@stevecastaneda/paseo-progress 0.2.1 → 0.3.0

package/dist/server/cli.js

@@ -6,7 +6,7 @@ import { fileURLToPath } from "node:url";
 import { parseArgs } from "node:util";
 import { isSettled } from "../shared/dashboard.js";
 import { DELIVERABLE_KINDS, TICKET_STATUSES } from "../shared/events.js";
-import { appendProgress, InvalidEvent, readProgress } from "./progress-file.js";
+import { appendProgress, InvalidEvent, readLatestRun, readProgress } from "./progress-file.js";
 import { findRoot, outside } from "./paths.js";
 import { installLauncher } from "./launcher.js";
 import { findStore, saveRunCopy } from "./store.js";
@@ -114,6 +114,31 @@ function unfinishedWork(dashboard) {
         flagged.length ? `flagged blockers ${flagged.map((item) => item.id).join(", ")} (clear with "stuck clear")` : "",
     ].filter(Boolean);
 }
+// Tickets another session added since this agent last wrote to the run, still
+// to do. Nothing until the agent has written to the run: it reads `show` first.
+function addedByOthers(events, dashboard, agentId) {
+    if (!agentId)
+        return [];
+    const since = events.findLastIndex((event) => event.by === agentId);
+    if (since === -1)
+        return [];
+    const added = new Set(events.slice(since + 1).flatMap((event) => (event.type === "ticket.add" && event.by !== agentId ? [event.id] : [])));
+    return dashboard.tickets.filter((ticket) => added.has(ticket.id) && !isSettled(ticket));
+}
+function addedByOthersText(tickets, dashboard) {
+    if (!tickets.length)
+        return "";
+    const label = (dashboard.run?.itemLabel ?? "Ticket").toLowerCase();
+    const one = tickets.length === 1;
+    // Starts with a blank line, to follow the command's own output.
+    return [
+        "",
+        "",
+        `Another session added ${one ? `a ${label}` : `${tickets.length} ${label}s`} since your last update:`,
+        ...tickets.map((ticket) => `  ${ticket.id}  ${ticket.title}`),
+        `${one ? "It is" : "They are"} part of this run: work ${one ? "it" : "them"} in order after your current ${label}.`,
+    ].join("\n");
+}
 const commands = {
     start: {
         usage: `start "<title>" [--subtitle <text>] [--item-label <word>]`,
@@ -141,27 +166,28 @@ const commands = {
         },
     },
     "ticket add": {
-        usage: `ticket add "<title>" --estimate <minutes> [--status <status>] [--waits-for <id>]`,
-        summary: "Add a ticket. Prints its id (T01, T02, ...). --waits-for names a ticket it can't start before; that is the order of work, not a blocker.",
-        options: { estimate: { type: "string" }, status: { type: "string" }, "waits-for": { type: "string" } },
-        run({ positionals, values, state }) {
+        usage: `ticket add "<title>" --estimate <minutes> [--status <status>] [--waits-for <id>] [--source <path or http(s) URL>[=<label>]]`,
+        summary: "Add a ticket. Prints its id (T01, T02, ...). --waits-for names a ticket it can't start before; that is the order of work, not a blocker. --source is where the ticket is written up, like its spec file or issue link.",
+        options: { estimate: { type: "string" }, status: { type: "string" }, "waits-for": { type: "string" }, source: { type: "string" } },
+        run({ positionals, values, state, cwd, root }) {
             const waitsFor = values["waits-for"] === undefined ? undefined : existingTicket(state, stringOption(values["waits-for"])).id;
             const title = required(positionals[0], "ticket title");
             const estimateMin = minutesOption(values.estimate, "estimate");
             if (estimateMin === undefined)
                 throw new UsageError("Missing --estimate <minutes>.");
+            const source = values.source === undefined ? undefined : parseFile(String(values.source), cwd, root);
             const id = state.nextIds.ticket;
             return {
-                event: { type: "ticket.add", id, title, estimateMin, status: statusOption(values.status), waitsFor },
-                message: `Added ${id}: ${title} (${estimateMin} min)${waitsFor ? `, waits for ${waitsFor}` : ""}`,
+                event: { type: "ticket.add", id, title, estimateMin, status: statusOption(values.status), waitsFor, source },
+                message: `Added ${id}: ${title} (${estimateMin} min)${waitsFor ? `, waits for ${waitsFor}` : ""}${source ? `, source ${source.path ?? source.url}` : ""}`,
             };
         },
     },
     "ticket update": {
-        usage: `ticket update <id> [--status <status>] [--stage <name>] [--title <text>] [--estimate <minutes>] [--note <text>] [--waits-for <id>]`,
-        summary: `Change a ticket. Statuses: ${TICKET_STATUSES.join(", ")}. --stage names the step in progress, like Build or Fixes ("" clears it). --waits-for names a ticket it can't start before ("" clears it); waiting is not stuck, so don't mark it blocked for that.`,
-        options: { status: { type: "string" }, stage: { type: "string" }, title: { type: "string" }, estimate: { type: "string" }, note: { type: "string" }, "waits-for": { type: "string" } },
-        run({ positionals, values, state }) {
+        usage: `ticket update <id> [--status <status>] [--stage <name>] [--title <text>] [--estimate <minutes>] [--note <text>] [--waits-for <id>] [--source <path or http(s) URL>[=<label>]]`,
+        summary: `Change a ticket. Statuses: ${TICKET_STATUSES.join(", ")}. --stage names the step in progress, like Build or Fixes ("" clears it). --waits-for names a ticket it can't start before ("" clears it); waiting is not stuck, so don't mark it blocked for that. --source is where the ticket is written up ("" clears it).`,
+        options: { status: { type: "string" }, stage: { type: "string" }, title: { type: "string" }, estimate: { type: "string" }, note: { type: "string" }, "waits-for": { type: "string" }, source: { type: "string" } },
+        run({ positionals, values, state, cwd, root }) {
             const ticket = existingTicket(state, positionals[0]);
             const rawWaitsFor = values["waits-for"] === undefined ? undefined : String(values["waits-for"]).trim();
             const waitsFor = rawWaitsFor === undefined || rawWaitsFor === "" ? rawWaitsFor : existingTicket(state, rawWaitsFor).id;
@@ -182,11 +208,13 @@ const commands = {
                 stage: stringOption(values.stage),
                 note: stringOption(values.note),
                 waitsFor,
+                source: values.source === undefined ? undefined : String(values.source).trim() === "" ? "" : parseFile(String(values.source), cwd, root),
             };
             const changes = Object.entries(event).filter(([key, value]) => key !== "type" && key !== "id" && value !== undefined);
             if (!changes.length)
-                throw new UsageError("Nothing to change. Pass --status, --stage, --title, --estimate, --note, or --waits-for.");
-            return { event, message: `Updated ${ticket.id}: ${changes.map(([key, value]) => `${key} ${value}`).join(", ")}` };
+                throw new UsageError("Nothing to change. Pass --status, --stage, --title, --estimate, --note, --waits-for, or --source.");
+            const shown = (value) => (typeof value === "object" ? value.path ?? value.url : value);
+            return { event, message: `Updated ${ticket.id}: ${changes.map(([key, value]) => `${key} ${shown(value)}`).join(", ")}` };
         },
     },
     "ticket remove": {
@@ -198,12 +226,11 @@ const commands = {
         },
     },
     "question ask": {
-        usage: `question ask "<short title>" "<question>" [--option "A=<label> | <consequence>" ...] --default <letter or word> [--waits] [--background <text>] [--file <path or http(s) URL>[=<label>] ...] [--raised-by <text>] [--ticket <id>]`,
-        summary: "Ask the user a question. Prints its reference (Q1, Q2, ...). Keep working on the default until it is answered, unless --waits: then the default is only a suggestion and you wait.",
+        usage: `question ask "<short title>" "<question>" [--option "A=<label> | <consequence>" ...] --recommend <letter or word> [--background <text>] [--file <path or http(s) URL>[=<label>] ...] [--raised-by <text>] [--ticket <id>]`,
+        summary: "Ask the user a question. Prints its reference (Q1, Q2, ...). --recommend is the option you would pick. Build no option before the answer: work only on what the question doesn't affect, and if nothing else is left, stop and wait.",
         options: {
             option: { type: "string", multiple: true },
-            default: { type: "string" },
-            waits: { type: "boolean" },
+            recommend: { type: "string" },
             background: { type: "string" },
             file: { type: "string", multiple: true },
             "raised-by": { type: "string" },
@@ -218,12 +245,12 @@ const commands = {
             const duplicate = letters.find((letter, index) => letters.indexOf(letter) !== index);
             if (duplicate)
                 throw new UsageError(`Option ${duplicate} is given twice.`);
-            let fallback = required(stringOption(values.default), "--default");
+            let recommend = required(stringOption(values.recommend), "--recommend (the option you would pick)");
             if (options.length) {
-                if (!/^[A-Za-z]$/.test(fallback) || !letters.includes(fallback.toUpperCase())) {
-                    throw new UsageError(`--default must be one of the option letters: ${letters.join(", ")}.`);
+                if (!/^[A-Za-z]$/.test(recommend) || !letters.includes(recommend.toUpperCase())) {
+                    throw new UsageError(`--recommend must be one of the option letters: ${letters.join(", ")}.`);
                 }
-                fallback = fallback.toUpperCase();
+                recommend = recommend.toUpperCase();
             }
             const id = state.nextIds.question;
             return {
@@ -233,14 +260,13 @@ const commands = {
                     title,
                     question,
                     options: options.length ? options : undefined,
-                    default: fallback,
-                    waits: values.waits === true ? true : undefined,
+                    recommend,
                     background: stringOption(values.background),
                     files: listOption(values.file).length ? listOption(values.file).map((raw) => parseFile(raw, cwd, root)) : undefined,
                     raisedBy: stringOption(values["raised-by"]),
                     ticket: ticket?.id,
                 },
-                message: `Asked ${id} (${title}). Default: ${fallback}${values.waits === true ? " (waiting for the answer)" : ""}`,
+                message: `Asked ${id} (${title}). You recommend ${recommend}. Build no option before the answer: work only on what it doesn't affect, and if nothing else is left, stop and wait.`,
             };
         },
     },
@@ -257,10 +283,10 @@ const commands = {
                 if (letters.length && !letters.includes(choice))
                     throw new UsageError(`${question.id} has options ${letters.join(", ")}, not ${choice}.`);
             }
-            const changedCourse = choice.toLowerCase() !== question.default.toLowerCase();
+            const asRecommended = choice.toLowerCase() === question.recommended.toLowerCase();
             return {
-                event: { type: "question.answer", id: question.id, choice, words: stringOption(values.words), changedCourse },
-                message: `Answered ${question.id}: ${choice}${changedCourse ? ` (differs from default ${question.default}: change course)` : " (same as the default)"}`,
+                event: { type: "question.answer", id: question.id, choice, words: stringOption(values.words) },
+                message: `Answered ${question.id}: ${choice}${asRecommended ? " (as you recommended)" : ` (not your recommendation, ${question.recommended})`}. Build it now.`,
             };
         },
     },
@@ -453,7 +479,9 @@ export async function runCli(argv, options) {
         if (first === "show") {
             const root = findRoot(options.cwd);
             const store = await findStore(root);
-            out(`Worktree: ${root}\n\n${dashboardText((await readProgress(store.directory, now())).dashboard, now().getTime())}`);
+            const { dashboard } = await readProgress(store.directory, now());
+            const added = addedByOthersText(addedByOthers(await readLatestRun(store.directory), dashboard, options.agentId), dashboard);
+            out(`Worktree: ${root}\n\n${dashboardText(dashboard, now().getTime())}${added}`);
             return 0;
         }
         const target = resolve(options.cwd, (argv[1] ?? DEFAULT_LAUNCHER).replace(/^~(?=$|\/)/, homedir()));
@@ -487,7 +515,8 @@ export async function runCli(argv, options) {
                 throw new UsageError(`The run "${state.dashboard.run.title}" is finished. Start new work with: ${USAGE_NAME} start "<title>"`);
             }
             const { event, message } = command.run({ positionals: parsed.positionals, values: parsed.values, state, cwd: options.cwd, root });
-            return { event, result: message };
+            const added = command === commands.start ? "" : addedByOthersText(addedByOthers(state.events, state.dashboard, options.agentId), state.dashboard);
+            return { event: { ...event, by: options.agentId }, result: `${message}${added}` };
         }, (text) => saveRunCopy(root, text));
         out(message);
         return 0;
@@ -511,7 +540,7 @@ function isMain() {
     }
 }
 if (isMain()) {
-    runCli(process.argv.slice(2), { cwd: process.cwd() }).then((code) => { process.exitCode = code; }, (error) => {
+    runCli(process.argv.slice(2), { cwd: process.cwd(), agentId: process.env.PASEO_AGENT_ID || undefined }).then((code) => { process.exitCode = code; }, (error) => {
         console.error(error instanceof Error ? error.message : error);
         process.exitCode = 1;
     });

package/dist/server/progress-file.js

@@ -4,7 +4,7 @@
 // the panel's RPC handlers go through here, so they agree on how they're read.
 import { access, appendFile, mkdir, readFile, stat, writeFile } from "node:fs/promises";
 import { join } from "node:path";
-import { EMPTY_DASHBOARD, parseProgress, reduceProgress } from "../shared/dashboard.js";
+import { EMPTY_DASHBOARD, latestRun, parseProgress, reduceProgress } from "../shared/dashboard.js";
 import { EVENT_VERSION, eventSchema, PANEL_OPENED_NAME, PROGRESS_FILE_NAME } from "../shared/events.js";
 import { withLock } from "./lock.js";
 const LOCK_NAME = `${PROGRESS_FILE_NAME}.lock`;
@@ -34,17 +34,24 @@ export async function readProgress(directory, now = new Date()) {
     }
     return { configured: true, dashboard: cached.dashboard, panelOpened };
 }
+// The events of the latest run, oldest first.
+export async function readLatestRun(directory) {
+    return latestRun((await readParsed(directory))?.events ?? []).map(({ event }) => event);
+}
 // Appends the one event `write` builds from the file as it is now. Commands
 // that run at once take turns, so each sees the others' events and no two hand
 // out the same id. `write` may throw to append nothing.
-export async function appendProgress(directory, now, write, 
+export async function appendProgress(directory, now, 
+// `events` is the latest run as it is now, oldest first.
+write, 
 // Runs before the lock is released, with the whole file as it now is.
 after) {
     await mkdir(directory, { recursive: true });
     return withLock(join(directory, LOCK_NAME), async () => {
         const text = (await readText(directory)) ?? "";
-        const { dashboard, nextIds } = reduceProgress(parseProgress(text), now());
-        const { event, result } = write({ dashboard, nextIds });
+        const parsed = parseProgress(text);
+        const { dashboard, nextIds } = reduceProgress(parsed, now());
+        const { event, result } = write({ dashboard, nextIds, events: latestRun(parsed.events).map((line) => line.event) });
         const checked = eventSchema.safeParse({ v: EVENT_VERSION, ts: now().toISOString(), ...withoutUndefined(event) });
         if (!checked.success) {
             throw new InvalidEvent(checked.error.issues.map((issue) => `${issue.path.join(".") || "value"}: ${issue.message}`).join("; "));

package/dist/shared/attachments.js

@@ -1,13 +1,14 @@
 export function deliverableAttachment(deliverable) {
     return { ref: deliverable.id, title: deliverable.title, path: deliverable.path, url: deliverable.url, kind: deliverable.kind };
 }
+function fileAttachment(ref, file) {
+    return { ref, title: file.label ?? (file.path ?? file.url ?? "").replace(/[\\/]+$/, "").split(/[\\/]/).pop() ?? "", path: file.path, url: file.url };
+}
 export function questionAttachments(question) {
-    return question.files.map((file, index) => ({
-        ref: `${question.id}.${index + 1}`,
-        title: file.label ?? (file.path ?? file.url ?? "").replace(/[\\/]+$/, "").split(/[\\/]/).pop() ?? "",
-        path: file.path,
-        url: file.url,
-    }));
+    return question.files.map((file, index) => fileAttachment(`${question.id}.${index + 1}`, file));
+}
+export function ticketSourceAttachment(ticket) {
+    return ticket.source ? fileAttachment(`${ticket.id}.source`, ticket.source) : null;
 }
 // The attachment a reference names, or null when it names nothing.
 export function findAttachment(dashboard, ref) {
@@ -16,6 +17,11 @@ export function findAttachment(dashboard, ref) {
         const found = [...dashboard.questions.open, ...dashboard.questions.answered].find((candidate) => candidate.id === question[1]);
         return (found && questionAttachments(found).find((attachment) => attachment.ref === ref)) ?? null;
     }
+    const ticket = ref.match(/^(.+)\.source$/);
+    if (ticket) {
+        const found = dashboard.tickets.find((candidate) => candidate.id === ticket[1]);
+        return found ? ticketSourceAttachment(found) : null;
+    }
     const deliverable = dashboard.deliverables.find((candidate) => candidate.id === ref);
     return deliverable ? deliverableAttachment(deliverable) : null;
 }

package/dist/shared/dashboard.js

@@ -55,17 +55,17 @@ function clock(now) {
 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);
-    let start = 0;
-    parsed.events.forEach(({ event }, index) => {
-        if (event.type === "run.start")
-            start = index;
-    });
-    const events = parsed.events.slice(start);
+    const events = latestRun(parsed.events);
     const issues = [...parsed.issues];
     let run = null;
     const tickets = new Map();
@@ -96,6 +96,8 @@ export function reduceProgress(parsed, now) {
                     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": {
@@ -131,6 +133,10 @@ export function reduceProgress(parsed, now) {
                     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":
@@ -143,8 +149,7 @@ export function reduceProgress(parsed, now) {
                     title: event.title,
                     question: event.question,
                     options: event.options ?? [],
-                    default: event.default,
-                    waits: event.waits ?? false,
+                    recommended: event.recommend ?? event.default ?? "",
                     background: event.background,
                     files: event.files ?? [],
                     raisedBy: event.raisedBy,
@@ -209,7 +214,7 @@ export function reduceProgress(parsed, now) {
                     issues.push({ line, reason: `unknown activity ${event.id}` });
                 break;
             case "ticker.set":
-                ticker = { text: event.text, since: event.ts };
+                ticker = { text: event.text, since: event.ts, ...(event.by ? { by: event.by } : {}) };
                 break;
             case "ticker.clear":
                 ticker = null;

package/dist/shared/events.js

@@ -12,7 +12,8 @@ export const TICKET_STATUSES = ["not_started", "working", "blocked", "done", "sk
 export const ticketStatusSchema = z.enum(TICKET_STATUSES);
 const text = z.string().trim().min(1);
 const minutes = z.number().int().positive().max(100_000);
-const base = { v: z.literal(EVENT_VERSION), ts: z.iso.datetime() };
+// `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,
@@ -43,6 +44,8 @@ export const eventSchema = z.discriminatedUnion("type", [
         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,
@@ -56,12 +59,16 @@ export const eventSchema = z.discriminatedUnion("type", [
         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, picks `default`, and keeps working on it until answered.
+    // 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"),
@@ -69,9 +76,9 @@ export const eventSchema = z.discriminatedUnion("type", [
         title: text,
         question: text,
         options: z.array(questionOptionSchema).max(26).optional(),
-        // An option letter, or a word such as "Your check" when there are no options.
-        default: text,
-        // True when the agent will not act on the default and waits for the answer.
+        // 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(),
@@ -86,7 +93,8 @@ export const eventSchema = z.discriminatedUnion("type", [
         choice: text,
         // The user's own words, quoted under the answer.
         words: text.optional(),
-        changedCourse: z.boolean(),
+        // 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({

package/dist/shared/format.js

@@ -35,6 +35,12 @@ export function formatClock(iso) {
     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`;

package/dist/shared/show.js

@@ -41,11 +41,13 @@ export function dashboardText(dashboard, nowMs) {
         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} Default ${question.default}${question.waits ? ", waiting for the answer" : ""}`);
+            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}` : ""}`);
         }

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@stevecastaneda/paseo-progress",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@stevecastaneda/paseo-progress",
-      "version": "0.2.1",
+      "version": "0.3.0",
       "license": "MIT",
       "dependencies": {
         "@getpaseo/client": "^0.9.2",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stevecastaneda/paseo-progress",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "A live progress dashboard per worktree for Paseo, drawn from a file agents write with the paseo-progress command.",
   "license": "MIT",
   "author": "Steve Castaneda",