sizmo 0.4.0

package/commands/brief.mjs

@@ -0,0 +1,213 @@
+// commands/brief.mjs — Morning brief orchestrator. In-process: calls the 5 sub-collect()s on the
+// SAME shared ctx. One http client, one rate budget, zero child-process spawning.
+// NEEDS YOU TODAY uses rankActions from lib/prioritize.mjs — same ranker as ghl focus.
+// READ-ONLY. Never writes, never sends, never charges.
+import { collect as snapCollect } from './snapshot.mjs';
+import { collect as triageCollect } from './triage.mjs';
+import { collect as noshowCollect } from './noshow.mjs';
+import { collect as pipeCollect } from './pipeline.mjs';
+import { collect as arCollect } from './receivables.mjs';
+import { rankActions, hasMixedCurrencies } from '../lib/prioritize.mjs';
+
+export const meta = {
+  name: 'brief',
+  summary: 'morning brief — numbers + NEEDS YOU TODAY',
+  flags: [{ name: '--days', type: 'int', default: 7, desc: 'snapshot window in days' }],
+  readOnly: true,
+};
+
+// ── helpers ──────────────────────────────────────────────────────────────────
+const SYM = { PHP: '₱', USD: '$', EUR: '€', GBP: '£' };
+const m = (n, c = 'PHP') => !Number.isFinite(Number(n)) ? '—' : (SYM[c] || c + ' ') + Number(n || 0).toLocaleString('en-PH', { maximumFractionDigits: 0 });
+
+// Parse an age string like "21d", "3h", "5m" back to ageDays
+function parseAgeDays(str) {
+  if (typeof str === 'number') return str;
+  if (!str) return 0;
+  const match = String(str).match(/^(\d+(?:\.\d+)?)(d|h|m)$/i);
+  if (!match) return 0;
+  const n = Number(match[1]);
+  if (match[2] === 'd') return n;
+  if (match[2] === 'h') return Math.ceil(n / 24);
+  return Math.max(0, Math.ceil(n / 1440));
+}
+
+// Shape the 4 lane sources into rankActions input format.
+// Called by both collect() (for the JSON envelope) and run() (for the TTY card).
+function shapeLanes(sources, now) {
+  const { triage, noshow, pipeline: pipe, receivables: ar, bnp } = sources;
+
+  const deals = pipe?.__error ? [] : (pipe?.stuck || []).map(d => ({
+    contactId:     d.contactId,
+    name:          d.name || '(unknown)',
+    monetaryValue: Number(d.value) || 0,
+    ageDays:       parseAgeDays(d.idle),
+  }));
+
+  const invoices = ar?.__error ? [] : (ar?.list || []).map(i => ({
+    contactId: i.id,
+    name:      i.name || '(unknown)',
+    due:       Number(i.due) || 0,
+    cur:       i.cur || 'PHP',
+    ageDays:   Number(i.age) || 0,
+  }));
+
+  const threads = triage?.__error ? [] : (triage?.threads || []).map(t => ({
+    contactId: t.contactId,
+    name:      t.name || '(unknown)',
+    ageDays:   parseAgeDays(t.waiting),
+  }));
+
+  const noshows = noshow?.__error ? [] : (noshow?.list || []).map(n => ({
+    contactId: n.contactId,
+    name:      n.name || '(unknown)',
+    ageDays:   Math.floor((now - new Date(n.when).getTime()) / 86400000),
+  }));
+
+  const neverBilled = bnp?.__error ? [] : (bnp?.neverBilled || []).map(b => ({
+    contactId: b.contactId,
+    name:      b.name || '(unknown)',
+    estValue:  0,
+    ageDays:   Math.floor((now - (b.lastSessionTs || 0)) / 86400000),
+  }));
+
+  return { deals, invoices, threads, noshows, neverBilled };
+}
+
+// Wrap a collect() so a throw → degraded sentinel instead of crashing the brief.
+async function safe(name, fn, ctx) {
+  try {
+    return await fn();
+  } catch (err) {
+    const msg = `${name} failed — ${(err?.message || String(err)).split('\n')[0]}`;
+    ctx.out.warn(msg, { degraded: true });
+    return { __error: msg };
+  }
+}
+
+// ── collect: the composable data layer ───────────────────────────────────────
+export async function collect(args, ctx) {
+  const DAYS = args.days != null ? args.days : 7;
+
+  // Fan-out all 5 sub-collects in parallel on the same ctx.
+  // Each uses ctx.cfg.loc / ctx.http / ctx.now — no creds duplication.
+  const [snap, triage, noshow, pipe, ar] = await Promise.all([
+    safe('snapshot',   () => snapCollect({ days: DAYS }, ctx), ctx),
+    safe('triage',     () => triageCollect({ days: 30, top: 100 }, ctx), ctx),
+    safe('noshow',     () => noshowCollect({ days: 30, top: 100 }, ctx), ctx),
+    safe('pipeline',   () => pipeCollect({ 'stuck-days': 7, top: 100 }, ctx), ctx),
+    safe('receivables',() => arCollect({ top: 100 }, ctx), ctx),
+  ]);
+
+  const loc = snap.location || triage.location || ctx.cfg.loc;
+
+  // Build the prioritised action list using rankActions (same ranker as ghl focus).
+  // Additive: keep count + recipe for backward compat; add money + age fields.
+  const lanes = shapeLanes({ triage, noshow, pipeline: pipe, receivables: ar }, ctx.now);
+  const { ranked, unknownValue } = rankActions(lanes);
+
+  // Build the actions array: ranked items first (money-ordered), then unknownValue items.
+  // Keep backward-compat fields (count, kind, recipe) — add money + age.
+  const actions = [];
+  for (const item of ranked) {
+    const recipeMap = { deal: 'pipeline', invoice: 'receivables', 'never-billed': 'booked-not-paid' };
+    actions.push({
+      count: 1,
+      kind:  item.kind === 'deal' ? 'stuck-deals' : item.kind === 'invoice' ? 'receivables' : item.kind,
+      recipe: recipeMap[item.kind] || item.action.replace('ghl ', ''),
+      money:  item.money,
+      cur:    item.cur,
+      age:    item.age,
+      inputs: item.inputs,
+      contact: item.contact,
+      name:    item.name,
+    });
+  }
+  for (const item of unknownValue) {
+    const recipeMap = { 'waiting-reply': 'triage', noshow: 'noshow', 'never-billed': 'booked-not-paid' };
+    actions.push({
+      count: 1,
+      kind:  item.kind,
+      recipe: recipeMap[item.kind] || item.action.replace('ghl ', ''),
+      money:  null,
+      age:    item.age,
+      inputs: item.inputs,
+      contact: item.contact,
+      name:    item.name,
+    });
+  }
+
+  return {
+    location: loc,
+    days: DAYS,
+    snapshot: snap,
+    actions,
+    sources: { triage, noshow, pipeline: pipe, receivables: ar },
+  };
+}
+
+// ── run: bimodal output (JSON envelope OR TTY morning card) ──────────────────
+export async function run(args, ctx) {
+  const DAYS = args.days != null ? args.days : 7;
+  const data = await collect(args, ctx);
+
+  // Machine mode: hand the combined document to the envelope
+  ctx.out.data(data);
+
+  // TTY mode: render the MORNING BRIEF card
+  ctx.out.card(() => {
+    const today = new Date().toLocaleDateString('en-US', {
+      timeZone: 'Asia/Manila', weekday: 'long', month: 'short', day: 'numeric',
+    });
+    const W = 64;
+    const bar = (ch = '─') => ch.repeat(W);
+    const pad = (s) => { const str = String(s); return str.length >= W ? str.slice(0, W) : str + ' '.repeat(W - str.length); };
+
+    ctx.out.line('\n╔' + bar('═') + '╗');
+    ctx.out.line('║' + pad('  MORNING BRIEF — ' + today) + '║');
+    ctx.out.line('║' + pad('  loc ' + data.location + '  ·  read-only') + '║');
+    ctx.out.line('╚' + bar('═') + '╝');
+
+    // THE NUMBERS
+    ctx.out.line('\n  THE NUMBERS (last ' + DAYS + 'd)');
+    ctx.out.line('  ' + bar());
+    const snap = data.snapshot;
+    if (snap.__error) {
+      ctx.out.line('  ⚠ snapshot — ' + snap.__error);
+    } else {
+      for (const metric of (snap.metrics || [])) {
+        const v = metric.blocked ? "⚠ can't see (" + metric.blocker + ')' : metric.value;
+        ctx.out.line('  ' + String(metric.label).padEnd(16) + ' ' + v);
+      }
+    }
+
+    // NEEDS YOU TODAY — ordered by rankActions (same ranker as ghl focus)
+    const { triage, noshow, pipeline: pipe, receivables: ar } = data.sources;
+
+    ctx.out.line('\n  NEEDS YOU TODAY');
+    ctx.out.line('  ' + bar());
+
+    // Surface blocked sources honestly — never fake a number
+    for (const [name, obj] of [['triage', triage], ['no-show', noshow], ['pipeline', pipe], ['receivables', ar]]) {
+      if (obj?.__error) ctx.out.line(`  ⚠ ${name} — ${obj.__error}`);
+    }
+
+    const actions = data.actions || [];
+    if (!actions.length) {
+      ctx.out.line('  All clear — nobody waiting, nothing stuck, nothing owed. ✅');
+    } else {
+      actions.forEach((action, i) => {
+        const label = action.inputs || action.name || action.kind;
+        const recipe = `ghl ${action.recipe}`;
+        ctx.out.line(`  ${i + 1}. ${label.padEnd(48)} → ${recipe}`);
+      });
+    }
+
+    ctx.out.line('  ' + bar());
+    ctx.out.line('  Ranked by money at stake (deal value, invoice amount due). Value-unknown items below.');
+    ctx.out.line('  Drill into any line with its recipe. Segment/tag on demand: ghl segment.');
+    ctx.out.line('  I draft + you approve every outward action. Money stays you, always.\n');
+  });
+
+  return 0;
+}

