gsd-pi 2.44.0 → 2.45.0-dev.1afbdaa

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

@@ -4,10 +4,10 @@
 // AND under a backward-compatible alias name.
 // The alias must share the exact same execute function reference as the canonical tool.
 
-import { createTestContext } from './test-helpers.ts';
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
 import { registerDbTools } from '../bootstrap/db-tools.ts';
 
-const { assertEq, assertTrue, report } = createTestContext();
 
 // ─── Mock PI ──────────────────────────────────────────────────────────────────
 
@@ -34,6 +34,7 @@ const RENAME_MAP: Array<{ canonical: string; alias: string }> = [
   { canonical: "gsd_replan_slice", alias: "gsd_slice_replan" },
   { canonical: "gsd_reassess_roadmap", alias: "gsd_roadmap_reassess" },
   { canonical: "gsd_complete_milestone", alias: "gsd_milestone_complete" },
+  { canonical: "gsd_validate_milestone", alias: "gsd_milestone_validate" },
 ];
 
 // ─── Registration count ──────────────────────────────────────────────────────
@@ -43,7 +44,7 @@ console.log('\n── Tool naming: registration count ──');
 const pi = makeMockPi();
 registerDbTools(pi);
 
-assertEq(pi.tools.length, 24, 'Should register exactly 24 tools (12 canonical + 12 aliases)');
+assert.deepStrictEqual(pi.tools.length, 26, 'Should register exactly 26 tools (13 canonical + 13 aliases)');
 
 // ─── Both names exist for each pair ──────────────────────────────────────────
 
@@ -53,8 +54,8 @@ for (const { canonical, alias } of RENAME_MAP) {
   const canonicalTool = pi.tools.find((t: any) => t.name === canonical);
   const aliasTool = pi.tools.find((t: any) => t.name === alias);
 
-  assertTrue(canonicalTool !== undefined, `Canonical tool "${canonical}" should be registered`);
-  assertTrue(aliasTool !== undefined, `Alias tool "${alias}" should be registered`);
+  assert.ok(canonicalTool !== undefined, `Canonical tool "${canonical}" should be registered`);
+  assert.ok(aliasTool !== undefined, `Alias tool "${alias}" should be registered`);
 }
 
 // ─── Execute function identity ───────────────────────────────────────────────
