@stevecastaneda/paseo-progress 1.14.2 → 1.14.3

package/server/tool.ts

@@ -14,10 +14,12 @@ export const agentToolsSupported = "defineAgentTool" in sdk;
 // mirrors its typing; Paseo validates the input before execute.
 type Tool = Omit<AgentToolDefinition, "name">;
 
-function agentTool<Input extends z.ZodType>(tool: Omit<Tool, "input" | "execute"> & {
-  input: Input;
-  execute(input: z.output<Input>, context: AgentToolContext): Promise<AgentToolResult>;
-}): Tool {
+function agentTool<Input extends z.ZodType>(
+  tool: Omit<Tool, "input" | "execute"> & {
+    input: Input;
+    execute(input: z.output<Input>, context: AgentToolContext): Promise<AgentToolResult>;
+  },
+): Tool {
   return { ...tool, execute: (input, context) => tool.execute(input as z.output<Input>, context) };
 }
 
@@ -39,8 +41,10 @@ function commandArgs(command: string, positionals: string[], flags: Flags = {}):
 // The command's --help summary, with its flags renamed to this tool's fields.
 const FIELD_FOR_FLAG: Record<string, string> = { estimate: "estimateMinutes", option: "options", file: "files" };
 function toolSummary(command: string): string {
-  return commandSummary(command).replace(/--([a-z]+(?:-[a-z]+)*)/g, (_, flag: string) =>
-    FIELD_FOR_FLAG[flag] ?? flag.replace(/-([a-z])/g, (_m, letter: string) => letter.toUpperCase()));
+  return commandSummary(command).replace(
+    /--([a-z]+(?:-[a-z]+)*)/g,
+    (_, flag: string) => FIELD_FOR_FLAG[flag] ?? flag.replace(/-([a-z])/g, (_m, letter: string) => letter.toUpperCase()),
+  );
 }
 
 function commandTool<Input extends z.ZodType>(title: string, command: string, input: Input, args: (input: z.output<Input>) => string[], extra = "") {
@@ -54,28 +58,37 @@ function commandTool<Input extends z.ZodType>(title: string, command: string, in
 
 const ticketId = (what: string) => z.string().describe(`${what}, like T03`);
 const estimate = z.number().int().describe("Whole minutes, like 90");
-const source = z.string().describe("Spec file path or http(s) link where the ticket is written up");
+const ticketSource = z.string().describe("Spec file path or http(s) link where the ticket is written up");
 
 // Keyed by name, so the compiler holds this to the shared list.
 const tools: Record<ProgressToolName, Tool> = {
   progress_show: commandTool("Show", "show", z.object({}), () => ["show"]),
-  progress_start: commandTool("Start run", "start",
+  progress_start: commandTool(
+    "Start run",
+    "start",
     z.object({
       title: z.string(),
       subtitle: z.string().optional(),
       itemLabel: z.string().optional().describe('What to call each item instead of "Ticket", like Step'),
     }),
-    ({ title, subtitle, itemLabel }) => commandArgs("start", [title], { subtitle, "item-label": itemLabel })),
-  progress_ticket_add: commandTool("Add ticket", "ticket add",
+    ({ title, subtitle, itemLabel }) => commandArgs("start", [title], { subtitle, "item-label": itemLabel }),
+  ),
+  progress_ticket_add: commandTool(
+    "Add ticket",
+    "ticket add",
     z.object({
       title: z.string().describe('Like "Ticket 01: Export button"'),
       estimateMinutes: estimate,
       status: ticketStatusSchema.optional(),
       waitsFor: ticketId("A ticket this one can't start before").optional(),
-      source: source.optional(),
+      source: ticketSource.optional(),
     }),
-    ({ title, estimateMinutes, status, waitsFor, source }) => commandArgs("ticket add", [title], { estimate: estimateMinutes, status, "waits-for": waitsFor, source })),
-  progress_ticket_update: commandTool("Update ticket", "ticket update",
+    ({ title, estimateMinutes, status, waitsFor, source }) =>
+      commandArgs("ticket add", [title], { estimate: estimateMinutes, status, "waits-for": waitsFor, source }),
+  ),
+  progress_ticket_update: commandTool(
+    "Update ticket",
+    "ticket update",
     z.object({
       id: ticketId("The ticket"),
       status: ticketStatusSchema.optional(),
@@ -87,58 +100,81 @@ const tools: Record<ProgressToolName, Tool> = {
       source: z.string().optional().describe('Spec file path or http(s) link where the ticket is written up; "" clears it'),
     }),
     ({ id, status, stage, title, estimateMinutes, note, waitsFor, source }) =>
-      commandArgs("ticket update", [id], { status, stage, title, estimate: estimateMinutes, note, "waits-for": waitsFor, source })),
-  progress_question_ask: commandTool("Ask question", "question ask",
+      commandArgs("ticket update", [id], { status, stage, title, estimate: estimateMinutes, note, "waits-for": waitsFor, source }),
+  ),
+  progress_question_ask: commandTool(
+    "Ask question",
+    "question ask",
     z.object({
       title: z.string().describe("A short title"),
       question: z.string(),
-      options: z.array(z.object({
-        letter: z.string().describe("A, B, C, ..."),
-        label: z.string(),
-        consequence: z.string().describe("What picking it means for the user"),
-      })),
+      options: z.array(
+        z.object({
+          letter: z.string().describe("A, B, C, ..."),
+          label: z.string(),
+          consequence: z.string().describe("What picking it means for the user"),
+        }),
+      ),
       recommend: z.string().describe("The option letter you would pick"),
       big: z.string().optional().describe("Only for a big question: which test it meets, in a few plain words"),
       background: z.string().optional(),
-      files: z.array(z.object({
-        target: z.string().describe("A file path or http(s) link, like a screenshot"),
-        label: z.string().optional(),
-      })).optional(),
+      files: z
+        .array(
+          z.object({
+            target: z.string().describe("A file path or http(s) link, like a screenshot"),
+            label: z.string().optional(),
+          }),
+        )
+        .optional(),
       ticket: ticketId("The ticket it's about").optional(),
     }),
-    ({ title, question, options, recommend, big, background, files, ticket }) => commandArgs("question ask", [title, question], {
-      option: options.map(({ letter, label, consequence }) => `${letter}=${label} | ${consequence}`),
-      recommend,
-      big,
-      background,
-      file: files?.map(({ target, label }) => (label ? `${target}=${label}` : target)),
-      ticket,
-    })),
-  progress_question_answer: commandTool("Record answer", "question answer",
+    ({ title, question, options, recommend, big, background, files, ticket }) =>
+      commandArgs("question ask", [title, question], {
+        option: options.map(({ letter, label, consequence }) => `${letter}=${label} | ${consequence}`),
+        recommend,
+        big,
+        background,
+        file: files?.map(({ target, label }) => (label ? `${target}=${label}` : target)),
+        ticket,
+      }),
+  ),
+  progress_question_answer: commandTool(
+    "Record answer",
+    "question answer",
     z.object({
       id: z.string().describe("The question, like Q2"),
       choice: z.string().describe("An option letter, or the user's own short answer"),
       words: z.string().optional().describe("What the user said"),
     }),
-    ({ id, choice, words }) => commandArgs("question answer", [id, choice], { words })),
-  progress_deliverable_add: commandTool("Add deliverable", "deliverable add",
+    ({ id, choice, words }) => commandArgs("question answer", [id, choice], { words }),
+  ),
+  progress_deliverable_add: commandTool(
+    "Add deliverable",
+    "deliverable add",
     z.object({
       title: z.string(),
       target: z.string().describe("A file or folder path, or an http(s) link"),
       ticket: ticketId("The ticket it belongs to").optional(),
       kind: z.enum(DELIVERABLE_KINDS).optional(),
     }),
-    ({ title, target, ticket, kind }) => commandArgs("deliverable add", [title, target], { ticket, kind })),
-  progress_activity_add: commandTool("Log activity", "activity add",
+    ({ title, target, ticket, kind }) => commandArgs("deliverable add", [title, target], { ticket, kind }),
+  ),
+  progress_activity_add: commandTool(
+    "Log activity",
+    "activity add",
     z.object({ text: z.string(), ticket: ticketId("The ticket it's about").optional() }),
-    ({ text, ticket }) => commandArgs("activity add", [text], { ticket })),
-  progress_ticker: commandTool("Set ticker", "ticker set",
+    ({ text, ticket }) => commandArgs("activity add", [text], { ticket }),
+  ),
+  progress_ticker: commandTool(
+    "Set ticker",
+    "ticker set",
     z.object({ text: z.string() }),
     ({ text }) => (text.trim() ? commandArgs("ticker set", [text]) : commandArgs("ticker clear", [])),
-    ' Pass "" to hide it.'),
-  progress_finish: commandTool("Finish run", "finish",
-    z.object({ outcome: z.string().describe("One line") }),
-    ({ outcome }) => commandArgs("finish", [outcome])),
+    ' Pass "" to hide it.',
+  ),
+  progress_finish: commandTool("Finish run", "finish", z.object({ outcome: z.string().describe("One line") }), ({ outcome }) =>
+    commandArgs("finish", [outcome]),
+  ),
   paseo_progress: agentTool({
     title: "Progress",
     description: [
@@ -147,7 +183,16 @@ const tools: Record<ProgressToolName, Tool> = {
       'Pass ["--help"] to list the commands, or add "--help" after any command for its options.',
     ].join(" "),
     input: z.object({ args: z.array(z.string()).min(1).describe("Arguments for paseo-progress, one per item") }),
-    execute: ({ args }, context) => run(args, context),
+    // install-launcher writes a program wherever it's told, such as a git hook,
+    // so only the user installs it. Every other command writes only in
+    // Progress's own folder and the run-history folder the user chose.
+    execute: async ({ args }, context) =>
+      args[0] === "install-launcher"
+        ? {
+            text: "Agents can't install the paseo-progress command. The user installs it with Install command in the Progress panel.",
+            isError: true,
+          }
+        : run(args, context),
   }),
 };
 

package/server/whats-new.ts

@@ -9,15 +9,18 @@ import { z } from "zod";
 import { NOTE_KINDS, type NoteKind, type WhatsNew, type WhatsNewNote, type WhatsNewRelease } from "../shared/whats-new.ts";
 import { spans } from "../shared/blocks.ts";
 import { findPluginDirectory } from "./skill.ts";
-import { stateRoot, writeAtomic } from "./store.ts";
+import { stateRoot } from "./store.ts";
+import { writeFileIn } from "./system.ts";
 
 export type Release = { version: string; readme: string | null };
 
 const seenSchema = z.object({ seen: z.string().regex(/^\d+\.\d+\.\d+$/) });
 const packageSchema = z.object({ version: z.string() });
 
+const WHATS_NEW_NAME = "whats-new.json";
+
 export function whatsNewPath(home = homedir()): string {
-  return join(stateRoot(home), "whats-new.json");
+  return join(stateRoot(home), WHATS_NEW_NAME);
 }
 
 // Each `### x.y.z` under the README's `## Changelog` with its top-level
@@ -44,8 +47,8 @@ export function changelog(readme: string): WhatsNewRelease[] {
   }
   return releases
     .filter((release) => release.bullets.length)
-    .map(({ version, bullets }) => ({ version, notes: bullets.map(note) }))
-    .sort((a, b) => compareVersions(b.version, a.version));
+    .map(({ version, bullets }) => ({ version, notes: bullets.map(noteFromBullet) }))
+    .toSorted((a, b) => compareVersions(b.version, a.version));
 }
 
 function compareVersions(a: string, b: string): number {
@@ -55,27 +58,36 @@ function compareVersions(a: string, b: string): number {
 
 // A bullet can open with a kind tag, like `[Fixed]`, and then a bold
 // sentence, like `**Title.** Detail.`, which is its title.
-function note(bullet: string): WhatsNewNote {
+function noteFromBullet(bullet: string): WhatsNewNote {
   const tag = /^\[([a-z]+)\]\s*(.*)$/i.exec(bullet);
   const kind = tag ? noteKind(tag[1]) : undefined;
   const rest = kind ? tag![2] : bullet;
-  const text = rest.split(/(`[^`]+`)/).map((part, index) => index % 2 ? part : curly(part)).join("");
+  const text = rest
+    .split(/(`[^`]+`)/)
+    .map((part, index) => (index % 2 ? part : curly(part)))
+    .join("");
   const lead = /^\*\*([^*]+?[.!?])\*\*\s*(.*)$/.exec(text);
   return { ...(kind && { kind }), ...(lead ? { title: plain(lead[1]), body: lead[2] } : { body: text }) };
 }
 
 function noteKind(tag: string): NoteKind | undefined {
   const key = tag.toLowerCase();
-  return Object.hasOwn(NOTE_KINDS, key) ? key as NoteKind : undefined;
+  return Object.hasOwn(NOTE_KINDS, key) ? (key as NoteKind) : undefined;
 }
 
 // The README is typed with straight quotes; the panel shows typeset ones. Code keeps its own.
 function curly(text: string): string {
-  return text.replace(/(^|[\s([{])"/g, "$1\u201c").replace(/"/g, "\u201d").replace(/(^|[\s([{])'/g, "$1\u2018").replace(/'/g, "\u2019");
+  return text
+    .replace(/(^|[\s([{])"/g, "$1\u201c")
+    .replace(/"/g, "\u201d")
+    .replace(/(^|[\s([{])'/g, "$1\u2018")
+    .replace(/'/g, "\u2019");
 }
 
 function plain(markdown: string): string {
-  return spans(markdown).map((span) => span.text).join("");
+  return spans(markdown)
+    .map((span) => span.text)
+    .join("");
 }
 
 // A note's title, or else the first sentence of its body, without Markdown.
@@ -94,7 +106,7 @@ async function readSeen(home: string): Promise<string | null> {
 }
 
 export async function markWhatsNewSeen(version: string, home = homedir()): Promise<void> {
-  await writeAtomic(whatsNewPath(home), `${JSON.stringify({ seen: version })}\n`);
+  await writeFileIn(stateRoot(home), WHATS_NEW_NAME, `${JSON.stringify({ seen: version })}\n`, { atomic: true });
 }
 
 // A worktree's folder (see outsideDirectory) means the plugin was in use
@@ -115,9 +127,9 @@ export async function whatsNew({ version, readme }: Release, home = homedir()):
     await markWhatsNewSeen(version, home);
     return null;
   }
-  const releases = (readme === null ? [] : changelog(readme)).filter((release) => seen === null
-    ? release.version === version
-    : compareVersions(release.version, seen) > 0 && compareVersions(release.version, version) <= 0);
+  const releases = (readme === null ? [] : changelog(readme)).filter((release) =>
+    seen === null ? release.version === version : compareVersions(release.version, seen) > 0 && compareVersions(release.version, version) <= 0,
+  );
   if (!releases.length) return null;
   const notes = releases.flatMap((release) => release.notes);
   return { version, headline: headline(notes.find((note) => note.kind === "new") ?? notes[0]), releases };

package/shared/attachments.ts

@@ -19,7 +19,18 @@ export function deliverableAttachment(deliverable: Deliverable): Attachment {
 }
 
 function fileAttachment(ref: string, file: FileLink): Attachment {
-  return { ref, title: file.label ?? (file.path ?? file.url ?? "").replace(/[\\/]+$/, "").split(/[\\/]/).pop() ?? "", path: file.path, url: file.url };
+  return {
+    ref,
+    title:
+      file.label ??
+      (file.path ?? file.url ?? "")
+        .replace(/[\\/]+$/, "")
+        .split(/[\\/]/)
+        .pop() ??
+      "",
+    path: file.path,
+    url: file.url,
+  };
 }
 
 export function questionAttachments(question: Question): Attachment[] {
@@ -118,6 +129,18 @@ export function previewKind(path: string): PreviewKind | null {
   return DOCUMENT_KINDS[extension(path) ?? ""] ?? (textFormat(path) ? "text" : null);
 }
 
+const AUDIO_EXTENSIONS = new Set([".mp3", ".m4a", ".aac", ".wav", ".flac", ".ogg", ".opus"]);
+
+// Whether a file opens in the host's default app, the way a double-click
+// would. Only kinds whose default app shows them and never runs them: a
+// script, an app or an installer would run. SVG and HTML stay out too, since a
+// browser opens them and their scripts run with the user's files at hand.
+export function opensOnHost(path: string): boolean {
+  const kind = previewKind(path);
+  if (kind === "html" || extension(path) === ".svg") return false;
+  return kind !== null || AUDIO_EXTENSIONS.has(extension(path) ?? "");
+}
+
 export function isFolder(attachment: Attachment): boolean {
   return attachment.kind === "folder" || /[\\/]$/.test(attachment.path ?? "");
 }
@@ -176,13 +199,13 @@ export function attachmentIcon(attachment: Attachment): string {
   if (attachment.url) return "Globe";
   if (!attachment.path) return "File";
   const kind = previewKind(attachment.path);
-  return kind ? PREVIEW_ICON[kind] : /[\/]$/.test(attachment.path) ? "Folder" : "File";
+  return kind ? PREVIEW_ICON[kind] : attachment.path.endsWith("/") ? "Folder" : "File";
 }
 
-// An HTML page is too wide for the dialog, so where the host can't open it the
-// desktop app gives it a screen of its own. The phone apps can't draw one.
-export function opensAsPage(attachment: Attachment, where: { browser: boolean }): boolean {
-  return where.browser && Boolean(attachment.path) && previewKind(attachment.path!) === "html";
+// An HTML page opens in a Paseo tab, in Paseo's own preview, which runs the
+// page's scripts and blocks everything it would load from the web.
+export function isPage(attachment: Attachment): boolean {
+  return !isFolder(attachment) && previewKind(attachment.path ?? "") === "html";
 }
 
 // Android's viewer has no PDF support.
@@ -197,7 +220,16 @@ export function opensInTab(attachment: Attachment, where: { platform: string }):
 // The short name people recognize: a file or folder's own name, or a link's site.
 export function shortName(attachment: Attachment): string {
   if (attachment.url) {
-    try { return new URL(attachment.url).host.replace(/^www\./, ""); } catch { return attachment.url; }
+    try {
+      return new URL(attachment.url).host.replace(/^www\./, "");
+    } catch {
+      return attachment.url;
+    }
   }
-  return (attachment.path ?? "").replace(/[\\/]+$/, "").split(/[\\/]/).pop() ?? "";
+  return (
+    (attachment.path ?? "")
+      .replace(/[\\/]+$/, "")
+      .split(/[\\/]/)
+      .pop() ?? ""
+  );
 }

package/shared/blocks.ts

@@ -15,12 +15,15 @@ export function spans(text: string): Span[] {
       result.push({ text: part.slice(1, -1), code: true });
       return;
     }
-    part.replace(/!?\[([^\]]*)\]\([^)]*\)/g, "$1").split(/((?:\*\*|__).+?(?:\*\*|__))/).forEach((piece) => {
-      if (!piece) return;
-      const strong = /^(\*\*|__).+\1$/.test(piece);
-      const text = (strong ? piece.slice(2, -2) : piece).replace(/(^|[\s(])[*_](\S(?:.*?\S)?)[*_](?=[\s).,;:!?]|$)/g, "$1$2");
-      result.push(strong ? { text, strong } : { text });
-    });
+    part
+      .replace(/!?\[([^\]]*)\]\([^)]*\)/g, "$1")
+      .split(/((?:\*\*|__).+?(?:\*\*|__))/)
+      .forEach((piece) => {
+        if (!piece) return;
+        const strong = /^(\*\*|__).+\1$/.test(piece);
+        const unmarked = (strong ? piece.slice(2, -2) : piece).replace(/(^|[\s(])[*_](\S(?:.*?\S)?)[*_](?=[\s).,;:!?]|$)/g, "$1$2");
+        result.push(strong ? { text: unmarked, strong } : { text: unmarked });
+      });
   });
   return result;
 }

package/shared/dashboard.ts

@@ -152,20 +152,23 @@ export function parseProgress(text: string): { events: ParsedLine[]; issues: Fil
   const issues: FileIssue[] = [];
   // 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: unknown;
-    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) });
-  });
+  text
+    .split("\n")
+    .slice(0, -1)
+    .forEach((raw, index) => {
+      const line = index + 1;
+      if (!raw.trim()) return;
+      let json: unknown;
+      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 };
 }
 
@@ -209,7 +212,10 @@ export function latestRun(events: ParsedLine[]): ParsedLine[] {
 // 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: { events: ParsedLine[]; issues: FileIssue[] }, now: Date): { dashboard: Dashboard; validUntil: number; nextIds: NextIds } {
+export function reduceProgress(
+  parsed: { events: ParsedLine[]; issues: FileIssue[] },
+  now: Date,
+): { dashboard: Dashboard; validUntil: number; nextIds: NextIds } {
   const time = clock(now);
   const events = latestRun(parsed.events);
   const issues = [...parsed.issues];
@@ -358,9 +364,7 @@ export function reduceProgress(parsed: { events: ParsedLine[]; issues: FileIssue
   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;
+    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);
@@ -368,9 +372,7 @@ export function reduceProgress(parsed: { events: ParsedLine[]; issues: FileIssue
   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 answered = allQuestions.filter((question) => question.answer).sort((a, b) => Date.parse(b.answer!.at) - Date.parse(a.answer!.at));
   const dashboard: Dashboard = {
     run,
     updatedAt,
@@ -388,17 +390,27 @@ export function reduceProgress(parsed: { events: ParsedLine[]; issues: FileIssue
     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)) };
+  return {
+    dashboard,
+    validUntil: time.validUntil,
+    nextIds: nextIds(
+      parsed.events.map(({ event }) => event),
+      events.map(({ event }) => event),
+    ),
+  };
+}
+
+function idsOf(events: ProgressEvent[], type: ProgressEvent["type"]): string[] {
+  return events.flatMap((event) => (event.type === type && "id" in event ? [event.id] : []));
 }
 
 function nextIds(all: ProgressEvent[], inRun: ProgressEvent[]): NextIds {
-  const used = (events: ProgressEvent[], type: ProgressEvent["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),
+    ticket: nextId("T", idsOf(inRun, "ticket.add")),
+    question: nextId("Q", idsOf(all, "question.ask"), 1),
+    deliverable: nextId("D", idsOf(inRun, "deliverable.add"), 1),
+    activity: nextId("A", idsOf(inRun, "activity.add"), 1),
+    stuck: nextId("S", idsOf(inRun, "stuck.set"), 1),
   };
 }
 
@@ -425,7 +437,12 @@ function lastTicketUpdate(ticket: Ticket, activity: Activity[]): number {
   );
 }
 
-function stuckItems(tickets: Ticket[], activity: Activity[], manual: Array<{ id: string; reason: string; ticket?: string; since: string }>, reached: (at: number) => boolean): StuckItem[] {
+function stuckItems(
+  tickets: Ticket[],
+  activity: Activity[],
+  manual: Array<{ id: string; reason: string; ticket?: string; since: string }>,
+  reached: (at: number) => boolean,
+): StuckItem[] {
   const items: StuckItem[] = [];
   for (const ticket of tickets) {
     // Blocked only on another ticket in the run is waiting, not stuck.

package/shared/events.ts

@@ -121,16 +121,18 @@ export const eventSchema = z.discriminatedUnion("type", [
   }),
   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.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 }),

package/shared/markdown.ts

@@ -42,7 +42,9 @@ export interface FileLocation {
 }
 
 export function prepareMarkdown(bytes: Uint8Array, truncated: boolean, where: FileLocation): string {
-  const text = previewText(bytes, truncated).replace(/^\uFEFF/, "").replace(/\r\n?/g, "\n");
+  const text = previewText(bytes, truncated)
+    .replace(/^\uFEFF/, "")
+    .replace(/\r\n?/g, "\n");
   return rewriteTargets(fenceFrontMatter(text), where);
 }
 
@@ -195,7 +197,8 @@ function rewriteTargets(source: string, where: FileLocation): string {
       if (!lines[index].definition) continue;
       const lineText = source.slice(lines[index].start, lines[index].end);
       const target = definitionTarget(lineText);
-      if (target && !mask[lines[index].start - offset + target.start]) add(lines[index].start - offset + target.start, lines[index].start - offset + target.end, target.target, false);
+      if (target && !mask[lines[index].start - offset + target.start])
+        add(lines[index].start - offset + target.start, lines[index].start - offset + target.end, target.target, false);
     }
     for (const tag of text.matchAll(/<(img|a)\b[^>]*>/gi)) {
       if (mask[tag.index]) continue;
@@ -428,11 +431,15 @@ function blockUnits(body: string): { units: Unit[]; definitions: Line[] } {
     const text = body.slice(line.start, line.end);
     const current = unit as Unit | null;
     const inFence = line.kind === "fence-body" || line.kind === "fence-close";
-    const continues = current !== null && (
-      (current.kind === "fence" && inFence)
-      || (current.kind === "code" && line.kind === "indented-code")
-      || (current.kind === "item" && !line.topLevelItem && line.kind !== "blank" && (inFence || indentOf(text) >= 2 || (!afterBlank && line.kind === "text" && !line.headingLevel)))
-      || (current.kind === "paragraph" && line.kind === "text" && !line.headingLevel && !line.topLevelItem && !line.definition));
+    const continues =
+      current !== null &&
+      ((current.kind === "fence" && inFence) ||
+        (current.kind === "code" && line.kind === "indented-code") ||
+        (current.kind === "item" &&
+          !line.topLevelItem &&
+          line.kind !== "blank" &&
+          (inFence || indentOf(text) >= 2 || (!afterBlank && line.kind === "text" && !line.headingLevel))) ||
+        (current.kind === "paragraph" && line.kind === "text" && !line.headingLevel && !line.topLevelItem && !line.definition));
     if (continues) {
       current.end = line.end;
       current.lines.push(line);
@@ -468,7 +475,8 @@ function cutFirstBlock(body: string, first: Unit, maxChars: number): { end: numb
 
 function visibleLength(body: string, unit: Unit, maxChars: number): number {
   const text = body.slice(unit.start, unit.end);
-  if (unit.kind === "fence" || unit.kind === "code") return (unit.kind === "fence" ? unit.lines.slice(1, -1) : unit.lines).reduce((sum, line) => sum + line.end - line.start, 0);
+  if (unit.kind === "fence" || unit.kind === "code")
+    return (unit.kind === "fence" ? unit.lines.slice(1, -1) : unit.lines).reduce((sum, line) => sum + line.end - line.start, 0);
   if (/!\[[^\]]*\]\(|<img\b/i.test(text)) return maxChars;
   return text
     .replace(/<!--[\s\S]*?-->|<[^>]+>/g, "")

package/shared/question-modes.ts

@@ -19,13 +19,15 @@ interface QuestionModeRules {
   state(big: boolean): QuestionState;
 }
 
-const HOLD = "Build no option before the answer, not even your recommendation. Work on everything the question doesn't affect. If nothing else is left, end your turn, tell the user in chat which questions you're waiting on, and leave the run open.";
+const HOLD =
+  "Build no option before the answer, not even your recommendation. Work on everything the question doesn't affect. If nothing else is left, end your turn, tell the user in chat which questions you're waiting on, and leave the run open.";
 
 export const QUESTION_MODE_RULES: Record<QuestionMode, QuestionModeRules> = {
   stop: {
     label: "Stop",
     hint: "Agents stop all work when they ask, until you answer.",
-    askRule: () => "Ask any other questions you already have, then stop all work and resume only after an answer. End your turn now, tell the user in chat which questions you're waiting on, and leave the run open.",
+    askRule: () =>
+      "Ask any other questions you already have, then stop all work and resume only after an answer. End your turn now, tell the user in chat which questions you're waiting on, and leave the run open.",
     state: () => "stopped",
   },
   "work-around": {
@@ -37,9 +39,10 @@ export const QUESTION_MODE_RULES: Record<QuestionMode, QuestionModeRules> = {
   "keep-building": {
     label: "Keep building",
     hint: "Agents build their recommended option while you decide, and change course if you pick another. Big questions still wait.",
-    askRule: ({ recommend, big }) => big
-      ? `This question is big, so hold it like Work around. ${HOLD}`
-      : `Build ${recommend} now and keep working. If the user picks another option, undo the work built on ${recommend} and build their choice first. If the rest of the work is done while it's still open, leave it open and tell the user in chat; don't withdraw it.`,
+    askRule: ({ recommend, big }) =>
+      big
+        ? `This question is big, so hold it like Work around. ${HOLD}`
+        : `Build ${recommend} now and keep working. If the user picks another option, undo the work built on ${recommend} and build their choice first. If the rest of the work is done while it's still open, leave it open and tell the user in chat; don't withdraw it.`,
     state: (big) => (big ? "waiting" : "building"),
   },
 };