gitroots 0.5.0 → 0.6.1

package/src/session/workspace.js

@@ -0,0 +1,270 @@
+// /status · /repos · /repo · /approvals · /pushes · /audit · /activity · /members (all live from gitroots)
+import { select, interactive, ask, confirm } from '../ui/term.js';
+import { json } from '../ui/components.js';
+import { localSessions } from '../agents/local.js';
+import { c, h, line, pad, fit, next, needWorkspace, load, ago, empty, table, cols, cmdText } from './helpers.js';
+
+const plural = (n, w) => `${n} ${n === 1 ? w : w.endsWith('y') && !/[aeiou]y$/.test(w) ? `${w.slice(0, -1)}ies` : w.endsWith('s') || w.endsWith('sh') || w.endsWith('ch') ? `${w}es` : w === 'person' ? 'people' : `${w}s`}`;
+
+// ---------------------------------------------------------------- /status
+
+export async function status(ctx) {
+  needWorkspace(ctx);
+  const [home, agents] = await load(ctx, 'Loading your workspace…', () => Promise.all([
+    ctx.api.home({ signal: ctx.signal }),
+    ctx.api.agents({ signal: ctx.signal }).catch(() => null),
+  ]));
+  const local = localSessions({ limit: 30 });
+  const waitingAgents = (agents?.sessions || []).filter((s) => s.needs_you);
+  if (ctx.json) { json({ ...home, agents_waiting: waitingAgents, local_agents_live: local.filter((s) => s.status === 'live').length }); return 0; }
+
+  const p = home.posture || {};
+  const cov = p.coverage || {};
+  line(`${c.g(c.b('gitroots'))} ${c.m('·')} ${c.b(home.organization.name)} ${c.m('·')} ${home.user.display_name || home.user.name} ${c.m('·')} ${c.m(ctx.api.host)}`);
+  line();
+  line(h('Posture'));
+  const inPolicy = p.all_in_policy ? c.g('✓ all in policy') : c.w('◐ not all in policy');
+  line(`  ${plural(p.repo_count || 0, 'repository')} ${c.m('·')} ${p.protected_count || 0} protected ${c.m('·')} ${cov.overlay || 0} shared by overlay ${c.m('·')} ${cov.open || 0} open   ${inPolicy}`);
+  line(`  ${plural(home.developer_count || 0, 'developer')} ${c.m('·')} ${home.blocked_24h ? c.r(`✕ ${plural(home.blocked_24h, 'blocked push')} in 24h`) : c.g('✓ no blocked pushes in 24h')}`);
+  line();
+  line(h('Needs you'));
+  let any = false;
+  for (const a of home.awaiting || []) {
+    any = true;
+    line(`  ${c.w(pad('◐ review', 11))} ${fit(a.title, 44)}  ${c.m(fit(`${a.meta || ''} · ${a.age || ''}`, Math.max(10, cols() - 62)))}`);
+  }
+  if (home.pending_count > (home.awaiting || []).length) line(`  ${c.m(`+ ${home.pending_count - (home.awaiting || []).length} more`)}`);
+  for (const s of waitingAgents.slice(0, 4)) {
+    any = true;
+    line(`  ${c.w(pad('◐ agent', 11))} ${fit(`${s.agent_name} on ${s.machine}: ${s.ask?.what || s.title}`, 44)}  ${c.m(fit(s.ask?.cmd || '', Math.max(10, cols() - 62)))}`);
+  }
+  if (!any) line(`  ${c.g('✓ nothing waiting on you')}`);
+  line();
+  const live = local.filter((s) => s.status === 'live').length;
+  const remote = (agents?.sessions || []).filter((s) => s.active).length;
+  line(h('Agents'));
+  line(`  ${remote ? c.g(`● ${remote} active on your machines`) : c.m('○ none reported by the gitroots app')} ${c.m('·')} ${live ? c.g(`● ${live} live on this computer`) : c.m(`○ ${local.length} recent on this computer`)}`);
+  line();
+  if (home.pending_count) next(ctx, 'approvals');
+  else if (waitingAgents.length) next(ctx, 'agents');
+  else if (home.blocked_24h) next(ctx, 'pushes', '--blocked');
+  else next(ctx, 'repos');
+  return 0;
+}
+
+// ---------------------------------------------------------------- /repos, /repo
+
+export async function repos(ctx) {
+  needWorkspace(ctx);
+  const d = await load(ctx, 'Loading repositories…', () => ctx.api.repos({ signal: ctx.signal }));
+  if (ctx.json) { json(d.repos); return 0; }
+  if (!d.repos.length) {
+    empty(d.github?.connected === false ? 'no repositories · connect GitHub in the gitroots dashboard' : 'no repositories synced yet');
+    return 0;
+  }
+  table([
+    { label: 'REPOSITORY', w: 34, fmt: (r) => c.b(r.full_name) },
+    { label: 'DEFAULT', w: 12, key: 'default_branch' },
+    { label: 'BRANCHES', w: 10, key: 'branch_count' },
+    { label: 'RULES', w: 8, key: 'rule_count' },
+    { label: 'OVERLAYS', w: 10, key: 'overlay_count' },
+    { label: 'STATUS', w: 16, fmt: (r) => (r.protected ? c.g('● protected') : c.m('○ open')) },
+  ], d.repos);
+  line();
+  next(ctx, 'repo', d.repos[0].name);
+  return 0;
+}
+
+async function pickRepo(ctx) {
+  const d = await load(ctx, 'Loading repositories…', () => ctx.api.repos({ signal: ctx.signal }));
+  if (!d.repos.length) throw new Error('no repositories in this workspace yet');
+  if (!interactive()) throw new Error(`which repository? ${cmdText(ctx, 'repo', '<name>')}`);
+  line(`${c.i(c.b('?'))} Which repository?`);
+  const res = await select({
+    count: d.repos.length,
+    render: (i) => windowed(d.repos, i, 10, (r, sel) => `${sel ? c.g('❯ ') : '  '}${sel ? c.b(pad(r.full_name, 40)) : pad(r.full_name, 40)}${r.protected ? c.g('● protected') : c.m('○ open')}`),
+  });
+  return res.action === 'cancel' ? null : d.repos[res.index].full_name;
+}
+
+export function windowed(items, idx, max, row) {
+  const start = Math.max(0, Math.min(idx - Math.floor(max / 2), items.length - max));
+  const out = items.slice(start, start + max).map((it, j) => row(it, start + j === idx));
+  if (items.length > max) out.push(c.m(`  ${idx + 1} of ${items.length} · ↑↓ to move · enter to choose · esc to cancel`));
+  return out.join('\n');
+}
+
+export async function repo(ctx, args) {
+  needWorkspace(ctx);
+  const name = args[0] || await pickRepo(ctx);
+  if (!name) return 1;
+  const r = await load(ctx, `Loading ${name}…`, () => ctx.api.repo(name, { signal: ctx.signal }));
+  if (ctx.json) { json(r); return 0; }
+  line(`${c.b(r.full_name)}  ${r.protected ? c.g('● protected') : c.m('○ open')}  ${c.m(`default ${r.default_branch} · ${plural(r.branches.length, 'branch')} · ${plural(r.overlay_count, 'overlay')}`)}`);
+  line();
+  line(h('Branch rules'));
+  if (!r.branch_rules.length) empty(`no rules${r.can_manage ? ' · add them on gitroots.com › Repositories' : ''}`);
+  for (const b of r.branch_rules) {
+    const push = b.allow_direct_push ? c.g('✓ direct push') : c.r('✕ no direct push');
+    line(`  ${c.b(pad(b.pattern, 22))}${pad(b.level === 'leads' ? c.w('◐ leads only') : b.level === 'open' ? c.m('○ open') : c.g(`● ${b.level}`), 16)}${pad(push, 20)}${c.m(b.description)}`);
+  }
+  if (r.github_protected_branches?.length) line(`  ${c.m(`GitHub protects: ${r.github_protected_branches.join(', ')}`)}`);
+  if (r.environments?.length) {
+    line();
+    line(h('Environments'));
+    for (const e of r.environments) line(`  ${pad(e.name, 18)}${pad(e.branch || '', 22)}${c.m(`${e.audience || ''} · ${e.state || ''}`)}`);
+  }
+  line();
+  line(h(`People · ${r.developer_count}${r.external_count ? ` (${r.external_count} external)` : ''}`));
+  for (const p of r.people.slice(0, 12)) line(`  ${pad(p.display_name || p.name, 26)}${c.m(p.detail || p.kind)}`);
+  if (r.people.length > 12) line(`  ${c.m(`+ ${r.people.length - 12} more`)}`);
+  line();
+  line(h('Branches'));
+  if (!r.branches.length) empty('none synced yet · gitroots fetches them from GitHub');
+  else line(`  ${fit(r.branches.slice(0, 30).join('  '), cols() - 4)}${r.branches.length > 30 ? c.m(`  + ${r.branches.length - 30} more`) : ''}`);
+  return 0;
+}
+
+// ---------------------------------------------------------------- /approvals
+
+function approvalRow(a, sel) {
+  const mark = a.status === 'failed' ? c.r('✕ failed ') : a.status === 'queued' ? c.i('○ merging') : a.type === 'access' ? c.w('◐ access ') : c.w('◐ merge  ');
+  const who = a.requested_by?.display_name || a.user?.display_name || '';
+  const t = `${fit(a.title, 40)}  ${c.m(fit([who, a.meta, a.age].filter(Boolean).join(' · '), Math.max(10, cols() - 62)))}`;
+  return `${sel ? c.g('❯ ') : '  '}${mark}  ${sel ? c.b(t) : t}`;
+}
+
+export async function approvals(ctx, args) {
+  needWorkspace(ctx);
+  const state = ['waiting', 'approved', 'declined'].includes(args[0]) ? args[0] : 'waiting';
+  const d = await load(ctx, 'Loading approvals…', () => ctx.api.approvals(state, { signal: ctx.signal }));
+  if (ctx.json) { json(d); return 0; }
+  if (!d.items.length) { line(`${c.g('✓')} nothing ${state === 'waiting' ? 'waiting on approval' : state}`); return 0; }
+  if (!ctx.session || !interactive() || state !== 'waiting') {
+    for (const a of d.items) line(approvalRow(a, false));
+    line();
+    next(ctx, 'approvals');
+    return 0;
+  }
+  line(`${c.i(c.b('?'))} ${plural(d.waiting_count, 'request')} waiting · pick one`);
+  const res = await select({ count: d.items.length, render: (i) => windowed(d.items, i, 8, approvalRow) });
+  if (res.action === 'cancel') return 0;
+  return decideApproval(ctx, d.items[res.index]);
+}
+
+async function decideApproval(ctx, a) {
+  line();
+  line(`${c.b(a.title)}  ${c.m(a.kind)}`);
+  if (a.type === 'sync') {
+    line(`  ${c.s(pad('from', 10))}${a.from}:${a.from_branch} → ${a.to}:${a.to_branch}`);
+    line(`  ${c.s(pad('changes', 10))}${plural(a.commits || 0, 'commit')}${a.files != null ? ` · ${plural(a.files, 'file')} ${c.g(`+${a.additions || 0}`)} ${c.r(`−${a.deletions || 0}`)}` : ''}`);
+    if (a.requested_by) line(`  ${c.s(pad('by', 10))}${a.requested_by.display_name} ${c.m(a.requester_meta || '')}`);
+    if (a.ai_risk) line(`  ${c.s(pad('ai review', 10))}${a.ai_risk}`);
+  } else {
+    line(`  ${c.s(pad('who', 10))}${a.user?.display_name} ${c.m(a.requester_meta || '')}`);
+    line(`  ${c.s(pad('wants', 10))}${a.rule.replace(/_/g, ' ')} on ${a.repo}${a.branch ? ` (${a.branch})` : ''} for ${a.days} days ${a.within_policy ? c.g('✓ within policy') : c.w(`◐ policy max ${a.policy_max_days} days`)}`);
+  }
+  if (a.note) line(`  ${c.s(pad('note', 10))}${a.note}`);
+  line();
+  const actions = a.type === 'sync'
+    ? (a.status === 'failed' ? [['retry', 'Retry the merge'], ['decline', 'Decline'], ['back', 'Back']]
+      : a.status === 'queued' ? [['back', 'Back (merge in progress)']]
+        : [['approve', 'Approve and merge'], ['changes', 'Request changes'], ['decline', 'Decline'], ['back', 'Back']])
+    : [['approve', 'Approve access'], ['decline', 'Decline'], ['back', 'Back']];
+  const pick = await select({ count: actions.length, render: (i) => actions.map(([, label], j) => `${j === i ? c.g('❯ ') : '  '}${j === i ? c.b(label) : label}`).join('\n') });
+  if (pick.action === 'cancel') return 0;
+  const act = actions[pick.index][0];
+  if (act === 'back') return 0;
+  let result;
+  if (a.type === 'sync' && (act === 'approve' || act === 'retry')) {
+    if (!(await confirm(`Merge ${a.from_branch} into ${a.to}:${a.to_branch}?`, { def: false }))) { line(c.m('  nothing changed')); return 0; }
+    const note = await ask('Note (optional)');
+    result = await load(ctx, 'Approving…', () => ctx.api.approveSync(a.id, note, { signal: ctx.signal }));
+    line(`${c.g('✓')} Approved ${c.b(a.title)} ${c.m(`· ${result?.detail === 'queued' ? 'merge queued' : 'merged'}`)}`);
+  } else if (a.type === 'sync') {
+    const reason = await ask(act === 'changes' ? 'What needs to change?' : 'Reason (optional)');
+    if (act === 'changes' && !reason) { line(c.m('  nothing sent')); return 0; }
+    await load(ctx, 'Sending…', () => ctx.api.declineSync(a.id, act === 'changes' ? 'changes' : 'decline', reason, { signal: ctx.signal }));
+    line(`${act === 'changes' ? c.w('◐ Changes requested on') : c.r('✕ Declined')} ${c.b(a.title)}`);
+  } else {
+    const reason = act === 'decline' ? await ask('Reason (optional)') : '';
+    await load(ctx, 'Saving…', () => ctx.api.decideAccess(a.id, act, reason, { signal: ctx.signal }));
+    line(`${act === 'approve' ? c.g('✓ Approved') : c.r('✕ Declined')} ${c.b(a.title)}`);
+  }
+  next(ctx, 'approvals');
+  return 0;
+}
+
+// ---------------------------------------------------------------- /pushes, /audit, /activity, /members
+
+export async function pushes(ctx, args, flags) {
+  needWorkspace(ctx);
+  const blocked = Boolean(flags.blocked || args.includes('blocked'));
+  const d = await load(ctx, 'Loading pushes…', () => ctx.api.pushEvents(blocked, { signal: ctx.signal }));
+  if (ctx.json) { json(d.items); return 0; }
+  if (!d.items.length) { empty(blocked ? 'no blocked pushes' : 'no pushes recorded yet'); return 0; }
+  table([
+    { label: 'WHEN', w: 18, fmt: (e) => c.m(`${e.date} ${e.time}`) },
+    { label: 'REPO', w: 22, key: 'repo_name' },
+    { label: 'BRANCH', w: 24, key: 'branch' },
+    { label: 'BY', w: 16, key: 'pusher' },
+    { label: 'COMMITS', w: 9, key: 'commit_count' },
+    { label: 'RESULT', w: 30, fmt: (e) => (e.blocked ? c.r(`✕ blocked ${e.rule ? `· ${e.rule}` : ''}`) : c.g('✓ allowed')) },
+  ], d.items.slice(0, 40));
+  return 0;
+}
+
+const CATEGORIES = ['All', 'Blocked', 'Merges', 'Access', 'Other'];
+
+export async function audit(ctx, args, flags) {
+  needWorkspace(ctx);
+  const category = CATEGORIES.find((x) => x.toLowerCase() === String(args[0] || flags.category || 'all').toLowerCase()) || 'All';
+  const q = flags.q || flags.search || (CATEGORIES.some((x) => x.toLowerCase() === String(args[0]).toLowerCase()) ? args.slice(1) : args).join(' ');
+  const d = await load(ctx, 'Loading audit log…', () => ctx.api.audit(category, q, { signal: ctx.signal }));
+  if (ctx.json) { json(d.items); return 0; }
+  if (!d.items.length) { empty('no events match'); return 0; }
+  const summary = (m) => Object.entries(m || {}).filter(([, v]) => v !== '' && v !== null && typeof v !== 'object').slice(0, 3).map(([k, v]) => `${k} ${v}`).join(' · ');
+  table([
+    { label: 'WHEN', w: 17, fmt: (e) => c.m(`${e.day.slice(5)} ${e.time}`) },
+    { label: 'WHO', w: 20, key: 'actor_short' },
+    { label: 'WHAT', w: 30, fmt: (e) => (e.category === 'Blocked' ? c.r(e.action_display) : e.action_display) },
+    { label: 'DETAILS', w: 40, fmt: (e) => c.m(summary(e.metadata)) },
+  ], d.items.slice(0, 50));
+  line(`  ${c.m(`${Math.min(50, d.items.length)} of ${d.items.length} · categories: ${CATEGORIES.join(', ')} · e.g. ${cmdText(ctx, 'audit', 'blocked')}`)}`);
+  return 0;
+}
+
+export async function activity(ctx) {
+  needWorkspace(ctx);
+  const d = await load(ctx, 'Loading team activity…', () => ctx.api.teamActivity({ signal: ctx.signal }));
+  if (ctx.json) { json(d); return 0; }
+  const delta = d.delta_pct === null || d.delta_pct === undefined ? '' : d.delta_pct >= 0 ? c.g(` ↑ ${d.delta_pct}%`) : c.r(` ↓ ${Math.abs(d.delta_pct)}%`);
+  line(`${c.b(d.organization)} ${c.m(`· last ${d.weeks} weeks`)}`);
+  line(`  ${plural(d.commit_count || 0, 'commit')} ${c.m('·')} ${plural(d.merged_count || 0, 'merge')} ${c.m('·')} ${plural(d.people_count || 0, 'person')}${delta}`);
+  // heatmap: one row of the weekly levels
+  const levels = (d.cells || []).map((x) => (typeof x === 'object' ? x.level ?? 0 : x));
+  if (levels.length) {
+    const shades = [c.m('·'), c.g('▁'), c.g('▃'), c.g('▅'), c.g('█')];
+    line(`  ${levels.slice(-Math.min(levels.length, 70)).map((l) => shades[Math.max(0, Math.min(4, l))]).join('')}  ${c.m('daily, oldest → today')}`);
+  }
+  for (const [title, rows] of [['Most active', d.most_active], ['Leads', d.leads], ['External', d.external]]) {
+    if (!rows || !rows.length) continue;
+    line();
+    line(h(title));
+    for (const p of rows.slice(0, 8)) line(`  ${pad(p.display_name || p.name, 26)}${pad(`${p.commits} commits · ${p.merged} merged`, 30)}${c.m(p.detail || p.role || '')}`);
+  }
+  return 0;
+}
+
+export async function members(ctx) {
+  needWorkspace(ctx);
+  const d = await load(ctx, 'Loading members…', () => ctx.api.members({ signal: ctx.signal }));
+  if (ctx.json) { json(d.members); return 0; }
+  table([
+    { label: 'NAME', w: 28, fmt: (m) => c.b(m.display_name || m.name) },
+    { label: 'EMAIL', w: 34, key: 'email' },
+    { label: 'ROLE', w: 16, fmt: (m) => m.role_display || m.role },
+    { label: '', w: 10, fmt: (m) => (m.external ? c.w('external') : '') },
+  ], d.members);
+  return 0;
+}

