@alexkroman1/aai-cli 6.11.0 → 8.0.0

package/dist/workflow-bundler.d.ts

@@ -29,7 +29,7 @@
  *   guest's BAKED image instead of being inlined. Step bundle: 12 MB → ~7 KB.
  * - **`bundleFinalOutput: false`** — skips wrapping the workflow-mode code in a
  *   runtime host, which is exactly what `workflowEntrypoint(code)` supplies
- *   itself at the other end. Flow bundle: 3.7 MB → ~69 KB.
+ *   itself at the other end. Dialog bundle: 3.7 MB → ~69 KB.
  *
  * So `workflowCode` is passed to `workflowEntrypoint()` in the guest and
  * `stepCode` is evaluated there to register its step functions.
@@ -108,6 +108,11 @@ export type WorkflowBundleOutput = {
      * section for why it is this list and not a content sniff.
      */
     inputFiles: readonly string[];
+    /**
+     * Replay-safety findings, as lines to print. See {@link replayWarnings} for
+     * why they are warnings rather than a failed build.
+     */
+    warnings: readonly string[];
 };
 /**
  * Attach the compiler's `workflowId`/`stepId` to the agent bundle's copy of

package/dist/workflow.d.ts

@@ -25,7 +25,7 @@
  * slug, and PRINTING — which is most of why the verbs exist separately from the
  * client's methods.
  */
