gsd-pi 2.26.0 → 2.27.0

package/src/resources/extensions/gsd/visualizer-overlay.ts

@@ -15,25 +15,22 @@ import {
   type ProgressFilter,
 } from "./visualizer-views.js";
 import { writeExportFile } from "./export.js";
+import { stripAnsi } from "../shared/format-utils.js";
 
 const TAB_COUNT = 10;
 const TAB_LABELS = [
   "1 Progress",
-  "2 Deps",
-  "3 Metrics",
-  "4 Timeline",
-  "5 Agent",
-  "6 Changes",
-  "7 Export",
+  "2 Timeline",
+  "3 Deps",
+  "4 Metrics",
+  "5 Health",
+  "6 Agent",
+  "7 Changes",
   "8 Knowledge",
   "9 Captures",
-  "0 Health",
+  "0 Export",
 ];
 
-function stripAnsi(s: string): string {
-  return s.replace(/\x1b\[[0-9;]*m/g, "");
-}
-
 export class GSDVisualizerOverlay {
   private tui: { requestRender: () => void };
   private theme: Theme;
@@ -62,6 +59,7 @@ export class GSDVisualizerOverlay {
   private lastVisibleRows = 20;
   collapsedMilestones = new Set<string>();
   showHelp = false;
+  private resizeHandler: (() => void) | null = null;
 
   constructor(
     tui: { requestRender: () => void },
@@ -76,6 +74,14 @@ export class GSDVisualizerOverlay {
     // Enable SGR mouse tracking
     process.stdout.write("\x1b[?1003h\x1b[?1006h");
 
+    // Invalidate cache on terminal resize
+    this.resizeHandler = () => {
+      if (this.disposed) return;
+      this.invalidate();
+      this.tui.requestRender();
+    };
+    process.stdout.on("resize", this.resizeHandler);
+
     loadVisualizerData(this.basePath).then((d) => {
       this.data = d;
       this.loading = false;
@@ -89,7 +95,7 @@ export class GSDVisualizerOverlay {
         this.invalidate();
         this.tui.requestRender();
       });
-    }, 2000);
+    }, 5000);
   }
 
   private parseSGRMouse(data: string): { button: number; x: number; y: number; press: boolean } | null {
@@ -262,7 +268,7 @@ export class GSDVisualizerOverlay {
     }
 
     // Export tab key handling
-    if (this.activeTab === 6 && this.data) {
+    if (this.activeTab === 9 && this.data) {
       if (data === "m" || data === "j" || data === "s") {
         this.handleExportKey(data);
         return;
@@ -372,23 +378,23 @@ export class GSDVisualizerOverlay {
         return renderProgressView(this.data, th, width, filter, this.collapsedMilestones);
       }
       case 1:
-        return renderDepsView(this.data, th, width);
+        return renderTimelineView(this.data, th, width);
       case 2:
-        return renderMetricsView(this.data, th, width);
+        return renderDepsView(this.data, th, width);
       case 3:
-        return renderTimelineView(this.data, th, width);
+        return renderMetricsView(this.data, th, width);
       case 4:
-        return renderAgentView(this.data, th, width);
+        return renderHealthView(this.data, th, width);
       case 5:
-        return renderChangelogView(this.data, th, width);
+        return renderAgentView(this.data, th, width);
       case 6:
-        return renderExportView(this.data, th, width, this.lastExportPath);
+        return renderChangelogView(this.data, th, width);
       case 7:
         return renderKnowledgeView(this.data, th, width);
       case 8:
         return renderCapturesView(this.data, th, width);
       case 9:
-        return renderHealthView(this.data, th, width);
+        return renderExportView(this.data, th, width, this.lastExportPath);
       default:
         return [];
     }
@@ -470,7 +476,7 @@ export class GSDVisualizerOverlay {
       let viewLines = this.renderTabContent(this.activeTab, innerWidth);
 
       // Show export status message if present
-      if (this.exportStatus && this.activeTab === 6) {
+      if (this.exportStatus && this.activeTab === 9) {
         content.push(th.fg("success", this.exportStatus));
         content.push("");
         this.exportStatus = undefined;
@@ -547,6 +553,10 @@ export class GSDVisualizerOverlay {
   dispose(): void {
     this.disposed = true;
     clearInterval(this.refreshTimer);
+    if (this.resizeHandler) {
+      process.stdout.removeListener("resize", this.resizeHandler);
+      this.resizeHandler = null;
+    }
     // Disable SGR mouse tracking
     process.stdout.write("\x1b[?1003l\x1b[?1006l");
   }

package/src/resources/extensions/gsd/visualizer-views.ts

@@ -4,41 +4,8 @@ import type { Theme } from "@gsd/pi-coding-agent";
 import { truncateToWidth, visibleWidth } from "@gsd/pi-tui";
 import type { VisualizerData, VisualizerMilestone, SliceVerification, VisualizerSliceActivity, VisualizerStats, VisualizerSliceRef } from "./visualizer-data.js";
 import { formatCost, formatTokenCount, classifyUnitPhase } from "./metrics.js";
-
-// ─── Local Helpers ───────────────────────────────────────────────────────────
-
-function formatDuration(ms: number): string {
-  const s = Math.floor(ms / 1000);
-  if (s < 60) return `${s}s`;
-  const m = Math.floor(s / 60);
-  const rs = s % 60;
-  if (m < 60) return `${m}m ${rs}s`;
-  const h = Math.floor(m / 60);
-  const rm = m % 60;
-  return `${h}h ${rm}m`;
-}
-
-function padRight(content: string, width: number): string {
-  const vis = visibleWidth(content);
-  return content + " ".repeat(Math.max(0, width - vis));
-}
-
-function joinColumns(left: string, right: string, width: number): string {
-  const leftW = visibleWidth(left);
-  const rightW = visibleWidth(right);
-  if (leftW + rightW + 2 > width) {
-    return truncateToWidth(`${left}  ${right}`, width);
-  }
-  return left + " ".repeat(width - leftW - rightW) + right;
-}
-
-function sparkline(values: number[]): string {
-  if (values.length === 0) return "";
-  const chars = "\u2581\u2582\u2583\u2584\u2585\u2586\u2587\u2588";
-  const max = Math.max(...values);
-  if (max === 0) return chars[0].repeat(values.length);
-  return values.map(v => chars[Math.min(7, Math.floor((v / max) * 7))]).join("");
-}
+import { formatDuration, padRight, joinColumns, sparkline } from "../shared/format-utils.js";
+import { STATUS_GLYPH, STATUS_COLOR } from "../shared/ui.js";
 
 function formatCompletionDate(input: string): string {
   if (!input) return "unknown";
@@ -168,18 +135,9 @@ export function renderProgressView(
     }
 
     // Milestone header line
-    const statusGlyph =
-      ms.status === "complete"
-        ? th.fg("success", "\u2713")
-        : ms.status === "active"
-          ? th.fg("accent", "\u25b8")
-          : th.fg("dim", "\u25cb");
-    const statusLabel =
-      ms.status === "complete"
-        ? th.fg("success", "complete")
-        : ms.status === "active"
-          ? th.fg("accent", "active")
-          : th.fg("dim", "pending");
+    const msStatus = ms.status === "complete" ? "done" : ms.status === "active" ? "active" : "pending";
+    const statusGlyph = th.fg(STATUS_COLOR[msStatus], STATUS_GLYPH[msStatus]);
+    const statusLabel = th.fg(STATUS_COLOR[msStatus], ms.status);
 
     const collapseIndicator = collapsed?.has(ms.id) ? "[+] " : "";
     const msLeft = `${collapseIndicator}${ms.id}: ${ms.title}`;
@@ -206,11 +164,8 @@ export function renderProgressView(
       }
 
       // Slice line
-      const slGlyph = sl.done
-        ? th.fg("success", "\u2713")
-        : sl.active
-          ? th.fg("accent", "\u25b8")
-          : th.fg("dim", "\u25cb");
+      const slStatus = sl.done ? "done" : sl.active ? "active" : "pending";
+      const slGlyph = th.fg(STATUS_COLOR[slStatus], STATUS_GLYPH[slStatus]);
       const riskColor =
         sl.risk === "high"
           ? "warning"
@@ -241,11 +196,8 @@ export function renderProgressView(
       // Show tasks for active slice
       if (sl.active && sl.tasks.length > 0) {
         for (const task of sl.tasks) {
-          const tGlyph = task.done
-            ? th.fg("success", "\u2713")
-            : task.active
-              ? th.fg("accent", "\u25b8")
-              : th.fg("dim", "\u25cb");
+          const tStatus = task.done ? "done" : task.active ? "active" : "pending";
+          const tGlyph = th.fg(STATUS_COLOR[tStatus], STATUS_GLYPH[tStatus]);
           const estimateStr = task.estimate ? th.fg("dim", ` (${task.estimate})`) : "";
           lines.push(`      ${tGlyph} ${task.id}: ${task.title}${estimateStr}`);
         }
@@ -683,10 +635,8 @@ function renderTimelineList(data: VisualizerData, th: Theme, width: number): str
     const time = `${hh}:${mm}`;
 
     const duration = unit.finishedAt - unit.startedAt;
-    const glyph =
-      unit.finishedAt > 0
-        ? th.fg("success", "\u2713")
-        : th.fg("accent", "\u25b8");
+    const unitStatus = unit.finishedAt > 0 ? "done" : "active";
+    const glyph = th.fg(STATUS_COLOR[unitStatus], STATUS_GLYPH[unitStatus]);
 
     const typeLabel = padRight(unit.type, 16);
     const idLabel = padRight(unit.id, 14);
@@ -802,9 +752,8 @@ export function renderAgentView(
   }
 
   // Status line
-  const statusDot = activity.active
-    ? th.fg("success", "\u25cf")
-    : th.fg("dim", "\u25cb");
+  const agentStatus = activity.active ? "active" : "pending";
+  const statusDot = th.fg(STATUS_COLOR[agentStatus], STATUS_GLYPH[agentStatus]);
   const statusText = activity.active ? "ACTIVE" : "IDLE";
   const elapsedStr = activity.active ? formatDuration(activity.elapsed) : "\u2014";
 
@@ -877,7 +826,7 @@ export function renderAgentView(
       const typeLabel = padRight(u.type, 16);
       lines.push(
         truncateToWidth(
-          `  ${hh}:${mm}  ${th.fg("success", "\u2713")} ${typeLabel} ${padRight(u.id, 16)} ${dur}  ${cost}`,
+          `  ${hh}:${mm}  ${th.fg(STATUS_COLOR.done, STATUS_GLYPH.done)} ${typeLabel} ${padRight(u.id, 16)} ${dur}  ${cost}`,
           width,
         ),
       );
@@ -920,7 +869,7 @@ export function renderChangelogView(
       for (const f of entry.filesModified) {
         lines.push(
           truncateToWidth(
-            `    ${th.fg("success", "\u2713")} ${f.path} \u2014 ${f.description}`,
+            `    ${th.fg(STATUS_COLOR.done, STATUS_GLYPH.done)} ${f.path} \u2014 ${f.description}`,
             width,
           ),
         );

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

@@ -104,6 +104,12 @@ interface SearchDetails {
 const searchCache = new LRUTTLCache<CachedSearchResult>({ 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;
+let lastSearchKey = "";
+let consecutiveDupeCount = 0;
+
 // Summarizer responses: max 50 entries, 15-minute TTL
 const summarizerCache = new LRUTTLCache<string>({ max: 50, ttlMs: 900_000 });
 
@@ -388,6 +394,26 @@ export function registerSearchTool(pi: ExtensionAPI) {
       // Cache lookup (provider-prefixed key)
       // ------------------------------------------------------------------
       const cacheKey = normalizeQuery(effectiveQuery) + `|f:${freshness || ""}|s:${wantSummary}|p:${provider}`;
+
+      // ── Consecutive duplicate search guard (#949) ──────────────────────
+      // If the LLM keeps calling the same search query, break the loop
+      // with an explicit warning instead of returning the same results.
+      if (cacheKey === lastSearchKey) {
+        consecutiveDupeCount++;
+        if (consecutiveDupeCount >= MAX_CONSECUTIVE_DUPES) {
+          consecutiveDupeCount = 0;
+          lastSearchKey = "";
+          return {
+            content: [{ type: "text" as const, text: `⚠️ Search loop detected: the query "${params.query}" has been searched ${MAX_CONSECUTIVE_DUPES + 1} times consecutively with identical results. The information you need is already in the previous search results above. Stop searching and use those results to proceed with your task.` }],
+            isError: true,
+            details: { errorKind: "search_loop", error: "Consecutive duplicate search detected" } satisfies Partial<SearchDetails>,
+          };
+        }
+      } else {
+        lastSearchKey = cacheKey;
+        consecutiveDupeCount = 0;
+      }
+
       const cached = searchCache.get(cacheKey);
 
       if (cached) {

package/src/resources/extensions/shared/format-utils.ts

@@ -0,0 +1,85 @@
+/**
+ * Shared formatting and layout utilities for TUI dashboard components.
+ *
+ * Consolidates helpers that were previously duplicated across
+ * auto-dashboard.ts, dashboard-overlay.ts, and visualizer-views.ts.
+ */
+
+import { truncateToWidth, visibleWidth } from "@gsd/pi-tui";
+
+// ─── Duration Formatting ──────────────────────────────────────────────────────
+
+/** Format a millisecond duration as a compact human-readable string. */
+export function formatDuration(ms: number): string {
+  const s = Math.floor(ms / 1000);
+  if (s < 60) return `${s}s`;
+  const m = Math.floor(s / 60);
+  const rs = s % 60;
+  if (m < 60) return `${m}m ${rs}s`;
+  const h = Math.floor(m / 60);
+  const rm = m % 60;
+  return `${h}h ${rm}m`;
+}
+
+// ─── Layout Helpers ───────────────────────────────────────────────────────────
+
+/** Pad a string with trailing spaces to fill `width` (ANSI-aware). */
+export function padRight(content: string, width: number): string {
+  const vis = visibleWidth(content);
+  return content + " ".repeat(Math.max(0, width - vis));
+}
+
+/** Build a line with left-aligned and right-aligned content. */
+export function joinColumns(left: string, right: string, width: number): string {
+  const leftW = visibleWidth(left);
+  const rightW = visibleWidth(right);
+  if (leftW + rightW + 2 > width) {
+    return truncateToWidth(`${left}  ${right}`, width);
+  }
+  return left + " ".repeat(width - leftW - rightW) + right;
+}
+
+/** Center content within `width` (ANSI-aware). */
+export function centerLine(content: string, width: number): string {
+  const vis = visibleWidth(content);
+  if (vis >= width) return truncateToWidth(content, width);
+  const leftPad = Math.floor((width - vis) / 2);
+  return " ".repeat(leftPad) + content;
+}
+
+/** Join as many parts as fit within `width`, separated by `separator`. */
+export function fitColumns(parts: string[], width: number, separator = "  "): string {
+  const filtered = parts.filter(Boolean);
+  if (filtered.length === 0) return "";
+  let result = filtered[0];
+  for (let i = 1; i < filtered.length; i++) {
+    const candidate = `${result}${separator}${filtered[i]}`;
+    if (visibleWidth(candidate) > width) break;
+    result = candidate;
+  }
+  return truncateToWidth(result, width);
+}
+
+// ─── Data Visualization ───────────────────────────────────────────────────────
+
+/**
+ * Render a sparkline from numeric values using Unicode block characters.
+ * Uses loop-based max to avoid stack overflow on large arrays.
+ */
+export function sparkline(values: number[]): string {
+  if (values.length === 0) return "";
+  const chars = "\u2581\u2582\u2583\u2584\u2585\u2586\u2587\u2588";
+  let max = 0;
+  for (const v of values) {
+    if (v > max) max = v;
+  }
+  if (max === 0) return chars[0].repeat(values.length);
+  return values.map(v => chars[Math.min(7, Math.floor((v / max) * 7))]).join("");
+}
+
+// ─── ANSI Stripping ───────────────────────────────────────────────────────────
+
+/** Strip ANSI escape sequences from a string. */
+export function stripAnsi(s: string): string {
+  return s.replace(/\x1b\[[0-9;]*m/g, "");
+}

package/src/resources/extensions/shared/tests/format-utils.test.ts

@@ -0,0 +1,153 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import {
+  formatDuration,
+  padRight,
+  joinColumns,
+  centerLine,
+  fitColumns,
+  sparkline,
+  stripAnsi,
+} from "../format-utils.js";
+
+describe("formatDuration", () => {
+  it("formats seconds", () => {
+    assert.equal(formatDuration(0), "0s");
+    assert.equal(formatDuration(5_000), "5s");
+    assert.equal(formatDuration(59_000), "59s");
+  });
+
+  it("formats minutes and seconds", () => {
+    assert.equal(formatDuration(60_000), "1m 0s");
+    assert.equal(formatDuration(90_000), "1m 30s");
+    assert.equal(formatDuration(3_540_000), "59m 0s");
+  });
+
+  it("formats hours and minutes", () => {
+    assert.equal(formatDuration(3_600_000), "1h 0m");
+    assert.equal(formatDuration(5_400_000), "1h 30m");
+    assert.equal(formatDuration(7_200_000), "2h 0m");
+  });
+});
+
+describe("padRight", () => {
+  it("pads plain text to width", () => {
+    const result = padRight("abc", 6);
+    assert.equal(result, "abc   ");
+  });
+
+  it("does not pad when text fills width", () => {
+    const result = padRight("abcdef", 6);
+    assert.equal(result, "abcdef");
+  });
+
+  it("does not pad when text exceeds width", () => {
+    const result = padRight("abcdefgh", 6);
+    assert.equal(result, "abcdefgh");
+  });
+});
+
+describe("joinColumns", () => {
+  it("joins left and right with spacing", () => {
+    const result = joinColumns("left", "right", 20);
+    assert.equal(result.length, 20);
+    assert.ok(result.startsWith("left"));
+    assert.ok(result.endsWith("right"));
+  });
+
+  it("truncates when content overflows", () => {
+    const result = joinColumns("a".repeat(20), "b".repeat(20), 30);
+    // Should be truncated to 30 chars
+    assert.ok(result.length <= 30);
+  });
+});
+
+describe("centerLine", () => {
+  it("centers text within width", () => {
+    const result = centerLine("hi", 10);
+    assert.equal(result, "    hi");
+  });
+
+  it("truncates when content exceeds width", () => {
+    const result = centerLine("abcdefgh", 4);
+    assert.ok(result.length <= 4);
+  });
+});
+
+describe("fitColumns", () => {
+  it("joins parts that fit", () => {
+    const result = fitColumns(["aaa", "bbb", "ccc"], 20);
+    assert.ok(result.includes("aaa"));
+    assert.ok(result.includes("bbb"));
+    assert.ok(result.includes("ccc"));
+  });
+
+  it("drops parts that overflow", () => {
+    const result = fitColumns(["aaa", "bbb", "ccc"], 10);
+    assert.ok(result.includes("aaa"));
+    // May or may not include bbb depending on separator width
+  });
+
+  it("returns empty string for empty array", () => {
+    assert.equal(fitColumns([], 80), "");
+  });
+
+  it("filters out empty strings", () => {
+    const result = fitColumns(["aaa", "", "bbb"], 80);
+    assert.ok(result.includes("aaa"));
+    assert.ok(result.includes("bbb"));
+  });
+});
+
+describe("sparkline", () => {
+  it("returns empty string for empty array", () => {
+    assert.equal(sparkline([]), "");
+  });
+
+  it("renders all lowest blocks for all-zero values", () => {
+    const result = sparkline([0, 0, 0]);
+    assert.equal(result.length, 3);
+    // All chars should be the same (lowest block)
+    assert.equal(result[0], result[1]);
+    assert.equal(result[1], result[2]);
+  });
+
+  it("renders highest block for max value", () => {
+    const result = sparkline([0, 10, 5]);
+    assert.equal(result.length, 3);
+    // Middle should be highest block (█)
+    assert.equal(result[1], "\u2588");
+  });
+
+  it("handles single value", () => {
+    const result = sparkline([42]);
+    assert.equal(result.length, 1);
+    assert.equal(result, "\u2588");
+  });
+
+  it("handles large arrays without stack overflow", () => {
+    const largeArray = new Array(100_000).fill(0).map((_, i) => i);
+    const result = sparkline(largeArray);
+    assert.equal(result.length, 100_000);
+  });
+});
+
+describe("stripAnsi", () => {
+  it("strips ANSI escape sequences", () => {
+    const result = stripAnsi("\x1b[31mred\x1b[0m text");
+    assert.equal(result, "red text");
+  });
+
+  it("returns plain text unchanged", () => {
+    assert.equal(stripAnsi("plain text"), "plain text");
+  });
+
+  it("strips multiple escape sequences", () => {
+    const result = stripAnsi("\x1b[1m\x1b[32mbold green\x1b[0m");
+    assert.equal(result, "bold green");
+  });
+
+  it("handles empty string", () => {
+    assert.equal(stripAnsi(""), "");
+  });
+});

package/src/resources/extensions/subagent/index.ts

@@ -12,7 +12,7 @@
  * Uses JSON mode to capture structured output from subagents.
  */
 
-import { spawn } from "node:child_process";
+import { spawn, type ChildProcess } from "node:child_process";
 import * as crypto from "node:crypto";
 import * as fs from "node:fs";
 import * as os from "node:os";
@@ -38,6 +38,44 @@ import { registerWorker, updateWorker } from "./worker-registry.js";
 const MAX_PARALLEL_TASKS = 8;
 const MAX_CONCURRENCY = 4;
 const COLLAPSED_ITEM_COUNT = 10;
+const liveSubagentProcesses = new Set<ChildProcess>();
+
+async function stopLiveSubagents(): Promise<void> {
+	const active = Array.from(liveSubagentProcesses);
+	if (active.length === 0) return;
+
+	for (const proc of active) {
+		try {
+			proc.kill("SIGTERM");
+		} catch {
+			/* ignore */
+		}
+	}
+
+	await Promise.all(
+		active.map(
+			(proc) =>
+				new Promise<void>((resolve) => {
+					const done = () => resolve();
+					const timer = setTimeout(done, 500);
+					proc.once("exit", () => {
+						clearTimeout(timer);
+						resolve();
+					});
+				}),
+		),
+	);
+
+	for (const proc of active) {
+		if (proc.exitCode === null) {
+			try {
+				proc.kill("SIGKILL");
+			} catch {
+				/* ignore */
+			}
+		}
+	}
+}
 
 function formatTokens(count: number): string {
 	if (count < 1000) return count.toString();
@@ -302,6 +340,7 @@ async function runSingleAgent(
 				[process.env.GSD_BIN_PATH!, ...extensionArgs, ...args],
 				{ cwd: cwd ?? defaultCwd, shell: false, stdio: ["ignore", "pipe", "pipe"] },
 			);
+			liveSubagentProcesses.add(proc);
 			let buffer = "";
 
 			const processLine = (line: string) => {
@@ -353,11 +392,13 @@ async function runSingleAgent(
 			});
 
 			proc.on("close", (code) => {
+				liveSubagentProcesses.delete(proc);
 				if (buffer.trim()) processLine(buffer);
 				resolve(code ?? 0);
 			});
 
 			proc.on("error", () => {
+				liveSubagentProcesses.delete(proc);
 				resolve(1);
 			});
 
@@ -432,6 +473,10 @@ const SubagentParams = Type.Object({
 });
 
 export default function (pi: ExtensionAPI) {
+	pi.on("session_shutdown", async () => {
+		await stopLiveSubagents();
+	});
+
 	// /subagent command - list available agents
 	pi.registerCommand("subagent", {
 		description: "List available subagents",

package/src/resources/extensions/subagent/isolation.ts

@@ -273,13 +273,16 @@ export async function createWorktreeIsolation(
 		async cleanup(): Promise<void> {
 			activeIsolations.delete(worktreeDir);
 			try {
-				await git(
-					["worktree", "remove", "--force", worktreeDir],
-					repoRoot,
-				);
+				await Promise.race([
+					git(["worktree", "remove", "--force", worktreeDir], repoRoot),
+					new Promise<never>((_, reject) =>
+						setTimeout(() => reject(new Error("Worktree cleanup timed out")), 10_000),
+					),
+				]);
 			} catch {
-				// Force remove directory if git worktree remove fails
-				fs.rmSync(worktreeDir, { recursive: true, force: true });
+				try {
+					fs.rmSync(worktreeDir, { recursive: true, force: true });
+				} catch { /* best effort */ }
 			}
 		},
 	};