gsd-pi 2.41.0 → 2.42.0

package/README.md

@@ -24,35 +24,75 @@ One command. Walk away. Come back to a built project with clean git history.
 
 ---
 
-## What's New in v2.39–v2.40
-
-- **GitHub sync extension** — auto-sync milestones, slices, and tasks to GitHub Issues, PRs, and Milestones. Opt in with `github.enabled: true` in preferences. Requires `gh` CLI.
-- **Skill tool resolution** — skills are now resolved and activated automatically in dispatched prompts based on `always_use_skills`, `prefer_skills`, and `skill_rules` preferences. Skills are matched to dispatch context at build time.
-- **Health check phase 2** — `/gsd doctor` issues now surface in real time across the dashboard widget, workflow visualizer, and HTML reports with severity levels (error/warning/info).
-- **Forensics upgrade** — `/gsd forensics` is now a full-access GSD debugger with structured anomaly detection (stuck loops, cost spikes, timeouts, missing artifacts), unit traces, and LLM-guided root-cause analysis.
-- **Auto PR on milestone completion** — set `git.auto_pr: true` to automatically create a draft PR when a milestone completes. Requires `auto_push: true` and `gh` CLI.
-- **RUNTIME.md template** — declare project-level runtime context (API endpoints, env vars, deployment info) in `.gsd/RUNTIME.md`. Inlined into task execution prompts to prevent hallucination.
-- **Welcome screen** — branded startup UI showing version, active model, available tool keys, and quick-start commands.
-- **`GSD_HOME` and `GSD_PROJECT_ID` env vars** — override the global `~/.gsd` directory and per-project identity hash for CI/CD and multi-clone environments.
-- **Browser and runtime UAT types** — new `browser-executable` and `runtime-executable` UAT types control when auto-mode pauses for validation.
-- **Pipeline decomposition** — auto-loop rewritten from recursive dispatch to a linear phase pipeline (pre-dispatch → dispatch → post-unit → verification → stuck detection) for better debuggability.
-- **Sliding-window stuck detection** — replaces the simple counter with a pattern-aware sliding window, reducing false positives on legitimate retries.
-- **Data-loss recovery** — automatic detection and recovery of `.gsd/` data loss from v2.30.0–v2.38.0 migration issues, with atomic migration and rollback on failure.
-- **Model preferences in guided flow** — per-phase model selection now applies in step mode, not just auto mode.
-
-See the full [Changelog](./CHANGELOG.md) for details.
-
-### Previous highlights (v2.34–v2.38)
-
-- **Reactive task execution (ADR-004)** — graph-derived parallel task dispatch within slices
-- **Anthropic Vertex AI provider** — Claude on Google Vertex AI
-- **cmux integration** — sidebar status, progress bars, and notifications for cmux terminal multiplexer users
-- **Redesigned dashboard** — two-column layout with 4 widget modes (full → small → min → off)
-- **AGENTS.md support** — deprecated `agent-instructions.md` in favor of standard `AGENTS.md` / `CLAUDE.md`
-- **AI-powered triage** — automated issue and PR triage via Claude Haiku
-- **Auto-generated OpenRouter registry** — model registry built from OpenRouter API
-- **`/gsd changelog`** — LLM-summarized release notes for any version
-- **Search budget enforcement** — session-level cap prevents unbounded web search
+## What's New in v2.41.0
+
+### New Features
+
+- **Browser-based web interface** — run GSD from the browser with `gsd --web`. Full project management, real-time progress, and multi-project support via server-sent events. (#1717)
+- **Doctor: worktree lifecycle checks** — `/gsd doctor` now validates worktree health, detects orphaned worktrees, consolidates cleanup, and enhances `/worktree list` with lifecycle status. (#1814)
+- **CI: docs-only PR detection** — PRs that only change documentation skip build and test steps, with a new prompt injection scan for security. (#1699)
+- **Custom Models guide** — new documentation for adding custom providers (Ollama, vLLM, LM Studio, proxies) via `models.json`. (#1670)
+
+### Data Loss Prevention (Critical Fixes)
+
+This release includes 7 fixes preventing silent data loss in auto-mode:
+
+- **Hallucination guard** — execute-task agents that complete with zero tool calls are now rejected as hallucinated. Previously, agents could produce detailed but fabricated summaries without writing any code, wasting ~$25/milestone. (#1838)
+- **Merge anchor verification** — before deleting a milestone worktree/branch, GSD now verifies the code is actually on the integration branch. Prevents orphaning commits when squash-merge produces an empty diff. (#1829)
+- **Dirty working tree detection** — `nativeMergeSquash` now distinguishes dirty-tree rejections from content conflicts, preventing silent commit loss when synced `.gsd/` files block the merge. (#1752)
+- **Doctor cleanup safety** — the `orphaned_completed_units` check no longer auto-fixes during post-task health checks. Previously, timing races could cause the doctor to remove valid completion keys, reverting users to earlier tasks. (#1825)
+- **Root file reverse-sync** — worktree teardown now syncs root-level `.gsd/` files (PROJECT.md, REQUIREMENTS.md, completed-units.json) back to the project root. Previously these were lost on milestone closeout. (#1831)
+- **Empty merge guard** — milestone branches with unanchored code changes are preserved instead of deleted when squash-merge produces nothing to commit. (#1755)
+- **Crash-safe task closeout** — orphaned checkboxes in PLAN.md are unchecked on retry, preventing phantom task completion. (#1759)
+
+### Auto-Mode Stability
+
+- **Terminal hang fix** — `stopAuto()` now resolves pending promises, preventing the terminal from freezing permanently after stopping auto-mode. (#1818)
+- **Signal handler coverage** — SIGHUP and SIGINT now clean up lock files, not just SIGTERM. Prevents stranded locks on VS-Code crash. (#1821)
+- **Needs-discussion routing** — milestones in `needs-discussion` phase now route to the smart entry UI instead of hard-stopping, breaking the infinite loop. (#1820)
+- **Infrastructure error handling** — auto-mode stops immediately on ENOSPC, ENOMEM, and similar unrecoverable errors instead of retrying. (#1780)
+- **Dependency-aware dispatch** — slice dispatch now uses declared `depends_on` instead of positional ordering. (#1770)
+- **Queue mode depth verification** — the write gate now processes depth verification in queue mode, fixing a deadlock where CONTEXT.md writes were permanently blocked. (#1823)
+
+### Roadmap Parser Improvements
+
+- **Table format support** — roadmaps using markdown tables (`| S01 | Title | Risk | Status |`) are now parsed correctly. (#1741)
+- **Prose header fallback** — when `## Slices` contains H3 headers instead of checkboxes, the prose parser is invoked as a fallback. (#1744)
+- **Completion marker detection** — prose headers with `✓` or `(Complete)` markers are correctly identified as done. (#1816)
+- **Zero-slice stub handling** — stub roadmaps from `/gsd queue` return `pre-planning` instead of `blocked`. (#1826)
+- **Immediate roadmap fix** — roadmap checkbox and UAT stub are fixed immediately after last task instead of deferring to `complete-slice`. (#1819)
+
+### State & Git Improvements
+
+- **CONTEXT-DRAFT.md fallback** — `depends_on` is read from CONTEXT-DRAFT.md when CONTEXT.md doesn't exist, preventing draft milestones from being promoted past dependency constraints. (#1743)
+- **Unborn branch support** — `nativeBranchExists` handles repos with zero commits, preventing dispatch deadlock on new repos. (#1815)
+- **Ghost milestone detection** — empty `.gsd/milestones/` directories are skipped instead of crashing `deriveState()`. (#1817)
+- **Default branch detection** — milestone merge detects `master` vs `main` instead of hardcoding. (#1669)
+- **Milestone title extraction** — titles are pulled from CONTEXT.md headings when no ROADMAP exists. (#1729)
+
+### Windows & Platform
+
+- **Windows path handling** — 8.3 short paths, `pathToFileURL` for ESM imports, and `realpathSync.native` fixes across the test suite and verification gate. (#1804)
+- **DEP0190 fix** — `spawnSync` deprecation warning eliminated by passing commands to shell explicitly. (#1827)
+- **Web build skip on Windows** — Next.js webpack EPERM errors on system directories are handled gracefully.
+
+### Developer Experience
+
+- **@ file finder fix** — typing `@` no longer freezes the TUI. The fix adds debounce, dedup, and empty-query short-circuit. (#1832)
+- **Tool-call loop guard** — detects and breaks infinite tool-call loops within a single unit, preventing stack overflow. (#1801)
+- **Completion deferral fix** — roadmap checkbox and UAT stub are fixed at task level, closing the fragile handoff window between last task and `complete-slice`. (#1819)
+
+See the full [Changelog](./CHANGELOG.md) for all 70+ fixes in this release.
+
+### Previous highlights (v2.39–v2.40)
+
+- **GitHub sync extension** — auto-sync milestones to GitHub Issues, PRs, and Milestones
+- **Skill tool resolution** — skills auto-activate in dispatched prompts
+- **Health check phase 2** — real-time doctor issues in dashboard and visualizer
+- **Forensics upgrade** — full-access GSD debugger with anomaly detection
+- **Pipeline decomposition** — auto-loop rewritten as linear phase pipeline
+- **Sliding-window stuck detection** — pattern-aware, fewer false positives
+- **Data-loss recovery** — automatic detection and recovery from v2.30–v2.38 migration issues
 
 ---
 

package/dist/cli-web-branch.d.ts

@@ -13,6 +13,12 @@ export interface CliFlags {
     web?: boolean;
     /** Optional project path for web mode: `gsd --web <path>` or `gsd web start <path>` */
     webPath?: string;
+    /** Custom host to bind web server to: `--host 0.0.0.0` */
+    webHost?: string;
+    /** Custom port for web server: `--port 8080` */
+    webPort?: number;
+    /** Additional allowed origins for CORS: `--allowed-origins http://192.168.1.10:8080` */
+    webAllowedOrigins?: string[];
     help?: boolean;
     version?: boolean;
 }

package/dist/cli-web-branch.js

@@ -29,6 +29,20 @@ export function parseCliArgs(argv) {
                 flags.webPath = args[++i];
             }
         }
+        else if (arg === '--host' && i + 1 < args.length) {
+            flags.webHost = args[++i];
+        }
+        else if (arg === '--port' && i + 1 < args.length) {
+            const portStr = args[++i];
+            const port = parseInt(portStr, 10);
+            if (Number.isFinite(port) && port > 0 && port < 65536) {
+                flags.webPort = port;
+            }
+        }
+        else if (arg === '--allowed-origins' && i + 1 < args.length) {
+            const origins = args[++i].split(',').map(o => o.trim()).filter(Boolean);
+            flags.webAllowedOrigins = (flags.webAllowedOrigins ?? []).concat(origins);
+        }
         else if (arg === '--model' && i + 1 < args.length) {
             flags.model = args[++i];
         }
@@ -216,6 +230,9 @@ export async function runWebCliBranch(flags, deps = {}) {
         cwd: currentCwd,
         projectSessionsDir,
         agentDir,
+        host: flags.webHost,
+        port: flags.webPort,
+        allowedOrigins: flags.webAllowedOrigins,
     });
     if (!status.ok) {
         emitWebModeFailure(stderr, status);

package/dist/onboarding.js

@@ -94,7 +94,8 @@ async function loadPico() {
 /** Open a URL in the system browser (best-effort, non-blocking) */
 function openBrowser(url) {
     if (process.platform === 'win32') {
-        execFile('cmd', ['/c', 'start', '', url], () => { });
+        // PowerShell's Start-Process handles URLs with '&' safely; cmd /c start does not.
+        execFile('powershell', ['-c', `Start-Process '${url.replace(/'/g, "''")}'`], () => { });
     }
     else {
         const cmd = process.platform === 'darwin' ? 'open' : 'xdg-open';

package/dist/resources/extensions/gsd/auto/loop.js

@@ -6,11 +6,13 @@
  *
  * Imports from: auto/types, auto/resolve, auto/phases
  */
+import { randomUUID } from "node:crypto";
 import { MAX_LOOP_ITERATIONS, } from "./types.js";
 import { _clearCurrentResolve } from "./resolve.js";
 import { runPreDispatch, runDispatch, runGuards, runUnitPhase, runFinalize, } from "./phases.js";
 import { debugLog } from "../debug-logger.js";
 import { isInfrastructureError } from "./infra-errors.js";
+import { resolveEngine } from "../engine-resolver.js";
 /**
  * Main auto-mode execution loop. Iterates: derive → dispatch → guards →
  * runUnit → finalize → repeat. Exits when s.active becomes false or a
@@ -27,6 +29,10 @@ export async function autoLoop(ctx, pi, s, deps) {
     while (s.active) {
         iteration++;
         debugLog("autoLoop", { phase: "loop-top", iteration });
+        // ── Journal: per-iteration flow grouping ──
+        const flowId = randomUUID();
+        let seqCounter = 0;
+        const nextSeq = () => ++seqCounter;
         if (iteration > MAX_LOOP_ITERATIONS) {
             debugLog("autoLoop", {
                 phase: "exit",
@@ -53,6 +59,7 @@ export async function autoLoop(ctx, pi, s, deps) {
                     unitType: sidecarItem.unitType,
                     unitId: sidecarItem.unitId,
                 });
+                deps.emitJournalEvent({ ts: new Date().toISOString(), flowId, seq: nextSeq(), eventType: "sidecar-dequeue", data: { kind: sidecarItem.kind, unitType: sidecarItem.unitType, unitId: sidecarItem.unitId } });
             }
             const sessionLockBase = deps.lockBase();
             if (sessionLockBase) {
@@ -73,8 +80,88 @@ export async function autoLoop(ctx, pi, s, deps) {
                     break;
                 }
             }
-            const ic = { ctx, pi, s, deps, prefs, iteration };
+            const ic = { ctx, pi, s, deps, prefs, iteration, flowId, nextSeq };
+            deps.emitJournalEvent({ ts: new Date().toISOString(), flowId, seq: nextSeq(), eventType: "iteration-start", data: { iteration } });
             let iterData;
+            // ── Custom engine path ──────────────────────────────────────────────
+            // When activeEngineId is a non-dev value, bypass runPreDispatch and
+            // runDispatch entirely — the custom engine drives its own state via
+            // GRAPH.yaml. Shares runGuards and runUnitPhase with the dev path.
+            // After unit execution, verifies then reconciles via the engine layer.
+            //
+            // GSD_ENGINE_BYPASS=1 skips the engine layer entirely — falls through
+            // to the dev path below.
+            if (s.activeEngineId != null && s.activeEngineId !== "dev" && !sidecarItem && process.env.GSD_ENGINE_BYPASS !== "1") {
+                debugLog("autoLoop", { phase: "custom-engine-derive", iteration, engineId: s.activeEngineId });
+                const { engine, policy } = resolveEngine({
+                    activeEngineId: s.activeEngineId,
+                    activeRunDir: s.activeRunDir,
+                });
+                const engineState = await engine.deriveState(s.basePath);
+                if (engineState.isComplete) {
+                    await deps.stopAuto(ctx, pi, "Workflow complete");
+                    break;
+                }
+                debugLog("autoLoop", { phase: "custom-engine-dispatch", iteration });
+                const dispatch = await engine.resolveDispatch(engineState, { basePath: s.basePath });
+                if (dispatch.action === "stop") {
+                    await deps.stopAuto(ctx, pi, dispatch.reason ?? "Engine stopped");
+                    break;
+                }
+                if (dispatch.action === "skip") {
+                    continue;
+                }
+                // dispatch.action === "dispatch"
+                const step = dispatch.step;
+                const gsdState = await deps.deriveState(s.basePath);
+                iterData = {
+                    unitType: step.unitType,
+                    unitId: step.unitId,
+                    prompt: step.prompt,
+                    finalPrompt: step.prompt,
+                    pauseAfterUatDispatch: false,
+                    observabilityIssues: [],
+                    state: gsdState,
+                    mid: s.currentMilestoneId ?? "workflow",
+                    midTitle: "Workflow",
+                    isRetry: false,
+                    previousTier: undefined,
+                };
+                // ── Progress widget (mirrors dev path in runDispatch) ──
+                deps.updateProgressWidget(ctx, iterData.unitType, iterData.unitId, iterData.state);
+                // ── Guards (shared with dev path) ──
+                const guardsResult = await runGuards(ic, s.currentMilestoneId ?? "workflow");
+                if (guardsResult.action === "break")
+                    break;
+                // ── Unit execution (shared with dev path) ──
+                const unitPhaseResult = await runUnitPhase(ic, iterData, loopState);
+                if (unitPhaseResult.action === "break")
+                    break;
+                // ── Verify first, then reconcile (only mark complete on pass) ──
+                debugLog("autoLoop", { phase: "custom-engine-verify", iteration, unitId: iterData.unitId });
+                const verifyResult = await policy.verify(iterData.unitType, iterData.unitId, { basePath: s.basePath });
+                if (verifyResult === "pause") {
+                    await deps.pauseAuto(ctx, pi);
+                    break;
+                }
+                if (verifyResult === "retry") {
+                    debugLog("autoLoop", { phase: "custom-engine-verify-retry", iteration, unitId: iterData.unitId });
+                    continue;
+                }
+                // Verification passed — mark step complete
+                debugLog("autoLoop", { phase: "custom-engine-reconcile", iteration, unitId: iterData.unitId });
+                await engine.reconcile(engineState, {
+                    unitType: iterData.unitType,
+                    unitId: iterData.unitId,
+                    startedAt: s.currentUnit?.startedAt ?? Date.now(),
+                    finishedAt: Date.now(),
+                });
+                deps.clearUnitTimeout();
+                consecutiveErrors = 0;
+                deps.emitJournalEvent({ ts: new Date().toISOString(), flowId, seq: nextSeq(), eventType: "iteration-end", data: { iteration } });
+                debugLog("autoLoop", { phase: "iteration-complete", iteration });
+                continue;
+            }
             if (!sidecarItem) {
                 // ── Phase 1: Pre-dispatch ─────────────────────────────────────────
                 const preDispatchResult = await runPreDispatch(ic, loopState);
@@ -121,6 +208,7 @@ export async function autoLoop(ctx, pi, s, deps) {
             if (finalizeResult.action === "continue")
                 continue;
             consecutiveErrors = 0; // Iteration completed successfully
+            deps.emitJournalEvent({ ts: new Date().toISOString(), flowId, seq: nextSeq(), eventType: "iteration-end", data: { iteration } });
             debugLog("autoLoop", { phase: "iteration-complete", iteration });
         }
         catch (loopErr) {

package/dist/resources/extensions/gsd/auto/phases.js

@@ -13,6 +13,7 @@ import { runUnit } from "./run-unit.js";
 import { debugLog } from "../debug-logger.js";
 import { gsdRoot } from "../paths.js";
 import { atomicWriteSync } from "../atomic-write.js";
+import { PROJECT_FILES } from "../detection.js";
 import { join } from "node:path";
 // ─── generateMilestoneReport ──────────────────────────────────────────────────
 /**
@@ -121,6 +122,7 @@ export async function runPreDispatch(ic, loopState) {
     });
     // ── Milestone transition ────────────────────────────────────────────
     if (mid && s.currentMilestoneId && mid !== s.currentMilestoneId) {
+        deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: ic.nextSeq(), eventType: "milestone-transition", data: { from: s.currentMilestoneId, to: mid } });
         ctx.ui.notify(`Milestone ${s.currentMilestoneId} complete. Advancing to ${mid}: ${midTitle}.`, "info");
         deps.sendDesktopNotification("GSD", `Milestone ${s.currentMilestoneId} complete!`, "success", "milestone");
         deps.logCmuxEvent(prefs, `Milestone ${s.currentMilestoneId} complete. Advancing to ${mid}.`, "success");
@@ -248,6 +250,7 @@ export async function runPreDispatch(ic, loopState) {
             await deps.stopAuto(ctx, pi, `No active milestone — ${incomplete.length} incomplete (${ids}), see diagnostic above`);
         }
         debugLog("autoLoop", { phase: "exit", reason: "no-active-milestone" });
+        deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: ic.nextSeq(), eventType: "terminal", data: { reason: "no-active-milestone" } });
         return { action: "break", reason: "no-active-milestone" };
     }
     if (!midTitle) {
@@ -295,6 +298,7 @@ export async function runPreDispatch(ic, loopState) {
         deps.logCmuxEvent(prefs, `Milestone ${mid} complete.`, "success");
         await closeoutAndStop(ctx, pi, s, deps, `Milestone ${mid} complete`);
         debugLog("autoLoop", { phase: "exit", reason: "milestone-complete" });
+        deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: ic.nextSeq(), eventType: "terminal", data: { reason: "milestone-complete", milestoneId: mid } });
         return { action: "break", reason: "milestone-complete" };
     }
     // Terminal: blocked
@@ -305,6 +309,7 @@ export async function runPreDispatch(ic, loopState) {
         deps.sendDesktopNotification("GSD", blockerMsg, "error", "attention");
         deps.logCmuxEvent(prefs, blockerMsg, "error");
         debugLog("autoLoop", { phase: "exit", reason: "blocked" });
+        deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: ic.nextSeq(), eventType: "terminal", data: { reason: "blocked", blockers: state.blockers } });
         return { action: "break", reason: "blocked" };
     }
     return { action: "next", data: { state, mid, midTitle } };
@@ -328,6 +333,7 @@ export async function runDispatch(ic, preData, loopState) {
         session: s,
     });
     if (dispatchResult.action === "stop") {
+        deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: ic.nextSeq(), eventType: "dispatch-stop", rule: dispatchResult.matchedRule, data: { reason: dispatchResult.reason } });
         await closeoutAndStop(ctx, pi, s, deps, dispatchResult.reason);
         debugLog("autoLoop", { phase: "exit", reason: "dispatch-stop" });
         return { action: "break", reason: "dispatch-stop" };
@@ -337,6 +343,7 @@ export async function runDispatch(ic, preData, loopState) {
         await new Promise((r) => setImmediate(r));
         return { action: "continue" };
     }
+    deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: ic.nextSeq(), eventType: "dispatch-match", rule: dispatchResult.matchedRule, data: { unitType: dispatchResult.unitType, unitId: dispatchResult.unitId } });
     let unitType = dispatchResult.unitType;
     let unitId = dispatchResult.unitId;
     let prompt = dispatchResult.prompt;
@@ -402,6 +409,7 @@ export async function runDispatch(ic, preData, loopState) {
     const preDispatchResult = deps.runPreDispatchHooks(unitType, unitId, prompt, s.basePath);
     if (preDispatchResult.firedHooks.length > 0) {
         ctx.ui.notify(`Pre-dispatch hook${preDispatchResult.firedHooks.length > 1 ? "s" : ""}: ${preDispatchResult.firedHooks.join(", ")}`, "info");
+        deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: ic.nextSeq(), eventType: "pre-dispatch-hook", data: { firedHooks: preDispatchResult.firedHooks, action: preDispatchResult.action } });
     }
     if (preDispatchResult.action === "skip") {
         ctx.ui.notify(`Skipping ${unitType} ${unitId} (pre-dispatch hook).`, "info");
@@ -544,25 +552,27 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         unitType,
         unitId,
     });
-    // ── Worktree health check (#1833) ───────────────────────────────────
+    // ── Worktree health check (#1833, #1843) ────────────────────────────
     // Verify the working directory is a valid git checkout with project
     // files before dispatching work. A broken worktree causes agents to
     // hallucinate summaries since they cannot read or write any files.
+    // Uses the shared PROJECT_FILES list from detection.ts to support all
+    // ecosystems (Rust, Go, Python, Java, etc.), not just JS.
     if (s.basePath && unitType === "execute-task") {
         const gitMarker = join(s.basePath, ".git");
         const hasGit = deps.existsSync(gitMarker);
-        const hasPackageJson = deps.existsSync(join(s.basePath, "package.json"));
-        const hasSrcDir = deps.existsSync(join(s.basePath, "src"));
         if (!hasGit) {
             const msg = `Worktree health check failed: ${s.basePath} has no .git — refusing to dispatch ${unitType} ${unitId}`;
-            debugLog("runUnitPhase", { phase: "worktree-health-fail", basePath: s.basePath, hasGit, hasPackageJson, hasSrcDir });
+            debugLog("runUnitPhase", { phase: "worktree-health-fail", basePath: s.basePath, hasGit });
             ctx.ui.notify(msg, "error");
             await deps.stopAuto(ctx, pi, msg);
             return { action: "break", reason: "worktree-invalid" };
         }
-        if (!hasPackageJson && !hasSrcDir) {
-            const msg = `Worktree health check failed: ${s.basePath} has no package.json or src/ — refusing to dispatch ${unitType} ${unitId}`;
-            debugLog("runUnitPhase", { phase: "worktree-health-fail", basePath: s.basePath, hasGit, hasPackageJson, hasSrcDir });
+        const hasProjectFile = PROJECT_FILES.some((f) => deps.existsSync(join(s.basePath, f)));
+        const hasSrcDir = deps.existsSync(join(s.basePath, "src"));
+        if (!hasProjectFile && !hasSrcDir) {
+            const msg = `Worktree health check failed: ${s.basePath} has no recognized project files — refusing to dispatch ${unitType} ${unitId}`;
+            debugLog("runUnitPhase", { phase: "worktree-health-fail", basePath: s.basePath, hasProjectFile, hasSrcDir });
             ctx.ui.notify(msg, "error");
             await deps.stopAuto(ctx, pi, msg);
             return { action: "break", reason: "worktree-invalid" };
@@ -574,6 +584,8 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         s.currentUnit.id === unitId);
     const previousTier = s.currentUnitRouting?.tier;
     s.currentUnit = { type: unitType, id: unitId, startedAt: Date.now() };
+    const unitStartSeq = ic.nextSeq();
+    deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: unitStartSeq, eventType: "unit-start", data: { unitType, unitId } });
     deps.captureAvailableSkills();
     deps.writeUnitRuntimeRecord(s.basePath, unitType, unitId, s.currentUnit.startedAt, {
         phase: "dispatched",
@@ -683,7 +695,12 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         unitId,
         prefs,
         buildSnapshotOpts: () => deps.buildSnapshotOpts(unitType, unitId),
-        buildRecoveryContext: () => ({}),
+        buildRecoveryContext: () => ({
+            basePath: s.basePath,
+            verbose: s.verbose,
+            currentUnitStartedAt: s.currentUnit?.startedAt ?? Date.now(),
+            unitRecoveryCount: s.unitRecoveryCount,
+        }),
         pauseAuto: deps.pauseAuto,
     });
     // Write preliminary lock (no session path yet — runUnit creates a new session).
@@ -759,8 +776,8 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
     if (s.currentUnitRouting) {
         deps.recordOutcome(unitType, s.currentUnitRouting.tier, true);
     }
-    const isHookUnit = unitType.startsWith("hook/");
-    const artifactVerified = isHookUnit ||
+    const skipArtifactVerification = unitType.startsWith("hook/") || unitType === "custom-step";
+    const artifactVerified = skipArtifactVerification ||
         deps.verifyExpectedArtifact(unitType, unitId, s.basePath);
     if (artifactVerified) {
         s.completedUnits.push({
@@ -783,6 +800,7 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         s.unitDispatchCount.delete(`${unitType}/${unitId}`);
         s.unitRecoveryCount.delete(`${unitType}/${unitId}`);
     }
+    deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: ic.nextSeq(), eventType: "unit-end", data: { unitType, unitId, status: unitResult.status, artifactVerified }, causedBy: { flowId: ic.flowId, seq: unitStartSeq } });
     return { action: "next", data: { unitStartedAt: s.currentUnit.startedAt } };
 }
 // ─── runFinalize ──────────────────────────────────────────────────────────────

package/dist/resources/extensions/gsd/auto/session.js

@@ -27,6 +27,8 @@ export class AutoSession {
     paused = false;
     stepMode = false;
     verbose = false;
+    activeEngineId = null;
+    activeRunDir = null;
     cmdCtx = null;
     // ── Paths ────────────────────────────────────────────────────────────────
     basePath = "";
@@ -113,6 +115,8 @@ export class AutoSession {
         this.paused = false;
         this.stepMode = false;
         this.verbose = false;
+        this.activeEngineId = null;
+        this.activeRunDir = null;
         this.cmdCtx = null;
         // Paths
         this.basePath = "";
@@ -156,6 +160,8 @@ export class AutoSession {
             paused: this.paused,
             stepMode: this.stepMode,
             basePath: this.basePath,
+            activeEngineId: this.activeEngineId,
+            activeRunDir: this.activeRunDir,
             currentMilestoneId: this.currentMilestoneId,
             currentUnit: this.currentUnit,
             completedUnits: this.completedUnits.length,

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

@@ -18,6 +18,7 @@ import { GLYPH, INDENT } from "../shared/mod.js";
 import { computeProgressScore } from "./progress-score.js";
 import { getActiveWorktreeName } from "./worktree-command.js";
 import { loadEffectiveGSDPreferences, getGlobalGSDPreferencesPath } from "./preferences.js";
+import { resolveServiceTierIcon, getEffectiveServiceTier } from "./service-tier.js";
 // ─── UAT Slice Extraction ─────────────────────────────────────────────────────
 /**
  * Extract the target slice ID from a run-uat unit ID (e.g. "M001/S01" → "S01").
@@ -45,6 +46,7 @@ export function unitVerb(unitType) {
         case "rewrite-docs": return "rewriting";
         case "reassess-roadmap": return "reassessing";
         case "run-uat": return "running UAT";
+        case "custom-step": return "executing workflow step";
         default: return unitType;
     }
 }
@@ -63,6 +65,7 @@ export function unitPhaseLabel(unitType) {
         case "rewrite-docs": return "REWRITE";
         case "reassess-roadmap": return "REASSESS";
         case "run-uat": return "UAT";
+        case "custom-step": return "WORKFLOW";
         default: return unitType.toUpperCase();
     }
 }
@@ -370,6 +373,8 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
     }
     // Pre-fetch last commit for display
     refreshLastCommit(accessors.getBasePath());
+    // Cache the effective service tier at widget creation time (reads preferences)
+    const effectiveServiceTier = getEffectiveServiceTier();
     ctx.ui.setWidget("gsd-progress", (tui, theme) => {
         let pulseBright = true;
         let cachedLines;
@@ -471,9 +476,10 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
                 // Model display — shown in context section, not stats
                 const modelId = cmdCtx?.model?.id ?? "";
                 const modelProvider = cmdCtx?.model?.provider ?? "";
-                const modelDisplay = modelProvider && modelId
+                const tierIcon = resolveServiceTierIcon(effectiveServiceTier, modelId);
+                const modelDisplay = (modelProvider && modelId
                     ? `${modelProvider}/${modelId}`
-                    : modelId;
+                    : modelId) + (tierIcon ? ` ${tierIcon}` : "");
                 // ── Mode: off — return empty ──────────────────────────────────
                 if (widgetMode === "off") {
                     cachedLines = [];

package/dist/resources/extensions/gsd/auto-dispatch.js

@@ -24,7 +24,7 @@ function missingSliceStop(mid, phase) {
 // ─── Rewrite Circuit Breaker ──────────────────────────────────────────────
 const MAX_REWRITE_ATTEMPTS = 3;
 // ─── Rules ────────────────────────────────────────────────────────────────
-const DISPATCH_RULES = [
+export const DISPATCH_RULES = [
     {
         name: "rewrite-docs (override gate)",
         match: async ({ mid, midTitle, state, basePath, session }) => {
@@ -480,22 +480,39 @@ const DISPATCH_RULES = [
         },
     },
 ];
+import { getRegistry } from "./rule-registry.js";
 // ─── Resolver ─────────────────────────────────────────────────────────────
 /**
  * Evaluate dispatch rules in order. Returns the first matching action,
  * or a "stop" action if no rule matches (unhandled phase).
+ *
+ * Delegates to the RuleRegistry when initialized; falls back to inline
+ * loop over DISPATCH_RULES for backward compatibility (tests that import
+ * resolveDispatch directly without registry initialization).
  */
 export async function resolveDispatch(ctx) {
+    // Delegate to registry when available
+    try {
+        const registry = getRegistry();
+        return await registry.evaluateDispatch(ctx);
+    }
+    catch {
+        // Registry not initialized — fall back to inline loop
+    }
     for (const rule of DISPATCH_RULES) {
         const result = await rule.match(ctx);
-        if (result)
+        if (result) {
+            if (result.action !== "skip")
+                result.matchedRule = rule.name;
             return result;
+        }
     }
     // No rule matched — unhandled phase
     return {
         action: "stop",
         reason: `Unhandled phase "${ctx.state.phase}" — run /gsd doctor to diagnose.`,
         level: "info",
+        matchedRule: "<no-match>",
     };
 }
 /** Exposed for testing — returns the rule names in evaluation order. */

package/dist/resources/extensions/gsd/auto-post-unit.js

@@ -31,6 +31,7 @@ import { existsSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 import { uncheckTaskInPlan } from "./undo.js";
 import { atomicWriteSync } from "./atomic-write.js";
+import { _resetHasChangesCache } from "./native-git-bridge.js";
 /** Throttle STATE.md rebuilds — at most once per 30 seconds */
 const STATE_REBUILD_MIN_INTERVAL_MS = 30_000;
 /**
@@ -103,6 +104,12 @@ export async function postUnitPreVerification(pctx, opts) {
                     }
                 }
             }
+            // Invalidate the nativeHasChanges cache before auto-commit (#1853).
+            // The cache has a 10-second TTL and is keyed by basePath.  A stale
+            // `false` result causes autoCommit to skip staging entirely, leaving
+            // code files only in the working tree where they are destroyed by
+            // `git worktree remove --force` during teardown.
+            _resetHasChangesCache();
             const commitMsg = autoCommitCurrentBranch(s.basePath, s.currentUnit.type, s.currentUnit.id, taskContext);
             if (commitMsg) {
                 ctx.ui.notify(`Committed: ${commitMsg.split("\n")[0]}`, "info");

package/dist/resources/extensions/gsd/auto-recovery.js

@@ -263,10 +263,15 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
     // plan has no tasks, creating an infinite skip loop (#699).
     if (unitType === "plan-slice") {
         const planContent = readFileSync(absPath, "utf-8");
-        if (!/^- \[[xX ]\] \*\*T\d+:/m.test(planContent))
+        // Accept checkbox-style (- [x] **T01: ...) or heading-style (### T01 -- / ### T01: / ### T01 —)
+        const hasCheckboxTask = /^- \[[xX ]\] \*\*T\d+:/m.test(planContent);
+        const hasHeadingTask = /^#{2,4}\s+T\d+\s*(?:--|—|:)/m.test(planContent);
+        if (!hasCheckboxTask && !hasHeadingTask)
             return false;
     }
-    // execute-task must also have its checkbox marked [x] in the slice plan
+    // execute-task must also have its checkbox marked [x] in the slice plan.
+    // Heading-style plans (### T01 -- Title) have no checkbox — the task summary
+    // file existence (checked above via resolveExpectedArtifactPath) is sufficient.
     if (unitType === "execute-task") {
         const parts = unitId.split("/");
         const mid = parts[0];
@@ -277,8 +282,11 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
             if (planAbs && existsSync(planAbs)) {
                 const planContent = readFileSync(planAbs, "utf-8");
                 const escapedTid = tid.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-                const re = new RegExp(`^- \\[[xX]\\] \\*\\*${escapedTid}:`, "m");
-                if (!re.test(planContent))
+                const cbRe = new RegExp(`^- \\[[xX]\\] \\*\\*${escapedTid}:`, "m");
+                const hdRe = new RegExp(`^#{2,4}\\s+${escapedTid}\\s*(?:--|—|:)`, "m");
+                // Heading-style entries count as verified (no checkbox to toggle);
+                // checkbox-style entries require [x].
+                if (!cbRe.test(planContent) && !hdRe.test(planContent))
                     return false;
             }
         }