package/commands/focus.mjs

@@ -0,0 +1,163 @@
+// commands/focus.mjs — One ranked action queue by money at stake.
+// Reuses the 5 existing collect()s on the shared cached ctx — inherits A's speed + cache.
+// Ranks via lib/prioritize.mjs (single source of truth shared with brief).
+// READ-ONLY. Never sends, charges, or writes.
+import { collect as pipeCollect }   from './pipeline.mjs';
+import { collect as arCollect }     from './receivables.mjs';
+import { collect as triageCollect } from './triage.mjs';
+import { collect as noshowCollect } from './noshow.mjs';
+import { collect as bnpCollect }    from './booked-not-paid.mjs';
+import { rankActions, hasMixedCurrencies } from '../lib/prioritize.mjs';
+
+export const meta = {
+  name: 'focus',
+  summary: 'one ranked to-do queue by money at stake',
+  flags: [
+    { name: '--top',       type: 'int', default: 15, desc: 'max items to display' },
+    { name: '--stuck-days',type: 'int', default: 7,  desc: 'idle threshold for stuck deals' },
+  ],
+  readOnly: true,
+};
+
+// Parse an age string like "21d", "3h", "5m" back to ageDays (fractional ok, floor to 0)
+function parseAgeDays(str, nowMs) {
+  if (typeof str === 'number') return str;
+  if (!str) return 0;
+  const m = String(str).match(/^(\d+(?:\.\d+)?)(d|h|m)$/i);
+  if (!m) return 0;
+  const n = Number(m[1]);
+  if (m[2] === 'd') return n;
+  if (m[2] === 'h') return Math.ceil(n / 24);
+  return Math.max(0, Math.ceil(n / 1440));
+}
+
+// Wrap a collect() so a throw → degraded sentinel instead of crashing focus
+async function safe(name, fn, ctx) {
+  try { return await fn(); }
+  catch (err) {
+    const msg = `${name} failed — ${(err?.message || String(err)).split('\n')[0]}`;
+    ctx.out.warn(msg, { degraded: true });
+    return { __error: msg };
+  }
+}
+
+// ── collect: shape all lanes into rankActions input, return ranked result ─────
+export async function collect(args, ctx) {
+  const STUCK_DAYS = args['stuck-days'] ?? 7;
+  const NOW = ctx.now;
+
+  // Fan-out all 5 sub-collects in parallel on the same ctx (same http client, same cache)
+  const [pipe, ar, triage, noshow, bnp] = await Promise.all([
+    safe('pipeline',       () => pipeCollect({ 'stuck-days': STUCK_DAYS, top: 200 }, ctx), ctx),
+    safe('receivables',    () => arCollect({ top: 200 }, ctx), ctx),
+    safe('triage',         () => triageCollect({ days: 30, top: 200 }, ctx), ctx),
+    safe('noshow',         () => noshowCollect({ days: 30, top: 200 }, ctx), ctx),
+    safe('booked-not-paid',() => bnpCollect({ days: 30, top: 200 }, ctx), ctx),
+  ]);
+
+  const loc = pipe.location || ar.location || triage.location || ctx.cfg.loc;
+
+  // ── Shape lane data into rankActions input ────────────────────────────────
+
+  // deals: pipeline stuck — each has monetaryValue + idle string like "21d"
+  const deals = pipe.__error ? [] : (pipe.stuck || []).map(d => ({
+    contactId:     d.contactId,
+    name:          d.name || '(unknown)',
+    monetaryValue: Number(d.value) || 0,
+    ageDays:       parseAgeDays(d.idle),
+  }));
+
+  // invoices: receivables list — already has due + cur + age (days)
+  const invoices = ar.__error ? [] : (ar.list || []).map(i => ({
+    contactId: i.id,   // receivables uses i.id as the invoice id; contactId not in list shape
+    name:      i.name || '(unknown)',
+    due:       Number(i.due) || 0,
+    cur:       i.cur || 'PHP',
+    ageDays:   Number(i.age) || 0,
+  }));
+  // Fix: receivables.list has no contactId in the shape. Use invoice id as fallback key.
+  // The action points to 'ghl receivables' which shows the full list.
+
+  // threads: triage.threads — has waiting string like "3d"; no monetary value
+  const threads = triage.__error ? [] : (triage.threads || []).map(t => ({
+    contactId: t.contactId,
+    name:      t.name || '(unknown)',
+    ageDays:   parseAgeDays(t.waiting),
+  }));
+
+  // noshows: noshow.list — has when (ISO), compute ageDays
+  const noshows = noshow.__error ? [] : (noshow.list || []).map(n => ({
+    contactId: n.contactId,
+    name:      n.name || '(unknown)',
+    ageDays:   Math.floor((NOW - new Date(n.when).getTime()) / 86400000),
+  }));
+
+  // neverBilled: booked-not-paid.neverBilled — no estValue in the collect output shape
+  // (booked-not-paid detect they have sessions but no invoice — value unknown)
+  const neverBilled = bnp.__error ? [] : (bnp.neverBilled || []).map(b => ({
+    contactId: b.contactId,
+    name:      b.name || '(unknown)',
+    estValue:  0,   // no estimate available from this collect → goes to unknownValue group
+    ageDays:   Math.floor((NOW - (b.lastSessionTs || 0)) / 86400000),
+  }));
+
+  const { ranked, unknownValue } = rankActions({ deals, invoices, threads, noshows, neverBilled });
+  const mixedCurrencies = hasMixedCurrencies(ranked);
+
+  return { location: loc, ranked, unknownValue, mixedCurrencies };
+}
+
+// ── run: bimodal output (JSON envelope OR TTY card) ───────────────────────────
+export async function run(args, ctx) {
+  const TOP = args.top ?? 15;
+  const data = await collect(args, ctx);
+
+  ctx.out.data(data);
+
+  ctx.out.card(() => {
+    const W = 70;
+    const bar = (ch = '─') => ch.repeat(W);
+    ctx.out.line('\n  FOCUS — ranked action queue by money at stake  ·  loc ' + data.location);
+    ctx.out.line('  ' + bar());
+
+    if (!data.ranked.length && !data.unknownValue.length) {
+      ctx.out.line('  Nothing to action — all clear. ✅\n');
+      return;
+    }
+
+    // ── MONEY-RANKED items ──────────────────────────────────────────────────
+    if (data.ranked.length) {
+      ctx.out.line('  RANKED BY MONEY AT STAKE');
+      const show = data.ranked.slice(0, TOP);
+      show.forEach((item, i) => {
+        const label = (item.name || '(unknown)').slice(0, 24).padEnd(24);
+        ctx.out.line(`  ${String(i + 1).padStart(2)}. ${label}  ${item.inputs}`);
+        ctx.out.line(`      → ${item.action}  ·  contact ${item.contact}`);
+      });
+      if (data.ranked.length > TOP) ctx.out.line(`  … +${data.ranked.length - TOP} more money items`);
+      ctx.out.line('');
+    }
+
+    // ── UNKNOWN VALUE items ─────────────────────────────────────────────────
+    if (data.unknownValue.length) {
+      ctx.out.line('  VALUE UNKNOWN — your call');
+      ctx.out.line('  (no money on record; sorted oldest first — may still be urgent)');
+      data.unknownValue.slice(0, TOP).forEach((item, i) => {
+        const label = (item.name || '(unknown)').slice(0, 24).padEnd(24);
+        ctx.out.line(`  ${String(i + 1).padStart(2)}. ${label}  ${item.inputs}`);
+        ctx.out.line(`      → ${item.action}  ·  contact ${item.contact}`);
+      });
+      if (data.unknownValue.length > TOP) ctx.out.line(`  … +${data.unknownValue.length - TOP} more unknown-value items`);
+      ctx.out.line('');
+    }
+
+    ctx.out.line('  ' + bar());
+    ctx.out.line('  Ranked by money we can actually see (deal value, invoice amount due, est. value).');
+    if (data.mixedCurrencies) {
+      ctx.out.line('  ⚠ Mixed currencies detected — ranked by raw number, NOT converted. ₱1000 vs $100 is NOT comparable.');
+    }
+    ctx.out.line('  Read-only: I surface + point to the recipe. You act.\n');
+  });
+
+  return 0;
+}

