ultra-builder-pro-cli 0.5.0

package/mcp-server/lib/plan-store.test.cjs

@@ -0,0 +1,132 @@
+'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 {
+  savePlanArtifact,
+  loadPlanArtifact,
+  selectSection,
+  renderPlanMd,
+  DEFAULT_ARTIFACT_RELPATH,
+} = require('./plan-store.cjs');
+
+function tmpRoot() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-plan-'));
+}
+
+const SAMPLE_PLAN = Object.freeze({
+  waves: [
+    { id: 1, tasks: ['a', 'b'], parallel: true },
+    { id: 2, tasks: ['c'], parallel: false },
+  ],
+  ownership_forecast: { a: ['src/a.ts'], b: ['src/b.ts'], c: ['src/c.ts'] },
+  conflict_surface: [],
+  estimated_cost_usd: 0.12,
+  estimated_duration_min: 35,
+  cycles: [],
+});
+
+test('savePlanArtifact: json format writes a file we can JSON.parse back', () => {
+  const root = tmpRoot();
+  try {
+    const outPath = path.join(root, '.ultra', 'execution-plan.json');
+    const { plan_path } = savePlanArtifact(SAMPLE_PLAN, outPath, 'json');
+    assert.equal(plan_path, path.resolve(outPath));
+    assert.ok(fs.existsSync(plan_path));
+    const parsed = JSON.parse(fs.readFileSync(plan_path, 'utf8'));
+    assert.deepEqual(parsed.waves, SAMPLE_PLAN.waves);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('savePlanArtifact: md format writes a human-readable report', () => {
+  const root = tmpRoot();
+  try {
+    const outPath = path.join(root, '.ultra', 'execution-plan.md');
+    savePlanArtifact(SAMPLE_PLAN, outPath, 'md');
+    const text = fs.readFileSync(outPath, 'utf8');
+    assert.match(text, /# Execution Plan/);
+    assert.match(text, /Wave 1/);
+    assert.match(text, /parallel/);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('savePlanArtifact: missing out_path → WRITE_FAILED', () => {
+  assert.throws(
+    () => savePlanArtifact(SAMPLE_PLAN, '', 'json'),
+    (err) => err.code === 'WRITE_FAILED',
+  );
+});
+
+test('loadPlanArtifact: no file → null', () => {
+  const root = tmpRoot();
+  try {
+    assert.equal(loadPlanArtifact(root), null);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('loadPlanArtifact: round-trip via DEFAULT_ARTIFACT_RELPATH', () => {
+  const root = tmpRoot();
+  try {
+    const target = path.join(root, DEFAULT_ARTIFACT_RELPATH);
+    savePlanArtifact(SAMPLE_PLAN, target, 'json');
+    const loaded = loadPlanArtifact(root);
+    assert.deepEqual(loaded.waves, SAMPLE_PLAN.waves);
+    assert.equal(loaded.estimated_cost_usd, 0.12);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('loadPlanArtifact: corrupt file → null (no throw)', () => {
+  const root = tmpRoot();
+  try {
+    const target = path.join(root, DEFAULT_ARTIFACT_RELPATH);
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.writeFileSync(target, '{not json');
+    assert.equal(loadPlanArtifact(root), null);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('selectSection: tasks returns ownership_forecast only', () => {
+  const r = selectSection(SAMPLE_PLAN, 'tasks');
+  assert.deepEqual(Object.keys(r), ['ownership_forecast']);
+});
+
+test('selectSection: topo returns waves only', () => {
+  const r = selectSection(SAMPLE_PLAN, 'topo');
+  assert.deepEqual(Object.keys(r), ['waves']);
+});
+
+test('selectSection: conflicts returns conflict_surface only', () => {
+  const r = selectSection(SAMPLE_PLAN, 'conflicts');
+  assert.deepEqual(Object.keys(r), ['conflict_surface']);
+});
+
+test('selectSection: all (default) returns whole plan', () => {
+  assert.deepEqual(selectSection(SAMPLE_PLAN, 'all'), SAMPLE_PLAN);
+  assert.deepEqual(selectSection(SAMPLE_PLAN), SAMPLE_PLAN);
+});
+
+test('renderPlanMd: reports cycles + conflicts counts when present', () => {
+  const planWithConflicts = {
+    ...SAMPLE_PLAN,
+    conflict_surface: [{ files: ['x.ts'], tasks: ['a', 'b'], recommend: 'sequentialize' }],
+    cycles: [['z', 'y']],
+  };
+  const md = renderPlanMd(planWithConflicts);
+  assert.match(md, /Conflicts: 1/);
+  assert.match(md, /Cycles: 1/);
+  assert.match(md, /## Conflict Surface/);
+});

package/mcp-server/lib/prd-parser.cjs

@@ -0,0 +1,110 @@
+'use strict';
+
+// Phase 8A.1 — PRD → task[] parser. Delegates LLM call to an injected
+// llmClient (see lib/llm-client.cjs). The parser itself is pure logic:
+// prompt assembly → schema validation → id normalization. Keeping the
+// llmClient as a parameter makes unit tests a Test Double exercise without
+// mocking network I/O.
+
+const Ajv = require('ajv/dist/2020');
+const {
+  buildSystemPrompt,
+  buildUserPrompt,
+} = require('../../orchestrator/planner/prd-prompt.cjs');
+
+const TASK_LIST_SCHEMA = Object.freeze({
+  type: 'object',
+  required: ['tasks'],
+  properties: {
+    tasks: {
+      type: 'array',
+      minItems: 1,
+      items: {
+        type: 'object',
+        required: ['id', 'title', 'type', 'priority'],
+        properties: {
+          id:          { type: 'string', pattern: '^[a-zA-Z0-9_\\-]+$' },
+          title:       { type: 'string', minLength: 3, maxLength: 200 },
+          type:        { type: 'string', enum: ['architecture', 'feature', 'bugfix'] },
+          priority:    { type: 'string', enum: ['P0', 'P1', 'P2', 'P3'] },
+          complexity:  { type: 'integer', minimum: 1, maximum: 10 },
+          deps:        { type: 'array', items: { type: 'string' } },
+          files_modified: { type: 'array', items: { type: 'string' } },
+        },
+      },
+    },
+  },
+});
+
+const ajv = new Ajv({ allErrors: true, strict: false });
+const validateTaskList = ajv.compile(TASK_LIST_SCHEMA);
+
+class PrdParseError extends Error {
+  constructor(code, message, cause) {
+    super(message);
+    this.name = 'PrdParseError';
+    this.code = code;
+    if (cause) this.cause = cause;
+  }
+}
+
+async function parsePrd(prdText, { llmClient, tag } = {}) {
+  if (!prdText || typeof prdText !== 'string' || !prdText.trim()) {
+    throw new PrdParseError('NO_INPUT', 'prd text is empty');
+  }
+  if (!llmClient || typeof llmClient.completeJson !== 'function') {
+    throw new PrdParseError('NO_LLM_CLIENT', 'llmClient.completeJson is required');
+  }
+
+  const system = buildSystemPrompt();
+  const user = buildUserPrompt(prdText);
+
+  let reply;
+  try {
+    reply = await llmClient.completeJson({ system, user });
+  } catch (err) {
+    throw new PrdParseError(
+      'PARSE_FAILED',
+      `LLM call failed: ${err.message}`,
+      err,
+    );
+  }
+
+  if (!validateTaskList(reply.json)) {
+    throw new PrdParseError(
+      'PARSE_FAILED',
+      `LLM output failed schema: ${ajv.errorsText(validateTaskList.errors)}`,
+    );
+  }
+
+  const ids = new Set();
+  const tasks = reply.json.tasks.map((t) => {
+    if (ids.has(t.id)) {
+      throw new PrdParseError('PARSE_FAILED', `duplicate task id "${t.id}" in LLM output`);
+    }
+    ids.add(t.id);
+    return {
+      id: t.id,
+      title: t.title,
+      type: t.type,
+      priority: t.priority,
+      complexity: t.complexity ?? null,
+      deps: Array.isArray(t.deps) ? t.deps : [],
+      files_modified: Array.isArray(t.files_modified) ? t.files_modified : [],
+      tag: tag || null,
+    };
+  });
+
+  return {
+    tasks,
+    usage: reply.usage || {},
+    model: reply.model,
+    provider: reply.provider,
+  };
+}
+
+module.exports = {
+  parsePrd,
+  PrdParseError,
+  TASK_LIST_SCHEMA,
+};

package/mcp-server/lib/prd-parser.test.cjs

@@ -0,0 +1,171 @@
+'use strict';
+
+// Test Double rationale: external LLM API — deterministic fixtures prove
+// parsing logic (prompt assembly, schema validation, id normalization)
+// without egress cost or key dependence. Integration coverage against a
+// real LLM lives behind an env gate and is exercised separately.
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const { parsePrd, PrdParseError, TASK_LIST_SCHEMA } = require('./prd-parser.cjs');
+
+function fakeClient(jsonFn, { usage = { input_tokens: 100, output_tokens: 50 }, model = 'claude-sonnet-4-6', provider = 'anthropic' } = {}) {
+  return {
+    provider,
+    model,
+    async completeJson({ system, user }) {
+      const json = typeof jsonFn === 'function' ? await jsonFn({ system, user }) : jsonFn;
+      return { json, raw: JSON.stringify(json), usage, model, provider };
+    },
+  };
+}
+
+const HAPPY_TASKS = {
+  tasks: [
+    {
+      id: 'task-1',
+      title: 'Design auth schema',
+      type: 'architecture',
+      priority: 'P1',
+      complexity: 5,
+      deps: [],
+      files_modified: ['src/auth/schema.ts'],
+    },
+    {
+      id: 'task-2',
+      title: 'Implement login endpoint',
+      type: 'feature',
+      priority: 'P1',
+      complexity: 6,
+      deps: ['task-1'],
+      files_modified: ['src/auth/login.ts'],
+    },
+  ],
+};
+
+test('parsePrd: happy path normalizes tasks and returns usage metadata', async () => {
+  const client = fakeClient(HAPPY_TASKS);
+  const result = await parsePrd('Build login', { llmClient: client, tag: 'feat-auth' });
+  assert.equal(result.tasks.length, 2);
+  assert.equal(result.tasks[0].id, 'task-1');
+  assert.equal(result.tasks[0].tag, 'feat-auth');
+  assert.deepEqual(result.tasks[1].deps, ['task-1']);
+  assert.equal(result.model, 'claude-sonnet-4-6');
+  assert.equal(result.provider, 'anthropic');
+  assert.equal(result.usage.input_tokens, 100);
+});
+
+test('parsePrd: empty text → NO_INPUT', async () => {
+  await assert.rejects(
+    parsePrd('', { llmClient: fakeClient(HAPPY_TASKS) }),
+    (err) => err instanceof PrdParseError && err.code === 'NO_INPUT',
+  );
+  await assert.rejects(
+    parsePrd('   ', { llmClient: fakeClient(HAPPY_TASKS) }),
+    (err) => err instanceof PrdParseError && err.code === 'NO_INPUT',
+  );
+});
+
+test('parsePrd: missing llmClient → NO_LLM_CLIENT', async () => {
+  await assert.rejects(
+    parsePrd('Build something', {}),
+    (err) => err instanceof PrdParseError && err.code === 'NO_LLM_CLIENT',
+  );
+});
+
+test('parsePrd: llmClient error bubbles up as PARSE_FAILED', async () => {
+  const brokenClient = {
+    provider: 'anthropic',
+    model: 'claude-sonnet-4-6',
+    async completeJson() { throw new Error('upstream LLM 500'); },
+  };
+  await assert.rejects(
+    parsePrd('Build something', { llmClient: brokenClient }),
+    (err) => err instanceof PrdParseError && err.code === 'PARSE_FAILED' && /upstream LLM 500/.test(err.message),
+  );
+});
+
+test('parsePrd: invalid JSON shape rejected — missing required "priority"', async () => {
+  const bad = {
+    tasks: [{
+      id: 'task-1', title: 'Foo', type: 'feature', // priority missing
+      complexity: 3, deps: [], files_modified: [],
+    }],
+  };
+  await assert.rejects(
+    parsePrd('Build Foo', { llmClient: fakeClient(bad) }),
+    (err) => err instanceof PrdParseError && err.code === 'PARSE_FAILED' && /priority/.test(err.message),
+  );
+});
+
+test('parsePrd: invalid enum value rejected — bad type', async () => {
+  const bad = {
+    tasks: [{
+      id: 'task-1', title: 'Foo', type: 'chore', priority: 'P1',
+    }],
+  };
+  await assert.rejects(
+    parsePrd('Build Foo', { llmClient: fakeClient(bad) }),
+    (err) => err instanceof PrdParseError && err.code === 'PARSE_FAILED',
+  );
+});
+
+test('parsePrd: duplicate task id rejected', async () => {
+  const dup = {
+    tasks: [
+      { id: 'task-1', title: 'First copy', type: 'feature', priority: 'P2' },
+      { id: 'task-1', title: 'Second copy', type: 'feature', priority: 'P2' },
+    ],
+  };
+  await assert.rejects(
+    parsePrd('Build dupes', { llmClient: fakeClient(dup) }),
+    (err) => err instanceof PrdParseError && err.code === 'PARSE_FAILED' && /duplicate/i.test(err.message),
+  );
+});
+
+test('parsePrd: missing optional fields are normalized to defaults', async () => {
+  const minimal = {
+    tasks: [{
+      id: 'task-1', title: 'Minimal task', type: 'feature', priority: 'P3',
+    }],
+  };
+  const result = await parsePrd('anything', { llmClient: fakeClient(minimal) });
+  assert.equal(result.tasks[0].complexity, null);
+  assert.deepEqual(result.tasks[0].deps, []);
+  assert.deepEqual(result.tasks[0].files_modified, []);
+  assert.equal(result.tasks[0].tag, null);
+});
+
+test('parsePrd: prompt contains PRD text passed to llmClient', async () => {
+  let captured;
+  const client = {
+    provider: 'anthropic',
+    model: 'claude-sonnet-4-6',
+    async completeJson({ system, user }) {
+      captured = { system, user };
+      return {
+        json: HAPPY_TASKS,
+        raw: '',
+        usage: {},
+        model: 'claude-sonnet-4-6',
+        provider: 'anthropic',
+      };
+    },
+  };
+  await parsePrd('Build the thing with acceptance criteria X', { llmClient: client });
+  assert.match(captured.system, /engineering planner/i);
+  assert.match(captured.user, /Build the thing with acceptance criteria X/);
+});
+
+test('parsePrd: empty tasks array rejected (schema requires minItems:1)', async () => {
+  await assert.rejects(
+    parsePrd('Build nothing', { llmClient: fakeClient({ tasks: [] }) }),
+    (err) => err instanceof PrdParseError && err.code === 'PARSE_FAILED',
+  );
+});
+
+test('TASK_LIST_SCHEMA: exported for downstream consumers', () => {
+  assert.equal(TASK_LIST_SCHEMA.required[0], 'tasks');
+  assert.equal(TASK_LIST_SCHEMA.properties.tasks.minItems, 1);
+});

package/mcp-server/lib/pricing.cjs

@@ -0,0 +1,53 @@
+'use strict';
+
+// Phase 6.2 — Runtime × model pricing table (USD per token).
+//
+// Last updated: 2026-04-17. Public rate cards change — re-check before
+// trusting the cost panel for billing. Numbers below are per token (not
+// per million), so a 1000-token input at 3e-6 costs $0.003.
+//
+// Sources (2026-04):
+//   Claude:  https://www.anthropic.com/pricing
+//   OpenAI:  https://platform.openai.com/docs/pricing
+//   Gemini:  https://ai.google.dev/pricing
+//
+// `default` inside each runtime is the fallback when a session did not
+// record which specific model it used.
+
+const PRICING = Object.freeze({
+  claude: Object.freeze({
+    'claude-opus-4-7':      { input: 15e-6, output: 75e-6 },
+    'claude-sonnet-4-6':    { input: 3e-6,  output: 15e-6 },
+    'claude-haiku-4-5':     { input: 0.8e-6, output: 4e-6 },
+    default:                { input: 3e-6,  output: 15e-6 }, // assume sonnet
+  }),
+  codex: Object.freeze({
+    'gpt-5.4':              { input: 2e-6,  output: 10e-6 },
+    default:                { input: 2e-6,  output: 10e-6 },
+  }),
+  opencode: Object.freeze({
+    // OpenCode is a frontend over whichever model the user configured;
+    // treat as sonnet-equivalent unless a model name is passed in.
+    default:                { input: 3e-6,  output: 15e-6 },
+  }),
+  gemini: Object.freeze({
+    'gemini-2.5-pro':       { input: 1.25e-6, output: 10e-6 },
+    'gemini-2.5-flash':     { input: 0.15e-6, output: 0.6e-6 },
+    default:                { input: 1.25e-6, output: 10e-6 },
+  }),
+});
+
+function computeCost(runtime, model, tokens_input, tokens_output) {
+  const r = PRICING[runtime];
+  if (!r) return null;
+  const p = (model && r[model]) || r.default;
+  if (!p) return null;
+  const ti = Number(tokens_input) || 0;
+  const to = Number(tokens_output) || 0;
+  return ti * p.input + to * p.output;
+}
+
+module.exports = {
+  PRICING,
+  computeCost,
+};

package/mcp-server/lib/projector.cjs

@@ -0,0 +1,158 @@
+'use strict';
+
+// Projector: regenerates the read-only file views from .ultra/state.db.
+//
+// state.db is the only authority (D32). tasks.json and contexts/task-*.md
+// are projections — humans may read them, never write them. The projector
+// is trigger-based: state-ops calls projectAll() after each successful
+// write transaction. Projection output passes the v4.5 schemas under
+// spec/schemas/ — see mcp-server/tests/projector.test.cjs for the
+// round-trip check.
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const SCHEMA_VERSION = '4.5';
+const SOURCE_TAG = '.ultra/state.db';
+
+// Frozen SELECTs — values bind through @placeholders.
+const LIST_TASKS_FOR_PROJECTION_SQL = "SELECT id, title, type, priority, complexity, status, deps, files_modified, session_id, stale, complexity_hint, tag, trace_to, context_file, completion_commit, created_at, updated_at FROM tasks ORDER BY created_at ASC";
+const READ_TASK_FOR_PROJECTION_SQL = "SELECT id, title, type, priority, complexity, status, deps, files_modified, session_id, stale, complexity_hint, tag, trace_to, context_file, completion_commit, created_at, updated_at FROM tasks WHERE id = @id";
+
+function rowToProjection(row) {
+  if (!row) return null;
+  const out = { ...row };
+  for (const k of ['deps', 'files_modified']) {
+    if (typeof out[k] === 'string') {
+      try { out[k] = JSON.parse(out[k]); } catch { out[k] = null; }
+    }
+    if (out[k] === null || out[k] === undefined) delete out[k];
+  }
+  if (out.stale !== undefined && out.stale !== null) out.stale = Boolean(out.stale);
+  for (const k of Object.keys(out)) {
+    if (out[k] === null || out[k] === undefined) delete out[k];
+  }
+  return out;
+}
+
+function defaultPaths(rootDir) {
+  return {
+    tasksJson: path.join(rootDir, '.ultra', 'tasks', 'tasks.json'),
+    contextsDir: path.join(rootDir, '.ultra', 'tasks', 'contexts'),
+  };
+}
+
+function writeAtomic(file, contents) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const tmp = `${file}.tmp-${process.pid}-${Date.now()}`;
+  fs.writeFileSync(tmp, contents);
+  fs.renameSync(tmp, file);
+}
+
+function dbContentTimestamp(db) {
+  const row = db.prepare("SELECT MAX(latest) AS ts FROM (SELECT MAX(updated_at) AS latest FROM tasks UNION ALL SELECT MAX(ts) AS latest FROM events UNION ALL SELECT MAX(applied_at) AS latest FROM schema_version)").get();
+  return (row && row.ts) || new Date(0).toISOString();
+}
+
+function projectTasks(db, { tasksJson } = {}, opts = {}) {
+  const rootDir = opts.rootDir;
+  const target = tasksJson || defaultPaths(rootDir || '.').tasksJson;
+  const rows = db.prepare(LIST_TASKS_FOR_PROJECTION_SQL).all();
+  // generated_at = max(content timestamps) so identical state → identical
+  // bytes → idempotent commits (PLAN Phase 2.6 / Phase 2.8 chore commit).
+  const payload = {
+    schema_version: SCHEMA_VERSION,
+    generated_at: dbContentTimestamp(db),
+    source: SOURCE_TAG,
+    tasks: rows.map(rowToProjection),
+  };
+  writeAtomic(target, JSON.stringify(payload, null, 2) + '\n');
+  return { path: target, count: rows.length };
+}
+
+function buildContextDoc(taskRow, existingBody) {
+  const headerLines = [
+    '---',
+    `task_id: ${taskRow.id}`,
+    `title: ${escapeYaml(taskRow.title)}`,
+    `status: ${taskRow.status}`,
+  ];
+  if (taskRow.priority) headerLines.push(`priority: ${taskRow.priority}`);
+  if (taskRow.type) headerLines.push(`type: ${taskRow.type}`);
+  if (taskRow.session_id) headerLines.push(`session_id: ${taskRow.session_id}`);
+  if (taskRow.completion_commit) headerLines.push(`completion_commit: ${taskRow.completion_commit}`);
+  if (taskRow.stale) headerLines.push('stale: true');
+  headerLines.push(`schema_version: ${SCHEMA_VERSION}`);
+  headerLines.push(`generated_at: ${taskRow.updated_at || new Date().toISOString()}`);
+  headerLines.push('---', '');
+
+  let body = existingBody || '';
+  // Strip any previous STALE banner so re-projection after reset is clean.
+  body = body.replace(/^> ⚠️\s*STALE[^\n]*\n(?:>[^\n]*\n)*\n?/m, '');
+  if (taskRow.stale) {
+    const banner = [
+      `> ⚠️ STALE since ${taskRow.updated_at || new Date().toISOString()}`,
+      '> spec 改动可能让此 task 上下文失效；重新跑 spec 对齐后再继续。',
+      '',
+    ].join('\n');
+    body = banner + body;
+  }
+  return headerLines.join('\n') + body;
+}
+
+function escapeYaml(str) {
+  if (str == null) return '';
+  if (/[:#\[\]\{\}&\*!|>'"%@`]/.test(str) || /^\s|\s$/.test(str)) {
+    return JSON.stringify(str);
+  }
+  return str;
+}
+
+function extractBodyFromExistingFile(file) {
+  if (!fs.existsSync(file)) return '';
+  const text = fs.readFileSync(file, 'utf8');
+  if (!text.startsWith('---')) return text;
+  const end = text.indexOf('\n---', 3);
+  if (end === -1) return text;
+  return text.slice(end + 4).replace(/^\n/, '');
+}
+
+function projectContext(db, taskId, { contextsDir } = {}, opts = {}) {
+  const row = db.prepare(READ_TASK_FOR_PROJECTION_SQL).get({ id: taskId });
+  if (!row) return null;
+  const projection = rowToProjection(row);
+  const dir = contextsDir || defaultPaths(opts.rootDir || '.').contextsDir;
+  const target = projection.context_file
+    ? path.resolve(opts.rootDir || '.', projection.context_file)
+    : path.join(dir, `task-${taskId}.md`);
+  const body = extractBodyFromExistingFile(target);
+  const next = buildContextDoc(projection, body);
+  writeAtomic(target, next);
+  return { path: target, task_id: taskId };
+}
+
+function projectAll(db, { rootDir = '.', tasksJson, contextsDir } = {}) {
+  const paths = defaultPaths(rootDir);
+  const tasksTarget = tasksJson || paths.tasksJson;
+  const contextsTarget = contextsDir || paths.contextsDir;
+
+  const tasksResult = projectTasks(db, { tasksJson: tasksTarget });
+  const contextResults = [];
+  const rows = db.prepare("SELECT id FROM tasks").all();
+  for (const r of rows) {
+    contextResults.push(projectContext(db, r.id, { contextsDir: contextsTarget }, { rootDir }));
+  }
+  return {
+    tasks_json: tasksResult,
+    contexts: contextResults.filter(Boolean),
+  };
+}
+
+module.exports = {
+  SCHEMA_VERSION,
+  defaultPaths,
+  projectTasks,
+  projectContext,
+  projectAll,
+  rowToProjection,
+};