@stringsync/splates 0.0.52 → 0.0.53

package/hook.ts

@@ -0,0 +1,328 @@
+import { commaList } from "@stringsync/splates-server/comma-list";
+import { fail } from "@stringsync/splates-server/exit";
+import {
+	type Hook,
+	HookStore,
+	hookAdd,
+	hookEdit,
+	hookGardener,
+	hookGroomer,
+	hookList,
+	hookPause,
+	hookRemove,
+	lanesNamed,
+	stagesNamed,
+	TASK_EVENTS,
+	type TaskEventName,
+	type TaskFilter,
+	type Trigger,
+} from "@stringsync/splates-server/hooks";
+import { repository } from "@stringsync/splates-server/records";
+import type { SplatesDeps } from "@stringsync/splates-server/server";
+import type { Storage } from "@stringsync/splates-server/storage";
+import { cli } from "webappwiz/cmd";
+import { z } from "zod";
+import { assigneeIn } from "./flags";
+
+/** `splates hook`, which the root cli mounts beside `splates queue`. */
+export const splatesHook = cli<SplatesDeps>("hook").description(
+	`automations: what runs on a task event (${TASK_EVENTS.join(", ")}), as \`splates server\` sees the journal take it, or on a schedule it keeps: an agent told of it; or a shell command. Kept for you in this project's .git/splates, never checked in, since an agent hook spends your tokens; splates.config.ts's \`on\` holds the shell commands a project checks in. None set, nothing runs. The page's Automations tab lists them with when each last ran and for what task`,
+);
+
+splatesHook
+	.command("list")
+	.use(repository({ needs: "read" }))
+	.description("every automation set here, by number, with its trigger")
+	.option("json", z.boolean(), { default: false, description: "emit JSON" })
+	.action((opts, ctx) =>
+		hookList({ hooks: storeOf(ctx), log: ctx.log }, { json: opts.json }),
+	);
+
+splatesHook
+	.command("add")
+	.use(repository({ needs: "tasks" }))
+	.description(
+		"run something on a task event, or on a schedule with `--every` or `--cron` in place of the event: `--agent <a> --prompt <words>` starts that agent in the main tree, told the event as `[SPLATES EVENT <event> #N]`, or a schedule as `[SPLATES SCHEDULE <number>]`, then your words; `--run <command>` runs it via `sh -c` in the main tree, with $SPLATES_EVENT (`schedule` for one), $SPLATES_TASKS and $SPLATES_TASK set. A schedule that came due while `splates server` was down runs once as it starts",
+	)
+	.arg("event", z.string().optional(), {
+		description: "the task event, as task.created; none for a schedule",
+	})
+	.option("stage", z.string(), {
+		default: "",
+		description:
+			"only for tasks in these stages, comma separated: backlog, ready, queued, running",
+	})
+	.option("lane", z.string(), {
+		default: "",
+		description: "only for tasks in these lanes, by number, comma separated",
+	})
+	.option("every", z.string(), {
+		default: "",
+		description: "run every so often, as 30m, 2h or 1d",
+	})
+	.option("cron", z.string(), {
+		default: "",
+		description:
+			'run on a five-field cron line, in this machine\'s time, as "0 9 * * 1-5"',
+	})
+	.option("agent", z.string(), {
+		default: "",
+		description: "the agent to run, as `splates agents` names it",
+	})
+	.option("model", z.string(), {
+		default: "",
+		description: "its model (default: the agent's own)",
+	})
+	.option("effort", z.string(), {
+		default: "",
+		description: "its thinking level (default: the agent's own)",
+	})
+	.option("prompt", z.string(), {
+		default: "",
+		description: "what the agent is told after the event",
+	})
+	.option("run", z.string(), {
+		default: "",
+		description: "a shell command to run",
+	})
+	.action(async (opts, ctx) => {
+		const pick = await assigneeIn(ctx, opts.agent, opts.model, opts.effort);
+		let hook: Hook;
+		if (opts.run !== "") {
+			if (pick != null || opts.prompt !== "") {
+				fail("usage", "--run goes alone: a shell command runs no agent", {});
+			}
+			hook = { kind: "run", command: opts.run };
+		} else if (pick == null) {
+			fail("usage", "say what runs: --agent with --prompt, or --run", {});
+		} else if (opts.prompt === "") {
+			fail("usage", "an agent hook needs --prompt: what to tell it", {});
+		} else {
+			hook = { kind: "agent", prompt: opts.prompt, ...pick };
+		}
+		await hookAdd({ hooks: storeOf(ctx), log: ctx.log }, triggerOf(opts), hook);
+	});
+
+splatesHook
+	.command("edit")
+	.use(repository({ needs: "tasks" }))
+	.description(
+		"change one of your automations, by its number in `splates hook list`, keeping its number, its pause and its last runs. Each flag changes only what it names, as `splates hook add` takes it: `--event`, `--every` or `--cron` sets what sets it off anew, `--stage` or `--lane` alone narrows its event again (`any` for no narrowing), `--prompt` or `--agent` changes what an agent is told or which agent, and `--run` makes it a shell command. The groomer changes through `splates hook groomer`",
+	)
+	.arg("id", z.string(), { description: "its number in `splates hook list`" })
+	.option("event", z.string(), {
+		default: "",
+		description:
+			"a task event to run on, as task.created, in place of what sets it off now",
+	})
+	.option("stage", z.string(), {
+		default: "",
+		description:
+			"only for tasks in these stages, comma separated, or `any`: backlog, ready, queued, running",
+	})
+	.option("lane", z.string(), {
+		default: "",
+		description:
+			"only for tasks in these lanes, by number, comma separated, or `any`",
+	})
+	.option("every", z.string(), {
+		default: "",
+		description: "run every so often, as 30m, 2h or 1d",
+	})
+	.option("cron", z.string(), {
+		default: "",
+		description:
+			'run on a five-field cron line, in this machine\'s time, as "0 9 * * 1-5"',
+	})
+	.option("agent", z.string(), {
+		default: "",
+		description: "the agent to run, as `splates agents` names it",
+	})
+	.option("model", z.string(), {
+		default: "",
+		description: "its model, with --agent (default: the agent's own)",
+	})
+	.option("effort", z.string(), {
+		default: "",
+		description: "its thinking level, with --agent (default: the agent's own)",
+	})
+	.option("prompt", z.string(), {
+		default: "",
+		description: "what the agent is told after the event",
+	})
+	.option("run", z.string(), {
+		default: "",
+		description: "a shell command to run in place of an agent",
+	})
+	.action(async (opts, ctx) => {
+		const { id, agent, model, effort, ...change } = opts;
+		const pick = await assigneeIn(ctx, agent, model, effort);
+		if (pick === null) {
+			fail(
+				"usage",
+				"an agent automation needs an agent: name one, or --run",
+				{},
+			);
+		}
+		await hookEdit({ hooks: storeOf(ctx), log: ctx.log }, id, {
+			...change,
+			...(pick === undefined ? {} : { pick }),
+		});
+	});
+
+splatesHook
+	.command("remove")
+	.use(repository({ needs: "tasks" }))
+	.description(
+		"take away an automation, by its number in `splates hook list`, or every one on an event",
+	)
+	.arg("id", z.string(), {
+		description: "its number, or a task event, as task.created",
+	})
+	.action((opts, ctx) =>
+		hookRemove({ hooks: storeOf(ctx), log: ctx.log }, opts.id),
+	);
+
+splatesHook
+	.command("pause")
+	.use(repository({ needs: "tasks" }))
+	.description("stop an automation running, keeping it to resume")
+	.arg("id", z.string(), { description: "its number in `splates hook list`" })
+	.action((opts, ctx) =>
+		hookPause({ hooks: storeOf(ctx), log: ctx.log }, opts.id, true),
+	);
+
+splatesHook
+	.command("resume")
+	.use(repository({ needs: "tasks" }))
+	.description("let a paused automation run again")
+	.arg("id", z.string(), { description: "its number in `splates hook list`" })
+	.action((opts, ctx) =>
+		hookPause({ hooks: storeOf(ctx), log: ctx.log }, opts.id, false),
+	);
+
+splatesHook
+	.command("groomer")
+	.use(repository({ needs: "tasks" }))
+	.description(
+		"turn on the project's groomer, built-in automation `groomer`, or set the agent it runs as, as the Automations page does: on each task deferred to the backlog, and the backlog as `splates server` starts, a conversation of its own per run, archived as the run ends, organizes each task in order and marks it ready, never doing it. `--off` turns it off, retiring its conversations",
+	)
+	.option("agent", z.string(), {
+		default: "",
+		description: "the agent it runs as, as `splates agents` names it",
+	})
+	.option("model", z.string(), {
+		default: "",
+		description: "its model (default: the agent's own)",
+	})
+	.option("effort", z.string(), {
+		default: "",
+		description: "its thinking level (default: the agent's own)",
+	})
+	.option("off", z.boolean(), {
+		default: false,
+		description: "turn it off",
+	})
+	.action(async (opts, ctx) => {
+		const pick = await assigneeIn(ctx, opts.agent, opts.model, opts.effort);
+		if (opts.off === (pick != null)) {
+			fail(
+				"usage",
+				"say how it runs with --agent, or turn it off with --off",
+				{},
+			);
+		}
+		await hookGroomer({ hooks: storeOf(ctx), log: ctx.log }, pick ?? null);
+	});
+
+splatesHook
+	.command("gardener")
+	.use(repository({ needs: "tasks" }))
+	.description(
+		"turn on the notes gardener, built-in automation `notes-gardener`, or set the agent it runs as and its schedule, as the Automations page does: on each run, an agent reads each project note no open task names by its path, checks it against the code and the other notes, and drafts the fixes in one task, `notes-garden`: rewriting what went stale, merging notes that say one thing, splitting one that says several, settling a contradiction the code settles and sharpening descriptions, then asks you to review the change rather than merge it, asking about any contradiction the code does not settle. No run starts while `notes-garden` is open. Off by default, since each run reads code for every note on your tokens; it runs every 7d until you set `--every` or `--cron`. `--off` turns it off",
+	)
+	.option("agent", z.string(), {
+		default: "",
+		description: "the agent it runs as, as `splates agents` names it",
+	})
+	.option("model", z.string(), {
+		default: "",
+		description: "its model (default: the agent's own)",
+	})
+	.option("effort", z.string(), {
+		default: "",
+		description: "its thinking level (default: the agent's own)",
+	})
+	.option("every", z.string(), {
+		default: "",
+		description: "run every so often, as 1d (default: as it was, or 7d)",
+	})
+	.option("cron", z.string(), {
+		default: "",
+		description:
+			'run on a five-field cron line, in this machine\'s time, as "0 9 * * 1"',
+	})
+	.option("off", z.boolean(), {
+		default: false,
+		description: "turn it off",
+	})
+	.action(async (opts, ctx) => {
+		const pick = await assigneeIn(ctx, opts.agent, opts.model, opts.effort);
+		if (opts.off === (pick != null)) {
+			fail(
+				"usage",
+				"say how it runs with --agent, or turn it off with --off",
+				{},
+			);
+		}
+		await hookGardener({ hooks: storeOf(ctx), log: ctx.log }, pick ?? null, {
+			every: opts.every,
+			cron: opts.cron,
+		});
+	});
+
+/** What sets the automation `splates hook add` adds off, refusing two triggers or none. */
+function triggerOf(opts: TriggerOptions): Trigger {
+	const given = [opts.event, opts.every, opts.cron].filter(
+		(each) => each !== undefined && each !== "",
+	);
+	if (given.length !== 1) {
+		fail(
+			"usage",
+			"say what sets it off: a task event, --every or --cron, one of them",
+			{},
+		);
+	}
+	if (opts.event === undefined || opts.event === "") {
+		if (opts.stage !== "" || opts.lane !== "") {
+			fail(
+				"usage",
+				"--stage and --lane narrow a task event, not a schedule",
+				{},
+			);
+		}
+		return opts.every !== "" ? { every: opts.every } : { cron: opts.cron };
+	}
+	const filter: TaskFilter = {};
+	if (opts.stage !== "") {
+		filter.stages = stagesNamed(commaList(opts.stage));
+	}
+	if (opts.lane !== "") {
+		filter.lanes = lanesNamed(opts.lane);
+	}
+	const event = opts.event as TaskEventName;
+	return Object.keys(filter).length === 0 ? { event } : { event, filter };
+}
+
+/** The options of `splates hook add` that say what sets it off. */
+interface TriggerOptions {
+	event?: string;
+	every: string;
+	cron: string;
+	stage: string;
+	lane: string;
+}
+
+function storeOf(ctx: { storage: Storage }) {
+	return new HookStore(ctx.storage);
+}

