gsd-pi 2.50.0-dev.d210a87 → 2.50.0

package/src/resources/extensions/gsd/tests/retry-diagnostic-reasoning.test.ts

@@ -1,161 +0,0 @@
-/**
- * Regression tests for #2195: formatTraceSummary (used by getDeepDiagnostic →
- * retry prompts) must NOT include lastReasoning from prior assistant text.
- *
- * Including prior assistant free-text in retry diagnostics causes hallucination
- * loops when the previous turn was truncated or malformed.
- *
- * The crash recovery path (formatCrashRecoveryBriefing) has its own safe handling
- * of lastReasoning and is NOT affected by this change.
- */
-import { describe, test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdirSync, writeFileSync, rmSync, mkdtempSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-
-import { extractTrace, getDeepDiagnostic } from "../session-forensics.ts";
-
-/** Build a minimal assistant text reasoning entry. */
-function makeAssistantText(text: string): unknown {
-  return {
-    type: "message",
-    message: {
-      role: "assistant",
-      content: [{ type: "text", text }],
-    },
-  };
-}
-
-/** Build a minimal assistant tool call + tool result pair. */
-function makeToolPair(
-  toolName: string,
-  input: Record<string, unknown>,
-  resultText: string,
-  isError: boolean,
-): unknown[] {
-  const toolCallId = `toolu_${Math.random().toString(36).slice(2, 10)}`;
-  return [
-    {
-      type: "message",
-      message: {
-        role: "assistant",
-        content: [
-          {
-            type: "toolCall",
-            id: toolCallId,
-            name: toolName,
-            arguments: input,
-          },
-        ],
-      },
-    },
-    {
-      type: "message",
-      message: {
-        role: "toolResult",
-        toolCallId,
-        toolName,
-        isError,
-        content: [{ type: "text", text: resultText }],
-      },
-    },
-  ];
-}
-
-describe("retry diagnostic excludes lastReasoning (#2195)", () => {
-  test("extractTrace still captures lastReasoning in the trace object", () => {
-    const entries = [
-      makeAssistantText("I am going to write the summary file now"),
-      ...makeToolPair("write", { path: "/tmp/SUMMARY.md" }, "ok", false),
-      makeAssistantText("The task is complete — all files written."),
-    ];
-
-    const trace = extractTrace(entries);
-    // extractTrace should still collect lastReasoning for crash recovery
-    assert.ok(trace.lastReasoning.length > 0,
-      "extractTrace should still populate lastReasoning");
-    assert.ok(trace.lastReasoning.includes("all files written"),
-      "lastReasoning should contain the last assistant text");
-  });
-
-  test("getDeepDiagnostic output does NOT contain lastReasoning", () => {
-    // Create a temporary activity directory with a JSONL file
-    const tempBase = mkdtempSync(join(tmpdir(), "gsd-diag-test-"));
-    const gsdDir = join(tempBase, ".gsd");
-    const activityDir = join(gsdDir, "activity");
-    mkdirSync(activityDir, { recursive: true });
-
-    try {
-      // Build entries with both tool calls and assistant reasoning
-      const entries = [
-        makeAssistantText("Let me analyze the codebase structure first"),
-        ...makeToolPair("bash", { command: "ls src/" }, "index.ts\nutils.ts", false),
-        makeAssistantText("I see the milestone/M001 branch has a significantly different ... 3. "),
-      ];
-
-      // Write JSONL activity file
-      const jsonl = entries.map(e => JSON.stringify(e)).join("\n");
-      writeFileSync(join(activityDir, "2025-01-01T00-00-00.jsonl"), jsonl);
-
-      const diagnostic = getDeepDiagnostic(tempBase);
-
-      // Diagnostic should exist (we have tool calls)
-      assert.ok(diagnostic !== null, "diagnostic should not be null");
-
-      // Diagnostic should contain structured execution evidence
-      assert.ok(diagnostic!.includes("Tool calls completed:"),
-        "should include tool call count");
-      assert.ok(diagnostic!.includes("ls src/"),
-        "should include commands run");
-
-      // Diagnostic must NOT contain the assistant's free-text reasoning
-      assert.ok(!diagnostic!.includes("Last reasoning"),
-        "diagnostic must not include 'Last reasoning' label");
-      assert.ok(!diagnostic!.includes("analyze the codebase"),
-        "diagnostic must not include prior assistant text");
-      assert.ok(!diagnostic!.includes("significantly different"),
-        "diagnostic must not include truncated assistant reasoning");
-    } finally {
-      rmSync(tempBase, { recursive: true, force: true });
-    }
-  });
-
-  test("getDeepDiagnostic still includes errors and file operations", () => {
-    const tempBase = mkdtempSync(join(tmpdir(), "gsd-diag-test-"));
-    const gsdDir = join(tempBase, ".gsd");
-    const activityDir = join(gsdDir, "activity");
-    mkdirSync(activityDir, { recursive: true });
-
-    try {
-      const entries = [
-        makeAssistantText("Writing the plan file"),
-        ...makeToolPair("write", { path: "M001/S01/S01-PLAN.md" }, "ok", false),
-        ...makeToolPair("bash", { command: "npm run build" }, "Error: type mismatch", true),
-        makeAssistantText("The build failed, let me investigate"),
-      ];
-
-      const jsonl = entries.map(e => JSON.stringify(e)).join("\n");
-      writeFileSync(join(activityDir, "2025-01-01T00-00-00.jsonl"), jsonl);
-
-      const diagnostic = getDeepDiagnostic(tempBase);
-      assert.ok(diagnostic !== null);
-
-      // Structured evidence should be present
-      assert.ok(diagnostic!.includes("S01-PLAN.md"),
-        "should include files written");
-      assert.ok(diagnostic!.includes("npm run build"),
-        "should include commands run");
-      assert.ok(diagnostic!.includes("type mismatch"),
-        "should include errors");
-
-      // But NOT the assistant's free-text
-      assert.ok(!diagnostic!.includes("Writing the plan"),
-        "must not include assistant reasoning");
-      assert.ok(!diagnostic!.includes("build failed"),
-        "must not include assistant reasoning about failures");
-    } finally {
-      rmSync(tempBase, { recursive: true, force: true });
-    }
-  });
-});

package/src/resources/extensions/gsd/tests/rewrite-count-persist.test.ts

@@ -1,82 +0,0 @@
-/**
- * Regression tests for #2203: rewrite-docs circuit breaker must persist
- * across session restarts.
- *
- * The rewrite attempt counter was stored in-memory on the session object,
- * resetting to 0 on every session restart. This allowed the rewrite-docs
- * dispatch rule to fire indefinitely, never tripping the MAX_REWRITE_ATTEMPTS
- * circuit breaker.
- *
- * The fix persists the counter to `.gsd/runtime/rewrite-count.json`.
- */
-import { describe, test, beforeEach, afterEach } from "node:test";
-import assert from "node:assert/strict";
-import { mkdirSync, existsSync, readFileSync, writeFileSync, rmSync, mkdtempSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-
-import { getRewriteCount, setRewriteCount } from "../auto-dispatch.ts";
-
-describe("rewrite-docs circuit breaker persistence (#2203)", () => {
-  let tempBase: string;
-
-  beforeEach(() => {
-    tempBase = mkdtempSync(join(tmpdir(), "gsd-rewrite-test-"));
-    // Create .gsd/ directory so gsdRoot resolves to it
-    mkdirSync(join(tempBase, ".gsd", "runtime"), { recursive: true });
-  });
-
-  afterEach(() => {
-    rmSync(tempBase, { recursive: true, force: true });
-  });
-
-  test("getRewriteCount returns 0 when no file exists", () => {
-    const count = getRewriteCount(tempBase);
-    assert.equal(count, 0);
-  });
-
-  test("setRewriteCount writes and getRewriteCount reads back", () => {
-    setRewriteCount(tempBase, 2);
-    const count = getRewriteCount(tempBase);
-    assert.equal(count, 2);
-  });
-
-  test("counter persists across simulated session restarts", () => {
-    // Session 1: increment to 1
-    setRewriteCount(tempBase, 1);
-
-    // "Session restart" — only the disk file survives, session object is gone
-    const countAfterRestart = getRewriteCount(tempBase);
-    assert.equal(countAfterRestart, 1, "counter should survive session restart");
-
-    // Session 2: increment to 2
-    setRewriteCount(tempBase, countAfterRestart + 1);
-    assert.equal(getRewriteCount(tempBase), 2);
-  });
-
-  test("setRewriteCount(0) resets the counter", () => {
-    setRewriteCount(tempBase, 3);
-    assert.equal(getRewriteCount(tempBase), 3);
-
-    setRewriteCount(tempBase, 0);
-    assert.equal(getRewriteCount(tempBase), 0);
-  });
-
-  test("getRewriteCount handles corrupt JSON gracefully", () => {
-    const filePath = join(tempBase, ".gsd", "runtime", "rewrite-count.json");
-    // writeFileSync is imported at the top of this file
-    writeFileSync(filePath, "not json{{{");
-    const count = getRewriteCount(tempBase);
-    assert.equal(count, 0, "corrupt file should return 0");
-  });
-
-  test("rewrite-count.json is written to .gsd/runtime/", () => {
-    setRewriteCount(tempBase, 1);
-    const filePath = join(tempBase, ".gsd", "runtime", "rewrite-count.json");
-    assert.ok(existsSync(filePath), "rewrite-count.json should exist");
-
-    const content = JSON.parse(readFileSync(filePath, "utf-8"));
-    assert.equal(content.count, 1);
-    assert.ok(content.updatedAt, "should include timestamp");
-  });
-});

package/src/resources/extensions/gsd/tests/skill-catalog.test.ts

@@ -1,193 +0,0 @@
-/**
- * Unit tests for GSD Skill Catalog — pack matching logic.
- *
- * Exercises matchPacksForProject() to verify that project signals
- * correctly map to skill packs.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { PROJECT_FILES } from "../detection.ts";
-import { GREENFIELD_STACKS, SKILL_CATALOG, matchPacksForProject } from "../skill-catalog.ts";
-import type { ProjectSignals } from "../detection.ts";
-
-function makeSignals(overrides: Partial<ProjectSignals> = {}): ProjectSignals {
-  return {
-    detectedFiles: [],
-    isGitRepo: false,
-    isMonorepo: false,
-    xcodePlatforms: [],
-    hasCI: false,
-    hasTests: false,
-    verificationCommands: [],
-    ...overrides,
-  };
-}
-
-function packLabels(signals: ProjectSignals): string[] {
-  return matchPacksForProject(signals).map((p) => p.label);
-}
-
-// ── matchAlways packs are always included ────────────────────────────────────
-
-test("matchPacksForProject: always includes matchAlways packs", () => {
-  const labels = packLabels(makeSignals());
-  assert.ok(labels.includes("Skill Discovery"), "should include Skill Discovery");
-  assert.ok(labels.includes("Skill Authoring"), "should include Skill Authoring");
-  assert.ok(labels.includes("Browser Automation"), "should include Browser Automation");
-  assert.ok(labels.includes("Document Handling"), "should include Document Handling");
-  assert.ok(labels.includes("Code Review & Quality"), "should include Code Review & Quality");
-  assert.ok(labels.includes("Git Advanced Workflows"), "should include Git Advanced Workflows");
-});
-
-// ── Language matching ────────────────────────────────────────────────────────
-
-test("matchPacksForProject: Python language matches Python packs", () => {
-  const labels = packLabels(makeSignals({ primaryLanguage: "python", detectedFiles: ["pyproject.toml"] }));
-  assert.ok(labels.includes("Python"), "should include Python");
-  assert.ok(labels.includes("Python Advanced"), "should include Python Advanced");
-});
-
-test("matchPacksForProject: Rust language matches Rust packs", () => {
-  const labels = packLabels(makeSignals({ primaryLanguage: "rust", detectedFiles: ["Cargo.toml"] }));
-  assert.ok(labels.includes("Rust"), "should include Rust");
-  assert.ok(labels.includes("Rust Async Patterns"), "should include Rust Async Patterns");
-});
-
-test("matchPacksForProject: Go language matches Go packs", () => {
-  const labels = packLabels(makeSignals({ primaryLanguage: "go", detectedFiles: ["go.mod"] }));
-  assert.ok(labels.includes("Go"), "should include Go");
-  assert.ok(labels.includes("Go Concurrency Patterns"), "should include Go Concurrency Patterns");
-});
-
-test("matchPacksForProject: JS/TS matches web frontend packs", () => {
-  const labels = packLabels(makeSignals({ primaryLanguage: "javascript/typescript", detectedFiles: ["package.json"] }));
-  assert.ok(labels.includes("React & Web Frontend"), "should include React");
-  assert.ok(labels.includes("TypeScript & JS Development"), "should include TS/JS Dev");
-  assert.ok(labels.includes("React State & Patterns"), "should include React State");
-  assert.ok(labels.includes("shadcn/ui"), "should include shadcn");
-  assert.ok(labels.includes("Frontend Design & UX"), "should include Frontend Design");
-});
-
-// ── File matching ────────────────────────────────────────────────────────────
-
-test("matchPacksForProject: angular.json triggers Angular packs", () => {
-  const labels = packLabels(makeSignals({ detectedFiles: ["angular.json"] }));
-  assert.ok(labels.includes("Angular"), "should include Angular");
-  assert.ok(labels.includes("Angular Migration"), "should include Angular Migration");
-});
-
-test("matchPacksForProject: next.config.ts triggers Next.js packs", () => {
-  const labels = packLabels(makeSignals({ detectedFiles: ["next.config.ts"] }));
-  assert.ok(labels.includes("Next.js"), "should include Next.js");
-  assert.ok(labels.includes("Next.js App Router Patterns"), "should include Next.js App Router");
-});
-
-test("matchPacksForProject: *.vue triggers Vue.js", () => {
-  const labels = packLabels(makeSignals({ detectedFiles: ["*.vue"] }));
-  assert.ok(labels.includes("Vue.js"), "should include Vue.js");
-});
-
-test("matchPacksForProject: Chart.yaml triggers Kubernetes", () => {
-  const labels = packLabels(makeSignals({ detectedFiles: ["Chart.yaml"] }));
-  assert.ok(labels.includes("Kubernetes"), "should include Kubernetes");
-});
-
-test("matchPacksForProject: hardhat.config.ts triggers Blockchain", () => {
-  const labels = packLabels(makeSignals({ detectedFiles: ["hardhat.config.ts"] }));
-  assert.ok(labels.includes("Blockchain & Web3"), "should include Blockchain & Web3");
-});
-
-test("matchPacksForProject: tailwind.config.ts triggers Tailwind CSS", () => {
-  const labels = packLabels(makeSignals({ detectedFiles: ["tailwind.config.ts"] }));
-  assert.ok(labels.includes("Tailwind CSS"), "should include Tailwind CSS");
-});
-
-// ── Xcode platform matching ─────────────────────────────────────────────────
-
-test("matchPacksForProject: iphoneos triggers iOS packs", () => {
-  const labels = packLabels(makeSignals({ xcodePlatforms: ["iphoneos"] }));
-  assert.ok(labels.includes("iOS App Frameworks"), "should include iOS App Frameworks");
-  assert.ok(labels.includes("iOS Data Frameworks"), "should include iOS Data Frameworks");
-  assert.ok(labels.includes("iOS AI & ML"), "should include iOS AI & ML");
-  assert.ok(labels.includes("iOS Engineering"), "should include iOS Engineering");
-  assert.ok(labels.includes("iOS Hardware"), "should include iOS Hardware");
-  assert.ok(labels.includes("iOS Platform"), "should include iOS Platform");
-});
-
-// ── Isolation checks — packs that should NOT match ──────────────────────────
-
-test("matchPacksForProject: FastAPI does not match generic Python", () => {
-  const labels = packLabels(makeSignals({ primaryLanguage: "python", detectedFiles: ["pyproject.toml"] }));
-  assert.ok(!labels.includes("FastAPI"), "FastAPI should NOT match generic Python projects");
-});
-
-test("matchPacksForProject: FastAPI matches when dep:fastapi detected", () => {
-  const labels = packLabels(makeSignals({ primaryLanguage: "python", detectedFiles: ["pyproject.toml", "dep:fastapi"] }));
-  assert.ok(labels.includes("FastAPI"), "FastAPI should match when dep:fastapi is in detectedFiles");
-});
-
-test("matchPacksForProject: Spring Boot does not match via language alone", () => {
-  // Simulate Android project: has java/kotlin language but no root pom.xml/build.gradle
-  const labels = packLabels(makeSignals({ primaryLanguage: "java/kotlin", detectedFiles: ["app/build.gradle"] }));
-  assert.ok(!labels.includes("Java & Spring Boot"), "Spring Boot should NOT match via language alone");
-});
-
-test("matchPacksForProject: Spring Boot matches only dep:spring-boot", () => {
-  const positive = packLabels(makeSignals({ detectedFiles: ["dep:spring-boot"] }));
-  assert.ok(positive.includes("Java & Spring Boot"), "should include Spring Boot pack when dependency marker exists");
-
-  const androidLike = packLabels(makeSignals({ detectedFiles: ["build.gradle", "app/build.gradle"], primaryLanguage: "java/kotlin" }));
-  assert.ok(!androidLike.includes("Java & Spring Boot"), "generic Gradle + Android markers should not imply Spring Boot");
-});
-
-test("matchPacksForProject: Unity does not include Godot", () => {
-  const labels = packLabels(makeSignals({ detectedFiles: ["ProjectSettings/ProjectVersion.txt"] }));
-  assert.ok(labels.includes("Unity"), "should include Unity");
-  assert.ok(!labels.includes("Godot"), "should NOT include Godot");
-});
-
-test("matchPacksForProject: Godot does not include Unity", () => {
-  const labels = packLabels(makeSignals({ detectedFiles: ["project.godot"] }));
-  assert.ok(labels.includes("Godot"), "should include Godot");
-  assert.ok(!labels.includes("Unity"), "should NOT include Unity");
-});
-
-test("matchPacksForProject: .NET backend patterns match F# and solution markers", () => {
-  const fsprojLabels = packLabels(makeSignals({ detectedFiles: ["*.fsproj"], primaryLanguage: "fsharp" }));
-  assert.ok(fsprojLabels.includes(".NET Backend Patterns"), "should include generic .NET backend patterns for F# projects");
-  assert.ok(!fsprojLabels.includes(".NET & C#"), "should not include C#-specific pack for F# projects");
-
-  const slnLabels = packLabels(makeSignals({ detectedFiles: ["*.sln"], primaryLanguage: "dotnet" }));
-  assert.ok(slnLabels.includes(".NET Backend Patterns"), "should include generic .NET backend patterns for solution files");
-});
-
-test("SKILL_CATALOG: every matchFiles entry is backed by detection", () => {
-  const knownMarkers = new Set<string>([
-    ...PROJECT_FILES,
-    "*.sqlite",
-    "*.sql",
-    "*.csproj",
-    "*.fsproj",
-    "*.sln",
-    "*.vue",
-    "dep:fastapi",
-    "dep:spring-boot",
-  ]);
-
-  for (const pack of SKILL_CATALOG) {
-    for (const marker of pack.matchFiles ?? []) {
-      assert.ok(knownMarkers.has(marker), `Unknown detection marker: ${marker} (pack: ${pack.label})`);
-    }
-  }
-});
-
-test("GREENFIELD_STACKS: every pack label resolves to SKILL_CATALOG", () => {
-  const labels = new Set(SKILL_CATALOG.map((pack) => pack.label));
-
-  for (const stack of GREENFIELD_STACKS) {
-    for (const packLabel of stack.packs) {
-      assert.ok(labels.has(packLabel), `Unknown pack label: ${packLabel} (stack: ${stack.id})`);
-    }
-  }
-});

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

@@ -1,249 +0,0 @@
-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)}%)`;
-}