gsd-pi 2.43.0-next.7 → 2.43.0-next.7-dev.4684f0e

package/README.md

@@ -24,6 +24,29 @@ One command. Walk away. Come back to a built project with clean git history.
 
 ---
 
+## What's New in v2.42.0
+
+### New Features
+
+- **Declarative workflow engine** — define YAML workflows that execute through auto-loop, enabling repeatable multi-step automations without code. (#2024)
+- **Unified rule registry & event journal** — centralized rule registry, event journal with query tool, and standardized tool naming convention. (#1928)
+- **PR risk checker** — CI classifies changed files by system area and surfaces risk level on pull requests. (#1930)
+- **`/gsd fast`** — toggle service tier for supported models, enabling prioritized API routing for faster responses. (#1862)
+- **Web mode CLI flags** — `--host`, `--port`, and `--allowed-origins` flags give full control over the web server bind address and CORS policy. (#1873)
+- **ADR attribution** — architecture decision records now distinguish human, agent, and collaborative authorship. (#1830)
+
+### Key Fixes
+
+- **Node v24 web boot** — resolved `ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING` that prevented `gsd --web` from starting on Node v24. (#1864)
+- **Worktree health check for all ecosystems** — broadened from JS-only to 17+ ecosystems (Rust, Go, Python, Java, etc.). (#1860)
+- **Doctor roadmap atomicity** — roadmap checkbox gating now checks summary on disk, not issue detection, preventing false unchecks. (#1915)
+- **Windows path handling** — 8.3 short path resolution, backslash normalization in bash commands, PowerShell browser launch, and parenthesis escaping. (#1960, #1863, #1870, #1872)
+- **Auth token persistence** — web UI auth token survives page refreshes via sessionStorage. (#1877)
+- **German/non-English locale git errors** — git commands now force `LC_ALL=C` to prevent locale-dependent parse failures.
+- **Orphan web server process** — stale web server processes on port 3000 are now cleaned up automatically.
+
+---
+
 ## What's New in v2.41.0
 
 ### New Features

package/dist/cli.js

@@ -1,4 +1,4 @@
-import { AuthStorage, DefaultResourceLoader, ModelRegistry, SettingsManager, SessionManager, createAgentSession, InteractiveMode, runPrintMode, runRpcMode, } from '@gsd/pi-coding-agent';
+import { AuthStorage, DefaultResourceLoader, ModelRegistry, runPackageCommand, SettingsManager, SessionManager, createAgentSession, InteractiveMode, runPrintMode, runRpcMode, } from '@gsd/pi-coding-agent';
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { agentDir, sessionsDir, authFilePath } from './app-paths.js';
@@ -14,6 +14,14 @@ import { parseCliArgs as parseWebCliArgs, runWebCliBranch, migrateLegacyFlatSess
 import { stopWebMode } from './web-mode.js';
 import { getProjectSessionsDir } from './project-sessions.js';
 import { markStartup, printStartupTimings } from './startup-timings.js';
+// ---------------------------------------------------------------------------
+// V8 compile cache — Node 22+ can cache compiled bytecode across runs,
+// eliminating repeated parse/compile overhead for unchanged modules.
+// Must be set early so dynamic imports (extensions, lazy subcommands) benefit.
+// ---------------------------------------------------------------------------
+if (parseInt(process.versions.node) >= 22) {
+    process.env.NODE_COMPILE_CACHE ??= join(agentDir, '.compile-cache');
+}
 function exitIfManagedResourcesAreNewer(currentAgentDir) {
     const currentVersion = process.env.GSD_VERSION || '0.0.0';
     const managedVersion = getNewerManagedResourceVersion(currentAgentDir, currentVersion);
@@ -113,6 +121,18 @@ if (subcommand && process.argv.includes('--help')) {
         process.exit(0);
     }
 }
+const packageCommand = await runPackageCommand({
+    appName: 'gsd',
+    args: process.argv.slice(2),
+    cwd: process.cwd(),
+    agentDir,
+    stdout: process.stdout,
+    stderr: process.stderr,
+    allowedCommands: new Set(['install', 'remove', 'list']),
+});
+if (packageCommand.handled) {
+    process.exit(packageCommand.exitCode);
+}
 // `gsd config` — replay the setup wizard and exit
 if (cliFlags.messages[0] === 'config') {
     const authStorage = AuthStorage.create(authFilePath);
@@ -461,8 +481,14 @@ const sessionManager = cliFlags._selectedSessionPath
 exitIfManagedResourcesAreNewer(agentDir);
 initResources(agentDir);
 markStartup('initResources');
+// Overlap resource loading with session manager setup — both are independent.
+// resourceLoader.reload() is the most expensive step (jiti compilation), so
+// starting it early shaves ~50-200ms off interactive startup.
 const resourceLoader = buildResourceLoader(agentDir);
-await resourceLoader.reload();
+const resourceLoadPromise = resourceLoader.reload();
+// While resources load, let session manager finish any async I/O it needs.
+// Then await the resource promise before creating the agent session.
+await resourceLoadPromise;
 markStartup('resourceLoader.reload');
 const { session, extensionsResult } = await createAgentSession({
     authStorage,
@@ -530,8 +556,9 @@ if (!process.stdin.isTTY) {
     process.stderr.write('[gsd]   gsd --mode text "message"      Text output mode\n');
     process.exit(1);
 }
-// Welcome screen — shown on every fresh interactive session before TUI takes over
-{
+// Welcome screen — shown on every fresh interactive session before TUI takes over.
+// Skip when the first-run banner was already printed in loader.ts (prevents double banner).
+if (!process.env.GSD_FIRST_RUN_BANNER) {
     const { printWelcomeScreen } = await import('./welcome-screen.js');
     printWelcomeScreen({
         version: process.env.GSD_VERSION || '0.0.0',

package/dist/help-text.js

@@ -29,6 +29,27 @@ const SUBCOMMAND_HELP = {
         '',
         'Compare with --continue (-c) which always resumes the most recent session.',
     ].join('\n'),
+    install: [
+        'Usage: gsd install <source> [-l, --local]',
+        '',
+        'Install a package/extension source and run declared lifecycle hooks.',
+        '',
+        'Examples:',
+        '  gsd install npm:@foo/bar',
+        '  gsd install git:github.com/user/repo',
+        '  gsd install https://github.com/user/repo',
+        '  gsd install ./local/path',
+    ].join('\n'),
+    remove: [
+        'Usage: gsd remove <source> [-l, --local]',
+        '',
+        'Remove an installed package source and its settings entry.',
+    ].join('\n'),
+    list: [
+        'Usage: gsd list',
+        '',
+        'List installed package sources from user and project settings.',
+    ].join('\n'),
     worktree: [
         'Usage: gsd worktree <command> [args]',
         '',
@@ -122,6 +143,9 @@ export function printHelp(version) {
     process.stdout.write('  --help, -h               Print this help and exit\n');
     process.stdout.write('\nSubcommands:\n');
     process.stdout.write('  config                   Re-run the setup wizard\n');
+    process.stdout.write('  install <source>         Install a package/extension source\n');
+    process.stdout.write('  remove <source>          Remove an installed package source\n');
+    process.stdout.write('  list                     List installed package sources\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');

package/dist/loader.js

@@ -42,7 +42,8 @@ const pkgDir = resolve(dirname(fileURLToPath(import.meta.url)), '..', 'pkg');
 process.env.PI_PACKAGE_DIR = pkgDir;
 process.env.PI_SKIP_VERSION_CHECK = '1'; // GSD runs its own update check in cli.ts — suppress pi's
 process.title = 'gsd';
-// Print branded banner on first launch (before ~/.gsd/ exists)
+// Print branded banner on first launch (before ~/.gsd/ exists).
+// Set GSD_FIRST_RUN_BANNER so cli.ts skips the duplicate welcome screen.
 if (!existsSync(appRoot)) {
     const cyan = '\x1b[36m';
     const green = '\x1b[32m';
@@ -53,6 +54,7 @@ if (!existsSync(appRoot)) {
         '\n' +
         `  Get Shit Done ${dim}v${gsdVersion}${reset}\n` +
         `  ${green}Welcome.${reset} Setting up your environment...\n\n`);
+    process.env.GSD_FIRST_RUN_BANNER = '1';
 }
 // GSD_CODING_AGENT_DIR — tells pi's getAgentDir() to return ~/.gsd/agent/ instead of ~/.gsd/agent/
 process.env.GSD_CODING_AGENT_DIR = agentDir;

package/dist/resource-loader.js

@@ -48,14 +48,25 @@ function getBundledGsdVersion() {
     }
 }
 function writeManagedResourceManifest(agentDir) {
-    // Record root-level files currently in the bundled extensions source so that
-    // future upgrades can detect and prune any that get removed or moved.
+    // Record root-level files and subdirectory extension names currently in the
+    // bundled extensions source so that future upgrades can detect and prune any
+    // that get removed or moved.
     let installedExtensionRootFiles = [];
+    let installedExtensionDirs = [];
     try {
         if (existsSync(bundledExtensionsDir)) {
-            installedExtensionRootFiles = readdirSync(bundledExtensionsDir, { withFileTypes: true })
+            const entries = readdirSync(bundledExtensionsDir, { withFileTypes: true });
+            installedExtensionRootFiles = entries
                 .filter(e => e.isFile())
                 .map(e => e.name);
+            installedExtensionDirs = entries
+                .filter(e => e.isDirectory())
+                .filter(e => {
+                // Only track directories that are actual extensions (contain index.js or index.ts)
+                const dirPath = join(bundledExtensionsDir, e.name);
+                return existsSync(join(dirPath, 'index.js')) || existsSync(join(dirPath, 'index.ts'));
+            })
+                .map(e => e.name);
         }
     }
     catch { /* non-fatal */ }
@@ -64,6 +75,7 @@ function writeManagedResourceManifest(agentDir) {
         syncedAt: Date.now(),
         contentHash: computeResourceFingerprint(),
         installedExtensionRootFiles,
+        installedExtensionDirs,
     };
     writeFileSync(getManagedResourceManifestPath(agentDir), JSON.stringify(manifest));
 }
@@ -284,16 +296,20 @@ function pruneRemovedBundledExtensions(manifest, agentDir) {
         return;
     // Current bundled root-level files (what the new version provides)
     const currentSourceFiles = new Set();
+    // Current bundled subdirectory extensions
+    const currentSourceDirs = new Set();
     try {
         if (existsSync(bundledExtensionsDir)) {
             for (const e of readdirSync(bundledExtensionsDir, { withFileTypes: true })) {
                 if (e.isFile())
                     currentSourceFiles.add(e.name);
+                if (e.isDirectory())
+                    currentSourceDirs.add(e.name);
             }
         }
     }
     catch { /* non-fatal */ }
-    const removeIfStale = (fileName) => {
+    const removeFileIfStale = (fileName) => {
         if (currentSourceFiles.has(fileName))
             return; // still in bundle, not stale
         const stale = join(extensionsDir, fileName);
@@ -303,17 +319,33 @@ function pruneRemovedBundledExtensions(manifest, agentDir) {
         }
         catch { /* non-fatal */ }
     };
+    const removeDirIfStale = (dirName) => {
+        if (currentSourceDirs.has(dirName))
+            return; // still in bundle, not stale
+        const stale = join(extensionsDir, dirName);
+        try {
+            if (existsSync(stale))
+                rmSync(stale, { recursive: true, force: true });
+        }
+        catch { /* non-fatal */ }
+    };
     if (manifest?.installedExtensionRootFiles) {
         // Manifest-based: remove previously-installed root files that are no longer bundled
         for (const prevFile of manifest.installedExtensionRootFiles) {
-            removeIfStale(prevFile);
+            removeFileIfStale(prevFile);
+        }
+    }
+    if (manifest?.installedExtensionDirs) {
+        // Manifest-based: remove previously-installed subdirectory extensions that are no longer bundled
+        for (const prevDir of manifest.installedExtensionDirs) {
+            removeDirIfStale(prevDir);
         }
     }
     // Always remove known stale files regardless of manifest state.
     // These were installed by pre-manifest versions so they may not appear in
     // installedExtensionRootFiles even when a manifest exists.
     // env-utils.js was moved from extensions/ root → gsd/ in v2.39.x (#1634)
-    removeIfStale('env-utils.js');
+    removeFileIfStale('env-utils.js');
 }
 /**
  * Syncs all bundled resources to agentDir (~/.gsd/agent/) on every launch.
@@ -416,5 +448,6 @@ export function buildResourceLoader(agentDir) {
     return new DefaultResourceLoader({
         agentDir,
         additionalExtensionPaths: piExtensionPaths,
+        bundledExtensionNames: bundledKeys,
     });
 }

package/dist/resources/extensions/async-jobs/async-bash-tool.js

@@ -83,6 +83,15 @@ export function createAsyncBashTool(getManager, getCwd) {
  */
 function executeBashInBackground(command, cwd, signal, timeout) {
     return new Promise((resolve, reject) => {
+        let settled = false;
+        const safeResolve = (value) => { if (!settled) {
+            settled = true;
+            resolve(value);
+        } };
+        const safeReject = (err) => { if (!settled) {
+            settled = true;
+            reject(err);
+        } };
         const { shell, args } = getShellConfig();
         const resolvedCommand = sanitizeCommand(command);
         const child = spawn(shell, [...args, resolvedCommand], {
@@ -93,11 +102,42 @@ function executeBashInBackground(command, cwd, signal, timeout) {
         });
         let timedOut = false;
         let timeoutHandle;
+        let sigkillHandle;
+        let hardDeadlineHandle;
+        /** Grace period (ms) between SIGTERM and SIGKILL. */
+        const SIGKILL_GRACE_MS = 5_000;
+        /** Hard deadline (ms) after SIGKILL to force-resolve the promise. */
+        const HARD_DEADLINE_MS = 3_000;
         if (timeout !== undefined && timeout > 0) {
             timeoutHandle = setTimeout(() => {
                 timedOut = true;
                 if (child.pid)
                     killTree(child.pid);
+                // If the process ignores SIGTERM, escalate to SIGKILL
+                sigkillHandle = setTimeout(() => {
+                    if (child.pid) {
+                        try {
+                            process.kill(-child.pid, "SIGKILL");
+                        }
+                        catch { /* ignore */ }
+                        try {
+                            process.kill(child.pid, "SIGKILL");
+                        }
+                        catch { /* ignore */ }
+                    }
+                    // Hard deadline: if even SIGKILL doesn't trigger 'close',
+                    // force-resolve so the job doesn't hang forever (#2186).
+                    hardDeadlineHandle = setTimeout(() => {
+                        const output = Buffer.concat(chunks).toString("utf-8");
+                        safeResolve(output
+                            ? `${output}\n\nCommand timed out after ${timeout} seconds (force-killed)`
+                            : `Command timed out after ${timeout} seconds (force-killed)`);
+                    }, HARD_DEADLINE_MS);
+                    if (typeof hardDeadlineHandle === "object" && "unref" in hardDeadlineHandle)
+                        hardDeadlineHandle.unref();
+                }, SIGKILL_GRACE_MS);
+                if (typeof sigkillHandle === "object" && "unref" in sigkillHandle)
+                    sigkillHandle.unref();
             }, timeout * 1000);
         }
         const chunks = [];
@@ -139,23 +179,31 @@ function executeBashInBackground(command, cwd, signal, timeout) {
         child.on("error", (err) => {
             if (timeoutHandle)
                 clearTimeout(timeoutHandle);
+            if (sigkillHandle)
+                clearTimeout(sigkillHandle);
+            if (hardDeadlineHandle)
+                clearTimeout(hardDeadlineHandle);
             signal.removeEventListener("abort", onAbort);
-            reject(err);
+            safeReject(err);
         });
         child.on("close", (code) => {
             if (timeoutHandle)
                 clearTimeout(timeoutHandle);
+            if (sigkillHandle)
+                clearTimeout(sigkillHandle);
+            if (hardDeadlineHandle)
+                clearTimeout(hardDeadlineHandle);
             signal.removeEventListener("abort", onAbort);
             if (spillStream)
                 spillStream.end();
             if (signal.aborted) {
                 const output = Buffer.concat(chunks).toString("utf-8");
-                resolve(output ? `${output}\n\nCommand aborted` : "Command aborted");
+                safeResolve(output ? `${output}\n\nCommand aborted` : "Command aborted");
                 return;
             }
             if (timedOut) {
                 const output = Buffer.concat(chunks).toString("utf-8");
-                resolve(output ? `${output}\n\nCommand timed out after ${timeout} seconds` : `Command timed out after ${timeout} seconds`);
+                safeResolve(output ? `${output}\n\nCommand timed out after ${timeout} seconds` : `Command timed out after ${timeout} seconds`);
                 return;
             }
             const fullOutput = Buffer.concat(chunks).toString("utf-8");
@@ -176,7 +224,7 @@ function executeBashInBackground(command, cwd, signal, timeout) {
             if (code !== 0 && code !== null) {
                 text += `\n\nCommand exited with code ${code}`;
             }
-            resolve(text);
+            safeResolve(text);
         });
     });
 }

package/dist/resources/extensions/async-jobs/await-tool.js

@@ -54,6 +54,11 @@ export function createAwaitTool(getManager) {
                     };
                 }
             }
+            // Mark all watched jobs as awaited upfront so the onJobComplete
+            // callback (which fires synchronously in the promise .then()) knows
+            // to suppress the follow-up message.
+            for (const j of watched)
+                j.awaited = true;
             // If all watched jobs are already done, return immediately
             const running = watched.filter((j) => j.status === "running");
             if (running.length === 0) {

package/dist/resources/extensions/async-jobs/index.js

@@ -34,6 +34,8 @@ export default function AsyncJobs(pi) {
         latestCwd = ctx.cwd;
         manager = new AsyncJobManager({
             onJobComplete: (job) => {
+                if (job.awaited)
+                    return;
                 const statusEmoji = job.status === "completed" ? "done" : "error";
                 const elapsed = ((Date.now() - job.startTime) / 1000).toFixed(1);
                 const output = job.status === "completed"

package/dist/resources/extensions/bg-shell/overlay.js

@@ -371,6 +371,9 @@ export class BgManagerOverlay {
         inner.push(th.fg("dim", "↑↓ scroll · tab output · q back"));
         return this.box(inner, width);
     }
+    dispose() {
+        clearInterval(this.refreshTimer);
+    }
     invalidate() {
         this.cachedWidth = undefined;
         this.cachedLines = undefined;

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

@@ -165,9 +165,7 @@ export async function runPreDispatch(ic, loopState) {
         midTitle = state.activeMilestone?.title;
         if (mid) {
             if (deps.getIsolationMode() !== "none") {
-                deps.captureIntegrationBranch(s.basePath, mid, {
-                    commitDocs: prefs?.git?.commit_docs,
-                });
+                deps.captureIntegrationBranch(s.basePath, mid);
             }
             deps.resolver.enterMilestone(mid, ctx.ui);
         }

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

@@ -5,7 +5,8 @@
 import { deriveState } from "./state.js";
 import { loadFile } from "./files.js";
 import { isDbAvailable, getMilestoneSlices } from "./gsd-db.js";
-import { resolveSliceFile, relSliceFile, } from "./paths.js";
+import { parseRoadmap } from "./parsers-legacy.js";
+import { resolveMilestoneFile, resolveSliceFile, relSliceFile, } from "./paths.js";
 import { buildResearchSlicePrompt, buildResearchMilestonePrompt, buildPlanSlicePrompt, buildPlanMilestonePrompt, buildExecuteTaskPrompt, buildCompleteSlicePrompt, buildCompleteMilestonePrompt, buildReassessRoadmapPrompt, buildRunUatPrompt, buildReplanSlicePrompt, } from "./auto-prompts.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { pauseAuto } from "./auto.js";
@@ -118,14 +119,20 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
         }
         case "reassess":
         case "reassess-roadmap": {
-            // DB primary path — get completed slices
+            // DB primary path — get completed slices, fall back to file parsing when DB has no data
             let completedSliceIds = [];
             if (isDbAvailable()) {
                 completedSliceIds = getMilestoneSlices(mid).filter(s => s.status === "complete").map(s => s.id);
             }
-            else {
-                ctx.ui.notify("Cannot dispatch reassess-roadmap: DB unavailable.", "warning");
-                return;
+            if (completedSliceIds.length === 0) {
+                // File-based fallback: parse roadmap checkboxes
+                const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
+                if (roadmapPath) {
+                    const roadmapContent = await loadFile(roadmapPath);
+                    if (roadmapContent) {
+                        completedSliceIds = parseRoadmap(roadmapContent).slices.filter(s => s.done).map(s => s.id);
+                    }
+                }
             }
             if (completedSliceIds.length === 0) {
                 ctx.ui.notify("Cannot dispatch reassess-roadmap: no completed slices.", "warning");
@@ -147,9 +154,15 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
             if (isDbAvailable()) {
                 uatCompletedSliceIds = getMilestoneSlices(mid).filter(s => s.status === "complete").map(s => s.id);
             }
-            else {
-                ctx.ui.notify("Cannot dispatch run-uat: DB unavailable.", "warning");
-                return;
+            if (uatCompletedSliceIds.length === 0) {
+                // File-based fallback: parse roadmap checkboxes
+                const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
+                if (roadmapPath) {
+                    const roadmapContent = await loadFile(roadmapPath);
+                    if (roadmapContent) {
+                        uatCompletedSliceIds = parseRoadmap(roadmapContent).slices.filter(s => s.done).map(s => s.id);
+                    }
+                }
             }
             if (uatCompletedSliceIds.length === 0) {
                 ctx.ui.notify("Cannot dispatch run-uat: no completed slices.", "warning");

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

@@ -13,7 +13,7 @@
 import { deriveState } from "./state.js";
 import { loadFile, parseSummary, resolveAllOverrides } from "./files.js";
 import { loadPrompt } from "./prompt-loader.js";
-import { resolveSliceFile, resolveSlicePath, resolveTaskFile, resolveMilestoneFile, resolveTasksDir, buildTaskFileName, gsdRoot, } from "./paths.js";
+import { resolveSliceFile, resolveTaskFile, resolveMilestoneFile, resolveTasksDir, buildTaskFileName, gsdRoot, } from "./paths.js";
 import { invalidateAllCaches } from "./cache.js";
 import { closeoutUnit } from "./auto-unit-closeout.js";
 import { autoCommitCurrentBranch, } from "./worktree.js";
@@ -22,13 +22,13 @@ import { writeUnitRuntimeRecord, clearUnitRuntimeRecord } from "./unit-runtime.j
 import { runGSDDoctor, rebuildState, summarizeDoctorIssues } from "./doctor.js";
 import { recordHealthSnapshot, checkHealEscalation } from "./doctor-proactive.js";
 import { syncStateToProjectRoot } from "./auto-worktree-sync.js";
-import { isDbAvailable, getTask, getSlice, getMilestone, updateTaskStatus } from "./gsd-db.js";
+import { isDbAvailable, getTask, getSlice, getMilestone, updateTaskStatus, _getAdapter } from "./gsd-db.js";
 import { renderPlanCheckboxes } from "./markdown-renderer.js";
 import { consumeSignal } from "./session-status-io.js";
 import { checkPostUnitHooks, isRetryPending, consumeRetryTrigger, persistHookState, resolveHookArtifactPath, } from "./post-unit-hooks.js";
 import { hasPendingCaptures, loadPendingCaptures } from "./captures.js";
 import { debugLog } from "./debug-logger.js";
-import { existsSync, unlinkSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 import { atomicWriteSync } from "./atomic-write.js";
 import { _resetHasChangesCache } from "./native-git-bridge.js";
@@ -101,6 +101,39 @@ export function detectRogueFileWrites(unitType, unitId, basePath) {
         if (!hasPlanningState) {
             rogues.push({ path: planPath, unitType, unitId });
         }
+        // Also check for rogue REPLAN.md
+        const replanPath = resolveSliceFile(basePath, mid, sid, "REPLAN");
+        if (replanPath && existsSync(replanPath) && !hasPlanningState) {
+            rogues.push({ path: replanPath, unitType, unitId });
+        }
+    }
+    else if (unitType === "reassess-roadmap") {
+        const [mid, sid] = parts;
+        if (!mid || !sid)
+            return [];
+        const assessPath = resolveSliceFile(basePath, mid, sid, "ASSESSMENT");
+        if (!assessPath || !existsSync(assessPath))
+            return [];
+        // Assessment file exists on disk — check if DB knows about it via the artifacts table
+        const adapter = _getAdapter();
+        if (adapter) {
+            const row = adapter.prepare(`SELECT 1 FROM artifacts WHERE path LIKE :pattern AND artifact_type = 'ASSESSMENT' LIMIT 1`).get({ ":pattern": `%${sid}-ASSESSMENT.md` });
+            if (!row) {
+                rogues.push({ path: assessPath, unitType, unitId });
+            }
+        }
+    }
+    else if (unitType === "plan-task") {
+        const [mid, sid, tid] = parts;
+        if (!mid || !sid || !tid)
+            return [];
+        const taskPlanPath = resolveTaskFile(basePath, mid, sid, tid, "PLAN");
+        if (!taskPlanPath || !existsSync(taskPlanPath))
+            return [];
+        const dbRow = getTask(mid, sid, tid);
+        if (!dbRow) {
+            rogues.push({ path: taskPlanPath, unitType, unitId });
+        }
     }
     return rogues;
 }
@@ -468,26 +501,10 @@ export async function postUnitPostVerification(pctx) {
                             updateTaskStatus(mid, sid, tid, "pending");
                             await renderPlanCheckboxes(s.basePath, mid, sid);
                         }
-                        catch {
-                            // DB may be unavailable — fall back to direct file-based uncheck
-                            try {
-                                const slicePath = resolveSlicePath(s.basePath, mid, sid);
-                                if (slicePath) {
-                                    const { readdirSync } = await import("node:fs");
-                                    const planCandidates = readdirSync(slicePath)
-                                        .filter((f) => f.includes("PLAN") && (f.startsWith(sid) || f.startsWith(`${sid}-`)));
-                                    if (planCandidates.length > 0) {
-                                        const planFile = join(slicePath, planCandidates[0]);
-                                        let content = readFileSync(planFile, "utf-8");
-                                        const regex = new RegExp(`^(\\s*-\\s*)\\[x\\](\\s*\\**${tid}\\**[:\\s])`, "mi");
-                                        if (regex.test(content)) {
-                                            content = content.replace(regex, "$1[ ]$2");
-                                            writeFileSync(planFile, content, "utf-8");
-                                        }
-                                    }
-                                }
-                            }
-                            catch { /* non-fatal: file-based fallback failure */ }
+                        catch (dbErr) {
+                            // DB unavailable — fail explicitly rather than silently reverting to markdown mutation.
+                            // Use 'gsd recover' to rebuild DB state from disk if needed.
+                            process.stderr.write(`gsd: retry state-reset failed (DB unavailable): ${dbErr.message}. Run 'gsd recover' to reconcile.\n`);
                         }
                     }
                     // 2. Delete SUMMARY.md for the task