gsd-pi 2.77.0 → 2.78.0-dev.aeeb2ca00

package/dist/resources/extensions/cmux/index.js

@@ -1,5 +1,6 @@
 import { execFileSync, spawn } from "node:child_process";
 import { existsSync } from "node:fs";
+import { CMUX_CHANNELS } from "../shared/cmux-events.js";
 const DEFAULT_SOCKET_PATH = "/tmp/cmux.sock";
 const STATUS_KEY = "gsd";
 const lastSidebarSnapshots = new Map();
@@ -382,3 +383,22 @@ function extractSurfaceIds(value) {
     visit(value);
     return Array.from(found);
 }
+/**
+ * Wire event subscriptions so cmux reacts to gsd events.
+ * Called by the gsd extension during registration, passing pi.events.
+ */
+export function initCmuxEventListeners(events) {
+    events.on(CMUX_CHANNELS.SIDEBAR, (data) => {
+        const event = data;
+        if (event.action === "sync" && event.state) {
+            syncCmuxSidebar(event.preferences, event.state);
+        }
+        if (event.action === "clear") {
+            clearCmuxSidebar(event.preferences);
+        }
+    });
+    events.on(CMUX_CHANNELS.LOG, (data) => {
+        const event = data;
+        logCmuxEvent(event.preferences, event.message, event.level);
+    });
+}

package/dist/resources/extensions/github-sync/templates.js

@@ -116,3 +116,106 @@ export function formatSummaryComment(data) {
     }
     return lines.join("\n");
 }
+export const SWARM_LANE_LABELS = {
+    workflow: "lane/workflow",
+    state: "lane/state",
+    writer: "lane/writer",
+    uok: "lane/uok",
+    github: "lane/github",
+};
+function checkedList(items, emptyLabel) {
+    if (!items?.length)
+        return [`- [ ] ${emptyLabel}`];
+    return items.map((item) => `- [ ] ${item}`);
+}
+export function formatSwarmLanePRBody(data) {
+    const lines = [];
+    const laneLabel = SWARM_LANE_LABELS[data.lane.id];
+    lines.push("## Swarm lane");
+    lines.push("");
+    lines.push(`**Lane:** \`${laneLabel}\``);
+    lines.push(`**Branch:** \`${data.lane.branch}\``);
+    if (data.lane.owner)
+        lines.push(`**Owner:** ${data.lane.owner}`);
+    if (data.lane.latestCommit)
+        lines.push(`**Latest commit:** \`${data.lane.latestCommit}\``);
+    lines.push("");
+    lines.push("## Impact area");
+    lines.push("");
+    lines.push(data.impactArea);
+    lines.push("");
+    lines.push("## Changed contracts");
+    lines.push(...checkedList(data.lane.changedContracts, "No shared contracts changed"));
+    lines.push("");
+    lines.push("## Transition risks");
+    lines.push(...checkedList(data.transitionRisks, "No transition risks identified"));
+    lines.push("");
+    lines.push("## Rollback plan");
+    lines.push(...checkedList(data.rollbackPlan, "Revert this lane PR"));
+    lines.push("");
+    lines.push("## Test evidence");
+    lines.push(...checkedList(data.lane.testEvidence, "Test evidence pending"));
+    lines.push("");
+    if (data.lane.blockers?.length) {
+        lines.push("## Blockers");
+        for (const blocker of data.lane.blockers)
+            lines.push(`- ${blocker}`);
+        lines.push("");
+    }
+    if (data.linkedIssue) {
+        lines.push(`Closes #${data.linkedIssue}`);
+        lines.push("");
+    }
+    lines.push("---");
+    lines.push("*Auto-generated by GSD GitHub Sync swarm routines*");
+    return lines.join("\n");
+}
+export function formatSwarmReleaseChecklistBody(data) {
+    const lines = [];
+    lines.push(`# UOK Swarm Release Checklist`);
+    lines.push("");
+    lines.push(`**Integration branch:** \`${data.integrationBranch}\``);
+    lines.push("");
+    lines.push("## Lane summary");
+    lines.push("");
+    lines.push("| Lane | Branch | Owner | Commit | Status |");
+    lines.push("|------|--------|-------|--------|--------|");
+    for (const lane of data.lanes) {
+        const owner = lane.owner ?? "";
+        const commit = lane.latestCommit ? `\`${lane.latestCommit}\`` : "";
+        const status = lane.blockers?.length ? "blocked" : "ready";
+        lines.push(`| \`${SWARM_LANE_LABELS[lane.id]}\` | \`${lane.branch}\` | ${owner} | ${commit} | ${status} |`);
+    }
+    lines.push("");
+    lines.push("## Required evidence");
+    lines.push("- [ ] Changed contracts summarized");
+    lines.push("- [ ] Transition matrix diff attached or linked");
+    lines.push("- [ ] Writer sequence proof attached or linked");
+    lines.push("- [ ] UOK parity report attached or linked");
+    lines.push("- [ ] Rollback drill evidence attached or linked");
+    lines.push("");
+    if (data.requiredChecks?.length) {
+        lines.push("## Required checks");
+        for (const check of data.requiredChecks)
+            lines.push(`- [ ] ${check}`);
+        lines.push("");
+    }
+    lines.push("## Parity report");
+    lines.push(data.parityReport ?? "Pending.");
+    lines.push("");
+    lines.push("## Rollback drill");
+    lines.push(data.rollbackDrill ?? "Pending.");
+    lines.push("");
+    lines.push("## Open risks");
+    if (data.openRisks?.length) {
+        for (const risk of data.openRisks)
+            lines.push(`- ${risk}`);
+    }
+    else {
+        lines.push("None.");
+    }
+    lines.push("");
+    lines.push("---");
+    lines.push("*Auto-generated by GSD GitHub Sync swarm routines*");
+    return lines.join("\n");
+}

package/dist/resources/extensions/google-search/extension-manifest.json

@@ -1,12 +1,13 @@
 {
   "id": "google-search",
-  "name": "Google Search",
+  "name": "Google Search (deprecated stub)",
   "version": "1.0.0",
-  "description": "Web search via Google with AI-synthesized answers and source citations",
+  "description": "Deprecation stub. The google_search tool moved to @gsd-extensions/google-search. Install with: gsd extensions install @gsd-extensions/google-search",
   "tier": "bundled",
+  "deprecated": true,
   "requires": { "platform": ">=2.29.0" },
   "provides": {
-    "tools": ["google_search"],
-    "hooks": ["session_start", "session_shutdown"]
+    "tools": [],
+    "hooks": ["session_start"]
   }
 }

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

@@ -1,379 +1,7 @@
-/**
- * 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 is being extracted to @gsd-extensions/google-search " +
+            "(not yet published to npm). This stub will be replaced once the " +
+            "package is available. No action needed for now.", "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,
+    };
+}