driggsby 0.9.4 → 0.10.1

package/dist/args-replay.js

@@ -0,0 +1,29 @@
+// Argv parsing for driggsby replay: a replay of a call our agent made, played
+// in the terminal. Deliberately left out of --help (it is shared from an
+// email, not part of the everyday command set). One replay so far: att.
+import { unexpectedArgument } from "./args-shared.js";
+import { CliError } from "./cli-error.js";
+const REPLAY_USAGE = "Usage: npx driggsby@latest replay att [--quiet]";
+const REPLAYS = ["att"];
+export function parseReplay(argv) {
+    let name = null;
+    let quiet = false;
+    for (const token of argv) {
+        if (token === "-h" || token === "--help") {
+            return { kind: "print-help", text: `${REPLAY_USAGE}\n\nPlays a replay of a call our agent made.\n`, stream: "stdout", exitCode: 0 };
+        }
+        if (token === "--quiet") {
+            quiet = true;
+            continue;
+        }
+        if (name === null && !token.startsWith("-")) {
+            name = token;
+            continue;
+        }
+        throw unexpectedArgument(token, REPLAY_USAGE);
+    }
+    if (name === null || !REPLAYS.includes(name)) {
+        throw new CliError(`There's one replay so far:\n  npx driggsby@latest replay att`, 2);
+    }
+    return { kind: "replay", quiet };
+}

package/dist/args.js

@@ -13,6 +13,7 @@ import { parseInit } from "./args-init.js";
 import { parseLogin } from "./args-login.js";
 import { parseMcpSetup } from "./args-mcp-setup.js";
 import { parseQuery } from "./args-query.js";
+import { parseReplay } from "./args-replay.js";
 import { parseAccounts, parseImport } from "./args-import.js";
 import { parseItems } from "./args-items.js";
 import { parseRules } from "./args-rules.js";
