gsd-pi 2.77.0-dev.538325aea → 2.77.0-dev.eaa4973bc

package/dist/resources/extensions/google-search/index.js

@@ -1,379 +1,6 @@
-/**
- * Google Search Extension
- *
- * Provides a `google_search` tool that performs web searches via Gemini's
- * Google Search grounding feature. Uses the user's existing GEMINI_API_KEY
- * and Google Cloud GenAI credits.
- *
- * The tool sends queries to Gemini Flash with `googleSearch: {}` enabled.
- * Gemini internally performs Google searches, synthesizes an answer, and
- * returns it with source URLs from grounding metadata.
- */
-import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, truncateHead, } from "@gsd/pi-coding-agent";
-import { Text } from "@gsd/pi-tui";
-import { Type } from "@sinclair/typebox";
-let client = null;
-async function getClient() {
-    if (!client) {
-        const { GoogleGenAI } = await import("@google/genai");
-        client = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
-    }
-    return client;
-}
-/**
- * Perform a search using OAuth credentials via the Cloud Code Assist API.
- * This is used as a fallback when GEMINI_API_KEY is not set.
- */
-async function searchWithOAuth(query, accessToken, projectId, signal) {
-    const model = process.env.GEMINI_SEARCH_MODEL || "gemini-2.5-flash";
-    const url = `https://cloudcode-pa.googleapis.com/v1internal:streamGenerateContent?alt=sse`;
-    const GEMINI_CLI_HEADERS = {
-        ideType: "IDE_UNSPECIFIED",
-        platform: "PLATFORM_UNSPECIFIED",
-        pluginType: "GEMINI",
-    };
-    const executeFetch = async (retries = 3) => {
-        const response = await fetch(url, {
-            method: "POST",
-            headers: {
-                Authorization: `Bearer ${accessToken}`,
-                "Content-Type": "application/json",
-                "User-Agent": "google-cloud-sdk vscode_cloudshelleditor/0.1",
-                "X-Goog-Api-Client": "gl-node/22.17.0",
-                "Client-Metadata": JSON.stringify(GEMINI_CLI_HEADERS),
-            },
-            body: JSON.stringify({
-                project: projectId,
-                model,
-                request: {
-                    contents: [{ parts: [{ text: query }] }],
-                    tools: [{ googleSearch: {} }],
-                },
-                userAgent: "pi-coding-agent",
-            }),
-            signal,
-        });
-        if (!response.ok && retries > 0 && (response.status === 429 || response.status >= 500)) {
-            await new Promise((resolve) => setTimeout(resolve, 1000 * (4 - retries)));
-            return executeFetch(retries - 1);
-        }
-        return response;
-    };
-    const response = await executeFetch();
-    if (!response.ok) {
-        const errorText = await response.text();
-        throw new Error(`Cloud Code Assist API error (${response.status}): ${errorText}`);
-    }
-    // Note: streamGenerateContent returns SSE; for now, we consume all chunks.
-    // For simplicity and to match the previous structure, we'll read to end.
-    const text = await response.text();
-    const jsonLines = text.split("\n")
-        .filter(l => l.startsWith("data:"))
-        .map(l => l.slice(5).trim())
-        .filter(l => l.length > 0);
-    let data;
-    if (jsonLines.length > 0) {
-        // Aggregate chunks if needed, but for now we take the last chunk or assume it's one
-        data = JSON.parse(jsonLines[jsonLines.length - 1]);
-    }
-    else {
-        data = JSON.parse(text);
-    }
-    const candidate = data.response?.candidates?.[0];
-    const answer = candidate?.content?.parts?.find((p) => p.text)?.text ?? "";
-    const grounding = candidate?.groundingMetadata;
-    const sources = [];
-    const seenTitles = new Set();
-    if (grounding?.groundingChunks) {
-        for (const chunk of grounding.groundingChunks) {
-            if (chunk.web) {
-                const title = chunk.web.title ?? "Untitled";
-                if (seenTitles.has(title))
-                    continue;
-                seenTitles.add(title);
-                const domain = chunk.web.domain ?? title;
-                sources.push({
-                    title,
-                    uri: chunk.web.uri ?? "",
-                    domain,
-                });
-            }
-        }
-    }
-    const searchQueries = grounding?.webSearchQueries ?? [];
-    return { answer, sources, searchQueries, cached: false };
-}
-// ── In-session cache ─────────────────────────────────────────────────────────
-const resultCache = new Map();
-function cacheKey(query) {
-    return query.toLowerCase().trim();
-}
-// ── Extension ────────────────────────────────────────────────────────────────
 export default function (pi) {
-    pi.registerTool({
-        name: "google_search",
-        label: "Google Search",
-        description: "Search the web using Google Search via Gemini. " +
-            "Returns an AI-synthesized answer grounded in Google Search results, plus source URLs. " +
-            "Use this when you need current information from the web: recent events, documentation, " +
-            "product details, technical references, news, etc. " +
-            "Requires GEMINI_API_KEY or Google login. Alternative to Brave-based search tools.",
-        promptSnippet: "Search the web via Google Search to get current information with sources",
-        promptGuidelines: [
-            "Use google_search when you need up-to-date web information that isn't in your training data.",
-            "Be specific with queries for better results, e.g. 'Next.js 15 app router migration guide' not just 'Next.js'.",
-            "The tool returns both an answer and source URLs. Cite sources when sharing results with the user.",
-            "Results are cached per-session, so repeated identical queries are free.",
-            "You can still use fetch_page to read a specific URL if needed after getting results from google_search.",
-        ],
-        parameters: Type.Object({
-            query: Type.String({
-                description: "The search query, e.g. 'latest Node.js LTS version' or 'how to configure Tailwind v4'",
-            }),
-            maxSources: Type.Optional(Type.Number({
-                description: "Maximum number of source URLs to include (default 5, max 10).",
-                minimum: 1,
-                maximum: 10,
-            })),
-        }),
-        async execute(_toolCallId, params, signal, _onUpdate, ctx) {
-            const startTime = Date.now();
-            const maxSources = Math.min(Math.max(params.maxSources ?? 5, 1), 10);
-            // Check for credentials
-            let oauthToken;
-            let projectId;
-            if (!process.env.GEMINI_API_KEY) {
-                const oauthRaw = await ctx.modelRegistry.getApiKeyForProvider("google-gemini-cli");
-                if (oauthRaw) {
-                    try {
-                        const parsed = JSON.parse(oauthRaw);
-                        oauthToken = parsed.token;
-                        projectId = parsed.projectId;
-                    }
-                    catch {
-                        // Fall through to error
-                    }
-                }
-            }
-            if (!process.env.GEMINI_API_KEY && (!oauthToken || !projectId)) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: "Error: No authentication found for Google Search. Please set GEMINI_API_KEY or log in via Google.\n\nExample: export GEMINI_API_KEY=your_key or use /login google",
-                        },
-                    ],
-                    isError: true,
-                    details: {
-                        query: params.query,
-                        sourceCount: 0,
-                        cached: false,
-                        durationMs: Date.now() - startTime,
-                        error: "auth_error: No credentials set",
-                    },
-                };
-            }
-            // Check cache
-            const key = cacheKey(params.query);
-            if (resultCache.has(key)) {
-                const cached = resultCache.get(key);
-                const output = formatOutput(cached, maxSources);
-                return {
-                    content: [{ type: "text", text: output }],
-                    details: {
-                        query: params.query,
-                        sourceCount: cached.sources.length,
-                        cached: true,
-                        durationMs: Date.now() - startTime,
-                    },
-                };
-            }
-            // Call Gemini with Google Search grounding
-            let result;
-            try {
-                if (process.env.GEMINI_API_KEY) {
-                    const ai = await getClient();
-                    // Add a 30-second timeout to prevent hanging (#1100)
-                    const timeoutController = new AbortController();
-                    const timeoutId = setTimeout(() => timeoutController.abort(), 30_000);
-                    const combinedSignal = signal
-                        ? AbortSignal.any([signal, timeoutController.signal])
-                        : timeoutController.signal;
-                    let response;
-                    try {
-                        response = await ai.models.generateContent({
-                            model: process.env.GEMINI_SEARCH_MODEL || "gemini-2.5-flash",
-                            contents: params.query,
-                            config: {
-                                tools: [{ googleSearch: {} }],
-                                abortSignal: combinedSignal,
-                            },
-                        });
-                    }
-                    finally {
-                        clearTimeout(timeoutId);
-                    }
-                    // Extract answer text
-                    const answer = response.text ?? "";
-                    // Extract grounding metadata
-                    const candidate = response.candidates?.[0];
-                    const grounding = candidate?.groundingMetadata;
-                    // Parse sources from grounding chunks
-                    const sources = [];
-                    const seenTitles = new Set();
-                    if (grounding?.groundingChunks) {
-                        for (const chunk of grounding.groundingChunks) {
-                            if (chunk.web) {
-                                const title = chunk.web.title ?? "Untitled";
-                                // Dedupe by title since URIs are redirect URLs that differ per call
-                                if (seenTitles.has(title))
-                                    continue;
-                                seenTitles.add(title);
-                                // domain field is not available via Gemini API, use title as fallback
-                                // (title is typically the domain name, e.g. "wikipedia.org")
-                                const domain = chunk.web.domain ?? title;
-                                sources.push({
-                                    title,
-                                    uri: chunk.web.uri ?? "",
-                                    domain,
-                                });
-                            }
-                        }
-                    }
-                    // Extract search queries Gemini actually performed
-                    const searchQueries = grounding?.webSearchQueries ?? [];
-                    result = { answer, sources, searchQueries, cached: false };
-                }
-                else {
-                    result = await searchWithOAuth(params.query, oauthToken, projectId, signal);
-                }
-            }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                let errorType = "api_error";
-                if (msg.includes("401") || msg.includes("UNAUTHENTICATED")) {
-                    errorType = "auth_error";
-                }
-                else if (msg.includes("429") || msg.includes("RESOURCE_EXHAUSTED") || msg.includes("quota")) {
-                    errorType = "rate_limit";
-                }
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `Google Search failed (${errorType}): ${msg}`,
-                        },
-                    ],
-                    isError: true,
-                    details: {
-                        query: params.query,
-                        sourceCount: 0,
-                        cached: false,
-                        durationMs: Date.now() - startTime,
-                        error: `${errorType}: ${msg}`,
-                    },
-                };
-            }
-            // Cache the result
-            resultCache.set(key, result);
-            // Format and truncate output
-            const rawOutput = formatOutput(result, maxSources);
-            const truncation = truncateHead(rawOutput, {
-                maxLines: DEFAULT_MAX_LINES,
-                maxBytes: DEFAULT_MAX_BYTES,
-            });
-            let finalText = truncation.content;
-            if (truncation.truncated) {
-                finalText +=
-                    `\n\n[Truncated: showing ${truncation.outputLines}/${truncation.totalLines} lines` +
-                        ` (${formatSize(truncation.outputBytes)} of ${formatSize(truncation.totalBytes)})]`;
-            }
-            return {
-                content: [{ type: "text", text: finalText }],
-                details: {
-                    query: params.query,
-                    sourceCount: result.sources.length,
-                    cached: false,
-                    durationMs: Date.now() - startTime,
-                },
-            };
-        },
-        renderCall(args, theme) {
-            let text = theme.fg("toolTitle", theme.bold("google_search "));
-            text += theme.fg("accent", `"${args.query}"`);
-            return new Text(text, 0, 0);
-        },
-        renderResult(result, { isPartial, expanded }, theme) {
-            const d = result.details;
-            if (isPartial)
-                return new Text(theme.fg("warning", "Searching Google..."), 0, 0);
-            if (result.isError || d?.error) {
-                return new Text(theme.fg("error", `Error: ${d?.error ?? "unknown"}`), 0, 0);
-            }
-            let text = theme.fg("success", `${d?.sourceCount ?? 0} sources`);
-            text += theme.fg("dim", ` (${d?.durationMs ?? 0}ms)`);
-            if (d?.cached)
-                text += theme.fg("dim", " · cached");
-            if (expanded) {
-                const content = result.content[0];
-                if (content?.type === "text") {
-                    const preview = content.text.split("\n").slice(0, 8).join("\n");
-                    text += "\n\n" + theme.fg("dim", preview);
-                    if (content.text.split("\n").length > 8) {
-                        text += "\n" + theme.fg("muted", "...");
-                    }
-                }
-            }
-            return new Text(text, 0, 0);
-        },
-    });
-    // ── Session cleanup ─────────────────────────────────────────────────────
-    pi.on("session_shutdown", async () => {
-        resultCache.clear();
-        client = null;
-    });
-    // ── Startup notification ─────────────────────────────────────────────────
     pi.on("session_start", async (_event, ctx) => {
-        if (process.env.GEMINI_API_KEY)
-            return;
-        const hasOAuth = await ctx.modelRegistry.authStorage.hasAuth("google-gemini-cli");
-        if (!hasOAuth) {
-            ctx.ui.notify("Google Search: No authentication set. Log in via Google or set GEMINI_API_KEY to use google_search.", "warning");
-        }
+        ctx.ui.notify("google_search has moved to @gsd-extensions/google-search. " +
+            "Install: gsd extensions install @gsd-extensions/google-search", "warning");
     });
 }
