gsd-pi 2.30.0-dev.7e1bbce → 2.30.0

package/dist/cli.js

@@ -59,15 +59,6 @@ function parseCliArgs(argv) {
             process.stdout.write((process.env.GSD_VERSION || '0.0.0') + '\n');
             process.exit(0);
         }
-        else if (arg === '--worktree' || arg === '-w') {
-            // -w with no value → auto-generate name; -w <name> → use that name
-            if (i + 1 < args.length && !args[i + 1].startsWith('-')) {
-                flags.worktree = args[++i];
-            }
-            else {
-                flags.worktree = true;
-            }
-        }
         else if (arg === '--help' || arg === '-h') {
             printHelp(process.env.GSD_VERSION || '0.0.0');
             process.exit(0);
@@ -352,48 +343,6 @@ if (isPrintMode) {
     process.exit(0);
 }
 // ---------------------------------------------------------------------------
-// Worktree subcommand — `gsd worktree <list|merge|clean|remove>`
-// ---------------------------------------------------------------------------
-if (cliFlags.messages[0] === 'worktree' || cliFlags.messages[0] === 'wt') {
-    const { handleList, handleMerge, handleClean, handleRemove } = await import('./worktree-cli.js');
-    const sub = cliFlags.messages[1];
-    const subArgs = cliFlags.messages.slice(2);
-    if (!sub || sub === 'list') {
-        handleList(process.cwd());
-    }
-    else if (sub === 'merge') {
-        await handleMerge(process.cwd(), subArgs);
-    }
-    else if (sub === 'clean') {
-        handleClean(process.cwd());
-    }
-    else if (sub === 'remove' || sub === 'rm') {
-        handleRemove(process.cwd(), subArgs);
-    }
-    else {
-        process.stderr.write(`Unknown worktree command: ${sub}\n`);
-        process.stderr.write('Commands: list, merge [name], clean, remove <name>\n');
-    }
-    process.exit(0);
-}
-// ---------------------------------------------------------------------------
-// Worktree flag (-w) — create/resume a worktree for the interactive session
-// ---------------------------------------------------------------------------
-if (cliFlags.worktree) {
-    const { handleWorktreeFlag } = await import('./worktree-cli.js');
-    handleWorktreeFlag(cliFlags.worktree);
-}
-// ---------------------------------------------------------------------------
-// Active worktree banner — remind user of unmerged worktrees on normal launch
-// ---------------------------------------------------------------------------
-if (!cliFlags.worktree && !isPrintMode) {
-    try {
-        const { handleStatusBanner } = await import('./worktree-cli.js');
-        handleStatusBanner(process.cwd());
-    }
-    catch { /* non-fatal */ }
-}
-// ---------------------------------------------------------------------------
 // Interactive mode — normal TTY session
 // ---------------------------------------------------------------------------
 // Per-directory session storage — same encoding as the upstream SDK so that

package/dist/help-text.js

@@ -29,37 +29,6 @@ const SUBCOMMAND_HELP = {
         '',
         'Compare with --continue (-c) which always resumes the most recent session.',
     ].join('\n'),
-    worktree: [
-        'Usage: gsd worktree <command> [args]',
-        '',
-        'Manage isolated git worktrees for parallel work streams.',
-        '',
-        'Commands:',
-        '  list                 List worktrees with status (files changed, commits, dirty)',
-        '  merge [name]         Squash-merge a worktree into main and clean up',
-        '  clean                Remove all worktrees that have been merged or are empty',
-        '  remove <name>        Remove a worktree (--force to remove with unmerged changes)',
-        '',
-        'The -w flag creates/resumes worktrees for interactive sessions:',
-        '  gsd -w               Auto-name a new worktree, or resume the only active one',
-        '  gsd -w my-feature    Create or resume a named worktree',
-        '',
-        'Lifecycle:',
-        '  1. gsd -w             Create worktree, start session inside it',
-        '  2. (work normally)    All changes happen on the worktree branch',
-        '  3. Ctrl+C             Exit — dirty work is auto-committed',
-        '  4. gsd -w             Resume where you left off',
-        '  5. gsd worktree merge Squash-merge into main when done',
-        '',
-        'Examples:',
-        '  gsd -w                              Start in a new auto-named worktree',
-        '  gsd -w auth-refactor                Create/resume "auth-refactor" worktree',
-        '  gsd worktree list                   See all worktrees and their status',
-        '  gsd worktree merge auth-refactor    Merge and clean up',
-        '  gsd worktree clean                  Remove all merged/empty worktrees',
-        '  gsd worktree remove old-branch      Remove a specific worktree',
-        '  gsd worktree remove old-branch --force  Remove even with unmerged changes',
-    ].join('\n'),
     headless: [
         'Usage: gsd headless [flags] [command] [args...]',
         '',
@@ -103,8 +72,6 @@ const SUBCOMMAND_HELP = {
         'Exit codes: 0 = complete, 1 = error/timeout, 2 = blocked',
     ].join('\n'),
 };
-// Alias: `gsd wt --help` → same as `gsd worktree --help`
-SUBCOMMAND_HELP['wt'] = SUBCOMMAND_HELP['worktree'];
 export function printHelp(version) {
     process.stdout.write(`GSD v${version} — Get Shit Done\n\n`);
     process.stdout.write('Usage: gsd [options] [message...]\n\n');
@@ -112,7 +79,6 @@ export function printHelp(version) {
     process.stdout.write('  --mode <text|json|rpc|mcp> Output mode (default: interactive)\n');
     process.stdout.write('  --print, -p              Single-shot print mode\n');
     process.stdout.write('  --continue, -c           Resume the most recent session\n');
-    process.stdout.write('  --worktree, -w [name]    Start in an isolated worktree (auto-named if omitted)\n');
     process.stdout.write('  --model <id>             Override model (e.g. claude-opus-4-6)\n');
     process.stdout.write('  --no-session             Disable session persistence\n');
     process.stdout.write('  --extension <path>       Load additional extension\n');
@@ -124,7 +90,6 @@ export function printHelp(version) {
     process.stdout.write('  config                   Re-run the setup wizard\n');
     process.stdout.write('  update                   Update GSD to the latest version\n');
     process.stdout.write('  sessions                 List and resume a past session\n');
-    process.stdout.write('  worktree <cmd>           Manage worktrees (list, merge, clean, remove)\n');
     process.stdout.write('  headless [cmd] [args]    Run /gsd commands without TUI (default: auto)\n');
     process.stdout.write('\nRun gsd <subcommand> --help for subcommand-specific help.\n');
 }

package/dist/resources/extensions/gsd/auto-dashboard.ts

@@ -205,6 +205,13 @@ export function estimateTimeRemaining(): string | null {
 
 // ─── Slice Progress Cache ─────────────────────────────────────────────────────
 
+/** Cached task detail for the widget task checklist */
+interface CachedTaskDetail {
+  id: string;
+  title: string;
+  done: boolean;
+}
+
 /** Cached slice progress for the widget — avoid async in render */
 let cachedSliceProgress: {
   done: number;
@@ -212,6 +219,8 @@ let cachedSliceProgress: {
   milestoneId: string;
   /** Real task progress for the active slice, if its plan file exists */
   activeSliceTasks: { done: number; total: number } | null;
+  /** Full task list for the active slice checklist */
+  taskDetails: CachedTaskDetail[] | null;
 } | null = null;
 
 export function updateSliceProgressCache(base: string, mid: string, activeSid?: string): void {
@@ -222,6 +231,7 @@ export function updateSliceProgressCache(base: string, mid: string, activeSid?:
     const roadmap = parseRoadmap(content);
 
     let activeSliceTasks: { done: number; total: number } | null = null;
+    let taskDetails: CachedTaskDetail[] | null = null;
     if (activeSid) {
       try {
         const planFile = resolveSliceFile(base, mid, activeSid, "PLAN");
@@ -232,6 +242,7 @@ export function updateSliceProgressCache(base: string, mid: string, activeSid?:
             done: plan.tasks.filter(t => t.done).length,
             total: plan.tasks.length,
           };
+          taskDetails = plan.tasks.map(t => ({ id: t.id, title: t.title, done: t.done }));
         }
       } catch {
         // Non-fatal — just omit task count
@@ -243,13 +254,19 @@ export function updateSliceProgressCache(base: string, mid: string, activeSid?:
       total: roadmap.slices.length,
       milestoneId: mid,
       activeSliceTasks,
+      taskDetails,
     };
   } catch {
     // Non-fatal — widget just won't show progress bar
   }
 }
 
-export function getRoadmapSlicesSync(): { done: number; total: number; activeSliceTasks: { done: number; total: number } | null } | null {
+export function getRoadmapSlicesSync(): {
+  done: number;
+  total: number;
+  activeSliceTasks: { done: number; total: number } | null;
+  taskDetails: CachedTaskDetail[] | null;
+} | null {
   return cachedSliceProgress;
 }
 
@@ -350,87 +367,84 @@ export function updateProgressWidget(
         const lines: string[] = [];
         const pad = INDENT.base;
 
-        // ── Line 1: Top bar ───────────────────────────────────────────────
+        // ── Top bar ─────────────────────────────────────────────────────
         lines.push(...ui.bar());
 
+        // ── Header: GSD AUTO ... elapsed ────────────────────────────────
         const dot = pulseBright
           ? theme.fg("accent", GLYPH.statusActive)
           : theme.fg("dim", GLYPH.statusPending);
         const elapsed = formatAutoElapsed(accessors.getAutoStartTime());
         const modeTag = accessors.isStepMode() ? "NEXT" : "AUTO";
-        const headerLeft = `${pad}${dot} ${theme.fg("accent", theme.bold("GSD"))}  ${theme.fg("success", modeTag)}`;
+        const headerLeft = `${pad}${dot} ${theme.fg("accent", theme.bold("GSD"))} ${theme.fg("success", modeTag)}`;
         const headerRight = elapsed ? theme.fg("dim", elapsed) : "";
         lines.push(rightAlign(headerLeft, headerRight, width));
 
-        lines.push("");
-
-        if (mid) {
-          lines.push(truncateToWidth(`${pad}${theme.fg("dim", mid.title)}`, width));
-        }
-
+        // ── Context: project · slice · action (merged into one line) ────
+        const contextParts: string[] = [];
+        if (mid) contextParts.push(theme.fg("dim", mid.title));
         if (slice && unitType !== "research-milestone" && unitType !== "plan-milestone") {
-          lines.push(truncateToWidth(
-            `${pad}${theme.fg("text", theme.bold(`${slice.id}: ${slice.title}`))}`,
-            width,
-          ));
+          contextParts.push(theme.fg("text", theme.bold(`${slice.id}: ${slice.title}`)));
         }
-
-        lines.push("");
-
         const isHook = unitType.startsWith("hook/");
         const target = isHook
           ? (unitId.split("/").pop() ?? unitId)
           : (task ? `${task.id}: ${task.title}` : unitId);
-        const actionLeft = `${pad}${theme.fg("accent", "▸")} ${theme.fg("accent", verb)}  ${theme.fg("text", target)}`;
+        contextParts.push(`${theme.fg("accent", "▸")} ${theme.fg("accent", verb)} ${theme.fg("text", target)}`);
+
         const tierTag = tierBadge ? theme.fg("dim", `[${tierBadge}] `) : "";
         const phaseBadge = `${tierTag}${theme.fg("dim", phaseLabel)}`;
-        lines.push(rightAlign(actionLeft, phaseBadge, width));
-        lines.push("");
-
-        if (mid) {
-          const roadmapSlices = getRoadmapSlicesSync();
-          if (roadmapSlices) {
-            const { done, total, activeSliceTasks } = roadmapSlices;
-            const barWidth = Math.max(8, Math.min(24, Math.floor(width * 0.3)));
-            const pct = total > 0 ? done / total : 0;
-            const filled = Math.round(pct * barWidth);
-            const bar = theme.fg("success", "█".repeat(filled))
-              + theme.fg("dim", "░".repeat(barWidth - filled));
-
-            let meta = theme.fg("dim", `${done}/${total} slices`);
-
-            if (activeSliceTasks && activeSliceTasks.total > 0) {
-              // For hooks, show the trigger task number (done), not the next task (done + 1)
-              const taskNum = isHook
-                ? Math.max(activeSliceTasks.done, 1)
-                : Math.min(activeSliceTasks.done + 1, activeSliceTasks.total);
-              meta += theme.fg("dim", `  ·  task ${taskNum}/${activeSliceTasks.total}`);
-            }
-
-            // ETA estimate
-            const eta = estimateTimeRemaining();
-            if (eta) {
-              meta += theme.fg("dim", `  ·  ${eta}`);
-            }
+        const contextLine = contextParts.join(theme.fg("dim", " · "));
+        lines.push(rightAlign(`${pad}${contextLine}`, phaseBadge, width));
+
+        // ── Two-column body ─────────────────────────────────────────────
+        // Left: progress, ETA, next, stats (fixed)  |  Right: task checklist (fixed, adjacent)
+        // Both columns sit left-to-center; empty space is on the right.
+        const divider = theme.fg("dim", "│");
+        const minTwoColWidth = 100;
+        const rightColFixed = 44;
+        const colGap = 5; // breathing room between columns
+        // Left column takes remaining space — no truncation on wide terminals
+        const useTwoCol = width >= minTwoColWidth;
+        const rightColWidth = useTwoCol ? rightColFixed : 0;
+        const leftColWidth = useTwoCol ? width - rightColWidth - colGap : width;
+
+        const roadmapSlices = mid ? getRoadmapSlicesSync() : null;
+
+        // Build left column: progress bar, ETA, next step, token stats
+        const leftLines: string[] = [];
+
+        if (roadmapSlices) {
+          const { done, total, activeSliceTasks } = roadmapSlices;
+          const barWidth = Math.max(6, Math.min(18, Math.floor(leftColWidth * 0.4)));
+          const pct = total > 0 ? done / total : 0;
+          const filled = Math.round(pct * barWidth);
+          const bar = theme.fg("success", "█".repeat(filled))
+            + theme.fg("dim", "░".repeat(barWidth - filled));
+
+          let meta = theme.fg("dim", `${done}/${total} slices`);
+          if (activeSliceTasks && activeSliceTasks.total > 0) {
+            const taskNum = isHook
+              ? Math.max(activeSliceTasks.done, 1)
+              : Math.min(activeSliceTasks.done + 1, activeSliceTasks.total);
+            meta += theme.fg("dim", ` · task ${taskNum}/${activeSliceTasks.total}`);
+          }
+          leftLines.push(truncateToWidth(`${pad}${bar} ${meta}`, leftColWidth));
 
-            lines.push(truncateToWidth(`${pad}${bar}  ${meta}`, width));
+          const eta = estimateTimeRemaining();
+          if (eta) {
+            leftLines.push(truncateToWidth(`${pad}${theme.fg("dim", eta)}`, leftColWidth));
           }
         }
 
-        lines.push("");
-
         if (next) {
-          lines.push(truncateToWidth(
+          leftLines.push(truncateToWidth(
             `${pad}${theme.fg("dim", "→")} ${theme.fg("dim", `then ${next}`)}`,
-            width,
+            leftColWidth,
           ));
         }
 
-        // ── Footer info (pwd, tokens, cost, context, model) ──────────────
-        lines.push("");
-        lines.push(truncateToWidth(theme.fg("dim", `${pad}${widgetPwd}`), width, theme.fg("dim", "…")));
-
-        // Token stats from current unit session + cumulative cost from metrics
+        // Token stats
         {
           const cmdCtx = accessors.getCmdCtx();
           let totalInput = 0, totalOutput = 0;
@@ -465,7 +479,6 @@ export function updateProgressWidget(
           if (totalOutput) sp.push(`↓${formatWidgetTokens(totalOutput)}`);
           if (totalCacheRead) sp.push(`R${formatWidgetTokens(totalCacheRead)}`);
           if (totalCacheWrite) sp.push(`W${formatWidgetTokens(totalCacheWrite)}`);
-          // Cache hit rate for current unit
           if (totalCacheRead + totalInput > 0) {
             const hitRate = Math.round((totalCacheRead / (totalCacheRead + totalInput)) * 100);
             sp.push(`\u26A1${hitRate}%`);
@@ -484,33 +497,134 @@ export function updateProgressWidget(
             sp.push(cxDisplay);
           }
 
-          const sLeft = sp.map(p => p.includes("\x1b[") ? p : theme.fg("dim", p))
+          const tokenLine = sp.map(p => p.includes("\x1b[") ? p : theme.fg("dim", p))
             .join(theme.fg("dim", " "));
+          leftLines.push(truncateToWidth(`${pad}${tokenLine}`, leftColWidth));
 
           const modelId = cmdCtx?.model?.id ?? "";
           const modelProvider = cmdCtx?.model?.provider ?? "";
-          const modelPhase = phaseLabel ? theme.fg("dim", `[${phaseLabel}] `) : "";
           const modelDisplay = modelProvider && modelId
             ? `${modelProvider}/${modelId}`
             : modelId;
-          const sRight = modelDisplay
-            ? `${modelPhase}${theme.fg("dim", modelDisplay)}`
-            : "";
-          lines.push(rightAlign(`${pad}${sLeft}`, sRight, width));
+          if (modelDisplay) {
+            leftLines.push(truncateToWidth(`${pad}${theme.fg("dim", modelDisplay)}`, leftColWidth));
+          }
 
-          // Dynamic routing savings summary
+          // Dynamic routing savings
           if (mLedger && mLedger.units.some(u => u.tier)) {
             const savings = formatTierSavings(mLedger.units);
             if (savings) {
-              lines.push(truncateToWidth(theme.fg("dim", `${pad}${savings}`), width));
+              leftLines.push(truncateToWidth(`${pad}${theme.fg("dim", savings)}`, leftColWidth));
+            }
+          }
+        }
+
+        // Build right column: task checklist (pegged to right edge)
+        const rightLines: string[] = [];
+        const taskDetails = roadmapSlices?.taskDetails ?? null;
+        const maxVisibleTasks = 8;
+        const rpad = " ";
+
+        if (useTwoCol) {
+          if (taskDetails && taskDetails.length > 0) {
+            const visibleTasks = taskDetails.slice(0, maxVisibleTasks);
+            for (const t of visibleTasks) {
+              const isCurrent = task && t.id === task.id;
+              const glyph = t.done
+                ? theme.fg("success", GLYPH.statusDone)
+                : isCurrent
+                  ? theme.fg("accent", "▸")
+                  : theme.fg("dim", " ");
+              const label = isCurrent
+                ? theme.fg("text", `${t.id}: ${t.title}`)
+                : t.done
+                  ? theme.fg("dim", `${t.id}: ${t.title}`)
+                  : theme.fg("text", `${t.id}: ${t.title}`);
+              rightLines.push(truncateToWidth(`${rpad}${glyph} ${label}`, rightColWidth));
+            }
+            if (taskDetails.length > maxVisibleTasks) {
+              rightLines.push(truncateToWidth(
+                `${rpad}${theme.fg("dim", `  …+${taskDetails.length - maxVisibleTasks} more`)}`,
+                rightColWidth,
+              ));
+            }
+          } else if (roadmapSlices?.activeSliceTasks) {
+            const { done: tDone, total: tTotal } = roadmapSlices.activeSliceTasks;
+            rightLines.push(`${rpad}${theme.fg("dim", `${tDone}/${tTotal} tasks`)}`);
+          }
+        } else {
+          // Narrow single-column: task list goes into left column
+          if (taskDetails && taskDetails.length > 0) {
+            for (const t of taskDetails.slice(0, maxVisibleTasks)) {
+              const isCurrent = task && t.id === task.id;
+              const glyph = t.done
+                ? theme.fg("success", GLYPH.statusDone)
+                : isCurrent
+                  ? theme.fg("accent", "▸")
+                  : theme.fg("dim", " ");
+              const label = isCurrent
+                ? theme.fg("text", `${t.id}: ${t.title}`)
+                : t.done
+                  ? theme.fg("dim", `${t.id}: ${t.title}`)
+                  : theme.fg("text", `${t.id}: ${t.title}`);
+              leftLines.push(truncateToWidth(`${pad}${glyph} ${label}`, leftColWidth));
+            }
+          }
+          // Add progress bar inline
+          if (roadmapSlices) {
+            const { done, total, activeSliceTasks } = roadmapSlices;
+            const barWidth = Math.max(6, Math.min(18, Math.floor(leftColWidth * 0.4)));
+            const pct = total > 0 ? done / total : 0;
+            const filled = Math.round(pct * barWidth);
+            const bar = theme.fg("success", "█".repeat(filled))
+              + theme.fg("dim", "░".repeat(barWidth - filled));
+            let meta = theme.fg("dim", `${done}/${total} slices`);
+            if (activeSliceTasks && activeSliceTasks.total > 0) {
+              const taskNum = isHook
+                ? Math.max(activeSliceTasks.done, 1)
+                : Math.min(activeSliceTasks.done + 1, activeSliceTasks.total);
+              meta += theme.fg("dim", ` · task ${taskNum}/${activeSliceTasks.total}`);
             }
+            const eta = estimateTimeRemaining();
+            if (eta) meta += theme.fg("dim", ` · ${eta}`);
+            leftLines.push(truncateToWidth(`${pad}${bar} ${meta}`, leftColWidth));
+          }
+          if (next) {
+            leftLines.push(truncateToWidth(
+              `${pad}${theme.fg("dim", "→")} ${theme.fg("dim", `then ${next}`)}`,
+              leftColWidth,
+            ));
           }
         }
 
+        // Compose columns
+        if (useTwoCol) {
+          const maxRows = Math.max(leftLines.length, rightLines.length);
+          if (maxRows > 0) {
+            lines.push(""); // spacer before columns
+            for (let i = 0; i < maxRows; i++) {
+              const left = padToWidth(leftLines[i] ?? "", leftColWidth);
+              const gap = " ".repeat(colGap - 2); // colGap minus divider and its trailing space
+              const right = rightLines[i] ?? "";
+              lines.push(truncateToWidth(`${left}${gap}${divider} ${right}`, width));
+            }
+          }
+        } else {
+          // Narrow single-column: just stack
+          if (leftLines.length > 0) {
+            lines.push("");
+            for (const l of leftLines) lines.push(l);
+          }
+        }
+
+        // ── Footer: pwd + hints ─────────────────────────────────────────
+        lines.push("");
         const hintParts: string[] = [];
         hintParts.push("esc pause");
         hintParts.push(process.platform === "darwin" ? "⌃⌥G dashboard" : "Ctrl+Alt+G dashboard");
-        lines.push(...ui.hints(hintParts));
+        const hintStr = theme.fg("dim", hintParts.join(" | "));
+        const pwdStr = theme.fg("dim", widgetPwd);
+        lines.push(rightAlign(`${pad}${pwdStr}`, hintStr, width));
 
         lines.push(...ui.bar());
 
@@ -628,3 +742,10 @@ function rightAlign(left: string, right: string, width: number): string {
   const gap = Math.max(1, width - leftVis - rightVis);
   return truncateToWidth(left + " ".repeat(gap) + right, width);
 }
+
+/** Pad a string with trailing spaces to fill exactly `colWidth` (ANSI-aware). */
+function padToWidth(s: string, colWidth: number): string {
+  const vis = visibleWidth(s);
+  if (vis >= colWidth) return truncateToWidth(s, colWidth);
+  return s + " ".repeat(colWidth - vis);
+}

package/dist/resources/extensions/gsd/index.ts

@@ -1048,19 +1048,6 @@ export default function (pi: ExtensionAPI) {
       } catch { /* best-effort */ }
     }
 
-    // Auto-commit dirty work in CLI-spawned worktrees so nothing is lost.
-    // The CLI sets GSD_CLI_WORKTREE when launched with -w.
-    const cliWorktree = process.env.GSD_CLI_WORKTREE;
-    if (cliWorktree) {
-      try {
-        const { autoCommitCurrentBranch } = await import("./worktree.js");
-        const msg = autoCommitCurrentBranch(process.cwd(), "session-end", cliWorktree);
-        if (msg) {
-          ctx.ui.notify(`Auto-committed worktree ${cliWorktree} before exit.`, "info");
-        }
-      } catch { /* best-effort */ }
-    }
-
     if (!isAutoActive() && !isAutoPaused()) return;
 
     // Save the current session — the lock file stays on disk

package/dist/resources/extensions/gsd/roadmap-slices.ts

@@ -96,39 +96,24 @@ export function parseRoadmapSlices(content: string): RoadmapSliceEntry[] {
 
 /**
  * Fallback parser for prose-style roadmaps where the LLM wrote
- * slice headers instead of the machine-readable `## Slices` checklist.
- * Extracts slice IDs and titles so auto-mode can at least identify
- * slices and plan them.
+ * `## Slice S01: Title` headers instead of the machine-readable
+ * `## Slices` checklist. Extracts slice IDs and titles so auto-mode
+ * can at least identify slices and plan them.
  *
- * Handles these LLM-generated variants:
- *   ## S01: Title           (H2, colon separator)
- *   ### S01: Title          (H3)
- *   #### S01: Title         (H4)
- *   ## Slice S01: Title     (with "Slice" prefix)
- *   ## S01 — Title          (em dash)
- *   ## S01 – Title          (en dash)
- *   ## S01 - Title          (hyphen)
- *   ## S01. Title           (dot separator)
- *   ## S01 Title            (space only, no separator)
- *   ## **S01: Title**       (bold-wrapped)
- *   ## **S01**: Title       (bold ID only)
- *   ## S1: Title            (non-zero-padded ID)
+ * Also handles `## S01: Title` and `## S01 — Title` variants.
  */
 function parseProseSliceHeaders(content: string): RoadmapSliceEntry[] {
   const slices: RoadmapSliceEntry[] = [];
-  // Match H1–H4 headers containing S<digits> with optional "Slice" prefix and bold markers.
-  // Separator after the ID is flexible: colon, dash, em/en dash, dot, or just whitespace.
-  const headerPattern = /^#{1,4}\s+\*{0,2}(?:Slice\s+)?(S\d+)\*{0,2}[:\s.—–-]*\s*(.+)/gm;
+  const headerPattern = /^##\s+(?:Slice\s+)?(S\d+)[:\s—–-]+\s*(.+)/gm;
   let match: RegExpExecArray | null;
 
   while ((match = headerPattern.exec(content)) !== null) {
     const id = match[1]!;
-    let title = match[2]!.trim().replace(/\*{1,2}$/g, "").trim(); // strip trailing bold markers
-    if (!title) continue; // skip if we only matched the ID with no title
+    const title = match[2]!.trim();
 
     // Try to extract depends from prose: "Depends on: S01" or "**Depends on:** S01, S02"
     const afterHeader = content.slice(match.index + match[0].length);
-    const nextHeader = afterHeader.search(/^#{1,4}\s/m);
+    const nextHeader = afterHeader.search(/^##\s/m);
     const section = nextHeader !== -1 ? afterHeader.slice(0, nextHeader) : afterHeader.slice(0, 500);
 
     const depsMatch = section.match(/\*{0,2}Depends\s+on:?\*{0,2}\s*(.+)/i);

package/dist/resources/extensions/gsd/session-lock.ts

@@ -17,7 +17,7 @@
  */
 
 import { createRequire } from "node:module";
-import { existsSync, readFileSync, mkdirSync, unlinkSync, rmSync, statSync } from "node:fs";
+import { existsSync, readFileSync, mkdirSync, unlinkSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { gsdRoot } from "./paths.js";
 import { atomicWriteSync } from "./atomic-write.js";
@@ -92,12 +92,11 @@ export function acquireSessionLock(basePath: string): SessionLockResult {
     return acquireFallbackLock(basePath, lp, lockData);
   }
 
-  const gsdDir = gsdRoot(basePath);
-
   try {
     // Try to acquire an exclusive OS-level lock on the lock file.
     // We lock the directory (gsdRoot) since proper-lockfile works best
     // on directories, and the lock file itself may not exist yet.
+    const gsdDir = gsdRoot(basePath);
     mkdirSync(gsdDir, { recursive: true });
 
     const release = lockfile.lockSync(gsdDir, {
@@ -110,53 +109,16 @@ export function acquireSessionLock(basePath: string): SessionLockResult {
     _lockedPath = basePath;
     _lockPid = process.pid;
 
-    // Safety net: clean up lock dir on process exit if _releaseFunction
-    // wasn't called (e.g., normal exit after clean completion) (#1245).
-    const lockDirForCleanup = join(gsdDir + ".lock");
-    process.once("exit", () => {
-      try {
-        if (_releaseFunction) { _releaseFunction(); _releaseFunction = null; }
-      } catch { /* best-effort */ }
-      try {
-        if (existsSync(lockDirForCleanup)) rmSync(lockDirForCleanup, { recursive: true, force: true });
-      } catch { /* best-effort */ }
-    });
-
     // Write the informational lock data
     atomicWriteSync(lp, JSON.stringify(lockData, null, 2));
 
     return { acquired: true };
   } catch (err) {
-    // Lock is held by another process — or the .gsd.lock/ directory is stranded.
-    // Check: if auto.lock is gone and no process is alive, the lock dir is stale.
+    // Lock is held by another process
     const existingData = readExistingLockData(lp);
     const existingPid = existingData?.pid;
-
-    // If no lock file or no alive process, try to clean up and re-acquire (#1245)
-    if (!existingData || (existingPid && !isPidAlive(existingPid))) {
-      try {
-        const lockDir = join(gsdDir + ".lock");
-        if (existsSync(lockDir)) rmSync(lockDir, { recursive: true, force: true });
-        if (existsSync(lp)) unlinkSync(lp);
-
-        // Retry acquisition after cleanup
-        const release = lockfile.lockSync(gsdDir, {
-          realpath: false,
-          stale: 300_000,
-          update: 10_000,
-        });
-        _releaseFunction = release;
-        _lockedPath = basePath;
-        _lockPid = process.pid;
-        atomicWriteSync(lp, JSON.stringify(lockData, null, 2));
-        return { acquired: true };
-      } catch {
-        // Retry also failed — fall through to the error path
-      }
-    }
-
     const reason = existingPid
-      ? `Another auto-mode session (PID ${existingPid}) appears to be running.\nStop it with \`kill ${existingPid}\` before starting a new session.`
+      ? `Another auto-mode session (PID ${existingPid}) is already running on this project.`
       : `Another auto-mode session is already running on this project.`;
 
     return { acquired: false, reason, existingPid };
@@ -271,17 +233,6 @@ export function releaseSessionLock(basePath: string): void {
     // Non-fatal
   }
 
-  // Remove the proper-lockfile directory (.gsd.lock/) if it exists.
-  // proper-lockfile creates this directory as the OS-level lock mechanism.
-  // If the process exits without calling _releaseFunction (SIGKILL, crash),
-  // this directory is stranded and blocks the next session (#1245).
-  try {
-    const lockDir = join(gsdRoot(basePath) + ".lock");
-    if (existsSync(lockDir)) rmSync(lockDir, { recursive: true, force: true });
-  } catch {
-    // Non-fatal
-  }
-
   _lockedPath = null;
   _lockPid = 0;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gsd-pi",
-  "version": "2.30.0-dev.7e1bbce",
+  "version": "2.30.0",
   "description": "GSD — Get Shit Done coding agent",
   "license": "MIT",
   "repository": {