-import type { WorkflowRunSnapshot, WorkflowSummary } from "@alexkroman1/aai";
+import type { WorkflowRunSnapshot, WorkflowSummary } from "@alexkroman1/aai/workflow-api";
 import { type CommandResult } from "./_output.ts";
 /**
  * One run, as the API reports it.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alexkroman1/aai-cli",
-  "version": "6.11.0",
+  "version": "8.0.0",
   "type": "module",
   "bin": {
     "aai": "bin.mjs"
@@ -44,8 +44,9 @@
     "p-timeout": "^7.0.1",
     "vite": "^8.2.1",
     "zod": "^4.4.3",
-    "@alexkroman1/aai": "6.11.0",
-    "@alexkroman1/aai-ui": "6.11.0"
+    "@alexkroman1/aai-runtime": "8.0.0",
+    "@alexkroman1/aai": "8.0.0",
+    "@alexkroman1/aai-ui": "8.0.0"
   },
   "devDependencies": {
     "playwright": "^1.62.1",
@@ -53,7 +54,7 @@
     "verdaccio": "^6.9.2",
     "vitest": "^4.1.10",
     "workflow": "4.8.2",
-    "aai-templates": "0.3.6"
+    "aai-templates": "0.3.8"
   },
   "peerDependencies": {
     "vitest": "^4.1.10"

package/dist/eject-31gjtaHF.mjs

@@ -1,116 +0,0 @@
-#!/usr/bin/env node
-import { a as ok, t as CliError } from "./_output-CKkmWs7i.mjs";
-import { n as log } from "./_ui-u7T4YooX.mjs";
-import { l as readJson, o as errorMessage, p as writeJson, s as fileExists } from "./_utils-B8QmtFhK.mjs";
-import { scaffoldDir } from "./_templates-Dxb_P2Wz.mjs";
-import path from "node:path";
-import fs from "node:fs/promises";
-//#region eject.ts
-/**
-* `aai eject` — retrofit the self-hosted entrypoint into an existing project.
-*
-* Every project scaffolded from this CLI version onwards already has
-* `server.mjs` and the `prestart`/`start` pair: the scaffold ships them, so
-* self-hosting is the default rather than something to opt into. This command
-* exists for the projects that predate that — `aai init` before it, or a
-* workspace pulled from a studio that was created earlier — where the files
-* are simply missing.
-*
-* It COPIES from the scaffold rather than writing its own contents. Two
-* definitions of "the self-hosted entrypoint" would drift, and the one nobody
-* runs locally is the one that would rot; this way an ejected project is
-* byte-identical to a freshly scaffolded one.
-*
-* The SCRIPTS are the exception it cannot copy, since a project's package.json
-* is its own — so `PRESTART_SCRIPT`/`START_SCRIPT` are written here and pinned
-* against the scaffold's manifest by `eject.test.ts`. Both matter: the
-* entrypoint boots the BUILT worker, so an ejected project with no `prestart`
-* exits at once naming the missing artifact.
-*/
-/** The file `npm start` runs. Named once — the scaffold ships it under this name. */
-const SERVER_ENTRY = "server.mjs";
-/** The `scripts.start` value that runs {@link SERVER_ENTRY}. */
-const START_SCRIPT = `node ${SERVER_ENTRY}`;
-/**
-* The `scripts.prestart` value, which npm runs before `start`.
-*
-* {@link SERVER_ENTRY} boots the BUILT worker (`.aai/worker.mjs`), because a
-* tool is discovered by the bundler enumerating `tools/` and an un-bundled
-* loader would serve an agent with no tools at all — so an entrypoint with no
-* build in front of it is not a working project. `--skip-tests` because this
-* runs on the way to serving traffic: `npm test` is where a suite belongs, and
-* a failing test must not be what stops a container from starting. The
-* typecheck stays, since the bundlers strip types unchecked and self-hosting
-* has no other gate.
-*
-* Kept in step with the scaffold's own `package.json`, which the two together
-* are the only definition of — `eject.test.ts` asserts they agree.
-*/
-const PRESTART_SCRIPT = "aai build --skip-tests";
-/**
-* Add `scripts.start` — and the `prestart` that builds what it boots — unless
-* the project already declares a `start` of its own.
-*
-* An existing `start` is left alone even under `--force`: `--force` is about
-* replacing the entrypoint file, and silently rewriting the command a project
-* boots with is a different, larger act. `prestart` is part of the same act
-* rather than a separate one, so it is written only alongside a `start` we
-* wrote — bolting a build onto someone else's start command changes what that
-* command does, which is precisely what the rule above refuses. The mismatch is
-* reported instead, naming both halves, so the choice stays the author's.
-*/
-async function ensureStartScript(cwd) {
-	const manifestPath = path.join(cwd, "package.json");
-	const manifest = await readJson(manifestPath);
-	if (!manifest) {
-		log.warn(`No package.json here — add "prestart": "${PRESTART_SCRIPT}" and "start": "${START_SCRIPT}" yourself to get \`npm start\`.`);
-		return false;
-	}
-	const existing = manifest.scripts?.start;
-	if (existing === START_SCRIPT && manifest.scripts?.prestart === "aai build --skip-tests") return false;
-	if (existing !== void 0 && existing !== START_SCRIPT) {
-		log.warn(`Kept your existing "start" script (${existing}) — run \`${PRESTART_SCRIPT}\` then \`${START_SCRIPT}\`.`);
-		return false;
-	}
-	manifest.scripts = {
-		...manifest.scripts,
-		prestart: PRESTART_SCRIPT,
-		start: START_SCRIPT
-	};
-	await writeJson(manifestPath, manifest);
-	return true;
-}
-/**
-* A missing scaffold source means a broken install (or an `AAI_TEMPLATES_DIR`
-* pointed somewhere wrong), not anything the user did — so the message names
-* the file and where it was looked for.
-*
-* Built here and thrown by the caller, the shape `build.ts` uses for the same
-* reason: `useErrorCause` reads a `throw new Error` inside a `catch` as
-* dropping the cause, and cannot see that `CliError` takes its options fourth.
-*/
-function scaffoldMissingError(source, err) {
-	return new CliError("scaffold_missing", `Could not read the scaffold's ${SERVER_ENTRY} at ${source}: ${errorMessage(err)}`, "Reinstall @alexkroman1/aai-cli.", { cause: err });
-}
-async function executeEject(opts) {
-	const { cwd, force } = opts;
-	const target = path.join(cwd, SERVER_ENTRY);
-	const overwritten = await fileExists(target);
-	if (overwritten && !force) throw new CliError("server_exists", `${SERVER_ENTRY} already exists — this project can already be self-hosted.`, `Run \`npm start\`, or re-run with --force to replace it with the current scaffold's copy.`);
-	const source = path.join(scaffoldDir(), SERVER_ENTRY);
-	try {
-		await fs.copyFile(source, target);
-	} catch (err) {
-		throw scaffoldMissingError(source, err);
-	}
-	const addedScripts = await ensureStartScript(cwd);
-	log.success(`Wrote ${SERVER_ENTRY}${overwritten ? " (replaced)" : ""}`);
-	log.info(`Next: npm start — it builds first (\`${PRESTART_SCRIPT}\`), then serves on 127.0.0.1:3000 (PORT and HOST override that)`);
-	return ok({
-		file: target,
-		overwritten,
-		addedScripts
-	});
-}
-//#endregion
-export { executeEject };

