@alexkroman1/aai-cli 5.14.0 → 6.1.0

package/dist/templates/plan-and-execute/graph.ts

@@ -0,0 +1,178 @@
+/**
+ * The three nodes: plan, execute one step, replan.
+ *
+ * ```text
+ * plan → execute(step 1) → replan ──plan──→ execute(next step) → replan
+ *                             └──respond──→ done
+ * ```
+ *
+ * **The loop is driven by the CALLER, not by the graph.** Their notebook runs
+ * `plan → execute → replan → execute …` to completion and prints the answer; a
+ * phone call cannot go quiet for a minute and a half. So one `work_next_step`
+ * tool call is exactly one execute-then-replan turn, the desk says what it
+ * found, and the caller decides whether to carry on — which is also what makes
+ * `revise_plan` possible, since there is a gap between steps for a human to
+ * speak into. The nodes below are the same nodes; the driver is the
+ * conversation.
+ *
+ * **Search is injected** (see `shared.ts`): the executor's search is really the
+ * web, so the spec passes its own.
+ */
+
+import type { GenerateFn } from "@alexkroman1/aai";
+import { type DeepReadonly, errorMessage } from "@alexkroman1/aai";
+import {
+  actSchema,
+  EXECUTOR_SYSTEM,
+  PLANNER_SYSTEM,
+  planSchema,
+  REPLANNER_SYSTEM,
+  stepActionSchema,
+} from "./prompts.ts";
+import type { FrozenPlanState, PastStep, SearchFn } from "./shared.ts";
+
+/** Model turns one step may take, including its final answer. */
+export const MAX_STEP_TURNS = 3;
+/** Searches one step may run. The budget is the mechanism: a step told to
+ *  "search until sure" is a step whose cost nobody can quote. */
+export const MAX_STEP_SEARCHES = 2;
+
+/** Their `plan_step`. */
+export async function planNode(generate: GenerateFn, objective: string): Promise<string[]> {
+  const { object } = await generate({
+    system: PLANNER_SYSTEM,
+    prompt: `Objective: ${objective}`,
+    schema: planSchema,
+  });
+  return object.steps;
+}
+
+export interface StepOutcome {
+  result: string;
+  searches: string[];
+}
+
+function describeHits(hits: { title: string; url: string }[]): string {
+  if (hits.length === 0) return "No results.";
+  return hits.map((hit) => `- ${hit.title} (${hit.url})`).join("\n");
+}
+
+/** Completed steps as the executor and the replanner both read them. */
+function historyOf(pastSteps: readonly DeepReadonly<PastStep>[]): string {
+  if (pastSteps.length === 0) return "Nothing done yet.";
+  return pastSteps
+    .map((past, index) => `${index + 1}. ${past.step}\n   → ${past.result}`)
+    .join("\n");
+}
+
+/**
+ * Their `execute_step` — a ReAct agent with a search tool, distilled to a
+ * bounded search/answer loop.
+ */
+export async function executeStep(
+  generate: GenerateFn,
+  search: SearchFn,
+  objective: string,
+  step: string,
+  pastSteps: readonly DeepReadonly<PastStep>[],
+): Promise<StepOutcome> {
+  const searches: string[] = [];
+  const notes: string[] = [];
+
+  for (let turn = 0; turn < MAX_STEP_TURNS; turn++) {
+    const exhausted = searches.length >= MAX_STEP_SEARCHES;
+    const { object } = await generate({
+      system: EXECUTOR_SYSTEM,
+      prompt: [
+        `Objective: ${objective}`,
+        `Steps already done:\n${historyOf(pastSteps)}`,
+        `The step you are doing now: ${step}`,
+        notes.length > 0 ? `What your searches returned:\n${notes.join("\n\n")}` : "",
+        exhausted ? "You have used your search budget — answer with what you have." : "",
+      ]
+        .filter(Boolean)
+        .join("\n\n"),
+      schema: stepActionSchema,
+    });
+
+    if (object.action === "search" && object.query && !exhausted) {
+      searches.push(object.query);
+      try {
+        const hits = await search(object.query);
+        notes.push(`Search "${object.query}":\n${describeHits(hits)}`);
+      } catch (err: unknown) {
+        // A failed search goes back to the model, not only to a log: told
+        // nothing, it reads silence as "no such pages exist" and burns the rest
+        // of the budget re-asking the same question.
+        notes.push(`Search "${object.query}" failed: ${errorMessage(err)}`);
+      }
+      continue;
+    }
+
+    if (object.answer) return { result: object.answer, searches };
+    // An `answer` action with no answer is a malformed turn, not a verdict —
+    // let the loop try again rather than recording an empty step result.
+    notes.push("Your last reply carried no answer. Answer the step.");
+  }
+
+  return {
+    result: "This step could not be settled within its budget.",
+    searches,
+  };
+}
+
+/** Their `Act`, once it has been checked for the halves a provider can drop. */
+export type ActDecision = { kind: "respond"; response: string } | { kind: "plan"; steps: string[] };
+
+/**
+ * Read an `Act` the way a caller needs it read.
+ *
+ * A structured-output model can return `kind: "respond"` with no `response`, or
+ * `kind: "plan"` with an empty list. Neither is a reason to loop: the fallback
+ * is always an ANSWER, because the failure mode that matters on a phone call is
+ * a desk that never stops working.
+ */
+export function normalizeAct(
+  // `| undefined` on both optionals is what `exactOptionalPropertyTypes`
+  // requires of a parameter that receives a validated schema output: the
+  // schema's own type says "absent", and a caller destructuring one may well
+  // pass an explicit `undefined`.
+  object: { kind: "respond" | "plan"; response?: string | undefined; steps?: string[] | undefined },
+  fallback: string,
+): ActDecision {
+  const steps = object.steps?.filter((step) => step.trim().length > 0) ?? [];
+  if (object.kind === "plan" && steps.length > 0) return { kind: "plan", steps };
+  if (object.response && object.response.trim().length > 0) {
+    return { kind: "respond", response: object.response.trim() };
+  }
+  if (steps.length > 0) return { kind: "plan", steps };
+  return { kind: "respond", response: fallback };
+}
+
+/** Their `replan_step`. `instruction` is the caller interrupting; theirs has no
+ *  equivalent, because a notebook has nobody to interrupt it. */
+export async function replanNode(
+  generate: GenerateFn,
+  state: Pick<FrozenPlanState, "objective" | "plan" | "pastSteps">,
+  options: { system?: string; instruction?: string } = {},
+): Promise<ActDecision> {
+  const { object } = await generate({
+    system: options.system ?? REPLANNER_SYSTEM,
+    prompt: [
+      `Objective: ${state.objective ?? "(none stated)"}`,
+      `Steps done:\n${historyOf(state.pastSteps)}`,
+      `Steps still planned:\n${state.plan.length > 0 ? state.plan.map((step) => `- ${step}`).join("\n") : "(none)"}`,
+      options.instruction ? `The caller has just said: ${options.instruction}` : "",
+    ]
+      .filter(Boolean)
+      .join("\n\n"),
+    schema: actSchema,
+  });
+
+  return normalizeAct(
+    object,
+    // The last step's result is the honest fallback answer: it is the most
+    // recent true thing the desk knows.
+    state.pastSteps.at(-1)?.result ?? "There is nothing left to do on that.",
+  );
+}

