gsd-pi 2.59.0 → 2.60.0-dev.2580e65

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

@@ -0,0 +1,347 @@
+// GSD Extension — Capability-Aware Router Tests
+// Tests for new capability scoring functions and data tables (Plan 01-01)
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  scoreModel,
+  computeTaskRequirements,
+  scoreEligibleModels,
+  getEligibleModels,
+  resolveModelForComplexity,
+  MODEL_CAPABILITY_PROFILES,
+  BASE_REQUIREMENTS,
+  defaultRoutingConfig,
+} from "../model-router.js";
+import type { ModelCapabilities, DynamicRoutingConfig, RoutingDecision } from "../model-router.js";
+
+// ─── scoreModel ──────────────────────────────────────────────────────────────
+
+describe("scoreModel", () => {
+  const sonnetProfile: ModelCapabilities = {
+    coding: 85, debugging: 80, research: 75, reasoning: 80,
+    speed: 60, longContext: 75, instruction: 85,
+  };
+
+  test("produces correct weighted average for single dimension", () => {
+    // Only coding weight 1.0 → result should be the coding score
+    const score = scoreModel(sonnetProfile, { coding: 1.0 });
+    assert.equal(score, 85);
+  });
+
+  test("produces correct weighted average for two dimensions (coding 0.9, instruction 0.7)", () => {
+    // (0.9*85 + 0.7*85) / (0.9+0.7) = (76.5+59.5)/1.6 = 136/1.6 = 85.0
+    const score = scoreModel(sonnetProfile, { coding: 0.9, instruction: 0.7 });
+    assert.ok(Math.abs(score - 85.0) < 0.01, `Expected ~85.0, got ${score}`);
+  });
+
+  test("returns 50 when requirements is empty", () => {
+    const score = scoreModel(sonnetProfile, {});
+    assert.equal(score, 50);
+  });
+
+  test("uses 50 as fallback for unknown dimension in requirements", () => {
+    // 'unknown' dimension not in profile → treated as 50
+    const score = scoreModel(sonnetProfile, { coding: 0.5, unknown: 1.0 } as any);
+    // (0.5*85 + 1.0*50) / (0.5+1.0) = (42.5+50)/1.5 = 92.5/1.5 = 61.67
+    assert.ok(score > 61 && score < 62, `Expected ~61.67, got ${score}`);
+  });
+});
+
+// ─── computeTaskRequirements ─────────────────────────────────────────────────
+
+describe("computeTaskRequirements", () => {
+  test("execute-task with no metadata returns base requirements", () => {
+    const req = computeTaskRequirements("execute-task", undefined);
+    assert.deepStrictEqual(req, { coding: 0.9, instruction: 0.7, speed: 0.3 });
+  });
+
+  test("execute-task with docs tag returns docs-adjusted requirements", () => {
+    const req = computeTaskRequirements("execute-task", { tags: ["docs"] });
+    assert.equal(req.instruction, 0.9);
+    assert.equal(req.coding, 0.3);
+    assert.equal(req.speed, 0.7);
+  });
+
+  test("execute-task with readme tag returns docs-adjusted requirements", () => {
+    const req = computeTaskRequirements("execute-task", { tags: ["readme"] });
+    assert.equal(req.instruction, 0.9);
+  });
+
+  test("execute-task with concurrency keyword boosts debugging and reasoning", () => {
+    const req = computeTaskRequirements("execute-task", { complexityKeywords: ["concurrency"] });
+    assert.equal(req.debugging, 0.9);
+    assert.equal(req.reasoning, 0.8);
+  });
+
+  test("execute-task with compatibility keyword boosts debugging and reasoning", () => {
+    const req = computeTaskRequirements("execute-task", { complexityKeywords: ["compatibility"] });
+    assert.equal(req.debugging, 0.9);
+    assert.equal(req.reasoning, 0.8);
+  });
+
+  test("execute-task with migration keyword boosts reasoning and coding", () => {
+    const req = computeTaskRequirements("execute-task", { complexityKeywords: ["migration"] });
+    assert.equal(req.reasoning, 0.9);
+    assert.equal(req.coding, 0.8);
+  });
+
+  test("execute-task with architecture keyword boosts reasoning and coding", () => {
+    const req = computeTaskRequirements("execute-task", { complexityKeywords: ["architecture"] });
+    assert.equal(req.reasoning, 0.9);
+    assert.equal(req.coding, 0.8);
+  });
+
+  test("execute-task with fileCount >= 6 boosts coding and reasoning", () => {
+    const req = computeTaskRequirements("execute-task", { fileCount: 8 });
+    assert.equal(req.coding, 0.9);
+    assert.equal(req.reasoning, 0.7);
+  });
+
+  test("execute-task with fileCount exactly 6 triggers large-file boost", () => {
+    const req = computeTaskRequirements("execute-task", { fileCount: 6 });
+    assert.equal(req.coding, 0.9);
+    assert.equal(req.reasoning, 0.7);
+  });
+
+  test("execute-task with estimatedLines >= 500 boosts coding and reasoning", () => {
+    const req = computeTaskRequirements("execute-task", { estimatedLines: 500 });
+    assert.equal(req.coding, 0.9);
+    assert.equal(req.reasoning, 0.7);
+  });
+
+  test("research-milestone with no metadata returns base requirements", () => {
+    const req = computeTaskRequirements("research-milestone", undefined);
+    assert.deepStrictEqual(req, { research: 0.9, longContext: 0.7, reasoning: 0.5 });
+  });
+
+  test("unknown unit type returns default reasoning requirement", () => {
+    const req = computeTaskRequirements("unknown-type", undefined);
+    assert.deepStrictEqual(req, { reasoning: 0.5 });
+  });
+});
+
+// ─── MODEL_CAPABILITY_PROFILES ───────────────────────────────────────────────
+
+describe("MODEL_CAPABILITY_PROFILES", () => {
+  test("contains all 9 required models", () => {
+    const required = [
+      "claude-opus-4-6", "claude-sonnet-4-6", "claude-haiku-4-5",
+      "gpt-4o", "gpt-4o-mini", "gemini-2.5-pro", "gemini-2.0-flash",
+      "deepseek-chat", "o3",
+    ];
+    for (const model of required) {
+      assert.ok(MODEL_CAPABILITY_PROFILES[model], `Missing profile for ${model}`);
+    }
+  });
+
+  test("each profile has all 7 capability dimensions", () => {
+    const dims: Array<keyof ModelCapabilities> = [
+      "coding", "debugging", "research", "reasoning",
+      "speed", "longContext", "instruction",
+    ];
+    for (const [modelId, profile] of Object.entries(MODEL_CAPABILITY_PROFILES)) {
+      for (const dim of dims) {
+        assert.ok(profile[dim] !== undefined, `${modelId} missing dimension ${dim}`);
+        assert.ok(profile[dim] >= 0 && profile[dim] <= 100, `${modelId}.${dim} out of range`);
+      }
+    }
+  });
+
+  test("claude-opus-4-6 has high reasoning and coding", () => {
+    const opus = MODEL_CAPABILITY_PROFILES["claude-opus-4-6"];
+    assert.ok(opus.reasoning >= 90, `Expected reasoning >= 90, got ${opus.reasoning}`);
+    assert.ok(opus.coding >= 90, `Expected coding >= 90, got ${opus.coding}`);
+  });
+
+  test("claude-haiku-4-5 has high speed but lower reasoning", () => {
+    const haiku = MODEL_CAPABILITY_PROFILES["claude-haiku-4-5"];
+    assert.ok(haiku.speed >= 90, `Expected speed >= 90, got ${haiku.speed}`);
+    assert.ok(haiku.reasoning < 70, `Expected reasoning < 70, got ${haiku.reasoning}`);
+  });
+});
+
+// ─── BASE_REQUIREMENTS ───────────────────────────────────────────────────────
+
+describe("BASE_REQUIREMENTS", () => {
+  test("contains all 11 unit types", () => {
+    const required = [
+      "execute-task", "research-milestone", "research-slice",
+      "plan-milestone", "plan-slice", "replan-slice",
+      "reassess-roadmap", "complete-slice", "run-uat",
+      "discuss-milestone", "complete-milestone",
+    ];
+    for (const unitType of required) {
+      assert.ok(BASE_REQUIREMENTS[unitType], `Missing requirements for ${unitType}`);
+    }
+  });
+});
+
+// ─── scoreEligibleModels ─────────────────────────────────────────────────────
+
+describe("scoreEligibleModels", () => {
+  test("returns array sorted by score descending", () => {
+    const requirements = { research: 0.9, longContext: 0.7, reasoning: 0.5 };
+    const results = scoreEligibleModels(["claude-sonnet-4-6", "gpt-4o"], requirements);
+    assert.ok(results.length === 2);
+    assert.ok(results[0].score >= results[1].score, "Should be sorted descending by score");
+  });
+
+  test("returns single model when only one eligible", () => {
+    const requirements = { coding: 0.9 };
+    const results = scoreEligibleModels(["claude-sonnet-4-6"], requirements);
+    assert.equal(results.length, 1);
+    assert.equal(results[0].modelId, "claude-sonnet-4-6");
+  });
+
+  test("models without profiles get uniform 50s score", () => {
+    const requirements = { coding: 1.0 };
+    const results = scoreEligibleModels(["unknown-model-xyz"], requirements);
+    assert.equal(results[0].score, 50);
+  });
+
+  test("when two models score within 2 points, prefers cheaper model", () => {
+    // gemini-2.0-flash is cheaper than gpt-4o-mini ($0.0001 vs $0.00015)
+    // Use a requirement that causes similar scores for both
+    const requirements = { speed: 1.0 };
+    const results = scoreEligibleModels(["gpt-4o-mini", "gemini-2.0-flash"], requirements);
+    // Both are high-speed: gpt-4o-mini=90, gemini-2.0-flash=95 — scores differ by 5, not within 2
+    // So top should be gemini-2.0-flash by score
+    assert.equal(results[0].modelId, "gemini-2.0-flash");
+  });
+
+  test("tie-breaks by lexicographic model ID when cost and score are equal", () => {
+    // Use models without cost entries — both get Infinity cost
+    const requirements = { coding: 1.0 };
+    const results = scoreEligibleModels(["model-z", "model-a"], requirements);
+    // Both unknown → score=50, cost=Infinity → tiebreak by ID
+    assert.equal(results[0].modelId, "model-a");
+  });
+
+  test("scoreEligibleModels respects capabilityOverrides", () => {
+    const requirements = { coding: 1.0 };
+    // Override claude-sonnet-4-6's coding to 30 (worse)
+    const results = scoreEligibleModels(
+      ["claude-sonnet-4-6", "gpt-4o"],
+      requirements,
+      { "claude-sonnet-4-6": { coding: 30 } },
+    );
+    // gpt-4o coding=80 should beat overridden sonnet coding=30
+    assert.equal(results[0].modelId, "gpt-4o");
+  });
+});
+
+// ─── getEligibleModels ───────────────────────────────────────────────────────
+
+describe("getEligibleModels", () => {
+  const MODELS = [
+    "claude-opus-4-6",      // heavy
+    "claude-sonnet-4-6",    // standard
+    "claude-haiku-4-5",     // light
+    "gpt-4o-mini",          // light
+  ];
+
+  test("returns light-tier models sorted by cost when no explicit config", () => {
+    const config: DynamicRoutingConfig = defaultRoutingConfig();
+    const result = getEligibleModels("light", MODELS, config);
+    assert.ok(result.length >= 1);
+    // All results should be light-tier
+    for (const id of result) {
+      assert.ok(
+        ["claude-haiku-4-5", "gpt-4o-mini"].includes(id),
+        `Expected light-tier model, got ${id}`,
+      );
+    }
+  });
+
+  test("returns explicit tier_models when configured and available", () => {
+    const config: DynamicRoutingConfig = {
+      ...defaultRoutingConfig(),
+      tier_models: { light: "gpt-4o-mini" },
+    };
+    const result = getEligibleModels("light", MODELS, config);
+    assert.deepStrictEqual(result, ["gpt-4o-mini"]);
+  });
+
+  test("returns empty array when no eligible models for tier", () => {
+    const config: DynamicRoutingConfig = defaultRoutingConfig();
+    // Only heavy model available, requesting light
+    const result = getEligibleModels("light", ["claude-opus-4-6"], config);
+    assert.equal(result.length, 0);
+  });
+});
+
+// ─── DynamicRoutingConfig extension ─────────────────────────────────────────
+
+describe("DynamicRoutingConfig.capability_routing", () => {
+  test("defaultRoutingConfig includes capability_routing: true", () => {
+    const config = defaultRoutingConfig();
+    assert.equal(config.capability_routing, true);
+  });
+});
+
+// ─── RoutingDecision.selectionMethod ─────────────────────────────────────────
+
+describe("RoutingDecision.selectionMethod", () => {
+  const MODELS = ["claude-opus-4-6", "claude-sonnet-4-6", "claude-haiku-4-5", "gpt-4o-mini"];
+
+  function makeClassification(tier: "light" | "standard" | "heavy") {
+    return { tier, reason: "test", downgraded: false };
+  }
+
+  test("returns selectionMethod: tier-only when routing is disabled", () => {
+    const config = { ...defaultRoutingConfig(), enabled: false };
+    const result: RoutingDecision = resolveModelForComplexity(
+      makeClassification("light"),
+      { primary: "claude-opus-4-6", fallbacks: [] },
+      config,
+      MODELS,
+    );
+    assert.equal(result.selectionMethod, "tier-only");
+  });
+
+  test("returns selectionMethod: tier-only for no phase config passthrough", () => {
+    const config = { ...defaultRoutingConfig(), enabled: true };
+    const result: RoutingDecision = resolveModelForComplexity(
+      makeClassification("light"),
+      undefined,
+      config,
+      MODELS,
+    );
+    assert.equal(result.selectionMethod, "tier-only");
+  });
+
+  test("returns selectionMethod: tier-only for unknown model passthrough", () => {
+    const config = { ...defaultRoutingConfig(), enabled: true };
+    const result: RoutingDecision = resolveModelForComplexity(
+      makeClassification("light"),
+      { primary: "custom-provider/my-model-v3", fallbacks: [] },
+      config,
+      ["custom-provider/my-model-v3", ...MODELS],
+    );
+    assert.equal(result.selectionMethod, "tier-only");
+  });
+
+  test("returns selectionMethod: tier-only for no-downgrade passthrough", () => {
+    const config = { ...defaultRoutingConfig(), enabled: true };
+    const result: RoutingDecision = resolveModelForComplexity(
+      makeClassification("heavy"),
+      { primary: "claude-opus-4-6", fallbacks: [] },
+      config,
+      MODELS,
+    );
+    assert.equal(result.selectionMethod, "tier-only");
+  });
+
+  test("returns selectionMethod: tier-only when downgraded", () => {
+    const config = { ...defaultRoutingConfig(), enabled: true };
+    const result: RoutingDecision = resolveModelForComplexity(
+      makeClassification("light"),
+      { primary: "claude-opus-4-6", fallbacks: [] },
+      config,
+      MODELS,
+    );
+    assert.equal(result.selectionMethod, "tier-only");
+  });
+});