package/dist/eject.d.ts

@@ -1,60 +0,0 @@
-/**
- * `aai eject` — retrofit the self-hosted entrypoint into an existing project.
- *
- * Every project scaffolded from this CLI version onwards already has
- * `server.mjs` and the `prestart`/`start` pair: the scaffold ships them, so
- * self-hosting is the default rather than something to opt into. This command
- * exists for the projects that predate that — `aai init` before it, or a
- * workspace pulled from a studio that was created earlier — where the files
- * are simply missing.
- *
- * It COPIES from the scaffold rather than writing its own contents. Two
- * definitions of "the self-hosted entrypoint" would drift, and the one nobody
- * runs locally is the one that would rot; this way an ejected project is
- * byte-identical to a freshly scaffolded one.
- *
- * The SCRIPTS are the exception it cannot copy, since a project's package.json
- * is its own — so `PRESTART_SCRIPT`/`START_SCRIPT` are written here and pinned
- * against the scaffold's manifest by `eject.test.ts`. Both matter: the
- * entrypoint boots the BUILT worker, so an ejected project with no `prestart`
- * exits at once naming the missing artifact.
- */
-import { type CommandResult } from "./_output.ts";
-/** The file `npm start` runs. Named once — the scaffold ships it under this name. */
-export declare const SERVER_ENTRY = "server.mjs";
-/** The `scripts.start` value that runs {@link SERVER_ENTRY}. */
-export declare const START_SCRIPT = "node server.mjs";
-/**
- * The `scripts.prestart` value, which npm runs before `start`.
- *
- * {@link SERVER_ENTRY} boots the BUILT worker (`.aai/worker.mjs`), because a
- * tool is discovered by the bundler enumerating `tools/` and an un-bundled
- * loader would serve an agent with no tools at all — so an entrypoint with no
- * build in front of it is not a working project. `--skip-tests` because this
- * runs on the way to serving traffic: `npm test` is where a suite belongs, and
- * a failing test must not be what stops a container from starting. The
- * typecheck stays, since the bundlers strip types unchecked and self-hosting
- * has no other gate.
- *
- * Kept in step with the scaffold's own `package.json`, which the two together
- * are the only definition of — `eject.test.ts` asserts they agree.
- */
-export declare const PRESTART_SCRIPT = "aai build --skip-tests";
-type EjectData = {
-    /** Absolute path of the entrypoint written. */
-    file: string;
-    /** True when an existing `server.mjs` was replaced (`--force`). */
-    overwritten: boolean;
-    /**
-     * True when this run wrote `scripts.prestart`/`scripts.start` into
-     * package.json. Also true for a project ejected by an older CLI, whose
-     * `start` is already correct and whose `prestart` is missing — the entrypoint
-     * this run just wrote needs the build in front of it.
-     */
-    addedScripts: boolean;
-};
-export declare function executeEject(opts: {
-    cwd: string;
-    force?: boolean | undefined;
-}): Promise<CommandResult<EjectData>>;
-export {};

