@opengsd/gsd-pi 1.3.0 → 1.4.0-dev.c18009cd

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

@@ -297,6 +297,41 @@ test("cross-provider: configured primary available by bare ID wins over equivale
   assert.equal(result.wasDowngraded, false);
 });
 
+test("resolveModelForComplexity: preferred GLM session model wins over cheaper standard-tier GLM models", () => {
+  const config: DynamicRoutingConfig = { ...defaultRoutingConfig(), enabled: true, capability_routing: false };
+  const result = resolveModelForComplexity(
+    makeClassification("standard"),
+    { primary: "claude-opus-4-6", fallbacks: [] },
+    config,
+    ["zai/glm-4.5-air", "zai/glm-5.1", "zai/glm-5.2"],
+    "execute-task",
+    undefined,
+    undefined,
+    "zai/glm-5.2",
+  );
+  assert.equal(result.modelId, "zai/glm-5.2");
+  assert.equal(result.selectionMethod, "tier-only");
+});
+
+test("resolveModelForComplexity: wasDowngraded is false when preferred session model matches configuredPrimary with different ID format", () => {
+  // configuredPrimary is bare ("claude-opus-4-6"), preferred comes back as provider-prefixed
+  // ("anthropic/claude-opus-4-6") from availableModelIds. They refer to the same model —
+  // wasDowngraded must NOT be true, which would otherwise trigger a spurious UI notification.
+  const config: DynamicRoutingConfig = { ...defaultRoutingConfig(), enabled: true, capability_routing: false };
+  const result = resolveModelForComplexity(
+    makeClassification("standard"),
+    { primary: "claude-opus-4-6", fallbacks: [] },
+    config,
+    ["anthropic/claude-opus-4-6"],
+    "execute-task",
+    undefined,
+    undefined,
+    "anthropic/claude-opus-4-6",
+  );
+  assert.equal(result.modelId, "anthropic/claude-opus-4-6");
+  assert.equal(result.wasDowngraded, false);
+});
+
 // ─── resolveModelForTier (provider-agnostic tier resolution) ────────────────
 
 test("resolveModelForTier: returns canonical Anthropic model when no available models", () => {
@@ -355,15 +390,68 @@ test("resolveModelForTier: picks light-tier cross-provider model", () => {
   assert.equal(result, "gpt-4o-mini");
 });
 
-test("resolveModelForTier: falls back to canonical when no tier match available", () => {
+test("resolveModelForTier: preserves selected standard-tier model over cheaper same-tier provider models", () => {
+  const result = resolveModelForTier(
+    "standard",
+    ["zai/glm-4.5-air", "zai/glm-5.1", "zai/glm-5.2"],
+    defaultRoutingConfig(),
+    true,
+    "zai/glm-5.2",
+  );
+  assert.equal(result, "zai/glm-5.2");
+});
+
+test("resolveModelForTier: light tier with no light provider model stays on selected provider model", () => {
   try {
     resetLegacyTelemetry();
-    // Only unknown models available — getModelTier classifies unknowns as
-    // "standard", so a request for "heavy" finds no match and the canonical
-    // Anthropic ID is returned as a documented fallback.
-    const result = resolveModelForTier("heavy", ["some-custom-model"]);
-    assert.equal(result, "claude-opus-4-6");
-    assert.equal(getLegacyTelemetry()["legacy.providerDefaultUsed"], 1);
+    const result = resolveModelForTier(
+      "light",
+      ["zai/glm-4.5-air", "zai/glm-5.1", "zai/glm-5.2"],
+      defaultRoutingConfig(),
+      true,
+      "zai/glm-5.2",
+    );
+    assert.equal(result, "zai/glm-5.2");
+    assert.equal(getLegacyTelemetry()["legacy.providerDefaultUsed"], 0);
+  } finally {
+    resetLegacyTelemetry();
+  }
+});
+
+test("resolveModelForTier: cross_provider:false ignores non-Anthropic preferred model and returns Claude", () => {
+  // When dynamic_routing.cross_provider is false, the sameProvider (Claude-only) filter must
+  // win over a non-Anthropic session model — the preferred model must not bypass the restriction.
+  const config: DynamicRoutingConfig = { ...defaultRoutingConfig(), cross_provider: false };
+  const result = resolveModelForTier(
+    "standard",
+    ["zai/glm-5.2", "claude-sonnet-4-6"],
+    config,
+    false, // crossProvider=false
+    "zai/glm-5.2",
+  );
+  assert.equal(result, "claude-sonnet-4-6");
+});
+
+test("resolveModelForTier: cross_provider:false honors preferred model when it is a Claude model", () => {
+  // When the session model itself is a Claude model, it should still win within the
+  // same-provider restriction.
+  const config: DynamicRoutingConfig = { ...defaultRoutingConfig(), cross_provider: false };
+  const result = resolveModelForTier(
+    "standard",
+    ["anthropic/claude-sonnet-4-6", "anthropic/claude-haiku-4-5"],
+    config,
+    false,
+    "anthropic/claude-sonnet-4-6",
+  );
+  assert.equal(result, "claude-sonnet-4-6");
+});
+
+test("resolveModelForTier: non-empty provider list without a tier match does not fall back to canonical", () => {
+  try {
+    resetLegacyTelemetry();
+    const result = resolveModelForTier("heavy", ["zai/glm-5.2"]);
+    assert.equal(result, "zai/glm-5.2");
+    assert.equal(getLegacyTelemetry()["legacy.providerDefaultUsed"], 0);
   } finally {
     resetLegacyTelemetry();
   }
@@ -429,6 +517,34 @@ test("resolveProfileDefaults: empty availableModelIds falls back to canonical An
   assert.ok(typeof planningModel === "string" && planningModel.startsWith("claude-"));
 });
 
+test("resolveProfileDefaults: empty availableModelIds preserves selected model when provided", async () => {
+  const { resolveProfileDefaults } = await import("../preferences-models.js");
+  const defaults = resolveProfileDefaults(
+    "balanced",
+    [],
+    defaultRoutingConfig(),
+    "zai/glm-5.2",
+  );
+  assert.equal(defaults.models?.planning, "zai/glm-5.2");
+  assert.equal(defaults.models?.execution, "zai/glm-5.2");
+  assert.equal(defaults.models?.completion, "zai/glm-5.2");
+  assert.equal(defaults.models?.subagent, "zai/glm-5.2");
+});
+
+test("resolveProfileDefaults: selected GLM model wins for standard and light profile slots", async () => {
+  const { resolveProfileDefaults } = await import("../preferences-models.js");
+  const defaults = resolveProfileDefaults(
+    "balanced",
+    ["zai/glm-4.5-air", "zai/glm-5.1", "zai/glm-5.2"],
+    defaultRoutingConfig(),
+    "zai/glm-5.2",
+  );
+  assert.equal(defaults.models?.planning, "zai/glm-5.2");
+  assert.equal(defaults.models?.execution, "zai/glm-5.2");
+  assert.equal(defaults.models?.completion, "zai/glm-5.2");
+  assert.equal(defaults.models?.subagent, "zai/glm-5.2");
+});
+
 test("loadEffectiveGSDPreferences: balanced profile resolves OpenAI tiers from registry", async () => {
   const oldHome = process.env.GSD_HOME;
   const { mkdtempSync, rmSync, writeFileSync } = await import("node:fs");
@@ -496,6 +612,87 @@ test("loadEffectiveGSDPreferences: implicit balanced (D046) resolves tiers from
   }
 });
 
+test("loadEffectiveGSDPreferences: implicit balanced preserves selected GLM model", async () => {
+  const oldHome = process.env.GSD_HOME;
+  const { mkdtempSync, rmSync, writeFileSync } = await import("node:fs");
+  const { join } = await import("node:path");
+  const { tmpdir } = await import("node:os");
+  const home = mkdtempSync(join(tmpdir(), "gsd-profile-selected-glm-"));
+  try {
+    process.env.GSD_HOME = home;
+    writeFileSync(join(home, "PREFERENCES.md"), "---\nmode: solo\n---\n");
+    const { loadEffectiveGSDPreferencesWithRegistry } = await import("../preferences.ts");
+    const registry = {
+      getAvailable: () => [
+        { provider: "zai", id: "glm-4.5-air" },
+        { provider: "zai", id: "glm-5.1" },
+        { provider: "zai", id: "glm-5.2" },
+      ],
+    };
+    const loaded = loadEffectiveGSDPreferencesWithRegistry(registry, undefined, "zai", "zai/glm-5.2");
+    const models = loaded?.preferences.models as Record<string, string> | undefined;
+    assert.equal(models?.planning, "zai/glm-5.2");
+    assert.equal(models?.execution, "zai/glm-5.2");
+    assert.equal(models?.completion, "zai/glm-5.2");
+  } finally {
+    if (oldHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = oldHome;
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test("loadEffectiveGSDPreferences: implicit balanced preserves selected model when scoped registry is empty", async () => {
+  const oldHome = process.env.GSD_HOME;
+  const { mkdtempSync, rmSync, writeFileSync } = await import("node:fs");
+  const { join } = await import("node:path");
+  const { tmpdir } = await import("node:os");
+  const home = mkdtempSync(join(tmpdir(), "gsd-profile-empty-scope-selected-"));
+  try {
+    process.env.GSD_HOME = home;
+    writeFileSync(join(home, "PREFERENCES.md"), "---\nmode: solo\n---\n");
+    const { loadEffectiveGSDPreferencesWithRegistry } = await import("../preferences.ts");
+    const registry = {
+      getAvailable: () => [
+        { provider: "google", id: "gemini-2.0-flash" },
+        { provider: "openai-codex", id: "gpt-4o" },
+      ],
+    };
+    const loaded = loadEffectiveGSDPreferencesWithRegistry(registry, undefined, "zai", "zai/glm-5.2");
+    const models = loaded?.preferences.models as Record<string, string> | undefined;
+    assert.equal(models?.planning, "zai/glm-5.2");
+    assert.equal(models?.execution, "zai/glm-5.2");
+    assert.equal(models?.completion, "zai/glm-5.2");
+    assert.equal(models?.subagent, "zai/glm-5.2");
+  } finally {
+    if (oldHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = oldHome;
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test("loadEffectiveGSDPreferences: implicit balanced preserves selected model when registry is missing", async () => {
+  const oldHome = process.env.GSD_HOME;
+  const { mkdtempSync, rmSync, writeFileSync } = await import("node:fs");
+  const { join } = await import("node:path");
+  const { tmpdir } = await import("node:os");
+  const home = mkdtempSync(join(tmpdir(), "gsd-profile-missing-registry-selected-"));
+  try {
+    process.env.GSD_HOME = home;
+    writeFileSync(join(home, "PREFERENCES.md"), "---\nmode: solo\n---\n");
+    const { loadEffectiveGSDPreferencesWithRegistry } = await import("../preferences.ts");
+    const loaded = loadEffectiveGSDPreferencesWithRegistry(undefined, undefined, undefined, "zai/glm-5.2");
+    const models = loaded?.preferences.models as Record<string, string> | undefined;
+    assert.equal(models?.planning, "zai/glm-5.2");
+    assert.equal(models?.execution, "zai/glm-5.2");
+    assert.equal(models?.completion, "zai/glm-5.2");
+    assert.equal(models?.subagent, "zai/glm-5.2");
+  } finally {
+    if (oldHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = oldHome;
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
 test("modelIdsForProfileResolution: empty anchor scope does not fall back to other providers", async () => {
   const { modelIdsForProfileResolution } = await import("../preferences.ts");
   const registry = {

package/src/resources/extensions/gsd/tests/notification-store.test.ts

@@ -306,6 +306,29 @@ describe("notification-store", () => {
     rmSync(lockPath, { force: true });
   });
 
+  test("markAllRead does not busy-spin when a foreign lock is held", (t) => {
+    initNotificationStore(tmp);
+    appendNotification("msg1", "info");
+
+    const lockPath = join(tmp, ".gsd", "notifications.lock");
+    writeFileSync(lockPath, "1000", "utf-8");
+
+    let now = 1001;
+    let calls = 0;
+    t.mock.method(Date, "now", () => {
+      calls++;
+      return now++;
+    });
+
+    markAllRead();
+
+    assert.ok(calls <= 2, `expected no retry spin, got ${calls} Date.now calls`);
+    assert.ok(existsSync(lockPath), "foreign lock file should not be deleted");
+    assert.equal(getUnreadCount(), 0, "best-effort mutation should still run");
+
+    rmSync(lockPath, { force: true });
+  });
+
   test("structured meta persists kind and scope on the entry", () => {
     initNotificationStore(tmp);
     appendNotification("Auto-mode blocked — validation gate", "warning", "notify", { kind: "auto-stop", scope: "M005" });

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

@@ -1,5 +1,7 @@
 import test from "node:test";
 import assert from "node:assert/strict";
+import childProcess from "node:child_process";
+import type { ChildProcess } from "node:child_process";
 import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -11,6 +13,7 @@ import {
   buildDesktopNotificationCommand,
   shouldSendDesktopNotification,
   formatNotificationTitle,
+  launchDesktopNotification,
   playNotificationBell,
   shouldPlayNotificationBell,
 } from "../notifications.js";
@@ -127,6 +130,36 @@ test("stopAuto plays local bell for auto-mode stop notifications", async () => {
   }
 });
 
+test("launchDesktopNotification starts notifier as detached fire-and-forget process", (t) => {
+  const child = {
+    on(_event: string, _listener: (error: Error) => void) {
+      return child;
+    },
+    unref() {
+      return child;
+    },
+  };
+  const onMock = t.mock.method(child, "on");
+  const unrefMock = t.mock.method(child, "unref");
+  const spawnMock = t.mock.method(
+    childProcess,
+    "spawn",
+    () => child as unknown as ChildProcess,
+  );
+
+  launchDesktopNotification({ file: "notify-send", args: ["Title", "Message"] });
+
+  assert.equal(spawnMock.mock.callCount(), 1);
+  assert.deepEqual(spawnMock.mock.calls[0].arguments, [
+    "notify-send",
+    ["Title", "Message"],
+    { detached: true, stdio: "ignore" },
+  ]);
+  assert.equal(onMock.mock.callCount(), 1);
+  assert.equal(onMock.mock.calls[0].arguments[0], "error");
+  assert.equal(unrefMock.mock.callCount(), 1);
+});
+
 test("buildDesktopNotificationCommand falls back to osascript on macOS when terminal-notifier is absent", () => {
   // When terminal-notifier is not on PATH, falls back to osascript.
   // This test runs in CI where terminal-notifier is typically not installed.

package/src/resources/extensions/gsd/tests/observability-validator-boundary.test.ts

@@ -0,0 +1,194 @@
+// Regression tests for issue #912:
+// validatePlanBoundary and validateCompleteBoundary must load all task
+// artifact files and collect issues from every file, not just the first.
+//
+// The bug was sequential await-inside-loop loading; the fix batches reads
+// with Promise.all. These tests assert the observable outcome: issues are
+// returned for every task file present, not only one.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync, realpathSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { validatePlanBoundary, validateCompleteBoundary } from "../observability-validator.ts";
+import { clearPathCache, _clearGsdRootCache } from "../paths.ts";
+
+// ─── Fixtures ───────────────────────────────────────────────────────────────
+//
+// Each file is intentionally minimal so it triggers at least one deterministic
+// validation issue (missing ## Steps → empty_steps_section, missing frontmatter
+// observability_surfaces → missing_observability_frontmatter). The exact issue
+// count is not asserted; we only verify that at least one issue refers to each
+// task file path, proving all files were loaded and validated.
+
+const BARE_TASK_PLAN = (id: string) => `# ${id}: Bare Task\n\n## Description\n\nDoes something.\n`;
+
+const BARE_TASK_SUMMARY = (id: string) => `# ${id}-SUMMARY\n\n## Summary\n\nCompleted.\n`;
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+/**
+ * Create an isolated temp project root and return its path plus a cleanup
+ * function that clears path caches and removes the directory.
+ */
+function makeProject(): { root: string; cleanup: () => void } {
+  const root = realpathSync(mkdtempSync(join(tmpdir(), "gsd-obs-boundary-")));
+  return {
+    root,
+    cleanup() {
+      _clearGsdRootCache();
+      clearPathCache();
+      try { rmSync(root, { recursive: true, force: true }); } catch { /* ignore */ }
+    },
+  };
+}
+
+/**
+ * Create the legacy tasks directory structure inside a temp project root:
+ *   {root}/.gsd/milestones/{mid}/slices/{sid}/tasks/
+ *
+ * Legacy layout is used because flat-phase projects embed tasks as inline
+ * checkboxes in the slice plan file (no tasks/ subdir). The legacy layout
+ * has an explicit tasks/ directory that resolveTasksDir returns.
+ */
+function makeLegacyTasksDir(root: string, mid: string, sid: string): string {
+  const dir = join(root, ".gsd", "milestones", mid, "slices", sid, "tasks");
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+// ─── Tests ──────────────────────────────────────────────────────────────────
+
+// ── validatePlanBoundary ────────────────────────────────────────────────────
+
+test("#912 validatePlanBoundary: issues collected from every task plan file", async (t) => {
+  const { root, cleanup } = makeProject();
+  t.after(cleanup);
+
+  _clearGsdRootCache();
+  clearPathCache();
+
+  const tasksDir = makeLegacyTasksDir(root, "M001", "S01");
+  writeFileSync(join(tasksDir, "T01-PLAN.md"), BARE_TASK_PLAN("T01"), "utf-8");
+  writeFileSync(join(tasksDir, "T02-PLAN.md"), BARE_TASK_PLAN("T02"), "utf-8");
+  writeFileSync(join(tasksDir, "T03-PLAN.md"), BARE_TASK_PLAN("T03"), "utf-8");
+
+  _clearGsdRootCache();
+  clearPathCache();
+
+  const issues = await validatePlanBoundary(root, "M001", "S01");
+
+  // Every task file must appear in at least one issue — proving all three
+  // were loaded. Before the fix only the last file in the loop would be
+  // validated because the loop re-used a stale `content` binding.
+  const paths = new Set(issues.map(i => i.file));
+  assert.ok(
+    paths.size >= 3,
+    `expected issues from at least 3 task plan files, got paths: ${JSON.stringify([...paths])}`,
+  );
+
+  const t01Issues = issues.filter(i => i.file.includes("T01"));
+  const t02Issues = issues.filter(i => i.file.includes("T02"));
+  const t03Issues = issues.filter(i => i.file.includes("T03"));
+  assert.ok(t01Issues.length > 0, "T01-PLAN.md should produce at least one validation issue");
+  assert.ok(t02Issues.length > 0, "T02-PLAN.md should produce at least one validation issue");
+  assert.ok(t03Issues.length > 0, "T03-PLAN.md should produce at least one validation issue");
+});
+
+test("#912 validatePlanBoundary: no issues when tasks directory is empty", async (t) => {
+  const { root, cleanup } = makeProject();
+  t.after(cleanup);
+
+  _clearGsdRootCache();
+  clearPathCache();
+
+  // Create the tasks dir but leave it empty — no PLAN files.
+  makeLegacyTasksDir(root, "M001", "S01");
+
+  _clearGsdRootCache();
+  clearPathCache();
+
+  const issues = await validatePlanBoundary(root, "M001", "S01");
+
+  // No slice plan and no task plans → no issues.
+  assert.strictEqual(issues.length, 0, "empty tasks dir should produce no issues");
+});
+
+test("#912 validatePlanBoundary: returns empty array when basePath has no .gsd dir", async (t) => {
+  const { root, cleanup } = makeProject();
+  t.after(cleanup);
+
+  _clearGsdRootCache();
+  clearPathCache();
+
+  // Don't create any .gsd structure — resolveTasksDir returns null.
+  const issues = await validatePlanBoundary(root, "M001", "S01");
+
+  assert.strictEqual(issues.length, 0, "missing .gsd layout should produce no issues");
+});
+
+// ── validateCompleteBoundary ─────────────────────────────────────────────────
+
+test("#912 validateCompleteBoundary: issues collected from every task summary file", async (t) => {
+  const { root, cleanup } = makeProject();
+  t.after(cleanup);
+
+  _clearGsdRootCache();
+  clearPathCache();
+
+  const tasksDir = makeLegacyTasksDir(root, "M001", "S01");
+  writeFileSync(join(tasksDir, "T01-SUMMARY.md"), BARE_TASK_SUMMARY("T01"), "utf-8");
+  writeFileSync(join(tasksDir, "T02-SUMMARY.md"), BARE_TASK_SUMMARY("T02"), "utf-8");
+  writeFileSync(join(tasksDir, "T03-SUMMARY.md"), BARE_TASK_SUMMARY("T03"), "utf-8");
+
+  _clearGsdRootCache();
+  clearPathCache();
+
+  const issues = await validateCompleteBoundary(root, "M001", "S01");
+
+  // Every task file must appear in at least one issue — proving all three
+  // summary files were loaded in parallel and validated.
+  const paths = new Set(issues.map(i => i.file));
+  assert.ok(
+    paths.size >= 3,
+    `expected issues from at least 3 task summary files, got paths: ${JSON.stringify([...paths])}`,
+  );
+
+  const t01Issues = issues.filter(i => i.file.includes("T01"));
+  const t02Issues = issues.filter(i => i.file.includes("T02"));
+  const t03Issues = issues.filter(i => i.file.includes("T03"));
+  assert.ok(t01Issues.length > 0, "T01-SUMMARY.md should produce at least one validation issue");
+  assert.ok(t02Issues.length > 0, "T02-SUMMARY.md should produce at least one validation issue");
+  assert.ok(t03Issues.length > 0, "T03-SUMMARY.md should produce at least one validation issue");
+});
+
+test("#912 validateCompleteBoundary: no issues when tasks directory is empty", async (t) => {
+  const { root, cleanup } = makeProject();
+  t.after(cleanup);
+
+  _clearGsdRootCache();
+  clearPathCache();
+
+  makeLegacyTasksDir(root, "M001", "S01");
+
+  _clearGsdRootCache();
+  clearPathCache();
+
+  const issues = await validateCompleteBoundary(root, "M001", "S01");
+
+  assert.strictEqual(issues.length, 0, "empty tasks dir should produce no issues");
+});
+
+test("#912 validateCompleteBoundary: returns empty array when basePath has no .gsd dir", async (t) => {
+  const { root, cleanup } = makeProject();
+  t.after(cleanup);
+
+  _clearGsdRootCache();
+  clearPathCache();
+
+  const issues = await validateCompleteBoundary(root, "M001", "S01");
+
+  assert.strictEqual(issues.length, 0, "missing .gsd layout should produce no issues");
+});

package/src/resources/extensions/gsd/tests/orchestrator-logs.test.ts

@@ -36,6 +36,7 @@ import {
 import { resolveExpectedArtifactPath } from "../auto-artifact-paths.ts";
 import { AutoSession } from "../auto/session.ts";
 import { acquireSessionLock, releaseSessionLock } from "../session-lock.ts";
+import { clearGSDPreferencesCache } from "../preferences.ts";
 import { invalidateAllCaches } from "../cache.ts";
 import { invalidateStateCache } from "../state.ts";
 import {
@@ -63,12 +64,15 @@ interface FixtureOptions {
   dispatch?: UnifiedRule["where"];
   /** Drop the gate_runs table after seeding so emitUokGate's insertGateRun throws (:538 path). */
   dropGateRuns?: boolean;
+  /** Write project preferences that disable UOK gate telemetry. */
+  disableUokGates?: boolean;
 }
 
 interface Fixture {
   base: string;
   session: AutoSession;
   orchestrator: ReturnType<typeof createAutoOrchestrator>;
+  getAvailableCalls(): number;
   cleanup(): void;
 }
 
@@ -82,6 +86,7 @@ function makeFixture(opts: FixtureOptions = {}): Fixture {
 
   invalidateAllCaches();
   invalidateStateCache();
+  clearGSDPreferencesCache();
   openDatabase(join(base, ".gsd", "gsd.db"));
   insertMilestone({ id: "M001", title: "Milestone", status: "active" });
   insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "active", risk: "low", depends: [], demo: "", sequence: 1 });
@@ -100,6 +105,13 @@ function makeFixture(opts: FixtureOptions = {}): Fixture {
     join(sliceDir, "S01-PLAN.md"),
     ["# S01: Slice", "", "**Goal:** g", "**Demo:** d", "", "## Tasks", "", "- [ ] **T01: Task** `est:1h`", ""].join("\n"),
   );
+  if (opts.disableUokGates) {
+    writeFileSync(
+      join(base, ".gsd", "PREFERENCES.md"),
+      "---\nuok:\n  gates:\n    enabled: false\n---\n",
+    );
+    clearGSDPreferencesCache();
+  }
 
   acquireSessionLock(base);
 
@@ -112,8 +124,19 @@ function makeFixture(opts: FixtureOptions = {}): Fixture {
   session.currentMilestoneId = "M001";
   session.resourceVersionOnStart = null;
 
+  let getAvailableCalls = 0;
   const ctx: OrchestratorContext = {
-    ctx: { model: {}, modelRegistry: { getAll: () => [], getAvailable: () => [] }, ui: { notify() {} } } as never,
+    ctx: {
+      model: {},
+      modelRegistry: {
+        getAll: () => [],
+        getAvailable: () => {
+          getAvailableCalls += 1;
+          return [];
+        },
+      },
+      ui: { notify() {} },
+    } as never,
     pi: { getActiveTools: () => [] } as never,
     dispatchBasePath: base,
     runtimeBasePath: base,
@@ -140,8 +163,10 @@ function makeFixture(opts: FixtureOptions = {}): Fixture {
     base,
     session,
     orchestrator,
+    getAvailableCalls: () => getAvailableCalls,
     cleanup() {
       resetRegistry();
+      clearGSDPreferencesCache();
       try { releaseSessionLock(base); } catch { /* */ }
       try { closeDatabase(); } catch { /* */ }
       try { rmSync(base, { recursive: true, force: true }); } catch { /* */ }
@@ -210,6 +235,23 @@ test("advance() logs an engine warning when the uok gate emit fails (orchestrato
   assert.ok(uokFail!.context?.gateId, "the failing gate id must be captured in context");
 });
 
+test("advance() resolves disabled uok gate flags once before gate emission", async (t) => {
+  const f = makeFixture({ dropGateRuns: true, disableUokGates: true });
+  t.after(() => f.cleanup());
+
+  const { logs } = await captureLogs(() => f.orchestrator.advance());
+
+  assert.equal(
+    logs.some((e) => e.component === "engine" && /uok gate emit failed/u.test(e.message)),
+    false,
+    "disabled uok gates must not construct the runner or write gate rows",
+  );
+  assert.ok(
+    f.getAvailableCalls() <= 2,
+    `uok gate preferences should be resolved once per advance, not once per emitted gate (getAvailable calls: ${f.getAvailableCalls()})`,
+  );
+});
+
 // orchestrator.ts:637 — mergePendingCompleteMilestone catches a
 // rebuildMarkdownProjectionsFromDb failure after the system-owned milestone
 // merge and logs `markdown projection rebuild after settlement merge failed`.
@@ -261,6 +303,10 @@ test("advance() logs an engine warning when the post-settlement projection rebui
   // summary artifact path (resolveExpectedArtifactPath needs the dir to exist).
   const milestoneProjDir = join(worktree, ".gsd", "milestones", "M001");
   mkdirSync(milestoneProjDir, { recursive: true });
+  // A content-bearing legacy milestone dir requires at least one non-META file
+  // (dirIsContentBearingLegacyMilestone) so the layout sniffer treats it as a
+  // real legacy milestone rather than a metadata-only placeholder.
+  writeFileSync(join(milestoneProjDir, "M001-CONTEXT.md"), "# M001\n");
   const summaryPath = resolveExpectedArtifactPath("complete-milestone", "M001", worktree);
   assert.ok(summaryPath, "complete-milestone summary path must resolve");
   mkdirSync(dirname(summaryPath), { recursive: true });