@stevecastaneda/paseo-progress 1.14.1 → 1.14.3

package/README.md

@@ -13,7 +13,7 @@ The dashboard shows:
 - percent of estimated work done, time done of time estimated (like "1h 30m of 2h"; once everything is done, how long it really took), and a bar with one segment per ticket
 - **Stuck:** blocked tickets, working tickets with no update for longer than their estimate, and blockers the agent flags
 - **Tickets:** estimate, status, and the working ticket's stage. A ticket that waits for another (`--waits-for T03`) shows "Waits for Ticket 03" under its title until that one is done; waiting is the order of work, so it never counts as stuck, even if the agent also marked it blocked. Press a ticket for its story in a dialog. A summary on top shows its status and stage, time worked against the estimate as a bar that turns red past it, the agent's latest status line while it's working, and the agent on it. Tabs below hold the rest, each only when it has something: the ticket's write-up when it has a `--source` file (the start of it, with the rest a press away), a timeline of its stages and statuses with how long each took, and the activity, questions and deliverables that belong to it. The agent on a ticket shows by its chat title; pressing it opens that chat. Items tagged with `--ticket` belong exactly; older, untagged ones are matched by when they happened and marked "by time"
-- **Questions:** each with a permanent reference (Q1, Q2, ...), lettered options, and the option the agent recommends. You pick what the agent does while you decide in Paseo's Settings (Settings, Plugins, Progress, Settings). **Stop**: it stops all work until you answer. **Work around**, the default: it holds what your answer affects and keeps working on the rest. **Keep building**: it builds its recommendation and changes course if you pick another, except for big questions, which wait. A question is big when building ahead would send something off your computer, when the answer sets something people or programs outside the repo rely on, or when most of the remaining work would be built on it. Each open question shows what the agent is doing: "Agent stopped until you answer", "Waiting for you" (with the reason when it's big), or "Building with B: <its label>". Press a question to open it in a dialog, then press **Copy Q2 B** to copy `Q2 (title): B` for your reply. Files and links the agent attached (`--file`) open like deliverables: images, videos, PDFs and text files preview in Paseo (with **Back** to the question), a folder lists its files there, links open in Paseo's browser, and other files open in their default app. From the pill's popover, the preview opens over the popover, which stays open so you can go back to it. Answers stay listed under the same reference.
+- **Questions:** each with a permanent reference (Q1, Q2, ...), lettered options, and the option the agent recommends. You pick what the agent does while you decide in Paseo's Settings (Settings, Plugins, Progress, Settings). **Stop**: it stops all work until you answer. **Work around**, the default: it holds what your answer affects and keeps working on the rest. **Keep building**: it builds its recommendation and changes course if you pick another, except for big questions, which wait. A question is big when building ahead would send something off your computer, when the answer sets something people or programs outside the repo rely on, or when most of the remaining work would be built on it. Each open question shows what the agent is doing: "Agent stopped until you answer", "Waiting for you" (with the reason when it's big), or "Building with B: <its label>". Press a question to open it in a dialog, then press **Copy Q2 B** to copy `Q2 (title): B` for your reply. Files and links the agent attached (`--file`) open like deliverables: images, videos, PDFs and text files preview in Paseo (with **Back** to the question), a folder lists its files there, links open in Paseo's browser, audio files open in their default app, and any other file copies its path. From the pill's popover, the preview opens over the popover, which stays open so you can go back to it. Answers stay listed under the same reference.
 - **Activity**, **Answered** questions and **Deliverables** (press one to open it), sharing one card with a tab for each; the panel remembers the tab you picked. Each shows the newest 10, with **Show 10 older** below
 
 <img src="images/2-ticket.png" alt="A ticket's story: its status, time against the estimate, the agent on it, and its timeline" width="400"> <img src="images/3-question.png" alt="A question waiting for an answer, with lettered options, the agent's recommendation and Copy buttons" width="400">
@@ -24,7 +24,7 @@ The panel lives in Explorer, beside the agent chat, so you can watch both. Open
 
 <img src="images/4-pill.png" alt="The pill above the message box, showing two questions waiting" width="600">
 
-On phones, Progress opens in Explorer too. On any phone, the pill stays above the message box while a run is open, so there's always a way in. SVG files, videos and PDFs preview on desktop and in Paseo's web app; on phones they open on the daemon host. A PDF in the Deliverables tab also has a button beside Copy that opens it in a Paseo tab, which is where it shows on an iPhone or iPad.
+On phones, Progress opens in Explorer too. On any phone, the pill stays above the message box while a run is open, so there's always a way in. SVG files, videos and PDFs preview on desktop and in Paseo's web app. On phones, videos and PDFs open on the daemon host, and an SVG file copies its path. A PDF in the Deliverables tab also has a button beside Copy that opens it in a Paseo tab, which is where it shows on an iPhone or iPad.
 
 The first time a run starts in a worktree whose Progress panel has never been opened, the pill shows a spinner and reads **Progress** instead; pressing it opens the panel. Once the panel has been opened there, the plugin writes an empty `progress-panel-opened` file next to the progress file and the nudge never comes back, even for later runs. It doesn't open the panel by itself because Paseo switches to a workspace to open its panel, which would pull you away from whatever you're looking at.
 
