gsd-pi 2.59.0 → 2.60.0-dev.2580e65

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

@@ -34,7 +34,7 @@ import { clearSkillSnapshot } from "./skill-discovery.js";
 import { captureAvailableSkills, resetSkillTelemetry, } from "./skill-telemetry.js";
 import { getRtkSessionSavings } from "../shared/rtk-session-stats.js";
 import { initMetrics, resetMetrics, getLedger, getProjectTotals, formatCost, formatTokenCount, } from "./metrics.js";
-import { setLogBasePath } from "./workflow-logger.js";
+import { setLogBasePath, logWarning } from "./workflow-logger.js";
 import { join } from "node:path";
 import { readFileSync, existsSync, mkdirSync, writeFileSync, unlinkSync } from "node:fs";
 import { atomicWriteSync } from "./atomic-write.js";
@@ -137,8 +137,9 @@ export function getAutoDashboardData() {
             pendingCaptureCount = countPendingCaptures(s.basePath);
         }
     }
-    catch {
+    catch (err) {
         // Non-fatal — captures module may not be loaded
+        logWarning("engine", `capture count failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
     }
     return {
         active: s.active,
@@ -340,8 +341,9 @@ function cleanupAfterLoopExit(ctx) {
         if (lockBase())
             releaseSessionLock(lockBase());
     }
-    catch {
+    catch (err) {
         /* best-effort — mirror stopAuto cleanup */
+        logWarning("session", `lock cleanup failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
     }
     ctx.ui.setStatus("gsd-auto", undefined);
     ctx.ui.setWidget("gsd-progress", undefined);
@@ -352,8 +354,9 @@ function cleanupAfterLoopExit(ctx) {
         try {
             process.chdir(s.basePath);
         }
-        catch {
+        catch (err) {
             /* best-effort */
+            logWarning("engine", `chdir failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
         }
     }
 }
@@ -415,8 +418,9 @@ export async function stopAuto(ctx, pi, reason) {
                         milestoneComplete = true;
                     }
                 }
-                catch {
+                catch (err) {
                     // Non-fatal — fall through to preserveBranch path
+                    logWarning("engine", `milestone summary check failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
                 }
                 if (milestoneComplete) {
                     // Milestone is complete — merge worktree branch back to main
@@ -452,8 +456,9 @@ export async function stopAuto(ctx, pi, reason) {
                 try {
                     process.chdir(s.basePath);
                 }
-                catch {
+                catch (err) {
                     /* best-effort */
+                    logWarning("engine", `chdir failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
                 }
             }
         }
@@ -522,7 +527,9 @@ export async function stopAuto(ctx, pi, reason) {
             if (existsSync(pausedPath))
                 unlinkSync(pausedPath);
         }
-        catch { /* non-fatal */ }
+        catch (err) { /* non-fatal */
+            logWarning("engine", `file unlink failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
+        }
         // ── Step 13: Restore original model (before reset clears IDs) ──
         try {
             if (pi && ctx && s.originalModelId && s.originalModelProvider) {
@@ -556,7 +563,9 @@ export async function stopAuto(ctx, pi, reason) {
                 await closeBrowser();
             }
         }
-        catch { /* non-fatal: browser-tools may not be loaded */ }
+        catch (err) { /* non-fatal: browser-tools may not be loaded */
+            logWarning("engine", `browser teardown failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
+        }
         // External cleanup (not covered by session reset)
         clearInFlightTools();
         clearSliceProgressCache();
@@ -602,16 +611,18 @@ export async function pauseAuto(ctx, _pi, _errorContext) {
         mkdirSync(runtimeDir, { recursive: true });
         writeFileSync(join(runtimeDir, "paused-session.json"), JSON.stringify(pausedMeta, null, 2), "utf-8");
     }
-    catch {
+    catch (err) {
         // Non-fatal — resume will still work via full bootstrap, just without worktree context
+        logWarning("engine", `paused-session file write failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
     }
     // Close out the current unit so its runtime record doesn't stay at "dispatched"
     if (s.currentUnit && ctx) {
         try {
             await closeoutUnit(ctx, s.basePath, s.currentUnit.type, s.currentUnit.id, s.currentUnit.startedAt);
         }
-        catch {
+        catch (err) {
             // Non-fatal — best-effort closeout on pause
+            logWarning("engine", `unit closeout on pause failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
         }
         s.currentUnit = null;
     }
@@ -798,7 +809,9 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
                     try {
                         unlinkSync(pausedPath);
                     }
-                    catch { /* non-fatal */ }
+                    catch (err) { /* non-fatal */
+                        logWarning("session", `pause file cleanup failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
+                    }
                     ctx.ui.notify(`Resuming paused custom workflow${meta.activeRunDir ? ` (${meta.activeRunDir})` : ""}.`, "info");
                 }
                 else if (meta.milestoneId) {
@@ -810,7 +823,9 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
                         try {
                             unlinkSync(pausedPath);
                         }
-                        catch { /* non-fatal */ }
+                        catch (err) { /* non-fatal */
+                            logWarning("session", `pause file cleanup failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
+                        }
                         ctx.ui.notify(`Paused milestone ${meta.milestoneId} is ${!mDir ? "missing" : "already complete"}. Starting fresh.`, "info");
                     }
                     else {
@@ -822,14 +837,17 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
                         try {
                             unlinkSync(pausedPath);
                         }
-                        catch { /* non-fatal */ }
+                        catch (err) { /* non-fatal */
+                            logWarning("session", `pause file cleanup failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
+                        }
                         ctx.ui.notify(`Resuming paused session for ${meta.milestoneId}${meta.worktreePath ? ` (worktree)` : ""}.`, "info");
                     }
                 }
             }
         }
-        catch {
+        catch (err) {
             // Malformed or missing — proceed with fresh bootstrap
+            logWarning("session", `paused-session restore failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
         }
     }
     if (s.paused) {
@@ -917,8 +935,9 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
     try {
         syncCmuxSidebar(loadEffectiveGSDPreferences()?.preferences, await deriveState(s.basePath));
     }
-    catch {
+    catch (err) {
         // Best-effort only — sidebar sync must never block auto-mode startup
+        logWarning("engine", `cmux sync failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
     }
     logCmuxEvent(loadEffectiveGSDPreferences()?.preferences, requestedStepMode ? "Step-mode started." : "Auto-mode started.", "progress");
     // Dispatch the first unit
@@ -1043,8 +1062,9 @@ export async function dispatchHookUnit(ctx, pi, hookName, triggerUnitType, trigg
             try {
                 await pi.setModel(match);
             }
-            catch {
+            catch (err) {
                 /* non-fatal */
+                logWarning("dispatch", `hook model set failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
             }
         }
         else {
@@ -1072,7 +1092,9 @@ export async function dispatchHookUnit(ctx, pi, hookName, triggerUnitType, trigg
         if (process.cwd() !== s.basePath)
             process.chdir(s.basePath);
     }
-    catch { }
+    catch (err) {
+        logWarning("engine", `chdir failed before hook dispatch: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
+    }
     debugLog("dispatchHookUnit", {
         phase: "send-message",
         promptLength: hookPrompt.length,

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

@@ -1,3 +1,4 @@
+import { logWarning } from "../workflow-logger.js";
 import { checkAutoStartAfterDiscuss } from "../guided-flow.js";
 import { getAutoDashboardData, getAutoModeStartModel, isAutoActive, pauseAuto } from "../auto.js";
 import { getNextFallbackModel, resolveModelWithFallbacksForUnit } from "../preferences.js";
@@ -68,7 +69,9 @@ export async function handleAgentEnd(pi, event, ctx) {
                 try {
                     await pauseAuto(ctx, pi);
                 }
-                catch { /* best-effort */ }
+                catch (e) {
+                    logWarning("bootstrap", `pauseAuto failed after empty-content abort: ${e.message}`);
+                }
             }
             return;
         }
@@ -184,8 +187,8 @@ export async function handleAgentEnd(pi, event, ctx) {
         try {
             await pauseAuto(ctx, pi);
         }
-        catch {
-            // best-effort
+        catch (e) {
+            logWarning("bootstrap", `pauseAuto failed in agent_end handler: ${e.message}`);
         }
     }
 }

package/dist/resources/extensions/gsd/bootstrap/db-tools.js

@@ -403,8 +403,8 @@ export function registerDbTools(pi) {
             const { insertMilestone } = await import("../gsd-db.js");
             insertMilestone({ id: milestoneId, status: "queued" });
         }
-        catch {
-            // Non-fatal — the safety-net in deriveStateFromDb will catch this
+        catch (e) {
+            logError("tool", `insertMilestone failed for ${milestoneId}: ${e.message}`);
         }
     }
     const milestoneGenerateIdTool = {
@@ -832,6 +832,76 @@ export function registerDbTools(pi) {
     };
     pi.registerTool(sliceCompleteTool);
     registerAlias(pi, sliceCompleteTool, "gsd_complete_slice", "gsd_slice_complete");
+    // ─── gsd_skip_slice (#3477 / #3487) ───────────────────────────────────
+    const skipSliceExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
+        const dbAvailable = await ensureDbOpen();
+        if (!dbAvailable) {
+            return {
+                content: [{ type: "text", text: "Error: GSD database is not available. Cannot skip slice." }],
+                details: { operation: "skip_slice", error: "db_unavailable" },
+            };
+        }
+        try {
+            const { getSlice, updateSliceStatus } = await import("../gsd-db.js");
+            const { invalidateStateCache } = await import("../state.js");
+            const slice = getSlice(params.milestoneId, params.sliceId);
+            if (!slice) {
+                return {
+                    content: [{ type: "text", text: `Error: Slice ${params.sliceId} not found in milestone ${params.milestoneId}` }],
+                    details: { operation: "skip_slice", error: "slice_not_found" },
+                };
+            }
+            if (slice.status === "complete" || slice.status === "done") {
+                return {
+                    content: [{ type: "text", text: `Error: Slice ${params.sliceId} is already complete — cannot skip.` }],
+                    details: { operation: "skip_slice", error: "already_complete" },
+                };
+            }
+            if (slice.status === "skipped") {
+                return {
+                    content: [{ type: "text", text: `Slice ${params.sliceId} is already skipped.` }],
+                    details: { operation: "skip_slice", sliceId: params.sliceId, milestoneId: params.milestoneId },
+                };
+            }
+            updateSliceStatus(params.milestoneId, params.sliceId, "skipped");
+            invalidateStateCache();
+            return {
+                content: [{ type: "text", text: `Skipped slice ${params.sliceId} (${params.milestoneId}). Reason: ${params.reason ?? "User-directed skip"}. Auto-mode will advance past this slice.` }],
+                details: {
+                    operation: "skip_slice",
+                    sliceId: params.sliceId,
+                    milestoneId: params.milestoneId,
+                    reason: params.reason,
+                },
+            };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            logError("tool", `skip_slice tool failed: ${msg}`, { tool: "gsd_skip_slice", error: String(err) });
+            return {
+                content: [{ type: "text", text: `Error skipping slice: ${msg}` }],
+                details: { operation: "skip_slice", error: msg },
+            };
+        }
+    };
+    pi.registerTool({
+        name: "gsd_skip_slice",
+        label: "Skip Slice",
+        description: "Mark a slice as skipped so auto-mode advances past it without executing. " +
+            "The slice data is preserved for reference. The state machine treats skipped slices like completed ones for dependency satisfaction.",
+        promptSnippet: "Skip a GSD slice (mark as skipped, auto-mode will advance past it)",
+        promptGuidelines: [
+            "Use gsd_skip_slice when a slice should be bypassed — descoped, superseded, or no longer relevant.",
+            "Cannot skip a slice that is already complete.",
+            "Skipped slices satisfy downstream dependencies just like completed slices.",
+        ],
+        parameters: Type.Object({
+            sliceId: Type.String({ description: "Slice ID (e.g. S02)" }),
+            milestoneId: Type.String({ description: "Milestone ID (e.g. M003)" }),
+            reason: Type.Optional(Type.String({ description: "Reason for skipping this slice" })),
+        }),
+        execute: skipSliceExecute,
+    });
     // ─── gsd_complete_milestone ────────────────────────────────────────────
     const milestoneCompleteExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
         const dbAvailable = await ensureDbOpen();

package/dist/resources/extensions/gsd/bootstrap/dynamic-tools.js

@@ -2,7 +2,7 @@ import { existsSync } from "node:fs";
 import { join, sep } from "node:path";
 import { createBashTool, createEditTool, createReadTool, createWriteTool } from "@gsd/pi-coding-agent";
 import { DEFAULT_BASH_TIMEOUT_SECS } from "../constants.js";
-import { setLogBasePath } from "../workflow-logger.js";
+import { setLogBasePath, logWarning } from "../workflow-logger.js";
 /**
  * Resolve the correct DB path for the current working directory.
  * If `basePath` is inside a `.gsd/worktrees/<MID>/` directory, returns
@@ -82,7 +82,7 @@ export async function ensureDbOpen() {
                         migrateFromMarkdown(basePath);
                     }
                     catch (err) {
-                        process.stderr.write(`gsd-db: ensureDbOpen auto-migration failed: ${err.message}\n`);
+                        logWarning("bootstrap", `ensureDbOpen auto-migration failed: ${err.message}`);
                     }
                 }
                 return opened;
@@ -93,17 +93,11 @@ export async function ensureDbOpen() {
                 setLogBasePath(projectRoot);
             return opened;
         }
-        process.stderr.write(`gsd-db: ensureDbOpen failed — no .gsd directory found (resolvedPath=${resolveProjectRootDbPath(basePath)}, cwd=${basePath})\n`);
+        logWarning("bootstrap", "ensureDbOpen failed — no .gsd directory found");
         return false;
     }
     catch (err) {
-        const basePath = process.cwd();
-        const diagnostic = {
-            resolvedPath: resolveProjectRootDbPath(basePath),
-            cwd: basePath,
-            error: err.message ?? String(err),
-        };
-        process.stderr.write(`gsd-db: ensureDbOpen failed — ${JSON.stringify(diagnostic)}\n`);
+        logWarning("bootstrap", `ensureDbOpen failed: ${err.message ?? String(err)}`);
         return false;
     }
 }

package/dist/resources/extensions/gsd/bootstrap/journal-tools.js

@@ -1,5 +1,6 @@
 import { Type } from "@sinclair/typebox";
 import { queryJournal } from "../journal.js";
+import { logWarning } from "../workflow-logger.js";
 export function registerJournalTools(pi) {
     pi.registerTool({
         name: "gsd_journal_query",
@@ -51,7 +52,7 @@ export function registerJournalTools(pi) {
             }
             catch (err) {
                 const msg = err instanceof Error ? err.message : String(err);
-                process.stderr.write(`gsd-journal: gsd_journal_query tool failed: ${msg}\n`);
+                logWarning("tool", `gsd_journal_query tool failed: ${msg}`);
                 return {
                     content: [{ type: "text", text: `Error querying journal: ${msg}` }],
                     details: { operation: "journal_query", error: msg },

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

@@ -244,17 +244,70 @@ export function registerHooks(pi) {
         await syncServiceTierStatus(ctx);
     });
     pi.on("before_provider_request", async (event) => {
+        const payload = event.payload;
+        if (!payload || typeof payload !== "object")
+            return;
+        // ── Observation Masking ─────────────────────────────────────────────
+        // Replace old tool results with placeholders to reduce context bloat.
+        // Only active during auto-mode when context_management.observation_masking is enabled.
+        if (isAutoActive()) {
+            try {
+                const { loadEffectiveGSDPreferences } = await import("../preferences.js");
+                const prefs = loadEffectiveGSDPreferences();
+                const cmConfig = prefs?.preferences.context_management;
+                // Observation masking: replace old tool results with placeholders
+                if (cmConfig?.observation_masking !== false) {
+                    const keepTurns = cmConfig?.observation_mask_turns ?? 8;
+                    const { createObservationMask } = await import("../context-masker.js");
+                    const mask = createObservationMask(keepTurns);
+                    const messages = payload.messages;
+                    if (Array.isArray(messages)) {
+                        payload.messages = mask(messages);
+                    }
+                }
+                // Tool result truncation: cap individual tool result content length.
+                // In pi-ai format, toolResult messages have role: "toolResult" and content: TextContent[].
+                // Creates new objects to avoid mutating shared conversation state.
+                const maxChars = cmConfig?.tool_result_max_chars ?? 800;
+                const msgs = payload.messages;
+                if (Array.isArray(msgs)) {
+                    payload.messages = msgs.map((msg) => {
+                        // Match toolResult messages (role: "toolResult", content is array of content blocks)
+                        if (msg?.role === "toolResult" && Array.isArray(msg.content)) {
+                            const blocks = msg.content;
+                            const totalLen = blocks.reduce((sum, b) => sum + (typeof b.text === "string" ? b.text.length : 0), 0);
+                            if (totalLen > maxChars) {
+                                const truncated = blocks.map(b => {
+                                    if (typeof b.text === "string" && b.text.length > maxChars) {
+                                        return { ...b, text: b.text.slice(0, maxChars) + "\n…[truncated]" };
+                                    }
+                                    return b;
+                                });
+                                return { ...msg, content: truncated };
+                            }
+                        }
+                        return msg;
+                    });
+                }
+            }
+            catch { /* non-fatal */ }
+        }
+        // ── Service Tier ────────────────────────────────────────────────────
         const modelId = event.model?.id;
         if (!modelId)
-            return;
+            return payload;
         const { getEffectiveServiceTier, supportsServiceTier } = await import("../service-tier.js");
         const tier = getEffectiveServiceTier();
         if (!tier || !supportsServiceTier(modelId))
-            return;
-        const payload = event.payload;
-        if (!payload || typeof payload !== "object")
-            return;
+            return payload;
         payload.service_tier = tier;
         return payload;
     });
+    // Capability-aware model routing hook (ADR-004)
+    // Extensions can override model selection by returning { modelId: "..." }
+    // Return undefined to let the built-in capability scoring proceed.
+    pi.on("before_model_select", async (_event) => {
+        // Default: no override — let capability scoring handle selection
+        return undefined;
+    });
 }

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

@@ -1,6 +1,7 @@
 import { existsSync, readFileSync, unlinkSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
+import { logWarning } from "../workflow-logger.js";
 import { debugTime } from "../debug-logger.js";
 import { loadPrompt } from "../prompt-loader.js";
 import { readForensicsMarker } from "../forensics.js";
@@ -61,8 +62,8 @@ export async function buildBeforeAgentStartResult(event, ctx) {
             }
         }
     }
-    catch {
-        // non-fatal
+    catch (e) {
+        logWarning("bootstrap", `memory block fetch failed: ${e.message}`);
     }
     let newSkillsBlock = "";
     if (hasSkillSnapshot()) {
@@ -88,8 +89,8 @@ export async function buildBeforeAgentStartResult(event, ctx) {
                 codebaseBlock = `\n\n[PROJECT CODEBASE — File structure and descriptions (generated ${generatedAt}, may be stale — run /gsd codebase update to refresh)]\n\n${content}`;
             }
         }
-        catch {
-            // skip
+        catch (e) {
+            logWarning("bootstrap", `CODEBASE file read failed: ${e.message}`);
         }
     }
     warnDeprecatedAgentInstructions();
@@ -128,8 +129,8 @@ export function loadKnowledgeBlock(gsdHomeDir, cwd) {
                 globalKnowledge = content;
             }
         }
-        catch {
-            // skip
+        catch (e) {
+            logWarning("bootstrap", `global knowledge file read failed: ${e.message}`);
         }
     }
     // 2. Project knowledge (.gsd/KNOWLEDGE.md) — project-specific
@@ -141,8 +142,8 @@ export function loadKnowledgeBlock(gsdHomeDir, cwd) {
             if (content)
                 projectKnowledge = content;
         }
-        catch {
-            // skip
+        catch (e) {
+            logWarning("bootstrap", `project knowledge file read failed: ${e.message}`);
         }
     }
     if (!globalKnowledge && !projectKnowledge) {
@@ -381,8 +382,8 @@ export function clearForensicsMarker(basePath) {
         try {
             unlinkSync(markerPath);
         }
-        catch {
-            // non-fatal
+        catch (e) {
+            logWarning("bootstrap", `unlinkSync forensics marker failed: ${e.message}`);
         }
     }
 }

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

@@ -14,7 +14,7 @@ import { gsdRoot } from "./paths.js";
 // ─── Constants ────────────────────────────────────────────────────────────────
 const CAPTURES_FILENAME = "CAPTURES.md";
 const VALID_CLASSIFICATIONS = [
-    "quick-task", "inject", "defer", "replan", "note",
+    "quick-task", "inject", "defer", "replan", "note", "stop", "backtrack",
 ];
 // ─── Path Resolution ──────────────────────────────────────────────────────────
 /**
@@ -216,6 +216,59 @@ export function loadActionableCaptures(basePath, currentMilestoneId) {
             !c.resolvedInMilestone ||
             c.resolvedInMilestone === currentMilestoneId));
 }
+/**
+ * Load unexecuted stop captures — user directives to halt auto-mode.
+ * These are checked in the pre-dispatch guard pipeline (runGuards) to
+ * pause auto-mode before the next unit is dispatched.
+ */
+export function loadStopCaptures(basePath) {
+    return loadAllCaptures(basePath).filter(c => c.status === "resolved" && !c.executed &&
+        (c.classification === "stop" || c.classification === "backtrack"));
+}
+/**
+ * Load unexecuted backtrack captures specifically — captures directing
+ * auto-mode to abandon current milestone and return to a previous one.
+ */
+export function loadBacktrackCaptures(basePath) {
+    return loadAllCaptures(basePath).filter(c => c.status === "resolved" && !c.executed && c.classification === "backtrack");
+}
+/**
+ * Revert captures that were silenced by non-triage agents.
+ *
+ * When an execute-task or other non-triage agent writes `**Status:** resolved`
+ * to CAPTURES.md, it bypasses the triage pipeline entirely. This function
+ * detects such captures (resolved but missing the Classification field that
+ * triage always writes) and reverts them to pending so the triage sidecar
+ * picks them up properly.
+ *
+ * Returns the number of captures reverted.
+ */
+export function revertExecutorResolvedCaptures(basePath) {
+    const filePath = resolveCapturesPath(basePath);
+    if (!existsSync(filePath))
+        return 0;
+    let content = readFileSync(filePath, "utf-8");
+    let reverted = 0;
+    const all = loadAllCaptures(basePath);
+    for (const capture of all) {
+        // A properly triaged capture has both resolved status AND a classification.
+        // An executor-silenced capture has resolved status but NO classification.
+        if (capture.status === "resolved" && !capture.classification) {
+            const sectionRegex = new RegExp(`(### ${escapeRegex(capture.id)}\\n(?:(?!### ).)*?)(?=### |$)`, "s");
+            const match = sectionRegex.exec(content);
+            if (match) {
+                let section = match[1];
+                section = section.replace(/\*\*Status:\*\*\s*resolved/i, "**Status:** pending");
+                content = content.replace(sectionRegex, section);
+                reverted++;
+            }
+        }
+    }
+    if (reverted > 0) {
+        writeFileSync(filePath, content, "utf-8");
+    }
+    return reverted;
+}
 /**
  * Retroactively stamp a capture with a milestone ID.
  *

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

@@ -216,8 +216,10 @@ const NESTED_COMPLETIONS = {
     codebase: [
         { cmd: "generate", desc: "Generate or regenerate CODEBASE.md" },
         { cmd: "generate --max-files", desc: "Generate with custom file limit (default: 500)" },
+        { cmd: "generate --collapse-threshold", desc: "Generate with custom collapse threshold (default: 20)" },
         { cmd: "update", desc: "Incremental update (preserves descriptions)" },
         { cmd: "update --max-files", desc: "Update with custom file limit" },
+        { cmd: "update --collapse-threshold", desc: "Update with custom collapse threshold" },
         { cmd: "stats", desc: "Show file count, description coverage, and generation time" },
         { cmd: "help", desc: "Show usage and available subcommands" },
     ],