gsd-pi 2.59.0-dev.3de3832 → 2.59.0-dev.d77b3dd

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

@@ -487,11 +487,47 @@ export async function runDispatch(ic, preData, loopState) {
 }
 // ─── runGuards ────────────────────────────────────────────────────────────────
 /**
- * Phase 2: Guards — budget ceiling, context window, secrets re-check.
+ * Phase 2: Guards — stop directives, budget ceiling, context window, secrets re-check.
  * Returns break to exit the loop, or next to proceed to dispatch.
  */
 export async function runGuards(ic, mid) {
     const { ctx, pi, s, deps, prefs } = ic;
+    // ── Stop/Backtrack directive guard (#3487) ──
+    // Check for unexecuted stop or backtrack captures BEFORE dispatching any unit.
+    // This ensures user "halt" directives are honored immediately.
+    try {
+        const { loadStopCaptures, markCaptureExecuted } = await import("../captures.js");
+        const stopCaptures = loadStopCaptures(s.basePath);
+        if (stopCaptures.length > 0) {
+            const first = stopCaptures[0];
+            const isBacktrack = first.classification === "backtrack";
+            const label = isBacktrack
+                ? `Backtrack directive: ${first.text}`
+                : `Stop directive: ${first.text}`;
+            ctx.ui.notify(label, "warning");
+            deps.sendDesktopNotification("GSD", label, "warning", "stop-directive", basename(s.originalBasePath || s.basePath));
+            // Mark all stop/backtrack captures as executed so they don't re-fire
+            for (const cap of stopCaptures) {
+                markCaptureExecuted(s.basePath, cap.id);
+            }
+            // For backtrack captures, write the backtrack trigger before pausing
+            if (isBacktrack) {
+                try {
+                    const { executeBacktrack } = await import("../triage-resolution.js");
+                    executeBacktrack(s.basePath, mid, first);
+                }
+                catch (e) {
+                    debugLog("guards", { phase: "backtrack-execution-error", error: String(e) });
+                }
+            }
+            await deps.pauseAuto(ctx, pi);
+            debugLog("autoLoop", { phase: "exit", reason: isBacktrack ? "user-backtrack" : "user-stop" });
+            return { action: "break", reason: isBacktrack ? "user-backtrack" : "user-stop" };
+        }
+    }
+    catch (e) {
+        debugLog("guards", { phase: "stop-guard-error", error: String(e) });
+    }
     // Budget ceiling guard
     const budgetCeiling = prefs?.budget_ceiling;
     if (budgetCeiling !== undefined && budgetCeiling > 0) {
@@ -843,6 +879,23 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         s.unitDispatchCount.delete(`${unitType}/${unitId}`);
         s.unitRecoveryCount.delete(`${unitType}/${unitId}`);
     }
+    // Write phase handoff anchor after successful research/planning completion
+    const anchorPhases = new Set(["research-milestone", "research-slice", "plan-milestone", "plan-slice"]);
+    if (artifactVerified && mid && anchorPhases.has(unitType)) {
+        try {
+            const { writePhaseAnchor } = await import("../phase-anchor.js");
+            writePhaseAnchor(s.basePath, mid, {
+                phase: unitType,
+                milestoneId: mid,
+                generatedAt: new Date().toISOString(),
+                intent: `Completed ${unitType} for ${unitId}`,
+                decisions: [],
+                blockers: [],
+                nextSteps: [],
+            });
+        }
+        catch { /* non-fatal — anchor is advisory */ }
+    }
     deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: ic.nextSeq(), eventType: "unit-end", data: { unitType, unitId, status: unitResult.status, artifactVerified, ...(unitResult.errorContext ? { errorContext: unitResult.errorContext } : {}) }, causedBy: { flowId: ic.flowId, seq: unitStartSeq } });
     return { action: "next", data: { unitStartedAt: s.currentUnit?.startedAt } };
 }

package/dist/resources/extensions/gsd/auto-model-selection.js

@@ -4,7 +4,7 @@
  * and fallback chains.
  */
 import { resolveModelWithFallbacksForUnit, resolveDynamicRoutingConfig } from "./preferences.js";
-import { classifyUnitComplexity, tierLabel } from "./complexity-classifier.js";
+import { classifyUnitComplexity, tierLabel, extractTaskMetadata } from "./complexity-classifier.js";
 import { resolveModelForComplexity, escalateTier } from "./model-router.js";
 import { getLedger, getProjectTotals } from "./metrics.js";
 import { unitPhaseLabel } from "./auto-dashboard.js";
