@letterstory/cli 0.64.0 → 0.66.0

package/README.md

@@ -777,10 +777,17 @@ letterstory sequences list | get <id> | create | update <id> | pause <id> | resu
 letterstory sequences enroll <id> --list <list-id>           # or --email a@x.com ...
 letterstory sequences review list | approve <item-id> | skip <item-id> | edit <item-id> --subject "…"
 letterstory sequences links create --days 2                  # no-login phone review link, shown once
+letterstory sequences update <id> --test-mode                # internal accounts only: walks as live, sends nothing
+
+# Dispatches (the review desks a sequence queues to)
+letterstory dispatches list | create --name "Founders" | rename <id> --name "VIPs" | delete <id> --yes
 
 # Prospects
 letterstory prospects lists | ls --list <list-id> | get <id> | import --csv-file leads.csv --list-name "Q4"
 letterstory prospects source --description "heads of growth at seed-stage fintech" --list-name "Fintech"
+letterstory prospects openers <list-id> --new-group "Fintech openers"   # print an opening line per row
+letterstory prospects columns add "Cake image" | columns delete <column-id> --yes
+letterstory prospects delete <prospect-id>... --yes
 ```
 
 Connecting a bring-your-own Gmail mailbox needs a browser (Google consent), so it is done in the

package/lib/cli.mjs

@@ -44,6 +44,7 @@ import {
 	cmdLede,
 	cmdLandings,
 	cmdSequences,
+	cmdDispatches,
 	cmdProspects,
 	cmdMail,
 	cmdMailers,
@@ -55,7 +56,7 @@ import {
 } from "./commands.mjs";
 
 // Keep in sync with cli/package.json.
-export const VERSION = "0.64.0";
+export const VERSION = "0.66.0";
 
 // Flags that never take a value. Listing them explicitly means `deploy get --json <id>`
 // can't accidentally swallow the id as --json's value.
@@ -549,6 +550,13 @@ Admin (STAFF key — --staff-key / LETTERSTORY_STAFF_API_KEY; acts before an org
                                                        read-only SQL across every org; --sql prints
                                                        the queries behind the answer. Needs the
                                                        fleet:query capability on the staff key.
+  admin replays [--org <uuid>] [--target <uuid>] [--status captured|not_reproduced|queued|running|unsupported|failed] [--limit <n>]
+                                                       Live answer replays: breakthroughs re-asked in ChatGPT /
+                                                       Gemini / Google / Perplexity / Claude, with screenshots.
+                                                       Omit --org for the whole fleet. Needs fleet:read.
+  admin replay --org <uuid> (<response-id> | --target <uuid>) [--surface openai|anthropic|google-aio|google-gemini|perplexity]
+                                                       Replay a breakthrough live now (background; poll
+                                                       admin replays). Needs fleet:replay.
   admin experiments list [--q colons] [--status proposed] | show <id>
           | new "<question>" [--hypothesis …] [--plan-file p.json] [--tags a,b] [--as "<agent>"]
           | update <id> [--plan-file …] [--result-file …] [--evidence kind:ref,…] [--budget N]
@@ -808,13 +816,14 @@ Sequences (multi-step cold email sent from your mailers; approving or enrolling
   sequences get <sequence-id>                          Flow, enrollments, who replied at each step
   sequences create --name <n> (--flow '<json>'|--flow-file <path>) [--mailer <mailer-id>]...
            [--[no-]opt-out-footer] [--[no-]postal-address-footer] [--[no-]unsubscribe-links] [--[no-]detect-reply-opt-outs]
-           [--send-window-start <HH:MM>] [--send-window-end <HH:MM>] [--send-window-timezone <IANA tz>]
+           [--[no-]test-mode] [--send-window-start <HH:MM>] [--send-window-end <HH:MM>] [--send-window-timezone <IANA tz>]
                                                        New draft sequence (nothing sends yet; rails default on, opt-out line off;
                                                        sends 9:00-17:00 in each recipient's inferred timezone, else the sender's)
   sequences update <sequence-id> [--name <n>] [--flow '<json>'|--flow-file <path>]
            [--status draft|active|paused|archived] [--mailer <mailer-id>]...
            [--[no-]opt-out-footer] [--[no-]postal-address-footer] [--[no-]unsubscribe-links] [--[no-]detect-reply-opt-outs]
-           [--send-window-start <HH:MM>] [--send-window-end <HH:MM>] [--send-window-timezone <IANA tz>]
+           [--[no-]test-mode] [--send-window-start <HH:MM>] [--send-window-end <HH:MM>] [--send-window-timezone <IANA tz>]
+                                                       --test-mode (internal accounts only): walks as live, sends nothing
   sequences pause|resume <sequence-id>                 Stop / restart sending
   sequences enroll <sequence-id> (--list <list-id> | --email <addr>... | --recipients '<json>'|--recipients-file <path>)
   sequences stop <sequence-id> <enrollment-id>         Stop one recipient
@@ -825,6 +834,12 @@ Sequences (multi-step cold email sent from your mailers; approving or enrolling
   sequences links create --days <1..3>                 Mint a no-login review link (shown once)
   sequences links revoke <link-id> --yes
 
+Dispatches (the named review desks a sequence's review stage queues to):
+  dispatches list                                      Desks + how many emails each has queued
+  dispatches create --name <n>
+  dispatches rename <dispatch-id> --name <n>
+  dispatches delete <dispatch-id> --yes                Queued emails move to the default desk
+
 Prospects (who you write to):
   prospects lists                                      Your lists + counts
   prospects list <list-id>                             One list
@@ -837,6 +852,11 @@ Prospects (who you write to):
                                                        --enrich starts enrichment as soon as the pull lands
   prospects enrich [--list <list-id>] [--status <s>] [--q <search>]
                                                        Funding + competitors for un-enriched rows
+  prospects openers <list-id> [--group <ledes-group-id>|--new-group <name>]
+                                                       Print an opening line for every row without one (background)
+  prospects delete <prospect-id>... --yes              Permanently delete prospects
+  prospects columns add <label>                        Add a custom column (key returned)
+  prospects columns delete <column-id> --yes
   prospects update <prospect-id> [--status new|contacted|replied|unsubscribed|archived] [--name <n>]
            [--first-name] [--last-name] [--title] [--company] [--website] [--linkedin] [--school]
            [--city] [--country] [--years] [--notes] [--custom key=value]...
@@ -960,6 +980,7 @@ const CLIENT_COMMANDS = {
 	ledes: cmdLede,
 	landings: cmdLandings,
 	sequences: cmdSequences,
+	dispatches: cmdDispatches,
 	prospects: cmdProspects,
 	mail: cmdMail,
 	mailers: cmdMailers,

package/lib/commands/admin.mjs

@@ -10,6 +10,8 @@
 //   admin tuning kernels|kernel|candidate|compare|comparisons|comparison|picks|pick|promote …   (tuning:experiment)
 //   admin evals scoreboard|cases|runs|run|triage|guard|retire …                      (fleet:read / tuning:experiment)
 //   admin crm import|capture|signals|record|signal|accounts|account|score|slack-channels|link-slack|white-glove|set-white-glove|churn|record-churn|undo-churn|onboard|onboarding|retry-onboarding|onboard-plan|payment-link …  (crm:read / crm:write)
+//   admin replays [--org <id>] [--target <id>] [--status …] [--limit n]                (fleet:read)
+//   admin replay --org <id> (<response-id> | --target <id>) [--surface …]           (fleet:replay)
 //   admin create-org --domain acme.com [--name "Acme"] [--test] [--no-key] [--key-name N]
 //                    [--capabilities a,b] [--onboard] [--about "…"] [--sitemap <url>]
 //                    [--cms <provider>] [--posts N] [--seers suggest|skip] [--no-visuals]
@@ -1926,8 +1928,80 @@ async function cmdAdminEvals(ctx) {
 	}
 }
 
+const REPLAY_SURFACES = ["openai", "anthropic", "google-aio", "google-gemini", "perplexity"];
+const REPLAY_STATUSES = ["queued", "running", "captured", "not_reproduced", "unsupported", "failed"];
+const REPLAYS = "/api/superadmin/answer-replays";
+
+function oneOf(flags, name, values) {
+	const v = flagStr(flags[name]);
+	if (v !== undefined && !values.includes(v)) throw new CliError(`--${name} must be one of: ${values.join(", ")}`);
+	return v;
+}
+
+function formatReplays(r) {
+	const rows = r.replays ?? [];
+	if (!rows.length) return "No answer replays.";
+	return rows
+		.map((x) => {
+			const head = `${x.id}  ${x.surfaceLabel}  ${x.status}  ${x.attemptsMade}/${x.plannedAttempts} asks  ${x.createdAt}`;
+			const lines = [head];
+			if (x.capture) {
+				lines.push(
+					`  captured on ask ${x.capture.step + 1}: "${x.capture.query}" (web search ${x.capture.webSearch})`
+				);
+				for (const img of x.capture.images ?? []) lines.push(`  ${img.kind}: ${img.url}`);
+			}
+			if (x.error) lines.push(`  ${x.error}`);
+			return lines.join("\n");
+		})
+		.join("\n");
+}
+
+/** `admin replays` / `admin replay` — live answer replays (staff only). */
+async function cmdAdminReplays(ctx, sub) {
+	const { flags, positionals, io } = ctx;
+	if (sub === "replays") {
+		const params = new URLSearchParams(
+			compact({
+				org_id: flagStr(flags.org),
+				target_id: flagStr(flags.target),
+				status: oneOf(flags, "status", REPLAY_STATUSES),
+				limit: flagNum(flags.limit)?.toString(),
+			})
+		);
+		const result = await staffRequest(ctx, "GET", `${REPLAYS}${params.size ? `?${params}` : ""}`);
+		printResult(io, flags, result, formatReplays);
+		return 0;
+	}
+	const org = flagStr(flags.org);
+	const responseId = positionals[0];
+	const target = flagStr(flags.target);
+	if (!org) throw new CliError("admin replay needs --org <org-id>");
+	if (!responseId && !target) throw new CliError("Pass a breakthrough <response-id>, or --target <target-id>");
+	const result = await staffPost(
+		ctx,
+		REPLAYS,
+		compact({
+			org_id: org,
+			response_id: responseId,
+			target_id: target,
+			surface: oneOf(flags, "surface", REPLAY_SURFACES),
+		})
+	);
+	ok(
+		ctx,
+		result.already_queued
+			? `Already replaying: ${result.replay_id}`
+			: `Replay ${result.replay_id} is ${result.status}. Poll: ${ctx.bin} admin replays --org ${org}`
+	);
+	printResult(io, flags, result);
+	return 0;
+}
+
 export async function cmdAdmin(ctx) {
 	const sub = ctx.positionals[0];
+	if (sub === "replays" || sub === "replay")
+		return cmdAdminReplays({ ...ctx, positionals: ctx.positionals.slice(1) }, sub);
 	if (sub === "crm") return cmdAdminCrm({ ...ctx, positionals: ctx.positionals.slice(1) });
 	if (sub === "create-org") return cmdAdminCreateOrg({ ...ctx, positionals: ctx.positionals.slice(1) });
 	if (sub === "ask") return cmdAdminAsk({ ...ctx, positionals: ctx.positionals.slice(1) });
@@ -1937,6 +2011,6 @@ export async function cmdAdmin(ctx) {
 	if (sub === "tuning") return cmdAdminTuning({ ...ctx, positionals: ctx.positionals.slice(1) });
 	if (sub === "evals") return cmdAdminEvals({ ...ctx, positionals: ctx.positionals.slice(1) });
 	throw new CliError(
-		'Usage: admin create-org --domain <bare-domain> [--onboard] … | admin ask "<question>" | admin experiments … | admin crm … | admin evals … | admin tuning … | admin tuning-context (see --help)'
+		'Usage: admin create-org --domain <bare-domain> [--onboard] … | admin ask "<question>" | admin experiments … | admin crm … | admin evals … | admin tuning … | admin tuning-context | admin replays … (see --help)'
 	);
 }

package/lib/commands/kernel.mjs

@@ -228,8 +228,109 @@ export const ARGS = {
 	get_kernel_endpoint_run_steps: {
 		run_id: { positional: 0, label: "run-id", required: true },
 	},
+	// `kernel endpoint bind <id> --kernel <id|none> --shredder <id|none>`: "none" unbinds (null),
+	// which is not the same as leaving the flag out (unchanged).
+	update_kernel_endpoint: {
+		endpoint_id: { positional: 1, label: "endpoint-id", required: true },
+		kernel_id: { value: (flags) => noneIsNull(flags.kernel) },
+		shredder_endpoint_id: { value: (flags) => noneIsNull(flags.shredder) },
+	},
+
+	// ── Making a kernel your own, and choosing the org's ───────────────────────────────
+	configure_kernel: {
+		source_kernel_id: { positional: 0, label: "source-kernel-id", required: true },
+		name: "name",
+	},
+	create_kernel: {
+		file: { value: (flags) => readJsonFileFlag(flags, "file") },
+	},
+	get_org_writing_kernel: {},
+	set_org_writing_kernel: {
+		writing_kernel_id: {
+			value: (_flags, positionals) => {
+				const id = positionals[0];
+				if (id === undefined) throw new CliError("Missing required <kernel-id> (or none to clear it)");
+				return id === "none" ? null : id;
+			},
+		},
+	},
+
+	// ── The kernel file and its versions ──────────────────────────────────────────────
+	get_kernel_file: {
+		kernel_id: { positional: 0, label: "kernel-id", required: true },
+		version: { flag: "version", type: "num" },
+	},
+	get_kernel_file_schema: {},
+	list_kernel_versions: {
+		kernel_id: { positional: 0, label: "kernel-id", required: true },
+	},
+	// A candidate unless --live: the safe default is the one that changes no run.
+	save_kernel_file: {
+		kernel_id: { positional: 0, label: "kernel-id", required: true },
+		file: { value: (flags) => readJsonFileFlag(flags, "file") },
+		status: { value: (flags) => (flags.live === true ? "live" : undefined) },
+		note: "note",
+	},
+	promote_kernel_version: {
+		kernel_id: { positional: 0, label: "kernel-id", required: true },
+		version: { value: (_flags, positionals) => positiveInt(positionals[1], "version") },
+	},
+	get_kernel_offer: {
+		kernel_id: { positional: 0, label: "kernel-id", required: true },
+	},
+	accept_kernel_offer: {
+		kernel_id: { positional: 0, label: "kernel-id", required: true },
+		status: { value: (flags) => (flags.live === true ? "live" : undefined) },
+	},
+	suggest_kernel_voice_settings: {
+		kernel_id: { positional: 0, label: "kernel-id", required: true },
+		notes: { value: (flags) => flagStr(flags.notes) ?? readTextFileFlag(flags, "notes-file") },
+		current: { value: (flags) => readJsonFileFlag(flags, "voice-config-file") },
+	},
+
+	// ── The Studio: try a kernel, keep the history ────────────────────────────────────
+	list_kernel_studio_runs: {
+		kernel_id: "kernel",
+		limit: { flag: "limit", type: "num" },
+	},
+	get_kernel_studio_run: {
+		run_id: { positional: 0, label: "run-id", required: true },
+	},
 };
 
+/** `--kernel none` → null (unbind); a value → itself; absent → undefined (leave it). */
+function noneIsNull(raw) {
+	const v = flagStr(raw);
+	if (v === undefined) return undefined;
+	return v === "none" ? null : v;
+}
+
+function positiveInt(raw, label) {
+	if (raw === undefined) throw new CliError(`Missing required <${label}>`);
+	const n = Number(raw);
+	if (!Number.isInteger(n) || n < 1) throw new CliError(`<${label}> must be a positive whole number (got "${raw}")`);
+	return n;
+}
+
+// `kernel try` is the Studio's run: the same per-run options as `kernel write` (one map, so a
+// field run_kernel gains is a field this learns too), on a kernel rather than an endpoint.
+{
+	const {
+		endpoint_id: _endpoint,
+		input: _input,
+		article_id: _article,
+		kernel_id: _kernel,
+		...runOptions
+	} = ARGS.run_kernel;
+	ARGS.start_kernel_studio_run = {
+		kernel_id: { positional: 0, label: "kernel-id", required: true },
+		brief: { value: (flags) => readBodyInput(flags) },
+		// --name, not --title: --title is the template's title in the run options.
+		title: "name",
+		...runOptions,
+	};
+}
+
 export async function cmdKernel(ctx) {
 	const sub = ctx.positionals[0];
 	const rest = { ...ctx, positionals: ctx.positionals.slice(1) };
@@ -257,11 +358,37 @@ export async function cmdKernel(ctx) {
 			return kernelRunStatus(rest);
 		case "runs":
 			return kernelRuns(rest);
+		case "fork":
+			return kernelFork(rest);
+		case "create":
+			return kernelCreate(rest);
+		case "default":
+			return kernelDefault(rest);
+		case "use":
+			return kernelUse(rest);
+		case "file":
+			return kernelFile(rest);
+		case "schema":
+			return kernelSchema(rest);
+		case "versions":
+			return kernelVersions(rest);
+		case "save":
+			return kernelSave(rest);
+		case "promote":
+			return kernelPromote(rest);
+		case "offer":
+			return kernelOffer(rest);
+		case "suggest-voice":
+			return kernelSuggestVoice(rest);
+		case "try":
+			return kernelTry(rest);
+		case "history":
+			return kernelHistory(rest);
 		case "balance":
 			return kernelBalance(rest);
 		default:
 			throw new CliError(
-				`Unknown kernel subcommand: ${sub ?? "(none)"}. Try: list, endpoints, endpoint, eval, update, archive, write, polish, run-status, runs, balance, status`
+				`Unknown kernel subcommand: ${sub ?? "(none)"}. Try: list, fork, create, default, use, file, schema, versions, save, promote, offer, update, suggest-voice, archive, eval, try, history, endpoints, endpoint, write, polish, run-status, runs, balance, status`
 			);
 	}
 }
@@ -435,7 +562,17 @@ async function kernelEndpoint(ctx) {
 		printResult(io, flags, result);
 		return 0;
 	}
-	throw new CliError(`Unknown kernel endpoint action: ${action ?? "(none)"}. Try: create, delete, config`);
+	if (action === "bind") {
+		const args = argsFromFlags(ARGS.update_kernel_endpoint, flags, positionals);
+		if (args.kernel_id === undefined && args.shredder_endpoint_id === undefined) {
+			throw new CliError("Provide --kernel <id|none> and/or --shredder <id|none>.");
+		}
+		const result = await client.callTool("update_kernel_endpoint", args);
+		ok(ctx, `Rebound kernel endpoint ${args.endpoint_id}.`);
+		printResult(io, flags, result);
+		return 0;
+	}
+	throw new CliError(`Unknown kernel endpoint action: ${action ?? "(none)"}. Try: create, delete, config, bind`);
 }
 
 /**
@@ -615,3 +752,232 @@ async function kernelBalance(ctx) {
 	printResult(io, flags, result);
 	return 0;
 }
+
+/* ------------------------------------------------------------------ */
+/* Making a kernel your own, and its file                              */
+/* ------------------------------------------------------------------ */
+
+/** `kernel fork <source-kernel-id> [--name <name>]` — copy a catalog kernel (or one of yours) into one your org can tune. */
+async function kernelFork(ctx) {
+	const { client, positionals, flags, io } = ctx;
+	const result = await client.callTool("configure_kernel", argsFromFlags(ARGS.configure_kernel, flags, positionals));
+	const kernel = toolField(result, "kernel");
+	if (kernel?.id) ok(ctx, `Forked as "${kernel.name}" (${kernel.id}). Its file: ${ctx.bin} kernel file ${kernel.id}`);
+	printResult(io, flags, result);
+	return 0;
+}
+
+/** `kernel create --file kernel.json` — bring your own: a kernel made from a file (a name and a voice is enough). */
+async function kernelCreate(ctx) {
+	const { client, positionals, flags, io } = ctx;
+	if (flagStr(flags.file) === undefined) {
+		throw new CliError('Provide the kernel file with --file <path> (as short as {"name": "…", "voice": "…"}).');
+	}
+	const result = await client.callTool("create_kernel", argsFromFlags(ARGS.create_kernel, flags, positionals));
+	const kernel = toolField(result, "kernel");
+	if (kernel?.id) ok(ctx, `Created "${kernel.name}" (${kernel.id}), version 1, live.`);
+	printResult(io, flags, result);
+	return 0;
+}
+
+/** `kernel default` — the org's selected writing kernel. */
+async function kernelDefault(ctx) {
+	const { client, positionals, flags, io } = ctx;
+	const result = await client.callTool(
+		"get_org_writing_kernel",
+		argsFromFlags(ARGS.get_org_writing_kernel, flags, positionals)
+	);
+	printResult(io, flags, result);
+	return 0;
+}
+
+/** `kernel use <kernel-id|none>` — make a kernel the org's default (a shared one needs an org admin's key). */
+async function kernelUse(ctx) {
+	const { client, positionals, flags, io } = ctx;
+	const args = argsFromFlags(ARGS.set_org_writing_kernel, flags, positionals);
+	const result = await client.callTool("set_org_writing_kernel", args);
+	ok(
+		ctx,
+		args.writing_kernel_id ? `The org now writes with ${args.writing_kernel_id}.` : "Cleared the org's kernel."
+	);
+	printResult(io, flags, result);
+	return 0;
+}
+
+/**
+ * `kernel file <kernel-id> [--version N]` — the kernel file itself, printed as the document so
+ * `> kernel.json` round-trips into `kernel save <kernel-id> --file kernel.json`.
+ */
+async function kernelFile(ctx) {
+	const { client, positionals, flags, io } = ctx;
+	const result = await client.callTool("get_kernel_file", argsFromFlags(ARGS.get_kernel_file, flags, positionals));
+	printResult(io, flags, result, (r) => JSON.stringify(r?.file ?? r, null, 2));
+	return 0;
+}
+
+/** `kernel schema` — the kernel file's JSON Schema, as the kernels service validates it. */
+async function kernelSchema(ctx) {
+	const { client, positionals, flags, io } = ctx;
+	const result = await client.callTool(
+		"get_kernel_file_schema",
+		argsFromFlags(ARGS.get_kernel_file_schema, flags, positionals)
+	);
+	printResult(io, flags, result, (r) => JSON.stringify(r?.schema ?? r, null, 2));
+	return 0;
+}
+
+/** `kernel versions <kernel-id>` — every version, the live one, the base it came from and any offer. */
+async function kernelVersions(ctx) {
+	const { client, positionals, flags, io } = ctx;
+	const result = await client.callTool(
+		"list_kernel_versions",
+		argsFromFlags(ARGS.list_kernel_versions, flags, positionals)
+	);
+	printResult(io, flags, result, (r) => {
+		const lines = (r?.versions ?? []).map(
+			(v) =>
+				`v${v.version}  ${v.status.padEnd(9)} ${v.writer.padEnd(18)} ${v.note ?? ""}${v.changes?.length ? `  [${v.changes.join(", ")}]` : ""}`
+		);
+		if (r?.base)
+			lines.push(
+				`\nCopied from ${r.base.name} (v${r.base.version}); differs in: ${r.base.changes.join(", ") || "nothing"}`
+			);
+		if (r?.offer)
+			lines.push(
+				`Offer: ${r.base?.name ?? "the base"} v${r.offer.base_version_from} → v${r.offer.base_version_to} changes ${r.offer.changes.join(", ")}`
+			);
+		return lines.join("\n");
+	});
+	return 0;
+}
+
+/**
+ * `kernel save <kernel-id> --file kernel.json [--live] [--note "…"]` — a new version. A candidate
+ * unless --live: try it with `kernel try <kernel-id> --kernel-version N`, then `kernel promote`.
+ */
+async function kernelSave(ctx) {
+	const { client, positionals, flags, io } = ctx;
+	if (flagStr(flags.file) === undefined) throw new CliError("Provide the kernel file with --file <path>.");
+	const args = argsFromFlags(ARGS.save_kernel_file, flags, positionals);
+	const result = await client.callTool("save_kernel_file", args);
+	const version = toolField(result, "version");
+	ok(
+		ctx,
+		args.status === "live"
+			? `Version ${version} is live.`
+			: `Saved version ${version} as a candidate. Try it: ${ctx.bin} kernel try ${args.kernel_id} --kernel-version ${version} --body "…"; ship it: ${ctx.bin} kernel promote ${args.kernel_id} ${version} --yes`
+	);
+	if (toolField(result, "voice_settings_detached"))
+		ok(ctx, "The voice is now edited as text; voice_config no longer applies.");
+	printResult(io, flags, result);
+	return 0;
+}
+
+/** `kernel promote <kernel-id> <version> --yes` — make a version live: ship a candidate, or roll back. */
+async function kernelPromote(ctx) {
+	const { client, positionals, flags, io } = ctx;
+	const args = argsFromFlags(ARGS.promote_kernel_version, flags, positionals);
+	if (!flags.yes) {
+		io.error(
+			`Every run of this kernel will use version ${args.version} from its next call. Re-run with --yes to confirm: ${ctx.bin} kernel promote ${args.kernel_id} ${args.version} --yes`
+		);
+		return 1;
+	}
+	const result = await client.callTool("promote_kernel_version", args);
+	const previous = toolField(result, "previous_live");
+	ok(
+		ctx,
+		`Version ${args.version} is live.${previous ? ` To undo: ${ctx.bin} kernel promote ${args.kernel_id} ${previous} --yes` : ""}`
+	);
+	printResult(io, flags, result);
+	return 0;
+}
+
+/** `kernel offer <kernel-id> [--accept [--live]]` — the base's newer version, and taking it. */
+async function kernelOffer(ctx) {
+	const { client, positionals, flags, io } = ctx;
+	if (flags.accept !== true) {
+		const result = await client.callTool(
+			"get_kernel_offer",
+			argsFromFlags(ARGS.get_kernel_offer, flags, positionals)
+		);
+		printResult(io, flags, result);
+		return 0;
+	}
+	const args = argsFromFlags(ARGS.accept_kernel_offer, flags, positionals);
+	const result = await client.callTool("accept_kernel_offer", args);
+	ok(ctx, `Accepted as version ${toolField(result, "version")} (${toolField(result, "status")}).`);
+	printResult(io, flags, result);
+	return 0;
+}
+
+/**
+ * `kernel suggest-voice <kernel-id> --notes "make it funnier" --voice-config-file current.json` —
+ * which voice settings a note asks for. Changes nothing; `kernel update --voice-config-file` saves.
+ */
+async function kernelSuggestVoice(ctx) {
+	const { client, positionals, flags, io } = ctx;
+	const args = argsFromFlags(ARGS.suggest_kernel_voice_settings, flags, positionals);
+	if (args.notes === undefined) throw new CliError("Provide the note with --notes <text> or --notes-file <path>.");
+	if (args.current === undefined) {
+		throw new CliError(
+			"Provide the kernel's current voice settings with --voice-config-file <path> (register, humor, inquisitive)."
+		);
+	}
+	const result = await client.callTool("suggest_kernel_voice_settings", args);
+	printResult(io, flags, result);
+	return 0;
+}
+
+/**
+ * `kernel try <kernel-id> --body "…" [--kernel-version N] [--name "…"]` — the Studio's run: a
+ * throwaway article from any kernel the org can use, kept in the Studio's History. Follows the
+ * run like `write` unless --no-wait.
+ */
+async function kernelTry(ctx) {
+	const { client, positionals, flags, io } = ctx;
+	const args = argsFromFlags(ARGS.start_kernel_studio_run, flags, positionals);
+	if (args.brief === undefined) {
+		throw new CliError("Provide the brief with --body <text>, --file <path>, or --file - (stdin).");
+	}
+	const result = await client.callTool("start_kernel_studio_run", args);
+	const runId = toolField(result, "run")?.external_id;
+	if (!runId || flags["no-wait"] === true) {
+		if (runId) ok(ctx, `Started ${runId}. Follow it with: ${ctx.bin} kernel history --kernel ${args.kernel_id}`);
+		printResult(io, flags, result);
+		return 0;
+	}
+	ok(ctx, `Started ${runId}. Waiting — this keeps running on the server if you stop.`);
+	let lastStatus;
+	const { settled, value: polled } = await followJob(
+		io,
+		async () => {
+			const r = await client.callTool(
+				"get_kernel_studio_run",
+				argsFromFlags(ARGS.get_kernel_studio_run, {}, [runId])
+			);
+			lastStatus = toolField(r, "run")?.status;
+			return { done: !!lastStatus && lastStatus !== "running", value: r };
+		},
+		{ intervalMs: POLL_INTERVAL_MS, ceilingMs: POLL_CEILING_MS }
+	);
+	if (!settled) {
+		ok(ctx, `Still running after 45 minutes. It stays in the Studio's History: ${ctx.bin} kernel history`);
+		printResult(io, flags, polled);
+		return 0;
+	}
+	ok(ctx, `Run ${lastStatus}.`);
+	printResult(io, flags, polled, (v) => (typeof v?.article === "string" ? v.article : JSON.stringify(v, null, 2)));
+	return lastStatus === "done" ? 0 : 1;
+}
+
+/** `kernel history [--kernel <id>] [--limit N]` — the Studio's History. */
+async function kernelHistory(ctx) {
+	const { client, positionals, flags, io } = ctx;
+	const result = await client.callTool(
+		"list_kernel_studio_runs",
+		argsFromFlags(ARGS.list_kernel_studio_runs, flags, positionals)
+	);
+	printResult(io, flags, result);
+	return 0;
+}

