ultra-builder-pro-cli 0.14.0 → 0.16.0

package/orchestrator/tests/skill-miner.test.cjs

@@ -1,147 +0,0 @@
-'use strict';
-
-// Phase 7.3 — Skill miner (heuristic, no LLM):
-//   • mineSession scans a session's events + task state for "solved
-//     something non-trivial" signals and writes skills/learned/
-//     <ts>_<sid>_unverified.md drafts.
-//   • Idempotent: same sid twice → only one draft per signal.
-
-const { test } = require('node:test');
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-const { initStateDb, closeStateDb } = require('../../mcp-server/lib/state-db.cjs');
-const ops = require('../../mcp-server/lib/state-ops.cjs');
-const skillMiner = require('../skill-miner.cjs');
-
-function mkFixture() {
-  const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-skill-'));
-  const dbPath = path.join(repoRoot, '.ultra', 'state.db');
-  const { db } = initStateDb(dbPath);
-  const skillsRoot = path.join(repoRoot, 'skills');
-  fs.mkdirSync(skillsRoot, { recursive: true });
-  return { repoRoot, db, skillsRoot };
-}
-
-function teardown(repoRoot, db) {
-  try { closeStateDb(db); } catch (_) { /* ignore */ }
-  try { fs.rmSync(repoRoot, { recursive: true, force: true }); } catch (_) { /* ignore */ }
-}
-
-function seed(db, { sid, task_id, title = 'demo', tag = null }) {
-  ops.createTask(db, { id: task_id, title, type: 'feature', priority: 'P1', tag });
-  ops.createSession(db, {
-    sid, task_id, runtime: 'claude',
-    worktree_path: `/tmp/${sid}/wt`, artifact_dir: `/tmp/${sid}/art`,
-  });
-}
-
-test('mineSession: task_completed signal → generates draft', () => {
-  const { repoRoot, db, skillsRoot } = mkFixture();
-  try {
-    seed(db, { sid: 's-done', task_id: 't-done', title: 'ship auth flow' });
-    ops.patchTask(db, 't-done', { status: 'in_progress' });
-    ops.appendEvent(db, { type: 'task_completed', task_id: 't-done', session_id: 's-done', payload: { to: 'completed' } });
-    ops.patchTask(db, 't-done', { status: 'completed' });
-
-    const out = skillMiner.mineSession(db, { sid: 's-done', skillsRoot });
-    assert.equal(out.drafts.length, 1);
-    assert.match(out.drafts[0], /_unverified\.md$/);
-    const draft = fs.readFileSync(out.drafts[0], 'utf8');
-    assert.match(draft, /kind: task-completion/);
-    assert.match(draft, /unverified: true/);
-    assert.match(draft, /ship auth flow/);
-  } finally { teardown(repoRoot, db); }
-});
-
-test('mineSession: task_circuit_broken signal → debug-pattern draft', () => {
-  const { repoRoot, db, skillsRoot } = mkFixture();
-  try {
-    seed(db, { sid: 's-cb', task_id: 't-cb', title: 'flaky integration' });
-    ops.appendEvent(db, { type: 'task_circuit_broken', task_id: 't-cb', session_id: 's-cb', payload: { threshold: 3 } });
-    const out = skillMiner.mineSession(db, { sid: 's-cb', skillsRoot });
-    assert.equal(out.drafts.length, 1);
-    const draft = fs.readFileSync(out.drafts[0], 'utf8');
-    assert.match(draft, /kind: debug-pattern/);
-  } finally { teardown(repoRoot, db); }
-});
-
-test('mineSession: session_crashed signal → recovery-pattern draft', () => {
-  const { repoRoot, db, skillsRoot } = mkFixture();
-  try {
-    seed(db, { sid: 's-crash', task_id: 't-crash', title: 'crashing task' });
-    ops.appendEvent(db, { type: 'session_crashed', task_id: 't-crash', session_id: 's-crash', payload: { to: 'crashed' } });
-    const out = skillMiner.mineSession(db, { sid: 's-crash', skillsRoot });
-    assert.equal(out.drafts.length, 1);
-    const draft = fs.readFileSync(out.drafts[0], 'utf8');
-    assert.match(draft, /kind: recovery-pattern/);
-  } finally { teardown(repoRoot, db); }
-});
-
-test('mineSession: no trigger signals → no draft', () => {
-  const { repoRoot, db, skillsRoot } = mkFixture();
-  try {
-    seed(db, { sid: 's-quiet', task_id: 't-quiet', title: 'nothing happened' });
-    const out = skillMiner.mineSession(db, { sid: 's-quiet', skillsRoot });
-    assert.equal(out.drafts.length, 0);
-  } finally { teardown(repoRoot, db); }
-});
-
-test('mineSession: idempotent — running twice on same sid yields no new drafts', () => {
-  const { repoRoot, db, skillsRoot } = mkFixture();
-  try {
-    seed(db, { sid: 's-idem', task_id: 't-idem', title: 'shipped' });
-    ops.patchTask(db, 't-idem', { status: 'in_progress' });
-    ops.appendEvent(db, { type: 'task_completed', task_id: 't-idem', session_id: 's-idem', payload: { to: 'completed' } });
-    ops.patchTask(db, 't-idem', { status: 'completed' });
-
-    const first = skillMiner.mineSession(db, { sid: 's-idem', skillsRoot });
-    const second = skillMiner.mineSession(db, { sid: 's-idem', skillsRoot });
-    assert.equal(first.drafts.length, 1);
-    assert.equal(second.drafts.length, 0, 'second mining should see existing draft and skip');
-    const learned = fs.readdirSync(path.join(skillsRoot, 'learned'));
-    assert.equal(learned.length, 1);
-  } finally { teardown(repoRoot, db); }
-});
-
-test('mineSession: missing session → empty drafts array', () => {
-  const { repoRoot, db, skillsRoot } = mkFixture();
-  try {
-    const out = skillMiner.mineSession(db, { sid: 's-nope', skillsRoot });
-    assert.deepEqual(out.drafts, []);
-  } finally { teardown(repoRoot, db); }
-});
-
-test('AC flow: 5 mock sessions (3 with signal, 2 empty) → ≥3 drafts', () => {
-  const { repoRoot, db, skillsRoot } = mkFixture();
-  try {
-    // 3 with a trigger signal
-    for (const [i, kind] of [['ac1', 'completed'], ['ac2', 'crashed'], ['ac3', 'broken']]) {
-      seed(db, { sid: `s-${i}`, task_id: `t-${i}`, title: `task ${i}` });
-      if (kind === 'completed') {
-        ops.patchTask(db, `t-${i}`, { status: 'in_progress' });
-        ops.appendEvent(db, { type: 'task_completed', task_id: `t-${i}`, session_id: `s-${i}`, payload: {} });
-        ops.patchTask(db, `t-${i}`, { status: 'completed' });
-      } else if (kind === 'crashed') {
-        ops.appendEvent(db, { type: 'session_crashed', task_id: `t-${i}`, session_id: `s-${i}`, payload: {} });
-      } else if (kind === 'broken') {
-        ops.appendEvent(db, { type: 'task_circuit_broken', task_id: `t-${i}`, session_id: `s-${i}`, payload: { threshold: 3 } });
-      }
-    }
-    // 2 empty
-    for (const i of ['ac4', 'ac5']) {
-      seed(db, { sid: `s-${i}`, task_id: `t-${i}`, title: `task ${i}` });
-    }
-
-    let totalDrafts = 0;
-    for (const i of ['ac1', 'ac2', 'ac3', 'ac4', 'ac5']) {
-      const out = skillMiner.mineSession(db, { sid: `s-${i}`, skillsRoot });
-      totalDrafts += out.drafts.length;
-    }
-    assert.ok(totalDrafts >= 3, `expected ≥3 drafts across 5 sessions, got ${totalDrafts}`);
-    const learned = fs.readdirSync(path.join(skillsRoot, 'learned'));
-    assert.ok(learned.length >= 3);
-  } finally { teardown(repoRoot, db); }
-});