package/dist/templates/call-audit/workflows/temp-media.ts

@@ -1,138 +0,0 @@
-// Copyright 2026 the AAI authors. MIT license.
-/**
- * Moving bytes between the upload store and a local file, which is what an
- * ffmpeg step spends most of its lines on.
- *
- * No directive, so it sits under `workflows/` untransformed and is called FROM
- * steps, inheriting their environment. It exists because both ffmpeg steps in
- * this template need the same three things and the third one is the one that is
- * easy to get wrong.
- *
- * ## Why a temp file at all
- *
- * `@alexkroman1/aai/ffmpeg` takes bytes as happily as a path, and for a short
- * clip bytes are the better call. This desk uses paths, for two reasons that are
- * both properties of real recordings rather than preferences:
- *
- * - **A pipe cannot seek.** An `.m4a` off a phone usually carries its `moov`
- *   index at the END of the file, so ffmpeg reading it from `pipe:0` fails with
- *   `moov atom not found`. That is the flagship input.
- * - **Piped output is capped**, at `DEFAULT_MAX_FFMPEG_OUTPUT_BYTES` (64 MiB),
- *   which is about half an hour of this desk's 16 kHz mono PCM. The desk exists
- *   for the two-hour call.
- *
- * ## A temp file may not outlive its step
- *
- * A step is journaled by its RETURN VALUE and may be dispatched into a different
- * process than its neighbours, so a path in a return value is a path that is
- * replayed after the file behind it is gone — and the failure mode is a resumed
- * run reading a directory that another run is using. {@link withTempDir} makes
- * the lifetime a lexical scope: the directory is created on entry, removed on
- * exit, and what crosses the step boundary is an upload id.
- */
-
-import { mkdtemp, open, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { readUpload } from "@alexkroman1/aai/utils";
-
-/**
- * Bytes moved per `readUpload`, and per write.
- *
- * Large enough that a two-hour recording is a few hundred round trips rather
- * than tens of thousands, and small enough that a step's resident set is a
- * constant rather than a function of the recording. The number this must NOT be
- * is "the whole file", which is the shape every first draft has.
- */
-export const WINDOW_BYTES = 8 * 1024 * 1024;
-
-/**
- * Run `work` with a private temp directory, and remove it afterwards.
- *
- * `join(tmpdir(), …)` rather than a `/tmp` literal, which is this repo's rule
- * (`guard-invariants` rule 11) and not merely portability theatre: on Windows a
- * literal `/tmp/x` is DRIVE-RELATIVE, so it resolves somewhere that does not
- * exist and every write fails with ENOENT. A step runs in a Linux guest when it
- * is deployed and on the developer's own machine under `aai dev`, which is the
- * half that makes it matter.
- *
- * The removal is in a `finally`, so it also runs on the failure paths — a guest's
- * disk is small, and a step that leaves a copy of every recording it touched
- * fills it. `force` so a run that never created its output does not fail HERE and
- * replace the real error with this one.
- */
-export async function withTempDir<T>(work: (dir: string) => Promise<T>): Promise<T> {
-  const dir = await mkdtemp(join(tmpdir(), "aai-call-audit-"));
-  try {
-    return await work(dir);
-  } finally {
-    await rm(dir, { recursive: true, force: true });
-  }
-}
-
-/**
- * Write an upload to a local path, a window at a time.
- *
- * A `for` loop rather than a fan-out deliberately: the bytes land in one file at
- * one offset each, so concurrency buys nothing and costs exactly the memory the
- * windows are here to bound.
- *
- * `windowBytes` defaults to {@link WINDOW_BYTES}; see {@link fileChunks} for why
- * it is a parameter at all.
- */
-export async function materializeUpload(
-  uploadId: string,
-  size: number,
-  path: string,
-  windowBytes: number = WINDOW_BYTES,
-): Promise<void> {
-  const handle = await open(path, "w");
-  try {
-    for (let at = 0; at < size; at += windowBytes) {
-      const slice = await readUpload(uploadId, {
-        start: at,
-        end: Math.min(at + windowBytes, size),
-      });
-      await handle.write(slice.bytes);
-    }
-  } finally {
-    await handle.close();
-  }
-}
-
-/**
- * A local file as the stream `writeUpload` takes.
- *
- * A generator rather than `readFile`, for the same reason the windows above
- * exist: the normalized PCM is the largest thing this desk touches, and handing
- * the store an `AsyncIterable` is what keeps it off the heap.
- *
- * **The `.slice()` is load-bearing.** One buffer is reused across reads, so
- * yielding a view of it hands the consumer memory the next read overwrites — a
- * bug whose symptom is a stored file made of the LAST chunk repeated, and which
- * does not reproduce whenever the consumer happens to copy before the next
- * iteration.
- *
- * `windowBytes` is a parameter with a default for exactly that reason, and it is
- * the one testability seam in this template. The aliasing bug above only manifests
- * across MULTIPLE reads, so at the real 8 MiB window a spec would have to write a
- * 16 MB file to reach it — and a first draft of that spec used 200 KB, passed with
- * the `.slice()` deleted, and would have shipped a test proving nothing. A small
- * window makes the multi-chunk path a few kilobytes instead.
- */
-export async function* fileChunks(
-  path: string,
-  windowBytes: number = WINDOW_BYTES,
-): AsyncIterable<Uint8Array> {
-  const handle = await open(path, "r");
-  try {
-    const buffer = new Uint8Array(windowBytes);
-    for (;;) {
-      const { bytesRead } = await handle.read(buffer, 0, buffer.length, null);
-      if (bytesRead === 0) return;
-      yield buffer.subarray(0, bytesRead).slice();
-    }
-  } finally {
-    await handle.close();
-  }
-}

package/dist/templates/infocom-adventure/tools/game_state_history.ts

@@ -1,14 +0,0 @@
-import { z } from "zod";
-import { gameSlot, REPORTED_HISTORY, recordCommand } from "../shared.ts";
-
-export default gameSlot.updateTool({
-  description: "Log a player command to the history and increment the move counter.",
-  inputSchema: z.object({
-    value: z.string().describe("Command text to log"),
-  }),
-  execute(args, game) {
-    recordCommand(game, args.value);
-    game.moves++;
-    return { moves: game.moves, recentHistory: game.history.slice(-REPORTED_HISTORY) };
-  },
-});

package/dist/templates/support-line/graph.ts

@@ -1,224 +0,0 @@
-/**
- * The corrective-RAG loop, node by node.
- *
- * This is the port of the self-RAG / CRAG graph (see `prompts.ts` for the
- * attribution). Their control flow is edges between nodes; here it is a `while`
- * loop in one tool body, and the node names survive in {@link AnswerTrace.steps}
- * so a run is still readable as the graph it came from:
- *
- * ```text
- * retrieve → grade_documents → decide_to_generate
- *                                ├─ no relevant docs → transform_query → retrieve
- *                                └─ generate → grade_generation_v_documents
- *                                                ├─ not grounded → generate (once)
- *                                                └─ grade_generation_v_question
- *                                                     ├─ not useful → transform_query
- *                                                     └─ done
- * ```
- *
- * **The budget is the mechanism, not the prompt.** A graph with a
- * `transform_query` edge can cycle, and their notebooks bound it with a recursion
- * limit that raises on hit. A caller is holding the line, so the bound here is
- * two attempts and one regeneration — {@link MAX_ATTEMPTS} — and running out is
- * an ANSWER (`exhausted`, the caller is offered a ticket) rather than an error.
- * An agent that cannot say "I don't have that documented" is the failure the
- * whole grading apparatus exists to prevent, so it has to be a reachable state.
- *
- * **Documents are graded CONCURRENTLY.** Their loop is sequential because a
- * notebook does not care; four serial grader calls is four round trips of dead
- * air on a phone. The grades are independent, so the fan-out is free.
- */
-
-import type { GenerateFn } from "@alexkroman1/aai";
-import {
-  ANSWER_SYSTEM,
-  ANSWERS_SYSTEM,
-  binaryScore,
-  DOC_GRADER_SYSTEM,
-  GROUNDED_SYSTEM,
-  REWRITE_SYSTEM,
-} from "./prompts.ts";
-import type { AnswerTrace, Doc, GradedDoc, TraceStep } from "./shared.ts";
-import { formatDoc, retrieve } from "./shared.ts";
-
-/** Retrieve-and-answer attempts, i.e. one query rewrite. */
-export const MAX_ATTEMPTS = 2;
-/** Regenerations after a "not grounded" verdict, within one attempt. */
-export const MAX_REGENERATIONS = 1;
-
-function step(trace: AnswerTrace, node: string, detail: string): void {
-  const entry: TraceStep = { node, detail };
-  trace.steps.push(entry);
-}
-
-/** `grade_documents` — one closed question per document, all at once. */
-async function gradeDocuments(
-  generate: GenerateFn,
-  question: string,
-  docs: Doc[],
-): Promise<GradedDoc[]> {
-  return await Promise.all(
-    docs.map(async (doc) => {
-      const { object } = await generate({
-        system: DOC_GRADER_SYSTEM,
-        prompt: `Caller's question: ${question}\n\nDocument:\n${formatDoc(doc)}`,
-        schema: binaryScore,
-      });
-      return {
-        id: doc.id,
-        title: doc.title,
-        relevant: object.score === "yes",
-        reason: object.reason,
-      };
-    }),
-  );
-}
-
-/** `transform_query` — their question re-writer, aimed at a keyword index. */
-async function transformQuery(generate: GenerateFn, question: string): Promise<string> {
-  const { text } = await generate({
-    system: REWRITE_SYSTEM,
-    prompt: `Caller's question: ${question}`,
-  });
-  const rewritten = text.trim().replace(/^["']|["']$/g, "");
-  // A rewriter that returns nothing usable must not empty the query — that
-  // would retrieve zero documents and read as "we have nothing on this".
-  return rewritten.length > 0 ? rewritten : question;
-}
-
-/** `generate` — the answer, from the graded-relevant documents only. */
-async function generateAnswer(
-  generate: GenerateFn,
-  question: string,
-  docs: Doc[],
-): Promise<string> {
-  const { text } = await generate({
-    system: ANSWER_SYSTEM,
-    prompt: `Documents:\n\n${docs.map(formatDoc).join("\n\n")}\n\nCaller's question: ${question}`,
-  });
-  return text.trim();
-}
-
-/** The two generation graders — same closed question, different subject. */
-async function grade(
-  generate: GenerateFn,
-  system: string,
-  prompt: string,
-): Promise<{ pass: boolean; reason: string }> {
-  const { object } = await generate({ system, prompt, schema: binaryScore });
-  return { pass: object.score === "yes", reason: object.reason };
-}
-
-/**
- * Run the graph for one caller question. Never throws for a bad ANSWER — only
- * for a broken model call, which is the tool's to report.
- */
-export async function runCorrectiveRag(
-  generate: GenerateFn,
-  question: string,
-): Promise<AnswerTrace> {
-  const trace: AnswerTrace = {
-    question,
-    query: question,
-    rewrites: 0,
-    steps: [],
-    docs: [],
-    answer: null,
-    grounded: null,
-    useful: null,
-    exhausted: false,
-  };
-
-  for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
-    const retrieved = retrieve(trace.query);
-    step(trace, "retrieve", `${retrieved.length} document(s) for "${trace.query}"`);
-
-    const graded = await gradeDocuments(
-      generate,
-      question,
-      retrieved.map((one) => one.doc),
-    );
-    trace.docs = graded;
-    const relevant = retrieved.filter((one) => graded.find((g) => g.id === one.doc.id)?.relevant);
-    step(trace, "grade_documents", `${relevant.length} of ${graded.length} relevant`);
-
-    // `decide_to_generate`: nothing relevant means the retrieval was wrong, not
-    // that the answer is unknown — so rewrite and try once more before giving up.
-    if (relevant.length === 0) {
-      if (attempt < MAX_ATTEMPTS) {
-        trace.query = await transformQuery(generate, question);
-        trace.rewrites++;
-        step(trace, "transform_query", `retrying as "${trace.query}"`);
-        continue;
-      }
-      trace.exhausted = true;
-      step(trace, "decide_to_generate", "no relevant documents, and no attempts left");
-      return trace;
-    }
-
-    const docs = relevant.map((one) => one.doc);
-    const facts = docs.map(formatDoc).join("\n\n");
-    let answer = await generateAnswer(generate, question, docs);
-    step(trace, "generate", `answered from ${docs.map((d) => d.id).join(", ")}`);
-
-    // `grade_generation_v_documents`: is it grounded? A regeneration is worth
-    // one shot — the same documents with the ungrounded attempt now visible.
-    let grounded = await grade(
-      generate,
-      GROUNDED_SYSTEM,
-      `Facts:\n\n${facts}\n\nAnswer: ${answer}`,
-    );
-    for (let redo = 0; !grounded.pass && redo < MAX_REGENERATIONS; redo++) {
-      step(trace, "grade_generation_v_documents", `not grounded: ${grounded.reason}`);
-      answer = await generateAnswer(generate, question, docs);
-      step(trace, "generate", "regenerated");
-      grounded = await grade(generate, GROUNDED_SYSTEM, `Facts:\n\n${facts}\n\nAnswer: ${answer}`);
-    }
-    trace.answer = answer;
-    trace.grounded = grounded.pass;
-    step(
-      trace,
-      "grade_generation_v_documents",
-      grounded.pass ? "grounded" : `still not grounded: ${grounded.reason}`,
-    );
-    if (!grounded.pass) {
-      // An ungrounded answer is never spoken. Two regenerations that both
-      // invented something is a signal about the documents, not the phrasing.
-      trace.answer = null;
-      trace.exhausted = true;
-      return trace;
-    }
-
-    // `grade_generation_v_question`: grounded is not the same as useful.
-    const useful = await grade(
-      generate,
-      ANSWERS_SYSTEM,
-      `Question: ${question}\n\nAnswer: ${answer}`,
-    );
-    trace.useful = useful.pass;
-    step(
-      trace,
-      "grade_generation_v_question",
-      useful.pass ? "useful" : `not useful: ${useful.reason}`,
-    );
-    if (useful.pass) return trace;
-
-    if (attempt < MAX_ATTEMPTS) {
-      trace.query = await transformQuery(generate, question);
-      trace.rewrites++;
-      step(trace, "transform_query", `retrying as "${trace.query}"`);
-      trace.answer = null;
-      trace.grounded = null;
-      trace.useful = null;
-      continue;
-    }
-    // Out of attempts holding an answer that is grounded but beside the point.
-    // It is still the best thing we have, so it is returned WITH its verdict —
-    // the tool tells the model to offer a ticket alongside it.
-    trace.exhausted = true;
-    return trace;
-  }
-
-  trace.exhausted = true;
-  return trace;
-}

package/dist/{_config-D_s09e7g.mjs → _config-CmJOFsAP.mjs}

@@ -4,8 +4,8 @@ import { c as isEexist, l as readJson, o as errorMessage, p as writeJson } from
 import { mkdtempSync } from "node:fs";
 import path from "node:path";
 import fs from "node:fs/promises";
-import { tmpdir } from "node:os";
 import { sleep } from "@alexkroman1/aai/internal";
+import { tmpdir } from "node:os";
 import envPaths from "env-paths";
 import { z } from "zod";
 //#region _config.ts