@m6d/cortex-cli 0.14.0 → 0.16.0

package/src/commands/management.ts

@@ -88,18 +88,22 @@ export function registerManagement(program: Program, argv: string[]) {
 }
 
 /**
- * The key is never a flag (argv is visible to other processes and lands in
- * shell history): it is prompted for masked, or read from `CORTEX_KEY`
- * when there is no terminal to ask.
+ * The URL is `--url`, or asked for on a terminal. The key is never a flag
+ * (argv is visible to other processes and lands in shell history): it is
+ * prompted for masked, or read from `CORTEX_KEY` when there is no terminal
+ * to ask.
  */
 async function login(given: string | undefined, name: string) {
-    const url = requireTls(
-        (given ?? (await prompts.askValue("Cortex URL", "https://cortex.example.com"))).replace(
-            /\/+$/,
-            "",
-        ),
-    );
-    const key = process.stdin.isTTY
+    const typed =
+        given ??
+        (prompts.canAsk()
+            ? await prompts.askValue("Cortex URL", "https://cortex.example.com")
+            : report.fail({
+                  what: "No terminal to ask for the Cortex URL",
+                  blocks: ["Pass it with --url."],
+              }));
+    const url = requireTls(typed.replace(/\/+$/, ""));
+    const key = prompts.canAsk()
         ? await prompts.askSecret("Management key")
         : (process.env["CORTEX_KEY"] ??
           report.fail({
@@ -248,7 +252,8 @@ function groupByRouter(document: OpenApiDocument) {
 /**
  * One procedure as one command: a positional for `id`, a typed flag per
  * field, `--json` for a whole body, `--all` on paginated reads, `--publish`
- * on writes to a publishable router.
+ * on writes to a publishable router, `--yes` wherever a destructive
+ * procedure (`x-destructive`) would run.
  */
 function registerOperation(scope: {
     group: Command;
@@ -273,10 +278,13 @@ function registerOperation(scope: {
     const publisher = publishWith === undefined ? undefined : byProcedure.get(publishWith);
     const canPublish = publisher !== undefined;
     const liveFields = operation["x-live-fields"] ?? [];
+    const destructive = operation["x-destructive"] === true;
+    const publishDestructive = publisher?.operation["x-destructive"] === true;
 
     const command = declareCommand(group, name, operation.summary ?? "", flags, {
         paginated,
         canPublish,
+        confirms: destructive || publishDestructive,
     });
 
     command.action(async function (...args) {
@@ -285,11 +293,12 @@ function registerOperation(scope: {
             json?: string;
             all?: boolean;
             publish?: boolean;
+            yes?: boolean;
         };
         // Commander passes the options object first when the command declares
         // no argument, so only a string is the `[id]` positional.
         const positional = typeof args[0] === "string" ? args[0] : undefined;
-        const { output: format, json, all, publish, ...given } = options;
+        const { output: format, json, all, publish, yes, ...given } = options;
         const body = await collectInput(flags, given, json, positional, name);
         // `-o json` promises stdout holds only the result; prose moves to stderr.
         const note = format === "json" ? report.aside : report.note;
@@ -297,6 +306,20 @@ function registerOperation(scope: {
             report.header(`cortex ${router} ${name}`);
             report.input("Cortex", profile.url);
         }
+        // One question before anything is sent, covering the publish too, so
+        // a no leaves no draft behind.
+        const confirming = [
+            ...(destructive ? [`${router} ${name}`] : []),
+            ...(publish === true && publishDestructive
+                ? [publisher.operation.operationId.replace(".", " ")]
+                : []),
+        ];
+        if (confirming.length > 0) {
+            await confirmDestructive(
+                `Running ${confirming.join(" and ")} on ${profile.url} replaces or removes state.`,
+                yes,
+            );
+        }
         const result = await callOrFail(profile, () =>
             all
                 ? walkPages(profile, method, path, body)
@@ -320,7 +343,7 @@ function declareCommand(
     name: string,
     summary: string,
     flags: Flag[],
-    shape: { paginated: boolean; canPublish: boolean },
+    shape: { paginated: boolean; canPublish: boolean; confirms: boolean },
 ) {
     const command = group
         .command(name)
@@ -353,9 +376,34 @@ function declareCommand(
     }
     if (shape.paginated) command.option("--all", "Walk every page");
     if (shape.canPublish) command.option("--publish", "Publish the entity right after saving");
+    if (shape.confirms)
+        command.option("--yes", "Skip the confirmation; required without a terminal");
     return command;
 }
 
+/** What a publish went ahead despite, such as a prompt naming a tool without an @-mention. */
+function warningsOf(published: unknown) {
+    return isRecord(published) && Array.isArray(published.warnings)
+        ? published.warnings.filter((warning): warning is string => typeof warning === "string")
+        : [];
+}
+
+/**
+ * The go-ahead for a call that replaces or removes state, which `effect`
+ * names: `--yes`, or a yes on a terminal. With no terminal to ask, the run
+ * fails before anything is sent, so a script never hangs on the question.
+ * The hint does not echo argv, which may hold values that must not reach a
+ * CI log.
+ */
+export async function confirmDestructive(effect: string, yes: boolean | undefined) {
+    if (yes === true) return;
+    if (prompts.canAsk()) return prompts.askToProceed(`${effect} Continue?`);
+    report.fail({
+        what: "No terminal to confirm this call",
+        blocks: [effect, "Rerun the command with --yes to run it without asking."],
+    });
+}
+
 /**
  * A write to a publishable router is a draft: publish it now, or say how to.
  * Fields Cortex reads live are already in effect and are named as such,
@@ -378,10 +426,11 @@ async function publishAfterWrite(
         );
     }
     if (publish) {
-        await callOrFail(profile, () =>
+        const published = await callOrFail(profile, () =>
             callManagement(profile, publisher.method, publisher.path, { id }),
         );
         options.note(`Published ${id}.`);
+        for (const warning of warningsOf(published)) options.note(`Warning: ${warning}`);
     } else {
         options.note(
             `${live ? "The rest is" : "Saved as"} a draft. Add --publish, or run: ${command}`,
@@ -400,14 +449,18 @@ export async function callOrFail<T>(profile: ResolvedProfile, call: () => Promis
 
 /**
  * A management refusal, or a Cortex that cannot be reached, is the
- * run's outcome, in the error grammar, with whatever the refusal names;
- * anything else is a bug, and rethrown.
+ * run's outcome, in the error grammar: the refusal's literal, the sentence
+ * Cortex words it in, then whatever it names; anything else is a bug, and
+ * rethrown.
  */
 export function failCall(profile: { url: string }, error: unknown): never {
     if (error instanceof ManagementError) {
         report.fail({
             what: `${error.status} ${error.code}: ${error.message}`,
-            blocks: refusalBlocks(error.detail ?? {}),
+            blocks: [
+                ...(error.refusal === undefined ? [] : [error.refusal]),
+                ...refusalBlocks(error.detail ?? {}),
+            ],
         });
     }
     if (error instanceof UnreachableError) {
@@ -451,8 +504,8 @@ function issueLine(issue: unknown) {
 
 /**
  * The body: `--json` first, flags layered over it, the positional as `id`.
- * A required field left missing is asked for on a TTY and named as the
- * flag, or the positional, to add otherwise.
+ * A required field left missing is asked for on a terminal and named as
+ * the flag, or the positional, to add otherwise.
  */
 async function collectInput(
     flags: Flag[],
@@ -468,7 +521,7 @@ async function collectInput(
     if (positional !== undefined) body.set("id", positional);
 
     const missing = flags.filter((flag) => flag.required && body.get(flag.name) === undefined);
-    if (missing.length > 0 && !process.stdin.isTTY) {
+    if (missing.length > 0 && !prompts.canAsk()) {
         const named = (flag: Flag) =>
             flag.name === "id"
                 ? "<id>"

package/src/commands/new.ts

@@ -9,7 +9,7 @@ import pkg from "../../package.json";
 import { askProvider } from "@/commands/setup";
 import { AGENT_SLUG, manifestIdOf, scaffoldFiles } from "@/scaffold/files";
 import { allocatePorts, type Ports } from "@/scaffold/ports";
-import { askConfirm, askName, intro, log, outro, runSteps } from "@/ui/prompts";
+import { askConfirm, askName, canAsk, intro, log, outro, runSteps } from "@/ui/prompts";
 import * as report from "@/ui/report";
 
 /** npm's rule for an unscoped package name. The name is the directory too. */
@@ -46,9 +46,8 @@ type Options = { datasets?: true; setup?: boolean; yes?: true; verbose: boolean
 async function scaffold(name: string | undefined, options: Options) {
     const { verbose } = options;
 
-    // No TTY ⇒ never prompt and behave as `--yes`. On Bun a piped stdin reports
-    // `undefined` rather than `false`, which is why this compares against `true`.
-    const interactive = process.stdin.isTTY === true && options.yes !== true;
+    // No terminal ⇒ never prompt and behave as `--yes`.
+    const interactive = canAsk() && options.yes !== true;
 
     if (name === undefined && !interactive) missingName();
 
@@ -280,14 +279,13 @@ function isInsideWorkTree(target: string) {
 }
 
 function missingName(): never {
-    // No TTY ⇒ never prompt, so a missing required argument is a hard error.
-    // With a TTY this branch is only reached under `--yes`, which answers every
+    // No terminal ⇒ never prompt, so a missing required argument is a hard error.
+    // With one, this branch is only reached under `--yes`, which answers every
     // question including the one that has no default.
     report.fail({
-        what:
-            process.stdin.isTTY === true
-                ? "cortex new needs a project name."
-                : "cortex new needs a project name when stdin is not a TTY.",
+        what: canAsk()
+            ? "cortex new needs a project name."
+            : "cortex new needs a project name when there is no terminal to ask on.",
         blocks: [
             "Pass it as an argument, and --yes to accept defaults for the rest:",
             "  cortex new my-app --yes",

package/src/commands/setup.ts

@@ -12,15 +12,23 @@ import {
     normalizeHost,
     scrubCredentialStrings,
 } from "@cortex/contracts/egress-policy";
+import { MODEL_PROVIDER_LIMITS, NAME_MAX_LENGTH } from "@cortex/contracts/manifest";
 import { z } from "zod";
 
 import {
     applyManifest,
     DEFAULT_MANIFEST,
     findManifest,
+    loadManifest,
     printTriggerSecrets,
 } from "@/commands/apply";
-import { callOrFail, failCall, requireProfile, walkPages } from "@/commands/management";
+import {
+    callOrFail,
+    confirmDestructive,
+    failCall,
+    requireProfile,
+    walkPages,
+} from "@/commands/management";
 import { callManagement, ManagementError, UnreachableError } from "@/management/client";
 import { DOCKER_HOST, EMBEDDING, withEnvValues } from "@/scaffold/files";
 import * as prompts from "@/ui/prompts";
@@ -34,7 +42,7 @@ const POLL_MS = 2_000;
 
 /** The backend as `cortex new` writes it into .env, which Bun loads from the directory it runs in. */
 const projectSchema = z.object({
-    CORTEX_SERVER_NAME: z.string().min(1),
+    CORTEX_SERVER_NAME: z.string().min(1).max(NAME_MAX_LENGTH),
     CORTEX_SERVER_URL: z.url(),
     CORTEX_SERVER_KEY: z.string().min(1),
 });
@@ -48,14 +56,16 @@ const ENV_SAFE = /^[^\s$#'"`\\]+$/;
 
 /** The model provider in .env: all four values, or none. */
 const providerFields = z.object({
-    // Its key's secret is `<name>-api-key-<digest>`, within Cortex's 120 characters.
-    MODEL_PROVIDER_NAME: z.string().min(1).max(103),
-    MODEL_PROVIDER_URL: z.string().superRefine(function (value, context) {
-        const problem = checkBaseUrl(value);
-        if (problem) context.addIssue({ code: "custom", message: problem });
-    }),
+    MODEL_PROVIDER_NAME: z.string().min(1).max(NAME_MAX_LENGTH),
+    MODEL_PROVIDER_URL: z
+        .string()
+        .max(MODEL_PROVIDER_LIMITS.urlLength)
+        .superRefine(function (value, context) {
+            const problem = checkBaseUrl(value);
+            if (problem) context.addIssue({ code: "custom", message: problem });
+        }),
     MODEL_PROVIDER_API_KEY: z.string().min(1),
-    MODEL_PROVIDER_MODEL: z.string().min(1).max(200),
+    MODEL_PROVIDER_MODEL: z.string().min(1).max(MODEL_PROVIDER_LIMITS.modelLength),
 });
 const providerEnvSchema = providerFields.transform((env) => ({
     name: env.MODEL_PROVIDER_NAME,
@@ -94,8 +104,12 @@ const embeddingsSchema = z.object({
  * creates what is missing and keeps what exists, so it runs again on every
  * `bun run dev`. A provider or server under .env's name must call .env's URL,
  * or setup leaves it alone and stops, so no key reaches a URL .env did not name. With no model provider in .env it asks for
- * one on a terminal, and under `--yes` registers the server and applies
- * nothing, since Cortex publishes no agent without a model.
+ * one on a terminal, and under `--yes` registers the server without a model
+ * and applies all the same, since an agent may name its own; when Cortex
+ * refuses an agent for want of one, setup says so and applies nothing. The
+ * apply deletes what the manifest no longer lists, so setup checks the
+ * manifest, then waits for a yes on a terminal or `--yes`, before it asks or
+ * writes anything else, as `cortex apply` does.
  */
 export function registerSetup(program: Command<[], { verbose?: true; profile?: string }>) {
     const command = program
@@ -103,19 +117,26 @@ export function registerSetup(program: Command<[], { verbose?: true; profile?: s
         .helpGroup("Project:")
         .description("Register this project's backend and model in Cortex, then apply its manifest")
         .option("--wait", "Wait for Cortex to come up first")
-        .option("--yes", "Never ask; leave out what .env does not hold");
+        .option(
+            "--yes",
+            "Never ask: leave out what .env does not hold, and apply without confirming",
+        );
 
     command.action(async function (options) {
         const { verbose = false, profile: profileName } = program.opts();
         const project = readProject();
         const profile = requireProfile(profileName);
-        const file = findManifest(DEFAULT_MANIFEST);
-        const interactive = process.stdin.isTTY === true && options.yes !== true;
+        const manifest = await loadManifest(findManifest(DEFAULT_MANIFEST), verbose);
+        const interactive = prompts.canAsk() && options.yes !== true;
         if (profileName === undefined) requireEnvCortex(profile.url);
 
         report.header("cortex setup");
         await waitForCortex(profile, options.wait === true);
         report.input("Cortex", profile.url);
+        await confirmDestructive(
+            `Applying deletes what the manifest created on ${profile.url} and no longer lists.`,
+            options.yes,
+        );
 
         const provider = readProvider() ?? (interactive ? await askAndSave() : undefined);
         if (provider) await requireReachable(provider.baseUrl);
@@ -124,21 +145,26 @@ export function registerSetup(program: Command<[], { verbose?: true; profile?: s
         const server = await ensureServer(profile, project, provider);
         await syncServer(profile, server.id, project.CORTEX_SERVER_URL);
 
-        if (server.modelProvider === null) {
+        const applied = await applyManifest({
+            profile,
+            manifest,
+            dryRun: false,
+            interactive,
+            command: "bun cortex apply --yes",
+        }).catch(function (error: unknown) {
+            if (error instanceof ManagementError && error.message === "chat_model_required") {
+                return undefined;
+            }
+            return failCall(profile, error);
+        });
+        if (!applied) {
             report.footer("no model yet, so nothing applied");
             report.note("Run `bun cortex setup` in a terminal to add a model provider.");
             return;
         }
-
-        const { changes, triggerSecrets } = await applyManifest({
-            profile,
-            file,
-            dryRun: false,
-            verbose,
-        });
         report.footer(`live · chat at ${profile.url}/playground`);
-        printTriggerSecrets(triggerSecrets);
-        if (Object.values(changes.create).flat().length > 0) printSignIn(profile.url);
+        printTriggerSecrets(applied.triggerSecrets);
+        if (Object.values(applied.changes.create).flat().length > 0) printSignIn(profile.url);
     });
 }
 
@@ -146,8 +172,9 @@ function readProject() {
     const parsed = projectSchema.safeParse(process.env);
     if (parsed.success) return parsed.data;
     return report.fail({
-        what: "No project here for cortex setup",
+        what: "No project here cortex setup can register",
         blocks: [
+            z.prettifyError(parsed.error),
             "It reads CORTEX_SERVER_NAME, CORTEX_SERVER_URL and CORTEX_SERVER_KEY from\n.env, which `cortex new` writes. Run it from that project's root.",
         ],
     });
@@ -242,13 +269,15 @@ async function findByName<TItem extends typeof namedSchema>(
 }
 
 /**
- * A secret's name for one value: its base and a short digest of the value.
- * A name then holds one value only, so a secret that exists is the value
- * .env holds, and a changed key gets a secret of its own while every row
- * presenting the old one keeps it.
+ * A secret's name for one value: its owner's name, what it is to the owner,
+ * and a short digest of the value, the owner's name cut so the whole is a
+ * name Cortex holds. A name then holds one value only, so a secret that
+ * exists is the value .env holds, and a changed key gets a secret of its own
+ * while every row presenting the old one keeps it.
  */
-function secretFor(base: string, value: string) {
-    return `${base}-${createHash("sha256").update(value).digest("hex").slice(0, 8)}`;
+function secretFor(owner: string, role: "api-key" | "server-key", value: string) {
+    const suffix = `-${role}-${createHash("sha256").update(value).digest("hex").slice(0, 8)}`;
+    return `${owner.slice(0, NAME_MAX_LENGTH - suffix.length)}${suffix}`;
 }
 
 async function ensureSecret(profile: Profile, name: string, value: string) {
@@ -271,7 +300,9 @@ function failCallsElsewhere(what: string, calls: string | null, wanted: string,
 
 /**
  * The provider, on its key's secret. One that exists takes a changed key and
- * the .env model as well; one that calls another URL ends the run.
+ * the .env model as well; one that calls another URL, or lists as many
+ * models as Cortex allows without the .env one, ends the run before any
+ * write.
  */
 async function ensureProvider(profile: Profile, provider: Provider) {
     const found = await findByName(profile, "model-providers", provider.name, providerRowSchema);
@@ -283,7 +314,17 @@ async function ensureProvider(profile: Profile, provider: Provider) {
             "MODEL_PROVIDER_NAME",
         );
     }
-    const secretName = secretFor(`${provider.name}-api-key`, provider.apiKey);
+    // Added, never replaced: a model a server still runs on stays offered.
+    const models = [...new Set([...(found?.models ?? []), provider.model])];
+    if (models.length > MODEL_PROVIDER_LIMITS.models) {
+        report.fail({
+            what: `Provider ${provider.name} in Cortex lists ${MODEL_PROVIDER_LIMITS.models} models, not ${provider.model}`,
+            blocks: [
+                "Cortex lists no more on one provider. Remove one in the console, or set\nMODEL_PROVIDER_MODEL in .env to a model it lists.",
+            ],
+        });
+    }
+    const secretName = secretFor(provider.name, "api-key", provider.apiKey);
     await ensureSecret(profile, secretName, provider.apiKey);
 
     if (!found) {
@@ -291,7 +332,7 @@ async function ensureProvider(profile: Profile, provider: Provider) {
             name: provider.name,
             baseUrl: provider.baseUrl,
             secretName,
-            models: [provider.model],
+            models,
             efforts: [],
         });
         report.input("Provider", `${provider.name} · created`);
@@ -305,8 +346,7 @@ async function ensureProvider(profile: Profile, provider: Provider) {
         id: found.id,
         baseUrl: found.baseUrl,
         secretName,
-        // Added, never replaced: a model a server still runs on stays offered.
-        models: [...new Set([...found.models, provider.model])],
+        models,
         efforts: found.efforts,
     });
     report.input("Provider", `${provider.name} · updated`);
@@ -332,7 +372,7 @@ async function ensureServer(
     if (server && server.url !== url) {
         failCallsElsewhere(`Server ${name}`, server.url, url, "CORTEX_SERVER_NAME");
     }
-    const keySecretName = secretFor(`${name}-server-key`, project.CORTEX_SERVER_KEY);
+    const keySecretName = secretFor(name, "server-key", project.CORTEX_SERVER_KEY);
     await ensureSecret(profile, keySecretName, project.CORTEX_SERVER_KEY);
 
     const model = {

package/src/contracts/datasets/dataset-sql.ts

@@ -15,7 +15,14 @@ import type {
     DatasetQueryInput,
     DatasetRelation,
 } from "./datasets";
-import { DATASET_BUCKETS, DATASET_DATE_PARTS, describeOperand, groupKeyName } from "./datasets";
+import {
+    DATASET_BUCKETS,
+    DATASET_DATE_PARTS,
+    DATASET_REQUEST_MAX_BYTES,
+    describeOperand,
+    groupKeyName,
+    unknownColumnError,
+} from "./datasets";
 
 /*
  * The SQL a model writes against a dataset, and how it becomes the wire
@@ -272,6 +279,15 @@ const WINDOW_PLACE =
     "RANK() goes in QUALIFY (QUALIFY RANK() OVER (PARTITION BY a ORDER BY b DESC) <= n) or in a derived table filtered on its alias (FROM (SELECT ..., RANK() OVER (...) AS rn FROM ...) WHERE rn <= n).";
 const INTERVAL_PLACE =
     "INTERVAL only shifts CURRENT_DATE (CURRENT_DATE - INTERVAL '7 days'); compare the column against a date instead.";
+const TOO_LARGE =
+    "The statement grows too large to send: a simple CASE repeats its subject in every WHEN, so a CASE nested in that subject multiplies. Compare a column instead, or ask in smaller queries.";
+
+/**
+ * The most tokens a statement may read, a simple CASE's subject counted again
+ * for every WHEN that repeats it. A token writes about a byte or more of the
+ * wire query, so a statement past this could never be sent.
+ */
+const EXPANDED_TOKENS_MAX = DATASET_REQUEST_MAX_BYTES;
 
 const REFUSED_CLAUSES = {
     UNION: "UNION is not supported: ask each dataset in its own query.",
@@ -396,6 +412,8 @@ function datePartTerm(unit: DatasetDatePart, of: Term) {
 
 class Parser {
     private position = 0;
+    /** Tokens read so far, a simple CASE's subject counted once per WHEN: how large the statement grows once written out. */
+    private expanded = 0;
 
     public constructor(
         private readonly tokens: Token[],
@@ -763,11 +781,15 @@ class Parser {
      */
     private caseTerm() {
         this.take();
+        const start = this.expanded;
         const subject = this.peekWord("WHEN")
             ? undefined
             : this.term("CASE is followed by WHEN, or by a value to compare.");
+        const subjectSize = this.expanded - start;
         const branches: { when: Predicate[]; then: Term }[] = [];
         while (this.optionalWord("WHEN")) {
+            // The wire has no simple CASE: every WHEN after the first writes the subject out again.
+            if (branches.length > 0) this.expand(subjectSize);
             const when = subject ? [this.simpleCaseMatch(subject)] : this.predicates();
             this.expectWord("THEN", "CASE WHEN condition needs THEN value.");
             if (this.peekWord("NULL")) {
@@ -1224,8 +1246,14 @@ class Parser {
     private take() {
         const token = this.peek();
         this.position += 1;
+        this.expand(1);
         return token;
     }
+    /** Counts `tokens` toward the statement's written-out size, refused the moment it passes what a request carries. */
+    private expand(tokens: number) {
+        this.expanded += tokens;
+        if (this.expanded > EXPANDED_TOKENS_MAX) throw new DatasetSqlError(TOO_LARGE);
+    }
     private peekWord(upper: string) {
         const token = this.peek();
         return token.kind === "word" && token.upper === upper;
@@ -1328,11 +1356,16 @@ function unqualified(ref: string, table: string | undefined) {
     return table !== undefined && ref.startsWith(`${table}.`) ? ref.slice(table.length + 1) : ref;
 }
 
-/** The outer list of a derived table: `*` keeps every inner value, names keep those; the RANK() itself is never answered. */
+/**
+ * The outer list of a derived table: `*` keeps every inner value, names keep
+ * those, each once since every listing writes the value out again; the
+ * RANK() itself is never answered.
+ */
 function narrowed(inner: SelectItem[], outer: SelectItem[], table: string | undefined) {
     const values = inner.filter((item) => item.kind !== "rankWindow");
     if (outer.some((item) => item.kind === "star")) return values;
     const windowNames = inner.flatMap((item) => (item.kind === "rankWindow" ? [item.alias] : []));
+    const listed = new Set<SelectItem>();
     const kept = outer.flatMap((item) => {
         const name =
             item.kind === "column" && item.alias === undefined
@@ -1346,6 +1379,12 @@ function narrowed(inner: SelectItem[], outer: SelectItem[], table: string | unde
                 "The outer SELECT of a derived table lists names the inner SELECT answers, or *.",
             );
         }
+        if (listed.has(found)) {
+            throw new DatasetSqlError(
+                `The outer SELECT lists "${name}" twice; list each value of the derived table once.`,
+            );
+        }
+        listed.add(found);
         return [found];
     });
     const unnamed = values.flatMap((value) =>
@@ -1658,6 +1697,11 @@ class Sources {
                 `"${qualifier}" is a link table; read its columns from the datasets it links.`,
             );
         }
+        // Checked here, where the query's own dataset name is known: the wire
+        // reference names the relation path instead.
+        if (!source.dataset.columns.some((c) => c.name === column)) {
+            throw new DatasetSqlError(unknownColumnError(source.dataset, column));
+        }
         return source.path ? `${source.path}.${column}` : column;
     }
 
@@ -1747,10 +1791,8 @@ class Sources {
                 `"${column}" is a column of ${owners.map((o) => o.dataset.name).join(" and ")}; qualify it as dataset.column.`,
             );
         }
-        const joined = this.paths.length ? " or of the joined datasets" : "";
-        throw new DatasetSqlError(
-            `"${column}" is not a column of ${this.root.dataset.name}${joined}.`,
-        );
+        const joined = this.paths.length ? " Nor does any joined dataset." : "";
+        throw new DatasetSqlError(unknownColumnError(this.root.dataset, column) + joined);
     }
 
     /** Every readable dataset once, whatever it is named as. */
@@ -2073,7 +2115,8 @@ function resolveGroupKeys(
             key = twin ?? { expr, as: lastSegment(column ?? "") };
         }
         const taken = keys.get(groupKeyName(key));
-        if (taken && !same(operandOf(taken), operandOf(key))) {
+        // A name grouped again is the very same key; only a different one is written out to compare.
+        if (taken && taken !== key && !same(operandOf(taken), operandOf(key))) {
             throw new DatasetSqlError(
                 `Two group keys would answer as "${groupKeyName(key)}"; name each value: ${describeTerm(group)} AS name.`,
             );
@@ -2466,10 +2509,18 @@ function calendarDate(now: Date, timeZone: string | undefined) {
     }
 }
 
+/** The longest statement a query may be: room for any query a model writes, and a bound on the work one costs. */
+export const DATASET_SQL_MAX_LENGTH = 8_000;
+
 /** Parses one SELECT against the catalog into the wire query; throws {@link DatasetSqlError} with what to write instead. */
 export function parseDatasetSql(sql: string, catalog: DatasetCatalog, options: ParseOptions) {
     const trimmed = sql.trim();
     if (!trimmed) throw new DatasetSqlError("The query is empty.");
+    if (trimmed.length > DATASET_SQL_MAX_LENGTH) {
+        throw new DatasetSqlError(
+            `The query is longer than ${DATASET_SQL_MAX_LENGTH} characters; ask for less at once.`,
+        );
+    }
     const today = calendarDate(options.now, options.timeZone);
     return compile(catalog, new Parser(tokenize(trimmed), today).statement());
 }