gsd-pi 2.82.0-dev.3a3c6509d → 2.82.0-dev.57fd453e4

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
+8862dc8dc822437d

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-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/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/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 [];
         }