-// ── Output formatting ────────────────────────────────────────────────────────
-function formatOutput(result, maxSources) {
-    const lines = [];
-    // Answer
-    if (result.answer) {
-        lines.push(result.answer);
-    }
-    else {
-        lines.push("(No answer text returned from search)");
-    }
-    // Sources
-    if (result.sources.length > 0) {
-        lines.push("");
-        lines.push("Sources:");
-        const sourcesToShow = result.sources.slice(0, maxSources);
-        for (let i = 0; i < sourcesToShow.length; i++) {
-            const s = sourcesToShow[i];
-            lines.push(`[${i + 1}] ${s.title} - ${s.domain}`);
-            lines.push(`    ${s.uri}`);
-        }
-        if (result.sources.length > maxSources) {
-            lines.push(`(${result.sources.length - maxSources} more sources omitted)`);
-        }
-    }
-    else {
-        lines.push("");
-        lines.push("(No source URLs found in grounding metadata)");
-    }
-    // Search queries
-    if (result.searchQueries.length > 0) {
-        lines.push("");
-        lines.push(`Searches performed: ${result.searchQueries.map((q) => `"${q}"`).join(", ")}`);
-    }
-    return lines.join("\n");
-}

package/dist/resources/extensions/gsd/abandon-detect.js

@@ -0,0 +1,44 @@
+/**
+ * Abandon-milestone detection for rewrite-docs overrides (#3490).
+ *
+ * Isolated from auto-post-unit.ts so behavioral tests can import this module
+ * without pulling in the full post-unit handler graph (which transitively
+ * loads model-router, workflow engine, etc.).
+ */
+// Detect when a rewrite-docs override is about abandoning THE CURRENT
+// MILESTONE — not just any override containing an abandon verb. Naively
+// matching `/\b(abandon|cancel|drop|...)\b/` against override text produces
+// false positives on scope-change prose ("cancel the standup reminder",
+// "drop the dependency on X", "scrap the v1 design for the landing page").
+//
+// To qualify as an abandon-milestone signal, an override must contain both:
+//   1. An abandon-family verb (abandon|descope|cancel|shelve|drop|scrap)
+//   2. A milestone reference — either the literal word "milestone" or the
+//      current milestone ID — in the same override text.
+// Verb variants cover both US and UK inflections:
+//   cancel / canceled / canceling / cancelled / cancelling / cancels
+//   travel-style "l"-doubling also applies to shelve/drop/scrap.
+// "descope" also accepts "de-scope" and "de scope" (hyphen / space forms).
+const ABANDON_VERB_RE = /\b(abandon(?:ed|ing|s)?|de[-\s]?scope(?:d|s|ing)?|cancel(?:led|ling|ed|ing|s)?|shelve(?:d|s)?|shelving|drop(?:ped|ping|s)?|scrap(?:ped|ping|s)?)\b/i;
+/**
+ * Decide whether a set of active overrides indicates the current milestone
+ * should be parked. Pure function — no I/O, no imports beyond types.
+ */
+export function detectAbandonMilestone(overrides, currentMilestoneId) {
+    if (!currentMilestoneId) {
+        return { shouldPark: false, reason: "", matched: [] };
+    }
+    const escapedId = currentMilestoneId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const milestoneRefRe = new RegExp(`\\b(?:milestone|${escapedId})\\b`, "i");
+    const matched = overrides
+        .filter(o => ABANDON_VERB_RE.test(o.change) && milestoneRefRe.test(o.change))
+        .map(o => o.change);
+    if (matched.length === 0) {
+        return { shouldPark: false, reason: "", matched: [] };
+    }
+    return {
+        shouldPark: true,
+        reason: matched.join("; "),
+        matched,
+    };
+}

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

