@bongos/core 1.17.0

package/tests/abandon_task.mjs

@@ -0,0 +1,138 @@
+// tests/abandon_task.mjs
+//
+// Regression guard for task 987 — db.abandonTask, the terminal "retire this
+// task" transition (status → 'abandoned'). It is the missing first-class
+// lifecycle move: the GDS had promote/ship/confirm/resolve but no clean way to
+// kill a stale/dup task, so they lingered in 'ready' as claimable noise.
+//
+// Contract under test:
+//   - a live (ready/backlog/blocked/completed/confirmed) task abandons: the
+//     tasks UPDATE runs, the txn COMMITs, previousStatus is reported.
+//   - 'shipped'  → CANNOT_ABANDON_SHIPPED, ROLLBACK, no UPDATE (immutable history).
+//   - active claim → TASK_HAS_ACTIVE_CLAIM, ROLLBACK, no UPDATE (release first).
+//   - 'abandoned' → idempotent no-op: alreadyAbandoned:true, COMMIT, no UPDATE.
+//   - not found → TASK_NOT_FOUND, ROLLBACK.
+//   - the reason binds into value_summary as "Abandoned: <reason>" (NULLIF keeps
+//     the existing summary when no reason is given).
+//   - the shipped guard short-circuits BEFORE the claims lookup runs.
+//
+// abandonTask opens its own transaction via pool.connect(); the #538 deps.pool
+// injection seam (honored ONLY when NODE_ENV==='test') lets us drive it with a
+// SQL-aware fakeClient — no live DB — same posture as confirm_attribution.mjs.
+//
+// Run:  node tests/abandon_task.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import { makeRunner, makeSqlAwareClient } from './helpers.mjs';
+
+process.env.NODE_ENV = 'test';
+
+const require = createRequire(import.meta.url);
+const db = require('../modules/lifecycle/db.js');
+const { abandonTask } = db;
+
+const { test, summary } = makeRunner();
+
+// SQL-aware fake: returns rows by matching the statement, records every call so
+// the test can inspect params + ordering. Order-independent.
+//   notFound       → the FOR UPDATE select matches no row
+//   status         → the row's current status
+//   hasActiveClaim → the claims lookup returns an unreleased claim
+function fakePool({ status = 'ready', notFound = false, hasActiveClaim = false }) {
+  return makeSqlAwareClient((s, params) => {
+      if (/^SELECT id, title, status FROM tasks WHERE id = \$1 FOR UPDATE/.test(s)) {
+        return { rows: notFound ? [] : [{ id: params[0], title: 'fixture task', status }] };
+      }
+      if (/SELECT id FROM claims WHERE task_id = \$1 AND released_at IS NULL/.test(s)) {
+        return { rows: hasActiveClaim ? [{ id: 999 }] : [] };
+      }
+      if (/^UPDATE tasks/.test(s)) {
+        return { rows: [{ id: params[0], title: 'fixture task', status: 'abandoned' }] };
+      }
+      return { rows: [] };   // BEGIN / COMMIT / ROLLBACK
+  });
+}
+
+const find = (queries, re) => queries.find((q) => re.test(String(q.sql).replace(/\s+/g, ' ')));
+const all = (queries, re) => queries.filter((q) => re.test(String(q.sql).replace(/\s+/g, ' ')));
+
+const TASK = 987;
+
+// =========================================================================
+await test('abandon: a ready task flips to abandoned, COMMITs, reports previousStatus', async () => {
+  const pool = fakePool({ status: 'ready' });
+  const out = await abandonTask({ taskId: TASK, reason: 'stale chore' }, { pool });
+
+  assert.equal(out.taskStatus, 'abandoned', 'returns abandoned');
+  assert.equal(out.previousStatus, 'ready', 'reports the prior status');
+  assert.equal(out.alreadyAbandoned, false);
+  assert.ok(find(pool._client.queries, /^UPDATE tasks/), 'the tasks UPDATE must run');
+  assert.ok(find(pool._client.queries, /^COMMIT/), 'must COMMIT');
+  assert.ok(!find(pool._client.queries, /^ROLLBACK/), 'no ROLLBACK on the happy path');
+});
+
+await test('abandon: reason binds into value_summary as "Abandoned: <reason>"', async () => {
+  const pool = fakePool({ status: 'ready' });
+  await abandonTask({ taskId: TASK, reason: 'dup of #925' }, { pool });
+  const upd = find(pool._client.queries, /^UPDATE tasks/);
+  assert.equal(upd.params[0], TASK);
+  assert.equal(upd.params[1], 'Abandoned: dup of #925', 'reason is prefixed + bound to $2');
+});
+
+await test('abandon: no reason binds empty string (NULLIF keeps existing value_summary)', async () => {
+  const pool = fakePool({ status: 'backlog' });
+  await abandonTask({ taskId: TASK }, { pool });
+  const upd = find(pool._client.queries, /^UPDATE tasks/);
+  assert.equal(upd.params[1], '', 'empty reason → empty string so COALESCE(NULLIF(...)) is a no-op');
+});
+
+await test('abandon: a shipped task is refused (immutable history) and rolls back', async () => {
+  const pool = fakePool({ status: 'shipped' });
+  await assert.rejects(
+    () => abandonTask({ taskId: TASK, reason: 'x' }, { pool }),
+    (err) => err.code === 'CANNOT_ABANDON_SHIPPED',
+  );
+  assert.equal(all(pool._client.queries, /^UPDATE tasks/).length, 0, 'must not UPDATE a shipped task');
+  assert.ok(find(pool._client.queries, /^ROLLBACK/), 'must ROLLBACK');
+});
+
+await test('abandon: the shipped guard short-circuits BEFORE the claims lookup', async () => {
+  const pool = fakePool({ status: 'shipped' });
+  await abandonTask({ taskId: TASK }, { pool }).catch(() => {});
+  assert.equal(all(pool._client.queries, /SELECT id FROM claims/).length, 0,
+    'a shipped task must not even query claims');
+});
+
+await test('abandon: a task with an active claim is refused (release first) and rolls back', async () => {
+  const pool = fakePool({ status: 'ready', hasActiveClaim: true });
+  await assert.rejects(
+    () => abandonTask({ taskId: TASK }, { pool }),
+    (err) => err.code === 'TASK_HAS_ACTIVE_CLAIM',
+  );
+  assert.equal(all(pool._client.queries, /^UPDATE tasks/).length, 0, 'must not UPDATE while a claim is live');
+  assert.ok(find(pool._client.queries, /^ROLLBACK/), 'must ROLLBACK');
+});
+
+await test('abandon: an already-abandoned task is an idempotent no-op (no UPDATE, COMMIT)', async () => {
+  const pool = fakePool({ status: 'abandoned' });
+  const out = await abandonTask({ taskId: TASK }, { pool });
+  assert.equal(out.alreadyAbandoned, true, 'reports it was already abandoned');
+  assert.equal(out.taskStatus, 'abandoned');
+  assert.equal(all(pool._client.queries, /^UPDATE tasks/).length, 0, 'idempotent — no second UPDATE');
+  assert.equal(all(pool._client.queries, /SELECT id FROM claims/).length, 0, 'no claims lookup needed');
+  assert.ok(find(pool._client.queries, /^COMMIT/), 'still COMMITs the (empty) txn');
+});
+
+await test('abandon: a missing task throws TASK_NOT_FOUND and rolls back', async () => {
+  const pool = fakePool({ notFound: true });
+  await assert.rejects(
+    () => abandonTask({ taskId: 424242 }, { pool }),
+    (err) => err.code === 'TASK_NOT_FOUND',
+  );
+  assert.equal(all(pool._client.queries, /^UPDATE tasks/).length, 0);
+  assert.ok(find(pool._client.queries, /^ROLLBACK/), 'must ROLLBACK');
+});
+
+// -------------------------------------------------------------------------
+summary();

