gsd-pi 2.73.1-dev.1040fb0 → 2.73.1-dev.49397e5

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

@@ -632,6 +632,9 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         }
         ctx.ui.setStatus("gsd-auto", s.stepMode ? "next" : "auto");
         ctx.ui.setFooter(hideFooter);
+        // Hide gsd-health during AUTO — gsd-progress is the single source of truth
+        // for last-commit / cost / health signal while auto is running.
+        ctx.ui.setWidget("gsd-health", undefined);
         const modeLabel = s.stepMode ? "Step-mode" : "Auto-mode";
         const pendingCount = (state.registry ?? []).filter((m) => m.status !== "complete" && m.status !== "parked").length;
         const scopeMsg = pendingCount > 1

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

@@ -156,6 +156,19 @@ export async function recoverTimedOutUnit(ctx, pi, unitType, unitId, reason, rct
         ctx.ui.notify(`${reason === "idle" ? "Idle" : "Timeout"} recovery: steering ${unitType} ${unitId} to produce ${expected} (attempt ${attemptNumber}, session ${recoveryAttempts + 1}/${maxRecoveryAttempts}).`, "warning");
         return "recovered";
     }
+    // #4175: For complete-milestone, never write a blocker placeholder — a stub
+    // SUMMARY has no recovery value (milestone is terminal), it does not update
+    // DB status, and downstream merge paths can treat the stub as a legitimate
+    // completion signal. Pause instead so the worktree branch is preserved.
+    if (unitType === "complete-milestone") {
+        writeUnitRuntimeRecord(basePath, unitType, unitId, currentUnitStartedAt, {
+            phase: "paused",
+            recoveryAttempts: recoveryAttempts + 1,
+            lastRecoveryReason: reason,
+        });
+        ctx.ui.notify(`Milestone ${unitId} ${reason}-recovery exhausted ${maxRecoveryAttempts} attempt(s) — worktree branch preserved. Re-run /gsd auto once blockers are resolved.`, "error");
+        return "paused";
+    }
     // Retries exhausted — write a blocker placeholder and advance the pipeline
     // instead of silently stalling.
     const placeholder = writeBlockerPlaceholder(unitType, unitId, basePath, `${reason} recovery exhausted ${maxRecoveryAttempts} attempts without producing the artifact.`);

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

@@ -10,10 +10,15 @@
  * checks the result and handles control flow.
  */
 import { mkdirSync, writeFileSync } from "node:fs";
-import { resolveSlicePath } from "./paths.js";
+import { resolveSlicePath, resolveMilestoneFile } from "./paths.js";
 import { parseUnitId } from "./unit-id.js";
-import { isDbAvailable, getTask, getSliceTasks } from "./gsd-db.js";
+import { isDbAvailable, getTask, getSliceTasks, getMilestoneSlices } from "./gsd-db.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
+import { extractVerdict } from "./verdict-parser.js";
+import { isClosedStatus } from "./status-guards.js";
+import { loadFile } from "./files.js";
+import { parseRoadmap } from "./parsers-legacy.js";
+import { isMilestoneComplete } from "./state.js";
 import { runVerificationGate, formatFailureContext, captureRuntimeErrors, runDependencyAudit, } from "./verification-gate.js";
 import { writeVerificationJSON } from "./verification-evidence.js";
 import { logWarning } from "./workflow-logger.js";
@@ -22,6 +27,80 @@ import { join } from "node:path";
 function isInfraVerificationFailure(stderr) {
     return /\b(ENOENT|ENOTFOUND|ETIMEDOUT|ECONNRESET|EAI_AGAIN|spawn\s+\S+\s+ENOENT|command not found)\b/i.test(stderr);
 }