package/dist/templates/plan-and-execute/prompts.ts

@@ -0,0 +1,110 @@
+/**
+ * The planner, the executor and the replanner — and where they come from.
+ *
+ * **Adapted from LangGraph's plan-and-execute tutorial** (MIT,
+ * <https://github.com/langchain-ai/langgraph>,
+ * `docs/docs/tutorials/plan-and-execute/plan-and-execute.ipynb`), itself after
+ * the Plan-and-Solve paper and BabyAGI.
+ *
+ * | plan-and-execute | here |
+ * | --- | --- |
+ * | `Plan` (pydantic, `steps: List[str]`) | {@link planSchema} |
+ * | `planner` prompt | {@link PLANNER_SYSTEM} |
+ * | the ReAct `agent_executor` with a search tool | {@link EXECUTOR_SYSTEM} + {@link stepActionSchema} |
+ * | `Act = Union[Response, Plan]` | {@link actSchema} |
+ * | `replanner` prompt | {@link REPLANNER_SYSTEM} |
+ *
+ * **Their `Act` is a union and this is a discriminated object, which is a real
+ * difference worth knowing.** `Union[Response, Plan]` becomes a JSON Schema
+ * `anyOf`, and structured-output support for `anyOf` varies by provider — a
+ * model that quietly emits `{"steps": [...]}` when it meant to respond leaves a
+ * plan looping. One object with a `kind` discriminant is the same decision in a
+ * shape every provider constrains reliably, and the validator can then say
+ * which half is missing.
+ *
+ * **The prompts are adapted for a caller who is listening.** Theirs plan for a
+ * reader with a notebook open; a plan read down a phone has to be four or five
+ * steps a person can hold in their head, and the replanner has to be told that
+ * finishing early is a good outcome rather than a failure to plan thoroughly.
+ * What is kept close to verbatim is the part that carries the mechanism: "do
+ * not add superfluous steps", "each step has all the information needed", and
+ * the replanner's "only add steps that still NEED to be done".
+ */
+
+import { z } from "zod";
+
+/** Their `Plan`. Bounded, because a caller is listening to it read out. */
+export const planSchema = z.object({
+  steps: z
+    .array(z.string().max(200))
+    .min(1)
+    .max(5)
+    .describe("The steps, in order, each one a task that can be done on its own"),
+});
+
+/** Their `Act` — `Response | Plan` as one discriminated object. */
+export const actSchema = z.object({
+  kind: z.enum(["respond", "plan"]).describe("'respond' when the objective is met, else 'plan'"),
+  response: z
+    .string()
+    .max(600)
+    .describe("The answer for the caller, when kind is 'respond'")
+    .optional(),
+  steps: z
+    .array(z.string().max(200))
+    .max(5)
+    .describe("The steps STILL to do, when kind is 'plan'")
+    .optional(),
+});
+
+/** One turn of the executor's ReAct loop: search, or answer the step. */
+export const stepActionSchema = z.object({
+  action: z.enum(["search", "answer"]),
+  query: z.string().max(120).describe("The web search to run, when action is 'search'").optional(),
+  answer: z
+    .string()
+    .max(600)
+    .describe("What the step established, when action is 'answer'")
+    .optional(),
+});
+
+export const PLANNER_SYSTEM = [
+  "For the given objective, come up with a simple step by step plan.",
+  "The plan is individual tasks which, done in order, yield the objective.",
+  "Do not add superfluous steps. Make sure each step carries all the",
+  "information it needs — a step is done without seeing the others.",
+  "The result of the final step is the final answer.",
+  "This plan is READ ALOUD to the person who asked for it, so use four steps",
+  "or fewer where you can, and write each one as a short spoken sentence.",
+].join(" ");
+
+export const EXECUTOR_SYSTEM = [
+  "You are doing one step of a plan. You may search the web, or answer.",
+  "Search when the step turns on a fact you do not reliably know — a price, a",
+  "date, an availability, anything current. Search once, read what comes back,",
+  "and search again only if it genuinely did not answer the step.",
+  "Answer as soon as you can support the step; say what you found and where it",
+  "came from. If searching did not settle it, say that plainly in the answer",
+  "rather than inventing a result — a later step may be able to work around it,",
+  "but only if it is told the truth.",
+].join(" ");
+
+export const REPLANNER_SYSTEM = [
+  "You are updating a plan after a step was done.",
+  "Only include steps that still NEED to be done — never repeat a step already",
+  "completed. If everything the objective needs is now known, reply with",
+  "kind 'respond' and the answer for the caller.",
+  "Finishing early is a good outcome: if the completed steps already answer the",
+  "objective, respond rather than inventing more work.",
+  "The caller is on the phone, so an answer is two or three spoken sentences.",
+].join(" ");
+
+/** The caller changed their mind mid-plan — no counterpart in the notebook. */
+export const REVISE_SYSTEM = [
+  "You are updating a plan because the person it belongs to just changed what",
+  "they want, mid-call. Their instruction wins over the original objective.",
+  "Keep completed steps out of the new plan, keep any pending step their",
+  "instruction does not affect, and reply with kind 'plan'.",
+  "Reply with kind 'respond' only if their instruction means there is nothing",
+  "left to do.",
+].join(" ");

