@letterstory/cli 0.39.0 → 0.40.0

package/README.md

@@ -172,6 +172,9 @@ letterstory collection run-status <run-id>                      # status, steps,
 letterstory collection runs --collection <id> --status ready
 letterstory collection approve <run-id> --now
 letterstory collection cancel <run-id>
+letterstory collection inventory <id>                           # every piece; each finished draft's publish-on-its-own time
+letterstory collection links <id>                               # internal-link refresh: on/off, posts due
+letterstory collection links <id> --refresh                     # run the next batch now
 letterstory collection delete <id> --yes
 
 # the legacy verbs still work under `collections`
@@ -245,6 +248,23 @@ letterstory onboarding status
 letterstory onboarding step --complete connect_domain
 ```
 
+### What needs you — the collection's "needs you" strip, from the terminal
+
+Everything in the strip either applies itself after its countdown or waits for your
+decision; the same reads and decisions are here.
+
+```bash
+letterstory suggestions list <collection-id>          # strategy cards + when each applies itself
+letterstory suggestions dismiss proposal <id>         # reject one inside its window
+letterstory collection inventory <collection-id>      # finished drafts + when each publishes on its own
+letterstory collection links <collection-id>          # internal links due for a refresh
+
+# proposed edits to live posts: a mention an AI citation earned, or fresher internal links
+letterstory revisions list --collection <collection-id>
+letterstory revisions accept <revision-id>                     # every change; live where we publish
+letterstory revisions reject <revision-id> --change <change-id> --note "not this one"
+```
+
 ### Offerings — one org, many products
 
 Context is layered **org → offering → collection**. An offering is anything the org would

package/lib/cli.mjs

@@ -27,6 +27,7 @@ import {
 	cmdDirectives,
 	cmdProbes,
 	cmdSuggestions,
+	cmdRevisions,
 	cmdOnboarding,
 	cmdSeries,
 	cmdInsights,
@@ -47,10 +48,11 @@ import {
 	cmdAdmin,
 	cmdFeedback,
 	cmdOfferings,
+	cmdTargets,
 } from "./commands.mjs";
 
 // Keep in sync with cli/package.json.
-export const VERSION = "0.39.0";
+export const VERSION = "0.40.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.
@@ -116,6 +118,8 @@ const BOOLEAN_FLAGS = new Set([
 	"none",
 	// `prospects import|source --one-per-company`.
 	"one-per-company",
+	// `targets update <id> --clear-framing`.
+	"clear-framing",
 ]);
 
 // Tiny argv parser: `--flag value`, `--flag=value`, boolean `--flag`, and positionals.
@@ -205,6 +209,8 @@ Collections (the content engine as a primitive — one door, 'collection run'):
   collection runs [--collection <id>] [--status <s>] [--limit <n>]
   collection approve <run-id> [--now]                  Answer the gate (--now publishes immediately)
   collection cancel <run-id>
+  collection inventory <id>                            Where every piece is; each finished draft's publish-on-its-own time
+  collection links <id> [--refresh]                    Internal-link refresh: on/off, posts due (--refresh runs the next batch now)
   collection delete <id> --yes
 
 Phantomstory (a collection Letterstory hosts as an independent publication):
@@ -303,6 +309,9 @@ Strategy & onboarding:
   strategy topics set --collection <uuid> (--topic <topic-id> | --suggestion <suggestion-id>)
   suggestions list <collection_id>                     List pending strategy suggestions + their auto-apply countdown
   suggestions approve | dismiss | snooze <verdict|proposal> <id> [--days <n>]
+  revisions list [--collection <uuid>]                 Proposed edits to live posts waiting for a decision
+  revisions accept | reject <revision-id> [--change <change-id>] [--note <text>]
+                                                       Decide one change or all; accepting goes live where we publish
   directives list <collection_id>                      What is steering this collection right now
   directives propose <collection_id> <what you want>   Read one instruction back as concrete levers (applies nothing)
   directives apply <directive_id> --effect <id>...     Commit the levers you kept (or --reason to decline them all)
@@ -344,6 +353,19 @@ Offerings (context layered org → offering → collection; a layer sets only wh
   series create --name <n> --description <d> [--coverage a,b,c] [--collection <uuid>] [--template <key>]
   series backfill <series-id> [--collection <uuid>]    Reconstruct a series from existing posts
 
+Ranking targets (what the org wants to be THE answer for — company-wide or on one offering):
+  targets list [--offering <offering-id|company>]      Targets grouped by scope, each with its active cap and usage
+  targets add <phrase> [--framing <f>] [--offering <offering-id|company>]
+                                                       Lands active while its scope has room, inactive after —
+                                                       adding never fails on the cap
+  targets update <target-id> [--phrase <p>] [--framing <f> | --clear-framing] [--offering <offering-id|company>]
+                   [--position <n>] [--state active|inactive|achieved|retired]
+                                                       Moving an ACTIVE target needs room in the new scope
+  targets activate | deactivate <target-id>            Switch a target on/off; activating is refused at the cap
+  targets cap <offering-id|company> <n|default>        Active targets allowed in that scope (preset 5; default =
+                                                       inherit the company's cap / back to the preset)
+  targets suggest [--offering <offering-id|company>]   Evidence-informed suggestions (nothing saved)
+
 Arenas (adversarial clusters of research agents -> a sourced, fact-checked outline):
   arena run --topic <text> [--source <url> …] [--must-include <text> …] [--depth barebones|fleshed_out]
             [--gate] [--no-verify] [--provider native|exa|youcom|firecrawl] [--mention off|subtle|woven]
@@ -740,7 +762,8 @@ Prospects (who you write to):
            [--city] [--country] [--years] [--notes] [--custom key=value]...
 
 Mail:
-  mail connections                                     Connected mailboxes, Google connect + Vercel key status
+  mail connections                                     Connected mailboxes, Google connect, Vercel key + mailing address status
+  mail postal-address "<address>"                      Set the org's CAN-SPAM mailing address (email footers)
 
 Insights:
   insights site [--period 14d|30d|90d] [--collection <uuid>]
@@ -806,8 +829,10 @@ const CLIENT_COMMANDS = {
 	strategy: cmdStrategy,
 	directives: cmdDirectives,
 	offerings: cmdOfferings,
+	targets: cmdTargets,
 	probes: cmdProbes,
 	suggestions: cmdSuggestions,
+	revisions: cmdRevisions,
 	onboarding: cmdOnboarding,
 	series: cmdSeries,
 	insights: cmdInsights,

package/lib/commands/collection.mjs

@@ -10,7 +10,7 @@
 
 import { readFileSync } from "node:fs";
 import { CliError } from "../client.mjs";
-import { flagStr, printResult, ok, toolField, followJob, argsFromFlags } from "./shared.mjs";
+import { flagStr, printResult, ok, toolField, followJob, argsFromFlags, refuseUnknownFlags } from "./shared.mjs";
 
 function readJsonFileFlag(flags, flag) {
 	const path = flagStr(flags[flag]);
@@ -114,6 +114,15 @@ export const ARGS = {
 	cancel_collection_run: {
 		run_id: { positional: 0, label: "run-id", required: true },
 	},
+	get_collection_inventory: {
+		collection_id: { positional: 0, label: "collection-id", required: true },
+	},
+	get_internal_link_status: {
+		collection_id: { positional: 0, label: "collection-id", required: true },
+	},
+	refresh_internal_links: {
+		collection_id: { positional: 0, label: "collection-id", required: true },
+	},
 };
 
 export async function cmdCollection(ctx) {
@@ -142,9 +151,13 @@ export async function cmdCollection(ctx) {
 			return collectionApprove(rest);
 		case "cancel":
 			return collectionCancel(rest);
+		case "inventory":
+			return collectionInventory(rest);
+		case "links":
+			return collectionLinks(rest);
 		default:
 			throw new CliError(
-				`Unknown collection subcommand: ${sub ?? "(none)"}. Try: list, new, config, delete, run, run-status, runs, approve, cancel`
+				`Unknown collection subcommand: ${sub ?? "(none)"}. Try: list, new, config, delete, run, run-status, runs, approve, cancel, inventory, links`
 			);
 	}
 }
@@ -277,3 +290,72 @@ async function collectionCancel(ctx) {
 	printResult(ctx.io, ctx.flags, result);
 	return 0;
 }
+
+// `collection inventory <id>` — where every piece is, and each finished draft's
+// publish-on-its-own time (the collection room's Work tab + "needs you" strip).
+function formatInventory(r) {
+	const lines = [
+		`Planner: ${r.planner?.enabled ? "on" : "off"} (${r.planner?.approvalMode ?? "?"})`,
+		`Live ${r.live?.count ?? 0} · written, not live ${r.readyNotLive?.count ?? 0} · being written ${r.beingWritten?.count ?? 0} · imported ${r.imported?.count ?? 0}`,
+	];
+	const pending = r.pendingReview?.items ?? [];
+	if (pending.length) {
+		lines.push(`Finished drafts (${r.pendingReview.count}):`);
+		for (const d of pending) {
+			const when = d.autoPublishAt ? `publishes on its own ${d.autoPublishAt}` : "waits for a person";
+			lines.push(`  ${d.articleId}  ${d.title}  [${when}]`);
+		}
+	}
+	return lines.join("\n");
+}
+
+async function collectionInventory(ctx) {
+	refuseUnknownFlags(ctx, {});
+	const result = await ctx.client.callTool(
+		"get_collection_inventory",
+		argsFromFlags(ARGS.get_collection_inventory, ctx.flags, ctx.positionals)
+	);
+	printResult(ctx.io, ctx.flags, result, formatInventory);
+	return 0;
+}
+
+// `collection links <id>` reads the internal-link refresh; `--refresh` runs the next
+// batch now (republished, or proposed for approval on a manual-approval collection).
+async function collectionLinks(ctx) {
+	const { client, flags, positionals, io } = ctx;
+	refuseUnknownFlags(ctx, {}, ["refresh"]);
+	if (flags.refresh === true) {
+		const r = await client.callTool(
+			"refresh_internal_links",
+			argsFromFlags(ARGS.refresh_internal_links, flags, positionals)
+		);
+		const parts = [];
+		if (r.posts_started) parts.push(`${r.posts_started} refreshing (each republishes when it finishes)`);
+		if (r.posts_proposed) parts.push(`${r.posts_proposed} proposed for approval (see: revisions list)`);
+		if (r.posts_skipped) parts.push(`${r.posts_skipped} busy with another run`);
+		if (!parts.length) {
+			parts.push(
+				r.skipped?.no_sitemap
+					? "no sitemap to link from"
+					: r.next_due_in_days === null
+						? "nothing due: every post already links to everything published since"
+						: `nothing due yet (next in ${r.next_due_in_days ?? "?"} days)`
+			);
+		}
+		ok(ctx, `Internal links: ${parts.join("; ")}.`);
+		if (flags.json) printResult(io, flags, r);
+		return 0;
+	}
+	const s = await client.callTool(
+		"get_internal_link_status",
+		argsFromFlags(ARGS.get_internal_link_status, flags, positionals)
+	);
+	printResult(io, flags, s, (r) =>
+		[
+			`Internal links: ${r.enabled ? "on" : "off"}`,
+			`Due now: ${r.due}`,
+			`Next due: ${r.next_due_in_days === null ? "only when something new publishes" : `in ${r.next_due_in_days} days`}`,
+		].join("\n")
+	);
+	return 0;
+}

package/lib/commands/outbound.mjs

@@ -167,6 +167,9 @@ export const ARGS = {
 		custom: { value: readCustom },
 	},
 	get_mail_connections: {},
+	set_mail_postal_address: {
+		mail_postal_address: { positional: 0, label: "address", required: true },
+	},
 };
 
 // Flags the computed `value` sources read (refuseUnknownFlags can't see them).
@@ -318,7 +321,9 @@ export async function cmdMail(ctx) {
 		case "connections":
 		case "status":
 			return run(rest, "get_mail_connections");
+		case "postal-address":
+			return run(rest, "set_mail_postal_address", "Mailing address saved.");
 		default:
-			throw new CliError(`Unknown mail subcommand: ${sub ?? "(none)"}. Try: connections`);
+			throw new CliError(`Unknown mail subcommand: ${sub ?? "(none)"}. Try: connections, postal-address`);
 	}
 }

package/lib/commands/revisions.mjs

@@ -0,0 +1,81 @@
+// `revisions` — proposed edits to already-live posts, waiting for a decision: the
+// Approvals queue in a collection's "needs you" strip. A mention an AI citation
+// earned (review-posture collection), or internal links the nightly refresh would
+// add (manual-approval or client-CMS collection). Thin wrappers over the MCP tools
+// list_revisions / decide_revision, which call the same lib/revisions functions the
+// web queue does — accepting on a page we publish puts it live.
+
+import { CliError } from "../client.mjs";
+import { printResult, argsFromFlags, refuseUnknownFlags, ok } from "./shared.mjs";
+
+const DECISIONS = ["accepted", "rejected"];
+
+// How every tool this module calls gets its arguments — see `argsFromFlags` in shared.mjs.
+// `scripts/parity-check.ts` compares these keys against each tool's published input schema.
+export const ARGS = {
+	list_revisions: { collection_id: "collection" },
+	decide_revision: {
+		revision_id: { positional: 0, label: "revision-id", required: true },
+		// `accept` / `reject` set this for you.
+		decision: { flag: "decision", enum: DECISIONS },
+		change_id: "change",
+		note: "note",
+	},
+};
+
+const USAGE = `Usage: revisions <list|accept|reject>
+  revisions list [--collection <uuid>]
+  revisions accept <revision-id> [--change <change-id>]
+  revisions reject <revision-id> [--change <change-id>] [--note <text>]`;
+
+export async function cmdRevisions(ctx) {
+	const sub = ctx.positionals[0];
+	const rest = { ...ctx, positionals: ctx.positionals.slice(1) };
+	switch (sub) {
+		case "list":
+		case "ls":
+			return revisionsList(rest);
+		case "accept":
+			return revisionsDecide(rest, "accepted");
+		case "reject":
+			return revisionsDecide(rest, "rejected");
+		default:
+			throw new CliError(USAGE);
+	}
+}
+
+function formatRevision(r) {
+	const where = r.publish_control === "platform" ? "goes live on accept" : "apply it in your CMS after accepting";
+	const lines = [
+		`${r.id}  ${r.article_title ?? "Untitled"}  (${r.source}; ${where})${r.is_stale ? "  [STALE — needs recomputing]" : ""}`,
+	];
+	if (r.reason) lines.push(`  ${r.reason}`);
+	for (const c of r.changes ?? []) {
+		const state = c.decision ?? "undecided";
+		lines.push(`  - ${c.id} [${state}] ${c.before ? `${c.before} → ` : ""}${c.after}`);
+	}
+	return lines.join("\n");
+}
+
+async function revisionsList(ctx) {
+	const { client, flags, io } = ctx;
+	refuseUnknownFlags(ctx, ARGS.list_revisions);
+	const result = await client.callTool("list_revisions", argsFromFlags(ARGS.list_revisions, flags));
+	printResult(io, flags, result, (r) => {
+		const items = r.revisions ?? [];
+		return items.length ? items.map(formatRevision).join("\n\n") : "No proposed edits waiting.";
+	});
+	return 0;
+}
+
+async function revisionsDecide(ctx, decision) {
+	const { client, flags, positionals, io } = ctx;
+	refuseUnknownFlags(ctx, ARGS.decide_revision);
+	const result = await client.callTool(
+		"decide_revision",
+		argsFromFlags(ARGS.decide_revision, { ...flags, decision }, positionals)
+	);
+	ok(ctx, result.applied ?? `Revision is ${result.status}.`);
+	if (flags.json) printResult(io, flags, result);
+	return 0;
+}

package/lib/commands/targets.mjs

@@ -0,0 +1,223 @@
+// `targets` — ranking targets: what the org wants to be THE answer for.
+//
+// A target belongs to the company (company-wide) or to one offering. Each scope — the
+// company layer and every offering — holds its own ACTIVE targets up to its cap (a preset
+// of 5, adjustable per scope with `targets cap`); inactive targets are never capped, so
+// `add` never fails on the cap: it lands inactive when the scope is full. Thin wrappers
+// over the MCP tools, which call the same store functions the app's /api/ranking-targets
+// routes and staff Fleet do.
+
+import { CliError } from "../client.mjs";
+import { flagStr, flagNum, printResult, argsFromFlags, refuseUnknownFlags, ok } from "./shared.mjs";
+
+const STATUSES = ["active", "inactive", "achieved", "retired"];
+const COMPANY = "company";
+
+// `--offering <offering-id|company>`: company = the company layer (null). Absent = not sent.
+function readOffering(flags) {
+	const v = flagStr(flags.offering);
+	if (v === undefined) {
+		if (flags.offering === true) throw new CliError("--offering takes an offering id, or `company`");
+		return undefined;
+	}
+	return v === COMPANY ? null : v;
+}
+const offering = { value: readOffering };
+
+// How every tool this module calls gets its arguments — see `argsFromFlags` in shared.mjs.
+// `scripts/parity-check.ts` compares these keys against each tool's published input schema.
+export const ARGS = {
+	list_ranking_targets: { offering_id: offering },
+	add_ranking_target: {
+		// The phrase is every positional, so `targets add best payroll software` needs no quotes.
+		phrase: {
+			value: (_flags, positionals) => {
+				const phrase = positionals.join(" ").trim();
+				if (!phrase) throw new CliError("Missing required <phrase>");
+				return phrase;
+			},
+		},
+		mention_framing: "framing",
+		offering_id: offering,
+	},
+	update_ranking_target: {
+		target_id: { positional: 0, label: "target-id", required: true },
+		phrase: "phrase",
+		mention_framing: {
+			value: (flags) => (flags["clear-framing"] === true ? null : flagStr(flags.framing)),
+		},
+		// `activate` / `deactivate` set this for you.
+		status: { flag: "state", enum: STATUSES },
+		offering_id: offering,
+		position: { flag: "position", type: "num" },
+	},
+	set_ranking_target_cap: {
+		offering_id: {
+			value: (_flags, positionals) => {
+				const scope = positionals[0];
+				if (scope === undefined) throw new CliError("Missing required <offering-id|company>");
+				return scope === COMPANY ? null : scope;
+			},
+		},
+		// `default` = back to inheriting (an offering → the company's cap; the company → the preset).
+		cap: {
+			value: (_flags, positionals) => {
+				const raw = positionals[1];
+				if (raw === undefined) throw new CliError("Missing required <n|default>");
+				return raw === "default" ? null : flagNum(raw);
+			},
+		},
+	},
+	suggest_ranking_targets: { offering_id: offering },
+};
+
+const USAGE = `Usage: targets <list|add|update|activate|deactivate|cap|suggest>
+  targets list [--offering <offering-id|company>]
+  targets add <phrase> [--framing <f>] [--offering <offering-id|company>]
+  targets update <target-id> [--phrase <p>] [--framing <f> | --clear-framing] [--offering <offering-id|company>]
+                 [--position <n>] [--state active|inactive|achieved|retired]
+  targets activate <target-id>
+  targets deactivate <target-id>
+  targets cap <offering-id|company> <n|default>
+  targets suggest [--offering <offering-id|company>]`;
+
+export async function cmdTargets(ctx) {
+	const sub = ctx.positionals[0];
+	const rest = { ...ctx, positionals: ctx.positionals.slice(1) };
+	switch (sub) {
+		case "list":
+		case "ls":
+			return targetsList(rest);
+		case "add":
+			return targetsAdd(rest);
+		case "update":
+			return targetsUpdate(rest);
+		case "activate":
+			return targetsSetStatus(rest, "active");
+		case "deactivate":
+			return targetsSetStatus(rest, "inactive");
+		case "cap":
+			return targetsCap(rest);
+		case "suggest":
+			return targetsSuggest(rest);
+		default:
+			throw new CliError(USAGE);
+	}
+}
+
+const scopeName = (s) => (s.offeringId === null ? "Company-wide" : s.label);
+
+function formatScope(s) {
+	const where = s.capSetHere ? "set here" : s.offeringId === null ? "preset" : "company's cap";
+	return `${scopeName(s)} — ${s.active}/${s.cap} active (${where})`;
+}
+
+function formatTarget(t) {
+	const framing = t.mention_framing ? ` — as ${t.mention_framing}` : "";
+	return `  ${t.id}  [${t.status}]  ${t.phrase}${framing}`;
+}
+
+// Targets grouped under their scope, each headed by its cap and usage. A target on an
+// offering the scopes list doesn't carry (archived) still shows, under its id.
+export function formatTargets(r) {
+	const scopes = r.scopes ?? [];
+	const items = r.items ?? [];
+	if (!items.length && !scopes.length) return "No ranking targets yet.";
+	const lines = [];
+	const shown = new Set();
+	for (const s of scopes) {
+		const mine = items.filter((t) => (t.offering_id ?? null) === s.offeringId);
+		lines.push(formatScope(s));
+		for (const t of mine) {
+			lines.push(formatTarget(t));
+			shown.add(t.id);
+		}
+		if (!mine.length) lines.push("  (none)");
+	}
+	const orphans = items.filter((t) => !shown.has(t.id));
+	for (const id of [...new Set(orphans.map((t) => t.offering_id))]) {
+		lines.push(`Offering ${id} (not active)`);
+		for (const t of orphans.filter((o) => o.offering_id === id)) lines.push(formatTarget(t));
+	}
+	return lines.join("\n");
+}
+
+async function targetsList(ctx) {
+	const { client, flags, io } = ctx;
+	const result = await client.callTool("list_ranking_targets", argsFromFlags(ARGS.list_ranking_targets, flags));
+	printResult(io, flags, result, formatTargets);
+	return 0;
+}
+
+async function targetsAdd(ctx) {
+	const { client, flags, positionals, io } = ctx;
+	refuseUnknownFlags(ctx, ARGS.add_ranking_target, ["offering"]);
+	const result = await client.callTool(
+		"add_ranking_target",
+		argsFromFlags(ARGS.add_ranking_target, flags, positionals)
+	);
+	const t = result.target;
+	ok(
+		ctx,
+		t?.status === "active"
+			? `Added "${t.phrase}" — active.`
+			: `Added "${t?.phrase}" as inactive: its scope is at its active cap. Deactivate one there, or raise the cap (targets cap), then: ${ctx.bin} targets activate ${t?.id}`
+	);
+	printResult(io, flags, result, (r) => formatTarget(r.target));
+	return 0;
+}
+
+async function update(ctx, flags) {
+	const { client, positionals, io } = ctx;
+	const args = argsFromFlags(ARGS.update_ranking_target, flags, positionals);
+	if (Object.keys(args).length === 1) {
+		throw new CliError(
+			"Nothing to update — pass --phrase, --framing, --clear-framing, --offering, --position or --state."
+		);
+	}
+	const result = await client.callTool("update_ranking_target", args);
+	ok(ctx, `Updated "${result.target?.phrase}" — ${result.target?.status}.`);
+	printResult(io, ctx.flags, result, (r) => formatTarget(r.target));
+	return 0;
+}
+
+async function targetsUpdate(ctx) {
+	refuseUnknownFlags(ctx, ARGS.update_ranking_target, ["framing", "clear-framing", "offering"]);
+	return update(ctx, ctx.flags);
+}
+
+// Activate / deactivate are the first-class switch. Activating is refused when the
+// target's scope is at its cap — the server's message names the scope.
+async function targetsSetStatus(ctx, status) {
+	refuseUnknownFlags(ctx, {});
+	return update(ctx, { ...ctx.flags, state: status });
+}
+
+async function targetsCap(ctx) {
+	const { client, flags, positionals, io } = ctx;
+	refuseUnknownFlags(ctx, {});
+	const result = await client.callTool(
+		"set_ranking_target_cap",
+		argsFromFlags(ARGS.set_ranking_target_cap, flags, positionals)
+	);
+	ok(ctx, "Cap saved.");
+	printResult(io, flags, result, (r) => (r.scopes ?? []).map(formatScope).join("\n"));
+	return 0;
+}
+
+async function targetsSuggest(ctx) {
+	const { client, flags, io } = ctx;
+	const result = await client.callTool("suggest_ranking_targets", argsFromFlags(ARGS.suggest_ranking_targets, flags));
+	printResult(io, flags, result, (r) => {
+		const all = r.suggestions ?? [];
+		if (!all.length) return "No suggestions yet — add positioning first.";
+		const scope = r.offering_id ? ` --offering ${r.offering_id}` : "";
+		const lines = all.map(
+			(s) =>
+				`  ${s.phrase} [${s.basis}]${s.suggestedFraming ? ` — as ${s.suggestedFraming}` : ""}\n    ${s.rationale}`
+		);
+		lines.push(`Nothing saved. Keep one with: ${ctx.bin} targets add <phrase>${scope}`);
+		return lines.join("\n");
+	});
+	return 0;
+}

package/lib/commands.mjs

@@ -18,6 +18,7 @@ export * from "./commands/connectors.mjs";
 export * from "./commands/strategy.mjs";
 export * from "./commands/directives.mjs";
 export * from "./commands/probes.mjs";
+export * from "./commands/revisions.mjs";
 export * from "./commands/series.mjs";
 export * from "./commands/insights.mjs";
 export * from "./commands/covers.mjs";
@@ -34,5 +35,6 @@ export * from "./commands/shredder.mjs";
 export * from "./commands/landings.mjs";
 export * from "./commands/outbound.mjs";
 export * from "./commands/offerings.mjs";
+export * from "./commands/targets.mjs";
 export * from "./commands/admin.mjs";
 export * from "./commands/feedback.mjs";

package/package.json

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