@stevecastaneda/paseo-progress 0.1.7 → 0.2.0

package/README.md

@@ -1,6 +1,6 @@
 # Progress
 
-A plugin for Paseo 0.9 and later that gives each worktree a live progress dashboard. Agents record progress with the `paseo-progress` command, which adds one line per change to `.scratch/progress.jsonl` in the worktree. The **Progress** panel draws the dashboard from that file and updates by itself.
+A plugin for Paseo 0.9 and later that gives each worktree a live progress dashboard. Agents record progress with the `paseo-progress` command, which adds one line per change to the worktree's progress file. That file lives outside the repo, so git never sees it. The **Progress** panel draws the dashboard from that file and updates by itself.
 
 <img src="images/1-panel.png" alt="The Progress panel in Explorer" width="400">
 
@@ -18,7 +18,7 @@ The panel lives in Explorer, beside the agent chat, so you can watch both. Open
 
 On phones, where Paseo has no Explorer pane, Progress opens as a tab of its own, and the pill stays above the message box while a run is open so there's always a way in. SVG files preview on desktop; on phones they open on the daemon host.
 
-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 `.scratch/progress-panel-opened` 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.
+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.
 
 ## Install
 
@@ -41,7 +41,19 @@ node "$([ -f "$dir/dist/server/cli.js" ] && echo "$dir/dist/server/cli.js" || ec
 
 If `paseo` isn't on your `PATH`, use `/Applications/Paseo.app/Contents/Resources/bin/paseo`. The command doesn't name a plugin folder: each run asks Paseo (`paseo plugin ls`) which copy of the plugin it is running and runs that copy, so it keeps working after updates and `npm run dev` switches. The npm package carries the command compiled to JavaScript in `dist/`, because Node won't run TypeScript from `node_modules`.
 
-The plugin keeps each worktree's progress in `.scratch/progress.jsonl`. The first time it creates `.scratch/`, it also writes `.scratch/.gitignore` naming only its own files, so git ignores them without any change to your repository's `.gitignore`. If `.scratch/.gitignore` already exists, the plugin leaves it alone.
+## Where progress is kept
+
+Each worktree's progress lives outside the repo, in its own folder under `~/.local/state/paseo-progress/` on the daemon host. There's nothing to set up and nothing to hide: git never sees these files, and the plugin never edits a `.gitignore` or git's exclude file. The panel's empty state shows the exact path.
+
+### Saving run history to the repo
+
+If you want to keep runs, at the bottom of the panel press **Save to repo…** and pick a folder (or name a new one). From then on, each run is saved as its own file there, like `history/20261001-064512-export-feature.jsonl`, and updated as the run goes. Commit them like any other file. One file per run means two branches never write the same file, so merges don't conflict. The lock and the panel marker never go there.
+
+The choice covers every worktree of the repo and is kept in the repo's local git config (`paseo-progress.saveRuns`), which nothing commits. **Change…** picks another folder for future runs; **Stop saving** turns it off. Files already saved are never moved or deleted.
+
+### Upgrading from 0.1.x
+
+Earlier versions kept progress in `.scratch/` in each worktree, hidden by a `.scratch/.gitignore` they wrote. The first time the command or the panel touches a worktree after the upgrade, the plugin moves its files out of `.scratch/` and removes that `.gitignore` if it's exactly the one the plugin wrote. If `.scratch/` is then empty, it goes too; anything else you keep there stays. If git tracks the old progress file (for example, an agent committed it), the plugin leaves it where it is and keeps using it, so nothing changes in that repo.
 
 ## Agent skill
 
@@ -86,13 +98,14 @@ paseo-progress finish "Snapshots ship for all four tables"
 
 ## The progress file
 
-`.scratch/progress.jsonl` holds one JSON event per line, each with a version (`v`), a UTC timestamp (`ts`) from the real clock, and a `type`. It is only ever appended to, so you can read or diff the history. A half-written last line is ignored. Other bad lines are skipped and listed in a small notice in the panel while the rest still renders. A lock keeps two commands from writing at once or handing out the same id.
+The progress file, `progress.jsonl`, holds one JSON event per line, each with a version (`v`), a UTC timestamp (`ts`) from the real clock, and a `type`. It is only ever appended to, so you can read or diff the history. A half-written last line is ignored. Other bad lines are skipped and listed in a small notice in the panel while the rest still renders. A lock keeps two commands from writing at once or handing out the same id.
 
 ## Limitations
 
 - Nothing updates unless the agent runs `paseo-progress`. Agents need the skill, and an agent that skips the command leaves the dashboard behind.
 - The command runs on the machine that hosts the Paseo daemon, and it needs Node.js 22.18 or later there.
