@opengsd/gsd-pi 1.3.0 → 1.4.0

package/src/resources/extensions/gsd/tests/stop-backtrack.test.ts

@@ -143,8 +143,12 @@ test("executeBacktrack writes trigger and regression markers", () => {
   const tmp = makeTempDir("exec-bt");
   setupGsdDir(tmp);
 
-  // Create target milestone directory
-  mkdirSync(join(tmp, ".gsd", "milestones", "M003"), { recursive: true });
+  // Create target milestone directory with a content file so it is recognised as
+  // a content-bearing legacy milestone by dirIsContentBearingLegacyMilestone
+  // (a metadata-only dir would be ignored by resolveMilestonePath).
+  const m003Dir = join(tmp, ".gsd", "milestones", "M003");
+  mkdirSync(m003Dir, { recursive: true });
+  writeFileSync(join(m003Dir, "M003-CONTEXT.md"), "# M003\n");
 
   const targetMid = executeBacktrack(tmp, "M005", {
     id: "CAP-test123",

package/src/resources/extensions/gsd/tests/stuck-state-via-db.test.ts

@@ -130,6 +130,91 @@ test("getRecentUnitKeysForProjectRoot restores compound keys used by stuck detec
   assert.match(result?.reason ?? "", /3 consecutive times/);
 });
 
+// ── #852: stuck window must be scoped to the current session (trace_id) ───────
+//
+// Without trace_id scoping, two consecutive finalize-retry failures from a
+// PREVIOUS session persist in unit_dispatches and fire detectStuck Rule 1 on
+// the first iteration of every new session — killing auto-mode before any new
+// dispatch runs. The trace_id filter ensures only the current session's
+// dispatches populate the window.
+
+test("#852: getRecentUnitKeysForProjectRoot scoped to trace_id ignores prior-session entries", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M015", title: "T", status: "active" });
+  const worker = registerAutoWorker({ projectRootRealpath: base });
+  const lease = claimMilestoneLease(worker, "M015");
+  assert.equal(lease.ok, true);
+  if (!lease.ok) return;
+
+  // PRIOR session: two consecutive finalize-retry failures (trace_id = "old").
+  for (let i = 0; i < 2; i++) {
+    const claim = recordDispatchClaim({
+      traceId: "old-session",
+      workerId: worker,
+      milestoneLeaseToken: lease.token,
+      milestoneId: "M015",
+      unitType: "discuss-milestone",
+      unitId: "M015",
+    });
+    assert.equal(claim.ok, true);
+    if (!claim.ok) return;
+    markFailed(claim.dispatchId, { errorSummary: "finalize-retry" });
+  }
+
+  // NEW session (trace_id = "new") has dispatched nothing yet.
+  // Without the trace_id filter, the window loads the two stale "old-session"
+  // finalize-retry entries → detectStuck Rule 1 fires immediately.
+  const unscopedWindow = getRecentUnitKeysForProjectRoot(base, 20);
+  assert.equal(unscopedWindow.length, 2, "unscoped window sees prior-session entries");
+
+  // With the trace_id filter, the new session's window is empty — no false stuck.
+  const scopedWindow = getRecentUnitKeysForProjectRoot(base, 20, "new-session");
+  assert.equal(scopedWindow.length, 0, "trace_id-scoped window excludes prior-session entries");
+
+  // detectStuck on an empty window returns null (not stuck).
+  assert.equal(detectStuck(scopedWindow), null);
+});
+
+test("#852: getRecentUnitKeysForProjectRoot trace_id filter still includes current-session entries", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M016", title: "T", status: "active" });
+  const worker = registerAutoWorker({ projectRootRealpath: base });
+  const lease = claimMilestoneLease(worker, "M016");
+  assert.equal(lease.ok, true);
+  if (!lease.ok) return;
+
+  // Prior session entries.
+  const oldClaim = recordDispatchClaim({
+    traceId: "prior", workerId: worker, milestoneLeaseToken: lease.token,
+    milestoneId: "M016", unitType: "plan-milestone", unitId: "M016",
+  });
+  assert.equal(oldClaim.ok, true);
+  if (oldClaim.ok) markFailed(oldClaim.dispatchId, { errorSummary: "finalize-retry" });
+
+  // Current session entries.
+  for (let i = 0; i < 2; i++) {
+    const claim = recordDispatchClaim({
+      traceId: "current", workerId: worker, milestoneLeaseToken: lease.token,
+      milestoneId: "M016", unitType: "plan-milestone", unitId: "M016",
+    });
+    assert.equal(claim.ok, true);
+    if (!claim.ok) return;
+    markFailed(claim.dispatchId, { errorSummary: "finalize-retry" });
+  }
+
+  // Scoped to "current" → only the 2 current-session entries.
+  const scoped = getRecentUnitKeysForProjectRoot(base, 20, "current");
+  assert.equal(scoped.length, 2, "trace_id filter includes current-session entries");
+
+  // Unscoped → 3 (prior + current).
+  const unscoped = getRecentUnitKeysForProjectRoot(base, 20);
+  assert.equal(unscoped.length, 3, "unscoped window includes all sessions");
+});
+
 test("getRecentUnitKeysForWorker honors the limit parameter", (t) => {
   const base = makeBase();
   t.after(() => cleanup(base));

package/src/resources/extensions/gsd/tests/sync-lock.test.ts

@@ -6,6 +6,7 @@ import assert from 'node:assert/strict';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as os from 'node:os';
+import { performance } from 'node:perf_hooks';
 import { acquireSyncLock, releaseSyncLock } from '../sync-lock.ts';
 
 function tempDir(): string {
@@ -151,3 +152,25 @@ test('sync-lock: EPERM from live owner PID prevents stale lock stealing', () =>
     cleanupDir(base);
   }
 });
+
+test('sync-lock: contended fresh lock fails fast without honoring long sync timeout', () => {
+  const base = tempDir();
+  fs.mkdirSync(path.join(base, '.gsd'), { recursive: true });
+  const lockPath = path.join(base, '.gsd', 'sync.lock');
+
+  try {
+    fs.writeFileSync(lockPath, JSON.stringify({ pid: 99999, acquired_at: new Date().toISOString() }));
+
+    const startedAt = performance.now();
+    const result = acquireSyncLock(base, 1_000);
+    const elapsedMs = performance.now() - startedAt;
+
+    assert.strictEqual(result.acquired, false, 'fresh lock should not be stolen');
+    assert.ok(
+      elapsedMs < 250,
+      `contended sync lock should fail fast instead of blocking for timeout; elapsed=${elapsedMs.toFixed(1)}ms`,
+    );
+  } finally {
+    cleanupDir(base);
+  }
+});

package/src/resources/extensions/gsd/tests/system-context-message-routing.test.ts

@@ -4,7 +4,35 @@
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
 
-import { buildContextMessage } from "../bootstrap/system-context.ts";
+import { buildContextMessage, stripVolatileCodebaseMetadata } from "../bootstrap/system-context.ts";
+
+describe("stripVolatileCodebaseMetadata (#847 — KV cache stability)", () => {
+  const map = [
+    "# Codebase Map",
+    "",
+    "Generated: 2026-03-23T14:00:00Z | Files: 3 | Described: 2/3",
+    `<!-- gsd:codebase-meta {"generatedAt":"2026-03-23T14:00:00Z","fingerprint":"abc","fileCount":3,"truncated":false} -->`,
+    "",
+    "### src/",
+    "- `a.ts` — does a",
+    "- `b.ts`",
+  ].join("\n");
+
+  test("removes the Generated timestamp and meta comment lines", () => {
+    const stripped = stripVolatileCodebaseMetadata(map);
+    assert.ok(!stripped.includes("Generated:"));
+    assert.ok(!stripped.includes("gsd:codebase-meta"));
+    assert.ok(stripped.includes("- `a.ts` — does a"));
+    assert.ok(stripped.includes("### src/"));
+  });
+
+  test("is stable across regenerations that only change the timestamp", () => {
+    const later = map
+      .replace("2026-03-23T14:00:00Z | Files", "2026-03-24T09:30:00Z | Files")
+      .replace('"generatedAt":"2026-03-23T14:00:00Z"', '"generatedAt":"2026-03-24T09:30:00Z"');
+    assert.equal(stripVolatileCodebaseMetadata(map), stripVolatileCodebaseMetadata(later));
+  });
+});
 
 describe("buildContextMessage (#5019 — memory routing)", () => {
   const markedMemory = "[GSD Context Metadata]\n- Memory supplied: yes\n\n[MEMORY]\nrule one";

package/src/resources/extensions/gsd/tests/terminal-tool-surface-classification.test.ts

@@ -0,0 +1,80 @@
+// Project/App: gsd-pi
+// File Purpose: Contract coverage for terminal tool-surface failure classification (#783).
+//
+// A terminal MCP server status (failed / needs-auth / disabled) must not be
+// classified as transient — retrying the same model cannot repair a dead
+// server and burns retries until the per-unit cost cap pauses auto-mode.
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+
+import { isTerminalToolSurfaceError, getToolSurfaceReadinessError, TOOL_SURFACE_NOT_READY } from "../tool-surface-readiness.ts";
+import { classifyError, isTransient } from "../error-classifier.ts";
+
+const SERVER = "gsd-workflow";
+
+function readinessFor(status: string): string {
+  return getToolSurfaceReadinessError({
+    unitType: "run-uat",
+    workflowServerName: SERVER,
+    observation: { tools: ["read"], mcpServers: [{ name: SERVER, status }] },
+  })!;
+}
+
+describe("isTerminalToolSurfaceError", () => {
+  test("recognizes every canonical terminal status", () => {
+    for (const status of ["failed", "needs-auth", "disabled"]) {
+      const error = readinessFor(status);
+      assert.ok(error, `expected a readiness error for status=${status}`);
+      assert.equal(
+        isTerminalToolSurfaceError(error),
+        true,
+        `status=${status} should be terminal`,
+      );
+    }
+  });
+
+  test("returns false for genuinely transient (not-yet-connected) variants", () => {
+    assert.equal(isTerminalToolSurfaceError(readinessFor("pending")), false);
+    assert.equal(isTerminalToolSurfaceError(readinessFor("connected")), false);
+    assert.equal(isTerminalToolSurfaceError(readinessFor("connecting")), false);
+  });
+
+  test("returns false for non-readiness and unrelated messages", () => {
+    assert.equal(isTerminalToolSurfaceError(null), false);
+    assert.equal(isTerminalToolSurfaceError(undefined), false);
+    assert.equal(isTerminalToolSurfaceError(""), false);
+    assert.equal(isTerminalToolSurfaceError("some unrelated network error"), false);
+    // A bare "(terminal)" without a real readiness prefix/status must not trip.
+    assert.equal(isTerminalToolSurfaceError("something (terminal) happened"), false);
+  });
+
+  test("the readiness prefix alone (without the terminal marker) is not terminal", () => {
+    const transientMessage = `${TOOL_SURFACE_NOT_READY} for run-uat: MCP server "${SERVER}" is absent from the init surface (not yet connected): gsd_uat_exec`;
+    assert.equal(isTerminalToolSurfaceError(transientMessage), false);
+  });
+});
+
+describe("classifyError terminal readiness contract (#783)", () => {
+  test("every terminal status classifies as non-transient permanent", () => {
+    for (const status of ["failed", "needs-auth", "disabled"]) {
+      const cls = classifyError(`Claude Code error: ${readinessFor(status)}`);
+      assert.equal(isTransient(cls), false, `status=${status} must not be transient`);
+      assert.equal(cls.kind, "permanent", `status=${status} must classify as permanent`);
+    }
+  });
+
+  test("transient not-yet-connected variants still classify as transient network", () => {
+    const cls = classifyError(`Claude Code error: ${readinessFor("pending")}`);
+    assert.equal(isTransient(cls), true);
+    assert.equal(cls.kind, "network");
+  });
+
+  test("terminal branch is matched ahead of the shared transient prefix branch", () => {
+    // The failed-status message shares the TOOL_SURFACE_NOT_READY prefix with
+    // the transient branches. If ordering regressed, this would be `network`.
+    const cls = classifyError(readinessFor("needs-auth"));
+    assert.notEqual(cls.kind, "network");
+    assert.equal(cls.kind, "permanent");
+  });
+});

package/src/resources/extensions/gsd/tests/tool-call-loop-guard.test.ts

@@ -7,9 +7,11 @@ import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import {
   checkToolCallLoop,
+  recordToolCallLoopMutation,
   resetToolCallLoopGuard,
   disableToolCallLoopGuard,
   getToolCallLoopCount,
+  getToolCallCountForTool,
 } from '../bootstrap/tool-call-loop-guard.ts';
 
 
@@ -177,3 +179,209 @@ console.log('\n── Loop guard: nested key order is normalized ──');
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
+// Per-tool-name cap (#783 Brief C) — catches improvisation loops with varied args
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Loop guard: per-tool cap blocks varied-args improvisation (#783) ──');
+
+{
+  resetToolCallLoopGuard();
+
+  // A one-shot workflow tool called with DIFFERENT args each time (the reported
+  // improvisation pattern). The identical-signature streak alone would reset
+  // every call; the per-tool cap must catch it.
+  for (let i = 1; i <= 6; i++) {
+    const result = checkToolCallLoop('gsd_complete_milestone', { milestone: `M${i}` });
+    assert.ok(result.block === false, `one-shot call ${i} (varied args) should be allowed`);
+    assert.deepStrictEqual(getToolCallCountForTool('gsd_complete_milestone'), i, `per-tool count should be ${i}`);
+  }
+  // 7th call (cap 6 + 1) must be blocked by the per-tool guard.
+  const blocked = checkToolCallLoop('gsd_complete_milestone', { milestone: 'M7' });
+  assert.ok(blocked.block === true, '7th one-shot call (varied args) should be blocked by per-tool cap');
+  assert.ok(blocked.reason!.includes('repeated tool'), 'reason should identify the per-tool guard');
+  assert.ok(blocked.reason!.includes('gsd_complete_milestone'), 'reason should name the tool');
+  assert.ok(blocked.reason!.includes('7'), 'reason should mention the count');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Repeatable tools get the higher cap
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Loop guard: repeatable tools get the higher cap (#783) ──');
+
+{
+  resetToolCallLoopGuard();
+
+  // bash is repeatable: varied commands are legitimate up to the higher cap.
+  for (let i = 1; i <= 15; i++) {
+    const result = checkToolCallLoop('bash', { command: `echo ${i}` });
+    assert.ok(result.block === false, `bash call ${i} (varied args) should be allowed`);
+  }
+  // 16th call (cap 15 + 1) is blocked by the per-tool guard — this is the
+  // improvisation-through-bash case from the forensics (~51 calls).
+  const blocked = checkToolCallLoop('bash', { command: 'echo 16' });
+  assert.ok(blocked.block === true, '16th bash call (varied args) should be blocked by per-tool cap');
+  assert.ok(blocked.reason!.includes('cap 15'), 'reason should mention the repeatable cap');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Mutation progress decays per-tool counts (#1092)
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Loop guard: mutation progress decays per-tool counts (#1092) ──');
+
+{
+  resetToolCallLoopGuard();
+
+  // bash is called more than the repeatable cap, but each count is separated
+  // by a successful file mutation. Guard 2 should treat that as progress and
+  // avoid blocking the progressing unit.
+  for (let i = 1; i <= 20; i++) {
+    const result = checkToolCallLoop('bash', { command: `echo ${i}` });
+    assert.ok(result.block === false, `bash call ${i} after mutation progress should be allowed`);
+    assert.deepStrictEqual(getToolCallCountForTool('bash'), 1, `bash count should decay before call ${i}`);
+
+    const mutationTool = i % 2 === 0 ? 'write' : 'edit';
+    const mutation = checkToolCallLoop(mutationTool, {
+      path: `file-${i}.ts`,
+      content: `content ${i}`,
+    });
+    assert.ok(mutation.block === false, `${mutationTool} mutation ${i} should be allowed`);
+    recordToolCallLoopMutation(mutationTool);
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Distinct read-only navigation calls are context gathering, not repeated-tool loops.
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Loop guard: distinct read-only navigation calls are not capped by per-tool count ──');
+
+{
+  const exemptTools = ['find', 'glob', 'grep', 'ls', 'read', 'search_and_read'];
+
+  for (const toolName of exemptTools) {
+    resetToolCallLoopGuard();
+
+    for (let i = 1; i <= 20; i++) {
+      const result = checkToolCallLoop(toolName, { path: `file-${i}.ts` });
+      assert.ok(result.block === false, `distinct ${toolName} call ${i} should be allowed`);
+    }
+
+    resetToolCallLoopGuard();
+    for (let i = 1; i <= 4; i++) {
+      const result = checkToolCallLoop(toolName, { path: 'same-file.ts' });
+      assert.ok(result.block === false, `identical ${toolName} call ${i} should be allowed`);
+    }
+
+    const blocked = checkToolCallLoop(toolName, { path: 'same-file.ts' });
+    assert.ok(blocked.block === true, `5th identical ${toolName} call should still be blocked`);
+    assert.ok(blocked.reason?.includes('identical args'), `${toolName} loops should be caught by Guard 1`);
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Per-tool counts are independent per tool and reset together
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Loop guard: per-tool counts are independent and reset together (#783) ──');
+
+{
+  resetToolCallLoopGuard();
+
+  // Two different tools tracked separately.
+  for (let i = 0; i < 3; i++) checkToolCallLoop('read', { path: `f${i}` });
+  for (let i = 0; i < 3; i++) checkToolCallLoop('write', { path: `g${i}` });
+  assert.deepStrictEqual(getToolCallCountForTool('read'), 3, 'read tracked separately');
+  assert.deepStrictEqual(getToolCallCountForTool('write'), 3, 'write tracked separately');
+  assert.deepStrictEqual(getToolCallCountForTool('edit'), 0, 'uncalled tool reports 0');
+
+  resetToolCallLoopGuard();
+  assert.deepStrictEqual(getToolCallCountForTool('read'), 0, 'per-tool counts cleared on reset');
+  assert.deepStrictEqual(getToolCallCountForTool('write'), 0, 'per-tool counts cleared on reset');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Non-exempt repeatable tools from core-session-tools.ts get the higher cap.
+// Read-only navigation tools are exempted earlier; mutating/execution repeatable
+// tools (e.g. gsd_exec) must still trip the per-tool cap.
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Loop guard: non-exempt repeatable tools get high cap ──');
+
+{
+  for (const toolName of ['bg_shell', 'gsd_exec', 'write']) {
+    resetToolCallLoopGuard();
+
+    // Should allow up to 15 varied calls without blocking.
+    for (let i = 1; i <= 15; i++) {
+      const result = checkToolCallLoop(toolName, { arg: `v${i}` });
+      assert.ok(result.block === false, `${toolName} call ${i} (varied args) should be allowed`);
+    }
+    // 16th call with varied args must be blocked by the per-tool repeatable cap.
+    const blocked = checkToolCallLoop(toolName, { arg: 'v16' });
+    assert.ok(blocked.block === true, `${toolName}: 16th call must be blocked by repeatable cap`);
+    assert.ok(blocked.reason?.includes('cap 15'), `${toolName}: reason must mention cap 15`);
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Non-repeatable tools excluded from INHERENTLY_REPEATABLE_TOOL_SET use the
+// default cap (6), not the repeatable cap (15).
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Loop guard: ToolSearch (excluded from repeatable set) hits default cap ──');
+
+{
+  // ToolSearch is in MINIMAL_AUTO_BASE but explicitly excluded from repeatable.
+  // It should hit the default cap of 6, not 15.
+  resetToolCallLoopGuard();
+  for (let i = 1; i <= 6; i++) {
+    const result = checkToolCallLoop('ToolSearch', { query: `q${i}` });
+    assert.ok(result.block === false, `ToolSearch call ${i} should be allowed`);
+  }
+  const blocked = checkToolCallLoop('ToolSearch', { query: 'q7' });
+  assert.ok(blocked.block === true, 'ToolSearch: 7th varied call must be blocked by default cap');
+  assert.ok(!blocked.reason?.includes('cap 15'), 'ToolSearch must NOT use the repeatable cap');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Block reasons instruct the model to stop tooling this turn
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Loop guard: block reasons tell model to respond in text ──');
+
+{
+  resetToolCallLoopGuard();
+
+  for (let i = 0; i < 4; i++) {
+    checkToolCallLoop('web_search', { query: 'same query' });
+  }
+  const identicalBlocked = checkToolCallLoop('web_search', { query: 'same query' });
+  assert.ok(identicalBlocked.block === true, 'identical-args guard should block');
+  assert.ok(
+    identicalBlocked.reason!.includes('respond to the user in text'),
+    'identical-args reason should tell the model to stop tooling',
+  );
+  assert.ok(
+    !identicalBlocked.reason!.includes('Try a different approach'),
+    'identical-args reason should not suggest retrying another tool',
+  );
+
+  resetToolCallLoopGuard();
+  for (let i = 0; i < 6; i++) {
+    checkToolCallLoop('gsd_complete_milestone', { milestone: `M${i}` });
+  }
+  const perToolBlocked = checkToolCallLoop('gsd_complete_milestone', { milestone: 'M7' });
+  assert.ok(perToolBlocked.block === true, 'per-tool guard should block');
+  assert.ok(
+    perToolBlocked.reason!.includes('respond to the user in text'),
+    'per-tool reason should tell the model to stop tooling',
+  );
+  assert.ok(
+    perToolBlocked.reason!.includes('Do not retry this tool'),
+    'per-tool reason should forbid retrying the blocked tool',
+  );
+}
+
+// ═══════════════════════════════════════════════════════════════════════════

package/src/resources/extensions/gsd/tests/tool-param-optionality.test.ts

@@ -13,6 +13,7 @@
 
 import { test } from "node:test";
 import assert from "node:assert/strict";
+import { SUMMARY_SAVE_CONTENT_MAX_LENGTH } from "@opengsd/contracts";
 import { registerDbTools } from "../bootstrap/db-tools.ts";
 import AjvModule from "ajv";
 
@@ -86,6 +87,31 @@ test("gsd_summary_save — validates UAT assessment params", () => {
   assert.strictEqual(valid, true, `UAT assessment params should validate but got errors: ${JSON.stringify(validate.errors)}`);
 });
 
+test("gsd_summary_save — content has a provider-safe maxLength", () => {
+  const tool = getTool("gsd_summary_save");
+  assert.ok(tool, "gsd_summary_save must be registered");
+
+  const contentSchema = tool.parameters.properties.content;
+  assert.strictEqual(contentSchema.maxLength, SUMMARY_SAVE_CONTENT_MAX_LENGTH);
+
+  const validAtLimit = validateSchema(tool, {
+    milestone_id: "M001",
+    artifact_type: "CONTEXT-DRAFT",
+    content: "x".repeat(SUMMARY_SAVE_CONTENT_MAX_LENGTH),
+  });
+  assert.deepEqual(validAtLimit, []);
+
+  const overLimit = validateSchema(tool, {
+    milestone_id: "M001",
+    artifact_type: "CONTEXT-DRAFT",
+    content: "x".repeat(SUMMARY_SAVE_CONTENT_MAX_LENGTH + 1),
+  });
+  assert.ok(
+    overLimit.some((error) => error.includes(`must NOT have more than ${SUMMARY_SAVE_CONTENT_MAX_LENGTH} characters`)),
+    `expected maxLength validation error, got: ${overLimit.join("; ")}`,
+  );
+});
+
 // ─── gsd_slice_complete: enrichment arrays must be optional ──────────────────
 
 test("gsd_slice_complete — enrichment arrays are optional", () => {
@@ -359,14 +385,17 @@ test("gsd_plan_slice — enrichment fields are optional", () => {
 
   const required = new Set(getRequiredProps(tool));
 
-  // Core fields
-  const coreRequired = ["milestoneId", "sliceId", "goal", "tasks"];
+  // Core fields. `tasks` is intentionally NOT here: incremental planning
+  // (#1027) lets gsd_plan_slice persist slice metadata only, then add tasks
+  // one at a time via gsd_plan_task, so tasks must be optional.
+  const coreRequired = ["milestoneId", "sliceId", "goal"];
   for (const field of coreRequired) {
     assert.ok(required.has(field), `core field "${field}" must be required`);
   }
 
-  // Enrichment fields
+  // Enrichment fields (plus tasks, optional for incremental planning).
   const enrichmentFields = [
+    "tasks",
     "successCriteria",
     "proofLevel",
     "integrationClosure",

package/src/resources/extensions/gsd/tests/tool-schema-model-fallback.test.ts

@@ -0,0 +1,64 @@
+/**
+ * tool-schema-model-fallback.test.ts — Regression test for #813.
+ *
+ * Auto mode aborted with "Schema overload: consecutive tool validation
+ * failures exceeded cap" instead of recovering. The tool-schema handler now
+ * attempts the unit's configured fallbacks and the auto-mode start model (the
+ * model the user actually selected) before hard-pausing, mirroring the
+ * model-error path.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { classifyError } from "../error-classifier.ts";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const RECOVERY_PATH = join(__dirname, "..", "bootstrap", "agent-end-recovery.ts");
+
+function getRecoverySource(): string {
+  return readFileSync(RECOVERY_PATH, "utf-8");
+}
+
+test("schema overload classifies as tool-schema (#813)", () => {
+  const cls = classifyError(
+    "Schema overload: consecutive tool validation failures exceeded cap",
+  );
+  assert.equal(cls.kind, "tool-schema");
+});
+
+test("tool-schema handler attempts model fallback before pausing (#813)", () => {
+  const src = getRecoverySource();
+
+  // Isolate the tool-schema branch body.
+  const branchStart = src.indexOf('if (cls.kind === "tool-schema")');
+  assert.ok(branchStart !== -1, "tool-schema branch must exist");
+  const branch = src.slice(branchStart, branchStart + 1200);
+
+  assert.ok(
+    branch.includes("tryProviderModelFallback"),
+    "tool-schema branch must attempt tryProviderModelFallback before pausing (#813)",
+  );
+  // Fallback success must short-circuit the pause so auto-mode continues.
+  assert.ok(
+    /if\s*\(switched\)\s*return;/.test(branch),
+    "tool-schema branch must return early when a fallback model is switched in (#813)",
+  );
+});
+
+test("tool-schema handler still pauses when no fallback succeeds (#813)", () => {
+  const src = getRecoverySource();
+
+  const branchStart = src.indexOf('if (cls.kind === "tool-schema")');
+  const branch = src.slice(branchStart, branchStart + 1200);
+
+  // The terminal pause must still classify as a tool-schema pause, not a
+  // generic provider pause.
+  assert.ok(
+    /category:\s*"tool-schema"/.test(branch),
+    "tool-schema branch must retain its tool-schema pause category when fallback fails (#813)",
+  );
+});