package/dist/templates/plan-and-execute/shared.ts

@@ -0,0 +1,161 @@
+/**
+ * The plan's state, the web-search seam, and what the browser is shown.
+ *
+ * **The state is theirs, field for field.** `PlanExecute` in the notebook is
+ * `{input, plan, past_steps, response}`, and {@link PlanState} is the same four
+ * plus the one thing a phone call needs on top: the trail of how the plan got
+ * to where it is, which the sidebar renders and a caller cannot hold by ear.
+ *
+ * **A plan does not survive the call, and that is a decision.** It lives in one
+ * `sessionSlot` keyed per session, so two callers planning at once never see
+ * each other's steps and an abandoned plan vanishes with the session.
+ * Cross-session persistence would mean `ctx.db` and a caller identity, which is
+ * a different template (`solo-rpg` has the save-slot version).
+ */
+
+import { type DeepReadonly, pushCapped, sessionSlot } from "@alexkroman1/aai";
+import { webSearch } from "@alexkroman1/aai/tools";
+import { isToolFailure } from "@alexkroman1/aai/utils";
+
+/** One completed step — their `past_steps`, as a pair rather than a tuple. */
+export interface PastStep {
+  step: string;
+  result: string;
+  /** Searches this step ran, so the sidebar can show what the wait bought. */
+  searches: string[];
+}
+
+export interface PlanState {
+  /** Their `input`: what the caller asked for. */
+  objective: string | null;
+  /** Their `plan`: the steps STILL to do, head first. */
+  plan: string[];
+  /** Their `past_steps`. */
+  pastSteps: PastStep[];
+  /** Their `response`: set once the replanner decides the objective is met. */
+  response: string | null;
+  /** Every plan the desk has held on this call, for the sidebar. */
+  revisions: string[];
+}
+
+/** Growth cap on the revision trail — it rides in every `syncState` frame. */
+export const MAX_REVISIONS = 20;
+
+/**
+ * Growth cap on the completed-step trail, for the same reason one step up.
+ *
+ * `pastSteps` is not only a render: `historyOf` writes the whole list into the
+ * EXECUTOR's prompt and the REPLANNER's, so an uncapped list is a model bill
+ * that grows linearly with the plan's length — ~12 KB per call at twenty steps
+ * — on top of riding in every `syncState` frame. The cap drops the OLDEST,
+ * which is the right end: the replanner decides from what has just been found,
+ * and its fallback answer is `pastSteps.at(-1)`. Past the cap `progress` is
+ * over the steps still remembered, which is the price of a bound and is
+ * recorded on {@link planView}.
+ */
+export const MAX_PAST_STEPS = 20;
+
+export function emptyPlan(): PlanState {
+  return { objective: null, plan: [], pastSteps: [], response: null, revisions: [] };
+}
+
+export const planSlot = sessionSlot("plan", emptyPlan);
+
+export function noteRevision(state: PlanState, entry: string): void {
+  pushCapped(state.revisions, entry, MAX_REVISIONS);
+}
+
+/** Record a completed step, holding {@link MAX_PAST_STEPS}. */
+export function recordStep(state: PlanState, step: PastStep): void {
+  pushCapped(state.pastSteps, step, MAX_PAST_STEPS);
+}
+
+/**
+ * The plan as a READ hands it out: deep-frozen, and typed to say so.
+ *
+ * The projection and both graph nodes take this rather than {@link PlanState},
+ * which is the widening a deep-readonly slot forces and the reason it is worth
+ * doing: a mutable plan still satisfies it, so a call with an `update` draft is
+ * unaffected, while a helper that WOULD have mutated stops compiling instead of
+ * throwing at its first call.
+ */
+export type FrozenPlanState = DeepReadonly<PlanState>;
+
+// ─── The search seam ─────────────────────────────────────────────────────────
+
+export interface SearchHit {
+  title: string;
+  url: string;
+}
+
+/**
+ * The executor's search, as an injected function.
+ *
+ * The seam exists because the search is REAL — `webSearch` from
+ * `@alexkroman1/aai/tools` is the same DuckDuckGo-backed implementation behind
+ * the model-facing `web_search` builtin, with the same screening and size caps,
+ * and it needs no API key. A template's spec must not depend on the live web
+ * (or on a stranger's rate limit), so the executor takes its searcher as an
+ * argument and the tool passes {@link liveSearch}.
+ */
+export type SearchFn = (query: string) => Promise<SearchHit[]>;
+
+/** How many results one search reads. Enough to compare, short enough to hear. */
+export const SEARCH_RESULTS = 4;
+
+export const liveSearch: SearchFn = async (query) => {
+  const results = await webSearch<{ results?: { title?: string; url?: string }[] }>({
+    query,
+    max_results: SEARCH_RESULTS,
+  });
+  // A REFUSED search is not an empty web, and `webSearch` answers with
+  // `{ error }` rather than throwing — so an unnarrowed `?? []` below would tell
+  // the executor there is nothing out there. Measured: DuckDuckGo answers `403`
+  // often enough that this is the ordinary case, not an edge one.
+  if (isToolFailure(results)) throw new Error(`Search failed: ${results.error}`);
+  return (results.results ?? [])
+    .filter(
+      (one): one is { title?: string; url: string } =>
+        typeof one.url === "string" && one.url.length > 0,
+    )
+    .map((one) => ({ title: one.title || one.url, url: one.url }));
+};
+
+// ─── The projection ──────────────────────────────────────────────────────────
+
+export interface PlanView {
+  objective: string | null;
+  /** Steps still to do. */
+  plan: readonly string[];
+  /** Completed steps, newest last and capped at {@link MAX_PAST_STEPS}. */
+  done: readonly DeepReadonly<PastStep>[];
+  response: string | null;
+  revisions: readonly string[];
+  /**
+   * Done ÷ (done + remaining), 0–1, so the sidebar needs no arithmetic.
+   *
+   * `done` is the steps still REMEMBERED — see {@link MAX_PAST_STEPS} — so a
+   * plan longer than the cap reports progress over its recent history rather
+   * than over its whole life. A plan that long on a phone call is already the
+   * pathological case; an unbounded prompt is the one that costs money.
+   */
+  progress: number;
+}
+
+/**
+ * What the browser sees. Nearly the state — a plan has nothing private in it —
+ * with `progress` derived here so the bar and any spoken "two of four" can
+ * never disagree about what fraction means.
+ */
+export function planView(state: FrozenPlanState): PlanView {
+  const done = state.pastSteps.length;
+  const total = done + state.plan.length;
+  return {
+    objective: state.objective,
+    plan: state.plan,
+    done: state.pastSteps,
+    response: state.response,
+    revisions: state.revisions,
+    progress: total === 0 ? 0 : done / total,
+  };
+}

