@letterstory/cli 0.23.0 → 0.25.0

package/lib/cli.mjs

@@ -44,7 +44,7 @@ import {
 } from "./commands.mjs";
 
 // Keep in sync with cli/package.json.
-export const VERSION = "0.23.0";
+export const VERSION = "0.25.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.
@@ -316,14 +316,20 @@ Writing kernels (kernels write the draft; they do not research — run research
                                                         to a kernel and an in-loop shredder
   kernel endpoint delete <endpoint-id> --yes           Remove one
   kernel write <endpoint-id> (--body <text>|--file <path>|--file -)
-export const VERSION = "0.23.0";
                                                         WRITE a new article from a headline,
                                                         outline, notes or a finished post.
                                                         Follows the run unless --no-wait, and
                                                         prints the article when it lands.
-  kernel polish <endpoint-id> (--body <html>|--file <path>) [--format auto|html]
-                                                        POLISH the document you have: prose
-                                                        reworded, your own markup kept
+  kernel polish <endpoint-id> (--body <html>|--file <path>|--file -) [--no-wait]
+                                                        Run the SAME pipeline against a
+                                                        document you already have instead of
+                                                        writing a new one: prose reworded,
+                                                        your own markup kept, the same rules
+                                                        and jury as any other run. Follows the
+                                                        run unless --no-wait, and costs a run
+                                                        exactly like 'kernel write' does —
+                                                        there is no separate free, instant
+                                                        polish any more.
   kernel run-status <run-id>                           Poll a write started with 'kernel write'
   kernel runs [--endpoint <id>] [--limit <n>]          Recent endpoint writes (telemetry)
   kernel balance                                       Kernel runs left on this org

package/lib/commands/connectors.mjs

@@ -1,12 +1,12 @@
 // `connectors` — export finished articles to external CMSs/doc tools (Webflow,
-// Framer, Google Docs, Contentful) and check publish status. Ported from
-// phantomstory-cli's connectors.ts.
+// Framer, Google Docs, Contentful, GitHub) and check publish status. Ported
+// from phantomstory-cli's connectors.ts.
 
 import { CliError } from "../client.mjs";
 import { printResult, ok, argsFromFlags } from "./shared.mjs";
 
 const CMS_PROVIDERS = ["webflow", "framer", "sanity", "contentful"];
-const PUBLISH_CONNECTORS = ["webflow", "framer", "google_docs", "contentful"];
+const PUBLISH_CONNECTORS = ["webflow", "framer", "google_docs", "contentful", "github"];
 
 // 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.

package/lib/commands/kernel.mjs

@@ -145,6 +145,9 @@ async function kernelWrite(ctx) {
 		// it, so the verdict lands on the text that actually ships. Costs a shred as well as a
 		// run. Reachable from every other surface and, until now, not from here.
 		shredder_endpoint_id: flagStr(flags.shredder),
+		// How hard that in-loop shred rewrites — 'standard' (default, recommended), 'high',
+		// or 'max'. Ignored when no shred runs.
+		shred_aggression: flagStr(flags["shred-aggression"]),
 		// The flag is --read-as, which is what shipped; an earlier draft of this branch
 		// called it --brief-mode and never reached anyone.
 		brief_mode: flagStr(flags["read-as"]),
@@ -225,7 +228,18 @@ async function kernelEndpoint(ctx) {
 	throw new CliError(`Unknown kernel endpoint action: ${action ?? "(none)"}. Try: create, delete`);
 }
 
-/** The OTHER door: reword the document you already have, keeping its own markup. */
+/**
+ * The OTHER door: run the same pipeline against a document you already have, instead of
+ * writing a new one. Skips generation only — the rules, the in-loop shred and the jury all
+ * still run, which is what keeps your own markup (images, embeds, links, tables, anchors,
+ * shortcodes) intact through a real pass rather than an unguarded shortcut.
+ *
+ * ASYNCHRONOUS, same as `write` — this used to be a separate, synchronous, unmetered "polish"
+ * that answered in one request. That path was deleted (2026-09-15, letterstory#1783): it
+ * worked by skipping the rules and the jury, and that was the actual cost of being instant
+ * and free. `document` now costs a run and follows the identical submit-and-poll shape
+ * `write` does, so this command does too — `--no-wait` behaves the same way here.
+ */
 async function kernelPolish(ctx) {
 	const { client, positionals, flags, io } = ctx;
 	const endpointId = requirePositional(positionals, 0, "endpoint-id");
@@ -238,10 +252,38 @@ async function kernelPolish(ctx) {
 		document,
 		format: flagStr(flags.format),
 	});
-	// Synchronous by nature: a polish is one pass over the sentences, not a multi-round write.
 	const result = await client.callTool("run_kernel", args);
-	printResult(io, flags, result);
-	return 0;
+	const runId = toolField(result, "run_id");
+	if (!runId) {
+		printResult(io, flags, result);
+		return 0;
+	}
+	if (flags["no-wait"] === true) {
+		ok(ctx, `Polish started as ${runId}. Follow it with: letterstory kernel run-status ${runId}`);
+		printResult(io, flags, result);
+		return 0;
+	}
+
+	ok(ctx, `Polish started as ${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_endpoint_run", { run_id: runId });
+			lastStatus = toolField(r, "status");
+			return { done: !!lastStatus && lastStatus !== "running" && lastStatus !== "queued", value: r };
+		},
+		{ intervalMs: POLL_INTERVAL_MS, ceilingMs: POLL_CEILING_MS }
+	);
+
+	if (!settled) {
+		ok(ctx, `Still running after 45 minutes. Follow it with: letterstory kernel run-status ${runId}`);
+		printResult(io, flags, polled);
+		return 0;
+	}
+	ok(ctx, `Polish ${lastStatus}.`);
+	printResult(io, flags, polled, (v) => (typeof v?.article === "string" ? v.article : JSON.stringify(v, null, 2)));
+	return lastStatus === "done" ? 0 : 1;
 }
 
 async function kernelRunStatus(ctx) {

package/package.json

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