gsd-pi 2.28.0-dev.e19bf89 → 2.29.0-dev.49d972f

package/dist/resources/extensions/gsd/tests/verification-gate.test.ts

@@ -581,7 +581,7 @@ test("formatFailureContext: formats a single failure with command, exit code, st
   const result: import("../types.ts").VerificationResult = {
     passed: false,
     checks: [
-      { command: "npm run lint", exitCode: 1, stdout: "", stderr: "error: unused var", durationMs: 500 },
+      { command: "npm run lint", exitCode: 1, stdout: "", stderr: "error: unused var", durationMs: 500, blocking: true },
     ],
     discoverySource: "preference",
     timestamp: Date.now(),
@@ -598,9 +598,9 @@ test("formatFailureContext: formats multiple failures", () => {
   const result: import("../types.ts").VerificationResult = {
     passed: false,
     checks: [
-      { command: "npm run lint", exitCode: 1, stdout: "", stderr: "lint error", durationMs: 100 },
-      { command: "npm run test", exitCode: 2, stdout: "", stderr: "test failure", durationMs: 200 },
-      { command: "npm run typecheck", exitCode: 0, stdout: "ok", stderr: "", durationMs: 50 },
+      { command: "npm run lint", exitCode: 1, stdout: "", stderr: "lint error", durationMs: 100, blocking: true },
+      { command: "npm run test", exitCode: 2, stdout: "", stderr: "test failure", durationMs: 200, blocking: true },
+      { command: "npm run typecheck", exitCode: 0, stdout: "ok", stderr: "", durationMs: 50, blocking: true },
     ],
     discoverySource: "preference",
     timestamp: Date.now(),
@@ -619,7 +619,7 @@ test("formatFailureContext: truncates stderr longer than 2000 chars", () => {
   const result: import("../types.ts").VerificationResult = {
     passed: false,
     checks: [
-      { command: "big-err", exitCode: 1, stdout: "", stderr: longStderr, durationMs: 100 },
+      { command: "big-err", exitCode: 1, stdout: "", stderr: longStderr, durationMs: 100, blocking: true },
     ],
     discoverySource: "preference",
     timestamp: Date.now(),
@@ -634,8 +634,8 @@ test("formatFailureContext: returns empty string when all checks pass", () => {
   const result: import("../types.ts").VerificationResult = {
     passed: true,
     checks: [
-      { command: "npm run lint", exitCode: 0, stdout: "ok", stderr: "", durationMs: 100 },
-      { command: "npm run test", exitCode: 0, stdout: "ok", stderr: "", durationMs: 200 },
+      { command: "npm run lint", exitCode: 0, stdout: "ok", stderr: "", durationMs: 100, blocking: true },
+      { command: "npm run test", exitCode: 0, stdout: "ok", stderr: "", durationMs: 200, blocking: true },
     ],
     discoverySource: "preference",
     timestamp: Date.now(),
@@ -663,6 +663,7 @@ test("formatFailureContext: caps total output at 10,000 chars", () => {
       stdout: "",
       stderr: "e".repeat(1000), // 1000 chars each, 20 * ~1050 (with formatting) > 10,000
       durationMs: 100,
+      blocking: true,
     });
   }
   const result: import("../types.ts").VerificationResult = {
@@ -1077,3 +1078,131 @@ test("dependency-audit: subdirectory package.json does not trigger audit", () =>
   assert.equal(npmAuditCalled, false, "subdirectory dependency files should not trigger audit");
   assert.deepStrictEqual(result, []);
 });
+
+// ─── Non-Blocking Discovery Tests ────────────────────────────────────────────
+
+test("non-blocking: package-json discovered commands failing → result.passed is still true", () => {
+  const tmp = makeTempDir("vg-nb-pkg-fail");
+  try {
+    writeFileSync(
+      join(tmp, "package.json"),
+      JSON.stringify({ scripts: { lint: "eslint .", test: "vitest" } }),
+    );
+    // These commands will fail because eslint/vitest don't exist in the temp dir
+    const result = runVerificationGate({
+      basePath: tmp,
+      unitId: "T01",
+      cwd: tmp,
+      // No preference commands — discovery falls through to package.json
+    });
+    assert.equal(result.discoverySource, "package-json");
+    assert.ok(result.checks.length > 0, "should have discovered package.json checks");
+    assert.equal(result.passed, true, "package-json failures should not block the gate");
+    for (const check of result.checks) {
+      assert.equal(check.blocking, false, "package-json checks should be non-blocking");
+    }
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+test("non-blocking: preference commands failing → result.passed is false", () => {
+  const tmp = makeTempDir("vg-nb-pref-fail");
+  try {
+    const result = runVerificationGate({
+      basePath: tmp,
+      unitId: "T01",
+      cwd: tmp,
+      preferenceCommands: ["sh -c 'exit 1'"],
+    });
+    assert.equal(result.discoverySource, "preference");
+    assert.equal(result.passed, false, "preference failures should block the gate");
+    assert.equal(result.checks[0].blocking, true, "preference checks should be blocking");
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+test("non-blocking: task-plan commands failing → result.passed is false", () => {
+  const tmp = makeTempDir("vg-nb-tp-fail");
+  try {
+    const result = runVerificationGate({
+      basePath: tmp,
+      unitId: "T01",
+      cwd: tmp,
+      taskPlanVerify: "sh -c 'exit 1'",
+    });
+    assert.equal(result.discoverySource, "task-plan");
+    assert.equal(result.passed, false, "task-plan failures should block the gate");
+    assert.equal(result.checks[0].blocking, true, "task-plan checks should be blocking");
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+test("non-blocking: blocking field is set correctly based on discovery source", () => {
+  const tmp = makeTempDir("vg-nb-field");
+  try {
+    // preference → blocking
+    const prefResult = runVerificationGate({
+      basePath: tmp,
+      unitId: "T01",
+      cwd: tmp,
+      preferenceCommands: ["echo ok"],
+    });
+    assert.equal(prefResult.checks[0].blocking, true);
+
+    // task-plan → blocking
+    const tpResult = runVerificationGate({
+      basePath: tmp,
+      unitId: "T01",
+      cwd: tmp,
+      taskPlanVerify: "echo ok",
+    });
+    assert.equal(tpResult.checks[0].blocking, true);
+
+    // package-json → non-blocking
+    writeFileSync(
+      join(tmp, "package.json"),
+      JSON.stringify({ scripts: { test: "echo ok" } }),
+    );
+    const pkgResult = runVerificationGate({
+      basePath: tmp,
+      unitId: "T01",
+      cwd: tmp,
+    });
+    assert.equal(pkgResult.checks[0].blocking, false);
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+test("non-blocking: formatFailureContext only includes blocking failures", () => {
+  const result: import("../types.ts").VerificationResult = {
+    passed: true,
+    checks: [
+      { command: "npm run lint", exitCode: 1, stdout: "", stderr: "lint warning", durationMs: 100, blocking: false },
+      { command: "npm run test", exitCode: 1, stdout: "", stderr: "test error", durationMs: 200, blocking: true },
+      { command: "npm run typecheck", exitCode: 1, stdout: "", stderr: "type error", durationMs: 50, blocking: false },
+    ],
+    discoverySource: "preference",
+    timestamp: Date.now(),
+  };
+  const output = formatFailureContext(result);
+  assert.ok(output.includes("`npm run test`"), "should include blocking failure");
+  assert.ok(!output.includes("npm run lint"), "should not include non-blocking failure");
+  assert.ok(!output.includes("npm run typecheck"), "should not include non-blocking failure");
+});
+
+test("non-blocking: formatFailureContext returns empty when only non-blocking failures exist", () => {
+  const result: import("../types.ts").VerificationResult = {
+    passed: true,
+    checks: [
+      { command: "npm run lint", exitCode: 1, stdout: "", stderr: "lint warning", durationMs: 100, blocking: false },
+      { command: "npm run test", exitCode: 1, stdout: "", stderr: "test warning", durationMs: 200, blocking: false },
+    ],
+    discoverySource: "package-json",
+    timestamp: Date.now(),
+  };
+  assert.equal(formatFailureContext(result), "", "should return empty when only non-blocking failures");
+});

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

@@ -55,6 +55,7 @@ export interface VerificationCheck {
   stdout: string;
   stderr: string;
   durationMs: number;
+  blocking: boolean;     // true for preference/task-plan sources, false for package-json (advisory only)
 }
 
 /** A runtime error captured from bg-shell processes or browser console */

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

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, unlinkSync } from "node:fs";
+import { existsSync, readdirSync, readFileSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 import {
   gsdRoot,
@@ -8,6 +8,7 @@ import {
   resolveTaskFile,
 } from "./paths.js";
 import { loadFile, parseTaskPlanMustHaves, countMustHavesMentionedInSummary } from "./files.js";
+import { loadJsonFileOrNull, saveJsonFile } from "./json-persistence.js";
 
 export type UnitRuntimePhase =
   | "dispatched"
@@ -46,13 +47,23 @@ export interface AutoUnitRuntimeRecord {
   lastRecoveryReason?: "idle" | "hard";
 }
 
+function isAutoUnitRuntimeRecord(data: unknown): data is AutoUnitRuntimeRecord {
+  return (
+    typeof data === "object" &&
+    data !== null &&
+    (data as AutoUnitRuntimeRecord).version === 1 &&
+    typeof (data as AutoUnitRuntimeRecord).unitType === "string" &&
+    typeof (data as AutoUnitRuntimeRecord).unitId === "string"
+  );
+}
+
 function runtimeDir(basePath: string): string {
   return join(gsdRoot(basePath), "runtime", "units");
 }
 
 function runtimePath(basePath: string, unitType: string, unitId: string): string {
-  const sanitizedUnitType = unitType.replace(/[\/]/g, "-");
-  const sanitizedUnitId = unitId.replace(/[\/]/g, "-");
+  const sanitizedUnitType = unitType.replace(/[^a-zA-Z0-9._-]+/g, "-");
+  const sanitizedUnitId = unitId.replace(/[^a-zA-Z0-9._-]+/g, "-");
   return join(runtimeDir(basePath), `${sanitizedUnitType}-${sanitizedUnitId}.json`);
 }
 
@@ -63,8 +74,6 @@ export function writeUnitRuntimeRecord(
   startedAt: number,
   updates: Partial<AutoUnitRuntimeRecord> = {},
 ): AutoUnitRuntimeRecord {
-  const dir = runtimeDir(basePath);
-  mkdirSync(dir, { recursive: true });
   const path = runtimePath(basePath, unitType, unitId);
   const prev = readUnitRuntimeRecord(basePath, unitType, unitId);
   const next: AutoUnitRuntimeRecord = {
@@ -84,18 +93,12 @@ export function writeUnitRuntimeRecord(
     recoveryAttempts: updates.recoveryAttempts ?? prev?.recoveryAttempts ?? 0,
     lastRecoveryReason: updates.lastRecoveryReason ?? prev?.lastRecoveryReason,
   };
-  writeFileSync(path, JSON.stringify(next, null, 2) + "\n", "utf-8");
+  saveJsonFile(path, next);
   return next;
 }
 
 export function readUnitRuntimeRecord(basePath: string, unitType: string, unitId: string): AutoUnitRuntimeRecord | null {
-  const path = runtimePath(basePath, unitType, unitId);
-  if (!existsSync(path)) return null;
-  try {
-    return JSON.parse(readFileSync(path, "utf-8")) as AutoUnitRuntimeRecord;
-  } catch {
-    return null;
-  }
+  return loadJsonFileOrNull(runtimePath(basePath, unitType, unitId), isAutoUnitRuntimeRecord);
 }
 
 export function clearUnitRuntimeRecord(basePath: string, unitType: string, unitId: string): void {

package/dist/resources/extensions/gsd/verification-evidence.ts

@@ -20,6 +20,7 @@ export interface EvidenceCheckJSON {
   exitCode: number;
   durationMs: number;
   verdict: "pass" | "fail";
+  blocking: boolean;
 }
 
 export interface RuntimeErrorJSON {
@@ -80,6 +81,7 @@ export function writeVerificationJSON(
       exitCode: check.exitCode,
       durationMs: check.durationMs,
       verdict: check.exitCode === 0 ? "pass" : "fail",
+      blocking: check.blocking,
     })),
     ...(retryAttempt !== undefined ? { retryAttempt } : {}),
     ...(maxRetries !== undefined ? { maxRetries } : {}),

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

@@ -112,7 +112,9 @@ const MAX_FAILURE_CONTEXT_CHARS = 10_000;
  * Returns an empty string when all checks pass or the checks array is empty.
  */
 export function formatFailureContext(result: VerificationResult): string {
-  const failures = result.checks.filter((c) => c.exitCode !== 0);
+  // Only include blocking failures in retry context — non-blocking (advisory) failures
+  // should not be injected into retry prompts to avoid noise pollution.
+  const failures = result.checks.filter((c) => c.exitCode !== 0 && c.blocking);
   if (failures.length === 0) return "";
 
   const blocks: string[] = [];
@@ -256,6 +258,10 @@ export function runVerificationGate(options: RunVerificationGateOptions): Verifi
     };
   }
 
+  // Commands from preference and task-plan sources are blocking;
+  // package-json discovered commands are advisory (non-blocking).
+  const blocking = source === "preference" || source === "task-plan";
+
   const checks: VerificationCheck[] = [];
 
   for (const command of commands) {
@@ -291,11 +297,16 @@ export function runVerificationGate(options: RunVerificationGateOptions): Verifi
       stdout: truncate(result.stdout, MAX_OUTPUT_BYTES),
       stderr,
       durationMs,
+      blocking,
     });
   }
 
+  // Gate passes if all blocking checks pass (non-blocking failures are advisory)
+  const blockingChecks = checks.filter(c => c.blocking);
+  const passed = blockingChecks.length === 0 || blockingChecks.every(c => c.exitCode === 0);
+
   return {
-    passed: checks.every(c => c.exitCode === 0),
+    passed,
     checks,
     discoverySource: source,
     timestamp,

package/dist/resources/extensions/remote-questions/discord-adapter.ts

@@ -2,11 +2,12 @@
  * Remote Questions — Discord adapter
  */
 
-import type { ChannelAdapter, RemotePrompt, RemoteDispatchResult, RemoteAnswer, RemotePromptRef } from "./types.js";
+import { type ChannelAdapter, type RemotePrompt, type RemoteDispatchResult, type RemoteAnswer, type RemotePromptRef } from "./types.js";
 import { formatForDiscord, parseDiscordResponse, DISCORD_NUMBER_EMOJIS } from "./format.js";
+import { apiRequest } from "./http-client.js";
 
 const DISCORD_API = "https://discord.com/api/v10";
-const PER_REQUEST_TIMEOUT_MS = 15_000;
+
 export class DiscordAdapter implements ChannelAdapter {
   readonly name = "discord" as const;
   private botUserId: string | null = null;
@@ -137,23 +138,11 @@ export class DiscordAdapter implements ChannelAdapter {
     return parseDiscordResponse([], String(replies[0].content), prompt.questions);
   }
 
-  private async discordApi(method: string, path: string, body?: unknown): Promise<any> {
-    const headers: Record<string, string> = { Authorization: `Bot ${this.token}` };
-    const init: RequestInit = { method, headers };
-    if (body) {
-      headers["Content-Type"] = "application/json";
-      init.body = JSON.stringify(body);
-    }
-
-    init.signal = AbortSignal.timeout(PER_REQUEST_TIMEOUT_MS);
-    const response = await fetch(`${DISCORD_API}${path}`, init);
-    if (response.status === 204) return {};
-    if (!response.ok) {
-      const text = await response.text().catch(() => "");
-      // Limit error body length to avoid leaking verbose Discord error responses
-      const safeText = text.length > 200 ? text.slice(0, 200) + "…" : text;
-      throw new Error(`Discord API HTTP ${response.status}: ${safeText}`);
-    }
-    return response.json();
+  private async discordApi(method: "GET" | "POST" | "PUT" | "DELETE", path: string, body?: unknown): Promise<any> {
+    return apiRequest(`${DISCORD_API}${path}`, method, body, {
+      authScheme: "Bot",
+      authToken: this.token,
+      errorLabel: "Discord API",
+    });
   }
 }

package/dist/resources/extensions/remote-questions/http-client.ts

@@ -0,0 +1,76 @@
+/**
+ * Remote Questions — shared HTTP client
+ *
+ * Centralizes timeout, error handling, and JSON serialization logic
+ * used by all channel adapters (Discord, Slack, Telegram).
+ */
+
+import { PER_REQUEST_TIMEOUT_MS } from "./types.js";
+
+export interface ApiRequestOptions {
+  /** Authorization header scheme. Omit to skip the Authorization header entirely. */
+  authScheme?: "Bearer" | "Bot";
+  /** Token for the Authorization header. Ignored when authScheme is omitted. */
+  authToken?: string;
+  /** Max chars of error body to include in thrown Error. Default 200. */
+  safeErrorLength?: number;
+  /** Label used in error messages (e.g. "Discord API", "Slack API"). Default "HTTP". */
+  errorLabel?: string;
+  /** Content-Type override. Default "application/json" when body is present. */
+  contentType?: string;
+}
+
+/**
+ * Makes an HTTP request with standardized timeout, error handling, and JSON
+ * serialization.
+ *
+ * - Sets `AbortSignal.timeout(PER_REQUEST_TIMEOUT_MS)` on every request.
+ * - Serializes `body` as JSON and sets Content-Type when provided.
+ * - Returns `{}` for 204 No Content responses.
+ * - Truncates error response bodies to `safeErrorLength` chars (default 200).
+ */
+export async function apiRequest(
+  url: string,
+  method: "GET" | "POST" | "PUT" | "DELETE",
+  body?: unknown,
+  options: ApiRequestOptions = {},
+): Promise<any> {
+  const {
+    authScheme,
+    authToken,
+    safeErrorLength = 200,
+    errorLabel = "HTTP",
+    contentType,
+  } = options;
+
+  const headers: Record<string, string> = {};
+  if (authScheme && authToken) {
+    headers["Authorization"] = `${authScheme} ${authToken}`;
+  }
+
+  const init: RequestInit = {
+    method,
+    headers,
+    signal: AbortSignal.timeout(PER_REQUEST_TIMEOUT_MS),
+  };
+
+  if (body !== undefined) {
+    headers["Content-Type"] = contentType ?? "application/json";
+    init.body = JSON.stringify(body);
+  }
+
+  const response = await fetch(url, init);
+
+  if (response.status === 204) return {};
+
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    const safeText =
+      text.length > safeErrorLength
+        ? text.slice(0, safeErrorLength) + "\u2026"
+        : text;
+    throw new Error(`${errorLabel} HTTP ${response.status}: ${safeText}`);
+  }
+
+  return response.json();
+}

package/dist/resources/extensions/remote-questions/notify.ts

@@ -9,8 +9,7 @@
 
 import { resolveRemoteConfig } from "./config.js";
 import type { ResolvedConfig } from "./config.js";
-
-const PER_REQUEST_TIMEOUT_MS = 15_000;
+import { PER_REQUEST_TIMEOUT_MS } from "./types.js";
 
 /**
  * Send a one-way notification to the configured remote channel.

package/dist/resources/extensions/remote-questions/slack-adapter.ts

@@ -2,11 +2,11 @@
  * Remote Questions — Slack adapter
  */
 
-import type { ChannelAdapter, RemotePrompt, RemoteDispatchResult, RemoteAnswer, RemotePromptRef } from "./types.js";
+import { type ChannelAdapter, type RemotePrompt, type RemoteDispatchResult, type RemoteAnswer, type RemotePromptRef } from "./types.js";
 import { formatForSlack, parseSlackReply, parseSlackReactionResponse, SLACK_NUMBER_REACTION_NAMES } from "./format.js";
+import { apiRequest } from "./http-client.js";
 
 const SLACK_API = "https://slack.com/api";
-const PER_REQUEST_TIMEOUT_MS = 15_000;
 const SLACK_ACK_REACTION = "white_check_mark";
 
 export class SlackAdapter implements ChannelAdapter {
@@ -123,26 +123,19 @@ export class SlackAdapter implements ChannelAdapter {
   }
 
   private async slackApi(method: string, params: Record<string, unknown>): Promise<Record<string, unknown>> {
-    const url = `${SLACK_API}/${method}`;
     const isGet = method === "conversations.replies" || method === "auth.test" || method === "reactions.get";
+    const opts = { authScheme: "Bearer" as const, authToken: this.token, errorLabel: "Slack API" };
 
-    let response: Response;
     if (isGet) {
-      const qs = new URLSearchParams(Object.fromEntries(Object.entries(params).map(([k, v]) => [k, String(v)]))).toString();
-      response = await fetch(`${url}?${qs}`, { method: "GET", headers: { Authorization: `Bearer ${this.token}` }, signal: AbortSignal.timeout(PER_REQUEST_TIMEOUT_MS) });
-    } else {
-      response = await fetch(url, {
-        method: "POST",
-        headers: {
-          Authorization: `Bearer ${this.token}`,
-          "Content-Type": "application/json; charset=utf-8",
-        },
-        body: JSON.stringify(params),
-        signal: AbortSignal.timeout(PER_REQUEST_TIMEOUT_MS),
-      });
+      const qs = new URLSearchParams(
+        Object.fromEntries(Object.entries(params).map(([k, v]) => [k, String(v)])),
+      ).toString();
+      return apiRequest(`${SLACK_API}/${method}?${qs}`, "GET", undefined, opts);
     }
 
-    if (!response.ok) throw new Error(`Slack API HTTP ${response.status}: ${response.statusText}`);
-    return (await response.json()) as Record<string, unknown>;
+    return apiRequest(`${SLACK_API}/${method}`, "POST", params, {
+      ...opts,
+      contentType: "application/json; charset=utf-8",
+    });
   }
 }

package/dist/resources/extensions/remote-questions/telegram-adapter.ts

@@ -2,11 +2,11 @@
  * Remote Questions — Telegram adapter
  */
 
-import type { ChannelAdapter, RemotePrompt, RemoteDispatchResult, RemoteAnswer, RemotePromptRef } from "./types.js";
+import { type ChannelAdapter, type RemotePrompt, type RemoteDispatchResult, type RemoteAnswer, type RemotePromptRef } from "./types.js";
 import { formatForTelegram, parseTelegramResponse } from "./format.js";
+import { apiRequest } from "./http-client.js";
 
 const TELEGRAM_API = "https://api.telegram.org";
-const PER_REQUEST_TIMEOUT_MS = 15_000;
 
 export class TelegramAdapter implements ChannelAdapter {
   readonly name = "telegram" as const;
@@ -139,23 +139,11 @@ export class TelegramAdapter implements ChannelAdapter {
   }
 
   private async telegramApi(method: string, params?: Record<string, unknown>): Promise<any> {
-    const url = `${TELEGRAM_API}/bot${this.token}/${method}`;
-    const init: RequestInit = {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      signal: AbortSignal.timeout(PER_REQUEST_TIMEOUT_MS),
-    };
-
-    if (params) {
-      init.body = JSON.stringify(params);
-    }
-
-    const response = await fetch(url, init);
-    if (!response.ok) {
-      const text = await response.text().catch(() => "");
-      const safeText = text.length > 200 ? text.slice(0, 200) + "…" : text;
-      throw new Error(`Telegram API HTTP ${response.status}: ${safeText}`);
-    }
-    return response.json();
+    return apiRequest(
+      `${TELEGRAM_API}/bot${this.token}/${method}`,
+      "POST",
+      params,
+      { errorLabel: "Telegram API" },
+    );
   }
 }

package/dist/resources/extensions/remote-questions/types.ts

@@ -2,6 +2,9 @@
  * Remote Questions — shared types
  */
 
+/** Timeout applied to every outbound HTTP request across all channel adapters. */
+export const PER_REQUEST_TIMEOUT_MS = 15_000;
+
 export type RemoteChannel = "slack" | "discord" | "telegram";
 
 export interface RemoteQuestionOption {

package/dist/resources/extensions/shared/mod.ts

@@ -28,3 +28,6 @@ export { showInterviewRound } from "./interview-ui.js";
 export type { Question, QuestionOption, RoundResult } from "./interview-ui.js";
 export { showNextAction } from "./next-action-ui.js";
 export { showConfirm } from "./confirm-ui.js";
+export { sanitizeError } from "./sanitize.js";
+export { formatDateShort, truncateWithEllipsis } from "./format-utils.js";
+export { splitFrontmatter, parseFrontmatterMap } from "./frontmatter.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gsd-pi",
-  "version": "2.28.0-dev.e19bf89",
+  "version": "2.29.0-dev.49d972f",
   "description": "GSD — Get Shit Done coding agent",
   "license": "MIT",
   "repository": {
@@ -35,7 +35,7 @@
     "configDir": ".gsd"
   },
   "engines": {
-    "node": ">=20.6.0"
+    "node": ">=22.0.0"
   },
   "packageManager": "npm@10.9.3",
   "scripts": {
@@ -73,6 +73,9 @@
     "validate-pack": "node scripts/validate-pack.js",
     "typecheck:extensions": "tsc --noEmit --project tsconfig.extensions.json",
     "pipeline:version-stamp": "node scripts/version-stamp.mjs",
+    "release:changelog": "node scripts/generate-changelog.mjs",
+    "release:bump": "node scripts/bump-version.mjs",
+    "release:update-changelog": "node scripts/update-changelog.mjs",
     "docker:build-runtime": "docker build --target runtime -t ghcr.io/gsd-build/gsd-pi .",
     "docker:build-builder": "docker build --target builder -t ghcr.io/gsd-build/gsd-ci-builder .",
     "prepublishOnly": "npm run sync-pkg-version && npm run sync-platform-versions && ([ \"$CI\" = 'true' ] || git diff --exit-code || (echo 'ERROR: version sync changed files — commit them before publishing' && exit 1)) && npm run build && npm run typecheck:extensions && npm run validate-pack"
@@ -117,7 +120,7 @@
     "zod-to-json-schema": "^3.24.6"
   },
   "devDependencies": {
-    "@types/node": "^22.0.0",
+    "@types/node": "^24.12.0",
     "@types/picomatch": "^4.0.2",
     "c8": "^11.0.0",
     "jiti": "^2.6.1",

package/packages/pi-coding-agent/dist/core/settings-manager.d.ts

@@ -112,6 +112,7 @@ export interface Settings {
     editorPaddingX?: number;
     autocompleteMaxVisible?: number;
     respectGitignoreInPicker?: boolean;
+    searchExcludeDirs?: string[];
     showHardwareCursor?: boolean;
     markdown?: MarkdownSettings;
     memory?: MemorySettings;
@@ -281,6 +282,8 @@ export declare class SettingsManager {
     setAutocompleteMaxVisible(maxVisible: number): void;
     getRespectGitignoreInPicker(): boolean;
     setRespectGitignoreInPicker(value: boolean): void;
+    getSearchExcludeDirs(): string[];
+    setSearchExcludeDirs(dirs: string[]): void;
     getCodeBlockIndent(): string;
     getMemorySettings(): {
         enabled: boolean;