gsd-pi 2.43.0 → 2.44.0-dev.62b5d6c

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';
@@ -121,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);

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/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/github-sync/sync.js

@@ -9,7 +9,8 @@
  */
 import { existsSync, readdirSync } from "node:fs";
 import { join } from "node:path";
-import { loadFile, parseRoadmap, parsePlan, parseSummary } from "../gsd/files.js";
+import { loadFile, parseSummary } from "../gsd/files.js";
+import { parseRoadmap, parsePlan } from "../gsd/parsers-legacy.js";
 import { resolveMilestoneFile, resolveSliceFile, resolveTaskFile, } from "../gsd/paths.js";
 import { debugLog } from "../gsd/debug-logger.js";
 import { loadEffectiveGSDPreferences } from "../gsd/preferences.js";

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

@@ -120,7 +120,6 @@ export async function autoLoop(ctx, pi, s, deps) {
                     prompt: step.prompt,
                     finalPrompt: step.prompt,
                     pauseAfterUatDispatch: false,
-                    observabilityIssues: [],
                     state: gsdState,
                     mid: s.currentMilestoneId ?? "workflow",
                     midTitle: "Workflow",
@@ -191,7 +190,6 @@ export async function autoLoop(ctx, pi, s, deps) {
                     prompt: sidecarItem.prompt,
                     finalPrompt: sidecarItem.prompt,
                     pauseAfterUatDispatch: false,
-                    observabilityIssues: [],
                     state: sidecarState,
                     mid: sidecarState.activeMilestone?.id,
                     midTitle: sidecarState.activeMilestone?.title,

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

@@ -428,12 +428,11 @@ export async function runDispatch(ic, preData, loopState) {
         debugLog("autoLoop", { phase: "exit", reason: "prior-slice-blocker" });
         return { action: "break", reason: "prior-slice-blocker" };
     }
-    const observabilityIssues = await deps.collectObservabilityWarnings(ctx, s.basePath, unitType, unitId);
     return {
         action: "next",
         data: {
             unitType, unitId, prompt, finalPrompt: prompt,
-            pauseAfterUatDispatch, observabilityIssues,
+            pauseAfterUatDispatch,
             state, mid, midTitle,
             isRetry: false, previousTier: undefined,
             hookModelOverride: preDispatchResult.model,
@@ -543,7 +542,7 @@ export async function runGuards(ic, mid) {
  */
 export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
     const { ctx, pi, s, deps, prefs } = ic;
-    const { unitType, unitId, prompt, observabilityIssues, state, mid } = iterData;
+    const { unitType, unitId, prompt, state, mid } = iterData;
     debugLog("autoLoop", {
         phase: "unit-execution",
         iteration: ic.iteration,
@@ -569,11 +568,11 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         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" };
+            // Greenfield projects won't have project files yet — the first task creates them.
+            // Log a warning but allow execution to proceed. The .git check above is sufficient
+            // to ensure we're in a valid working directory.
+            debugLog("runUnitPhase", { phase: "worktree-health-warn-greenfield", basePath: s.basePath, hasProjectFile, hasSrcDir });
+            ctx.ui.notify(`Warning: ${s.basePath} has no recognized project files — proceeding as greenfield project`, "warning");
         }
     }
     // Detect retry and capture previous tier for escalation
@@ -628,10 +627,6 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
             finalPrompt = `**RETRY — your previous attempt did not produce the required artifact.**\n\nDiagnostic from previous attempt:\n${cappedDiag}\n\nFix whatever went wrong and make sure you write the required file this time.\n\n---\n\n${finalPrompt}`;
         }
     }
-    const repairBlock = deps.buildObservabilityRepairBlock(observabilityIssues);
-    if (repairBlock) {
-        finalPrompt = `${finalPrompt}${repairBlock}`;
-    }
     // Prompt char measurement
     s.lastPromptCharCount = finalPrompt.length;
     s.lastBaselineCharCount = undefined;

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

@@ -8,8 +8,7 @@
 import { getCurrentBranch } from "./worktree.js";
 import { getActiveHook } from "./post-unit-hooks.js";
 import { getLedger, getProjectTotals } from "./metrics.js";
-import { resolveMilestoneFile, resolveSliceFile, } from "./paths.js";
-import { parseRoadmap, parsePlan } from "./files.js";
+import { isDbAvailable, getMilestoneSlices, getSliceTasks } from "./gsd-db.js";
 import { readFileSync, writeFileSync, existsSync } from "node:fs";
 import { execFileSync } from "node:child_process";
 import { truncateToWidth, visibleWidth } from "@gsd/pi-tui";
@@ -192,24 +191,26 @@ export function estimateTimeRemaining() {
 let cachedSliceProgress = null;
 export function updateSliceProgressCache(base, mid, activeSid) {
     try {
-        const roadmapFile = resolveMilestoneFile(base, mid, "ROADMAP");
-        if (!roadmapFile)
-            return;
-        const content = readFileSync(roadmapFile, "utf-8");
-        const roadmap = parseRoadmap(content);
+        let normSlices;
+        if (isDbAvailable()) {
+            normSlices = getMilestoneSlices(mid).map(s => ({ id: s.id, done: s.status === "complete", title: s.title }));
+        }
+        else {
+            normSlices = [];
+        }
         let activeSliceTasks = null;
         let taskDetails = null;
         if (activeSid) {
             try {
-                const planFile = resolveSliceFile(base, mid, activeSid, "PLAN");
-                if (planFile && existsSync(planFile)) {
-                    const planContent = readFileSync(planFile, "utf-8");
-                    const plan = parsePlan(planContent);
-                    activeSliceTasks = {
-                        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 }));
+                if (isDbAvailable()) {
+                    const dbTasks = getSliceTasks(mid, activeSid);
+                    if (dbTasks.length > 0) {
+                        activeSliceTasks = {
+                            done: dbTasks.filter(t => t.status === "complete" || t.status === "done").length,
+                            total: dbTasks.length,
+                        };
+                        taskDetails = dbTasks.map(t => ({ id: t.id, title: t.title, done: t.status === "complete" || t.status === "done" }));
+                    }
                 }
             }
             catch {
@@ -217,8 +218,8 @@ export function updateSliceProgressCache(base, mid, activeSid) {
             }
         }
         cachedSliceProgress = {
-            done: roadmap.slices.filter(s => s.done).length,
-            total: roadmap.slices.length,
+            done: normSlices.filter(s => s.done).length,
+            total: normSlices.length,
             milestoneId: mid,
             activeSliceTasks,
             taskDetails,

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

@@ -3,7 +3,9 @@
  * Resolves phase name → unit type + prompt, creates a session, and sends the message.
  */
 import { deriveState } from "./state.js";
-import { loadFile, parseRoadmap } from "./files.js";
+import { loadFile } from "./files.js";
+import { isDbAvailable, getMilestoneSlices } from "./gsd-db.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";
@@ -117,19 +119,26 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
         }
         case "reassess":
         case "reassess-roadmap": {
-            const roadmapFile = resolveMilestoneFile(base, mid, "ROADMAP");
-            const roadmapContent = roadmapFile ? await loadFile(roadmapFile) : null;
-            if (!roadmapContent) {
-                ctx.ui.notify("Cannot dispatch reassess-roadmap: no roadmap found.", "warning");
-                return;
+            // 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);
+            }
+            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);
+                    }
+                }
             }
-            const roadmap = parseRoadmap(roadmapContent);
-            const completedSlices = roadmap.slices.filter(s => s.done);
-            if (completedSlices.length === 0) {
+            if (completedSliceIds.length === 0) {
                 ctx.ui.notify("Cannot dispatch reassess-roadmap: no completed slices.", "warning");
                 return;
             }
-            const completedSliceId = completedSlices[completedSlices.length - 1].id;
+            const completedSliceId = completedSliceIds[completedSliceIds.length - 1];
             unitType = "reassess-roadmap";
             unitId = `${mid}/${completedSliceId}`;
             prompt = await buildReassessRoadmapPrompt(mid, midTitle, completedSliceId, base);
@@ -141,19 +150,25 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
             // incomplete) slice. After slice completion, state.activeSlice advances
             // to the next incomplete slice, so we find the last done slice from the
             // roadmap instead (#1693).
-            const roadmapFile = resolveMilestoneFile(base, mid, "ROADMAP");
-            const roadmapContent = roadmapFile ? await loadFile(roadmapFile) : null;
-            if (!roadmapContent) {
-                ctx.ui.notify("Cannot dispatch run-uat: no roadmap found.", "warning");
-                return;
+            let uatCompletedSliceIds = [];
+            if (isDbAvailable()) {
+                uatCompletedSliceIds = getMilestoneSlices(mid).filter(s => s.status === "complete").map(s => s.id);
+            }
+            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);
+                    }
+                }
             }
-            const roadmap = parseRoadmap(roadmapContent);
-            const completedSlices = roadmap.slices.filter(s => s.done);
-            if (completedSlices.length === 0) {
+            if (uatCompletedSliceIds.length === 0) {
                 ctx.ui.notify("Cannot dispatch run-uat: no completed slices.", "warning");
                 return;
             }
-            const sid = completedSlices[completedSlices.length - 1].id;
+            const sid = uatCompletedSliceIds[uatCompletedSliceIds.length - 1];
             const uatFile = resolveSliceFile(base, mid, sid, "UAT");
             if (!uatFile) {
                 ctx.ui.notify("Cannot dispatch run-uat: no UAT file found.", "warning");

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

@@ -8,7 +8,8 @@
  * data structure that is inspectable, testable per-rule, and extensible
  * without modifying orchestration code.
  */
-import { loadFile, loadActiveOverrides, parseRoadmap } from "./files.js";
+import { loadFile, loadActiveOverrides } from "./files.js";
+import { isDbAvailable, getMilestoneSlices } from "./gsd-db.js";
 import { resolveMilestoneFile, resolveMilestonePath, resolveSliceFile, resolveTaskFile, relSliceFile, buildMilestoneFileName, } from "./paths.js";
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
@@ -92,12 +93,18 @@ export const DISPATCH_RULES = [
             if (!prefs?.uat_dispatch)
                 return null;
             const roadmapFile = resolveMilestoneFile(basePath, mid, "ROADMAP");
-            const roadmapContent = roadmapFile ? await loadFile(roadmapFile) : null;
-            if (!roadmapContent)
+            // DB-first: get completed slices from DB
+            let completedSliceIds;
+            if (isDbAvailable()) {
+                completedSliceIds = getMilestoneSlices(mid)
+                    .filter(s => s.status === "complete")
+                    .map(s => s.id);
+            }
+            else {
                 return null;
-            const roadmap = parseRoadmap(roadmapContent);
-            for (const slice of roadmap.slices.filter(s => s.done)) {
-                const resultFile = resolveSliceFile(basePath, mid, slice.id, "UAT-RESULT");
+            }
+            for (const sliceId of completedSliceIds) {
+                const resultFile = resolveSliceFile(basePath, mid, sliceId, "UAT-RESULT");
                 if (!resultFile)
                     continue;
                 const content = await loadFile(resultFile);
@@ -108,7 +115,7 @@ export const DISPATCH_RULES = [
                 if (verdict && verdict !== "pass" && verdict !== "passed") {
                     return {
                         action: "stop",
-                        reason: `UAT verdict for ${slice.id} is "${verdict}" — blocking progression until resolved.\nReview the UAT result and update the verdict to PASS, or re-run /gsd auto after fixing.`,
+                        reason: `UAT verdict for ${sliceId} is "${verdict}" — blocking progression until resolved.\nReview the UAT result and update the verdict to PASS, or re-run /gsd auto after fixing.`,
                         level: "warning",
                     };
                 }
@@ -376,15 +383,19 @@ export const DISPATCH_RULES = [
             // Safety guard (#1368): verify all roadmap slices have SUMMARY files before
             // allowing milestone validation. If any slice lacks a summary, the milestone
             // is not genuinely complete — something skipped earlier slices.
-            const roadmapFile = resolveMilestoneFile(basePath, mid, "ROADMAP");
-            const roadmapContent = roadmapFile ? await loadFile(roadmapFile) : null;
-            if (roadmapContent) {
-                const roadmap = parseRoadmap(roadmapContent);
+            let sliceIds;
+            if (isDbAvailable()) {
+                sliceIds = getMilestoneSlices(mid).map(s => s.id);
+            }
+            else {
+                sliceIds = [];
+            }
+            if (sliceIds.length > 0) {
                 const missingSlices = [];
-                for (const slice of roadmap.slices) {
-                    const summaryPath = resolveSliceFile(basePath, mid, slice.id, "SUMMARY");
+                for (const sid of sliceIds) {
+                    const summaryPath = resolveSliceFile(basePath, mid, sid, "SUMMARY");
                     if (!summaryPath || !existsSync(summaryPath)) {
-                        missingSlices.push(slice.id);
+                        missingSlices.push(sid);
                     }
                 }
                 if (missingSlices.length > 0) {
@@ -430,15 +441,19 @@ export const DISPATCH_RULES = [
             if (state.phase !== "completing-milestone")
                 return null;
             // Safety guard (#1368): verify all roadmap slices have SUMMARY files.
-            const roadmapFile = resolveMilestoneFile(basePath, mid, "ROADMAP");
-            const roadmapContent = roadmapFile ? await loadFile(roadmapFile) : null;
-            if (roadmapContent) {
-                const roadmap = parseRoadmap(roadmapContent);
+            let sliceIds;
+            if (isDbAvailable()) {
+                sliceIds = getMilestoneSlices(mid).map(s => s.id);
+            }
+            else {
+                sliceIds = [];
+            }
+            if (sliceIds.length > 0) {
                 const missingSlices = [];
-                for (const slice of roadmap.slices) {
-                    const summaryPath = resolveSliceFile(basePath, mid, slice.id, "SUMMARY");
+                for (const sid of sliceIds) {
+                    const summaryPath = resolveSliceFile(basePath, mid, sid, "SUMMARY");
                     if (!summaryPath || !existsSync(summaryPath)) {
-                        missingSlices.push(slice.id);
+                        missingSlices.push(sid);
                     }
                 }
                 if (missingSlices.length > 0) {

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

@@ -22,16 +22,121 @@ 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 } 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 } 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";
+/**
+ * Detect summary files written directly to disk without the LLM calling
+ * the completion tool. A "rogue" file is one that exists on disk but has
+ * no corresponding DB row with status "complete".
+ *
+ * This is a safety-net diagnostic (D003). The existing migrateFromMarkdown()
+ * in postUnitPostVerification() eventually ingests rogue files, but explicit
+ * detection provides immediate diagnostics so operators know the prompt failed.
+ */
+export function detectRogueFileWrites(unitType, unitId, basePath) {
+    if (!isDbAvailable())
+        return [];
+    const parts = unitId.split("/");
+    const rogues = [];
+    if (unitType === "execute-task") {
+        const [mid, sid, tid] = parts;
+        if (!mid || !sid || !tid)
+            return [];
+        const summaryPath = resolveTaskFile(basePath, mid, sid, tid, "SUMMARY");
+        if (!summaryPath || !existsSync(summaryPath))
+            return [];
+        const dbRow = getTask(mid, sid, tid);
+        if (!dbRow || dbRow.status !== "complete") {
+            rogues.push({ path: summaryPath, unitType, unitId });
+        }
+    }
+    else if (unitType === "complete-slice") {
+        const [mid, sid] = parts;
+        if (!mid || !sid)
+            return [];
+        const summaryPath = resolveSliceFile(basePath, mid, sid, "SUMMARY");
+        if (!summaryPath || !existsSync(summaryPath))
+            return [];
+        const dbRow = getSlice(mid, sid);
+        if (!dbRow || dbRow.status !== "complete") {
+            rogues.push({ path: summaryPath, unitType, unitId });
+        }
+    }
+    else if (unitType === "plan-milestone") {
+        const [mid] = parts;
+        if (!mid)
+            return [];
+        const roadmapPath = resolveMilestoneFile(basePath, mid, "ROADMAP");
+        if (!roadmapPath || !existsSync(roadmapPath))
+            return [];
+        const dbRow = getMilestone(mid);
+        const hasPlanningState = !!dbRow && (String(dbRow.title || "").trim().length > 0 ||
+            String(dbRow.vision || "").trim().length > 0 ||
+            String(dbRow.requirement_coverage || "").trim().length > 0 ||
+            String(dbRow.boundary_map_markdown || "").trim().length > 0);
+        if (!hasPlanningState) {
+            rogues.push({ path: roadmapPath, unitType, unitId });
+        }
+    }
+    else if (unitType === "plan-slice" || unitType === "replan-slice") {
+        const [mid, sid] = parts;
+        if (!mid || !sid)
+            return [];
+        const planPath = resolveSliceFile(basePath, mid, sid, "PLAN");
+        if (!planPath || !existsSync(planPath))
+            return [];
+        const dbRow = getSlice(mid, sid);
+        const hasPlanningState = !!dbRow && (String(dbRow.title || "").trim().length > 0 ||
+            String(dbRow.demo || "").trim().length > 0 ||
+            String(dbRow.risk || "").trim().length > 0 ||
+            String(dbRow.depends || "").trim().length > 0);
+        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;
+}
 /** Throttle STATE.md rebuilds — at most once per 30 seconds */
 const STATE_REBUILD_MIN_INTERVAL_MS = 30_000;
 /**
@@ -283,6 +388,17 @@ export async function postUnitPreVerification(pctx, opts) {
                 process.stderr.write(`gsd-triage: resolution execution failed: ${err.message}\n`);
             }
         }
+        // Rogue file detection — safety net for LLM bypassing completion tools (D003)
+        try {
+            const rogueFiles = detectRogueFileWrites(s.currentUnit.type, s.currentUnit.id, s.basePath);
+            for (const rogue of rogueFiles) {
+                process.stderr.write(`gsd-rogue: detected rogue file write: ${rogue.path} (unit: ${rogue.unitId})\n`);
+                ctx.ui.notify(`Rogue file write detected: ${rogue.path}`, "warning");
+            }
+        }
+        catch (e) {
+            debugLog("postUnit", { phase: "rogue-detection", error: String(e) });
+        }
         // Artifact verification
         let triggerArtifactVerified = false;
         if (!s.currentUnit.type.startsWith("hook/")) {
@@ -346,16 +462,6 @@ export async function postUnitPreVerification(pctx, opts) {
  */
 export async function postUnitPostVerification(pctx) {
     const { s, ctx, pi, buildSnapshotOpts, lockBase, stopAuto, pauseAuto, updateProgressWidget } = pctx;
-    // ── DB dual-write ──
-    if (isDbAvailable()) {
-        try {
-            const { migrateFromMarkdown } = await import("./md-importer.js");
-            migrateFromMarkdown(s.basePath);
-        }
-        catch (err) {
-            process.stderr.write(`gsd-db: re-import failed: ${err.message}\n`);
-        }
-    }
     // ── Post-unit hooks ──
     if (s.currentUnit && !s.stepMode) {
         const hookUnit = checkPostUnitHooks(s.currentUnit.type, s.currentUnit.id, s.basePath);
@@ -389,9 +495,17 @@ export async function postUnitPostVerification(pctx) {
                 try {
                     const parts = trigger.unitId.split("/");
                     const [mid, sid, tid] = parts;
-                    // 1. Uncheck [x] → [ ] in PLAN.md
+                    // 1. Reset task status in DB and re-render plan checkboxes
                     if (mid && sid && tid) {
-                        uncheckTaskInPlan(s.basePath, mid, sid, tid);
+                        try {
+                            updateTaskStatus(mid, sid, tid, "pending");
+                            await renderPlanCheckboxes(s.basePath, mid, sid);
+                        }
+                        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
                     if (mid && sid && tid) {