-- Each worktree keeps its own dashboard in `.scratch/progress.jsonl`. There's no view across worktrees.
+- Each worktree keeps its own dashboard. There's no view across worktrees.
+- 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 and the first 256 KB of a text file. Other files open in their default app.

package/client/attachments.tsx

@@ -16,10 +16,11 @@ export function isPreviewable(attachment: Attachment): boolean {
   return canPreview(attachment, { browser: Platform.OS === "web" });
 }
 
-// Full path on the daemon host for a stored path.
-export function absolutePath(path: string, workspaceDirectory: string): string {
+// 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 {
   if (path.startsWith("/") || /^[A-Za-z]:[\\/]/.test(path)) return path;
-  const base = workspaceDirectory.replace(/[\\/]+$/, "");
+  const base = root.replace(/[\\/]+$/, "");
   return path === "./" ? `${base}/` : `${base}/${path}`;
 }
 

package/client/history.tsx

@@ -0,0 +1,157 @@
+import { type PluginWorkspacePanelProps, useRpc } from "@getpaseo/plugin/client";
+import { Icon, Modal, useToast } from "@getpaseo/plugin/client/react-native";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import React, { useState } from "react";
+import { ActivityIndicator, ScrollView, Text, TextInput, View } from "react-native";
+import { PressScale } from "./motion";
+import { PressableRow } from "./row";
+import { listFolders, setHistoryFolder } from "../shared/rpc";
+
+type Colors = PluginWorkspacePanelProps["theme"]["colors"];
+
+// Run history stays on this computer unless the repo opts in. This quiet row
+// is the only place that changes it; nothing in the repo changes until then.
+export function HistoryRow({ colors, workspaceId, directory, savedTo }: {
+  colors: Colors;
+  workspaceId: string;
+  directory: string;
+  savedTo: string | null;
+}) {
+  const [picking, setPicking] = useState(false);
+  const set = useRpc(setHistoryFolder);
+  const queryClient = useQueryClient();
+  const toast = useToast();
+  const mutation = useMutation({
+    mutationFn: (folder: string | null) => set({ workspaceId, workspaceDirectory: directory, folder }),
+    onSuccess: ({ savedTo: next }) => {
+      queryClient.invalidateQueries({ queryKey: ["progress", "dashboard"] });
+      toast.show(next ? `Each run will be saved to ${next}.` : "Runs will stay on this computer. Files already saved stay in the repo.", { variant: "success" });
+    },
+    onError: (error) => toast.error(error instanceof Error ? error.message : "Could not change where runs are saved."),
+  });
+  // While saving, the button that started it says so.
+  const busy = mutation.isPending ? (mutation.variables === null ? "stop" : "pick") : null;
+  const actions: { label: string; busyLabel: string; kind: "pick" | "stop"; onPress(): void }[] = savedTo
+    ? [{ label: "Change…", busyLabel: "Saving…", kind: "pick", onPress: () => setPicking(true) }, { label: "Stop saving", busyLabel: "Stopping…", kind: "stop", onPress: () => mutation.mutate(null) }]
+    : [{ label: "Save to repo…", busyLabel: "Saving…", kind: "pick", onPress: () => setPicking(true) }];
+
+  return (
+    <View style={{ flexDirection: "row", flexWrap: "wrap", alignItems: "center", columnGap: 8, rowGap: 4, marginHorizontal: 12, marginTop: 16 }}>
+      <View style={{ flexDirection: "row", alignItems: "flex-start", gap: 6, flex: 1, minWidth: 180 }}>
+        <View style={{ paddingTop: 2 }}><Icon name="History" size={13} color={colors.foregroundMuted} /></View>
+        <Text style={{ flex: 1, color: colors.foregroundMuted, fontSize: 12, lineHeight: 17 }}>
+          {savedTo ? <>Each run is saved to <Text style={{ color: colors.foreground }}>{savedTo}</Text> in this repo.</> : "Run history stays on this computer."}
+        </Text>
+      </View>
+      <View style={{ flexDirection: "row", gap: 4 }}>
+        {actions.map((action) => (
+          <PressScale key={action.label} accessibilityRole="button" disabled={mutation.isPending} onPress={action.onPress}
+            style={({ pressed, hovered }) => ({ paddingHorizontal: 8, paddingVertical: 4, borderRadius: 4, opacity: mutation.isPending ? 0.7 : 1,
+              backgroundColor: pressed ? colors.border : hovered ? colors.surface2 : "transparent" })}>
+            <Text style={{ color: colors.foreground, fontSize: 12, lineHeight: 16, fontWeight: "600" }}>{busy === action.kind ? action.busyLabel : action.label}</Text>
+          </PressScale>
+        ))}
+      </View>
+      <FolderPicker key={picking ? "open" : "closed"} colors={colors} workspaceId={workspaceId} directory={directory} open={picking} start={savedTo ?? ""}
+        onClose={() => setPicking(false)} onPick={(folder) => { setPicking(false); mutation.mutate(folder); }} />
+    </View>
+  );
+}
+
+// Browses the repo's folders on the daemon host. A new folder only needs a
+// name: it's made the first time a run is saved there.
+function FolderPicker({ colors, workspaceId, directory, open, start, onClose, onPick }: {
+  colors: Colors;
+  workspaceId: string;
+  directory: string;
+  open: boolean;
+  // The folder chosen so far; browsing starts in the folder that holds it.
+  start: string;
+  onClose(): void;
+  onPick(folder: string): void;
+}) {
+  const parentOf = (path: string) => path.split("/").slice(0, -1).join("/");
+  const [at, setAt] = useState(() => parentOf(start));
+  const [naming, setNaming] = useState<string | null>(null);
+  const list = useRpc(listFolders);
+  const listed = useQuery({
+    queryKey: ["progress", "folders", workspaceId, directory, at],
+    queryFn: () => list({ workspaceId, workspaceDirectory: directory, folder: at }),
+    enabled: open,
+  });
+  const join = (name: string) => (at ? `${at}/${name}` : name);
+  const crumbs = at ? at.split("/") : [];
+  const close = () => { setNaming(null); setAt(parentOf(start)); onClose(); };
+  const newName = naming?.trim().replace(/\/+$/, "") ?? "";
+
+  return (
+    <Modal title="Save run history to a folder" icon={<Icon name="FolderOpen" size={16} color={colors.foregroundMuted} />} open={open} onOpenChange={(next) => { if (!next) close(); }}>
+      {/* Paseo sizes a non-scrolling dialog to 85% of the window, so let it size to
+          its content; the list's own height cap keeps the buttons in view. */}
+      <Modal.Content>
+        <Text style={{ color: colors.foregroundMuted, fontSize: 12, lineHeight: 17 }}>
+          Each run becomes its own file in this folder, in every worktree of this repo. Commit them like any other file.
+        </Text>
+        <View style={{ flexDirection: "row", flexWrap: "wrap", alignItems: "center", gap: 2, paddingHorizontal: 4 }}>
+          {["Top of the repo", ...crumbs].map((crumb, index) => (
+            <React.Fragment key={index}>
+              {index ? <Icon name="ChevronRight" size={12} color={colors.foregroundMuted} /> : null}
+              <PressScale accessibilityRole="button" disabled={index === crumbs.length} onPress={() => { setNaming(null); setAt(crumbs.slice(0, index).join("/")); }}
+                style={({ pressed, hovered }) => ({ paddingHorizontal: 4, paddingVertical: 2, borderRadius: 4,
+                  backgroundColor: index === crumbs.length ? "transparent" : pressed ? colors.border : hovered ? colors.surface2 : "transparent" })}>
+                <Text style={{ color: index === crumbs.length ? colors.foreground : colors.foregroundMuted, fontSize: 12, lineHeight: 16, fontWeight: index === crumbs.length ? "600" : "400" }}>{crumb}</Text>
+              </PressScale>
+            </React.Fragment>
+          ))}
+        </View>
+
+        {/* Only the list scrolls, so Use and Cancel stay in view in a big repo. */}
+        <ScrollView style={{ maxHeight: 320, flexGrow: 0 }} contentContainerStyle={{ gap: 2 }}>
+          {listed.isPending ? <ActivityIndicator color={colors.foregroundMuted} accessibilityLabel="Loading folders" style={{ alignSelf: "flex-start", padding: 8 }} /> : null}
+          {listed.data?.folders.map((name) => (
+            <PressableRow key={name} colors={colors} accessibilityRole="button" accessibilityLabel={`Open ${name}`} onPress={() => { setNaming(null); setAt(join(name)); }}
+              style={{ flexDirection: "row", alignItems: "center", gap: 8, paddingHorizontal: 8, paddingVertical: 6, borderRadius: 6 }}>
+              <Icon name="Folder" size={14} color={colors.foregroundMuted} />
+              <Text numberOfLines={1} ellipsizeMode="middle" style={{ flex: 1, color: colors.foreground, fontSize: 12, lineHeight: 16 }}>{name}</Text>
+              <Icon name="ChevronRight" size={14} color={colors.foregroundMuted} />
+            </PressableRow>
+          ))}
+          {listed.data && !listed.data.folders.length ? (
+            <Text style={{ color: colors.foregroundMuted, fontSize: 12, lineHeight: 16, paddingHorizontal: 8, paddingVertical: 6 }}>No folders in here.</Text>
+          ) : null}
+          {listed.error ? <Text accessibilityRole="alert" style={{ color: colors.statusDanger, fontSize: 12, lineHeight: 17, paddingHorizontal: 8 }}>{listed.error.message}</Text> : null}
+        </ScrollView>
+
+        {naming === null ? (
+          <PressScale accessibilityRole="button" onPress={() => setNaming("")}
+            style={({ pressed, hovered }) => ({ alignSelf: "flex-start", flexDirection: "row", alignItems: "center", gap: 6, paddingHorizontal: 8, paddingVertical: 5, borderRadius: 6, backgroundColor: pressed ? colors.border : hovered ? colors.surface2 : "transparent" })}>
+            <Icon name="FolderPlus" size={14} color={colors.foreground} />
+            <Text style={{ color: colors.foreground, fontSize: 12, lineHeight: 16, fontWeight: "600" }}>New folder</Text>
+          </PressScale>
+        ) : (
+          <View style={{ flexDirection: "row", alignItems: "center", gap: 6 }}>
+            <TextInput autoFocus value={naming} onChangeText={setNaming} onSubmitEditing={() => { if (newName) onPick(join(newName)); }}
+              autoCapitalize="none" autoCorrect={false} spellCheck={false} accessibilityLabel="New folder name" placeholder="progress-history" placeholderTextColor={colors.foregroundMuted}
+              style={{ flex: 1, color: colors.foreground, fontSize: 12, lineHeight: 16, paddingHorizontal: 8, paddingVertical: 6, borderRadius: 6, borderWidth: 1, borderColor: colors.border, backgroundColor: colors.surface1 }} />
+            <PressScale accessibilityRole="button" disabled={!newName} onPress={() => onPick(join(newName))}
+              style={({ pressed, hovered }) => ({ paddingHorizontal: 10, paddingVertical: 6, borderRadius: 6, backgroundColor: colors.accent, opacity: !newName ? 0.5 : pressed ? 0.7 : hovered ? 0.85 : 1 })}>
+              <Text style={{ color: colors.accentForeground, fontSize: 12, lineHeight: 16, fontWeight: "600" }}>Use new folder</Text>
+            </PressScale>
+          </View>
+        )}
+
+        <View style={{ flexDirection: "row", flexWrap: "wrap", alignItems: "center", justifyContent: "flex-end", gap: 8 }}>
+          {at ? null : <Text style={{ flex: 1, minWidth: 140, color: colors.foregroundMuted, fontSize: 12, lineHeight: 17 }}>Open a folder to use it, or make a new one.</Text>}
+          <PressScale accessibilityRole="button" onPress={close}
+            style={({ pressed, hovered }) => ({ paddingHorizontal: 12, paddingVertical: 6, borderRadius: 6, backgroundColor: pressed ? colors.border : hovered ? colors.surface2 : "transparent" })}>
+            <Text style={{ color: colors.foreground, fontSize: 12, lineHeight: 16, fontWeight: "600" }}>Cancel</Text>
+          </PressScale>
+          <PressScale accessibilityRole="button" disabled={!at} onPress={() => onPick(at)} outerStyle={{ flexShrink: 1 }}
+            style={({ pressed, hovered }) => ({ paddingHorizontal: 12, paddingVertical: 6, borderRadius: 6, backgroundColor: colors.accent, opacity: !at ? 0.5 : pressed ? 0.7 : hovered ? 0.85 : 1 })}>
+            <Text numberOfLines={1} ellipsizeMode="middle" style={{ color: colors.accentForeground, fontSize: 12, lineHeight: 16, fontWeight: "600" }}>{at ? `Use ${crumbs[crumbs.length - 1]}` : "Use folder"}</Text>
+          </PressScale>
+        </View>
+      </Modal.Content>
+    </Modal>
+  );
+}