package/lib/commands/outbound.mjs

@@ -59,6 +59,8 @@ const SEQUENCE_RAIL_ARGS = {
 	postal_address_footer: { flag: "postal-address-footer", type: "bool", negate: "no-postal-address-footer" },
 	unsubscribe_links: { flag: "unsubscribe-links", type: "bool", negate: "no-unsubscribe-links" },
 	detect_reply_opt_outs: { flag: "detect-reply-opt-outs", type: "bool", negate: "no-detect-reply-opt-outs" },
+	// Staff-only to turn on (the server refuses it for anyone else): walks as live, sends nothing.
+	test_mode: { flag: "test-mode", type: "bool", negate: "no-test-mode" },
 };
 
 // A send-window edge from --<flag> HH:MM (or a raw minute of day) → the
@@ -158,6 +160,17 @@ export const ARGS = {
 		item_id: { positional: 0, label: "item-id", required: true },
 		action: { flag: "action", required: true, enum: ["approve", "skip", "delete"] },
 	},
+	list_dispatches: {},
+	create_dispatch: {
+		name: { flag: "name", required: true },
+	},
+	update_dispatch: {
+		dispatch_id: { positional: 0, label: "dispatch-id", required: true },
+		name: { flag: "name", required: true },
+	},
+	delete_dispatch: {
+		dispatch_id: { positional: 0, label: "dispatch-id", required: true },
+	},
 	list_dispatch_links: {},
 	create_dispatch_link: {
 		days: { flag: "days", type: "num", required: true },
@@ -210,6 +223,26 @@ export const ARGS = {
 		status: { flag: "status", enum: PROSPECT_STATUSES },
 		q: "q",
 	},
+	delete_prospects: {
+		prospect_ids: {
+			value: (flags, positionals) => {
+				const ids = [...positionals, ...flagList(flags.id)];
+				if (!ids.length) throw new CliError("Missing <prospect-id>... (or --id <prospect-id>, repeatable)");
+				return ids;
+			},
+		},
+	},
+	create_prospect_column: {
+		label: { positional: 0, label: "label", required: true },
+	},
+	delete_prospect_column: {
+		column_id: { positional: 0, label: "column-id", required: true },
+	},
+	generate_prospect_openers: {
+		list_id: { positional: 0, label: "list-id", required: true },
+		group_id: "group",
+		new_group_name: "new-group",
+	},
 	update_prospect: {
 		prospect_id: { positional: 0, label: "prospect-id", required: true },
 		status: { flag: "status", enum: PROSPECT_STATUSES },
@@ -292,6 +325,7 @@ const VALUE_FLAGS = {
 	update_sequence: ["flow", "flow-file", "mailer", "send-window-start", "send-window-end"],
 	enroll_in_sequence: ["recipients", "recipients-file", "email"],
 	update_review_item: ["body", "file"],
+	delete_prospects: ["id"],
 	import_prospects_csv: ["csv", "csv-file"],
 	update_prospect: ["custom"],
 	set_mailer_forwarding: ["to", "clear"],
@@ -306,6 +340,37 @@ async function run(ctx, tool, message) {
 }
 
 const SEQUENCES_USAGE = `Usage: sequences <list|get|create|update|pause|resume|enroll|stop|review|links>`;
+const DISPATCHES_USAGE = `Usage: dispatches <list|create|rename|delete>`;
+
+// Dispatches: the named review desks a sequence's review stage queues to.
+export async function cmdDispatches(ctx) {
+	const sub = ctx.positionals[0];
+	const rest = { ...ctx, positionals: ctx.positionals.slice(1) };
+	switch (sub) {
+		case "list":
+		case "ls":
+		case undefined:
+			return run(rest, "list_dispatches");
+		case "create":
+		case "new":
+			return run(rest, "create_dispatch", "Dispatch created.");
+		case "rename":
+		case "update":
+			return run(rest, "update_dispatch", "Dispatch renamed.");
+		case "delete": {
+			if (!ctx.flags.yes) {
+				const id = flagStr(rest.positionals[0]) ?? "<dispatch-id>";
+				ctx.io.error(
+					`Its queued emails move to the default desk. Re-run with --yes to confirm: ${ctx.bin} dispatches delete ${id} --yes`
+				);
+				return 1;
+			}
+			return run(rest, "delete_dispatch", "Dispatch deleted; its queued emails moved to the default desk.");
+		}
+		default:
+			throw new CliError(`Unknown dispatches subcommand: ${sub}. ${DISPATCHES_USAGE}`);
+	}
+}
 
 export async function cmdSequences(ctx) {
 	const sub = ctx.positionals[0];
@@ -395,7 +460,7 @@ async function sequencesLinks(ctx, sub) {
 	}
 }
 
-const PROSPECTS_USAGE = `Usage: prospects <lists|list|ls|get|create-list|delete-list|import|source|enrich|update>`;
+const PROSPECTS_USAGE = `Usage: prospects <lists|list|ls|get|create-list|delete-list|import|source|enrich|openers|update|delete|columns>`;
 
 export async function cmdProspects(ctx) {
 	const sub = ctx.positionals[0];
@@ -424,13 +489,46 @@ export async function cmdProspects(ctx) {
 			);
 		case "enrich":
 			return run(rest, "enrich_prospects", "Enrichment queued.");
+		case "openers":
+			return run(rest, "generate_prospect_openers", "Printing openers; they fill in as each one lands.");
 		case "update":
 			return run(rest, "update_prospect", "Updated prospect.");
+		case "delete":
+		case "rm": {
+			if (!ctx.flags.yes) {
+				ctx.io.error(`Deleting prospects cannot be undone. Re-run with --yes to confirm.`);
+				return 1;
+			}
+			return run(rest, "delete_prospects", "Deleted.");
+		}
+		case "columns":
+			return prospectsColumns(rest, rest.positionals[0]);
 		default:
 			throw new CliError(`Unknown prospects subcommand: ${sub ?? "(none)"}. ${PROSPECTS_USAGE}`);
 	}
 }
 
+async function prospectsColumns(ctx, sub) {
+	const inner = { ...ctx, positionals: ctx.positionals.slice(1) };
+	switch (sub) {
+		case "add":
+			return run(inner, "create_prospect_column", "Column added.");
+		case "delete":
+		case "rm": {
+			if (!ctx.flags.yes) {
+				const id = flagStr(inner.positionals[0]) ?? "<column-id>";
+				ctx.io.error(`Re-run with --yes to confirm: ${ctx.bin} prospects columns delete ${id} --yes`);
+				return 1;
+			}
+			return run(inner, "delete_prospect_column", "Column removed.");
+		}
+		default:
+			throw new CliError(
+				`Unknown columns subcommand: ${sub ?? "(none)"}. Try: add <label>, delete <column-id> --yes`
+			);
+	}
+}
+
 const MAILERS_USAGE = `Usage: mailers <list|domain|messages|message|forward|warmup|limit|retire|suppressions>`;
 
 export async function cmdMailers(ctx) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@letterstory/cli",
-	"version": "0.64.0",
+	"version": "0.66.0",
 	"description": "Spin up and manage Letterstory phantom blogs from your terminal.",
 	"type": "module",
 	"license": "UNLICENSED",