@stringsync/splates 0.0.59 → 0.0.61

package/index.js

@@ -97,7 +97,7 @@ import {
   MIGRATION_LIMIT,
   migrateRecords,
   OpenBoards as OpenBoards2,
-  repository as repository10
+  repository as repository11
 } from "@stringsync/splates-server/records";
 import {
   newest,
@@ -107,7 +107,6 @@ import {
   seeded as seeded2,
   update
 } from "@stringsync/splates-server/server";
-import { ship } from "@stringsync/splates-server/ship";
 import { addFactTasks } from "@stringsync/splates-server/stats";
 import {
   add,
@@ -125,9 +124,9 @@ import {
   untilAfter as untilAfter3,
   wait
 } from "@stringsync/splates-server/tasks";
-import { cli as cli15 } from "webappwiz/cmd";
+import { cli as cli16 } from "webappwiz/cmd";
 import { Duration as Duration3 } from "webappwiz/time";
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 
 // artifact.ts
 import { basename, resolve as resolve2 } from "node:path";
@@ -650,10 +649,10 @@ function storeOf(ctx) {
 
 // lane.ts
 import {
-  APPROVAL,
   BACKLOG_LANE as BACKLOG_LANE2,
   laneAdd,
   laneList,
+  laneQueue,
   laneRemove,
   laneShow,
   laneUpdate,
@@ -662,7 +661,10 @@ import {
 } from "@stringsync/splates-server/board";
 import { refuseGroomer } from "@stringsync/splates-server/conversations";
 import { UNTRIAGED } from "@stringsync/splates-server/plans";
-import { refuseAgentQueue } from "@stringsync/splates-server/queue";
+import {
+  refuseAgentQueue,
+  sayUnqueuedBlockers
+} from "@stringsync/splates-server/queue";
 import { repository as repository4 } from "@stringsync/splates-server/records";
 import { cli as cli5 } from "webappwiz/cmd";
 import { z as z6 } from "zod";
@@ -670,7 +672,7 @@ var laneNumber = z6.union([
   z6.literal("backlog").transform(() => BACKLOG_LANE2),
   z6.coerce.number().int().nonnegative()
 ]);
-var splatesLane = cli5("lane").description("lanes: named groups of tasks, for you to see related work together on the board; queue one whole with `splates lane queue`. Backlog (lane 0) is permanent and holds unmatched deferred work. Untriaged is groomed into lanes and cannot be queued whole");
+var splatesLane = cli5("lane").description("lanes: named groups of tasks, for you to see related work together on the board; queue all its tasks at once with `splates lane queue`. Backlog (lane 0) is permanent and holds unmatched deferred work. Untriaged is groomed into lanes and cannot be queued as a lane");
 splatesLane.command("list").use(repository4({ needs: "read" })).description("every lane: its name, its queued tasks in order, the started tasks on it, its next task, and what blocks that in other lanes").option("json", z6.boolean(), { default: false, description: "emit JSON" }).action((opts, ctx) => laneList(ctx, { json: opts.json }));
 splatesLane.command("show").use(repository4({ needs: "read" })).description("one lane step by step, and what its agent does next: start the next task, or wait for the one blocking it in another lane to land first; `untriaged` lists the tasks in no lane, to place in lanes").arg("lane", z6.union([z6.literal(UNTRIAGED).transform(() => null), laneNumber], {
   error: "pass a lane's number, backlog, or untriaged"
@@ -690,27 +692,19 @@ splatesLane.command("update").use(repository4({ needs: "tasks" })).description("
   const change = { name: opts.name, position: opts.position };
   await ctx.journal.record("lane update", null, () => laneUpdate(ctx, opts.lane, change), (record) => laneUpdated(opts.lane, record, change));
 });
-splatesLane.command("queue").use(repository4({ needs: "tasks" })).description("queue a lane whole: each of its tasks is queued as soon as nothing blocks it, now and as tasks land, until the lane is empty; a task you take out with `splates queue remove` stays out until you queue it again. Untriaged cannot be queued whole").arg("lane", laneNumber, {
+splatesLane.command("queue").use(repository4({ needs: "tasks" })).description("queue every task in a lane now, once: the queue starts each once nothing it is blocked by is open; one blocked by a task outside the queue waits queued until that is queued too, as the command names; a task put in the lane later is queued on its own. Untriaged cannot be queued as a lane").arg("lane", laneNumber, {
   description: "lane number"
 }).action(async (opts, ctx) => {
   refuseAgentQueue(ctx.service, "lane queue");
   await refuseGroomer(ctx.service, "lane queue");
-  const change = { queued: true };
-  await ctx.journal.record("lane update", null, () => laneUpdate(ctx, opts.lane, change), (record) => laneUpdated(opts.lane, record, change));
+  const queued = await laneQueue(ctx, opts.lane, true);
+  await sayUnqueuedBlockers(ctx, queued.map((task) => task.id));
 });
-splatesLane.command("approve").use(repository4({ needs: "tasks" })).description("let a queued lane queue more tasks on its own: it stops when its budget is spent, which starts at its tasks then plus 5, and this adds 10 to what is left; refused from an agent").arg("lane", laneNumber, {
-  description: "lane number"
-}).action(async (opts, ctx) => {
-  refuseAgentQueue(ctx.service, "lane approve");
-  const change = { approve: APPROVAL };
-  await ctx.journal.record("lane update", null, () => laneUpdate(ctx, opts.lane, change), (record) => laneUpdated(opts.lane, record, change));
-});
-splatesLane.command("unqueue").use(repository4({ needs: "tasks" })).description("stop queueing a lane whole, taking out of the queue each of its tasks that has yet to start; those under way go on").arg("lane", laneNumber, {
+splatesLane.command("unqueue").use(repository4({ needs: "tasks" })).description("take each of a lane's queued tasks out of the queue; those under way go on").arg("lane", laneNumber, {
   description: "lane number"
 }).action(async (opts, ctx) => {
   refuseAgentQueue(ctx.service, "lane unqueue");
-  const change = { queued: false };
-  await ctx.journal.record("lane update", null, () => laneUpdate(ctx, opts.lane, change), (record) => laneUpdated(opts.lane, record, change));
+  await laneQueue(ctx, opts.lane, false);
 });
 splatesLane.command("remove").use(repository4({ needs: "tasks" })).description("remove a lane and its tasks, kept to restore; a lane whose last task merges goes on its own; agents may remove an empty lane; for one containing tasks, ask with a permission card").arg("lane", laneNumber, {
   description: "lane number"
@@ -1094,12 +1088,38 @@ function printUndo(log, plan) {
   log.info(color3.dim("the Setup page's Undo does it, after the user confirms"));
 }
 
-// slots.ts
-import { Slots } from "@stringsync/splates-server/ports";
+// ship.ts
+import { repository as repository8 } from "@stringsync/splates-server/records";
+import { DEFAULT_PORT as DEFAULT_PORT2 } from "@stringsync/splates-server/server";
 import { cli as cli10 } from "webappwiz/cmd";
 import { z as z11 } from "zod";
-var splatesSlots = cli10("slots").description("the words `splates server --slot` hands out on this machine, each held by the tree that claimed it: a task's worktree holds its word until the task merges or is removed, which stops its server and gives the word back");
-splatesSlots.command("list").description("print each claimed word, the tree holding it, its server's pid while one runs, and whether it is orphaned: its tree gone, or a splates repository's main tree, which every agent shares").option("json", z11.boolean(), { default: false, description: "emit JSON" }).action(async (opts, ctx) => {
+var splatesShip = cli10("ship").description("open the Ships page with a project picked").fallback("run");
+splatesShip.command("run").use(repository8({ needs: "read" })).arg("project", z11.string(), {
+  default: "",
+  description: "the registered project to show"
+}).option("dev", z11.string(), {
+  default: "",
+  description: "the splates server URL"
+}).action((opts, ctx) => {
+  const page = new URL("/", opts.dev || ctx.ps.env("SPLATES_DEV") || `http://localhost:${DEFAULT_PORT2}`);
+  page.hash = "ships";
+  if (opts.project !== "") {
+    page.searchParams.set("ship", opts.project);
+  }
+  ctx.log.info(`Open ship plan: ${page}`);
+  const local = new URL(page);
+  local.hostname = "localhost";
+  local.protocol = "http:";
+  local.port = page.hostname === "localhost" || page.hostname === "127.0.0.1" ? page.port : String(DEFAULT_PORT2);
+  ctx.log.info(`Local: ${local}`);
+});
+
+// slots.ts
+import { Slots } from "@stringsync/splates-server/ports";
+import { cli as cli11 } from "webappwiz/cmd";
+import { z as z12 } from "zod";
+var splatesSlots = cli11("slots").description("the words `splates server --slot` hands out on this machine, each held by the tree that claimed it: a task's worktree holds its word until the task merges or is removed, which stops its server and gives the word back");
+splatesSlots.command("list").description("print each claimed word, the tree holding it, its server's pid while one runs, and whether it is orphaned: its tree gone, or a splates repository's main tree, which every agent shares").option("json", z12.boolean(), { default: false, description: "emit JSON" }).action(async (opts, ctx) => {
   const held = await Slots.ofMachine(ctx).status();
   if (opts.json) {
     ctx.log.info(JSON.stringify(held.map(({ slot, tree, pid, orphaned }) => ({
@@ -1145,16 +1165,16 @@ import {
 import { commaList as commaList5 } from "@stringsync/splates-server/comma-list";
 import { refuseGroomer as refuseGroomer3 } from "@stringsync/splates-server/conversations";
 import { fail as fail9 } from "@stringsync/splates-server/exit";
-import { OpenBoards, repository as repository8 } from "@stringsync/splates-server/records";
+import { OpenBoards, repository as repository9 } from "@stringsync/splates-server/records";
 import {
   DEFAULT_TIMEOUT as DEFAULT_TIMEOUT2,
   taskWait,
   untilAfter as untilAfter2
 } from "@stringsync/splates-server/tasks";
-import { cli as cli11 } from "webappwiz/cmd";
+import { cli as cli12 } from "webappwiz/cmd";
 import { Duration as Duration2 } from "webappwiz/time";
-import { z as z12 } from "zod";
-var splatesTask = cli11("task").description("the numbered tasks: defer work for later instead of growing the task you are in, and `splates add <slug> --task <n>` starts one; `merge` recommends the next one when a task lands. The person puts tasks in `splates queue`, for workers to start");
+import { z as z13 } from "zod";
+var splatesTask = cli12("task").description("the numbered tasks: defer work for later instead of growing the task you are in, and `splates add <slug> --task <n>` starts one; `merge` recommends the next one when a task lands. The person puts tasks in `splates queue`, for workers to start");
 async function projectFrom(ctx) {
   if (ctx.elsewhere === null) {
     return;
@@ -1162,29 +1182,29 @@ async function projectFrom(ctx) {
   return (await ctx.projects.list()).find((each) => each.root === ctx.git.root)?.slug;
 }
 function adding(name, description, ready) {
-  splatesTask.command(name).use(repository8({ needs: "queue" })).description(description).arg("subject", z12.string(), {
+  splatesTask.command(name).use(repository9({ needs: "queue" })).description(description).arg("subject", z13.string(), {
     description: "what is left to do, in a line"
-  }).arg("text", z12.string(), {
+  }).arg("text", z13.string(), {
     default: "",
     description: "whatever more there is to say about it, in markdown"
-  }).option("slug", z12.string(), {
+  }).option("slug", z13.string(), {
     description: "a short name for the task that takes it (lowercase-with-dashes), naming its branch, worktree and conversation: a few words for what it changes, not the subject cut short"
   }).option("position", position, {
     description: "where it goes in the list, 1 at the top, pushing those from there down (default: the bottom)"
-  }).repeated("file", z12.string(), {
+  }).repeated("file", z13.string(), {
     description: "files to attach, comma separated or the flag repeated: copied under .git/splates/tasks/<n>/"
-  }).repeated("blocked-by", z12.string(), {
+  }).repeated("blocked-by", z13.string(), {
     description: "the tasks blocking it, comma separated or the flag repeated: a number for one here, <project>#<number> for one of another project (`webappwiz#404`); each has to merge before this one starts"
-  }).option("lane", z12.string(), {
+  }).option("lane", z13.string(), {
     default: "",
     description: "the lane it goes in, at the bottom: a lane's number, `backlog` for the permanent catch-all, or `new` for one of its own (default: none, untriaged)"
-  }).option("agent", z12.string(), {
+  }).option("agent", z13.string(), {
     default: "",
     description: "the agent on the roster (`splates agents`) that should work it, which Start on the `splates server` board offers first"
-  }).option("model", z12.string(), {
+  }).option("model", z13.string(), {
     default: "",
     description: "with --agent: the model, by its id or name on the roster"
-  }).option("effort", z12.string(), {
+  }).option("effort", z13.string(), {
     default: "",
     description: "with --agent: the thinking level, one the agent offers (default: the agent's own)"
   }).action(async (opts, ctx) => {
@@ -1229,10 +1249,10 @@ function adding(name, description, ready) {
 }
 adding("add", "queue a task to do later and move on, groomed, so it goes in ready: you checked no task already asks it, and linked what blocks it; run from a worktree, it records the task it came up in", true);
 adding("defer", "queue a task as it is, rough, in the backlog for whoever grooms it: to check for one that already asks it, link what blocks it, and mark it ready; run from a worktree, it records the task it came up in", false);
-splatesTask.command("list").use(repository8({ needs: "read" })).description("every queued task, top of the list first, with the task it came from and the started one that took it up").option("json", z12.boolean(), { default: false, description: "emit JSON" }).option("open", z12.boolean(), {
+splatesTask.command("list").use(repository9({ needs: "read" })).description("every queued task, top of the list first, with the task it came from and the started one that took it up").option("json", z13.boolean(), { default: false, description: "emit JSON" }).option("open", z13.boolean(), {
   default: false,
   description: "only tasks no started one has taken up: the ones free to pick up"
-}).option("ready", z12.boolean(), {
+}).option("ready", z13.boolean(), {
   default: false,
   description: "only tasks free to start now: none has taken them, and nothing blocking them is still open"
 }).action(async (opts, ctx) => taskList(ctx, {
@@ -1241,7 +1261,7 @@ splatesTask.command("list").use(repository8({ needs: "read" })).description("eve
   ready: opts.ready,
   project: await projectFrom(ctx)
 }));
-splatesTask.command("show").use(repository8({ needs: "read" })).description("one task in full: where it stands, its files, and its detail").arg("id", z12.coerce.number().int().positive(), { description: "task number" }).option("json", z12.boolean(), { default: false, description: "emit JSON" }).action(async (opts, ctx) => {
+splatesTask.command("show").use(repository9({ needs: "read" })).description("one task in full: where it stands, its files, and its detail").arg("id", z13.coerce.number().int().positive(), { description: "task number" }).option("json", z13.boolean(), { default: false, description: "emit JSON" }).action(async (opts, ctx) => {
   let __stack = [];
   try {
     const boards = __using(__stack, new OpenBoards(ctx, ctx.projects), 0);
@@ -1258,52 +1278,43 @@ splatesTask.command("show").use(repository8({ needs: "read" })).description("one
     __callDispose(__stack, _err, _hasErr);
   }
 });
-splatesTask.command("update").use(repository8({ needs: "tasks" })).description("say what a queued task is in other words, move it up or down the list, or attach and drop files; it keeps its number").arg("id", z12.coerce.number().int().positive(), { description: "task number" }).arg("text", z12.string(), {
+splatesTask.command("update").use(repository9({ needs: "tasks" })).description("say what a queued task is in other words, move it up or down the list, or attach and drop files; it keeps its number").arg("id", z13.coerce.number().int().positive(), { description: "task number" }).arg("text", z13.string(), {
   default: "",
   description: "whatever more there is to say about it, in markdown; leave out to keep the detail"
-}).option("subject", z12.string(), {
+}).option("subject", z13.string(), {
   default: "",
   description: "what is left to do, in a line; leave out to keep it"
-}).option("slug", z12.string(), {
+}).option("slug", z13.string(), {
   default: "",
   description: "a new name for the task that takes it (lowercase-with-dashes); leave out to keep it"
 }).option("position", position, {
   description: "where to move it in the list, 1 at the top; the others close up around it"
-}).repeated("file", z12.string(), {
+}).repeated("file", z13.string(), {
   description: "files to attach, comma separated or the flag repeated"
-}).repeated("remove-file", z12.string(), {
+}).repeated("remove-file", z13.string(), {
   description: "attached files to drop, comma separated or the flag repeated, by path or stored name"
-}).repeated("blocked-by", z12.string(), {
+}).repeated("blocked-by", z13.string(), {
   description: "more tasks blocking it, comma separated or the flag repeated: a number for one here, <project>#<number> for one of another project (`webappwiz#404`); each has to merge before this one starts; refused when that makes a loop"
-}).repeated("remove-blocked-by", z12.string(), {
+}).repeated("remove-blocked-by", z13.string(), {
   description: "tasks no longer blocking it, as --blocked-by names them, comma separated or the flag repeated"
-}).option("lane", z12.string(), {
+}).option("lane", z13.string(), {
   default: "",
   description: "move it to a lane, at the bottom: a lane's number, `backlog` for the permanent catch-all, `new` for one of its own, or `none` for untriaged"
-}).option("agent", z12.string(), {
+}).option("agent", z13.string(), {
   default: "",
   description: "the agent on the roster (`splates agents`) that should work it, which Start on the `splates server` board offers first, or `none`"
-}).option("model", z12.string(), {
+}).option("model", z13.string(), {
   default: "",
   description: "with --agent: the model, by its id or name on the roster"
-}).option("effort", z12.string(), {
+}).option("effort", z13.string(), {
   default: "",
   description: "with --agent: the thinking level, one the agent offers (default: the agent's own)"
-}).option("ready", z12.boolean(), {
+}).option("ready", z13.boolean(), {
   default: false,
   description: "mark it groomed, moving it from the backlog to ready: no task already asks it, and what blocks it is linked"
-}).option("manual", z12.boolean(), {
-  default: false,
-  description: "queue it by hand only: a queued lane passes over it, and it starts once you `splates queue add` it"
-}).option("auto", z12.boolean(), {
-  default: false,
-  description: "let a queued lane queue it again, undoing --manual"
 }).action(async (opts, ctx) => {
   let __stack = [];
   try {
-    if (opts.manual && opts.auto) {
-      fail9("usage", "pass --manual or --auto, not both", { number: opts.id });
-    }
     await refuseGroomer3(ctx.service, "task update", await ctx.tasks.find(opts.id));
     const assignee = await assigneeIn(ctx, opts.agent, opts.model, opts.effort);
     const boards = __using(__stack, new OpenBoards(ctx, ctx.projects), 0);
@@ -1327,7 +1338,6 @@ splatesTask.command("update").use(repository8({ needs: "tasks" })).description("
       lane: laneIn(opts.lane),
       assignee,
       ready: opts.ready,
-      manual: opts.manual ? true : opts.auto ? false : undefined,
       boards
     }));
   } catch (_catch) {
@@ -1336,11 +1346,11 @@ splatesTask.command("update").use(repository8({ needs: "tasks" })).description("
     __callDispose(__stack, _err, _hasErr);
   }
 });
-splatesTask.command("remove").use(repository8({ needs: "tasks" })).description("drop a queued task that was done some other way or no longer applies").arg("id", z12.coerce.number().int().positive(), { description: "task number" }).action(async (opts, ctx) => {
+splatesTask.command("remove").use(repository9({ needs: "tasks" })).description("drop a queued task that was done some other way or no longer applies").arg("id", z13.coerce.number().int().positive(), { description: "task number" }).action(async (opts, ctx) => {
   await refuseGroomer3(ctx.service, "task remove", await ctx.tasks.find(opts.id));
   await ctx.journal.record("task remove", null, () => taskRemove(ctx, opts.id), (removed) => ({ tasks: tasksNamed2([removed]) }));
 });
-splatesTask.command("wait").use(repository8({ needs: "read" })).description("block until a task leaves the queue, which it does when the task that took it merges: for a task blocked by one another lane is on; ends early when that task waits on a person to answer its questions, and gives up with `timeout`").arg("id", z12.coerce.number().int().positive(), { description: "task number" }).option("timeout-secs", z12.coerce.number(), {
+splatesTask.command("wait").use(repository9({ needs: "read" })).description("block until a task leaves the queue, which it does when the task that took it merges: for a task blocked by one another lane is on; ends early when that task waits on a person to answer its questions, and gives up with `timeout`").arg("id", z13.coerce.number().int().positive(), { description: "task number" }).option("timeout-secs", z13.coerce.number(), {
   default: DEFAULT_TIMEOUT2.secs,
   description: "how long to wait before giving up"
 }).action(async (opts, ctx) => {
@@ -1354,25 +1364,25 @@ splatesTask.command("wait").use(repository8({ needs: "read" })).description("blo
 });
 
 // tunnel.ts
-import { repository as repository9 } from "@stringsync/splates-server/records";
+import { repository as repository10 } from "@stringsync/splates-server/records";
 import { savedTunnelOf } from "@stringsync/splates-server/server";
 import {
   API_TOKEN,
   tunnelRemove,
   tunnelSetup
 } from "@stringsync/splates-server/tunnel";
-import { cli as cli12 } from "webappwiz/cmd";
-import { z as z13 } from "zod";
-var splatesTunnel = cli12("tunnel").description("reach `splates server` from elsewhere: a Cloudflare tunnel with Cloudflare Access in front, set up once per machine");
-splatesTunnel.command("setup").use(repository9({ needs: "own" })).description(`make a Cloudflare tunnel to \`splates server\`, the DNS record routing <host> to it, and an Access application letting in only --email, through the API with the token kept as the cred ${API_TOKEN}, then save them for this machine, so a bare \`splates server\` comes up tunneled; run again, it changes only what is not so already. Without that token it requests it on the Creds page of \`splates server\`, with how to make it, and exits \`requested\`: \`splates creds wait ${API_TOKEN}\`, then run it again`).arg("host", z13.string(), {
+import { cli as cli13 } from "webappwiz/cmd";
+import { z as z14 } from "zod";
+var splatesTunnel = cli13("tunnel").description("reach `splates server` from elsewhere: a Cloudflare tunnel with Cloudflare Access in front, set up once per machine");
+splatesTunnel.command("setup").use(repository10({ needs: "own" })).description(`make a Cloudflare tunnel to \`splates server\`, the DNS record routing <host> to it, and an Access application letting in only --email, through the API with the token kept as the cred ${API_TOKEN}, then save them for this machine, so a bare \`splates server\` comes up tunneled; run again, it changes only what is not so already. Without that token it requests it on the Creds page of \`splates server\`, with how to make it, and exits \`requested\`: \`splates creds wait ${API_TOKEN}\`, then run it again`).arg("host", z14.string(), {
   description: "the public host name, in a zone of the account, as in splates.example.com"
-}).option("email", z13.string(), {
+}).option("email", z14.string(), {
   default: "",
   description: "comma-separated email addresses Access lets in"
-}).option("name", z13.string(), {
+}).option("name", z14.string(), {
   default: "splates",
   description: "what the tunnel, the Access application and its policy are called"
-}).option("team", z13.string(), {
+}).option("team", z14.string(), {
   default: "",
   description: "the Zero Trust team to make, as in <team>.cloudflareaccess.com, when the account has none yet"
 }).action(async (opts, ctx) => ctx.journal.record("tunnel setup", null, async () => tunnelSetup({
@@ -1383,7 +1393,7 @@ splatesTunnel.command("setup").use(repository9({ needs: "own" })).description(`m
   log: ctx.log,
   fetch: ctx.fetch
 })));
-splatesTunnel.command("status").description("print the tunnel `splates tunnel setup` saved for this machine, which a bare `splates server` runs, and whether its token is in the system's secret store").option("json", z13.boolean(), { default: false, description: "emit JSON" }).action(async (opts, ctx) => {
+splatesTunnel.command("status").description("print the tunnel `splates tunnel setup` saved for this machine, which a bare `splates server` runs, and whether its token is in the system's secret store").option("json", z14.boolean(), { default: false, description: "emit JSON" }).action(async (opts, ctx) => {
   const saved = savedTunnelOf(ctx);
   const record = await saved.read();
   const token = record === null ? false : await saved.token() !== undefined;
@@ -1404,7 +1414,7 @@ splatesTunnel.command("status").description("print the tunnel `splates tunnel se
   ].join(`
 `));
 });
-splatesTunnel.command("remove").use(repository9({ needs: "own" })).description(`delete what \`splates tunnel setup\` and \`splates server --slot\` made in Cloudflare by what they saved: each tunnel, the DNS record routing to it, the Access applications and their policy, then forget the saved files and the tunnels' tokens; the API token kept as ${API_TOKEN} stays. Run again after a failure, it finishes what is left`).action(async (_opts, ctx) => ctx.journal.record("tunnel remove", null, async () => tunnelRemove({
+splatesTunnel.command("remove").use(repository10({ needs: "own" })).description(`delete what \`splates tunnel setup\` and \`splates server --slot\` made in Cloudflare by what they saved: each tunnel, the DNS record routing to it, the Access applications and their policy, then forget the saved files and the tunnels' tokens; the API token kept as ${API_TOKEN} stays. Run again after a failure, it finishes what is left`).action(async (_opts, ctx) => ctx.journal.record("tunnel remove", null, async () => tunnelRemove({
   saved: savedTunnelOf(ctx),
   slots: slotTunnelsOf(ctx),
   creds: ctx.creds,
@@ -1423,20 +1433,20 @@ import {
   removeWorker,
   workerRun
 } from "@stringsync/splates-server/workers";
-import { cli as cli14 } from "webappwiz/cmd";
+import { cli as cli15 } from "webappwiz/cmd";
 import { CompositeLogger } from "webappwiz/log";
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 
 // waiting.ts
 import { listQueue, moveQueued } from "@stringsync/splates-server/workers";
-import { cli as cli13 } from "webappwiz/cmd";
-import { z as z14 } from "zod";
+import { cli as cli14 } from "webappwiz/cmd";
+import { z as z15 } from "zod";
 var DEV = {
   default: "",
   description: "the `splates server` to ask, a URL such as http://localhost:4310; by default the one an agent runs under, from SPLATES_DEV"
 };
-var splatesWaiting = cli13("queue").description("the agents waiting to start on a worker of the running `splates server`: nothing caps how many agents run, so one waits only while what splates starts on its own (the queue, automations, hooks, the groomer) is paused, or while no worker it can run on is up, first come, first served; none is ever failed for waiting. An agent you start waits only while no worker is up");
-splatesWaiting.command("list").description("list the agents waiting to start, first in line first: position, project, task, conversation, how long each has waited and why (paused, no worker up, or worker draining)").option("dev", z14.string(), DEV).option("json", z14.boolean(), { default: false, description: "emit JSON" }).action((opts, ctx) => listQueue({
+var splatesWaiting = cli14("queue").description("the agents waiting to start on a worker of the running `splates server`: nothing caps how many agents run, so one waits only while what splates starts on its own (the queue, automations, hooks, the groomer) is paused, or while no worker it can run on is up, first come, first served; none is ever failed for waiting. An agent you start waits only while no worker is up");
+splatesWaiting.command("list").description("list the agents waiting to start, first in line first: position, project, task, conversation, how long each has waited and why (paused, no worker up, or worker draining)").option("dev", z15.string(), DEV).option("json", z15.boolean(), { default: false, description: "emit JSON" }).action((opts, ctx) => listQueue({
   dev: opts.dev,
   json: opts.json,
   log: ctx.log,
@@ -1444,11 +1454,11 @@ splatesWaiting.command("list").description("list the agents waiting to start, fi
   ps: ctx.ps,
   send: ctx.fetch
 }));
-splatesWaiting.command("move").description("move an agent waiting to start to another place in line, from 1 for the next to start, then list the queue").arg("which", z14.string(), {
+splatesWaiting.command("move").description("move an agent waiting to start to another place in line, from 1 for the next to start, then list the queue").arg("which", z15.string(), {
   description: "the task it works, or its conversation's id"
-}).arg("position", z14.coerce.number().int(), {
+}).arg("position", z15.coerce.number().int(), {
   description: "where in line to put it, from 1"
-}).option("dev", z14.string(), DEV).option("json", z14.boolean(), { default: false, description: "emit JSON" }).action((opts, ctx) => moveQueued({
+}).option("dev", z15.string(), DEV).option("json", z15.boolean(), { default: false, description: "emit JSON" }).action((opts, ctx) => moveQueued({
   which: opts.which,
   position: opts.position,
   dev: opts.dev,
@@ -1460,20 +1470,20 @@ splatesWaiting.command("move").description("move an agent waiting to start to an
 }));
 
 // worker.ts
-var splatesWorker = cli14("worker").description("this machine’s worker, which runs agents, terminals and process reads for `splates server` over its Unix socket");
-splatesWorker.command("run").description("run this machine’s worker until stopped, connecting over its private Unix socket and reconnecting when the server restarts").option("server", z15.string(), {
+var splatesWorker = cli15("worker").description("this machine’s worker, which runs agents, terminals and process reads for `splates server` over its Unix socket");
+splatesWorker.command("run").description("run this machine’s worker until stopped, connecting over its private Unix socket and reconnecting when the server restarts").option("server", z16.string(), {
   default: "",
   description: "the `splates server` to dial: unix:<path>; by default this machine's"
-}).option("coordinator", z15.string(), {
+}).option("coordinator", z16.string(), {
   default: "",
   description: "the old name for --server, still read for workers installed before it, and passed to a build older than it"
-}).option("slots", z15.coerce.number().int().min(0), {
+}).option("slots", z16.coerce.number().int().min(0), {
   default: 0,
   description: "ignored: nothing caps how many agents a worker runs; still read, since a `splates server` started before it was dropped passes it"
-}).option("id", z15.literal("local"), {
+}).option("id", z16.literal("local"), {
   default: "local",
   description: "what the server knows this worker by, kept across restarts so it picks up where it was; by default local"
-}).option("quiet", z15.boolean(), {
+}).option("quiet", z16.boolean(), {
   default: false,
   description: "say only what went wrong, not each time it joins or loses its server, as the worker `splates server` starts beside itself does; all of it still goes to worker.log in ~/.splates, the one before it kept as worker.log.1"
 }).action((opts, ctx) => workerRun({
@@ -1483,10 +1493,10 @@ splatesWorker.command("run").description("run this machine’s worker until stop
   ps: ctx.ps,
   fs: ctx.fs
 }));
-splatesWorker.command("list").description("list the workers the running `splates server` has: platform, build, protocol, health with when it was last heard, and tasks, then any it refused for speaking another protocol").option("dev", z15.string(), {
+splatesWorker.command("list").description("list the workers the running `splates server` has: platform, build, protocol, health with when it was last heard, and tasks, then any it refused for speaking another protocol").option("dev", z16.string(), {
   default: "",
   description: "the `splates server` to ask, a URL such as http://localhost:4310; by default the one an agent runs under, from SPLATES_DEV"
-}).option("json", z15.boolean(), { default: false, description: "emit JSON" }).action((opts, ctx) => listWorkers({
+}).option("json", z16.boolean(), { default: false, description: "emit JSON" }).action((opts, ctx) => listWorkers({
   dev: opts.dev,
   json: opts.json,
   log: ctx.log,
@@ -1498,12 +1508,12 @@ var dev = {
   default: "",
   description: "the `splates server` to ask, a URL such as http://localhost:4310; by default the one an agent runs under, from SPLATES_DEV"
 };
-splatesWorker.command("drain").description("take no new agents on a worker, letting those on it run to their end, but for one asking you something in a task, which saves its task and lets its slot go, its question kept for you to answer and carry it on elsewhere; --undo takes new ones again").arg("id", z15.string(), {
+splatesWorker.command("drain").description("take no new agents on a worker, letting those on it run to their end, but for one asking you something in a task, which saves its task and lets its slot go, its question kept for you to answer and carry it on elsewhere; --undo takes new ones again").arg("id", z16.string(), {
   description: "the worker, as `splates worker list` names it"
-}).option("undo", z15.boolean(), {
+}).option("undo", z16.boolean(), {
   default: false,
   description: "take new agents again"
-}).option("dev", z15.string(), dev).action((opts, ctx) => drainWorker({
+}).option("dev", z16.string(), dev).action((opts, ctx) => drainWorker({
   id: opts.id,
   undo: opts.undo,
   dev: opts.dev,
@@ -1512,12 +1522,12 @@ splatesWorker.command("drain").description("take no new agents on a worker, lett
   ps: ctx.ps,
   send: ctx.fetch
 }));
-splatesWorker.command("remove").description("stop this machine’s worker taking agents, letting its agents run to their end; resume it with `splates worker drain local --undo`").arg("id", z15.string(), {
+splatesWorker.command("remove").description("stop this machine’s worker taking agents, letting its agents run to their end; resume it with `splates worker drain local --undo`").arg("id", z16.string(), {
   description: "the worker, as `splates worker list` names it"
-}).option("force", z15.boolean(), {
+}).option("force", z16.boolean(), {
   default: false,
   description: "end the agents on it now rather than wait for them"
-}).option("dev", z15.string(), dev).action((opts, ctx) => removeWorker({
+}).option("dev", z16.string(), dev).action((opts, ctx) => removeWorker({
   id: opts.id,
   force: opts.force,
   dev: opts.dev,
@@ -1549,15 +1559,15 @@ function projectArgs(argv) {
   }
   return { argv };
 }
-var splates = cli15("splates").use(exits());
-splates.command("init").use(repository10({ creates: true, needs: "own" })).description("make this repository a splates project: set up its records under .git/splates when it has none, install the splates skill of this release with `bunx skills add`, and register it in ~/.splates/projects.json, so `splates server` serves it beside every other; run again, it changes only what is not so already").action((_opts, ctx) => init(ctx));
+var splates = cli16("splates").use(exits());
+splates.command("init").use(repository11({ creates: true, needs: "own" })).description("make this repository a splates project: set up its records under .git/splates when it has none, install the splates skill of this release with `bunx skills add`, and register it in ~/.splates/projects.json, so `splates server` serves it beside every other; run again, it changes only what is not so already").action((_opts, ctx) => init(ctx));
 splates.command("migrate").description(`move this repository's records under .git/splates to this splates's format, as \`splates server\` does as it starts: backed up first, the steps run with ${MIGRATION_LIMIT.human()} to finish, and the backup put back if one fails or runs over, with why kept in .git/splates-migration.json; it tries again past a failure kept there, which the server and every other command leave alone. Run it only while no older \`splates server\` serves the repository, which would refuse the records once moved; \`splates update\` restarts one first`).action(async (_opts, ctx) => {
   const format = await migrateRecords(ctx);
   if (ctx.ps.env(MIGRATING) === undefined) {
     ctx.log.info(`splates's records are in format ${format}`);
   }
 });
-splates.command("update").use(recordsFirst()).use(repository10({ needs: "own" })).description("bring this repository up to the newest splates on npm: run `update` on that release when it is newer than this one, which moves the records under .git/splates to its format, as `splates migrate` does, unless an older `splates server` serves the repository, which it asks to restart onto that release once its agents have checkpointed, migrating them as it starts; then installs its splates skill with `bunx skills add` over the copy there, leaving one that links to your own; commit what changed").action(async (_opts, ctx) => {
+splates.command("update").use(recordsFirst()).use(repository11({ needs: "own" })).description("bring this repository up to the newest splates on npm: run `update` on that release when it is newer than this one, which moves the records under .git/splates to its format, as `splates migrate` does, unless an older `splates server` serves the repository, which it asks to restart onto that release once its agents have checkpointed, migrating them as it starts; then installs its splates skill with `bunx skills add` over the copy there, leaving one that links to your own; commit what changed").action(async (_opts, ctx) => {
   const code = await update({
     root: ctx.git.root,
     fs: ctx.fs,
@@ -1570,31 +1580,31 @@ splates.command("update").use(recordsFirst()).use(repository10({ needs: "own" })
   }
 });
 splates.command("refresh").description("bring the tree you stand in, a task's worktree included, up to this splates: install its splates skill with `bunx skills add` over the copy there and move what an older config holds to where it reads it, leaving the records and any `splates server` alone; what a project runs once a ship's bump task has installed a newer splates, as splates's `afterBump` names; commit what changed").action((_opts, ctx) => refreshHere(ctx));
-splates.command("forget").use(repository10({ needs: "own" })).description("take this repository off ~/.splates/projects.json, so `splates server` no longer offers it; its records stay, and `splates init` brings it back").action((_opts, ctx) => forget(ctx));
-splates.command("add").use(repository10({ needs: "tasks" })).description("start a task: a new one, or with --task one from the queue; create branch task/<slug>, a worktree at ../<repo>-splates.noindex/<slug> and a state record").arg("slug", z16.string(), {
+splates.command("forget").use(repository11({ needs: "own" })).description("take this repository off ~/.splates/projects.json, so `splates server` no longer offers it; its records stay, and `splates init` brings it back").action((_opts, ctx) => forget(ctx));
+splates.command("add").use(repository11({ needs: "tasks" })).description("start a task: a new one, or with --task one from the queue; create branch task/<slug>, a worktree at ../<repo>-splates.noindex/<slug> and a state record").arg("slug", z17.string(), {
   description: "the task's name, for its branch and worktree (lowercase-with-dashes)"
-}).option("base", z16.string(), {
+}).option("base", z17.string(), {
   default: "",
   description: "branch this task starts from and merges onto (default: trunk); `task/<other>` stacks this task on that one and lands the work in its worktree"
-}).option("task", z16.string(), {
+}).option("task", z17.string(), {
   default: "",
   description: "start this queued task by number: its words become the plan's Goal, merging removes it, and removing this task puts it back where it was"
-}).option("goal", z16.string(), {
+}).option("goal", z17.string(), {
   default: "",
   description: "one or two lines on what done means, written under `## Goal` in the task's SPLATES.md; required unless --task seeds the Goal"
-}).option("agent", z16.string(), {
+}).option("agent", z17.string(), {
   default: "",
   description: "how `splates server`'s queue hands the task to an agent on the roster (`splates agents`), which it starts in the worktree; refused from an agent, which starts no agents and queues work with `splates task add` instead"
-}).option("model", z16.string(), {
+}).option("model", z17.string(), {
   default: "",
   description: "with --agent: the model it works on, by its id or name on the roster (default: the agent's own)"
-}).option("effort", z16.string(), {
+}).option("effort", z17.string(), {
   default: "",
   description: "with --agent: the thinking level it works at, one the agent offers (default: the agent's own)"
-}).option("prompt", z16.string(), {
+}).option("prompt", z17.string(), {
   default: "",
   description: "with --agent: what to tell the agent beyond claiming the task"
-}).option("held", z16.string(), {
+}).option("held", z17.string(), {
   default: "",
   description: "with --agent: the conversation `splates server`'s queue held for the queued task, which takes the task rather than a new one"
 }).action(async (opts, ctx) => {
@@ -1639,11 +1649,11 @@ splates.command("add").use(repository10({ needs: "tasks" })).description("start
     await serveProject(ctx);
   }
 });
-splates.command("claim").use(repository10({ needs: "own" })).description("resume an existing task: take ownership of its worktree and print its path, status and any half-finished rebase; refuses while another agent holds the lease, but takes a stale one silently, so `splates show` first if the tree may not be abandoned").arg("task", z16.string(), { description: "task name" }).action(async (opts, ctx) => {
+splates.command("claim").use(repository11({ needs: "own" })).description("resume an existing task: take ownership of its worktree and print its path, status and any half-finished rebase; refuses while another agent holds the lease, but takes a stale one silently, so `splates show` first if the tree may not be abandoned").arg("task", z17.string(), { description: "task name" }).action(async (opts, ctx) => {
   await ctx.journal.record("claim", opts.task, () => claim(ctx, opts.task), (claimed) => claimed);
   await follow(ctx, opts.task);
 });
-splates.command("merge").use(repository10({ needs: "own" })).description("land this worktree's branch on its base (trunk unless created with --base): rebase onto it, run tests on the rebased code, fast-forward it in whichever worktree has it checked out, then discard the worktree, branch and record (linear history, never a merge commit, no flag to skip tests); requires committed work, refusing a dirty worktree").option("message", z16.string(), {
+splates.command("merge").use(repository11({ needs: "own" })).description("land this worktree's branch on its base (trunk unless created with --base): rebase onto it, run tests on the rebased code, fast-forward it in whichever worktree has it checked out, then discard the worktree, branch and record (linear history, never a merge commit, no flag to skip tests); requires committed work, refusing a dirty worktree").option("message", z17.string(), {
   default: "",
   description: "squash the task's commits into one with this message before landing, saying what the base gains in at least 5 characters"
 }).action(async (opts, ctx) => {
@@ -1658,21 +1668,21 @@ splates.command("merge").use(repository10({ needs: "own" })).description("land t
     await follow(ctx, null, { from: task });
   }
 });
-splates.command("remove").use(repository10({ needs: "tasks" })).description("discard a task: worktree, branch and board tasks; cheap and encouraged, since redoing a task against current trunk often beats a hard rebase").arg("task", z16.string(), { description: "task name" }).option("force", z16.boolean(), {
+splates.command("remove").use(repository11({ needs: "tasks" })).description("discard a task: worktree, branch and board tasks; cheap and encouraged, since redoing a task against current trunk often beats a hard rebase").arg("task", z17.string(), { description: "task name" }).option("force", z17.boolean(), {
   default: false,
   description: "discard even when another agent holds the lease"
-}).option("reason", z16.optional(z16.enum(REMOVE_REASONS)), {
+}).option("reason", z17.optional(z17.enum(REMOVE_REASONS)), {
   description: "why, for the Stats page: nothing (nothing to change), moot (no longer needed), superseded (done some other way), redo (better redone against current trunk), blocked (set aside until what it waits on lands, so back on the list, which takes --why and at least one blocker)"
-}).option("why", z16.string(), {
+}).option("why", z17.string(), {
   default: "",
   description: "with --reason blocked: what you found that stops the work, in a sentence or two, for the person and whoever takes it next"
-}).repeated("blocked-by", z16.string(), {
+}).repeated("blocked-by", z17.string(), {
   description: "with --reason blocked: the tasks it waits on to merge, comma separated or the flag repeated: a number for one here, <project>#<number> for one of another project"
-}).repeated("ask", z16.string(), {
+}).repeated("ask", z17.string(), {
   description: "with --reason blocked: a question only the person can answer, in the skill's question format; repeat the flag for each"
-}).repeated("waiting-on", z16.string(), {
+}).repeated("waiting-on", z17.string(), {
   description: "with --reason blocked: something outside splates it waits on, such as a key or an upstream release; repeat the flag for each"
-}).option("detail", z16.string(), {
+}).option("detail", z17.string(), {
   default: "",
   description: "with --reason blocked: the task's detail rewritten for whoever takes it next: why it stopped, what you found, the steps done and left, and where any pushed work is"
 }).action(async (opts, ctx) => {
@@ -1703,30 +1713,30 @@ splates.command("remove").use(repository10({ needs: "tasks" })).description("dis
     __callDispose(__stack, _err, _hasErr);
   }
 });
-splates.command("list").use(repository10({ needs: "read" })).description("list every started task: its number, name, status, lease (held: an agent is on it now; stale: gone quiet, normal for a task mid-edit; none), commits ahead of trunk, age; `splates task list` lists the queue").option("json", z16.boolean(), { default: false, description: "emit JSON" }).option("files", z16.boolean(), {
+splates.command("list").use(repository11({ needs: "read" })).description("list every started task: its number, name, status, lease (held: an agent is on it now; stale: gone quiet, normal for a task mid-edit; none), commits ahead of trunk, age; `splates task list` lists the queue").option("json", z17.boolean(), { default: false, description: "emit JSON" }).option("files", z17.boolean(), {
   default: false,
   description: "add each task's Goal and changed files (committed or not), to check for overlap before starting"
 }).action((opts, ctx) => list(ctx, { json: opts.json, files: opts.files }));
-splates.command("show").use(repository10({ needs: "read" })).description("read one task without touching it: everything `list` shows for it, plus the SPLATES.md its agent left at the worktree root; takes no lease, so it cannot knock that agent off its own tree; for a task no longer live, the newest finished one of that name: how it ended, its base, the commit it landed as, its conversation and the SPLATES.md it ended on").arg("task", z16.string(), { description: "task name" }).option("json", z16.boolean(), { default: false, description: "emit JSON" }).action((opts, ctx) => show(ctx, opts.task, { json: opts.json }));
-splates.command("wait").use(repository10({ needs: "read" })).description("block until a task stops moving: waiting on a person to answer its questions, or gone (merged or removed), or broken; takes no lease, and gives up with `timeout` rather than waiting forever").arg("task", z16.string(), { description: "task name" }).option("timeout-secs", z16.coerce.number(), {
+splates.command("show").use(repository11({ needs: "read" })).description("read one task without touching it: everything `list` shows for it, plus the SPLATES.md its agent left at the worktree root; takes no lease, so it cannot knock that agent off its own tree; for a task no longer live, the newest finished one of that name: how it ended, its base, the commit it landed as, its conversation and the SPLATES.md it ended on").arg("task", z17.string(), { description: "task name" }).option("json", z17.boolean(), { default: false, description: "emit JSON" }).action((opts, ctx) => show(ctx, opts.task, { json: opts.json }));
+splates.command("wait").use(repository11({ needs: "read" })).description("block until a task stops moving: waiting on a person to answer its questions, or gone (merged or removed), or broken; takes no lease, and gives up with `timeout` rather than waiting forever").arg("task", z17.string(), { description: "task name" }).option("timeout-secs", z17.coerce.number(), {
   default: DEFAULT_TIMEOUT3.secs,
   description: "how long to wait before giving up"
 }).action((opts, ctx) => {
   const timeout = Duration3.secs(opts["timeout-secs"]);
   return ctx.journal.waiting("wait", opts.task, { until: untilAfter3(timeout) }, () => wait(ctx, opts.task, { timeout }));
 });
-splates.command("log").use(repository10({ needs: "read" })).description("show what has been done here recently: one line per add, claim, merge, remove, retry, queued task and more, with how it ended; outlives the tasks themselves").option("count", z16.coerce.number(), {
+splates.command("log").use(repository11({ needs: "read" })).description("show what has been done here recently: one line per add, claim, merge, remove, retry, queued task and more, with how it ended; outlives the tasks themselves").option("count", z17.coerce.number(), {
   default: DEFAULT_COUNT,
   description: "how many entries to show"
-}).option("json", z16.boolean(), { default: false, description: "emit JSON" }).action((opts, ctx) => showLog(ctx, { count: opts.count, json: opts.json }));
+}).option("json", z17.boolean(), { default: false, description: "emit JSON" }).action((opts, ctx) => showLog(ctx, { count: opts.count, json: opts.json }));
 splates.mount("server", splatesServer);
-splates.command("ports").description("list the ports tasks serve, found by the running `splates server` as an editor finds ports to forward: each port a process in a task's worktree, or under its agent, listens on, with its link through the ports host `splates server --ports-host` saved, behind Cloudflare Access, and its link on this machine; give the user both").arg("task", z16.string(), {
+splates.command("ports").description("list the ports tasks serve, found by the running `splates server` as an editor finds ports to forward: each port a process in a task's worktree, or under its agent, listens on, with its link through the ports host `splates server --ports-host` saved, behind Cloudflare Access, and its link on this machine; give the user both").arg("task", z17.string(), {
   default: "",
   description: "only this task's ports; every task's by default"
-}).option("dev", z16.string(), {
+}).option("dev", z17.string(), {
   default: "",
   description: "the `splates server` to ask, a URL such as http://localhost:4310; by default the one an agent runs under, from SPLATES_DEV, else this machine's on its default port"
-}).option("json", z16.boolean(), { default: false, description: "emit JSON" }).action((opts, ctx) => portsLs({
+}).option("json", z17.boolean(), { default: false, description: "emit JSON" }).action((opts, ctx) => portsLs({
   task: opts.task,
   dev: opts.dev,
   json: opts.json,
@@ -1734,41 +1744,41 @@ splates.command("ports").description("list the ports tasks serve, found by the r
   ps: ctx.ps,
   send: ctx.fetch
 }));
-splates.command("agents").description("print the roster of agents splates can start, kept for every project in ~/.splates/agents.json: each agent's launch command and models, with what each model is good at and what it costs, and the thinking levels `--effort` takes, as the agent offered them when last started, for choosing whom to delegate to; writes the defaults (Claude, Codex) there first when there is none, and `splates server` starts conversations with those it lists").option("json", z16.boolean(), { default: false, description: "emit JSON" }).action(async (opts, ctx) => agents({
+splates.command("agents").description("print the roster of agents splates can start, kept for every project in ~/.splates/agents.json: each agent's launch command and models, with what each model is good at and what it costs, and the thinking levels `--effort` takes, as the agent offered them when last started, for choosing whom to delegate to; writes the defaults (Claude, Codex) there first when there is none, and `splates server` starts conversations with those it lists").option("json", z17.boolean(), { default: false, description: "emit JSON" }).action(async (opts, ctx) => agents({
   roster: rosterOf2(ctx),
   offered: await offeredOf(ctx).all(),
   log: ctx.log
 }, { json: opts.json }));
-splates.command("setup").description("set splates up on this machine, one step at a time: with no step, each area's steps, checked from real state, and the one to do next; with a step, why it matters, the one thing the user does and what the agent does. Skips are kept in ~/.splates/setup.json, so a skipped step stops asking").arg("step", z16.string(), {
+splates.command("setup").description("set splates up on this machine, one step at a time: with no step, each area's steps, checked from real state, and the one to do next; with a step, why it matters, the one thing the user does and what the agent does. Skips are kept in ~/.splates/setup.json, so a skipped step stops asking").arg("step", z17.string(), {
   default: "",
   description: "a step's id; omit for every area's progress"
-}).option("json", z16.boolean(), { default: false, description: "emit JSON" }).option("skip", z16.boolean(), {
+}).option("json", z17.boolean(), { default: false, description: "emit JSON" }).option("skip", z17.boolean(), {
   default: false,
   description: "with a step: stop asking for it"
-}).option("unskip", z16.boolean(), {
+}).option("unskip", z17.boolean(), {
   default: false,
   description: "with a step: ask for it again"
-}).option("undo", z16.boolean(), {
+}).option("undo", z17.boolean(), {
   default: false,
   description: "with an area's id in place of a step: print what undoing it would remove, the creds it forgets and keeps, and what only the user can remove; the Setup page's Undo does it, after the user confirms"
 }).action((opts, ctx) => setup(ctx, opts));
-splates.command("path").use(repository10({ needs: "read" })).description("print a task's worktree path, or the main tree with no task; names another agent's tree without taking its lease").arg("task", z16.string(), {
+splates.command("path").use(repository11({ needs: "read" })).description("print a task's worktree path, or the main tree with no task; names another agent's tree without taking its lease").arg("task", z17.string(), {
   default: "",
   description: "task name; omit for the main tree"
 }).action((opts, ctx) => path(ctx, opts.task || undefined));
-splates.command("checkpoint").use(repository10({ needs: "own" })).description("save this task to the central remote (`remote` in splates.config.ts) before a stop: commit what is uncommitted as a `WIP: checkpoint` commit, to squash before merging, and push the branch as `splates/<task>`, so a worker that dies loses nothing; with no remote configured, leaves the tree as it is").action(async (_opts, ctx) => {
+splates.command("checkpoint").use(repository11({ needs: "own" })).description("save this task to the central remote (`remote` in splates.config.ts) before a stop: commit what is uncommitted as a `WIP: checkpoint` commit, to squash before merging, and push the branch as `splates/<task>`, so a worker that dies loses nothing; with no remote configured, leaves the tree as it is").action(async (_opts, ctx) => {
   await checkpoint(ctx, ctx.ps.cwd());
 });
-splates.command("attach").use(repository10({ needs: "own" })).description("store screenshots and recordings for this task's questions to show: prints the path each was stored at, under .git/splates, which the `splates server` page shows inline; from a conversation (its $SPLATES_CONVERSATION, or --conversation) they stay with it past the task, otherwise they go when the task merges or is removed; those the task's final SPLATES.md shows are copied to keep with its finished record. A task holds at most attachmentCapacity bytes; with no files, lists what it holds. A file the user will come back for on its own is an artifact instead (`splates artifact add`)").arg("files", z16.string(), {
+splates.command("attach").use(repository11({ needs: "own" })).description("store screenshots and recordings for this task's questions to show: prints the path each was stored at, under .git/splates, which the `splates server` page shows inline; from a conversation (its $SPLATES_CONVERSATION, or --conversation) they stay with it past the task, otherwise they go when the task merges or is removed; those the task's final SPLATES.md shows are copied to keep with its finished record. A task holds at most attachmentCapacity bytes; with no files, lists what it holds. A file the user will come back for on its own is an artifact instead (`splates artifact add`)").arg("files", z17.string(), {
   default: "",
   description: "files to store, comma separated"
-}).option("task", z16.string(), {
+}).option("task", z17.string(), {
   default: "",
   description: "task name, when run outside its worktree"
-}).option("remove", z16.string(), {
+}).option("remove", z17.string(), {
   default: "",
   description: "files it holds to drop first, comma separated, by path or stored name"
-}).option("conversation", z16.string(), {
+}).option("conversation", z17.string(), {
   default: "",
   description: "conversation to keep the files with, when $SPLATES_CONVERSATION is not set"
 }).action(async (opts, ctx) => ctx.journal.record("attach", opts.task || await here(ctx), () => attach(ctx, commaList6(opts.files), ctx.ps.cwd(), {
@@ -1776,38 +1786,8 @@ splates.command("attach").use(repository10({ needs: "own" })).description("store
   remove: commaList6(opts.remove),
   conversation: opts.conversation || undefined
 }), (stored) => ({ stored, removed: commaList6(opts.remove) })));
-splates.command("retry").use(repository10({ needs: "own" })).description("give a task that spent its merge attempts another mergeRetryCount of them; the way out of `budget_exhausted` that is not remove and redo, for a person to run once they have seen the tree").arg("task", z16.string(), { description: "task name" }).action((opts, ctx) => recordRetry(ctx, opts.task));
-splates.command("ship").use(repository10({ needs: "read" })).description("ship a project and its cascade: `splates server` runs its `ship` command from splates.config.ts on its machine, under your own npm sign-in, signing in with `npm login --auth-type=web` first when npm knows no one, and shows npm's sign-in and 2FA links on the page for any device; this prints that ship's output until it ends. The server then carries the release through every registered project that depends on it, in dependency order: a bump task queued in each once all it takes from are shipped, and, once that merges, each public one with a `ship` command and dependents of its own ships in turn. A bump that asks you, or is removed, stops the cascade at that project until it merges or you retry or drop it, as does a failed ship. While a cascade is under way, this prints where it stands instead of starting another, or changes one of its pending publishes with `--bump`. `--plan` prints the cascade and runs nothing. The person's alone to start, refused an agent, which asks with a run-command card").arg("project", z16.string(), {
-  default: "",
-  description: "the registered project's slug; this one by default"
-}).option("plan", z16.boolean(), {
-  default: false,
-  description: "print the plan without running anything"
-}).option("json", z16.boolean(), { default: false, description: "emit JSON" }).option("dev", z16.string(), {
-  default: "",
-  description: "the `splates server` to run the ship on, a URL such as http://localhost:4310; by default the one from SPLATES_DEV, else this machine's on its default port"
-}).option("bump", z16.optional(z16.enum(["patch", "minor", "major"])), {
-  description: "how far to move the starting project's version, patch by default; while its cascade runs, change this pending publish instead"
-}).option("drop", z16.string(), {
-  default: "",
-  description: "take this registered project out of the cascade under way, so those after it go on without its new version"
-}).option("retry", z16.string(), {
-  default: "",
-  description: "run this registered project's part of the cascade under way again: its ship again when that failed, or a new bump task when its last was removed"
-}).option("abandon", z16.boolean(), {
-  default: false,
-  description: "end the cascade under way: what shipped stays published, a running ship is stopped, its open bump tasks are removed, and history files it as abandoned"
-}).action((opts, ctx) => ship(ctx, {
-  project: opts.project || undefined,
-  plan: opts.plan,
-  json: opts.json,
-  dev: opts.dev,
-  bump: opts.bump,
-  drop: opts.drop || undefined,
-  retry: opts.retry || undefined,
-  abandon: opts.abandon
-}));
-splates.mount("artifact", splatesArtifact).mount("task", splatesTask).mount("lane", splatesLane).mount("projects", splatesProjects).mount("creds", splatesCreds).mount("tunnel", splatesTunnel).mount("slots", splatesSlots).mount("worker", splatesWorker).mount("queue", splatesQueue).mount("hook", splatesHook).mount("replica", splatesReplica).mount("evals", splatesEvals);
+splates.command("retry").use(repository11({ needs: "own" })).description("give a task that spent its merge attempts another mergeRetryCount of them; the way out of `budget_exhausted` that is not remove and redo, for a person to run once they have seen the tree").arg("task", z17.string(), { description: "task name" }).action((opts, ctx) => recordRetry(ctx, opts.task));
+splates.mount("artifact", splatesArtifact).mount("task", splatesTask).mount("lane", splatesLane).mount("ship", splatesShip).mount("projects", splatesProjects).mount("creds", splatesCreds).mount("tunnel", splatesTunnel).mount("slots", splatesSlots).mount("worker", splatesWorker).mount("queue", splatesQueue).mount("hook", splatesHook).mount("replica", splatesReplica).mount("evals", splatesEvals);
 
 // index.ts
 if (basename2(process.argv[1] ?? "") === LEGACY) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@stringsync/splates",
-	"version": "0.0.59",
+	"version": "0.0.61",
 	"description": "Runs several AI coding agents on one repository at once, each in its own git worktree",
 	"license": "MIT",
 	"author": "stringsync LLC",
@@ -17,8 +17,8 @@
 		"access": "public"
 	},
 	"dependencies": {
-		"@stringsync/splates-server": "^0.0.59",
-		"webappwiz": "0.0.53",
+		"@stringsync/splates-server": "^0.0.61",
+		"webappwiz": "0.0.58",
 		"zod": "^4.4.3"
 	},
 	"main": "./index.js",

package/ship.d.ts

@@ -0,0 +1,3 @@
+import type { SplatesDeps } from "@stringsync/splates-server/server";
+/** `splates ship [project]` prints the Ships page link for the person to open. */
+export declare const splatesShip: import("webappwiz/cmd").Cli<SplatesDeps, SplatesDeps>;