@iceinvein/agent-skills 0.1.39 → 0.2.0

package/skills/migrate/scripts/__tests__/run-state.test.ts

@@ -0,0 +1,136 @@
+import { afterEach, beforeEach, expect, test } from 'bun:test'
+import { mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { runCheck } from '../check.ts'
+
+let root: string
+let source: string
+
+async function init(): Promise<void> {
+  const { runInit } = await import('../init-cmd.ts')
+  const code = await runInit({
+    root,
+    sourcePath: source,
+    scope: 'run-state fixture',
+    targetName: 'target',
+  })
+  expect(code).toBe(0)
+}
+
+async function setPhases(states: Record<string, unknown>): Promise<void> {
+  const all: Record<string, unknown> = {}
+  for (const p of [
+    'probe',
+    'enumerate',
+    'seam',
+    'extract',
+    'parity',
+    'queue',
+    'adjudicate',
+    'handoff',
+  ]) {
+    all[p] = { status: 'pending', batches: [], pending: [], ...(states[p] as object) }
+  }
+  await writeFile(
+    join(root, '.migrate', 'phases.json'),
+    JSON.stringify({ version: 1, phases: all }),
+  )
+}
+
+beforeEach(async () => {
+  root = await mkdtemp(join(tmpdir(), 'migrate-runstate-'))
+  source = join(root, 'legacy')
+  await Bun.write(join(source, 'app.js'), '// legacy\n')
+  await init()
+})
+
+afterEach(async () => {
+  await rm(root, { recursive: true, force: true })
+})
+
+test('a store nobody worked in fails run-state once per phase', async () => {
+  const result = await runCheck({ root })
+  const runState = result.violations.filter((v) => v.gate === 'run-state')
+  expect(runState.length).toBe(8)
+  expect(runState.some((v) => v.message.includes('probe is pending'))).toBe(true)
+  expect(runState.some((v) => v.message.includes('handoff is pending'))).toBe(true)
+})
+
+test('--phase bounds run-state at the named phase', async () => {
+  await setPhases({ probe: { status: 'done' } })
+  const result = await runCheck({ root, phase: 'probe' })
+  expect(result.violations.filter((v) => v.gate === 'run-state').length).toBe(0)
+})
+
+test('--phase still fails when a phase at or below the terminus is short of done', async () => {
+  await setPhases({ probe: { status: 'done' }, enumerate: { status: 'running' } })
+  const result = await runCheck({ root, phase: 'enumerate' })
+  const runState = result.violations.filter((v) => v.gate === 'run-state')
+  expect(runState.length).toBe(1)
+  expect(runState[0]?.message).toContain('enumerate is running')
+})
+
+test('a phase marked done above a pending predecessor is named', async () => {
+  await setPhases({ seam: { status: 'done' } })
+  const result = await runCheck({ root })
+  const runState = result.violations.filter((v) => v.gate === 'run-state')
+  expect(
+    runState.some((v) => v.message.includes('seam is done while enumerate is still pending')),
+  ).toBe(true)
+})
+
+test('a lens census naming an uncommitted batch is named', async () => {
+  await setPhases({
+    probe: { status: 'done' },
+    enumerate: { status: 'done', batches: [{ id: 'b-other-001', count: 1 }] },
+  })
+  await writeFile(
+    join(root, '.migrate', 'census.jsonl'),
+    `${JSON.stringify({
+      kind: 'lens',
+      surface: 'routes',
+      phase: 'enumerate',
+      directions: {
+        code: { count: 0, evidence: 'rg -n "app.(get|post)" app.js' },
+        nav: { count: 0, evidence: 'manual review of route registrations' },
+      },
+      total: 0,
+      in_ledger: 0,
+      added: 0,
+      skipped: [],
+      queued: [],
+      batch: 'b-routes-census-001',
+    })}\n`,
+  )
+  const result = await runCheck({ root, phase: 'enumerate' })
+  const runState = result.violations.filter((v) => v.gate === 'run-state')
+  expect(runState.some((v) => v.message.includes('b-routes-census-001'))).toBe(true)
+})
+
+test('citations run by default and can be turned off', async () => {
+  await writeFile(
+    join(root, '.migrate', 'capabilities.jsonl'),
+    `${JSON.stringify({ slug: 'core', title: 'Core', ns: 'core', elements: [] })}\n`,
+  )
+  await writeFile(
+    join(root, '.migrate', 'requirements.jsonl'),
+    `${JSON.stringify({
+      id: 'UM-001',
+      cap: 'core',
+      requirement: 'r',
+      actors: 'a',
+      objects: 'o',
+      rules: 'x',
+      origin: 'intended',
+      confidence: { kind: 'confirmed' },
+      citations: [{ kind: 'src', path: 'Gone.cs' }],
+      parity: { kind: 'rubric', level: 'high' },
+      batch: 'b-001',
+    })}\n`,
+  )
+  const on = await runCheck({ root })
+  expect(on.violations.some((v) => v.gate === 'citations')).toBe(true)
+  const off = await runCheck({ root, citations: false })
+  expect(off.violations.some((v) => v.gate === 'citations')).toBe(false)
+})

package/skills/migrate/scripts/__tests__/status-reset.test.ts

@@ -0,0 +1,318 @@
+import { afterEach, beforeEach, expect, test } from 'bun:test'
+import { existsSync } from 'node:fs'
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { writeConfig } from '../config.ts'
+import { storePaths } from '../paths.ts'
+import { loadPhases, recordBatch, setPhaseStatus } from '../phases.ts'
+import { loadQueue } from '../queue.ts'
+import { runReset } from '../reset-cmd.ts'
+import { runStatus } from '../status-cmd.ts'
+import { readRows, writeRows } from '../store.ts'
+import type { Capability, Census, Delta, Element, Requirement } from '../types.ts'
+
+let root: string
+let source: string
+
+beforeEach(async () => {
+  root = await mkdtemp(join(tmpdir(), 'migrate-status-'))
+  source = join(root, 'legacy')
+  await mkdir(join(root, '.migrate', 'queue'), { recursive: true })
+  await mkdir(source, { recursive: true })
+  await writeConfig(root, { sourcePath: source, scope: 'all', targetName: 'newapp' })
+})
+
+afterEach(async () => {
+  await rm(root, { recursive: true, force: true })
+})
+
+const ELEMENT: Element = {
+  id: 'route-a',
+  surface: 'routes',
+  element: 'GET /a',
+  found_by: ['code'],
+  disposition: { kind: 'mapped', fr: 'UM-001' },
+  refs: [],
+  lens: 'code',
+  batch: 'b-1',
+  notes: '',
+}
+
+const REQUIREMENT: Requirement = {
+  id: 'UM-001',
+  cap: 'user-management',
+  requirement: 'List',
+  actors: '-',
+  objects: '-',
+  rules: '-',
+  origin: 'intended',
+  confidence: { kind: 'confirmed' },
+  citations: [{ kind: 'ledger', id: 'route-a' }],
+  parity: { kind: 'rubric', level: 'high' },
+  batch: 'b-1',
+}
+
+const LENS_CENSUS: Census = {
+  kind: 'lens',
+  surface: 'routes',
+  phase: 'enumerate',
+  directions: {
+    code: { count: 1, evidence: 'rg -n "app.(get|post)" app.js' },
+    nav: { count: 1, evidence: 'manual review of route registrations' },
+  },
+  total: 1,
+  in_ledger: 1,
+  added: 0,
+  skipped: [],
+  queued: [],
+  batch: 'b-1',
+}
+
+const ATTR_CENSUS: Census = {
+  kind: 'attribute',
+  surface: 'tables',
+  subject: 'table-a',
+  phase: 'enumerate',
+  directions: {
+    ddl: { count: 3, evidence: 'rg -n "CREATE TABLE" schema.sql' },
+    code: { count: 3, evidence: 'rg -n "table-a" app.js' },
+  },
+  total: 3,
+  behavioral: 1,
+  explained: 1,
+  queued: [],
+  batch: 'b-2',
+}
+
+const CAPABILITY: Capability = {
+  slug: 'user-management',
+  title: 'User management',
+  ns: 'UM',
+  elements: ['route-a'],
+}
+
+const DELTA: Delta = {
+  id: 'delta-1',
+  scope: 'user-management',
+  rationale: 'legacy quirk not worth replicating',
+  parity_exclusion: 'silent 500 on double-submit',
+  validation: 'manual review',
+  owner_signed: 'jane@example.com',
+  batch: 'b-1',
+}
+
+const QUEUE_ITEM = `---
+id: q-invoice-batch-scope
+severity: moderate
+status: open
+---
+
+## Evidence
+
+Route POST /api/invoice/batch found in InvoiceController.cs:215-240.
+
+## Options
+
+(a) Replicate as-is. (b) Harden it. (c) Mark out of scope.
+
+## Recommendation
+
+Recommend (c); three invocations in six months.
+`
+
+async function writeQueueItem(root: string): Promise<string> {
+  const path = join(storePaths(root).queueDir, 'q-invoice-batch-scope.md')
+  await writeFile(path, QUEUE_ITEM)
+  return path
+}
+
+test('reset extract clears requirements and returns dispositions to unaccounted', async () => {
+  const p = storePaths(root)
+  await writeRows(p.elements, [ELEMENT], source)
+  await writeRows(p.requirements, [REQUIREMENT], source)
+  await writeRows(p.census, [LENS_CENSUS, ATTR_CENSUS], source)
+  await setPhaseStatus(root, 'extract', 'done', source)
+
+  expect(await runReset({ root, phase: 'extract' })).toBe(0)
+
+  expect(await readRows<Requirement>(p.requirements)).toEqual([])
+  const elements = await readRows<Element>(p.elements)
+  expect(elements[0]?.disposition).toEqual({ kind: 'unaccounted' })
+  const census = await readRows<Census>(p.census)
+  expect(census.map((c) => c.kind)).toEqual(['lens'])
+  expect((await loadPhases(root)).extract.status).toBe('pending')
+})
+
+test('reset enumerate clears elements and lens census but leaves attribute census', async () => {
+  const p = storePaths(root)
+  await writeRows(p.elements, [ELEMENT], source)
+  await writeRows(p.census, [LENS_CENSUS, ATTR_CENSUS], source)
+  await recordBatch(root, 'enumerate', { id: 'b-1', count: 1 }, source)
+
+  expect(await runReset({ root, phase: 'enumerate' })).toBe(0)
+
+  expect(await readRows(p.elements)).toEqual([])
+  expect((await readRows<Census>(p.census)).map((c) => c.kind)).toEqual(['attribute'])
+  const phases = await loadPhases(root)
+  expect(phases.enumerate.status).toBe('pending')
+  expect(phases.enumerate.batches).toEqual([])
+})
+
+test('reset rejects an unknown phase', async () => {
+  expect(await runReset({ root, phase: 'seams' })).toBe(2)
+})
+
+test('reset seam clears capabilities and seam files but leaves elements and requirements alone', async () => {
+  const p = storePaths(root)
+  await writeRows(p.elements, [ELEMENT], source)
+  await writeRows(p.requirements, [REQUIREMENT], source)
+  await writeRows(p.capabilities, [CAPABILITY], source)
+  await writeFile(p.seamJson, '{"capabilities":[]}\n')
+  await writeFile(p.seamMd, '# Seam\n')
+  await setPhaseStatus(root, 'seam', 'done', source)
+
+  expect(await runReset({ root, phase: 'seam' })).toBe(0)
+
+  expect(await readRows<Capability>(p.capabilities)).toEqual([])
+  expect(existsSync(p.seamJson)).toBe(false)
+  expect(existsSync(p.seamMd)).toBe(false)
+  expect(await readRows<Element>(p.elements)).toEqual([ELEMENT])
+  expect(await readRows<Requirement>(p.requirements)).toEqual([REQUIREMENT])
+  expect((await loadPhases(root)).seam.status).toBe('pending')
+})
+
+test('reset parity clears deltas and nulls every requirement parity but leaves elements alone', async () => {
+  const p = storePaths(root)
+  const other: Requirement = {
+    ...REQUIREMENT,
+    id: 'UM-002',
+    parity: { kind: 'golden-master', ref: 'gm-1' },
+  }
+  await writeRows(p.elements, [ELEMENT], source)
+  await writeRows(p.requirements, [REQUIREMENT, other], source)
+  await writeRows(p.deltas, [DELTA], source)
+  await setPhaseStatus(root, 'parity', 'done', source)
+
+  expect(await runReset({ root, phase: 'parity' })).toBe(0)
+
+  expect(await readRows<Delta>(p.deltas)).toEqual([])
+  const reqs = await readRows<Requirement>(p.requirements)
+  expect(reqs.map((r) => r.parity)).toEqual([null, null])
+  expect(await readRows<Element>(p.elements)).toEqual([ELEMENT])
+  expect((await loadPhases(root)).parity.status).toBe('pending')
+})
+
+test('reset on a phase that owns no rows resets only its state, touching no store file', async () => {
+  const p = storePaths(root)
+  await writeRows(p.elements, [ELEMENT], source)
+  await writeRows(p.requirements, [REQUIREMENT], source)
+  await writeRows(p.capabilities, [CAPABILITY], source)
+  await writeRows(p.deltas, [DELTA], source)
+  await writeRows(p.census, [LENS_CENSUS, ATTR_CENSUS], source)
+  await recordBatch(root, 'probe', { id: 'b-1', count: 1 }, source)
+
+  expect(await runReset({ root, phase: 'probe' })).toBe(0)
+
+  expect(await readRows<Element>(p.elements)).toEqual([ELEMENT])
+  expect(await readRows<Requirement>(p.requirements)).toEqual([REQUIREMENT])
+  expect(await readRows<Capability>(p.capabilities)).toEqual([CAPABILITY])
+  expect(await readRows<Delta>(p.deltas)).toEqual([DELTA])
+  expect((await readRows<Census>(p.census)).map((c) => c.kind)).toEqual(['lens', 'attribute'])
+  const phases = await loadPhases(root)
+  expect(phases.probe.status).toBe('pending')
+  expect(phases.probe.batches).toEqual([])
+})
+
+test('reset never touches queue items, regardless of which phase is reset', async () => {
+  const queuePath = await writeQueueItem(root)
+  const p = storePaths(root)
+  await writeRows(p.elements, [ELEMENT], source)
+  await writeRows(p.requirements, [REQUIREMENT], source)
+  await writeRows(p.capabilities, [CAPABILITY], source)
+  await writeRows(p.deltas, [DELTA], source)
+  await writeRows(p.census, [LENS_CENSUS, ATTR_CENSUS], source)
+
+  for (const phase of ['enumerate', 'seam', 'extract', 'parity', 'probe'] as const) {
+    expect(await runReset({ root, phase })).toBe(0)
+  }
+
+  expect(existsSync(queuePath)).toBe(true)
+  const { items, errors } = await loadQueue(p.queueDir)
+  expect(errors).toEqual([])
+  expect(items.map((i) => i.id)).toEqual(['q-invoice-batch-scope'])
+})
+
+async function captureStdout(fn: () => Promise<number>): Promise<{ code: number; text: string }> {
+  const out: string[] = []
+  const original = process.stdout.write.bind(process.stdout)
+  process.stdout.write = ((s: string) => {
+    out.push(s)
+    return true
+  }) as typeof process.stdout.write
+  try {
+    const code = await fn()
+    return { code, text: out.join('') }
+  } finally {
+    process.stdout.write = original
+  }
+}
+
+test('status names the first non-done phase and its last batch as the resume pointer', async () => {
+  const p = storePaths(root)
+  await writeRows(p.elements, [ELEMENT], source)
+  await writeRows(p.requirements, [REQUIREMENT], source)
+  await setPhaseStatus(root, 'probe', 'done', source)
+  await recordBatch(root, 'enumerate', { id: 'b-1', count: 1 }, source)
+  await setPhaseStatus(root, 'enumerate', 'done', source)
+  await recordBatch(root, 'seam', { id: 'b-2', count: 2 }, source)
+
+  const { code, text } = await captureStdout(() => runStatus({ root }))
+
+  expect(code).toBe(0)
+  expect(text).toContain('probe       done')
+  expect(text).toContain('enumerate   done (1 batch(es))')
+  expect(text).toContain('seam        running (1 batch(es))')
+  expect(text).toContain('1 requirement(s), 1 element(s)')
+  expect(text).toContain('resume: seam, last batch b-2 (2 row(s))')
+})
+
+test('status reports all phases done when nothing is left to resume', async () => {
+  const phases = await loadPhases(root)
+  for (const phase of Object.keys(phases) as (keyof typeof phases)[]) {
+    await setPhaseStatus(root, phase, 'done', source)
+  }
+
+  const { code, text } = await captureStdout(() => runStatus({ root }))
+
+  expect(code).toBe(0)
+  expect(text).toContain('resume: all phases done')
+})
+
+async function captureStderr(fn: () => Promise<number>): Promise<{ code: number; text: string }> {
+  const out: string[] = []
+  const original = process.stderr.write.bind(process.stderr)
+  process.stderr.write = ((s: string) => {
+    out.push(s)
+    return true
+  }) as typeof process.stderr.write
+  try {
+    const code = await fn()
+    return { code, text: out.join('') }
+  } finally {
+    process.stderr.write = original
+  }
+}
+
+// Important finding 3: `check` and `queue list` already flag a malformed
+// queue item and exit 1 for the identical condition; status used to print
+// its counts at exit 0 with no mention of it at all, which reads as "the
+// store is fine" when part of it could not even be read.
+test('status surfaces a malformed queue item on stderr and exits 1, not silently 0', async () => {
+  await writeFile(join(storePaths(root).queueDir, 'q-broken.md'), 'not a queue item at all')
+
+  const { code, text } = await captureStderr(() => runStatus({ root }))
+
+  expect(code).toBe(1)
+  expect(text).toContain('q-broken.md')
+})

package/skills/migrate/scripts/__tests__/store.test.ts

@@ -0,0 +1,132 @@
+import { afterEach, beforeEach, expect, test } from 'bun:test'
+import { mkdir, mkdtemp, readdir, readFile, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { readRawRows, readRows, upsertRows, writeRows } from '../store.ts'
+
+let root: string
+const NO_SOURCE = '/nonexistent-source'
+
+beforeEach(async () => {
+  root = await mkdtemp(join(tmpdir(), 'migrate-store-'))
+})
+
+afterEach(async () => {
+  await rm(root, { recursive: true, force: true })
+})
+
+test('readRows returns empty for a missing file', async () => {
+  expect(await readRows(join(root, 'nope.jsonl'))).toEqual([])
+})
+
+test('write then read round-trips and ignores blank lines', async () => {
+  const path = join(root, 'x.jsonl')
+  await writeRows(
+    path,
+    [
+      { id: 'a', n: 1 },
+      { id: 'b', n: 2 },
+    ],
+    NO_SOURCE,
+  )
+  const text = await readFile(path, 'utf8')
+  expect(text.endsWith('\n')).toBe(true)
+  expect(await readRows(path)).toEqual([
+    { id: 'a', n: 1 },
+    { id: 'b', n: 2 },
+  ])
+})
+
+test('readRows names the offending line on malformed JSON', async () => {
+  const path = join(root, 'bad.jsonl')
+  await writeFile(path, '{"id":"a"}\nnot json\n')
+  await expect(readRows(path)).rejects.toThrow(/line 2/)
+})
+
+// readRawRows is readRows's own foundation now, but check.ts is the only
+// caller that needs the line number rather than just the parsed value, so
+// this pins that contract directly instead of leaving it to be exercised
+// only indirectly through check.ts's gate tests. A blank line shifts every
+// line number after it, which is exactly the case a 1-based index computed
+// from the filtered array (rather than the original split) would get wrong.
+test('readRawRows pairs each parsed value with its 1-based line number, including across a blank line', async () => {
+  const path = join(root, 'y.jsonl')
+  await writeFile(path, '{"id":"a"}\n\n{"id":"b"}\n')
+  expect(await readRawRows(path)).toEqual([
+    { line: 1, raw: { id: 'a' } },
+    { line: 3, raw: { id: 'b' } },
+  ])
+})
+
+test('readRawRows returns empty for a missing file', async () => {
+  expect(await readRawRows(join(root, 'nope.jsonl'))).toEqual([])
+})
+
+test('upsertRows replaces by id in place and counts', () => {
+  const existing = [
+    { id: 'a', n: 1 },
+    { id: 'b', n: 2 },
+  ]
+  const result = upsertRows(existing, [
+    { id: 'b', n: 99 },
+    { id: 'c', n: 3 },
+  ])
+  expect(result.rows).toEqual([
+    { id: 'a', n: 1 },
+    { id: 'b', n: 99 },
+    { id: 'c', n: 3 },
+  ])
+  expect(result.added).toBe(1)
+  expect(result.updated).toBe(1)
+})
+
+test('re-importing an identical batch is idempotent', () => {
+  const batch = [{ id: 'a', n: 1 }]
+  const once = upsertRows([], batch)
+  const twice = upsertRows(once.rows, batch)
+  expect(twice.rows).toEqual(once.rows)
+  expect(twice.added).toBe(0)
+})
+
+test('writeRows refuses a path inside the source tree', async () => {
+  const source = join(root, 'legacy')
+  await expect(writeRows(join(source, 'x.jsonl'), [], source)).rejects.toThrow(/source/)
+})
+
+test('upsertRows handles repeated ids in incoming batch', () => {
+  const existing = [{ id: 'a', n: 0 }]
+  const result = upsertRows(existing, [
+    { id: 'a', n: 1 },
+    { id: 'a', n: 2 },
+  ])
+  expect(result.rows).toEqual([{ id: 'a', n: 2 }])
+  expect(result.added).toBe(0)
+  expect(result.updated).toBe(1)
+})
+
+test('updated count is insensitive to key order', () => {
+  const existing = [{ id: 'a', x: 1, y: 2 }]
+  const result = upsertRows(existing, [{ id: 'a', y: 2, x: 1 }])
+  expect(result.rows).toEqual([{ id: 'a', y: 2, x: 1 }])
+  expect(result.added).toBe(0)
+  expect(result.updated).toBe(0)
+})
+
+test('concurrent writes to same path do not collide', async () => {
+  const path = join(root, 'concurrent.jsonl')
+  await Promise.all([
+    writeRows(path, [{ id: 'a', n: 1 }], NO_SOURCE),
+    writeRows(path, [{ id: 'b', n: 2 }], NO_SOURCE),
+  ])
+  const rows = await readRows(path)
+  expect(rows.length).toBe(1)
+})
+
+test('writeRows cleans up temp file on failure', async () => {
+  const dir = join(root, 'target-dir')
+  await mkdir(dir)
+  await expect(writeRows(dir, [{ id: 'a', n: 1 }], NO_SOURCE)).rejects.toThrow()
+  const files = await readdir(root)
+  const tmpFiles = files.filter((f) => f.endsWith('.tmp'))
+  expect(tmpFiles.length).toBe(0)
+})

package/skills/migrate/scripts/__tests__/validate.test.ts

@@ -0,0 +1,54 @@
+import { expect, test } from 'bun:test'
+import type { Config } from '../config.ts'
+import { validateDelta, validateElement, validateRequirement } from '../validate.ts'
+
+const CFG: Config = {
+  source: {
+    path: '/tmp/legacy',
+    scope: 'all',
+    stack: 'unknown',
+    vcs: 'none',
+    basis: 'source-only',
+  },
+  target: { name: 'newapp', stack: 'unknown', parity_test_path: 'x', layout: {}, commands: {} },
+  surfaces: ['routes'],
+  surfaceSingular: {},
+  closers: [],
+  handoff: { adapter: 'markdown' },
+}
+
+test('validateElement rejects a null row instead of throwing', () => {
+  const result = validateElement(null, CFG)
+  expect(result.ok).toBe(false)
+  if (!result.ok) expect(result.errors.join(' ')).toContain('object')
+})
+
+test('validateElement rejects a non-object row instead of throwing', () => {
+  const result = validateElement('not a row', CFG)
+  expect(result.ok).toBe(false)
+  if (!result.ok) expect(result.errors.join(' ')).toContain('object')
+})
+
+test('validateRequirement rejects a null row instead of throwing', () => {
+  const result = validateRequirement(null, CFG)
+  expect(result.ok).toBe(false)
+  if (!result.ok) expect(result.errors.join(' ')).toContain('object')
+})
+
+test('validateRequirement rejects a non-object row instead of throwing', () => {
+  const result = validateRequirement(42, CFG)
+  expect(result.ok).toBe(false)
+  if (!result.ok) expect(result.errors.join(' ')).toContain('object')
+})
+
+test('validateDelta rejects a null row instead of throwing', () => {
+  const result = validateDelta(null, CFG)
+  expect(result.ok).toBe(false)
+  if (!result.ok) expect(result.errors.join(' ')).toContain('object')
+})
+
+test('validateDelta rejects a non-object row instead of throwing', () => {
+  const result = validateDelta(['not', 'a', 'row'], CFG)
+  expect(result.ok).toBe(false)
+  if (!result.ok) expect(result.errors.join(' ')).toContain('object')
+})