package/tests/achievements_reconcile.mjs

@@ -0,0 +1,167 @@
+// tests/achievements_reconcile.mjs
+//
+// Unit coverage for task #1679 — the state-based, idempotent
+// reconcileBuilderAchievements (modules/economy/achievements.js). This is the
+// durable replacement for the per-trigger evaluators that silently skipped the
+// confirmTask (--skip-grade / grader_bypass) ship path, so most builders only
+// ever unlocked first-claim.
+//
+// Driven by the shared SQL-aware fake client (no DB): the handler decides, per
+// statement, whether the builder is eligible and what's already unlocked, and
+// records every INSERT so we can assert exactly which achievements unlocked and
+// which credit bonuses were awarded.
+//
+// Run:  node tests/achievements_reconcile.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import { makeRunner, makeSqlAwareClient } from './helpers.mjs';
+
+const require = createRequire(import.meta.url);
+const { reconcileBuilderAchievements, STATE_EVALUATORS } =
+  require('../modules/economy/achievements.js');
+
+const { test, summary } = makeRunner();
+
+// credit_bonus per achievement id (mirrors the seeded values).
+const BONUS = {
+  'first-ship': 1,
+  'first-claim': 1,
+  'first-parallel-claim': 2,
+  'streak-3': 2,
+  'streak-7': 5,
+  'art-pipeline-shipper': 2,
+  'subtractor': 2,
+  'gds-shipper': 2,
+  'breaking-the-100c-bar': 5,
+};
+
+// Build a fake client where `eligible` is the set of achievement ids the builder
+// currently qualifies for, and `unlocked` is the set already in
+// builder_achievements. Returns { client, queries }.
+function fakeClient({ eligible = new Set(), unlocked = new Set(), credits = 0 }) {
+  const yes = { rows: [{ x: 1 }], rowCount: 1 };
+  const no = { rows: [], rowCount: 0 };
+
+  const harness = makeSqlAwareClient((sql, params) => {
+    const s = sql.toLowerCase();
+
+    // --- streak internals first (precise) — resolve longest_streak to 0 so the
+    //     streak predicates report not-eligible. The qualifyingShipDays CTE
+    //     itself contains "SELECT timezone FROM builders WHERE id = $1", so it
+    //     MUST be matched before the standalone-timezone fallback below.
+    if (s.includes('with builder_tz')) return no;                              // ship-days → empty
+    if (s.includes('now() at time zone timezone')) {                          // today-in-tz
+      return { rows: [{ today: '2026-06-30' }], rowCount: 1 };
+    }
+    if (s.includes('select timezone from builders where id = $1')) {           // tz fallback
+      return { rows: [{ timezone: 'UTC' }], rowCount: 1 };
+    }
+
+    // alreadyUnlocked(client, builderId, achievementId)
+    if (s.includes('from builder_achievements where builder_id=$1 and achievement_id=$2')) {
+      return unlocked.has(params[1]) ? yes : no;
+    }
+    // unlockAchievement's lookup
+    if (s.includes('select id, name, credit_bonus from achievements where id=$1')) {
+      const id = params[0];
+      return { rows: [{ id, name: id, credit_bonus: BONUS[id] ?? 0 }], rowCount: 1 };
+    }
+    // writes
+    if (s.startsWith('insert into builder_achievements')) return yes;
+    if (s.startsWith('insert into credit_log')) return yes;
+
+    // --- eligibility predicates -------------------------------------------
+    // first-claim
+    if (s.includes('from claims where builder_id=$1 limit 1')) {
+      return eligible.has('first-claim') ? yes : no;
+    }
+    // first-ship
+    if (s.includes("from claims where builder_id=$1 and outcome='shipped' limit 1")) {
+      return eligible.has('first-ship') ? yes : no;
+    }
+    // art-pipeline-shipper
+    if (s.includes('join tasks t') && s.includes("like 'art/%'")) {
+      return eligible.has('art-pipeline-shipper') ? yes : no;
+    }
+    // gds-shipper
+    if (s.includes('join tasks t') && s.includes("like 'src/bongos/%'")) {
+      return eligible.has('gds-shipper') ? yes : no;
+    }
+    // first-parallel-claim
+    if (s.includes('with shipped as')) {
+      return eligible.has('first-parallel-claim') ? yes : no;
+    }
+    // breaking-the-100c-bar
+    if (s.includes('select total_credits from builders where id = $1')) {
+      return { rows: [{ total_credits: credits }], rowCount: 1 };
+    }
+    // subtractor
+    if (s.includes("reason = 'ship.net_negative'")) {
+      return { rows: [{ n: eligible.has('subtractor') ? 3 : 0 }], rowCount: 1 };
+    }
+    return no;
+  });
+
+  return { client: harness._client, queries: harness.queries };
+}
+
+function unlockedIds(queries) {
+  return queries
+    .filter((q) => String(q.sql).toLowerCase().includes('insert into builder_achievements'))
+    .map((q) => q.params[1]); // (builder_id, achievement_id, ...)
+}
+function bonusIds(queries) {
+  return queries
+    .filter((q) => String(q.sql).toLowerCase().includes('insert into credit_log'))
+    .map((q) => q.params[3]); // (builder_id, task_id, delta, reason='achievement.<id>')
+}
+
+await test('unlocks every eligible+locked achievement and awards each bonus once', async () => {
+  const eligible = new Set(['first-claim', 'first-ship', 'gds-shipper', 'breaking-the-100c-bar']);
+  const { client, queries } = fakeClient({ eligible, credits: 150 });
+
+  const result = await reconcileBuilderAchievements(client, 95, { taskId: 1679 });
+
+  const got = new Set(result.map((r) => r.id));
+  assert.deepEqual(got, eligible, 'returns exactly the eligible set');
+  assert.deepEqual(new Set(unlockedIds(queries)), eligible, 'inserts one builder_achievements row per unlock');
+  // every one of these has credit_bonus > 0 → a credit_log row each
+  assert.deepEqual(
+    new Set(bonusIds(queries)),
+    new Set(['achievement.first-claim', 'achievement.first-ship', 'achievement.gds-shipper', 'achievement.breaking-the-100c-bar']),
+    'awards the credit bonus for each new unlock'
+  );
+});
+
+await test('skips achievements already unlocked (no duplicate insert or bonus)', async () => {
+  // Eligible for first-ship + breaking-100c, but first-ship is already unlocked.
+  const eligible = new Set(['first-ship', 'breaking-the-100c-bar']);
+  const unlocked = new Set(['first-ship']);
+  const { client, queries } = fakeClient({ eligible, unlocked, credits: 200 });
+
+  const result = await reconcileBuilderAchievements(client, 95, {});
+
+  assert.deepEqual(result.map((r) => r.id), ['breaking-the-100c-bar'], 'only the not-yet-unlocked one fires');
+  assert.deepEqual(unlockedIds(queries), ['breaking-the-100c-bar'], 'no insert for the already-unlocked first-ship');
+});
+
+await test('idempotent: everything already unlocked → no writes', async () => {
+  const all = new Set(STATE_EVALUATORS.map((e) => e.id));
+  const { client, queries } = fakeClient({ eligible: all, unlocked: all, credits: 9999 });
+
+  const result = await reconcileBuilderAchievements(client, 95, {});
+
+  assert.equal(result.length, 0, 'returns nothing');
+  assert.equal(unlockedIds(queries).length, 0, 'no builder_achievements inserts');
+  assert.equal(bonusIds(queries).length, 0, 'no credit_log inserts');
+});
+
+await test('not eligible for anything → no writes', async () => {
+  const { client, queries } = fakeClient({ eligible: new Set(), credits: 0 });
+  const result = await reconcileBuilderAchievements(client, 95, {});
+  assert.equal(result.length, 0);
+  assert.equal(unlockedIds(queries).length, 0);
+});
+
+summary();