@@ -8,6 +8,7 @@
  * Imports from: auto/types
  */
 import { debugLog } from "../debug-logger.js";
+import { bumpTurnGeneration } from "./turn-epoch.js";
 // ─── Per-unit one-shot promise state ────────────────────────────────────────
 //
 // A single module-level resolve function scoped to the current unit execution.
@@ -56,6 +57,22 @@ export function resolveAgentEnd(event) {
 export function isSessionSwitchInFlight() {
     return _sessionSwitchInFlight;
 }
+// ─── bumpAndResolveSynthetic ────────────────────────────────────────────────
+/**
+ * Bump the turn epoch and synthetically resolve the pending unit promise —
+ * the exact sequence timeout recovery must perform when it advances past a
+ * timed-out unit. Using this helper enforces the invariant "bump iff we are
+ * actually superseding the turn" so a future caller cannot resolve without
+ * bumping (orphaned writes leak) or bump without resolving (next turn starts
+ * already stale).
+ *
+ * NOT to be used for steering retries that keep the same turn alive — those
+ * do not supersede the turn and must not bump.
+ */
+export function bumpAndResolveSynthetic(reason) {
+    bumpTurnGeneration(reason);
+    resolveAgentEnd({ messages: [], _synthetic: reason });
+}
 // ─── resolveAgentEndCancelled ─────────────────────────────────────────────────
 /**
  * Force-resolve the pending unit promise with { status: "cancelled" }.
@@ -66,6 +83,10 @@ export function isSessionSwitchInFlight() {
  */
 export function resolveAgentEndCancelled(errorContext) {
     if (_currentResolve) {
+        // Cancellation supersedes the in-flight turn the same way timeout
+        // recovery does — bump the turn epoch so any lingering writes from the
+        // cancelled turn drop themselves.
+        bumpTurnGeneration(`cancelled:${errorContext?.category ?? "unknown"}`);
         debugLog("resolveAgentEndCancelled", { status: "resolving-cancelled" });
         const r = _currentResolve;
         _currentResolve = null;
@@ -81,6 +102,9 @@ export function _resetPendingResolve() {
     _currentResolve = null;
     _sessionSwitchInFlight = false;
 }
+export function _hasPendingResolveForTest() {
+    return _currentResolve !== null;
+}
 /**
  * No-op for backward compatibility with tests that previously set the
  * active session. The module no longer holds a session reference.

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

@@ -4,7 +4,8 @@
  * Imports from: auto/types, auto/resolve
  */
 import { NEW_SESSION_TIMEOUT_MS } from "./session.js";
-import { _setCurrentResolve, _setSessionSwitchInFlight } from "./resolve.js";
+import { _clearCurrentResolve, _setCurrentResolve, _setSessionSwitchInFlight } from "./resolve.js";
+import { getCurrentTurnGeneration, runWithTurnGeneration, } from "./turn-epoch.js";
 import { debugLog } from "../debug-logger.js";
 import { logWarning } from "../workflow-logger.js";
 import { resolveAutoSupervisorConfig } from "../preferences.js";
@@ -117,6 +118,7 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
                 ready = false;
             }
             if (!ready) {
+                _clearCurrentResolve();
                 return {
                     status: "cancelled",
                     errorContext: {
@@ -128,6 +130,12 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
             }
         }
     }
+    // ── Capture turn generation for stale-write detection ──
+    // Any write site reached via the sendMessage → tool-call → await chain
+    // below sees this generation via AsyncLocalStorage. If a timeout recovery
+    // or cancellation bumps the generation while this turn is in flight, those
+    // writes see themselves as stale and self-drop.
+    const capturedTurnGen = getCurrentTurnGeneration();
     // ── Send the prompt ──
     debugLog("runUnit", { phase: "send-message", unitType, unitId });
     pi.sendMessage({ customType: "gsd-auto", content: prompt, display: s.verbose }, { triggerTurn: true });
@@ -143,7 +151,7 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
             resolve({ status: "cancelled", errorContext: { message: "Unit hard timeout — supervision may have failed", category: "timeout", isTransient: true } });
         }, UNIT_HARD_TIMEOUT_MS);
     });
