gsd-pi 2.75.0-dev.2203010a0 → 2.75.0-dev.96d4bb599

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/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,

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/skip-slice-cascades-tasks.test.ts

@@ -0,0 +1,125 @@
+/**
+ * Regression test for #4375: gsd_skip_slice must cascade "skipped" status to
+ * all non-closed tasks in the slice.
+ *
+ * Without the cascade, executeCompleteMilestone's deep-task check finds
+ * pending tasks inside a skipped slice and refuses to complete the milestone,
+ * causing auto-mode to loop on complete-milestone until stuck-recovery aborts.
+ */
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+  getSlice,
+  getSliceTasks,
+  updateSliceStatus,
+  updateTaskStatus,
+} from "../gsd-db.ts";
+import { handleSkipSlice } from "../tools/skip-slice.ts";
+
+describe("handleSkipSlice cascades skip to tasks (#4375)", () => {
+  let dir: string;
+  let dbPath: string;
+
+  beforeEach(() => {
+    dir = mkdtempSync(join(tmpdir(), "gsd-skip-cascade-"));
+    dbPath = join(dir, "test.db");
+    openDatabase(dbPath);
+    insertMilestone({ id: "M001", title: "Test", status: "active" });
+    insertSlice({ milestoneId: "M001", id: "S03", title: "Deferred", status: "pending", sequence: 3 });
+    insertTask({ milestoneId: "M001", sliceId: "S03", id: "T01", title: "task 1", status: "pending", sequence: 1 });
+    insertTask({ milestoneId: "M001", sliceId: "S03", id: "T02", title: "task 2", status: "active", sequence: 2 });
+    insertTask({ milestoneId: "M001", sliceId: "S03", id: "T03", title: "task 3", status: "pending", sequence: 3 });
+  });
+
+  afterEach(() => {
+    closeDatabase();
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  test("sets slice to skipped and cascades pending/active tasks to skipped", () => {
+    const result = handleSkipSlice({ milestoneId: "M001", sliceId: "S03", reason: "deferred" });
+
+    assert.equal(result.error, undefined, `expected success, got error: ${result.error ?? ""}`);
+    assert.equal(result.sliceId, "S03");
+    assert.equal(result.milestoneId, "M001");
+    assert.equal(result.tasksSkipped, 3, "all three non-closed tasks should be cascaded");
+
+    const slice = getSlice("M001", "S03");
+    assert.equal(slice?.status, "skipped", "slice status must be skipped");
+
+    const tasks = getSliceTasks("M001", "S03");
+    for (const t of tasks) {
+      assert.equal(t.status, "skipped", `task ${t.id} must be skipped after cascade`);
+    }
+  });
+
+  test("does not downgrade already-closed tasks", () => {
+    updateTaskStatus("M001", "S03", "T01", "complete", new Date().toISOString());
+
+    const result = handleSkipSlice({ milestoneId: "M001", sliceId: "S03" });
+
+    assert.equal(result.error, undefined);
+    assert.equal(result.tasksSkipped, 2, "only the two non-closed tasks should be cascaded");
+
+    const tasks = getSliceTasks("M001", "S03");
+    const byId = new Map(tasks.map((t) => [t.id, t.status]));
+    assert.equal(byId.get("T01"), "complete", "completed task must not be downgraded");
+    assert.equal(byId.get("T02"), "skipped");
+    assert.equal(byId.get("T03"), "skipped");
+  });
+
+  test("re-running skip on an already-skipped slice heals leftover pending tasks (#4375 recovery)", () => {
+    const first = handleSkipSlice({ milestoneId: "M001", sliceId: "S03" });
+    assert.equal(first.error, undefined);
+    assert.equal(first.tasksSkipped, 3);
+
+    // Simulate historical inconsistent state: slice skipped but a task was
+    // later recreated or reset to pending by some migration/bug path.
+    updateTaskStatus("M001", "S03", "T01", "pending");
+
+    const second = handleSkipSlice({ milestoneId: "M001", sliceId: "S03" });
+    assert.equal(second.error, undefined, "re-running must succeed (no 'already skipped' hard error)");
+    assert.equal(second.tasksSkipped, 1, "only the leftover pending task should be cascaded");
+    assert.equal(second.wasAlreadySkipped, true);
+
+    const tasks = getSliceTasks("M001", "S03");
+    for (const t of tasks) {
+      assert.equal(t.status, "skipped", `task ${t.id} must be skipped after recovery`);
+    }
+  });
+
+  test("refuses to skip an already-complete slice", () => {
+    updateSliceStatus("M001", "S03", "complete");
+
+    const result = handleSkipSlice({ milestoneId: "M001", sliceId: "S03" });
+    assert.ok(result.error, "expected error when slice is already complete");
+    assert.match(result.error!, /already complete/i);
+    assert.equal(result.errorCode, "already_complete");
+  });
+
+  test("refuses to skip a slice in the legacy 'done' status", () => {
+    updateSliceStatus("M001", "S03", "done");
+
+    const result = handleSkipSlice({ milestoneId: "M001", sliceId: "S03" });
+    assert.ok(result.error, "expected error when slice is already done");
+    assert.match(result.error!, /already complete/i);
+    assert.equal(result.errorCode, "already_complete");
+  });
+
+  test("returns error for unknown slice", () => {
+    const result = handleSkipSlice({ milestoneId: "M001", sliceId: "S99" });
+    assert.ok(result.error);
+    assert.match(result.error!, /not found/i);
+    assert.equal(result.errorCode, "slice_not_found");
+  });
+});