@bongos/core 1.23.22 → 1.24.1

package/scripts/bongos/backfill-disciplines.js

@@ -1,144 +0,0 @@
-#!/usr/bin/env node
-// scripts/bongos/backfill-disciplines.js — task 1002988: give every role-less task a craft.
-//
-// WHY THIS EXISTS SEPARATELY FROM THE MIGRATION. core_247 narrows
-// tasks_discipline_check to {engineer, artist, ideator, ui} and carries a
-// last-resort `UPDATE ... SET discipline='engineer'` so a fresh install can never
-// be blocked on a human remembering to run a script. But that net is a blunt
-// guess. The real classification is classifyTaskDiscipline() — a JS heuristic over
-// title + description + touches that SQL cannot express — so the good pass runs
-// here, first, and the migration only catches what is left.
-//
-// Run this BEFORE deploying core_247. Order matters: rows this script resolves keep
-// a reasoned craft; rows it does not are parked on 'engineer' by the migration.
-//
-// USAGE
-//   node scripts/bongos/backfill-disciplines.js              # dry run — the spot-check list
-//   node scripts/bongos/backfill-disciplines.js --apply      # commit the PATCHes
-//   node scripts/bongos/backfill-disciplines.js --sample 40  # widen the printed sample
-//
-// The dry run is the default on purpose: the task required a spot-check list for the
-// owner BEFORE anything was applied, and 1,189 rows is not a diff anyone reviews in
-// their head.
-
-'use strict';
-
-const { cliClient, requireSession } = require('./cli-lib');
-const { resolveWriteDiscipline, WRITABLE_DISCIPLINES } = require('../../modules/lifecycle/task-classifier.js');
-
-// Rows whose title marks them as test debris. The classifier already skips these
-// (they are not real work), but they still carry 'unclassified' and therefore still
-// violate the narrowed constraint — so they must be resolved, not skipped, or the
-// migration's net silently becomes the thing that handles 164 rows.
-const SMOKE_RE = /__smoke__/;
-
-// The fallback for anything the heuristic refuses. Stated as a constant with its
-// reasoning rather than inlined, because this value is a GUESS and every report
-// below labels it as one.
-const FALLBACK = 'engineer';
-
-function classify(task) {
-  const resolved = resolveWriteDiscipline({
-    title: task.title, description: task.description, touches: task.touches,
-  });
-  if (resolved.discipline) {
-    return { discipline: resolved.discipline, reasoned: true, confidence: resolved.confidence ?? null };
-  }
-  return { discipline: FALLBACK, reasoned: false, confidence: null };
-}
-
-const { sleep } = require('../../src/sleep'); // the one shared sleep (task 1004893)
-
-// PATCH one row, WAITING OUT the per-session rate limit rather than counting it as a
-// failure. The first run of this backfill treated a 429 as a failed row and stopped
-// having written 120 of 1,189 — the limiter was doing its job and the script was
-// reading "slow down" as "no". The server tells us how long to wait; honour it.
-// Re-running is safe either way: the query only returns rows still unclassified.
-async function patchWithBackoff(api, id, discipline, maxAttempts = 6) {
-  for (let attempt = 1; ; attempt += 1) {
-    const res = await api.tasks.patchTasksId({ id, body: { discipline } });
-    if (res.status !== 429 || attempt >= maxAttempts) return res;
-    const retryAfter = Number(res.data?.error?.details?.retry_after_seconds);
-    const waitMs = (Number.isFinite(retryAfter) && retryAfter > 0 ? retryAfter : 2 ** attempt) * 1000;
-    console.log(`    rate limited — waiting ${Math.round(waitMs / 1000)}s (attempt ${attempt}/${maxAttempts - 1})`);
-    await sleep(waitMs + 500);
-  }
-}
-
-async function main() {
-  const args = process.argv.slice(2);
-  const apply = args.includes('--apply');
-  const sampleIdx = args.indexOf('--sample');
-  const sampleSize = sampleIdx >= 0 ? Number(args[sampleIdx + 1]) || 20 : 20;
-
-  await requireSession();
-  const api = await cliClient();
-
-  const r = await api.tasks.getTasks({ query: { discipline: 'unclassified' } });
-  if (!r.ok) {
-    console.error(`failed to read tasks (${r.status}):`, r.data);
-    process.exit(1);
-  }
-  const tasks = r.data?.tasks || [];
-  if (!tasks.length) {
-    console.log('Nothing to do — no task carries discipline=unclassified.');
-    return;
-  }
-
-  const plan = tasks.map((t) => ({ task: t, ...classify(t), smoke: SMOKE_RE.test(t.title || '') }));
-  const reasoned = plan.filter((p) => p.reasoned);
-  const guessed = plan.filter((p) => !p.reasoned);
-  const byDiscipline = {};
-  for (const p of plan) byDiscipline[p.discipline] = (byDiscipline[p.discipline] || 0) + 1;
-
-  console.log(`\n${apply ? 'Applying' : 'DRY RUN —'} discipline backfill over ${plan.length} role-less task(s)\n`);
-  console.log('  Resolved by the classifier (a reasoned answer):');
-  for (const [d, n] of Object.entries(byDiscipline).sort((a, b) => b[1] - a[1])) {
-    const reasonedN = reasoned.filter((p) => p.discipline === d).length;
-    console.log(`    ${d.padEnd(12)} ${String(reasonedN).padStart(5)}`);
-  }
-  console.log(`\n  BEST GUESS (classifier refused → ${FALLBACK}): ${guessed.length}`);
-  console.log(`    of which __smoke__ test debris:            ${guessed.filter((p) => p.smoke).length}`);
-  console.log('    These are NOT determined answers. A later reader must not treat');
-  console.log('    them as evidence that anyone classified the row (owner decision 2026-09-17).\n');
-
-  console.log(`  Spot-check sample — reasoned (first ${sampleSize}):`);
-  for (const p of reasoned.slice(0, sampleSize)) {
-    console.log(`    ${p.discipline.padEnd(9)} ${p.confidence != null ? `(${p.confidence.toFixed(2)})` : '      '}  ${String(p.task.title).slice(0, 72)}`);
-  }
-  console.log(`\n  Spot-check sample — GUESSED (first ${sampleSize}):`);
-  for (const p of guessed.filter((x) => !x.smoke).slice(0, sampleSize)) {
-    console.log(`    ${p.discipline.padEnd(9)}          ${String(p.task.title).slice(0, 72)}`);
-  }
-
-  if (!apply) {
-    console.log(`\nDry run — nothing was written. Re-run with --apply to commit.\n`);
-    return;
-  }
-
-  let ok = 0;
-  const failures = [];
-  for (const p of plan) {
-    const res = await patchWithBackoff(api, p.task.id, p.discipline);
-    if (res.ok) ok += 1;
-    else failures.push({ id: p.task.id, status: res.status, detail: JSON.stringify(res.data).slice(0, 160) });
-    if (ok % 100 === 0 && res.ok) console.log(`  … ${ok}/${plan.length}`);
-  }
-  console.log(`\nApplied: ${ok}/${plan.length}`);
-  if (failures.length) {
-    console.log(`Failed:  ${failures.length}`);
-    for (const f of failures.slice(0, 20)) console.log(`   #${f.id} → ${f.status} ${f.detail}`);
-    process.exitCode = 1;
-  }
-  // Report the residue against the same query, so the number quoted afterwards is
-  // measured rather than assumed.
-  const after = await api.tasks.getTasks({ query: { discipline: 'unclassified' } });
-  const left = after.ok ? (after.data?.tasks || []).length : null;
-  console.log(`Remaining unclassified: ${left == null ? '(re-read failed)' : left}`);
-}
-
-if (require.main === module) {
-  main().catch((e) => { console.error(e && e.message ? e.message : e); process.exit(1); });
-}
-
-module.exports = { classify, FALLBACK, SMOKE_RE };

