@@ -97,6 +97,8 @@ pnpm --filter @objectstack/scenarios run-scenarios --only service_desk --modes s
 pnpm --filter @objectstack/scenarios run-scenarios --record /tmp/rec.json  # also save every turn
 pnpm --filter @objectstack/scenarios run-scenarios --driver recorded:/tmp/rec.json  # replay, no model
 pnpm --filter @objectstack/scenarios run-scenarios --author-timeout 90       # minutes per authoring turn (default 60)
+pnpm --filter @objectstack/scenarios run-scenarios --author-max-turns 400    # turns per authoring turn, every card (default by tier)
+pnpm --filter @objectstack/scenarios run-scenarios --ask-max-turns 20        # turns per question or operation turn (default 12)
 ```
 
 Per card and mode the runner writes `docs/qa/platform-checklist/runs/<date>-scenario-<card>.json`
@@ -110,14 +112,22 @@ Per card and mode the runner writes `docs/qa/platform-checklist/runs/<date>-scen
 - **Driver** (`driver.ts`): the local `claude` CLI on your own login (`claude -p --output-format stream-json`, the
   prompt written to its stdin: a build prompt carries the whole seed, and one argv string over 128 KiB makes `spawn`
   fail with `E2BIG` on Linux). It refuses to start when `ANTHROPIC_API_KEY` / `ANTHROPIC_AUTH_TOKEN` is set or the CLI