package/client/panel.tsx

@@ -2,6 +2,7 @@ import { type PluginWorkspacePanelProps, useRpc, useWorkspace } from "@getpaseo/
 import { Icon } from "@getpaseo/plugin/client/react-native";
 import { DeliverablesList } from "./deliverables";
 import { LauncherBanner, SkillBanner } from "./launcher";
+import { HistoryRow } from "./history";
 import { AnsweredQuestionsList, QuestionsSection } from "./questions";
 import { Spinner, StalledPulse, WaitingDot } from "./spinner";
 import { IconSwap, Presence, StaggerRoot, nativeDriver } from "./motion";
@@ -11,7 +12,7 @@ import { When } from "./when";
 import React, { useEffect, useRef, useState } from "react";
 import { ActivityIndicator, Animated, Platform, Pressable, ScrollView, Text, View } from "react-native";
 import { finishedToFold, isFinished, shortTitle, type Activity, type Dashboard, type FileIssue, type ProgressSegment, type StuckItem, type Ticket } from "../shared/dashboard";
-import { PROGRESS_FILE, type TicketStatus } from "../shared/events";
+import type { TicketStatus } from "../shared/events";
 import { formatEstimate, formatMinutes, formatWorkDone, minutesSince } from "../shared/format";
 import { markPanelOpened } from "../shared/rpc";
 import { useDashboard } from "./dashboard-query";
