@bongos/core 1.21.175 → 1.21.176

package/scripts/bongos/seed-board-room-tasks.js

@@ -0,0 +1,196 @@
+// Seed the tasks for goal 1000069 "Governance & voting — the Board Room" (BONGOS-V1).
+// Source of truth: docs/specs/bongos-v1-board-room.md (status: final).
+// Idempotent on (source, source_ref). Re-running resolves to the existing rows.
+//
+// Run: node scripts/bongos/seed-board-room-tasks.js
+const os = require('os');
+const sess = require(os.homedir() + '/.config/cloudbongos/gds-session.json');
+const BASE = sess.api_base.replace(/\/$/, '');
+const TOKEN = sess.token;
+const VER = 'BONGOS-V1';
+const GOAL = 1000069;
+const SRC = 'planning-session';
+const H = { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' };
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function api(method, path, body, _tries = 0) {
+  await sleep(500); // base throttle to stay under the per-IP rate limit
+  const res = await fetch(`${BASE}/api/bongos${path}`, {
+    method, headers: H, body: body ? JSON.stringify(body) : undefined,
+  });
+  const text = await res.text();
+  let json; try { json = JSON.parse(text); } catch { json = { _raw: text.slice(0, 300) }; }
+  if (res.status === 429 && _tries < 8) {
+    const wait = ((json.error && json.error.details && json.error.details.retry_after_seconds) || 30) + 1;
+    console.log(`  …rate-limited, waiting ${wait}s`);
+    await sleep(wait * 1000);
+    return api(method, path, body, _tries + 1);
+  }
+  return { status: res.status, ok: res.ok, json };
+}
+
+// Criterion slugs (position-independent — see the spec's Criteria table).
+const C1 = 'board-full-idea-ratification';
+const C2 = 'rejection-returns-with-reason';
+const C3 = 'who-governs-is-config';
+const C4 = 'timed-sitting-absence-never-blocks';
+const C5 = 'board-room-and-charter-library';
+const C6 = 'discord-notification-mirror';
+
+const SPEC = 'See docs/specs/bongos-v1-board-room.md (status: final).';
+
+const TASKS = [
+  // ---- Phase A — decide + foundation (P5) ----
+  { ref:'R01', kind:'decision', disc:'engineer', prio:5, est:150, crit:[C1,C3,C4], deps:[],
+    title:'R01 · ADR: the Board Room government model',
+    desc:`Record the government model as one decision so the schema has something to encode.\n\nMUST STATE: the board's TWO subjects (a Full Idea, and a change to the constitution itself) and why nothing else is votable; membership as a configured predicate resolved per request and uncached; the timed SITTING (absent votes are nulled, not blocking) and why that replaces quorum — the clock IS the deadlock exit; CONSENT rather than majority, with silence as consent and one reasoned objection returning the idea; a zero-vote close PASSING; the OPEN ballot; Discord as an outbound notification mirror that casts nothing; and the amendment rule — a constitutional change is decided under whatever rule the CURRENT constitution names, so flipping out of monarchy is a legal monarchy act.\n\nAlso record the two owner decisions taken against recommendation with their trade-offs intact: vote-karma (yes-clicking bias, accepted because item volume is too low to farm) and automatic window-open on grade pass (author loses timing control; concurrent windows become normal).\n\nGrounding: idea 1000738, idea 1000754, the Six Variables of Governance synthesis, ADR 0151 (permissions-as-atoms), ADR 0157, ADR 0158 §2 (verdicts advisory), ADR 0162 (no human approval in the land path), ADR 0174 (government/ranks/roles). ${SPEC}` },
+
+  { ref:'R02', kind:'decision', disc:'engineer', prio:5, est:90, crit:[C1], deps:['R01'],
+    title:'R02 · The pass-event contract the ideator credit lane consumes',
+    desc:`Agree the pass-event shape with goal 1000067 (IC5, task 1002999) BEFORE the emitter is built, so no parallel vote is invented — ADR 0172 (per-craft compensation) is explicit that stream 3 "consumes the Board Room's pass event; invents no parallel vote".\n\nDone-when: payload fields, the idempotency key, and once-per-idea semantics are written down and referenced by both goals. Stream 3 pays max(30, round(completeness% x 100)) once per idea, reason 'idea.credit.governance_pass'. economy stays OUT of this goal's scope — we emit, 1000067 pays. Deps R01. ${SPEC}` },
+
+  { ref:'R03', kind:'feature', disc:'engineer', prio:5, est:210, crit:[C1,C2,C4], deps:['R01'],
+    title:'R03 · Schema: board items, votes, and rejections',
+    desc:`Module-owned migration under modules/government/. NOTE the fitness rule derives a module migration's legal table namespace from the DIRECTORY NAME (this is what forced tasks 1003004+1003005 to land together), so tables are government_*.\n\nMUST include subject_type ('full_idea' | 'constitutional_amendment') FROM DAY ONE — cheap now, expensive to bolt on. A vote row carries voter, direction, timestamp, and for an objection the free-text reason plus exactly one of the five Full Idea section keys. UNIQUE(item, voter) on the peer_votes precedent (migration 058). Item carries opened_at, closes_at, closed_at, outcome.\n\nRe-read modules/ideas/templates.js for the five section keys — they are the owner's own wording and must not be re-invented. Deps R01. ${SPEC}` },
+
+  { ref:'R04', kind:'feature', disc:'engineer', prio:5, est:150, crit:[C1,C3], deps:['R03'],
+    title:'R04 · Permission catalog + grant migration for the board keys',
+    desc:`Add board.item.open, board.vote.cast, board.config.manage following modules/government/catalog.js's five-step recipe EXACTLY. All three are operational (system:false) — creating or casting confers no authority on anyone; compare the version.create comment which argues this against a symmetry reading.\n\nThe grant migration is LOAD-BEARING not bookkeeping: an already-migrated DB never learns a key added only in code, and the new route then 403s everyone. Copy governance_006_version_create.sql's shape verbatim — one INSERT...SELECT '<rank>', unnest(ARRAY[...]) block PER RANK, because the drift guard tests/governance_seed.mjs scans for that literal form and a combined unnest parses as zero grants.\n\nPin every write route in src/bongos/route-rank-check.js. WATCH THE DEPLOY BOUNDARY: the grant rows and the code constant must land in the SAME deploy (ADR 0174 §Consequences) or the check fails closed. Deps R03. ${SPEC}` },
+
+  // ---- Phase B — the rule engine (P5 spine, P4 tail) ----
+  { ref:'R05', kind:'feature', disc:'engineer', prio:5, est:180, crit:[C3], deps:['R04'],
+    title:'R05 · The constitution: membership, pass rule, and window as config',
+    desc:`config/government.json + config/government.neutral.json gain a board block: membership predicate, pass_rule, window_minutes, close_early_on_full_turnout. Platform default and this instance's day-one value are MONARCHY — membership 'rank:archon', pass_rule 'first_ratifier', no clock — expressed as configuration on the real machinery, never as a separate code path.\n\nThe recommended starting point documented alongside it is: all Archons, one vote each, consent, 90-minute window. Deps R04. ${SPEC}` },
+
+  { ref:'R06', kind:'feature', disc:'engineer', prio:5, est:150, crit:[C3], deps:['R05'],
+    title:'R06 · Board membership resolver — per request, uncached',
+    desc:`Resolve the configured predicate to a live member list on every request with NO caching, preserving ADR 0016's instant-demotion property the permission resolver already guarantees.\n\nMembership derives from RANK, never from role: PATCH /me/disciplines is deliberately ungated ("a builder owns their own profile", src/bongos/routes/me.js:311), so a role-derived franchise would be one-request privilege escalation. The spec records why the role-chamber model was rejected. Deps R05. ${SPEC}` },
+
+  { ref:'R07', kind:'feature', disc:'engineer', prio:5, est:150, crit:[C1,C4], deps:['R06'],
+    title:'R07 · A window opens automatically when a Full Idea passes the grade',
+    desc:`The completeness grade is the FLOOR, the vote is the MERIT. A Full Idea crossing the pass bar (60, ADR 0172 per-craft) automatically opens a voting window; a sub-bar idea never reaches the board and instead returns to its author via R13.\n\nConcurrent windows are normal and expected — a direct consequence of automatic opening at a 90-minute default. Reuse modules/ideas/completeness.js; do not re-implement scoring. Deps R06. ${SPEC}` },
+
+  { ref:'R08', kind:'feature', disc:'engineer', prio:5, est:210, crit:[C1,C4], deps:['R06'],
+    title:'R08 · Cast a vote: open ballot, anti-self, live re-check, karma',
+    desc:`POST a vote gated on board.vote.cast. HARD RULES: an author may NOT vote on their own item (server-side, the peer_votes anti-self precedent) — this is the bright line that keeps ratification from being ceremonial; membership is re-checked LIVE on every write; the write is idempotent on (item, voter).\n\nOpen ballot: member, direction and timestamp are visible to all members, which is what makes the vote-karma auditable. Award the voter karma for a vote cast IN-WINDOW (proposed +1 — surface the constant for confirmation). The Full Idea's author earns karma on ratification, mirroring KARMA_RATIFY_DELTA (+3, tuned down from +5 in V3.R28 — do NOT copy the stale +5 still printed in planning-session/SKILL.md and openapi.json). Deps R06. ${SPEC}` },
+
+  { ref:'R09', kind:'feature', disc:'engineer', prio:5, est:120, crit:[C2], deps:['R03'],
+    title:'R09 · Rejection payload: a reason plus one of the five sections',
+    desc:`An objection carries free-text plus EXACTLY ONE of the five Full Idea section keys as the cause. This is the mechanism that makes the hall the only possible voting surface — a Discord reaction cannot express it, so reaction-voting would make every rejection feedback-free.\n\nA sub-bar completeness grade flags its weakest section automatically, using the per-field scores completeness.js already computes. Section keys come from modules/ideas/templates.js. Deps R03. ${SPEC}` },
+
+  { ref:'R10', kind:'feature', disc:'engineer', prio:5, est:210, crit:[C4], deps:['R08','R09'],
+    title:'R10 · Close + tally: consent, nulled absences, zero-vote pass',
+    desc:`Closing rules, all declared rather than emergent: absent members are NULLED — dropped from the denominator, never counted as a no, so absence can never block; silence is consent; ONE reasoned objection returns the idea under C2; a window closing with ZERO votes PASSES (the idea already cleared the grade gate, and absence never blocks); and the window closes EARLY the moment every member has voted, so latency is min(full turnout, window).\n\nThe monarchy pass_rule 'first_ratifier' resolves through this same path. Deps R08,R09. ${SPEC}` },
+
+  { ref:'R12', kind:'feature', disc:'engineer', prio:5, est:120, crit:[C1], deps:['R10'],
+    title:'R12 · Emit the pass event exactly once per ratified idea',
+    desc:`Fire R02's agreed contract on a passing close. Idempotent — a replay, a re-close, or a resubmission that passes again must never double-fire. This is the event goal 1000067 (IC5, task 1002999) is BLOCKED on; shipping it unblocks stream 3. Deps R10. ${SPEC}` },
+
+  { ref:'R11', kind:'feature', disc:'engineer', prio:4, est:150, crit:[C4], deps:['R10'],
+    title:'R11 · The window expiry poller',
+    desc:`A window closes on time with nobody touching it. Nothing in-tree expires a vote today; the nearest precedents are the 7-day lagged peer-vote tally and the ~5-minute publish reconciler — follow the reconciler's per-sweep disposition-logging habit so a stuck window is visible rather than silent. Must handle concurrent windows. Deps R10. ${SPEC}` },
+
+  { ref:'R13', kind:'feature', disc:'engineer', prio:4, est:180, crit:[C2], deps:['R09','R10'],
+    title:'R13 · Return-to-originator, and resubmission',
+    desc:`A vote fail OR a sub-bar grade sends the idea back to its ORIGINATOR carrying its feedback — it never dies and never stalls. The author revises and resubmits, which re-opens a window.\n\nBecause completeness.js scores the five fields per-field, a resubmission can be checked against the flagged section — surface whether the flagged section actually changed. Resubmission is unbounded in v1 (the grade gate already bounds spam) and every past rejection stays visible on the item history. Deps R09,R10. ${SPEC}` },
+
+  { ref:'R14', kind:'feature', disc:'engineer', prio:4, est:180, crit:[C3], deps:['R10'],
+    title:'R14 · Constitutional amendments as the board\'s second subject',
+    desc:`Propose a change to the constitution, then ratify it under whatever rule the CURRENT constitution names. Under monarchy that resolves to "the Archon ratifies", so flipping OUT of monarchy is a legal monarchy act; every change after that belongs to the consent board. This is how a constitution's own amendment procedure normally works, and it is why no bootstrap special case is needed.\n\nThis is the owner's answer to the loophole that motivated the whole feature — the rule that constrains the owner can no longer be weakened by the owner alone. Deps R10. ${SPEC}` },
+
+  // ---- Phase C — the hall (P4) ----
+  { ref:'R15', kind:'feature', disc:'engineer', prio:4, est:150, crit:[C5], deps:['R05'],
+    title:'R15 · Government page IA: Constitution / Board Room / Ranks & Permissions',
+    desc:`Government becomes the page that answers "how is this project governed", in three sections: Constitution (what we run + the charter library), Board Room (open items, your vote, the clock), and Ranks & Permissions (today's administration surface, unchanged).\n\nThe tab was renamed from Governance under task 1003007 — build on that, do not re-litigate the naming. Deps R05. ${SPEC}` },
+
+  { ref:'R16', kind:'feature', disc:'engineer', prio:4, est:240, crit:[C1,C4,C5], deps:['R08','R15'],
+    title:'R16 · The Board Room: open items, the clock, the tally',
+    desc:`Open items with their remaining time, your own vote state, a LIVE open-ballot tally (who voted which way and when), and the closed history with outcomes. Must read sensibly with several concurrent windows, which are normal at a 90-minute default with automatic opening. Deps R08,R15. ${SPEC}` },
+
+  { ref:'R17', kind:'feature', disc:'engineer', prio:4, est:180, crit:[C2,C5], deps:['R09','R16'],
+    title:'R17 · The vote UI: cast, reason box, five-section picker',
+    desc:`Cast a vote, and for an objection write the reason and pick exactly one of the five Full Idea sections. The full idea and its five sections must be in front of the voter while they decide — that context is the entire reason voting happens in the hall rather than on a Discord reaction. Deps R09,R16. ${SPEC}` },
+
+  { ref:'R18', kind:'feature', disc:'engineer', prio:4, est:150, crit:[C3,C5], deps:['R14','R15'],
+    title:'R18 · The Constitution section: what we run, and how it changed',
+    desc:`Show the active constitution in plain language — who may vote, how an item passes, how long a window runs — plus the full change history, so a switch can never be flipped quietly. Deps R14,R15. ${SPEC}` },
+
+  { ref:'R19', kind:'feature', disc:'engineer', prio:4, est:210, crit:[C5], deps:['R15'],
+    title:'R19 · The charter library: seven constitutions and the ladder',
+    desc:`Present all seven government structures (Monarchy/BDFL, Timocratic Republic, Direct Democracy, Presidential, Cooperative, Federation, Foundation), the three trajectories (Locked, Laddered, Scheduled), and the developmental ladder's thresholds (~9 named executive, ~25, ~50 written charter + council, ~150 adjudication separates / federate beyond).\n\nMark which are SELECTABLE TODAY versus documented-for-later, so nobody is misled. Name which is recommended at this project's CURRENT builder count. This is the half of the surface that earns its keep at two builders — the owner's stated purpose is getting a team up to speed before deciding when to flip the switch.\n\nSource: the Six Variables of Governance synthesis (Parts III and IV). Deps R15. ${SPEC}` },
+
+  // ---- Phase D — the mirror (P3) ----
+  { ref:'R20', kind:'feature', disc:'engineer', prio:3, est:90, crit:[C6], deps:['R01'],
+    title:'R20 · The board channel, with per-rank view access',
+    desc:`Add the board channel to docs/discord/channels.json with per-rank view access (ADR 0037 — the bot creates/edits channels, topics and access from that config file). Independent of the whole rule engine, so this is good early parallel work for a second builder. Deps R01. ${SPEC}` },
+
+  { ref:'R21', kind:'feature', disc:'engineer', prio:3, est:180, crit:[C6], deps:['R07','R20'],
+    title:'R21 · Announce a window: mention the members, deep-link the hall',
+    desc:`On window open, post to the board channel mentioning the members whose vote is wanted, carrying a deep link straight to that item in the hall. The mention IS the "vote within X" notice, and Discord's own mobile app IS the mobile push — no new surface is needed and the bot has no DM capability today (verified).\n\nFollow modules/discord/approval-broadcast + discord-approvals.js for the BROADCAST shape only. Discord is outbound-only here: it reads nothing inbound and casts no vote. Deps R07,R20. ${SPEC}` },
+
+  { ref:'R22', kind:'feature', disc:'engineer', prio:3, est:120, crit:[C6], deps:['R10','R21'],
+    title:'R22 · Mirror state: closed, and the outcome',
+    desc:`Edit the announcement in place as the item closes and resolves, so the channel never shows a stale open window. The item's state lives in the DATABASE — Discord is a mirror of it, never a source. Deps R10,R21. ${SPEC}` },
+
+  // ---- Phase E — proofs (P3) ----
+  { ref:'R23', kind:'verify', disc:'engineer', prio:3, est:150, crit:[C1,C3], deps:['R12','R17','R22'],
+    title:'R23 · PROOF: day-one monarchy, end to end',
+    desc:`On the live configuration: a Full Idea passes the completeness grade, a window opens automatically, the Archon ratifies in the hall, and the pass event fires exactly once with the payload IC5 expects. Proves C1 and the day-one half of C3 — and proves the board path really is the code path monarchy runs through. Deps R12,R17,R22. ${SPEC}` },
+
+  { ref:'R24', kind:'verify', disc:'engineer', prio:3, est:120, crit:[C2], deps:['R13','R17'],
+    title:'R24 · PROOF: a rejection round-trip',
+    desc:`Reject a Full Idea with a reason and a flagged section, confirm the author sees both, revise that section, resubmit, and pass. Also confirm the sub-bar-grade path flags the weakest section automatically. Proves C2 end to end. Deps R13,R17. ${SPEC}` },
+
+  { ref:'R25', kind:'verify', disc:'engineer', prio:3, est:180, crit:[C3,C4], deps:['R11','R14','R18'],
+    title:'R25 · PROOF: flip the switch, then run a real sitting',
+    desc:`Change the constitution from monarchy to the consent board BY RATIFICATION under the monarchy rule, then run a timed sitting through to expiry — verifying an absent member's vote is nulled rather than blocking, that a zero-vote close passes, and that a window closes early on full turnout. The single most important proof in the goal: it is the only thing that shows the switch actually works before you need it. Deps R11,R14,R18. ${SPEC}` },
+
+  { ref:'R26', kind:'verify', disc:'engineer', prio:3, est:90, crit:[C5], deps:['R19'],
+    title:'R26 · PROOF: the charter library reads right at this headcount',
+    desc:`Confirm the library's recommendation matches this project's actual builder count, that selectable-today is honestly marked, and that a newcomer can answer "what are we running, and what could we run" from the page alone. Deps R19. ${SPEC}` },
+];
+
+async function main() {
+  const idByRef = {};
+  console.log(`Seeding ${TASKS.length} tasks → ${VER} / goal ${GOAL}\n`);
+
+  for (const t of TASKS) {
+    const source_ref = `board-room-${t.ref}`;
+    const body = {
+      version_id: VER, goal_id: GOAL, source: SRC, source_ref,
+      title: t.title, description: t.desc,
+      kind: t.kind, discipline: t.disc, status: 'backlog',
+      priority: t.prio, est_minutes: t.est,
+      criterion_ids: t.crit,
+    };
+    const r = await api('POST', '/tasks', body);
+    if (r.ok && r.json.task) {
+      idByRef[t.ref] = r.json.task.id;
+      console.log(`  ${t.ref} → ${r.json.task.id}  ${t.title.slice(0, 62)}`);
+    } else if (r.status === 409 && r.json.task) {
+      idByRef[t.ref] = r.json.task.id;
+      console.log(`  ${t.ref} → ${r.json.task.id}  (already seeded)`);
+    } else {
+      console.error(`  ${t.ref} FAILED ${r.status}`, JSON.stringify(r.json).slice(0, 400));
+    }
+  }
+
+  console.log('\nWiring dependencies…');
+  let edges = 0;
+  for (const t of TASKS) {
+    const id = idByRef[t.ref];
+    if (!id || !t.deps.length) continue;
+    for (const ref of t.deps) {
+      const dep = idByRef[ref];
+      if (!dep) { console.error(`  ${t.ref} dep ${ref} unresolved`); continue; }
+      const r = await api('POST', `/tasks/${id}/dependencies`, { depends_on_task_id: dep });
+      if (r.ok || r.status === 409) { edges++; console.log(`  ${t.ref} ← ${ref}`); }
+      else console.error(`  ${t.ref} ← ${ref} FAILED ${r.status}`, JSON.stringify(r.json).slice(0, 300));
+    }
+  }
+
+  console.log(`\nDone. ${Object.keys(idByRef).length}/${TASKS.length} tasks, ${edges} dependency edges.`);
+  console.log('Zero-dep layer (promote to ready): R01');
+}
+
+main().catch((e) => { console.error(e); process.exit(1); });

package/scripts/bongos/seed-bongos-app-tasks.js

@@ -0,0 +1,294 @@
+#!/usr/bin/env node
+// Seed the 17 net-new BONGOS-V1 tasks — the Cloud Bongos desktop "Feedback
+// Capture" app (a Zoom-style floating toolbar: record + markup over any target
+// -> one model-agnostic prompt -> Claude Desktop/Code). The Dev Box app is
+// absorbed as a module of this app. Visual element-select is deferred to V2.
+// Design home: the "Bongos App — V1" plan artifact (favicon 🥁).
+//
+// Shape mirrors seed-bongos-tasks.js exactly:
+//   - POST /api/bongos/tasks   { version_id:'BONGOS-V1', criterion_ids:['C1'], ... }
+//   - POST /api/bongos/tasks/:id/dependencies   { depends_on_task_ids:[...] }
+//   - idempotent on source_ref (skips already-created); deps idempotent server-side.
+// Run migration 120_bongos_v1_planning_seed.sql FIRST so the version + C1..C4 exist.
+// After this runs, promote the zero-dependency tasks (R01/R02/R03) to 'ready'
+// (planning-session Phase 5 step 6) — they never auto-promote.
+//
+// Usage:  node scripts/bongos/seed-bongos-app-tasks.js [--dry-run]
+
+const { cliClient, requireSession } = require('./cli-lib');
+
+const DRY = process.argv.includes('--dry-run');
+
+// key = symbolic intra-version ref used in deps[]. Display R## assigned dynamically.
+const TASKS = [
+  {
+    key: 'R01',
+    title: 'Resolve Windows code-signing cert (reuse existing Apple Developer ID for Mac)',
+    description: `Part of Bongos App V1 / C1. The launch gate for a mic+screen app: an unsigned app that asks for Screen Recording + Microphone is treated as hostile (macOS grants may not persist; Windows SmartScreen blocks first launch). The macOS half is settled — reuse the Apple Developer ID already in hand for the Dev Box app. This task resolves the Windows code-signing path (cert acquisition + electron-builder wiring decision) so packaging (R15/R16) is unblocked on both OSes.
+
+**Done when:** the Windows signing approach is decided + the cert/identity is available (or an explicit interim "ship Mac-signed only" decision is recorded), and the Mac path is confirmed to reuse the existing Apple Developer ID.`,
+    kind: 'decision', discipline: 'engineer', priority: 3,
+    est_minutes: 30, manual_degree: 4, credits_reward: 10,
+    touches: ['bongos-app/'], criteria: ['C1'], deps: [],
+  },
+  {
+    key: 'R02',
+    title: 'Spike — transparent always-on-top click-through overlay on Mac + Windows',
+    description: `Part of Bongos App V1 / C2. De-risk the load-bearing UX primitive before building on it: an Electron transparent, frameless, always-on-top BrowserWindow with setIgnoreMouseEvents(true,{forward:true}) that lets the user draw over any other app (the Zoom annotation model). Prove the macOS type:'panel' / setVisibleOnAllWorkspaces({visibleOnFullScreen:true}) approach survives fullscreen apps + Spaces, and Windows multi-monitor / per-monitor DPI coordinate mapping.
+
+**Done when:** a throwaway build draws a click-through overlay over a fullscreen app on macOS and over a second monitor on Windows, with the cursor passing through to the app underneath; findings (gotchas, the chosen window flags) are captured for R04.`,
+    kind: 'spike', discipline: 'engineer', priority: 4,
+    est_minutes: 180, manual_degree: 3, credits_reward: 30,
+    touches: ['bongos-app/'], criteria: ['C2'], deps: [],
+  },
+  {
+    key: 'R03',
+    title: 'Stand up the bongos-app umbrella Electron app; absorb the Dev Box app as a module',
+    description: `Part of Bongos App V1 / C1. Establish bongos-app/ as the umbrella Cloud Bongos desktop app, and bring the existing Dev Box app (devbox-app/, ADR 0045) INTO it as a module rather than a sibling install. Reuse the Dev Box app's Electron shell + app-pairing auth (writes the same ~/.config/otb/gds-session.json), branded /downloads redirect distribution, in-app updater, brand discipline (ADR 0004), and the existing Apple Developer ID. The result is one signed app that offers both the Dev Box switch and (new) the feedback toolbar.
+
+**Done when:** bongos-app/ builds + launches as one Electron app containing the prior Dev Box functionality as a module; auth + branded distribution + updater are reused (not reimplemented); and the migration path for existing Dev Box app users is recorded.`,
+    kind: 'infra', discipline: 'engineer', priority: 5,
+    est_minutes: 360, manual_degree: 3, credits_reward: 60,
+    touches: ['bongos-app/', 'devbox-app/'], criteria: ['C1'], deps: [],
+  },
+  {
+    key: 'R04',
+    title: 'Floating toolbar + global hotkey + click-through overlay',
+    description: `Part of Bongos App V1 / C2. Cross-ref: R02 (spike), R03 (shell). Build the production floating toolbar: a small always-on-top bar summoned/dismissed by a global hotkey, plus the transparent click-through overlay window proven in R02, with macOS panel/fullscreen/Spaces handling and Windows per-monitor-DPI coordinate handling.
+
+**Done when:** the toolbar appears over any app via a global hotkey; the overlay draws over arbitrary windows including fullscreen apps; coordinates are correct across multiple monitors / DPI scales on both OSes.`,
+    kind: 'feature', discipline: 'engineer', priority: 5,
+    est_minutes: 300, manual_degree: 2, credits_reward: 55,
+    touches: ['bongos-app/'], criteria: ['C2'], deps: ['R02', 'R03'],
+  },
+  {
+    key: 'R05',
+    title: 'First-run macOS permission wizard (Screen Recording + Microphone)',
+    description: `Part of Bongos App V1 / C1. Cross-ref: R03. A one-screen guided wizard that detects each TCC grant state (systemPreferences.getMediaAccessStatus), deep-links straight to the exact System Settings pane, and shows a live green check as each is granted. Screen Recording + Microphone are mandatory; Accessibility is requested lazily (only when rung-2 element reads land in V2), never up front. Frame the recurring (~monthly) macOS Screen-Recording re-prompt as normal.
+
+**Done when:** on a fresh macOS install the wizard walks the user to grant Screen Recording + Microphone with live state + deep-links, and capture works immediately after; Windows (lighter: no TCC) is handled gracefully.`,
+    kind: 'feature', discipline: 'engineer', priority: 4,
+    est_minutes: 180, manual_degree: 2, credits_reward: 35,
+    touches: ['bongos-app/'], criteria: ['C1'], deps: ['R03'],
+  },
+  {
+    key: 'R06',
+    title: 'Screen/window + microphone capture + target picker',
+    description: `Part of Bongos App V1 / C2. Cross-ref: R04, R05. Use getDisplayMedia/desktopCapturer to capture a chosen window or the full screen, plus the microphone. A target picker lets the user choose WHAT to capture (and excludes the toolbar/overlay itself from the capture).
+
+**Done when:** the user picks a target window or screen, capture streams video + mic, and the toolbar/overlay are excluded from the captured frames; works on macOS + Windows after the R05 grants.`,
+    kind: 'feature', discipline: 'engineer', priority: 5,
+    est_minutes: 240, manual_degree: 2, credits_reward: 50,
+    touches: ['bongos-app/'], criteria: ['C2'], deps: ['R04', 'R05'],
+  },
+  {
+    key: 'R07',
+    title: '~1/sec snapshot grabber + snapshot-on-change + perceptual dedup + cap',
+    description: `Part of Bongos App V1 / C2. Cross-ref: R06. Grab ~1 frame/sec off the capture stream as the token-discipline core: snapshot-on-meaningful-change rather than fixed 1/sec, perceptual-hash dedup of near-identical frames, and a hard frame cap (~60) per session. This is what keeps a session ~90x cheaper than naive full-res 1/sec.
+
+**Done when:** frames are grabbed at ~1/sec, near-duplicate frames are dropped, a session cannot exceed the frame cap, and each kept frame carries a timestamp for later alignment.`,
+    kind: 'feature', discipline: 'engineer', priority: 4,
+    est_minutes: 180, manual_degree: 2, credits_reward: 35,
+    touches: ['bongos-app/'], criteria: ['C2'], deps: ['R06'],
+  },
+  {
+    key: 'R08',
+    title: 'Markup canvas (box/arrow/freehand/text) + freeze-frame over any window',
+    description: `Part of Bongos App V1 / C2. Cross-ref: R04. A drawing layer on the overlay: freehand, box, arrow, and text annotation over any window's pixels, plus a "freeze" that snapshots the current frame so the user can mark up a still. Markup events are timestamped (for alignment in R10) and serialized as part of the bundle.
+
+**Done when:** the user can freeze the target and draw box/arrow/freehand/text over it; annotations export as an image + structured strokes with timestamps.`,
+    kind: 'feature', discipline: 'engineer', priority: 4,
+    est_minutes: 180, manual_degree: 2, credits_reward: 35,
+    touches: ['bongos-app/'], criteria: ['C2'], deps: ['R04'],
+  },
+  {
+    key: 'R09',
+    title: 'On-device transcription (whisper.cpp) with word timestamps',
+    description: `Part of Bongos App V1 / C3. Cross-ref: R06. Bundle whisper.cpp (small/q5 default, base fallback, large-v3-turbo opt-in) to transcribe the recorded mic audio fully on-device — privacy-respecting and effectively free, removing ~99% of the audio token cost (audio -> text). Decide lazy-download of model weights on first use vs bundling (~250-300MB).
+
+**Done when:** recorded audio is transcribed locally to text with per-word timestamps on macOS + Windows; no audio leaves the machine; the model-weights delivery (bundle vs lazy-download) is decided + implemented.`,
+    kind: 'feature', discipline: 'engineer', priority: 4,
+    est_minutes: 240, manual_degree: 2, credits_reward: 45,
+    touches: ['bongos-app/'], criteria: ['C3'], deps: ['R06'],
+  },
+  {
+    key: 'R10',
+    title: 'Transcript <-> frame time-alignment + salience frame-escalation',
+    description: `Part of Bongos App V1 / C3. Cross-ref: R07, R08, R09. Join the word-timestamped transcript with the timestamped frame stream and the markup events, then decide which frames escalate to full resolution: the ones the speech points at (deictic words like "this/here/that"), the ones with markup, and element/freeze moments. Everything else stays a cheap thumbnail.
+
+**Done when:** transcript segments, frames, and markup are aligned on one clock; a salience pass selects which frames escalate to full-res (capped); the output is an ordered, aligned timeline ready for prompt assembly.`,
+    kind: 'feature', discipline: 'engineer', priority: 4,
+    est_minutes: 240, manual_degree: 3, credits_reward: 50,
+    touches: ['bongos-app/'], criteria: ['C3'], deps: ['R07', 'R08', 'R09'],
+  },
+  {
+    key: 'R11',
+    title: 'Deterministic prompt.md template + bundle writer (model-agnostic)',
+    description: `Part of Bongos App V1 / C3. Cross-ref: R10. Assemble the aligned timeline into one deterministic, model-agnostic prompt.md (no LLM call by default): target context, the transcript with timestamps, attached images with captions + inlined ABSOLUTE file paths, and the ask. Write the bundle (prompt.md + frame PNGs) to a stable dir e.g. ~/CloudBongos/feedback/<id>/. Keep it agent-neutral so it feeds Claude, Cursor, Codex, etc.
+
+**Done when:** a session produces a self-contained prompt.md + image files at a stable path, a typical session lands at the disciplined token envelope (~5-11k), and the format is documented enough for any agent to consume.`,
+    kind: 'feature', discipline: 'engineer', priority: 5,
+    est_minutes: 180, manual_degree: 2, credits_reward: 45,
+    touches: ['bongos-app/'], criteria: ['C3'], deps: ['R10'],
+  },
+  {
+    key: 'R12',
+    title: 'File-bundle + clipboard handoff for Claude Desktop',
+    description: `Part of Bongos App V1 / C4. Cross-ref: R11. The universal handoff for Claude Desktop: copy the prompt.md text to the clipboard and open the bundle folder so the user drags the images into the composer (Desktop accepts mixed text + images). Print the one-liner that tells the user exactly what to do.
+
+**Done when:** one click puts the prompt on the clipboard + opens the folder; pasting into Claude Desktop + dragging the images produces a complete, actionable message.`,
+    kind: 'feature', discipline: 'engineer', priority: 4,
+    est_minutes: 150, manual_degree: 2, credits_reward: 30,
+    touches: ['bongos-app/'], criteria: ['C4'], deps: ['R11'],
+  },
+  {
+    key: 'R13',
+    title: '/feedback Claude Code slash command',
+    description: `Part of Bongos App V1 / C4. Cross-ref: R11. A shipped /feedback slash command that injects the latest prompt.md into a Claude Code session (cat ~/CloudBongos/feedback/latest/prompt.md) so the inlined absolute image paths let Claude's Read tool load the frames — sidestepping the unreliable CLI clipboard-image paste.
+
+**Done when:** running /feedback in a Claude Code session pulls in the latest bundle (text + image paths Claude can Read), with no manual file wrangling.`,
+    kind: 'feature', discipline: 'engineer', priority: 4,
+    est_minutes: 120, manual_degree: 2, credits_reward: 25,
+    touches: ['.claude/skills/', 'scripts/bongos/'], criteria: ['C4'], deps: ['R11'],
+  },
+  {
+    key: 'R14',
+    title: 'Local stdio MCP server — get_latest_feedback (optional "direct" path)',
+    description: `Part of Bongos App V1 / C4. Cross-ref: R11. A local stdio MCP server (bundled with the app) exposing get_latest_feedback so both Claude Desktop and Claude Code can PULL the latest bundle hands-free. CRITICAL: return image FILE PATHS, not inline base64 (inline blows the MCP tool-result size cap). Optional/stretch for V1 — the file-bundle + /feedback paths already complete the loop.
+
+**Done when:** a connected Claude session can call get_latest_feedback and receive the prompt text + image file paths; documented as the optional "direct" handoff.`,
+    kind: 'feature', discipline: 'engineer', priority: 2,
+    est_minutes: 180, manual_degree: 2, credits_reward: 35,
+    touches: ['bongos-app/', 'scripts/'], criteria: ['C4'], deps: ['R11'],
+  },
+  {
+    key: 'R15',
+    title: 'Code-signing + notarization config (electron-builder)',
+    description: `Part of Bongos App V1 / C1. Cross-ref: R01, R03. Wire electron-builder to sign + notarize the macOS build (reusing the existing Apple Developer ID) and sign the Windows build (per the R01 decision), including the hardened-runtime entitlements and the Info.plist usage keys (NSMicrophoneUsageDescription, screen capture) a mic+screen app needs.
+
+**Done when:** CI produces a signed + notarized macOS build and a signed Windows build that launch without Gatekeeper/SmartScreen blocks and whose TCC grants persist across relaunches.`,
+    kind: 'infra', discipline: 'engineer', priority: 3,
+    est_minutes: 180, manual_degree: 3, credits_reward: 35,
+    touches: ['bongos-app/', '.github/'], criteria: ['C1'], deps: ['R01', 'R03'],
+  },
+  {
+    key: 'R16',
+    title: 'Branded download + auto-update wiring',
+    description: `Part of Bongos App V1 / C1. Cross-ref: R15. Reuse the Dev Box app's distribution pattern: per-platform binaries published to the public releases repo, the branded server-side /downloads/* 302-redirect, and the in-app semver updater — now serving the unified bongos app.
+
+**Done when:** users install the bongos app from the branded /downloads link on Mac + Windows and receive in-app auto-updates; the Dev Box app's old download path redirects/upgrades to the unified app.`,
+    kind: 'infra', discipline: 'engineer', priority: 3,
+    est_minutes: 150, manual_degree: 2, credits_reward: 30,
+    touches: ['bongos-app/', '.github/'], criteria: ['C1'], deps: ['R15'],
+  },
+  {
+    key: 'R17',
+    title: 'ADR + README — architecture + model-agnostic handoff contract',
+    description: `Part of Bongos App V1 / C4. Cross-ref: R11. Write the ADR recording the bongos app architecture (umbrella app absorbing Dev Box, the capture->synthesize->handoff pipeline, the Rung-3 capture floor with element-select deferred to V2) and a README documenting the bundle format + the model-agnostic prompt/handoff contract so any agent can consume it.
+
+**Done when:** an ADR under docs/adr/ records the architecture + the bongos-as-GDS-successor intent, and a bongos-app/README.md documents the prompt.md/bundle contract + the three handoff paths.`,
+    kind: 'infra', discipline: 'engineer', priority: 3,
+    est_minutes: 120, manual_degree: 2, credits_reward: 25,
+    touches: ['docs/adr/', 'bongos-app/'], criteria: ['C4'], deps: ['R11'],
+  },
+];
+
+async function main() {
+  await requireSession();
+  const api = await cliClient();
+
+  // Pull the current BONGOS-V1 task list once: idempotency (skip existing
+  // source_ref) and the next free decorative R## (fresh version -> starts at R1).
+  const list = await api.tasks.getTasks({ query: { version: 'BONGOS-V1' } });
+  const existing = list.data?.tasks || [];
+  const bySourceRef = {};
+  let maxR = 0;
+  for (const t of existing) {
+    if (t.source_ref) bySourceRef[t.source_ref] = t;
+    const m = /BV1\.R(\d+)\b/.exec(t.title || '');
+    if (m) { const n = Number(m[1]); if (n > maxR) maxR = n; }
+  }
+  console.log(`context: ${existing.length} BONGOS-V1 tasks, maxR=R${maxR}`);
+
+  // Assign display R## numbers sequentially after the current max.
+  const refByKey = {};
+  TASKS.forEach((def, i) => { refByKey[def.key] = `R${String(maxR + 1 + i).padStart(2, '0')}`; });
+
+  const idByKey = {};
+  let created = 0, skipped = 0, errors = 0;
+
+  for (const def of TASKS) {
+    const r = refByKey[def.key];
+    const source_ref = `bongos-v1-${def.key.toLowerCase()}`;
+    if (bySourceRef[source_ref]) {
+      idByKey[def.key] = Number(bySourceRef[source_ref].id);
+      console.log(`SKIP  ${def.key} (${r}) already exists: id=${bySourceRef[source_ref].id}`);
+      skipped++;
+      continue;
+    }
+    const body = {
+      version_id: 'BONGOS-V1',
+      title: `BV1.${r} — ${def.title}`,
+      description: def.description,
+      kind: def.kind,
+      discipline: def.discipline,
+      status: 'backlog',
+      priority: def.priority,
+      est_minutes: def.est_minutes,
+      manual_degree: def.manual_degree,
+      credits_reward: def.credits_reward,
+      touches: def.touches || [],
+      criterion_ids: def.criteria || [],
+      source: 'planning-session',
+      source_ref,
+    };
+    if (DRY) {
+      const deps = (def.deps || []).map((d) => (refByKey[d] ? `${d}=${refByKey[d]}` : d)).join(',');
+      console.log(`DRY   ${def.key} -> ${r}  P${def.priority} ${def.kind}  crit=${(def.criteria || []).join('/')}  deps=[${deps}]  ${def.title.slice(0, 52)}`);
+      continue;
+    }
+    const res = await api.tasks.postTasks({ body });
+    if (res.status !== 201) {
+      console.error(`FAIL  ${def.key}: status=${res.status} ${JSON.stringify(res.data).slice(0, 220)}`);
+      errors++;
+      continue;
+    }
+    idByKey[def.key] = Number(res.data.task.id);
+    console.log(`OK    ${def.key} -> BV1.${r}  task id=${idByKey[def.key]}  (crit ${(def.criteria || []).join('/')})`);
+    created++;
+  }
+
+  const resolveDep = (ref) => idByKey[ref] ?? null;
+
+  let depsWired = 0, depErrors = 0;
+  if (!DRY) {
+    for (const def of TASKS) {
+      const deps = def.deps || [];
+      if (deps.length === 0) continue;
+      const taskId = idByKey[def.key];
+      if (!taskId) { console.error(`DEPS  ${def.key}: no task id (create failed?), skipping`); depErrors++; continue; }
+      const depIds = deps.map(resolveDep).filter((n) => Number.isFinite(n));
+      if (depIds.length !== deps.length) {
+        const missing = deps.filter((d) => !Number.isFinite(resolveDep(d)));
+        console.error(`DEPS  ${def.key}: unresolved deps [${missing.join(',')}] — wiring the resolvable ones only`);
+        depErrors++;
+        if (depIds.length === 0) continue;
+      }
+      const res = await api.tasks.postTasksIdDependencies({ id: taskId, body: { depends_on_task_ids: depIds } });
+      if (res.status === 200) {
+        console.log(`DEPS  ${def.key} <- [${deps.join(',')}] (ids ${depIds.join(',')})`);
+        depsWired++;
+      } else {
+        console.error(`DEPS FAIL ${def.key}: ${res.status} ${JSON.stringify(res.data).slice(0, 220)}`);
+        depErrors++;
+      }
+    }
+  }
+
+  const zeroDep = TASKS.filter((d) => (d.deps || []).length === 0).map((d) => `${d.key}=${idByKey[d.key] || '?'}`);
+  console.log(`\nDONE  created=${created} skipped=${skipped} errors=${errors} deps_wired=${depsWired} dep_errors=${depErrors}  (manifest: ${TASKS.length})`);
+  console.log(`NEXT  promote zero-dependency tasks to 'ready' (they never auto-promote): ${zeroDep.join(', ')}`);
+  process.exit(errors === 0 && depErrors === 0 ? 0 : 1);
+}
+
+main().catch((err) => { console.error('FATAL', err); process.exit(1); });

package/scripts/bongos/seed-bongos-coreB-tranche1-tasks.js

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+// seed-bongos-coreB-tranche1-tasks.js
+// Seeds BONGOS-V1 criterion C7 (gds-core-modularized) — the "Config B" core
+// decomposition wave, tranche 1: kernel boundary + db.js per-domain carve +
+// proving carve (memory, grading). Planning session 2026-06-26 (task 1567).
+// Idempotent on source_ref; criterion links + dependency edges idempotent too.
+// Run: node scripts/bongos/seed-bongos-coreB-tranche1-tasks.js
+const os = require('os');
+const TOKEN = require(os.homedir() + '/.config/otb/gds-session.json').token;
+const BASE = require('../../src/instance-config').resolveEnv('BASE') || 'https://example.com';
+const H = { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' };
+
+// ref → task spec. depends_on_refs are local R## refs resolved after create.
+const TASKS = [
+  { ref: 'R67', kind: 'spike', priority: 5, title: 'BV1.R67 — Define + bound the kernel (ADR amending 0083)',
+    description: 'Spike → ADR amending 0083: fix the KERNEL file roster (auth · rank · pool · audit · permission-path-check · route-rank-check · config/identity · loader · seams), decide the db.js per-domain carve strategy, and the fix for the doorway leaking domain queries (getBuilderById/createTask/insertAuditLog re-exported from module-api.js). Output: ADR + a sub-task shape for the carve. GATES the whole C7 tranche. The audit found the "kernel" is currently only the 6 loader-machinery files; this defines the real ~3.5k-LOC trust kernel. deps: none.',
+    deps: [] },
+  { ref: 'R68', kind: 'feature', priority: 5, title: 'BV1.R68 — Doorway surface for core domains (withTx + stop leaking db.js)',
+    description: 'Add `withTx` (BEGIN/COMMIT wrapper) + any shared primitives a core-domain module needs to module-api.js; minor CORE_VERSION bump. Stop re-exporting domain-specific queries through the doorway (relocate/deprecate getBuilderById, createTask, insertAuditLog, getBuilderGeminiKeyRow — these belong to their domains, not the kernel). deps: R67.',
+    deps: ['R67'] },
+  { ref: 'R69', kind: 'refactor', priority: 5, title: 'BV1.R69 — Per-domain db.js access pattern + carve the reference slice',
+    description: 'Establish HOW a carved core domain owns its SQL (module gets pool+withTx via the doorway and owns its queries; db.js shrinks per-domain). Prove the pattern on one reference slice. This is the mechanism every later carve copies. deps: R67, R68.',
+    deps: ['R67', 'R68'] },
+  { ref: 'R70', kind: 'infra', priority: 4, title: 'BV1.R70 — Fitness: real KERNEL_FILES roster + kernel-imports-no-domain',
+    description: 'Replace fitness.js KERNEL_FILES (currently just the 6 loader-machinery files) with the true kernel roster from R67; add a check that the kernel imports no soon-to-be-module domain. Ratchets the boundary so core-carve regressions are a red build. deps: R67.',
+    deps: ['R67'] },
+  { ref: 'R71', kind: 'infra', priority: 4, title: 'BV1.R71 — Register new core module keys in module-scope-map.js',
+    description: 'Add the new core module keys (memory, grading, and the tranche-2 domains as they are scoped) to src/bongos/module-scope-map.js so goals (scope walls), task→module affinity, and ship-time diff⊆module drift detection work for them. Then widen goal 10 (GDS core modularization) scope to include them via POST /goals/10/scope. deps: R67.',
+    deps: ['R67'] },
+  { ref: 'R72', kind: 'refactor', priority: 4, title: 'BV1.R72 — Carve memory → modules/memory/',
+    description: 'Move memory/recall/search/learnings (~2.2k LOC: memory.js, search.js, search-chunker.js, learnings.js + routes) into modules/memory/ with its tables + db.js slice (per the R69 pattern). Cleanest db.js-split proof — the design scan shows memory slices cleanly. OTB byte-identical. deps: R69, R71.',
+    deps: ['R69', 'R71'] },
+  { ref: 'R73', kind: 'refactor', priority: 4, title: 'BV1.R73 — Carve grading → modules/grading/, lifecycle resolves grade via a kernel PORT',
+    description: 'Move the grader + worker panel (~3.1k LOC) into modules/grading/. The lifecycle (tasks.js ship path) stops importing the grader directly and instead resolves a `grade` capability via a kernel PORT (registerProvider/resolve). Proves the design\'s "keep the state machine whole, extract the capability behind a seam" pattern AND closes the audit\'s unimplemented-port gap (reward/grade were illustrative-only). deps: R68, R69, R71.',
+    deps: ['R68', 'R69', 'R71'] },
+  { ref: 'R74', kind: 'verify', priority: 3, title: 'BV1.R74 — Proof: the core-carve pattern holds (memory + grading as modules)',
+    description: 'Prove C7\'s tranche-1: memory + grading live as modules/, db.js shrank by their slices, the kernel is bounded + fitness green (R70), a capability resolves via a kernel port (R73), and OTB behaves byte-identically. The single live demonstration the criterion hinges on for tranche 1. deps: R72, R73.',
+    deps: ['R72', 'R73'] },
+];
+
+async function post(path, body) {
+  const r = await fetch(BASE + path, { method: 'POST', headers: H, body: JSON.stringify(body) });
+  return { status: r.status, json: await r.json().catch(() => ({})) };
+}
+
+(async () => {
+  const idByRef = {};
+  // Phase 1: create tasks (idempotent on source_ref), link C7 at create.
+  for (const t of TASKS) {
+    const body = {
+      version_id: 'BONGOS-V1', title: t.title, description: t.description,
+      kind: t.kind, discipline: 'engineer', priority: t.priority,
+      criterion_ids: ['C7'],
+      source: 'planning', source_ref: `BONGOS-V1-coreB-${t.ref}`,
+    };
+    let { status, json } = await post('/api/bongos/tasks', body);
+    let id = json.id || (json.task && json.task.id);
+    if (!id && t.kind === 'verify') {
+      // memory: kind=verify has 500'd before (idea #357). Fall back, keep going.
+      console.log(`  ${t.ref}: kind=verify failed (${json.error || status}); retrying as kind=feature`);
+      ({ status, json } = await post('/api/bongos/tasks', { ...body, kind: 'feature' }));
+      id = json.id || (json.task && json.task.id);
+    }
+    if (!id) { console.log(`  ${t.ref}: CREATE FAILED — ${status} ${JSON.stringify(json).slice(0, 160)}`); continue; }
+    idByRef[t.ref] = id;
+    console.log(`  ${t.ref} -> task ${id} (${t.kind}, P${t.priority})`);
+  }
+  // Phase 2: wire dependencies (idempotent on (task_id, depends_on_task_id)).
+  console.log('--- dependencies ---');
+  for (const t of TASKS) {
+    const id = idByRef[t.ref];
+    if (!id || !t.deps.length) continue;
+    for (const dep of t.deps) {
+      const depId = idByRef[dep];
+      if (!depId) { console.log(`  ${t.ref}: dep ${dep} not created — skip`); continue; }
+      const { status, json } = await post(`/api/bongos/tasks/${id}/dependencies`, { depends_on_task_id: depId });
+      console.log(`  ${t.ref}(${id}) depends on ${dep}(${depId}) -> ${status === 200 || status === 201 ? 'ok' : (json.error || status)}`);
+    }
+  }
+  console.log('refs:', JSON.stringify(idByRef));
+})();