package/src/resources/extensions/gsd/tests/codebase-generator.test.ts

@@ -486,3 +486,66 @@ test("getCodebaseMapStats: reads total file count from header for accuracy with
     cleanup(base);
   }
 });
+
+// ─── excludePatterns from options ────────────────────────────────────────
+
+test("generateCodebaseMap: custom excludePatterns filters additional directories", () => {
+  const base = makeTmpRepo();
+  try {
+    addFile(base, "src/main.ts");
+    addFile(base, "src/utils.ts");
+    addFile(base, ".cache-data/data/index.lance");
+    addFile(base, "docs/guide.md");
+
+    const result = generateCodebaseMap(base, {
+      excludePatterns: [".cache-data/", "docs/"],
+    });
+    assert.ok(result.content.includes("`src/main.ts`"));
+    assert.ok(result.content.includes("`src/utils.ts`"));
+    assert.ok(!result.content.includes(".cache-data"));
+    assert.ok(!result.content.includes("guide.md"));
+    assert.equal(result.fileCount, 2);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("generateCodebaseMap: collapseThreshold option overrides default", () => {
+  const base = makeTmpRepo();
+  try {
+    // Create 10 files in one directory — below default threshold (20)
+    // but above a custom threshold of 5
+    for (let i = 0; i < 10; i++) {
+      addFile(base, `src/comp${i}.ts`);
+    }
+
+    // With default threshold (20), files should NOT collapse
+    const expanded = generateCodebaseMap(base);
+    assert.ok(expanded.content.includes("`src/comp0.ts`"));
+
+    // With custom threshold (5), files SHOULD collapse
+    const collapsed = generateCodebaseMap(base, { collapseThreshold: 5 });
+    assert.ok(collapsed.content.includes("10 files"));
+    assert.ok(!collapsed.content.includes("`src/comp0.ts`\n"));
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("updateCodebaseMap: respects excludePatterns option", () => {
+  const base = makeTmpRepo();
+  try {
+    addFile(base, "src/main.ts");
+    addFile(base, "vendor-extra/lib.js");
+
+    const initial = generateCodebaseMap(base);
+    writeCodebaseMap(base, initial.content);
+
+    // Update with exclusion should remove vendor-extra files
+    const result = updateCodebaseMap(base, { excludePatterns: ["vendor-extra/"] });
+    assert.ok(result.content.includes("`src/main.ts`"));
+    assert.ok(!result.content.includes("vendor-extra"));
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/complexity-classifier.test.ts

@@ -1,7 +1,7 @@
-import test from "node:test";
+import test, { describe } from "node:test";
 import assert from "node:assert/strict";
 
-import { classifyUnitComplexity, tierLabel, tierOrdinal } from "../complexity-classifier.js";
+import { classifyUnitComplexity, tierLabel, tierOrdinal, extractTaskMetadata } from "../complexity-classifier.js";
 import type { ComplexityTier, TaskMetadata } from "../complexity-classifier.js";
 
 // ─── tierLabel ───────────────────────────────────────────────────────────────
@@ -179,3 +179,28 @@ test("execute-task with few code blocks stays standard", () => {
   const result = classifyUnitComplexity("execute-task", "M001/S01/T01", "/tmp/fake", undefined, metadata);
   assert.equal(result.tier, "standard");
 });
+
+// ─── ClassificationResult taskMetadata passthrough ───────────────────────────
+
+describe("ClassificationResult taskMetadata", () => {
+  test("classifyUnitComplexity for execute-task returns result with taskMetadata populated", () => {
+    const metadata: TaskMetadata = { fileCount: 3, tags: ["docs"] };
+    const result = classifyUnitComplexity("execute-task", "M001/S01/T01", "/tmp/fake", undefined, metadata);
+    assert.ok(result.taskMetadata !== undefined, "taskMetadata should be populated for execute-task");
+    assert.equal(result.taskMetadata!.tags?.[0], "docs");
+  });
+
+  test("classifyUnitComplexity for hook/xyz returns result with taskMetadata undefined", () => {
+    const result = classifyUnitComplexity("hook/verify", "M001/S01/T01", "/tmp/fake");
+    assert.equal(result.taskMetadata, undefined, "taskMetadata should be undefined for hook units");
+  });
+
+  test("classifyUnitComplexity for plan-slice returns result with taskMetadata undefined", () => {
+    const result = classifyUnitComplexity("plan-slice", "M001/S01", "/tmp/fake");
+    assert.equal(result.taskMetadata, undefined, "taskMetadata should be undefined for plan-slice");
+  });
+
+  test("extractTaskMetadata is importable as a named export and is a function", () => {
+    assert.equal(typeof extractTaskMetadata, "function", "extractTaskMetadata should be a callable function");
+  });
+});

package/src/resources/extensions/gsd/tests/context-masker.test.ts

@@ -0,0 +1,122 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { createObservationMask } from "../context-masker.js";
+
+// These helpers produce messages in the pi-ai LLM payload format
+// (post-convertToLlm, pre-provider), which is what before_provider_request sees.
+
+function userMsg(content: string) {
+  return { role: "user", content: [{ type: "text", text: content }] };
+}
+
+function assistantMsg(content: string) {
+  return { role: "assistant", content: [{ type: "text", text: content }] };
+}
+
+/** toolResult in pi-ai format: role "toolResult", content as TextContent[] */
+function toolResult(text: string) {
+  return { role: "toolResult", content: [{ type: "text", text }], toolCallId: "toolu_test", toolName: "Read", isError: false };
+}
+
+/** bashExecution after convertToLlm: becomes a user message with "Ran `cmd`" prefix */
+function bashResult(text: string) {
+  return { role: "user", content: [{ type: "text", text: `Ran \`echo test\`\n\`\`\`\n${text}\n\`\`\`` }] };
+}
+
+const MASK_TEXT = "[result masked — within summarized history]";
+
+test("masks nothing when message count is within keepRecentTurns", () => {
+  const mask = createObservationMask(8);
+  const messages = [
+    userMsg("hello"),
+    assistantMsg("hi"),
+    toolResult("file contents"),
+  ];
+  const result = mask(messages as any);
+  assert.equal(result.length, 3);
+  assert.deepEqual((result[2].content as any)[0].text, "file contents");
+});
+
+test("masks tool results older than keepRecentTurns", () => {
+  const mask = createObservationMask(2);
+  const messages = [
+    userMsg("turn 1"),
+    toolResult("old tool output"),
+    assistantMsg("response 1"),
+    userMsg("turn 2"),
+    toolResult("newer tool output"),
+    assistantMsg("response 2"),
+    userMsg("turn 3"),
+    toolResult("newest tool output"),
+    assistantMsg("response 3"),
+  ];
+  const result = mask(messages as any);
+  // Old tool result (before boundary) should be masked
+  assert.equal((result[1].content as any)[0].text, MASK_TEXT);
+  // Recent tool results (within keep window) should be preserved
+  assert.equal((result[4].content as any)[0].text, "newer tool output");
+  assert.equal((result[7].content as any)[0].text, "newest tool output");
+});
+
+test("never masks assistant messages", () => {
+  const mask = createObservationMask(1);
+  const messages = [
+    userMsg("turn 1"),
+    assistantMsg("old reasoning"),
+    userMsg("turn 2"),
+    assistantMsg("new reasoning"),
+  ];
+  const result = mask(messages as any);
+  assert.equal((result[1].content as any)[0].text, "old reasoning");
+  assert.equal((result[3].content as any)[0].text, "new reasoning");
+});
+
+test("never masks user messages", () => {
+  const mask = createObservationMask(1);
+  const messages = [
+    userMsg("old user message"),
+    assistantMsg("response"),
+    userMsg("new user message"),
+    assistantMsg("response"),
+  ];
+  const result = mask(messages as any);
+  assert.equal((result[0].content as any)[0].text, "old user message");
+});
+
+test("masks bash result user messages", () => {
+  const mask = createObservationMask(1);
+  const messages = [
+    userMsg("turn 1"),
+    bashResult("huge log output"),
+    assistantMsg("response 1"),
+    userMsg("turn 2"),
+    assistantMsg("response 2"),
+  ];
+  const result = mask(messages as any);
+  assert.equal((result[1].content as any)[0].text, MASK_TEXT);
+});
+
+test("returns same array length", () => {
+  const mask = createObservationMask(1);
+  const messages = [
+    userMsg("a"), toolResult("b"), assistantMsg("c"),
+    userMsg("d"), toolResult("e"), assistantMsg("f"),
+  ];
+  const result = mask(messages as any);
+  assert.equal(result.length, messages.length);
+});
+
+test("masks toolResult by role, not by type field", () => {
+  const mask = createObservationMask(1);
+  const messages = [
+    userMsg("turn 1"),
+    // This is the actual pi-ai format: role "toolResult", no type field
+    { role: "toolResult", content: [{ type: "text", text: "old result" }], toolCallId: "t1", toolName: "Read", isError: false },
+    assistantMsg("response 1"),
+    userMsg("turn 2"),
+    assistantMsg("response 2"),
+  ];
+  const result = mask(messages as any);
+  assert.equal((result[1].content as any)[0].text, MASK_TEXT);
+});

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

@@ -94,11 +94,11 @@ const dynamicToolsSrc = readFileSync(
   "utf-8",
 );
 
-// ensureDbOpen should return a structured result, not just boolean false
-// Check that the catch block provides diagnostic information
+// ensureDbOpen should surface diagnostic context, not just boolean false
+// Check that the catch block logs error details via workflow-logger
 assertTrue(
-  dynamicToolsSrc.includes("resolvedPath") || dynamicToolsSrc.includes("diagnostic"),
-  "ensureDbOpen catch block surfaces diagnostic information (resolvedPath or diagnostic) instead of bare false (#2517)",
+  dynamicToolsSrc.includes("ensureDbOpen failed") && dynamicToolsSrc.includes("logWarning"),
+  "ensureDbOpen catch block surfaces diagnostic information via logWarning instead of bare false (#2517)",
 );
 
 // ── Part 3: post-unit does NOT artifact-retry on db_unavailable ──────────