gsd-pi 2.74.0-dev.2b524c3 → 2.74.0-dev.658744a

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";
@@ -61,10 +61,12 @@ import { clearCmuxSidebar, logCmuxEvent, syncCmuxSidebar } from "../cmux/index.j
 // ── 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 { runAutoLoopWithUok } from "./uok/kernel.js";
+import { resolveUokFlags } from "./uok/flags.js";
 import { WorktreeResolver, } from "./worktree-resolver.js";
 import { reorderForCaching } from "./prompt-ordering.js";
 // ─── Session State ─────────────────────────────────────────────────────────
@@ -360,10 +362,22 @@ function clearUnitTimeout() {
 }
 /** Build snapshot metric opts. */
 function buildSnapshotOpts(_unitType, _unitId) {
+    const prefs = loadEffectiveGSDPreferences()?.preferences;
+    const uokFlags = resolveUokFlags(prefs);
     return {
         ...(s.autoStartTime > 0 ? { autoSessionKey: String(s.autoStartTime) } : {}),
         promptCharCount: s.lastPromptCharCount,
         baselineCharCount: s.lastBaselineCharCount,
+        traceId: s.currentTraceId ?? undefined,
+        turnId: s.currentTurnId ?? undefined,
+        ...(uokFlags.gitops
+            ? {
+                gitAction: uokFlags.gitopsTurnAction,
+                gitPush: uokFlags.gitopsTurnPush,
+                gitStatus: s.lastGitActionStatus ?? undefined,
+                gitError: s.lastGitActionFailure ?? undefined,
+            }
+            : {}),
         ...(s.currentUnitRouting ?? {}),
     };
 }
@@ -884,6 +898,7 @@ function buildLoopDeps() {
         getMainBranch,
         // Unit closeout + runtime records
         closeoutUnit,
+        autoCommitUnit,
         recordOutcome,
         writeLock,
         captureAvailableSkills,
@@ -1081,6 +1096,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())
@@ -1159,7 +1179,13 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         writeLock(lockBase(), "resuming", s.currentMilestoneId ?? "unknown");
         logCmuxEvent(loadEffectiveGSDPreferences()?.preferences, s.stepMode ? "Step-mode resumed." : "Auto-mode resumed.", "progress");
         captureProjectRootEnv(s.originalBasePath || s.basePath);
-        await autoLoop(ctx, pi, s, buildLoopDeps());
+        await runAutoLoopWithUok({
+            ctx,
+            pi,
+            s,
+            deps: buildLoopDeps(),
+            runLegacyLoop: autoLoop,
+        });
         cleanupAfterLoopExit(ctx);
         return;
     }
@@ -1183,7 +1209,13 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
     }
     logCmuxEvent(loadEffectiveGSDPreferences()?.preferences, requestedStepMode ? "Step-mode started." : "Auto-mode started.", "progress");
     // Dispatch the first unit
-    await autoLoop(ctx, pi, s, buildLoopDeps());
+    await runAutoLoopWithUok({
+        ctx,
+        pi,
+        s,
+        deps: buildLoopDeps(),
+        runLegacyLoop: autoLoop,
+    });
     cleanupAfterLoopExit(ctx);
 }
 // ─── Agent End Handler ────────────────────────────────────────────────────────

package/dist/resources/extensions/gsd/bootstrap/provider-error-resume.js

@@ -1,5 +1,6 @@
 import { getAutoDashboardData, startAuto } from "../auto.js";
 import { resetTransientRetryState } from "./agent-end-recovery.js";
+import { resetSessionTimeoutState } from "../auto/phases.js";
 const defaultDeps = {
     getSnapshot: () => getAutoDashboardData(),
     startAuto,
@@ -14,10 +15,11 @@ export async function resumeAutoAfterProviderDelay(pi, ctx, deps = defaultDeps)
         ctx.ui.notify("Provider error recovery delay elapsed, but no paused auto-mode base path was available. Leaving auto-mode paused.", "warning");
         return "missing-base";
     }