package/tests/adopt_detect.mjs

@@ -0,0 +1,141 @@
+// tests/adopt_detect.mjs
+//
+// ADR 0121 §Decision 4 / task 2043 — `bongos init --adopt` inspects an EXISTING repo
+// (language/runtime, package manager, tests, CI, layout, pre-existing surfaces) so
+// layering fits what is already there. Pins detectStack against temp-dir fixtures +
+// the pure detectPackageManager precedence + formatStackSummary rendering.
+//
+// Run:  node tests/adopt_detect.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+const require = createRequire(import.meta.url);
+const { detectStack, detectPackageManager, formatStackSummary } = require('../scripts/gds/adopt-detect.js');
+
+let passed = 0;
+let failed = 0;
+function t(name, fn) {
+  try { fn(); passed++; console.log(`  PASS  ${name}`); }
+  catch (e) { failed++; console.log(`  FAIL  ${name}\n        ${e.message}`); }
+}
+
+// Build a throwaway repo tree from a { relPath: contents } map and hand its dir to fn.
+function withRepo(files, fn) {
+  const dir = mkdtempSync(join(tmpdir(), 'detect-'));
+  try {
+    for (const [rel, content] of Object.entries(files)) {
+      const abs = join(dir, rel);
+      mkdirSync(join(abs, '..'), { recursive: true });
+      writeFileSync(abs, content);
+    }
+    fn(dir);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+// ---- detectPackageManager (pure precedence) --------------------------------
+t('detectPackageManager: lockfile precedence pnpm > yarn > bun > npm; package.json→npm; none→null', () => {
+  const has = (...present) => (rel) => present.includes(rel);
+  assert.equal(detectPackageManager(has('pnpm-lock.yaml', 'yarn.lock', 'package-lock.json'), true), 'pnpm');
+  assert.equal(detectPackageManager(has('yarn.lock', 'package-lock.json'), true), 'yarn');
+  assert.equal(detectPackageManager(has('package-lock.json'), true), 'npm');
+  assert.equal(detectPackageManager(has(), true), 'npm');   // package.json but no lockfile → npm
+  assert.equal(detectPackageManager(has(), false), null);   // no package.json, no lockfile → null
+});
+
+// ---- detectStack: node / TS repo -------------------------------------------
+t('detectStack: node+typescript, pnpm, jest, github-actions, src layout, migrations', () => {
+  withRepo({
+    'package.json': JSON.stringify({ name: 'their-app', scripts: { test: 'jest' }, devDependencies: { jest: '^29' } }),
+    'pnpm-lock.yaml': 'lockfileVersion: 5.4\n',
+    'tsconfig.json': '{}',
+    '.github/workflows/ci.yml': 'name: ci\n',
+    '.github/workflows/release.yaml': 'name: release\n',
+    'src/index.ts': 'export {}',
+    'migrations/001_init.sql': 'create table x();',
+    'config/app.json': '{}',
+  }, (dir) => {
+    const s = detectStack({ dir });
+    assert.equal(s.runtime, 'node');
+    assert.ok(s.languages.includes('typescript'));
+    assert.equal(s.packageManager, 'pnpm');
+    assert.equal(s.packageName, 'their-app');
+    assert.deepEqual(s.testFrameworks, ['jest']);
+    assert.equal(s.hasTestScript, true);
+    assert.equal(s.ci.length, 1);
+    assert.equal(s.ci[0].system, 'github-actions');
+    assert.deepEqual(s.ci[0].workflows, ['ci.yml', 'release.yaml']); // sorted, both extensions
+    assert.deepEqual(s.sourceDirs, ['src']);
+    assert.equal(s.hasMigrations, true);
+    assert.deepEqual(s.migrationsDirs, ['migrations']);
+    assert.equal(s.hasConfigDir, true);
+    assert.equal(s.hasClaudeDir, false);
+    assert.equal(s.isEmptyRepo, false);
+  });
+});
+
+// ---- detectStack: python repo ----------------------------------------------
+t('detectStack: python via requirements.txt + pytest, no package manager', () => {
+  withRepo({
+    'requirements.txt': 'flask\npytest\n',
+    'pytest.ini': '[pytest]\n',
+    'app/main.py': 'print(1)',
+    '.gitlab-ci.yml': 'stages: [test]\n',
+  }, (dir) => {
+    const s = detectStack({ dir });
+    assert.equal(s.runtime, 'python');
+    assert.ok(s.languages.includes('python'));
+    assert.equal(s.packageManager, null);       // no node lockfile / package.json
+    assert.equal(s.hasPackageJson, false);
+    assert.ok(s.testFrameworks.includes('pytest'));
+    assert.equal(s.ci[0].system, 'gitlab-ci');
+    assert.deepEqual(s.sourceDirs, ['app']);
+  });
+});
+
+// ---- detectStack: empty repo -----------------------------------------------
+t('detectStack: an empty repo → isEmptyRepo, runtime unknown, everything negative', () => {
+  withRepo({}, (dir) => {
+    const s = detectStack({ dir });
+    assert.equal(s.isEmptyRepo, true);
+    assert.equal(s.runtime, 'unknown');
+    assert.equal(s.packageManager, null);
+    assert.equal(s.hasMigrations, false);
+    assert.deepEqual(s.topLevelDirs, []);
+    assert.deepEqual(s.ci, []);
+  });
+});
+
+t('detectStack: never throws on a missing dir; requires a dir arg', () => {
+  const s = detectStack({ dir: join(tmpdir(), 'definitely-does-not-exist-detect-xyz') });
+  assert.equal(s.runtime, 'unknown');
+  assert.equal(s.isEmptyRepo, true);
+  assert.throws(() => detectStack({}), /dir is required/);
+});
+
+// ---- formatStackSummary ----------------------------------------------------
+t('formatStackSummary: renders the load-bearing lines; flags migrations + carried dirs', () => {
+  const lines = formatStackSummary({
+    runtime: 'node', languages: ['typescript'], packageManager: 'pnpm',
+    testFrameworks: ['jest'], hasTestScript: true,
+    ci: [{ system: 'github-actions', workflows: ['ci.yml'] }],
+    topLevelDirs: ['src'], sourceDirs: ['src'],
+    migrationsDirs: ['migrations'], hasMigrations: true,
+    hasClaudeDir: true, hasConfigDir: false, isEmptyRepo: false,
+  });
+  const blob = lines.join('\n');
+  assert.match(blob, /runtime: node \(typescript\)/);
+  assert.match(blob, /package manager: pnpm/);
+  assert.match(blob, /tests: jest/);
+  assert.match(blob, /CI: github-actions/);
+  assert.match(blob, /migrations: migrations/);
+  assert.match(blob, /already carries: \.claude\//);
+});
+
+console.log(`\nadopt_detect: ${passed} passed, ${failed} failed`);
+process.exit(failed ? 1 : 0);

package/tests/adopt_import.mjs

@@ -0,0 +1,132 @@
+// tests/adopt_import.mjs
+//
+// ADR 0121 §Decision 3 / task 2044 — `bongos init --adopt` imports an existing repo's
+// backlog into GDS tasks so the ledger starts truthful. Pins the pure parsers
+// (parseBacklogFile, parseGitHubIssues), the file finder, the injectable GitHub fetch,
+// and the resolveBacklogTasks source precedence.
+//
+// Run:  node tests/adopt_import.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import { mkdtempSync, writeFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+const require = createRequire(import.meta.url);
+const imp = require('../scripts/gds/adopt-import.js');
+
+let passed = 0;
+let failed = 0;
+async function t(name, fn) {
+  try { await fn(); passed++; console.log(`  PASS  ${name}`); }
+  catch (e) { failed++; console.log(`  FAIL  ${name}\n        ${e.message}`); }
+}
+
+await t('parseBacklogFile: checklist + bullets + numbered; skips [x] done; carries heading context', () => {
+  const md = [
+    '# Roadmap', '## Now',
+    '- [ ] Ship the login page',
+    '- [x] Set up CI',            // done → skip
+    '* Refactor the API client',
+    '1. Add dark mode',
+    'not a list item',            // ignored
+  ].join('\n');
+  const tasks = imp.parseBacklogFile(md);
+  assert.deepEqual(tasks.map((x) => x.title), ['Ship the login page', 'Refactor the API client', 'Add dark mode']);
+  assert.match(tasks[0].body, /under "Now"/);
+});
+
+await t('parseBacklogFile: empty / null / prose → []', () => {
+  assert.deepEqual(imp.parseBacklogFile(''), []);
+  assert.deepEqual(imp.parseBacklogFile(null), []);
+  assert.deepEqual(imp.parseBacklogFile('just prose, no list'), []);
+});
+
+await t('findBacklogFile: finds TODO.md at the root; null when none', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'imp-'));
+  try {
+    assert.equal(imp.findBacklogFile(dir), null);
+    writeFileSync(join(dir, 'TODO.md'), '- [ ] x');
+    assert.equal(imp.findBacklogFile(dir), 'TODO.md');
+  } finally { rmSync(dir, { recursive: true, force: true }); }
+});
+
+await t('parseGitHubIssues: keeps open issues, drops pull requests + closed; non-array → []', () => {
+  const tasks = imp.parseGitHubIssues([
+    { number: 1, title: 'Bug: crash on save', state: 'open', html_url: 'https://gh/1' },
+    { number: 2, title: 'A pull request', state: 'open', pull_request: { url: 'x' } }, // PR → drop
+    { number: 3, title: 'Closed thing', state: 'closed' },                             // closed → drop
+    { number: 4, title: 'Feature: export CSV', html_url: 'https://gh/4' },             // no state → open
+  ]);
+  assert.deepEqual(tasks.map((x) => x.title), ['Bug: crash on save', 'Feature: export CSV']);
+  assert.match(tasks[0].body, /https:\/\/gh\/1/);
+  assert.deepEqual(imp.parseGitHubIssues(null), []);
+  assert.deepEqual(imp.parseGitHubIssues({}), []);
+});
+
+await t('fetchGitHubIssues: happy path returns parsed tasks; auth header + repo URL used', async () => {
+  let seenUrl = null, seenAuth = null;
+  const fetchImpl = async (url, opts) => { seenUrl = url; seenAuth = opts.headers.Authorization; return { ok: true, json: async () => [{ number: 7, title: 'Do the thing', state: 'open' }] }; };
+  const out = await imp.fetchGitHubIssues({ owner: 'acme', repo: 'web', token: 'ghp_x', fetchImpl });
+  assert.equal(out.length, 1);
+  assert.equal(out[0].title, 'Do the thing');
+  assert.match(seenUrl, /repos\/acme\/web\/issues\?state=open/);
+  assert.equal(seenAuth, 'Bearer ghp_x');
+});
+
+await t('fetchGitHubIssues: no token → [] without calling fetch; non-ok + throw → [] (best-effort)', async () => {
+  let called = false;
+  const spy = async () => { called = true; return { ok: true, json: async () => [] }; };
+  assert.deepEqual(await imp.fetchGitHubIssues({ owner: 'a', repo: 'b', token: null, fetchImpl: spy }), []);
+  assert.equal(called, false, 'no token → never calls fetch');
+  const warns = [];
+  assert.deepEqual(await imp.fetchGitHubIssues({ owner: 'a', repo: 'b', token: 't', fetchImpl: async () => ({ ok: false, status: 403 }), onWarn: (m) => warns.push(m) }), []);
+  assert.deepEqual(await imp.fetchGitHubIssues({ owner: 'a', repo: 'b', token: 't', fetchImpl: async () => { throw new Error('network'); }, onWarn: (m) => warns.push(m) }), []);
+  assert.equal(warns.length, 2, 'both failures warned, neither threw');
+});
+
+await t('resolveBacklogTasks: explicit file > github > auto-file > none', async () => {
+  const dir = mkdtempSync(join(tmpdir(), 'imp-'));
+  try {
+    writeFileSync(join(dir, 'TODO.md'), '- Auto detected task\n');
+    writeFileSync(join(dir, 'my-backlog.md'), '- Explicit task\n');
+    const ghFetch = async () => ({ ok: true, json: async () => [{ number: 1, title: 'GitHub task', state: 'open' }] });
+
+    const explicit = await imp.resolveBacklogTasks({ dir, repo: { owner: 'a', name: 'b' }, githubToken: 't', backlogFile: 'my-backlog.md', fetchImpl: ghFetch });
+    assert.equal(explicit.source, 'my-backlog.md');
+    assert.equal(explicit.tasks[0].title, 'Explicit task');
+
+    const gh = await imp.resolveBacklogTasks({ dir, repo: { owner: 'a', name: 'b' }, githubToken: 't', fetchImpl: ghFetch });
+    assert.equal(gh.source, 'github-issues');
+    assert.equal(gh.tasks[0].title, 'GitHub task');
+
+    const file = await imp.resolveBacklogTasks({ dir, repo: { owner: 'a', name: 'b' }, githubToken: null });
+    assert.equal(file.source, 'TODO.md');
+    assert.equal(file.tasks[0].title, 'Auto detected task');
+    assert.equal(file.tasks[0].kind, 'unclassified');
+  } finally { rmSync(dir, { recursive: true, force: true }); }
+});
+
+await t('resolveBacklogTasks: nothing anywhere → source none, empty tasks', async () => {
+  const dir = mkdtempSync(join(tmpdir(), 'imp-'));
+  try {
+    const r = await imp.resolveBacklogTasks({ dir, repo: {}, githubToken: null });
+    assert.equal(r.source, 'none');
+    assert.deepEqual(r.tasks, []);
+  } finally { rmSync(dir, { recursive: true, force: true }); }
+});
+
+await t('resolveBacklogTasks: caps the import at DEFAULT_MAX + flags truncation', async () => {
+  const dir = mkdtempSync(join(tmpdir(), 'imp-'));
+  try {
+    const many = Array.from({ length: imp.DEFAULT_MAX + 10 }, (_, i) => `- task ${i}`).join('\n');
+    writeFileSync(join(dir, 'BACKLOG.md'), many);
+    const r = await imp.resolveBacklogTasks({ dir, githubToken: null });
+    assert.equal(r.tasks.length, imp.DEFAULT_MAX);
+    assert.equal(r.truncated, true);
+  } finally { rmSync(dir, { recursive: true, force: true }); }
+});
+
+console.log(`\nadopt_import: ${passed} passed, ${failed} failed`);
+process.exit(failed ? 1 : 0);