+/**
+ * Post-unit guard for `validate-milestone` units (#4094).
+ *
+ * When validate-milestone writes verdict=needs-remediation, the agent is
+ * expected to also call gsd_reassess_roadmap in the same turn to add
+ * remediation slices. If they don't, the state machine re-derives
+ * `phase: validating-milestone` indefinitely (all slices still complete +
+ * verdict still needs-remediation), wasting ~3 dispatches before the stuck
+ * detector fires.
+ *
+ * This guard fires immediately on the first occurrence: if VALIDATION.md
+ * verdict is needs-remediation and no incomplete slices exist for the
+ * milestone, pause the auto-loop with a clear blocker.
+ */
+async function runValidateMilestonePostCheck(vctx, pauseAuto) {
+    const { s, ctx, pi } = vctx;
+    if (!s.currentUnit)
+        return "continue";
+    const { milestone: mid } = parseUnitId(s.currentUnit.id);
+    if (!mid)
+        return "continue";
+    const validationFile = resolveMilestoneFile(s.basePath, mid, "VALIDATION");
+    if (!validationFile)
+        return "continue";
+    const validationContent = await loadFile(validationFile);
+    if (!validationContent)
+        return "continue";
+    const verdict = extractVerdict(validationContent);
+    if (verdict !== "needs-remediation")
+        return "continue";
+    const incompleteSliceCount = await countIncompleteSlices(s.basePath, mid);
+    // If any non-closed slices exist, the agent successfully queued remediation
+    // work — proceed normally. The state machine will execute those slices and
+    // re-validate per the #3596/#3670 fix.
+    if (incompleteSliceCount > 0)
+        return "continue";
+    ctx.ui.notify(`Milestone ${mid} validation returned verdict=needs-remediation but no remediation slices were added. Pausing for human review.`, "error");
+    process.stderr.write(`validate-milestone: pausing — verdict=needs-remediation with no incomplete slices for ${mid}. ` +
+        `The agent must call gsd_reassess_roadmap to add remediation slices before re-validation.\n`);
+    await pauseAuto(ctx, pi);
+    return "pause";
+}
+/**
+ * Count slices for a milestone that are not in a closed status.
+ * DB-backed projects are authoritative (#4094 peer review); falls back to
+ * roadmap parsing only when the DB is unavailable.
+ */
+async function countIncompleteSlices(basePath, milestoneId) {
+    if (isDbAvailable()) {
+        const slices = getMilestoneSlices(milestoneId);
+        if (slices.length === 0) {
+            // No DB rows — treat as "unknown", do not pause.
+            return 1;
+        }
+        return slices.filter((slice) => !isClosedStatus(slice.status)).length;
+    }
+    // Filesystem fallback: parse the roadmap markdown.
+    try {
+        const roadmapFile = resolveMilestoneFile(basePath, milestoneId, "ROADMAP");
+        if (!roadmapFile)
+            return 1;
+        const roadmapContent = await loadFile(roadmapFile);
+        if (!roadmapContent)
+            return 1;
+        const roadmap = parseRoadmap(roadmapContent);
+        if (roadmap.slices.length === 0)
+            return 1;
+        return isMilestoneComplete(roadmap) ? 0 : 1;
+    }
+    catch {
+        // Parsing failures should not cause false-positive pauses.
+        return 1;
+    }
+}
 /**
  * Run the verification gate for the current execute-task unit.
  * Returns:
@@ -31,7 +110,13 @@ function isInfraVerificationFailure(stderr) {
  */
 export async function runPostUnitVerification(vctx, pauseAuto) {
     const { s, ctx, pi } = vctx;
-    if (!s.currentUnit || s.currentUnit.type !== "execute-task") {
+    if (!s.currentUnit) {
+        return "continue";
+    }
+    if (s.currentUnit.type === "validate-milestone") {
+        return await runValidateMilestonePostCheck(vctx, pauseAuto);
+    }
+    if (s.currentUnit.type !== "execute-task") {
         return "continue";
     }
     try {

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

@@ -36,7 +36,7 @@ import { captureAvailableSkills, resetSkillTelemetry, } from "./skill-telemetry.
 import { getRtkSessionSavings } from "../shared/rtk-session-stats.js";
 import { deactivateGSD } from "../shared/gsd-phase-state.js";
 import { initMetrics, resetMetrics, getLedger, getProjectTotals, formatCost, formatTokenCount, } from "./metrics.js";
-import { logWarning } from "./workflow-logger.js";
+import { setLogBasePath, logWarning } from "./workflow-logger.js";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { pathToFileURL } from "node:url";
@@ -55,14 +55,15 @@ import { initRegistry, convertDispatchRules } from "./rule-registry.js";
 import { emitJournalEvent as _emitJournalEvent } from "./journal.js";
 import { updateProgressWidget as _updateProgressWidget, updateSliceProgressCache, clearSliceProgressCache, hideFooter, } from "./auto-dashboard.js";
 import { registerSigtermHandler as _registerSigtermHandler, deregisterSigtermHandler as _deregisterSigtermHandler, } from "./auto-supervisor.js";
-import { isDbAvailable } from "./gsd-db.js";
+import { isDbAvailable, getMilestone } from "./gsd-db.js";
 import { countPendingCaptures } from "./captures.js";
 import { clearCmuxSidebar, logCmuxEvent, syncCmuxSidebar } from "../cmux/index.js";
 // ── Extracted modules ──────────────────────────────────────────────────────
 import { startUnitSupervision } from "./auto-timers.js";
 import { runPostUnitVerification } from "./auto-verification.js";
-import { postUnitPreVerification, postUnitPostVerification, } from "./auto-post-unit.js";
+import { autoCommitUnit, postUnitPreVerification, postUnitPostVerification, } from "./auto-post-unit.js";
 import { bootstrapAutoSession, openProjectDbIfPresent } from "./auto-start.js";
+import { initHealthWidget } from "./health-widget.js";
 import { autoLoop, resolveAgentEnd, resolveAgentEndCancelled, _resetPendingResolve, isSessionSwitchInFlight } from "./auto-loop.js";
 import { WorktreeResolver, } from "./worktree-resolver.js";
 import { reorderForCaching } from "./prompt-ordering.js";
@@ -397,6 +398,8 @@ function handleLostSessionLock(ctx, lockStatus) {
     ctx?.ui.setStatus("gsd-auto", undefined);
     ctx?.ui.setWidget("gsd-progress", undefined);
     ctx?.ui.setFooter(undefined);
+    if (ctx)
+        initHealthWidget(ctx);
 }
 /**
  * Lightweight cleanup after autoLoop exits via step-wizard break.
@@ -431,6 +434,7 @@ function cleanupAfterLoopExit(ctx) {
         ctx.ui.setStatus("gsd-auto", undefined);
         ctx.ui.setWidget("gsd-progress", undefined);
         ctx.ui.setFooter(undefined);
+        initHealthWidget(ctx);
     }
     // Restore CWD out of worktree back to original project root
     if (s.originalBasePath) {
@@ -501,17 +505,30 @@ export async function stopAuto(ctx, pi, reason) {
                     ? { notify: ctx.ui.notify.bind(ctx.ui) }
                     : { notify: () => { } };
                 const resolver = buildResolver();
-                // Check if the milestone is complete — SUMMARY file is the authoritative signal.
+                // Check if the milestone is complete. DB status is the authoritative
+                // signal — only a successful gsd_complete_milestone call flips it to
+                // "complete" (tools/complete-milestone.ts). SUMMARY file presence is
+                // NOT sufficient: a blocker placeholder stub or a partial write can
+                // leave a file behind without the milestone actually being done,
+                // which previously caused stopAuto to merge a failed milestone and
+                // emit a misleading metadata-only merge warning (#4175).
+                // DB-unavailable projects fall back to SUMMARY-file presence.
                 let milestoneComplete = false;
                 try {
-                    const summaryPath = resolveMilestoneFile(s.originalBasePath || s.basePath, s.currentMilestoneId, "SUMMARY");
-                    if (!summaryPath) {
-                        // Also check in the worktree path (SUMMARY may not be synced yet)
-                        const wtSummaryPath = resolveMilestoneFile(s.basePath, s.currentMilestoneId, "SUMMARY");
-                        milestoneComplete = wtSummaryPath !== null;
+                    if (isDbAvailable()) {
+                        const dbRow = getMilestone(s.currentMilestoneId);
+                        milestoneComplete = dbRow?.status === "complete";
                     }
                     else {
-                        milestoneComplete = true;
+                        const summaryPath = resolveMilestoneFile(s.originalBasePath || s.basePath, s.currentMilestoneId, "SUMMARY");
+                        if (!summaryPath) {
+                            // Also check in the worktree path (SUMMARY may not be synced yet)
+                            const wtSummaryPath = resolveMilestoneFile(s.basePath, s.currentMilestoneId, "SUMMARY");
+                            milestoneComplete = wtSummaryPath !== null;
+                        }
+                        else {
+                            milestoneComplete = true;
+                        }
                     }
                 }
                 catch (err) {
@@ -676,6 +693,8 @@ export async function stopAuto(ctx, pi, reason) {
         ctx?.ui.setStatus("gsd-auto", undefined);
         ctx?.ui.setWidget("gsd-progress", undefined);
         ctx?.ui.setFooter(undefined);
+        if (ctx)
+            initHealthWidget(ctx);
         restoreProjectRootEnv();
         restoreMilestoneLockEnv();
         // Reset all session state in one call
@@ -762,6 +781,8 @@ export async function pauseAuto(ctx, _pi, _errorContext) {
     ctx?.ui.setStatus("gsd-auto", "paused");
     ctx?.ui.setWidget("gsd-progress", undefined);
     ctx?.ui.setFooter(undefined);
+    if (ctx)
+        initHealthWidget(ctx);
     const resumeCmd = s.stepMode ? "/gsd next" : "/gsd auto";
     ctx?.ui.notify(`${s.stepMode ? "Step" : "Auto"}-mode paused (Escape). Type to interact, or ${resumeCmd} to resume.`, "info");
 }
@@ -863,6 +884,7 @@ function buildLoopDeps() {
         getMainBranch,
         // Unit closeout + runtime records
         closeoutUnit,
+        autoCommitUnit,
         recordOutcome,
         writeLock,
         captureAvailableSkills,
@@ -1060,6 +1082,11 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         s.stepMode = requestedStepMode;
         s.cmdCtx = ctx;
         s.basePath = base;
+        // Ensure the workflow-logger audit log is pinned to the project root
+        // even when auto-mode is entered via a path that bypasses the
+        // bootstrap/dynamic-tools ensureDbOpen() → setLogBasePath() chain
+        // (e.g. /clear resume, hot-reload).
+        setLogBasePath(base);
         s.unitDispatchCount.clear();
         s.unitLifetimeDispatches.clear();
         if (!getLedger())

package/dist/resources/extensions/gsd/bootstrap/register-extension.js

@@ -1,5 +1,4 @@
 // GSD2 — Extension registration: wires all GSD tools, commands, and hooks into pi
-import { registerGSDCommand } from "../commands.js";
 import { registerExitCommand } from "../exit-command.js";
 import { registerWorktreeCommand } from "../worktree-command.js";
 import { registerDbTools } from "./db-tools.js";
@@ -9,6 +8,7 @@ import { registerQueryTools } from "./query-tools.js";
 import { registerHooks } from "./register-hooks.js";
 import { registerShortcuts } from "./register-shortcuts.js";
 import { writeCrashLog } from "./crash-log.js";
+import { logWarning } from "../workflow-logger.js";
 export { writeCrashLog } from "./crash-log.js";
 export function handleRecoverableExtensionProcessError(err) {
     if (err.code === "EPIPE") {
@@ -52,7 +52,8 @@ function installEpipeGuard() {
     }
 }
 export function registerGsdExtension(pi) {
-    registerGSDCommand(pi);
+    // Note: registerGSDCommand is called by index.ts before this function,
+    // so we intentionally skip it here to avoid double-registration.
     registerWorktreeCommand(pi);
     registerExitCommand(pi);
     installEpipeGuard();
@@ -62,10 +63,22 @@ export function registerGsdExtension(pi) {
             process.exit(0);
         },
     });
-    registerDynamicTools(pi);
-    registerDbTools(pi);
-    registerJournalTools(pi);
-    registerQueryTools(pi);
-    registerShortcuts(pi);
-    registerHooks(pi);
+    // Wrap non-critical registrations individually so one failure
+    // doesn't prevent the others from loading.
+    const nonCriticalRegistrations = [
+        ["dynamic-tools", () => registerDynamicTools(pi)],
+        ["db-tools", () => registerDbTools(pi)],
+        ["journal-tools", () => registerJournalTools(pi)],
+        ["query-tools", () => registerQueryTools(pi)],
+        ["shortcuts", () => registerShortcuts(pi)],
+        ["hooks", () => registerHooks(pi)],
+    ];
+    for (const [name, register] of nonCriticalRegistrations) {
+        try {
+            register();
+        }
+        catch (err) {
+            logWarning("bootstrap", `Failed to register ${name}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
 }

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

@@ -4,7 +4,7 @@ import { join } from "node:path";
 import { loadRegistry } from "../workflow-templates.js";
 import { resolveProjectRoot } from "../worktree.js";
 const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
-export const GSD_COMMAND_DESCRIPTION = "GSD — Get Shit Done: /gsd help|start|templates|next|auto|stop|pause|status|widget|visualize|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|logs|forensics|changelog|migrate|remote|steer|knowledge|new-milestone|parallel|cmux|park|unpark|init|setup|inspect|extensions|update|fast|mcp|rethink|codebase|notifications";
+export const GSD_COMMAND_DESCRIPTION = "GSD — Get Shit Done: /gsd help|start|templates|next|auto|stop|pause|status|widget|visualize|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|logs|forensics|changelog|migrate|remote|steer|knowledge|new-milestone|parallel|cmux|park|unpark|init|setup|inspect|extensions|update|fast|mcp|rethink|codebase|notifications|ship|do|session-report|backlog|pr-branch|add-tests";
 export const TOP_LEVEL_SUBCOMMANDS = [
     { cmd: "help", desc: "Categorized command reference with descriptions" },
     { cmd: "next", desc: "Explicit step mode (same as /gsd)" },
@@ -62,6 +62,12 @@ export const TOP_LEVEL_SUBCOMMANDS = [
     { cmd: "rethink", desc: "Conversational project reorganization — reorder, park, discard, add milestones" },
     { cmd: "workflow", desc: "Custom workflow lifecycle (new, run, list, validate, pause, resume)" },
     { cmd: "codebase", desc: "Generate, refresh, and inspect the codebase map cache (.gsd/CODEBASE.md)" },
+    { cmd: "ship", desc: "Create PR from milestone artifacts and open for review" },
+    { cmd: "do", desc: "Route freeform text to the right GSD command" },
+    { cmd: "session-report", desc: "Session cost, tokens, and work summary" },
+    { cmd: "backlog", desc: "Manage backlog items (add, promote, remove, list)" },
+    { cmd: "pr-branch", desc: "Create clean PR branch filtering .gsd/ commits" },
+    { cmd: "add-tests", desc: "Generate tests for completed slices" },
 ];
 const NESTED_COMPLETIONS = {
     auto: [
@@ -231,6 +237,25 @@ const NESTED_COMPLETIONS = {
         { cmd: "stats", desc: "Show file count, description coverage, and generation time" },
         { cmd: "help", desc: "Show usage and available subcommands" },
     ],
+    ship: [
+        { cmd: "--dry-run", desc: "Preview PR without creating" },
+        { cmd: "--draft", desc: "Open as draft PR" },
+        { cmd: "--base", desc: "Override target branch (default: main)" },
+        { cmd: "--force", desc: "Ship even with pending tasks" },
+    ],
+    "session-report": [
+        { cmd: "--json", desc: "Machine-readable JSON output" },
+        { cmd: "--save", desc: "Save report to .gsd/reports/" },
+    ],
+    backlog: [
+        { cmd: "add", desc: "Add item to backlog" },
+        { cmd: "promote", desc: "Promote backlog item to active slice" },
+        { cmd: "remove", desc: "Remove backlog item" },
+    ],
+    "pr-branch": [
+        { cmd: "--dry-run", desc: "Preview what would be filtered" },
+        { cmd: "--name", desc: "Custom branch name" },
+    ],
 };
 function filterOptions(partial, options, prefix = "") {
     const normalizedPrefix = prefix ? `${prefix} ` : "";

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

@@ -8,6 +8,9 @@ import { handleExport } from "../../export.js";
 import { handleHistory } from "../../history.js";
 import { handleUndo } from "../../undo.js";
 import { handleRemote } from "../../../remote-questions/mod.js";
+import { handleShip } from "../../commands-ship.js";
+import { handleSessionReport } from "../../commands-session-report.js";
+import { handlePrBranch } from "../../commands-pr-branch.js";
 import { projectRoot } from "../context.js";
 export async function handleOpsCommand(trimmed, ctx, pi) {
     if (trimmed === "init") {
@@ -213,5 +216,22 @@ Examples:
         await handleCodebase(trimmed.replace(/^codebase\s*/, "").trim(), ctx, pi);
         return true;
     }
