lynkeus 0.4.0 → 0.5.0

package/src/commands/device.ts

@@ -76,8 +76,26 @@ export const simulatorArgv = (platform: Platform, deviceId: string, sub: string,
           { bin: 'xcrun', args: ['simctl', 'launch', deviceId, app, '-AppleLanguages', `(${tag})`, '-AppleLocale', locale] },
         ];
       }
+      case 'biometrics': {
+        // The simulator's Face ID / Touch ID enrollment, as Features ▸ Face ID ▸ Enrolled toggles it; which of the two
+        // the device has is its model's.
+        const [available] = args;
+        if (!available) throw new Error('lynkeus os biometrics --available FaceID|TouchID|none on a simulator');
+        const enrolled = available === 'none' ? '0' : '1';
+        return [
+          { bin: 'xcrun', args: ['simctl', 'spawn', deviceId, 'notifyutil', '-s', 'com.apple.BiometricKit.enrollmentChanged', enrolled] },
+          { bin: 'xcrun', args: ['simctl', 'spawn', deviceId, 'notifyutil', '-p', 'com.apple.BiometricKit.enrollmentChanged'] },
+        ];
+      }
+      case 'appstate': {
+        // Another app in front puts this one in the background; launching it again brings it back as it was.
+        const [state] = args;
+        if (state === 'background') return [{ bin: 'xcrun', args: ['simctl', 'launch', deviceId, 'com.apple.Preferences'] }];
+        if (state === 'active') return [{ bin: 'xcrun', args: ['simctl', 'launch', deviceId, needApp()] }];
+        throw new Error('lynkeus os appstate background|active on a simulator');
+      }
       default:
-        throw new Error(`unknown os subcommand "${sub}"; one of permissions, push, appearance, location, language`);
+        throw new Error(`unknown os subcommand "${sub}"; one of permissions, push, appearance, location, language, appstate`);
     }
   }
   const adb = (a: string[]): Invocation => ({ bin: 'adb', args: ['-s', deviceId, ...a] });
@@ -99,8 +117,15 @@ export const simulatorArgv = (platform: Platform, deviceId: string, sub: string,
       const [lat, lon] = where.split(',');
       return [adb(['emu', 'geo', 'fix', lon!, lat!])];
     }
+    case 'appstate': {
+      // Home sends the app to the background; its launcher intent brings the same task back, not a new one.
+      const [state] = args;
+      if (state === 'background') return [adb(['shell', 'input', 'keyevent', 'KEYCODE_HOME'])];
+      if (state === 'active') return [adb(['shell', 'monkey', '--pct-syskeys', '0', '-p', needApp(), '-c', 'android.intent.category.LAUNCHER', '1'])];
+      throw new Error('lynkeus os appstate background|active on an emulator or a phone');
+    }
     default:
-      throw new Error(`"${sub}" is not available on Android through lynkeus; permissions, appearance and location are`);
+      throw new Error(`"${sub}" is not available on Android through lynkeus; permissions, appearance, location and appstate are`);
   }
 };
 

package/src/commands/drive.ts

