gsd-pi 2.81.0 → 2.82.0-dev.2841a1e44

package/dist/resources/extensions/gsd/bootstrap/agent-end-recovery.js

@@ -2,7 +2,7 @@
 import { logWarning } from "../workflow-logger.js";
 import { checkDeepProjectSetupAfterTurn, checkAutoStartAfterDiscuss, maybeHandleReadyPhraseWithoutFiles, maybeHandleEmptyIntentTurn, resetEmptyTurnCounter, } from "../guided-flow.js";
 import { clearPathCache } from "../paths.js";
-import { getAutoDashboardData, getAutoModeStartModel, isAutoActive, pauseAuto, setCurrentDispatchedModelId } from "../auto.js";
+import { getAutoDashboardData, getAutoModeStartModel, isAutoActive, isAutoCompletionStopInProgress, pauseAuto, setCurrentDispatchedModelId, } from "../auto.js";
 import { getNextFallbackModel, resolveModelWithFallbacksForUnit } from "../preferences.js";
 import { pauseAutoForProviderError } from "../provider-error-pause.js";
 import { isSessionSwitchAbortGraceActive, isSessionSwitchInFlight, resolveAgentEnd, resolveAgentEndCancelled, } from "../auto/resolve.js";
@@ -116,8 +116,7 @@ export function isBareClaudeCodeStreamAbortPlaceholder(lastMsg) {
  * Claude Code abort markers are intentionally ignored when the abort fires
  * while the session-switch is in flight: the abort is the expected side-effect
  * of the transition, not a user signal. Other branches (genuine `stopReason
- * === "aborted"` with diagnostic content/errorMessage) preserve the prior
- * behavior.
+ * === "aborted"` with explicit errorMessage) preserve the prior behavior.
  */
 export function _handleSessionSwitchAgentEnd(lastMsg, resolveCancelled) {
     if (!lastMsg || typeof lastMsg !== "object")
@@ -136,10 +135,8 @@ export function _handleSessionSwitchAgentEnd(lastMsg, resolveCancelled) {
         return;
     }
     if (m.stopReason === "aborted") {
-        const content = m.content;
-        const hasEmptyContent = Array.isArray(content) && content.length === 0;
         const hasErrorMessage = !!m.errorMessage;
-        if (!hasEmptyContent || hasErrorMessage) {
+        if (hasErrorMessage) {
             resolveCancelled(_buildAbortedPauseContext(m));
         }
     }
@@ -239,6 +236,11 @@ export async function handleAgentEnd(pi, event, ctx) {
         return;
     }
     if (isObjectRecord(lastMsg) && "stopReason" in lastMsg && lastMsg.stopReason === "aborted") {
+        if (isAutoCompletionStopInProgress()) {
+            resetRetryState(retryState);
+            resolveAgentEnd(event);
+            return;
+        }
         // Empty content with aborted stopReason is a non-fatal agent stop (the LLM
         // chose to end without producing output). Only pause on genuine fatal aborts
         // that carry error context — e.g. errorMessage field or non-empty content
@@ -274,6 +276,11 @@ export async function handleAgentEnd(pi, event, ctx) {
         // errorMessage looks uninformative.
         const rawErrorMsg = ("errorMessage" in lastMsg && lastMsg.errorMessage) ? String(lastMsg.errorMessage) : "";
         if (isUserInitiatedAbortMessage(rawErrorMsg)) {
+            if (isAutoCompletionStopInProgress()) {
+                resetRetryState(retryState);
+                resolveAgentEnd(event);
+                return;
+            }
             resolveAgentEndCancelled({
                 message: rawErrorMsg,
                 category: "aborted",

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

@@ -10,7 +10,7 @@ import { canonicalToolName, clearDiscussionFlowState, isDepthConfirmationAnswer,
 import { resolveManifest } from "../unit-context-manifest.js";
 import { isBlockedStateFile, isBashWriteToStateFile, BLOCKED_WRITE_ERROR } from "../write-intercept.js";
 import { loadFile, saveFile, formatContinue } from "../files.js";
-import { getAutoRuntimeSnapshot, isAutoActive, isAutoPaused, markToolEnd, markToolStart, recordToolInvocationError } from "../auto-runtime-state.js";
+import { clearToolInvocationError, getAutoRuntimeSnapshot, isAutoActive, isAutoPaused, markToolEnd, markToolStart, recordToolInvocationError } from "../auto-runtime-state.js";
 import { checkToolCallLoop, resetToolCallLoopGuard } from "./tool-call-loop-guard.js";
 import { saveActivityLog } from "../activity-log.js";
 import { recordToolCall as safetyRecordToolCall, recordToolResult as safetyRecordToolResult, saveEvidenceToDisk } from "../safety/evidence-collector.js";
@@ -123,7 +123,7 @@ const AUTO_UNIT_SCOPED_TOOLS = {
     "plan-slice": ["gsd_plan_slice", "gsd_plan_task", "gsd_decision_save"],
     "refine-slice": ["gsd_plan_slice", "gsd_plan_task", "gsd_decision_save"],
     "replan-slice": ["gsd_replan_slice", "gsd_plan_task", "gsd_decision_save"],
-    "complete-slice": ["gsd_slice_complete", "gsd_decision_save", "gsd_requirement_update", "subagent"],
+    "complete-slice": ["gsd_slice_complete", "gsd_task_reopen", "gsd_replan_slice", "gsd_decision_save", "gsd_requirement_update", "subagent"],
     "reassess-roadmap": ["gsd_reassess_roadmap"],
     "execute-task": ["gsd_task_complete", "gsd_decision_save"],
     "execute-task-simple": ["gsd_task_complete", "gsd_decision_save"],
@@ -355,6 +355,9 @@ async function writeContextModeCompactionSnapshot(basePath) {
     }
 }
 export function registerHooks(pi, ecosystemHandlers) {
+    // ADR-005 Phase 3b: surface pi-ai ProviderSwitchReport via audit, notification, and counter.
+    // Idempotent — only the first registerHooks call installs.
+    void import("../provider-switch-observer.js").then((m) => m.installProviderSwitchObserver());
     pi.on("session_start", async (_event, ctx) => {
         const basePath = contextBasePath(ctx);
         initSessionNotifications(ctx);
@@ -411,6 +414,8 @@ export function registerHooks(pi, ecosystemHandlers) {
         }
         await loadToolApiKeysForSession();
         if (!isAutoActive()) {
+            ctx.ui.setWidget("gsd-progress", undefined);
+            ctx.ui.setWidget("gsd-outcome", undefined);
             const { initHealthWidget } = await import("../health-widget.js");
             initHealthWidget(ctx);
         }
@@ -773,6 +778,9 @@ export function registerHooks(pi, ecosystemHandlers) {
             // errors and deterministic policy rejections are handled consistently.
             recordToolInvocationError(event.toolName, errorText);
         }
+        else if (isAutoActive()) {
+            clearToolInvocationError();
+        }
         const toolName = canonicalToolName(event.toolName);
         if (toolName !== "ask_user_questions")
             return;
@@ -891,6 +899,9 @@ export function registerHooks(pi, ecosystemHandlers) {
             // errors and deterministic policy rejections are handled consistently.
             recordToolInvocationError(event.toolName, errorText);
         }
+        else if (isAutoActive()) {
+            clearToolInvocationError();
+        }
         // Safety harness: record tool execution results for evidence cross-referencing
         if (isAutoActive()) {
             safetyRecordToolResult(event.toolCallId, event.toolName, event.result, event.isError);

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

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Registers GSD keyboard shortcuts for dashboard, notifications, and parallel overlays.
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { Key } from "@gsd/pi-tui";
@@ -29,16 +31,10 @@ export function registerShortcuts(pi) {
         });
     };
     const openNotificationsOverlay = async (ctx) => {
-        const { GSDNotificationOverlay } = await import("../notification-overlay.js");
+        const { GSDNotificationOverlay, notificationOverlayOptions } = await import("../notification-overlay.js");
         await ctx.ui.custom((tui, theme, _kb, done) => new GSDNotificationOverlay(tui, theme, () => done(true)), {
             overlay: true,
-            overlayOptions: {
-                width: "80%",
-                minWidth: 60,
-                maxHeight: "88%",
-                anchor: "center",
-                backdrop: true,
-            },
+            overlayOptions: notificationOverlayOptions(),
         });
     };
     const openParallelOverlay = async (ctx) => {

package/dist/resources/extensions/gsd/bootstrap/subagent-input.js

@@ -1,22 +1,31 @@
 export function extractSubagentAgentClasses(input) {
     if (!input || typeof input !== "object")
         return [];
-    const record = input;
     const agentClasses = [];
+    const visited = new WeakSet();
     const addAgentClass = (value) => {
         if (typeof value === "string" && value.trim().length > 0)
             agentClasses.push(value.trim());
     };
-    const addFromItems = (value) => {
+    const visitItems = (value) => {
         if (!Array.isArray(value))
             return;
         for (const item of value) {
-            if (item && typeof item === "object")
-                addAgentClass(item.agent);
+            visit(item);
         }
     };
-    addAgentClass(record.agent);
-    addFromItems(record.tasks);
-    addFromItems(record.chain);
+    const visit = (value) => {
+        if (!value || typeof value !== "object")
+            return;
+        if (visited.has(value))
+            return;
+        visited.add(value);
+        const record = value;
+        addAgentClass(record.agent);
+        visitItems(record.tasks);
+        visitItems(record.chain);
+        visitItems(record.parallel);
+    };
+    visit(input);
     return agentClasses;
 }

package/dist/resources/extensions/gsd/bootstrap/system-context.js

@@ -10,6 +10,7 @@ import { resolveAllSkillReferences, renderPreferencesForSystemPrompt, loadEffect
 import { resolveModelWithFallbacksForUnit } from "../preferences-models.js";
 import { resolveSkillReference } from "../preferences-skills.js";
 import { resolveGsdRootFile, resolveSliceFile, resolveSlicePath, resolveTaskFile, resolveTaskFiles, resolveTasksDir, relSliceFile, relSlicePath, relTaskFile } from "../paths.js";
+import { extractIntroAndRules } from "../knowledge-parser.js";
 import { ensureCodebaseMapFresh, readCodebaseMap } from "../codebase-generator.js";
 import { hasSkillSnapshot, detectNewSkills, formatSkillsXml } from "../skill-discovery.js";
 import { getActiveAutoWorktreeContext } from "../auto-worktree.js";
@@ -116,19 +117,19 @@ export async function buildBeforeAgentStartResult(event, ctx) {
     catch (e) {
         logWarning("bootstrap", `cmux prompt setup skipped: ${e.message}`);
     }
+    const ctxProjectRoot = ctx.projectRoot;
+    const basePath = typeof ctxProjectRoot === "string" && ctxProjectRoot.length > 0
+        ? ctxProjectRoot
+        : process.cwd();
     let preferenceBlock = "";
     if (loadedPreferences) {
-        const cwd = process.cwd();
+        const cwd = basePath;
         const report = resolveAllSkillReferences(loadedPreferences.preferences, cwd);
         preferenceBlock = `\n\n${renderPreferencesForSystemPrompt(loadedPreferences.preferences, report.resolutions)}`;
         if (report.warnings.length > 0) {
             ctx.ui.notify(`GSD skill preferences: ${report.warnings.length} unresolved skill${report.warnings.length === 1 ? "" : "s"}: ${report.warnings.join(", ")}`, "warning");
         }
     }
-    const { block: knowledgeBlock, globalSizeKb } = loadKnowledgeBlock(gsdHome(), process.cwd());
-    if (globalSizeKb > 4) {
-        ctx.ui.notify(`GSD: ~/.gsd/agent/KNOWLEDGE.md is ${globalSizeKb.toFixed(1)}KB — consider trimming to keep system prompt lean.`, "warning");
-    }
     // ADR-013 step 5: opportunistic decisions->memories backfill. Idempotent
     // and best-effort — first run absorbs the existing decisions table into
     // the memory store; subsequent runs are a single sentinel SELECT.
@@ -136,12 +137,47 @@ export async function buildBeforeAgentStartResult(event, ctx) {
         const { backfillDecisionsToMemories } = await import("../memory-backfill.js");
         const written = backfillDecisionsToMemories();
         if (written > 0) {
-            ctx.ui.notify(`GSD: backfilled ${written} decision${written === 1 ? "" : "s"} into the memory store (ADR-013).`, "info");
+            ctx.ui.notify(`GSD: backfilled ${written} decision${written === 1 ? "" : "s"} into the memory store.`, "info");
         }
     }
     catch (e) {
         logWarning("bootstrap", `decisions backfill failed: ${e.message}`);
     }
+    // ADR-013 Stage 2b: KNOWLEDGE.md Patterns + Lessons backfill, then
+    // re-render the hybrid projection (manual Rules + projected Patterns +
+    // projected Lessons). Both are idempotent and best-effort — failures here
+    // can't block agent startup.
+    try {
+        const { backfillKnowledgeToMemories } = await import("../knowledge-backfill.js");
+        const writtenK = backfillKnowledgeToMemories(basePath);
+        if (writtenK > 0) {
+            ctx.ui.notify(`GSD: backfilled ${writtenK} KNOWLEDGE.md row${writtenK === 1 ? "" : "s"} into the memory store.`, "info");
+        }
+    }
+    catch (e) {
+        logWarning("bootstrap", `KNOWLEDGE.md backfill failed: ${e.message}`);
+    }
+    try {
+        const { renderKnowledgeProjection } = await import("../knowledge-projection.js");
+        renderKnowledgeProjection(basePath);
+    }
+    catch (e) {
+        logWarning("bootstrap", `KNOWLEDGE.md projection render failed: ${e.message}`);
+    }
+    // ADR-013 step 6 preflight: warn when decisions / KNOWLEDGE.md rows are not
+    // yet in the memories table. Read-only; never throws. Runs after the two
+    // backfills above so the gap report reflects post-backfill state.
+    try {
+        const { reportConsolidationGaps } = await import("../memory-consolidation-scanner.js");
+        reportConsolidationGaps(basePath);
+    }
+    catch (e) {
+        logWarning("bootstrap", `memory consolidation scan failed: ${e.message}`);
+    }
+    const { block: knowledgeBlock, globalSizeKb } = loadKnowledgeBlock(gsdHome(), basePath);
+    if (globalSizeKb > 4) {
+        ctx.ui.notify(`GSD: ~/.gsd/agent/KNOWLEDGE.md is ${globalSizeKb.toFixed(1)}KB — consider trimming to keep system prompt lean.`, "warning");
+    }
     let newSkillsBlock = "";
     if (hasSkillSnapshot()) {
         const newSkills = detectNewSkills();
@@ -320,7 +356,9 @@ export async function loadMemoryBlock(userPrompt, opts = {}) {
     }
 }
 export function loadKnowledgeBlock(gsdHomeDir, cwd) {
-    // 1. Global knowledge (~/.gsd/agent/KNOWLEDGE.md) — cross-project, user-maintained
+    // 1. Global knowledge (~/.gsd/agent/KNOWLEDGE.md) — cross-project,
+    //    user-maintained. NOT migrated to memories (which are project-scoped),
+    //    so the full file is injected unchanged.
     let globalKnowledge = "";
     let globalSizeKb = 0;
     const globalKnowledgePath = join(gsdHomeDir, "agent", "KNOWLEDGE.md");
@@ -336,14 +374,19 @@ export function loadKnowledgeBlock(gsdHomeDir, cwd) {
             logWarning("bootstrap", `global knowledge file read failed: ${e.message}`);
         }
     }
-    // 2. Project knowledge (.gsd/KNOWLEDGE.md) — project-specific
+    // 2. Project knowledge (.gsd/KNOWLEDGE.md) — project-specific.
+    //    ADR-013 Stage 2b: Patterns and Lessons are projected from the
+    //    memories table and already reach the LLM via loadMemoryBlock. Inject
+    //    only the intro prose + `## Rules` section here to avoid duplicating
+    //    Patterns/Lessons content in the prompt. Rules stay manual per
+    //    ADR-013 line 39 and have no memory equivalent.
     let projectKnowledge = "";
     const knowledgePath = resolveGsdRootFile(cwd, "KNOWLEDGE");
     if (existsSync(knowledgePath)) {
         try {
-            const content = readFileSync(knowledgePath, "utf-8").trim();
-            if (content)
-                projectKnowledge = content;
+            const raw = readFileSync(knowledgePath, "utf-8").trim();
+            if (raw)
+                projectKnowledge = extractIntroAndRules(raw).trim();
         }
         catch (e) {
             logWarning("bootstrap", `project knowledge file read failed: ${e.message}`);
@@ -361,7 +404,7 @@ export function loadKnowledgeBlock(gsdHomeDir, cwd) {
     }
     const body = limitKnowledgeBlock(parts.join("\n\n"), getKnowledgeCharLimit());
     return {
-        block: `\n\n[KNOWLEDGE — Rules, patterns, and lessons learned]\n\n${body}`,
+        block: `\n\n[KNOWLEDGE — Rules from KNOWLEDGE.md (Patterns and Lessons reach the LLM via the memory block)]\n\n${body}`,
         globalSizeKb,
     };
 }

package/dist/resources/extensions/gsd/bootstrap/write-gate.js

@@ -3,6 +3,7 @@ import { copyFileSync, existsSync, lstatSync, mkdirSync, readFileSync, readlinkS
 import { isAbsolute, join, relative, resolve, sep } from "node:path";
 import { minimatch } from "minimatch";
 import { getIsolationMode } from "../preferences.js";
+import { compileSubagentPermissionContract } from "../unit-context-manifest.js";
 import { logWarning } from "../workflow-logger.js";
 import { isGsdWorktreePath, resolveWorktreeProjectRoot } from "../worktree-root.js";
 /**
@@ -681,7 +682,8 @@ export function shouldBlockPlanningUnit(toolName, pathOrCommand, basePath, unitT
     if (PLANNING_SUBAGENT_TOOLS.has(tool)) {
         if (policy.mode === "planning-dispatch") {
             const requested = (agentClasses ?? []).map(a => a.trim()).filter(Boolean);
-            const allowedSubagents = Array.isArray(policy.allowedSubagents) ? policy.allowedSubagents : [];
+            const dispatchContract = compileSubagentPermissionContract(policy);
+            const allowedSubagents = dispatchContract.allowedSubagents;
             const allowed = new Set(allowedSubagents);
             // When agentClasses is undefined, the caller has not been updated to extract
             // agent identities yet. Block and warn so stale callers surface in telemetry

package/dist/resources/extensions/gsd/clean-root-preflight.js

@@ -8,14 +8,153 @@
  *
  * Design constraints (from Trek-e approval):
  *  - Warn the user before stashing (no silent surprises)
- *  - git stash push / git stash pop only — no custom stash management layer
- *  - Stash/pop errors are logged but MUST NOT block the merge itself
+ *  - git stash push / git stash apply+drop for targeted restore
+ *  - Stash/apply errors are logged but MUST NOT block the merge itself
  *  - Fast-path status check — clean trees pay no extra cost
  */
 import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
 import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
 import { logWarning } from "./workflow-logger.js";
 import { nativeHasChanges } from "./native-git-bridge.js";
+function gitText(basePath, args) {
+    return execFileSync("git", args, {
+        cwd: basePath,
+        stdio: ["ignore", "pipe", "pipe"],
+        encoding: "utf-8",
+        env: GIT_NO_PROMPT_ENV,
+    });
+}
+function gitBuffer(basePath, args) {
+    return execFileSync("git", args, {
+        cwd: basePath,
+        stdio: ["ignore", "pipe", "pipe"],
+        env: GIT_NO_PROMPT_ENV,
+    });
+}
+function errorText(err) {
+    if (!err || typeof err !== "object")
+        return String(err);
+    const parts = [];
+    const stderr = err.stderr;
+    const stdout = err.stdout;
+    for (const value of [stderr, stdout]) {
+        if (typeof value === "string")
+            parts.push(value);
+        else if (value instanceof Uint8Array)
+            parts.push(Buffer.from(value).toString("utf-8"));
+    }
+    parts.push(err instanceof Error ? err.message : String(err));
+    return parts.filter(Boolean).join("\n");
+}
+function parseAlreadyExistsNoCheckoutPaths(text) {
+    const paths = [];
+    for (const line of text.split(/\r?\n/)) {
+        const match = /^(.+?) already exists, no checkout$/i.exec(line.trim());
+        if (match?.[1])
+            paths.push(match[1]);
+    }
+    return [...new Set(paths)];
+}
+function readZeroDelimitedPaths(output) {
+    return output.split("\0").filter(Boolean);
+}
+function listStashUntrackedPaths(basePath, stashRef) {
+    try {
+        const output = gitText(basePath, ["ls-tree", "-r", "-z", "--name-only", `${stashRef}^3`]);
+        return readZeroDelimitedPaths(output);
+    }
+    catch {
+        return null;
+    }
+}
+function listStashTrackedPaths(basePath, stashRef) {
+    try {
+        const output = gitText(basePath, ["diff", "--name-only", "-z", `${stashRef}^1`, stashRef]);
+        return readZeroDelimitedPaths(output);
+    }
+    catch {
+        return null;
+    }
+}
+function isWorktreeClean(basePath) {
+    try {
+        return gitText(basePath, ["status", "--porcelain"]).trim() === "";
+    }
+    catch {
+        return null;
+    }
+}
+function stashBlobEqualsWorktreeFile(basePath, stashRef, path) {
+    try {
+        const worktreePath = join(basePath, path);
+        if (!existsSync(worktreePath))
+            return false;
+        const worktreeContent = readFileSync(worktreePath);
+        const stashContent = gitBuffer(basePath, ["show", `${stashRef}^3:${path}`]);
+        return Buffer.compare(worktreeContent, stashContent) === 0;
+    }
+    catch {
+        return null;
+    }
+}
+function reconcileAlreadyPresentUntrackedStash(basePath, milestoneId, stashRef, err) {
+    const text = errorText(err);
+    const collidedPaths = parseAlreadyExistsNoCheckoutPaths(text);
+    if (collidedPaths.length === 0)
+        return null;
+    const untrackedPaths = listStashUntrackedPaths(basePath, stashRef);
+    if (!untrackedPaths || untrackedPaths.length === 0)
+        return null;
+    const trackedPaths = listStashTrackedPaths(basePath, stashRef);
+    if (trackedPaths === null || trackedPaths.length > 0)
+        return null;
+    const untrackedPathSet = new Set(untrackedPaths);
+    if (!collidedPaths.every((path) => untrackedPathSet.has(path)))
+        return null;
+    if (!untrackedPaths.every((path) => existsSync(join(basePath, path))))
+        return null;
+    if (isWorktreeClean(basePath) !== true)
+        return null;
+    const blobComparisons = untrackedPaths.map((path) => stashBlobEqualsWorktreeFile(basePath, stashRef, path));
+    if (blobComparisons.some((result) => result === null))
+        return null;
+    const allIdentical = blobComparisons.every(Boolean);
+    if (allIdentical) {
+        let dropped = true;
+        try {
+            execFileSync("git", ["stash", "drop", stashRef], {
+                cwd: basePath,
+                stdio: ["ignore", "pipe", "pipe"],
+                encoding: "utf-8",
+                env: GIT_NO_PROMPT_ENV,
+            });
+        }
+        catch (err) {
+            dropped = false;
+            logWarning("preflight", `git stash drop ${stashRef} failed after identical preflight stash reconciliation: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        return {
+            restored: true,
+            needsManualRecovery: false,
+            message: dropped
+                ? `Preflight stash for milestone ${milestoneId} contained files already present after merge; identical stash dropped.`
+                : `Preflight stash for milestone ${milestoneId} contained files already present after merge, but ${stashRef} could not be dropped and remains as a backup.`,
+            stashRef,
+            resolution: dropped ? "already-present-dropped" : "already-present-preserved",
+            collidedPaths,
+        };
+    }
+    return {
+        restored: false,
+        needsManualRecovery: false,
+        message: `Preflight stash for milestone ${milestoneId} contained untracked files already present after merge. Keeping merged files and preserving ${stashRef} as a backup.`,
+        stashRef,
+        resolution: "already-present-preserved",
+        collidedPaths,
+    };
+}
 function findPreflightStashRef(basePath, milestoneId, stashMarker) {
     const markerPrefix = `gsd-preflight-stash:${milestoneId}:`;
     let fallbackRef = null;
@@ -115,28 +254,50 @@ export function postflightPopStash(basePath, milestoneId, stashMarker, notify) {
                 message: msg,
             };
         }
-        execFileSync("git", ["stash", "pop", stashRef], {
+        execFileSync("git", ["stash", "apply", stashRef], {
             cwd: basePath,
             stdio: ["ignore", "pipe", "pipe"],
             encoding: "utf-8",
             env: GIT_NO_PROMPT_ENV,
         });
+        let dropWarning = null;
+        try {
+            execFileSync("git", ["stash", "drop", stashRef], {
+                cwd: basePath,
+                stdio: ["ignore", "pipe", "pipe"],
+                encoding: "utf-8",
+                env: GIT_NO_PROMPT_ENV,
+            });
+        }
+        catch (err) {
+            dropWarning = ` Stash was restored, but git stash drop ${stashRef} failed: ${err instanceof Error ? err.message : String(err)}.`;
+            logWarning("preflight", dropWarning.trim());
+        }
         const msg = `Restored stashed changes after milestone ${milestoneId} merge.`;
-        notify(msg, "info");
+        notify(`${msg}${dropWarning ?? ""}`, dropWarning ? "warning" : "info");
         return {
             restored: true,
             needsManualRecovery: false,
-            message: msg,
+            message: `${msg}${dropWarning ?? ""}`,
             stashRef,
+            resolution: "applied",
         };
     }
     catch (err) {
-        // Pop conflicts mean the merged code collides with the stashed changes.
+        if (stashRef) {
+            const reconciled = reconcileAlreadyPresentUntrackedStash(basePath, milestoneId, stashRef, err);
+            if (reconciled) {
+                logWarning("preflight", reconciled.message);
+                notify(reconciled.message, reconciled.resolution === "already-present-preserved" ? "warning" : "info");
+                return reconciled;
+            }
+        }
+        // Apply conflicts mean the merged code collides with the stashed changes.
         // Log a warning — the user needs to resolve manually, but the merge succeeded.
         const restoreHint = stashRef
-            ? `Run "git stash pop ${stashRef}" or "git stash apply ${stashRef}" manually to restore the correct stash.`
+            ? `Run "git stash apply ${stashRef}" manually to restore the correct stash, then "git stash drop ${stashRef}" after recovery.`
             : `Run "git stash list" to find the matching GSD preflight stash before restoring manually.`;
-        const msg = `git stash pop ${stashRef ?? ""}`.trim() + ` failed after merge of milestone ${milestoneId}: ${err instanceof Error ? err.message : String(err)}. ${restoreHint}`;
+        const msg = `git stash apply ${stashRef ?? ""}`.trim() + ` failed after merge of milestone ${milestoneId}: ${err instanceof Error ? err.message : String(err)}. ${restoreHint}`;
         logWarning("preflight", msg);
         notify(msg, "warning");
         return {
@@ -144,6 +305,7 @@ export function postflightPopStash(basePath, milestoneId, stashMarker, notify) {
             needsManualRecovery: true,
             message: msg,
             ...(stashRef ? { stashRef } : {}),
+            resolution: "manual-recovery",
         };
     }
 }

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

@@ -2,7 +2,8 @@ import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { loadRegistry } from "../workflow-templates.js";
 import { gsdHome } from "../gsd-home.js";
-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|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";
+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 TOP_LEVEL_SUBCOMMANDS = [
     { cmd: "help", desc: "Categorized command reference with descriptions" },
     { cmd: "next", desc: "Explicit step mode (same as /gsd)" },
@@ -12,6 +13,7 @@ export const TOP_LEVEL_SUBCOMMANDS = [
     { cmd: "status", desc: "Progress dashboard" },
     { cmd: "widget", desc: "Cycle widget: full → small → min → off" },
     { cmd: "visualize", desc: "Open 10-tab workflow visualizer (progress, timeline, deps, metrics, health, agent, changes, knowledge, captures, export)" },
+    { cmd: "brief", desc: "Generate a visual HTML brief: diagram, plan, diff review, recap, table, or slides" },
     { cmd: "queue", desc: "Queue and reorder future milestones" },
     { cmd: "quick", desc: "Execute a quick task without full planning overhead" },
     { cmd: "discuss", desc: "Discuss architecture and decisions" },
@@ -75,6 +77,7 @@ export const TOP_LEVEL_SUBCOMMANDS = [
     { cmd: "eval-review", desc: "Audit a slice's AI evaluation strategy and write a scored EVAL-REVIEW.md (--force, --show)" },
 ];
 const NESTED_COMPLETIONS = {
+    brief: VISUAL_BRIEF_MODES.map((mode) => ({ cmd: mode.mode, desc: mode.description })),
     auto: [
         { cmd: "--verbose", desc: "Show detailed execution output" },
         { cmd: "--debug", desc: "Enable debug logging" },

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

@@ -7,6 +7,8 @@ import { handleCmux } from "../../commands-cmux.js";
 import { setSessionModelOverride } from "../../session-model-override.js";
 import { projectRoot } from "../context.js";
 import { formattedShortcutPair } from "../../shortcut-defs.js";
+import { getVisualBriefOutputDir } from "../../../visual-brief/artifact-policy.js";
+import { buildVisualBriefPrompt, parseVisualBriefArgs, VISUAL_BRIEF_USAGE } from "../../../visual-brief/prompts.js";
 export function showHelp(ctx, args = "") {
     const summaryLines = [
         "GSD — Get Shit Done\n",
@@ -22,6 +24,7 @@ export function showHelp(ctx, args = "") {
         `  /gsd parallel watch Parallel monitor  (${formattedShortcutPair("parallel")})`,
         `  /gsd notifications  Notification history  (${formattedShortcutPair("notifications")})`,
         "  /gsd visualize      Interactive 10-tab TUI",
+        "  /gsd brief <mode>   Visual HTML brief (diagram, plan, diff, recap, table, slides)",
         "  /gsd queue          Show queued/dispatched units",
         "",
         "COURSE CORRECTION",
@@ -69,6 +72,7 @@ export function showHelp(ctx, args = "") {
         `  /gsd parallel watch Open parallel worker monitor  (${formattedShortcutPair("parallel")})`,
         "  /gsd widget         Cycle status widget  [full|small|min|off]",
         "  /gsd visualize      Interactive 10-tab TUI (progress, timeline, deps, metrics, health, agent, changes, knowledge, captures, export)",
+        "  /gsd brief <mode>   Generate a visual HTML brief  [diagram|plan|diff|recap|table|slides] [topic] [--slides]",
         "  /gsd queue          Show queued/dispatched units and execution order",
         "  /gsd history        View execution history  [--cost] [--phase] [--model] [N]",
         "  /gsd changelog      Show categorized release notes  [version]",
@@ -90,7 +94,7 @@ export function showHelp(ctx, args = "") {
         "  /gsd unpark [id]    Reactivate a parked milestone",
         "",
         "PROJECT KNOWLEDGE",
-        "  /gsd knowledge <type> <text>   Add rule, pattern, or lesson to KNOWLEDGE.md",
+        "  /gsd knowledge <type> <text>   Add a rule to KNOWLEDGE.md or capture a pattern/lesson to memories",
         "  /gsd codebase [generate|update|stats]   Manage the CODEBASE.md cache used in prompt context",
         "",
         "SHIPPING & BACKLOG",
@@ -182,6 +186,19 @@ export async function handleVisualize(ctx) {
         ctx.ui.notify("Visualizer requires an interactive terminal. Use /gsd status for a text-based overview.", "warning");
     }
 }
+export async function handleBrief(args, ctx, pi) {
+    const request = parseVisualBriefArgs(args);
+    if (!request) {
+        ctx.ui.notify(VISUAL_BRIEF_USAGE, "info");
+        return;
+    }
+    if (!pi?.sendUserMessage) {
+        ctx.ui.notify("Visual brief generation is unavailable in this context.", "warning");
+        return;
+    }
+    const outputDir = getVisualBriefOutputDir();
+    pi.sendUserMessage(buildVisualBriefPrompt(request, { outputDir }));
+}
 export async function handleSetup(args, ctx, pi) {
     const { detectProjectState, hasGlobalSetup } = await import("../../detection.js");
     const { isOnboardingComplete, readOnboardingRecord } = await import("../../onboarding-state.js");
@@ -370,6 +387,10 @@ export async function handleCoreCommand(trimmed, ctx, pi) {
         await handleVisualize(ctx);
         return true;
     }
+    if (trimmed === "brief" || trimmed.startsWith("brief ")) {
+        await handleBrief(trimmed.replace(/^brief\s*/, "").trim(), ctx, pi);
+        return true;
+    }
     if (trimmed === "widget" || trimmed.startsWith("widget ")) {
         const { cycleWidgetMode, setWidgetMode, getWidgetMode } = await import("../../auto-dashboard.js");
         const arg = trimmed.replace(/^widget\s*/, "").trim();