@opengsd/gsd-pi 1.9.0 → 1.10.0

package/src/resources/extensions/gsd/tests/parallel-skill-prompt-integration.test.ts

@@ -29,12 +29,14 @@ import {
 
 const SKILL_NAME = "testskill";
 const COMPLETE_SLICE_SKILL_NAME = "complete-slice-policies";
-const SKILL_ACTIVATION_SUBSTRING = `Read the installed '${SKILL_NAME}' skill file from <available_skills>`;
-const COMPLETE_SLICE_SKILL_ACTIVATION_SUBSTRING = `Read the installed '${COMPLETE_SLICE_SKILL_NAME}' skill file from <available_skills>`;
 
 const tmpDirs: string[] = [];
 let savedCwd: string | undefined;
 
+function expectedSkillRead(base: string, name: string): string {
+  return `Read the skill file at \`${join(base, ".agents", "skills", name, "SKILL.md")}\``;
+}
+
 function setupProjectWithSkill(options: {
   skillName?: string;
   preferencesLines?: string[];
@@ -139,7 +141,7 @@ test("worker prompt (buildResearchSlicePrompt) includes <skill_activation> from
     "research-slice prompt should contain a <skill_activation> block",
   );
   assert.ok(
-    prompt.includes(SKILL_ACTIVATION_SUBSTRING),
+    prompt.includes(expectedSkillRead(base, SKILL_NAME)),
     `research-slice prompt should reference the always-used skill '${SKILL_NAME}'`,
   );
 });
@@ -164,7 +166,7 @@ test("complete-slice prompt includes <skill_activation> from unit-specific skill
     "complete-slice prompt should contain a <skill_activation> block",
   );
   assert.ok(
-    prompt.includes(COMPLETE_SLICE_SKILL_ACTIVATION_SUBSTRING),
+    prompt.includes(expectedSkillRead(base, COMPLETE_SLICE_SKILL_NAME)),
     `complete-slice prompt should reference the skill-rule skill '${COMPLETE_SLICE_SKILL_NAME}'`,
   );
 });