@@ -86,19 +86,19 @@ Versions before 0.2.0 kept progress in `.scratch/` in each worktree. From 1.14.1
 
 On Paseo 0.14 and later, Progress hands agents a tool for each common command, so recording progress needs nothing installed and every update names the agent that sent it. Paseo only gives plugin tools to agents while **Settings → your host → Agents → Enable Paseo tools** is on. It's off by default, and turning it on also gives agents Paseo's own tools for starting, messaging and stopping other agents. Progress never changes the setting. Once it's on, start a new chat or reload one to give it the tools.
 
-| Tool | Does what this command does |
-| --- | --- |
-| `progress_show` | `show` |
-| `progress_start` | `start` |
-| `progress_ticket_add` | `ticket add` |
-| `progress_ticket_update` | `ticket update` |
-| `progress_question_ask` | `question ask` |
-| `progress_question_answer` | `question answer` |
-| `progress_deliverable_add` | `deliverable add` |
-| `progress_activity_add` | `activity add` |
-| `progress_ticker` | `ticker set`, or `ticker clear` when the text is empty |
-| `progress_finish` | `finish` |
-| `paseo_progress` | Any command, given as the list of words you'd type after `paseo-progress` |
+| Tool                       | Does what this command does                                               |
+| -------------------------- | ------------------------------------------------------------------------- |
+| `progress_show`            | `show`                                                                    |
+| `progress_start`           | `start`                                                                   |
+| `progress_ticket_add`      | `ticket add`                                                              |
+| `progress_ticket_update`   | `ticket update`                                                           |
+| `progress_question_ask`    | `question ask`                                                            |
+| `progress_question_answer` | `question answer`                                                         |
+| `progress_deliverable_add` | `deliverable add`                                                         |
+| `progress_activity_add`    | `activity add`                                                            |
+| `progress_ticker`          | `ticker set`, or `ticker clear` when the text is empty                    |
+| `progress_finish`          | `finish`                                                                  |
+| `paseo_progress`           | Any command, given as the list of words you'd type after `paseo-progress` |
 
 Each tool runs the command inside the plugin, so it checks the same things and answers with the same words. Statuses and deliverable kinds are listed in the tool, so an agent can't send one the command doesn't know. Paths are relative to the agent's folder, like the command run there. Claude Code shows them as `mcp__paseo__progress_show` and so on, and holds them back until the agent searches for them. The skill tells agents to search.
 
@@ -152,7 +152,7 @@ paseo-progress finish "Snapshots ship for all four tables"
 - A working ticket is stuck once it goes longer than its estimate without an update, timed from its last status, stage or note change, or activity tagged to it. The ticket's dialog still shows total time worked against the estimate.
 - `question ask` needs `--recommend`, the agent's pick. The question dialog tags that option "Recommended". Its output tells the agent the question mode and what to do until the answer. `--big "<why>"` marks a big question, which waits for the answer even in Keep building. `start` and `show` also print the mode.
 - Paseo keeps the question mode in its own settings, which only the plugin's server can read, so the server copies it to `~/.local/state/paseo-progress/settings.json` for the command. Without that file, for example while the plugin is off, the command uses Work around.
-- Deliverable paths are stored relative to the worktree root. Web links open in Paseo's browser. Pressing an image (PNG, JPEG, GIF, WebP, up to 10 MB) or text deliverable (Markdown, text, logs, JSON, YAML, CSV; the first 256 KB) previews it in a dialog inside Paseo, which also works from a phone. Markdown shows formatted, with links and images relative to the file's own folder; **Open** there opens the file in its default app. **Open** shows only when the computer running Paseo can open files. A Linux server with no desktop can't, so there a file Paseo can't preview copies its path and says why. A video (MP4, MOV, WebM, up to 200 MB) plays in the same dialog in the desktop app, and a PDF (up to 100 MB) shows there too. When there are several files, **Previous** and **Next** step through them, and so do the left and right arrow keys. Pressing a folder lists its files in the same dialog. Press a file to preview it, or a folder inside to list that one, and **Back** returns to the list. Pressing any other local deliverable opens it with its default app on the machine running the Paseo daemon (for example HTML in your browser). On macOS, **Open** sends text files to your default browser. Only recorded deliverables inside the worktree open this way; otherwise the path is copied. The copy icon on each row copies the path.
+- Deliverable paths are stored relative to the worktree root. Web links open in Paseo's browser. Pressing an image (PNG, JPEG, GIF, WebP, up to 10 MB) or text deliverable (Markdown, text, logs, JSON, YAML, CSV; the first 256 KB) previews it in a dialog inside Paseo, which also works from a phone. Markdown shows formatted, with links and images relative to the file's own folder; **Open** there opens the file in its default app. **Open** shows only when the computer running Paseo can open files. A Linux server with no desktop can't, so there a file Paseo can't preview copies its path and says why. A video (MP4, MOV, WebM, up to 200 MB) plays in the same dialog in the desktop app, and a PDF (up to 100 MB) shows there too. When there are several files, **Previous** and **Next** step through them, and so do the left and right arrow keys. Pressing a folder lists its files in the same dialog. Press a file to preview it, or a folder inside to list that one, and **Back** returns to the list. Pressing an audio file opens it with its default app on the machine running the Paseo daemon. Pressing an HTML page opens it in a Paseo tab with Paseo's own preview, on desktop and on phones, never in your browser. The preview runs the page's own scripts but loads nothing from the web, so a report needs its CSS and images inside the file. Progress hands no other file or folder to a default app, because a script or an app would run, so pressing one copies its path. On macOS, **Open** sends text files to your default browser. Previews and **Open** work only for recorded deliverables inside the worktree; for any other file the path is copied. An HTML page or PDF opens in a Paseo tab from the path the agent recorded. The copy icon on each row copies the path.
 - Several agents can share one run. When another session adds a ticket, each agent sees it at the end of its next command's output (and in `show`), and the skill has it work that ticket in order after its current one. An agent only hears about tickets added since its own last update in the run, and only once.
 - Subagents record their own progress. A Claude Code subagent can call the Progress tools too, and its updates carry its parent chat's agent id. Since Paseo 0.11, an agent waiting on background subagents shows as idle, so only the subagents' updates show the work is still going. The skill has the agent give each subagent the worktree path and ticket id, and the subagent records its stages and a ticker line on that worktree's dashboard.
 - `start` begins a fresh dashboard. Earlier runs stay in the file. Question references stay unique across runs.
