gsd-pi 2.28.0-dev.853dfc5 → 2.28.0-dev.a8d3050

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

@@ -45,12 +45,6 @@ import { handleCleanupBranches, handleCleanupSnapshots, handleSkip, handleDryRun
 import { handleDoctor, handleSteer, handleCapture, handleTriage, handleKnowledge, handleRunHook, handleUpdate, handleSkillHealth } from "./commands-handlers.js";
 import { handleLogs } from "./commands-logs.js";
 
-// ─── Re-exports (preserve public API surface) ───────────────────────────────
-export { handlePrefs, handlePrefsMode, handlePrefsWizard, ensurePreferencesFile, handleImportClaude, buildCategorySummaries, serializePreferencesToFrontmatter, yamlSafeString, configureMode } from "./commands-prefs-wizard.js";
-export { TOOL_KEYS, loadToolApiKeys, getConfigAuthStorage, handleConfig } from "./commands-config.js";
-export { type InspectData, formatInspectOutput, handleInspect } from "./commands-inspect.js";
-export { handleCleanupBranches, handleCleanupSnapshots, handleSkip, handleDryRun } from "./commands-maintenance.js";
-export { handleDoctor, handleSteer, handleCapture, handleTriage, handleKnowledge, handleRunHook, handleUpdate, handleSkillHealth } from "./commands-handlers.js";
 
 export function dispatchDoctorHeal(pi: ExtensionAPI, scope: string | undefined, reportText: string, structuredIssues: string): void {
   const workflowPath = process.env.GSD_WORKFLOW_PATH ?? join(process.env.HOME ?? "~", ".pi", "GSD-WORKFLOW.md");
@@ -846,7 +840,7 @@ function showHelp(ctx: ExtensionCommandContext): void {
     "  /gsd init           Project init wizard — detect, configure, bootstrap .gsd/",
     "  /gsd setup          Global setup status  [llm|search|remote|keys|prefs]",
     "  /gsd mode           Set workflow mode (solo/team)  [global|project]",
-    "  /gsd prefs          Manage preferences  [global|project|status|wizard|setup]",
+    "  /gsd prefs          Manage preferences  [global|project|status|wizard|setup|import-claude]",
     "  /gsd config         Set API keys for external tools",
     "  /gsd keys           API key manager  [list|add|remove|test|rotate|doctor]",
     "  /gsd hooks          Show post-unit hook configuration",

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

@@ -27,7 +27,8 @@ import { createBashTool, createWriteTool, createReadTool, createEditTool, isTool
 import { Type } from "@sinclair/typebox";
 
 import { debugLog, debugTime } from "./debug-logger.js";
-import { registerGSDCommand, loadToolApiKeys } from "./commands.js";
+import { registerGSDCommand } from "./commands.js";
+import { loadToolApiKeys } from "./commands-config.js";
 import { registerExitCommand } from "./exit-command.js";
 import { registerWorktreeCommand, getWorktreeOriginalCwd, getActiveWorktreeName } from "./worktree-command.js";
 import { getActiveAutoWorktreeContext } from "./auto-worktree.js";

package/src/resources/extensions/gsd/json-persistence.ts

@@ -0,0 +1,52 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+
+/**
+ * Load a JSON file with validation, returning a default on failure.
+ * Handles missing files, corrupt JSON, and schema mismatches uniformly.
+ */
+export function loadJsonFile<T>(
+  filePath: string,
+  validate: (data: unknown) => data is T,
+  defaultFactory: () => T,
+): T {
+  try {
+    if (!existsSync(filePath)) return defaultFactory();
+    const raw = readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return validate(parsed) ? parsed : defaultFactory();
+  } catch {
+    return defaultFactory();
+  }
+}
+
+/**
+ * Load a JSON file with validation, returning null on failure.
+ * For callers that distinguish "no data" from "default data".
+ */
+export function loadJsonFileOrNull<T>(
+  filePath: string,
+  validate: (data: unknown) => data is T,
+): T | null {
+  try {
+    if (!existsSync(filePath)) return null;
+    const raw = readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return validate(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Save a JSON file, creating parent directories as needed.
+ * Non-fatal — swallows errors to prevent persistence from breaking operations.
+ */
+export function saveJsonFile<T>(filePath: string, data: T): void {
+  try {
+    mkdirSync(dirname(filePath), { recursive: true });
+    writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+  } catch {
+    // Non-fatal — don't let persistence failures break operation
+  }
+}

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

@@ -13,11 +13,11 @@
  *   4. On crash recovery or fresh start, the ledger is loaded from disk
  */
 
-import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 import type { ExtensionContext } from "@gsd/pi-coding-agent";
 import { gsdRoot } from "./paths.js";
 import { getAndClearSkills } from "./skill-telemetry.js";
+import { loadJsonFile, loadJsonFileOrNull, saveJsonFile } from "./json-persistence.js";
 
 // Re-export from shared — canonical implementation lives in format-utils.
 export { formatTokenCount } from "../shared/mod.js";
@@ -502,45 +502,31 @@ function metricsPath(base: string): string {
   return join(gsdRoot(base), "metrics.json");
 }
 
+function isMetricsLedger(data: unknown): data is MetricsLedger {
+  return (
+    typeof data === "object" &&
+    data !== null &&
+    (data as MetricsLedger).version === 1 &&
+    Array.isArray((data as MetricsLedger).units)
+  );
+}
+
+function defaultLedger(): MetricsLedger {
+  return { version: 1, projectStartedAt: Date.now(), units: [] };
+}
+
 /**
  * Load ledger from disk without initializing in-memory state.
  * Used by history/export commands outside of auto-mode.
  */
 export function loadLedgerFromDisk(base: string): MetricsLedger | null {
-  try {
-    const raw = readFileSync(metricsPath(base), "utf-8");
-    const parsed = JSON.parse(raw);
-    if (parsed.version === 1 && Array.isArray(parsed.units)) {
-      return parsed as MetricsLedger;
-    }
-  } catch {
-    // File doesn't exist or is corrupt
-  }
-  return null;
+  return loadJsonFileOrNull(metricsPath(base), isMetricsLedger);
 }
 
 function loadLedger(base: string): MetricsLedger {
-  try {
-    const raw = readFileSync(metricsPath(base), "utf-8");
-    const parsed = JSON.parse(raw);
-    if (parsed.version === 1 && Array.isArray(parsed.units)) {
-      return parsed as MetricsLedger;
-    }
-  } catch {
-    // File doesn't exist or is corrupt — start fresh
-  }
-  return {
-    version: 1,
-    projectStartedAt: Date.now(),
-    units: [],
-  };
+  return loadJsonFile(metricsPath(base), isMetricsLedger, defaultLedger);
 }
 
 function saveLedger(base: string, data: MetricsLedger): void {
-  try {
-    mkdirSync(gsdRoot(base), { recursive: true });
-    writeFileSync(metricsPath(base), JSON.stringify(data, null, 2) + "\n", "utf-8");
-  } catch {
-    // Don't let metrics failures break auto-mode
-  }
+  saveJsonFile(metricsPath(base), data);
 }

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

@@ -137,14 +137,6 @@ export function clearPathCache(): void {
 
 // ─── Name Builders ─────────────────────────────────────────────────────────
 
-/**
- * Build a directory name from an ID.
- * ("M001") → "M001"
- */
-export function buildDirName(id: string): string {
-  return id;
-}
-
 /**
  * Build a milestone-level file name.
  * ("M001", "CONTEXT") → "M001-CONTEXT.md"

package/src/resources/extensions/gsd/routing-history.ts

@@ -2,10 +2,10 @@
 // Tracks success/failure per tier per unit-type pattern to improve
 // classification accuracy over time.
 
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { gsdRoot } from "./paths.js";
 import type { ComplexityTier } from "./types.js";
+import { loadJsonFile, saveJsonFile } from "./json-persistence.js";
 
 // ─── Types ───────────────────────────────────────────────────────────────────
 
@@ -267,24 +267,20 @@ function historyPath(base: string): string {
   return join(gsdRoot(base), HISTORY_FILE);
 }
 
+function isRoutingHistoryData(data: unknown): data is RoutingHistoryData {
+  return (
+    typeof data === "object" &&
+    data !== null &&
+    (data as RoutingHistoryData).version === 1 &&
+    typeof (data as RoutingHistoryData).patterns === "object" &&
+    (data as RoutingHistoryData).patterns !== null
+  );
+}
+
 function loadHistory(base: string): RoutingHistoryData {
-  try {
-    const raw = readFileSync(historyPath(base), "utf-8");
-    const parsed = JSON.parse(raw);
-    if (parsed.version === 1 && parsed.patterns) {
-      return parsed as RoutingHistoryData;
-    }
-  } catch {
-    // File doesn't exist or is corrupt — start fresh
-  }
-  return createEmptyHistory();
+  return loadJsonFile(historyPath(base), isRoutingHistoryData, createEmptyHistory);
 }
 
 function saveHistory(base: string, data: RoutingHistoryData): void {
-  try {
-    mkdirSync(gsdRoot(base), { recursive: true });
-    writeFileSync(historyPath(base), JSON.stringify(data, null, 2) + "\n", "utf-8");
-  } catch {
-    // Non-fatal — don't let history failures break auto-mode
-  }
+  saveJsonFile(historyPath(base), data);
 }

package/src/resources/extensions/gsd/tests/gsd-inspect.test.ts

@@ -3,7 +3,7 @@
 // Tests the pure formatInspectOutput function with known data.
 
 import { createTestContext } from './test-helpers.ts';
-import { formatInspectOutput, type InspectData } from '../commands.ts';
+import { formatInspectOutput, type InspectData } from '../commands-inspect.ts';
 
 const { assertEq, assertTrue, assertMatch, report } = createTestContext();
 

package/src/resources/extensions/gsd/tests/verification-evidence.test.ts

@@ -58,6 +58,7 @@ test("verification-evidence: writeVerificationJSON writes correct JSON shape", (
           stdout: "all good",
           stderr: "",
           durationMs: 2340,
+          blocking: true,
         },
       ],
     });
@@ -105,9 +106,9 @@ test("verification-evidence: writeVerificationJSON maps exitCode to verdict corr
     const result = makeResult({
       passed: false,
       checks: [
-        { command: "lint", exitCode: 0, stdout: "", stderr: "", durationMs: 100 },
-        { command: "test", exitCode: 1, stdout: "", stderr: "fail", durationMs: 200 },
-        { command: "audit", exitCode: 2, stdout: "", stderr: "err", durationMs: 300 },
+        { command: "lint", exitCode: 0, stdout: "", stderr: "", durationMs: 100, blocking: true },
+        { command: "test", exitCode: 1, stdout: "", stderr: "fail", durationMs: 200, blocking: true },
+        { command: "audit", exitCode: 2, stdout: "", stderr: "err", durationMs: 300, blocking: true },
       ],
     });
 
@@ -133,6 +134,7 @@ test("verification-evidence: writeVerificationJSON excludes stdout/stderr from o
           stdout: "hello\n",
           stderr: "some warning",
           durationMs: 50,
+          blocking: true,
         },
       ],
     });
@@ -181,8 +183,8 @@ test("verification-evidence: writeVerificationJSON uses optional unitId when pro
 test("verification-evidence: formatEvidenceTable returns markdown table with correct columns", () => {
   const result = makeResult({
     checks: [
-      { command: "npm run typecheck", exitCode: 0, stdout: "", stderr: "", durationMs: 2340 },
-      { command: "npm run lint", exitCode: 1, stdout: "", stderr: "err", durationMs: 1100 },
+      { command: "npm run typecheck", exitCode: 0, stdout: "", stderr: "", durationMs: 2340, blocking: true },
+      { command: "npm run lint", exitCode: 1, stdout: "", stderr: "err", durationMs: 1100, blocking: true },
     ],
   });
 
@@ -214,9 +216,9 @@ test("verification-evidence: formatEvidenceTable returns no-checks message for e
 test("verification-evidence: formatEvidenceTable formats duration as seconds with 1 decimal", () => {
   const result = makeResult({
     checks: [
-      { command: "fast", exitCode: 0, stdout: "", stderr: "", durationMs: 150 },
-      { command: "slow", exitCode: 0, stdout: "", stderr: "", durationMs: 2340 },
-      { command: "zero", exitCode: 0, stdout: "", stderr: "", durationMs: 0 },
+      { command: "fast", exitCode: 0, stdout: "", stderr: "", durationMs: 150, blocking: true },
+      { command: "slow", exitCode: 0, stdout: "", stderr: "", durationMs: 2340, blocking: true },
+      { command: "zero", exitCode: 0, stdout: "", stderr: "", durationMs: 0, blocking: true },
     ],
   });
 
@@ -230,8 +232,8 @@ test("verification-evidence: formatEvidenceTable uses ✅/❌ emoji for pass/fai
   const result = makeResult({
     passed: false,
     checks: [
-      { command: "pass-cmd", exitCode: 0, stdout: "", stderr: "", durationMs: 100 },
-      { command: "fail-cmd", exitCode: 1, stdout: "", stderr: "", durationMs: 200 },
+      { command: "pass-cmd", exitCode: 0, stdout: "", stderr: "", durationMs: 100, blocking: true },
+      { command: "fail-cmd", exitCode: 1, stdout: "", stderr: "", durationMs: 200, blocking: true },
     ],
   });
 
@@ -335,8 +337,8 @@ test("verification-evidence: integration — VerificationResult → JSON → tab
     const result = makeResult({
       passed: false,
       checks: [
-        { command: "npm run typecheck", exitCode: 0, stdout: "ok", stderr: "", durationMs: 1500 },
-        { command: "npm run test:unit", exitCode: 1, stdout: "", stderr: "1 failed", durationMs: 3200 },
+        { command: "npm run typecheck", exitCode: 0, stdout: "ok", stderr: "", durationMs: 1500, blocking: true },
+        { command: "npm run test:unit", exitCode: 1, stdout: "", stderr: "1 failed", durationMs: 3200, blocking: true },
       ],
       discoverySource: "package-json",
     });
@@ -390,7 +392,7 @@ test("verification-evidence: writeVerificationJSON with retryAttempt and maxRetr
     const result = makeResult({
       passed: false,
       checks: [
-        { command: "npm run lint", exitCode: 1, stdout: "", stderr: "error", durationMs: 300 },
+        { command: "npm run lint", exitCode: 1, stdout: "", stderr: "error", durationMs: 300, blocking: true },
       ],
     });
 
@@ -415,7 +417,7 @@ test("verification-evidence: writeVerificationJSON without retry params omits re
     const result = makeResult({
       passed: true,
       checks: [
-        { command: "npm run test", exitCode: 0, stdout: "ok", stderr: "", durationMs: 100 },
+        { command: "npm run test", exitCode: 0, stdout: "ok", stderr: "", durationMs: 100, blocking: true },
       ],
     });
 
@@ -441,7 +443,7 @@ test("verification-evidence: writeVerificationJSON includes runtimeErrors when p
     const result = makeResult({
       passed: false,
       checks: [
-        { command: "npm run test", exitCode: 0, stdout: "ok", stderr: "", durationMs: 100 },
+        { command: "npm run test", exitCode: 0, stdout: "ok", stderr: "", durationMs: 100, blocking: true },
       ],
       runtimeErrors: [
         { source: "bg-shell", severity: "crash", message: "Server crashed", blocking: true },
@@ -473,7 +475,7 @@ test("verification-evidence: writeVerificationJSON omits runtimeErrors when abse
     const result = makeResult({
       passed: true,
       checks: [
-        { command: "npm run lint", exitCode: 0, stdout: "", stderr: "", durationMs: 50 },
+        { command: "npm run lint", exitCode: 0, stdout: "", stderr: "", durationMs: 50, blocking: true },
       ],
     });
 
@@ -512,7 +514,7 @@ test("verification-evidence: formatEvidenceTable appends runtime errors section"
   const result = makeResult({
     passed: false,
     checks: [
-      { command: "npm run test", exitCode: 0, stdout: "", stderr: "", durationMs: 100 },
+      { command: "npm run test", exitCode: 0, stdout: "", stderr: "", durationMs: 100, blocking: true },
     ],
     runtimeErrors: [
       { source: "bg-shell", severity: "crash", message: "Server crashed with SIGKILL", blocking: true },
@@ -537,7 +539,7 @@ test("verification-evidence: formatEvidenceTable omits runtime errors section wh
   const result = makeResult({
     passed: true,
     checks: [
-      { command: "npm run lint", exitCode: 0, stdout: "", stderr: "", durationMs: 200 },
+      { command: "npm run lint", exitCode: 0, stdout: "", stderr: "", durationMs: 200, blocking: true },
     ],
   });
 
@@ -552,7 +554,7 @@ test("verification-evidence: formatEvidenceTable truncates runtime error message
   const result = makeResult({
     passed: false,
     checks: [
-      { command: "npm run test", exitCode: 0, stdout: "", stderr: "", durationMs: 100 },
+      { command: "npm run test", exitCode: 0, stdout: "", stderr: "", durationMs: 100, blocking: true },
     ],
     runtimeErrors: [
       { source: "bg-shell", severity: "error", message: longMessage, blocking: false },
@@ -598,7 +600,7 @@ test("verification-evidence: writeVerificationJSON includes auditWarnings when p
     const result = makeResult({
       passed: true,
       checks: [
-        { command: "npm run test", exitCode: 0, stdout: "ok", stderr: "", durationMs: 100 },
+        { command: "npm run test", exitCode: 0, stdout: "ok", stderr: "", durationMs: 100, blocking: true },
       ],
       auditWarnings: SAMPLE_AUDIT_WARNINGS,
     });
@@ -627,7 +629,7 @@ test("verification-evidence: writeVerificationJSON omits auditWarnings when abse
     const result = makeResult({
       passed: true,
       checks: [
-        { command: "npm run lint", exitCode: 0, stdout: "", stderr: "", durationMs: 50 },
+        { command: "npm run lint", exitCode: 0, stdout: "", stderr: "", durationMs: 50, blocking: true },
       ],
     });
 
@@ -666,7 +668,7 @@ test("verification-evidence: formatEvidenceTable appends audit warnings section"
   const result = makeResult({
     passed: true,
     checks: [
-      { command: "npm run test", exitCode: 0, stdout: "", stderr: "", durationMs: 100 },
+      { command: "npm run test", exitCode: 0, stdout: "", stderr: "", durationMs: 100, blocking: true },
     ],
     auditWarnings: SAMPLE_AUDIT_WARNINGS,
   });
@@ -689,7 +691,7 @@ test("verification-evidence: formatEvidenceTable omits audit warnings section wh
   const result = makeResult({
     passed: true,
     checks: [
-      { command: "npm run lint", exitCode: 0, stdout: "", stderr: "", durationMs: 200 },
+      { command: "npm run lint", exitCode: 0, stdout: "", stderr: "", durationMs: 200, blocking: true },
     ],
   });
 
@@ -705,7 +707,7 @@ test("verification-evidence: integration — VerificationResult with auditWarnin
     const result = makeResult({
       passed: true,
       checks: [
-        { command: "npm run typecheck", exitCode: 0, stdout: "ok", stderr: "", durationMs: 1500 },
+        { command: "npm run typecheck", exitCode: 0, stdout: "ok", stderr: "", durationMs: 1500, blocking: true },
       ],
       auditWarnings: [
         {

package/src/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/src/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 */