gsd-pi 2.75.0 → 2.76.0-dev.4100bd590

package/src/resources/extensions/gsd/tests/memory-tools.test.ts

@@ -0,0 +1,295 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+
+import { closeDatabase, openDatabase } from '../gsd-db.ts';
+import { createMemory, supersedeMemory } from '../memory-store.ts';
+import {
+  executeGsdGraph,
+  executeMemoryCapture,
+  executeMemoryQuery,
+} from '../tools/memory-tools.ts';
+
+// ═══════════════════════════════════════════════════════════════════════════
+// capture_thought
+// ═══════════════════════════════════════════════════════════════════════════
+
+test('memory-tools: capture_thought creates a memory with a MEM id', () => {
+  openDatabase(':memory:');
+
+  const result = executeMemoryCapture({
+    category: 'gotcha',
+    content: 'sql.js FTS5 virtual tables need explicit triggers.',
+  });
+
+  assert.ok(!result.isError, 'capture should not error');
+  assert.equal(result.details.operation, 'memory_capture');
+  assert.equal(result.details.id, 'MEM001');
+  assert.equal(result.details.category, 'gotcha');
+  assert.equal(result.details.confidence, 0.8);
+
+  closeDatabase();
+});
+
+test('memory-tools: capture_thought rejects invalid category', () => {
+  openDatabase(':memory:');
+
+  const result = executeMemoryCapture({
+    category: 'opinion', // not in the allow-list
+    content: 'some content',
+  });
+
+  assert.ok(result.isError, 'invalid category should error');
+  assert.equal(result.details.error, 'invalid_category');
+
+  closeDatabase();
+});
+
+test('memory-tools: capture_thought rejects missing fields', () => {
+  openDatabase(':memory:');
+
+  const empty = executeMemoryCapture({ category: '', content: '' });
+  assert.ok(empty.isError, 'missing fields should error');
+  assert.equal(empty.details.error, 'missing_fields');
+
+  closeDatabase();
+});
+
+test('memory-tools: capture_thought clamps confidence to the 0.1–0.99 range', () => {
+  openDatabase(':memory:');
+
+  const hi = executeMemoryCapture({
+    category: 'convention',
+    content: 'clamp test high',
+    confidence: 42,
+  });
+  assert.ok(!hi.isError);
+  assert.equal(hi.details.confidence, 0.99);
+
+  const lo = executeMemoryCapture({
+    category: 'convention',
+    content: 'clamp test low',
+    confidence: -5,
+  });
+  assert.ok(!lo.isError);
+  assert.equal(lo.details.confidence, 0.1);
+
+  closeDatabase();
+});
+
+test('memory-tools: capture_thought fails gracefully when DB is closed', () => {
+  closeDatabase();
+
+  const result = executeMemoryCapture({
+    category: 'gotcha',
+    content: 'db closed',
+  });
+
+  assert.ok(result.isError, 'db-closed capture should error');
+  assert.equal(result.details.error, 'db_unavailable');
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// memory_query
+// ═══════════════════════════════════════════════════════════════════════════
+
+test('memory-tools: memory_query keyword-matches and ranks by confidence × hits', () => {
+  openDatabase(':memory:');
+
+  createMemory({ category: 'gotcha', content: 'sql.js FTS5 triggers must mirror insert/update/delete', confidence: 0.9 });
+  createMemory({ category: 'pattern', content: 'use prepared statements for hot paths', confidence: 0.7 });
+  createMemory({ category: 'convention', content: 'prefer async iterators for streaming', confidence: 0.8 });
+
+  const result = executeMemoryQuery({ query: 'sql triggers', k: 5 });
+  assert.ok(!result.isError);
+  const hits = result.details.hits as Array<{ id: string; content: string; reason: string }>;
+  assert.ok(hits.length >= 1, 'should return at least one keyword hit');
+  assert.equal(hits[0].id, 'MEM001', 'most-relevant memory should rank first');
+  assert.equal(hits[0].reason, 'keyword');
+
+  closeDatabase();
+});
+
+test('memory-tools: memory_query returns empty list when no keywords match', () => {
+  openDatabase(':memory:');
+  createMemory({ category: 'gotcha', content: 'unrelated content' });
+
+  const result = executeMemoryQuery({ query: 'totally different phrase', k: 5 });
+  assert.ok(!result.isError);
+  const hits = result.details.hits as unknown[];
+  assert.equal(hits.length, 0);
+  assert.equal(result.content[0].text, 'No matching memories.');
+
+  closeDatabase();
+});
+
+test('memory-tools: memory_query with empty query returns ranked memories', () => {
+  openDatabase(':memory:');
+  createMemory({ category: 'gotcha', content: 'first', confidence: 0.95 });
+  createMemory({ category: 'pattern', content: 'second', confidence: 0.5 });
+
+  const result = executeMemoryQuery({ query: '   ' });
+  assert.ok(!result.isError);
+  const hits = result.details.hits as Array<{ id: string; reason: string }>;
+  assert.equal(hits.length, 2);
+  assert.equal(hits[0].id, 'MEM001', 'higher-confidence memory ranks first under empty query');
+  assert.equal(hits[0].reason, 'ranked');
+
+  closeDatabase();
+});
+
+test('memory-tools: memory_query filters by category', () => {
+  openDatabase(':memory:');
+  createMemory({ category: 'gotcha', content: 'db pragma needed' });
+  createMemory({ category: 'pattern', content: 'db pragma needed' });
+
+  const result = executeMemoryQuery({ query: 'db pragma', category: 'gotcha' });
+  assert.ok(!result.isError);
+  const hits = result.details.hits as Array<{ id: string; category: string }>;
+  assert.equal(hits.length, 1);
+  assert.equal(hits[0].category, 'gotcha');
+
+  closeDatabase();
+});
+
+test('memory-tools: memory_query filters by scope and tag', () => {
+  openDatabase(':memory:');
+  createMemory({ category: 'gotcha', content: 'shared fact', scope: 'project', tags: ['db', 'sqlite'] });
+  createMemory({ category: 'gotcha', content: 'global fact', scope: 'global', tags: ['db'] });
+  createMemory({ category: 'gotcha', content: 'other scope', scope: 'project', tags: ['net'] });
+
+  const projectScoped = executeMemoryQuery({ query: 'fact', scope: 'project' });
+  assert.ok(!projectScoped.isError);
+  const projectHits = projectScoped.details.hits as Array<{ id: string }>;
+  assert.equal(projectHits.length, 1);
+  assert.equal(projectHits[0].id, 'MEM001');
+
+  const tagged = executeMemoryQuery({ query: 'fact', tag: 'sqlite' });
+  assert.ok(!tagged.isError);
+  const taggedHits = tagged.details.hits as Array<{ id: string }>;
+  assert.equal(taggedHits.length, 1);
+  assert.equal(taggedHits[0].id, 'MEM001');
+
+  closeDatabase();
+});
+
+test('memory-tools: capture_thought stores scope and tags', () => {
+  openDatabase(':memory:');
+  const result = executeMemoryCapture({
+    category: 'architecture',
+    content: 'use WAL journaling by default',
+    scope: 'global',
+    tags: ['sqlite', 'wal'],
+  });
+  assert.ok(!result.isError);
+  assert.equal(result.details.scope, 'global');
+  assert.deepEqual(result.details.tags, ['sqlite', 'wal']);
+
+  const lookup = executeMemoryQuery({ query: 'WAL', scope: 'global', tag: 'wal' });
+  const hits = lookup.details.hits as Array<{ id: string }>;
+  assert.equal(hits.length, 1);
+  assert.equal(hits[0].id, 'MEM001');
+
+  closeDatabase();
+});
+
+test('memory-tools: memory_query clamps k to the 1–50 range', () => {
+  openDatabase(':memory:');
+  for (let i = 0; i < 10; i++) {
+    createMemory({ category: 'pattern', content: `pattern ${i}` });
+  }
+
+  const tooLow = executeMemoryQuery({ query: 'pattern', k: 0 });
+  assert.ok(!tooLow.isError);
+  assert.equal((tooLow.details.hits as unknown[]).length, 1);
+
+  const sane = executeMemoryQuery({ query: 'pattern', k: 999 });
+  assert.ok(!sane.isError);
+  assert.equal((sane.details.hits as unknown[]).length, 10);
+
+  closeDatabase();
+});
+
+test('memory-tools: memory_query can reinforce returned hits', () => {
+  openDatabase(':memory:');
+  createMemory({ category: 'gotcha', content: 'needs reinforcement' });
+
+  executeMemoryQuery({ query: 'reinforcement', reinforce_hits: true });
+  const follow = executeMemoryQuery({ query: 'reinforcement' });
+  const hits = follow.details.hits as Array<{ hit_count: number }>;
+  assert.equal(hits.length, 1);
+  assert.ok(hits[0].hit_count >= 1, 'hit_count should increment on reinforce');
+
+  closeDatabase();
+});
+
+test('memory-tools: memory_query ignores superseded memories by default', () => {
+  openDatabase(':memory:');
+  createMemory({ category: 'convention', content: 'old way of doing X' });
+  createMemory({ category: 'convention', content: 'new way of doing X' });
+  supersedeMemory('MEM001', 'MEM002');
+
+  const active = executeMemoryQuery({ query: 'doing' });
+  const activeHits = active.details.hits as Array<{ id: string }>;
+  assert.equal(activeHits.length, 1);
+  assert.equal(activeHits[0].id, 'MEM002');
+
+  const withSuperseded = executeMemoryQuery({ query: 'doing', include_superseded: true });
+  const allHits = withSuperseded.details.hits as Array<{ id: string }>;
+  assert.equal(allHits.length, 2);
+
+  closeDatabase();
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// gsd_graph
+// ═══════════════════════════════════════════════════════════════════════════
+
+test('memory-tools: gsd_graph build acknowledges request', () => {
+  openDatabase(':memory:');
+  const result = executeGsdGraph({ mode: 'build' });
+  assert.ok(!result.isError);
+  assert.equal(result.details.operation, 'gsd_graph');
+  assert.equal(result.details.mode, 'build');
+  closeDatabase();
+});
+
+test('memory-tools: gsd_graph query rejects missing memoryId', () => {
+  openDatabase(':memory:');
+  const result = executeGsdGraph({ mode: 'query' });
+  assert.ok(result.isError);
+  assert.equal(result.details.error, 'missing_memory_id');
+  closeDatabase();
+});
+
+test('memory-tools: gsd_graph query returns node + supersedes edge', () => {
+  openDatabase(':memory:');
+  createMemory({ category: 'convention', content: 'first' });
+  createMemory({ category: 'convention', content: 'second' });
+  supersedeMemory('MEM001', 'MEM002');
+
+  const result = executeGsdGraph({ mode: 'query', memoryId: 'MEM001', depth: 1 });
+  assert.ok(!result.isError);
+  const nodes = result.details.nodes as Array<{ id: string }>;
+  const edges = result.details.edges as Array<{ from: string; to: string; rel: string }>;
+
+  const nodeIds = nodes.map((n) => n.id).sort();
+  assert.deepEqual(nodeIds, ['MEM001', 'MEM002']);
+  assert.ok(edges.some((e) => e.from === 'MEM001' && e.to === 'MEM002' && e.rel === 'supersedes'));
+
+  closeDatabase();
+});
+
+test('memory-tools: gsd_graph query returns empty when memoryId does not exist', () => {
+  openDatabase(':memory:');
+  const result = executeGsdGraph({ mode: 'query', memoryId: 'MEM999' });
+  assert.ok(!result.isError, 'missing memory is not an error, just empty');
+  assert.equal((result.details.nodes as unknown[]).length, 0);
+  closeDatabase();
+});
+
+test('memory-tools: gsd_graph errors when DB is closed', () => {
+  closeDatabase();
+  const result = executeGsdGraph({ mode: 'query', memoryId: 'MEM001' });
+  assert.ok(result.isError);
+  assert.equal(result.details.error, 'db_unavailable');
+});

package/src/resources/extensions/gsd/tests/milestone-status-tool.test.ts

@@ -79,8 +79,9 @@ function seedTask(milestoneId: string, sliceId: string, taskId: string, status:
 test("registerQueryTools registers gsd_milestone_status tool", () => {
   const pi = makeMockPi();
   registerQueryTools(pi);
-  assert.equal(pi.tools.length, 1, "Should register exactly one tool");
-  assert.equal(pi.tools[0].name, "gsd_milestone_status");
+  const names = pi.tools.map((t: { name: string }) => t.name);
+  assert.ok(names.includes("gsd_milestone_status"), "Should register gsd_milestone_status");
+  assert.ok(names.includes("gsd_checkpoint_db"), "Should register gsd_checkpoint_db");
 });
 
 test("gsd_milestone_status has promptGuidelines mentioning prohibited alternatives", () => {

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

@@ -74,7 +74,7 @@ test("#2885: cost table includes openai-codex provider models", () => {
   const ids = BUNDLED_COST_TABLE.map(e => e.id);
   const codexModels = [
     "gpt-5.1", "gpt-5.1-codex-max", "gpt-5.1-codex-mini",
-    "gpt-5.2", "gpt-5.2-codex", "gpt-5.3-codex", "gpt-5.3-codex-spark", "gpt-5.4",
+    "gpt-5.2", "gpt-5.2-codex", "gpt-5.3-codex", "gpt-5.3-codex-spark", "gpt-5.4", "gpt-5.4-mini",
   ];
   for (const model of codexModels) {
     assert.ok(ids.includes(model), `cost table should include openai-codex model "${model}"`);
@@ -94,7 +94,7 @@ test("#2885: cost table includes modern OpenAI models", () => {
 });
 
 test("#2885: lookupModelCost returns costs for new models (not 999 fallback)", () => {
-  const newModels = ["o4-mini", "gpt-4.1", "gpt-5", "gpt-5.4", "gpt-5.1-codex-mini"];
+  const newModels = ["o4-mini", "gpt-4.1", "gpt-5", "gpt-5.4", "gpt-5.4-mini", "gpt-5.1-codex-mini"];
   for (const model of newModels) {
     const entry = lookupModelCost(model);
     assert.ok(entry, `lookupModelCost should find "${model}"`);

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

@@ -126,6 +126,43 @@ test("uses explicit tier_models when configured", () => {
   assert.equal(result.wasDowngraded, true);
 });
 
+test("preserves explicit provider-qualified tier_models when duplicate bare IDs exist", () => {
+  const config: DynamicRoutingConfig = {
+    ...defaultRoutingConfig(),
+    enabled: true,
+    capability_routing: false,
+    tier_models: {
+      light: "custom-openai/gpt-5.3-codex-spark",
+      standard: "custom-openai/gpt-5.4",
+    },
+  };
+  const providerModels = [
+    "openai-codex/gpt-5.4",
+    "custom-openai/gpt-5.4",
+    "openai-codex/gpt-5.3-codex-spark",
+    "custom-openai/gpt-5.3-codex-spark",
+    "custom-anthropic/claude-opus-4-7",
+  ];
+
+  const standard = resolveModelForComplexity(
+    makeClassification("standard"),
+    { primary: "custom-anthropic/claude-opus-4-7", fallbacks: [] },
+    config,
+    providerModels,
+  );
+  assert.equal(standard.modelId, "custom-openai/gpt-5.4");
+  assert.equal(standard.wasDowngraded, true);
+
+  const light = resolveModelForComplexity(
+    makeClassification("light"),
+    { primary: "custom-anthropic/claude-opus-4-7", fallbacks: [] },
+    config,
+    providerModels,
+  );
+  assert.equal(light.modelId, "custom-openai/gpt-5.3-codex-spark");
+  assert.equal(light.wasDowngraded, true);
+});
+
 // ─── Fallback chain construction ─────────────────────────────────────────────
 
 test("fallback chain includes configured primary as last resort", () => {
@@ -218,6 +255,19 @@ test("defaultRoutingConfig includes capability_routing: true", () => {
   assert.equal(config.capability_routing, true);
 });
 
+test("scoreEligibleModels uses bare capability profiles for provider-qualified IDs", () => {
+  const scored = scoreEligibleModels(
+    ["custom-openai/gpt-5.4", "custom-openai/gpt-5.3-codex-spark"],
+    { coding: 1 },
+  );
+
+  assert.equal(scored[0]?.modelId, "custom-openai/gpt-5.4");
+  assert.ok(
+    (scored[0]?.score ?? 0) > (scored[1]?.score ?? 0),
+    "provider-qualified IDs should still use the built-in bare model capability profile",
+  );
+});
+
 test("scoreModel computes weighted average of capability × requirement", () => {
   const caps: ModelCapabilities = {
     coding: 90, debugging: 80, research: 70,
@@ -298,7 +348,7 @@ test("MODEL_CAPABILITY_PROFILES has entries for all tier-mapped models", () => {
 
 test("#2885: openai-codex light-tier models are recognized", () => {
   const config = { ...defaultRoutingConfig(), enabled: true };
-  const lightModels = ["gpt-4.1-mini", "gpt-4.1-nano", "gpt-5-mini", "gpt-5-nano", "gpt-5.1-codex-mini", "gpt-5.3-codex-spark"];
+  const lightModels = ["gpt-4.1-mini", "gpt-4.1-nano", "gpt-5-mini", "gpt-5-nano", "gpt-5.1-codex-mini", "gpt-5.3-codex-spark", "gpt-5.4-mini"];
   for (const model of lightModels) {
     const result = resolveModelForComplexity(
       makeClassification("light"),

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

@@ -215,6 +215,65 @@ test("unitVerb handles discuss-slice", () => {
 // auto-artifact-paths.ts: artifact resolution
 // ═══════════════════════════════════════════════════════════════════════════
 
+// ═══════════════════════════════════════════════════════════════════════════
+// ADR-011: meta-test — every KNOWN_UNIT_TYPES entry must appear in all four
+// downstream registries so a future unit type added to KNOWN_UNIT_TYPES can't
+// silently fall through to wrong defaults in metrics/dashboard/artifacts/post-unit.
+// ═══════════════════════════════════════════════════════════════════════════
+
+// Intentional exceptions — unit types that legitimately rely on default/null
+// behavior in a specific registry. Entries captured here reflect the current
+// baseline at the time ADR-011 landed; adding to this allowlist for a NEW unit
+// type requires explicit justification in the commit.
+//
+// Test intent: catch the case where someone adds a new unit type to
+// KNOWN_UNIT_TYPES but forgets to wire it into one of the four registries.
+// The allowlist freezes the baseline so pre-existing omissions do not block
+// the test, but any brand-new addition must be either handled or justified.
+const REGISTRY_EXCEPTIONS: Record<string, Set<string>> = {
+  // metrics.ts classifyUnitPhase uses default → "execution" for most unit types.
+  "metrics.ts": new Set([
+    "worktree-merge", "custom-step",
+    "rewrite-docs", "run-uat", "gate-evaluate", "replan-slice",
+    "reactive-execute", "validate-milestone", "complete-milestone",
+  ]),
+  "auto-dashboard.ts": new Set([
+    "worktree-merge",
+    "gate-evaluate", "reactive-execute", "validate-milestone", "complete-milestone",
+  ]),
+  "auto-artifact-paths.ts": new Set([
+    "rewrite-docs", "gate-evaluate", "reactive-execute", "discuss-slice", "worktree-merge",
+  ]),
+  "auto-post-unit.ts": new Set([
+    "execute-task", "reactive-execute", "gate-evaluate", "worktree-merge",
+  ]),
+};
+
+const REGISTRY_SOURCES: Array<[string, string]> = [
+  ["metrics.ts", metricsSrc],
+  ["auto-dashboard.ts", dashboardSrc],
+  ["auto-artifact-paths.ts", artifactSrc],
+  ["auto-post-unit.ts", postUnitSrc],
+];
+
+test("ADR-011 meta: every KNOWN_UNIT_TYPES entry appears in all 4 downstream registries", () => {
+  const missing: Array<{ registry: string; unitType: string }> = [];
+  for (const [registry, src] of REGISTRY_SOURCES) {
+    for (const ut of ALL_KNOWN_UNIT_TYPES) {
+      if (REGISTRY_EXCEPTIONS[registry]?.has(ut)) continue;
+      if (!src.includes(`"${ut}"`)) {
+        missing.push({ registry, unitType: ut });
+      }
+    }
+  }
+  assert.deepEqual(
+    missing,
+    [],
+    "Each listed unit type is absent from the given registry — either add a handler or add to REGISTRY_EXCEPTIONS with justification:\n" +
+      missing.map((m) => `  ${m.registry}: "${m.unitType}"`).join("\n"),
+  );
+});
+
 test("resolveExpectedArtifactPath handles discuss-slice", () => {
   assert.ok(artifactSrc.includes('"discuss-slice"'), "missing discuss-slice in artifact paths");
 });

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

@@ -1,31 +1,21 @@
 // GSD Extension — Notification Overlay Tests
-// Tests for message wrapping and content-fit sizing in the notification panel.
+// Tests for message wrapping in the notification panel.
+// Mirrors the private wrapText from notification-overlay.ts so its contract
+// can be exercised without exporting internals.
 
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
 
-// The wrapText function is private to the module, so we test the overlay's
-// render output indirectly. We also extract and test wrapText logic directly.
+import { truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@gsd/pi-tui";
 
-// ── wrapText logic (mirrors the private function) ───────────────────────────
+// ── wrapText logic (mirrors the private function in notification-overlay.ts) ──
 
 function wrapText(text: string, maxWidth: number): string[] {
-  if (text.length <= maxWidth) return [text];
-  const words = text.split(/\s+/);
-  const lines: string[] = [];
-  let current = "";
-  for (const word of words) {
-    if (current.length === 0) {
-      current = word;
-    } else if (current.length + 1 + word.length <= maxWidth) {
-      current += " " + word;
-    } else {
-      lines.push(current);
-      current = word;
-    }
-  }
-  if (current.length > 0) lines.push(current);
-  return lines.map((l) => l.length > maxWidth ? l.slice(0, maxWidth - 1) + "…" : l);
+  if (maxWidth <= 0) return [text];
+  const lines = wrapTextWithAnsi(text, maxWidth);
+  return lines.map((l) =>
+    visibleWidth(l) > maxWidth ? truncateToWidth(l, maxWidth, "…") : l,
+  );
 }
 
 describe("notification overlay — wrapText", () => {
@@ -34,31 +24,26 @@ describe("notification overlay — wrapText", () => {
     assert.deepStrictEqual(result, ["hello world"]);
   });
 
-  test("long text wraps at word boundaries", () => {
+  test("long text wraps at word boundaries without exceeding maxWidth", () => {
     const text = "This is a long notification message that should wrap across multiple lines";
     const result = wrapText(text, 40);
     assert.ok(result.length > 1, `expected multiple lines, got ${result.length}`);
     for (const line of result) {
-      assert.ok(line.length <= 40, `line exceeds maxWidth: "${line}" (${line.length})`);
+      assert.ok(
+        visibleWidth(line) <= 40,
+        `line exceeds maxWidth: "${line}" (${visibleWidth(line)})`,
+      );
     }
   });
 
-  test("single word exceeding maxWidth is truncated", () => {
+  test("single word exceeding maxWidth is broken to fit column budget", () => {
     const result = wrapText("superlongwordthatexceedsmaxwidth", 10);
-    assert.equal(result.length, 1);
-    assert.equal(result[0]!.length, 10);
-    assert.ok(result[0]!.endsWith("…"));
-  });
-
-  test("empty string returns single empty line", () => {
-    const result = wrapText("", 80);
-    assert.deepStrictEqual(result, [""]);
-  });
-
-  test("exact-fit text returns single line", () => {
-    const text = "exactly twenty chars";
-    const result = wrapText(text, 20);
-    assert.deepStrictEqual(result, [text]);
+    for (const line of result) {
+      assert.ok(
+        visibleWidth(line) <= 10,
+        `line exceeds maxWidth: "${line}" (${visibleWidth(line)})`,
+      );
+    }
   });
 
   test("preserves all words across wrapped lines", () => {
@@ -70,4 +55,38 @@ describe("notification overlay — wrapText", () => {
       assert.ok(rejoined.includes(w), `missing word: ${w}`);
     }
   });
+
+  // Regression for #4465 — the previous .length-based wrapper could allow
+  // lines to bleed past the panel border when measured in terminal columns.
+  // Verify that every wrapped line stays within the column budget, including
+  // for the real-world long multi-provider notification payload.
+  test("regression #4465: long notification stays within column budget", () => {
+    const msg =
+      "GSD API Key Manager LLM Providers ✗ anthropic — not configured " +
+      "(console.anthropic.com) ✗ openai — not configured " +
+      "(platform.openai.com/api-keys) ✓ github-copilot — OAuth (expires in 13m) " +
+      "✓ openai-codex — OAuth (expires in 99h 9m) ✓ google-gemini-cli — OAuth " +
+      "(expired — will auto-refresh) ✓ google-antigravity — OAuth " +
+      "(expired — will auto-refresh) ✗ google — not configured " +
+      "(aistudio.google.com/apikey) ✗ groq — not configured";
+    const maxWidth = 118;
+    const result = wrapText(msg, maxWidth);
+    for (const line of result) {
+      assert.ok(
+        visibleWidth(line) <= maxWidth,
+        `line exceeds column budget: visibleWidth=${visibleWidth(line)} max=${maxWidth}: "${line}"`,
+      );
+    }
+  });
+
+  test("unbreakable long token (URL) is clamped to maxWidth", () => {
+    const url = "https://example.com/" + "a".repeat(200);
+    const result = wrapText(url, 40);
+    for (const line of result) {
+      assert.ok(
+        visibleWidth(line) <= 40,
+        `line exceeds maxWidth: visibleWidth=${visibleWidth(line)} line="${line}"`,
+      );
+    }
+  });
 });

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

@@ -17,7 +17,7 @@ test("buildNotificationWidgetLines shows unread count with shortcut pair", () =>
 
     const lines = buildNotificationWidgetLines();
     assert.equal(lines.length, 1);
-    assert.match(lines[0]!, /Notifications:\s+1 unread/);
+    assert.match(lines[0]!, /🔔\s+1 unread/);
     assert.match(lines[0]!, /\(.+\/.+\)/);
   } finally {
     _resetNotificationStore();