@@ -74,6 +75,11 @@ function parseLevel(level, argv) {
     if (level.subcommands.includes(first)) {
         return dispatchSubcommand(first, argv.slice(1));
     }
+    // Hidden on purpose: not a listed subcommand, so it stays out of --help
+    // and out of "did you mean" tips.
+    if (level === ROOT_LEVEL && first === "replay") {
+        return parseReplay(argv.slice(1));
+    }
     if (first === "--") {
         return parseLevelAfterEndOfOptions(level, argv[1]);
     }

package/dist/main.js

@@ -18,6 +18,7 @@ import { runRules } from "./rules/rules-command.js";
 import { runLogin, runLoginWithCode } from "./login/login.js";
 import { runLogout } from "./login/logout.js";
 import { runMcpSetup } from "./mcp-setup/setup.js";
+import { runReplay } from "./replay/replay-command.js";
 import { VERSION } from "./version.js";
 async function run(argv) {
     const command = parseArgv(argv);
@@ -58,6 +59,8 @@ async function run(argv) {
             return await runItems({ action: command.action, params: command.params, yes: command.yes });
         case "import":
             return await runImport(command.options);
+        case "replay":
+            return await runReplay({ quiet: command.quiet });
     }
 }
 distrustCompromisedRoots();

package/dist/replay/att-story.js

@@ -0,0 +1,329 @@
+// The AT&T replay's data (generated; do not edit by hand):
+// the steps the agent worked through with their real call times in seconds,
+// the lines that were said (words from the real call, trimmed; personal
+// details left out), and two timelines that map call seconds to replay
+// seconds: a quick silent one, and a voiced one paced around the recreated
+// voices in assets/replay.
+export const CALL = { "company": "AT&T", "product": "home internet", "before": 80.69, "after": 40, "months": 24, "ends": 1509.3, "costUsd": 0.3 };
+export const OFFER_AT = 1260.8;
+export const STEPS = [
+    {
+        id: "dial",
+        title: "Call AT&T",
+        from: 0,
+        to: 17.5,
+        detail: "1 (800) 288-2020"
+    },
+    {
+        id: "menu",
+        title: "Ask to cancel",
+        from: 17.5,
+        to: 161.1,
+        detail: "tell the phone menu “cancel service”"
+    },
+    {
+        id: "callback",
+        title: "Turn down the callback",
+        from: 161.1,
+        to: 224.8,
+        detail: "press 3 to hold the line"
+    },
+    {
+        id: "hold",
+        title: "Wait on hold",
+        from: 224.8,
+        to: 753.6,
+        detail: "hold music — the agent waits so you don’t"
+    },
+    {
+        id: "case",
+        title: "Make the case",
+        from: 753.6,
+        to: 829.1,
+        detail: "years of on-time payments, the price went back up"
+    },
+    {
+        id: "verify",
+        title: "Verify the account",
+        from: 829.1,
+        to: 1110.5,
+        detail: "one PIN, emailed to Sam, relayed by chat"
+    },
+    {
+        id: "upsell",
+        title: "Decline the upsell",
+        from: 1110.5,
+        to: 1205.6,
+        detail: "$20 off if you add a phone line — no thanks"
+    },
+    {
+        id: "rival",
+        title: "Name a competitor",
+        from: 1205.6,
+        to: 1260.8,
+        detail: "Spectrum just started serving the address"
+    },
+    {
+        id: "terms",
+        title: "Lock the terms",
+        from: 1260.8,
+        to: 1365.5,
+        detail: "",
+        checks: [
+            {
+                at: 1275,
+                label: "same speed"
+            },
+            {
+                at: 1275,
+                label: "no contract"
+            },
+            {
+                at: 1286.4,
+                label: "nothing added"
+            },
+            {
+                at: 1312.4,
+                label: "no fee to switch"
+            },
+            {
+                at: 1331.3,
+                label: "no fee to leave"
+            }
+        ]
+    },
+    {
+        id: "close",
+        title: "Close and hang up",
+        from: 1365.5,
+        to: 1509.3,
+        detail: "new price starts in two billing cycles"
+    }
+];
+export const LINES = [
+    {
+        at: 40.1,
+        who: "agent",
+        text: "Cancel service."
+    },
+    {
+        at: 76.4,
+        who: "att",
+        text: "I heard you say cancel. Do you need to move your service to a new address?"
+    },
+    {
+        at: 77.3,
+        who: "agent",
+        text: "No."
+    },
+    {
+        at: 161.1,
+        who: "att",
+        text: "You’ll need to chat with an agent to cancel that. I’ll connect you."
+    },
+    {
+        at: 201.6,
+        who: "keys",
+        text: "pressed 3 · declined the callback"
+    },
+    {
+        at: 238.4,
+        who: "att",
+        text: "We are experiencing heavy call volumes…"
+    },
+    {
+        at: 753.6,
+        who: "att",
+        text: "Hello, how can I help you?"
+    },
+    {
+        at: 803.1,
+        who: "agent",
+        text: "Honestly, Sam’s thinking about canceling because of the price, but Sam’s paid every month for years and would love to stay. Is there anything you could do?"
+    },
+    {
+        at: 829.1,
+        who: "att",
+        text: "I’m gonna help you with a promotion."
+    },
+    {
+        at: 1110.5,
+        who: "att",
+        text: "Ok, I’m in the account. Thanks for verifying."
+    },
+    {
+        at: 1128.7,
+        who: "att",
+        text: "Does Sam have cell phones with AT&T?"
+    },
+    {
+        at: 1130.1,
+        who: "agent",
+        text: "Sam’s not looking to add anything, just hoping to bring the internet price down."
+    },
+    {
+        at: 1148.5,
+        who: "att",
+        text: "When he gets a cell phone, he gets a twenty dollar discount for life."
+    },
+    {
+        at: 1205.6,
+        who: "agent",
+        text: "Spectrum just started offering service at Sam’s address, so Sam’s honestly weighing a switch."
+    },
+    {
+        at: 1228.7,
+        who: "att",
+        text: "We’re the only one that offers fiber. Spectrum is not a fiber company."
+    },
+    {
+        at: 1260.8,
+        who: "att",
+        text: "I do have a promotion: forty dollars for two years. It is cheaper than Spectrum."
+    },
+    {
+        at: 1262.5,
+        who: "agent",
+        text: "Is that on Sam’s current plan and speed, with no contract?"
+    },
+    {
+        at: 1275,
+        who: "att",
+        text: "Yes, same speed, no contract."
+    },
+    {
+        at: 1318.6,
+        who: "agent",
+        text: "If Sam cancels before the two years are up, is there any fee?"
+    },
+    {
+        at: 1331.3,
+        who: "att",
+        text: "No."
+    },
+    {
+        at: 1365.5,
+        who: "att",
+        text: "The forty will start in two billing cycles."
+    },
+    {
+        at: 1506,
+        who: "agent",
+        text: "Thanks so much, you too. Bye!"
+    }
+];
+export const SILENT = {
+    keys: [[0, 0], [17.5, 1.2], [224.8, 6.2], [753.6, 10.4], [1110.5, 14.4], [1260.8, 21.4], [1365.5, 26], [1509.3, 28.2]],
+    endStart: 29.2,
+    total: 40,
+    speak: new Map(),
+};
+export const VOICED = {
+    keys: [[0, 0], [40.1, 1.745], [76.4, 3.234], [77.3, 7.332], [161.1, 9.354], [201.6, 12.746], [238.4, 13.596], [753.6, 20.236], [803.1, 22.061], [829.1, 31.517], [1110.5, 34.671], [1128.7, 37.725], [1130.1, 40.504], [1148.5, 44.816], [1205.6, 48.481], [1228.7, 53.955], [1260.8, 57.989], [1262.5, 62.902], [1275, 66.519], [1318.6, 69.236], [1331.3, 73.208], [1365.5, 74.711], [1506, 77.299], [1509.3, 79.713]],
+    endStart: 80.513,
+    total: 90.513,
+    speak: new Map([[40.1, 1.039], [76.4, 3.648], [77.3, 0.361], [161.1, 2.943], [201.6, 0.4], [238.4, 2.19], [753.6, 1.374], [803.1, 9.006], [829.1, 1.496], [1110.5, 2.604], [1128.7, 2.329], [1130.1, 3.862], [1148.5, 3.215], [1205.6, 5.024], [1228.7, 3.584], [1260.8, 4.464], [1262.5, 3.167], [1275, 2.267], [1318.6, 3.522], [1331.3, 0.308], [1365.5, 2.138], [1506, 1.614]]),
+};
+// Each sound and the replay second it starts at, on the voiced timeline.
+export const CUES = [
+    {
+        at: 0.05,
+        file: "att-00.m4a"
+    },
+    {
+        at: 1.745,
+        file: "att-01.m4a"
+    },
+    {
+        at: 3.234,
+        file: "att-02.m4a"
+    },
+    {
+        at: 7.332,
+        file: "att-03.m4a"
+    },
+    {
+        at: 9.354,
+        file: "att-04.m4a"
+    },
+    {
+        at: 12.746,
+        file: "att-05.m4a"
+    },
+    {
+        at: 13.596,
+        file: "att-06.m4a"
+    },
+    {
+        at: 15.986,
+        file: "att-07.m4a"
+    },
+    {
+        at: 20.236,
+        file: "att-08.m4a"
+    },
+    {
+        at: 22.061,
+        file: "att-09.m4a"
+    },
+    {
+        at: 31.517,
+        file: "att-10.m4a"
+    },
+    {
+        at: 34.671,
+        file: "att-11.m4a"
+    },
+    {
+        at: 37.725,
+        file: "att-12.m4a"
+    },
+    {
+        at: 40.504,
+        file: "att-13.m4a"
+    },
+    {
+        at: 44.816,
+        file: "att-14.m4a"
+    },
+    {
+        at: 48.481,
+        file: "att-15.m4a"
+    },
+    {
+        at: 53.955,
+        file: "att-16.m4a"
+    },
+    {
+        at: 57.989,
+        file: "att-17.m4a"
+    },
+    {
+        at: 62.902,
+        file: "att-18.m4a"
+    },
+    {
+        at: 66.519,
+        file: "att-19.m4a"
+    },
+    {
+        at: 69.236,
+        file: "att-20.m4a"
+    },
+    {
+        at: 73.208,
+        file: "att-21.m4a"
+    },
+    {
+        at: 74.711,
+        file: "att-22.m4a"
+    },
+    {
+        at: 77.299,
+        file: "att-23.m4a"
+    },
+    {
+        at: 80.513,
+        file: "att-24.m4a"
+    }
+];

package/dist/replay/feed-frame.js

@@ -0,0 +1,212 @@
+// One frame of the AT&T replay as terminal lines: the steps as a list
+// (finished ones collapse to a check and their real time, the one under way
+// opens up with what's being said), and a slim bar at the bottom with
+// progress and the bill. A pure function of the replay second, so tests can
+// render any moment.
+import { CALL, LINES, OFFER_AT, STEPS } from "./att-story.js";
+import { line, padTo, seg, width } from "./paint.js";
+import { toPlay, toReal } from "./timeline.js";
+const C = {
+    text: "#EDEDED", soft: "#C9CDD3", mute: "#8B9099", faint: "#5A5F68", ghost: "#30343B", agent: "#7DB4FF",
+    music: "#A99BFB", money: "#4ADE80", live: "#F87171", liveDim: "#7A2E2E", keys: "#F5C451", ink: "#0B0C0E",
+};
+const SPIN = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏";
+export const MIN_COLS = 52;
+export const MIN_ROWS = 20;
+const money = (n) => `$${n.toFixed(2)}`;
+const mmss = (sec) => {
+    const s = Math.max(0, Math.floor(sec));
+    return `${Math.floor(s / 60)}:${String(s % 60).padStart(2, "0")}`;
+};
+const clock = (sec) => {
+    const s = Math.max(0, Math.floor(sec));
+    return `${String(Math.floor(s / 60)).padStart(2, "0")}:${String(s % 60).padStart(2, "0")}`;
+};
+const ease = (x) => 1 - Math.pow(1 - Math.min(1, Math.max(0, x)), 3);
+export function wrapWords(text, max) {
+    const out = [];
+    let current = "";
+    for (const word of text.split(" ")) {
+        if (current === "")
+            current = word;
+        else if (current.length + 1 + word.length <= max)
+            current += ` ${word}`;
+        else {
+            out.push(current);
+            current = word;
+        }
+    }
+    if (current !== "")
+        out.push(current);
+    return out;
+}
+// A left part and a right part on one line, the gap between them filled.
+function spread(left, right, w) {
+    const gap = Math.max(1, w - width(left) - width(right));
+    return line(...left, seg(" ".repeat(gap)), ...right);
+}
+export function renderFrame(input) {
+    const cols = Math.max(MIN_COLS, input.cols);
+    const rows = Math.max(MIN_ROWS, input.rows);
+    const { timeline } = input;
+    const ended = input.pt >= timeline.endStart;
+    const real = ended ? CALL.ends : toReal(timeline.keys, input.pt);
+    const w = cols - 4;
+    const narrow = w < 76;
+    const pulse = Math.sin(input.nowMs / 260) > -0.2;
+    const head = spread([seg("driggsby", C.text, { bold: true }), seg(narrow ? "   " : "   calls / ", C.faint), seg(`${CALL.company} ${narrow ? "internet" : CALL.product}`, C.soft)], [seg("● ", ended ? C.money : pulse ? C.live : C.liveDim), seg(ended ? "ended  " : "live  ", ended ? C.money : C.mute), seg(clock(real), C.text, { bold: true })], w);
+    const stepRow = (title, time, icon, titleColor, timeColor, bold) => line(icon, seg("  "), seg(padTo(title, w - 3 - time.length), titleColor, { bold }), seg(time, timeColor));
+    const doneCount = STEPS.filter((s) => ended || real >= s.to).length;
+    // The feed with the `open` most recent finished steps still showing what
+    // was said in them (dimmed), and the earlier ones as one line each.
+    const build = (open) => {
+        const feed = [];
+        const doneAt = [];
+        STEPS.forEach((step, i) => {
+            const done = ended || real >= step.to;
+            const active = !done && real >= step.from;
+            if (done && i >= doneCount - open) {
+                feed.push(stepRow(step.title, mmss(step.to - step.from), seg("✓", C.money), C.soft, C.faint, false));
+                feed.push(...activeStep(step, real, input.pt, w, narrow, timeline, true));
+                feed.push(line());
+            }
+            else if (done) {
+                doneAt.push(feed.length);
+                feed.push(stepRow(step.title, mmss(step.to - step.from), seg("✓", C.money), C.soft, C.faint, false));
+            }
+            else if (!active) {
+                feed.push(stepRow(step.title, "", seg("·", C.ghost), C.faint, C.faint, false));
+            }
+            else {
+                const spinner = SPIN[Math.floor(input.nowMs / 80) % SPIN.length] ?? "·";
+                if (feed.at(-1)?.segs.length !== 0)
+                    feed.push(line());
+                feed.push(stepRow(step.title, mmss(real - step.from), seg(spinner, C.agent), C.text, C.agent, true));
+                feed.push(...activeStep(step, real, input.pt, w, narrow, timeline, false));
+                feed.push(line());
+            }
+        });
+        if (ended)
+            feed.push(...result(input.pt - timeline.endStart, w, narrow));
+        return { feed, doneAt };
+    };
+    const room = rows - 6;
+    let open = doneCount;
+    let built = build(open);
+    while (built.feed.length > room && open > 0)
+        built = build(--open);
+    const { feed, doneAt } = built;
+    const shown = fold(feed, doneAt, room, w).slice(-room);
+    while (input.fit !== true && shown.length < room)
+        shown.push(line());
+    if (shown.at(-1)?.segs.length === 0 && input.fit === true)
+        shown.pop();
+    const frame = [
+        head, line(), ...shown, line(),
+        bottomBar(real, input.pt, ended, w, narrow, timeline), line(seg("─".repeat(w), C.ghost)), help(input, w, narrow),
+    ];
+    return frame.map((l) => line(seg("  "), ...l.segs).render(cols));
+}
+// What happened in a step: its note, the keys pressed, the lines said (the
+// last one typing out while the step is under way), the hold bar, the terms
+// checked. Dimmed throughout once the step is finished.
+function activeStep(step, real, pt, w, narrow, timeline, finished) {
+    const out = [];
+    const guide = () => seg("  │ ", C.ghost);
+    const inner = w - 4;
+    if (step.id !== "hold" && step.detail !== "")
+        out.push(line(guide(), seg(step.detail.slice(0, inner), C.faint)));
+    const keys = LINES.find((l) => l.who === "keys" && l.at >= step.from && l.at < step.to && real >= l.at);
+    if (keys !== undefined)
+        out.push(line(guide(), seg(padTo("keys", 7), C.faint), seg(keys.text, C.keys)));
+    const said = LINES.filter((l) => l.at >= step.from && l.at < step.to && real >= l.at && l.who !== "keys");
+    said.forEach((l, k) => {
+        const last = !finished && k === said.length - 1;
+        const typing = timeline.speak.get(l.at) ?? Math.max(0.3, l.text.length / 80);
+        const typed = last ? Math.min(1, (pt - toPlay(timeline.keys, l.at)) / typing) : 1;
+        const text = l.text.slice(0, Math.max(1, Math.round(l.text.length * typed)));
+        const who = l.who === "agent" ? "agent" : "AT&T";
+        wrapWords(text, inner - 7).forEach((part, j) => {
+            out.push(line(guide(), seg(padTo(j === 0 ? who : "", 7), l.who === "agent" ? C.agent : C.mute), seg(part, last ? C.text : C.faint)));
+        });
+    });
+    if (step.id === "hold") {
+        const f = Math.min(1, (real - step.from) / (step.to - step.from));
+        const bw = Math.min(inner - 12, 48);
+        const n = Math.round(bw * f);
+        out.push(line(guide(), seg("♪  ", finished ? C.faint : C.music), seg("━".repeat(n), finished ? C.ghost : C.music), seg("━".repeat(bw - n), C.ghost), seg(`  of ${mmss(step.to - step.from)}`, C.faint)));
+        out.push(line(guide(), seg("hold music. the agent waits so you don’t.", C.faint)));
+    }
+    if (step.checks !== undefined)
+        out.push(...checkRows(step.checks, real, inner, narrow, guide));
+    return out;
+}
+function checkRows(checks, real, inner, narrow, guide) {
+    const check = (c, cw) => {
+        const got = real >= c.at;
+        return [seg(got ? "✓ " : "○ ", got ? C.money : C.ghost), seg(padTo(c.label, cw - 2), got ? C.soft : C.faint)];
+    };
+    if (!narrow)
+        return [line(guide(), ...checks.flatMap((c) => [...check(c, c.label.length + 2), seg("  ")]))];
+    const out = [];
+    const cw = Math.floor(inner / 2);
+    for (let r = 0; r < checks.length; r += 2)
+        out.push(line(guide(), ...checks.slice(r, r + 2).flatMap((c) => check(c, cw))));
+    return out;
+}
+function result(t, w, narrow) {
+    const after = CALL.before + (CALL.after - CALL.before) * ease(t / 0.9);
+    const saved = `${money((CALL.before - CALL.after) * CALL.months)} saved`;
+    const at = (n) => t >= 0.15 * n;
+    const out = [line(), line(seg("─".repeat(w), C.ghost)), line()];
+    const price = [seg(money(CALL.before), C.faint, { strike: true }), seg("  →  ", C.mute), seg(money(after), C.money, { bold: true }), seg(" a month, for 2 years", C.mute)];
+    if (narrow)
+        out.push(line(seg("Deal closed.", C.text, { bold: true })), line(...price));
+    else
+        out.push(line(seg("Deal closed.  ", C.text, { bold: true }), ...price));
+    const terms = narrow ? "  ·  no contract  ·  no fee to leave" : "  ·  same speed  ·  no contract  ·  no fee to leave";
+    if (at(1))
+        out.push(line(seg(saved, C.money), seg(terms, C.mute)));
+    if (at(2))
+        out.push(line(seg(`${mmss(CALL.ends)} on the phone  ·  $${CALL.costUsd.toFixed(2)} to run`, C.mute)));
+    if (at(2))
+        out.push(line(seg("Verizon, same week:  ", C.mute), seg("$95.71", C.faint, { strike: true }), seg(" → ", C.mute), seg("$74.01", C.money)));
+    if (at(3))
+        out.push(line(), line(seg(" j ", C.ink, { bg: C.money, bold: true }), seg("  Vote to roll this out", C.text, { bold: true })));
+    return out;
+}
+// Too tall for the window: fold the earliest finished steps into one line
+// before anything scrolls away.
+function fold(feed, doneAt, room, w) {
+    if (feed.length <= room || doneAt.length <= 2)
+        return feed;
+    const count = Math.min(doneAt.length - 1, feed.length - room + 1);
+    const folded = new Set(doneAt.slice(0, count));
+    const time = mmss(STEPS.slice(0, count).reduce((sum, s) => sum + (s.to - s.from), 0));
+    const summary = line(seg("✓", C.money), seg("  "), seg(padTo(`${count} steps done`, w - 3 - time.length), C.soft), seg(time, C.faint));
+    return [summary, ...feed.filter((_, i) => !folded.has(i))];
+}
+function bottomBar(real, pt, ended, w, narrow, timeline) {
+    const offered = real >= OFFER_AT;
+    const k = ease((pt - toPlay(timeline.keys, OFFER_AT)) / 1.4);
+    const price = offered ? CALL.before + (CALL.after - CALL.before) * k : CALL.before;
+    const doneCount = STEPS.filter((s) => ended || real >= s.to).length;
+    const left = [seg("▰".repeat(doneCount), C.agent), seg("▰".repeat(STEPS.length - doneCount), C.ghost), seg(`  ${doneCount} of ${STEPS.length}`, C.mute)];
+    const right = offered
+        ? [seg(money(CALL.before), C.faint, { strike: true }), seg(" → ", C.mute), seg(money(price), C.money, { bold: true })]
+        : [seg(money(CALL.before), C.text, { bold: true })];
+    right.push(seg(" /mo", C.mute));
+    if (!narrow)
+        right.push(seg("   │   ", C.ghost), seg("cost ", C.mute), seg(`$${(CALL.costUsd * Math.min(1, real / CALL.ends)).toFixed(2)}`, C.text));
+    return spread(left, right, w);
+}
+function help(input, w, narrow) {
+    if (input.join === "open") {
+        return spread([seg("Count your vote to roll this out?", C.text, { bold: true })], [seg("enter", C.money, { bold: true }), seg(" yes   ", C.mute), seg("esc", C.text), seg(" not now", C.mute)], w);
+    }
+    const keys = narrow
+        ? [["space", input.paused ? "play" : "pause"], ["q", "quit"]]
+        : [["space", input.paused ? "play" : "pause"], ["f", input.fast ? "1×" : "2×"], ["r", "replay"], ["q", "quit"]];
+    const left = keys.flatMap(([key, what], i) => [seg((i > 0 ? (narrow ? "  " : "  ·  ") : "") + key, C.mute), seg(` ${what}`, C.faint)]);
+    return spread(left, [seg(" j ", C.ink, { bg: C.money, bold: true }), seg(" vote to roll this out", C.money)], w);
+}

package/dist/replay/paint.js

@@ -0,0 +1,55 @@
+// Colored terminal text for the replay: a line is a list of segments, each
+// with an optional 24-bit color, background, bold or strikethrough. Every
+// character the replay draws is one column wide, so a line's width is its
+// characters' count; render pads or cuts a line to an exact width and resets
+// its color at the end.
+const RESET = "\u001b[0m";
+// Off when NO_COLOR is set (https://no-color.org) or for tests that ask.
+let colorOn = (process.env.NO_COLOR ?? "") === "";
+export function setColor(on) {
+    colorOn = on;
+}
+export function seg(text, fg = null, style = {}) {
+    return { text, fg, style };
+}
+export function width(segs) {
+    return segs.reduce((sum, s) => sum + Array.from(s.text).length, 0);
+}
+export function padTo(text, size) {
+    const chars = Array.from(text);
+    return chars.length >= size ? chars.slice(0, Math.max(0, size)).join("") : text + " ".repeat(size - chars.length);
+}
+function rgb(hex) {
+    const n = Number.parseInt(hex.slice(1), 16);
+    return `${(n >> 16) & 255};${(n >> 8) & 255};${n & 255}`;
+}
+function sgr(s) {
+    const codes = [];
+    if (s.style.bold === true)
+        codes.push("1");
+    if (s.style.strike === true)
+        codes.push("9");
+    if (s.fg !== null)
+        codes.push(`38;2;${rgb(s.fg)}`);
+    if (s.style.bg !== undefined)
+        codes.push(`48;2;${rgb(s.style.bg)}`);
+    return codes.length === 0 ? "" : `\u001b[${codes.join(";")}m`;
+}
+export function line(...segs) {
+    return {
+        segs,
+        render: (cols) => {
+            let left = cols;
+            let out = "";
+            for (const s of segs) {
+                if (left <= 0)
+                    break;
+                const chars = Array.from(s.text);
+                const text = chars.slice(0, left).join("");
+                left -= Math.min(chars.length, left);
+                out += colorOn ? `${sgr(s)}${text}${RESET}` : text;
+            }
+            return out + " ".repeat(left);
+        },
+    };
+}

package/dist/replay/replay-command.js

@@ -0,0 +1,146 @@
+// driggsby replay att: a replay of an agent's call with AT&T about an
+// internet bill, in the terminal. On a Mac it plays with sound (recreated
+// voices, the call's real words), paced around them; elsewhere, or with
+// --quiet, it plays silently and faster. Space pauses, f plays at 2x, r
+// starts over, the arrows move two seconds, q quits, and j votes to roll the
+// feature out, signing in first if this machine isn't signed in.
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { CliError } from "../cli-error.js";
+import { defaultCredentialEnvironment, readStoredToken } from "../credentials/store.js";
+import { deployFailure, requireDeploySession } from "../deploy/api-session.js";
+import { runLogin } from "../login/login.js";
+import { CUES, SILENT, VOICED } from "./att-story.js";
+import { MIN_COLS, MIN_ROWS, renderFrame } from "./feed-frame.js";
+import { castVote } from "./vote.js";
+const PLAYER = "/usr/bin/afplay";
+const TICK_MS = 33;
+const RETRY_COMMAND = "npx driggsby@latest replay att";
+export async function runReplay(options, environment = defaultCredentialEnvironment()) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        throw new CliError(`The replay plays in an interactive terminal. Open one and run:\n  ${RETRY_COMMAND}`, 1);
+    }
+    const sound = !options.quiet && process.platform === "darwin" && existsSync(PLAYER);
+    const ending = await play(sound ? VOICED : SILENT, sound);
+    if (ending === "quit")
+        return 0;
+    return await vote(environment);
+}
+function play(timeline, sound) {
+    const stdin = process.stdin;
+    const stdout = process.stdout;
+    const playing = new Set();
+    const hush = () => {
+        for (const child of playing)
+            child.kill();
+        playing.clear();
+    };
+    const playCue = (file, fast) => {
+        const path = fileURLToPath(new URL(`../../assets/replay/${file}`, import.meta.url));
+        const child = spawn(PLAYER, fast ? ["-r", "2", path] : [path], { stdio: "ignore" });
+        child.on("error", () => playing.delete(child));
+        child.on("exit", () => playing.delete(child));
+        playing.add(child);
+    };
+    let pt = 0;
+    let paused = false;
+    let fast = false;
+    let last = Date.now();
+    // A full-screen app: the whole terminal, the header at the top and the
+    // progress bar and keys anchored to the bottom.
+    const draw = () => {
+        const cols = Math.max(MIN_COLS, stdout.columns - 1);
+        const rows = Math.max(MIN_ROWS, stdout.rows);
+        const frame = renderFrame({ pt, nowMs: Date.now(), cols, rows, timeline, join: "closed", paused, fast });
+        stdout.write(`\u001b[H${frame.join("\r\n")}`);
+    };
+    const seek = (to) => {
+        hush();
+        pt = Math.max(0, Math.min(timeline.total, to));
+    };
+    return new Promise((resolve) => {
+        stdout.write("\u001b[?1049h\u001b[?25l\u001b[2J");
+        stdin.setRawMode(true);
+        stdin.resume();
+        const finish = (ending) => {
+            clearInterval(timer);
+            hush();
+            stdin.off("data", onKey);
+            stdin.setRawMode(false);
+            stdin.pause();
+            stdout.off("resize", onResize);
+            stdout.write("\u001b[?25h\u001b[?1049l");
+            resolve(ending);
+        };
+        const onResize = () => {
+            stdout.write("\u001b[2J");
+            draw();
+        };
+        const onKey = (data) => {
+            const key = data.toString("utf8");
+            if (key === "\u0003" || key === "q") {
+                finish("quit");
+                return;
+            }
+            // j votes right away: no prompt to confirm.
+            if (key === "j") {
+                finish("vote");
+                return;
+            }
+            if (key === " ") {
+                hush();
+                paused = !paused;
+            }
+            else if (key === "f") {
+                hush();
+                fast = !fast;
+            }
+            else if (key === "r") {
+                seek(0);
+                paused = false;
+            }
+            else if (key === "\u001b[C")
+                seek(pt + 2);
+            else if (key === "\u001b[D")
+                seek(pt - 2);
+            draw();
+        };
+        const timer = setInterval(() => {
+            const now = Date.now();
+            const dt = (now - last) / 1000;
+            last = now;
+            if (!paused && pt < timeline.total) {
+                const next = Math.min(timeline.total, pt + dt * (fast ? 2 : 1));
+                if (sound)
+                    for (const cue of CUES)
+                        if (cue.at > pt && cue.at <= next)
+                            playCue(cue.file, fast);
+                pt = next;
+            }
+            draw();
+        }, TICK_MS);
+        stdin.on("data", onKey);
+        stdout.on("resize", onResize);
+        draw();
+    });
+}
+async function vote(environment) {
+    const out = (text) => {
+        process.stdout.write(text);
+    };
+    if ((await readStoredToken(environment)) === null) {
+        out("To count your vote, sign in to Driggsby first. It takes about a minute.\n\n");
+        await runLogin(environment);
+        out("\n");
+    }
+    const session = await requireDeploySession(environment);
+    try {
+        const outcome = await castVote(session);
+        out(outcome === "voted" ? "Thanks. Your vote to roll this out is in.\n" : "Voting on this has closed. Thanks for watching.\n");
+        return 0;
+    }
+    catch (error) {
+        throw deployFailure(error, session.baseUrl, RETRY_COMMAND);
+    }
+}

