@opengsd/gsd-pi 1.1.1-dev.a5a2de8 → 1.1.1-dev.b2556262

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

@@ -7,7 +7,7 @@ import { fileURLToPath } from "node:url";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
-import { ModelPolicyDispatchBlockedError, resolvePreferredModelConfig, resolveModelId, selectAndApplyModel } from "../auto-model-selection.js";
+import { ModelPolicyDispatchBlockedError, resolvePreferredModelConfig, resolveModelId, selectAndApplyModel, floorThinkingLevelForUnit } from "../auto-model-selection.js";
 
 function makeTempDir(prefix: string): string {
   return mkdtempSync(join(tmpdir(), prefix));
@@ -534,6 +534,304 @@ test("selectAndApplyModel re-applies captured thinking level after setModel succ
   assert.deepEqual(thinkingLevels, [{ effort: "high" }]);
 });
 
+// ─── floorThinkingLevelForUnit (#read-bash-thrash) ─────────────────────
+test("floorThinkingLevelForUnit raises minimal/low to the floor for execute-task", () => {
+  assert.equal(floorThinkingLevelForUnit("execute-task", "off" as any), "medium");
+  assert.equal(floorThinkingLevelForUnit("execute-task", "minimal" as any), "medium");
+  assert.equal(floorThinkingLevelForUnit("execute-task", "low" as any), "medium");
+});
+
+test("floorThinkingLevelForUnit never lowers a level already at/above the floor", () => {
+  assert.equal(floorThinkingLevelForUnit("execute-task", "medium" as any), "medium");
+  assert.equal(floorThinkingLevelForUnit("execute-task", "high" as any), "high");
+  assert.equal(floorThinkingLevelForUnit("execute-task", "xhigh" as any), "xhigh");
+});
+
+test("floorThinkingLevelForUnit leaves non-execute-task units untouched", () => {
+  for (const unit of ["plan-slice", "plan-milestone", "research-milestone", "complete-slice", "validate-milestone"]) {
+    assert.equal(floorThinkingLevelForUnit(unit, "minimal" as any), "minimal");
+  }
+});
+
+test("floorThinkingLevelForUnit passes through null/undefined and unrecognized shapes", () => {
+  assert.equal(floorThinkingLevelForUnit("execute-task", null), null);
+  assert.equal(floorThinkingLevelForUnit("execute-task", undefined), undefined);
+  // A richer host snapshot object must not be coerced into a bare string.
+  const snapshot = { effort: "minimal" } as any;
+  assert.deepEqual(floorThinkingLevelForUnit("execute-task", snapshot), snapshot);
+});
+
+test("selectAndApplyModel raises minimal thinking to the floor for execute-task", async (t) => {
+  const originalCwd = process.cwd();
+  const tempProject = makeTempDir("gsd-routing-thinking-floor-");
+  const thinkingLevels: unknown[] = [];
+  t.after(() => {
+    process.chdir(originalCwd);
+    rmSync(tempProject, { recursive: true, force: true });
+  });
+
+  mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+  writeFileSync(
+    join(tempProject, ".gsd", "PREFERENCES.md"),
+    ["---", "models:", "  execute-task: claude-sonnet-4-6", "---"].join("\n"),
+    "utf-8",
+  );
+  process.chdir(tempProject);
+
+  await selectAndApplyModel(
+    {
+      modelRegistry: { getAvailable: () => [{ id: "claude-sonnet-4-6", provider: "anthropic", api: "anthropic-messages" }] },
+      sessionManager: { getSessionId: () => "test-session" },
+      ui: { notify: () => {} },
+      model: { provider: "anthropic", id: "claude-sonnet-4-6", api: "anthropic-messages" },
+    } as any,
+    {
+      setModel: async () => true,
+      setThinkingLevel: (level: unknown) => { thinkingLevels.push(level); },
+      emitBeforeModelSelect: async () => undefined,
+      getActiveTools: () => [],
+      emitAdjustToolSet: async () => undefined,
+      setActiveTools: () => {},
+    } as any,
+    "execute-task",
+    "M001/S01/T01",
+    tempProject,
+    undefined,
+    false,
+    { provider: "anthropic", id: "claude-sonnet-4-6" },
+    undefined,
+    true,
+    undefined,
+    "minimal" as any,
+  );
+
+  assert.deepEqual(thinkingLevels, ["medium"]);
+});
+
+test("selectAndApplyModel capability-clamps an unsupported thinking level (ADR-026)", async (t) => {
+  const originalCwd = process.cwd();
+  const tempProject = makeTempDir("gsd-routing-thinking-clamp-");
+  const thinkingLevels: unknown[] = [];
+  t.after(() => {
+    process.chdir(originalCwd);
+    rmSync(tempProject, { recursive: true, force: true });
+  });
+
+  // Reasoning-capable model whose map omits xhigh → xhigh must clamp to high.
+  const model = {
+    id: "claude-sonnet-4-6",
+    provider: "anthropic",
+    api: "anthropic-messages",
+    reasoning: true,
+    thinkingLevelMap: { low: "low", medium: "medium", high: "high" },
+  };
+  mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+  writeFileSync(
+    join(tempProject, ".gsd", "PREFERENCES.md"),
+    ["---", "models:", "  planning: claude-sonnet-4-6", "---"].join("\n"),
+    "utf-8",
+  );
+  process.chdir(tempProject);
+
+  await selectAndApplyModel(
+    {
+      modelRegistry: { getAvailable: () => [model] },
+      sessionManager: { getSessionId: () => "test-session" },
+      ui: { notify: () => {} },
+      model: { provider: "anthropic", id: "claude-sonnet-4-6", api: "anthropic-messages" },
+    } as any,
+    {
+      setModel: async () => true,
+      setThinkingLevel: (level: unknown) => { thinkingLevels.push(level); },
+      emitBeforeModelSelect: async () => undefined,
+      getActiveTools: () => [],
+      emitAdjustToolSet: async () => undefined,
+      setActiveTools: () => {},
+    } as any,
+    "plan-slice",
+    "M001/S01",
+    tempProject,
+    undefined,
+    false,
+    { provider: "anthropic", id: "claude-sonnet-4-6" },
+    undefined,
+    true,
+    undefined,
+    "xhigh" as any,
+  );
+
+  assert.deepEqual(thinkingLevels, ["high"]);
+});
+
+test("selectAndApplyModel applies an explicit per-phase thinking level (ADR-026)", async (t) => {
+  const originalCwd = process.cwd();
+  const tempProject = makeTempDir("gsd-routing-thinking-explicit-");
+  const thinkingLevels: unknown[] = [];
+  t.after(() => {
+    process.chdir(originalCwd);
+    rmSync(tempProject, { recursive: true, force: true });
+  });
+
+  const model = {
+    id: "claude-sonnet-4-6",
+    provider: "anthropic",
+    api: "anthropic-messages",
+    reasoning: true,
+    thinkingLevelMap: { low: "low", medium: "medium", high: "high", xhigh: "xhigh" },
+  };
+  mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+  writeFileSync(
+    join(tempProject, ".gsd", "PREFERENCES.md"),
+    ["---", "models:", "  planning:", "    model: claude-sonnet-4-6", "    thinking: xhigh", "---"].join("\n"),
+    "utf-8",
+  );
+  process.chdir(tempProject);
+
+  await selectAndApplyModel(
+    {
+      modelRegistry: { getAvailable: () => [model] },
+      sessionManager: { getSessionId: () => "test-session" },
+      ui: { notify: () => {} },
+      model: { provider: "anthropic", id: "claude-sonnet-4-6", api: "anthropic-messages" },
+    } as any,
+    {
+      setModel: async () => true,
+      setThinkingLevel: (level: unknown) => { thinkingLevels.push(level); },
+      emitBeforeModelSelect: async () => undefined,
+      getActiveTools: () => [],
+      emitAdjustToolSet: async () => undefined,
+      setActiveTools: () => {},
+    } as any,
+    "plan-slice",
+    "M001/S01",
+    tempProject,
+    undefined,
+    false,
+    { provider: "anthropic", id: "claude-sonnet-4-6" },
+    undefined,
+    true,
+    undefined,
+    // Session level is "low"; the explicit planning thinking (xhigh) must win.
+    "low" as any,
+  );
+
+  assert.deepEqual(thinkingLevels, ["xhigh"]);
+});
+
+test("selectAndApplyModel applies explicit thinking with no model pin (interactive, ADR-026)", async (t) => {
+  const originalCwd = process.cwd();
+  const tempProject = makeTempDir("gsd-routing-thinking-nomodel-");
+  const thinkingLevels: unknown[] = [];
+  t.after(() => {
+    process.chdir(originalCwd);
+    rmSync(tempProject, { recursive: true, force: true });
+  });
+
+  const model = {
+    id: "claude-sonnet-4-6",
+    provider: "anthropic",
+    api: "anthropic-messages",
+    reasoning: true,
+    thinkingLevelMap: { low: "low", medium: "medium", high: "high", xhigh: "xhigh" },
+  };
+  mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+  // A `thinking:` block with NO models config — the interactive guided-flow
+  // scenario the bug report flagged (no per-phase model, no start model).
+  writeFileSync(
+    join(tempProject, ".gsd", "PREFERENCES.md"),
+    ["---", "thinking:", "  planning: high", "---"].join("\n"),
+    "utf-8",
+  );
+  process.chdir(tempProject);
+
+  await selectAndApplyModel(
+    {
+      modelRegistry: { getAvailable: () => [model] },
+      sessionManager: { getSessionId: () => "test-session" },
+      ui: { notify: () => {} },
+      model: { provider: "anthropic", id: "claude-sonnet-4-6", api: "anthropic-messages" },
+    } as any,
+    {
+      setModel: async () => true,
+      setThinkingLevel: (level: unknown) => { thinkingLevels.push(level); },
+      emitBeforeModelSelect: async () => undefined,
+      getActiveTools: () => [],
+      emitAdjustToolSet: async () => undefined,
+      setActiveTools: () => {},
+    } as any,
+    "plan-slice",
+    "M001/S01",
+    tempProject,
+    undefined,
+    false,
+    null,            // no autoModeStartModel
+    undefined,
+    false,           // isAutoMode = false (interactive)
+    undefined,
+    undefined,       // no captured session thinking level
+  );
+
+  // No model branch runs, but the explicit block thinking must still apply.
+  assert.deepEqual(thinkingLevels, ["high"]);
+});
+
+test("selectAndApplyModel clamps explicit no-model thinking via ctx.model when registry lookup fails (ADR-026)", async (t) => {
+  const originalCwd = process.cwd();
+  const tempProject = makeTempDir("gsd-routing-thinking-ctxmodel-");
+  const thinkingLevels: unknown[] = [];
+  t.after(() => {
+    process.chdir(originalCwd);
+    rmSync(tempProject, { recursive: true, force: true });
+  });
+
+  // ctx.model carries reasoning capability (map omits xhigh) but the registry
+  // returns nothing, so resolveModelId fails and ctx.model is the clamp source.
+  const ctxModel = {
+    id: "claude-sonnet-4-6",
+    provider: "anthropic",
+    api: "anthropic-messages",
+    reasoning: true,
+    thinkingLevelMap: { low: "low", medium: "medium", high: "high" },
+  };
+  mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+  writeFileSync(
+    join(tempProject, ".gsd", "PREFERENCES.md"),
+    ["---", "thinking:", "  planning: xhigh", "---"].join("\n"),
+    "utf-8",
+  );
+  process.chdir(tempProject);
+
+  await selectAndApplyModel(
+    {
+      modelRegistry: { getAvailable: () => [] },   // registry lookup fails
+      sessionManager: { getSessionId: () => "test-session" },
+      ui: { notify: () => {} },
+      model: ctxModel,
+    } as any,
+    {
+      setModel: async () => true,
+      setThinkingLevel: (level: unknown) => { thinkingLevels.push(level); },
+      emitBeforeModelSelect: async () => undefined,
+      getActiveTools: () => [],
+      emitAdjustToolSet: async () => undefined,
+      setActiveTools: () => {},
+    } as any,
+    "plan-slice",
+    "M001/S01",
+    tempProject,
+    undefined,
+    false,
+    null,
+    undefined,
+    false,
+    undefined,
+    undefined,
+  );
+
+  // xhigh is unsupported by ctx.model → clamped to high, never sent verbatim.
+  assert.deepEqual(thinkingLevels, ["high"]);
+});
+
 test("resolveModelId: anthropic wins over claude-code when session provider is not claude-code", () => {
   const availableModels = [
     { id: "claude-sonnet-4-6", provider: "claude-code" },

package/src/resources/extensions/gsd/tests/auto-paused-ui-cleanup.test.ts

@@ -173,6 +173,38 @@ test("cleanupAfterLoopExit preserves completion closeout surface after stopAuto
   }
 });
 
+test("cleanupAfterLoopExit clears completionStopInProgress even when preserveStepSurfaceAfterLoopExit is also set", async () => {
+  const statusCalls: unknown[] = [];
+  const widgetCalls: unknown[] = [];
+
+  autoSession.reset();
+  autoSession.active = true;
+  autoSession.paused = false;
+  autoSession.completionStopInProgress = true;
+  autoSession.preserveStepSurfaceAfterLoopExit = true;
+
+  try {
+    await cleanupAfterLoopExit({
+      hasUI: true,
+      ui: {
+        setStatus: (...args: unknown[]) => statusCalls.push(args),
+        setWidget: (...args: unknown[]) => widgetCalls.push(args),
+        setHeader: () => {},
+        notify: () => {},
+      },
+    } as any);
+
+    assert.equal(
+      autoSession.completionStopInProgress,
+      false,
+      "completionStopInProgress must be cleared even when preserveStepSurfaceAfterLoopExit was also set",
+    );
+    assert.equal(autoSession.preserveStepSurfaceAfterLoopExit, false);
+  } finally {
+    autoSession.reset();
+  }
+});
+
 test("pauseAuto preserves artifact retry counts across pause/resume", async () => {
   const base = mkdtempSync(join(tmpdir(), "gsd-pause-retry-count-"));
   const previousCwd = process.cwd();

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

@@ -207,6 +207,7 @@ test("runFinalize merges a verified complete-milestone immediately and only once
   const startedAt = Date.now();
   let lifecycleMergeCalls = 0;
   let resolverMergeCalls = 0;
+  const stopAutoCalls: Array<{ reason?: string; options?: unknown }> = [];
   s.basePath = base;
   s.originalBasePath = base;
   s.currentMilestoneId = "M001";
@@ -219,6 +220,9 @@ test("runFinalize merges a verified complete-milestone immediately and only once
   const result = await runFinalizeWithDeps(s, {
     preflightCleanRoot: () => ({ stashPushed: false }),
     postflightPopStash: () => ({ needsManualRecovery: false }),
+    stopAuto: async (_ctx: unknown, _pi: unknown, reason?: string, options?: unknown) => {
+      stopAutoCalls.push({ reason, options });
+    },
     resolver: {
       mergeAndExit() {
         resolverMergeCalls++;
@@ -232,10 +236,19 @@ test("runFinalize merges a verified complete-milestone immediately and only once
     },
   });
 
-  assert.equal(result.action, "next");
+  assert.equal(result.action, "break");
+  assert.equal(result.reason, "milestone-complete");
   assert.equal(lifecycleMergeCalls, 1);
   assert.equal(resolverMergeCalls, 0);
   assert.equal(s.milestoneMergedInPhases, true);
+  assert.equal(stopAutoCalls.length, 1);
+  assert.equal(stopAutoCalls[0]?.reason, "Milestone M001 complete");
+  assert.deepEqual(stopAutoCalls[0]?.options, {
+    completionWidget: {
+      milestoneId: "M001",
+      milestoneTitle: "Milestone",
+    },
+  });
 
   s.currentUnit = {
     type: "complete-milestone",
@@ -245,6 +258,9 @@ test("runFinalize merges a verified complete-milestone immediately and only once
   const second = await runFinalizeWithDeps(s, {
     preflightCleanRoot: () => ({ stashPushed: false }),
     postflightPopStash: () => ({ needsManualRecovery: false }),
+    stopAuto: async (_ctx: unknown, _pi: unknown, reason?: string, options?: unknown) => {
+      stopAutoCalls.push({ reason, options });
+    },
     resolver: {
       mergeAndExit() {
         resolverMergeCalls++;
@@ -258,9 +274,11 @@ test("runFinalize merges a verified complete-milestone immediately and only once
     },
   });
 
-  assert.equal(second.action, "next");
+  assert.equal(second.action, "break");
+  assert.equal(second.reason, "milestone-complete");
   assert.equal(lifecycleMergeCalls, 1);
   assert.equal(resolverMergeCalls, 0);
+  assert.equal(stopAutoCalls.length, 2);
 });
 
 test("runFinalize does not render next-phase handoff for complete-milestone", async (t) => {
@@ -302,7 +320,7 @@ test("runFinalize does not render next-phase handoff for complete-milestone", as
     },
   );
 
-  assert.equal(result.action, "next");
+  assert.equal(result.action, "break");
   assert.equal(
     widgetCalls.some(([key]) => key === "gsd-outcome"),
     false,
@@ -310,6 +328,60 @@ test("runFinalize does not render next-phase handoff for complete-milestone", as
   );
 });
 
+test("runFinalize clears gsd-step and gsd-progress before stopAuto on complete-milestone", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-finalize-stale-widget-"));
+  t.after(() => {
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  const s = new AutoSession();
+  s.basePath = base;
+  s.originalBasePath = base;
+  s.currentMilestoneId = "M001";
+  s.currentUnit = {
+    type: "complete-milestone",
+    id: "M001",
+    startedAt: Date.now(),
+  };
+
+  const statusCalls: Array<[string, unknown]> = [];
+  const widgetCalls: Array<[string, unknown]> = [];
+
+  await runFinalizeWithDeps(
+    s,
+    {
+      preflightCleanRoot: () => ({ stashPushed: false }),
+      postflightPopStash: () => ({ needsManualRecovery: false }),
+      lifecycle: {
+        exitMilestone() {
+          return { ok: true, merged: true, codeFilesChanged: false };
+        },
+      },
+    },
+    {
+      hasUI: true,
+      ui: {
+        notify() {},
+        setStatus(key: string, value: unknown) {
+          statusCalls.push([key, value]);
+        },
+        setWidget(key: string, value: unknown) {
+          widgetCalls.push([key, value]);
+        },
+      },
+    },
+  );
+
+  assert.ok(
+    statusCalls.some(([key, val]) => key === "gsd-step" && val === undefined),
+    "gsd-step status should be cleared before stopAuto",
+  );
+  assert.ok(
+    widgetCalls.some(([key, val]) => key === "gsd-progress" && val === undefined),
+    "gsd-progress widget should be cleared before stopAuto",
+  );
+});
+
 test("runFinalize stops before merge when an isolated unit leaks app files into project root", async (t) => {
   const root = mkdtempSync(join(tmpdir(), "gsd-root-leak-root-"));
   const worktree = join(root, ".gsd", "worktrees", "M001");

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

@@ -9,7 +9,7 @@ import { randomUUID } from "node:crypto";
 
 import { verifyExpectedArtifact, hasImplementationArtifacts, resolveExpectedArtifactPath, diagnoseExpectedArtifact, diagnoseWorktreeIntegrityFailure, buildLoopRemediationSteps, writeBlockerPlaceholder, refreshRecoveryDbForArtifact, writeReactiveExecuteBlocker } from "../auto-recovery.ts";
 import { resolveMilestoneFile } from "../paths.ts";
-import { openDatabase, closeDatabase, insertMilestone, insertSlice, insertGateRow, insertTask, insertAssessment, getMilestone, getMilestoneCommitAttributionShas, getTask } from "../gsd-db.ts";
+import { openDatabase, closeDatabase, insertMilestone, insertSlice, insertGateRow, insertTask, insertAssessment, getMilestone, getMilestoneCommitAttributionShas, getTask, saveGateResult } from "../gsd-db.ts";
 import { readEvents } from "../workflow-events.ts";
 import { clearParseCache } from "../files.ts";
 import { parseRoadmap } from "../parsers-legacy.ts";
@@ -1613,6 +1613,27 @@ test("verifyExpectedArtifact checks pending gate-evaluate artifacts without ESM
   assert.equal(verified, false, "pending gates should keep gate-evaluate unverified");
 });
 
+test("verifyExpectedArtifact fails closed for gate-evaluate when the DB is unavailable", () => {
+  const base = makeTmpProject();
+  closeDatabase();
+
+  const verified = verifyExpectedArtifact("gate-evaluate", "M001/S01/gates+Q3", base);
+
+  assert.equal(verified, false, "gate-evaluate must verify against the DB-backed gate rows");
+});
+
+test("verifyExpectedArtifact ignores complete-slice gates in stale gate-evaluate unit ids", () => {
+  const base = makeTmpProject();
+  insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q4", scope: "slice" });
+  insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q8", scope: "slice" });
+  saveGateResult({ milestoneId: "M001", sliceId: "S01", gateId: "Q3", verdict: "pass", rationale: "OK", findings: "" });
+  saveGateResult({ milestoneId: "M001", sliceId: "S01", gateId: "Q4", verdict: "pass", rationale: "OK", findings: "" });
+
+  const verified = verifyExpectedArtifact("gate-evaluate", "M001/S01/gates+Q3,Q4,Q8", base);
+
+  assert.equal(verified, true, "pending Q8 belongs to complete-slice and must not keep gate-evaluate unverified");
+});
+
 // ─── #4414 regressions ────────────────────────────────────────────────────────
 
 test("#4414: writeBlockerPlaceholder invalidates path cache so dispatch guard sees file", () => {

package/src/resources/extensions/gsd/tests/auto-supervisor.test.mjs

@@ -20,6 +20,10 @@ test('resolveAutoSupervisorConfig provides safe timeout defaults', () => {
     assert.equal(supervisor.soft_timeout_minutes, 20);
     assert.equal(supervisor.idle_timeout_minutes, 10);
     assert.equal(supervisor.hard_timeout_minutes, 30);
+    // A single hung tool gets its own short budget, well below the idle window,
+    // so a genuinely stuck tool is recovered in minutes instead of waiting out
+    // the full idle timeout.
+    assert.equal(supervisor.stalled_tool_timeout_minutes, 5);
   } finally {
     if (previousGsdHome === undefined) {
       delete process.env.GSD_HOME;

package/src/resources/extensions/gsd/tests/before-provider-context-management.test.ts

@@ -0,0 +1,145 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { _setAutoActiveForTest } from "../auto.ts";
+import { autoSession } from "../auto-runtime-state.js";
+import { registerHooks } from "../bootstrap/register-hooks.ts";
+
+type HookHandler = (event: any, ctx?: any) => Promise<any> | any;
+
+function createHookHandlers(): Map<string, HookHandler[]> {
+  const handlers = new Map<string, HookHandler[]>();
+  const pi = {
+    on(event: string, handler: HookHandler) {
+      const existing = handlers.get(event) ?? [];
+      existing.push(handler);
+      handlers.set(event, existing);
+    },
+  };
+
+  registerHooks(pi as any, []);
+  return handlers;
+}
+
+function requireHook(handlers: Map<string, HookHandler[]>, event: string): HookHandler {
+  const handler = handlers.get(event)?.[0];
+  assert.ok(handler, `${event} hook should be registered`);
+  return handler;
+}
+
+test("before_provider_request truncates tool results outside auto-mode", async (t) => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-before-provider-context-"));
+  const gsdHome = join(dir, "home");
+  const project = join(dir, "project");
+  const previousCwd = process.cwd();
+  const previousGsdHome = process.env.GSD_HOME;
+
+  mkdirSync(join(project, ".gsd"), { recursive: true });
+  mkdirSync(gsdHome, { recursive: true });
+  writeFileSync(
+    join(project, ".gsd", "PREFERENCES.md"),
+    [
+      "---",
+      "version: 1",
+      "context_management:",
+      "  tool_result_max_chars: 200",
+      "  observation_mask_turns: 1",
+      "---",
+      "",
+    ].join("\n"),
+    "utf-8",
+  );
+
+  process.env.GSD_HOME = gsdHome;
+  process.chdir(project);
+  _setAutoActiveForTest(false);
+
+  t.after(() => {
+    _setAutoActiveForTest(false);
+    process.chdir(previousCwd);
+    if (previousGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = previousGsdHome;
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  const beforeProviderRequest = requireHook(createHookHandlers(), "before_provider_request");
+  const messageText = "m".repeat(250);
+  const responsesOutput = "r".repeat(250);
+  const payload = {
+    messages: [
+      { role: "user", content: [{ type: "text", text: "keep me" }] },
+      {
+        role: "toolResult",
+        toolCallId: "toolu_test",
+        toolName: "Read",
+        isError: false,
+        content: [{ type: "text", text: messageText }],
+      },
+    ],
+    input: [
+      { role: "user", content: [{ type: "input_text", text: "keep me" }] },
+      { type: "function_call_output", call_id: "call_test", output: responsesOutput },
+    ],
+  };
+
+  await beforeProviderRequest({ payload });
+
+  const truncatedMessage = (payload.messages[1]?.content as Array<{ text?: string }>)[0]?.text ?? "";
+  const truncatedResponsesOutput = String(payload.input[1]?.output ?? "");
+
+  assert.match(truncatedMessage, /\[truncated\]/);
+  assert.match(truncatedResponsesOutput, /\[truncated\]/);
+  assert.ok(truncatedMessage.length < messageText.length);
+  assert.ok(truncatedResponsesOutput.length < responsesOutput.length);
+  assert.doesNotMatch(truncatedMessage, /result masked/);
+  assert.doesNotMatch(truncatedResponsesOutput, /result masked/);
+});
+
+test("successful shell result clears source context before provider injection", async (t) => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-before-provider-source-"));
+  const project = join(dir, "project");
+  mkdirSync(project, { recursive: true });
+  writeFileSync(join(project, "app.ts"), "export const value = 'before';\n");
+
+  autoSession.reset();
+  autoSession.active = true;
+  autoSession.basePath = project;
+  autoSession.setCurrentUnit({
+    type: "execute-task",
+    id: "M001/S01/T01",
+    startedAt: 123,
+    workspaceRoot: project,
+  });
+  autoSession.sourceObservations.observeRead({ path: "app.ts" });
+
+  t.after(() => {
+    autoSession.reset();
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  assert.match(autoSession.sourceObservations.renderActiveBlock() ?? "", /before/);
+
+  const handlers = createHookHandlers();
+  const toolResult = requireHook(handlers, "tool_result");
+  const beforeProviderRequest = requireHook(handlers, "before_provider_request");
+
+  await toolResult({
+    toolCallId: "toolu_bash",
+    toolName: "bash",
+    input: { command: "printf after > app.ts" },
+    isError: false,
+    result: "ok",
+  }, { cwd: project });
+
+  const payload = {
+    messages: [{ role: "user", content: [{ type: "text", text: "continue" }] }],
+  };
+  await beforeProviderRequest({ payload });
+
+  assert.equal(autoSession.sourceObservations.renderActiveBlock(), null);
+  assert.equal(payload.messages.length, 1);
+  assert.doesNotMatch(payload.messages[0].content[0].text, /Source Context Block/);
+});

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

@@ -76,3 +76,12 @@ test('BUNDLED_SKILL_TRIGGERS: skill ids are unique', () => {
     seen.add(skill);
   }
 });
+
+test('BUNDLED_SKILL_TRIGGERS: gsd-browser and agent-browser stay distinct', () => {
+  const gsdBrowser = BUNDLED_SKILL_TRIGGERS.find(entry => entry.skill === 'gsd-browser');
+  const agentBrowser = BUNDLED_SKILL_TRIGGERS.find(entry => entry.skill === 'agent-browser');
+
+  assert.ok(gsdBrowser, 'gsd-browser trigger should be registered');
+  assert.ok(agentBrowser, 'agent-browser trigger should be registered');
+  assert.notStrictEqual(gsdBrowser.trigger, agentBrowser.trigger);
+});