package/commands/noshow.mjs

@@ -0,0 +1,117 @@
+// commands/noshow.mjs — No-show recovery: surfaces who no-showed to re-book.
+// Trust-fix #1: LOC from ctx.cfg.loc (no baked default).
+// READ-ONLY. Never messages, never books.
+import { mapLimit } from '../lib/pool.mjs';
+export const meta = {
+  name: 'noshow',
+  summary: 'No-show recovery — who to re-book',
+  flags: [
+    { name: '--days', type: 'int', default: 30, desc: 'lookback window' },
+    { name: '--top', type: 'int', default: 15, desc: 'max results' },
+  ],
+  readOnly: true,
+};
+
+// I-2 truncation cap: GHL's /calendars/events has no pagination cursor.
+// If a calendar returns >= CAP events it is likely truncated (silently under-reports).
+// Full fix = date-window splitting; tracked as follow-up. Cheap mitigation: warn + degrade.
+const EVENTS_CAP = 100;
+
+export async function collect(args, ctx) {
+  const DAYS = args.days ?? 30;
+  const TOP = args.top ?? 15;
+  const LOC = ctx.cfg.loc;
+  const NOW = ctx.now;
+  const START = NOW - DAYS * 24 * 60 * 60 * 1000;
+
+  const cr = await ctx.http.get('/calendars/', { query: { locationId: LOC }, version: '2021-04-15' });
+  if (!cr.ok) {
+    ctx.out.warn(`can't see calendars → HTTP ${cr.code}`, { degraded: true });
+    return { location: LOC, calendars: 0, noshows: 0, shown: 0, list: [] };
+  }
+  const cals = cr.j.calendars || [];
+  const noshows = [];
+  let skippedCalendars = 0;
+  // Parallel fan-out, capped at 5 concurrent (GHL rate-limit-safe: 100 req/10s; 5 concurrent is well under).
+  // ONLY the independent per-calendar fetches are parallelized — pagination pages stay sequential.
+  const evResults = await mapLimit(cals, 5, async (cal) => {
+    const ev = await ctx.http.get('/calendars/events', {
+      query: { locationId: LOC, calendarId: cal.id, startTime: String(START), endTime: String(NOW) },
+      version: '2021-04-15',
+    });
+    return { cal, ev };
+  });
+  for (const { cal, ev } of evResults) {
+    if (!ev.ok) {
+      skippedCalendars++;
+      ctx.out.warn(`calendar "${cal.name || cal.id}" events unreadable (HTTP ${ev.code})`, { degraded: true });
+      continue;
+    }
+    const evList = ev.j.events || ev.j.appointments || [];
+    // I-2: truncation mitigation — no cursor available; warn if at cap
+    if (evList.length >= EVENTS_CAP) {
+      ctx.out.warn(`calendar "${cal.name || cal.id}" returned ${evList.length} events — may be truncated (no pagination cursor available); counts for this calendar may under-report`, { degraded: true });
+    }
+    for (const e of evList) {
+      const s = (e.appointmentStatus || e.status || '').toLowerCase();
+      if (s !== 'noshow' && s !== 'no-show' && s !== 'no_show') continue;
+      const t = Date.parse(e.startTime || e.startTimeISO || e.appointmentStartTime) || 0;
+      noshows.push({
+        name: e.title || e.contactName || '(unknown)',
+        contactId: e.contactId,
+        apptId: e.id,
+        when: t,
+        cal: cal.name,
+        calId: cal.id,
+      });
+    }
+  }
+  noshows.sort((a, b) => b.when - a.when);
+  const top = noshows.slice(0, TOP);
+
+  return {
+    location: LOC,
+    calendars: cals.length,
+    ...(skippedCalendars > 0 && { skippedCalendars }),
+    noshows: noshows.length,
+    shown: top.length,
+    list: top.map(n => ({
+      name: n.name,
+      contactId: n.contactId,
+      apptId: n.apptId,
+      when: new Date(n.when).toISOString(),
+      calendar: n.cal,
+    })),
+  };
+}
+
+export async function run(args, ctx) {
+  const data = await collect(args, ctx);
+  ctx.out.data(data);
+
+  const DAYS = args.days ?? 30;
+  const NOW = ctx.now;
+  const ago = (t) => {
+    const d = Math.floor((NOW - t) / 86400000);
+    return d >= 1 ? d + 'd' : Math.max(1, Math.floor((NOW - t) / 3600000)) + 'h';
+  };
+  const fmt = (t) =>
+    new Date(t).toLocaleString('en-US', { timeZone: 'Asia/Manila', month: 'short', day: 'numeric', hour: 'numeric', minute: '2-digit' });
+
+  ctx.out.card(() => {
+    ctx.out.line(`\n  NO-SHOW RECOVERY — ${data.noshows} no-show(s) · last ${DAYS}d · ${data.calendars} calendars · loc ${data.location}`);
+    ctx.out.line('  ' + '─'.repeat(70));
+    if (!data.list.length) {
+      ctx.out.line('  No no-shows in window. ✅\n');
+      return;
+    }
+    data.list.forEach((n, i) => {
+      const ts = new Date(n.when).getTime();
+      ctx.out.line(`  ${String(i + 1).padStart(2)}. ${(n.name || '(unknown)').slice(0, 24).padEnd(24)} ${fmt(ts).padEnd(20)} (${ago(ts)} ago)`);
+      ctx.out.line(`      ${n.calendar} · contact ${n.contactId || '—'} · appt ${n.apptId}`);
+    });
+    ctx.out.line('  ' + '─'.repeat(70));
+    ctx.out.line('  → hand to ghl-conversations: draft a warm re-book message per contact; you approve each send (L2).\n');
+  });
+  return 0;
+}