package/orchestrator/tests/worktree-manager.test.cjs

@@ -1,148 +0,0 @@
-'use strict';
-
-// Phase 8B.3 — N-concurrent git worktree management.
-//
-// Session-runner (Phase 4.5) already encapsulates `git worktree add/remove`
-// for a single session. worktree-manager is the registry / batch layer:
-// allocate N, track them via `git worktree list --porcelain`, release one
-// or all (for crash recovery), detect filesystem orphans.
-//
-// AC (from PLAN §6 Phase 8B.3):
-//   - 3 concurrent slices → 3 independent worktrees, git worktree list
-//     shows them; main branch checkout untouched
-//   - 5 rapid allocations in one tick → no .git/config.lock contention
-//     (Node single-thread execFileSync is naturally serialized)
-//   - releaseAll cleans filesystem leftovers even when git forgot them
-
-const { test } = require('node:test');
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const { execFileSync } = require('node:child_process');
-
-const wm = require('../worktree-manager.cjs');
-
-function mkRepo() {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-wtmgr-'));
-  execFileSync('git', ['init', '-q'], { cwd: dir });
-  execFileSync('git', ['config', 'user.email', 'test@ubp.dev'], { cwd: dir });
-  execFileSync('git', ['config', 'user.name', 'ubp-test'], { cwd: dir });
-  fs.writeFileSync(path.join(dir, 'README.md'), '# seed\n');
-  execFileSync('git', ['add', '-A'], { cwd: dir });
-  execFileSync('git', ['commit', '-q', '-m', 'seed'], { cwd: dir });
-  return dir;
-}
-
-function cleanup(dir) {
-  try { fs.rmSync(dir, { recursive: true, force: true }); } catch (_) { /* best-effort */ }
-}
-
-test('allocate: creates worktree under .ultra/worktrees/<sid> and returns path', () => {
-  const repo = mkRepo();
-  try {
-    const { worktree_path } = wm.allocate({ repoRoot: repo, sid: 'sess-abc' });
-    assert.ok(worktree_path.endsWith('.ultra/worktrees/sess-abc'));
-    assert.ok(fs.existsSync(worktree_path), 'worktree dir should exist');
-    assert.ok(fs.existsSync(path.join(worktree_path, 'README.md')), 'seed file visible');
-  } finally { cleanup(repo); }
-});
-
-test('release: removes worktree dir and unregisters from git', () => {
-  const repo = mkRepo();
-  try {
-    const { worktree_path } = wm.allocate({ repoRoot: repo, sid: 'sess-rel' });
-    wm.release({ repoRoot: repo, worktree_path });
-    assert.equal(fs.existsSync(worktree_path), false, 'dir should be removed');
-    const active = wm.listActive(repo);
-    assert.equal(active.length, 0, 'no slices should remain');
-  } finally { cleanup(repo); }
-});
-
-test('3 concurrent allocates → 3 independent worktrees visible via listActive', () => {
-  const repo = mkRepo();
-  try {
-    const sids = ['sess-a', 'sess-b', 'sess-c'];
-    const paths = sids.map((sid) => wm.allocate({ repoRoot: repo, sid }).worktree_path);
-    for (const p of paths) assert.ok(fs.existsSync(p), `${p} missing`);
-    const active = wm.listActive(repo);
-    const activeSids = active.map((a) => a.sid).sort();
-    assert.deepEqual(activeSids, sids.slice().sort());
-    // Every entry has a distinct worktree_path
-    const uniquePaths = new Set(active.map((a) => a.worktree_path));
-    assert.equal(uniquePaths.size, 3);
-  } finally { cleanup(repo); }
-});
-
-test('5 rapid allocates in one tick → no .git/config.lock contention', () => {
-  const repo = mkRepo();
-  try {
-    const sids = ['s1', 's2', 's3', 's4', 's5'];
-    // Execute synchronously back-to-back; Node single-thread guarantees
-    // serialized git calls, so no file-lock race.
-    for (const sid of sids) {
-      wm.allocate({ repoRoot: repo, sid });
-    }
-    assert.equal(wm.listActive(repo).length, 5);
-  } finally { cleanup(repo); }
-});
-
-test('listActive: only returns worktrees under .ultra/worktrees/ (main excluded)', () => {
-  const repo = mkRepo();
-  try {
-    // Manually add a worktree OUTSIDE .ultra/worktrees — should be ignored.
-    const outsideDir = path.join(repo, 'other-wt');
-    execFileSync('git', ['worktree', 'add', '--detach', outsideDir, 'HEAD'], {
-      cwd: repo, stdio: 'pipe',
-    });
-    wm.allocate({ repoRoot: repo, sid: 'sess-domain' });
-    const active = wm.listActive(repo);
-    assert.equal(active.length, 1);
-    assert.equal(active[0].sid, 'sess-domain');
-  } finally { cleanup(repo); }
-});
-
-test('listActive: empty repo → []', () => {
-  const repo = mkRepo();
-  try {
-    assert.deepEqual(wm.listActive(repo), []);
-  } finally { cleanup(repo); }
-});
-
-test('releaseAll: clears all allocated worktrees + filesystem orphans', () => {
-  const repo = mkRepo();
-  try {
-    wm.allocate({ repoRoot: repo, sid: 'x1' });
-    wm.allocate({ repoRoot: repo, sid: 'x2' });
-    // Create an orphan dir: git doesn't know about it, but fs exists.
-    const orphanDir = path.join(repo, '.ultra', 'worktrees', 'orphan-dir');
-    fs.mkdirSync(orphanDir, { recursive: true });
-    fs.writeFileSync(path.join(orphanDir, 'junk.txt'), 'x');
-
-    const result = wm.releaseAll(repo);
-    assert.equal(result.cleaned, 2, 'should report 2 git-tracked cleanups');
-    assert.equal(wm.listActive(repo).length, 0);
-    assert.equal(fs.existsSync(orphanDir), false, 'orphan must be swept');
-  } finally { cleanup(repo); }
-});
-
-test('allocate: baseRef honored — worktree checked out at given ref', () => {
-  const repo = mkRepo();
-  try {
-    // Make a second commit so we have two distinct SHAs.
-    fs.writeFileSync(path.join(repo, 'second.md'), '# second\n');
-    execFileSync('git', ['add', '-A'], { cwd: repo });
-    execFileSync('git', ['commit', '-q', '-m', 'second'], { cwd: repo });
-    const firstSha = execFileSync('git', ['rev-parse', 'HEAD~1'], {
-      cwd: repo, stdio: ['ignore', 'pipe', 'pipe'],
-    }).toString().trim();
-
-    const { worktree_path } = wm.allocate({
-      repoRoot: repo, sid: 'sess-ref', baseRef: firstSha,
-    });
-    const wtSha = execFileSync('git', ['rev-parse', 'HEAD'], {
-      cwd: worktree_path, stdio: ['ignore', 'pipe', 'pipe'],
-    }).toString().trim();
-    assert.equal(wtSha, firstSha);
-  } finally { cleanup(repo); }
-});