@@ -173,11 +173,22 @@ The progress file, `progress.jsonl`, holds one JSON event per line, each with a
 - Progress folders outside the repo stay behind when a worktree is deleted. They're small, and you can delete them from `~/.local/state/paseo-progress/`.
 - Paseo can't open a panel without switching you to its workspace. So a new run shows a "Progress" pill, and you open the panel yourself.
 - Pills check busy worktrees every 5 seconds and quiet ones every 30. In a quiet worktree, a new question can take up to half a minute to show.
-- Previews cover images up to 10 MB, videos up to 200 MB and PDFs up to 100 MB (desktop and web apps only), the first 256 KB of a text file, and the first 500 items in a folder. The folder list leaves out hidden files. Other files open in their default app. A video the app can't decode shows the player's error, and **Open** still works.
+- Previews cover images up to 10 MB, videos up to 200 MB and PDFs up to 100 MB (desktop and web apps only), the first 256 KB of a text file, and the first 500 items in a folder. The folder list leaves out hidden files. Audio files open in their default app, and other files copy their path. A video the app can't decode shows the player's error, and **Open** still works.
 - Stale warnings and overdue times use the daemon host's clock.
 
 ## Changelog
 
+### 1.14.3
+
+- [Fixed] **Open hands only pictures, video, audio, PDFs and text to their default app.** This fixes a security issue in opening deliverables. Progress used to open any file an agent recorded with its default app, and for a script or an app that means running it. Now Open works only for images, video, audio, PDFs and text files. Pressing any other file, an SVG file or a folder copies its path, and an HTML page always opens in Paseo.
+- [Fixed] **Agents can't install the paseo-progress command.** This fixes a security issue in the agent tools. You install it yourself with **Install command** in the Progress panel.
+- [Fixed] **HTML reports open in Paseo's own preview.** This fixes a security issue in the HTML preview. Progress used to show a report on a screen of its own and copy the files it loaded into the page, which could hand the page a file git ignores. Now pressing an HTML report opens it in a Paseo tab, on desktop and on phones. Paseo's preview runs the page's own scripts but loads nothing from the web, and Progress no longer copies files into the page, so a report needs its CSS in the page and its images embedded in the file.
+- [Fixed] **The Windows command runs the Node that installed it.** This fixes a security issue in `paseo-progress.cmd`. It now names the full path to Node, and it looks for Paseo from Node's folder. Because the command changed on every system, the panel asks you once to update it.
+
+### 1.14.2
+
+- [Fixed] **Links in a question open, and its text can be selected.** A web address in a question or in its background used to show as plain text, so you couldn't click it, and the question itself couldn't be selected or copied. The question dialog now draws the question and its background with Paseo's own Markdown view, so an address is a link and the question's text can be selected and copied. The text on an option, and what choosing it leads to, can be selected too. Because the text is read as Markdown now, characters like `*` and `_` format it, a line starting with `#` or `-` becomes a heading or a list, and the background takes Paseo's body size and color instead of the small, muted style it had.
+
 ### 1.14.1
 
 - [Fixed] **Run history stays in its folder.** This fixes a security issue in saving run history. Progress now saves a run only when the dashboard can read the line that started it, and only into a folder inside the repo and outside `.git`.

package/client/attachments.tsx

@@ -1,12 +1,12 @@
 import { openExternalUrl, type PluginWorkspacePanelProps, useRpc } from "@getpaseo/plugin/client";
-import { copyText, Icon, useToast } from "@getpaseo/plugin/client/ui";
-import React from "react";
+import { copyText, Icon, Markdown, useToast } from "@getpaseo/plugin/client/ui";
+import React, { createRef, type RefObject } from "react";
 import { Platform, Text, View } from "react-native";
-import { type Attachment, attachmentIcon, canPreview, opensAsPage, shortName } from "../shared/attachments";
-import { openPage } from "./page-opener";
+import { type Attachment, attachmentIcon, canPreview, isFolder, isPage, opensOnHost, shortName } from "../shared/attachments";
+import { localLinkTarget } from "../shared/markdown";
 import { errorText } from "./errors";
 import { PressableRow } from "./row";
-import { canOpenOnHost, openDeliverable } from "../shared/rpc";
+import { openDeliverable } from "../shared/rpc";
 import { useProgressLanguage } from "./language";
 
 export { type Attachment, attachmentIcon, deliverableAttachment, questionAttachments, shortName, ticketSourceAttachment } from "../shared/attachments";
