gsd-pi 2.50.0 → 2.51.0-dev.ae8f7cb

package/src/resources/extensions/gsd/tests/terminated-transient.test.ts

@@ -47,3 +47,27 @@ test("#2309: rate limits are still transient", () => {
   assert.equal(rlResult.isTransient, true, "rate limits are still transient");
   assert.equal(rlResult.isRateLimit, true, "rate limits are flagged as rate limits");
 });
+
+// --- #2572: stream-truncation JSON parse errors should be transient ---
+
+test("#2572: 'Expected double-quoted property name' (truncated stream) is transient", () => {
+  const result = classifyProviderError("Expected double-quoted property name in JSON at position 23 (line 1 column 24)");
+  assert.equal(result.isTransient, true, "truncated-stream JSON parse error should be transient");
+  assert.equal(result.isRateLimit, false, "not a rate limit");
+  assert.equal(result.suggestedDelayMs, 15_000, "should use 15s backoff like connection errors");
+});
+
+test("#2572: 'Unexpected end of JSON input' (truncated stream) is transient", () => {
+  const result = classifyProviderError("Unexpected end of JSON input");
+  assert.equal(result.isTransient, true, "'Unexpected end of JSON input' should be transient");
+});
+
+test("#2572: 'Unexpected token' in JSON (truncated stream) is transient", () => {
+  const result = classifyProviderError("Unexpected token < in JSON at position 0");
+  assert.equal(result.isTransient, true, "'Unexpected token in JSON' should be transient");
+});
+
+test("#2572: 'SyntaxError' with JSON context (truncated stream) is transient", () => {
+  const result = classifyProviderError("SyntaxError: JSON.parse: unexpected character at line 1 column 1");
+  assert.equal(result.isTransient, true, "'SyntaxError...JSON' should be transient");
+});

package/src/resources/extensions/gsd/tests/triage-dispatch.test.ts

@@ -119,7 +119,7 @@ test("dispatch: triage dispatch keeps the loop in continue mode", () => {
     postUnitSrc.indexOf("// ── Quick-task dispatch"),
   );
   assert.ok(
-    triageBlock.includes('return "continue"'),
+    triageBlock.includes('return "continue"') || triageBlock.includes("return enqueueSidecar("),
     "triage dispatch should return 'continue' after enqueuing sidecar work",
   );
 });
@@ -320,7 +320,7 @@ test("dispatch: quick-task dispatch keeps the loop in continue mode", () => {
     postUnitSrc.indexOf("if (s.stepMode)"),
   );
   assert.ok(
-    quickTaskSection.includes('return "continue"'),
+    quickTaskSection.includes('return "continue"') || quickTaskSection.includes("return enqueueSidecar("),
     "quick-task dispatch should return 'continue' after enqueuing sidecar work",
   );
 });

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

@@ -157,6 +157,8 @@ export interface Summary {
   whatHappened: string;
   deviations: string;
   filesModified: FileModified[];
+  followUps: string;
+  knownLimitations: string;
 }
 
 // ─── Continue-Here ─────────────────────────────────────────────────────────

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

