mixdog 0.9.62 → 0.9.64

package/scripts/memory-core-input-test.mjs

@@ -1,167 +0,0 @@
-import test from 'node:test'
-import assert from 'node:assert/strict'
-import { mkdtemp, mkdir, writeFile, rm } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { normalizeCoreInput } from '../src/runtime/memory/lib/core-memory-store.mjs'
-import { createMemoryActionHandlers } from '../src/runtime/memory/lib/memory-action-handlers.mjs'
-import { TOOL_DEFS as MEMORY_TOOL_DEFS } from '../src/runtime/memory/tool-defs.mjs'
-import { parseMemoryCandidateRows, parseMemoryCoreRows } from '../src/tui/app/input-parsers.mjs'
-import { memoryToolArgsForCaller } from '../src/session-runtime/runtime-core.mjs'
-
-test('memory mutation schema omits category while recall keeps its internal filter', () => {
-  const memoryTool = MEMORY_TOOL_DEFS.find((tool) => tool.name === 'memory')
-  const recallTool = MEMORY_TOOL_DEFS.find((tool) => tool.name === 'recall')
-  assert.equal(Object.hasOwn(memoryTool.inputSchema.properties, 'category'), false)
-  assert.doesNotMatch(memoryTool.description, /category/i)
-  assert.equal(Object.hasOwn(recallTool.inputSchema.properties, 'category'), true)
-})
-
-test('memory tool calls inherit the active caller cwd only when cwd is omitted', () => {
-  assert.deepEqual(memoryToolArgsForCaller({ action: 'status' }, '/active/project'), {
-    action: 'status',
-    cwd: '/active/project',
-  })
-  const explicit = { action: 'status', cwd: '/explicit/project' }
-  assert.equal(memoryToolArgsForCaller(explicit, '/active/project'), explicit)
-})
-
-test('core content aliases summary, derives an element, and accepts no category', () => {
-  const content = 'A durable preference that callers should receive concise answers.'
-  const input = normalizeCoreInput({ content }, {
-    requireElement: true,
-    requireSummary: true,
-    requireCategory: false,
-  })
-  assert.equal(input.summary, content)
-  assert.equal(input.element, content.slice(0, 40))
-  assert.equal(input.category, 'fact')
-  assert.deepEqual(input.errors, [])
-})
-
-test('core add reports every invalid field and cwd project hint together', async () => {
-  const cwd = await mkdtemp(join(tmpdir(), 'mixdog-core-input-'))
-  await mkdir(join(cwd, '.mixdog'))
-  await writeFile(join(cwd, '.mixdog', 'project.id'), 'owner/repo\n')
-  try {
-    const { handleMemoryAction } = createMemoryActionHandlers({
-      getDb: () => ({}),
-      dataDir: cwd,
-      readMainConfig: () => ({}),
-    })
-    const result = await handleMemoryAction({
-      action: 'core',
-      op: 'add',
-      cwd,
-      element: 'x'.repeat(41),
-      summary: 'y'.repeat(101),
-    })
-    assert.equal(result.isError, true)
-    assert.equal(
-      result.text,
-      'core add: project_id required — pass "common" for COMMON pool, or project slug like "owner/repo" for scoped pool (cwd suggests "owner/repo"); element too long (41/40 chars, remove 1); summary too long (101/100 chars, remove 1)',
-    )
-  } finally {
-    await rm(cwd, { recursive: true, force: true })
-  }
-})
-
-test('core add rejects blank project_id in the batched error', async () => {
-  const { handleMemoryAction } = createMemoryActionHandlers({
-    getDb: () => ({}),
-    dataDir: tmpdir(),
-    readMainConfig: () => ({}),
-  })
-  const result = await handleMemoryAction({
-    action: 'core',
-    op: 'add',
-    project_id: ' ',
-    element: 'x'.repeat(41),
-    summary: 'y'.repeat(101),
-  })
-  assert.equal(result.isError, true)
-  assert.match(result.text, /^core add: project_id required —/)
-  assert.match(result.text, /element too long \(41\/40 chars, remove 1\)/)
-  assert.match(result.text, /summary too long \(101\/100 chars, remove 1\)/)
-})
-
-test('core add folds project_id "*" into the batched error', async () => {
-  const { handleMemoryAction } = createMemoryActionHandlers({
-    getDb: () => ({}),
-    dataDir: tmpdir(),
-    readMainConfig: () => ({}),
-  })
-  const result = await handleMemoryAction({
-    action: 'core',
-    op: 'add',
-    project_id: '*',
-    element: 'x'.repeat(41),
-    summary: 'y'.repeat(101),
-  })
-  assert.equal(result.isError, true)
-  assert.match(result.text, /^core add: project_id "\*" only valid for op="list"; element too long/)
-  assert.match(result.text, /summary too long \(101\/100 chars, remove 1\)/)
-})
-
-test('core add suppresses malformed cwd project hints', async () => {
-  const cwd = await mkdtemp(join(tmpdir(), 'mixdog-core-input-'))
-  await mkdir(join(cwd, '.mixdog'))
-  await writeFile(join(cwd, '.mixdog', 'project.id'), '/absolute/path\n')
-  try {
-    const { handleMemoryAction } = createMemoryActionHandlers({
-      getDb: () => ({}),
-      dataDir: cwd,
-      readMainConfig: () => ({}),
-    })
-    const result = await handleMemoryAction({
-      action: 'core',
-      op: 'add',
-      cwd,
-      element: 'durable preference',
-      summary: 'Callers prefer concise answers.',
-    })
-    assert.equal(result.text, 'core add: project_id required — pass "common" for COMMON pool, or project slug like "owner/repo" for scoped pool')
-  } finally {
-    await rm(cwd, { recursive: true, force: true })
-  }
-})
-
-test('core edit by id succeeds without project_id', async () => {
-  let call
-  const { handleMemoryAction } = createMemoryActionHandlers({
-    getDb: () => ({}),
-    dataDir: tmpdir(),
-    readMainConfig: () => ({}),
-    editCoreImpl: async (dataDir, id, patch) => {
-      call = { dataDir, id, patch }
-      return { id: Number(id), element: patch.element, summary: patch.summary, category: 'preference' }
-    },
-  })
-  const result = await handleMemoryAction({
-    action: 'core',
-    op: 'edit',
-    id: 7,
-    element: 'reply style',
-    summary: 'Use concise answers.',
-  })
-  assert.equal(result.isError, undefined)
-  assert.equal(result.text, 'core edited (id=7): reply style — Use concise answers.')
-  assert.equal(call.id, 7)
-  assert.equal(call.patch.project_id, undefined)
-  assert.equal(call.patch.category, undefined)
-})
-
-test('category-free core and candidate rows remain selectable in the TUI', () => {
-  const [core] = parseMemoryCoreRows('COMMON:\nid=7 reply style — Use concise answers.')
-  assert.equal(core._id, 7)
-  assert.equal(core._element, 'reply style')
-  assert.equal(core._summary, 'Use concise answers.')
-  assert.equal(Object.hasOwn(core, '_category'), false)
-
-  const [candidate] = parseMemoryCandidateRows(
-    'id=9 project=COMMON score=1.60 coding agent refs — Use C:\\Project\\refs. (durable)',
-  )
-  assert.equal(candidate._id, 9)
-  assert.equal(candidate.label, '#9 coding agent refs')
-  assert.equal(candidate._projectId, null)
-})