package/dist/templates/plan-and-execute/system-prompt.md

@@ -0,0 +1,18 @@
+You are the planning desk. Someone calls with something they want to get done, and you turn it into a short plan, work it one step at a time, and tell them what you found. You are on a phone call: one or two spoken sentences per turn, no lists read out at length, no markdown.
+
+How a call goes:
+
+- Find out what they actually want first. One clarifying question is usually enough — you are planning, not interviewing.
+- Call `start_plan` with the objective, then read the steps back in one breath: "I'd do three things — check X, compare Y, then book Z. Want me to start?"
+- Call `work_next_step` once per step, never in a loop. It does the step, searches the web where it needs to, and updates the plan from what it found.
+- After each step, say what it found in a sentence and ask whether to carry on. That pause is the point: it is where the caller gets to change their mind.
+- When a step comes back `done`, give them the answer.
+- If they change what they want, call `revise_plan` with their instruction. Do not re-plan by hand and do not redo finished steps.
+- `plan_status` is for when they ask where things are, or to pick the thread back up.
+
+Two things not to do:
+
+- Do not answer a factual question about the world from your own knowledge when it is part of the plan — that is what a step is for, and a step searches.
+- Do not read out the whole plan again after every step. Say the step you just did and what is next.
+
+If a step comes back saying it could not be settled, say so plainly and ask whether to work around it or drop it.