-    // Reset the transient retry counter before restarting — without this,
-    // consecutiveTransientCount accumulates across pause/resume cycles and
-    // permanently locks out auto-resume after MAX_TRANSIENT_AUTO_RESUMES errors.
+    // Reset retry counters before restarting — without this, counters
+    // accumulate across pause/resume cycles and permanently lock out
+    // auto-resume after their respective MAX thresholds.
     resetTransientRetryState();
+    resetSessionTimeoutState();
     await deps.startAuto(ctx, pi, snapshot.basePath, false, { step: snapshot.stepMode });
     return "resumed";
 }

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

@@ -1,7 +1,7 @@
 // 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 { loadEcosystemExtensions } from "../ecosystem/loader.js";
 import { registerDbTools } from "./db-tools.js";
 import { registerDynamicTools } from "./dynamic-tools.js";
 import { registerJournalTools } from "./journal-tools.js";
@@ -9,6 +9,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,20 +53,41 @@ 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();
+    // Ecosystem handlers captured by the GSDExtensionAPI wrapper for the
+    // GSD-owned `before_agent_start` dispatch step (#3338).
+    const ecosystemHandlers = [];
     pi.registerCommand("kill", {
         description: "Exit GSD immediately (no cleanup)",
         handler: async (_args, _ctx) => {
             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, ecosystemHandlers)],
+        ["ecosystem", () => {
+                void loadEcosystemExtensions(pi, ecosystemHandlers).catch((err) => {
+                    logWarning("ecosystem", `loader failed: ${err instanceof Error ? err.message : String(err)}`);
+                });
+            }],
+    ];
+    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/bootstrap/register-hooks.js

@@ -1,5 +1,7 @@
 import { join } from "node:path";
 import { isToolCallEventType } from "@gsd/pi-coding-agent";
+import { updateSnapshot } from "../ecosystem/gsd-extension-api.js";
+import { getEcosystemReadyPromise } from "../ecosystem/loader.js";
 import { buildMilestoneFileName, resolveMilestonePath, resolveSliceFile, resolveSlicePath } from "../paths.js";
 import { buildBeforeAgentStartResult } from "./system-context.js";
 import { handleAgentEnd } from "./agent-end-recovery.js";
@@ -29,7 +31,7 @@ async function syncServiceTierStatus(ctx) {
     const { getEffectiveServiceTier, formatServiceTierFooterStatus } = await import("../service-tier.js");
     ctx.ui.setStatus("gsd-fast", formatServiceTierFooterStatus(getEffectiveServiceTier(), ctx.model?.id));
 }