-    const result = await Promise.race([unitPromise, timeoutResult]);
+    const result = await runWithTurnGeneration(capturedTurnGen, () => Promise.race([unitPromise, timeoutResult]));
     if (unitTimeoutHandle)
         clearTimeout(unitTimeoutHandle);
     debugLog("runUnit", {

package/dist/resources/extensions/gsd/auto/turn-epoch.js

@@ -0,0 +1,95 @@
+/**
+ * auto/turn-epoch.ts — Turn generation counter + AsyncLocalStorage-backed
+ * capture for stale-turn write dropping.
+ *
+ * Problem: when auto-timeout-recovery synthetically resolves a timed-out
+ * unit so the loop can advance, the original LLM turn keeps running in the
+ * background. Its subsequent writes (journal events, audit events, tool
+ * calls that flow through closeout) then race the replacement unit's
+ * writes. DB-level guards (complete-task/complete-slice) block double
+ * state transitions, but journal/audit/closeout side-effects still fire
+ * with fresh identifiers and pollute forensics.
+ *
+ * Containment: every time we decide a turn is done (timeout recovery,
+ * explicit cancellation), bump a module-level generation counter.
+ * Turn-aware call sites wrap their body in `runWithTurnGeneration`, which
+ * captures the generation into AsyncLocalStorage. Write sites deep in the
+ * stack call `isStaleWrite` — if the captured generation is older than
+ * current, the turn has been superseded and the write is dropped.
+ *
+ * Failure mode: if AsyncLocalStorage context is lost across some exotic
+ * async boundary (e.g. a native-side worker callback), the write site sees
+ * `no-store` and falls through to current behavior — the write proceeds
+ * normally. That is a safe default; the correctness regression is only
+ * "noisier forensics under rare boundary loss," not duplicated state.
+ */
+import { AsyncLocalStorage } from "node:async_hooks";
+import { debugLog } from "../debug-logger.js";
+let _currentGeneration = 0;
+const turnContext = new AsyncLocalStorage();
+/** Current turn generation. Mutated only by bumpTurnGeneration. */
+export function getCurrentTurnGeneration() {
+    return _currentGeneration;
+}
+/**
+ * Bump the turn generation and return the new value. Every caller should
+ * pass a short `reason` string so forensics can reconstruct why a given
+ * turn was marked stale.
+ */
+export function bumpTurnGeneration(reason) {
+    _currentGeneration += 1;
+    debugLog("turnEpoch.bump", { reason, newGeneration: _currentGeneration });
+    return _currentGeneration;
+}
+/**
+ * Run fn() with `capturedGen` attached to AsyncLocalStorage so that any
+ * write site reached from within fn() can check for staleness without
+ * parameter threading.
+ */
+export function runWithTurnGeneration(capturedGen, fn) {
+    return turnContext.run({ capturedGen }, fn);
+}
+/**
+ * True when the current async context was started at a turn generation
+ * older than the current one — meaning the turn has been superseded by
+ * recovery/cancellation since it began.
+ *
+ * Returns false when there is no captured generation (e.g. the write is
+ * happening outside any wrapped turn). That is the safe default: writes
+ * proceed as they did before this epoch was introduced.
+ */
+export function isStaleWrite(component) {
+    const store = turnContext.getStore();
+    if (!store)
+        return false;
+    const captured = store.capturedGen;
+    const current = _currentGeneration;
+    if (captured < current) {
+        debugLog("turnEpoch.stale", {
+            component: component ?? "unknown",
+            captured,
+            current,
+        });
+        return true;
+    }
+    return false;
+}
+/**
+ * Snapshot of both the captured turn generation and the current one.
+ * Used by closeoutUnit to persist an orphan-marker entry instead of
+ * silently skipping the full closeout on a stale turn.
+ */
+export function describeTurnEpoch() {
+    const store = turnContext.getStore();
+    const captured = store?.capturedGen ?? null;
+    const current = _currentGeneration;
+    return {
+        captured,
+        current,
+        stale: captured !== null && captured < current,
+    };
+}
+/** Test helper — resets module state so tests start from a known baseline. */
+export function _resetTurnEpoch() {
+    _currentGeneration = 0;
+}

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

@@ -319,6 +319,30 @@ export const DISPATCH_RULES = [
             };
         },
     },