package/scripts/memory-cycle-routing-test.mjs

@@ -1,111 +0,0 @@
-import test from 'node:test'
-import assert from 'node:assert/strict'
-import { resolveMaintenancePreset } from '../src/runtime/shared/llm/index.mjs'
-import { sonnetCascade } from '../src/runtime/memory/lib/memory-cycle2-gate.mjs'
-import { runPhaseMerge } from '../src/runtime/memory/lib/memory-cycle2-mutations.mjs'
-import { invokeCycle3Maintenance } from '../src/runtime/memory/lib/memory-cycle3.mjs'
-
-test('cycle2 cascade uses the memory maintenance route', async () => {
-  const expected = resolveMaintenancePreset('memory')
-  let received
-  await sonnetCascade(
-    [{ id: 1, status: 'pending', verb: 'active', category: 'fact', element: 'x', summary: 'y' }],
-    '',
-    {
-      callLlm: (opts) => {
-        received = opts
-        return '1|keep'
-      },
-    },
-  )
-  assert.deepEqual(received.preset, expected)
-  assert.equal(received.mode, 'cycle2-cascade')
-})
-
-test('cycle2 cascade preserves an explicit test override', async () => {
-  let received
-  await sonnetCascade(
-    [{ id: 1, status: 'pending', verb: 'active', category: 'fact', element: 'x', summary: 'y' }],
-    '',
-    {
-      cascadePreset: 'test-route',
-      callLlm: (opts) => {
-        received = opts
-        return '1|keep'
-      },
-    },
-  )
-  assert.equal(received.preset, 'test-route')
-})
-
-test('cycle2 phase merge judge dispatches through the memory maintenance route', async () => {
-  const expected = resolveMaintenancePreset('memory')
-  let received
-  const db = {
-    query: async () => ({ rows: [] }),
-  }
-  db.query = async (sql) => {
-    if (sql.includes('WITH active AS')) {
-      return {
-        rows: [{
-          a_id: 1, a_category: 'fact', a_summary: 'a', a_score: 1, a_last_seen_at: 1, a_status: 'active',
-          b_id: 2, b_category: 'fact', b_summary: 'b', b_score: 1, b_last_seen_at: 1, b_status: 'active',
-          sim: 0.8,
-        }],
-      }
-    }
-    return { rows: [] }
-  }
-  const result = await runPhaseMerge(db, {
-    callLlm: (opts) => {
-      received = opts
-      return 'distinct'
-    },
-  })
-  assert.equal(result.llm_calls, 1)
-  assert.deepEqual(received.preset, expected)
-  assert.equal(received.mode, 'cycle2-phase_merge_judge')
-})
-
-test('cycle2 phase merge preserves an explicit test override', async () => {
-  let received
-  const db = {
-    query: async (sql) => (sql.includes('WITH active AS')
-      ? { rows: [{ a_id: 1, a_category: 'fact', a_summary: 'a', a_score: 1, a_last_seen_at: 1, a_status: 'active', b_id: 2, b_category: 'fact', b_summary: 'b', b_score: 1, b_last_seen_at: 1, b_status: 'active', sim: 0.8 }] }
-      : { rows: [] }),
-  }
-  await runPhaseMerge(db, {
-    preset: 'test-route',
-    callLlm: (opts) => {
-      received = opts
-      return 'distinct'
-    },
-  })
-  assert.equal(received.preset, 'test-route')
-})
-
-test('cycle3 dispatches through the memory maintenance route', async () => {
-  const expected = resolveMaintenancePreset('memory')
-  let received
-  await invokeCycle3Maintenance('test prompt', {
-    callLlm: (opts) => {
-      received = opts
-      return '1|keep'
-    },
-  })
-  assert.deepEqual(received.preset, expected)
-  assert.equal(received.agent, 'cycle3-agent')
-  assert.equal(received.mode, 'cycle3-review')
-})
-
-test('cycle3 preserves an explicit test override', async () => {
-  let received
-  await invokeCycle3Maintenance('test prompt', {
-    preset: 'test-route',
-    callLlm: (opts) => {
-      received = opts
-      return '1|keep'
-    },
-  })
-  assert.equal(received.preset, 'test-route')
-})

