@stevecastaneda/paseo-progress 0.3.3 → 0.3.4

package/dist/shared/dashboard.js

@@ -1,386 +0,0 @@
-import { EVENT_VERSION, eventSchema } from "./events.js";
-// Reads the JSONL text. A last line without a newline may be half written by
-// a command that is still running, so it is skipped without an issue.
-export function parseProgress(text) {
-    const events = [];
-    const issues = [];
-    // Whether or not the text ends in a newline, the last split piece is either
-    // empty or unfinished.
-    text.split("\n").slice(0, -1).forEach((raw, index) => {
-        const line = index + 1;
-        if (!raw.trim())
-            return;
-        let json;
-        try {
-            json = JSON.parse(raw);
-        }
-        catch {
-            issues.push({ line, reason: "not valid JSON" });
-            return;
-        }
-        const parsed = eventSchema.safeParse(json);
-        if (parsed.success)
-            events.push({ line, event: parsed.data });
-        else
-            issues.push({ line, reason: describeInvalid(json) });
-    });
-    return { events, issues };
-}
-function describeInvalid(json) {
-    const version = typeof json === "object" && json !== null && "v" in json ? json.v : undefined;
-    if (typeof version === "number" && version !== EVENT_VERSION)
-        return `written by a newer version of the plugin (v${version})`;
-    const type = typeof json === "object" && json !== null && "type" in json ? String(json.type) : null;
-    return type ? `invalid ${type} event` : "not a progress event";
-}
-export const STALE_AFTER_MIN = 15;
-// Every time-dependent rule asks `reached(at)` instead of comparing with `now`
-// itself. Each answer also records the moment it would flip, so `validUntil`
-// is the first millisecond at which the same events can produce a different
-// dashboard, and a new rule can't forget to tell the cache.
-function clock(now) {
-    let validUntil = Infinity;
-    return {
-        reached(at) {
-            if (now.getTime() >= at)
-                return true;
-            validUntil = Math.min(validUntil, at);
-            return false;
-        },
-        get validUntil() {
-            return validUntil;
-        },
-    };
-}
-export function isSettled(ticket) {
-    return ticket.status === "done" || ticket.status === "skipped";
-}
-// The events from the last `run.start` on; earlier runs are ignored.
-export function latestRun(events) {
-    const start = events.findLastIndex(({ event }) => event.type === "run.start");
-    return events.slice(Math.max(start, 0));
-}
-// Folds the events of the latest run into what the panel shows at `now`, how
-// long that stays true while the events don't change, and the ids new items get.
-// Everything before the last `run.start` belongs to earlier runs and is ignored.
-export function reduceProgress(parsed, now) {
-    const time = clock(now);
-    const events = latestRun(parsed.events);
-    const issues = [...parsed.issues];
-    let run = null;
-    const tickets = new Map();
-    const questions = new Map();
-    const deliverables = new Map();
-    const activity = new Map();
-    let ticker = null;
-    const manualStuck = new Map();
-    let updatedAt = null;
-    for (const { line, event } of events) {
-        updatedAt = event.ts;
-        switch (event.type) {
-            case "run.start":
-                run = { title: event.title, subtitle: event.subtitle, itemLabel: event.itemLabel ?? "Ticket", startedAt: event.ts };
-                break;
-            case "run.finish":
-                if (run)
-                    run.finished = { at: event.ts, outcome: event.outcome };
-                ticker = null;
-                break;
-            case "ticket.add":
-                tickets.set(event.id, {
-                    id: event.id,
-                    title: event.title,
-                    estimateMin: event.estimateMin,
-                    status: event.status ?? "not_started",
-                    statusSince: event.ts,
-                    workingSince: event.status === "working" ? event.ts : undefined,
-                    history: [{ at: event.ts, status: event.status ?? "not_started" }],
-                    waitsFor: event.waitsFor,
-                    source: event.source,
-                    agentId: event.by,
-                });
-                break;
-            case "ticket.update": {
-                const ticket = tickets.get(event.id);
-                if (!ticket) {
-                    issues.push({ line, reason: `unknown ticket ${event.id}` });
-                    break;
-                }
-                if (event.title !== undefined)
-                    ticket.title = event.title;
-                if (event.estimateMin !== undefined)
-                    ticket.estimateMin = event.estimateMin;
-                const change = { at: event.ts };
-                if (event.status !== undefined && event.status !== ticket.status)
-                    change.status = event.status;
-                if (event.stage !== undefined && event.stage !== (ticket.stage ?? ""))
-                    change.stage = event.stage;
-                if (event.note)
-                    change.note = event.note;
-                if (Object.keys(change).length > 1)
-                    ticket.history.push(change);
-                if (event.status !== undefined && event.status !== ticket.status) {
-                    ticket.status = event.status;
-                    ticket.statusSince = event.ts;
-                    if (event.status === "working")
-                        ticket.workingSince = event.ts;
-                }
-                if (event.stage !== undefined && event.stage !== (ticket.stage ?? "")) {
-                    ticket.stage = event.stage || undefined;
-                    ticket.stageSince = event.stage ? event.ts : undefined;
-                }
-                if (event.note !== undefined)
-                    ticket.note = event.note || undefined;
-                if (event.waitsFor !== undefined)
-                    ticket.waitsFor = event.waitsFor || undefined;
-                if (event.source !== undefined)
-                    ticket.source = event.source || undefined;
-                if (event.by)
-                    ticket.agentId = event.by;
-                break;
-            }
-            case "ticket.remove":
-                if (!tickets.delete(event.id))
-                    issues.push({ line, reason: `unknown ticket ${event.id}` });
-                break;
-            case "question.ask":
-                questions.set(event.id, {
-                    id: event.id,
-                    title: event.title,
-                    question: event.question,
-                    options: event.options ?? [],
-                    recommended: event.recommend ?? event.default ?? "",
-                    background: event.background,
-                    files: event.files ?? [],
-                    raisedBy: event.raisedBy,
-                    ticketId: event.ticket,
-                    askedAt: event.ts,
-                });
-                break;
-            case "question.answer": {
-                const question = questions.get(event.id);
-                if (!question)
-                    issues.push({ line, reason: `unknown question ${event.id}` });
-                else
-                    question.answer = { choice: event.choice, words: event.words, changedCourse: event.changedCourse, at: event.ts };
-                break;
-            }
-            case "question.update": {
-                const question = questions.get(event.id);
-                if (!question) {
-                    issues.push({ line, reason: `unknown question ${event.id}` });
-                    break;
-                }
-                if (event.question !== undefined)
-                    question.question = event.question;
-                if (event.background !== undefined)
-                    question.background = event.background;
-                if (event.files !== undefined)
-                    question.files = [...question.files, ...event.files];
-                break;
-            }
-            case "question.remove":
-                if (!questions.delete(event.id))
-                    issues.push({ line, reason: `unknown question ${event.id}` });
-                break;
-            case "deliverable.add":
-                deliverables.set(event.id, {
-                    id: event.id,
-                    title: event.title,
-                    path: event.path,
-                    url: event.url,
-                    ticketId: event.ticket,
-                    kind: event.kind,
-                    addedAt: event.ts,
-                });
-                break;
-            case "deliverable.remove":
-                if (!deliverables.delete(event.id))
-                    issues.push({ line, reason: `unknown deliverable ${event.id}` });
-                break;
-            case "activity.add":
-                activity.set(event.id, { id: event.id, text: event.text, ticketId: event.ticket, at: event.ts });
-                break;
-            case "activity.update": {
-                const entry = activity.get(event.id);
-                if (!entry)
-                    issues.push({ line, reason: `unknown activity ${event.id}` });
-                else
-                    Object.assign(entry, { text: event.text, editedAt: event.ts });
-                break;
-            }
-            case "activity.remove":
-                if (!activity.delete(event.id))
-                    issues.push({ line, reason: `unknown activity ${event.id}` });
-                break;
-            case "ticker.set":
-                ticker = { text: event.text, since: event.ts, ...(event.by ? { by: event.by } : {}) };
-                break;
-            case "ticker.clear":
-                ticker = null;
-                break;
-            case "stuck.set":
-                manualStuck.set(event.id, { id: event.id, reason: event.reason, ticket: event.ticket, since: event.ts });
-                break;
-            case "stuck.clear":
-                if (!manualStuck.delete(event.id))
-                    issues.push({ line, reason: `unknown stuck item ${event.id}` });
-                break;
-        }
-    }
-    const list = [...tickets.values()];
-    for (const ticket of list) {
-        const other = ticket.waitsFor ? tickets.get(ticket.waitsFor) : undefined;
-        ticket.waitingFor = other && !isSettled(other) && !isSettled(ticket)
-            ? { id: other.id, title: other.title }
-            : undefined;
-    }
-    const itemLabel = run?.itemLabel ?? "Ticket";
-    const stuck = stuckItems(list, [...activity.values()], [...manualStuck.values()], time.reached);
-    const allQuestions = [...questions.values()];
-    const open = allQuestions.filter((question) => !question.answer);
-    // A finished run has nothing left to stall, so it never goes stale.
-    const finished = Boolean(run?.finished) || (list.length > 0 && list.every(isSettled));
-    const answered = allQuestions
-        .filter((question) => question.answer)
-        .sort((a, b) => Date.parse(b.answer.at) - Date.parse(a.answer.at));
-    const dashboard = {
-        run,
-        updatedAt,
-        stale: !finished && updatedAt !== null && time.reached(Date.parse(updatedAt) + STALE_AFTER_MIN * 60_000),
-        headline: headline(list, itemLabel, open.length, stuck.length),
-        stuck,
-        questions: { open, answered },
-        activity: [...activity.values()].reverse(),
-        ticker,
-        deliverables: [...deliverables.values()].reverse().map((deliverable) => {
-            const ticket = deliverable.ticketId ? tickets.get(deliverable.ticketId) : undefined;
-            return ticket ? { ...deliverable, ticketLabel: shortTitle(ticket.title) } : deliverable;
-        }),
-        progress: progress(list, run?.startedAt),
-        tickets: list,
-        issues: issues.sort((a, b) => a.line - b.line),
-    };
-    return { dashboard, validUntil: time.validUntil, nextIds: nextIds(parsed.events.map(({ event }) => event), events.map(({ event }) => event)) };
-}
-function nextIds(all, inRun) {
-    const used = (events, type) => events.flatMap((event) => (event.type === type && "id" in event ? [event.id] : []));
-    return {
-        ticket: nextId("T", used(inRun, "ticket.add")),
-        question: nextId("Q", used(all, "question.ask"), 1),
-        deliverable: nextId("D", used(inRun, "deliverable.add"), 1),
-        activity: nextId("A", used(inRun, "activity.add"), 1),
-        stuck: nextId("S", used(inRun, "stuck.set"), 1),
-    };
-}
-function progress(tickets, startedAt) {
-    const counted = tickets.filter((ticket) => ticket.status !== "skipped");
-    const totalMin = counted.reduce((sum, ticket) => sum + ticket.estimateMin, 0);
-    const doneMin = counted.filter((ticket) => ticket.status === "done").reduce((sum, ticket) => sum + ticket.estimateMin, 0);
-    // All done: the last ticket to settle, done or skipped, ended the work.
-    const allDone = counted.length > 0 && counted.every((ticket) => ticket.status === "done") && tickets.every(isSettled);
-    const endedAt = Math.max(...tickets.map((ticket) => Date.parse(ticket.statusSince)));
-    return {
-        percent: totalMin ? Math.round((doneMin / totalMin) * 100) : 0,
-        doneMin,
-        totalMin,
-        tookMin: allDone && startedAt ? Math.max(0, (endedAt - Date.parse(startedAt)) / 60_000) : undefined,
-        segments: counted.map(({ id, estimateMin, status, waitingFor }) => ({ id, estimateMin, status, waiting: Boolean(waitingFor) })),
-    };
-}
-function lastTicketUpdate(ticket, activity) {
-    return Math.max(...ticket.history.map((change) => Date.parse(change.at)), ...activity.filter((entry) => entry.ticketId === ticket.id).map((entry) => Date.parse(entry.at)));
-}
-function stuckItems(tickets, activity, manual, reached) {
-    const items = [];
-    for (const ticket of tickets) {
-        // Blocked only on another ticket in the run is waiting, not stuck.
-        if (ticket.status === "blocked" && !ticket.waitingFor) {
-            items.push({ kind: "blocked", key: `blocked:${ticket.id}`, ticketId: ticket.id, title: ticket.title, since: ticket.statusSince, note: ticket.note });
-        }
-        else if (ticket.status === "working") {
-            // Any sign of work resets the clock: a status, stage or note change, or activity tagged to the ticket.
-            const lastUpdate = lastTicketUpdate(ticket, activity);
-            // Overdue once more than the estimate has passed, so a millisecond after it.
-            if (reached(lastUpdate + ticket.estimateMin * 60_000 + 1)) {
-                items.push({
-                    kind: "overdue",
-                    key: `overdue:${ticket.id}`,
-                    ticketId: ticket.id,
-                    title: ticket.title,
-                    since: new Date(lastUpdate).toISOString(),
-                    estimateMin: ticket.estimateMin,
-                });
-            }
-        }
-    }
-    for (const item of manual) {
-        const ticket = item.ticket ? tickets.find((candidate) => candidate.id === item.ticket) : undefined;
-        items.push({
-            kind: "manual",
-            key: `manual:${item.id}`,
-            id: item.id,
-            ticketId: item.ticket,
-            title: ticket?.title ?? item.reason,
-            reason: item.reason,
-            since: item.since,
-        });
-    }
-    return items;
-}
-// "Ticket 03: Frozen links survive deletes" → "Ticket 03".
-export function shortTitle(title) {
-    const index = title.indexOf(":");
-    return index > 0 && index <= 24 ? title.slice(0, index) : title;
-}
-// The finished tickets (done or skipped) the panel folds into one row at the
-// top, in plan order, so the work still ahead sits near the top. A ticket
-// finished out of order folds too. A single one isn't worth a fold row. Once
-// every ticket is finished nothing is ahead, and the whole list is the record
-// of the run, so nothing folds.
-export function finishedToFold(tickets) {
-    const finished = tickets.filter(isFinished);
-    return finished.length >= 2 && finished.length < tickets.length ? finished : [];
-}
-export function isFinished(ticket) {
-    return ticket.status === "done" || ticket.status === "skipped";
-}
-function plural(count, noun) {
-    return `${count} ${count === 1 ? noun : `${noun}s`}`;
-}
-function headline(tickets, itemLabel, waiting, stuck) {
-    const counted = tickets.filter((ticket) => ticket.status !== "skipped");
-    const done = counted.filter((ticket) => ticket.status === "done").length;
-    const parts = [{ text: `${done} of ${plural(counted.length, itemLabel.toLowerCase())} done`, tone: "normal" }];
-    if (waiting)
-        parts.push({ text: `${plural(waiting, "question")} waiting for you`, tone: "normal" });
-    if (stuck)
-        parts.push({ text: `${stuck} stuck`, tone: "danger" });
-    return parts;
-}
-export function headlineText(dashboard) {
-    return dashboard.headline.map((part) => part.text).join(", ");
-}
-function nextId(prefix, used, width = 2) {
-    let max = 0;
-    for (const id of used) {
-        const match = new RegExp(`^${prefix}(\\d+)$`).exec(id);
-        if (match)
-            max = Math.max(max, Number(match[1]));
-    }
-    return `${prefix}${String(max + 1).padStart(width, "0")}`;
-}
-export const EMPTY_DASHBOARD = {
-    run: null,
-    updatedAt: null,
-    stale: false,
-    headline: [],
-    stuck: [],
-    questions: { open: [], answered: [] },
-    deliverables: [],
-    activity: [],
-    ticker: null,
-    progress: { percent: 0, doneMin: 0, totalMin: 0, segments: [] },
-    tickets: [],
-    issues: [],
-};

