@alexkroman1/aai-cli 5.14.0 → 6.1.0

package/dist/templates/redline/agent.test.ts

@@ -0,0 +1,222 @@
+/**
+ * Specs for the redline desk — the reflection port, as a workflow app.
+ *
+ * Same honest line as `link-digest`'s spec, for the same reason: the workflow
+ * BODY is only durable once the Workflow DevKit's build has transformed it, so
+ * testing it here would exercise a plain async function and prove nothing about
+ * replay. What IS testable is the declaration (three things that are silent when
+ * wrong — the `page: "static"` field, the workflow's name, and the input schema)
+ * and the STEPS, which imported with no bundler in the path are ordinary async
+ * functions: their JSON contract with the model, their `FatalError` guards, and
+ * the pure helpers underneath them.
+ *
+ * The loop's EXIT is the one thing worth naming that a spec here cannot reach.
+ * It is decided in the body, on a step's journaled verdict — see the module doc
+ * in `workflows/redline.ts` — and what would prove it is a replay, which needs a
+ * built world. The critique step's verdict handling is where the testable half
+ * of that lives.
+ */
+
+import { installStubGateway as stubGateway } from "@alexkroman1/aai/testing/vitest";
+import { beforeEach, describe, expect, test, vi } from "vitest";
+import { FatalError } from "workflow";
+import agentDef, { MAX_ROUNDS, redline } from "./agent.ts";
+import {
+  briefBlock,
+  clampScore,
+  countWords,
+  critiqueDraft,
+  MAX_NOTES,
+  type RedlineInput,
+  reviseDraft,
+  writeDraft,
+} from "./workflows/redline.ts";
+
+const INPUT: RedlineInput = {
+  brief: "Explain why our API returns 402 when a workspace is over budget.",
+  audience: "customers",
+  rounds: 2,
+  mustCover: ["what to do about it", "how to raise the cap"],
+};
+
+// ─── 1. The declaration ──────────────────────────────────────────────────────
+
+describe("the agent declares itself a workflow app", () => {
+  test("its front door is a page, not a microphone", () => {
+    // The port's own decision: seven long-form model calls in sequence is not
+    // something anyone holds a phone for.
+    expect(agentDef.page).toBe("static");
+  });
+
+  test("it declares no voice pipeline and no tools, because nothing talks", () => {
+    expect(agentDef.stt).toBeUndefined();
+    expect(agentDef.llm).toBeUndefined();
+    expect(agentDef.tts).toBeUndefined();
+    expect(agentDef.tools).toEqual({});
+  });
+
+  test("under the name the page starts a run by", () => {
+    // `useWorkflowSubmit("redline")` in client.tsx names this key. Nothing else
+    // records it, so a rename here is a 400 there rather than a compile error.
+    expect(Object.keys(agentDef.workflows ?? {})).toEqual(["redline"]);
+    expect(agentDef.workflows?.redline).toBe(redline);
+  });
+
+  test("and declares the credential its steps read", () => {
+    // A workflow app declares no providers, so `requiredEnv` is the ONLY thing
+    // in its config that can name a credential.
+    expect(agentDef.requiredEnv).toContain("ASSEMBLYAI_API_KEY");
+  });
+});
+
+describe("the input schema", () => {
+  const validate = (value: unknown) => redline.input?.["~standard"].validate(value);
+
+  test("caps the rounds at the CALL SITE rather than on the bill", async () => {
+    const tooMany = await validate({ ...INPUT, rounds: MAX_ROUNDS + 1 });
+    expect(tooMany?.issues).toBeDefined();
+  });
+
+  test("defaults the rounds and the required points, so the form need not", async () => {
+    const result = await validate({ brief: INPUT.brief, audience: "engineers" });
+    if (!result || result.issues) throw new Error("expected valid input");
+    expect(result.value).toMatchObject({ rounds: 2, mustCover: [] });
+  });
+
+  test("rejects an audience outside the enum — which is also what makes it a select", async () => {
+    // `<WorkflowFields>` renders a `z.enum` as a `<SelectField>`; the same
+    // declaration is what stops an API caller inventing a fifth audience.
+    expect((await validate({ ...INPUT, audience: "cats" }))?.issues).toBeDefined();
+  });
+
+  test("declares mustCover as an array, which is what the page renders by hand", async () => {
+    // The mixed-form case: `<WorkflowFields>` renders scalars only, so client.tsx
+    // writes this field itself and maps a textarea into it.
+    expect((await validate({ ...INPUT, mustCover: "one point" }))?.issues).toBeDefined();
+    expect((await validate({ ...INPUT, mustCover: ["one point"] }))?.issues).toBeUndefined();
+  });
+});
+
+// ─── 2. Pure helpers ─────────────────────────────────────────────────────────
+
+describe("pure helpers", () => {
+  test("briefBlock restates the brief the same way for all three stages", () => {
+    const block = briefBlock(INPUT);
+    expect(block).toContain(INPUT.brief);
+    expect(block).toContain("customers");
+    expect(block).toContain("- how to raise the cap");
+  });
+
+  test("briefBlock says so when nothing was required, rather than showing an empty list", () => {
+    expect(briefBlock({ ...INPUT, mustCover: [] })).toContain("nothing specific");
+  });
+
+  test("countWords ignores surrounding and repeated whitespace", () => {
+    expect(countWords("  one  two\nthree ")).toBe(3);
+    expect(countWords("   ")).toBe(0);
+  });
+
+  test("clampScore holds a model's number inside the range it was given", () => {
+    expect(clampScore(12)).toBe(10);
+    expect(clampScore(0)).toBe(1);
+    expect(clampScore(7.4)).toBe(7);
+    expect(clampScore(Number.NaN)).toBe(0);
+  });
+});
+
+// ─── 3. The steps ────────────────────────────────────────────────────────────
+
+describe("the steps", () => {
+  beforeEach(() => {
+    // `stepEnv` falls back to the process env when no host has published one,
+    // which is exactly the case a spec is. `unstubEnvs` clears it per test.
+    vi.stubEnv("ASSEMBLYAI_API_KEY", "sk-test");
+  });
+
+  describe("writeDraft", () => {
+    test("returns the piece the model wrote, trimmed", async () => {
+      const calls = stubGateway("\n  A draft about 402s.  \n");
+      expect(await writeDraft(INPUT)).toBe("A draft about 402s.");
+      // The brief reaches the writer — otherwise it writes something else well.
+      expect(calls[0]?.prompt).toContain("how to raise the cap");
+    });
+
+    test("fails FATALLY on a brief that is only whitespace", async () => {
+      // The schema's `.min(20)` counts CHARACTERS, so twenty spaces validate at
+      // `start()` and arrive here as nothing to write from. No number of
+      // attempts makes a brief longer, so it is fatal rather than retryable.
+      stubGateway("unused");
+      await expect(writeDraft({ ...INPUT, brief: " ".repeat(25) })).rejects.toThrow(/too short/);
+    });
+
+    test("lets the SDK refuse an empty completion, RETRYABLY", async () => {
+      // Neither writer step carries an empty-reply guard, because `stepGenerate`
+      // already has one — and its verdict is the one that matters: retryable, so
+      // a blank answer costs an attempt rather than the run. A hand-written
+      // check here would have to re-derive that and could get it wrong.
+      stubGateway("   ");
+      const failure = await writeDraft(INPUT).catch((err: unknown) => err);
+      expect(failure).toBeInstanceOf(Error);
+      expect(failure).not.toBeInstanceOf(FatalError);
+      expect(String(failure)).toMatch(/empty completion/);
+    });
+  });
+
+  describe("critiqueDraft", () => {
+    test("returns the verdict the body branches on, with the score clamped", async () => {
+      stubGateway('{"verdict":"ship","score":42,"notes":["nothing major"]}');
+      const critique = await critiqueDraft("A draft.", INPUT, 1);
+      expect(critique.verdict).toBe("ship");
+      expect(critique.score).toBe(10);
+    });
+
+    test("keeps at most the notes the prompt asked for", async () => {
+      const notes = JSON.stringify(["a", "b", "c", "d", "e"]);
+      stubGateway(`{"verdict":"revise","score":6,"notes":${notes}}`);
+      const critique = await critiqueDraft("A draft.", INPUT, 1);
+      expect(critique.notes).toHaveLength(MAX_NOTES);
+    });
+
+    test("unwraps a fenced reply rather than failing on it", async () => {
+      stubGateway('```json\n{"verdict":"revise","score":5,"notes":["thin"]}\n```');
+      expect((await critiqueDraft("A draft.", INPUT, 1)).notes).toEqual(["thin"]);
+    });
+
+    test("throws PLAINLY when the critic answered with prose, so the step retries", async () => {
+      // The distinction that is the whole retry policy: a model that ignored the
+      // format may well obey on the next attempt, where a 401 will not. Plain
+      // means NOT a `FatalError`, which is what the DevKit stops retrying on.
+      stubGateway("I think the draft is pretty good, honestly.");
+      const err = await critiqueDraft("A draft.", INPUT, 1).catch((thrown: unknown) => thrown);
+
+      expect(FatalError.is(err)).toBe(false);
+      expect((err as Error).message).toMatch(/Expected JSON from the model/);
+    });
+
+    test("rejects a verdict outside the two the loop understands", async () => {
+      // Anything else would be read as "not ship" and quietly cost a round. The
+      // schema NAMES the field, which the hand-written guard this replaced could
+      // not: it answered a bare false.
+      stubGateway('{"verdict":"looks fine","score":8,"notes":[]}');
+      await expect(critiqueDraft("A draft.", INPUT, 1)).rejects.toThrow(
+        /did not match the shape: verdict/,
+      );
+    });
+  });
+
+  describe("reviseDraft", () => {
+    const CRITIQUE = { verdict: "revise" as const, score: 5, notes: ["Say what to do about it."] };
+
+    test("sends the notes to the reviser and returns the revision", async () => {
+      const calls = stubGateway("A better draft about 402s.");
+      const revised = await reviseDraft("A draft.", CRITIQUE, INPUT, 1);
+      expect(revised).toBe("A better draft about 402s.");
+      expect(calls[0]?.prompt).toContain("Say what to do about it.");
+    });
+
+    test("trims what the model returned, since it goes on to be the output", async () => {
+      stubGateway("\n  A better draft.  \n");
+      expect(await reviseDraft("A draft.", CRITIQUE, INPUT, 1)).toBe("A better draft.");
+    });
+  });
+});

