gsd-pi 2.49.0 → 2.50.0-dev.d210a87

package/src/resources/extensions/gsd/worktree-resolver.ts

@@ -150,6 +150,18 @@ export class WorktreeResolver {
    */
   enterMilestone(milestoneId: string, ctx: NotifyCtx): void {
     this.validateMilestoneId(milestoneId);
+
+    // If worktree creation failed earlier this session, skip all future attempts
+    if (this.s.isolationDegraded) {
+      debugLog("WorktreeResolver", {
+        action: "enterMilestone",
+        milestoneId,
+        skipped: true,
+        reason: "isolation-degraded",
+      });
+      return;
+    }
+
     if (!this.deps.shouldUseWorktreeIsolation()) {
       debugLog("WorktreeResolver", {
         action: "enterMilestone",
@@ -220,6 +232,9 @@ export class WorktreeResolver {
         `Auto-worktree creation for ${milestoneId} failed: ${msg}. Continuing in project root.`,
         "warning",
       );
+      // Degrade isolation for the rest of this session so mergeAndExit
+      // doesn't try to merge a nonexistent worktree branch (#2483)
+      this.s.isolationDegraded = true;
       // Do NOT update s.basePath — stay in project root
     }
   }
@@ -304,6 +319,22 @@ export class WorktreeResolver {
    */
   mergeAndExit(milestoneId: string, ctx: NotifyCtx): void {
     this.validateMilestoneId(milestoneId);
+
+    // If worktree creation failed earlier, skip merge — work is on current branch (#2483)
+    if (this.s.isolationDegraded) {
+      debugLog("WorktreeResolver", {
+        action: "mergeAndExit",
+        milestoneId,
+        skipped: true,
+        reason: "isolation-degraded",
+      });
+      ctx.notify(
+        `Skipping worktree merge for ${milestoneId} — isolation was degraded (worktree creation failed earlier). Work is on the current branch.`,
+        "info",
+      );
+      return;
+    }
+
     const mode = this.deps.getIsolationMode();
     debugLog("WorktreeResolver", {
       action: "mergeAndExit",

package/src/resources/extensions/gsd/worktree.ts

@@ -235,8 +235,9 @@ export function getSliceBranchName(milestoneId: string, sliceId: string, worktre
   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.

package/src/resources/extensions/remote-questions/config.ts

@@ -2,7 +2,7 @@
  * Remote Questions — configuration resolution and validation
  */
 
-import { join } from "node:path";
+import { AuthStorage } from "@gsd/pi-coding-agent";
 import { loadEffectiveGSDPreferences, type RemoteQuestionsConfig } from "../gsd/preferences.js";
 import type { RemoteChannel } from "./types.js";
 
@@ -54,9 +54,7 @@ function hydrateRemoteTokensFromAuth(): void {
   if (needed.length === 0) return;
 
   try {
-    const { AuthStorage } = require("@gsd/pi-coding-agent") as typeof import("@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 {
@@ -72,7 +70,7 @@ function hydrateRemoteTokensFromAuth(): void {
       }
     }
   } catch {
-    // AuthStorage unavailable (unit tests, stripped build) — skip silently.
+    // AuthStorage unavailable or auth.json missing/unreadable — skip silently.
   }
 }
 

package/src/resources/extensions/search-the-web/native-search.ts

@@ -176,11 +176,15 @@ export function registerNativeSearchHooks(pi: NativeSearchPI): { getIsAnthropic:
     );
     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) {
@@ -192,8 +196,9 @@ export function registerNativeSearchHooks(pi: NativeSearchPI): { getIsAnthropic:
           }
         }
       }
-      // 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);

package/src/resources/extensions/search-the-web/tool-search.ts

@@ -106,14 +106,20 @@ 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(): void {
   lastSearchKey = "";
   consecutiveDupeCount = 0;
+  sessionTotalSearches = 0;
 }
 
 // Summarizer responses: max 50 entries, 15-minute TTL
@@ -357,6 +363,17 @@ export function registerSearchTool(pi: ExtensionAPI) {
         };
       }
 
+      // ------------------------------------------------------------------
+      // Session-level search budget
+      // ------------------------------------------------------------------
+      if (sessionTotalSearches >= MAX_SEARCHES_PER_SESSION) {
+        return {
+          content: [{ type: "text" as const, 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})` } satisfies Partial<SearchDetails>,
+        };
+      }
+
       const count = params.count ?? 5;
       const wantSummary = params.summary ?? false;
 
@@ -410,6 +427,9 @@ export function registerSearchTool(pi: ExtensionAPI) {
         consecutiveDupeCount = 1;
       }
 
+      // Count every search that passes the guards toward the session budget.
+      sessionTotalSearches++;
+
       const cached = searchCache.get(cacheKey);
 
       if (cached) {

package/src/resources/extensions/shared/rtk-session-stats.ts

@@ -0,0 +1,249 @@
+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;
+
+export interface RtkGainSummary {
+  totalCommands: number;
+  totalInput: number;
+  totalOutput: number;
+  totalSaved: number;
+  avgSavingsPct: number;
+  totalTimeMs: number;
+  avgTimeMs: number;
+}
+
+export interface RtkSessionSavings {
+  commands: number;
+  inputTokens: number;
+  outputTokens: number;
+  savedTokens: number;
+  savingsPct: number;
+  totalTimeMs: number;
+  avgTimeMs: number;
+  updatedAt: string;
+}
+
+interface BaselineEntry {
+  summary: RtkGainSummary;
+  createdAt: string;
+  updatedAt: string;
+}
+
+interface BaselineStore {
+  version: 1;
+  sessions: Record<string, BaselineEntry>;
+}
+
+let cachedSummary: { at: number; binaryPath: string; summary: RtkGainSummary | null } | null = null;
+
+function getRuntimeDir(basePath: string): string {
+  return join(gsdRoot(basePath), "runtime");
+}
+
+function getBaselinesPath(basePath: string): string {
+  return join(getRuntimeDir(basePath), SESSION_BASELINES_FILE);
+}
+
+function defaultStore(): BaselineStore {
+  return { version: 1, sessions: {} };
+}
+
+function loadBaselineStore(basePath: string): BaselineStore {
+  const path = getBaselinesPath(basePath);
+  if (!existsSync(path)) return defaultStore();
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf-8")) as Partial<BaselineStore>;
+    if (parsed.version !== 1 || typeof parsed.sessions !== "object" || parsed.sessions === null) {
+      return defaultStore();
+    }
+    return {
+      version: 1,
+      sessions: parsed.sessions as Record<string, BaselineEntry>,
+    };
+  } catch {
+    return defaultStore();
+  }
+}
+
+function saveBaselineStore(basePath: string, store: BaselineStore): void {
+  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: BaselineStore = {
+    version: 1,
+    sessions: Object.fromEntries(entries),
+  };
+
+  writeFileSync(getBaselinesPath(basePath), JSON.stringify(normalized, null, 2), "utf-8");
+}
+
+function normalizeSummary(raw: unknown): RtkGainSummary | null {
+  if (!raw || typeof raw !== "object") return null;
+  const summary = raw as Record<string, unknown>;
+  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: NodeJS.ProcessEnv = process.env): RtkGainSummary | null {
+  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 ?? "{}") as { summary?: unknown };
+    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: RtkGainSummary, baseline: RtkGainSummary): RtkSessionSavings {
+  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: string,
+  sessionId: string,
+  env: NodeJS.ProcessEnv = process.env,
+): RtkGainSummary | null {
+  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: string,
+  sessionId: string | null | undefined,
+  env: NodeJS.ProcessEnv = process.env,
+): RtkSessionSavings | null {
+  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: string, sessionId: string): void {
+  if (!sessionId) return;
+  const store = loadBaselineStore(basePath);
+  if (!(sessionId in store.sessions)) return;
+  delete store.sessions[sessionId];
+  saveBaselineStore(basePath, store);
+}
+
+export function formatRtkSavingsLabel(savings: RtkSessionSavings | null | undefined): string | null {
+  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/src/resources/extensions/shared/rtk.ts

@@ -0,0 +1,120 @@
+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: string | undefined): boolean {
+  if (!value) return false;
+  const normalized = value.trim().toLowerCase();
+  return normalized === "1" || normalized === "true" || normalized === "yes";
+}
+
+export function isRtkEnabled(env: NodeJS.ProcessEnv = process.env): boolean {
+  return !isTruthy(env[GSD_RTK_DISABLED_ENV]);
+}
+
+export function buildRtkEnv(env: NodeJS.ProcessEnv = process.env): NodeJS.ProcessEnv {
+  return {
+    ...env,
+    [RTK_TELEMETRY_DISABLED_ENV]: "1",
+  };
+}
+
+function getManagedRtkDir(env: NodeJS.ProcessEnv = process.env): string {
+  return join(env.GSD_HOME || join(homedir(), ".gsd"), "agent", "bin");
+}
+
+function getRtkBinaryName(platform: NodeJS.Platform = process.platform): string {
+  return platform === "win32" ? "rtk.exe" : "rtk";
+}
+
+function getPathValue(env: NodeJS.ProcessEnv): string | undefined {
+  const pathKey = Object.keys(env).find((key) => key.toLowerCase() === "path");
+  return pathKey ? env[pathKey] : env.PATH;
+}
+
+function resolvePathCandidates(pathValue: string | undefined): string[] {
+  if (!pathValue) return [];
+  return pathValue
+    .split(delimiter)
+    .map((part) => part.trim())
+    .filter(Boolean);
+}
+
+function resolveSystemRtkPath(pathValue: string | undefined, platform: NodeJS.Platform = process.platform): string | null {
+  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 interface ResolveRtkBinaryPathOptions {
+  binaryPath?: string;
+  env?: NodeJS.ProcessEnv;
+  pathValue?: string;
+  platform?: NodeJS.Platform;
+}
+
+export function resolveRtkBinaryPath(options: ResolveRtkBinaryPathOptions = {}): string | null {
+  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: string, env: NodeJS.ProcessEnv = process.env): string {
+  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/src/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