package/scripts/bongos/backfill-session-earnings.js

@@ -1,123 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-// scripts/bongos/backfill-session-earnings.js — repair the historical
-// `session_records.drachmae_earned` mirror (task 1003634).
-//
-// WHAT THIS IS, and what it emphatically is NOT. It moves NO money. It writes no
-// `credit_log` row, mints nothing, and cannot change any builder's balance. It
-// rewrites ONE display column to agree with the ledger that already exists. That
-// makes it categorically unlike its neighbours here (backfill-task-rewards.js,
-// backfill-subagent-rewards.js), which mint credits and carry an ADR 0097 /
-// ADR 0173 safety model to match. Read this one as a data repair.
-//
-// WHY IT IS NEEDED. `drachmae_earned` means "the credit_log delta attributable to
-// this session" (migration 062), but the only thing that ever wrote it summed
-// rows keyed on `task_id`. The cost-plus session reward (ADR 0054) keys on
-// `session_id` and leaves `task_id` NULL on purpose, because it pays for the
-// session's real token spend rather than for any one task in it. So the mirror
-// could not see it. Under reward mode `cost-plus-only` (ADR 0146 — this
-// instance's standing choice) that reward is the ONLY stream that pays, so the
-// column read 0 for essentially every session, and the hall told builders they
-// had earned nothing for work they had genuinely been paid for. A builder
-// reported it as missing pay; the pay was never missing, this number was.
-//
-// WHY THE LIVE FIX DOES NOT COVER HISTORY. The code fix re-derives the figure
-// whenever a reward books, and all three pay-on-land triggers now funnel through
-// that. But none of them revisits a session that is already paid in full — the
-// state-based sweep explicitly skips any session that already has a
-// `session.token_reward` row. So already-paid history never self-heals, which is
-// precisely the history a builder looks at. Hence a one-shot pass.
-//
-// SAFETY. DRY-RUN BY DEFAULT: with no flags it prints the plan and writes
-// nothing. `--apply` performs the UPDATEs. Idempotent by construction — every
-// row is SET to a value derived wholly from current ledger state, so re-running
-// lands on the same numbers, and a row already correct is skipped and reported
-// as such. `--builder N` scopes the pass to one builder (useful for verifying on
-// a single account before the full sweep).
-//
-// Run:  node scripts/bongos/backfill-session-earnings.js [--builder N] [--limit N]
-//       node scripts/bongos/backfill-session-earnings.js --apply
-
-const path = require('node:path');
-
-const credits = require('../../modules/economy/credits');
-const { arg, hasFlag } = require('./cli-lib');
-
-const REPO_ROOT = path.resolve(__dirname, '..', '..');
-
-function loadPool() {
-  const { pool } = require(path.join(REPO_ROOT, 'src/bongos/pool'));
-  return pool;
-}
-
-async function main() {
-  const apply = hasFlag('--apply');
-  const builderArg = arg('--builder');
-  const limitArg = Number(arg('--limit'));
-  const limit = Number.isFinite(limitArg) && limitArg > 0 ? Math.trunc(limitArg) : null;
-
-  const pool = loadPool();
-  const client = await pool.connect();
-  let changed = 0;
-  let alreadyCorrect = 0;
-  let scanned = 0;
-  let deltaTotal = 0;
-  const examples = [];
-
-  try {
-    const params = [];
-    let where = 'WHERE sr.session_id IS NOT NULL';
-    if (builderArg) { params.push(builderArg); where += ` AND sr.builder_id = $${params.length}`; }
-    let sql = `SELECT sr.session_id, sr.builder_id, sr.task_ids, sr.drachmae_earned,
-                      b.github_login
-                 FROM session_records sr
-                 JOIN builders b ON b.id = sr.builder_id
-                 ${where}
-                ORDER BY sr.uploaded_at DESC`;
-    if (limit) { params.push(limit); sql += ` LIMIT $${params.length}`; }
-
-    const { rows } = await client.query(sql, params);
-    scanned = rows.length;
-
-    for (const r of rows) {
-      const ids = Array.isArray(r.task_ids)
-        ? r.task_ids.map((n) => Number(n)).filter(Number.isFinite)
-        : [];
-      // The same two-key sum the live path uses — one definition, so a repaired
-      // row and a freshly-synced row can never disagree.
-      const truth = await credits.sumSessionEarnings(client, r.builder_id, ids, r.session_id);
-      const was = Number(r.drachmae_earned) || 0;
-      if (truth === was) { alreadyCorrect++; continue; }
-      changed++;
-      deltaTotal += (truth - was);
-      if (examples.length < 15) {
-        examples.push(`  ${String(r.github_login).padEnd(18)} ${r.session_id.slice(0, 8)}  ${was} → ${truth}`);
-      }
-      if (apply) {
-        await client.query(
-          `UPDATE session_records SET drachmae_earned = $3
-            WHERE session_id = $1 AND builder_id = $2`,
-          [r.session_id, r.builder_id, truth]
-        );
-      }
-    }
-  } finally {
-    client.release();
-    await pool.end().catch(() => {});
-  }
-
-  console.log(`\nsession-earnings backfill — ${apply ? 'APPLIED' : 'DRY RUN (no writes)'}`);
-  console.log(`  sessions scanned    ${scanned}`);
-  console.log(`  already correct     ${alreadyCorrect}`);
-  console.log(`  ${apply ? 'repaired' : 'would repair'}${apply ? '            ' : '        '}${changed}`);
-  console.log(`  net mirror change   ${deltaTotal >= 0 ? '+' : ''}${deltaTotal} drachmae of DISPLAY (no money moved)`);
-  if (examples.length > 0) {
-    console.log(`\n  sample rows:\n${examples.join('\n')}`);
-  }
-  if (!apply && changed > 0) {
-    console.log(`\n  re-run with --apply to write these.`);
-  }
-}
-
-main().catch((err) => { console.error(err); process.exit(1); });