package/dist/templates/redline/agent.ts

@@ -0,0 +1,89 @@
+/**
+ * A WORKFLOW APP — LangGraph's reflection agent, as a thing you submit work to.
+ *
+ * `link-digest` owns the shape and is the one to read first (`workflowApp()`, no
+ * session, no tools, a form that starts a run and a page that watches it), and
+ * none of that is restated here. What this one is FOR is the mechanism in
+ * `workflows/redline.ts`: write a piece, grade it against its brief, revise, and
+ * go round again until the critic says ship or the rounds run out.
+ *
+ * ## Why this one is not a voice agent
+ *
+ * It was the first question worth answering, and the answer is arithmetic: a
+ * three-round redline is up to seven long-form model calls in sequence. Nobody
+ * holds a phone for that, and nothing useful can be said down the line while it
+ * happens — the interesting output is a piece of prose to READ, not two
+ * sentences to hear. The same test sorts the other ports in this repo:
+ * `travel-concierge`, `support-line` and `plan-and-execute` all answer a caller inside a
+ * turn, so they are voice agents; this one and `transcription-workflow` produce a
+ * document, so they are pages over durable runs.
+ *
+ * ## What it needs
+ *
+ * - **`ASSEMBLYAI_API_KEY` in the agent env** — `.env` under `aai dev`,
+ *   `aai secret put ASSEMBLYAI_API_KEY` once deployed. A step is handed no
+ *   `ToolContext`, so it reads that key with `requireStepEnv` (inside
+ *   `stepGenerate`); `requiredEnv` below is what makes a deploy check for it
+ *   rather than letting the first run find out.
+ * - **Storage** (`aai storage enable`, or `DATABASE_URL` under `aai dev`) — runs
+ *   live there.
+ */
+
+import { workflow, workflowApp } from "@alexkroman1/aai";
+import { z } from "zod";
+import { redlineFlow } from "./workflows/redline.ts";
+
+/** The most rounds one run may spend. Their `should_continue` cap, as an input:
+ *  the critic can stop earlier, and nothing can go past this. */
+export const MAX_ROUNDS = 3;
+
+/**
+ * The declaration: schema, description, and the directive body.
+ *
+ * The input schema is doing three jobs at once here, which is the thing to
+ * notice. It validates at `start()`, so a `rounds: 40` is a 400 at the call site
+ * rather than forty model calls discovered on the bill; it is served on
+ * `GET /workflows` as JSON Schema, which is what lets `<WorkflowFields>` render
+ * most of this form without the page naming a field; and it is the type the
+ * body reads.
+ *
+ * `mustCover` is an ARRAY, deliberately. `<WorkflowFields>` renders scalars only
+ * — there is no honest control for an array — so the page writes that one field
+ * by hand in the same `<Form>` and maps it on submit. That mixed shape is the
+ * common case for any schema past the simplest, and this is its worked example;
+ * `transcription-workflow` is the all-declared one.
+ */
+export const redline = workflow({
+  description: "Write a piece from a brief, then critique and revise it until it is worth shipping",
+  input: z.object({
+    // Short on purpose: it renders as a one-line control, and a brief that
+    // needs three paragraphs is the `mustCover` list wearing a disguise.
+    brief: z.string().min(20).max(400).describe("One sentence: what to write, and why"),
+    audience: z
+      .enum(["general readers", "engineers", "executives", "customers"])
+      .describe("Who it is for"),
+    // A `z.enum` is what makes the control above a `<SelectField>` rather than a
+    // text box — the form is as good as the schema is specific.
+    rounds: z
+      .number()
+      .int()
+      .min(1)
+      .max(MAX_ROUNDS)
+      .default(2)
+      .describe("How many critique-and-revise rounds to allow"),
+    mustCover: z
+      .array(z.string().max(200))
+      .max(6)
+      .default([])
+      .describe("Points the piece must cover"),
+  }),
+  run: redlineFlow,
+});
+
+export default workflowApp({
+  name: "Redline",
+  workflows: { redline },
+  // Checked at deploy time, so a missing key is a warning naming it rather than
+  // a run that fails on its first step.
+  requiredEnv: ["ASSEMBLYAI_API_KEY"],
+});

