@opengsd/gsd-pi 1.9.0-dev.5c1a3ff2 → 1.9.0-dev.d2070876

package/src/resources/extensions/gsd/tests/external-markdown-edit.test.ts

@@ -8,7 +8,8 @@ import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
 
 import { externalMarkdownEditHandler } from "../state-reconciliation/drift/external-markdown-edit.ts";
-import { writeCompatMarker, computeProjectionSha } from "../compat/compat-marker.ts";
+import { readCompatMarker, writeCompatMarker, computeProjectionSha } from "../compat/compat-marker.ts";
+import { closeDatabase, insertArtifact, openDatabase } from "../gsd-db.ts";
 import type { DriftContext } from "../state-reconciliation/types.ts";
 import type { GSDState } from "../types.ts";
 
@@ -28,6 +29,11 @@ function ctx(base: string): DriftContext {
 }
 
 afterEach(() => {
+  try {
+    closeDatabase();
+  } catch {
+    /* noop */
+  }
   for (const dir of tmpDirs) {
     try { rmSync(dir, { recursive: true, force: true }); } catch { /* */ }
   }
@@ -71,6 +77,37 @@ test("detect returns drift when file content differs from marker", async () => {
   assert.deepEqual(drift[0].entities, ["m1"]);
 });
 
+test("detect refreshes stale marker when current file already matches DB artifact", async () => {
+  const base = makeTmpBase();
+  const rel = "milestones/M001/M001-ROADMAP.md";
+  const dbRel = "phases/01-alpha/01-ROADMAP.md";
+  const content = "# M001: Alpha\n\n## Slices\n\n- [ ] **S01: Work** `risk:low` `depends:[]`\n";
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  writeFileSync(join(base, ".gsd", rel), content, "utf-8");
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertArtifact({
+    path: dbRel,
+    artifact_type: "ROADMAP",
+    milestone_id: "M001",
+    slice_id: null,
+    task_id: null,
+    full_content: content,
+  });
+  writeCompatMarker(base, {
+    schema: 2,
+    lastWriter: "gsd-pi",
+    lastProjectedAt: "2026-06-21T00:00:00.000Z",
+    projections: { [rel]: { sha: "stale000000000000", entities: ["M001"] } },
+    planning: { active: false, layout: null, projections: {}, passthrough: {} },
+    piVersion: "1.9.0",
+  });
+
+  const drift = await externalMarkdownEditHandler.detect(stubState, ctx(base));
+  assert.equal(drift.length, 0);
+  const marker = readCompatMarker(base);
+  assert.equal(marker.projections[rel]?.sha, computeProjectionSha(content));
+});
+
 test("detect treats missing marker as drift on every tracked projection file", async () => {
   const base = makeTmpBase();
   const rel = "m1/roadmap.md";

package/src/resources/extensions/gsd/tests/flat-phase-migration.test.ts

@@ -122,7 +122,7 @@ test("migrateToFlatPhase creates a backup", async () => {
   assert.ok(backups.length >= 1, "at least one migrate-* backup dir should exist");
 });
 
-test("migrateToFlatPhase backs up existing phases projection before clearing it", async () => {
+test("migrateToFlatPhase removes disposable phases snapshot after successful migration", async () => {
   const base = makeTmp();
   const reviewPath = join(base, ".gsd", "phases", "01-foundation", "PLAN-REVIEW.md");
   mkdirSync(join(base, ".gsd", "phases", "01-foundation"), { recursive: true });
@@ -133,11 +133,10 @@ test("migrateToFlatPhase backs up existing phases projection before clearing it"
   const backupRoot = join(base, ".gsd-backups");
   const backups = readdirSync(backupRoot).filter(d => d.startsWith("migrate-"));
   assert.equal(backups.length, 1, "one migrate backup should exist");
-  const backedUpReview = join(backupRoot, backups[0]!, "__phases", "01-foundation", "PLAN-REVIEW.md");
   assert.equal(
-    readFileSync(backedUpReview, "utf-8"),
-    "# Plan Review\n\nHand-authored review.",
-    "pre-existing phases/ files should have a recovery copy",
+    existsSync(join(backupRoot, backups[0]!, "__phases")),
+    false,
+    "temporary phases/ recovery snapshot should be removed after success",
   );
 });
 
@@ -202,7 +201,7 @@ test("failed migration rolls back without leaking a .gsd-backups/migrate-* dir",
   assert.equal(leaked.length, 0, "rollback must delete the migrate-* backup it created");
 });
 
-test("resumed migration stores phases backup in retained migrate snapshot", async () => {
+test("resumed migration removes disposable phases snapshot after success", async () => {
   const base = makeTmp();
   const milestonesPath = join(base, ".gsd", "milestones");
   const migratingPath = join(base, ".gsd", "milestones.migrating");
@@ -218,9 +217,9 @@ test("resumed migration stores phases backup in retained migrate snapshot", asyn
   const backups = readdirSync(backupRoot).filter((d) => d.startsWith("migrate-"));
   assert.equal(backups.length, 1, "resumed migration should create one retained migrate backup");
   assert.equal(
-    readFileSync(join(backupRoot, backups[0]!, "__phases", "01-foundation", "PLAN-REVIEW.md"), "utf-8"),
-    "# Plan Review\n\nResume recovery copy.",
-    "resume should retain the phases snapshot under .gsd-backups",
+    existsSync(join(backupRoot, backups[0]!, "__phases")),
+    false,
+    "temporary phases/ recovery snapshot should be removed after resumed success",
   );
   assert.equal(
     existsSync(join(migratingPath, "__phases")),

package/src/resources/extensions/gsd/tests/flat-phase-validation-path.test.ts

@@ -9,7 +9,7 @@ import { join } from "node:path";
 import assert from "node:assert/strict";
 import test from "node:test";
 
-import { normalizeRealPath, relMilestoneFile, relSliceFile, resolveMilestoneFile, targetMilestoneFile } from "../paths.ts";
+import { normalizeRealPath, relMilestoneFile, relSliceFile, resolveMilestoneFile, resolveSliceFile, targetMilestoneFile } from "../paths.ts";
 
 function makeFlatPhaseFixture(): { basePath: string; cleanup: () => void } {
   const basePath = mkdtempSync(join(tmpdir(), "flat-phase-validation-"));
@@ -99,6 +99,25 @@ test("flat-phase: resolveMilestoneFile finds the on-disk file", (t) => {
   assert.equal(existsSync(abs!), true);
 });
 
+test("flat-phase: file resolvers ignore directories with artifact-like names", (t) => {
+  const basePath = mkdtempSync(join(tmpdir(), "flat-phase-dir-artifacts-"));
+  t.after(() => rmSync(basePath, { recursive: true, force: true }));
+  const phaseDir = join(basePath, ".gsd", "phases", "03-match-capture-manual-entry");
+  mkdirSync(join(phaseDir, "03-VALIDATION.md"), { recursive: true });
+  mkdirSync(join(phaseDir, "03-01-SUMMARY.md"), { recursive: true });
+
+  assert.equal(
+    resolveMilestoneFile(basePath, "M003", "VALIDATION"),
+    null,
+    "milestone resolver must not return a directory as a validation file",
+  );
+  assert.equal(
+    resolveSliceFile(basePath, "M003", "S01", "SUMMARY"),
+    null,
+    "slice resolver must not return a directory as a summary file",
+  );
+});
+
 test("flat-phase: the legacy hardcoded path does NOT resolve (regression for #876)", (t) => {
   const { basePath, cleanup } = makeFlatPhaseFixture();
   t.after(cleanup);

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

@@ -46,6 +46,9 @@ import {
   tryCreateMemoriesFts,
   _isLikelyWslDrvFsPathForTest,
   _shouldAttemptVacuumRecoveryForTest,
+  insertArtifact,
+  getArtifact,
+  upsertMilestonePlanning,
 } from '../gsd-db.ts';
 import { MigrationBackupError } from '../db-migration-backup.ts';
 import { _resetLogs, peekLogs, setStderrLoggingEnabled } from '../workflow-logger.ts';
@@ -357,6 +360,35 @@ describe('gsd-db', () => {
     closeDatabase();
   });
 
+  test("gsd-db: upsertMilestonePlanning rewrites placeholder phase artifact paths to final title slug", () => {
+    openDatabase(":memory:");
+
+    const stalePath = "phases/01-new-milestone-m001/01-ROADMAP.md";
+    const finalPath = "phases/01-lokably-brand-foundation-and-welcome-pag/01-ROADMAP.md";
+    insertMilestone({ id: "M001", title: "New milestone M001", status: "active" });
+    insertArtifact({
+      path: stalePath,
+      artifact_type: "ROADMAP",
+      milestone_id: "M001",
+      slice_id: null,
+      task_id: null,
+      full_content: "# Placeholder roadmap\n",
+    });
+
+    upsertMilestonePlanning("M001", {
+      title: "Lokably brand foundation and welcome page rebuild",
+    });
+
+    assert.equal(getArtifact(stalePath), null, "placeholder-derived artifact row should be removed");
+    assert.equal(
+      getArtifact(finalPath)?.full_content,
+      "# Placeholder roadmap\n",
+      "artifact row should move to the final title-derived phase path",
+    );
+
+    closeDatabase();
+  });
+
   test('gsd-db: active_requirements view excludes superseded', () => {
     openDatabase(':memory:');
 

package/src/resources/extensions/gsd/tests/guided-discuss-milestone-prompt-rendering.test.ts

@@ -87,6 +87,28 @@ test("guided milestone prompt builder preloads milestone planning context", asyn
   }
 });
 
+test("guided milestone prompt builder prepends configured response language", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-guided-milestone-language-"));
+  const gsdHome = mkdtempSync(join(tmpdir(), "gsd-guided-milestone-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");
+
+    const prompt = await buildDiscussMilestonePrompt("M001", "Language Preference", base, "true", {
+      includeContextMode: false,
+    });
+
+    assert.match(prompt, /^## Response Language\n\nAlways respond in 中文/);
+  } finally {
+    if (previousGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = previousGsdHome;
+    rmSync(base, { recursive: true, force: true });
+    rmSync(gsdHome, { recursive: true, force: true });
+  }
+});
+
 test("guided milestone prompt builder caps prior draft seed before interpolation", async () => {
   const base = mkdtempSync(join(tmpdir(), "gsd-guided-milestone-draft-cap-"));
   const previousGsdHome = process.env.GSD_HOME;

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

@@ -1428,6 +1428,19 @@ process.exit(result.status ?? 0);
     rmSync(repo, { recursive: true, force: true });
   });
 
+  test('Integration branch: write does not create legacy milestones scaffold', () => {
+    const repo = initBranchTestRepo();
+    mkdirSync(join(repo, ".gsd", "phases"), { recursive: true });
+
+    writeIntegrationBranch(repo, "M001", "f-123-new-thing");
+
+    assert.deepStrictEqual(readIntegrationBranch(repo, "M001"), "f-123-new-thing");
+    assert.ok(existsSync(join(repo, ".gsd", "M001-META.json")), "metadata is written at the flat .gsd root");
+    assert.ok(!existsSync(join(repo, ".gsd", "milestones")), "legacy milestones/ root is not created");
+
+    rmSync(repo, { recursive: true, force: true });
+  });
+
   // ─── writeIntegrationBranch: updates when branch changes (#300) ──────
 
   test('Integration branch: updates on branch change', () => {

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

@@ -775,6 +775,27 @@ describe("prompt-budget: execute-task inline cap (039)", () => {
 });
 
 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 {

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/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/state-reconciliation-drift.test.ts

@@ -1618,6 +1618,58 @@ test("ADR-017 (#5705): in-sync ROADMAP and DB → no roadmap-divergence drift",
   );
 });
 
+test("ADR-017 (#1370): roadmap-divergence skips completed milestone sharing active worktree phase", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-adr017-roadmap-shared-phase-"));
+  const milestoneDir = join(base, ".gsd", "phases", "06-rlrbot-m006-rlrbot-tool-registry-and-command-sa");
+  const roadmapPath = join(milestoneDir, "06-ROADMAP.md");
+  mkdirSync(milestoneDir, { recursive: true });
+  mkdirSync(join(base, ".gsd", "milestones", "M006"), { recursive: true });
+  mkdirSync(join(base, ".gsd", "milestones", "M006-rlrbot"), { recursive: true });
+  writeFileSync(join(base, ".gsd", "milestones", "M006", "M006-META.json"), "{}\n");
+  writeFileSync(join(base, ".gsd", "milestones", "M006-rlrbot", "M006-rlrbot-META.json"), "{}\n");
+  const activeRoadmap = [
+    "# M006-rlrbot: Active worktree",
+    "",
+    "**Vision:** Keep the active worktree projection authoritative.",
+    "",
+    "## Slices",
+    "",
+    "- [ ] **S01: Shared slice** `risk:medium` `depends:[]`",
+    "  > After this: Active work remains pending.",
+    "",
+  ].join("\n");
+  writeFileSync(roadmapPath, activeRoadmap);
+  t.after(() => {
+    try { closeDatabase(); } catch { /* noop */ }
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M006", title: "Completed source", status: "complete" });
+  insertSlice({ id: "S01", milestoneId: "M006", title: "Shared slice", status: "complete", risk: "medium", depends: [], demo: "Completed.", sequence: 1 });
+  insertMilestone({
+    id: "M006-rlrbot",
+    title: "Active worktree",
+    status: "active",
+    planning: { vision: "Keep the active worktree projection authoritative." },
+  });
+  insertSlice({ id: "S01", milestoneId: "M006-rlrbot", title: "Shared slice", status: "pending", risk: "medium", depends: [], demo: "Active work remains pending.", sequence: 1 });
+  insertTask({ id: "T01", sliceId: "S01", milestoneId: "M006-rlrbot", title: "Plan active work", status: "pending" });
+
+  const result = await reconcileBeforeDispatch(base, {
+    invalidateStateCache: () => {},
+    deriveState: async () => makeState({ activeMilestone: { id: "M006-rlrbot", title: "Active worktree" } }),
+  });
+
+  assert.equal(result.ok, true);
+  assert.equal(
+    result.repaired.some((d) => d.kind === "roadmap-divergence"),
+    false,
+    "completed milestone sharing the phase dir must not trigger roadmap-divergence repair",
+  );
+  assert.equal(readFileSync(roadmapPath, "utf-8"), activeRoadmap);
+});
+
 // ─── #5706: missing-completion-timestamp drift ──────────────────────────────
 
 test("ADR-017 (#5706): task with SUMMARY but null completed_at → backfilled", async (t) => {

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

@@ -7,6 +7,8 @@ import assert from "node:assert/strict";
 
 import {
   formatStopNoticePrefix,
+  formatVerdictRecordedNotice,
+  formatVerdictRejectedNotice,
   isBlockedStopReason,
   stopNoticeDisplayReason,
   stopNoticeKind,
@@ -63,6 +65,17 @@ describe("emitter↔detector round-trip", () => {
     assert.ok(isBlockedNoticeMessage(message));
   });
 
+  test("verdict notices classify as terminal with rejected notices blocked", () => {
+    const recorded = formatVerdictRecordedNotice("Milestone M001 verdict: needs-attention -> pass").toLowerCase();
+    const rejected = formatVerdictRejectedNotice("No milestone validation found for M001.").toLowerCase();
+
+    assert.ok(isTerminalNotice(recorded));
+    assert.equal(isBlockedNoticeMessage(recorded), false);
+
+    assert.ok(isTerminalNotice(rejected));
+    assert.ok(isBlockedNoticeMessage(rejected));
+  });
+
   test("un-showable menu notices classify as blocked (#1294)", () => {
     // Emitted verbatim by notifyCommandMenuUnavailable (next-action-ui.ts / command-feedback.ts).
     const menuUnavailable =
@@ -80,7 +93,14 @@ describe("emitter↔detector round-trip", () => {
   });
 
   test("terminal prefixes cover the known stop vocabulary", () => {
-    for (const message of ["auto-mode stopped.", "auto-mode complete", "auto-mode idle", "no active milestone"]) {
+    for (const message of [
+      "auto-mode stopped.",
+      "auto-mode complete",
+      "auto-mode idle",
+      "no active milestone",
+      "verdict recorded: milestone m001 verdict: needs-attention -> pass",
+      "verdict rejected: unexpected argument: x",
+    ]) {
       assert.ok(TERMINAL_NOTICE_PREFIXES.some((prefix) => message.startsWith(prefix)), message);
     }
   });

package/src/resources/extensions/gsd/tests/terminated-transient.test.ts

@@ -17,6 +17,20 @@ test("#2309: 'terminated' errors should be classified as transient", () => {
   assert.equal("retryAfterMs" in result && result.retryAfterMs, 15_000, "'terminated' should use 15s backoff");
 });
 
+test("#1364: provider abort stop reasons should be classified as transient", () => {
+  const result = classifyError("Unhandled stop reason: abort");
+  assert.equal(isTransient(result), true, "'abort' provider errors should be transient");
+  assert.equal(result.kind, "connection", "'abort' matches connection");
+  assert.equal("retryAfterMs" in result && result.retryAfterMs, 15_000, "'abort' should use 15s backoff");
+});
+
+test("#1364: provider unknown stop reasons should be classified as transient", () => {
+  const result = classifyError("Unhandled stop reason: unknown");
+  assert.equal(isTransient(result), true, "'unknown' provider stop reasons should be transient");
+  assert.equal(result.kind, "connection", "'unknown' stop reasons match connection");
+  assert.equal("retryAfterMs" in result && result.retryAfterMs, 15_000, "'unknown' should use 15s backoff");
+});
+
 test("#2309: 'connection reset by peer' errors should be classified as transient (network)", () => {
   const result = classifyError("connection reset by peer");
   assert.equal(isTransient(result), true, "'connection reset by peer' should be transient");