package/scripts/bongos/backfill-session-types.js

@@ -1,87 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-// scripts/bongos/backfill-session-types.js — classify the sessions that predate the
-// classifier (task 1003975, from idea 1001033).
-//
-// WHAT THIS IS, and what it is NOT. It writes ONE column, `session_records.session_type`,
-// and only where that column is NULL. It moves no money, books no reward, touches
-// no `task_ids` and creates no attribution. That separation is deliberate and it
-// is the lesson this module already paid for once: the attribution sweep had to be
-// windowed because it ran on the same tick as a payout and would have minted a mass
-// retroactive payment nobody authorised (see the warning in modules/sessions/CLAUDE.md).
-// A sweep that both labels and pays is the wrong shape whatever its intent, so this
-// one cannot pay even in principle — db.setSessionType writes that column alone.
-//
-// WHY IT IS NEEDED. The upload path classifies every session from now on, but the
-// corpus is ~4,600 rows old and none of them carry a verdict. Without this pass the
-// ledger's new filter would only ever see today's sessions, which is exactly the
-// half of the corpus nobody needs help reading.
-//
-// SAFETY. DRY-RUN BY DEFAULT: with no flags it classifies in memory, prints the
-// distribution it WOULD write, and writes nothing. `--apply` performs the UPDATEs.
-// Idempotent by construction: the verdict is a pure function of the row's own
-// stored digest, so a re-run lands on the same answer, and a row that already has
-// a type is never revisited (the query selects `WHERE session_type IS NULL`).
-// `--limit N` bounds one pass so the first apply can be small and checked.
-//
-// Run:  node scripts/bongos/backfill-session-types.js [--limit N]
-//       node scripts/bongos/backfill-session-types.js --apply
-
-const { classifySession, SESSION_TYPES } = require('../../modules/sessions/session-type');
-const db = require('../../modules/sessions/db');
-const { arg, hasFlag } = require('./cli-lib');
-
-const BATCH = 500;
-
-async function main() {
-  const apply = hasFlag('--apply');
-  const limitArg = Number(arg('--limit'));
-  const cap = Number.isFinite(limitArg) && limitArg > 0 ? Math.trunc(limitArg) : Infinity;
-
-  const tally = Object.fromEntries(SESSION_TYPES.map((t) => [t, 0]));
-  let scanned = 0;
-  let written = 0;
-
-  // Paged rather than one big SELECT: `detail` is a jsonb per row and the corpus
-  // is the largest table this module owns, so pulling it whole would hold the
-  // entire transcript corpus in memory at once for no gain.
-  for (;;) {
-    const room = Math.min(BATCH, cap - scanned);
-    if (room <= 0) break;
-    const rows = await db.unclassifiedSessions(room);
-    if (rows.length === 0) break;
-    for (const row of rows) {
-      const type = classifySession({ detail: row.detail, metrics: row.metrics });
-      tally[type] = (tally[type] || 0) + 1;
-      scanned++;
-      if (apply) written += await db.setSessionType(row.id, type);
-    }
-    // A dry run never writes, so the same unclassified page comes back forever.
-    // One page is enough to show the shape; say so rather than looping.
-    if (!apply) break;
-  }
-
-  console.log(`\nsession-type backfill — ${apply ? 'APPLIED' : 'DRY RUN (no writes)'}`);
-  console.log(`  rows classified     ${scanned}`);
-  if (apply) console.log(`  rows written        ${written}`);
-  console.log(`  distribution:`);
-  for (const t of SESSION_TYPES) {
-    const n = tally[t] || 0;
-    const pct = scanned ? ` (${Math.round((n / scanned) * 100)}%)` : '';
-    console.log(`    ${t.padEnd(14)} ${String(n).padStart(6)}${pct}`);
-  }
-
-  if (apply) {
-    console.log(`\n  corpus now:`);
-    for (const r of await db.sessionTypeCounts()) {
-      console.log(`    ${String(r.type).padEnd(14)} ${String(r.n).padStart(6)}`);
-    }
-  } else if (scanned > 0) {
-    console.log(`\n  dry run reads one page of ${BATCH}; re-run with --apply to write and walk the whole corpus.`);
-  }
-}
-
-main()
-  .then(() => process.exit(0))
-  .catch((err) => { console.error(err); process.exit(1); });