package/skills/ultra-research/references/architecture.md

@@ -1,38 +0,0 @@
-# Architecture research
-
-Read this reference when the system boundary, quality attributes, integration seams,
-technology choice, or implementation constraints are unresolved.
-
-## Current system evidence
-
-Start from the current checkout:
-
-- entry points and external interfaces;
-- domain boundaries and authoritative state;
-- data flows and side effects;
-- existing dependencies and deployment topology;
-- failure, recovery, authorization, and observability paths.
-
-Do not design a replacement architecture before identifying the live path and the
-constraint that requires change.
-
-## Decision method
-
-For each material architecture decision:
-
-1. state the required capability and quality constraints;
-2. identify credible options already compatible with the system when possible;
-3. use official primary documentation for library or platform behavior;
-4. evaluate integration cost, operability, failure modes, migration, and rollback;
-5. record the selected option, rejected alternatives that may recur, and the evidence
-   that would reopen the decision.
-
-Do not compare technologies for ceremony. A single established repository pattern is
-the default when it satisfies the contract.
-
-## Record the result
-
-Update the architecture specification with system context, boundaries, building
-blocks, runtime flow, authoritative state, external contracts, quality scenarios,
-deployment constraints, and accepted decisions. Connect each required behavior to a
-reachable public seam and a verification approach.