+    {
+        name: "planning (require_slice_discussion) → pause for discussion (#3454)",
+        match: async ({ state, mid, basePath, prefs }) => {
+            if (state.phase !== "planning")
+                return null;
+            if (!prefs?.phases?.require_slice_discussion)
+                return null;
+            if (!state.activeSlice)
+                return null;
+            // Only pause if the slice has no context file yet (discussion not done).
+            // resolveSliceFile returns null when the file does not exist on disk,
+            // but cachedReaddir could return a stale hit — verify with existsSync
+            // so the guard is defence-in-depth and the contract is explicit at the
+            // call site.
+            const sliceContextFile = resolveSliceFile(basePath, mid, state.activeSlice.id, "CONTEXT");
+            if (sliceContextFile && existsSync(sliceContextFile))
+                return null; // discussion already done, proceed
+            return {
+                action: "stop",
+                reason: `Slice ${state.activeSlice.id} requires discussion before planning (require_slice_discussion is enabled). Run /gsd discuss to discuss this slice, then /gsd auto to resume.`,
+                level: "info",
+            };
+        },
+    },
     {
         // Keep this rule before the single-slice research rule so the multi-slice
         // path wins whenever 2+ slices are ready.

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

@@ -8,6 +8,6 @@
  */
 export { autoLoop, runUokKernelLoop, runLegacyAutoLoop } from "./auto/loop.js";
 export { isInfrastructureError, INFRA_ERROR_CODES } from "./auto/infra-errors.js";
-export { resolveAgentEnd, resolveAgentEndCancelled, isSessionSwitchInFlight, _resetPendingResolve, _setActiveSession } from "./auto/resolve.js";
+export { resolveAgentEnd, resolveAgentEndCancelled, isSessionSwitchInFlight, _hasPendingResolveForTest, _resetPendingResolve, _setActiveSession } from "./auto/resolve.js";
 export { detectStuck } from "./auto/detect-stuck.js";
 export { runUnit } from "./auto/run-unit.js";