package/scripts/bongos/build-bongos.js

@@ -1,94 +0,0 @@
-#!/usr/bin/env node
-// scripts/bongos/build-bongos.js — compile the standalone `bongos` CLI binaries
-// (GDS-V4 · V4.R81 · task 1248). CI (.github/workflows/build-bongos-cli.yml) runs
-// this; a maintainer can run it locally too.
-//
-// Uses `bun build --compile`, which CROSS-compiles every target from a single
-// host (mac arm64/x64, linux x64/arm64, windows x64) — no per-OS runner matrix.
-// The binary is fully self-contained: no Node, no repo needed at runtime. The
-// on-ramp verbs (login/box/shell/code/init/reauth) are bundled + dispatched
-// in-process by bin/bongos.js (its COMPILED branch); work verbs print how to get
-// a real environment.
-//
-//   node scripts/bongos/build-bongos.js                 # all targets → dist/
-//   node scripts/bongos/build-bongos.js --target mac-arm64
-//   node scripts/bongos/build-bongos.js --outdir /tmp/out
-//
-// Output filenames match config/bongos-cli.json's `assets` exactly (so the
-// /downloads/bongos redirects resolve after `gh release create`). Version comes
-// from that same config — the single source of truth for a release.
-
-'use strict';
-
-const fs = require('node:fs');
-const path = require('node:path');
-const { spawnSync } = require('node:child_process');
-const { arg } = require('./cli-lib');
-
-const REPO_ROOT = path.join(__dirname, '..', '..');
-const ENTRY = path.join(REPO_ROOT, 'bin', 'bongos.js');
-const cfg = require(path.join(REPO_ROOT, 'config', 'bongos-cli.json'));
-const VERSION = cfg.version;
-
-// target key (matches config assets) → { bunTarget, asset filename }
-const TARGETS = {
-  'mac-arm64': { bun: 'bun-darwin-arm64', file: cfg.assets['mac-arm64'] },
-  'mac-x64': { bun: 'bun-darwin-x64', file: cfg.assets['mac-x64'] },
-  'linux-x64': { bun: 'bun-linux-x64', file: cfg.assets['linux-x64'] },
-  'linux-arm64': { bun: 'bun-linux-arm64', file: cfg.assets['linux-arm64'] },
-  'win-x64': { bun: 'bun-windows-x64', file: cfg.assets['win-x64'] },
-};
-
-function bunPresent() {
-  const r = spawnSync('bun', ['--version'], { encoding: 'utf8', shell: process.platform === 'win32' });
-  return !!r && !r.error && r.status === 0;
-}
-
-function build(one, outDir) {
-  const t = TARGETS[one];
-  if (!t) throw new Error(`unknown target "${one}" (known: ${Object.keys(TARGETS).join(', ')})`);
-  if (!t.file) throw new Error(`config/bongos-cli.json has no asset for target "${one}"`);
-  const outfile = path.join(outDir, t.file);
-  console.log(`  building ${one} → ${path.relative(REPO_ROOT, outfile)} (${t.bun})`);
-  const r = spawnSync(
-    'bun',
-    ['build', '--compile', `--target=${t.bun}`, ENTRY, '--outfile', outfile],
-    { stdio: 'inherit', cwd: REPO_ROOT, shell: process.platform === 'win32' }
-  );
-  if (!r || r.error || r.status !== 0) {
-    throw new Error(`bun build failed for ${one}${r && r.error ? `: ${r.error.message}` : ` (exit ${r ? r.status : '?'})`}`);
-  }
-  return outfile;
-}
-
-function main() {
-  if (!bunPresent()) {
-    console.error('✖ `bun` is required to compile the standalone binary but was not found.');
-    console.error('  Install it (https://bun.sh) — e.g. `curl -fsSL https://bun.sh/install | bash` —');
-    console.error('  or in CI use the oven-sh/setup-bun action. Then re-run.');
-    process.exit(1);
-  }
-  const outDir = arg('--outdir') || path.join(REPO_ROOT, 'dist');
-  fs.mkdirSync(outDir, { recursive: true });
-  const only = arg('--target');
-  const targets = only ? [only] : Object.keys(TARGETS);
-
-  console.log(`bongos build — version ${VERSION}, ${targets.length} target(s) → ${path.relative(REPO_ROOT, outDir) || '.'}`);
-  const built = [];
-  for (const t of targets) built.push(build(t, outDir));
-
-  console.log(`\n✓ Built ${built.length} binary(ies):`);
-  for (const f of built) {
-    let size = '';
-    try { size = ` (${(fs.statSync(f).size / 1e6).toFixed(1)} MB)`; } catch { /* ignore */ }
-    console.log(`  ${path.relative(REPO_ROOT, f)}${size}`);
-  }
-  console.log('\nNext: publish these as assets on a `v' + VERSION + '` release of the public releases repo');
-  console.log('(config/bongos-cli.json → releases_repo). See docs/recipes/bongos-cli-release.md.');
-}
-
-if (require.main === module) {
-  try { main(); } catch (e) { console.error(`✖ ${e.message}`); process.exit(1); }
-}
-
-module.exports = { TARGETS, VERSION };