+    if (trimmed === "ship" || trimmed.startsWith("ship ")) {
+        await handleShip(trimmed.replace(/^ship\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    if (trimmed === "session-report" || trimmed.startsWith("session-report ")) {
+        await handleSessionReport(trimmed.replace(/^session-report\s*/, "").trim(), ctx);
+        return true;
+    }
+    if (trimmed === "pr-branch" || trimmed.startsWith("pr-branch ")) {
+        await handlePrBranch(trimmed.replace(/^pr-branch\s*/, "").trim(), ctx);
+        return true;
+    }
+    if (trimmed === "add-tests" || trimmed.startsWith("add-tests ")) {
+        const { handleAddTests } = await import("../../commands-add-tests.js");
+        await handleAddTests(trimmed.replace(/^add-tests\s*/, "").trim(), ctx, pi);
+        return true;
+    }
     return false;
 }

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

@@ -25,6 +25,61 @@ const WORKFLOW_USAGE = [
     "  pause             — Pause custom workflow auto-mode",
     "  resume            — Resume paused custom workflow auto-mode",
 ].join("\n");
+function splitWorkflowRunArgs(input) {
+    const tokens = [];
+    let current = "";
+    let quote = null;
+    let escapeNext = false;
+    for (const ch of input) {
+        if (escapeNext) {
+            current += ch;
+            escapeNext = false;
+            continue;
+        }
+        if (ch === "\\") {
+            escapeNext = true;
+            continue;
+        }
+        if (quote) {
+            if (ch === quote) {
+                quote = null;
+            }
+            else {
+                current += ch;
+            }
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            quote = ch;
+            continue;
+        }
+        if (/\s/.test(ch)) {
+            if (current) {
+                tokens.push(current);
+                current = "";
+            }
+            continue;
+        }
+        current += ch;
+    }
+    if (escapeNext)
+        current += "\\";
+    if (current)
+        tokens.push(current);
+    return tokens;
+}
+export function parseWorkflowRunArgs(args) {
+    const parts = splitWorkflowRunArgs(args);
+    const defName = parts[0] ?? "";
+    const overrides = {};
+    for (let i = 1; i < parts.length; i++) {
+        const eqIdx = parts[i].indexOf("=");
+        if (eqIdx > 0) {
+            overrides[parts[i].slice(0, eqIdx)] = parts[i].slice(eqIdx + 1);
+        }
+    }
+    return { defName, overrides };
+}
 async function handleCustomWorkflow(sub, ctx, pi) {
     // Bare `/gsd workflow` — show usage
     if (!sub) {
@@ -43,15 +98,7 @@ async function handleCustomWorkflow(sub, ctx, pi) {
             ctx.ui.notify("Usage: /gsd workflow run <name> [param=value ...]", "warning");
             return true;
         }
-        const parts = args.split(/\s+/);
-        const defName = parts[0];
-        const overrides = {};
-        for (let i = 1; i < parts.length; i++) {
-            const eqIdx = parts[i].indexOf("=");
-            if (eqIdx > 0) {
-                overrides[parts[i].slice(0, eqIdx)] = parts[i].slice(eqIdx + 1);
-            }
-        }
+        const { defName, overrides } = parseWorkflowRunArgs(args);
         try {
             const base = projectRoot();
             const runDir = createRun(base, defName, Object.keys(overrides).length > 0 ? overrides : undefined);
@@ -146,6 +193,18 @@ async function handleCustomWorkflow(sub, ctx, pi) {
     return true;
 }
 export async function handleWorkflowCommand(trimmed, ctx, pi) {
+    // ── /gsd do — natural language routing (must be early to route to other commands) ──
+    if (trimmed === "do" || trimmed.startsWith("do ")) {
+        const { handleDo } = await import("../../commands-do.js");
+        await handleDo(trimmed.replace(/^do\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    // ── Backlog management ──
+    if (trimmed === "backlog" || trimmed.startsWith("backlog ")) {
+        const { handleBacklog } = await import("../../commands-backlog.js");
+        await handleBacklog(trimmed.replace(/^backlog\s*/, "").trim(), ctx, pi);
+        return true;
+    }
     // ── Custom workflow commands (`/gsd workflow ...`) ──
     if (trimmed === "workflow" || trimmed.startsWith("workflow ")) {
         const sub = trimmed.slice("workflow".length).trim();

package/dist/resources/extensions/gsd/commands-add-tests.js

@@ -0,0 +1,111 @@
+/**
+ * GSD Command — /gsd add-tests
+ *
+ * Generates tests for a completed slice by dispatching an LLM prompt
+ * with implementation context (summaries, changed files, test patterns).
+ */
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { deriveState } from "./state.js";
+import { gsdRoot, resolveSliceFile } from "./paths.js";
+import { loadPrompt } from "./prompt-loader.js";
+function findLastCompletedSlice(basePath, milestoneId) {
+    // Scan disk for slices that have a SUMMARY.md (indicating completion)
+    const slicesDir = join(gsdRoot(basePath), "milestones", milestoneId, "slices");
+    if (!existsSync(slicesDir))
+        return null;
+    try {
+        const entries = readdirSync(slicesDir, { withFileTypes: true })
+            .filter((e) => e.isDirectory() && /^S\d+$/.test(e.name))
+            .sort((a, b) => b.name.localeCompare(a.name)); // reverse order — latest first
+        for (const entry of entries) {
+            const summaryPath = join(slicesDir, entry.name, `${entry.name}-SUMMARY.md`);
+            if (existsSync(summaryPath))
+                return entry.name;
+        }
+    }
+    catch {
+        // non-fatal
+    }
+    return null;
+}
+function readSliceSummary(basePath, milestoneId, sliceId) {
+    const summaryPath = resolveSliceFile(basePath, milestoneId, sliceId, "SUMMARY");
+    if (summaryPath && existsSync(summaryPath)) {
+        const content = readFileSync(summaryPath, "utf-8");
+        const titleMatch = content.match(/^#\s+(.+)/m);
+        return { title: titleMatch?.[1] ?? sliceId, content };
+    }
+    return { title: sliceId, content: "(no summary available)" };
+}
+function detectTestPatterns(basePath) {
+    const patterns = [];
+    // Check for common test configs
+    const checks = [
+        { file: "jest.config.ts", name: "Jest" },
+        { file: "jest.config.js", name: "Jest" },
+        { file: "vitest.config.ts", name: "Vitest" },
+        { file: "vitest.config.js", name: "Vitest" },
+        { file: ".mocharc.yml", name: "Mocha" },
+    ];
+    for (const check of checks) {
+        if (existsSync(join(basePath, check.file))) {
+            patterns.push(`Framework: ${check.name} (${check.file})`);
+        }
+    }
+    // Look for existing test files to infer patterns
+    const testDirs = ["tests", "test", "src/__tests__", "__tests__"];
+    for (const dir of testDirs) {
+        const fullDir = join(basePath, dir);
+        if (existsSync(fullDir)) {
+            try {
+                const files = readdirSync(fullDir).filter((f) => f.endsWith(".test.ts") || f.endsWith(".spec.ts") || f.endsWith(".test.js"));
+                if (files.length > 0) {
+                    patterns.push(`Test directory: ${dir}/ (${files.length} test files)`);
+                    // Read first test file for patterns
+                    const samplePath = join(fullDir, files[0]);
+                    const sample = readFileSync(samplePath, "utf-8").slice(0, 500);
+                    patterns.push(`Sample pattern from ${files[0]}:\n${sample}`);
+                    break;
+                }
+            }
+            catch {
+                // non-fatal
+            }
+        }
+    }
+    return patterns.length > 0 ? patterns.join("\n") : "No test framework detected. Use Node.js built-in test runner.";
+}
+export async function handleAddTests(args, ctx, pi) {
+    const basePath = process.cwd();
+    const state = await deriveState(basePath);
+    if (!state.activeMilestone) {
+        ctx.ui.notify("No active milestone.", "warning");
+        return;
+    }
+    const milestoneId = state.activeMilestone.id;
+    // Determine target
+    const targetId = args.trim() || findLastCompletedSlice(basePath, milestoneId);
+    if (!targetId) {
+        ctx.ui.notify("No completed slices found. Specify a slice ID: /gsd add-tests S03", "warning");
+        return;
+    }
+    // Gather context
+    const summary = readSliceSummary(basePath, milestoneId, targetId);
+    const testPatterns = detectTestPatterns(basePath);
+    ctx.ui.notify(`Generating tests for ${targetId}: "${summary.title}"...`, "info");
+    try {
+        const prompt = loadPrompt("add-tests", {
+            sliceId: targetId,
+            sliceTitle: summary.title,
+            sliceSummary: summary.content,
+            existingTestPatterns: testPatterns,
+            workingDirectory: basePath,
+        });
+        pi.sendMessage({ customType: "gsd-add-tests", content: prompt, display: false }, { triggerTurn: true });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        ctx.ui.notify(`Failed to dispatch test generation: ${msg}`, "error");
+    }
+}