package/dist/shared/events.js

@@ -1,127 +0,0 @@
-import { z } from "zod";
-// One line of `progress.jsonl`. The command-line tool writes these; the
-// dashboard reducer reads them. `v` lets later versions change a shape without
-// misreading old files. Which folder holds it is set up per repo.
-export const PROGRESS_FILE_NAME = "progress.jsonl";
-// Present once someone has opened the Progress panel for this worktree.
-export const PANEL_OPENED_NAME = "progress-panel-opened";
-// Where 0.1.x kept each worktree's files. store.ts moves them out.
-export const LEGACY_FOLDER = ".scratch";
-export const EVENT_VERSION = 1;
-export const TICKET_STATUSES = ["not_started", "working", "blocked", "done", "skipped"];
-export const ticketStatusSchema = z.enum(TICKET_STATUSES);
-const text = z.string().trim().min(1);
-const minutes = z.number().int().positive().max(100_000);
-// `by` is the Paseo agent that wrote the event, absent when run outside Paseo.
-const base = { v: z.literal(EVENT_VERSION), ts: z.iso.datetime(), by: text.optional() };
-export const questionOptionSchema = z.object({
-    letter: z.string().regex(/^[A-Z]$/),
-    label: text,
-    consequence: text.optional(),
-});
-const httpUrl = z.url().refine((value) => /^https?:\/\//i.test(value), "Use an HTTP or HTTPS URL");
-// Something attached to a question: a local path or a web link.
-export const fileLinkSchema = z
-    .object({ path: text.optional(), url: httpUrl.optional(), label: text.optional() })
-    .refine((file) => Boolean(file.path) !== Boolean(file.url), "Give a path or a URL");
-export const DELIVERABLE_KINDS = ["file", "folder", "report", "screenshot", "link"];
-export const eventSchema = z.discriminatedUnion("type", [
-    z.object({
-        ...base,
-        type: z.literal("run.start"),
-        title: text,
-        subtitle: text.optional(),
-        itemLabel: text.optional(),
-    }),
-    // Closes the run. Nothing more is recorded on it; new work needs `run.start`.
-    z.object({ ...base, type: z.literal("run.finish"), outcome: text }),
-    z.object({
-        ...base,
-        type: z.literal("ticket.add"),
-        id: text,
-        title: text,
-        estimateMin: minutes,
-        status: ticketStatusSchema.optional(),
-        // Another ticket in the run this one can't start until it's done.
-        waitsFor: text.optional(),
-        // Where the ticket is written up: a spec file or an issue link.
-        source: fileLinkSchema.optional(),
-    }),
-    z.object({
-        ...base,
-        type: z.literal("ticket.update"),
-        id: text,
-        title: text.optional(),
-        estimateMin: minutes.optional(),
-        status: ticketStatusSchema.optional(),
-        // The step inside the ticket, like "Build" or "Fixes". Empty clears it.
-        stage: z.string().trim().optional(),
-        note: z.string().trim().optional(),
-        // Empty clears it.
-        waitsFor: z.string().trim().optional(),
-        // Empty clears it.
-        source: z.union([fileLinkSchema, z.literal("")]).optional(),
-    }),
-    z.object({ ...base, type: z.literal("ticket.remove"), id: text }),
-    // A blocker that is not a ticket status, like a failing external service.
-    z.object({ ...base, type: z.literal("stuck.set"), id: text, reason: text, ticket: text.optional() }),
-    z.object({ ...base, type: z.literal("stuck.clear"), id: text }),
-    // The agent asks, recommends an option, and builds none of them before the
-    // answer: it works only on what the question doesn't affect. Older questions
-    // carry `default` (the option the agent carried on with) and `waits` instead.
-    z.object({
-        ...base,
-        type: z.literal("question.ask"),
-        id: text,
-        title: text,
-        question: text,
-        options: z.array(questionOptionSchema).max(26).optional(),
-        // The agent's pick: an option letter, or a word such as "Looks right" when there are no options.
-        recommend: text.optional(),
-        default: text.optional(),
-        waits: z.boolean().optional(),
-        background: text.optional(),
-        files: z.array(fileLinkSchema).optional(),
-        raisedBy: text.optional(),
-        // The ticket this question came up on.
-        ticket: text.optional(),
-    }),
-    z.object({
-        ...base,
-        type: z.literal("question.answer"),
-        id: text,
-        choice: text,
-        // The user's own words, quoted under the answer.
-        words: text.optional(),
-        // Older answers: true when the agent had to undo work built on its default.
-        changedCourse: z.boolean().optional(),
-    }),
-    // Adds detail to an open question; its reference and default stay.
-    z.object({
-        ...base,
-        type: z.literal("question.update"),
-        id: text,
-        question: text.optional(),
-        background: text.optional(),
-        files: z.array(fileLinkSchema).optional(),
-    }),
-    z.object({ ...base, type: z.literal("question.remove"), id: text }),
-    // `path` is relative to the worktree root, or absolute when outside it.
-    z.object({
-        ...base,
-        type: z.literal("deliverable.add"),
-        id: text,
-        title: text,
-        path: text.optional(),
-        url: httpUrl.optional(),
-        ticket: text.optional(),
-        kind: z.enum(DELIVERABLE_KINDS).optional(),
-    }).refine((event) => Boolean(event.path) !== Boolean(event.url), "A deliverable has a path or a URL"),
-    z.object({ ...base, type: z.literal("deliverable.remove"), id: text }),
-    z.object({ ...base, type: z.literal("activity.add"), id: text, text, ticket: text.optional() }),
-    z.object({ ...base, type: z.literal("activity.update"), id: text, text }),
-    z.object({ ...base, type: z.literal("activity.remove"), id: text }),
-    // One line at the top saying what the agent is doing right now.
-    z.object({ ...base, type: z.literal("ticker.set"), text }),
-    z.object({ ...base, type: z.literal("ticker.clear") }),
-]);

package/dist/shared/format.js

@@ -1,50 +0,0 @@
-// Display helpers shared by the panel and the `show` command. Times are shown
-// in the viewer's local time zone.
-const MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
-export function formatMinutes(totalMin) {
-    const whole = Math.max(0, Math.floor(totalMin));
-    if (whole < 1)
-        return "<1 min";
-    const hours = Math.floor(whole / 60);
-    const minutes = whole % 60;
-    if (!hours)
-        return `${minutes} min`;
-    return minutes ? `${hours} h ${minutes} min` : `${hours} h`;
-}
-// A ticket's estimate, the way people say one: "45 min" under an hour, then
-// hours to one decimal: "1 h", "1.5 h", "2.1 h".
-export function formatEstimate(totalMin) {
-    if (totalMin < 60)
-        return formatMinutes(totalMin);
-    return `${Math.round(totalMin / 6) / 10} h`;
-}
-// Estimated work done out of the total, in the units people estimate in:
-// "5 of 10 min", "1 h 30 min of 2 h". Under an hour on both sides, the unit is
-// said once.
-// Once everything is done, how long it really took instead: "1 h 20 min".
-export function formatWorkDone(doneMin, totalMin, tookMin) {
-    if (tookMin !== undefined)
-        return formatMinutes(tookMin);
-    if (totalMin < 60 && doneMin >= 1)
-        return `${Math.floor(doneMin)} of ${formatMinutes(totalMin)}`;
-    return `${doneMin < 1 ? "0 min" : formatMinutes(doneMin)} of ${formatMinutes(totalMin)}`;
-}
-export function formatClock(iso) {
-    const date = new Date(iso);
-    const hours = date.getHours();
-    const minutes = String(date.getMinutes()).padStart(2, "0");
-    return `${MONTHS[date.getMonth()]} ${date.getDate()}, ${hours % 12 || 12}:${minutes} ${hours < 12 ? "AM" : "PM"}`;
-}
-// Just the time, "2:08 AM", when it falls on the same day as `nowMs`; the full
-// clock time otherwise.
-export function formatTimeOfDay(iso, nowMs) {
-    const full = formatClock(iso);
-    return new Date(iso).toDateString() === new Date(nowMs).toDateString() ? full.slice(full.indexOf(", ") + 2) : full;
-}
-export function formatAgo(iso, nowMs) {
-    const minutes = (nowMs - Date.parse(iso)) / 60_000;
-    return minutes < 1 ? "just now" : `${formatMinutes(minutes)} ago`;
-}
-export function minutesSince(iso, nowMs) {
-    return Math.max(0, (nowMs - Date.parse(iso)) / 60_000);
-}

package/dist/shared/show.js

@@ -1,74 +0,0 @@
-import { headlineText, shortTitle } from "./dashboard.js";
-import { formatAgo, formatClock, formatEstimate, formatMinutes, formatWorkDone, minutesSince } from "./format.js";
-const STATUS = { not_started: "Not started", working: "Working", blocked: "Blocked", done: "Done", skipped: "Skipped" };
-// The dashboard as plain text, so an agent can check what the user sees.
-export function dashboardText(dashboard, nowMs) {
-    if (!dashboard.run && !dashboard.tickets.length)
-        return "No run yet. Start one with: paseo-progress start \"<title>\"";
-    const lines = [];
-    const when = (iso) => `${formatClock(iso)} (${formatAgo(iso, nowMs)})`;
-    lines.push(dashboard.run?.title ?? "Progress");
-    if (dashboard.run?.subtitle)
-        lines.push(dashboard.run.subtitle);
-    lines.push(headlineText(dashboard));
-    if (dashboard.run?.finished) {
-        lines.push(`Finished ${when(dashboard.run.finished.at)}: ${dashboard.run.finished.outcome}`);
-        lines.push(`This run is closed. Start new work with: paseo-progress start "<title>"`);
-    }
-    if (dashboard.ticker)
-        lines.push(`Now: ${dashboard.ticker.text}`);
-    if (dashboard.updatedAt)
-        lines.push(`Last updated ${when(dashboard.updatedAt)}`);
-    if (dashboard.stale && dashboard.updatedAt)
-        lines.push(`POSSIBLY STALE: no update for ${formatMinutes(minutesSince(dashboard.updatedAt, nowMs))}.`);
-    if (dashboard.progress.totalMin) {
-        lines.push(`${dashboard.progress.percent}% of estimated work done, ${dashboard.progress.tookMin !== undefined ? "took " : ""}${formatWorkDone(dashboard.progress.doneMin, dashboard.progress.totalMin, dashboard.progress.tookMin)}`);
-    }
-    if (dashboard.issues.length) {
-        lines.push("", `Skipped lines: ${dashboard.issues.map((issue) => `line ${issue.line} (${issue.reason})`).join(", ")}`);
-    }
-    if (dashboard.stuck.length) {
-        lines.push("", "Stuck");
-        for (const item of dashboard.stuck) {
-            const detail = item.kind === "overdue" ? `no update for longer than its ${formatMinutes(item.estimateMin)} estimate`
-                : item.kind === "blocked" ? `blocked${item.note ? `: ${item.note}` : ""}`
-                    : `${item.id}: ${item.reason}`;
-            lines.push(`  ${item.title} (${detail}), since ${when(item.since)}`);
-        }
-    }
-    lines.push("", `${dashboard.run?.itemLabel ?? "Ticket"}s`);
-    for (const ticket of dashboard.tickets) {
-        const stage = ticket.status === "working" && ticket.stage ? `, ${ticket.stage} stage` : "";
-        const status = ticket.waitingFor ? `Waiting for ${ticket.waitingFor.id}` : STATUS[ticket.status];
-        lines.push(`  ${ticket.id}  ${status}${stage}  ${formatEstimate(ticket.estimateMin)}  ${ticket.title}`);
-        if (ticket.source)
-            lines.push(`      Source: ${ticket.source.path ?? ticket.source.url}${ticket.source.label ? ` (${ticket.source.label})` : ""}`);
-    }
-    if (dashboard.questions.open.length) {
-        lines.push("", "Questions waiting");
-        for (const question of dashboard.questions.open) {
-            lines.push(`  ${question.id} ${question.ticketId ? `[${question.ticketId}] ` : ""}(${question.title}): ${question.question} You recommended ${question.recommended}`);
-            for (const option of question.options)
-                lines.push(`      ${option.letter}) ${option.label}${option.consequence ? `: ${option.consequence}` : ""}`);
-        }
-    }
-    if (dashboard.questions.answered.length) {
-        lines.push("", "Answered");
-        for (const question of dashboard.questions.answered) {
-            lines.push(`  ${question.id} (${question.title}): ${question.answer.choice}${question.answer.changedCourse ? " (changed course)" : ""}`);
-        }
-    }
-    if (dashboard.deliverables.length) {
-        lines.push("", "Latest deliverables");
-        for (const deliverable of dashboard.deliverables.slice(0, 5)) {
-            const ticket = deliverable.ticketId ? `, ${deliverable.ticketLabel ?? shortTitle(deliverable.ticketId)}` : "";
-            lines.push(`  ${deliverable.id}  ${deliverable.title}: ${deliverable.url ?? deliverable.path}${ticket}`);
-        }
-    }
-    if (dashboard.activity.length) {
-        lines.push("", "Activity");
-        for (const entry of dashboard.activity.slice(0, 5))
-            lines.push(`  ${entry.id}  ${entry.ticketId ? `[${entry.ticketId}] ` : ""}${entry.text} (${formatAgo(entry.at, nowMs)})`);
-    }
-    return lines.join("\n");
-}