-export function registerHooks(pi) {
+export function registerHooks(pi, ecosystemHandlers) {
     pi.on("session_start", async (_event, ctx) => {
         initNotificationStore(process.cwd());
         installNotifyInterceptor(ctx);
@@ -39,8 +41,12 @@ export function registerHooks(pi) {
         resetToolCallLoopGuard();
         resetAskUserQuestionsCache();
         await syncServiceTierStatus(ctx);
-        const { prepareWorkflowMcpForProject } = await import("../workflow-mcp-auto-prep.js");
-        prepareWorkflowMcpForProject(ctx, process.cwd());
+        // Skip MCP auto-prep when running inside an auto-worktree (see session_switch below).
+        const { isInAutoWorktree } = await import("../auto-worktree.js");
+        if (!isInAutoWorktree(process.cwd())) {
+            const { prepareWorkflowMcpForProject } = await import("../workflow-mcp-auto-prep.js");
+            prepareWorkflowMcpForProject(ctx, process.cwd());
+        }
         // Apply show_token_cost preference (#1515)
         try {
             const { loadEffectiveGSDPreferences } = await import("../preferences.js");
@@ -80,12 +86,56 @@ export function registerHooks(pi) {
         resetAskUserQuestionsCache();
         clearDiscussionFlowState();
         await syncServiceTierStatus(ctx);
-        const { prepareWorkflowMcpForProject } = await import("../workflow-mcp-auto-prep.js");
-        prepareWorkflowMcpForProject(ctx, process.cwd());
+        // Skip MCP auto-prep when running inside an auto-worktree. The worktree
+        // already has .mcp.json from createAutoWorktree, and re-running the writer
+        // post-chdir rewrites the file mid-run (non-idempotent due to cwd-relative
+        // CLI path resolution), dirtying the tree and breaking the milestone merge.
+        const { isInAutoWorktree } = await import("../auto-worktree.js");
+        if (!isInAutoWorktree(process.cwd())) {
+            const { prepareWorkflowMcpForProject } = await import("../workflow-mcp-auto-prep.js");
+            prepareWorkflowMcpForProject(ctx, process.cwd());
+        }
         loadToolApiKeys();
     });
     pi.on("before_agent_start", async (event, ctx) => {
-        return buildBeforeAgentStartResult(event, ctx);
+        // Wait for ecosystem loader to finish (no-op after first turn).
+        await getEcosystemReadyPromise();
+        // GSD's own context injection (existing behavior — unchanged).
+        const gsdResult = await buildBeforeAgentStartResult(event, ctx);
+        // Refresh the snapshot used by ecosystem getPhase()/getActiveUnit().
+        // deriveState has its own ~100ms cache so this is cheap on repeat calls.
+        try {
+            const state = await deriveState(process.cwd());
+            updateSnapshot(state);
+        }
+        catch {
+            updateSnapshot(null);
+        }
+        // Chain ecosystem handlers using pi's runner.ts chaining protocol:
+        // each handler sees the systemPrompt mutated by prior handlers.
+        let currentSystemPrompt = gsdResult?.systemPrompt ?? event.systemPrompt;
+        // `any` because pi's BeforeAgentStartEventResult.message uses an internal
+        // CustomMessage type that's not re-exported (see ecosystem/gsd-extension-api.ts).
+        let lastMessage = gsdResult?.message;
+        for (const handler of ecosystemHandlers) {
+            try {
+                const r = await handler({ ...event, systemPrompt: currentSystemPrompt }, ctx);
+                if (r?.systemPrompt !== undefined)
+                    currentSystemPrompt = r.systemPrompt;
+                if (r?.message)
+                    lastMessage = r.message;
+            }
+            catch (err) {
+                safetyLogWarning("ecosystem", `before_agent_start handler failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        // Compose result. Return undefined if nothing changed (preserves runner contract).
+        if (currentSystemPrompt === event.systemPrompt && !lastMessage)
+            return undefined;
+        return {
+            systemPrompt: currentSystemPrompt !== event.systemPrompt ? currentSystemPrompt : undefined,
+            message: lastMessage,
+        };
     });
     pi.on("agent_end", async (event, ctx) => {
         resetToolCallLoopGuard();
@@ -116,8 +166,10 @@ export function registerHooks(pi) {
         const state = await deriveState(basePath);
         if (!state.activeMilestone || !state.activeSlice || !state.activeTask)
             return;
-        if (state.phase !== "executing")
-            return;
+        // Write checkpoint for ALL phases, not just "executing" — discuss, research,
+        // and planning also carry in-memory state (user answers, gate verification)
+        // that would be lost on compaction (#4258).
+        // if (state.phase !== "executing") return;
         const sliceDir = resolveSlicePath(basePath, state.activeMilestone.id, state.activeSlice.id);
         if (!sliceDir)
             return;
@@ -240,7 +292,7 @@ export function registerHooks(pi) {
     pi.on("tool_call", async (event, ctx) => {
         if (!isAutoActive())
             return;
-        safetyRecordToolCall(event.toolName, event.input);
+        safetyRecordToolCall(event.toolCallId, event.toolName, event.input);
         // Destructive command classification (warn only, never block)
         if (isToolCallEventType("bash", event)) {
             const classification = classifyCommand(event.input.command);

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

@@ -1,6 +1,6 @@
 // GSD Extension — Unified Cache Invalidation
 //
-// Three module-scoped caches exist across the GSD extension:
+// Three module-scoped read caches exist across the GSD extension:
 //   1. State cache (state.ts)  — memoized deriveState() result
 //   2. Path cache  (paths.ts)  — directory listing results (readdirSync)
 //   3. Parse cache (files.ts)  — parsed markdown file results
@@ -8,20 +8,31 @@
 // After any file write that changes .gsd/ contents, all three must be
 // invalidated together to prevent stale reads. This module provides a
 // single function that clears all three atomically.
+//
+// NOTE: The DB `artifacts` table is NOT included here. Earlier versions
+// called clearArtifacts() as part of this bundle (#793), intending to
+// force deriveState() to re-parse from disk when files were edited
+// out-of-band. But invalidateAllCaches() fires on every post-unit pass,
+// so bundling a DESTRUCTIVE `DELETE FROM artifacts` with routine cache
+// invalidation meant every row written by saveArtifactToDb / writeAndStore
+// was wiped within seconds — leaving the milestone completed on disk but
+// the `artifacts` table empty and the agent looping on "file exists but
+// DB record missing" recovery calls. If a call site genuinely needs the
+// artifact table cleared after an out-of-band file mutation, it should
+// invoke clearArtifacts() from gsd-db.js explicitly — do not add it back
+// here.
 import { invalidateStateCache } from './state.js';
 import { clearPathCache } from './paths.js';
 import { clearParseCache } from './files.js';
-import { clearArtifacts } from './gsd-db.js';
 /**
- * Invalidate all GSD runtime caches in one call.
+ * Invalidate all GSD runtime read caches in one call.
  *
  * Call this after file writes, milestone transitions, merge reconciliation,
  * or any operation that changes .gsd/ contents on disk. Forgetting to clear
- * any single cache causes stale reads (see #431, #793).
+ * any single cache causes stale reads (see #431).
  */
 export function invalidateAllCaches() {
     invalidateStateCache();
     clearPathCache();
     clearParseCache();
-    clearArtifacts();
 }

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|language";
 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,13 @@ 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" },
+    { cmd: "language", desc: "Set or clear the global response language (e.g. /gsd language Chinese)" },
 ];
 const NESTED_COMPLETIONS = {
     auto: [
@@ -231,6 +238,29 @@ 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" },
+    ],
+    language: [
+        { cmd: "off", desc: "Clear the language preference (revert to default)" },
+        { cmd: "clear", desc: "Alias for off — clear the language preference" },
+    ],
 };
 function filterOptions(partial, options, prefix = "") {
     const normalizedPrefix = prefix ? `${prefix} ` : "";

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

@@ -1,6 +1,6 @@
 import { computeProgressScore, formatProgressLine } from "../../progress-score.js";
 import { getGlobalGSDPreferencesPath, getProjectGSDPreferencesPath } from "../../preferences.js";
-import { ensurePreferencesFile, handlePrefs, handlePrefsMode, handlePrefsWizard } from "../../commands-prefs-wizard.js";
+import { ensurePreferencesFile, handlePrefs, handlePrefsMode, handlePrefsWizard, handleLanguage } from "../../commands-prefs-wizard.js";
 import { runEnvironmentChecks } from "../../doctor-environment.js";
 import { deriveState } from "../../state.js";
 import { handleCmux } from "../../commands-cmux.js";
@@ -339,6 +339,10 @@ export async function handleCoreCommand(trimmed, ctx, pi) {
         await handlePrefs(trimmed.replace(/^prefs\s*/, "").trim(), ctx);
         return true;
     }
+    if (trimmed === "language" || trimmed.startsWith("language ")) {
+        await handleLanguage(trimmed.replace(/^language\s*/, "").trim(), ctx);
+        return true;
+    }
     if (trimmed === "cmux" || trimmed.startsWith("cmux ")) {
         await handleCmux(trimmed.replace(/^cmux\s*/, "").trim(), ctx);
         return true;

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,27 @@ 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;
+    }
+    if (trimmed === "extract-learnings" || trimmed.startsWith("extract-learnings ")) {
+        const { handleExtractLearnings } = await import("../../commands-extract-learnings.js");
+        await handleExtractLearnings(trimmed.replace(/^extract-learnings\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");
+    }
+}