@@ -19,6 +19,12 @@ export function isPreviewable(attachment: Attachment): boolean {
   return canPreview(attachment, { browser: Platform.OS === "web" });
 }
 
+// Whether Open hands it to the host's default app. The server makes the same
+// check on the file itself.
+export function isHostOpenable(attachment: Attachment): boolean {
+  return Boolean(attachment.path) && !isFolder(attachment) && opensOnHost(attachment.path!);
+}
+
 // Full path on the daemon host for a stored path. `root` is the worktree
 // root the dashboard was read from, not the workspace directory.
 export function absolutePath(path: string, root: string): string {
@@ -27,7 +33,12 @@ export function absolutePath(path: string, root: string): string {
   return path === "./" ? `${base}/` : `${base}/${path}`;
 }
 
-export function useAttachmentOpener({ workspaceId, workspaceDirectory, navigation, onPreview }: {
+export function useAttachmentOpener({
+  workspaceId,
+  workspaceDirectory,
+  navigation,
+  onPreview,
+}: {
   workspaceId: string;
   workspaceDirectory: string;
   navigation?: Navigation;
@@ -36,7 +47,6 @@ export function useAttachmentOpener({ workspaceId, workspaceDirectory, navigatio
   const { messages: m } = useProgressLanguage();
   const toast = useToast();
   const openOnHostRpc = useRpc(openDeliverable);
-  const checkHost = useRpc(canOpenOnHost);
   async function copyPath(attachment: Attachment, prefix = "") {
     try {
       await copyText(absolutePath(attachment.path!, workspaceDirectory));
@@ -63,44 +73,128 @@ export function useAttachmentOpener({ workspaceId, workspaceDirectory, navigatio
       }
       return;
     }
-    // A page opens on the computer holding it, like a double-click, and in
-    // Paseo only where that computer has no screen to open it on.
-    if (openPage && opensAsPage(attachment, { browser: Platform.OS === "web" }) && !(await checkHost({ workspaceId, workspaceDirectory }).then((result) => result.canOpen, () => false))) {
-      openPage({ workspaceId, workspaceDirectory, ref: attachment.ref, title: attachment.title });
-      return;
-    }
+    // A page's row is a link to it, which already opened it in a tab.
+    if (isPage(attachment)) return;
     if (onPreview && isPreviewable(attachment)) {
       onPreview(attachment);
       return;
     }
-    await openOnHost(attachment);
+    if (isHostOpenable(attachment)) await openOnHost(attachment);
+    else await copyPath(attachment, `${m.openRefused}. `);
   }
   return { open, openOnHost, copyPath };
 }
 
 export const ATTACHMENT_ROW = { gap: 2, paddingVertical: 3, lineHeight: 17 };
 
+const PAGE_LINK_FILL = Array(200).fill("████").join(" ");
+
+// A Paseo Markdown link to a local file is the only way a plugin can open a tab,
+// so a page's row holds a link to the page. On a phone the link covers the row,
+// almost clear, because iOS ignores a view under 1% opaque. In a browser it stays
+// hidden and the row clicks it, so the row stays one keyboard stop.
+export function PageLink({ link, path }: { link: RefObject<View | null>; path: string }) {
+  const target = localLinkTarget(path);
+  if (Platform.OS === "web") {
+    return (
+      <View ref={link} style={{ display: "none" }}>
+        <Markdown>{`[page](${target})`}</Markdown>
+      </View>
+    );
+  }
+  return (
+    <View style={{ position: "absolute", top: 0, bottom: 0, start: 0, end: 0, overflow: "hidden", opacity: 0.011 }}>
+      <Markdown>{`[${PAGE_LINK_FILL}](${target})`}</Markdown>
+    </View>
+  );
+}
+
+// The plugin compiles without the DOM's types.
+type LinkElement = { querySelector(selector: string): { click(): void } | null };
+let clickingPageLink = false;
+
+// Opens a page row's link from the row's press, and is false for the press that
+// click sends back to the row, which the first one already handled. On a phone
+// the press landed on the link itself.
+export function followPageLink(link: RefObject<View | null>): boolean {
+  if (Platform.OS !== "web") return true;
+  if (clickingPageLink) return false;
+  clickingPageLink = true;
+  try {
+    (link.current as unknown as LinkElement | null)?.querySelector("a")?.click();
+  } finally {
+    clickingPageLink = false;
+  }
+  return true;
+}
+
+export function pageLinkRef(attachment: Attachment): RefObject<View | null> | null {
+  return isPage(attachment) ? createRef<View>() : null;
+}
+
 // A question's attachments as pressable rows.
 // Drawn in dialogs and the popover (surface1) unless `onSurface1` is false.
 // `onOpen` also gets the whole list, so a preview can step through its siblings.
-export function AttachmentList({ colors, attachments, onOpen, onSurface1 = true }: { colors: Colors; attachments: Attachment[]; onOpen(attachment: Attachment, group: Attachment[]): void; onSurface1?: boolean }) {
+// `root` is the worktree root their paths are relative to.
+export function AttachmentList({
+  colors,
+  attachments,
+  root,
+  onOpen,
+  onSurface1 = true,
+}: {
+  colors: Colors;
+  attachments: Attachment[];
+  root: string;
+  onOpen(attachment: Attachment, group: Attachment[]): void;
+  onSurface1?: boolean;
+}) {
   const { messages: m } = useProgressLanguage();
   if (!attachments.length) return null;
   return (
     <View style={{ gap: ATTACHMENT_ROW.gap }}>
-      {attachments.map((attachment) => (
-        <PressableRow key={attachment.ref} colors={colors} onSurface1={onSurface1} accessibilityRole={attachment.url ? "link" : "button"} accessibilityLabel={m.openItem(attachment.title)}
-          onPress={() => onOpen(attachment, attachments)}
-          style={{ flexDirection: "row", gap: 6, alignItems: "center", paddingVertical: ATTACHMENT_ROW.paddingVertical, paddingHorizontal: 4, marginHorizontal: -4, borderRadius: 4 }}>
-          {/* A 14px slot, like a section icon, so the title lines up with the heading above. */}
-          <View style={{ width: 14, alignItems: "center" }}><Icon name={attachmentIcon(attachment)} size={12} color={colors.foregroundMuted} /></View>
-          {/* The row is the target, so nothing in it is styled as a link. */}
-          <Text numberOfLines={1} style={{ flexShrink: 1, color: colors.foreground, fontSize: 12, lineHeight: ATTACHMENT_ROW.lineHeight }}>{attachment.title}</Text>
-          {shortName(attachment) !== attachment.title ? (
-            <Text numberOfLines={1} style={{ flex: 1, minWidth: 0, color: colors.foregroundMuted, fontSize: 11, lineHeight: 16 }}>{shortName(attachment)}</Text>
-          ) : <View style={{ flex: 1 }} />}
-        </PressableRow>
-      ))}
+      {attachments.map((attachment) => {
+        const link = pageLinkRef(attachment);
+        return (
+          <PressableRow
+            key={attachment.ref}
+            colors={colors}
+            onSurface1={onSurface1}
+            accessibilityRole={attachment.url ? "link" : "button"}
+            accessibilityLabel={m.openItem(attachment.title)}
+            onPress={() => {
+              if (link && !followPageLink(link)) return;
+              onOpen(attachment, attachments);
+            }}
+            style={{
+              flexDirection: "row",
+              gap: 6,
+              alignItems: "center",
+              paddingVertical: ATTACHMENT_ROW.paddingVertical,
+              paddingHorizontal: 4,
+              marginHorizontal: -4,
+              borderRadius: 4,
+            }}
+          >
+            {/* A 14px slot, like a section icon, so the title lines up with the heading above. */}
+            <View style={{ width: 14, alignItems: "center" }}>
+              <Icon name={attachmentIcon(attachment)} size={12} color={colors.foregroundMuted} />
+            </View>
+            {/* The row is the target, so nothing in it is styled as a link. */}
+            <Text numberOfLines={1} style={{ flexShrink: 1, color: colors.foreground, fontSize: 12, lineHeight: ATTACHMENT_ROW.lineHeight }}>
+              {attachment.title}
+            </Text>
+            {shortName(attachment) !== attachment.title ? (
+              <Text numberOfLines={1} style={{ flex: 1, minWidth: 0, color: colors.foregroundMuted, fontSize: 11, lineHeight: 16 }}>
+                {shortName(attachment)}
+              </Text>
+            ) : (
+              <View style={{ flex: 1 }} />
+            )}
+            {link ? <PageLink link={link} path={absolutePath(attachment.path!, root)} /> : null}
+          </PressableRow>
+        );
+      })}
     </View>
   );
 }

package/client/blocks.tsx

@@ -11,7 +11,11 @@ export function BlockView({ colors, block, first }: { colors: Colors; block: Blo
     case "heading":
       return (
         // A step under the section's own 13px title: smaller and muted, set apart from the body by weight.
-        <Text accessibilityRole="header" selectable style={{ color: colors.foregroundMuted, fontSize: 12, lineHeight: 17, fontWeight: "600", marginTop: first ? 0 : 6 }}>
+        <Text
+          accessibilityRole="header"
+          selectable
+          style={{ color: colors.foregroundMuted, fontSize: 12, lineHeight: 17, fontWeight: "600", marginTop: first ? 0 : 6 }}
+        >
           <Spans colors={colors} spans={block.spans} />
         </Text>
       );
@@ -19,23 +23,44 @@ export function BlockView({ colors, block, first }: { colors: Colors; block: Blo
       return (
         <View style={{ flexDirection: "row", gap: 6, paddingStart: block.depth * 14 }}>
           <Text style={{ minWidth: 10, color: colors.foregroundMuted, fontSize: 13, lineHeight: 19, fontVariant: ["tabular-nums"] }}>{block.marker}</Text>
-          <Text selectable style={{ flex: 1, color: colors.foreground, fontSize: 13, lineHeight: 19 }}><Spans colors={colors} spans={block.spans} /></Text>
+          <Text selectable style={{ flex: 1, color: colors.foreground, fontSize: 13, lineHeight: 19 }}>
+            <Spans colors={colors} spans={block.spans} />
+          </Text>
         </View>
       );
     case "code":
       return (
         <View style={{ padding: 8, borderRadius: 6, backgroundColor: colors.surface0 }}>
-          <Text selectable style={{ color: colors.foreground, fontFamily: MONO, fontSize: 12, lineHeight: 18 }}>{block.text}</Text>
+          <Text selectable style={{ color: colors.foreground, fontFamily: MONO, fontSize: 12, lineHeight: 18 }}>
+            {block.text}
+          </Text>
         </View>
       );
     default:
-      return <Text selectable style={{ color: colors.foreground, fontSize: 13, lineHeight: 19 }}><Spans colors={colors} spans={block.spans} /></Text>;
+      return (
+        <Text selectable style={{ color: colors.foreground, fontSize: 13, lineHeight: 19 }}>
+          <Spans colors={colors} spans={block.spans} />
+        </Text>
+      );
   }
 }
 
 export function Spans({ colors, spans }: { colors: Colors; spans: Span[] }) {
-  return <>{spans.map((span, index) => span.code
-    ? <Text key={index} style={{ fontFamily: MONO, fontSize: 12, color: colors.foreground }}>{span.text}</Text>
-    : span.strong ? <Text key={index} style={{ fontWeight: "600" }}>{span.text}</Text>
-    : <React.Fragment key={index}>{span.text}</React.Fragment>)}</>;
+  return (
+    <>
+      {spans.map((span, index) =>
+        span.code ? (
+          <Text key={index} style={{ fontFamily: MONO, fontSize: 12, color: colors.foreground }}>
+            {span.text}
+          </Text>
+        ) : span.strong ? (
+          <Text key={index} style={{ fontWeight: "600" }}>
+            {span.text}
+          </Text>
+        ) : (
+          <React.Fragment key={index}>{span.text}</React.Fragment>
+        ),
+      )}
+    </>
+  );
 }

package/client/chat-row-view.tsx

@@ -24,9 +24,15 @@ export function ChatRowView({ item, theme }: PluginTimelineItemProps<ChatRow>) {
   const active = more !== null && (hovered || expanded);
   const iconColor = failed ? colors.statusDanger : active ? colors.foreground : colors.foregroundMuted;
 
-  const icon = active
-    ? <View style={{ marginLeft: -4, transform: [{ scale: 1.3 }, { rotate: expanded ? "90deg" : "0deg" }] }}><Icon name="ChevronRight" size={12} color={colors.foreground} /></View>
-    : <View style={{ marginLeft: -1, opacity: failed ? 0.8 : 1 }}><Icon name={failed ? "TriangleAlert" : "ListChecks"} size={12} color={iconColor} /></View>;
+  const icon = active ? (
+    <View style={{ marginLeft: -4, transform: [{ scale: 1.3 }, { rotate: expanded ? "90deg" : "0deg" }] }}>
+      <Icon name="ChevronRight" size={12} color={colors.foreground} />
+    </View>
+  ) : (
+    <View style={{ marginLeft: -1, opacity: failed ? 0.8 : 1 }}>
+      <Icon name={failed ? "TriangleAlert" : "ListChecks"} size={12} color={iconColor} />
+    </View>
+  );
 
   return (
     <View style={{ marginHorizontal: -13 }}>
@@ -66,10 +72,17 @@ export function ChatRowView({ item, theme }: PluginTimelineItemProps<ChatRow>) {
         </Text>
       </Pressable>
       {open ? (
-        <View style={{ borderWidth: 1, borderTopWidth: 0, borderColor: colors.border, borderBottomLeftRadius: 8, borderBottomRightRadius: 8, overflow: "hidden" }}>
+        <View
+          style={{ borderWidth: 1, borderTopWidth: 0, borderColor: colors.border, borderBottomLeftRadius: 8, borderBottomRightRadius: 8, overflow: "hidden" }}
+        >
           {/* Scrolling past the end stays in the output instead of moving the chat. */}
-          <ScrollView style={[{ maxHeight: 320 }, Platform.OS === "web" ? ({ overscrollBehavior: "contain" } as object) : null]} contentContainerStyle={{ paddingHorizontal: 12, paddingVertical: 8 }}>
-            <Text selectable style={{ color: failed ? colors.statusDanger : colors.foreground, fontFamily: mono(), fontSize: 12, lineHeight: 18 }}>{more}</Text>
+          <ScrollView
+            style={[{ maxHeight: 320 }, Platform.OS === "web" ? ({ overscrollBehavior: "contain" } as object) : null]}
+            contentContainerStyle={{ paddingHorizontal: 12, paddingVertical: 8 }}
+          >
+            <Text selectable style={{ color: failed ? colors.statusDanger : colors.foreground, fontFamily: mono(), fontSize: 12, lineHeight: 18 }}>
+              {more}
+            </Text>
           </ScrollView>
         </View>
       ) : null}

package/client/chat-row.ts

@@ -63,12 +63,23 @@ export function transformChatRow({ item }: { item: ToolCall }) {
   return data && { items: [{ type: "plugin" as const, kind: CHAT_ROW_KIND, version: CHAT_ROW_VERSION, data }] };
 }
 
+function firstLine(text: string): string {
+  return (
+    text
+      .split("\n")
+      .map((line) => line.trim())
+      .find(Boolean) ?? ""
+  );
+}
+
+function withMore(line: string, text: string): { line: string; more: string | null } {
+  return { line, more: text.trim() || null };
+}
+
 // What the row says: one line, and the full text the row opens to. The line
 // truncates on a narrow chat, so any text at all can be opened.
 export function chatRowText(row: ChatRow, m: ProgressMessages): { line: string; more: string | null } {
   const labels = m.toolRow[row.tool];
-  const firstLine = (text: string) => text.split("\n").map((line) => line.trim()).find(Boolean) ?? "";
-  const withMore = (line: string, text: string) => ({ line, more: text.trim() || null });
   switch (row.state) {
     case "running":
       return { line: labels.running, more: null };

package/client/dashboard-query.ts

@@ -9,13 +9,19 @@ export const POLL_MS = 3_000;
 
 // `previous` is what the cache already holds. Polls send its version, and an
 // "unchanged" reply keeps that same object, so nothing re-renders.
-export function dashboardQueryOptions(fetchDashboard: FetchDashboard, hostId: string, workspaceId: string, directory: string | null, previous?: () => DashboardResult | undefined) {
+export function dashboardQueryOptions(
+  fetchDashboard: FetchDashboard,
+  hostId: string,
+  workspaceId: string,
+  directory: string | null,
+  previous?: () => DashboardResult | undefined,
+) {
   return {
     queryKey: ["progress", "dashboard", hostId, workspaceId, directory],
     queryFn: async (): Promise<DashboardResult> => {
       const last = previous?.();
       const result = await fetchDashboard({ workspaceId, workspaceDirectory: directory!, ...(last ? { since: last.version } : {}) });
-      return "unchanged" in result && last ? last : result as DashboardResult;
+      return "unchanged" in result && last ? last : (result as DashboardResult);
     },
     enabled: Boolean(directory),
     staleTime: POLL_MS,
@@ -26,7 +32,6 @@ export function dashboardQueryOptions(fetchDashboard: FetchDashboard, hostId: st
 export function useDashboard(hostId: string, workspaceId: string, directory: string | null) {
   const fetchDashboard = useRpc(getDashboard);
   const queryClient = useQueryClient();
-  const options = dashboardQueryOptions(fetchDashboard, hostId, workspaceId, directory,
-    () => queryClient.getQueryData<DashboardResult>(options.queryKey));
+  const options = dashboardQueryOptions(fetchDashboard, hostId, workspaceId, directory, () => queryClient.getQueryData<DashboardResult>(options.queryKey));
   return useQuery(options);
 }

package/client/deliverables.tsx

@@ -5,7 +5,17 @@ import { Platform, Text, View } from "react-native";
 import type { Deliverable } from "../shared/dashboard";
 import { opensInTab } from "../shared/attachments";
 import { localLinkTarget } from "../shared/markdown";
-import { type Attachment, absolutePath, attachmentIcon, deliverableAttachment, shortName, useAttachmentOpener } from "./attachments";
+import {
+  type Attachment,
+  absolutePath,
+  attachmentIcon,
+  deliverableAttachment,
+  followPageLink,
+  PageLink,
+  pageLinkRef,
+  shortName,
+  useAttachmentOpener,
+} from "./attachments";
 import { formatClientAgo } from "./i18n";
 import { PressScale } from "./motion";
 import { StackedDialog } from "./dialog-stack";
@@ -24,7 +34,14 @@ const BUTTON_PAIR_GAP = 4;
 const TAP_AREA_FILL = Array(8).fill("████").join(" ");
 
 // The Deliverables tab: newest first, 10 at a time (see usePaged).
-export function DeliverablesList({ colors, deliverables, now, workspaceId, workspaceDirectory, navigation }: {
+export function DeliverablesList({
+  colors,
+  deliverables,
+  now,
+  workspaceId,
+  workspaceDirectory,
+  navigation,
+}: {
   colors: Colors;
   now: number;
   deliverables: Deliverable[];
@@ -41,56 +58,104 @@ export function DeliverablesList({ colors, deliverables, now, workspaceId, works
       {paged.shown.map((deliverable, index) => {
         const attachment = deliverableAttachment(deliverable);
         const tab = opensInTab(attachment, { platform: Platform.OS });
+        const link = pageLinkRef(attachment);
         return (
-          <PressableRow key={deliverable.id} colors={colors} accessibilityRole={deliverable.url ? "link" : "button"}
+          <PressableRow
+            key={deliverable.id}
+            colors={colors}
+            accessibilityRole={deliverable.url ? "link" : "button"}
             accessibilityLabel={m.openItem(deliverable.title)}
-            onPress={() => void open(attachment)}
-            style={{ flexDirection: "row", gap: ROW_GAP, paddingHorizontal: 10, paddingVertical: 8, borderTopWidth: index ? 1 : 0, borderTopColor: colors.border }}>
+            onPress={() => {
+              if (link && !followPageLink(link)) return;
+              void open(attachment);
+            }}
+            style={{
+              flexDirection: "row",
+              gap: ROW_GAP,
+              paddingHorizontal: 10,
+              paddingVertical: 8,
+              borderTopWidth: index ? 1 : 0,
+              borderTopColor: colors.border,
+            }}
+          >
             {/* Optical: centers the 14px icon on the 18px title line. */}
-            <View style={{ paddingTop: 2 }}><Icon name={attachmentIcon(attachment)} size={14} color={colors.foregroundMuted} /></View>
+            <View style={{ paddingTop: 2 }}>
+              <Icon name={attachmentIcon(attachment)} size={14} color={colors.foregroundMuted} />
+            </View>
             <View style={{ flex: 1, minWidth: 0, gap: 1 }}>
               {/* What the agent found is the headline; the row itself is what opens. */}
-              <Text numberOfLines={3} style={{ color: colors.foreground, fontSize: 13, lineHeight: 18 }}>{deliverable.title}</Text>
+              <Text numberOfLines={3} style={{ color: colors.foreground, fontSize: 13, lineHeight: 18 }}>
+                {deliverable.title}
+              </Text>
               {/* Just the name, ticket and age. The full path is one press of Copy away. */}
               <Text numberOfLines={1} style={{ color: colors.foregroundMuted, fontSize: 12, lineHeight: 17 }}>
-                {[shortName(attachment), deliverable.ticketLabel ?? deliverable.ticketId, formatClientAgo(locale, deliverable.addedAt, now)].filter(Boolean).join(" · ")}
+                {[shortName(attachment), deliverable.ticketLabel ?? deliverable.ticketId, formatClientAgo(locale, deliverable.addedAt, now)]
+                  .filter(Boolean)
+                  .join(" · ")}
               </Text>
             </View>
+            {/* Under Copy, so Copy still takes its own presses. */}
+            {link ? <PageLink link={link} path={absolutePath(deliverable.path!, workspaceDirectory)} /> : null}
             {tab ? (
               <TabButton colors={colors} label={m.openInTab(deliverable.title)} target={localLinkTarget(absolutePath(deliverable.path!, workspaceDirectory))} />
             ) : null}
             {deliverable.path ? (
               // Optical: the 22px button centers on the 18px title line.
-              <PressScale accessibilityRole="button" accessibilityLabel={m.copyItemPath(deliverable.title)}
-                hitSlop={tab ? { top: 6, bottom: 6, left: BUTTON_PAIR_GAP / 2, right: 6 } : 6} outerStyle={{ marginTop: -2 }}
+              <PressScale
+                accessibilityRole="button"
+                accessibilityLabel={m.copyItemPath(deliverable.title)}
+                hitSlop={tab ? { top: 6, bottom: 6, left: BUTTON_PAIR_GAP / 2, right: 6 } : 6}
+                outerStyle={{ marginTop: -2 }}
                 onPress={() => void copyPath(attachment)}
                 // A step above the row's own hover tint (surface1), so it reads as its own target.
-                style={({ pressed, hovered }) => ({ padding: 4, borderRadius: 4, backgroundColor: pressed ? colors.border : hovered ? colors.surface2 : "transparent" })}>
+                style={({ pressed, hovered }) => ({
+                  padding: 4,
+                  borderRadius: 4,
+                  backgroundColor: pressed ? colors.border : hovered ? colors.surface2 : "transparent",
+                })}
+              >
                 <Icon name="Copy" size={14} color={colors.foregroundMuted} />
               </PressScale>
             ) : (
-              <View style={{ paddingTop: 2 }}><Icon name="ExternalLink" size={14} color={colors.foregroundMuted} /></View>
+              <View style={{ paddingTop: 2 }}>
+                <Icon name="ExternalLink" size={14} color={colors.foregroundMuted} />
+              </View>
             )}
           </PressableRow>
         );
       })}
       <ShowMoreRow colors={colors} total={deliverables.length} paged={paged} />
-      <StackedDialog colors={colors} now={now} onClose={() => setPreviewing(null)} context={{ workspaceId, workspaceDirectory, navigation }}
-        root={previewing ? { kind: "preview", attachment: previewing, group: galleryFiles(deliverables.map(deliverableAttachment)), fullScreen: false } : null} />
+      <StackedDialog
+        colors={colors}
+        now={now}
+        onClose={() => setPreviewing(null)}
+        context={{ workspaceId, workspaceDirectory, navigation }}
+        root={previewing ? { kind: "preview", attachment: previewing, group: galleryFiles(deliverables.map(deliverableAttachment)), fullScreen: false } : null}
+      />
     </View>
   );
 }
 
+function keepPressFromRow() {}
+
 // A Paseo Markdown link to a local file is the only way a plugin can open a tab.
 // A browser sends touches to a clear view; iOS ignores a view under 1% opaque.
 function TabButton({ colors, label, target }: { colors: Colors; label: string; target: string }) {
   const linkTakesFocus = Platform.OS === "web";
-  const keepPressFromRow = () => {};
   return (
-    <PressScale accessibilityRole="button" accessibilityLabel={label} focusable={!linkTakesFocus}
+    <PressScale
+      accessibilityRole="button"
+      accessibilityLabel={label}
+      focusable={!linkTakesFocus}
       outerStyle={{ marginTop: -2, marginEnd: BUTTON_PAIR_GAP - ROW_GAP, alignSelf: "flex-start" }}
       onPress={keepPressFromRow}
-      style={({ pressed, hovered }) => ({ padding: 4, borderRadius: 4, overflow: "hidden", backgroundColor: pressed ? colors.border : hovered ? colors.surface2 : "transparent" })}>
+      style={({ pressed, hovered }) => ({
+        padding: 4,
+        borderRadius: 4,
+        overflow: "hidden",
+        backgroundColor: pressed ? colors.border : hovered ? colors.surface2 : "transparent",
+      })}
+    >
       <Icon name="Maximize2" size={14} color={colors.foregroundMuted} />
       <View style={{ position: "absolute", top: -24, start: -24, width: 72, height: 72, opacity: Platform.OS === "web" ? 0 : 0.011 }}>
         <Markdown>{`[${TAP_AREA_FILL}](${target})`}</Markdown>