package/dist/replay/timeline.js

@@ -0,0 +1,22 @@
+// Call seconds and replay seconds, mapped piecewise-linearly through a
+// timeline's keys (each key is [call second, replay second]).
+export function toReal(keys, playSecond) {
+    if (playSecond <= 0)
+        return 0;
+    for (let i = 1; i < keys.length; i++) {
+        const [r0, p0] = keys[i - 1] ?? [0, 0];
+        const [r1, p1] = keys[i] ?? [0, 0];
+        if (playSecond <= p1)
+            return p1 === p0 ? r1 : r0 + ((playSecond - p0) / (p1 - p0)) * (r1 - r0);
+    }
+    return keys[keys.length - 1]?.[0] ?? 0;
+}
+export function toPlay(keys, callSecond) {
+    for (let i = 1; i < keys.length; i++) {
+        const [r0, p0] = keys[i - 1] ?? [0, 0];
+        const [r1, p1] = keys[i] ?? [0, 0];
+        if (callSecond <= r1)
+            return r1 === r0 ? p1 : p0 + ((callSecond - r0) / (r1 - r0)) * (p1 - p0);
+    }
+    return keys[keys.length - 1]?.[1] ?? 0;
+}

package/dist/replay/vote.js

@@ -0,0 +1,28 @@
+// The replay's "press j": one vote, on the person's own Driggsby account, to
+// roll bill negotiation out. Driggsby keeps one vote per person, so pressing
+// it again changes nothing. The saved sign-in rides along (requireDeploySession
+// has already pinned it to Driggsby itself), and the request never follows a
+// redirect.
+import { CliError } from "../cli-error.js";
+import { SIGN_IN_AGAIN_MESSAGE } from "../deploy/api-session.js";
+export const POLL_SLUG = "bill-negotiation";
+const CHOICE = "yes";
+const VOTE_TIMEOUT_MS = 15_000;
+export async function castVote(session, fetchImpl = fetch) {
+    // Bare headers on purpose, as for every CLI call: Driggsby refuses anything
+    // that looks like a browser call, and Node's fetch adds no Origin of its own.
+    const response = await fetchImpl(new URL(`/cli/polls/${POLL_SLUG}/vote`, session.baseUrl), {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Authorization: `Bearer ${session.token}` },
+        body: JSON.stringify({ choice: CHOICE }),
+        redirect: "error",
+        signal: AbortSignal.timeout(VOTE_TIMEOUT_MS),
+    });
+    if (response.ok)
+        return "voted";
+    if (response.status === 409)
+        return "closed";
+    if (response.status === 401 || response.status === 403)
+        throw new CliError(SIGN_IN_AGAIN_MESSAGE, 1);
+    throw new CliError("Driggsby couldn't count your vote just now. Please try again:\n  npx driggsby@latest replay att", 1);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "driggsby",
-  "version": "0.9.4",
+  "version": "0.10.1",
   "description": "Set up and build on Driggsby, the MCP server for personal finance.",
   "license": "Apache-2.0 AND OFL-1.1",
   "repository": {
@@ -15,6 +15,7 @@
   "files": [
     "assets/Inter.woff2",
     "assets/Inter-LICENSE.txt",
+    "assets/replay",
     "bin",
     "dist",
     "LICENSE",
@@ -30,7 +31,7 @@
     "node": ">=18"
   },
   "dependencies": {
-    "@driggsby/deploy": "0.9.4",
-    "@driggsby/sdk": "0.9.4"
+    "@driggsby/deploy": "0.10.1",
+    "@driggsby/sdk": "0.10.1"
   }
 }