package/skills/ultra-research/references/problem-product.md

@@ -1,39 +0,0 @@
-# Problem and product research
-
-Read this reference when the problem, value, market context, or product direction is
-uncertain.
-
-## Establish the problem
-
-- Identify the affected actor, current behavior, observable cost, and desired outcome.
-- Distinguish user evidence from stakeholder belief and solution preference.
-- Find current alternatives, including manual work or doing nothing.
-- State what evidence would disprove the problem framing.
-
-Use repository artifacts, support data, interviews, analytics, or primary external
-sources that actually exist. Do not invent quotes, demand, or market size.
-
-## Decide how much market work is needed
-
-Market sizing and competitive research are optional. Use them only when they affect a
-funding, positioning, pricing, or build-versus-buy decision.
-
-When needed:
-
-1. define the market boundary and time period;
-2. show the calculation inputs and sources;
-3. separate direct, adjacent, and substitute alternatives;
-4. explain how the evidence changes the product decision.
-
-Do not present unsourced top-down totals or call a category competitor-free.
-
-## Record the result
-
-Update the discovery specification with:
-
-- problem and affected actors;
-- observed evidence and source quality;
-- desired outcome and non-goals;
-- material alternatives and tradeoffs;
-- assumptions, validation method, and blocking questions;
-- the accepted product decision and why it follows from the evidence.