@@ -166,7 +166,7 @@ export const driveCommands = [
   define({
     name: 'wait',
     mcp: 'core',
-    mcpOmit: ['nth'],
+    mcpOmit: ['nth', 'since'],
     group: 'drive',
     summary: 'Until a route or element appears (or leaves), or a number of ms',
     positionals: [{ name: 'what', help: `Route | route:index | ${TARGET_HELP} | 800 (ms)`, required: true }],
@@ -175,6 +175,7 @@ export const driveCommands = [
       gone: { type: 'boolean', help: 'until it leaves the screen' },
       scroll: { type: 'boolean', help: 'scroll until it is in the window' },
       timeout: { type: 'number', help: 'give up after', default: 10000, value: 'ms' },
+      since: { type: 'number', help: 'a trace mark: a route reached after it counts, even if already left', value: 'seq' },
     },
     needs: 'app',
     run: async (ctx) => {
@@ -189,6 +190,7 @@ export const driveCommands = [
           gone: ctx.flags.gone ? true : undefined,
           scroll: ctx.flags.scroll ? true : undefined,
           timeoutMs: ctx.flags.timeout as number,
+          since: ctx.flags.since as number | undefined,
         }),
       };
     },

package/src/commands/fixtures.ts

@@ -0,0 +1,102 @@
+import { FIXTURES_PROTOCOL, type FixtureCommand } from 'lynkeus-protocol';
+
+import { DESCRIBE, type Description, Fixtures, lastDescription, readDescription } from '../cases/fixtures.js';
+import { define } from '../registry.js';
+
+const paramsOf = (c: FixtureCommand) =>
+  Object.entries(c.params ?? {})
+    .map(([k, p]) => `${k}${p.required ? '' : '?'}${p.values ? `=${p.values.join('|')}` : p.type ? `:${p.type}` : ''}`)
+    .join(' ');
+
+/** What a server keeps of the contract and what it leaves out, as lines a person can act on. */
+export const checkDescription = (d: Description | undefined): { ok: boolean; lines: string[] } => {
+  if (!d) return { ok: false, lines: ['✗ `lynkeus.describe` got no list of commands: answer {"commands": [...]} (docs/FIXTURES.md)'] };
+  const lines: string[] = [];
+  let ok = true;
+  if (d.down) {
+    ok = false;
+    lines.push(`✗ the server runs but cannot serve: ${d.down}`);
+  }
+  if (d.protocol !== undefined && d.protocol > FIXTURES_PROTOCOL) {
+    ok = false;
+    lines.push(`✗ it speaks fixtures protocol ${d.protocol}; this lynkeus knows ${FIXTURES_PROTOCOL}`);
+  }
+  const names = new Set<string>();
+  for (const c of d.details) {
+    if (names.has(c.name)) {
+      ok = false;
+      lines.push(`✗ ${c.name} is listed twice`);
+    }
+    names.add(c.name);
+  }
+  const bare = d.details.filter((c) => !c.summary);
+  lines.push(`✓ ${d.commands.length} command${d.commands.length === 1 ? '' : 's'}`);
+  if (bare.length)
+    lines.push(
+      `· ${bare.length} without a summary (${bare
+        .slice(0, 6)
+        .map((c) => c.name)
+        .join(', ')}${bare.length > 6 ? ', …' : ''}): a summary and params let authors and models pick a setup`,
+    );
+  return { ok, lines };
+};
+
+export const fixturesCommands = [
+  define({
+    name: 'fixtures describe',
+    group: 'runs',
+    summary: 'List what the project’s fixtures server can do: each command, what it makes or reads, its parameters',
+    details:
+      'Starts the command `cases.fixtures` names, asks `lynkeus.describe`, and prints each command with its summary and parameters, for whoever writes a case. A server that answers names only shows names. What it answered last (here or before a run) is kept in .lynkeus and shown for a day without starting it; --fresh asks again.',
+    flags: { fresh: { type: 'boolean', help: 'ask the server even when it described itself in the last day' } },
+    needs: 'nothing',
+    session: false,
+    mcp: 'core',
+    run: async (ctx) => {
+      const config = ctx.config.cases ?? {};
+      if (!config.fixtures) return { text: 'the project declares no fixtures (cases.fixtures in lynkeus.config.json)', code: 1 };
+      const root = config.base ?? ctx.root;
+      const kept = ctx.flags.fresh ? undefined : lastDescription(root, config.fixtures.command);
+      const recent = kept && Date.now() - kept.at < 24 * 3600_000 ? kept : undefined;
+      let d = recent?.description;
+      if (!d) {
+        const server = new Fixtures(config.fixtures, root);
+        d = await server.describe().finally(() => server.close());
+      }
+      if (!d) return { text: 'the fixtures server did not describe itself (it answers `lynkeus.describe` with {"commands": [...]})', code: 1 };
+      const text = d.details.map((c) => `${c.name}${c.params ? ` ${paramsOf(c)}` : ''}${c.summary ? `\n    ${c.summary}` : ''}`).join('\n');
+      const age = recent ? `\n(as the server described itself ${Math.round((Date.now() - recent.at) / 60_000)} min ago; --fresh asks it again)` : '';
+      return { text: d.down ? `${text}\n(the server cannot serve now: ${d.down})` : `${text}${age}`, json: d };
+    },
+  }),
+  define({
+    name: 'fixtures check',
+    group: 'runs',
+    summary: 'Tell whether the project’s fixtures server keeps the fixtures protocol',
+    details:
+      'Starts the server, asks `lynkeus.describe`, and checks the answer against the contract in docs/FIXTURES.md: a list of commands, no name twice, a protocol version this lynkeus knows, and whether it is up. It changes nothing in the backend.',
+    needs: 'nothing',
+    session: false,
+    mcp: 'core',
+    run: async (ctx) => {
+      const config = ctx.config.cases ?? {};
+      if (!config.fixtures) return { text: 'the project declares no fixtures (cases.fixtures in lynkeus.config.json)', code: 1 };
+      const server = new Fixtures(config.fixtures, config.base ?? ctx.root);
+      // Its own call, not describe(): a server that never answers is told apart from one that answers wrong.
+      const answered = await server.call(DESCRIBE, {}).then(
+        (answer) => ({ answer }),
+        (error: Error) => ({ error: error.message }),
+      );
+      server.close();
+      if ('error' in answered)
+        return {
+          text: `✗ the fixtures server gave no answer to lynkeus.describe: ${answered.error}\n  (is its backend up? the command is \`${config.fixtures.command}\`)`,
+          json: { ok: false, error: answered.error },
+          code: 1,
+        };
+      const d = readDescription(answered.answer);
+      const { ok, lines } = checkDescription(d);
+      return { text: lines.join('\n'), json: { ok, description: d }, code: ok ? 0 : 1 };
+    },
+  }),
+];

package/src/commands/headless.ts

@@ -1,5 +1,7 @@
 import { spawn } from 'node:child_process';
+import { createHash } from 'node:crypto';
 import fs from 'node:fs';
+import { createRequire } from 'node:module';
 import path from 'node:path';
 
 import { type LynkeusConfig, lynkeusDir, portFromEnv, readToken } from '../config.js';
@@ -36,6 +38,18 @@ const JEST_CONFIGS = ['jest.config.js', 'jest.config.cjs', 'jest.config.mjs', 'j
 // React Native and most of what an app adds to it ship untranspiled ES modules, which jest leaves alone unless told.
 const apiFromConfig = (config: LynkeusConfig): Record<string, string> => (config.apiUrl ? { [config.apiEnv ?? 'API_URL']: config.apiUrl } : {});
 
+/**
+ * A jest cache of its own for each API base. Babel inlines `process.env` into the code it transforms and jest
+ * keeps that output, so a host started with another API address kept calling the first one it was started with.
+ */
+export const cacheFor = (root: string, env: Record<string, string | undefined>, apiEnv = 'API_URL'): string => {
+  const key = createHash('sha256')
+    .update(`${apiEnv}=${env[apiEnv] ?? ''}`)
+    .digest('hex')
+    .slice(0, 12);
+  return path.join(lynkeusDir(root), 'jest-cache', key);
+};
+
 const TRANSFORM_PACKAGES =
   '((jest-)?react-native[^/]*|@react-native[^/]*|@react-navigation|react-navigation|expo(nent)?|@expo(nent)?/.*|expo-.*|@unimodules|unimodules|@shopify|@gorhom|@sentry/react-native|lynkeus-[^/]+|yoga-layout|@testing-library|immer|@reduxjs/toolkit|react-redux|redux|reselect|@expo-google-fonts|native-base|standard-navigation)';
 
@@ -65,6 +79,21 @@ const aliasesOf = (root: string): Record<string, string> => {
  * What jest is told when the app has not said it itself, so an app with no jest set up runs headless as it is:
  * the preset its framework needs (jest-expo for Expo, React Native's otherwise), and which packages under node_modules to transpile.
  */
+/** The app's react folder, when lynkeus-headless would load another copy; undefined when they are one. */
+export const duplicateReact = (root: string): string | undefined => {
+  const require = createRequire(import.meta.url);
+  try {
+    // Its exports leave out package.json: from its entry up to the folder that holds one.
+    let headless = path.dirname(fs.realpathSync(require.resolve('lynkeus-headless', { paths: [root] })));
+    while (!fs.existsSync(path.join(headless, 'package.json')) && path.dirname(headless) !== headless) headless = path.dirname(headless);
+    const ours = path.dirname(require.resolve('react/package.json', { paths: [root] }));
+    const theirs = path.dirname(require.resolve('react/package.json', { paths: [headless] }));
+    return fs.realpathSync(ours) === fs.realpathSync(theirs) ? undefined : ours;
+  } catch {
+    return undefined;
+  }
+};
+
 const jestDefaults = (root: string): string[] => {
   const file = JEST_CONFIGS.find((f) => fs.existsSync(path.join(root, f)));
   let config = file ? fs.readFileSync(path.join(root, file), 'utf8') : '';
@@ -75,13 +104,23 @@ const jestDefaults = (root: string): string[] => {
     } catch {}
   }
   const flags: string[] = [];
+  const react = duplicateReact(root);
+  // lynkeus-headless with a React of its own (a linked package, a workspace, pnpm) breaks every hook: the app and
+  // the renderer must share the app's copy.
+  const sameReact = react ? { '^react$': react, '^react/(.*)$': `${react}/$1` } : {};
   if (!config) {
     // A style sheet imported from native code (Expo's templates import global.css) means nothing to jest, even
     // behind an alias, so it is mapped first. Jest merges these with the preset's own mappings.
     const stub = path.join(lynkeusDir(root), 'style-stub.js');
     fs.mkdirSync(path.dirname(stub), { recursive: true });
     fs.writeFileSync(stub, 'module.exports = {};\n');
-    flags.push('--preset', jestPreset(root), `--moduleNameMapper=${JSON.stringify({ '\\.(css|less|sass|scss)$': stub, ...aliasesOf(root) })}`);
+    flags.push('--preset', jestPreset(root), `--moduleNameMapper=${JSON.stringify({ '\\.(css|less|sass|scss)$': stub, ...aliasesOf(root), ...sameReact })}`);
+  } else if (react) {
+    if (config.includes('moduleNameMapper'))
+      process.stderr.write(
+        `lynkeus: lynkeus-headless finds another copy of react than the app's; add to moduleNameMapper in the app's jest config: '^react$': '${react}', '^react/(.*)$': '${react}/$1'\n`,
+      );
+    else flags.push(`--moduleNameMapper=${JSON.stringify(sameReact)}`);
   }
   // Two that must stay as they are, as jest-expo leaves them: babel running itself, or Reanimated's plugin, fails.
   if (!config.includes('transformIgnorePatterns'))
@@ -190,17 +229,41 @@ export const headlessCommands = [
       fs.writeFileSync(testFile, hostTest(rel.startsWith('.') ? rel : `./${rel}`, port, ctx.config, path.basename(ctx.root)));
       // Node resolves `localhost` to ::1 first; local backends usually listen on IPv4 only.
       const nodeOptions = [process.env.NODE_OPTIONS, '--dns-result-order=ipv4first'].filter(Boolean).join(' ');
-      const child = spawn('npx', ['jest', testFile, '--runInBand', '--watchAll=false', ...jestDefaults(ctx.root), ...ctx.passthrough], {
+      // LYNKEUS_HEADLESS tells the app's jest setup a host is starting, not its unit tests: a setup that stubs a native
+      // SDK whole can leave it real there, so the call reaches the stand-in `nativeMocks` shows.
+      const env = { ...apiFromConfig(ctx.config), ...process.env, LYNKEUS_TOKEN: token, LYNKEUS_HEADLESS: '1', CI: '1', NODE_OPTIONS: nodeOptions };
+      const cache = `--cacheDirectory=${cacheFor(ctx.root, env, ctx.config.apiEnv)}`;
+      const child = spawn('npx', ['jest', testFile, '--runInBand', '--watchAll=false', ...jestDefaults(ctx.root), cache, ...ctx.passthrough], {
         cwd: ctx.root,
         stdio: ['inherit', 'inherit', 'pipe'],
-        env: { ...apiFromConfig(ctx.config), ...process.env, LYNKEUS_TOKEN: token, CI: '1', NODE_OPTIONS: nodeOptions },
+        env,
+        // Its own process group: npx, jest and the host it runs end together. Stopping only npx left the
+        // host dialing the port, where a later run's driver took it for the app it meant to drive.
+        detached: true,
+      });
+      const stop = (signal: NodeJS.Signals) => {
+        try {
+          if (child.pid) process.kill(-child.pid, signal);
+        } catch {
+          // already gone
+        }
+      };
+      const signals: NodeJS.Signals[] = ['SIGINT', 'SIGTERM', 'SIGHUP'];
+      const forward = signals.map((signal) => {
+        const handler = () => stop(signal);
+        process.on(signal, handler);
+        return () => process.off(signal, handler);
       });
+      const onExit = () => stop('SIGTERM');
+      process.on('exit', onExit);
       let tail = '';
       child.stderr?.on('data', (chunk: Buffer) => {
         process.stderr.write(chunk);
         tail = (tail + chunk.toString()).slice(-20000);
       });
       const code = await new Promise<number>((resolve) => child.on('exit', (c) => resolve(c ?? 0)));
+      for (const off of forward) off();
+      process.off('exit', onExit);
       if (code) {
         const found = explainError(tail);
         if (found.length) ctx.err(describeExplanations(found));

package/src/commands/map.ts

@@ -30,6 +30,25 @@ const describeAffected = (affected: Affected[], chain: boolean): string[] => {
   return lines;
 };
 
+/** Source files a branch changed against `base`, committed or not. */
+export const changedSources = (root: string, base: string, err: (line: string) => void): string[] => {
+  const git = (...args: string[]) => execFileSync('git', args, { cwd: root, encoding: 'utf8' });
+  try {
+    const names = `${git('diff', '--name-only', `${base}...HEAD`)}\n${git('diff', '--name-only', 'HEAD')}`;
+    return [
+      ...new Set(
+        names
+          .split('\n')
+          .map((l) => l.trim())
+          .filter((l) => /\.[cm]?[jt]sx?$/.test(l)),
+      ),
+    ];
+  } catch (error) {
+    err(`could not diff against ${base}: ${error instanceof Error ? error.message : String(error)}`);
+    return [];
+  }
+};
+
 export const mapCommands = [
   define({
     name: 'map build',
@@ -215,21 +234,7 @@ export const mapCommands = [
     run: async (ctx) => {
       const graph = ctx.graph();
       const base = ctx.flags.base as string;
-      const git = (...args: string[]) => execFileSync('git', args, { cwd: ctx.root, encoding: 'utf8' });
-      let changed: string[] = [];
-      try {
-        const names = `${git('diff', '--name-only', `${base}...HEAD`)}\n${git('diff', '--name-only', 'HEAD')}`;
-        changed = [
-          ...new Set(
-            names
-              .split('\n')
-              .map((l) => l.trim())
-              .filter((l) => /\.[cm]?[jt]sx?$/.test(l)),
-          ),
-        ];
-      } catch (error) {
-        ctx.err(`could not diff against ${base}: ${error instanceof Error ? error.message : String(error)}`);
-      }
+      const changed = changedSources(ctx.root, base, ctx.err);
       const affected = screensAffectedBy(graph, changed, ctx.flags.depth as number);
       const lines = [`changed against ${base}: ${changed.length} source file(s)`, ...describeAffected(affected, true)];
       if (!affected.length && changed.length) lines.push('  (no screen imports these files within the depth)');

package/src/commands/os.ts

@@ -35,11 +35,25 @@ export const osCommands = [
   define({
     name: 'os appstate',
     group: 'os',
-    summary: 'Headless: AppState listeners see the change (background, then active: what refetches or re-locks)',
-    positionals: [{ name: 'state', help: 'active | background | inactive', required: true }],
+    summary:
+      'AppState listeners see the change (background, then active: what refetches or re-locks); a host answers it, a simulator or an emulator does it for real',
+    positionals: [{ name: 'state', help: 'active | background | inactive (inactive: a host only)', required: true }],
+    flags: { app: { type: 'string', help: 'the app to bring back on a simulator or emulator (default: the config’s app)', value: 'bundleId' } },
     aliases: ['appstate'],
     needs: 'app',
-    run: agent('appstate', (ctx) => ({ state: ctx.args[0] })),
+    run: async (ctx) => {
+      const device = await ctx.device();
+      try {
+        return { json: await device.command('appstate', { state: ctx.args[0] }) };
+      } catch (error) {
+        // A host stands in for the OS; on a simulator or an emulator the OS itself moves the app.
+        if ((await device.resolved()).id === 'headless') throw error;
+        const done = await simulator('appstate')(ctx);
+        // Back in front, the app dials in again; what comes next reads its screen.
+        if (ctx.args[0] === 'active') await device.server.waitForApp(15_000);
+        return done;
+      }
+    },
   }),
   define({
     name: 'os network',
@@ -66,7 +80,7 @@ export const osCommands = [
   define({
     name: 'os biometrics',
     group: 'os',
-    summary: 'Headless: the sensor and what the next prompts answer',
+    summary: 'The sensor and what the next prompts answer; on a simulator, --available enrolls Face ID or Touch ID or not',
     flags: {
       available: { type: 'string', help: 'FaceID | TouchID | none', value: 'kind' },
       next: { type: 'string', help: 'outcomes of the next prompts, in order', value: 'success,fail,cancel' },
@@ -74,11 +88,25 @@ export const osCommands = [
     },
     aliases: ['biometrics'],
     needs: 'app',
-    run: agent('biometrics', ({ flags }) => ({
-      available: flags.available || undefined,
-      next: flags.next ? (flags.next as string).split(',') : undefined,
-      fallback: flags.fallback || undefined,
-    })),
+    run: async (ctx) => {
+      const device = await ctx.device();
+      const params = {
+        available: ctx.flags.available || undefined,
+        next: ctx.flags.next ? (ctx.flags.next as string).split(',') : undefined,
+        fallback: ctx.flags.fallback || undefined,
+      };
+      try {
+        return { json: await device.command('biometrics', params) };
+      } catch (error) {
+        const info = await device.resolved();
+        if (info.id === 'headless') throw error;
+        // A device's prompts answer the person in front of it: only a simulator's enrollment is set from outside.
+        // Anything else stays the host's, and the runner says the step cannot run here.
+        if (info.platform !== 'ios' || !params.available || params.next || params.fallback) throw error;
+        ctx.args = [String(params.available)];
+        return simulator('biometrics')(ctx);
+      }
+    },
   }),
   define({
     name: 'os scan',
@@ -107,7 +135,7 @@ export const osCommands = [
   define({
     name: 'mock',
     group: 'os',
-    summary: 'Headless: answer a request before the network (--sticky survives a reset)',
+    summary: 'Answer a request before the network: a host stands in for it, on a device the agent answers in the app (--sticky survives a host reset)',
     positionals: [{ name: 'route', help: "'GET /path' (a bare path matches any method)" }],
     flags: {
       status: { type: 'number', help: 'HTTP status to answer', default: 200, value: 'code' },

package/src/commands/report.ts

@@ -2,6 +2,8 @@ import fs from 'node:fs';
 import path from 'node:path';
 
 import { define } from '../registry.js';
+import { ageOf, megabytes, pruneRuns } from '../cases/runDirs.js';
+import { keptOrDeleted } from './cases.js';
 
 type Fetch = typeof fetch;
 
@@ -22,11 +24,54 @@ const answer = async (response: Response, doing: string) => {
   throw new Error(`${doing}: ${body.error ?? `the service answered ${response.status}`}`);
 };
 
+const UPLOADS_AT_ONCE = 4;
+const CASES_PART = 256 * 1024;
+const UPLOAD_ATTEMPTS = 3;
+
+// A ustar header holds a name of up to 100 bytes and a folder of up to 155 before it.
+const fitsTar = (file: string) => {
+  const cut = file.lastIndexOf('/');
+  return Buffer.byteLength(file.slice(cut + 1)) <= 100 && Buffer.byteLength(cut > 0 ? file.slice(0, cut) : '') <= 155;
+};
+
+/** An uncompressed tar: frames are PNG or AVIF, already compressed, and a tar is read as it arrives. */
+export const tarOf = (entries: [string, Uint8Array][]): Uint8Array => {
+  const blocks: Uint8Array[] = [];
+  for (const [file, data] of entries) {
+    const header = Buffer.alloc(512);
+    const cut = file.lastIndexOf('/');
+    header.write(file.slice(cut + 1), 0, 'utf8');
+    header.write('0000644\0', 100);
+    header.write('0000000\0', 108);
+    header.write('0000000\0', 116);
+    header.write(`${data.length.toString(8).padStart(11, '0')}\0`, 124);
+    header.write(
+      `${Math.floor(Date.now() / 1000)
+        .toString(8)
+        .padStart(11, '0')}\0`,
+      136,
+    );
+    header.write('0', 156);
+    header.write('ustar\0', 257);
+    header.write('00', 263);
+    if (cut > 0) header.write(file.slice(0, cut), 345, 'utf8');
+    header.fill(' ', 148, 156);
+    const sum = header.reduce((n, b) => n + b, 0);
+    header.write(`${sum.toString(8).padStart(6, '0')}\0 `, 148);
+    blocks.push(header, data, Buffer.alloc((512 - (data.length % 512)) % 512));
+  }
+  blocks.push(Buffer.alloc(1024));
+  return Buffer.concat(blocks);
+};
+
 /**
  * Uploads a run directory (`case run --out`) to the reports service: the run, its cases, then every frame and
  * film the cases name. A file the organization's plan does not keep (a film on Free) is left out and listed.
  */
-export const pushRun = async (dir: string, o: { url: string; key: string; project: string; fetch?: Fetch }): Promise<Pushed> => {
+export const pushRun = async (
+  dir: string,
+  o: { url: string; key: string; project: string; fetch?: Fetch; onReady?: (url: string) => void; onProgress?: (line: string) => void },
+): Promise<Pushed> => {
   const call = o.fetch ?? fetch;
   const auth = { authorization: `Bearer ${o.key}` };
   const base = o.url.replace(/\/+$/, '');
@@ -42,31 +87,98 @@ export const pushRun = async (dir: string, o: { url: string; key: string; projec
     'creating the run',
   );
   const id = String(created.id);
-  await answer(await call(`${base}/v1/runs/${id}/cases`, { method: 'PUT', headers: auth, body: cases }), 'sending its cases');
+  // A dropped connection, a 5xx or a 429 is tried again, waiting longer each time.
+  const sendWithRetries = async (target: string, body: Uint8Array, doing: string): Promise<Response> => {
+    for (let attempt = 1; ; attempt++) {
+      const response = await call(target, { method: 'PUT', headers: auth, body }).catch((error: unknown) => {
+        if (attempt >= UPLOAD_ATTEMPTS) throw new Error(`${doing}: ${error instanceof Error ? error.message : String(error)}`);
+        return undefined;
+      });
+      if (response && ((response.status < 500 && response.status !== 429) || attempt >= UPLOAD_ATTEMPTS)) return response;
+      await new Promise((resolve) => setTimeout(resolve, 500 * 2 ** (attempt - 1)));
+    }
+  };
+  // The run file in parts of about 256 KB: with every request's headers and bodies it runs to megabytes, more
+  // than the service reads in one request. A service from before parts answers without `part`, and then
+  // takes the whole file in one.
+  const parts: string[] = [];
+  for (const line of cases.split('\n').filter((l) => l.trim())) {
+    const last = parts.length - 1;
+    if (last >= 0 && Buffer.byteLength(parts[last]!) + Buffer.byteLength(line) < CASES_PART) parts[last] += `\n${line}`;
+    else parts.push(line);
+  }
+  for (const [n, part] of parts.entries()) {
+    const sent = await answer(await sendWithRetries(`${base}/v1/runs/${id}/cases?part=${n}`, Buffer.from(part), 'sending its cases'), 'sending its cases');
+    if (sent.part === undefined) {
+      await answer(await call(`${base}/v1/runs/${id}/cases`, { method: 'PUT', headers: auth, body: cases }), 'sending its cases');
+      break;
+    }
+  }
+  // The report opens as soon as its cases are in: their steps, results and requests show at once, and each
+  // frame as it arrives.
+  const finished = await answer(await call(`${base}/v1/runs/${id}/finish`, { method: 'POST', headers: auth }), 'finishing the run');
+  o.onReady?.(String(finished.url));
 
-  const named = new Set<string>();
+  // Per case: its frames, sent as one tar, and its film, sent on its own (a film can be bigger than a request).
+  const work: { frames: string[]; film?: string }[] = [];
   for (const line of cases.split('\n')) {
     if (!line.trim()) continue;
     const c = JSON.parse(line) as { video?: string; steps?: { screenshot?: string }[] };
-    for (const p of [c.video, ...(c.steps ?? []).map((s) => s.screenshot)]) if (p) named.add(p);
+    const frames = (c.steps ?? []).map((s) => s.screenshot).filter((p): p is string => !!p && fs.existsSync(path.join(dir, p)));
+    const film = c.video && fs.existsSync(path.join(dir, c.video)) ? c.video : undefined;
+    work.push({ frames: [...new Set(frames)], ...(film ? { film } : {}) });
   }
   let files = 0;
   const refused: string[] = [];
-  for (const file of named) {
-    const local = path.join(dir, file);
-    if (!fs.existsSync(local)) continue;
-    const response = await call(`${base}/v1/runs/${id}/files/${file.split('/').map(encodeURIComponent).join('/')}`, {
-      method: 'PUT',
-      headers: auth,
-      body: fs.readFileSync(local),
-    });
+  const sendFile = async (file: string) => {
+    const target = `${base}/v1/runs/${id}/files/${file.split('/').map(encodeURIComponent).join('/')}`;
+    const response = await sendWithRetries(target, fs.readFileSync(path.join(dir, file)), `sending ${file}`);
     if (response.status === 402) refused.push(file);
     else {
       await answer(response, `sending ${file}`);
       files += 1;
     }
-  }
-  const finished = await answer(await call(`${base}/v1/runs/${id}/finish`, { method: 'POST', headers: auth }), 'finishing the run');
+  };
+  // A suite with screenshots is thousands of frames: a request per frame took one over 20 minutes to send. A
+  // service from before bundles answers 404, and the frames then go one by one, as they used to.
+  let bundles = true;
+  const sendFrames = async (frames: string[]) => {
+    const fits = frames.filter(fitsTar);
+    if (bundles && fits.length > 0) {
+      const response = await sendWithRetries(
+        `${base}/v1/runs/${id}/bundle`,
+        tarOf(fits.map((f) => [f, fs.readFileSync(path.join(dir, f))])),
+        `sending ${fits.length} frames`,
+      );
+      if (response.status === 404 || response.status === 405) bundles = false;
+      else {
+        await answer(response, `sending ${fits.length} frames`);
+        files += fits.length;
+        for (const f of frames.filter((f) => !fitsTar(f))) await sendFile(f);
+        return;
+      }
+    }
+    for (const f of frames) await sendFile(f);
+  };
+  const queue = [...work];
+  const total = work.length;
+  let sent = 0;
+  let bytes = 0;
+  const started = Date.now();
+  const sizeOf = (c: { frames: string[]; film?: string }) =>
+    [...c.frames, ...(c.film ? [c.film] : [])].reduce((n, f) => n + fs.statSync(path.join(dir, f)).size, 0);
+  await Promise.all(
+    Array.from({ length: Math.min(UPLOADS_AT_ONCE, queue.length) }, async () => {
+      for (let c = queue.shift(); c !== undefined; c = queue.shift()) {
+        await sendFrames(c.frames);
+        if (c.film) await sendFile(c.film);
+        sent += 1;
+        bytes += sizeOf(c);
+        if (sent === total || sent % Math.max(1, Math.ceil(total / 10)) === 0)
+          o.onProgress?.(`frames: ${sent}/${total} cases, ${(bytes / 1024 / 1024).toFixed(1)} MB in ${((Date.now() - started) / 1000).toFixed(0)} s`);
+      }
+    }),
+  );
   const changes = finished.changes as Pushed['changes'] | undefined;
   return { url: String(finished.url), files, refused, ...(changes ? { changes } : {}) };
 };
@@ -124,6 +236,34 @@ export const service = (): Service | string => {
 };
 
 export const reportCommands = [
+  define({
+    name: 'report prune',
+    group: 'runs',
+    summary: 'Delete the runs `case run --out` left in a folder that ended more than a while ago',
+    details:
+      'Looks at the folder given, or each folder right under it, and deletes the ones that hold a run (`run.json` and `cases.jsonl`) older than --older. Nothing else is touched. Pushed reports stay on the service; this only frees the disk.',
+    positionals: [{ name: 'dir', help: 'a run folder, or the folder that holds them' }],
+    flags: {
+      older: { type: 'string', help: 'how old a run must be: 7d, 12h, 30m', value: 'age', default: '7d' },
+      'dry-run': { type: 'boolean', help: 'list what would go, delete nothing' },
+    },
+    needs: 'nothing',
+    session: false,
+    mcp: false,
+    run: async (ctx) => {
+      const root = path.resolve(ctx.args[0] ?? '.');
+      if (!fs.existsSync(root)) return { text: `${ctx.args[0]}: no such folder`, code: 2 };
+      const older = ageOf(String(ctx.flags.older ?? '7d'));
+      if (older === undefined) return { text: `--older ${ctx.flags.older}: give it as 7d, 12h or 30m`, code: 2 };
+      const dry = !!ctx.flags['dry-run'];
+      const { removed, bytes } = pruneRuns(root, older, dry);
+      if (removed.length === 0) return { text: 'no run old enough to delete', json: { removed, bytes } };
+      return {
+        text: [...removed.map((d) => `${dry ? 'would delete' : 'deleted'} ${d}`), `${dry ? 'would free' : 'freed'} ${megabytes(bytes)}`].join('\n'),
+        json: { removed, bytes },
+      };
+    },
+  }),
   define({
     name: 'report push',
     group: 'runs',
@@ -145,8 +285,12 @@ export const reportCommands = [
       if (typeof to === 'string') return { text: to, code: 2 };
       const project = typeof ctx.flags.project === 'string' ? ctx.flags.project : path.basename(ctx.root);
       try {
-        const pushed = await pushRun(dir, { ...to, project });
-        const notes = [...describeChanges(pushed.changes), ...(pushed.refused.length ? [`not kept on this plan: ${pushed.refused.join(', ')}`] : [])];
+        const pushed = await pushRun(dir, { ...to, project, onReady: (url) => ctx.err(`report: ${url} (its frames are on their way)`), onProgress: ctx.err });
+        const notes = [
+          ...describeChanges(pushed.changes),
+          ...(pushed.refused.length ? [`not kept on this plan: ${pushed.refused.join(', ')}`] : []),
+          keptOrDeleted(dir, ctx.config.report?.afterPush === 'delete' ? 'delete' : 'keep', pushed.refused.length === 0),
+        ];
         return { text: [pushed.url, ...notes].join('\n'), json: pushed };
       } catch (error) {
         return { text: (error as Error).message, code: 1 };