package/scripts/memory-meta-concurrency-test.mjs

@@ -1,20 +0,0 @@
-#!/usr/bin/env node
-// Regression: mergeMetaValue uses jsonb shallow merge (not full replace).
-import test from 'node:test'
-import assert from 'node:assert/strict'
-import { mergeMetaValue } from '../src/runtime/memory/lib/memory.mjs'
-
-test('mergeMetaValue issues INSERT ... ON CONFLICT DO UPDATE with jsonb ||', async () => {
-  const calls = []
-  const db = {
-    async query(sql, params) {
-      calls.push({ sql, params })
-    },
-  }
-  await mergeMetaValue(db, 'state.cycle_last_run', { cycle1: 100, cycle2_last_error: '' })
-  assert.equal(calls.length, 1)
-  assert.match(calls[0].sql, /COALESCE\(meta\.value/)
-  assert.match(calls[0].sql, /\|\| EXCLUDED\.value/)
-  assert.deepEqual(calls[0].params, ['state.cycle_last_run', '{"cycle1":100,"cycle2_last_error":""}'])
-})
-

package/scripts/memory-pg-recovery-test.mjs

@@ -1,59 +0,0 @@
-import assert from 'node:assert/strict'
-import { EventEmitter } from 'node:events'
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import test from 'node:test'
-
-import {
-  installPoolErrorHandler,
-  isPgConnectionLossError,
-} from '../src/runtime/memory/lib/pg/adapter.mjs'
-import { startPg } from '../src/runtime/memory/lib/pg/process.mjs'
-
-test('checked-out pg clients always retain an error listener', () => {
-  const priorQuiet = process.env.MIXDOG_QUIET_MEMORY_LOG
-  process.env.MIXDOG_QUIET_MEMORY_LOG = '1'
-  try {
-    const pool = new EventEmitter()
-    const client = new EventEmitter()
-    installPoolErrorHandler(pool, 'test-pool')
-    pool.emit('connect', client)
-    pool.emit('connect', client)
-
-    assert.equal(client.listenerCount('error'), 1)
-    assert.doesNotThrow(() => {
-      client.emit('error', new Error('Connection terminated unexpectedly'))
-    })
-  } finally {
-    if (priorQuiet == null) delete process.env.MIXDOG_QUIET_MEMORY_LOG
-    else process.env.MIXDOG_QUIET_MEMORY_LOG = priorQuiet
-  }
-})
-
-test('postgres connection-loss classifier covers reset and server termination', () => {
-  assert.equal(isPgConnectionLossError(Object.assign(new Error('read ECONNRESET'), { code: 'ECONNRESET' })), true)
-  assert.equal(isPgConnectionLossError(new Error('Connection terminated unexpectedly')), true)
-  assert.equal(isPgConnectionLossError(Object.assign(new Error('admin shutdown'), { code: '57P01' })), true)
-  assert.equal(isPgConnectionLossError(new Error('duplicate key value violates unique constraint')), false)
-})
-
-test('startPg refuses a second start while postmaster.pid owner is alive but not ready', async () => {
-  const root = mkdtempSync(join(tmpdir(), 'mixdog-pg-recovery-'))
-  const runtimeDir = join(root, 'runtime')
-  const pgdataDir = join(root, 'pgdata')
-  mkdirSync(runtimeDir, { recursive: true })
-  mkdirSync(pgdataDir, { recursive: true })
-  writeFileSync(
-    join(pgdataDir, 'postmaster.pid'),
-    `${process.pid}\n${pgdataDir}\n${Math.floor(Date.now() / 1000)}\n55432\n\n127.0.0.1\n`,
-  )
-  try {
-    await assert.rejects(
-      startPg({ runtimeDir, pgdataDir, existingWaitMs: 20 }),
-      /is alive but not ready; refusing concurrent start/,
-    )
-  } finally {
-    rmSync(root, { recursive: true, force: true })
-  }
-})

package/scripts/memory-rule-contract-test.mjs

@@ -1,93 +0,0 @@
-import test from 'node:test'
-import assert from 'node:assert/strict'
-import { readFile } from 'node:fs/promises'
-
-const root = new URL('..', import.meta.url)
-const rawRules = Object.fromEntries(await Promise.all([
-  ['cycle1', 'src/rules/agent/40-cycle1-agent.md'],
-  ['cycle2', 'src/rules/agent/41-cycle2-agent.md'],
-  ['cycle3', 'src/rules/agent/42-cycle3-agent.md'],
-].map(async ([name, path]) => [
-  name,
-  await readFile(new URL(path, root), 'utf8'),
-])))
-const rules = Object.fromEntries(Object.entries(rawRules)
-  .map(([name, text]) => [name, text.replace(/\s+/g, ' ').trim()]))
-
-function includesAll(text, clauses) {
-  for (const clause of clauses) assert.ok(text.includes(clause), `missing: ${clause}`)
-}
-
-test('cycle1 preserves chunk schema, taxonomy, coverage, and escaping', () => {
-  const text = rules.cycle1
-  includesAll(text, [
-    '<idx_csv>|<element>|<category>|<summary>', 'included input row numbers',
-    'comma-separated, without `@`', '5–10-word recall key',
-    '`rule` (standing policy)', '`constraint` (hard limit)',
-    '`decision` (agreed choice)', '`fact` (verified truth)', '`goal` (open target)',
-    '`preference` (style/taste)', '`task` (pending work)', '`issue` (broken state)',
-    '1–3 complete sentences', 'important names, paths, IDs, versions, numbers, errors, causes, and outcomes verbatim',
-    'match input language', 'Every input row appears exactly once',
-    'Group nearby same-topic rows, splitting only at real topic changes',
-    'retain clarifications with their topic', 'Never mix `[sess:XXX]` markers',
-    'Replace literal `|` with `/`', 'fields contain no newlines',
-    'No JSON, fences, prose, preamble, or tool calls',
-  ])
-})
-
-test('cycle2 preserves essential taxonomy, phases, rejects, formats, and fields', () => {
-  const text = rules.cycle2
-  includesAll(text, [
-    '`is_root` long-term memory', 'candidate `id`/`category`/`score`/`element`/`summary`',
-    'only when clearly exactly one essential concept',
-    'identity (stable non-derivable user fact)', 'preference (durable taste/style/interaction preference)',
-    'goal (long-running committed goal)', 'principle (cross-session behavior directive)',
-    'policy (standing team decision)', 'procedure (recurring trigger + steps + caveats)',
-    'event (rare foundational change not reconstructible from its rule)',
-    'system constant (durable path/schema/model/channel invariant needed later and absent from rules)',
-    'Anything unclear or outside these concepts is `archived`',
-    '`phase1_new_chunks` → `active` if clearly essential, otherwise `archived`',
-    '`phase2_reevaluate` → `active` to promote, otherwise `archived`',
-    '`phase3_active_review` requires an `archived`, `active`, `update`, or `merge` verdict for every row',
-    'defaults to `archived`', 'never treats silence as keep', 'work narratives', 'static facts without behavior/user value',
-    'rule-system meta', 'resolved bug/fix logs', 'rule-file duplicates',
-    'single-run measurements/counts/versions', 'session-scoped or in-progress decisions',
-    '<id>|<verb>', '<id>|update|<element>|<summary>',
-    '<id>|merge|<target_id>|<source_ids_csv>|<element>|<summary>',
-    'Use only input IDs; never invent IDs', 'fresh `element` and a 3-sentence `summary`',
-    'keeps `target_id`, absorbs `source_ids_csv`, and uses only one `project_id`',
-    'complete sentences in input language', 'preserve important specifics verbatim',
-    'omit actor/meta filler', '`rule > constraint > decision > fact > goal > preference > task > issue`',
-    'Replace literal `|` with `/`', 'fields contain no newlines',
-    'Start every verdict with a digit',
-  ])
-})
-
-test('cycle3 preserves durable-event verdicts, formats, and exceptions', () => {
-  const text = rules.cycle3
-  includesAll(text, [
-    'one digit-starting pipe verdict line per input id', 'CORE is durable standing knowledge',
-    'rules, preferences, identity, goals, and current system/structure descriptions—not a log',
-    'Each entry is one short clause (≤120 chars)',
-    'Current rule/preference/live structure = durable',
-    'past event = not durable', 'When unsure, keep',
-    '`keep`: durable, already one short clause',
-    '`update`: durable but verbose/multi-sentence; compress to one ≤120-char clause',
-    '`merge`: duplicate; fold into its survivor in the same project pool',
-    '`delete`: past event, not a current rule or structure',
-    'Verbose durable is always `update`, never `keep`',
-    '<id>|keep', '<id>|update|<element>|<summary>',
-    '<id>|merge|<target_id>|<source_ids_csv>', '<id>|delete',
-    'IDs match input rows; never invent them', 'summary is one ≤120-char clause',
-    '`element` is short', 'retains `target_id`, absorbs sources, and stays within one `project_id`',
-    'Replace literal `|` with `/`', 'fields contain no newlines',
-    'Emit a digit-starting verdict for every input row',
-  ])
-})
-
-test('compacted rules remain below their pre-compaction character counts', () => {
-  const preCompaction = { cycle1: 1214, cycle2: 2166, cycle3: 1530 }
-  for (const [name, before] of Object.entries(preCompaction)) {
-    assert.ok(rawRules[name].length < before, `${name} was not compacted`)
-  }
-})

package/scripts/model-list-sanitize-test.mjs

@@ -1,37 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import { sanitizeModelList } from '../src/runtime/agent/orchestrator/providers/model-list-sanitize.mjs';
-
-test('Anthropic staleness keeps Claude subfamilies separate', () => {
-  const prev = process.env.MIXDOG_MODEL_STALE_MONTHS;
-  process.env.MIXDOG_MODEL_STALE_MONTHS = '0';
-  try {
-    const models = [
-      { id: 'claude-opus-4-8', mode: 'chat' },
-      { id: 'claude-sonnet-4-6', mode: 'chat' },
-      { id: 'claude-haiku-4-5-20251001', mode: 'chat' },
-    ];
-    const catalogRow = (release_date) => ({
-      family: 'claude',
-      release_date,
-      tool_call: true,
-      modalities: { output: ['text'] },
-    });
-    const out = sanitizeModelList(models, {
-      provider: 'anthropic',
-      _testCatalog: {
-        anthropic: {
-          models: {
-            'claude-opus-4-8': catalogRow('2025-12-01'),
-            'claude-sonnet-4-6': catalogRow('2025-11-01'),
-            'claude-haiku-4-5-20251001': catalogRow('2025-10-15'),
-          },
-        },
-      },
-    });
-    assert.deepEqual(out.map((m) => m.id), models.map((m) => m.id));
-  } finally {
-    if (prev == null) delete process.env.MIXDOG_MODEL_STALE_MONTHS;
-    else process.env.MIXDOG_MODEL_STALE_MONTHS = prev;
-  }
-});

package/scripts/mouse-tracking-restore-smoke.mjs

@@ -1,107 +0,0 @@
-#!/usr/bin/env node
-/**
- * Regression harness for the ctrl+wheel mouse-mode restore state machine.
- *
- * Run: node scripts/mouse-tracking-restore-smoke.mjs
- */
-import {
-  cancelPendingMouseTrackingRestores,
-  createMouseTrackingRestoreScheduler,
-} from '../src/tui/app/use-mouse-input.mjs';
-
-const expected = '\x1b[?1000h\x1b[?1002h\x1b[?1006h\x1b[?1007l';
-const expectedPassthrough = '\x1b[?1006l\x1b[?1002l\x1b[?1000l\x1b[?1007l';
-let failures = 0;
-
-function check(name, condition) {
-  if (condition) console.log(`ok   - ${name}`);
-  else {
-    failures += 1;
-    console.log(`FAIL - ${name}`);
-  }
-}
-
-function fakeTimers() {
-  const entries = [];
-  return {
-    entries,
-    setTimeoutFn(fn, delay) {
-      const entry = { fn, delay, cleared: false, ran: false, unref() {} };
-      entries.push(entry);
-      return entry;
-    },
-    clearTimeoutFn(entry) {
-      entry.cleared = true;
-    },
-    runNext() {
-      const entry = entries.find((item) => !item.cleared && !item.ran);
-      if (!entry) return false;
-      entry.ran = true;
-      entry.fn();
-      return true;
-    },
-  };
-}
-
-function createHarness({ alwaysFail = false } = {}) {
-  const timers = fakeTimers();
-  const writes = [];
-  const stdout = {
-    write(value, callback) {
-      writes.push({ value, callback });
-      if (alwaysFail) callback(Object.assign(new Error('temporarily unavailable'), { code: 'EAGAIN' }));
-      return false; // backpressure alone is not failure
-    },
-  };
-  const scheduler = createMouseTrackingRestoreScheduler(stdout, timers);
-  scheduler.attach();
-  return { scheduler, timers, writes };
-}
-
-{
-  const { scheduler, timers, writes } = createHarness();
-  scheduler.schedule();
-  check('initial restore is delayed 700ms', timers.entries[0]?.delay === 700);
-  timers.runNext();
-  check('restore emits all mouse modes plus alternate-scroll off', writes[0]?.value === expected);
-  writes[0].callback(Object.assign(new Error('temporarily unavailable'), { code: 'EAGAIN' }));
-  check('async EAGAIN schedules a 200ms retry', timers.entries[1]?.delay === 200);
-  scheduler.detach();
-}
-
-{
-  const { scheduler, timers, writes } = createHarness({ alwaysFail: true });
-  scheduler.schedule();
-  while (timers.runNext()) { /* drain deterministic retries */ }
-  check('async failure is capped at five retries', writes.length === 6);
-  check('retry cap leaves no runnable timer', timers.runNext() === false);
-  scheduler.detach();
-}
-
-{
-  const { scheduler, timers, writes } = createHarness();
-  scheduler.schedule();
-  const staleTimer = timers.entries[0];
-  scheduler.schedule();
-  staleTimer.fn(); // simulate a callback already queued when clearTimeout ran
-  check('stale-generation restore callback is a no-op', writes.length === 0);
-  timers.runNext();
-  check('current generation still restores', writes.length === 1);
-  scheduler.detach();
-}
-
-{
-  const { scheduler, timers, writes } = createHarness();
-  scheduler.passthrough();
-  check('ctrl+wheel emits the guarded passthrough modes', writes[0]?.value === expectedPassthrough);
-  const queuedBeforeTerminalRestore = timers.entries[0];
-  cancelPendingMouseTrackingRestores();
-  queuedBeforeTerminalRestore.fn();
-  const writesAtRestore = writes.length;
-  scheduler.passthrough(); // late buffered ctrl+wheel after restoreTerminal()
-  check('late ctrl+wheel after terminal restore emits no mode bytes',
-    writes.length === writesAtRestore && timers.runNext() === false);
-}
-
-console.log(failures === 0 ? '\nALL PASS' : `\n${failures} FAILURE(S)`);
-process.exit(failures === 0 ? 0 : 1);