package/scripts/bongos/cleanup-orphans.js

@@ -1,74 +0,0 @@
-#!/usr/bin/env node
-// Mark an orphan task as 'abandoned' with an audit value_summary.
-//
-// Used when a task has been superseded by a different task (e.g. reclassified
-// into a different version, replaced by a follow-up with full scope) and
-// should stop inflating the version's total_count.
-//
-// Refuses to abandon anything but a 'backlog' task — once a task has been
-// claimed, confirmed, or shipped, abandoning it would corrupt the audit
-// trail. Use a real lifecycle transition instead.
-//
-// Usage:
-//   node scripts/bongos/cleanup-orphans.js <task-id> --reason "Superseded by #48 (P6)"
-//
-// Audit log (one-shot abandonments via this script):
-//   - #12  (2026-05-10) — placeholder for 'themed /builders web UI'; superseded
-//                          by P6 (#48). Original task was carried over from
-//                          PMS-V1 reclassification and never picked up.
-//
-// When adding a new orphan, append a line to the audit log above so a future
-// reader can answer "why was this abandoned" without spelunking the DB.
-
-const { pool } = require('../../src/bongos/pool');
-const { arg } = require('./cli-lib');
-
-
-async function main() {
-  const args = process.argv.slice(2);
-  const taskId = Number(args[0]);
-  const reason = arg('--reason', args);
-  if (!Number.isFinite(taskId) || !reason) {
-    console.error('usage: node scripts/bongos/cleanup-orphans.js <task-id> --reason "<text>"');
-    process.exit(2);
-  }
-
-  const { rows: before } = await pool.query(
-    `SELECT id, title, status, version_id FROM tasks WHERE id = $1`,
-    [taskId]
-  );
-  if (before.length === 0) {
-    console.error(`Task #${taskId} not found.`);
-    process.exit(1);
-  }
-  const task = before[0];
-  if (task.status !== 'backlog') {
-    console.error(`Refusing: task #${taskId} status is '${task.status}', not 'backlog'.`);
-    console.error('Abandoning a non-backlog task would corrupt the audit trail.');
-    console.error('Use a real lifecycle transition instead.');
-    process.exit(1);
-  }
-
-  console.log(`Before:  #${task.id} [${task.version_id}] ${task.status}  — ${task.title}`);
-
-  const { rows: after } = await pool.query(
-    `UPDATE tasks
-        SET status = 'abandoned',
-            value_summary = $2,
-            updated_at = now()
-      WHERE id = $1 AND status = 'backlog'
-      RETURNING id, status, value_summary`,
-    [taskId, reason]
-  );
-  if (after.length === 0) {
-    console.error('UPDATE matched 0 rows — race with concurrent change?');
-    process.exit(1);
-  }
-  console.log(`After:   #${after[0].id}  ${after[0].status}  — ${after[0].value_summary}`);
-  await pool.end();
-}
-
-main().catch((err) => {
-  console.error('fatal:', err);
-  process.exit(1);
-});