gsd-pi 2.38.0-dev.add4f78 → 2.38.0-dev.d533afb

package/src/resources/extensions/gsd/tests/agent-end-retry.test.ts

@@ -1,9 +1,9 @@
 /**
- * agent-end-retry.test.ts — Regression checks for the post-#1419 agent_end model.
+ * agent-end-retry.test.ts — Regression checks for the agent_end model.
  *
- * The old recursive handleAgentEnd retry path is gone. The loop now keeps
- * pendingResolve + pendingAgentEndQueue on AutoSession, and handleAgentEnd is
- * only a thin compatibility wrapper around resolveAgentEnd().
+ * The per-unit one-shot resolve function lives at module level in auto-loop.ts
+ * (_currentResolve). handleAgentEnd is a thin compatibility wrapper around
+ * resolveAgentEnd().
  */
 
 import test from "node:test";
@@ -14,40 +14,43 @@ import { fileURLToPath } from "node:url";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const AUTO_TS_PATH = join(__dirname, "..", "auto.ts");
+const AUTO_LOOP_TS_PATH = join(__dirname, "..", "auto-loop.ts");
 const SESSION_TS_PATH = join(__dirname, "..", "auto", "session.ts");
 
 function getAutoTsSource(): string {
   return readFileSync(AUTO_TS_PATH, "utf-8");
 }
 
+function getAutoLoopTsSource(): string {
+  return readFileSync(AUTO_LOOP_TS_PATH, "utf-8");
+}
+
 function getSessionTsSource(): string {
   return readFileSync(SESSION_TS_PATH, "utf-8");
 }
 