@@ -68,14 +68,19 @@ export async function selectAndApplyModel(ctx, pi, unitType, unitId, basePath, p
                         }
                     }
                 }
-                const routingResult = resolveModelForComplexity(classification, modelConfig, routingConfig, availableModelIds);
+                // Extract task metadata for capability scoring
+                const taskMeta = unitType === "execute-task"
+                    ? extractTaskMetadata(unitId, basePath)
+                    : undefined;
+                const routingResult = resolveModelForComplexity(classification, modelConfig, routingConfig, availableModelIds, unitType, taskMeta);
                 if (routingResult.wasDowngraded) {
                     effectiveModelConfig = {
                         primary: routingResult.modelId,
                         fallbacks: routingResult.fallbacks,
                     };
                     if (verbose) {
-                        ctx.ui.notify(`Dynamic routing [${tierLabel(classification.tier)}]: ${routingResult.modelId} (${classification.reason})`, "info");
+                        const method = routingResult.selectionMethod === "capability-scored" ? "capability-scored" : "tier-only";
+                        ctx.ui.notify(`Dynamic routing [${tierLabel(classification.tier)}]: ${routingResult.modelId} (${method} — ${classification.reason})`, "info");
                     }
                 }
                 routingTierLabel = ` [${tierLabel(classification.tier)}]`;

package/dist/resources/extensions/gsd/auto-post-unit.js