package/src/ui/term.js

@@ -137,6 +137,8 @@ export function parseKeys(buf) {
       ['\x1b[A', 'up'], ['\x1b[B', 'down'], ['\x1b[C', 'right'], ['\x1b[D', 'left'],
       ['\x1bOA', 'up'], ['\x1bOB', 'down'], ['\x1bOC', 'right'], ['\x1bOD', 'left'],
       ['\x1b[Z', 'shift-tab'], ['\x1b[5~', 'pageup'], ['\x1b[6~', 'pagedown'],
+      ['\x1b[H', 'home'], ['\x1b[F', 'end'], ['\x1b[1~', 'home'], ['\x1b[4~', 'end'], ['\x1bOH', 'home'], ['\x1bOF', 'end'], ['\x1b[3~', 'delete'],
+      ['\x1b[1;3D', 'word-left'], ['\x1b[1;3C', 'word-right'], ['\x1bb', 'word-left'], ['\x1bf', 'word-right'], ['\x1b\x7f', 'ctrl-w'],
     ];
     const hit = seqs.find(([q]) => rest.startsWith(q));
     if (hit) { keys.push({ name: hit[1] }); i += hit[0].length; continue; }

package/src/commands/attach.js

@@ -1,262 +0,0 @@
-// gitroots attach <session> · full screen, prefix ctrl-g
-import { c, pad, fit, width } from '../ui/ansi.js';
-import { line, interactive, enterFullscreen, leaveFullscreen, paintFrame, size, parseKeys, FRAMES } from '../ui/term.js';
-import { json, next, sessionState } from '../ui/components.js';
-import { liveLog } from '../data/live.js';
-import { createBackup } from './backup.js';
-
-export async function run(_cmd, rest, flags, store) {
-  const [id] = rest;
-  if (!id) throw new Error('which session? gitroots attach <session> · see gitroots watch');
-  const s = store.session(id);
-  if (flags.shell) return shell(store, s);
-  if (flags.json) { json({ session: s, transcript: store.transcript(s.id) }); return 0; }
-  if (!interactive()) {
-    // Piped: print the transcript tail instead of taking over the terminal.
-    for (const t of store.transcript(s.id)) line(t.who === 'log' ? `       ${t.time}  ${t.verb.padEnd(8)}${t.body}${t.add || ''}` : `${t.who === 'you' ? 'you  ' : 'agent'}  ${t.text.replace(/[§*]/g, '')}`);
-    if (s.ask) line(`◐ ${s.agent} asks: ${s.ask.question}`);
-    return 0;
-  }
-  return attach(store, s.id);
-}
-
-// A shell next to the agent. Sessions on this machine get a real local shell;
-// remote machines need agentd and a connected relay.
-async function shell(store, s) {
-  const m = store.machine(s.machine);
-  if (!m.self) {
-    throw new Error(`${s.id} runs on ${m.name} · a remote shell goes through agentd on ${m.name}, which this sample org does not have · sessions on ${store.machines().find((x) => x.self)?.name || 'this machine'} open a real shell`);
-  }
-  const { spawn } = await import('node:child_process');
-  const sh = process.env.SHELL || (process.platform === 'win32' ? process.env.ComSpec || 'cmd.exe' : '/bin/sh');
-  line(`${c.g(c.b('gitroots'))}  shell for ${c.b(s.id)} on ${m.name} ${c.m(`· ${s.repo} · ${s.branch} · exit to return`)}`);
-  store.record({ actor: store.org.user, action: 'shell', target: s.id, decision: 'allowed', note: m.name, repo: s.repo });
-  store.save();
-  return new Promise((resolve) => {
-    const child = spawn(sh, [], { stdio: 'inherit', env: { ...process.env, GITROOTS_SESSION: s.id } });
-    child.on('exit', (code) => { line(c.m(`  shell closed · ${s.id} keeps running`)); resolve(code ?? 0); });
-  });
-}
-
-const REPLIES = {
-  's-2c91': [
-    [ // Yes, run on staging
-      { verb: 'run', body: 'odoo-bin -d staging -u pos_refund --stop-after-init', ms: 900 },
-      { verb: 'output', body: 'post-migrate 17.0.1.3: adding column pos_order.refunded_amount', ms: 700 },
-      { verb: 'output', body: 'backfilled 18,402 orders in 38.6s · ', add: 'OK', ms: 1400 },
-      { verb: 'backup', body: 'auto · before risky · kept', add: '  ✓', ms: 400 },
-      { say: 'The migration ran on staging: 18,402 orders backfilled, no errors. PR #412 is ready for your approval.' },
-    ],
-    [ // erp_test first
-      { verb: 'run', body: 'odoo-bin -d erp_test -u pos_refund --stop-after-init', ms: 900 },
-      { verb: 'output', body: 'backfilled 2,117 orders in 6.1s · ', add: 'OK', ms: 1200 },
-      { say: 'It ran cleanly on erp_test (2,117 orders). Say the word and I will run it on staging.' },
-    ],
-    [ // show SQL
-      { say: 'Here is what post-migrate.py runs:\n§ALTER TABLE pos_order ADD COLUMN refunded_amount numeric DEFAULT 0;§\n§UPDATE pos_order o SET refunded_amount = r.total FROM (§\n§  SELECT refund_order_id, SUM(amount_total) total FROM pos_order_refund GROUP BY 1) r§\n§WHERE o.id = r.refund_order_id;§' },
-    ],
-  ],
-};
-
-export function attach(store, id) {
-  const s = store.session(id);
-  return new Promise((resolve) => {
-    const st = {
-      tick: 0, input: '', prefix: false, choice: 0, flash: null, busy: false, mode: null,
-      running: null, // the activity line in progress
-    };
-    const say = (msg, tone = 'g') => { st.flash = { msg, tone, until: Date.now() + 3500 }; };
-    const transcript = () => (store.d.transcripts[s.id] = store.d.transcripts[s.id] || []);
-
-    const play = async (steps) => {
-      st.busy = true;
-      s.state = 'running';
-      for (const step of steps) {
-        if (step.say) { transcript().push({ who: 'agent', text: step.say }); continue; }
-        const entry = { who: 'log', verb: step.verb, body: step.body, add: step.add, time: new Date().toTimeString().slice(0, 8) };
-        transcript().push(entry);
-        st.running = entry;
-        await new Promise((r) => setTimeout(r, step.ms || 600));
-        st.running = null;
-      }
-      s.turns++;
-      s.updated = 'just now';
-      st.busy = false;
-      store.save();
-    };
-
-    const answer = (idx) => {
-      const ask = s.ask;
-      transcript().push({ who: 'you', text: `${idx + 1}. ${ask.options[idx]}` });
-      store.record({ actor: store.org.user, action: 'agent approval', target: `${s.id} · ${ask.options[idx]}`, decision: 'recorded', note: s.agent, repo: s.repo });
-      s.ask = undefined;
-      store.save();
-      const script = (REPLIES[s.id] || [])[idx] || [{ say: `OK: ${ask.options[idx].toLowerCase()}.` }];
-      play(script);
-    };
-
-    const send = (text) => {
-      transcript().push({ who: 'you', text });
-      store.save();
-      play([{ verb: 'think', body: `Reading the request: "${text.slice(0, 60)}"`, ms: 900 }, { say: 'On it. I will post progress here and ask before anything risky.' }]);
-    };
-
-    const detach = (msg) => {
-      clearInterval(timer);
-      process.stdin.off('data', onData);
-      process.stdout.off('resize', draw);
-      process.stdin.setRawMode(false);
-      process.stdin.pause();
-      leaveFullscreen();
-      store.save();
-      if (msg !== false) {
-        line(`${c.g('✓')} Detached from ${c.b(s.id)} ${c.m('·')} it keeps running on ${s.machine}   ${sessionState(s)}`);
-        line(next(`gitroots attach ${s.id}`, 'gitroots watch'));
-      }
-      resolve(0);
-    };
-
-    const onKey = async (k) => {
-      if (st.mode && st.mode.type === 'transfer') {
-        const m = st.mode;
-        if (k.name === 'escape' || k.name === 'ctrl-c') st.mode = null;
-        else if (k.name === 'up' || k.name === 'left') m.idx = (m.idx - 1 + m.targets.length) % m.targets.length;
-        else if (k.name === 'down' || k.name === 'right' || k.name === 'tab') m.idx = (m.idx + 1) % m.targets.length;
-        else if (k.name === 'enter') {
-          const to = m.targets[m.idx].name;
-          st.mode = null;
-          clearInterval(timer);
-          process.stdin.off('data', onData);
-          process.stdin.setRawMode(false);
-          leaveFullscreen();
-          const { transfer } = await import('./transfer.js');
-          try { await transfer(store, s.id, to); } catch (e) { line(`${c.r('✕')} ${e.message}`); }
-          await new Promise((r) => setTimeout(r, 1200));
-          enterFullscreen();
-          process.stdin.setRawMode(true);
-          process.stdin.resume();
-          process.stdin.on('data', onData);
-          timer = setInterval(tickDraw, 100);
-        }
-        return;
-      }
-      if (st.prefix) {
-        st.prefix = false;
-        switch (k.ch || k.name) {
-          case 'd': case 'q': return detach();
-          case 'b': { const b = createBackup(store, s, 'manual'); store.record({ actor: store.org.user, action: 'backup', target: `${s.id} · ${b.id}`, decision: 'allowed', note: 'from attach', repo: s.repo }); store.save(); say(`✓ backup ${b.id} saved · ${b.sizeMb} MB`); return; }
-          case 't': {
-            const targets = store.machines().filter((m) => m.online && m.name !== s.machine);
-            if (targets.length) st.mode = { type: 'transfer', idx: 0, targets }; else say('no other machine is online', 'w');
-            return;
-          }
-          case 'f': {
-            const nid = store.nextSessionId();
-            store.d.sessions.push({ ...s, id: nid, state: 'idle', ask: undefined, forkedFrom: s.id, updated: 'just now' });
-            store.record({ actor: store.org.user, action: 'fork', target: `${s.id} → ${nid}`, decision: 'allowed', repo: s.repo });
-            store.save();
-            say(`✓ forked → ${nid} · gitroots attach ${nid}`);
-            return;
-          }
-          case 's': {
-            const { default: crypto } = await import('node:crypto');
-            const url = `https://${process.env.GITROOTS_RELAY_DOMAIN || `${store.org.relay.name}.relay.gitroots.com`}/s/${crypto.randomBytes(4).toString('base64url').slice(0, 5)}`;
-            store.d.tunnels.push({ id: store.nextTunnelId(), session: s.id, machine: s.machine, target: 'live view', access: 'read-only link', viewers: 0, traffic: '0 B', at: new Date().toISOString(), url });
-            store.record({ actor: store.org.user, action: 'share', target: `${s.id} read-only`, decision: 'allowed', repo: s.repo });
-            store.save();
-            say(`✓ read-only link ${url}`);
-            return;
-          }
-          case 'h': say(`${store.d.hiddenTurns?.[s.id] || 0} earlier turns are kept in the session backups · gitroots backups --session ${s.id}`, 's'); return;
-          case 'ctrl-g': st.input += ''; say('ctrl-g sent to the agent', 's'); return;
-          default: say('ctrl-g then d detach · b backup · t transfer · f fork · s share · h history', 'w'); return;
-        }
-      }
-      if (k.name === 'ctrl-g') { st.prefix = true; return; }
-      if (k.name === 'ctrl-c') { say('^C goes to the agent · ctrl-g d detaches and keeps it running', 'w'); return; }
-      if (s.ask && !st.busy && !st.input) {
-        if (k.name === 'up') { st.choice = (st.choice - 1 + s.ask.options.length) % s.ask.options.length; return; }
-        if (k.name === 'down') { st.choice = (st.choice + 1) % s.ask.options.length; return; }
-        if (k.ch && /^[1-9]$/.test(k.ch) && Number(k.ch) <= s.ask.options.length) { st.choice = Number(k.ch) - 1; return; }
-        if (k.name === 'enter') { answer(st.choice); return; }
-      }
-      if (k.name === 'enter') { if (st.input.trim() && !st.busy) { send(st.input.trim()); st.input = ''; } return; }
-      if (k.name === 'backspace') { st.input = st.input.slice(0, -1); return; }
-      if (k.ch) st.input += k.ch;
-    };
-
-    const draw = () => {
-      const { cols, rows } = size();
-      const spin = FRAMES[st.tick % FRAMES.length];
-      const m = store.machines().find((x) => x.name === s.machine) || { os: '' };
-      const left = `  ${c.g(c.b('gitroots'))}   ${c.b(`attached · ${s.id}`)}   ${c.s(`${s.agent} on ${s.machine} (${m.os})`)}   ${c.s(`${s.repo} · ${s.branch}`)}   ${s.ask && !st.busy ? c.w('◐ waiting input') : st.busy ? c.g(`${spin} working`) : sessionState(s)}`;
-      const right = `${c.s(`latency 42 ms · backup ${s.backup}`)}  `;
-      const top = c.bg('attach')(fit(left, cols - width(right)) + right);
-
-      const body = [];
-      body.push(c.m(`gitroots · connected through relay ${store.org.relay.name} · this is the agent's own session, streamed live`));
-      body.push(c.m('gitroots · other viewers: none · controls: you'));
-      body.push('');
-      const hidden = store.d.hiddenTurns?.[s.id];
-      if (hidden) { const t = `── earlier · ${hidden} turns hidden · press `; body.push(`${c.m(t)}${c.bg('key')(c.b(' ctrl-g h '))} ${c.m(`for history ${'─'.repeat(Math.max(0, cols - width(t) - 30))}`)}`); body.push(''); }
-
-      const fmt = (text) => text.replace(/§([^§]*)§/g, (_, x) => c.s(x)).replace(/\*([^*]+)\*/g, (_, x) => c.b(x));
-      const tr = store.transcript(s.id);
-      if (!tr.length) {
-        for (const e of liveLog(s, Math.floor(st.tick / 16), 8)) body.push(`${c.m(e.time)}  ${pad(e.verb, 8)}${e.body}${e.add ? c.g(e.add) : ''}${e.del ? c.r(e.del) : ''}${e.fail ? c.r(e.fail) : ''}${e.last && e.running ? `  ${c.i(spin)}` : ''}`);
-        body.push('');
-      }
-      for (const [ti, t] of tr.entries()) {
-        if (t.who === 'log') {
-          body.push(`${' '.repeat(8)}${c.m(t.time)}  ${c.i(pad(t.verb, 8))}${t.body}${t.add ? c.g(t.add) : ''}${st.running === t ? `  ${c.i(spin)} ${c.s('running')}` : ''}`);
-          if (tr[ti + 1] && tr[ti + 1].who !== 'log') body.push('');
-          continue;
-        }
-        const lines = t.text.split('\n');
-        const who = t.who === 'you' ? c.i(c.b(pad('you', 8))) : c.g(c.b(pad('agent', 8)));
-        lines.forEach((l, i) => body.push(`${i === 0 ? who : ' '.repeat(8)}${fmt(l)}`));
-        body.push('');
-      }
-      if (s.ask && !st.busy) {
-        body.push(`${c.w(c.b(`  ◐ Approval needed`))}  ${s.ask.question}`);
-        s.ask.options.forEach((o, i) => body.push(i === st.choice ? `    ${c.g(`❯ ${i + 1}. ${o}`)}` : `      ${i + 1}. ${o}`));
-        body.push('');
-      }
-
-      const BH = rows - 4;
-      const view = body.slice(-BH);
-      while (view.length < BH) view.push('');
-      const sep = c.m('─'.repeat(cols - 2));
-      const cursor = c.bg('green')(c.ink(' '));
-      const prompt = `${c.g('❯')} ${st.input}${cursor}${st.prefix ? `   ${c.w('ctrl-g …')}` : ''}`;
-
-      let bottom;
-      if (st.mode && st.mode.type === 'transfer') {
-        const md = st.mode;
-        bottom = `  ${c.s(`transfer ${s.id} to`)}  ${md.targets.map((t, i) => (i === md.idx ? c.bg('sel')(c.b(` ❯ ${t.name} `)) : c.m(`  ${t.name} `))).join(' ')}   ${c.m('←→ choose · enter go · esc cancel')}`;
-      } else {
-        const k = (key, label) => `${c.bg('key')(c.b(` ${key} `))} ${label}`;
-        const keys = `  ${[k('ctrl-g d', 'detach, keep running'), k('ctrl-g b', 'backup now'), k('ctrl-g t', 'transfer'), k('ctrl-g f', 'fork'), k('ctrl-g s', 'share read-only')].join('  ')}`;
-        const hint = c.m('prefix ctrl-g · everything else goes to the agent  ');
-        bottom = `${fit(keys, Math.max(0, cols - width(hint)))}${hint}`;
-      }
-      if (st.flash && Date.now() < st.flash.until) {
-        const msg = c[st.flash.tone](st.flash.msg);
-        bottom = `${fit(bottom, Math.max(0, cols - width(msg) - 4))}  ${msg}  `;
-      }
-      const frame = [top, ...view.map((l) => ` ${fit(l, cols - 2)}`), ` ${sep}`, ` ${prompt}`, c.bg('bar')(fit(bottom, cols))];
-      paintFrame(frame.slice(0, rows));
-    };
-
-    const tickDraw = () => { st.tick++; draw(); };
-    const onData = (buf) => { (async () => { for (const k of parseKeys(buf)) await onKey(k); draw(); })(); };
-
-    enterFullscreen();
-    process.stdin.setRawMode(true);
-    process.stdin.resume();
-    process.stdin.on('data', onData);
-    process.stdout.on('resize', draw);
-    let timer = setInterval(tickDraw, 100);
-    draw();
-  });
-}