@@ -51,10 +52,11 @@ function WorkspaceProgress({ theme, workspaceId, host, layout, navigation }: Plu
       <LauncherBanner colors={colors} host={host} />
       <SkillBanner colors={colors} host={host} />
       {/* Fades in like the dashboard's sections instead of popping in after the spinner. */}
-      <Presence show={Boolean(result && !result.configured)}>{result && !result.configured ? <EmptyState colors={colors} /> : null}</Presence>
+      <Presence show={Boolean(result && !result.configured)}>{result && !result.configured ? <EmptyState colors={colors} file={result.file} /> : null}</Presence>
       {/* Keyed by run: a new run starts with fresh tabs, pages and dialogs. */}
       {result?.configured ? <DashboardView key={result.dashboard.run?.startedAt ?? "none"} colors={colors} dashboard={result.dashboard} agentRunning={agentRunning} compact={layout.compact}
-        workspaceId={workspaceId} workspaceDirectory={directory ?? ""} navigation={navigation} /> : null}
+        workspaceId={workspaceId} workspaceDirectory={result.root} file={result.file} navigation={navigation} /> : null}
+      {result?.inRepo && directory ? <HistoryRow colors={colors} workspaceId={workspaceId} directory={directory} savedTo={result.savedTo} /> : null}
     </ScrollView>
   );
 }