package/dist/templates/redline/client.tsx

@@ -0,0 +1,184 @@
+/**
+ * The redline desk's page: a form, the loop turning, and the piece it produced.
+ *
+ * `link-digest` shows the workflow primitives raw and `transcription-workflow` shows
+ * the form layer over them; this page is the MIXED case, which is what most real
+ * schemas need and what neither of those has.
+ *
+ * ## Half of this form is declared and half is written
+ *
+ * `<WorkflowFields>` renders one control per SCALAR property of the workflow's
+ * own input schema, read from `GET /workflows` — so the brief, the audience
+ * picker (a `<SelectField>`, because `agent.ts` declares a `z.enum`) and the
+ * rounds spinner exist here because of what the schema says, and adding a fourth
+ * scalar adds a fourth control with no edit to this file.
+ *
+ * It renders nothing for `mustCover`, deliberately: that property is an ARRAY,
+ * and there is no honest generic control for one. So this page writes that field
+ * itself — a plain `<TextAreaField>` in the same `<Form>`, one point per line —
+ * and maps it on submit. Every field in `@alexkroman1/aai-ui` is a plain named
+ * control, which is what lets the declared and the hand-written ones sit
+ * together and arrive as one object.
+ *
+ * The mapping is the other half of that: `<Form>` collects what the DOM holds,
+ * and a textarea holds a string where the workflow's schema wants `string[]`.
+ * `toInput` is where the two meet — and it is the only place, so the split lives
+ * in one function rather than in the field, the submit handler and the workflow.
+ */
+
+import "@alexkroman1/aai-ui/styles.css";
+import type { WorkflowOutputOf } from "@alexkroman1/aai";
+import {
+  Form,
+  type FormValues,
+  page,
+  SubmitButton,
+  TextAreaField,
+  useWorkflowSubmit,
+  WorkflowFields,
+  WorkflowProgress,
+  type WorkflowRun,
+} from "@alexkroman1/aai-ui";
+import type { redline } from "./agent.ts";
+
+/**
+ * What a finished run reports.
+ *
+ * Derived from the workflow declaration rather than restated — `import type` is
+ * erased, so naming `redline` here bundles none of the agent, the SDK, or the
+ * workflow body into this page.
+ */
+type Redline = WorkflowOutputOf<typeof redline>;
+
+/** The workflow this page drives. Matches the key in `workflowApp({ workflows })`. */
+const WORKFLOW = "redline";
+
+/**
+ * The submitted form as the workflow's input schema wants it.
+ *
+ * One function, because the textarea-to-array split is exactly the kind of
+ * thing that otherwise gets half-done in three places. Blank lines go, so a
+ * trailing newline is not a requirement to cover "".
+ */
+export function toInput(values: FormValues): FormValues {
+  const raw = typeof values.mustCover === "string" ? values.mustCover : "";
+  return {
+    ...values,
+    mustCover: raw
+      .split("\n")
+      .map((line) => line.trim())
+      .filter((line) => line.length > 0),
+  };
+}
+
+function RedlineDesk() {
+  const { submit, run, pending, error, reset } = useWorkflowSubmit<Redline>(WORKFLOW);
+
+  return (
+    <main className="mx-auto flex max-w-2xl flex-col gap-8 p-8">
+      <header className="flex flex-col gap-1">
+        <h1 className="text-2xl font-medium">Redline</h1>
+        <p className="text-sm opacity-70">
+          Give it a brief. It writes a draft, grades the draft against the brief, revises, and goes
+          round again until the critic would ship it or the rounds run out.
+        </p>
+      </header>
+
+      <Form onSubmit={(values) => submit(toInput(values))} error={error}>
+        {/* The scalars: brief, audience, rounds. Declared, not written. */}
+        <WorkflowFields workflow={WORKFLOW} />
+        {/* The array the schema declares and no generic control can render. */}
+        <TextAreaField
+          name="mustCover"
+          label="Must cover"
+          hint="One point per line. Leave empty if nothing is required."
+          rows={3}
+        />
+        <SubmitButton pending={pending}>Write it</SubmitButton>
+      </Form>
+
+      {run && <RunPanel run={run} onClear={reset} />}
+    </main>
+  );
+}
+
+/** The critique trail: what each round objected to, and what the score was. */
+function Rounds({ rounds }: { rounds: Redline["rounds"] }) {
+  if (rounds.length === 0) return null;
+  return (
+    <ol className="flex flex-col gap-3">
+      {rounds.map((entry) => (
+        <li key={entry.round} className="flex flex-col gap-1 border-l pl-4">
+          <p className="text-xs uppercase tracking-[1.2px] opacity-60">
+            Round {entry.round} · {entry.critique.score}/10 ·{" "}
+            {entry.critique.verdict === "ship" ? "ship it" : "revise"}
+          </p>
+          <ul className="flex list-disc flex-col gap-1 pl-5 text-sm">
+            {entry.critique.notes.map((note) => (
+              <li key={note}>{note}</li>
+            ))}
+          </ul>
+        </li>
+      ))}
+    </ol>
+  );
+}
+
+/** The run's status, its narration, its critique trail, and the piece. */
+function RunPanel({ run, onClear }: { run: WorkflowRun<Redline>; onClear: () => void }) {
+  return (
+    <section className="flex flex-col gap-4 rounded-md border p-5">
+      <div className="flex items-baseline justify-between gap-4">
+        <h2 className="text-sm font-medium uppercase tracking-[1.2px]">
+          {STATUS_LINE[run.status]}
+        </h2>
+        <button type="button" onClick={onClear} className="text-xs underline opacity-60">
+          Clear
+        </button>
+      </div>
+
+      {/* The run's own narration — the complement of the status line, which is
+          `running` for a run's whole life, so a one-round redline and a
+          three-round one look identical while they happen. These lines come from
+          the run itself (`report()` in `workflows/redline.ts`), and they REPLAY,
+          so a reload mid-run catches up rather than starting from whatever
+          arrives next. */}
+      <WorkflowProgress runId={run.runId} />
+
+      {/* Discriminated on `status`, so `output` and `error` are reachable
+          without a cast. */}
+      {run.status === "completed" && (
+        <>
+          <p className="text-xs opacity-60">
+            {run.output.words} words · {run.output.roundsRun} round
+            {run.output.roundsRun === 1 ? "" : "s"} ·{" "}
+            {/* Which of the two stop conditions ended the loop is the one thing
+                a reader cannot infer from the round count alone. */}
+            {run.output.shipped ? "the critic stopped it" : "the round budget stopped it"}
+          </p>
+          <Rounds rounds={run.output.rounds} />
+          <article className="whitespace-pre-wrap text-sm leading-relaxed">
+            {run.output.draft}
+          </article>
+        </>
+      )}
+      {run.status === "failed" && <p className="text-red-600">{run.error}</p>}
+    </section>
+  );
+}
+
+/**
+ * One line describing where a run has got to.
+ *
+ * A `Record` keyed by the status union rather than a switch, so a status added
+ * to the SDK is a compile error here instead of falling through a `default:`.
+ */
+const STATUS_LINE: Record<WorkflowRun["status"], string> = {
+  pending: "Queued",
+  running: "Writing…",
+  completed: "Done",
+  failed: "Failed",
+  cancelled: "Cancelled",
+};
+
+page({ name: "Redline", component: RedlineDesk });

