@stevecastaneda/paseo-progress 1.14.2 → 1.14.4

package/dist/server/cli.js

@@ -20024,16 +20024,16 @@ function reduceProgress(parsed, now) {
   const itemLabel = run?.itemLabel ?? "Ticket";
   const stuck = stuckItems(list, [...activity.values()], [...manualStuck.values()], time3.reached);
   const allQuestions = [...questions.values()];
-  const open2 = allQuestions.filter((question) => !question.answer);
+  const open3 = allQuestions.filter((question) => !question.answer);
   const finished = Boolean(run?.finished) || list.length > 0 && list.every(isSettled);
   const answered = allQuestions.filter((question) => question.answer).sort((a, b) => Date.parse(b.answer.at) - Date.parse(a.answer.at));
   const dashboard = {
     run,
     updatedAt,
     stale: !finished && updatedAt !== null && time3.reached(Date.parse(updatedAt) + STALE_AFTER_MIN * 6e4),
-    headline: headline(list, itemLabel, open2.length, stuck.length),
+    headline: headline(list, itemLabel, open3.length, stuck.length),
     stuck,
-    questions: { open: open2, answered },
+    questions: { open: open3, answered },
     activity: [...activity.values()].reverse(),
     ticker,
     deliverables: [...deliverables.values()].reverse().map((deliverable) => {
@@ -20044,16 +20044,25 @@ function reduceProgress(parsed, now) {
     tickets: list,
     issues: issues.sort((a, b) => a.line - b.line)
   };
-  return { dashboard, validUntil: time3.validUntil, nextIds: nextIds(parsed.events.map(({ event }) => event), events.map(({ event }) => event)) };
+  return {
+    dashboard,
+    validUntil: time3.validUntil,
+    nextIds: nextIds(
+      parsed.events.map(({ event }) => event),
+      events.map(({ event }) => event)
+    )
+  };
+}
+function idsOf(events, type) {
+  return events.flatMap((event) => event.type === type && "id" in event ? [event.id] : []);
 }
 function nextIds(all, inRun) {
-  const used = (events, type) => events.flatMap((event) => event.type === type && "id" in event ? [event.id] : []);
   return {
-    ticket: nextId("T", used(inRun, "ticket.add")),
-    question: nextId("Q", used(all, "question.ask"), 1),
-    deliverable: nextId("D", used(inRun, "deliverable.add"), 1),
-    activity: nextId("A", used(inRun, "activity.add"), 1),
-    stuck: nextId("S", used(inRun, "stuck.set"), 1)
+    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)
   };
 }
 function progress(tickets, startedAt) {
@@ -20151,35 +20160,105 @@ var EMPTY_DASHBOARD = {
 };
 
 // server/progress-file.ts
-import { access, appendFile, mkdir as mkdir2, readFile, stat as stat2, writeFile } from "node:fs/promises";
-import { join } from "node:path";
+import { access, readFile, stat as stat2 } from "node:fs/promises";
+import { join as join3 } from "node:path";
+
+// server/lock.ts
+import { stat } from "node:fs/promises";
+import { join as join2 } from "node:path";
+
+// server/system.ts
+import { exec, execFile } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { appendFile, chmod, lstat, mkdir, open as open2, rename, rm, symlink, unlink, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, join, sep } from "node:path";
+import { promisify } from "node:util";
+var LAUNCH_FOLDER = dirname(process.execPath);
+function runProgram(program, args, { cwd = LAUNCH_FOLDER, ...options } = {}) {
+  return promisify(execFile)(program, args, { ...options, cwd, encoding: "utf8" });
+}
+function stepsOf(folder, name) {
+  if (isAbsolute(name) || name.split(/[\\/]/).includes("..")) throw new Error(`${name} is not a name inside ${folder}.`);
+  return name.split(sep);
+}
+async function placeIn(folder, name) {
+  const steps = stepsOf(folder, name);
+  let step = folder;
+  for (const part of steps.slice(0, -1)) {
+    step = join(step, part);
+    if ((await lstat(step).catch(() => null))?.isSymbolicLink()) throw new Error(`${step} is a link, so nothing was written through it.`);
+  }
+  return join(folder, name);
+}
+async function writeFileIn(folder, name, text2, { atomic = false, executable = false } = {}) {
+  const path = await placeIn(folder, name);
+  await mkdir(dirname(path), { recursive: true });
+  if (!atomic) {
+    await writeFile(path, text2);
+  } else {
+    const temporary = `${path}.${randomUUID()}.tmp`;
+    try {
+      await writeFile(temporary, text2);
+      await rename(temporary, path);
+    } finally {
+      await rm(temporary, { force: true });
+    }
+  }
+  if (executable) await chmod(path, 493);
+}
+async function appendFileIn(folder, name, text2) {
+  await appendFile(await placeIn(folder, name), text2);
+}
+async function makeFolder(folder) {
+  await mkdir(folder, { recursive: true });
+}
+async function createFolderIn(folder, name) {
+  await mkdir(await placeIn(folder, name));
+}
+async function makeFoldersIn(folder, name) {
+  let directory = folder;
+  for (const part of stepsOf(folder, name)) {
+    directory = join(directory, part);
+    const info = await lstat(directory).catch(() => null);
+    if (!info) await mkdir(directory);
+    else if (!info.isDirectory()) return null;
+  }
+  return directory;
+}
+async function removeIn(folder, name, { recursive: recursive2 = false } = {}) {
+  await rm(await placeIn(folder, name), { recursive: recursive2, force: true });
+}
 
 // server/lock.ts
-import { mkdir, rm, stat } from "node:fs/promises";
 var RETRY_MS = 25;
 var WAIT_MS = 1e4;
 var STALE_MS = 3e4;
-async function withLock(lockPath, work) {
+async function withLock(folder, name, work) {
+  const lockPath = join2(folder, name);
   const started = Date.now();
   while (true) {
     try {
-      await mkdir(lockPath);
+      await createFolderIn(folder, name);
       break;
     } catch (error62) {
       if (error62.code !== "EEXIST") throw error62;
-      const since = await stat(lockPath).then((info) => Date.now() - info.mtimeMs, () => 0);
+      const since = await stat(lockPath).then(
+        (info) => Date.now() - info.mtimeMs,
+        () => 0
+      );
       if (since > STALE_MS) {
-        await rm(lockPath, { recursive: true, force: true });
+        await removeIn(folder, name, { recursive: true });
         continue;
       }
-      if (Date.now() - started > WAIT_MS) throw new Error(`Timed out waiting for ${lockPath}. If no other progress command is running, delete it.`);
+      if (Date.now() - started > WAIT_MS)
+        throw new Error(`Timed out waiting for ${lockPath}. If no other progress command is running, delete it.`, { cause: error62 });
       await new Promise((resolve4) => setTimeout(resolve4, RETRY_MS + Math.random() * RETRY_MS));
     }
   }
   try {
     return await work();
   } finally {
-    await rm(lockPath, { recursive: true, force: true });
+    await removeIn(folder, name, { recursive: true });
   }
 }
 
@@ -20191,7 +20270,7 @@ var parsedFiles = /* @__PURE__ */ new Map();
 var dashboards = /* @__PURE__ */ new WeakMap();
 async function readProgress(directory, now = /* @__PURE__ */ new Date()) {
   const parsed = await readParsed(directory);
-  const panelOpened = await exists(join(directory, PANEL_OPENED_NAME));
+  const panelOpened = await exists(join3(directory, PANEL_OPENED_NAME));
   if (parsed === null) return { configured: false, dashboard: EMPTY_DASHBOARD, panelOpened };
   let cached2 = dashboards.get(parsed);
   if (!cached2 || now.getTime() < cached2.from || now.getTime() >= cached2.until) {
@@ -20205,8 +20284,8 @@ async function readLatestRun(directory) {
   return latestRun((await readParsed(directory))?.events ?? []).map(({ event }) => event);
 }
 async function appendProgress(directory, now, write, after) {
-  await mkdir2(directory, { recursive: true });
-  return withLock(join(directory, LOCK_NAME), async () => {
+  await makeFolder(directory);
+  return withLock(directory, LOCK_NAME, async () => {
     const text2 = await readText(directory) ?? "";
     const parsed = parseProgress(text2);
     const { dashboard, nextIds: nextIds2 } = reduceProgress(parsed, now());
@@ -20218,21 +20297,21 @@ async function appendProgress(directory, now, write, after) {
     const lead = text2 && !text2.endsWith("\n") ? "\n" : "";
     const line = `${lead}${JSON.stringify(checked.data)}
 `;
-    await appendFile(join(directory, PROGRESS_FILE_NAME), line);
+    await appendFileIn(directory, PROGRESS_FILE_NAME, line);
     await after?.(text2 + line);
     return result;
   });
 }
 async function readText(directory) {
   try {
-    return await readFile(join(directory, PROGRESS_FILE_NAME), "utf8");
+    return await readFile(join3(directory, PROGRESS_FILE_NAME), "utf8");
   } catch (error62) {
     if (error62.code === "ENOENT") return null;
     throw error62;
   }
 }
 async function readParsed(directory) {
-  const info = await stat2(join(directory, PROGRESS_FILE_NAME)).catch((error62) => {
+  const info = await stat2(join3(directory, PROGRESS_FILE_NAME)).catch((error62) => {
     if (error62.code === "ENOENT") return null;
     throw error62;
   });
@@ -20265,29 +20344,29 @@ function withoutUndefined(value) {
 
 // server/paths.ts
 import { existsSync } from "node:fs";
-import { dirname, isAbsolute, join as join2, resolve, sep } from "node:path";
+import { dirname as dirname2, isAbsolute as isAbsolute2, join as join4, resolve, sep as sep2 } from "node:path";
 function outside(inside) {
-  return inside === ".." || inside.startsWith(`..${sep}`) || isAbsolute(inside);
+  return inside === ".." || inside.startsWith(`..${sep2}`) || isAbsolute2(inside);
 }
 function inGitFolder(inside) {
   return inside.split(/[\\/]/).some((name) => name.toLowerCase() === ".git");
 }
 function hasGitEntry(directory) {
-  return existsSync(join2(directory, ".git"));
+  return existsSync(join4(directory, ".git"));
 }
 function findRoot(cwd) {
   let directory = resolve(cwd);
   while (true) {
     if (hasGitEntry(directory)) return directory;
-    const parent = dirname(directory);
+    const parent = dirname2(directory);
     if (parent === directory) return resolve(cwd);
     directory = parent;
   }
 }
 
 // server/launcher.ts
-import { chmod, mkdir as mkdir3, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
-import { basename, dirname as dirname2, join as join3, posix, win32 } from "node:path";
+import { readFile as readFile2 } from "node:fs/promises";
+import { basename, dirname as dirname3, join as join5, posix, win32 } from "node:path";
 var PLUGIN_ID = "progress";
 function launcherScript() {
   return `#!/usr/bin/env node
@@ -20301,7 +20380,7 @@ if (major < 22 || (major === 22 && minor < 18)) {
 // Not require: a package.json with "type": "module" above this folder makes Node load it as ESM.
 const { spawnSync } = process.getBuiltinModule("node:child_process");
 const { existsSync } = process.getBuiltinModule("node:fs");
-const { join } = process.getBuiltinModule("node:path");
+const { dirname, join } = process.getBuiltinModule("node:path");
 
 const windows = process.platform === "win32";
 
@@ -20314,11 +20393,14 @@ function paseoCommands() {
 }
 
 // On Windows Paseo's command is paseo.cmd, which Node can start, or find on
-// PATH, only through cmd.exe.
+// PATH, only through cmd.exe. cmd.exe looks in the folder it starts in before
+// PATH, so it starts in Node's folder, not the agent's, where a repo could
+// have put its own paseo.cmd.
 function askPaseo(cli) {
+  const options = { cwd: dirname(process.execPath), encoding: "utf8" };
   return windows
-    ? spawnSync('"' + cli + '" plugin ls ${PLUGIN_ID} --json', { shell: true, encoding: "utf8" })
-    : spawnSync(cli, ["plugin", "ls", "${PLUGIN_ID}", "--json"], { encoding: "utf8" });
+    ? spawnSync('"' + cli + '" plugin ls ${PLUGIN_ID} --json', { ...options, shell: true })
+    : spawnSync(cli, ["plugin", "ls", "${PLUGIN_ID}", "--json"], options);
 }
 
 function pluginDirectory() {
@@ -20352,11 +20434,18 @@ var MARKER = `Written by the ${PLUGIN_ID} Paseo plugin`;
 function launcherFiles(path, platform) {
   const files = [{ path, content: launcherScript() }];
   if (platform === "win32") {
-    files.push({ path: `${path}.cmd`, content: `@echo off\r
+    const node2 = process.execPath.replaceAll("%", "%%");
+    const asNode = process.versions.electron ? `set "ELECTRON_RUN_AS_NODE=1"\r
+` : "";
+    files.push({
+      path: `${path}.cmd`,
+      content: `@echo off\r
 rem ${MARKER}. Lets PowerShell and cmd run ${basename(path)}.\r
-node "%~dp0${basename(path)}" %*\r
+setlocal\r
+${asNode}"${node2}" "%~dp0${basename(path)}" %*\r
 exit /b %errorlevel%\r
-` });
+`
+    });
   }
   return files;
 }
@@ -20378,26 +20467,22 @@ async function installLauncher(path, platform = process.platform) {
   let wrote = false;
   for (const file2 of files) {
     if (file2.state === "current") continue;
-    await mkdir3(dirname2(file2.path), { recursive: true });
-    await writeFile2(file2.path, file2.content);
-    await chmod(file2.path, 493);
+    await writeFileIn(dirname3(file2.path), basename(file2.path), file2.content, { executable: true });
     wrote = true;
   }
   return wrote;
 }
 
 // server/store.ts
-import { execFile } from "node:child_process";
-import { createHash, randomUUID } from "node:crypto";
+import { createHash } from "node:crypto";
 import { realpathSync } from "node:fs";
-import { lstat, mkdir as mkdir4, readdir, realpath, rename, rm as rm2, stat as stat3, writeFile as writeFile3 } from "node:fs/promises";
+import { readdir, realpath, stat as stat3 } from "node:fs/promises";
 import { homedir } from "node:os";
-import { basename as basename2, dirname as dirname3, join as join4, normalize, resolve as resolve2, sep as sep2 } from "node:path";
-import { promisify } from "node:util";
+import { basename as basename2, join as join6, normalize, resolve as resolve2 } from "node:path";
 var SAVE_RUNS_KEY = "paseo-progress.saveRuns";
 async function git(root, args) {
   try {
-    const { stdout } = await promisify(execFile)("git", ["-C", resolve2(root), ...args], { cwd: dirname3(process.execPath) });
+    const { stdout } = await runProgram("git", ["-C", resolve2(root), ...args]);
     return { code: 0, stdout };
   } catch (error62) {
     const failed = error62;
@@ -20405,17 +20490,7 @@ async function git(root, args) {
   }
 }
 function stateRoot(home = homedir()) {
-  return join4(home, ".local", "state", "paseo-progress");
-}
-async function writeAtomic(path, text2) {
-  await mkdir4(dirname3(path), { recursive: true });
-  const temp = `${path}.${randomUUID()}.tmp`;
-  try {
-    await writeFile3(temp, text2);
-    await rename(temp, path);
-  } finally {
-    await rm2(temp, { force: true });
-  }
+  return join6(home, ".local", "state", "paseo-progress");
 }
 function outsideDirectory(root, home = homedir()) {
   let real = root;
@@ -20424,7 +20499,7 @@ function outsideDirectory(root, home = homedir()) {
   } catch {
   }
   const hash2 = createHash("sha1").update(real).digest("hex").slice(0, 8);
-  return join4(stateRoot(home), `${basename2(real)}-${hash2}`);
+  return join6(stateRoot(home), `${basename2(real)}-${hash2}`);
 }
 function findStore(root, home = homedir()) {
   const directory = outsideDirectory(root, home);
@@ -20437,7 +20512,7 @@ async function configFile(root) {
   if (!configFiles.has(root)) {
     const { code, stdout } = await git(root, ["rev-parse", "--git-common-dir"]);
     if (code !== 0) return null;
-    configFiles.set(root, join4(resolve2(root, stdout.trim()), "config"));
+    configFiles.set(root, join6(resolve2(root, stdout.trim()), "config"));
   }
   return configFiles.get(root);
 }
@@ -20472,29 +20547,20 @@ async function saveRunCopy(root, text2) {
   const [start] = latestRun(parseProgress(text2).events);
   if (start?.event.type !== "run.start") return;
   const lines = text2.split("\n").slice(start.line - 1).filter((line) => line.trim());
-  const directory = await runsFolder(root, folder);
+  const directory = await makeFoldersIn(await realpath(root), folder);
   if (!directory) return;
-  await writeAtomic(join4(directory, runFileName(start.event.ts, start.event.title)), `${lines.join("\n")}
-`);
-}
-async function runsFolder(root, folder) {
-  let directory = await realpath(root);
-  for (const name of folder.split(sep2)) {
-    directory = join4(directory, name);
-    const info = await lstat(directory).catch(() => null);
-    if (!info) await mkdir4(directory);
-    else if (!info.isDirectory()) return null;
-  }
-  return directory;
+  await writeFileIn(directory, runFileName(start.event.ts, start.event.title), `${lines.join("\n")}
+`, { atomic: true });
 }
 
 // server/question-mode.ts
-import { readFile as readFile3, rm as rm3 } from "node:fs/promises";
+import { readFile as readFile3 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import { join as join5 } from "node:path";
+import { join as join7 } from "node:path";
 var mirrorSchema = external_exports.object({ questionMode: external_exports.enum(QUESTION_MODES) });
+var SETTINGS_NAME = "settings.json";
 function questionModePath(home = homedir2()) {
-  return join5(stateRoot(home), "settings.json");
+  return join7(stateRoot(home), SETTINGS_NAME);
 }
 async function readQuestionMode(home = homedir2()) {
   try {
@@ -20534,7 +20600,11 @@ function minutesSince(iso, nowMs) {
 
 // shared/show.ts
 var STATUS = { not_started: "Not started", working: "Working", blocked: "Blocked", done: "Done", skipped: "Skipped" };
-var QUESTION_STATE = { stopped: "agent stopped until the answer", waiting: "waiting for the answer", building: "building with it" };
+var QUESTION_STATE = {
+  stopped: "agent stopped until the answer",
+  waiting: "waiting for the answer",
+  building: "building with it"
+};
 function dashboardText(dashboard, nowMs) {
   if (!dashboard.run && !dashboard.tickets.length) return 'No run yet. Start one with: paseo-progress start "<title>"';
   const lines = [];
@@ -20550,7 +20620,9 @@ function dashboardText(dashboard, nowMs) {
   if (dashboard.updatedAt) lines.push(`Last updated ${when(dashboard.updatedAt)}`);
   if (dashboard.stale && dashboard.updatedAt) lines.push(`POSSIBLY STALE: no update for ${formatMinutes(minutesSince(dashboard.updatedAt, nowMs))}.`);
   if (dashboard.progress.totalMin) {
-    lines.push(`${dashboard.progress.percent}% of estimated work done, ${dashboard.progress.tookMin !== void 0 ? "took " : ""}${formatWorkDone(dashboard.progress.doneMin, dashboard.progress.totalMin, dashboard.progress.tookMin)}`);
+    lines.push(
+      `${dashboard.progress.percent}% of estimated work done, ${dashboard.progress.tookMin !== void 0 ? "took " : ""}${formatWorkDone(dashboard.progress.doneMin, dashboard.progress.totalMin, dashboard.progress.tookMin)}`
+    );
   }
   if (dashboard.issues.length) {
     lines.push("", `Skipped lines: ${dashboard.issues.map((issue2) => `line ${issue2.line} (${issue2.reason})`).join(", ")}`);
@@ -20572,7 +20644,9 @@ function dashboardText(dashboard, nowMs) {
   if (dashboard.questions.open.length) {
     lines.push("", "Questions waiting");
     for (const question of dashboard.questions.open) {
-      lines.push(`  ${question.id} ${question.ticketId ? `[${question.ticketId}] ` : ""}(${question.title}): ${question.question} You recommended ${question.recommended}, ${QUESTION_STATE[question.state]}${question.big ? `. Big: ${question.big}` : ""}`);
+      lines.push(
+        `  ${question.id} ${question.ticketId ? `[${question.ticketId}] ` : ""}(${question.title}): ${question.question} You recommended ${question.recommended}, ${QUESTION_STATE[question.state]}${question.big ? `. Big: ${question.big}` : ""}`
+      );
       for (const option of question.options) lines.push(`      ${option.letter}) ${option.label}${option.consequence ? `: ${option.consequence}` : ""}`);
     }
   }
@@ -20591,7 +20665,8 @@ function dashboardText(dashboard, nowMs) {
   }
   if (dashboard.activity.length) {
     lines.push("", "Activity");
-    for (const entry of dashboard.activity.slice(0, 5)) lines.push(`  ${entry.id}  ${entry.ticketId ? `[${entry.ticketId}] ` : ""}${entry.text} (${formatAgo(entry.at, nowMs)})`);
+    for (const entry of dashboard.activity.slice(0, 5))
+      lines.push(`  ${entry.id}  ${entry.ticketId ? `[${entry.ticketId}] ` : ""}${entry.text} (${formatAgo(entry.at, nowMs)})`);
   }
   return lines.join("\n");
 }
@@ -20655,7 +20730,7 @@ var URL_PATTERN = /^[a-z][a-z\d+.-]*:\/\//i;
 function parseFile(raw, cwd, root) {
   const isUrl = URL_PATTERN.test(raw);
   let index = isUrl ? raw.lastIndexOf("=") : raw.indexOf("=");
-  while (isUrl && index !== -1 && /[?&][^=&#]*$/.test(raw.slice(0, index))) index = raw.lastIndexOf("=", index - 1);
+  if (isUrl) while (index !== -1 && /[?&][^=&#]*$/.test(raw.slice(0, index))) index = raw.lastIndexOf("=", index - 1);
   const target = (index === -1 ? raw : raw.slice(0, index)).trim();
   const label = index === -1 ? void 0 : raw.slice(index + 1).trim() || void 0;
   if (!target) throw new UsageError(`--file needs a path or URL, got "${raw}".`);
@@ -20674,10 +20749,10 @@ function existingActivity(state, id) {
 }
 function existingQuestion(state, id) {
   const wanted = required2(id, "question id").toUpperCase();
-  const { open: open2, answered } = state.dashboard.questions;
-  const question = [...open2, ...answered].find((candidate) => candidate.id === wanted);
+  const { open: open3, answered } = state.dashboard.questions;
+  const question = [...open3, ...answered].find((candidate) => candidate.id === wanted);
   if (!question) {
-    const known = [...open2, ...answered].map((candidate) => candidate.id).join(", ") || "none";
+    const known = [...open3, ...answered].map((candidate) => candidate.id).join(", ") || "none";
     throw new UsageError(`No question ${wanted} in this run. Questions: ${known}.`);
   }
   return question;
@@ -20727,6 +20802,9 @@ function addedByOthersText(tickets, dashboard) {
     `${one ? "It is" : "They are"} part of this run: work ${one ? "it" : "them"} in order after your current ${label}.`
   ].join("\n");
 }
+function shown(value) {
+  return typeof value === "object" ? value.path ?? value.url : value;
+}
 var commands = {
   start: {
     usage: `start "<title>" [--subtitle <text>] [--item-label <word>]`,
@@ -20772,14 +20850,23 @@ ${modeLine(mode)}`
   "ticket update": {
     usage: `ticket update <id> [--status <status>] [--stage <name>] [--title <text>] [--estimate <minutes>] [--note <text>] [--waits-for <id>] [--source <path or http(s) URL>[=<label>]]`,
     summary: `Change a ticket. Statuses: ${TICKET_STATUSES.join(", ")}. --stage names the step in progress, like Build or Fixes ("" clears it). --waits-for names a ticket it can't start before ("" clears it); waiting is not stuck, so don't mark it blocked for that. --source is where the ticket is written up ("" clears it).`,
-    options: { status: { type: "string" }, stage: { type: "string" }, title: { type: "string" }, estimate: { type: "string" }, note: { type: "string" }, "waits-for": { type: "string" }, source: { type: "string" } },
+    options: {
+      status: { type: "string" },
+      stage: { type: "string" },
+      title: { type: "string" },
+      estimate: { type: "string" },
+      note: { type: "string" },
+      "waits-for": { type: "string" },
+      source: { type: "string" }
+    },
     run({ positionals, values, state, cwd, root }) {
       const ticket = existingTicket(state, positionals[0]);
       const rawWaitsFor = values["waits-for"] === void 0 ? void 0 : String(values["waits-for"]).trim();
       const waitsFor = rawWaitsFor === void 0 || rawWaitsFor === "" ? rawWaitsFor : existingTicket(state, rawWaitsFor).id;
       if (waitsFor && waitsFor === ticket.id) throw new UsageError(`${ticket.id} can't wait for itself.`);
       for (let next = waitsFor ? state.dashboard.tickets.find((entry) => entry.id === waitsFor) : void 0, seen = 0; next?.waitsFor && seen < 1e3; seen++) {
-        if (next.waitsFor === ticket.id) throw new UsageError(`${ticket.id} can't wait for ${waitsFor}: ${next.id} already waits for ${ticket.id}, so neither could start.`);
+        if (next.waitsFor === ticket.id)
+          throw new UsageError(`${ticket.id} can't wait for ${waitsFor}: ${next.id} already waits for ${ticket.id}, so neither could start.`);
         next = state.dashboard.tickets.find((entry) => entry.id === next.waitsFor);
       }
       const event = {
@@ -20795,7 +20882,6 @@ ${modeLine(mode)}`
       };
       const changes = Object.entries(event).filter(([key, value]) => key !== "type" && key !== "id" && value !== void 0);
       if (!changes.length) throw new UsageError("Nothing to change. Pass --status, --stage, --title, --estimate, --note, --waits-for, or --source.");
-      const shown = (value) => typeof value === "object" ? value.path ?? value.url : value;
       return { event, message: `Updated ${ticket.id}: ${changes.map(([key, value]) => `${key} ${shown(value)}`).join(", ")}` };
     }
   },
@@ -20867,7 +20953,13 @@ ${modeLine(mode)}`
       const built = question.state === "building";
       const next = !built ? "Build it now." : asRecommended ? "Carry on with it." : `Undo the work built on your recommendation and build ${choice} before anything else.`;
       return {
-        event: { type: "question.answer", id: question.id, choice, words: stringOption(values.words), changedCourse: built && !asRecommended ? true : void 0 },
+        event: {
+          type: "question.answer",
+          id: question.id,
+          choice,
+          words: stringOption(values.words),
+          changedCourse: built && !asRecommended ? true : void 0
+        },
         message: `Answered ${question.id}: ${choice}${asRecommended ? " (as you recommended)" : ` (not your recommendation, ${question.recommended})`}. ${next}`
       };
     }
@@ -20894,7 +20986,8 @@ ${modeLine(mode)}`
         files: files.length ? files : void 0,
         recommend
       };
-      if (!event.question && !event.background && !event.files && !recommend) throw new UsageError("Nothing to change. Pass --recommend, --background, --question, or --file.");
+      if (!event.question && !event.background && !event.files && !recommend)
+        throw new UsageError("Nothing to change. Pass --recommend, --background, --question, or --file.");
       if (!recommend) return { event, message: `Updated ${question.id} (${question.title})` };
       const rules = QUESTION_MODE_RULES[mode];
       const next = question.state === "building" ? `Undo the work built on ${question.recommended} and build ${recommend} instead.` : `Mode: ${rules.label}. ${rules.askRule({ recommend, big: Boolean(question.big) })}`;
@@ -20911,7 +21004,7 @@ ${modeLine(mode)}`
   },
   "deliverable add": {
     usage: `deliverable add "<title>" <path or http(s) URL> [--ticket <id>] [--kind ${DELIVERABLE_KINDS.join("|")}]`,
-    summary: "Add something the user can review. Paths are relative to where you run the command. Prints its id (D1, D2, ...).",
+    summary: `Add something the user can review. Paths are relative to where you run the command. Prints its id (D1, D2, ...). An HTML deliverable opens in Paseo's sandboxed preview, which blocks everything from the web, so put its CSS in the page and embed images as data URIs. In the preview, storage APIs and navigator.clipboard throw an error. The alert, confirm, prompt and window.open calls and form submits do nothing. One syntax error stops a whole script.`,
     options: { ticket: { type: "string" }, kind: { type: "string" } },
     run({ positionals, values, state, cwd, root }) {
       const title = required2(positionals[0], "deliverable title");
@@ -21021,13 +21114,13 @@ ${modeLine(mode)}`
 function rootRelative(target, cwd, root) {
   const absolute = resolve3(cwd, target);
   const inside = relative(root, absolute);
-  const suffix = /[\/]$/.test(target) || statSync(absolute, { throwIfNoEntry: false })?.isDirectory() ? "/" : "";
+  const suffix = target.endsWith("/") || statSync(absolute, { throwIfNoEntry: false })?.isDirectory() ? "/" : "";
   if (!inside) return "./";
   return outside(inside) ? absolute + suffix : inside + suffix;
 }
 function guessKind(target, isUrl, cwd) {
   if (isUrl) return "link";
-  if (/[\/]$/.test(target) || statSync(resolve3(cwd, target), { throwIfNoEntry: false })?.isDirectory()) return "folder";
+  if (target.endsWith("/") || statSync(resolve3(cwd, target), { throwIfNoEntry: false })?.isDirectory()) return "folder";
   if (imageMimeType(target)) return "screenshot";
   return "file";
 }
@@ -21111,15 +21204,20 @@ ${command.summary}`);
     const root = findRoot(options.cwd);
     const store = await findStore(root);
     const mode = await readQuestionMode();
-    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: message2 } = command.run({ positionals: parsed.positionals, values: parsed.values, state, cwd: options.cwd, root, mode });
-      const added = command === commands.start ? "" : addedByOthersText(addedByOthers(state.events, state.dashboard, options.agentId), state.dashboard);
-      return { event: { ...event, by: options.agentId }, result: `${message2}${added}` };
-    }, (text2) => saveRunCopy(root, text2));
+    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: summary } = command.run({ positionals: parsed.positionals, values: parsed.values, state, cwd: options.cwd, root, mode });
+        const added = command === commands.start ? "" : addedByOthersText(addedByOthers(state.events, state.dashboard, options.agentId), state.dashboard);
+        return { event: { ...event, by: options.agentId }, result: `${summary}${added}` };
+      },
+      (text2) => saveRunCopy(root, text2)
+    );
     out(message);
     return 0;
   } catch (error62) {