package/skills/ultra-research/references/quality-delivery.md

@@ -1,34 +0,0 @@
-# Quality and delivery research
-
-Read this reference when acceptance depends on operational risk, security, migration,
-deployment, recovery, or release constraints.
-
-## Risk-driven quality
-
-Identify failures that would materially affect users, data, authorization, money,
-availability, or recoverability. For each relevant risk, record:
-
-- trigger and affected boundary;
-- expected behavior and observable signal;
-- prevention, detection, and recovery;
-- verification method and owner.
-
-Apply security, performance, accessibility, and resilience checks according to the
-actual product surface. Do not impose generic categories or coverage percentages when
-they do not define acceptance.
-
-## Delivery path
-
-Capture the environments, configuration authority, migration order, compatibility
-window, health and readiness checks, observability, rollout, rollback, and operator
-actions needed for this product.
-
-Prefer existing repository and platform workflows. Add a new service, dependency, or
-deployment mechanism only when the accepted architecture requires it.
-
-## Record the result
-
-Update the architecture and product specifications with testable quality scenarios,
-delivery constraints, failure behavior, recovery evidence, and release acceptance.
-Keep exact volatile commands in the repository's runbook when they are operational
-procedure rather than durable architecture.

package/skills/ultra-research/references/synthesis.md

@@ -1,38 +0,0 @@
-# Baseline synthesis and validation
-
-Read this reference after the selected research lanes are complete.
-
-## Traceability check
-
-Verify that each accepted outcome has:
-
-1. supporting problem, user, or constraint evidence;
-2. an explicit decision and scope boundary;
-3. testable acceptance behavior;
-4. a compatible architecture or delivery path;
-5. a named unresolved blocker when any link is missing.
-
-Check the reverse direction as well: every proposed component, dependency, and quality
-requirement must support an accepted outcome or constraint.
-
-## Consistency check
-
-- Use one term for each actor, boundary, and authoritative data source.
-- Remove duplicate narratives and stale alternatives.
-- Keep source links next to the claims they support.
-- Separate durable decisions from volatile external facts.
-- Preserve explicit non-goals and rejected alternatives only when they prevent a
-  likely future mistake.
-
-## Handoff
-
-Report:
-
-- validated scope and decisive evidence;
-- specification files changed;
-- accepted decisions and material uncertainty;
-- blockers, or an explicit statement that none remain;
-- one next action.
-
-Do not create a parallel summary document solely for model consumption. The planning
-workflow should read the smallest authoritative baseline sections it needs.

package/skills/ultra-research/references/users-scope.md

@@ -1,40 +0,0 @@
-# Users, behavior, and scope
-
-Read this reference when actors, workflows, acceptance, boundaries, or success signals
-are unclear.
-
-## Actors and scenarios
-
-Model only actors supported by evidence. Prefer roles and jobs over fictional persona
-biographies. For each material scenario, capture:
-
-- trigger and preconditions;
-- actor goal;
-- main flow and system response;
-- important failure or recovery path;
-- observable completion signal.
-
-## Acceptance and scope
-
-Turn scenarios into testable behavior. Each requirement should name the observable
-outcome, relevant constraints, and how success can be verified.
-
-Define:
-
-- included behavior required for the accepted outcome;
-- explicit non-goals;
-- dependencies and assumptions;
-- deferred work only when a real sequencing decision exists.
-
-Avoid arbitrary release buckets or a fixed number of stories. Scope follows the
-validated outcome and delivery constraint.
-
-## Success signals
-
-Choose metrics only when they will guide a decision. Define the event, population,
-window, source, owner, and interpretation. Do not invent target values; record a
-baseline, a user-approved target, or the experiment needed to establish one.
-
-Update the product specification with actors, scenarios, acceptance, scope, non-goals,
-and decision-relevant success signals. Keep business facts in their source system and
-link them rather than copying volatile datasets into the specification.