-test("AutoSession declares pending agent_end queue state", () => {
-  const source = getSessionTsSource();
+test("auto-loop.ts declares _currentResolve for per-unit one-shot promises", () => {
+  const source = getAutoLoopTsSource();
   assert.ok(
-    source.includes("pendingResolve"),
-    "AutoSession must declare pendingResolve for the in-flight unit promise",
+    source.includes("_currentResolve"),
+    "auto-loop.ts must declare _currentResolve for the per-unit resolve function",
   );
   assert.ok(
-    source.includes("pendingAgentEndQueue"),
-    "AutoSession must declare pendingAgentEndQueue for between-iteration agent_end events",
+    source.includes("_sessionSwitchInFlight"),
+    "auto-loop.ts must declare _sessionSwitchInFlight guard",
   );
 });
 
-test("AutoSession reset clears pending agent_end queue state", () => {
+test("AutoSession no longer holds promise state (moved to auto-loop.ts module scope)", () => {
   const source = getSessionTsSource();
-  const resetIdx = source.indexOf("reset(): void");
-  assert.ok(resetIdx > -1, "AutoSession must have a reset() method");
-  const resetBlock = source.slice(resetIdx, resetIdx + 4000);
+  // Properties should NOT exist as class fields
   assert.ok(
-    resetBlock.includes("this.pendingResolve = null"),
-    "reset() must clear pendingResolve",
+    !source.includes("pendingResolve:"),
+    "AutoSession must not declare pendingResolve (moved to auto-loop.ts)",
   );
   assert.ok(
-    resetBlock.includes("this.pendingAgentEndQueue = []"),
-    "reset() must clear pendingAgentEndQueue",
+    !source.includes("pendingAgentEndQueue:"),
+    "AutoSession must not declare pendingAgentEndQueue (removed — events are dropped)",
   );
 });
 

package/src/resources/extensions/gsd/tests/auto-loop.test.ts

@@ -7,6 +7,7 @@ import {
   resolveAgentEnd,
   runUnit,
   autoLoop,
+  detectStuck,
   _resetPendingResolve,
   _setActiveSession,
   isSessionSwitchInFlight,
@@ -37,9 +38,6 @@ function makeMockSession(opts?: {
   const session = {
     active: true,
     verbose: false,
-    sessionSwitchInFlight: false,
-    pendingResolve: null,
-    pendingAgentEndQueue: [],
     cmdCtx: {
       newSession: () => {
         opts?.onNewSessionStart?.(session);
@@ -96,7 +94,6 @@ test("resolveAgentEnd resolves a pending runUnit promise", async () => {
   const ctx = makeMockCtx();
   const pi = makeMockPi();
   const s = makeMockSession();
-  _setActiveSession(s);
   const event = makeEvent();
 
   // Start runUnit — it will create the promise and send a message,
@@ -108,7 +105,6 @@ test("resolveAgentEnd resolves a pending runUnit promise", async () => {
     "task",
     "T01",
     "do stuff",
-    undefined,
   );
 
   // Give the microtask queue a tick so runUnit reaches the await
@@ -122,44 +118,35 @@ test("resolveAgentEnd resolves a pending runUnit promise", async () => {
   assert.deepEqual(result.event, event);
 });
 
-test("resolveAgentEnd queues event when no promise is pending", () => {
+test("resolveAgentEnd drops event when no promise is pending", () => {
   _resetPendingResolve();
-  const s = makeMockSession();
-  _setActiveSession(s);
 
-  // Should not throw — queues the event for the next runUnit
+  // Should not throw — event is dropped (logged as warning)
   assert.doesNotThrow(() => {
     resolveAgentEnd(makeEvent());
   });
-  assert.equal(s.pendingAgentEndQueue.length, 1, "event should be queued");
 });
 
-test("double resolveAgentEnd only resolves once (second is queued)", async () => {
+test("double resolveAgentEnd only resolves once (second is dropped)", async () => {
   _resetPendingResolve();
 
   const ctx = makeMockCtx();
   const pi = makeMockPi();
   const s = makeMockSession();
-  _setActiveSession(s);
   const event1 = makeEvent([{ id: 1 }]);
   const event2 = makeEvent([{ id: 2 }]);
 
-  const resultPromise = runUnit(ctx, pi, s, "task", "T01", "prompt", undefined);
+  const resultPromise = runUnit(ctx, pi, s, "task", "T01", "prompt");
 
   await new Promise((r) => setTimeout(r, 10));
 
   // First resolve — should work
   resolveAgentEnd(event1);
 
-  // Second resolve — should be queued (no pending promise)
+  // Second resolve — should be dropped (no pending resolver)
   assert.doesNotThrow(() => {
     resolveAgentEnd(event2);
   });
-  assert.equal(
-    s.pendingAgentEndQueue.length,
-    1,
-    "second event should be queued",
-  );
 
   const result = await resultPromise;
   assert.equal(result.status, "completed");
@@ -174,7 +161,7 @@ test("runUnit returns cancelled when session creation fails", async () => {
   const pi = makeMockPi();
   const s = makeMockSession({ newSessionThrows: "connection refused" });
 
-  const result = await runUnit(ctx, pi, s, "task", "T01", "prompt", undefined);
+  const result = await runUnit(ctx, pi, s, "task", "T01", "prompt");
 
   assert.equal(result.status, "cancelled");
   assert.equal(result.event, undefined);
@@ -190,7 +177,7 @@ test("runUnit returns cancelled when session creation times out", async () => {
   // Session returns cancelled: true (simulates the timeout race outcome)
   const s = makeMockSession({ newSessionResult: { cancelled: true } });
 
-  const result = await runUnit(ctx, pi, s, "task", "T01", "prompt", undefined);
+  const result = await runUnit(ctx, pi, s, "task", "T01", "prompt");
 
   assert.equal(result.status, "cancelled");
   assert.equal(result.event, undefined);
@@ -205,35 +192,31 @@ test("runUnit returns cancelled when s.active is false before sendMessage", asyn
   const s = makeMockSession();
   s.active = false;
 
-  const result = await runUnit(ctx, pi, s, "task", "T01", "prompt", undefined);
+  const result = await runUnit(ctx, pi, s, "task", "T01", "prompt");
 
   assert.equal(result.status, "cancelled");
   assert.equal(pi.calls.length, 0);
 });
 
-test("runUnit only arms pendingResolve after newSession completes", async () => {
+test("runUnit only arms resolve after newSession completes", async () => {
   _resetPendingResolve();
 
   let sawSwitchFlag = false;
-  let sawPendingResolve: unknown = "unset";
 
   const ctx = makeMockCtx();
   const pi = makeMockPi();
   const s = makeMockSession({
     newSessionDelayMs: 20,
-    onNewSessionStart: (session) => {
-      sawSwitchFlag = session.sessionSwitchInFlight;
-      sawPendingResolve = session.pendingResolve;
+    onNewSessionStart: () => {
+      sawSwitchFlag = isSessionSwitchInFlight();
     },
   });
-  _setActiveSession(s);
 
-  const resultPromise = runUnit(ctx, pi, s, "task", "T01", "prompt", undefined);
+  const resultPromise = runUnit(ctx, pi, s, "task", "T01", "prompt");
 
   await new Promise((r) => setTimeout(r, 30));
 
   assert.equal(sawSwitchFlag, true, "session switch guard should be active during newSession");
-  assert.equal(sawPendingResolve, null, "pendingResolve should not be armed before newSession completes");
   assert.equal(isSessionSwitchInFlight(), false, "session switch guard should clear after newSession settles");
 
   resolveAgentEnd(makeEvent());
@@ -275,24 +258,23 @@ test("auto-loop.ts contains a while keyword", () => {
   );
 });
 
-test("auto-loop.ts one-shot pattern: pendingResolve is nulled before calling resolver", () => {
+test("auto-loop.ts one-shot pattern: _currentResolve is nulled before calling resolver", () => {
   const src = readFileSync(
     resolve(import.meta.dirname, "..", "auto-loop.ts"),
     "utf-8",
   );
   // The one-shot pattern requires: save ref, null the variable, then call
-  // Look for the pattern: s.pendingResolve = null appearing before r(
   const resolveBlock = src.slice(
     src.indexOf("export function resolveAgentEnd"),
     src.indexOf("export function resolveAgentEnd") + 600,
   );
-  const nullIdx = resolveBlock.indexOf("pendingResolve = null");
+  const nullIdx = resolveBlock.indexOf("_currentResolve = null");
   const callIdx = resolveBlock.indexOf("r({");
-  assert.ok(nullIdx > 0, "should null pendingResolve in resolveAgentEnd");
+  assert.ok(nullIdx > 0, "should null _currentResolve in resolveAgentEnd");
   assert.ok(callIdx > 0, "should call resolver in resolveAgentEnd");
   assert.ok(
     nullIdx < callIdx,
-    "pendingResolve should be nulled before calling the resolver (one-shot)",
+    "_currentResolve should be nulled before calling the resolver (one-shot)",
   );
 });
 
@@ -462,8 +444,6 @@ function makeLoopSession(overrides?: Partial<Record<string, unknown>>) {
     pendingQuickTasks: [],
     sidecarQueue: [],
     autoModeStartModel: null,
-    pendingResolve: null,
-    pendingAgentEndQueue: [],
     unitDispatchCount: new Map<string, number>(),
     unitLifetimeDispatches: new Map<string, number>(),
     unitRecoveryCount: new Map<string, number>(),
@@ -1063,7 +1043,7 @@ test("handleAgentEnd in auto.ts is a thin wrapper calling resolveAgentEnd", () =
 
 // ── Stuck counter tests ──────────────────────────────────────────────────────
 
-test("stuck counter: stops when deriveState returns same unit 5 consecutive times", async () => {
+test("stuck detection: stops when sliding window detects same unit 3 consecutive times", async () => {
   _resetPendingResolve();
 
   const ctx = makeMockCtx();
@@ -1098,20 +1078,15 @@ test("stuck counter: stops when deriveState returns same unit 5 consecutive time
 
   const loopPromise = autoLoop(ctx, pi, s, deps);
 
-  // The loop will dispatch the same unit each iteration. On iteration 1, sameUnitCount
-  // starts at 0 and the unit key is set. On iterations 2-5, sameUnitCount increments.
-  // At sameUnitCount=5 (iteration 6), stopAuto is called.
-  // Each iteration requires resolving an agent_end event.
-  // But the stuck counter fires BEFORE runUnit, so we only need to resolve 4 times
-  // (iterations 1-4 each run a unit, iteration 5 increments to 5 and stops).
-
-  // Actually: iteration 1 sets lastDerivedUnit (sameUnitCount=0).
-  // Iteration 2: derivedKey === lastDerivedUnit → sameUnitCount=1.
-  // Iteration 3: sameUnitCount=2. Iteration 4: sameUnitCount=3.
-  // Iteration 5: sameUnitCount=4. Iteration 6: sameUnitCount=5 → stop.
-  // So we need to resolve 5 agent_end events (iterations 1-5 each run a unit).
+  // Sliding window: iteration 1 pushes [A], iteration 2 pushes [A,A],
+  // iteration 3 pushes [A,A,A] → Rule 2 fires (3 consecutive) → Level 1 recovery.
+  // Level 1 invalidates caches and continues. Iteration 4 pushes [A,A,A,A] →
+  // Rule 2 fires again → Level 2 hard stop.
+  // Iterations 1-3 each run a unit (3 resolves needed). Iteration 3 triggers
+  // Level 1 (cache invalidation + continue). Iteration 4 triggers Level 2 (stop
+  // before runUnit), so no 4th resolve needed.
 
-  for (let i = 0; i < 5; i++) {
+  for (let i = 0; i < 3; i++) {
     await new Promise((r) => setTimeout(r, 30));
     resolveAgentEnd(makeEvent());
   }
@@ -1126,17 +1101,13 @@ test("stuck counter: stops when deriveState returns same unit 5 consecutive time
     stopReason.includes("Stuck"),
     `stop reason should mention 'Stuck', got: ${stopReason}`,
   );
-  assert.ok(
-    stopReason.includes("execute-task"),
-    "stop reason should include unitType",
-  );
   assert.ok(
     stopReason.includes("M001/S01/T01"),
     "stop reason should include unitId",
   );
 });
 
-test("stuck counter: resets when deriveState returns a different unit", async () => {
+test("stuck detection: window resets recovery when deriveState returns a different unit", async () => {
   _resetPendingResolve();
 
   const ctx = makeMockCtx();
@@ -1197,10 +1168,11 @@ test("stuck counter: resets when deriveState returns a different unit", async ()
 
   await loopPromise;
 
-  // The counter should have reset when T02 was derived — no stuck stop
+  // Level 1 recovery fires on iteration 3 (cache invalidation + continue),
+  // then iteration 4 derives T02 — no Level 2 hard stop.
   assert.ok(
     !stopCalled,
-    "stopAuto should NOT have been called — counter reset on unit change",
+    "stopAuto should NOT have been called — different unit broke stuck pattern",
   );
   assert.ok(
     deriveCallCount >= 4,
@@ -1208,7 +1180,7 @@ test("stuck counter: resets when deriveState returns a different unit", async ()
   );
 });
 
-test("stuck counter: does not increment during verification retry", async () => {
+test("stuck detection: does not push to window during verification retry", async () => {
   _resetPendingResolve();
 
   const ctx = makeMockCtx();
@@ -1270,10 +1242,10 @@ test("stuck counter: does not increment during verification retry", async () =>
   await loopPromise;
 
   // Even though same unit was derived 4 times, verification retries should
-  // not count, so stuck counter should not have fired
+  // not push to the sliding window, so stuck detection should not have fired
   assert.ok(
     !stopReason.includes("Stuck"),
-    `stuck counter should not fire during verification retries, got: ${stopReason}`,
+    `stuck detection should not fire during verification retries, got: ${stopReason}`,
   );
   assert.equal(
     verifyCallCount,
@@ -1282,24 +1254,106 @@ test("stuck counter: does not increment during verification retry", async () =>
   );
 });
 
-test("stuck counter: logs debug output with stuck-detected phase", () => {
-  // Structural test: verify the auto-loop.ts source contains both
-  // stuck-detected and stuck-counter-reset debug log phases
+// ── detectStuck unit tests ────────────────────────────────────────────────────
+
+test("detectStuck: returns null for fewer than 2 entries", () => {
+  assert.equal(detectStuck([]), null);
+  assert.equal(detectStuck([{ key: "A" }]), null);
+});
+
+test("detectStuck: Rule 1 — same error twice in a row", () => {
+  const result = detectStuck([
+    { key: "A", error: "ENOENT: file not found" },
+    { key: "A", error: "ENOENT: file not found" },
+  ]);
+  assert.ok(result?.stuck, "should detect same error repeated");
+  assert.ok(result?.reason.includes("Same error repeated"));
+});
+
+test("detectStuck: Rule 1 — different errors do not trigger", () => {
+  const result = detectStuck([
+    { key: "A", error: "ENOENT: file not found" },
+    { key: "A", error: "EACCES: permission denied" },
+  ]);
+  assert.equal(result, null);
+});
+
+test("detectStuck: Rule 2 — same unit 3 consecutive times", () => {
+  const result = detectStuck([
+    { key: "execute-task/M001/S01/T01" },
+    { key: "execute-task/M001/S01/T01" },
+    { key: "execute-task/M001/S01/T01" },
+  ]);
+  assert.ok(result?.stuck);
+  assert.ok(result?.reason.includes("3 consecutive times"));
+});
+
+test("detectStuck: Rule 2 — 2 consecutive does not trigger", () => {
+  assert.equal(detectStuck([
+    { key: "A" },
+    { key: "A" },
+  ]), null);
+});
+
+test("detectStuck: Rule 3 — oscillation A→B→A→B", () => {
+  const result = detectStuck([
+    { key: "A" },
+    { key: "B" },
+    { key: "A" },
+    { key: "B" },
+  ]);
+  assert.ok(result?.stuck);
+  assert.ok(result?.reason.includes("Oscillation"));
+});
+
+test("detectStuck: Rule 3 — non-oscillation pattern A→B→C→B", () => {
+  assert.equal(detectStuck([
+    { key: "A" },
+    { key: "B" },
+    { key: "C" },
+    { key: "B" },
+  ]), null);
+});
+
+test("detectStuck: Rule 1 takes priority over Rule 2 when both match", () => {
+  const result = detectStuck([
+    { key: "A", error: "test error" },
+    { key: "A", error: "test error" },
+    { key: "A", error: "test error" },
+  ]);
+  assert.ok(result?.stuck);
+  // Rule 1 fires first
+  assert.ok(result?.reason.includes("Same error repeated"));
+});
+
+test("detectStuck: truncates long error strings", () => {
+  const longError = "x".repeat(500);
+  const result = detectStuck([
+    { key: "A", error: longError },
+    { key: "A", error: longError },
+  ]);
+  assert.ok(result?.stuck);
+  assert.ok(result!.reason.length < 300, "reason should be truncated");
+});
+
+test("stuck detection: logs debug output with stuck-detected phase", () => {
+  // Structural test: verify the auto-loop.ts source contains
+  // stuck-detected and stuck-counter-reset debug log phases, plus detectStuck
   const src = readFileSync(
     resolve(import.meta.dirname, "..", "auto-loop.ts"),
     "utf-8",
   );
   assert.ok(
     src.includes('"stuck-detected"'),
-    "auto-loop.ts must log phase: 'stuck-detected' when stuck counter fires",
+    "auto-loop.ts must log phase: 'stuck-detected' when stuck detection fires",
   );
   assert.ok(
     src.includes('"stuck-counter-reset"'),
-    "auto-loop.ts must log phase: 'stuck-counter-reset' when counter resets on new unit",
+    "auto-loop.ts must log phase: 'stuck-counter-reset' when recovery resets on new unit",
   );
   assert.ok(
-    src.includes("sameUnitCount"),
-    "auto-loop.ts must track sameUnitCount for stuck detection",
+    src.includes("detectStuck"),
+    "auto-loop.ts must use detectStuck for sliding window analysis",
   );
 });
 

package/src/resources/extensions/gsd/tests/doctor-providers.test.ts

@@ -47,6 +47,18 @@ function withEnv(vars: Record<string, string | undefined>, fn: () => void): void
   }
 }
 
+function withCwd(nextCwd: string, fn: () => void): void {
+  const saved = process.cwd();
+  process.chdir(nextCwd);
+  try {
+    fn();
+  } finally {
+    process.chdir(saved);
+  }
+}
+
+const PRESENT_TEST_VALUE = "configured";
+
 // ─── formatProviderReport ─────────────────────────────────────────────────────
 
 test("formatProviderReport returns fallback for empty results", () => {
@@ -312,7 +324,7 @@ test("runProviderChecks reports ok for Anthropic when GitHub Copilot env var is
   withEnv({
     ANTHROPIC_API_KEY: undefined,
     ANTHROPIC_OAUTH_TOKEN: undefined,
-    COPILOT_GITHUB_TOKEN: "ghu_copilot-token",
+    COPILOT_GITHUB_TOKEN: PRESENT_TEST_VALUE,
     GH_TOKEN: undefined,
     GITHUB_TOKEN: undefined,
     HOME: tmpHome,
@@ -336,7 +348,7 @@ test("runProviderChecks reports ok for Anthropic via GITHUB_TOKEN cross-provider
     ANTHROPIC_OAUTH_TOKEN: undefined,
     COPILOT_GITHUB_TOKEN: undefined,
     GH_TOKEN: undefined,
-    GITHUB_TOKEN: "ghp_github-token",
+    GITHUB_TOKEN: PRESENT_TEST_VALUE,
     HOME: tmpHome,
   }, () => {
     try {
@@ -354,7 +366,7 @@ test("runProviderChecks detects ANTHROPIC_OAUTH_TOKEN as valid Anthropic auth",
   const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-oauth-test-")));
   withEnv({
     ANTHROPIC_API_KEY: undefined,
-    ANTHROPIC_OAUTH_TOKEN: "oauth-token-test",
+    ANTHROPIC_OAUTH_TOKEN: PRESENT_TEST_VALUE,
     COPILOT_GITHUB_TOKEN: undefined,
     GH_TOKEN: undefined,
     GITHUB_TOKEN: undefined,
@@ -401,3 +413,74 @@ test("runProviderChecks reports ok via Copilot auth.json for Anthropic", () => {
     rmSync(tmpHome, { recursive: true, force: true });
   });
 });
+
+test("runProviderChecks uses provider-qualified anthropic-vertex model IDs", () => {
+  const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-vertex-prefix-home-")));
+  const repo = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-vertex-prefix-repo-")));
+  mkdirSync(join(repo, ".gsd"), { recursive: true });
+  writeFileSync(
+    join(repo, ".gsd", "preferences.md"),
+    [
+      "---",
+      "models:",
+      "  execution: anthropic-vertex/claude-sonnet-4-6",
+      "---",
+      "",
+    ].join("\n"),
+  );
+
+  withEnv({
+    HOME: tmpHome,
+    ANTHROPIC_API_KEY: undefined,
+    ANTHROPIC_OAUTH_TOKEN: undefined,
+    ANTHROPIC_VERTEX_PROJECT_ID: "vertex-project",
+  }, () => {
+    withCwd(repo, () => {
+      const results = runProviderChecks();
+      const vertex = results.find(r => r.name === "anthropic-vertex");
+      const anthropic = results.find(r => r.name === "anthropic");
+      assert.ok(vertex, "anthropic-vertex result should exist");
+      assert.equal(vertex!.status, "ok", "should accept ANTHROPIC_VERTEX_PROJECT_ID as configured");
+      assert.ok(!anthropic || !anthropic.required, "plain anthropic should not be required for anthropic-vertex config");
+    });
+  });
+
+  rmSync(repo, { recursive: true, force: true });
+  rmSync(tmpHome, { recursive: true, force: true });
+});
+
+test("runProviderChecks uses object provider field for anthropic-vertex models", () => {
+  const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-vertex-provider-home-")));
+  const repo = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-vertex-provider-repo-")));
+  mkdirSync(join(repo, ".gsd"), { recursive: true });
+  writeFileSync(
+    join(repo, ".gsd", "preferences.md"),
+    [
+      "---",
+      "models:",
+      "  execution:",
+      "    model: claude-sonnet-4-6",
+      "    provider: anthropic-vertex",
+      "---",
+      "",
+    ].join("\n"),
+  );
+
+  withEnv({
+    HOME: tmpHome,
+    ANTHROPIC_API_KEY: undefined,
+    ANTHROPIC_OAUTH_TOKEN: undefined,
+    ANTHROPIC_VERTEX_PROJECT_ID: undefined,
+  }, () => {
+    withCwd(repo, () => {
+      const results = runProviderChecks();
+      const vertex = results.find(r => r.name === "anthropic-vertex");
+      assert.ok(vertex, "anthropic-vertex result should exist");
+      assert.equal(vertex!.status, "error", "missing vertex config should be reported against anthropic-vertex");
+      assert.ok(vertex!.detail?.includes("ANTHROPIC_VERTEX_PROJECT_ID"), "should point to vertex setup");
+    });
+  });
+
+  rmSync(repo, { recursive: true, force: true });
+  rmSync(tmpHome, { recursive: true, force: true });
+});

package/src/resources/extensions/gsd/tests/preferences.test.ts

@@ -208,30 +208,25 @@ test("git fields comprehensive validation", () => {
   assert.equal(preferences.git?.isolation, "branch");
 });
 
-test("auto_visualize, auto_report, compression_strategy, context_selection validate correctly", () => {
+test("auto_visualize, auto_report, context_selection validate correctly", () => {
   const { preferences, errors } = validatePreferences({
     auto_visualize: true,
     auto_report: false,
-    compression_strategy: "compress",
     context_selection: "smart",
   });
   assert.equal(errors.length, 0);
   assert.equal(preferences.auto_visualize, true);
   assert.equal(preferences.auto_report, false);
-  assert.equal(preferences.compression_strategy, "compress");
   assert.equal(preferences.context_selection, "smart");
 });
 
-test("auto_visualize, auto_report, compression_strategy, context_selection reject invalid values", () => {
+test("auto_visualize, auto_report, context_selection reject invalid values", () => {
   const { errors: e1 } = validatePreferences({ auto_visualize: "yes" as never });
   assert.ok(e1.some(e => e.includes("auto_visualize")));
 
   const { errors: e2 } = validatePreferences({ auto_report: 1 as never });
   assert.ok(e2.some(e => e.includes("auto_report")));
 
-  const { errors: e3 } = validatePreferences({ compression_strategy: "shrink" as never });
-  assert.ok(e3.some(e => e.includes("compression_strategy")));
-
   const { errors: e4 } = validatePreferences({ context_selection: "partial" as never });
   assert.ok(e4.some(e => e.includes("context_selection")));
 });

package/src/resources/extensions/gsd/tests/prompt-contracts.test.ts

@@ -0,0 +1,59 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+const promptsDir = join(process.cwd(), "src/resources/extensions/gsd/prompts");
+
+function readPrompt(name: string): string {
+  return readFileSync(join(promptsDir, `${name}.md`), "utf-8");
+}
+
+test("reactive-execute prompt keeps task summaries with subagents and avoids batch commits", () => {
+  const prompt = readPrompt("reactive-execute");
+  assert.match(prompt, /subagent-written summary as authoritative/i);
+  assert.match(prompt, /Do NOT create a batch commit/i);
+  assert.doesNotMatch(prompt, /\*\*Write task summaries\*\*/i);
+  assert.doesNotMatch(prompt, /\*\*Commit\*\* all changes/i);
+});
+
+test("run-uat prompt branches on dynamic UAT mode and supports runtime evidence", () => {
+  const prompt = readPrompt("run-uat");
+  assert.match(prompt, /\*\*Detected UAT mode:\*\*\s*`\{\{uatType\}\}`/);
+  assert.match(prompt, /uatType:\s*\{\{uatType\}\}/);
+  assert.match(prompt, /live-runtime/);
+  assert.match(prompt, /browser\/runtime\/network/i);
+  assert.match(prompt, /NEEDS-HUMAN/);
+  assert.doesNotMatch(prompt, /uatType:\s*artifact-driven/);
+});
+
+test("workflow-start prompt defaults to autonomy instead of per-phase confirmation", () => {
+  const prompt = readPrompt("workflow-start");
+  assert.match(prompt, /Keep moving by default/i);
+  assert.match(prompt, /Decision gates, not ceremony/i);
+  assert.doesNotMatch(prompt, /confirm with the user before proceeding/i);
+  assert.doesNotMatch(prompt, /Gate between phases/i);
+});
+
+test("discuss prompt allows implementation questions when they materially matter", () => {
+  const prompt = readPrompt("discuss");
+  assert.match(prompt, /Lead with experience, but ask implementation when it materially matters/i);
+  assert.match(prompt, /one gate, not two/i);
+  assert.doesNotMatch(prompt, /Questions must be about the experience, not the implementation/i);
+});
+
+test("guided discussion prompts avoid wrap-up prompts after every round", () => {
+  const milestonePrompt = readPrompt("guided-discuss-milestone");
+  const slicePrompt = readPrompt("guided-discuss-slice");
+  assert.match(milestonePrompt, /Do \*\*not\*\* ask a meta "ready to wrap up\?" question after every round/i);
+  assert.match(slicePrompt, /Do \*\*not\*\* ask a meta "ready to wrap up\?" question after every round/i);
+  assert.doesNotMatch(milestonePrompt, /I think I have a solid picture of this milestone\. Ready to wrap up/i);
+  assert.doesNotMatch(slicePrompt, /I think I have a solid picture of this slice\. Ready to wrap up/i);
+});
+
+test("guided-resume-task prompt preserves recovery state until work is superseded", () => {
+  const prompt = readPrompt("guided-resume-task");
+  assert.match(prompt, /Do \*\*not\*\* delete the continue file immediately/i);
+  assert.match(prompt, /successfully completed or you have written a newer summary\/continue artifact/i);
+  assert.doesNotMatch(prompt, /Delete the continue file after reading it/i);
+});