@@ -66,7 +67,7 @@ for (const { canonical, alias } of RENAME_MAP) {
   const aliasTool = pi.tools.find((t: any) => t.name === alias);
 
   if (canonicalTool && aliasTool) {
-    assertTrue(
+    assert.ok(
       canonicalTool.execute === aliasTool.execute,
       `"${canonical}" and "${alias}" should share the same execute function reference`,
     );
@@ -81,7 +82,7 @@ for (const { canonical, alias } of RENAME_MAP) {
   const aliasTool = pi.tools.find((t: any) => t.name === alias);
 
   if (aliasTool) {
-    assertTrue(
+    assert.ok(
       aliasTool.description.includes(`alias for ${canonical}`),
       `Alias "${alias}" description should include "alias for ${canonical}"`,
     );
@@ -97,7 +98,7 @@ for (const { canonical } of RENAME_MAP) {
 
   if (canonicalTool) {
     const guidelinesText = canonicalTool.promptGuidelines.join(' ');
-    assertTrue(
+    assert.ok(
       guidelinesText.includes(canonical),
       `Canonical tool "${canonical}" promptGuidelines should reference its own name`,
     );
@@ -113,7 +114,7 @@ for (const { canonical, alias } of RENAME_MAP) {
 
   if (aliasTool) {
     const guidelinesText = aliasTool.promptGuidelines.join(' ');
-    assertTrue(
+    assert.ok(
       guidelinesText.includes(`Alias for ${canonical}`),
       `Alias "${alias}" promptGuidelines should say "Alias for ${canonical}"`,
     );
@@ -121,5 +122,3 @@ for (const { canonical, alias } of RENAME_MAP) {
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
-
-report();

package/src/resources/extensions/gsd/tests/unique-milestone-ids.test.ts

@@ -22,72 +22,72 @@ import {
 
 import { renderPreferencesForSystemPrompt } from '../preferences.ts';
 import type { GSDPreferences } from '../preferences.ts';
-import { createTestContext } from './test-helpers.ts';
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
 
 
-const { assertEq, assertTrue, assertMatch, report } = createTestContext();
 // ─── Tests ─────────────────────────────────────────────────────────────────
 
-async function main(): Promise<void> {
+describe('unique-milestone-ids', async () => {
   console.log('unique-milestone-ids tests');
 
   // (a) MILESTONE_ID_RE
   {
     console.log('  (a) MILESTONE_ID_RE');
     // Should match
-    assertTrue(MILESTONE_ID_RE.test('M001'), 'matches M001');
-    assertTrue(MILESTONE_ID_RE.test('M999'), 'matches M999');
-    assertTrue(MILESTONE_ID_RE.test('M001-abc123'), 'matches M001-abc123');
-    assertTrue(MILESTONE_ID_RE.test('M042-z9a8b7'), 'matches M042-z9a8b7');
+    assert.ok(MILESTONE_ID_RE.test('M001'), 'matches M001');
+    assert.ok(MILESTONE_ID_RE.test('M999'), 'matches M999');
+    assert.ok(MILESTONE_ID_RE.test('M001-abc123'), 'matches M001-abc123');
+    assert.ok(MILESTONE_ID_RE.test('M042-z9a8b7'), 'matches M042-z9a8b7');
 
     // Should reject
-    assertTrue(!MILESTONE_ID_RE.test('M1'), 'rejects M1 (too few digits)');
-    assertTrue(!MILESTONE_ID_RE.test('M0001'), 'rejects M0001 (too many digits)');
-    assertTrue(!MILESTONE_ID_RE.test('M001-ABCDEF'), 'rejects M001-ABCDEF (uppercase prefix)');
-    assertTrue(!MILESTONE_ID_RE.test('M001-short'), 'rejects M001-short (5-char prefix)');
-    assertTrue(!MILESTONE_ID_RE.test('M001-toolong1'), 'rejects M001-toolong1 (>6-char prefix)');
-    assertTrue(!MILESTONE_ID_RE.test('IM001'), 'rejects IM001 (prefix before M)');
-    assertTrue(!MILESTONE_ID_RE.test(''), 'rejects empty string');
-    assertTrue(!MILESTONE_ID_RE.test('M001extra'), 'rejects M001extra (trailing chars)');
-    assertTrue(!MILESTONE_ID_RE.test('notes'), 'rejects non-milestone string');
+    assert.ok(!MILESTONE_ID_RE.test('M1'), 'rejects M1 (too few digits)');
+    assert.ok(!MILESTONE_ID_RE.test('M0001'), 'rejects M0001 (too many digits)');
+    assert.ok(!MILESTONE_ID_RE.test('M001-ABCDEF'), 'rejects M001-ABCDEF (uppercase prefix)');
+    assert.ok(!MILESTONE_ID_RE.test('M001-short'), 'rejects M001-short (5-char prefix)');
+    assert.ok(!MILESTONE_ID_RE.test('M001-toolong1'), 'rejects M001-toolong1 (>6-char prefix)');
+    assert.ok(!MILESTONE_ID_RE.test('IM001'), 'rejects IM001 (prefix before M)');
+    assert.ok(!MILESTONE_ID_RE.test(''), 'rejects empty string');
+    assert.ok(!MILESTONE_ID_RE.test('M001extra'), 'rejects M001extra (trailing chars)');
+    assert.ok(!MILESTONE_ID_RE.test('notes'), 'rejects non-milestone string');
   }
 
   // (b) extractMilestoneSeq
   {
     console.log('  (b) extractMilestoneSeq');
     // Old format
-    assertEq(extractMilestoneSeq('M001'), 1, 'M001 → 1');
-    assertEq(extractMilestoneSeq('M042'), 42, 'M042 → 42');
-    assertEq(extractMilestoneSeq('M999'), 999, 'M999 → 999');
+    assert.deepStrictEqual(extractMilestoneSeq('M001'), 1, 'M001 → 1');
+    assert.deepStrictEqual(extractMilestoneSeq('M042'), 42, 'M042 → 42');
+    assert.deepStrictEqual(extractMilestoneSeq('M999'), 999, 'M999 → 999');
 
     // Unique format
-    assertEq(extractMilestoneSeq('M001-abc123'), 1, 'M001-abc123 → 1');
-    assertEq(extractMilestoneSeq('M042-z9a8b7'), 42, 'M042-z9a8b7 → 42');
+    assert.deepStrictEqual(extractMilestoneSeq('M001-abc123'), 1, 'M001-abc123 → 1');
+    assert.deepStrictEqual(extractMilestoneSeq('M042-z9a8b7'), 42, 'M042-z9a8b7 → 42');
 
     // Invalid → 0
-    assertEq(extractMilestoneSeq(''), 0, 'empty → 0');
-    assertEq(extractMilestoneSeq('notes'), 0, 'notes → 0');
-    assertEq(extractMilestoneSeq('M1'), 0, 'M1 → 0');
-    assertEq(extractMilestoneSeq('.DS_Store'), 0, '.DS_Store → 0');
-    assertEq(extractMilestoneSeq('M-ABC-001'), 0, 'M-ABC-001 (old format) → 0');
+    assert.deepStrictEqual(extractMilestoneSeq(''), 0, 'empty → 0');
+    assert.deepStrictEqual(extractMilestoneSeq('notes'), 0, 'notes → 0');
+    assert.deepStrictEqual(extractMilestoneSeq('M1'), 0, 'M1 → 0');
+    assert.deepStrictEqual(extractMilestoneSeq('.DS_Store'), 0, '.DS_Store → 0');
+    assert.deepStrictEqual(extractMilestoneSeq('M-ABC-001'), 0, 'M-ABC-001 (old format) → 0');
   }
 
   // (c) parseMilestoneId
   {
     console.log('  (c) parseMilestoneId');
     // Old format — no suffix
-    assertEq(parseMilestoneId('M001'), { num: 1 }, 'M001 → { num: 1 }');
-    assertEq(parseMilestoneId('M042'), { num: 42 }, 'M042 → { num: 42 }');
+    assert.deepStrictEqual(parseMilestoneId('M001'), { num: 1 }, 'M001 → { num: 1 }');
+    assert.deepStrictEqual(parseMilestoneId('M042'), { num: 42 }, 'M042 → { num: 42 }');
 
     // Unique format — with suffix
-    assertEq(parseMilestoneId('M001-abc123'), { suffix: 'abc123', num: 1 }, 'M001-abc123 → { suffix, num }');
-    assertEq(parseMilestoneId('M042-z9a8b7'), { suffix: 'z9a8b7', num: 42 }, 'M042-z9a8b7 → { suffix, num }');
+    assert.deepStrictEqual(parseMilestoneId('M001-abc123'), { suffix: 'abc123', num: 1 }, 'M001-abc123 → { suffix, num }');
+    assert.deepStrictEqual(parseMilestoneId('M042-z9a8b7'), { suffix: 'z9a8b7', num: 42 }, 'M042-z9a8b7 → { suffix, num }');
 
     // Invalid → { num: 0 }
-    assertEq(parseMilestoneId(''), { num: 0 }, 'empty → { num: 0 }');
-    assertEq(parseMilestoneId('notes'), { num: 0 }, 'notes → { num: 0 }');
-    assertEq(parseMilestoneId('M001-ABCDEF'), { num: 0 }, 'uppercase suffix → { num: 0 }');
-    assertEq(parseMilestoneId('M1'), { num: 0 }, 'M1 → { num: 0 }');
+    assert.deepStrictEqual(parseMilestoneId(''), { num: 0 }, 'empty → { num: 0 }');
+    assert.deepStrictEqual(parseMilestoneId('notes'), { num: 0 }, 'notes → { num: 0 }');
+    assert.deepStrictEqual(parseMilestoneId('M001-ABCDEF'), { num: 0 }, 'uppercase suffix → { num: 0 }');
+    assert.deepStrictEqual(parseMilestoneId('M1'), { num: 0 }, 'M1 → { num: 0 }');
   }
 
   // (d) milestoneIdSort
@@ -95,81 +95,81 @@ async function main(): Promise<void> {
     console.log('  (d) milestoneIdSort');
     const mixed = ['M003-abc123', 'M001', 'M002-z9a8b7'];
     const sorted = [...mixed].sort(milestoneIdSort);
-    assertEq(sorted, ['M001', 'M002-z9a8b7', 'M003-abc123'], 'sorts mixed IDs by sequence number');
+    assert.deepStrictEqual(sorted, ['M001', 'M002-z9a8b7', 'M003-abc123'], 'sorts mixed IDs by sequence number');
 
     // All old format
     const oldOnly = ['M003', 'M001', 'M002'];
-    assertEq([...oldOnly].sort(milestoneIdSort), ['M001', 'M002', 'M003'], 'sorts old-format IDs');
+    assert.deepStrictEqual([...oldOnly].sort(milestoneIdSort), ['M001', 'M002', 'M003'], 'sorts old-format IDs');
 
     // Invalid entries sort to front (seq 0)
     const withInvalid = ['M002', 'notes', 'M001'];
-    assertEq([...withInvalid].sort(milestoneIdSort), ['notes', 'M001', 'M002'], 'invalid entries (seq 0) sort first');
+    assert.deepStrictEqual([...withInvalid].sort(milestoneIdSort), ['notes', 'M001', 'M002'], 'invalid entries (seq 0) sort first');
   }
 
   // (e) generateMilestoneSuffix
   {
     console.log('  (e) generateMilestoneSuffix');
     const suffix1 = generateMilestoneSuffix();
-    assertEq(suffix1.length, 6, 'suffix length is 6');
-    assertMatch(suffix1, /^[a-z0-9]{6}$/, 'suffix matches [a-z0-9]{6}');
+    assert.deepStrictEqual(suffix1.length, 6, 'suffix length is 6');
+    assert.match(suffix1, /^[a-z0-9]{6}$/, 'suffix matches [a-z0-9]{6}');
 
     const suffix2 = generateMilestoneSuffix();
-    assertEq(suffix2.length, 6, 'second suffix length is 6');
-    assertMatch(suffix2, /^[a-z0-9]{6}$/, 'second suffix matches [a-z0-9]{6}');
+    assert.deepStrictEqual(suffix2.length, 6, 'second suffix length is 6');
+    assert.match(suffix2, /^[a-z0-9]{6}$/, 'second suffix matches [a-z0-9]{6}');
 
     // Two calls should produce different results (36^6 = ~2.2B possibilities)
-    assertTrue(suffix1 !== suffix2, 'two calls produce different suffixes');
+    assert.ok(suffix1 !== suffix2, 'two calls produce different suffixes');
   }
 
   // (f) nextMilestoneId
   {
     console.log('  (f) nextMilestoneId');
     // uniqueEnabled=false (default) → old format
-    assertEq(nextMilestoneId([]), 'M001', 'empty + uniqueEnabled=false → M001');
-    assertEq(nextMilestoneId(['M001', 'M002']), 'M003', 'sequential + uniqueEnabled=false → M003');
-    assertEq(nextMilestoneId(['M001', 'M002'], false), 'M003', 'explicit false → M003');
+    assert.deepStrictEqual(nextMilestoneId([]), 'M001', 'empty + uniqueEnabled=false → M001');
+    assert.deepStrictEqual(nextMilestoneId(['M001', 'M002']), 'M003', 'sequential + uniqueEnabled=false → M003');
+    assert.deepStrictEqual(nextMilestoneId(['M001', 'M002'], false), 'M003', 'explicit false → M003');
 
     // uniqueEnabled=true → unique format
     const newId = nextMilestoneId([], true);
-    assertMatch(newId, MILESTONE_ID_RE, 'uniqueEnabled=true produces valid ID');
-    assertTrue(newId.startsWith('M001-'), 'uniqueEnabled=true starts with M001-');
-    assertMatch(newId, /^M001-[a-z0-9]{6}$/, 'empty + uniqueEnabled=true → M001-{rand6}');
+    assert.match(newId, MILESTONE_ID_RE, 'uniqueEnabled=true produces valid ID');
+    assert.ok(newId.startsWith('M001-'), 'uniqueEnabled=true starts with M001-');
+    assert.match(newId, /^M001-[a-z0-9]{6}$/, 'empty + uniqueEnabled=true → M001-{rand6}');
 
     // Mixed array with uniqueEnabled=true
     const mixedIds = ['M001', 'M003-abc123', 'M002'];
     const nextNew = nextMilestoneId(mixedIds, true);
-    assertMatch(nextNew, MILESTONE_ID_RE, 'mixed array + uniqueEnabled=true → valid ID');
-    assertMatch(nextNew, /^M004-[a-z0-9]{6}$/, 'mixed array max=3 → M004-{rand6}');
+    assert.match(nextNew, MILESTONE_ID_RE, 'mixed array + uniqueEnabled=true → valid ID');
+    assert.match(nextNew, /^M004-[a-z0-9]{6}$/, 'mixed array max=3 → M004-{rand6}');
 
     // Mixed array with uniqueEnabled=false
-    assertEq(nextMilestoneId(mixedIds, false), 'M004', 'mixed array + uniqueEnabled=false → M004');
+    assert.deepStrictEqual(nextMilestoneId(mixedIds, false), 'M004', 'mixed array + uniqueEnabled=false → M004');
 
     // Correct sequential number from mixed arrays
     const mixedIds2 = ['M005-xyz999', 'M002'];
-    assertEq(nextMilestoneId(mixedIds2, false), 'M006', 'mixed max=5 → M006');
+    assert.deepStrictEqual(nextMilestoneId(mixedIds2, false), 'M006', 'mixed max=5 → M006');
     const nextNew2 = nextMilestoneId(mixedIds2, true);
-    assertMatch(nextNew2, /^M006-[a-z0-9]{6}$/, 'mixed max=5 + unique → M006-{rand6}');
+    assert.match(nextNew2, /^M006-[a-z0-9]{6}$/, 'mixed max=5 + unique → M006-{rand6}');
   }
 
   // (g) maxMilestoneNum
   {
     console.log('  (g) maxMilestoneNum');
     // Empty
-    assertEq(maxMilestoneNum([]), 0, 'empty → 0');
+    assert.deepStrictEqual(maxMilestoneNum([]), 0, 'empty → 0');
 
     // Old format only
-    assertEq(maxMilestoneNum(['M001', 'M002', 'M003']), 3, 'old format only → 3');
+    assert.deepStrictEqual(maxMilestoneNum(['M001', 'M002', 'M003']), 3, 'old format only → 3');
 
     // Unique format only — must not return NaN
-    assertEq(maxMilestoneNum(['M001-abc123', 'M002-def456']), 2, 'unique format only → 2');
-    assertTrue(!Number.isNaN(maxMilestoneNum(['M001-abc123'])), 'unique format does not return NaN');
+    assert.deepStrictEqual(maxMilestoneNum(['M001-abc123', 'M002-def456']), 2, 'unique format only → 2');
+    assert.ok(!Number.isNaN(maxMilestoneNum(['M001-abc123'])), 'unique format does not return NaN');
 
     // Mixed formats
-    assertEq(maxMilestoneNum(['M001', 'M003-abc123', 'M002']), 3, 'mixed → 3');
+    assert.deepStrictEqual(maxMilestoneNum(['M001', 'M003-abc123', 'M002']), 3, 'mixed → 3');
 
     // Non-matching entries ignored
-    assertEq(maxMilestoneNum(['M001', 'notes', '.DS_Store', 'M003']), 3, 'non-matching ignored → 3');
-    assertEq(maxMilestoneNum(['notes', '.DS_Store']), 0, 'all non-matching → 0');
+    assert.deepStrictEqual(maxMilestoneNum(['M001', 'notes', '.DS_Store', 'M003']), 3, 'non-matching ignored → 3');
+    assert.deepStrictEqual(maxMilestoneNum(['notes', '.DS_Store']), 0, 'all non-matching → 0');
   }
 
   // (h) Preferences round-trip via renderPreferencesForSystemPrompt
@@ -179,41 +179,25 @@ async function main(): Promise<void> {
     // validate { unique_milestone_ids: true } → field preserved (no validation error)
     const prefsTrue: GSDPreferences = { unique_milestone_ids: true };
     const renderedTrue = renderPreferencesForSystemPrompt(prefsTrue);
-    assertTrue(!renderedTrue.includes('some preference values were ignored'), 'unique_milestone_ids: true validates without error');
+    assert.ok(!renderedTrue.includes('some preference values were ignored'), 'unique_milestone_ids: true validates without error');
 
     // validate { unique_milestone_ids: undefined } → field absent (no error)
     const prefsUndefined: GSDPreferences = {};
     const renderedUndefined = renderPreferencesForSystemPrompt(prefsUndefined);
-    assertTrue(!renderedUndefined.includes('some preference values were ignored'), 'undefined unique_milestone_ids validates without error');
+    assert.ok(!renderedUndefined.includes('some preference values were ignored'), 'undefined unique_milestone_ids validates without error');
 
     // validate { unique_milestone_ids: false } → also valid
     const prefsFalse: GSDPreferences = { unique_milestone_ids: false };
     const renderedFalse = renderPreferencesForSystemPrompt(prefsFalse);
-    assertTrue(!renderedFalse.includes('some preference values were ignored'), 'unique_milestone_ids: false validates without error');
+    assert.ok(!renderedFalse.includes('some preference values were ignored'), 'unique_milestone_ids: false validates without error');
 
     // validate coercion: truthy non-boolean → coerced to boolean (no crash)
     const prefsCoerced: GSDPreferences = { unique_milestone_ids: 1 as unknown as boolean };
     const renderedCoerced = renderPreferencesForSystemPrompt(prefsCoerced);
-    assertTrue(!renderedCoerced.includes('some preference values were ignored'), 'truthy non-boolean coerces without validation error');
+    assert.ok(!renderedCoerced.includes('some preference values were ignored'), 'truthy non-boolean coerces without validation error');
 
     // GSDPreferences interface accepts the field (compile-time check — if this compiles, it works)
     const prefs: GSDPreferences = { unique_milestone_ids: true, version: 1 };
-    assertTrue(prefs.unique_milestone_ids === true, 'GSDPreferences interface accepts unique_milestone_ids');
+    assert.ok(prefs.unique_milestone_ids === true, 'GSDPreferences interface accepts unique_milestone_ids');
   }
-
-  report();
-}
-
-// When run via vitest, wrap in test(); when run via tsx, call directly.
-const isVitest = typeof globalThis !== 'undefined' && (globalThis as any).__vitest_worker__?.config?.defines != null && 'vitest' in (globalThis as any).__vitest_worker__.config.defines || process.env.VITEST;
-if (isVitest) {
-  const { test } = await import('node:test');
-  test('unique-milestone-ids: all ID primitives handle both formats', async () => {
-    await main();
-  });
-} else {
-  main().catch((error) => {
-    console.error(error);
-    process.exit(1);
-  });
-}
+});

package/src/resources/extensions/gsd/tests/unit-ownership.test.ts

@@ -0,0 +1,175 @@
+// GSD — unit-ownership tests
+// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync, existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import {
+  claimUnit,
+  releaseUnit,
+  getOwner,
+  checkOwnership,
+  taskUnitKey,
+  sliceUnitKey,
+} from '../unit-ownership.ts';
+
+function makeTmpBase(): string {
+  return mkdtempSync(join(tmpdir(), 'gsd-ownership-'));
+}
+
+function cleanup(base: string): void {
+  try { rmSync(base, { recursive: true, force: true }); } catch { /* noop */ }
+}
+
+// ─── Key builders ────────────────────────────────────────────────────────
+
+test('taskUnitKey: builds correct key', () => {
+  assert.equal(taskUnitKey('M001', 'S01', 'T01'), 'M001/S01/T01');
+});
+
+test('sliceUnitKey: builds correct key', () => {
+  assert.equal(sliceUnitKey('M001', 'S01'), 'M001/S01');
+});
+
+// ─── Claim / get / release ───────────────────────────────────────────────
+
+test('claimUnit: creates claim file and records agent', () => {
+  const base = makeTmpBase();
+  try {
+    claimUnit(base, 'M001/S01/T01', 'executor-01');
+
+    assert.ok(existsSync(join(base, '.gsd', 'unit-claims.json')), 'claim file should exist');
+    assert.equal(getOwner(base, 'M001/S01/T01'), 'executor-01');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('claimUnit: overwrites existing claim (last writer wins)', () => {
+  const base = makeTmpBase();
+  try {
+    claimUnit(base, 'M001/S01/T01', 'executor-01');
+    claimUnit(base, 'M001/S01/T01', 'executor-02');
+
+    assert.equal(getOwner(base, 'M001/S01/T01'), 'executor-02');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('claimUnit: multiple units can be claimed independently', () => {
+  const base = makeTmpBase();
+  try {
+    claimUnit(base, 'M001/S01/T01', 'agent-a');
+    claimUnit(base, 'M001/S01/T02', 'agent-b');
+
+    assert.equal(getOwner(base, 'M001/S01/T01'), 'agent-a');
+    assert.equal(getOwner(base, 'M001/S01/T02'), 'agent-b');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('getOwner: returns null when no claim file exists', () => {
+  const base = makeTmpBase();
+  try {
+    assert.equal(getOwner(base, 'M001/S01/T01'), null);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('getOwner: returns null for unclaimed unit', () => {
+  const base = makeTmpBase();
+  try {
+    claimUnit(base, 'M001/S01/T01', 'agent-a');
+    assert.equal(getOwner(base, 'M001/S01/T99'), null);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('releaseUnit: removes claim', () => {
+  const base = makeTmpBase();
+  try {
+    claimUnit(base, 'M001/S01/T01', 'agent-a');
+    releaseUnit(base, 'M001/S01/T01');
+
+    assert.equal(getOwner(base, 'M001/S01/T01'), null);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('releaseUnit: no-op for non-existent claim', () => {
+  const base = makeTmpBase();
+  try {
+    // Should not throw
+    releaseUnit(base, 'M001/S01/T01');
+  } finally {
+    cleanup(base);
+  }
+});
+
+// ─── checkOwnership ──────────────────────────────────────────────────────
+
+test('checkOwnership: returns null when no actorName provided (opt-in)', () => {
+  const base = makeTmpBase();
+  try {
+    claimUnit(base, 'M001/S01/T01', 'agent-a');
+
+    // No actorName → ownership not enforced
+    assert.equal(checkOwnership(base, 'M001/S01/T01', undefined), null);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('checkOwnership: returns null when no claim file exists', () => {
+  const base = makeTmpBase();
+  try {
+    assert.equal(checkOwnership(base, 'M001/S01/T01', 'agent-a'), null);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('checkOwnership: returns null when unit is unclaimed', () => {
+  const base = makeTmpBase();
+  try {
+    claimUnit(base, 'M001/S01/T01', 'agent-a');
+
+    // Different unit, unclaimed
+    assert.equal(checkOwnership(base, 'M001/S01/T99', 'agent-b'), null);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('checkOwnership: returns null when actor matches owner', () => {
+  const base = makeTmpBase();
+  try {
+    claimUnit(base, 'M001/S01/T01', 'agent-a');
+
+    assert.equal(checkOwnership(base, 'M001/S01/T01', 'agent-a'), null);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('checkOwnership: returns error string when actor does not match owner', () => {
+  const base = makeTmpBase();
+  try {
+    claimUnit(base, 'M001/S01/T01', 'agent-a');
+
+    const err = checkOwnership(base, 'M001/S01/T01', 'agent-b');
+    assert.ok(err !== null, 'should return error');
+    assert.match(err!, /owned by agent-a/);
+    assert.match(err!, /not agent-b/);
+  } finally {
+    cleanup(base);
+  }
+});