package/commands/pipeline.mjs

@@ -0,0 +1,147 @@
+// commands/pipeline.mjs — Pipeline health: value by stage + stuck sweep.
+// Trust-fix #1: LOC from ctx.cfg.loc.
+// Trust-fix #2: opps paginate to completion.
+// READ-ONLY.
+import { paginate } from '../lib/paginate.mjs';
+
+export const meta = {
+  name: 'pipeline',
+  summary: 'Pipeline health — value by stage + stuck deal sweep',
+  flags: [
+    { name: '--stuck-days', type: 'int', default: 7, desc: 'idle threshold in days' },
+    { name: '--top', type: 'int', default: 100, desc: 'max stuck deals to show' },
+  ],
+  readOnly: true,
+};
+
+// NOTE: GHL opportunity monetaryValue carries no currency field — it inherits pipeline config.
+// Hardcoding ₱ here is a known GHL API limitation; no currency param available per-opportunity.
+const money = (n) => !Number.isFinite(Number(n)) ? '—' : '₱' + Number(n || 0).toLocaleString('en-PH', { maximumFractionDigits: 0 });
+const touchedAt = (o) =>
+  Date.parse(o.lastStatusChangeAt || o.lastStageChangeAt || o.updatedAt || o.dateUpdated || o.dateAdded || 0) || 0;
+
+export async function collect(args, ctx) {
+  const STUCK_DAYS = args['stuck-days'] ?? 7;
+  const TOP = args.top ?? 100;
+  const LOC = ctx.cfg.loc;
+  const NOW = ctx.now;
+  const STUCK_MS = STUCK_DAYS * 24 * 60 * 60 * 1000;
+  const ago = (t) => {
+    const d = Math.floor((NOW - t) / 86400000);
+    return d >= 1 ? d + 'd' : Math.max(1, Math.floor((NOW - t) / 3600000)) + 'h';
+  };
+
+  // pipelines → stage id→name map
+  const p = await ctx.http.get('/opportunities/pipelines', { query: { locationId: LOC } });
+  if (!p.ok) {
+    ctx.out.warn(`can't see pipelines → HTTP ${p.code}`, { degraded: true });
+    return { location: LOC, totalValue: 0, openCount: 0, pipelines: [], stuck: [] };
+  }
+  const pipelines = p.j.pipelines || [];
+  const stageName = {}, pipeName = {}, stageOrder = {};
+  for (const pl of pipelines) {
+    pipeName[pl.id] = pl.name;
+    (pl.stages || []).forEach((s, i) => { stageName[s.id] = s.name; stageOrder[s.id] = i; });
+  }
+
+  // all open opps paginated to completion (trust-fix #2)
+  const opps = [];
+  let firstOppErr = null;
+  for await (const o of paginate({
+    fetchPage: async (page = 1) => {
+      const r = await ctx.http.get('/opportunities/search', {
+        query: { location_id: LOC, status: 'open', limit: 100, page },
+      });
+      if (!r.ok) return { _err: r.code, opportunities: [] };
+      return r.j;
+    },
+    getItems: (resp) => {
+      if (resp._err) { firstOppErr = resp._err; return []; }
+      return resp.opportunities || resp.data || [];
+    },
+    nextCursor: (resp, items, page = 1) => {
+      if (resp._err || items.length < 100) return null;
+      return page + 1;
+    },
+    maxPages: 20,
+    startCursor: 1,
+  })) {
+    opps.push(o);
+  }
+
+  if (firstOppErr && opps.length === 0) {
+    ctx.out.warn(`can't see opportunities → HTTP ${firstOppErr}`, { degraded: true });
+    return { location: LOC, totalValue: 0, openCount: 0, pipelines: [], stuck: [] };
+  }
+
+  // group by pipeline→stage
+  const byPipe = {};
+  let total = 0;
+  for (const o of opps) {
+    const pid = o.pipelineId, sid = o.pipelineStageId || o.stageId;
+    const val = Number(o.monetaryValue || o.monetary_value || 0) || 0;
+    total += val;
+    (byPipe[pid] ??= {})[sid] ??= { count: 0, value: 0 };
+    byPipe[pid][sid].count++;
+    byPipe[pid][sid].value += val;
+  }
+
+  // stuck = open, untouched >= STUCK_DAYS
+  const stuck = opps
+    .map(o => ({ o, t: touchedAt(o) }))
+    .filter(x => x.t > 0 && (NOW - x.t) >= STUCK_MS)
+    .sort((a, b) => a.t - b.t)
+    .slice(0, TOP);
+
+  return {
+    location: LOC,
+    totalValue: total,
+    openCount: opps.length,
+    pipelines: Object.entries(byPipe).map(([pid, stages]) => ({
+      pipeline: pipeName[pid] || pid,
+      stages: Object.entries(stages)
+        .map(([sid, v]) => ({ stage: stageName[sid] || sid, ...v }))
+        .sort((a, b) => (stageOrder[a.sid] || 0) - (stageOrder[b.sid] || 0)),
+    })),
+    stuck: stuck.map(x => ({
+      name: x.o.name,
+      value: x.o.monetaryValue,
+      stage: stageName[x.o.pipelineStageId] || '',
+      idle: ago(x.t),
+      oppId: x.o.id,
+      contactId: x.o.contactId,
+    })),
+  };
+}
+
+export async function run(args, ctx) {
+  const data = await collect(args, ctx);
+  ctx.out.data(data);
+
+  const STUCK_DAYS = args['stuck-days'] ?? 7;
+  const TOP = args.top ?? 100;
+  const money2 = (n) => '₱' + Number(n || 0).toLocaleString('en-PH', { maximumFractionDigits: 0 });
+
+  ctx.out.card(() => {
+    ctx.out.line(`\n  PIPELINE HEALTH  ·  ${money2(data.totalValue)} across ${data.openCount} open deal(s)  ·  loc ${data.location}`);
+    for (const pl of data.pipelines) {
+      ctx.out.line(`\n  ${pl.pipeline}`);
+      for (const s of pl.stages) {
+        ctx.out.line(`    ${(s.stage || '').slice(0, 28).padEnd(28)} ${String(s.count).padStart(3)} deal  ${money2(s.value).padStart(12)}`);
+      }
+    }
+    ctx.out.line(`\n  STUCK — open + untouched ≥ ${STUCK_DAYS}d (oldest first, top ${TOP})`);
+    ctx.out.line('  ' + '─'.repeat(70));
+    if (!data.stuck.length) {
+      ctx.out.line('  Nothing stuck. Pipeline moving. ✅');
+    } else {
+      data.stuck.forEach((x, i) => {
+        ctx.out.line(`  ${String(i + 1).padStart(2)}. ${(x.name || '(no name)').slice(0, 26).padEnd(26)} ${money2(x.value).padStart(11)}  idle ${(x.idle || '?').padEnd(5)} ${x.stage}`);
+        ctx.out.line(`      opp ${x.oppId} · contact ${x.contactId}`);
+      });
+    }
+    ctx.out.line('  ' + '─'.repeat(70));
+    ctx.out.line('  → nudge list = the stuck deals; I can move a stage / set lost-reason on your say-so (L2, one at a time).\n');
+  });
+  return 0;
+}