-  is logged in with an API key (the cost ruling on cloud#3600), and the record states the driver, the login and the
-  authoring timeout. Every turn records its process: elapsed time, and for a turn that did not finish its exit code or
-  signal, whether the runner's timeout killed it, and the end of its stderr. `RecordedDriver` replays a recording.
+  is logged in with an API key (the cost ruling on cloud#3600), and the record states the driver, the login, the
+  authoring timeout and the turn caps. Every turn records its process: elapsed time, the turn cap it ran under
+  (`--max-turns`), and for a turn that did not finish its exit code or signal, whether the runner's timeout killed it,
+  and the end of its stderr. `RecordedDriver` replays a recording, and refuses the three live-driver limits below.
+- **Turn caps** (`driver.ts`): an authoring turn, build and iterate alike, may take `DEFAULT_AUTHOR_MAX_TURNS` by the
+  card's `tier` — `control` 80, `starter` 300, `delivery` 600 — unless `--author-max-turns N` sets one cap for every
+  card; a question or operation turn takes 12 unless `--ask-max-turns N` says otherwise. The cap guards a looping turn
+  and `--author-timeout` a slow one, whichever comes first: the `starter` builds measured ran 11–18 s a turn, so the
+  60-minute default holds 200–325 of them and both limits bind at about the same point. A `delivery` card's 600 turns
+  outlast that default; raise `--author-timeout` with it.
 - **A build that did not finish is not measured** (`orchestrate.ts`): an authoring turn the timeout killed
   (`--author-timeout`, build and iterate alike) leaves its Build half **not measured: author timed out after N min**;
   one that ended with no result line or an error result (`error_max_turns`, `is_error`), or never ran, leaves it **not
   measured: author turn failed: …**. Never a degraded score, and nothing runs on it: no score, seed, Run or iterate. The
-  scorecard's author rows show every authoring turn's `resultSubtype` and elapsed time.
+  scorecard's author rows show every authoring turn's `resultSubtype`, the turns it took of its cap
+  (`error_max_turns · 300/300 turns`) and its elapsed time.
 - **Seed** (`seed.ts`): rows go in as the admin, a lookup's target before its referrer. Where the card's declared
   lookups lead back to where they start — `department.manager → employee` with `employee.department → department`, or a
   self-lookup naming a later row — the seed loads in two passes: every row first with each lookup naming a row not in
 
@@ -13,6 +13,13 @@
  *   --author-timeout MIN the live driver's budget per authoring turn, build and
  *                        iterate alike (default 60); a turn it kills leaves its
  *                        Build half not measured
+ *   --author-max-turns N the live driver's turn cap per authoring turn, build
+ *                        and iterate alike, on every card (default by the card's
+ *                        tier: control 80, starter 300, delivery 600); a turn
+ *                        that reaches it (`error_max_turns`) leaves its Build
+ *                        half not measured
+ *   --ask-max-turns N    the live driver's turn cap per question or operation
+ *                        turn (default 12)
  *   --template F         a verified build (dist/objectstack.json) for template mode
  *   --no-iterate-run     skip the Run half after the iterate (scratch mode)
  *   --out DIR            where records go (default docs/qa/platform-checklist/runs, git-ignored)
@@ -59,6 +66,10 @@ export interface CliArgs {
   iterateRun: boolean;
   /** Minutes per authoring turn (`--author-timeout`); the driver's default when absent. */
   authorTimeoutMin?: number;
+  /** Turns per authoring turn on every card (`--author-max-turns`); the card tier's default when absent. */
+  authorMaxTurns?: number;
+  /** Turns per question or operation turn (`--ask-max-turns`); the driver's default when absent. */
+  askMaxTurns?: number;
   out?: string;
   work?: string;
   createVersion?: string;
@@ -73,6 +84,12 @@ export function parseArgs(argv: readonly string[]): CliArgs {
       if (v === undefined) throw new Error(`${flag} needs a value`);
       return v;
     };
+    const turns = () => {
+      const raw = val();
+      const n = Number(raw);
+      if (!Number.isInteger(n) || n <= 0) throw new Error(`${flag} takes a whole number of turns above 0, not \`${raw}\``);
+      return n;
+    };
     if (flag === '--cards') a.cards = val();
     else if (flag === '--only') a.only = val().split(',');
     else if (flag === '--modes') {
@@ -89,6 +106,8 @@ export function parseArgs(argv: readonly string[]): CliArgs {
       if (!Number.isFinite(min) || min <= 0) throw new Error(`--author-timeout takes a number of minutes above 0, not \`${raw}\``);
       a.authorTimeoutMin = min;
     }
+    else if (flag === '--author-max-turns') a.authorMaxTurns = turns();
+    else if (flag === '--ask-max-turns') a.askMaxTurns = turns();
     else if (flag === '--out') a.out = val();
     else if (flag === '--work') a.work = val();
     else if (flag === '--create-version') a.createVersion = val();
@@ -97,10 +116,26 @@ export function parseArgs(argv: readonly string[]): CliArgs {
   return a;
 }
 
-export function makeDriver(spec: string, opts: { authorTimeoutMin?: number } = {}): AgentDriver {
-  if (spec === 'claude') return new ClaudeCodeDriver(opts.authorTimeoutMin !== undefined ? { authorTimeoutMs: opts.authorTimeoutMin * 60_000 } : {});
+/** The live driver's limits a run may set: `--author-timeout`, `--author-max-turns`, `--ask-max-turns`. */
+export type DriverLimits = Pick<CliArgs, 'authorTimeoutMin' | 'authorMaxTurns' | 'askMaxTurns'>;
+
+const LIMIT_FLAGS: ReadonlyArray<readonly [keyof DriverLimits, string]> = [
+  ['authorTimeoutMin', '--author-timeout'],
+  ['authorMaxTurns', '--author-max-turns'],
+  ['askMaxTurns', '--ask-max-turns'],
+];
+
+export function makeDriver(spec: string, opts: DriverLimits = {}): AgentDriver {
+  if (spec === 'claude') {
+    return new ClaudeCodeDriver({
+      ...(opts.authorTimeoutMin !== undefined ? { authorTimeoutMs: opts.authorTimeoutMin * 60_000 } : {}),
+      ...(opts.authorMaxTurns !== undefined ? { authorMaxTurns: opts.authorMaxTurns } : {}),
+      ...(opts.askMaxTurns !== undefined ? { askMaxTurns: opts.askMaxTurns } : {}),
+    });
+  }
   if (spec.startsWith('recorded:')) {
-    if (opts.authorTimeoutMin !== undefined) throw new Error('--author-timeout applies to the live driver only: a replay re-reads each turn as it was recorded');
+    const given = LIMIT_FLAGS.filter(([key]) => opts[key] !== undefined).map(([, flag]) => flag);
+    if (given.length) throw new Error(`${given.join(', ')} ${given.length === 1 ? 'applies' : 'apply'} to the live driver only: a replay re-reads each turn as it was recorded`);
     return RecordedDriver.fromFile(spec.slice('recorded:'.length));
   }
   throw new Error(`unknown driver \`${spec}\` (claude, recorded:FILE)`);
@@ -124,12 +159,14 @@ export async function main(argv: readonly string[]): Promise<number> {
     return 2;
   }
 
-  const live = makeDriver(args.driver, args.authorTimeoutMin !== undefined ? { authorTimeoutMin: args.authorTimeoutMin } : {});
+  const live = makeDriver(args.driver, args);
   const driver = args.record ? new RecordingDriver(live) : live;
   const info = driver.info();
   console.log(
     `driver: ${info.driver} ${info.version ?? ''} · login: ${info.authMethod ?? 'n/a'} · API-billed: no` +
-      (info.authorTimeoutMs !== undefined ? ` · author timeout: ${minutesText(info.authorTimeoutMs)}` : ''),
+      (info.authorTimeoutMs !== undefined ? ` · author timeout: ${minutesText(info.authorTimeoutMs)}` : '') +
+      (info.authorMaxTurns ? ` · author max turns: ${Object.entries(info.authorMaxTurns).map(([tier, n]) => `${tier} ${n}`).join(', ')}` : '') +
+      (info.askMaxTurns !== undefined ? ` · ask max turns: ${info.askMaxTurns}` : ''),
   );
 
   const ops: ProjectOps = {
 
@@ -26,6 +26,7 @@ import { mkdtempSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSyn
 import { tmpdir } from 'node:os';
 import { dirname, join, relative, resolve, sep } from 'node:path';
 
+import { SCENARIO_TIERS, type ScenarioTier } from '../schema.js';
 import { parseStreamJson, type ParsedTurn, type TurnProcess } from './transcript.js';
 
 /** Which run step a turn belongs to; the replay key is built from it. */
@@ -46,6 +47,8 @@ export interface AuthorTask extends StepRef {
   /** The project directory the agent edits. */
   cwd: string;
   prompt: string;
+  /** The card's tier: it sizes the live driver's turn cap ({@link DEFAULT_AUTHOR_MAX_TURNS}). Not part of the replay key. */
+  tier: ScenarioTier;
 }
 
 export interface AskTask extends StepRef {
@@ -71,6 +74,10 @@ export interface DriverInfo {
   apiBilled: false;
   /** The live driver's wall-clock budget per authoring turn (build and iterate), ms. */
   authorTimeoutMs?: number;
+  /** The live driver's turn cap per authoring turn, by card tier (`--author-max-turns` sets every tier alike). */
+  authorMaxTurns?: Record<ScenarioTier, number>;
+  /** The live driver's turn cap per question or operation turn. */
+  askMaxTurns?: number;
 }
 
 export interface AgentDriver {
@@ -121,13 +128,29 @@ export function assertSubscriptionLogin(env: NodeJS.ProcessEnv, authStatus: unkn
  */
 export const DEFAULT_AUTHOR_TIMEOUT_MIN = 60;
 
+/**
+ * The agentic turns one authoring turn (build or iterate) may take unless
+ * `--author-max-turns` says otherwise, by the card's tier. A `control` card's
+ * 2–3-object build finished in 17–21 turns under the old flat cap of 80, which
+ * stays. Every `starter` build measured hit that 80 (`error_max_turns`) after
+ * 15–24 minutes, 11–18 s a turn: the 60-minute author timeout holds 200–325
+ * such turns, so 300 puts the turn cap and the wall clock at about the same
+ * point. A `delivery` card (none in the library yet) gets twice that; at the
+ * same pace 600 turns outlast the default timeout, so its run raises
+ * `--author-timeout` too, or the clock ends the turn first.
+ */
+export const DEFAULT_AUTHOR_MAX_TURNS: Readonly<Record<ScenarioTier, number>> = { control: 80, starter: 300, delivery: 600 };
+
+/** The agentic turns one question or operation turn may take unless `--ask-max-turns` says otherwise, every tier alike. */
+export const DEFAULT_ASK_MAX_TURNS = 12;
+
 export interface ClaudeCodeDriverOptions {
   /** The CLI binary; default `claude`. */
   bin?: string;
-  /** Agentic turns allowed for one question or operation; default 12. */
-  maxTurnsAsk?: number;
-  /** Agentic turns allowed for one authoring task; default 80. */
-  maxTurnsAuthor?: number;
+  /** Agentic turns allowed for one question or operation; default {@link DEFAULT_ASK_MAX_TURNS}. */
+  askMaxTurns?: number;
+  /** Agentic turns allowed for one authoring task, every tier alike; default by the card's tier, {@link DEFAULT_AUTHOR_MAX_TURNS}. */
+  authorMaxTurns?: number;
   /** Wall-clock budget per authoring turn (build and iterate), ms; default {@link DEFAULT_AUTHOR_TIMEOUT_MIN}. */
   authorTimeoutMs?: number;
   /** Wall-clock budget per question or operation, ms; default 5 min. */
@@ -266,8 +289,24 @@ export class ClaudeCodeDriver implements AgentDriver {
     return this.opts.authorTimeoutMs ?? DEFAULT_AUTHOR_TIMEOUT_MIN * 60_000;
   }
 
+  private authorMaxTurns(tier: ScenarioTier): number {
+    return this.opts.authorMaxTurns ?? DEFAULT_AUTHOR_MAX_TURNS[tier];
+  }
+
+  private get askMaxTurns(): number {
+    return this.opts.askMaxTurns ?? DEFAULT_ASK_MAX_TURNS;
+  }
+
   info(): DriverInfo {
-    return { driver: 'claude-code-cli', version: this.version, authMethod: this.authMethod, apiBilled: false, authorTimeoutMs: this.authorTimeoutMs };
+    return {
+      driver: 'claude-code-cli',
+      version: this.version,
+      authMethod: this.authMethod,
+      apiBilled: false,
+      authorTimeoutMs: this.authorTimeoutMs,
+      authorMaxTurns: Object.fromEntries(SCENARIO_TIERS.map((t) => [t, this.authorMaxTurns(t)])) as Record<ScenarioTier, number>,
+      askMaxTurns: this.askMaxTurns,
+    };
   }
 
   private base(maxTurns: number): string[] {
@@ -280,16 +319,17 @@ export class ClaudeCodeDriver implements AgentDriver {
     const empty = join(mkdtempSync(join(tmpdir(), 'scenario-mcp-')), 'none.json');
     writeFileSync(empty, JSON.stringify({ mcpServers: {} }));
     try {
+      const maxTurns = this.authorMaxTurns(task.tier);
       const args = [
         '-p',
-        ...this.base(this.opts.maxTurnsAuthor ?? 80),
+        ...this.base(maxTurns),
         '--mcp-config', empty, '--strict-mcp-config',
         '--permission-mode', 'acceptEdits',
         '--allowedTools', 'Bash', 'Read', 'Edit', 'Write', 'Glob', 'Grep', 'Skill',
       ];
       const run = await runCli(this.bin, args, task.cwd, task.prompt, this.authorTimeoutMs);
       const turn = parseStreamJson(run.stdout);
-      turn.meta.process = run.process;
+      turn.meta.process = { ...run.process, maxTurns };
       if (turn.meta.resultSubtype === undefined) turn.meta.resultSubtype = noResult(run.process);
       return { turn, files: snapshotSources(task.cwd) };
     } finally {
@@ -308,10 +348,11 @@ export class ClaudeCodeDriver implements AgentDriver {
       { mode: 0o600 },
     );
     try {
-      const args = ['-p', ...this.base(this.opts.maxTurnsAsk ?? 12), '--mcp-config', cfg, '--strict-mcp-config', '--allowedTools', 'mcp__app'];
+      const maxTurns = this.askMaxTurns;
+      const args = ['-p', ...this.base(maxTurns), '--mcp-config', cfg, '--strict-mcp-config', '--allowedTools', 'mcp__app'];
       const run = await runCli(this.bin, args, dir, task.prompt, this.opts.askTimeoutMs ?? 5 * 60_000);
       const turn = parseStreamJson(run.stdout);
-      turn.meta.process = run.process;
+      turn.meta.process = { ...run.process, maxTurns };
       if (turn.meta.resultSubtype === undefined) turn.meta.resultSubtype = noResult(run.process);
       return turn;
     } finally {
 
@@ -91,6 +91,8 @@ export interface TurnSummary {
   /** The result line said `is_error: true` (a usage limit answers `success` with it). */
   isError?: true;
   numTurns?: number;
+  /** The turn cap the CLI process ran under (`meta.process`): `numTurns` of `maxTurns`. */
+  maxTurns?: number;
   toolCalls: number;
   model?: string;
   /** Wall-clock time of the CLI process, when the driver ran one (`meta.process`). */
@@ -198,6 +200,7 @@ const summarize = (t: ParsedTurn): TurnSummary => {
     ...(t.meta.resultSubtype ? { resultSubtype: t.meta.resultSubtype } : {}),
     ...(t.meta.isError === true ? { isError: true as const } : {}),
     ...(t.meta.numTurns !== undefined ? { numTurns: t.meta.numTurns } : {}),
+    ...(p?.maxTurns !== undefined ? { maxTurns: p.maxTurns } : {}),
     ...(t.meta.model ? { model: t.meta.model } : {}),
     toolCalls: t.toolCalls.length,
     ...(p ? { elapsedMs: p.elapsedMs } : {}),
@@ -705,14 +708,14 @@ async function scratchMode(original: LoadedScenario, driver: AgentDriver, ops: P
   const labels = citationLabels(original);
   const card = scenario.card;
   const ref = { card: card.id, mode: 'scratch' as const };
-  mode.build = await buildHalf(scenario, dir, ops, async () => (await driver.author({ ...ref, phase: 'build', step: 'author', cwd: dir, prompt: buildPrompt(card) })).turn, scenario);
+  mode.build = await buildHalf(scenario, dir, ops, async () => (await driver.author({ ...ref, phase: 'build', step: 'author', cwd: dir, prompt: buildPrompt(card), tier: card.tier })).turn, scenario);
   // A build whose authoring turn did not finish is not measured: no seed, no Run, no iterate on it.
   if (mode.build.notMeasured) return { mode };
   const builtArtifact = ops.readArtifact(dir);
   if (builtArtifact !== undefined) mode.run = await withApp(ops, dir, mode.findings, (app) => runHalf(scenario, app, driver, { ...ref, phase: 'run' }, labels, builtArtifact));
 
   const iterated = iteratedScenario(scenario);
-  const build = await buildHalf(iterated, dir, ops, async () => (await driver.author({ ...ref, phase: 'iterate', step: 'author', cwd: dir, prompt: iteratePrompt(card) })).turn, iterated);
+  const build = await buildHalf(iterated, dir, ops, async () => (await driver.author({ ...ref, phase: 'iterate', step: 'author', cwd: dir, prompt: iteratePrompt(card), tier: card.tier })).turn, iterated);
   if (build.notMeasured) {
     mode.iterate = { build };
     return { mode, ...(buildPassed(mode.build) ? { verified: builtArtifact } : {}) };
@@ -767,7 +770,7 @@ async function templateMode(original: LoadedScenario, driver: AgentDriver, ops:
     }
     const before = await app.metadataAsArtifact(collections);
     const build: BuildHalf = { commands: [], score: null };
-    await authorInto(build, async () => (await driver.author({ card: card.id, mode: 'template', phase: 'iterate', step: 'author', cwd: dir, prompt: templateIteratePrompt(card, { baseUrl: booted.url, adminEmail: opts.admin.email, adminPassword: opts.admin.password }) })).turn);
+    await authorInto(build, async () => (await driver.author({ card: card.id, mode: 'template', phase: 'iterate', step: 'author', cwd: dir, prompt: templateIteratePrompt(card, { baseUrl: booted.url, adminEmail: opts.admin.email, adminPassword: opts.admin.password }), tier: card.tier })).turn);
     if (build.notMeasured) {
       mode.iterate = { build };
       return;