package/dist/templates/plan-and-execute/tools/plan_status.ts

@@ -0,0 +1,20 @@
+import { planSlot } from "../shared.ts";
+
+/**
+ * Where the plan is. Read-only, so plain `tool` semantics — a synchronous
+ * read cannot interleave with anything.
+ */
+export default planSlot.tool({
+  description:
+    "Say where the plan has got to: what is done, what is left, and the answer " +
+    "if there is one. Use it when the caller asks, or to pick a call back up.",
+  execute(_args, plan) {
+    if (!plan.objective) return { message: "No plan yet. Ask what they want to get done." };
+    return {
+      objective: plan.objective,
+      done: plan.pastSteps.map((past) => ({ step: past.step, result: past.result })),
+      remaining: plan.plan,
+      response: plan.response,
+    };
+  },
+});

package/dist/templates/plan-and-execute/tools/revise_plan.ts

@@ -0,0 +1,63 @@
+import { errorMessage, tool, toolFailure } from "@alexkroman1/aai";
+import { z } from "zod";
+import { replanNode } from "../graph.ts";
+import { REVISE_SYSTEM } from "../prompts.ts";
+import { noteRevision, planSlot } from "../shared.ts";
+
+/**
+ * The replanner, driven by the caller instead of by a step result.
+ *
+ * There is no counterpart in the notebook, and the gap is the interesting part:
+ * their replanner only ever reacts to what a step returned, because a notebook
+ * has nobody to interrupt it. Half of what a person does on a planning call is
+ * change their mind, and the node that already exists to rewrite a plan from
+ * new information is the right one to hand that to.
+ *
+ * The await-then-mutate shape is `start_plan`'s, for the reason it gives — and
+ * note the READ before the await is `planSlot.get`, which the replanner only
+ * needs to look at.
+ */
+export default tool({
+  description:
+    "Rewrite the remaining plan because the caller changed what they want. " +
+    "Pass their instruction as they said it. Completed steps are never redone.",
+  inputSchema: z.object({
+    instruction: z
+      .string()
+      .max(400)
+      .describe("What the caller now wants changed, in their own words"),
+  }),
+  async execute(args, ctx) {
+    if (!planSlot.get(ctx).objective) {
+      return toolFailure("There is no plan to revise — use start_plan first.");
+    }
+
+    try {
+      const act = await replanNode(ctx.generate, planSlot.get(ctx), {
+        system: REVISE_SYSTEM,
+        instruction: args.instruction,
+      });
+      return planSlot.update(ctx, (plan) => {
+        noteRevision(plan, `Caller: ${args.instruction}`);
+
+        if (act.kind === "respond") {
+          plan.plan = [];
+          plan.response = act.response;
+          return { done: true, response: act.response, message: "Nothing is left to do." };
+        }
+
+        plan.plan = act.steps;
+        // A revision reopens a plan that had already answered: the caller has
+        // moved the goalposts, so the old answer is no longer the answer.
+        plan.response = null;
+        return {
+          done: false,
+          remaining: act.steps,
+          message: "Read the revised steps back and ask if that is right.",
+        };
+      });
+    } catch (err: unknown) {
+      return toolFailure(`The plan could not be revised: ${errorMessage(err)}`);
+    }
+  },
+});