@@ -74,7 +76,7 @@ function useMarkPanelOpened(workspaceId: string, directory: string | null, neede
   }, [needed, directory, workspaceId, mark]);
 }
 
-function EmptyState({ colors }: { colors: Colors }) {
+function EmptyState({ colors, file }: { colors: Colors; file: string }) {
   return (
     <View style={{ padding: 12, paddingTop: 20, gap: 10 }}>
       <View style={{ flexDirection: "row", alignItems: "center", gap: 8 }}>
@@ -91,9 +93,9 @@ function EmptyState({ colors }: { colors: Colors }) {
           {`paseo-progress start "Build the export feature"\npaseo-progress ticket add "Ticket 01: Export button" --estimate 60`}
         </Text>
       </View>
-      {/* So a new .scratch folder in the repo isn't a surprise. */}
+      {/* So people know nothing lands in the repo. */}
       <Text style={{ color: colors.foregroundMuted, fontSize: 12, lineHeight: 18 }}>
-        Progress is saved in <Text style={{ color: colors.foreground }}>.scratch/progress.jsonl</Text> in this worktree. The plugin adds a <Text style={{ color: colors.foreground }}>.gitignore</Text> there, so git leaves its files alone.
+        Progress is saved outside the repo, in <Text selectable style={{ color: colors.foreground }}>{file}</Text>, so git never sees it.
       </Text>
     </View>
   );
@@ -122,13 +124,14 @@ function useNow(intervalMs: number): number {
 
 const WIDE_MIN = 760;
 
-function DashboardView({ colors, dashboard, agentRunning, compact, workspaceId, workspaceDirectory, navigation }: {
+function DashboardView({ colors, dashboard, agentRunning, compact, workspaceId, workspaceDirectory, file, navigation }: {
   colors: Colors;
   dashboard: Dashboard;
   agentRunning: boolean;
   compact: boolean;
   workspaceId: string;
   workspaceDirectory: string;
+  file: string;
   navigation: PluginWorkspacePanelProps["navigation"];
 }) {
   const now = useNow(15_000);
@@ -198,7 +201,7 @@ function DashboardView({ colors, dashboard, agentRunning, compact, workspaceId,
           </Text>
         </View>
       ) : null}</Presence>
-      <Presence show={Boolean(dashboard.issues.length)} order={1}>{dashboard.issues.length ? <IssuesNotice colors={colors} issues={dashboard.issues} /> : null}</Presence>
+      <Presence show={Boolean(dashboard.issues.length)} order={1}>{dashboard.issues.length ? <IssuesNotice colors={colors} issues={dashboard.issues} file={file} /> : null}</Presence>
       <Presence show={Boolean(dashboard.progress.totalMin > 0)} order={2}>{dashboard.progress.totalMin > 0 ? <ProgressBar colors={colors} progress={dashboard.progress} live={live} /> : null}</Presence>
       <View onLayout={(event) => setWide(event.nativeEvent.layout.width >= WIDE_MIN)}
         style={{ flexDirection: wide ? "row" : "column", alignItems: "flex-start" }}>
@@ -314,13 +317,13 @@ function ActivityList({ colors, activity, now }: { colors: Colors; activity: Act
 }
 
 // Small and non-blocking: the rest of the dashboard still renders.
-function IssuesNotice({ colors, issues }: { colors: Colors; issues: FileIssue[] }) {
+function IssuesNotice({ colors, issues, file }: { colors: Colors; issues: FileIssue[]; file: string }) {
   const shown = issues.slice(0, 5);
   return (
     <View style={{ flexDirection: "row", gap: 8, margin: 12, marginBottom: 0, padding: 8, borderRadius: 6, backgroundColor: colors.surface1 }}>
       <View style={{ paddingTop: 1.5 }}><Icon name="FileWarning" size={14} color={colors.statusWarning} /></View>
       <Text selectable style={{ flex: 1, color: colors.foregroundMuted, fontSize: 12, lineHeight: 17 }}>
-        Skipped {issues.length === 1 ? "1 line" : `${issues.length} lines`} in {PROGRESS_FILE}:{" "}
+        Skipped {issues.length === 1 ? "1 line" : `${issues.length} lines`} in {file}:{" "}
         {shown.map((issue) => `line ${issue.line} (${issue.reason})`).join(", ")}
         {issues.length > shown.length ? `, and ${issues.length - shown.length} more` : ""}.
       </Text>

package/client/pill-popover.tsx

@@ -28,12 +28,14 @@ export function AttentionPopover({ theme, host, layout, workspaceId, close, open
   const directory = useWorkspace(workspaceId, (workspace) => workspace.directory);
   const query = useDashboard(host.id, workspaceId, directory);
   const dashboard = query.data?.configured ? query.data.dashboard : null;
+  // Stored paths are relative to the worktree root, which can sit above the workspace directory.
+  const root = query.data?.root ?? directory ?? "";
   const copy = useCopy();
   // Previews open in a dialog over the popover, which stays open to return to.
   // Links and other files leave Paseo, so the popover closes for those.
   const [previewing, setPreviewing] = useState<{ attachment: Attachment; group: Attachment[] } | null>(null);
   const group = useRef<Attachment[]>([]);
-  const opener = useAttachmentOpener({ workspaceId, workspaceDirectory: directory ?? "", onPreview: (attachment) => setPreviewing({ attachment, group: previewable(group.current) }) });
+  const opener = useAttachmentOpener({ workspaceId, workspaceDirectory: root, onPreview: (attachment) => setPreviewing({ attachment, group: previewable(group.current) }) });
   return (
     <View style={{ width: 360, maxWidth: "100%", gap: 8 }}>
       {dashboard ? (
@@ -52,7 +54,7 @@ export function AttentionPopover({ theme, host, layout, workspaceId, close, open
           {query.error ? `Could not read progress: ${query.error.message}` : "Loading…"}
         </Text>
       )}
-      <PreviewDialog colors={colors} attachment={previewing?.attachment ?? null} workspaceId={workspaceId} workspaceDirectory={directory ?? ""}
+      <PreviewDialog colors={colors} attachment={previewing?.attachment ?? null} workspaceId={workspaceId} workspaceDirectory={root}
         onClose={() => setPreviewing(null)} onOpenOnHost={(attachment) => void opener.openOnHost(attachment)}
         gallery={previewing ? { items: previewing.group, onSelect: (attachment) => setPreviewing({ ...previewing, attachment }) } : undefined} />
       <View style={{ paddingTop: touch ? 12 : 8, borderTopWidth: 1, borderTopColor: colors.border }}>

package/dist/server/cli.js

@@ -1,14 +1,15 @@
 // The command agents run to record progress. Each command appends one event
 // to the worktree's progress file and prints what it recorded.
-import { existsSync, realpathSync, statSync } from "node:fs";
-import { dirname, join, relative, resolve } from "node:path";
+import { realpathSync, statSync } from "node:fs";
+import { relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { parseArgs } from "node:util";
 import { isSettled } from "../shared/dashboard.js";
-import { DELIVERABLE_KINDS, PROGRESS_FILE, TICKET_STATUSES } from "../shared/events.js";
+import { DELIVERABLE_KINDS, TICKET_STATUSES } from "../shared/events.js";
 import { appendProgress, InvalidEvent, readProgress } from "./progress-file.js";
-import { outside } from "./paths.js";
+import { findRoot, outside } from "./paths.js";
 import { installLauncher } from "./launcher.js";
+import { findStore, saveRunCopy } from "./store.js";
 import { dashboardText } from "../shared/show.js";
 import { imageMimeType } from "../shared/attachments.js";
 import { homedir } from "node:os";
@@ -426,7 +427,7 @@ function help() {
     return [
         `Usage: ${USAGE_NAME} <command>`,
         "",
-        `Records progress in ${PROGRESS_FILE} at the worktree root, shown by the Progress panel in Paseo.`,
+        `Records progress for this worktree, shown by the Progress panel in Paseo. The file lives outside the repo, so git never sees it.`,
         `Add --help after any command for its options.`,
         "",
         ...Object.values(commands).flatMap((command) => [`  ${command.usage}`, `      ${command.summary}`]),
@@ -436,19 +437,6 @@ function help() {
         `      ${INSTALL_SUMMARY}`,
     ].join("\n");
 }
-// The worktree root is the nearest directory with a `.git` entry (a folder in
-// a checkout, a file in a linked worktree). Outside git, use the directory.
-export function findRoot(cwd) {
-    let directory = resolve(cwd);
-    while (true) {
-        if (existsSync(join(directory, ".git")))
-            return directory;
-        const parent = dirname(directory);
-        if (parent === directory)
-            return resolve(cwd);
-        directory = parent;
-    }
-}
 export async function runCli(argv, options) {
     const out = options.out ?? ((line) => console.log(line));
     const now = options.now ?? (() => new Date());
@@ -464,7 +452,8 @@ export async function runCli(argv, options) {
         }
         if (first === "show") {
             const root = findRoot(options.cwd);
-            out(`Worktree: ${root}\n\n${dashboardText((await readProgress(root, now())).dashboard, now().getTime())}`);
+            const store = await findStore(root);
+            out(`Worktree: ${root}\n\n${dashboardText((await readProgress(store.directory, now())).dashboard, now().getTime())}`);
             return 0;
         }
         const target = resolve(options.cwd, (argv[1] ?? DEFAULT_LAUNCHER).replace(/^~(?=$|\/)/, homedir()));
@@ -491,14 +480,15 @@ export async function runCli(argv, options) {
             throw new UsageError(error.message);
         }
         const root = findRoot(options.cwd);
-        const message = await appendProgress(root, now, (state) => {
+        const store = await findStore(root);
+        const message = await appendProgress(store.directory, now, (state) => {
             const finished = state.dashboard.run?.finished;
             if (finished && command !== commands.start) {
                 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 };
-        });
+        }, (text) => saveRunCopy(root, text));
         out(message);
         return 0;
     }

package/dist/server/paths.js

@@ -1,6 +1,22 @@
-import { isAbsolute, sep } from "node:path";
+import { existsSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve, sep } from "node:path";
 // Whether a path from relative(root, target) leaves the root. "..notes" is a
 // name inside it, not a step out.
 export function outside(inside) {
     return inside === ".." || inside.startsWith(`..${sep}`) || isAbsolute(inside);
 }
+// The worktree root is the nearest directory with a `.git` entry (a folder in
+// a checkout, a file in a linked worktree). Outside git, use the directory.
+// The command and the panel both start from here, so a Paseo project set at a
+// subfolder of the repo still reads the file the agent writes.
+export function findRoot(cwd) {
+    let directory = resolve(cwd);
+    while (true) {
+        if (existsSync(join(directory, ".git")))
+            return directory;
+        const parent = dirname(directory);
+        if (parent === directory)
+            return resolve(cwd);
+        directory = parent;
+    }
+}

package/dist/server/progress-file.js

@@ -1,26 +1,17 @@
 // Everything that reads or writes a worktree's progress files: the event log
-// the command appends to, the panel-opened marker, and the .gitignore that keeps
-// both out of git. The command and the panel's RPC handlers go through here, so
-// they always agree on where the files are and how they're read.
+// the command appends to and the panel-opened marker. Each function takes the
+// folder that holds them, which `findStore` in store.ts picks. The command and
+// 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 { basename, dirname, join } from "node:path";
+import { join } from "node:path";
 import { EMPTY_DASHBOARD, parseProgress, reduceProgress } from "../shared/dashboard.js";
-import { EVENT_VERSION, eventSchema, PANEL_OPENED_FILE, PROGRESS_FILE } from "../shared/events.js";
+import { EVENT_VERSION, eventSchema, PANEL_OPENED_NAME, PROGRESS_FILE_NAME } from "../shared/events.js";
 import { withLock } from "./lock.js";
-const SCRATCH_DIR = dirname(PROGRESS_FILE);
-const LOCK_FILE = `${PROGRESS_FILE}.lock`;
-// Names only this plugin's files, so they stay out of git without the user
-// editing their own .gitignore. Other files in .scratch/ are left to the repo.
-export const SCRATCH_GITIGNORE = `# Added by the progress plugin for Paseo so its files stay out of git.
-${basename(PROGRESS_FILE)}
-${basename(LOCK_FILE)}/
-${basename(PANEL_OPENED_FILE)}
-.gitignore
-`;
+const LOCK_NAME = `${PROGRESS_FILE_NAME}.lock`;
 // A draft the event schema rejects. The message names each bad field.
 export class InvalidEvent extends Error {
 }
-// The parsed file per worktree, kept until its size or change time moves. The
+// The parsed file per folder, kept until its size or change time moves. The
 // file only grows, and the panel and pills read it every few seconds.
 const parsedFiles = new Map();
 // Replaced file snapshots and their derived data can be collected together.
@@ -29,9 +20,9 @@ const dashboards = new WeakMap();
 // reuse the last one until the file changes or a stale or overdue time passes.
 // Stale and overdue checks use the daemon host's clock, the same clock the
 // command stamps events with.
-export async function readProgress(root, now = new Date()) {
-    const parsed = await readParsed(root);
-    const panelOpened = await exists(join(root, PANEL_OPENED_FILE));
+export async function readProgress(directory, now = new Date()) {
+    const parsed = await readParsed(directory);
+    const panelOpened = await exists(join(directory, PANEL_OPENED_NAME));
     if (parsed === null)
         return { configured: false, dashboard: EMPTY_DASHBOARD, panelOpened };
     let cached = dashboards.get(parsed);
@@ -46,10 +37,12 @@ export async function readProgress(root, now = new Date()) {
 // 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(root, now, write) {
-    await prepareScratch(root);
-    return withLock(join(root, LOCK_FILE), async () => {
-        const text = (await readText(root)) ?? "";
+export async function appendProgress(directory, now, 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 checked = eventSchema.safeParse({ v: EVENT_VERSION, ts: now().toISOString(), ...withoutUndefined(event) });
@@ -58,27 +51,19 @@ export async function appendProgress(root, now, write) {
         }
         // A line cut short (a killed command, a hand edit) would swallow this event, so start a new line.
         const lead = text && !text.endsWith("\n") ? "\n" : "";
-        await appendFile(join(root, PROGRESS_FILE), `${lead}${JSON.stringify(checked.data)}\n`);
+        const line = `${lead}${JSON.stringify(checked.data)}\n`;
+        await appendFile(join(directory, PROGRESS_FILE_NAME), line);
+        await after?.(text + line);
         return result;
     });
 }
-export async function markPanelOpened(root) {
-    await prepareScratch(root);
-    await writeFile(join(root, PANEL_OPENED_FILE), "");
-}
-// Creates .scratch/ in the worktree and, the first time, its .gitignore. An
-// existing .gitignore is the user's, so it is never touched.
-async function prepareScratch(root) {
-    const directory = join(root, SCRATCH_DIR);
+export async function markPanelOpened(directory) {
     await mkdir(directory, { recursive: true });
-    await writeFile(join(directory, ".gitignore"), SCRATCH_GITIGNORE, { flag: "wx" }).catch((error) => {
-        if (error.code !== "EEXIST")
-            throw error;
-    });
+    await writeFile(join(directory, PANEL_OPENED_NAME), "");
 }
-async function readText(root) {
+async function readText(directory) {
     try {
-        return await readFile(join(root, PROGRESS_FILE), "utf8");
+        return await readFile(join(directory, PROGRESS_FILE_NAME), "utf8");
     }
     catch (error) {
         if (error.code === "ENOENT")
@@ -86,27 +71,27 @@ async function readText(root) {
         throw error;
     }
 }
-async function readParsed(root) {
-    const info = await stat(join(root, PROGRESS_FILE)).catch((error) => {
+async function readParsed(directory) {
+    const info = await stat(join(directory, PROGRESS_FILE_NAME)).catch((error) => {
         if (error.code === "ENOENT")
             return null;
         throw error;
     });
     if (!info) {
-        parsedFiles.delete(root);
+        parsedFiles.delete(directory);
         return null;
     }
-    const cached = parsedFiles.get(root);
+    const cached = parsedFiles.get(directory);
     if (cached && cached.size === info.size && cached.mtimeMs === info.mtimeMs && cached.ctimeMs === info.ctimeMs)
         return cached.parsed;
     // Stat before reading: if the file grows in between, the next stat won't match and it's read again.
-    const text = await readText(root);
+    const text = await readText(directory);
     if (text === null) {
-        parsedFiles.delete(root);
+        parsedFiles.delete(directory);
         return null;
     }
     const parsed = parseProgress(text);
-    parsedFiles.set(root, { size: info.size, mtimeMs: info.mtimeMs, ctimeMs: info.ctimeMs, parsed });
+    parsedFiles.set(directory, { size: info.size, mtimeMs: info.mtimeMs, ctimeMs: info.ctimeMs, parsed });
     return parsed;
 }
 async function exists(path) {