package/dist/templates/redline/workflows/prompts.ts

@@ -0,0 +1,68 @@
+/**
+ * The writer, the critic and the reviser — and where they come from.
+ *
+ * **Adapted from LangGraph's reflection tutorial** (MIT,
+ * <https://github.com/langchain-ai/langgraph>,
+ * `docs/docs/tutorials/reflection/reflection.ipynb` — the essay assistant), with
+ * the structured critique from its Reflexion sibling.
+ *
+ * | reflection | here |
+ * | --- | --- |
+ * | `generation_node` (essay assistant) | {@link WRITER_SYSTEM} |
+ * | `reflection_node` (teacher grading a submission) | {@link CRITIC_SYSTEM} |
+ * | the generation node re-run with the critique | {@link REVISER_SYSTEM} |
+ * | `should_continue` (stop after N messages) | the `rounds` input, PLUS a critic that may stop early |
+ *
+ * **The critic decides when to stop, and that is the one real addition.** Their
+ * loop ends on a message count: three rounds is three rounds, whether the second
+ * draft was already good or the fourth would have been the one that landed. A
+ * fixed count spends the same money on a piece that was fine and gives up on one
+ * that was not. So {@link CRITIC_SYSTEM} asks for a VERDICT alongside the
+ * notes — and because that verdict comes back as a step's journaled result, the
+ * loop it controls is replay-stable (see `redline.ts`).
+ *
+ * The rest is theirs, and the part worth keeping verbatim in spirit is the
+ * critic's stance: it is grading a submission, not co-writing it. A critic
+ * prompted to "improve this" rewrites the piece in its own voice and the loop
+ * stops converging on the brief.
+ *
+ * A prompt is DATA, so this module carries no directive and the builder leaves
+ * it alone.
+ */
+
+/** Their `generation_node`, retargeted from five-paragraph essays to a brief. */
+export const WRITER_SYSTEM = [
+  "You are a writing assistant. Write the best piece you can for the brief you",
+  "are given, for the audience named in it.",
+  "Cover every point the brief says must be covered — those are requirements,",
+  "not suggestions.",
+  "Write prose, not an outline: no headings unless the brief asks for them, no",
+  "bullet lists standing in for paragraphs.",
+  "Return the piece alone, with no preamble and no note about what you did.",
+].join(" ");
+
+/** Their `reflection_node`: a teacher grading a submission, not a co-author. */
+export const CRITIC_SYSTEM = [
+  "You are grading a submission against its brief. Generate critique and",
+  "recommendations: be specific about length, depth, structure, evidence and",
+  "style, and say what is MISSING as well as what is weak.",
+  "Do not rewrite the piece — recommend, so the writer revises in their own",
+  "voice.",
+  "Then give a verdict. 'ship' means a reader would be well served by this as",
+  "it stands; 'revise' means at least one of your notes is worth another pass.",
+  "Be willing to say 'ship': a piece that is already good does not improve by",
+  "being sent round again, and every extra round costs the person waiting.",
+  'Reply as JSON only: {"verdict": "ship" | "revise", "score": number 1-10,',
+  '"notes": string[]}. Three notes at most, ordered by how much they matter.',
+  "No markdown fence, no preamble.",
+].join(" ");
+
+/** Their generation node re-entered with the critique in the conversation. */
+export const REVISER_SYSTEM = [
+  "You are revising your own piece against a critique of it.",
+  "Address every note. Where you disagree with one, address the underlying",
+  "concern rather than ignoring it.",
+  "Keep what already worked — a revision that rewrites the whole piece has",
+  "thrown away the part the critic did not object to.",
+  "Return the revised piece alone, with no preamble and no changelog.",
+].join(" ");