gsd-pi 2.82.0-dev.3a3c6509d → 2.82.0-dev.4285182e8

package/README.md

@@ -350,7 +350,7 @@ This is what makes GSD different. Run it, walk away, come back to built software
 
 Auto mode is a state machine driven by the GSD database at the project root. It derives the next unit of work from authoritative SQLite state, creates a fresh agent session, injects a focused prompt with all relevant context pre-inlined, and lets the LLM execute. When the LLM finishes, auto mode persists the result to the database, refreshes markdown projections such as `STATE.md`, and dispatches the next unit.
 
-The database is authoritative for milestones, slices, tasks, requirements, summaries, and completion status. Durable decisions and project knowledge are stored in the `memories` table: decisions are `architecture` memories, and KNOWLEDGE patterns/lessons are `pattern`/`gotcha` memories. Markdown under `.gsd/` is a rendered projection for review, prompts, and git-friendly history; it is not a runtime fallback unless you explicitly run a recovery/import command. In worktree mode, project-root DB state remains authoritative and worktree markdown projections are not synced back as state.
+The database is authoritative for milestones, slices, tasks, requirements, summaries, and completion status. Durable decisions and project knowledge are stored in the `memories` table: decisions are `architecture` memories, and KNOWLEDGE patterns/lessons are `pattern`/`gotcha` memories. Markdown under `.gsd/` is a rendered projection for review, prompts, and git-friendly history; it is not a runtime fallback unless you explicitly run a recovery/import command. In worktree mode, artifact/projection writes are rendered under the active worktree-local `.gsd/`, while the project-root DB remains authoritative runtime state.
 
 `KNOWLEDGE.md` is hybrid: rules remain file-canonical, while patterns and lessons are stored in the `memories` table and rendered back into `KNOWLEDGE.md` on the next session-start projection. Existing pattern and lesson rows are backfilled into memories before projection, so newly captured patterns and lessons may appear in memory-backed prompt context before the file view refreshes.
 

package/dist/resources/.managed-resources-content-hash