@@ -7,6 +7,7 @@ import type { ExtensionCommandContext, ExtensionAPI } from "@gsd/pi-coding-agent
 import { existsSync, readFileSync, writeFileSync, unlinkSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { nativeRevertCommit, nativeRevertAbort } from "./native-git-bridge.js";
+import { parseUnitId } from "./unit-id.js";
 import { deriveState } from "./state.js";
 import { invalidateAllCaches } from "./cache.js";
 import { gsdRoot, resolveTasksDir, resolveSlicePath, resolveTaskFile, buildTaskFileName, buildSliceFileName } from "./paths.js";
@@ -65,11 +66,11 @@ export async function handleUndo(args: string, ctx: ExtensionCommandContext, _pi
   }
 
   // 1. Delete summary artifact
-  const parts = unitId.split("/");
+  const { milestone, slice, task } = parseUnitId(unitId);
   let summaryRemoved = false;
-  if (parts.length === 3) {
+  if (task !== undefined && slice !== undefined) {
     // Task-level: M001/S01/T01
-    const [mid, sid, tid] = parts;
+    const [mid, sid, tid] = [milestone, slice, task];
     const tasksDir = resolveTasksDir(basePath, mid, sid);
     if (tasksDir) {
       const summaryFile = join(tasksDir, buildTaskFileName(tid, "SUMMARY"));
@@ -78,9 +79,9 @@ export async function handleUndo(args: string, ctx: ExtensionCommandContext, _pi
         summaryRemoved = true;
       }
     }
-  } else if (parts.length === 2) {
+  } else if (slice !== undefined) {
     // Slice-level: M001/S01
-    const [mid, sid] = parts;
+    const [mid, sid] = [milestone, slice];
     const slicePath = resolveSlicePath(basePath, mid, sid);
     if (slicePath) {
       for (const suffix of ["SUMMARY", "COMPLETE"]) {
@@ -95,8 +96,8 @@ export async function handleUndo(args: string, ctx: ExtensionCommandContext, _pi
 
   // 2. Uncheck task in PLAN if execute-task
   let planUpdated = false;
-  if (unitType === "execute-task" && parts.length === 3) {
-    const [mid, sid, tid] = parts;
+  if (unitType === "execute-task" && task !== undefined && slice !== undefined) {
+    const [mid, sid, tid] = [milestone, slice, task];
     planUpdated = uncheckTaskInPlan(basePath, mid, sid, tid);
   }
 

package/src/resources/extensions/gsd/unit-runtime.ts

@@ -8,6 +8,7 @@ import {
   resolveTaskFile,
 } from "./paths.js";
 import { loadFile, parseTaskPlanMustHaves, countMustHavesMentionedInSummary } from "./files.js";
+import { parseUnitId } from "./unit-id.js";
 
 export type UnitRuntimePhase =
   | "dispatched"
@@ -128,7 +129,7 @@ export async function inspectExecuteTaskDurability(
   basePath: string,
   unitId: string,
 ): Promise<ExecuteTaskRecoveryStatus | null> {
-  const [mid, sid, tid] = unitId.split("/");
+  const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
   if (!mid || !sid || !tid) return null;
 
   const planAbs = resolveSliceFile(basePath, mid, sid, "PLAN");

package/src/resources/extensions/gsd/verification-gate.ts

@@ -8,6 +8,7 @@ import { existsSync, readFileSync } from "node:fs";
 import { join, basename } from "node:path";
 import type { AuditWarning, RuntimeError, VerificationCheck, VerificationResult } from "./types.js";
 import { DEFAULT_COMMAND_TIMEOUT_MS } from "./constants.js";
+import { rewriteCommandWithRtk } from "../shared/rtk.js";
 
 /** Maximum bytes of stdout/stderr to retain per command (10 KB). */
 const MAX_OUTPUT_BYTES = 10 * 1024;
@@ -257,10 +258,11 @@ export function runVerificationGate(options: RunVerificationGateOptions): Verifi
 
   for (const command of commands) {
     const start = Date.now();
+    const rewrittenCommand = rewriteCommandWithRtk(command);
     // Pass the command string as an argument to the shell explicitly
     // to avoid Node.js DEP0190 (spawnSync with shell: true and no args).
     const shellBin = process.platform === "win32" ? "cmd" : "sh";
-    const shellArgs = process.platform === "win32" ? ["/c", command] : ["-c", command];
+    const shellArgs = process.platform === "win32" ? ["/c", rewrittenCommand] : ["-c", rewrittenCommand];
     const result: SpawnSyncReturns<string> = spawnSync(shellBin, shellArgs, {
       cwd: options.cwd,
       stdio: "pipe",

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;
+}