package/dist/templates/plan-and-execute/tools/start_plan.ts

@@ -0,0 +1,51 @@
+import { errorMessage, tool, toolFailure } from "@alexkroman1/aai";
+import { z } from "zod";
+import { planNode } from "../graph.ts";
+import { noteRevision, planSlot } from "../shared.ts";
+
+/**
+ * Their `plan_step`, as the call's opening move.
+ *
+ * **The await comes FIRST, then the mutation.** `slot.update` is synchronous —
+ * its window cannot span an await, which is what makes a read-modify-write
+ * atomic without a lock — so a body that has to call a model does that outside
+ * it and mutates once the answer is in hand. The hazard the old serialized
+ * version guarded against is unchanged (the LLM loop runs a step's tool calls
+ * concurrently, so two plans started at once must not interleave); what changed
+ * is that the window is now too short to interleave IN.
+ */
+export default tool({
+  description:
+    "Draft a plan for what the caller wants to get done. Use this once you " +
+    "understand the objective. Read the steps back to them afterwards.",
+  inputSchema: z.object({
+    objective: z
+      .string()
+      .max(400)
+      .describe("What the caller wants, stated as one goal in their own terms"),
+  }),
+  async execute(args, ctx) {
+    let steps: string[];
+    try {
+      steps = await planNode(ctx.generate, args.objective);
+    } catch (err: unknown) {
+      return toolFailure(`The planner failed: ${errorMessage(err)}`);
+    }
+
+    return planSlot.update(ctx, (plan) => {
+      plan.objective = args.objective;
+      plan.plan = steps;
+      plan.pastSteps = [];
+      plan.response = null;
+      noteRevision(plan, `Planned ${steps.length} step(s) for: ${args.objective}`);
+
+      return {
+        objective: args.objective,
+        steps,
+        message:
+          "Read the plan back in one breath, then ask if they want you to start. " +
+          "Work it one step at a time with work_next_step.",
+      };
+    });
+  },
+});