@@ -1 +1 @@
-b9c1b29c0681f84f
+8102192ede112252

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

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Main auto-mode execution loop.
 /**
  * auto/loop.ts — Main auto-mode execution loop.
  *
@@ -789,11 +791,18 @@ export async function autoLoop(ctx, pi, s, deps, options) {
                 unitId: iterData.unitId,
             });
             const finalizeReason = finalizeResult.action === "break" ? finalizeResult.reason : undefined;
+            const finalizeStatus = finalizeReason === "step-wizard"
+                ? "completed"
+                : finalizeResult.action === "next"
+                    ? "completed"
+                    : finalizeResult.action === "continue"
+                        ? "retry"
+                        : "stopped";
             journalReporter.emit("post-unit-finalize-end", {
                 iteration,
                 unitType: iterData.unitType,
                 unitId: iterData.unitId,
-                status: finalizeResult.action === "next" ? "completed" : finalizeResult.action === "continue" ? "retry" : "stopped",
+                status: finalizeStatus,
                 action: finalizeResult.action,
                 ...(finalizeReason ? { reason: finalizeReason } : {}),
             });
@@ -837,6 +846,10 @@ export async function autoLoop(ctx, pi, s, deps, options) {
             }) || dispatchSettled;
             completeIteration();
             finishTurn("completed");
+            if (finalizeDecision.action === "complete-and-break") {
+                s.preserveStepSurfaceAfterLoopExit = true;
+                break;
+            }
         }
         catch (loopErr) {
             // ── Blanket catch: absorb unexpected exceptions, apply graduated recovery ──

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

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Mutable auto-mode session state container.
 /**
  * AutoSession — encapsulates all mutable auto-mode state into a single instance.
  *
@@ -26,6 +28,7 @@ export class AutoSession {
     active = false;
     paused = false;
     completionStopInProgress = false;
+    preserveStepSurfaceAfterLoopExit = false;
     stepMode = false;
     verbose = false;
     activeEngineId = null;
@@ -210,6 +213,7 @@ export class AutoSession {
         this.active = false;
         this.paused = false;
         this.completionStopInProgress = false;
+        this.preserveStepSurfaceAfterLoopExit = false;
         this.stepMode = false;
         this.verbose = false;
         this.activeEngineId = null;

package/dist/resources/extensions/gsd/auto/workflow-kernel.js

@@ -66,6 +66,9 @@ export function decideEngineDispatch(input) {
 export function decideFinalizeResult(input) {
     if (input.action === "break") {
         const reason = input.reason ?? "unknown";
+        if (reason === "step-wizard") {
+            return { action: "complete-and-break" };
+        }
         return {
             action: "stop",
             failureClass: reason === "git-closeout-failure" ? "git" : "closeout",

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

@@ -1108,7 +1108,7 @@ export const DISPATCH_RULES = [
                     if (verdict !== "pass") {
                         return {
                             action: "stop",
-                            reason: `Cannot complete milestone ${mid}: VALIDATION verdict is "${verdict}". Address the validation findings and re-run validation, or update the verdict manually.`,
+                            reason: `Cannot complete milestone ${mid}: VALIDATION verdict is "${verdict}". Address the validation findings and re-run validation, or run \`/gsd verdict pass --rationale "..."\` to override.`,
                             level: "warning",
                         };
                     }

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

@@ -28,7 +28,7 @@ import { regenerateIfMissing } from "./workflow-projections.js";
 import { WorktreeStateProjection } from "./worktree-state-projection.js";
 import { createWorkspace, scopeMilestone } from "./workspace.js";
 import { normalizeWorktreePathForCompare } from "./worktree-root.js";
-import { isDbAvailable, getTask, getSlice, getMilestone, updateTaskStatus, _getAdapter, getVerificationEvidence } from "./gsd-db.js";
+import { isDbAvailable, getDbPath, refreshOpenDatabaseFromDisk, getTask, getSlice, getMilestone, updateTaskStatus, _getAdapter, getVerificationEvidence } 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";
@@ -294,14 +294,14 @@ export function detectRogueFileWrites(unitType, unitId, basePath) {
  * looping indefinitely (#2007).
  */
 export const MAX_ARTIFACT_VERIFICATION_RETRIES = 3;