package/ultra-tools/legacy-memory.test.cjs

@@ -1,80 +0,0 @@
-'use strict';
-
-const { test } = require('node:test');
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const Database = require('better-sqlite3');
-
-const legacy = require('./commands/legacy-memory.cjs');
-
-function fixture() {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-legacy-memory-'));
-  const ultra = path.join(root, '.ultra');
-  fs.mkdirSync(path.join(ultra, 'memory'), { recursive: true });
-  fs.writeFileSync(path.join(ultra, 'memory', 'memory.db'), 'legacy-hook-store');
-  const db = new Database(path.join(ultra, 'state.db'));
-  db.exec(`
-    CREATE TABLE memory_entries (
-      id INTEGER PRIMARY KEY, kind TEXT, content TEXT, task_id TEXT,
-      session_id TEXT, tag TEXT, source TEXT, ts TEXT
-    );
-    INSERT INTO memory_entries
-      (kind, content, task_id, session_id, tag, source, ts)
-    VALUES ('decision', 'legacy decision', 't1', 's1', 'arch', 'test', '2026-01-01T00:00:00Z');
-  `);
-  db.close();
-  return root;
-}
-
-test('inspect reports both legacy stores without mutating them', () => {
-  const root = fixture();
-  try {
-    const result = legacy.inspectLegacy(root);
-    assert.equal(result.hook_memory_dir, true);
-    assert.equal(result.state_memory_table, true);
-    assert.equal(result.state_memory_entries, 1);
-    assert.ok(fs.existsSync(path.join(root, '.ultra', 'memory', 'memory.db')));
-  } finally {
-    fs.rmSync(root, { recursive: true, force: true });
-  }
-});
-test('archive exports legacy state rows and copies hook memory without deletion', () => {
-  const root = fixture();
-  try {
-    const result = legacy.archiveLegacy(root, { timestamp: '2026-07-15T00-00-00-000Z' });
-    assert.equal(result.archived, true);
-    assert.ok(fs.existsSync(path.join(result.archive_dir, 'hook-memory', 'memory.db')));
-    const exported = JSON.parse(fs.readFileSync(path.join(result.archive_dir, 'state-memory-entries.json'), 'utf8'));
-    assert.equal(exported.entries.length, 1);
-    assert.equal(exported.entries[0].content, 'legacy decision');
-    assert.ok(fs.existsSync(path.join(root, '.ultra', 'memory', 'memory.db')));
-    const db = new Database(path.join(root, '.ultra', 'state.db'), { readonly: true });
-    assert.ok(db.prepare("SELECT 1 FROM sqlite_master WHERE name = 'memory_entries'").get());
-    db.close();
-  } finally {
-    fs.rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test('prune requires an exact confirmation and archives before deleting', () => {
-  const root = fixture();
-  try {
-    assert.throws(() => legacy.pruneLegacy(root, { confirm: 'yes' }), /DELETE_ULTRA_LEGACY_MEMORY/);
-    assert.ok(fs.existsSync(path.join(root, '.ultra', 'memory', 'memory.db')));
-
-    const result = legacy.pruneLegacy(root, {
-      confirm: 'DELETE_ULTRA_LEGACY_MEMORY',
-      timestamp: '2026-07-15T00-00-01-000Z',
-    });
-    assert.equal(result.pruned, true);
-    assert.ok(fs.existsSync(result.archive_dir));
-    assert.ok(!fs.existsSync(path.join(root, '.ultra', 'memory')));
-    const db = new Database(path.join(root, '.ultra', 'state.db'), { readonly: true });
-    assert.equal(db.prepare("SELECT 1 FROM sqlite_master WHERE name = 'memory_entries'").get(), undefined);
-    db.close();
-  } finally {
-    fs.rmSync(root, { recursive: true, force: true });
-  }
-});