gsd-pi 2.49.0 → 2.50.0-dev.d210a87

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

@@ -220,8 +220,9 @@ export function getSliceBranchName(milestoneId, sliceId, worktreeName) {
     }
     return `gsd/${milestoneId}/${sliceId}`;
 }
-/** Regex that matches both plain and worktree-namespaced slice branches. */
-export const SLICE_BRANCH_RE = /^gsd\/(?:([a-zA-Z0-9_-]+)\/)?(M\d+(?:-[a-z0-9]{6})?)\/(S\d+)$/;
+/** Re-export for backward compatibility — canonical definition in branch-patterns.ts */
+export { SLICE_BRANCH_RE } from "./branch-patterns.js";
+import { SLICE_BRANCH_RE } from "./branch-patterns.js";
 /**
  * Parse a slice branch name into its components.
  * Handles both `gsd/M001/S01` and `gsd/myworktree/M001/S01`.

package/dist/resources/extensions/remote-questions/config.js

@@ -1,7 +1,7 @@
 /**
  * Remote Questions — configuration resolution and validation
  */
-import { join } from "node:path";
+import { AuthStorage } from "@gsd/pi-coding-agent";
 import { loadEffectiveGSDPreferences } from "../gsd/preferences.js";
 const ENV_KEYS = {
     slack: "SLACK_BOT_TOKEN",
@@ -39,9 +39,7 @@ function hydrateRemoteTokensFromAuth() {
     if (needed.length === 0)
         return;
     try {
-        const { AuthStorage } = require("@gsd/pi-coding-agent");
-        const authPath = join(process.env.HOME ?? "~", ".gsd", "agent", "auth.json");
-        const auth = AuthStorage.create(authPath);
+        const auth = AuthStorage.create();
         for (const [providerId, envVar] of needed) {
             try {
                 const creds = auth.getCredentialsForProvider(providerId);
@@ -56,7 +54,7 @@ function hydrateRemoteTokensFromAuth() {
         }
     }
     catch {
-        // AuthStorage unavailable (unit tests, stripped build) — skip silently.
+        // AuthStorage unavailable or auth.json missing/unreadable — skip silently.
     }
 }
 export function resolveRemoteConfig() {

package/dist/resources/extensions/search-the-web/native-search.js

@@ -148,11 +148,15 @@ export function registerNativeSearchHooks(pi) {
         // the model and causes it to pick custom tools which can fail with network errors.
         tools = tools.filter((t) => !CUSTOM_SEARCH_TOOL_NAMES.includes(t.name));
         payload.tools = tools;
-        // ── Session-level search budget (#1309) ──────────────────────────────
+        // ── Session-level search budget (#1309, #compaction-safe) ─────────────
         // Count web_search_tool_result blocks in the conversation history to
         // determine how many native searches have already been used this session.
         // The Anthropic API's max_uses resets per request, so without this guard,
         // pause_turn → resubmit cycles allow unlimited total searches.
+        //
+        // Use the monotonic high-water mark: take the max of the history count
+        // and the running counter. This prevents budget resets when context
+        // compaction removes web_search_tool_result blocks from history.
         if (Array.isArray(messages)) {
             let historySearchCount = 0;
             for (const msg of messages) {
@@ -165,8 +169,9 @@ export function registerNativeSearchHooks(pi) {
                     }
                 }
             }
-            // Sync counter from history (handles session restore / context replay)
-            sessionSearchCount = historySearchCount;
+            // High-water mark: never decrease the counter, even if compaction
+            // removes web_search_tool_result blocks from the visible history.
+            sessionSearchCount = Math.max(sessionSearchCount, historySearchCount);
         }
         const remaining = Math.max(0, MAX_NATIVE_SEARCHES_PER_SESSION - sessionSearchCount);
         if (remaining <= 0) {

package/dist/resources/extensions/search-the-web/tool-search.js

@@ -27,13 +27,18 @@ const searchCache = new LRUTTLCache({ max: 100, ttlMs: 600_000 });
 searchCache.startPurgeInterval(60_000);
 // Consecutive duplicate search guard (#949)
 // Tracks recent query keys to detect and break search loops.
-const MAX_CONSECUTIVE_DUPES = 3;
+const MAX_CONSECUTIVE_DUPES = 1;
 let lastSearchKey = "";
 let consecutiveDupeCount = 0;
-/** Reset session-scoped duplicate-search guard state. */
+// Session-level total search budget (all queries, not just duplicates).
+// Prevents unbounded search accumulation across varied queries.
+const MAX_SEARCHES_PER_SESSION = 15;
+let sessionTotalSearches = 0;
+/** Reset session-scoped search guard state (both duplicate and budget). */
 export function resetSearchLoopGuardState() {
     lastSearchKey = "";
     consecutiveDupeCount = 0;
+    sessionTotalSearches = 0;
 }
 // Summarizer responses: max 50 entries, 15-minute TTL
 const summarizerCache = new LRUTTLCache({ max: 50, ttlMs: 900_000 });
@@ -221,6 +226,16 @@ export function registerSearchTool(pi) {
                     details: { errorKind: "auth_error", error: "No search API key set" },
                 };
             }
+            // ------------------------------------------------------------------
+            // Session-level search budget
+            // ------------------------------------------------------------------
+            if (sessionTotalSearches >= MAX_SEARCHES_PER_SESSION) {
+                return {
+                    content: [{ type: "text", text: `⚠️ Search budget exhausted: ${sessionTotalSearches}/${MAX_SEARCHES_PER_SESSION} searches used this session. The information you need should already be in previous search results. Stop searching and use those results to proceed with your task.` }],
+                    isError: true,
+                    details: { errorKind: "budget_exhausted", error: `Session search budget exhausted (${MAX_SEARCHES_PER_SESSION})` },
+                };
+            }
             const count = params.count ?? 5;
             const wantSummary = params.summary ?? false;
             // ------------------------------------------------------------------
@@ -271,6 +286,8 @@ export function registerSearchTool(pi) {
                 lastSearchKey = cacheKey;
                 consecutiveDupeCount = 1;
             }
+            // Count every search that passes the guards toward the session budget.
+            sessionTotalSearches++;
             const cached = searchCache.get(cacheKey);
             if (cached) {
                 const limited = cached.results.slice(0, count);

package/dist/resources/extensions/shared/rtk-session-stats.js

@@ -0,0 +1,189 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { gsdRoot } from "../gsd/paths.js";
+import { formatTokenCount } from "./format-utils.js";
+import { buildRtkEnv, isRtkEnabled, resolveRtkBinaryPath } from "./rtk.js";
+const SESSION_BASELINES_FILE = "rtk-session-baselines.json";
+const CURRENT_SUMMARY_TTL_MS = 15_000;
+const CURRENT_SUMMARY_TIMEOUT_MS = 5_000;
+const MAX_BASELINE_SESSIONS = 200;
+let cachedSummary = null;
+function getRuntimeDir(basePath) {
+    return join(gsdRoot(basePath), "runtime");
+}
+function getBaselinesPath(basePath) {
+    return join(getRuntimeDir(basePath), SESSION_BASELINES_FILE);
+}
+function defaultStore() {
+    return { version: 1, sessions: {} };
+}
+function loadBaselineStore(basePath) {
+    const path = getBaselinesPath(basePath);
+    if (!existsSync(path))
+        return defaultStore();
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf-8"));
+        if (parsed.version !== 1 || typeof parsed.sessions !== "object" || parsed.sessions === null) {
+            return defaultStore();
+        }
+        return {
+            version: 1,
+            sessions: parsed.sessions,
+        };
+    }
+    catch {
+        return defaultStore();
+    }
+}
+function saveBaselineStore(basePath, store) {
+    const runtimeDir = getRuntimeDir(basePath);
+    mkdirSync(runtimeDir, { recursive: true });
+    const entries = Object.entries(store.sessions)
+        .sort((left, right) => right[1].updatedAt.localeCompare(left[1].updatedAt))
+        .slice(0, MAX_BASELINE_SESSIONS);
+    const normalized = {
+        version: 1,
+        sessions: Object.fromEntries(entries),
+    };
+    writeFileSync(getBaselinesPath(basePath), JSON.stringify(normalized, null, 2), "utf-8");
+}
+function normalizeSummary(raw) {
+    if (!raw || typeof raw !== "object")
+        return null;
+    const summary = raw;
+    return {
+        totalCommands: Number(summary.total_commands ?? 0),
+        totalInput: Number(summary.total_input ?? 0),
+        totalOutput: Number(summary.total_output ?? 0),
+        totalSaved: Number(summary.total_saved ?? 0),
+        avgSavingsPct: Number(summary.avg_savings_pct ?? 0),
+        totalTimeMs: Number(summary.total_time_ms ?? 0),
+        avgTimeMs: Number(summary.avg_time_ms ?? 0),
+    };
+}
+export function readCurrentRtkGainSummary(env = process.env) {
+    if (!isRtkEnabled(env))
+        return null;
+    const binaryPath = resolveRtkBinaryPath({ env });
+    if (!binaryPath)
+        return null;
+    if (cachedSummary &&
+        cachedSummary.binaryPath === binaryPath &&
+        Date.now() - cachedSummary.at < CURRENT_SUMMARY_TTL_MS) {
+        return cachedSummary.summary;
+    }
+    const result = spawnSync(binaryPath, ["gain", "--all", "--format", "json"], {
+        encoding: "utf-8",
+        env: buildRtkEnv(env),
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: CURRENT_SUMMARY_TIMEOUT_MS,
+        // .cmd/.bat wrappers (used by fake-rtk in tests) require shell:true on Windows
+        shell: /\.(cmd|bat)$/i.test(binaryPath),
+    });
+    if (result.error || result.status !== 0) {
+        cachedSummary = { at: Date.now(), binaryPath, summary: null };
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(result.stdout ?? "{}");
+        const summary = normalizeSummary(parsed.summary ?? null);
+        cachedSummary = { at: Date.now(), binaryPath, summary };
+        return summary;
+    }
+    catch {
+        cachedSummary = { at: Date.now(), binaryPath, summary: null };
+        return null;
+    }
+}
+function computeSavingsDelta(current, baseline) {
+    const commands = Math.max(0, current.totalCommands - baseline.totalCommands);
+    const inputTokens = Math.max(0, current.totalInput - baseline.totalInput);
+    const outputTokens = Math.max(0, current.totalOutput - baseline.totalOutput);
+    const savedTokens = Math.max(0, current.totalSaved - baseline.totalSaved);
+    const totalTimeMs = Math.max(0, current.totalTimeMs - baseline.totalTimeMs);
+    const avgTimeMs = commands > 0 ? Math.round(totalTimeMs / commands) : 0;
+    const savingsPct = inputTokens > 0 ? (savedTokens / inputTokens) * 100 : 0;
+    return {
+        commands,
+        inputTokens,
+        outputTokens,
+        savedTokens,
+        savingsPct,
+        totalTimeMs,
+        avgTimeMs,
+        updatedAt: new Date().toISOString(),
+    };
+}
+export function ensureRtkSessionBaseline(basePath, sessionId, env = process.env) {
+    if (!sessionId)
+        return null;
+    const current = readCurrentRtkGainSummary(env);
+    if (!current)
+        return null;
+    const store = loadBaselineStore(basePath);
+    const existing = store.sessions[sessionId];
+    if (existing)
+        return existing.summary;
+    const now = new Date().toISOString();
+    store.sessions[sessionId] = {
+        summary: current,
+        createdAt: now,
+        updatedAt: now,
+    };
+    saveBaselineStore(basePath, store);
+    return current;
+}
+export function getRtkSessionSavings(basePath, sessionId, env = process.env) {
+    if (!sessionId)
+        return null;
+    const current = readCurrentRtkGainSummary(env);
+    if (!current)
+        return null;
+    const store = loadBaselineStore(basePath);
+    const existing = store.sessions[sessionId];
+    if (!existing) {
+        const now = new Date().toISOString();
+        store.sessions[sessionId] = {
+            summary: current,
+            createdAt: now,
+            updatedAt: now,
+        };
+        saveBaselineStore(basePath, store);
+        return computeSavingsDelta(current, current);
+    }
+    if (current.totalCommands < existing.summary.totalCommands ||
+        current.totalInput < existing.summary.totalInput ||
+        current.totalSaved < existing.summary.totalSaved) {
+        const now = new Date().toISOString();
+        store.sessions[sessionId] = {
+            summary: current,
+            createdAt: existing.createdAt,
+            updatedAt: now,
+        };
+        saveBaselineStore(basePath, store);
+        return computeSavingsDelta(current, current);
+    }
+    existing.updatedAt = new Date().toISOString();
+    saveBaselineStore(basePath, store);
+    return computeSavingsDelta(current, existing.summary);
+}
+export function clearRtkSessionBaseline(basePath, sessionId) {
+    if (!sessionId)
+        return;
+    const store = loadBaselineStore(basePath);
+    if (!(sessionId in store.sessions))
+        return;
+    delete store.sessions[sessionId];
+    saveBaselineStore(basePath, store);
+}
+export function formatRtkSavingsLabel(savings) {
+    if (!savings)
+        return null;
+    if (savings.commands <= 0)
+        return "rtk: waiting for shell usage";
+    if (savings.inputTokens <= 0 && savings.outputTokens <= 0) {
+        return `rtk: active (${savings.commands} cmd${savings.commands === 1 ? "" : "s"})`;
+    }
+    return `rtk: ${formatTokenCount(savings.savedTokens)} saved (${Math.round(savings.savingsPct)}%)`;
+}

package/dist/resources/extensions/shared/rtk.js

@@ -0,0 +1,100 @@
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { delimiter, join } from "node:path";
+const GSD_RTK_PATH_ENV = "GSD_RTK_PATH";
+const GSD_RTK_DISABLED_ENV = "GSD_RTK_DISABLED";
+const RTK_TELEMETRY_DISABLED_ENV = "RTK_TELEMETRY_DISABLED";
+const RTK_REWRITE_TIMEOUT_MS = 5_000;
+function isTruthy(value) {
+    if (!value)
+        return false;
+    const normalized = value.trim().toLowerCase();
+    return normalized === "1" || normalized === "true" || normalized === "yes";
+}
+export function isRtkEnabled(env = process.env) {
+    return !isTruthy(env[GSD_RTK_DISABLED_ENV]);
+}
+export function buildRtkEnv(env = process.env) {
+    return {
+        ...env,
+        [RTK_TELEMETRY_DISABLED_ENV]: "1",
+    };
+}
+function getManagedRtkDir(env = process.env) {
+    return join(env.GSD_HOME || join(homedir(), ".gsd"), "agent", "bin");
+}
+function getRtkBinaryName(platform = process.platform) {
+    return platform === "win32" ? "rtk.exe" : "rtk";
+}
+function getPathValue(env) {
+    const pathKey = Object.keys(env).find((key) => key.toLowerCase() === "path");
+    return pathKey ? env[pathKey] : env.PATH;
+}
+function resolvePathCandidates(pathValue) {
+    if (!pathValue)
+        return [];
+    return pathValue
+        .split(delimiter)
+        .map((part) => part.trim())
+        .filter(Boolean);
+}
+function resolveSystemRtkPath(pathValue, platform = process.platform) {
+    const candidates = platform === "win32"
+        ? ["rtk.exe", "rtk.cmd", "rtk.bat", "rtk"]
+        : ["rtk"];
+    for (const dir of resolvePathCandidates(pathValue)) {
+        for (const candidate of candidates) {
+            const fullPath = join(dir, candidate);
+            if (existsSync(fullPath)) {
+                return fullPath;
+            }
+        }
+    }
+    return null;
+}
+export function resolveRtkBinaryPath(options = {}) {
+    const env = options.env ?? process.env;
+    const platform = options.platform ?? process.platform;
+    const explicitPath = options.binaryPath ?? env[GSD_RTK_PATH_ENV];
+    if (explicitPath && existsSync(explicitPath)) {
+        return explicitPath;
+    }
+    const managedDir = getManagedRtkDir(env);
+    const managedPath = join(managedDir, getRtkBinaryName(platform));
+    if (existsSync(managedPath)) {
+        return managedPath;
+    }
+    // On Windows, also check for rtk.cmd in the managed dir (used by test fake RTK
+    // and any wrapper-style installs where a .cmd launcher accompanies the binary).
+    if (platform === "win32") {
+        const managedCmd = join(managedDir, "rtk.cmd");
+        if (existsSync(managedCmd)) {
+            return managedCmd;
+        }
+    }
+    return resolveSystemRtkPath(options.pathValue ?? getPathValue(env), platform);
+}
+export function rewriteCommandWithRtk(command, env = process.env) {
+    if (!command.trim())
+        return command;
+    if (!isRtkEnabled(env))
+        return command;
+    const binaryPath = resolveRtkBinaryPath({ env });
+    if (!binaryPath)
+        return command;
+    const result = spawnSync(binaryPath, ["rewrite", command], {
+        encoding: "utf-8",
+        env: buildRtkEnv(env),
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: RTK_REWRITE_TIMEOUT_MS,
+        // .cmd/.bat wrappers (used by fake-rtk in tests) require shell:true on Windows
+        shell: /\.(cmd|bat)$/i.test(binaryPath),
+    });
+    if (result.error)
+        return command;
+    if (result.status !== 0 && result.status !== 3)
+        return command;
+    const rewritten = (result.stdout ?? "").trimEnd();
+    return rewritten || command;
+}

package/dist/resources/skills/github-workflows/references/gh/SKILL.md

@@ -103,9 +103,12 @@ gh issue list -R gsd-build/gsd-2
 gh issue list -R gsd-build/gsd-2 --label "priority:p1" --state open
 
 # Create issue with labels and milestone
+# NOTE: Do NOT use labels for issue classification (bug, feature, etc.)
+# Use labels for metadata (priority, status, auto-generated) only.
+# Issue classification uses GitHub Issue Types, set via GraphQL after creation.
 gh issue create -R gsd-build/gsd-2 \
   --title "feat: add feature X" \
-  --label "priority:p1" --label "type:feature" \
+  --label "priority:p1" \
   --milestone "v1.0"
 
 # View issue
@@ -120,6 +123,24 @@ gh issue edit <number> -R gsd-build/gsd-2 \
   --remove-label "status:needs-grooming"
 ```
 
+### Issue Types (Classification)
+
+`gh issue create` has no `--type` flag. Issue types (Bug, Feature Request, etc.) are set via GraphQL after creation:
+
+```bash
+# Step 1: Create the issue (returns URL)
+ISSUE_URL=$(gh issue create -R gsd-build/gsd-2 \
+  --title "..." --body "...")
+
+# Step 2: Set the issue type via GraphQL
+ISSUE_NUM=$(echo "$ISSUE_URL" | grep -oE '[0-9]+$')
+ISSUE_ID=$(gh api graphql -f query='{ repository(owner:"gsd-build",name:"gsd-2") { issue(number:'"$ISSUE_NUM"') { id } } }' --jq '.data.repository.issue.id')
+TYPE_ID=$(gh api graphql -f query='{ repository(owner:"gsd-build",name:"gsd-2") { issueTypes(first:20) { nodes { id name } } } }' --jq '.data.repository.issueTypes.nodes[] | select(.name=="Bug") | .id')
+gh api graphql -f query='mutation { updateIssue(input:{id:"'"$ISSUE_ID"'",issueTypeId:"'"$TYPE_ID"'"}) { issue { number } } }'
+```
+
+Replace `"Bug"` with the appropriate type name (`"Feature Request"`, `"Task"`, etc.).
+
 ### Labels
 
 ```bash

package/dist/rtk.d.ts

@@ -0,0 +1,52 @@
+import { spawnSync } from "node:child_process";
+export declare const RTK_VERSION = "0.33.1";
+export declare const GSD_RTK_DISABLED_ENV = "GSD_RTK_DISABLED";
+export declare const GSD_SKIP_RTK_INSTALL_ENV = "GSD_SKIP_RTK_INSTALL";
+export declare const GSD_RTK_PATH_ENV = "GSD_RTK_PATH";
+export declare const RTK_TELEMETRY_DISABLED_ENV = "RTK_TELEMETRY_DISABLED";
+export interface EnsureRtkOptions {
+    targetDir?: string;
+    allowDownload?: boolean;
+    env?: NodeJS.ProcessEnv;
+    pathValue?: string;
+    releaseVersion?: string;
+    log?: (message: string) => void;
+}
+export interface EnsureRtkResult {
+    enabled: boolean;
+    supported: boolean;
+    available: boolean;
+    source: "disabled" | "unsupported" | "managed" | "system" | "downloaded" | "missing";
+    binaryPath?: string;
+    reason?: string;
+}
+export declare function isRtkEnabled(env?: NodeJS.ProcessEnv): boolean;
+export declare function getManagedRtkDir(env?: NodeJS.ProcessEnv): string;
+export declare function getRtkBinaryName(platform?: NodeJS.Platform): string;
+export declare function getManagedRtkPath(platform?: NodeJS.Platform, targetDir?: string): string;
+export declare function prependPathEntry(env: NodeJS.ProcessEnv, entry: string): NodeJS.ProcessEnv;
+export declare function applyRtkProcessEnv(env?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+export declare function buildRtkEnv(env?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+export declare function resolveRtkAssetName(platform: NodeJS.Platform, arch: string, version?: string): string | null;
+export interface ResolveRtkBinaryPathOptions {
+    binaryPath?: string;
+    env?: NodeJS.ProcessEnv;
+    pathValue?: string;
+    platform?: NodeJS.Platform;
+    targetDir?: string;
+}
+export declare function resolveRtkBinaryPath(options?: ResolveRtkBinaryPathOptions): string | null;
+export interface RewriteCommandOptions {
+    binaryPath?: string;
+    env?: NodeJS.ProcessEnv;
+    timeoutMs?: number;
+    spawnSyncImpl?: typeof spawnSync;
+}
+export declare function rewriteCommandWithRtk(command: string, options?: RewriteCommandOptions): string;
+export interface ValidateRtkBinaryOptions {
+    spawnSyncImpl?: typeof spawnSync;
+    env?: NodeJS.ProcessEnv;
+}
+export declare function validateRtkBinary(binaryPath: string, options?: ValidateRtkBinaryOptions): boolean;
+export declare function ensureRtkAvailable(options?: EnsureRtkOptions): Promise<EnsureRtkResult>;
+export declare function bootstrapRtk(options?: EnsureRtkOptions): Promise<EnsureRtkResult>;