-export const STEP_COMPLETE_FALLBACK_MESSAGE = "Step complete. Run /clear, then /gsd to continue (or /gsd auto to run continuously).";
+export const STEP_COMPLETE_FALLBACK_MESSAGE = "Step complete. Run /clear if you want a clean view, then /gsd next to continue one step (or /gsd auto to run continuously).";
 export function buildStepCompleteMessage(nextState) {
     if (nextState.phase === "complete") {
         return "Step complete — milestone finished. Run /gsd status to review, or start the next milestone.";
     }
     const next = describeNextUnit(nextState);
     return `Step complete. Next: ${next.label}\n`
-        + `Run /clear, then /gsd to continue (or /gsd auto to run continuously).`;
+        + `Run /clear if you want a clean view, then /gsd next to continue one step (or /gsd auto to run continuously).`;
 }
 /**
  * Decide whether step mode should stop at the step wizard after a unit finishes.
@@ -553,6 +553,13 @@ export async function postUnitPreVerification(pctx, opts) {
     if (!opts?.skipSettleDelay) {
         await new Promise(r => setTimeout(r, 100));
     }
+    const dbPath = getDbPath();
+    if (isDbAvailable() && dbPath && dbPath !== ":memory:") {
+        const refreshed = refreshOpenDatabaseFromDisk();
+        if (!refreshed) {
+            logWarning("db", "post-unit database refresh failed; derived state may be stale");
+        }
+    }
     // Turn-level git action (commit | snapshot | status-only)
     if (s.currentUnit) {
         const unit = s.currentUnit;
@@ -1458,8 +1465,8 @@ export async function postUnitPostVerification(pctx) {
         }
     }
     // Step mode → show wizard instead of dispatch.
-    // Without this notify(), /gsd in step mode finishes a unit and silently
-    // exits the loop, leaving the user with no hint to /clear and /gsd again.
+    // Without this notify(), /gsd next finishes a unit and silently exits the
+    // loop, leaving the user with no next-step command.
     if (s.stepMode) {
         let phaseAfterUnit = null;
         try {

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

@@ -689,6 +689,8 @@ export async function rerootCommandSession(cmdCtx, workspaceRoot) {
     }
 }
 export async function cleanupAfterLoopExit(ctx) {
+    const preserveStepSurface = s.preserveStepSurfaceAfterLoopExit;
+    const preservePausedSurface = s.paused;
     s.currentUnit = null;
     s.active = false;
     deactivateGSD();
@@ -712,19 +714,24 @@ export async function cleanupAfterLoopExit(ctx) {
     // A transient provider-error pause intentionally leaves the paused badge
     // visible so the user still has a resumable auto-mode signal on screen.
     if (!s.paused) {
-        ctx.ui.setStatus("gsd-auto", undefined);
-        ctx.ui.setWidget("gsd-progress", undefined);
-        if (s.completionStopInProgress) {
-            s.completionStopInProgress = false;
+        if (preserveStepSurface) {
+            s.preserveStepSurfaceAfterLoopExit = false;
+        }
+        else {
+            ctx.ui.setStatus("gsd-auto", undefined);
+            ctx.ui.setWidget("gsd-progress", undefined);
+            if (s.completionStopInProgress) {
+                s.completionStopInProgress = false;
+            }
+            initHealthWidget(ctx);
         }
-        initHealthWidget(ctx);
     }
     // ADR-016 phase 3 (#5693): the stop-path basePath restore + chdir routes
     // through `Lifecycle.restoreToProjectRoot()`, the sole owner of both
     // `s.basePath` mutation and the paired `process.chdir` for auto-loop
     // transitions. The verb assigns `s.basePath` before any throwable work, so
     // a thrown error still leaves basePath restored.
-    if (s.originalBasePath) {
+    if (s.originalBasePath && !preserveStepSurface && !preservePausedSurface) {
         try {
             buildLifecycle().restoreToProjectRoot();
         }
@@ -732,7 +739,7 @@ export async function cleanupAfterLoopExit(ctx) {
             logWarning("engine", `restore project root failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
         }
     }
-    if (s.originalBasePath && s.cmdCtx) {
+    if (s.originalBasePath && s.cmdCtx && !preserveStepSurface && !preservePausedSurface) {
         const result = await rerootCommandSession(s.cmdCtx, s.originalBasePath);
         if (result.status === "cancelled") {
             logWarning("engine", "post-loop session re-root was cancelled", { file: "auto.ts", basePath: s.originalBasePath });

package/dist/resources/extensions/gsd/commands/catalog.js

@@ -3,7 +3,7 @@ import { join, resolve } from "node:path";
 import { loadRegistry } from "../workflow-templates.js";
 import { gsdHome } from "../gsd-home.js";
 import { VISUAL_BRIEF_MODES } from "../../visual-brief/prompts.js";
-export const GSD_COMMAND_DESCRIPTION = "GSD — Get Shit Done: /gsd help|start|templates|next|auto|stop|pause|status|widget|visualize|brief|queue|quick|discuss|capture|triage|dispatch|history|undo|undo-task|reset-slice|rate|skip|export|cleanup|model|mode|prefs|config|keys|hooks|run-hook|skill-health|doctor|debug|logs|forensics|changelog|migrate|remote|steer|knowledge|new-milestone|new-project|parallel|cmux|park|unpark|init|setup|onboarding|inspect|extensions|update|fast|mcp|rethink|workflow|codebase|notifications|ship|do|session-report|backlog|pr-branch|add-tests|scan|language|worktree|eval-review";
+export const GSD_COMMAND_DESCRIPTION = "GSD — Get Shit Done: /gsd help|start|templates|next|auto|stop|pause|status|widget|visualize|brief|queue|quick|discuss|capture|triage|dispatch|verdict|history|undo|undo-task|reset-slice|rate|skip|export|cleanup|model|mode|prefs|config|keys|hooks|run-hook|skill-health|doctor|debug|logs|forensics|changelog|migrate|remote|steer|knowledge|new-milestone|new-project|parallel|cmux|park|unpark|init|setup|onboarding|inspect|extensions|update|fast|mcp|rethink|workflow|codebase|notifications|ship|do|session-report|backlog|pr-branch|add-tests|scan|language|worktree|eval-review";
 export const TOP_LEVEL_SUBCOMMANDS = [
     { cmd: "help", desc: "Categorized command reference with descriptions" },
     { cmd: "next", desc: "Explicit step mode (same as /gsd)" },
@@ -21,6 +21,7 @@ export const TOP_LEVEL_SUBCOMMANDS = [
     { cmd: "changelog", desc: "Show categorized release notes" },
     { cmd: "triage", desc: "Manually trigger triage of pending captures" },
     { cmd: "dispatch", desc: "Dispatch a specific phase directly" },
+    { cmd: "verdict", desc: "Override the recorded milestone validation verdict (pass|needs-attention|needs-remediation)" },
     { cmd: "history", desc: "View execution history" },
     { cmd: "undo", desc: "Revert last completed unit" },
     { cmd: "undo-task", desc: "Reset a specific task's completion state (DB + markdown)" },
@@ -235,6 +236,11 @@ const NESTED_COMPLETIONS = {
         { cmd: "uat", desc: "Run user acceptance testing" },
         { cmd: "replan", desc: "Replan the current slice" },
     ],
+    verdict: [
+        { cmd: "pass", desc: "Override the milestone validation verdict to pass" },
+        { cmd: "needs-attention", desc: "Override the verdict to needs-attention (requires --rationale)" },
+        { cmd: "needs-remediation", desc: "Override the verdict to needs-remediation (requires --rationale)" },
+    ],
     rate: [
         { cmd: "over", desc: "Model was overqualified for this task" },
         { cmd: "ok", desc: "Model was appropriate for this task" },

package/dist/resources/extensions/gsd/commands/handlers/core.js

@@ -65,6 +65,7 @@ export function showHelp(ctx, args = "") {
         "  /gsd new-project    Bootstrap a new project (use --deep for staged project-level discovery)",
         "  /gsd quick          Execute a quick task without full planning overhead",
         "  /gsd dispatch       Dispatch a specific phase directly  [research|plan|execute|complete|uat|replan]",
+        "  /gsd verdict <v>    Override milestone validation verdict  [pass|needs-attention|needs-remediation] [--milestone Mxxx] [--rationale \"...\"]",
         "  /gsd parallel       Parallel milestone orchestration  [start|status|stop|pause|resume|merge|watch]",
         "  /gsd workflow       Custom workflow lifecycle  [new|run|list|validate|pause|resume]",
         "",

package/dist/resources/extensions/gsd/commands/handlers/ops.js

@@ -183,6 +183,11 @@ Examples:
         await dispatchDirectPhase(ctx, pi, phase, projectRoot());
         return true;
     }
+    if (trimmed === "verdict" || trimmed.startsWith("verdict ")) {
+        const { handleVerdict } = await import("../../commands-verdict.js");
+        await handleVerdict(trimmed.replace(/^verdict\s*/, "").trim(), ctx, projectRoot());
+        return true;
+    }
     if (trimmed === "notifications" || trimmed.startsWith("notifications ")) {
         const { handleNotificationsCommand } = await import("./notifications-handler.js");
         await handleNotificationsCommand(trimmed.replace(/^notifications\s*/, "").trim(), ctx, pi);

package/dist/resources/extensions/gsd/commands-verdict.js

@@ -0,0 +1,139 @@
+import { loadFile } from "./files.js";
+import { resolveMilestoneFile } from "./paths.js";
+import { deriveState } from "./state.js";
+import { executeValidateMilestone } from "./tools/workflow-tool-executors.js";
+import { VALIDATION_VERDICTS, extractVerdict, isValidMilestoneVerdict, } from "./verdict-parser.js";
+const USAGE = 'Usage: /gsd verdict <pass|needs-attention|needs-remediation> [--milestone Mxxx] [--rationale "..."]';
+function tokenize(raw) {
+    const tokens = [];
+    const re = /"([^"]*)"|(\S+)/g;
+    let match;
+    while ((match = re.exec(raw)) !== null) {
+        tokens.push(match[1] ?? match[2]);
+    }
+    return tokens;
+}
+function parseArgs(raw) {
+    const tokens = tokenize(raw);
+    const out = {};
+    for (let i = 0; i < tokens.length; i++) {
+        const t = tokens[i];
+        if (t === "--milestone") {
+            const next = tokens[++i];
+            if (!next)
+                return { error: "--milestone requires a milestone ID" };
+            out.milestoneId = next;
+        }
+        else if (t === "--rationale") {
+            const next = tokens[++i];
+            if (next == null)
+                return { error: "--rationale requires a value" };
+            out.rationale = next;
+        }
+        else if (!out.verdict) {
+            if (!isValidMilestoneVerdict(t)) {
+                return {
+                    error: `Invalid verdict "${t}". Must be one of: ${VALIDATION_VERDICTS.join(", ")}`,
+                };
+            }
+            out.verdict = t;
+        }
+        else {
+            return { error: `Unexpected argument: ${t}` };
+        }
+    }
+    return out;
+}
+function extractRemediationRound(content) {
+    const fm = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!fm)
+        return 0;
+    const m = fm[1].match(/^remediation_round:\s*(\d+)/im);
+    return m ? Number.parseInt(m[1], 10) : 0;
+}
+function extractSection(content, heading) {
+    const escaped = heading.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    // Match section bodies bounded by the next "## " heading or end-of-string.
+    // Leading "\n" prefix lets a single pattern handle first-line headings too.
+    // No /m flag — we want `$` to mean end-of-string, not end-of-line.
+    const re = new RegExp(`\\n## ${escaped}\\s*\\n([\\s\\S]*?)(?=\\n## |$)`);
+    const m = ("\n" + content).match(re);
+    if (!m)
+        return undefined;
+    return m[1].replace(/\s+$/, "");
+}
+export function parseValidationFile(content) {
+    return {
+        verdict: extractVerdict(content),
+        remediationRound: extractRemediationRound(content),
+        successCriteriaChecklist: extractSection(content, "Success Criteria Checklist") ?? "",
+        sliceDeliveryAudit: extractSection(content, "Slice Delivery Audit") ?? "",
+        crossSliceIntegration: extractSection(content, "Cross-Slice Integration") ?? "",
+        requirementCoverage: extractSection(content, "Requirement Coverage") ?? "",
+        verificationClasses: extractSection(content, "Verification Class Compliance"),
+        verdictRationale: extractSection(content, "Verdict Rationale") ?? "",
+        remediationPlan: extractSection(content, "Remediation Plan"),
+    };
+}
+export async function handleVerdict(rawArgs, ctx, basePath) {
+    if (!rawArgs.trim()) {
+        ctx.ui.notify(USAGE, "warning");
+        return;
+    }
+    const parsed = parseArgs(rawArgs);
+    if ("error" in parsed) {
+        ctx.ui.notify(`${parsed.error}\n${USAGE}`, "warning");
+        return;
+    }
+    if (!parsed.verdict) {
+        ctx.ui.notify(USAGE, "warning");
+        return;
+    }
+    let milestoneId = parsed.milestoneId;
+    if (!milestoneId) {
+        const state = await deriveState(basePath);
+        if (!state.activeMilestone) {
+            ctx.ui.notify("No active milestone — pass --milestone Mxxx to target a specific milestone.", "warning");
+            return;
+        }
+        milestoneId = state.activeMilestone.id;
+    }
+    const validationPath = resolveMilestoneFile(basePath, milestoneId, "VALIDATION");
+    if (!validationPath) {
+        ctx.ui.notify(`No VALIDATION file found for ${milestoneId}. Run gsd_validate_milestone first to produce one.`, "warning");
+        return;
+    }
+    const existing = await loadFile(validationPath);
+    if (!existing) {
+        ctx.ui.notify(`Could not read VALIDATION file for ${milestoneId} (${validationPath}).`, "warning");
+        return;
+    }
+    const current = parseValidationFile(existing);
+    if (parsed.verdict !== "pass" && !parsed.rationale) {
+        ctx.ui.notify(`--rationale is required when overriding to ${parsed.verdict}.`, "warning");
+        return;
+    }
+    const verdictRationale = parsed.rationale ?? "Manually overridden via /gsd verdict";
+    const result = await executeValidateMilestone({
+        milestoneId,
+        verdict: parsed.verdict,
+        remediationRound: current.remediationRound,
+        successCriteriaChecklist: current.successCriteriaChecklist,
+        sliceDeliveryAudit: current.sliceDeliveryAudit,
+        crossSliceIntegration: current.crossSliceIntegration,
+        requirementCoverage: current.requirementCoverage,
+        verificationClasses: current.verificationClasses,
+        verdictRationale,
+        remediationPlan: current.remediationPlan,
+    }, basePath);
+    if (result.isError) {
+        const msg = result.content[0]?.type === "text" ? result.content[0].text : "Unknown error";
+        ctx.ui.notify(msg, "error");
+        return;
+    }
+    const prevVerdict = current.verdict ?? "unknown";
+    ctx.ui.notify(`Milestone ${milestoneId} verdict: ${prevVerdict} -> ${parsed.verdict}`, "success");
+    if (parsed.verdict === "needs-remediation") {
+        ctx.ui.notify("Follow up with gsd_reassess_roadmap to add remediation slices, then re-run /gsd auto.", "info");
+    }
+}