@@ -26,7 +26,7 @@ import { isDbAvailable, getTask, getSlice, getMilestone, updateTaskStatus, _getA
 import { renderPlanCheckboxes } from "./markdown-renderer.js";
 import { consumeSignal } from "./session-status-io.js";
 import { checkPostUnitHooks, isRetryPending, consumeRetryTrigger, persistHookState, resolveHookArtifactPath, } from "./post-unit-hooks.js";
-import { hasPendingCaptures, loadPendingCaptures } from "./captures.js";
+import { hasPendingCaptures, loadPendingCaptures, revertExecutorResolvedCaptures } from "./captures.js";
 import { debugLog } from "./debug-logger.js";
 import { runSafely } from "./auto-utils.js";
 /** Enqueue a sidecar item (hook, triage, or quick-task) for the main loop to
@@ -478,6 +478,45 @@ export async function postUnitPostVerification(pctx) {
             }
         }
     }
+    // ── Fast-path stop detection (#3487) ──
+    // Before waiting for triage, check if any PENDING captures contain explicit
+    // stop/halt language. If so, pause immediately — don't wait for triage.
+    if (s.currentUnit && s.currentUnit.type !== "triage-captures") {
+        try {
+            const pending = loadPendingCaptures(s.basePath);
+            // Match only when the capture text starts with a stop/halt directive word,
+            // or the entire text is short and dominated by such a word. This avoids
+            // false positives on captures like "add a pause button" or "stop the timer
+            // from re-rendering" — those are feature descriptions, not halt directives.
+            const STOP_PATTERN = /^(stop|halt|abort|don'?t continue|pause|cease)\b/i;
+            const stopCapture = pending.find(c => STOP_PATTERN.test(c.text.trim()));
+            if (stopCapture) {
+                ctx.ui.notify(`Stop directive detected in pending capture ${stopCapture.id}: "${stopCapture.text}" — pausing auto-mode.`, "warning");
+                debugLog("postUnit", { phase: "fast-stop", captureId: stopCapture.id });
+                await pauseAuto(ctx, pi);
+                return "stopped";
+            }
+        }
+        catch (e) {
+            debugLog("postUnit", { phase: "fast-stop-error", error: String(e) });
+        }
+    }
+    // ── Capture protection: revert executor-silenced captures (#3487) ──
+    // Non-triage agents can write **Status:** resolved to CAPTURES.md, bypassing
+    // the triage pipeline. Revert those to pending before the triage check.
+    if (s.currentUnit &&
+        s.currentUnit.type !== "triage-captures") {
+        try {
+            const reverted = revertExecutorResolvedCaptures(s.basePath);
+            if (reverted > 0) {
+                debugLog("postUnit", { phase: "capture-protection", reverted });
+                ctx.ui.notify(`Reverted ${reverted} capture${reverted === 1 ? "" : "s"} silenced by executor — re-queuing for triage.`, "warning");
+            }
+        }
+        catch (e) {
+            debugLog("postUnit", { phase: "capture-protection-error", error: String(e) });
+        }
+    }
     // ── Triage check ──
     if (!s.stepMode &&
         s.currentUnit &&

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

@@ -17,6 +17,7 @@ import { existsSync } from "node:fs";
 import { computeBudgets, resolveExecutorContextWindow, truncateAtSectionBoundary } from "./context-budget.js";
 import { getPendingGates } from "./gsd-db.js";
 import { formatDecisionsCompact, formatRequirementsCompact } from "./structured-data-formatter.js";
+import { readPhaseAnchor, formatAnchorForPrompt } from "./phase-anchor.js";
 // ─── Preamble Cap ─────────────────────────────────────────────────────────────
 const MAX_PREAMBLE_CHARS = 30_000;
 function capPreamble(preamble) {
@@ -797,6 +798,10 @@ export async function buildPlanMilestonePrompt(mid, midTitle, base, level) {
     const researchPath = resolveMilestoneFile(base, mid, "RESEARCH");
     const researchRel = relMilestoneFile(base, mid, "RESEARCH");
     const inlined = [];
+    // Inject phase handoff anchor from research phase (if available)
+    const researchAnchor = readPhaseAnchor(base, mid, "research-milestone");
+    if (researchAnchor)
+        inlined.push(formatAnchorForPrompt(researchAnchor));
     inlined.push(await inlineFile(contextPath, contextRel, "Milestone Context"));
     const researchInline = await inlineFileOptional(researchPath, researchRel, "Milestone Research");
     if (researchInline)
@@ -919,6 +924,10 @@ export async function buildPlanSlicePrompt(mid, _midTitle, sid, sTitle, base, le
     const researchPath = resolveSliceFile(base, mid, sid, "RESEARCH");
     const researchRel = relSliceFile(base, mid, sid, "RESEARCH");
     const inlined = [];
+    // Inject phase handoff anchor from research phase (if available)
+    const researchSliceAnchor = readPhaseAnchor(base, mid, "research-slice");
+    if (researchSliceAnchor)
+        inlined.push(formatAnchorForPrompt(researchSliceAnchor));
     inlined.push(await inlineFile(roadmapPath, roadmapRel, "Milestone Roadmap"));
     const researchInline = await inlineFileOptional(researchPath, researchRel, "Slice Research");
     if (researchInline)
@@ -974,6 +983,8 @@ export async function buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base
         ? level
         : { level: level };
     const inlineLevel = opts.level ?? resolveInlineLevel();
+    // Inject phase handoff anchor from planning phase (if available)
+    const planAnchor = readPhaseAnchor(base, mid, "plan-slice");
     const priorSummaries = opts.carryForwardPaths ?? await getPriorTaskSummaryPaths(mid, sid, tid, base);
     const priorLines = priorSummaries.length > 0
         ? priorSummaries.map(p => `- \`${p}\``).join("\n")
@@ -1042,9 +1053,11 @@ export async function buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base
     const runtimeContext = runtimeContent
         ? `### Runtime Context\nSource: \`.gsd/RUNTIME.md\`\n\n${runtimeContent.trim()}`
         : "";
+    const phaseAnchorSection = planAnchor ? formatAnchorForPrompt(planAnchor) : "";
     return loadPrompt("execute-task", {
         overridesSection,
         runtimeContext,
+        phaseAnchorSection,
         workingDirectory: base,
         milestoneId: mid, sliceId: sid, sliceTitle: sTitle, taskId: tid, taskTitle: tTitle,
         planPath: join(base, relSliceFile(base, mid, sid, "PLAN")),

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

@@ -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/register-hooks.js

@@ -244,16 +244,62 @@ 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;
     });

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/complexity-classifier.js

@@ -149,7 +149,7 @@ function analyzePlanComplexity(unitId, basePath) {
 /**
  * Extract task metadata from the task plan file on disk.
  */
-function extractTaskMetadata(unitId, basePath) {
+export function extractTaskMetadata(unitId, basePath) {
     const meta = {};
     const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
     if (!mid || !sid || !tid)

package/dist/resources/extensions/gsd/context-masker.js

@@ -0,0 +1,68 @@
+/**
+ * Observation masking for GSD auto-mode sessions.
+ *
+ * Replaces tool result content older than N turns with a placeholder.
+ * Reduces context bloat between compactions with zero LLM overhead.
+ * Preserves message ordering, roles, and all assistant/user messages.
+ *
+ * Operates on the pi-ai Message[] format (post-convertToLlm, pre-provider):
+ *   - toolResult messages: { role: "toolResult", content: TextContent[] }
+ *   - bash results are already converted to: { role: "user", content: [{type:"text",text:"..."}] }
+ *     and start with "Ran `" from bashExecutionToText.
+ */
+const MASK_PLACEHOLDER = "[result masked — within summarized history]";
+const MASK_CONTENT_BLOCK = [{ type: "text", text: MASK_PLACEHOLDER }];
+function findTurnBoundary(messages, keepRecentTurns) {
+    let turnsSeen = 0;
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const m = messages[i];
+        // In the LLM payload, genuine user turns have role "user".
+        // Tool results have role "toolResult" and are excluded by this check.
+        if (m.role === "user") {
+            // Skip bash-result user messages (converted from bashExecution) — these aren't real user turns
+            if (isBashResultUserMessage(m))
+                continue;
+            turnsSeen++;
+            if (turnsSeen >= keepRecentTurns)
+                return i;
+        }
+    }
+    return 0;
+}
+/**
+ * Detect user messages that originated from bashExecution.
+ * After convertToLlm, these are {role: "user", content: [{type:"text", text:"Ran `cmd`\n..."}]}.
+ * The bashExecutionToText format always starts with "Ran `".
+ */
+function isBashResultUserMessage(m) {
+    if (m.role !== "user" || !Array.isArray(m.content))
+        return false;
+    const first = m.content[0];
+    return first && typeof first === "object" && "text" in first &&
+        typeof first.text === "string" && first.text.startsWith("Ran `");
+}
+function isMaskableMessage(m) {
+    // Tool result messages (role: "toolResult" in pi-ai format)
+    if (m.role === "toolResult")
+        return true;
+    // Bash-result user messages (converted from bashExecution by convertToLlm)
+    if (isBashResultUserMessage(m))
+        return true;
+    return false;
+}
+export function createObservationMask(keepRecentTurns = 8) {
+    return (messages) => {
+        const boundary = findTurnBoundary(messages, keepRecentTurns);
+        if (boundary === 0)
+            return messages;
+        return messages.map((m, i) => {
+            if (i >= boundary)
+                return m;
+            if (isMaskableMessage(m)) {
+                // Content may be string or array of content blocks — always replace with array
+                return { ...m, content: MASK_CONTENT_BLOCK };
+            }
+            return m;
+        });
+    };
+}

package/dist/resources/extensions/gsd/docs/preferences-reference.md

@@ -189,6 +189,13 @@ Setting `prefer_skills: []` does **not** disable skill discovery — it just mea
   - `budget_pressure`: boolean — downgrade model tier when budget is under pressure. Default: `true`.
   - `cross_provider`: boolean — allow routing across different providers. Default: `true`.
   - `hooks`: boolean — enable routing hooks. Default: `true`.
+  - `capability_routing`: boolean — enable capability-profile scoring for model selection within a tier. Requires `enabled: true`. Default: `false`.
+
+- `context_management`: configures context hygiene for auto-mode sessions. Keys:
+  - `observation_masking`: boolean — mask old tool results to reduce context bloat. Default: `true`.
+  - `observation_mask_turns`: number — keep this many recent turns verbatim (1-50). Default: `8`.
+  - `compaction_threshold_percent`: number — trigger compaction at this % of context window (0.5-0.95). Lower values fire compaction earlier, reducing drift. Default: `0.70`.
+  - `tool_result_max_chars`: number — max chars per tool result in GSD sessions (200-10000). Default: `800`.
 
 - `auto_visualize`: boolean — show a visualizer hint after each milestone completion in auto-mode. Default: `false`.
 

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

@@ -1374,11 +1374,11 @@ export function getActiveSliceFromDb(milestoneId) {
     // Uses json_each() to expand the JSON depends array and checks each dep is complete.
     const row = currentDb.prepare(`SELECT s.* FROM slices s
      WHERE s.milestone_id = :mid
-       AND s.status NOT IN ('complete', 'done')
+       AND s.status NOT IN ('complete', 'done', 'skipped')
        AND NOT EXISTS (
          SELECT 1 FROM json_each(s.depends) AS dep
          WHERE dep.value NOT IN (
-           SELECT id FROM slices WHERE milestone_id = :mid AND status IN ('complete', 'done')
+           SELECT id FROM slices WHERE milestone_id = :mid AND status IN ('complete', 'done', 'skipped')
          )
        )
      ORDER BY s.sequence, s.id