@stringsync/splates 0.0.0-stage → 0.0.46

package/index.js

@@ -0,0 +1,1282 @@
+#!/usr/bin/env bun
+// @bun
+
+// main.ts
+import { basename as basename2 } from "node:path";
+import {
+  LEGACY,
+  legacyWarnings,
+  systemPs
+} from "@stringsync/splates-server/config";
+import { assets } from "@stringsync/splates-server/server";
+import { NodeFs } from "webappwiz/system";
+
+// splates.ts
+import { DEFAULT_PORT } from "@stringsync/splates-server";
+import { agents } from "@stringsync/splates-server/agents";
+import { attach } from "@stringsync/splates-server/artifacts";
+import { commaList as commaList4 } from "@stringsync/splates-server/comma-list";
+import { exits, fail as fail5 } from "@stringsync/splates-server/exit";
+import { DEFAULT_COUNT, log as showLog } from "@stringsync/splates-server/log";
+import { merge } from "@stringsync/splates-server/merge";
+import { portsLs } from "@stringsync/splates-server/ports";
+import { forget, init } from "@stringsync/splates-server/projects";
+import { repository as repository7 } from "@stringsync/splates-server/records";
+import {
+  newest,
+  rosterOf as rosterOf2,
+  runHeavy,
+  seeded as seeded2,
+  serveDev,
+  update
+} from "@stringsync/splates-server/server";
+import { addFactTodos } from "@stringsync/splates-server/stats";
+import {
+  add,
+  checkpoint,
+  claim,
+  DEFAULT_TIMEOUT as DEFAULT_TIMEOUT3,
+  escalate,
+  follow,
+  handoff,
+  list,
+  path,
+  REMOVE_REASONS,
+  recordRetry,
+  remove,
+  reportToCaller,
+  serveProject,
+  show,
+  tell,
+  untilAfter as untilAfter3,
+  wait
+} from "@stringsync/splates-server/tasks";
+import { LOCAL_SLOTS } from "@stringsync/splates-server/workers";
+import { cli as cli12 } from "webappwiz/cmd";
+import { Duration as Duration3 } from "webappwiz/time";
+import { z as z13 } from "zod";
+
+// artifact.ts
+import { basename, resolve } from "node:path";
+import {
+  addArtifact,
+  listArtifacts,
+  removeArtifact
+} from "@stringsync/splates-server/artifacts";
+import { commaList as commaList2 } from "@stringsync/splates-server/comma-list";
+import { conversationOf } from "@stringsync/splates-server/conversations";
+import { fail as fail2 } from "@stringsync/splates-server/exit";
+import { repository } from "@stringsync/splates-server/records";
+import { cli } from "webappwiz/cmd";
+import { z as z2 } from "zod";
+
+// flags.ts
+import { commaList } from "@stringsync/splates-server/comma-list";
+import { SYSTEM_STORES } from "@stringsync/splates-server/creds";
+import { fail } from "@stringsync/splates-server/exit";
+import {
+  Offered,
+  pickAgent,
+  pickEffort,
+  splatesHome
+} from "@stringsync/splates-server/models";
+import { SLOT_POOL } from "@stringsync/splates-server/ports";
+import { rosterOf, seeded } from "@stringsync/splates-server/server";
+import { SavedTunnel } from "@stringsync/splates-server/tunnel";
+import { z } from "zod";
+var position = z.coerce.number().int().positive().optional();
+async function assigneeIn(deps, agent, model, effort) {
+  if (agent === "") {
+    if (model !== "" || effort !== "") {
+      fail("usage", "--model and --effort go with --agent", {
+        model,
+        effort
+      });
+    }
+    return;
+  }
+  if (agent === "none") {
+    return null;
+  }
+  return pickIn(deps, await seeded(rosterOf(deps)), agent, model, effort);
+}
+async function pickIn(deps, agents, agent, model, effort, data = {}) {
+  const picked = pickAgent(agents, agent, model === "" ? undefined : model, data);
+  return { ...picked, ...await effortIn(deps, picked.agent, effort, data) };
+}
+async function effortIn(deps, agent, effort, data = {}) {
+  if (effort === "") {
+    return {};
+  }
+  const offered = (await offeredOf(deps).all())[agent];
+  return { effort: pickEffort(offered, agent, effort, data) };
+}
+function offeredOf({ ps, fs }) {
+  return new Offered(`${splatesHome(ps)}/offered.json`, { fs });
+}
+function slotTunnelsOf({
+  ps,
+  fs,
+  secrets = SYSTEM_STORES
+}) {
+  return SLOT_POOL.map(({ word }) => new SavedTunnel(`${splatesHome(ps)}/slots/${word}/tunnel.json`, {
+    fs,
+    store: secrets.device
+  }));
+}
+function laneIn(raw) {
+  const value = raw.trim();
+  if (value === "") {
+    return;
+  }
+  if (value === "new") {
+    return "new";
+  }
+  if (value === "none") {
+    return null;
+  }
+  const id = Number(value);
+  if (!Number.isInteger(id) || id <= 0) {
+    fail("usage", `'${value}' is not a lane: pass its number, new or none`, {
+      lane: value
+    });
+  }
+  return id;
+}
+function todoIds(raw) {
+  return commaList(raw).map((value) => {
+    const id = Number(value);
+    if (!Number.isInteger(id) || id <= 0) {
+      fail("usage", `'${value}' is not a todo id`, { todo: value });
+    }
+    return id;
+  });
+}
+async function here({
+  service,
+  git,
+  ps,
+  project
+}) {
+  return project === undefined ? service.taskFor(await git.currentBranch(ps.cwd())) : null;
+}
+
+// artifact.ts
+var splatesArtifact = cli("artifact").description("files your conversation made as its outputs, such as a screenshot, a recording or an HTML page: kept by name for the life of the conversation, whatever task it was made in, and listed on the `splates server` page beside its thread. A file that shows a question, an assumption or a demo step is no artifact: `splates attach` it. The conversation is $SPLATES_CONVERSATION, or --conversation <id> from an agent outside `splates server`");
+var conversation = [
+  "conversation",
+  z2.string(),
+  {
+    default: "",
+    description: "conversation id, when not run by an agent `splates server` started"
+  }
+];
+splatesArtifact.command("add").use(repository({ needs: "own" })).description("keep files as artifacts of this conversation, each named for its basename, or by --name when there is one; adding a name the conversation holds makes its next version, earlier ones kept until cleanup takes them. Past the project's limit (artifactProjectCapacity), `splates server` first evicts the oldest bytes the project keeps: removed and replaced versions, then what archived conversations show, then what live ones do. Past the file or conversation limit (artifactFileCapacity, artifactConversationCapacity), or the project's when even that would not make room, it stops with `too_large`, changing nothing for that file").arg("files", z2.string(), { description: "files to keep, comma separated" }).option("name", z2.string(), {
+  default: "",
+  description: "the artifact's name; for one file only"
+}).option(...conversation).action(async (opts, ctx) => {
+  const paths = commaList2(opts.files);
+  if (paths.length === 0) {
+    fail2("usage", "name the files to keep: nothing was changed");
+  }
+  if (opts.name !== "" && paths.length > 1) {
+    fail2("usage", "--name names one file: nothing was changed");
+  }
+  const id = await conversationOf(ctx.service, opts.conversation);
+  const files = await Promise.all(paths.map(async (given) => {
+    const path = resolve(ctx.ps.cwd(), given);
+    const bytes = await ctx.fs.readBytes(path).catch(() => null);
+    if (bytes === null) {
+      fail2("usage", `cannot read ${path}: nothing was changed`, {
+        file: path
+      });
+    }
+    return { name: opts.name || basename(path), bytes };
+  }));
+  const task = await here(ctx);
+  for (const file of files) {
+    await ctx.journal.record("artifact add", task, () => addArtifact(ctx, id, file), (added) => ({
+      name: file.name,
+      version: added.version,
+      bytes: added.bytes
+    }));
+  }
+});
+splatesArtifact.command("remove").use(repository({ needs: "own" })).description("stop listing the artifact of that name, every version kept until cleanup takes them; adding the name again lists it again").arg("name", z2.string(), { description: "the artifact's name" }).option(...conversation).action(async (opts, ctx) => {
+  const id = await conversationOf(ctx.service, opts.conversation);
+  await ctx.journal.record("artifact remove", await here(ctx), () => removeArtifact(ctx, id, opts.name), (version) => ({ name: opts.name, version }));
+});
+splatesArtifact.command("list").use(repository({ needs: "own" })).description("the artifacts this conversation lists, and their current version").option(...conversation).action(async (opts, ctx) => listArtifacts(ctx, await conversationOf(ctx.service, opts.conversation)));
+splatesArtifact.command("show").use(repository({ needs: "own" })).description("every version of an artifact, and which is current").arg("name", z2.string(), { description: "the artifact's name" }).option(...conversation).action(async (opts, ctx) => listArtifacts(ctx, await conversationOf(ctx.service, opts.conversation), opts.name));
+
+// budget.ts
+import {
+  endBudgetRaise,
+  raiseBudget,
+  setBudget,
+  showBudget
+} from "@stringsync/splates-server/workers";
+import { cli as cli2 } from "webappwiz/cmd";
+import { z as z3 } 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 JSON_OPTION = { default: false, description: "emit JSON" };
+var LIMIT = z3.enum(["hour", "day", "month"]);
+var LIMIT_ARG = {
+  description: "hour, the rate cap on what made workers running at once cost an hour; day; or month"
+};
+var splatesBudget = cli2("budget").description("what the workers a `workerProvider` makes may cost, in dollars: a rate cap per hour on those running at once ($0.25/h by default), and limits on a day ($5) and a month ($75). Past the rate cap, or once a day's or month's limit is spent, no worker is made and the queue says why; reaching the day's or month's stops made workers, whose agents stop at their checkpoint. Each warns at 80%, 90% and 100% by Web Push and on the page's header. Spend is an estimate at each type's list price. Agents' own API spend is not counted here");
+splatesBudget.command("show").description("show each limit: what made workers spent in its window, of how much, and what is left").option("dev", z3.string(), DEV).option("json", z3.boolean(), JSON_OPTION).action((opts, ctx) => showBudget({
+  dev: opts.dev,
+  json: opts.json,
+  log: ctx.log,
+  ps: ctx.ps,
+  send: ctx.fetch
+}));
+splatesBudget.command("set").description("set a limit, in dollars (dollars an hour for hour), then show the budget").arg("limit", LIMIT, LIMIT_ARG).arg("dollars", z3.string(), {
+  description: "like 5 or 0.25, or `default` to give it back to its default"
+}).option("dev", z3.string(), DEV).option("json", z3.boolean(), JSON_OPTION).action((opts, ctx) => setBudget({
+  limit: opts.limit,
+  dollars: opts.dollars,
+  dev: opts.dev,
+  json: opts.json,
+  log: ctx.log,
+  ps: ctx.ps,
+  send: ctx.fetch
+}));
+splatesBudget.command("raise").description("add dollars to a limit for a while, on top of what it is set to, then show the budget").arg("limit", LIMIT, LIMIT_ARG).arg("dollars", z3.string(), { description: "how much to add, like 2 or 0.1" }).option("for", z3.string(), {
+  default: "1d",
+  description: "how long it lasts, in hours, days or weeks, like 24h, 1d or 2w"
+}).option("dev", z3.string(), DEV).option("json", z3.boolean(), JSON_OPTION).action((opts, ctx) => raiseBudget({
+  limit: opts.limit,
+  dollars: opts.dollars,
+  for: opts.for,
+  dev: opts.dev,
+  json: opts.json,
+  log: ctx.log,
+  ps: ctx.ps,
+  send: ctx.fetch
+}));
+splatesBudget.command("end").description("end a raise now, by the number `show` gives it").arg("id", z3.coerce.number().int(), { description: "the raise's number" }).option("dev", z3.string(), DEV).option("json", z3.boolean(), JSON_OPTION).action((opts, ctx) => endBudgetRaise({
+  id: opts.id,
+  dev: opts.dev,
+  json: opts.json,
+  log: ctx.log,
+  ps: ctx.ps,
+  send: ctx.fetch
+}));
+
+// coordinator.ts
+import {
+  CoordinatorBox
+} from "@stringsync/splates-server/coordinator";
+import { RUNNING } from "@stringsync/splates-server/server";
+import { cli as cli3 } from "webappwiz/cmd";
+import { z as z4 } from "zod";
+var splatesCoordinator = cli3("coordinator").description("the always-on box in your own Hetzner Cloud account that `splates server` moves onto, made through Pulumi with the token and state the Cloud workers setup readied: a CPX21 in Ashburn with Hetzner's daily backups, reached by SSH alone");
+splatesCoordinator.command("up").description("make the coordinator's box, or bring it to its program, with splates of this release installed for the user splates and an SSH key splates makes under ~/.splates/coordinator; run again, it changes only what is not so already. The box serves nothing until the coordinator moves onto it").option("json", z4.boolean(), { default: false, description: "emit JSON" }).action(async (opts, ctx) => {
+  ctx.log.info("making the coordinator's box; its first boot takes minutes");
+  print(ctx, await box(ctx).up(), opts.json);
+});
+splatesCoordinator.command("status").description("print the coordinator's box as its Pulumi stack has it").option("json", z4.boolean(), { default: false, description: "emit JSON" }).action(async (opts, ctx) => {
+  const standing = await box(ctx).status();
+  if (standing === null) {
+    ctx.log.info(opts.json ? "null" : "no coordinator's box: `splates coordinator up` makes one");
+    return;
+  }
+  print(ctx, standing, opts.json);
+});
+splatesCoordinator.command("remove").description("destroy the coordinator's box and its backups, lifting the protection that keeps it from deletion first, and forget its stack; its SSH key stays. Anything only on the box is lost").action(async (_opts, ctx) => {
+  await box(ctx).remove();
+  ctx.log.info("removed the coordinator's box");
+});
+function box(ctx) {
+  return new CoordinatorBox({ version: RUNNING, ps: ctx.ps, fs: ctx.fs });
+}
+function print(ctx, standing, json) {
+  if (json) {
+    ctx.log.info(JSON.stringify(standing));
+    return;
+  }
+  ctx.log.info([
+    `address:  ${standing.ipv4}`,
+    `server:   ${standing.serverId} (${standing.serverType} in ${standing.location})`,
+    `ssh:      ssh -i ${standing.key} root@${standing.ipv4}`
+  ].join(`
+`));
+}
+
+// creds.ts
+import { DEFAULT_TIMEOUT } from "@stringsync/splates-server/creds";
+import { fail as fail3 } from "@stringsync/splates-server/exit";
+import { repository as repository2 } from "@stringsync/splates-server/records";
+import { untilAfter } from "@stringsync/splates-server/tasks";
+import { cli as cli4 } from "webappwiz/cmd";
+import { color } from "webappwiz/log";
+import { Duration } from "webappwiz/time";
+import { z as z5 } from "zod";
+var splatesCreds = cli4("creds").description("creds an agent needs a person for, such as an API token: request one saying what it is for, with instructions for getting it, which the Creds page of `splates server` shows for the person to paste, then wait for it; the value goes into the system's store (the macOS Keychain, Windows Credential Manager, a Linux secret service), never to the agent, and code reads it through webappwiz/creds");
+splatesCreds.command("request").use(repository2({ needs: "own" })).description("ask a person for a cred, saying why it is needed and what it will be used for, with markdown instructions for getting it; returns at once, and does nothing when the store already keeps it unless --replace; run from a worktree, it records the task asking").arg("name", z5.string(), {
+  description: "what it is kept as, an environment variable's name"
+}).option("purpose", z5.string(), {
+  default: "",
+  description: "why it is needed and what it will be used for, in a sentence the person reads before getting it"
+}).option("instructions", z5.string(), {
+  default: "",
+  description: "how to get it, in markdown: where to go, what to pick, what to paste"
+}).option("device", z5.boolean(), {
+  default: false,
+  description: "keep it for every project on this device, as for a person's own account, rather than this project alone"
+}).option("replace", z5.boolean(), {
+  default: false,
+  description: "ask again although one is kept, since the kept one does not work; --purpose and --instructions left off are those of the last request"
+}).action(async (opts, ctx) => {
+  const scope = opts.device ? "device" : "project";
+  const request = await ctx.journal.record("creds request", null, async () => ctx.creds.request(opts.name, {
+    scope,
+    purpose: opts.purpose,
+    instructions: opts.instructions,
+    task: await here(ctx),
+    replace: opts.replace
+  }), (asked) => ({ name: opts.name, asked: asked !== null }));
+  if (request === null) {
+    ctx.log.info(`${color.green("kept")} ${opts.name} in ${ctx.creds.label(scope)}: nothing to ask`);
+    return;
+  }
+  ctx.log.info(`${color.yellow("requested")} ${opts.name}  ${color.dim(request.purpose)}`);
+  ctx.log.error(`It shows on the Creds page of \`splates server\`. \`splates creds wait ${opts.name}\` until it is saved.`);
+});
+splatesCreds.command("wait").use(repository2({ needs: "own" })).description("block until a person saves the cred requested, or dismisses the request (`dismissed`); gives up with `timeout` rather than waiting forever").arg("name", z5.string(), { description: "the cred requested" }).option("timeout-secs", z5.coerce.number(), {
+  default: DEFAULT_TIMEOUT.secs,
+  description: "how long to wait before giving up"
+}).action(async (opts, ctx) => {
+  const timeout = Duration.secs(opts["timeout-secs"]);
+  await ctx.journal.waiting("creds wait", null, { name: opts.name, until: untilAfter(timeout) }, async () => {
+    const ended = await ctx.creds.wait(opts.name, { timeout });
+    if (ended === "dismissed") {
+      fail3("dismissed", `${opts.name} was dismissed: carry on without it, or ask the person why`, { name: opts.name });
+    }
+  });
+  ctx.log.info(`${color.green("saved")} ${opts.name}`);
+});
+splatesCreds.command("list").use(repository2({ needs: "read" })).description("the creds requested and still open, with what each is for, and every cred the project's store and the device's keep, by name; never a value").option("json", z5.boolean(), { default: false, description: "emit JSON" }).action(async (opts, ctx) => {
+  const open = (await ctx.creds.requests()).filter((each) => each.status === "open");
+  const kept = await ctx.creds.kept();
+  if (opts.json) {
+    ctx.log.info(JSON.stringify({ requested: open, kept }, null, 2));
+    return;
+  }
+  for (const each of open) {
+    ctx.log.info(`${color.yellow("requested")} ${each.name}  ${color.dim(each.scope)}${each.task === null ? "" : color.dim(`  by ${each.task}`)}`);
+    if (each.purpose !== "") {
+      ctx.log.info(`          ${each.purpose}`);
+    }
+  }
+  for (const each of kept) {
+    ctx.log.info(`${color.green("kept")}      ${each.name}  ${color.dim(each.scope)}${each.savedBy === null ? "" : color.dim(`  saved by ${each.savedBy}`)}`);
+  }
+  if (open.length === 0 && kept.length === 0) {
+    ctx.log.info(color.dim("no creds requested or kept"));
+  }
+});
+
+// lane.ts
+import {
+  laneAdd,
+  laneList,
+  laneRemove,
+  laneShow,
+  laneUpdate,
+  laneUpdated,
+  recordLaneRemove
+} from "@stringsync/splates-server/board";
+import { UNTRIAGED } from "@stringsync/splates-server/plans";
+import { repository as repository3 } from "@stringsync/splates-server/records";
+import { cli as cli5 } from "webappwiz/cmd";
+import { z as z6 } from "zod";
+var splatesLane = cli5("lane").description("lanes: named runs of todos, landed top first; `[SPLATES LANE <n>]` from `splates server` starts an orchestrator on one, handing out each todo nothing holds back to an agent on the model it names, or doing it itself. A todo in no lane is untriaged, and `[SPLATES LANE untriaged]` starts one that places those in lanes first");
+splatesLane.command("list").use(repository3({ needs: "read" })).description("every lane: its name, its todos in order, the tasks on it, its next todo, 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(repository3({ needs: "read" })).description("one lane step by step, and what its agent does next: start the next todo, or wait for the one blocking it in another lane to land first; `untriaged` lists the todos in no lane, to place in lanes").arg("lane", z6.union([
+  z6.literal(UNTRIAGED).transform(() => null),
+  z6.coerce.number().int().positive()
+], { error: "pass a lane's number, or untriaged" }), { description: "lane number, or `untriaged`" }).option("json", z6.boolean(), { default: false, description: "emit JSON" }).action((opts, ctx) => laneShow(ctx, opts.lane, { json: opts.json }));
+splatesLane.command("add").use(repository3({ needs: "tasks" })).description("start an empty lane, after the others").arg("name", z6.string(), {
+  description: "what its todos are for, like `Licensing`"
+}).action(async (opts, ctx) => {
+  await ctx.journal.record("lane add", null, () => laneAdd(ctx, opts.name), (lane) => ({ lane: lane.id, name: lane.name }));
+});
+splatesLane.command("update").use(repository3({ needs: "tasks" })).description("rename a lane, or move it among the others").arg("lane", z6.coerce.number().int().positive(), {
+  description: "lane number"
+}).option("name", z6.string().optional(), {
+  description: "what it is called from now on"
+}).option("position", position, {
+  description: "where to move it among the lanes, 1 the first column on the board; the others close up around it"
+}).action(async (opts, ctx) => {
+  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("remove").use(repository3({ needs: "tasks" })).description("remove a lane, putting its todos back with the untriaged ones; a lane whose last todo merges goes on its own").arg("lane", z6.coerce.number().int().positive(), {
+  description: "lane number"
+}).action((opts, ctx) => recordLaneRemove(ctx.journal, ctx.todos, opts.lane, () => laneRemove(ctx, opts.lane)));
+
+// projects.ts
+import {
+  grantReach,
+  listReaches,
+  REACHES
+} from "@stringsync/splates-server/projects";
+import { repository as repository4 } from "@stringsync/splates-server/records";
+import { cli as cli6 } from "webappwiz/cmd";
+import { z as z7 } from "zod";
+var splatesProjects = cli6("projects").description("the other splates projects on this machine, and what agents of each may do in the others through splates: `read` their tasks, todos and lanes; add `todos` to their untriaged lane, as every project may until granted otherwise; or hand their `tasks` to agents and orchestrate them. Any repo command runs on another project as `splates --project <slug> <command>`, refused where it needs more than that project granted").fallback("list");
+splatesProjects.command("list").use(repository4({ needs: "read" })).description("print each other project: its slug, its root, what it may do here, and what this one may do there").option("json", z7.boolean(), { default: false, description: "emit JSON" }).action((opts, ctx) => listReaches(ctx, { json: opts.json }));
+splatesProjects.command("grant").use(repository4({ needs: "own" })).description("let agents of another project do as much as `read`, `todos` or `tasks` here, each including those before it; the user's call, so an agent runs it only when the user asks it to").arg("project", z7.string(), { description: "the other project's slug" }).arg("reach", z7.enum(REACHES), {
+  description: "read, todos or tasks"
+}).action((opts, ctx) => grantReach(ctx, opts.project, opts.reach));
+
+// queue.ts
+import { listQueue, moveQueued } from "@stringsync/splates-server/workers";
+import { cli as cli7 } from "webappwiz/cmd";
+import { z as z8 } from "zod";
+var DEV2 = {
+  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 splatesQueue = cli7("queue").description("the agents waiting for a slot on a worker of the running `splates server`: each one another agent started (with `splates add --agent`, or a lane's orchestrator handing out todos), started or resumed while every worker it can run on is full, waits here, first come, first served, and starts once a slot frees, as when an agent left idle 30 minutes stops; none is ever failed for waiting. An agent you start waits only while no worker it can run on is up, as with this machine's own removed or none on the platform its project requires");
+splatesQueue.command("list").description("list the agents waiting for a slot, first in line first: position, project, task, conversation, how long each has waited and why (no free slot, no worker up, or a platform no worker runs, as `needs macOS`)").option("dev", z8.string(), DEV2).option("json", z8.boolean(), { default: false, description: "emit JSON" }).action((opts, ctx) => listQueue({
+  dev: opts.dev,
+  json: opts.json,
+  log: ctx.log,
+  ps: ctx.ps,
+  send: ctx.fetch
+}));
+splatesQueue.command("move").description("move an agent waiting for a slot to another place in line, from 1 for the next to start, then list the queue").arg("which", z8.string(), {
+  description: "the task it works, or its conversation's id"
+}).arg("position", z8.coerce.number().int(), {
+  description: "where in line to put it, from 1"
+}).option("dev", z8.string(), DEV2).option("json", z8.boolean(), { default: false, description: "emit JSON" }).action((opts, ctx) => moveQueued({
+  which: opts.which,
+  position: opts.position,
+  dev: opts.dev,
+  json: opts.json,
+  log: ctx.log,
+  ps: ctx.ps,
+  send: ctx.fetch
+}));
+
+// setup.ts
+import { dirname } from "node:path";
+import { SYSTEM_STORES as SYSTEM_STORES2 } from "@stringsync/splates-server/creds";
+import { splatesHome as splatesHome2 } from "@stringsync/splates-server/models";
+import { Projects } from "@stringsync/splates-server/projects";
+import {
+  SETUP_AREAS,
+  Setup,
+  setupProjectAt
+} from "@stringsync/splates-server/setup";
+import {
+  fetchWorkerBudget,
+  fetchWorkers,
+  putWorkerLimit
+} from "@stringsync/splates-server/workers";
+import { color as color2 } from "webappwiz/log";
+async function setup(deps, opts) {
+  const machine = await setupOf(deps);
+  const { log } = deps;
+  if (opts.step !== "") {
+    machine.step(opts.step);
+    if (opts.skip) {
+      await machine.skip(opts.step);
+    } else if (opts.unskip) {
+      await machine.unskip(opts.step);
+    }
+  }
+  const progress = await machine.read();
+  if (opts.step === "") {
+    if (opts.json) {
+      log.info(JSON.stringify(progress, null, 2));
+      return;
+    }
+    printProgress(log, progress);
+    return;
+  }
+  const step = progress.areas.flatMap((area) => area.steps).find((each) => each.id === opts.step);
+  if (opts.json) {
+    log.info(JSON.stringify(step, null, 2));
+    return;
+  }
+  printStep(log, step);
+}
+async function setupOf(deps) {
+  const { fs, ps, secrets = SYSTEM_STORES2, fetch } = deps;
+  const root = deps.project === undefined ? await repoRoot(ps) : (await Projects.ofMachine(deps).named(deps.project)).root;
+  return new Setup({
+    fs,
+    ps,
+    home: splatesHome2(ps),
+    device: secrets.device,
+    fetch,
+    workers: deps.ps.env("SPLATES_DEV") ? () => fetchWorkers({ dev: "", log: deps.log, ps: deps.ps }) : undefined,
+    workerBudget: deps.ps.env("SPLATES_DEV") ? {
+      report: () => fetchWorkerBudget({ dev: "", log: deps.log, ps: deps.ps }),
+      set: (limit, dollars) => putWorkerLimit(limit, dollars, {
+        dev: "",
+        log: deps.log,
+        ps: deps.ps
+      })
+    } : undefined,
+    project: root === null ? undefined : setupProjectAt(root, { fs, ps })
+  }, SETUP_AREAS);
+}
+async function repoRoot(ps) {
+  const { exitCode, stdout } = await ps.spawnCapture([
+    "git",
+    "-C",
+    ps.cwd(),
+    "rev-parse",
+    "--path-format=absolute",
+    "--git-common-dir"
+  ]);
+  return exitCode === 0 ? dirname(stdout.trim()) : null;
+}
+var MARKS = {
+  done: color2.green("✓"),
+  skipped: color2.dim("-"),
+  ready: color2.yellow("○"),
+  waiting: color2.dim("○")
+};
+function printProgress(log, progress) {
+  for (const area of progress.areas) {
+    const counts = [
+      `${area.done}/${area.steps.length} done`,
+      area.skipped > 0 ? `${area.skipped} skipped` : ""
+    ].filter(Boolean);
+    log.info(`${color2.bold(area.title)}  ${color2.dim(counts.join(", "))}`);
+    for (const step of area.steps) {
+      const notes = [
+        step.optional ? "optional" : "",
+        step.status === "waiting" ? `after ${step.after.join(", ")}` : "",
+        step.problem ?? ""
+      ].filter(Boolean);
+      log.info(`  ${MARKS[step.status]} ${step.id}  ${step.title}${notes.length > 0 ? color2.dim(`  ${notes.join("; ")}`) : ""}`);
+    }
+  }
+  const next = progress.areas.flatMap((area) => area.steps).find((step) => step.id === progress.next);
+  log.info(next === undefined ? color2.green("nothing left to set up") : `next: ${next.title}  ${color2.dim(`splates setup ${next.id}`)}`);
+}
+function printStep(log, step) {
+  log.info(`${color2.bold(step.title)}  ${color2.dim(`${step.status}${step.optional ? ", optional" : ""}`)}`);
+  log.info(step.why);
+  if (step.detail !== null) {
+    log.info(step.detail);
+  }
+  log.info(`you:    ${step.user}`);
+  log.info(`agent:  ${step.agent}`);
+  if (step.after.length > 0) {
+    log.info(`after:  ${step.after.join(", ")}`);
+  }
+  if (step.problem !== null) {
+    log.info(`${color2.red("problem:")} ${step.problem}`);
+  }
+}
+
+// slots.ts
+import { Slots } from "@stringsync/splates-server/ports";
+import { cli as cli8 } from "webappwiz/cmd";
+import { z as z9 } from "zod";
+var splatesSlots = cli8("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", z9.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 }) => ({
+      word: slot.word,
+      tree,
+      pid,
+      orphaned
+    }))));
+    return;
+  }
+  if (held.length === 0) {
+    ctx.log.info("no slot is claimed");
+    return;
+  }
+  ctx.log.info(held.map(heldLine).join(`
+`));
+});
+splatesSlots.command("prune").description("free every orphaned word, stopping its server, so another tree can claim it; the slots a task's worktree holds are that task's, and left alone. The way to free a slot: never kill another tree's server or edit ~/.splates/slots.json").action(async (_opts, ctx) => {
+  const freed = await Slots.ofMachine(ctx).prune();
+  if (freed.length === 0) {
+    ctx.log.info("nothing to prune: each claimed word is held by a task's worktree");
+    return;
+  }
+  ctx.log.info(freed.map(({ slot, tree, pid }) => `freed ${slot.word} ${slot.emoji} from ${tree}${pid === null ? "" : `, its server (pid ${pid}) stopped`}`).join(`
+`));
+});
+function heldLine({ slot, tree, pid, orphaned }) {
+  const server = pid === null ? "no server" : `server pid ${pid}`;
+  return `${slot.word} ${slot.emoji}  ${tree}  ${server}${orphaned ? "  orphaned: `splates slots prune` frees it" : ""}`;
+}
+
+// todo.ts
+import {
+  addedFacts,
+  recordUpdate,
+  todoAdd,
+  todoList,
+  todoRelease,
+  todoRemove,
+  todoShow,
+  todosNamed,
+  todoTake,
+  todoUpdate
+} from "@stringsync/splates-server/board";
+import { commaList as commaList3 } from "@stringsync/splates-server/comma-list";
+import { fail as fail4 } from "@stringsync/splates-server/exit";
+import { repository as repository5 } from "@stringsync/splates-server/records";
+import {
+  DEFAULT_TIMEOUT as DEFAULT_TIMEOUT2,
+  todoWait,
+  untilAfter as untilAfter2
+} from "@stringsync/splates-server/tasks";
+import { cli as cli9 } from "webappwiz/cmd";
+import { Duration as Duration2 } from "webappwiz/time";
+import { z as z10 } from "zod";
+var splatesTodo = cli9("todo").description("defer work for later instead of growing the task you are in: `merge` recommends the next one when a task lands");
+splatesTodo.command("add").use(repository5({ needs: "todos" })).description("note something to do later and move on; run from a worktree, it records the task it came up in").arg("subject", z10.string(), { description: "what is left to do, in a line" }).arg("text", z10.string(), {
+  default: "",
+  description: "whatever more there is to say about it, in markdown"
+}).option("position", position, {
+  description: "where it goes in the list, 1 at the top, pushing those from there down (default: the bottom)"
+}).option("file", z10.string(), {
+  default: "",
+  description: "files to attach, comma separated: copied under .git/splates/todos/<id>/"
+}).option("blocked-by", z10.string(), {
+  default: "",
+  description: "ids of the todos blocking it, comma separated: each has to merge before this one starts"
+}).option("lane", z10.string(), {
+  default: "",
+  description: "the lane it goes in, at the bottom: a lane's number, or `new` for one of its own (default: none, untriaged)"
+}).option("agent", z10.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", z10.string(), {
+  default: "",
+  description: "with --agent: the model, by its id or name on the roster"
+}).option("effort", z10.string(), {
+  default: "",
+  description: "with --agent: the thinking level, one the agent offers (default: the agent's own)"
+}).action(async (opts, ctx) => {
+  if (ctx.elsewhere !== null && opts.lane !== "") {
+    fail4("not_granted", "a todo from another project goes in its untriaged lane, for whoever orchestrates it there to place: leave --lane off", { subject: opts.subject });
+  }
+  const from = await here(ctx);
+  const assignee = await assigneeIn(ctx, opts.agent, opts.model, opts.effort);
+  const origin = ctx.elsewhere === null ? undefined : {
+    project: ctx.elsewhere,
+    task: ctx.project === undefined ? null : ctx.service.taskFor(await ctx.git.currentBranch(ctx.ps.cwd()))
+  };
+  await ctx.journal.record("todo add", from, () => todoAdd(ctx, opts.subject, from, {
+    text: opts.text,
+    position: opts.position,
+    files: commaList3(opts.file),
+    blockedBy: todoIds(opts["blocked-by"]),
+    lane: laneIn(opts.lane) ?? null,
+    assignee,
+    origin
+  }), addedFacts);
+});
+splatesTodo.command("list").use(repository5({ needs: "read" })).description("every todo, top of the list first, with the task it came from and the task that took it up").option("json", z10.boolean(), { default: false, description: "emit JSON" }).option("open", z10.boolean(), {
+  default: false,
+  description: "only todos no task has taken up: the ones free to pick up"
+}).option("ready", z10.boolean(), {
+  default: false,
+  description: "only todos free to start now: nobody has taken them, and nothing blocking them is still open"
+}).action((opts, ctx) => todoList(ctx, {
+  json: opts.json,
+  open: opts.open,
+  ready: opts.ready
+}));
+splatesTodo.command("show").use(repository5({ needs: "read" })).description("one todo in full: where it stands, its files, and its detail").arg("id", z10.coerce.number().int().positive(), { description: "todo id" }).option("json", z10.boolean(), { default: false, description: "emit JSON" }).action((opts, ctx) => todoShow(ctx, opts.id, { json: opts.json }));
+splatesTodo.command("update").use(repository5({ needs: "tasks" })).description("say what a todo is in other words, move it up or down the list, or attach and drop files; it keeps its id").arg("id", z10.coerce.number().int().positive(), { description: "todo id" }).arg("text", z10.string(), {
+  default: "",
+  description: "whatever more there is to say about it, in markdown; leave out to keep the detail"
+}).option("subject", z10.string(), {
+  default: "",
+  description: "what is left to do, in a line; 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"
+}).option("file", z10.string(), {
+  default: "",
+  description: "files to attach, comma separated"
+}).option("remove-file", z10.string(), {
+  default: "",
+  description: "attached files to drop, comma separated, by path or stored name"
+}).option("blocked-by", z10.string(), {
+  default: "",
+  description: "ids of more todos blocking it, comma separated: each has to merge before this one starts; refused when that makes a loop"
+}).option("remove-blocked-by", z10.string(), {
+  default: "",
+  description: "ids of todos no longer blocking it, comma separated"
+}).option("lane", z10.string(), {
+  default: "",
+  description: "move it to a lane, at the bottom: a lane's number, `new` for one of its own, or `none` to put it back with the untriaged"
+}).option("agent", z10.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", z10.string(), {
+  default: "",
+  description: "with --agent: the model, by its id or name on the roster"
+}).option("effort", z10.string(), {
+  default: "",
+  description: "with --agent: the thinking level, one the agent offers (default: the agent's own)"
+}).action(async (opts, ctx) => {
+  const assignee = await assigneeIn(ctx, opts.agent, opts.model, opts.effort);
+  await recordUpdate(ctx.journal, ctx.todos, opts.id, () => todoUpdate(ctx, opts.id, {
+    subject: opts.subject,
+    text: opts.text,
+    position: opts.position,
+    files: commaList3(opts.file),
+    removeFiles: commaList3(opts["remove-file"]),
+    blockedBy: todoIds(opts["blocked-by"]),
+    removeBlockedBy: todoIds(opts["remove-blocked-by"]),
+    lane: laneIn(opts.lane),
+    assignee
+  }));
+});
+splatesTodo.command("take").use(repository5({ needs: "own" })).description("take up todos for the task whose worktree you are in, as when they turn out to be part of its work: merging removes them, removing the task puts them back").rest("ids", z10.coerce.number().int().positive(), {
+  description: "todo ids"
+}).action(async (opts, ctx) => {
+  const task = await here(ctx);
+  await ctx.journal.record("todo take", task, () => todoTake(ctx, opts.ids, task), (taken) => ({ todos: todosNamed(taken) }));
+});
+splatesTodo.command("release").use(repository5({ needs: "own" })).description("put taken todos back on the list, as when a task lands without finishing them: `splates todo update` the leftover first; from a worktree, only its own task's").rest("ids", z10.coerce.number().int().positive(), {
+  description: "todo ids"
+}).action(async (opts, ctx) => {
+  const task = await here(ctx);
+  await ctx.journal.record("todo release", task, () => todoRelease(ctx, opts.ids, task), (released) => ({ todos: todosNamed(released) }));
+});
+splatesTodo.command("remove").use(repository5({ needs: "tasks" })).description("drop a todo that was done some other way or no longer applies").arg("id", z10.coerce.number().int().positive(), { description: "todo id" }).action((opts, ctx) => ctx.journal.record("todo remove", null, () => todoRemove(ctx, opts.id), (removed) => ({ todos: todosNamed([removed]) })));
+splatesTodo.command("wait").use(repository5({ needs: "read" })).description("block until a todo leaves the list, which it does when the task that took it merges: for a todo blocked by one another lane is on; ends early when that task is escalated, and gives up with `timeout`").arg("id", z10.coerce.number().int().positive(), { description: "todo id" }).option("timeout-secs", z10.coerce.number(), {
+  default: DEFAULT_TIMEOUT2.secs,
+  description: "how long to wait before giving up"
+}).action(async (opts, ctx) => {
+  const timeout = Duration2.secs(opts["timeout-secs"]);
+  const todo = (await ctx.todos.all()).find((each) => each.id === opts.id);
+  await ctx.journal.waiting("todo wait", null, {
+    todo: opts.id,
+    subject: todo?.subject ?? null,
+    until: untilAfter2(timeout)
+  }, () => todoWait(ctx, opts.id, { timeout }));
+});
+
+// tunnel.ts
+import { repository as repository6 } 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 cli10 } from "webappwiz/cmd";
+import { z as z11 } from "zod";
+var splatesTunnel = cli10("tunnel").description("reach `splates server` from elsewhere: a Cloudflare tunnel with Cloudflare Access in front, set up once per machine");
+splatesTunnel.command("setup").use(repository6({ 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", z11.string(), {
+  description: "the public host name, in a zone of the account, as in splates.example.com"
+}).option("email", z11.string(), {
+  default: "",
+  description: "comma-separated email addresses Access lets in"
+}).option("name", z11.string(), {
+  default: "splates",
+  description: "what the tunnel, the Access application and its policy are called"
+}).option("team", z11.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({
+  ...opts,
+  creds: ctx.creds,
+  task: await here(ctx),
+  saved: savedTunnelOf(ctx),
+  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", z11.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;
+  if (opts.json) {
+    ctx.log.info(JSON.stringify(record === null ? null : { ...record, token }));
+    return;
+  }
+  if (record === null) {
+    ctx.log.info("no tunnel saved: `splates tunnel setup <host> --email <you>` makes one");
+    return;
+  }
+  ctx.log.info([
+    `host:    https://${record.host}`,
+    `team:    ${record.team}.cloudflareaccess.com`,
+    `aud:     ${record.aud}`,
+    `tunnel:  ${record.tunnel}`,
+    `token:   ${token ? "in the device's store" : "missing: run `splates tunnel setup` again"}`
+  ].join(`
+`));
+});
+splatesTunnel.command("remove").use(repository6({ 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,
+  task: await here(ctx),
+  fs: ctx.fs,
+  log: ctx.log,
+  fetch: ctx.fetch
+})));
+
+// worker.ts
+import {
+  addWorker,
+  drainWorker,
+  listWorkers,
+  removeWorker,
+  setWorkerSlots,
+  wakeWorker,
+  workerJoin,
+  workerRecipe,
+  workerRun
+} from "@stringsync/splates-server/workers";
+import { cli as cli11 } from "webappwiz/cmd";
+import { z as z12 } from "zod";
+var splatesWorker = cli11("worker").description("the machines that run tasks for `splates server`: each dials out to its coordinator and runs what it is given, agents, terminals and the git and process reads around them, on its own machine");
+splatesWorker.command("run").description("run a worker on this machine until stopped: it dials the coordinator, by default the `splates server` on this machine through a socket in ~/.splates only you may open, and dials again whenever the link drops, while what it runs carries on; it stops reading a process's output while the coordinator is away too long, so nothing is lost. Once its agents have moved off it, a coordinator on another build has it restart on that build, through `bunx @stringsync/splates@<build>`, as it does when it refuses this worker for another protocol; one that says no build has it exit `outdated`").option("coordinator", z12.string(), {
+  default: "",
+  description: "the coordinator to dial: a `splates server` URL, whose /api/workers it opens, or unix:<path>; by default this machine's"
+}).option("slots", z12.coerce.number().int().min(0), {
+  default: 0,
+  description: "how many tasks this worker takes at once; by default one for each core and 4 GB of memory it has, whichever is fewer, as a VM such as WSL2 sees them"
+}).option("id", z12.string(), {
+  default: "",
+  description: "what the coordinator knows this worker by, kept across restarts so it picks up where it was; by default the machine's host name"
+}).option("join", z12.string(), {
+  default: "",
+  description: "a join token from `splates worker add` on the coordinator, spent to join it before dialing; the key it answers is kept in this machine's system store, or read from SPLATES_WORKER_KEY on one without"
+}).option("ephemeral", z12.boolean(), {
+  default: false,
+  description: "keep the key --join answers in memory alone, for a machine destroyed rather than restarted, as one a worker provider makes"
+}).option("key-file", z12.boolean(), {
+  default: false,
+  description: "keep the key --join answers in ~/.splates/worker.env, which only this user may read, rather than the system store, for a machine whose store is locked or missing at boot, as WSL's is with no one signed in; read it from there on each run after"
+}).option("quiet", z12.boolean(), {
+  default: false,
+  description: "say only what went wrong, not each time it joins or loses its coordinator, as the worker `splates server` starts beside itself does"
+}).action((opts, ctx) => workerRun({
+  coordinator: opts.coordinator,
+  slots: opts.slots,
+  id: opts.id,
+  join: opts.join,
+  ephemeral: opts.ephemeral,
+  keyFile: opts["key-file"],
+  log: opts.quiet ? { info: () => {}, error: (...said) => ctx.log.error(...said) } : ctx.log,
+  ps: ctx.ps,
+  fs: ctx.fs
+}));
+splatesWorker.command("join").description("spend a join token from `splates worker add` and keep the key it answers, as `splates worker run --join` does, then exit, for an installer that leaves running the worker to a service").option("coordinator", z12.string(), {
+  description: "the coordinator to join: its `splates server` URL"
+}).option("join", z12.string(), {
+  description: "the join token `splates worker add` printed there"
+}).option("id", z12.string(), {
+  default: "",
+  description: "what the coordinator knows this worker by; by default the machine's host name"
+}).option("key-file", z12.boolean(), {
+  default: false,
+  description: "keep the key in ~/.splates/worker.env, which only this user may read, rather than the system store, for `splates worker run --key-file` to read"
+}).action((opts, ctx) => workerJoin({
+  coordinator: opts.coordinator,
+  join: opts.join,
+  id: opts.id,
+  keyFile: opts["key-file"],
+  log: ctx.log,
+  ps: ctx.ps,
+  fs: ctx.fs
+}));
+splatesWorker.command("recipe").description("print the shell script, run as root on a fresh Debian or Ubuntu machine, that installs what a Linux worker needs: bun, git, the shared browser and this build of splates, for the user `splates`. It is what a provider's snapshot is built from, and what the Windows installer runs in WSL").action((_opts, ctx) => workerRecipe({ log: ctx.log }));
+splatesWorker.command("list").description("list the workers the running `splates server` has: kind (local over its socket, registered otherwise), platform, build, protocol, slots used and total, health with when it was last heard, tasks and $/hour, then any it refused for speaking another protocol").option("dev", z12.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", z12.boolean(), { default: false, description: "emit JSON" }).action((opts, ctx) => listWorkers({
+  dev: opts.dev,
+  json: opts.json,
+  log: ctx.log,
+  ps: ctx.ps,
+  send: ctx.fetch
+}));
+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("add").description("add a worker to the running `splates server`: prints a join token, single use and good for 15 minutes, for `splates worker run --join <token>` on the machine to join, which gets a key of its own that `splates worker remove` revokes; with --local N, makes this machine's own worker run N agents at once and take new ones again, adding it back if it was removed; with --provider, has the `workerProvider` in splates.config.ts make one, booted from the snapshot splates builds for it, which joins on its own and whose machine `splates worker remove` destroys").option("local", z12.coerce.number().int().min(0), {
+  default: 0,
+  description: "this machine's own worker, with this many slots"
+}).option("provider", z12.boolean(), {
+  default: false,
+  description: "have the server's worker provider make the worker, of its cheapest type unless --type says"
+}).option("type", z12.string(), {
+  default: "",
+  description: "the worker provider's type to make, as it names it; implies --provider"
+}).option("dev", z12.string(), dev).action((opts, ctx) => addWorker({
+  local: opts.local,
+  provider: opts.provider,
+  type: opts.type,
+  dev: opts.dev,
+  log: ctx.log,
+  ps: ctx.ps,
+  send: ctx.fetch
+}));
+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", z12.string(), {
+  description: "the worker, as `splates worker list` names it"
+}).option("undo", z12.boolean(), {
+  default: false,
+  description: "take new agents again"
+}).option("dev", z12.string(), dev).action((opts, ctx) => drainWorker({
+  id: opts.id,
+  undo: opts.undo,
+  dev: opts.dev,
+  log: ctx.log,
+  ps: ctx.ps,
+  send: ctx.fetch
+}));
+splatesWorker.command("wake").description("wake a worker asleep at home, a Windows PC that joined in WSL2: a worker awake on its network sends the Wake-on-LAN packet. Placement wakes one by itself when agents queue, before making a worker").arg("id", z12.string(), {
+  description: "the worker, as `splates worker list` names it"
+}).option("dev", z12.string(), dev).action((opts, ctx) => wakeWorker({
+  id: opts.id,
+  dev: opts.dev,
+  log: ctx.log,
+  ps: ctx.ps,
+  send: ctx.fetch
+}));
+splatesWorker.command("slots").description("set how many agents a worker runs at once, from now on, over what it started with").arg("id", z12.string(), {
+  description: "the worker, as `splates worker list` names it"
+}).arg("slots", z12.coerce.number().int().min(1), {
+  description: "how many at once"
+}).option("dev", z12.string(), dev).action((opts, ctx) => setWorkerSlots({
+  id: opts.id,
+  slots: opts.slots,
+  dev: opts.dev,
+  log: ctx.log,
+  ps: ctx.ps,
+  send: ctx.fetch
+}));
+splatesWorker.command("remove").description("remove a worker, revoking its key: one with agents on it drains and is removed once they end; --force ends them now, frees their slots, and places each again on another worker, to carry on its task from the checkpoint it last pushed. This machine's own worker, `local`, stops taking agents, its agents running to their end, and leaves this machine only coordinating until `splates worker add --local <slots>`; it takes no --force").arg("id", z12.string(), {
+  description: "the worker, as `splates worker list` names it"
+}).option("force", z12.boolean(), {
+  default: false,
+  description: "end the agents on it now rather than wait for them"
+}).option("dev", z12.string(), dev).action((opts, ctx) => removeWorker({
+  id: opts.id,
+  force: opts.force,
+  dev: opts.dev,
+  log: ctx.log,
+  ps: ctx.ps,
+  send: ctx.fetch
+}));
+
+// splates.ts
+function projectArgs(argv) {
+  const [first, second, ...rest] = argv;
+  if (first === "--project" && second !== undefined) {
+    return { project: second, argv: rest };
+  }
+  if (first?.startsWith("--project=")) {
+    return {
+      project: first.slice("--project=".length),
+      argv: argv.slice(1)
+    };
+  }
+  return { argv };
+}
+var splates = cli12("splates").use(exits());
+splates.command("init").use(repository7({ 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("update").use(repository7({ 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 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,
+    ps: ctx.ps,
+    log: ctx.log,
+    newest: () => newest()
+  });
+  if (code !== 0) {
+    ctx.ps.exit(code);
+  }
+});
+splates.command("heavy").description("run a heavy command (a full test run, an install) in one of this machine's heavy-job slots, waiting for one to come free first, so agents testing at once queue rather than run out of memory; `SPLATES_HEAVY_JOBS` sets how many run at once, 2 by default").rest("command", z13.string(), {
+  description: "the command and its arguments, after `--`"
+}).action(async (opts, ctx) => {
+  const code = await runHeavy(ctx, opts.command);
+  if (code !== 0) {
+    ctx.ps.exit(code);
+  }
+});
+splates.command("forget").use(repository7({ 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(repository7({ needs: "tasks" })).description("start a new task: create branch task/<task>, a worktree at ../<repo>-splates.noindex/<task> and a state record").arg("task", z13.string(), { description: "task name (lowercase-with-dashes)" }).option("base", z13.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("todo", z13.string(), {
+  default: "",
+  description: "take up these todos, comma separated: their words become the plan's Goal, merging removes them, and removing the task puts them back"
+}).option("goal", z13.string(), {
+  default: "",
+  description: "one or two lines on what done means, written under `## Goal` in the task's SPLATES.md; required unless --todo seeds the Goal"
+}).option("agent", z13.string(), {
+  default: "",
+  description: "hand the task to an agent on the roster (`splates agents`), which `splates server` starts in the worktree, told to claim it; the conversation you run this from stays where it is"
+}).option("model", z13.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", z13.string(), {
+  default: "",
+  description: "with --agent: the thinking level it works at, one the agent offers (default: the agent's own)"
+}).option("prompt", z13.string(), {
+  default: "",
+  description: "with --agent: what to tell the agent beyond claiming the task, such as a part's instructions"
+}).option("over-capacity", z13.boolean(), {
+  default: false,
+  description: "with --agent: hand it out though you have as many tasks out to agents as agentsPerAgent (splates.config.ts) allows; only when the person explicitly asked for more at once"
+}).action(async (opts, ctx) => {
+  if (opts.agent === "" && (opts.model !== "" || opts.effort !== "" || opts.prompt !== "" || opts["over-capacity"])) {
+    fail5("usage", "--model, --effort, --prompt and --over-capacity go with --agent", { task: opts.task });
+  }
+  if (opts.goal.trim() === "" && opts.todo === "") {
+    fail5("usage", `say what done means: \`splates add ${opts.task} --goal "<one or two lines>"\`, or take todos with --todo`, { task: opts.task });
+  }
+  const dispatch = opts.agent === "" ? undefined : {
+    agent: opts.agent,
+    ...opts.model === "" ? {} : { model: opts.model },
+    ...await effortIn(ctx, opts.agent, opts.effort, {
+      task: opts.task
+    }),
+    ...opts.prompt === "" ? {} : { prompt: opts.prompt }
+  };
+  const agents = dispatch === undefined ? [] : await seeded2(rosterOf2(ctx));
+  const all = await ctx.todos.all();
+  const subjects = todoIds(opts.todo).flatMap((id) => all.find((todo) => todo.id === id)?.subject ?? []);
+  await ctx.journal.record("add", opts.task, () => add(ctx, opts.task, {
+    base: opts.base || undefined,
+    todos: todoIds(opts.todo),
+    goal: opts.goal.trim() || undefined,
+    dispatch,
+    agents,
+    away: ctx.elsewhere !== null,
+    overCapacity: opts["over-capacity"],
+    onTree: dispatch === undefined ? () => follow(ctx, opts.task, { base: opts.base || undefined }) : undefined
+  }), {
+    base: opts.base || ctx.config.trunk,
+    todos: todoIds(opts.todo),
+    goal: opts.goal.trim() || null,
+    subjects,
+    agent: dispatch?.agent ?? null,
+    model: dispatch?.model ?? null
+  });
+  if (ctx.elsewhere !== null) {
+    await serveProject(ctx);
+  }
+});
+splates.command("claim").use(repository7({ needs: "own" })).description("resume an existing task: take ownership of its worktree and print its path, status and any half-finished rebase; an escalated task goes back to working; 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", z13.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(repository7({ 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").action(async (_opts, ctx) => {
+  const task = await here(ctx);
+  const landing = task === null ? null : await ctx.service.find(task);
+  const facts = {};
+  await ctx.journal.record("merge", task, () => merge(ctx, ctx.ps.cwd(), facts), facts);
+  if (task !== null) {
+    await addFactTodos(ctx, task).catch((error) => ctx.log.error(`could not add todos for what the merge found: ${error}`));
+    await follow(ctx, null, { from: task });
+  }
+  if (landing !== null) {
+    await reportToCaller(ctx, landing);
+  }
+});
+splates.command("remove").use(repository7({ needs: "tasks" })).description("discard a task: worktree, branch and state file; cheap and encouraged, since redoing a task against current trunk often beats a hard rebase").arg("task", z13.string(), { description: "task name" }).option("force", z13.boolean(), {
+  default: false,
+  description: "discard even when another agent holds the lease"
+}).option("reason", z13.optional(z13.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)"
+}).action(async (opts, ctx) => {
+  const removing = await ctx.service.find(opts.task);
+  await ctx.journal.record("remove", opts.task, () => remove(ctx, opts.task, { force: opts.force, reason: opts.reason }), ({ released }) => ({ why: opts.reason ?? null, released }));
+  await follow(ctx, null, { from: opts.task });
+  await reportToCaller(ctx, removing);
+});
+splates.command("list").use(repository7({ needs: "read" })).description("list every task: 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").option("json", z13.boolean(), { default: false, description: "emit JSON" }).option("files", z13.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(repository7({ 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").arg("task", z13.string(), { description: "task name" }).option("json", z13.boolean(), { default: false, description: "emit JSON" }).action((opts, ctx) => show(ctx, opts.task, { json: opts.json }));
+splates.command("wait").use(repository7({ needs: "read" })).description("block until a task stops moving: escalated, or gone (merged or removed), or broken; takes no lease, and gives up with `timeout` rather than waiting forever").arg("task", z13.string(), { description: "task name" }).option("timeout-secs", z13.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(repository7({ needs: "read" })).description("show what has been done here recently: one line per add, claim, merge, remove, escalate, retry, todo and more, with how it ended; outlives the tasks themselves").option("count", z13.coerce.number(), {
+  default: DEFAULT_COUNT,
+  description: "how many entries to show"
+}).option("json", z13.boolean(), { default: false, description: "emit JSON" }).action((opts, ctx) => showLog(ctx, { count: opts.count, json: opts.json }));
+splates.command("server").description("serve every splates project on this machine as a web page, from wherever it is run: the page picks the project it shows, adds one by its path, running `splates init` there, and shows its todos and tasks, where todos can be added, updated, reordered or removed; it brings each project's records forward as it opens it").option("port", z13.coerce.number(), {
+  default: DEFAULT_PORT,
+  description: "port to listen on, or the next open one above it"
+}).option("allow-hosts", z13.string(), {
+  default: "",
+  description: "comma-separated host names the page may also be reached by, like a tunnel's; put Cloudflare Access in front of them with --access-team and --access-aud"
+}).option("access-team", z13.string(), {
+  default: "",
+  description: "the Cloudflare Access team in front of --allow-hosts, as in <team>.cloudflareaccess.com; with --access-aud, those hosts answer only to a verified Access token, and may then use conversations and terminals"
+}).option("access-aud", z13.string(), {
+  default: "",
+  description: "the AUD tag of that Access application"
+}).option("tunnel", z13.string(), {
+  default: "",
+  description: "the public host name of a tunnel to run, with cloudflared or the tunnel provider named by splates.config.ts in the repository it is run in, if any, which is allowed as a host too; refused without --access-team and --access-aud, so a tunnel never exposes the page unauthenticated. With none of the tunnel and Access flags, the tunnel `splates tunnel setup` saved runs, if any"
+}).option("tunnel-name", z13.string(), {
+  default: "",
+  description: "the named tunnel cloudflared runs for --tunnel, by default the one its own config names; not with a tunnel provider of splates.config.ts"
+}).option("ports-host", z13.string(), {
+  default: "",
+  description: "the wildcard base host to serve task ports under, saved for this machine so a bare `splates server` serves it too: each port a task's processes listen on opens at https://<task>-<port>.<base>, to whoever Cloudflare Access lets in, and is refused without Access; routing *.<base> here, its DNS and TLS, are yours. `none` forgets it, leaving each task port forwarded to a port on this machine's loopback alone"
+}).option("worker-slots", z13.coerce.number().int().min(1), {
+  default: LOCAL_SLOTS,
+  description: "how many agents that other agents started (with `splates add --agent`, or a lane's orchestrator handing out todos) this machine's worker runs at once; past them, each new or resumed one waits in the queue, first come, first served, which `splates queue` shows and reorders. An agent you start runs at once on any worker up, taking no slot. Read as the server starts its worker, which a restart from the page leaves running"
+}).option("slot", z13.boolean(), {
+  default: false,
+  description: "serve this checkout's splates at https://<word>.<zone>, a slot of its own on the zone `splates tunnel setup` uses, behind the same Access policy, so several run side by side and a phone opens each by name: a task's worktree keeps its word, as fox, until the task merges or is removed, which stops its server; run again, it stops the tree's last server first. Refused in a splates repository's main tree, which every agent shares. A slot keeps its own projects in ~/.splates/slots/<word>, apart from yours, starting with a throwaway project there; not with the tunnel and Access flags"
+}).action((opts, ctx) => serveDev(ctx, opts));
+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", z13.string(), {
+  default: "",
+  description: "only this task's ports; every task's by default"
+}).option("dev", z13.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", z13.boolean(), { default: false, description: "emit JSON" }).action((opts, ctx) => portsLs({
+  task: opts.task,
+  dev: opts.dev,
+  json: opts.json,
+  log: ctx.log,
+  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", z13.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", z13.string(), {
+  default: "",
+  description: "a step's id; omit for every area's progress"
+}).option("json", z13.boolean(), { default: false, description: "emit JSON" }).option("skip", z13.boolean(), {
+  default: false,
+  description: "with a step: stop asking for it"
+}).option("unskip", z13.boolean(), {
+  default: false,
+  description: "with a step: ask for it again"
+}).action(async (opts, ctx) => {
+  if (opts.step === "" && (opts.skip || opts.unskip)) {
+    fail5("usage", "--skip and --unskip name a step", {});
+  }
+  if (opts.skip && opts.unskip) {
+    fail5("usage", "--skip or --unskip, not both", { step: opts.step });
+  }
+  await setup(ctx, opts);
+});
+splates.command("path").use(repository7({ 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", z13.string(), {
+  default: "",
+  description: "task name; omit for the main tree"
+}).action((opts, ctx) => path(ctx, opts.task || undefined));
+splates.command("checkpoint").use(repository7({ 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("escalate").use(repository7({ needs: "own" })).description("hand this task to a human and stop: records the reason, drops the lease and leaves the worktree exactly as it is; use instead of resolving a genuine conflict badly just to finish").arg("reason", z13.string(), {
+  description: "why this needs a human; with --review, what to look at before approving"
+}).option("task", z13.string(), {
+  default: "",
+  description: "task name, when run outside its worktree"
+}).option("review", z13.boolean(), {
+  default: false,
+  description: "ask a person to approve merging, the reason saying what to look at, approved in chat; refused until the task is ready to merge, with every question under ## Blocked and step under ## Next checked"
+}).action(async (opts, ctx) => {
+  const task = opts.task || await here(ctx);
+  await ctx.journal.record("escalate", task, () => escalate(ctx, opts.reason, ctx.ps.cwd(), {
+    task: opts.task || undefined,
+    review: opts.review
+  }), (facts) => facts);
+  if (task !== null) {
+    await reportToCaller(ctx, await ctx.service.find(task));
+  }
+});
+splates.command("tell").use(repository7({ needs: "tasks" })).description("say something in the conversation of the agent a task was handed to with `splates add --agent` or `splates handoff --relay`, as the user would: how an orchestrator wakes an agent that sits idle, stops it for a change of plans, or passes on what its lane taught it, and how a relaying agent passes on the user's answers; only the conversation that handed the task out may").arg("task", z13.string(), { description: "task name" }).arg("text", z13.string(), { description: "what to say, as markdown" }).option("stop", z13.boolean(), {
+  default: false,
+  description: "stop the turn the agent is running first, as the user's Stop does, then say text: for a change of plans"
+}).action((opts, ctx) => ctx.journal.record("tell", opts.task, () => tell(ctx, opts.task, opts.text, { stop: opts.stop }), (to) => ({ to })));
+splates.command("handoff").use(repository7({ needs: "own" })).description("hand the task you are at work on to another agent on the roster (`splates agents`), which `splates server` starts in its worktree, told `[SPLATES HANDOFF <task>]` to claim it and carry on from its SPLATES.md; it answers to the user as you did, or with --relay to you, and this conversation leaves the task, though a lane's orchestrator that started you goes on hearing of it; refused to an agent that answers to another conversation, and for a task another conversation is at work on").arg("task", z13.string(), { description: "task name" }).option("agent", z13.string(), {
+  description: "the agent on the roster to hand it to"
+}).option("model", z13.string(), {
+  default: "",
+  description: "the model it works on, by its id or name on the roster (default: the agent's own)"
+}).option("effort", z13.string(), {
+  default: "",
+  description: "the thinking level it works at, one the agent offers (default: the agent's own)"
+}).option("prompt", z13.string(), {
+  default: "",
+  description: "what to tell the agent beyond taking the task over, such as why it is handed on"
+}).option("relay", z13.boolean(), {
+  default: false,
+  description: "for work you judged another model fits better: the agent answers to you rather than the user, reporting back with `[SPLATES REPORT <task>]` and told what the user says with `splates tell`; needs `splates server`"
+}).action(async (opts, ctx) => {
+  const agents = await seeded2(rosterOf2(ctx));
+  const effort = await effortIn(ctx, opts.agent, opts.effort, {
+    task: opts.task
+  });
+  await ctx.journal.record("handoff", opts.task, () => handoff(ctx, opts.task, {
+    agent: opts.agent,
+    ...opts.model === "" ? {} : { model: opts.model },
+    ...effort,
+    ...opts.prompt === "" ? {} : { prompt: opts.prompt }
+  }, agents, { relay: opts.relay }), (picked) => ({
+    agent: picked.agent,
+    model: picked.model ?? null,
+    relay: opts.relay
+  }));
+  await follow(ctx, null, { from: opts.task });
+});
+splates.command("attach").use(repository7({ 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, and 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", z13.string(), {
+  default: "",
+  description: "files to store, comma separated"
+}).option("task", z13.string(), {
+  default: "",
+  description: "task name, when run outside its worktree"
+}).option("remove", z13.string(), {
+  default: "",
+  description: "files it holds to drop first, comma separated, by path or stored name"
+}).option("conversation", z13.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, commaList4(opts.files), ctx.ps.cwd(), {
+  task: opts.task || undefined,
+  remove: commaList4(opts.remove),
+  conversation: opts.conversation || undefined
+}), (stored) => ({ stored, removed: commaList4(opts.remove) })));
+splates.command("retry").use(repository7({ needs: "own" })).description("give an escalated task another mergeRetryCount merge attempts and put it back to working; the way out of `budget_exhausted` that is not remove and redo, and only from escalated, so a human has seen the tree first").arg("task", z13.string(), { description: "task name" }).action((opts, ctx) => recordRetry(ctx, opts.task));
+splates.mount("artifact", splatesArtifact).mount("todo", splatesTodo).mount("lane", splatesLane).mount("projects", splatesProjects).mount("creds", splatesCreds).mount("tunnel", splatesTunnel).mount("slots", splatesSlots).mount("worker", splatesWorker).mount("queue", splatesQueue).mount("budget", splatesBudget).mount("coordinator", splatesCoordinator);
+
+// main.ts
+async function main() {
+  if (basename2(process.argv[1] ?? "") === LEGACY) {
+    legacyWarnings.once(LEGACY, "splates");
+  }
+  const ps = systemPs();
+  const { project, argv } = projectArgs(ps.args);
+  await splates.run({ fs: new NodeFs, ps, assets, project }, argv);
+}
+
+// index.ts
+await main();