package/index.ts

@@ -0,0 +1,18 @@
+#!/usr/bin/env bun
+import { basename } from "node:path";
+import {
+	LEGACY,
+	legacyWarnings,
+	systemPs,
+} from "@stringsync/splates-server/config";
+import { assets } from "@stringsync/splates-server/server";
+import { NodeFs } from "webappwiz/system";
+import { projectArgs, splates } from "./splates";
+
+// The bin's old name, kept for one release.
+if (basename(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);

package/infra.ts

@@ -0,0 +1,107 @@
+import { resolve } from "node:path";
+import { commaList } from "@stringsync/splates-server/comma-list";
+import {
+	ACCESS_ENVIRONMENT,
+	accessEnvironmentExists,
+	CoordinatorBox,
+	pulumiOrg,
+	writeInfraConfig,
+} from "@stringsync/splates-server/coordinator";
+import { fail } from "@stringsync/splates-server/exit";
+import { infraConfigure } from "@stringsync/splates-server/infra/configure";
+import { secretsEnvironmentUrl } from "@stringsync/splates-server/infra/secrets";
+import { Projects } from "@stringsync/splates-server/projects";
+import { repository } from "@stringsync/splates-server/records";
+import type { SplatesDeps } from "@stringsync/splates-server/server";
+import { savedTunnelOf } from "@stringsync/splates-server/server";
+import { FsStorage } from "@stringsync/splates-server/storage";
+import { cli } from "webappwiz/cmd";
+import { z } from "zod";
+
+/** `splates server infra`, which `splates server` mounts. */
+export const splatesInfra = cli<SplatesDeps>("infra").description(
+	"the Pulumi project that makes everything the server's box needs in AWS, Cloudflare and GitHub, which `splates server deploy` then installs splates on",
+);
+
+splatesInfra
+	.command("init")
+	.use(repository({ needs: "own" }))
+	.description(
+		"write a Pulumi project in <dir>, its program a dozen lines using the components of @stringsync/splates-server/infra, and the stack's config from the flags; run again, it writes only what is not so already and keeps values you changed. It fills the stack's config from what splates keeps (the projects, the saved tunnel, the Cloudflare ids). The secrets never pass through splates: it makes the Pulumi ESC environment splates/secrets with a placeholder for each (the Cloudflare token, a GitHub token per owner, the Anthropic key), which the stack imports and the user replaces on the Pulumi site; `splates setup` has a step for each saying how to get it. When the Pulumi ESC environment `coordinator-access` makes (splates/aws) is there, the stack imports it. It records the directory in ~/.splates/coordinator/infra.json, where `splates server deploy` finds the stack. Its runtime is bun, which runs the program's TypeScript itself. Commit the project but not Pulumi.<stack>.yaml, which holds your own accounts and ids and which the .gitignore it writes keeps out of git; init writes it again from what splates keeps. Then `bun add @stringsync/splates-server @pulumi/pulumi @pulumi/aws @pulumi/awsx @pulumi/cloudflare @pulumi/github @pulumi/tls @pulumi/random` there and `pulumi up`",
+	)
+	.arg("dir", z.string(), { description: "where the Pulumi project goes" })
+	.option("stack", z.string(), { default: "prod", description: "the stack" })
+	.option("host", z.string(), {
+		default: "",
+		description:
+			"the public host name, as in splates.example.com; the saved tunnel's by default",
+	})
+	.option("email", z.string(), {
+		default: "",
+		description:
+			"the email address Access lets in; the tunnel's Access application's by default",
+	})
+	.option("region", z.string(), {
+		default: "us-east-1",
+		description: "the AWS region",
+	})
+	.option("projects", z.string(), {
+		default: "",
+		description:
+			"comma-separated slug=owner/repo, each a project the box pushes trunk of; every project registered here with a GitHub origin by default",
+	})
+	.action(async (opts, ctx) => {
+		const listed = commaList(opts.projects).map((entry) => {
+			const [slug, repository] = entry.split("=");
+			if (!slug || !repository?.includes("/")) {
+				fail("usage", `--projects wants slug=owner/repo, not ${entry}`, {
+					entry,
+				});
+			}
+			return { slug, repository };
+		});
+		const org = await pulumiOrg(ctx.ps);
+		const home = new CoordinatorBox({ ps: ctx.ps, fs: ctx.fs }).home;
+		const { written, todo } = await infraConfigure({
+			dir: opts.dir,
+			stack: opts.stack,
+			host: opts.host,
+			email: opts.email,
+			region: opts.region,
+			projects: listed.length === 0 ? null : listed,
+			registered: async () =>
+				(await Projects.in(new FsStorage(home, ctx.fs), ctx.fs).list()).filter(
+					(project) => !project.gone,
+				),
+			creds: ctx.creds,
+			saved: savedTunnelOf(ctx),
+			// The sign-in `coordinator-access` made, once it is there.
+			...(org !== null && (await accessEnvironmentExists(ctx.ps, org))
+				? { environment: ACCESS_ENVIRONMENT }
+				: {}),
+			fs: ctx.fs,
+			ps: ctx.ps,
+			log: ctx.log,
+			fetch: ctx.fetch,
+		});
+		await writeInfraConfig(ctx.fs, home, {
+			dir: resolve(opts.dir),
+			stack: opts.stack,
+		});
+		ctx.log.info(
+			written.length === 0
+				? "already so: nothing written"
+				: `wrote ${written.join(", ")}`,
+		);
+		ctx.log.info(
+			`Pulumi.${opts.stack}.yaml stays out of git: it holds your own accounts and ids, and init writes it again from what splates keeps`,
+		);
+		for (const command of todo) {
+			ctx.log.info(`still to run in ${opts.dir}: ${command}`);
+		}
+		if (org !== null) {
+			ctx.log.info(
+				`paste each secret over its placeholder at ${secretsEnvironmentUrl(org)}: \`splates setup\` has a step for each saying how to get it`,
+			);
+		}
+	});

package/lane.test.ts

@@ -0,0 +1,29 @@
+import { expect, it } from "bun:test";
+import { Testing } from "@stringsync/splates-server/testing";
+import { splates } from "./splates";
+
+it("addresses permanent Backlog by name in both task and lane commands", async () => {
+	await using testing = await Testing.open();
+	testing.ps.cd(testing.root);
+	const deps = {
+		log: testing.log,
+		fs: testing.fs,
+		ps: testing.ps,
+		assets: testing.assets,
+		secrets: testing.secrets,
+	};
+	await splates.run(deps, [
+		"task",
+		"defer",
+		"later",
+		"--slug",
+		"later",
+		"--lane",
+		"backlog",
+	]);
+	const [task] = await testing.tasks.all();
+	expect(task?.lane, testing.out()).toBe(0);
+	testing.log.clear();
+	await splates.run(deps, ["lane", "show", "backlog", "--json"]);
+	expect(JSON.parse(testing.out())).toMatchObject({ lane: 0, name: "Backlog" });
+});

package/lane.ts

@@ -0,0 +1,172 @@
+import {
+	APPROVAL,
+	BACKLOG_LANE,
+	laneAdd,
+	laneList,
+	laneRemove,
+	laneShow,
+	laneUpdate,
+	laneUpdated,
+	recordLaneRemove,
+} 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 { repository } from "@stringsync/splates-server/records";
+import type { SplatesDeps } from "@stringsync/splates-server/server";
+import { cli } from "webappwiz/cmd";
+import { z } from "zod";
+import { position } from "./flags";
+
+/** Backlog is lane zero, also addressable by its permanent name. */
+const laneNumber = z.union([
+	z.literal("backlog").transform(() => BACKLOG_LANE),
+	z.coerce.number().int().nonnegative(),
+]);
+
+/** `splates lane`, which the root cli mounts after `splates task`. */
+export const splatesLane = cli<SplatesDeps>("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",
+);
+
+splatesLane
+	.command("list")
+	.use(repository({ 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", z.boolean(), { default: false, description: "emit JSON" })
+	.action((opts, ctx) => laneList(ctx, { json: opts.json }));
+
+splatesLane
+	.command("show")
+	.use(repository({ 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",
+		z.union([z.literal(UNTRIAGED).transform(() => null), laneNumber], {
+			error: "pass a lane's number, backlog, or untriaged",
+		}),
+		{ description: "lane number, `backlog`, or `untriaged`" },
+	)
+	.option("json", z.boolean(), { default: false, description: "emit JSON" })
+	.action((opts, ctx) => laneShow(ctx, opts.lane, { json: opts.json }));
+
+splatesLane
+	.command("add")
+	.use(repository({ needs: "tasks" }))
+	.description("start an empty lane, after the others")
+	.arg("name", z.string(), {
+		description: "what its tasks 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(repository({ needs: "tasks" }))
+	.description("rename a lane, or move it among the others")
+	.arg("lane", laneNumber, {
+		description: "lane number",
+	})
+	.option("name", z.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("queue")
+	.use(repository({ 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, {
+		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),
+		);
+	});
+
+splatesLane
+	.command("approve")
+	.use(repository({ 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(repository({ 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, {
+		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),
+		);
+	});
+
+splatesLane
+	.command("remove")
+	.use(repository({ needs: "tasks" }))
+	.description(
+		"remove a lane and its tasks, kept to restore; a lane whose last task merges goes on its own; refused from an agent, which asks with a permission card",
+	)
+	.arg("lane", laneNumber, {
+		description: "lane number",
+	})
+	.action((opts, ctx) => {
+		refuseAgentQueue(ctx.service, "lane remove");
+		return recordLaneRemove(ctx.journal, ctx.tasks, opts.lane, () =>
+			laneRemove(ctx, opts.lane),
+		);
+	});

package/notes.ts

@@ -0,0 +1,19 @@
+import { loadConfig } from "@stringsync/splates-server/config";
+import { Notes } from "@stringsync/splates-server/notes";
+import type { Repository } from "@stringsync/splates-server/records";
+import type { SplatesDeps } from "@stringsync/splates-server/server";
+
+/** Prints the descriptions in this checkout, or the project explicitly named. */
+export async function notes(ctx: SplatesDeps & Repository): Promise<void> {
+	const root =
+		ctx.project === undefined
+			? (
+					await ctx.git.run(ctx.ps.cwd(), "rev-parse", "--show-toplevel")
+				).stdout.trim()
+			: ctx.git.root;
+	const config = await loadConfig(root, { fs: ctx.fs, git: ctx.git });
+	const found = await new Notes(ctx.fs).list(root, config);
+	for (const note of found) {
+		ctx.log.info(note.description);
+	}
+}