package/dist/resources/extensions/gsd/markdown-renderer.js

@@ -14,7 +14,7 @@ import { isClosedStatus } from "./status-guards.js";
 import { join, relative } from "node:path";
 import { createRequire } from "node:module";
 import { getAllMilestones, getMilestone, getMilestoneSlices, getSliceTasks, getTask, getSlice, getArtifact, insertArtifact, getGateResults, } from "./gsd-db.js";
-import { resolveMilestoneFile, resolveSliceFile, resolveSlicePath, resolveTasksDir, gsdRoot, buildTaskFileName, buildSliceFileName, } from "./paths.js";
+import { resolveMilestoneFile, resolveSliceFile, resolveSlicePath, gsdProjectionRoot, gsdRoot, buildTaskFileName, buildSliceFileName, } from "./paths.js";
 import { saveFile, clearParseCache } from "./files.js";
 import { invalidateStateCache } from "./state.js";
 import { clearPathCache } from "./paths.js";
@@ -24,7 +24,11 @@ import { clearPathCache } from "./paths.js";
  * E.g. "/project/.gsd/milestones/M001/M001-ROADMAP.md" → "milestones/M001/M001-ROADMAP.md"
  */
 function toArtifactPath(absPath, basePath) {
-    const root = gsdRoot(basePath);
+    const projectionRoot = gsdProjectionRoot(basePath);
+    const projectionRel = relative(projectionRoot, absPath);
+    const root = projectionRel && !projectionRel.startsWith("..") && !projectionRel.startsWith("/")
+        ? projectionRoot
+        : gsdRoot(basePath);
     const rel = relative(root, absPath);
     // Normalize to forward slashes for consistent DB keys
     return rel.replace(/\\/g, "/");
@@ -305,10 +309,9 @@ export async function renderPlanFromDb(basePath, milestoneId, sliceId) {
     if (tasks.length === 0) {
         throw new Error(`no tasks found for ${milestoneId}/${sliceId}`);
     }
-    const slicePath = resolveSlicePath(basePath, milestoneId, sliceId)
-        ?? join(gsdRoot(basePath), "milestones", milestoneId, "slices", sliceId);
-    const absPath = resolveSliceFile(basePath, milestoneId, sliceId, "PLAN")
-        ?? join(slicePath, `${sliceId}-PLAN.md`);
+    const slicePath = join(gsdProjectionRoot(basePath), "milestones", milestoneId, "slices", sliceId);
+    mkdirSync(slicePath, { recursive: true });
+    const absPath = join(slicePath, `${sliceId}-PLAN.md`);
     const artifactPath = toArtifactPath(absPath, basePath);
     const sliceGates = getGateResults(milestoneId, sliceId, "slice");
     const content = renderSlicePlanMarkdown(slice, tasks, sliceGates);
@@ -329,8 +332,7 @@ export async function renderTaskPlanFromDb(basePath, milestoneId, sliceId, taskI
     if (!task) {
         throw new Error(`task ${milestoneId}/${sliceId}/${taskId} not found`);
     }
-    const tasksDir = resolveTasksDir(basePath, milestoneId, sliceId)
-        ?? join(gsdRoot(basePath), "milestones", milestoneId, "slices", sliceId, "tasks");
+    const tasksDir = join(gsdProjectionRoot(basePath), "milestones", milestoneId, "slices", sliceId, "tasks");
     mkdirSync(tasksDir, { recursive: true });
     const absPath = join(tasksDir, buildTaskFileName(taskId, "PLAN"));
     const artifactPath = toArtifactPath(absPath, basePath);

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

@@ -320,6 +320,10 @@ export function resolveGsdPathContract(workRoot, originalProjectRoot) {
         isWorktree,
     };
 }
+export function gsdProjectionRoot(basePath) {
+    const contract = resolveGsdPathContract(basePath);
+    return normalizeRealPath(contract.worktreeGsd ?? contract.projectGsd);
+}
 /**
  * Invalidate the gsdRoot cache.
  * Use ONLY at session-reset boundaries: workspace switch, process exit, or

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

@@ -460,7 +460,7 @@ async function handleAllSlicesDone(basePath, activeMilestone, registry, requirem
             recentDecisions: [],
             blockers: [
                 `Milestone ${activeMilestone.id} validation verdict is needs-remediation but all slices are complete. ` +
-                    `Add remediation slices via gsd_reassess_roadmap or override the verdict manually.`,
+                    `Add remediation slices via gsd_reassess_roadmap, or run \`/gsd verdict pass --rationale "..."\` to override.`,
             ],
             nextAction: `Resolve ${activeMilestone.id} remediation before proceeding.`,
             registry, requirements,
@@ -1132,7 +1132,7 @@ export async function _deriveStateImpl(basePath, opts) {
                 recentDecisions: [],
                 blockers: [
                     `Milestone ${activeMilestone.id} validation verdict is needs-remediation but all slices are complete. ` +
-                        `Add remediation slices via gsd_reassess_roadmap or override the verdict manually.`,
+                        `Add remediation slices via gsd_reassess_roadmap, or run \`/gsd verdict pass --rationale "..."\` to override.`,
                 ],
                 nextAction: `Resolve ${activeMilestone.id} remediation before proceeding.`,
                 registry,

package/dist/resources/extensions/gsd/templates/plan.md

@@ -132,6 +132,7 @@
   Verify field rules:
   - MUST be a mechanically executable command: `npm test`, `grep -q "pattern" file`, `test -f path`
   - MUST NOT use shell pipes, redirects, semicolons, backticks, command substitution, or output trimming
+  - MUST NOT use inline `node -e` assertions for verification; put assertions in a real test file and run it with `node --test` or a package test script
   - For content/document tasks: verify file existence, section count, YAML validity, or word count
     NOT exact phrasing, specific formulas, or "zero TBD" aspirational criteria
   - If no command can verify the output, write: "Manual review — file exists and is non-empty"

package/dist/resources/extensions/gsd/templates/task-plan.md

@@ -57,6 +57,12 @@ skills_used:
 - {{howToVerifyThisTaskIsActuallyDone}}
 - {{commandToRun_OR_behaviorToCheck}}
 
+## Verify Rules
+
+- Use a real executable check, not prose.
+- If the check needs file-content assertions, write a `node:test` file and run it with `node --test` or a package test script.
+- Do not use inline `node -e` assertions for verification.
+
 ## Observability Impact
 
 <!-- OMIT THIS SECTION ENTIRELY for simple tasks that don't touch runtime boundaries,

package/dist/resources/extensions/gsd/tools/plan-slice.js

@@ -12,7 +12,7 @@ import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
 import { validatePlanningPathScope } from "../planning-path-scope.js";
 import { checkFilePathConsistency, checkTaskOrdering } from "../pre-execution-checks.js";
-import { buildTaskFileName, gsdRoot, resolveTasksDir } from "../paths.js";
+import { buildTaskFileName, gsdProjectionRoot } from "../paths.js";
 function validateTasks(value) {
     if (!Array.isArray(value) || value.length === 0) {
         throw new Error("tasks must be a non-empty array");
@@ -241,14 +241,12 @@ export async function handlePlanSlice(rawParams, basePath) {
         return { error: guardError };
     }
     try {
-        const tasksDir = resolveTasksDir(basePath, params.milestoneId, params.sliceId);
+        const tasksDir = join(gsdProjectionRoot(basePath), "milestones", params.milestoneId, "slices", params.sliceId, "tasks");
         for (const taskId of omittedTaskIds) {
-            if (!tasksDir)
-                continue;
             const taskPlanPath = join(tasksDir, buildTaskFileName(taskId, "PLAN"));
             if (existsSync(taskPlanPath))
                 rmSync(taskPlanPath, { force: true });
-            const artifactPath = relative(gsdRoot(basePath), taskPlanPath).replace(/\\/g, "/");
+            const artifactPath = relative(gsdProjectionRoot(basePath), taskPlanPath).replace(/\\/g, "/");
             deleteArtifactByPath(artifactPath);
         }
         const renderResult = await renderPlanFromDb(basePath, params.milestoneId, params.sliceId);

package/dist/resources/extensions/ttsr/ttsr-manager.js

@@ -43,6 +43,7 @@ const MAX_BUFFER_BYTES = 512 * 1024;
  * Prevents CPU spinning when deltas arrive faster than regex evaluation (#468).
  */
 const JS_FALLBACK_CHECK_INTERVAL_MS = 50;
+const JS_FALLBACK_THROTTLE_MIN_BUFFER_BYTES = 4 * 1024;
 const DEFAULT_SCOPE = {
     allowText: true,
     allowThinking: false,
@@ -308,7 +309,8 @@ export class TtsrManager {
         // streams — regex on a growing buffer is O(rules × buffer_size) (#468).
         const now = Date.now();
         const lastCheck = this.#lastJsCheckAt.get(bufferKey) ?? 0;
-        if (now - lastCheck < JS_FALLBACK_CHECK_INTERVAL_MS) {
+        if (nextBuffer.length >= JS_FALLBACK_THROTTLE_MIN_BUFFER_BYTES &&
+            now - lastCheck < JS_FALLBACK_CHECK_INTERVAL_MS) {
             stopTimer({ bufferSize: nextBuffer.length, throttled: true });
             return [];
         }