@@ -192,7 +194,7 @@ test("subagent dispatch prompt (buildParallelResearchSlicesPrompt) carries <skil
     `expected at least 2 <skill_activation> blocks (one per slice), got ${blockCount}`,
   );
   assert.ok(
-    prompt.includes(SKILL_ACTIVATION_SUBSTRING),
+    prompt.includes(expectedSkillRead(base, SKILL_NAME)),
     `parallel-research-slices prompt should reference the always-used skill '${SKILL_NAME}'`,
   );
   assert.ok(

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

@@ -823,6 +823,90 @@ test("pre-dispatch hook action validation via validatePreferences", () => {
   assert.ok(e3.some(e => e.includes("invalid action")));
 });
 
+test("planning_subagents validation accepts configured read-only planning specialists", () => {
+  const { preferences, errors } = validatePreferences({
+    planning_subagents: {
+      "plan-milestone": { allowed: ["security", "reviewer"] },
+      "plan-slice": { allowed: ["scout", "security", "security"] },
+    },
+  } as any);
+
+  assert.equal(errors.length, 0);
+  assert.deepEqual(preferences.planning_subagents?.["plan-milestone"]?.allowed, ["security", "reviewer"]);
+  assert.deepEqual(preferences.planning_subagents?.["plan-slice"]?.allowed, ["scout", "security"]);
+});
+
+test("planning_subagents validation rejects unsupported units and unsafe agents", () => {
+  const { preferences, errors } = validatePreferences({
+    planning_subagents: {
+      "execute-task": { allowed: ["security"] },
+      "plan-slice": { allowed: ["worker"] },
+    },
+  } as any);
+
+  assert.equal(preferences.planning_subagents, undefined);
+  assert.ok(errors.some(e => e.includes("unsupported unit \"execute-task\"")));
+  assert.ok(errors.some(e => e.includes("\"worker\"") && e.includes("read-only planning specialist")));
+});
+
+test("loadEffectiveGSDPreferences merges planning_subagents allowlists", (t) => {
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  const tempProject = mkdtempSync(join(tmpdir(), "gsd-planning-subagents-project-"));
+  const tempGsdHome = mkdtempSync(join(tmpdir(), "gsd-planning-subagents-home-"));
+
+  t.after(() => {
+    clearGSDPreferencesCache();
+    process.chdir(originalCwd);
+    if (originalGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = originalGsdHome;
+    rmSync(tempProject, { recursive: true, force: true });
+    rmSync(tempGsdHome, { recursive: true, force: true });
+  });
+
+  mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+  process.env.GSD_HOME = tempGsdHome;
+  process.chdir(tempProject);
+  clearGSDPreferencesCache();
+
+  writeFileSync(
+    getGlobalGSDPreferencesPath(),
+    [
+      "---",
+      "version: 1",
+      "planning_subagents:",
+      "  plan-slice:",
+      "    allowed: [scout, reviewer]",
+      "---",
+      "",
+    ].join("\n"),
+    "utf-8",
+  );
+  writeFileSync(
+    getProjectGSDPreferencesPath(tempProject),
+    [
+      "---",
+      "version: 1",
+      "planning_subagents:",
+      "  plan-slice:",
+      "    allowed: [security]",
+      "  plan-milestone:",
+      "    allowed: [planner]",
+      "---",
+      "",
+    ].join("\n"),
+    "utf-8",
+  );
+
+  const loaded = loadEffectiveGSDPreferences(tempProject);
+  assert.deepEqual(loaded?.preferences.planning_subagents?.["plan-slice"]?.allowed, [
+    "scout",
+    "reviewer",
+    "security",
+  ]);
+  assert.deepEqual(loaded?.preferences.planning_subagents?.["plan-milestone"]?.allowed, ["planner"]);
+});
+
 // ── Model config parsing ─────────────────────────────────────────────────────
 
 test("parses OpenRouter model config with org/model IDs and fallbacks", () => {

package/src/resources/extensions/gsd/tests/prefs-wizard-coverage.test.ts

@@ -54,6 +54,10 @@ const PREF_SAMPLE_VALUES: Record<string, unknown> = {
   },
   post_unit_hooks: [{ command: "npm test" }],
   pre_dispatch_hooks: [{ command: "npm run lint" }],
+  planning_subagents: {
+    "plan-milestone": { allowed: ["scout", "planner"] },
+    "plan-slice": { allowed: ["scout"] },
+  },
   dynamic_routing: { enabled: true },
   disabled_model_providers: ["slow-provider"],
   uok: { enabled: true },

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

@@ -13,6 +13,7 @@ import { tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
 
 import { buildExecuteTaskPrompt, buildPlanSlicePrompt, buildReactiveExecutePrompt, buildResearchSlicePrompt, inlineDependencySummaries } from "../auto-prompts.js";
+import { buildDiscussSlicePrompt } from "../guided-flow.js";
 import { computeBudgets, truncateAtSectionBoundary } from "../context-budget.js";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -735,3 +736,89 @@ describe("prompt-budget: modelRegistry + sessionContextWindow behavior", () => {
     }
   });
 });
+
+// ─── execute-task + discuss-slice inline caps (plan 039) ──────────────────────
+
+describe("prompt-budget: execute-task inline cap (039)", () => {
+  it("keeps the authoritative task plan whole but drops trailing templates when the plan alone exceeds the inline budget", async () => {
+    const base = createFixtureBase();
+    try {
+      const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+      const taskDir = join(sliceDir, "tasks");
+      mkdirSync(taskDir, { recursive: true });
+      writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "# Roadmap\n");
+      writeFileSync(join(sliceDir, "S01-PLAN.md"), "# Slice Plan\n");
+      // Oversized task plan (~60K) — well past the 20K inline ceiling.
+      const bigPlan = "# Task Plan\n\nMARKER_TASKPLAN_HEAD\n\n" + Array.from({ length: 30 }, (_, i) =>
+        `### Step ${i}\n\n${"Implementation detail. ".repeat(90)}`
+      ).join("\n\n");
+      writeFileSync(join(taskDir, "T01-PLAN.md"), bigPlan);
+
+      const prompt = await buildExecuteTaskPrompt("M001", "S01", "Slice", "T01", "Task", base, {
+        level: "standard",
+        sessionContextWindow: 32_000,
+      });
+
+      // The task plan is the authoritative execution contract — never truncated;
+      // its content survives whole even when it alone exceeds the inline budget.
+      assert.match(prompt, /MARKER_TASKPLAN_HEAD/);
+      assert.match(prompt, /### Step 29/);
+      // Trailing lower-priority templates are dropped — the on-demand decisions
+      // template that "standard" normally inlines is gone because the task plan
+      // consumed the entire inline budget. (Baseline: the tiny-plan test above
+      // asserts this block IS present.)
+      assert.doesNotMatch(prompt, /### On-demand Decisions Template/);
+    } finally {
+      cleanup(base);
+    }
+  });
+});
+
+describe("prompt-budget: discuss-slice inline cap (039)", () => {
+  it("prepends the configured response language", async () => {
+    const base = createFixtureBase();
+    const gsdHome = mkdtempSync(join(tmpdir(), "gsd-discuss-slice-language-home-"));
+    const previousGsdHome = process.env.GSD_HOME;
+    process.env.GSD_HOME = gsdHome;
+
+    try {
+      writeFileSync(join(gsdHome, "PREFERENCES.md"), "---\nversion: 1\nlanguage: 中文\n---\n", "utf-8");
+      mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01"), { recursive: true });
+
+      const prompt = await buildDiscussSlicePrompt("M001", "S01", "Current", base);
+
+      assert.match(prompt, /^## Response Language\n\nAlways respond in 中文/);
+    } finally {
+      if (previousGsdHome === undefined) delete process.env.GSD_HOME;
+      else process.env.GSD_HOME = previousGsdHome;
+      cleanup(base);
+      cleanup(gsdHome);
+    }
+  });
+
+  it("caps the inlined block — roadmap survives first, the trailing decisions register truncates", async () => {
+    const base = createFixtureBase();
+    try {
+      const msDir = join(base, ".gsd", "milestones", "M001");
+      mkdirSync(join(msDir, "slices", "S01"), { recursive: true });
+      writeFileSync(join(msDir, "M001-ROADMAP.md"), "# Roadmap\n\nMARKER_ROADMAP\n\n- [ ] **S01: Current** `risk:low`\n");
+      writeFileSync(join(msDir, "M001-CONTEXT.md"), "# Context\n\nMARKER_CONTEXT\n");
+      // Huge decisions register (~60K) — the unbounded-growth surface the cap bounds.
+      const bigDecisions = "# Decisions\n\n" + Array.from({ length: 40 }, (_, i) =>
+        `### D${String(i).padStart(3, "0")}\n\n${"Decision rationale detail. ".repeat(60)}`
+      ).join("\n\n");
+      writeFileSync(join(base, ".gsd", "DECISIONS.md"), bigDecisions);
+
+      const prompt = await buildDiscussSlicePrompt("M001", "S01", "Current", base);
+
+      // Roadmap is first in the inlined block → survives the cap.
+      assert.match(prompt, /MARKER_ROADMAP/);
+      // The cap fired (capPreamble ceiling is 20K; the block is ~60K).
+      assert.match(prompt, /\[\.\.\.truncated/);
+      // The last decision (trailing content) is dropped.
+      assert.doesNotMatch(prompt, /### D039/);
+    } finally {
+      cleanup(base);
+    }
+  });
+});

package/src/resources/extensions/gsd/tests/provider-errors.test.ts

@@ -23,7 +23,10 @@ import {
 } from "../bootstrap/agent-end-recovery.ts";
 import { blockModelUntil, clearTemporaryModelBlocksForTest } from "../blocked-models.ts";
 import { _buildCancelledUnitStopReason } from "../auto/phase-helpers.ts";
-import { _classifyZeroToolProviderMessageForTest } from "../auto/unit-phase.ts";
+import {
+  _classifyZeroToolProviderMessageForTest,
+  _zeroToolPseudoToolCallSnippetForTest,
+} from "../auto/unit-phase.ts";
 import { autoSession } from "../auto-runtime-state.ts";
 import { getNextFallbackModel } from "../preferences.ts";
 import { clearGuidedUnitContext, getGuidedUnitContext, setGuidedUnitContext } from "../guided-unit-context.ts";
@@ -77,6 +80,21 @@ test("zero-tool provider classifier treats weekly limit wording as transient rat
   assert.equal(result.kind, "rate-limit");
 });
 
+test("zero-tool pseudo tool-call detector identifies serialization drift", () => {
+  const snippet = _zeroToolPseudoToolCallSnippetForTest(
+    'bash<arg_key>command</arg_key><arg_value>ls -la /tmp && echo "---SRC---"</arg_value></tool_call>',
+  );
+  assert.ok(snippet, "pseudo tool-call text should be recognized");
+  assert.match(snippet, /bash<arg_key>command<\/arg_key>/);
+});
+
+test("zero-tool provider classifier does not treat pseudo tool-call text as an error class", () => {
+  const result = _classifyZeroToolProviderMessageForTest(
+    'bash<arg_key>command</arg_key><arg_value>ls -la /tmp && echo "---SRC---"</arg_value></tool_call>',
+  );
+  assert.equal(result, null, "pseudo tool-call text is drift, not a provider error");
+});
+
 test("classifyError treats extra-usage phrasing as transient rate-limit (#4397)", () => {
   const result = classifyError("You are out of extra usage. Please wait before retrying.");
   assert.ok(isTransient(result));
@@ -651,6 +669,108 @@ test("rate-limit agent_end walks past unavailable fallback models before pausing
   }
 });
 
+test("retry-exhausted abort/unknown provider stop reasons trigger model fallback (#1364)", async () => {
+  const originalCwd = process.cwd();
+  const originalSetTimeout = globalThis.setTimeout;
+
+  globalThis.setTimeout = ((fn: (...args: unknown[]) => void, delay?: number) => {
+    if ((delay ?? 0) === 0) {
+      fn();
+    }
+    return 0 as unknown as ReturnType<typeof setTimeout>;
+  }) as typeof setTimeout;
+
+  try {
+    for (const reason of ["abort", "unknown"]) {
+      const base = mkdtempSync(join(tmpdir(), `gsd-stop-reason-${reason}-`));
+      const notifications: Array<{ message: string; level?: string }> = [];
+      const setModelCalls: string[] = [];
+      const sendMessageCalls: unknown[][] = [];
+
+      try {
+        resetTransientRetryState();
+        clearTemporaryModelBlocksForTest();
+        autoSession.reset();
+        mkdirSync(join(base, ".gsd"), { recursive: true });
+        writeFileSync(
+          join(base, ".gsd", "PREFERENCES.md"),
+          [
+            "---",
+            "models:",
+            "  execution:",
+            "    model: gpt-5.5",
+            "    provider: openai-codex",
+            "    fallbacks:",
+            "      - anthropic/claude-sonnet-4-6",
+            "---",
+          ].join("\n"),
+          "utf-8",
+        );
+        process.chdir(base);
+
+        autoSession.active = true;
+        autoSession.basePath = base;
+        autoSession.currentUnit = { type: "execute-task", id: "M001/S01/T01", startedAt: Date.now() };
+        autoSession.autoModeStartModel = { provider: "openai-codex", id: "gpt-5.5" };
+
+        const availableModels = [
+          { id: "gpt-5.5", provider: "openai-codex", api: "responses" },
+          { id: "claude-sonnet-4-6", provider: "anthropic", api: "anthropic-messages" },
+        ];
+        const ctx = {
+          model: availableModels[0],
+          modelRegistry: { getAvailable: () => availableModels },
+          ui: {
+            notify(message: string, level?: "info" | "warning" | "error" | "success") {
+              notifications.push({ message, level });
+            },
+            setStatus: () => {},
+            setWidget: () => {},
+            setWorkingMessage: () => {},
+          },
+        } as any;
+        const pi = {
+          setModel: async (model: { provider: string; id: string }) => {
+            setModelCalls.push(`${model.provider}/${model.id}`);
+            return true;
+          },
+          sendMessage: (...args: unknown[]) => {
+            sendMessageCalls.push(args);
+          },
+        } as any;
+
+        await handleAgentEnd(pi, {
+          messages: [{
+            role: "assistant",
+            stopReason: "error",
+            errorMessage: `Retry failed after 3 attempts: Unhandled stop reason: ${reason}`,
+          }],
+        } as any, ctx);
+
+        assert.deepEqual(setModelCalls, ["anthropic/claude-sonnet-4-6"], `${reason} should switch to configured fallback`);
+        assert.equal(sendMessageCalls.length, 1, `${reason} fallback recovery must trigger a continuation turn`);
+        assert.deepEqual(sendMessageCalls[0][1], { triggerTurn: true });
+        assert.ok(
+          notifications.some((n) => n.message.includes("anthropic/claude-sonnet-4-6")),
+          `${reason} notification should name the selected fallback`,
+        );
+      } finally {
+        process.chdir(originalCwd);
+        clearTemporaryModelBlocksForTest();
+        resetTransientRetryState();
+        autoSession.reset();
+        rmSync(base, { recursive: true, force: true });
+      }
+    }
+  } finally {
+    globalThis.setTimeout = originalSetTimeout;
+    process.chdir(originalCwd);
+    clearTemporaryModelBlocksForTest();
+    resetTransientRetryState();
+    autoSession.reset();
+  }
+});
+
 test("isTerminalDeletedWorktreeProviderError matches removed auto-worktree paths only", () => {
   assert.equal(
     isTerminalDeletedWorktreeProviderError('Path "/Users/dev/.gsd/projects/abc123/worktrees/M005" does not exist'),

package/src/resources/extensions/gsd/tests/reactive-executor.test.ts

@@ -608,3 +608,42 @@ test("getDependencyTaskSummaryPaths handles missing dependency summaries gracefu
     rmSync(repo, { recursive: true, force: true });
   }
 });
+
+test("#1343: getPriorTaskSummaryPaths excludes sibling-slice summaries in flat-phase", async () => {
+  const { getPriorTaskSummaryPaths } = await import("../auto-prompts.ts");
+  const repo = mkdtempSync(join(tmpdir(), "gsd-reactive-flat-prior-"));
+  try {
+    // Flat-phase: slices S01 and S02 share the phase dir and overlap task ids.
+    const phaseDir = join(repo, ".gsd", "phases", "01-test");
+    mkdirSync(phaseDir, { recursive: true });
+    writeFileSync(join(phaseDir, "S01-T01-SUMMARY.md"), "---\nid: T01\n---\n# S01 T01\n");
+    writeFileSync(join(phaseDir, "S02-T01-SUMMARY.md"), "---\nid: T01\n---\n# S02 T01\n");
+
+    // S02/T02 prior summaries must not pull the sibling S01-T01 summary.
+    const paths = await getPriorTaskSummaryPaths("M001", "S02", "T02", repo);
+    assert.equal(paths.length, 1, "Should only return the current slice's prior summary");
+    assert.ok(paths[0].includes("S02-T01-SUMMARY"), "Should include S02's T01");
+    assert.ok(!paths.some((p) => p.includes("S01-T01-SUMMARY")), "Should NOT include sibling S01's T01");
+  } finally {
+    rmSync(repo, { recursive: true, force: true });
+  }
+});
+
+test("#1343: getDependencyTaskSummaryPaths excludes sibling-slice summaries in flat-phase", async () => {
+  const { getDependencyTaskSummaryPaths } = await import("../auto-prompts.ts");
+  const repo = mkdtempSync(join(tmpdir(), "gsd-reactive-flat-dep-"));
+  try {
+    const phaseDir = join(repo, ".gsd", "phases", "01-test");
+    mkdirSync(phaseDir, { recursive: true });
+    writeFileSync(join(phaseDir, "S01-T01-SUMMARY.md"), "---\nid: T01\n---\n# S01 T01\n");
+    writeFileSync(join(phaseDir, "S02-T01-SUMMARY.md"), "---\nid: T01\n---\n# S02 T01\n");
+
+    // S02/T02 depends on T01 — must resolve S02's T01, not the sibling S01's.
+    const paths = await getDependencyTaskSummaryPaths("M001", "S02", "T02", ["T01"], repo);
+    assert.equal(paths.length, 1, "Should only return the current slice's dependency summary");
+    assert.ok(paths[0].includes("S02-T01-SUMMARY"), "Should include S02's T01");
+    assert.ok(!paths.some((p) => p.includes("S01-T01-SUMMARY")), "Should NOT include sibling S01's T01");
+  } finally {
+    rmSync(repo, { recursive: true, force: true });
+  }
+});

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

@@ -6,8 +6,10 @@ import { join } from "node:path";
 import { randomUUID } from "node:crypto";
 
 import { autoSession } from "../auto-runtime-state.ts";
+import { postUnitPreVerification } from "../auto-post-unit.ts";
 import { registerHooks } from "../bootstrap/register-hooks.ts";
 import { resetToolCallLoopGuard } from "../bootstrap/tool-call-loop-guard.ts";
+import { closeDatabase, openDatabase } from "../gsd-db.ts";
 import { readUnitHarnessAbort } from "../unit-runtime.ts";
 
 type Handler = (event: any, ctx?: any) => Promise<any> | any;
@@ -166,6 +168,109 @@ test("register-hooks does not record normal product tool failures as harness abo
   assert.equal(abort, null);
 });
 
+test("tool_execution_end latches a failed ScheduleWakeup across unrelated tool success", async (t) => {
+  const base = makeRuntimeBase();
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  autoSession.reset();
+  autoSession.active = true;
+  autoSession.basePath = base;
+  autoSession.currentUnit = { type: "discuss-milestone", id: "M001", startedAt: Date.now() };
+  t.after(() => {
+    closeDatabase();
+    autoSession.reset();
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  const { emitToolExecutionEnd } = makeHookHarness();
+  const error = "`prompt` is required when `stop` is not true";
+
+  await emitToolExecutionEnd({
+    toolName: "ScheduleWakeup",
+    isError: true,
+    result: error,
+  });
+  assert.equal(autoSession.lastToolInvocationError, `ScheduleWakeup: ${error}`);
+
+  await emitToolExecutionEnd({
+    toolName: "read",
+    isError: false,
+    result: "file contents",
+  });
+  assert.equal(
+    autoSession.lastToolInvocationError,
+    `ScheduleWakeup: ${error}`,
+    "an unrelated success must not erase a failed continuation before the unit boundary",
+  );
+
+  await emitToolExecutionEnd({
+    toolName: "parse_payload",
+    isError: true,
+    result: "Unexpected end of JSON input",
+  });
+  assert.equal(
+    autoSession.lastToolInvocationError,
+    `ScheduleWakeup: ${error}`,
+    "a later invocation error must not replace the failed continuation",
+  );
+
+  let pauseCalled = false;
+  const notifications: Array<{ message: string; severity?: string }> = [];
+  const result = await postUnitPreVerification(
+    {
+      s: autoSession,
+      ctx: {
+        ui: {
+          notify: (message: string, severity?: string) => notifications.push({ message, severity }),
+        },
+      } as any,
+      pi: {} as any,
+      buildSnapshotOpts: () => ({}) as any,
+      lockBase: () => base,
+      stopAuto: async () => {},
+      pauseAuto: async () => { pauseCalled = true; },
+      updateProgressWidget: () => {},
+    },
+    { skipSettleDelay: true, skipWorktreeSync: true },
+  );
+
+  assert.equal(result, "dispatched");
+  assert.equal(pauseCalled, true);
+  assert.equal(autoSession.pendingVerificationRetry, null);
+  assert.ok(
+    notifications.some(({ message, severity }) => severity === "error" && message.includes(error)),
+    "the unit boundary must surface the rejected continuation",
+  );
+  assert.equal(autoSession.lastToolInvocationError, null);
+
+  await emitToolExecutionEnd({
+    toolName: "ScheduleWakeup",
+    isError: true,
+    result: error,
+  });
+  await emitToolExecutionEnd({
+    toolName: "ScheduleWakeup",
+    isError: false,
+    result: "Wakeup scheduled",
+  });
+  assert.equal(autoSession.lastToolInvocationError, null);
+});
+
+test("tool_execution_end ignores ScheduleWakeup-shaped business validation from other tools", async (t) => {
+  autoSession.reset();
+  autoSession.active = true;
+  t.after(() => autoSession.reset());
+
+  const { emitToolExecutionEnd } = makeHookHarness();
+  await emitToolExecutionEnd({
+    toolName: "submit_review",
+    isError: true,
+    result: "`prompt` is required when `stop` is not true",
+  });
+
+  assert.equal(autoSession.lastToolInvocationError, null);
+});
+
 test("register-hooks does not classify normal gsd_uat_exec nonzero exits as harness aborts", async (t) => {
   const base = makeRuntimeBase();
   const startedAt = Date.now();

package/src/resources/extensions/gsd/tests/service-tier.test.ts

@@ -35,6 +35,10 @@ describe("supportsServiceTier", () => {
     assert.equal(supportsServiceTier("gpt-5.5"), false);
   });
 
+  test("returns false for gpt-5.6 until service_tier payload support is verified", () => {
+    assert.equal(supportsServiceTier("gpt-5.6"), false);
+  });
+
   test("returns false for provider-only identifier without gpt-5.4 model suffix", () => {
     assert.equal(supportsServiceTier("vibeproxy-openai"), false);
   });

package/src/resources/extensions/gsd/tests/single-writer-v3-tool-surface.test.ts

@@ -7,8 +7,9 @@
  *      self-identify (Stream 2: actor identity passthrough).
  *
  *   2. The 3 reversibility handlers (reopen-task/slice/milestone) are
- *      registered as MCP tools with both canonical and alias names
- *      (Stream 3: reversibility tools).
+ *      registered as MCP tools under their canonical names, and additionally
+ *      under their alias names when GSD_ADVERTISE_TOOL_ALIASES=1 (plan 035
+ *      suppresses alias schemas by default) (Stream 3: reversibility tools).
  *
  *   3. The reopen tools accept the documented core params plus optional
  *      reason/actorName/triggerReason without rejecting valid payloads.
@@ -36,6 +37,18 @@ function getTool(name: string) {
   return pi.tools.find((t: any) => t.name === name);
 }
 
+function withEnv(name: string, value: string | undefined, fn: () => void): void {
+  const previous = process.env[name];
+  if (value === undefined) delete process.env[name];
+  else process.env[name] = value;
+  try {
+    fn();
+  } finally {
+    if (previous === undefined) delete process.env[name];
+    else process.env[name] = previous;
+  }
+}
+
 function getRequiredProps(tool: any): string[] {
   return tool.parameters.required ?? [];
 }
@@ -78,7 +91,9 @@ for (const name of ACTOR_TOOLS) {
   });
 }
 
-// ─── Stream 3: reopen tools registered with canonical + alias names ─────────
+// ─── Stream 3: reopen tools registered under canonical names ────────────────
+// Plan 035 suppresses alias schemas by default; the canonical reopen tools are
+// always registered, and their aliases only when GSD_ADVERTISE_TOOL_ALIASES=1.
 
 const REOPEN_TOOLS = [
   { canonical: "gsd_task_reopen", alias: "gsd_reopen_task" },
@@ -87,13 +102,24 @@ const REOPEN_TOOLS = [
 ];
 
 for (const { canonical, alias } of REOPEN_TOOLS) {
-  test(`${canonical} — registered with alias ${alias}`, () => {
+  test(`${canonical} — registered under its canonical name, no alias by default`, () => {
     const canonicalTool = getTool(canonical);
-    const aliasTool = getTool(alias);
     assert.ok(canonicalTool, `${canonical} must be registered`);
-    assert.ok(aliasTool, `${alias} must be registered as alias`);
     assert.ok(typeof canonicalTool.execute === "function", `${canonical} must have an execute function`);
-    assert.ok(typeof aliasTool.execute === "function", `${alias} must have an execute function`);
+    assert.ok(!getTool(alias), `${alias} must not be registered by default (plan 035 alias suppression)`);
+  });
+
+  test(`${canonical} — registered with alias ${alias} when GSD_ADVERTISE_TOOL_ALIASES=1`, () => {
+    withEnv("GSD_ADVERTISE_TOOL_ALIASES", "1", () => {
+      const aliasPi = makeMockPi();
+      registerDbTools(aliasPi);
+      const canonicalTool = aliasPi.tools.find((t: any) => t.name === canonical);
+      const aliasTool = aliasPi.tools.find((t: any) => t.name === alias);
+      assert.ok(canonicalTool, `${canonical} must be registered`);
+      assert.ok(aliasTool, `${alias} must be registered as alias`);
+      assert.ok(typeof canonicalTool.execute === "function", `${canonical} must have an execute function`);
+      assert.ok(typeof aliasTool.execute === "function", `${alias} must have an execute function`);
+    });
   });
 }