@asrunjs/asrun 0.11.0 → 0.13.0

package/dist/ui/server/ai-stream.js

@@ -1,10 +1,21 @@
+import { expandEscapedText } from '../shared/log-text.js';
 const MAX_DETAIL = 180;
 const MAX_ERROR = 300;
 const MAX_REASONING = 2000;
-/** A call's output is a preview, not a transcript: the first few lines say what it did without flooding the log. */
-const PREVIEW_LINES = 6;
-const PREVIEW_LINE = 200;
-const PREVIEW_CHARS = 500;
+/** The argument of a call is kept whole, within reason: the log opens it instead of a truncated summary. */
+const MAX_INPUT = 4000;
+/**
+ * An edit carries the snippet it replaces and the one it writes, or the whole content of a small file. Keeping more of
+ * it is what lets the log draw a diff instead of a JSON blob cut in the middle.
+ */
+const MAX_INPUT_EDIT = 20_000;
+/** Tools whose argument is a change to a file (the same family the log draws as a diff). */
+const EDIT_TOOL = /^(edit|multiedit|write|notebookedit|patch|applypatch)$/;
+/** What a call returned is kept up to this, so the log can show it all; a runaway dump still has an end. */
+const MAX_RESULT_CHARS = 20_000;
+const MAX_RESULT_LINES = 400;
+/** One line longer than this is a minified document or a data URL: its tail says nothing more. */
+const MAX_RESULT_LINE = 2000;
 const ANSI = /\u001b\[[0-9;?]*[ -/]*[@-~]/g;
 const SANDBOX_ERROR = /listen EPERM|outside of the sandbox|sandbox/i;
 /** A saved login is a password (AGENTS.md F5): never copy what a call read from `.auth` into the log. */
@@ -14,8 +25,15 @@ const oneLine = (value, max) => {
     return text.length > max ? `${text.slice(0, max - 1)}…` : text;
 };
 const cap = (text, max) => (text.length > max ? `${text.slice(0, max - 1)}…` : text);
+/** Keeps a body whole up to `max`, and says how much it left out instead of cutting it silently. */
+function capBody(text, max) {
+    if (text.length <= max)
+        return text;
+    const rest = text.length - max;
+    return `${text.slice(0, max)}\n… (${rest} more character${rest === 1 ? '' : 's'} not shown)`;
+}
 const seconds = (ms) => (ms < 90_000 ? `${Math.round(ms / 1000)} s` : `${(ms / 60_000).toFixed(1)} min`);
-/** The first thing a piece of code does, for a tool whose only argument is the code (`execute`). */
+/** The first thing a piece of code does, for code that makes no tool call of its own (`await page.goto(...)`). */
 function firstStatement(code) {
     const line = code
         .split('\n')
@@ -23,12 +41,98 @@ function firstStatement(code) {
         .find((text) => text !== '' && !text.startsWith('//') && !text.startsWith('#'));
     return line ?? '';
 }
+/** `tools["playwright-test"]`, `tools.playwright.mcp`, `tools['x']['y']`: one step into the tools object. */
+const ACCESSOR = /^\s*(?:\.\s*([A-Za-z0-9_$]+)|\[\s*(['"`])((?:\\.|(?!\2)[^\\])*)\2\s*\])/;
+function stepInto(text) {
+    const match = ACCESSOR.exec(text);
+    if (!match)
+        return null;
+    return { value: match[1] ?? match[3], length: match[0].length };
+}
+/** How much of a call's arguments is read to name the thing it touched. */
+const SUMMARY_ARGS = 600;
+/** The argument that says most about a call, in the order a person would look for it: the place it touched, then the
+ * intent it was given for. */
+const ARG_KEYS = [
+    'url',
+    'path',
+    'file_path',
+    'filePath',
+    'filename',
+    'element',
+    'selector',
+    'pattern',
+    'query',
+    'intent',
+    'description',
+    'name',
+    'text',
+];
+/**
+ * The calls a code-mode `execute` makes on the tools it is given
+ * (`tools["playwright-test"].browser_navigate({url: "..."})`). The code is the only thing that says what such a call
+ * did: the tool `execute` itself names nothing.
+ */
+function nestedCalls(code) {
+    const calls = [];
+    let from = 0;
+    for (;;) {
+        const at = code.indexOf('tools', from);
+        if (at < 0)
+            break;
+        from = at + 'tools'.length;
+        // `prototype.tools[...]` is somebody else's object, not the code mode's own.
+        if (at > 0 && /[A-Za-z0-9_$.]/.test(code[at - 1]))
+            continue;
+        const namespace = stepInto(code.slice(from));
+        if (!namespace)
+            continue;
+        const tool = stepInto(code.slice(from + namespace.length));
+        if (!tool)
+            continue;
+        const callAt = from + namespace.length + tool.length;
+        const open = /^\s*\(/.test(code.slice(callAt)) ? code.indexOf('(', callAt) : -1;
+        if (open < 0)
+            continue;
+        calls.push({ name: tool.value, args: code.slice(open + 1, open + 1 + SUMMARY_ARGS) });
+        from = open + 1;
+    }
+    return calls;
+}
+/** The first argument of a call that says what it touched: the URL, the element, the file, the intent. */
+function firstArgument(args) {
+    const found = new Map();
+    for (const match of args.matchAll(/(['"]?)([A-Za-z_$][\w$]*)\1\s*:\s*(['"`])((?:\\.|(?!\3)[^\\])*?)\3/g)) {
+        if (!found.has(match[2]))
+            found.set(match[2], match[4].replace(/\\(['"`\\])/g, '$1'));
+    }
+    for (const key of ARG_KEYS) {
+        const value = found.get(key);
+        if (value && value.trim())
+            return oneLine(value, MAX_DETAIL);
+    }
+    return '';
+}
+/**
+ * What a code-mode call does, in one line: `browser_navigate(http://…)`, or the code's first statement when it makes no
+ * tool call. The whole code opens from the call's card when the line is not enough.
+ */
+function codeSummary(code) {
+    const calls = nestedCalls(code);
+    const [call] = calls;
+    const summary = call ? `${call.name}(${firstArgument(call.args)})` : oneLine(firstStatement(code), MAX_DETAIL);
+    const extra = calls.length - 1;
+    if (extra > 0)
+        return cap(`${summary} +${extra} more call${extra === 1 ? '' : 's'}`, MAX_DETAIL);
+    return cap(summary, MAX_DETAIL);
+}
 /** `mcp__playwright-test__browser_click` -> `browser_click`. */
 const toolName = (name) => name.replace(/^mcp__[^_]+(?:-[^_]+)*__/, '');
 /**
  * What the call is about, in a few words: the intent the agent gave, or the argument that names the thing it touched.
  * The names differ per CLI and per tool (`file_path` for Claude, `path` for OpenCode; `pattern` for glob and grep;
- * `code` for a code-mode `execute`), so every one of them is looked at.
+ * `code` for a code-mode `execute`), so every one of them is looked at. This is the log's one line; the whole argument
+ * travels next to it (`fullInput`) and is opened on demand.
  */
 function describe(input) {
     if (!input || typeof input !== 'object')
@@ -51,45 +155,100 @@ function describe(input) {
     ].find((name) => typeof args[name] === 'string' && args[name].trim() !== '');
     if (key)
         return oneLine(args[key], MAX_DETAIL);
+    // A patch names its file inside the text, and the text itself would fill the whole line with diff noise.
+    const patch = args.patchText ?? args.patch_text ?? args.patch ?? args.diff ?? args.input;
+    if (typeof patch === 'string') {
+        const file = /^\+\+\+ b\/(.+)$/m.exec(patch)?.[1] ?? /^\*\*\* (?:Update|Add|Delete) File: (.+)$/m.exec(patch)?.[1];
+        if (file)
+            return oneLine(file.trim(), MAX_DETAIL);
+    }
     if (typeof args.code === 'string')
-        return oneLine(firstStatement(args.code), MAX_DETAIL);
+        return codeSummary(args.code);
     // Nothing known: the longest string still tells more than the bare tool name.
     const longest = Object.values(args)
         .filter((value) => typeof value === 'string')
         .sort((a, b) => b.length - a.length)[0];
     return longest ? oneLine(longest, MAX_DETAIL) : '';
 }
-const callOf = (name, input) => ({
-    name: toolName(name),
-    detail: describe(input),
-    ok: true,
-    pending: true,
-});
+/**
+ * The whole call, as the log opens it: the code or the command as written, else the arguments as JSON. One short
+ * argument that the summary already shows is not worth a second copy of the same words.
+ */
+function fullInput(input, detail, tool) {
+    if (!input || typeof input !== 'object')
+        return undefined;
+    const args = input;
+    const edit = EDIT_TOOL.test(tool.toLowerCase().replace(/[_-]/g, ''));
+    const max = edit ? MAX_INPUT_EDIT : MAX_INPUT;
+    if (typeof args.code === 'string' && args.code.trim())
+        return capBody(args.code.trimEnd(), max);
+    if (typeof args.command === 'string' && args.command.trim())
+        return capBody(args.command.trimEnd(), max);
+    // One short argument that the summary already shows is not worth a second copy of the same words; anything longer
+    // than the summary (a patch, a file's content) or anything more (a window, a flag) is worth opening. An edit always
+    // keeps its argument: that is what the log draws as a diff.
+    const named = Object.entries(args).filter(([, value]) => value !== undefined && value !== null && String(value).trim() !== '');
+    const only = named.length === 1 ? named[0][1] : undefined;
+    if (!edit && typeof only === 'string' && only.trim().length <= MAX_DETAIL && oneLine(only, MAX_DETAIL) === detail) {
+        return undefined;
+    }
+    try {
+        const json = JSON.stringify(args, null, 2);
+        return json && json !== '{}' ? capBody(json, max) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+const callOf = (name, input) => {
+    const detail = describe(input);
+    const full = fullInput(input, detail, name);
+    return {
+        name: toolName(name),
+        detail,
+        ...(full && full !== detail && { input: full }),
+        ok: true,
+        pending: true,
+    };
+};
 const labelText = (call) => (call.detail ? `${call.name}: ${call.detail}` : call.name);
 /**
- * The first lines of what a call returned, with the colors a shell put in it. Long output keeps its head only: the
- * point is to see what happened, not to copy a file into the log.
+ * A JSON result is kept with the indentation a person reads: a minified document is one endless line, which no reader
+ * and no line cap can handle. Anything that is not JSON comes back as it was.
+ */
+function prettyJsonText(text) {
+    if (!text.startsWith('{') && !text.startsWith('['))
+        return text;
+    try {
+        return JSON.stringify(JSON.parse(text), null, 2);
+    }
+    catch {
+        return text;
+    }
+}
+/**
+ * What a call returned, whole: the log opens one call and reads all of it. With the colors the shell put in it. A
+ * runaway dump is still cut at a point a person can come back from, and the line left out says how much it was.
  */
-function previewText(value) {
-    const text = (typeof value === 'string' ? value : value == null ? '' : String(value))
-        .replace(/\r\n?/g, '\n')
-        .replace(/\t/g, '  ')
-        .trim();
+function resultText(value) {
+    const raw = (typeof value === 'string' ? value : value == null ? '' : String(value)).replace(/\r\n?/g, '\n');
+    // A result that is a JSON string of its own text is decoded first: nobody reads `\n` as a line break in their head.
+    const text = prettyJsonText(expandEscapedText(raw).replace(/\t/g, '  ').trim());
     if (!text)
         return null;
     const lines = text.split('\n');
     const kept = [];
     let chars = 0;
     for (const line of lines) {
-        if (kept.length >= PREVIEW_LINES || chars >= PREVIEW_CHARS)
+        if (kept.length >= MAX_RESULT_LINES || chars >= MAX_RESULT_CHARS)
             break;
         // A cut line loses its colors, so a half escape sequence cannot bleed into the rest of the block.
-        const shown = line.length > PREVIEW_LINE ? oneLine(line.replace(ANSI, ''), PREVIEW_LINE) : line;
+        const shown = line.length > MAX_RESULT_LINE ? oneLine(line.replace(ANSI, ''), MAX_RESULT_LINE) : line;
         kept.push(shown);
         chars += shown.length;
     }
     const rest = lines.length - kept.length;
-    return kept.join('\n') + (rest > 0 ? `\n… (${rest} more line${rest === 1 ? '' : 's'})` : '');
+    return kept.join('\n') + (rest > 0 ? `\n… (${rest} more line${rest === 1 ? '' : 's'} not shown)` : '');
 }
 const HANDOFF_CFG = '__handoffCfg';
 const HANDOFF_CARD = /handoff-card\.js/;
@@ -251,12 +410,12 @@ export class AiStreamFormatter {
     /** A call the agent has started and not finished yet (Claude reports both ends). */
     start(id, call) {
         const now = Date.now();
-        this.pending.set(id, { name: call.name, detail: call.detail, startedAt: now });
+        this.pending.set(id, { name: call.name, detail: call.detail, input: call.input, startedAt: now });
         return [{ kind: 'tool', at: now, data: `>> ${labelText(call)}`, tool: call }];
     }
     /**
-     * The end of a call, plus the first lines of what it returned. `fallback` is for a CLI that reports a call only when
-     * it is over (OpenCode), which still knows when it started.
+     * The end of a call, plus what it returned. `fallback` is for a CLI that reports a call only when it is over
+     * (OpenCode), which still knows when it started.
      */
     finishCall(id, ok, output, fallback) {
         const now = Date.now();
@@ -266,6 +425,7 @@ export class AiStreamFormatter {
             this.waitingForUser = null;
         const name = call?.name ?? fallback?.name ?? 'tool';
         const detail = call?.detail ?? fallback?.detail ?? '';
+        const input = call?.input ?? fallback?.input;
         const startedAt = call?.startedAt ?? fallback?.startedAt;
         const took = startedAt ? seconds(now - startedAt) : undefined;
         const label = labelText({ name, detail });
@@ -275,7 +435,7 @@ export class AiStreamFormatter {
                 kind: 'tool',
                 at: now,
                 data: `${ok ? 'ok' : 'FAILED'}: ${label}${took ? ` after ${took}` : ''}`,
-                tool: { name, detail, ok, ...(took && { took }) },
+                tool: { name, detail, ...(input && { input }), ok, ...(took && { took }) },
             },
         ];
         if (!ok) {
@@ -285,9 +445,9 @@ export class AiStreamFormatter {
             return parts;
         }
         // A saved login is a password: what a call read from `.auth` never goes into the log.
-        const preview = SECRET_PATH.test(detail) ? null : previewText(output);
-        if (preview)
-            parts.push({ kind: 'result', at: now, data: preview });
+        const result = SECRET_PATH.test(detail) ? null : resultText(output);
+        if (result)
+            parts.push({ kind: 'result', at: now, data: result });
         return parts;
     }
     /** Said once per run, after the first tool call that Claude Code's sandbox refused (nobody is there to approve it). */

package/dist/ui/shared/log-text.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Text of a tool call, as the log can show it. A tool that answers with a JSON string of its own text (`"…\n…"`, which
+ * is what an MCP result arrives as) is unreadable as escapes: the line is decoded here, once, for both the server that
+ * stores it and the page that renders what an older run already stored.
+ */
+/**
+ * One line of a result. If the whole line is a JSON string literal with escapes in it, the text it holds comes back —
+ * `"a\nb"` becomes two lines; a plain `"OK"` or a sentence in quotes keeps its quotes. Two rounds cover a value that
+ * was serialized twice, which is as deep as tools go.
+ */
+export declare function expandEscapedLine(line: string): string;
+/** The whole result, line by line (`resultText` writes it this way on the server). */
+export declare function expandEscapedText(text: string): string;

package/dist/ui/shared/log-text.js

@@ -0,0 +1,45 @@
+/**
+ * Text of a tool call, as the log can show it. A tool that answers with a JSON string of its own text (`"…\n…"`, which
+ * is what an MCP result arrives as) is unreadable as escapes: the line is decoded here, once, for both the server that
+ * stores it and the page that renders what an older run already stored.
+ */
+/** A string literal that carries an escape: `\n`, `\t`, `\"`, `\\`, `\u001b`. Plain quotes are left alone. */
+const ESCAPED = /\\(?:[nrtbfv"'\\/]|u[0-9a-fA-F]{4})/;
+/**
+ * One line of a result. If the whole line is a JSON string literal with escapes in it, the text it holds comes back —
+ * `"a\nb"` becomes two lines; a plain `"OK"` or a sentence in quotes keeps its quotes. Two rounds cover a value that
+ * was serialized twice, which is as deep as tools go.
+ */
+export function expandEscapedLine(line) {
+    let text = line;
+    for (let depth = 0; depth < 3; depth += 1) {
+        const trimmed = text.trim();
+        if (trimmed.length < 2 || !trimmed.startsWith('"') || !trimmed.endsWith('"'))
+            break;
+        if (!ESCAPED.test(trimmed))
+            break;
+        let parsed;
+        try {
+            parsed = JSON.parse(trimmed);
+        }
+        catch {
+            break;
+        }
+        if (typeof parsed !== 'string')
+            break;
+        // The indentation a log line arrived with stays in front of what it turned into.
+        const indent = /^\s*/.exec(text)?.[0] ?? '';
+        text = parsed
+            .split('\n')
+            .map((part) => `${indent}${part}`)
+            .join('\n');
+    }
+    return text;
+}
+/** The whole result, line by line (`resultText` writes it this way on the server). */
+export function expandEscapedText(text) {
+    return text
+        .split('\n')
+        .map((line) => expandEscapedLine(line))
+        .join('\n');
+}

package/dist/ui/shared/types.d.ts

@@ -67,7 +67,7 @@ export type ResultState = 'ready' | 'needs-input';
 /**
  * How one block of an AI job's log is presented. Absent for the plain output of every other job, which stays raw.
  * `markdown`: what the agent said; `reasoning`: what it was thinking (not a result); `tool`: one call, started or
- * finished; `result`: the first lines of a call's output; `error` / `hint`: what failed and what to do about it;
+ * finished; `result`: what a call returned (whole, up to a cap); `error` / `hint`: what failed and what to do about it;
  * `meta`: anything else a person should read (the waiting line, noise the CLI printed).
  */
 export type JobChunkKind = 'tool' | 'result' | 'reasoning' | 'markdown' | 'error' | 'hint' | 'meta';
@@ -76,6 +76,11 @@ export interface JobChunkTool {
     name: string;
     /** What the call is about (the file, the command, the intent); empty when the CLI gave nothing telling. */
     detail: string;
+    /**
+     * The whole argument the call was made with (its code, its command, the rest as JSON), so the log can open one call
+     * and show it in full. Absent when the call gave nothing beyond `detail`, which a saved login's path never is.
+     */
+    input?: string;
     ok: boolean;
     /** Still running: Claude reports the start of a call, OpenCode only its end. */
     pending?: boolean;

package/docs/agents/case-format.md

@@ -89,7 +89,7 @@ Wrong: `- Create a draft named ... and delete it at the end.` (a write → a tag
 - `- Ready when:` is a sub-line of the step: the positive signal that what the step loads is there. The spec waits
   for it before reading; it is not an assertion.
 - `- Recipe (phase):` is a sub-line of an `[input]`/`[writes]` step: what a person did in the browser during an
-  attended exploration (positions, `[asrun]` names, control labels; no selectors). A tagged step with no recipe is a
+  attended exploration (positions, created names, control labels; no selectors). A tagged step with no recipe is a
   `needs-input` stop for `/gen-spec`.
 - A question block is indented under the sentence it belongs to: 4 spaces under a numbered step, 2 under a bullet.
   The parent line is the suggestion, written as a finished sentence; the `TODO` line holds one question and optional
@@ -121,7 +121,8 @@ example-staging:
 - A profile with no entry and no `default` fails with "Missing values ...". An empty value or one that starts with
   `TODO` fails with "Incomplete values ...". Fill them before running; never make a spec read the YAML itself.
 - Values hold literals only: names, labels, options, test-data names. The checks themselves stay in `## Steps` and
-  `## Expected`, and selectors come from `## Targets`.
+  `## Expected`, and selectors come from `## Targets`. A name the case creates is stored here **without** its run
+  stamp: the literal is the base, and the spec composes `<base> (<run stamp>)` with `testDataName()` (F11).
 - No marker or question inside the yaml: it would become part of the expected value. Put it on the prose line above
   the block and name the key there.
 
@@ -201,9 +202,11 @@ test.describe('<Case title>', {tag: caseTags('<id>')}, () => {
   a case limited to some environments is skipped elsewhere; a case that writes elsewhere only is skipped with a
   notice; a write in a non-staging environment needs the confirmation the CLI sets, never an environment variable
   that was merely present.
-- Write cases: name everything `[asrun] ...`, register it with `records.track` right after creating it, remove it
-  newest first (also after a failure), turn retries off with `configureCase`, and keep email steps behind
-  `emailStepAllowed(profile, '<step title>')`.
+- Write cases: name everything `<prefix> <base> (<run stamp>)` through `testDataName(base)`
+  (`@asrunjs/asrun/records`), where the prefix is `asrun.testDataPrefix` in `package.json` (default `[asrun]`, printed
+  by `pnpm asrun rules`) and the stamp is the run's UTC time; register it with `records.track` right after creating
+  it, remove it newest first (also after a failure), turn retries off with `configureCase`, and keep email steps
+  behind `emailStepAllowed(profile, '<step title>')`.
 
 ## Checks to run before reporting
 

package/docs/ai-workflow.md

@@ -93,10 +93,11 @@ opened and nothing is written about them, so a case can be explored in passes: A
 case keeps what the earlier runs recorded. In the web UI the profile picker of the toolbar does the same: every profile
 that is logged in in that environment is ticked, and the list you tick is remembered for the next run there.
 
-**To accept the suggestion, delete the whole block.** **To answer, write after `Answer:`.** Then run the command
-again. In the web UI, the run's **What to do next** bar offers **Answer**: the question list, an answer box,
-**Use the suggested defaults** and **Generate spec**. A continued job keeps the same conversation and permissions, and
-can be continued once per turn, only while the UI server has not restarted.
+**To keep what the case says, delete the whole block.** **To answer, write after `Answer:`.** Then run the command
+again. In the web UI the panel calls the first action **Keep what the case says**. The run's **What to do next** bar
+offers **Answer**: the question list, an answer box, **Use the suggested defaults** and **Generate spec**. A continued
+job keeps the same conversation and permissions, and can be continued once per turn, only while the UI server has not
+restarted.
 
 ### Attended exploration (`--attended`)
 
@@ -109,9 +110,10 @@ the browser window opens and the agent waits while you do those steps.
 - Recording starts and stops by itself. If Playwright's own recording toolbar shows at the top of the page, leave it
   alone: it can stop the recording.
 - The card records what you did, and the agent writes it into the case under the step as **general recipe lines**
-  (`- Recipe (phase): ...`): positions instead of names of changeable data, `[asrun]` names for created data, control
-  labels but no selectors.
-- Delete the `[asrun]` items you created before you press Done on the last step.
+  (`- Recipe (phase): ...`): positions instead of names of changeable data, created names (project prefix plus the
+  run's UTC stamp), control labels but no selectors.
+- Delete the test items you created (they start with the project's test-data prefix and carry this run's timestamp)
+  before you press Done on the last step.
 - Without `--attended` the agent never waits: a step that needs a person becomes a `TODO [blocking]`.
 
 In the web UI the **Attended** box is ticked by default for Explore.
@@ -221,6 +223,10 @@ Several binding rules hold in exploring, generating and healing. They live in th
 - **Case rules.** A `## Rules` bullet says how to run the case, never what it proves. The agent applies it while
   exploring and generating, marks code that exists only because of a rule with `// rule: <short quote>`, and lists every
   rule in its report. It never becomes an assertion and never authorizes a write or a person's step.
+- **Test data is findable per run.** Everything a write case creates is named with the project's test-data prefix
+  (`package.json` `"asrun"`, default `[asrun]`) and the run's UTC stamp: `testDataName()` builds
+  `[autotest] Draft CMA (2026-11-09 12-34-56)`. Two runs never share a name, the stamp matches `reports/<run-id>`, and
+  a person can search the product for one run's data. The case's `## Values` holds the base without the stamp.
 - **Targets.** A check on a logo, image, icon, file, PDF, screenshot or repeated text points to a `[T1]` card under
   `## Targets`: what it is (and what it is not), where it is, how it is identified (never `.first()` or a bare `img`),
   when it is ready, and a highlighted reference screenshot under `.explore/targets/`. When in doubt the agent does not
@@ -240,9 +246,10 @@ Checks you can run yourself:
 
 | Command | What it checks |
 |---|---|
-| `pnpm spec:lint [case-id]` | fails on screenshots without a target, `.first()` on images, sleeps, `networkidle`, raw download events, a `%PDF` check on its own |
+| `pnpm spec:lint [case-id]` | fails on screenshots without a target, `.first()` on images, sleeps, `networkidle`, raw download events, a `%PDF` check on its own; warns when a tracked test-data name is not built with `testDataName()` |
 | `pnpm baselines:review [case-id] [--new]` | lists every baseline with the card that says what it must show, so you can look at each new image |
 | `pnpm case:check [case-id]` | fails on an incomplete card, bad values, a marker inside a question or a question under a marked line; warns on an image check with no card and on a marker that does not say what to decide |
+| `pnpm asrun rules [--json] [--case <id>]` | prints the effective rules (baseline, §2, project settings) the AI steps read; fails on an invalid §2 row or `testDataPrefix` |
 | `pnpm markers:confirm --case <id> --env <env> [--report <run-id>]` | after a passing run, removes the `🔍 to be confirmed` markers whose line the spec checks with `// unconfirmed:`; `--dry-run` lists them |
 | `pnpm pdf:render <file.pdf> --out <dir> [--pages all] [--corner top-left]` | renders the pages to images and prints the text, to look at a PDF by hand |
 
@@ -281,10 +288,12 @@ An override is plain Markdown; write only what differs:
 - The staging account has no published documents: assert the empty state there instead.
 ```
 
-The project's `AGENTS.md` §2 is the other place: a table of rule ids (`F7`–`F10`, `R1`, `R3`, `R4`; `F1`–`F6` and
-`R2` are fixed) with `narrows` (stricter) or `replaces` (a different default). For example, a project that writes cases in Simplified Chinese
-`replaces` `F10`. `pnpm asrun doctor` fails on an unknown id, a missing `Effect`, or a non-negotiable rule, and lists
-the overrides it sees.
+The project's `AGENTS.md` §2 is the other place: a table of rule ids (`F7`–`F11`, `R1`, `R3`, `R4`; `F1`–`F6` and
+`R2` are fixed) with `narrows` (stricter) or `replaces` (a different default). A rule the baseline does not have gets
+a project id (`P1`, `P2`, ...) and `adds`. For example, a project that writes cases in Simplified Chinese `replaces`
+`F10`. `pnpm asrun doctor` fails on an unknown id, a missing `Effect`, a duplicate id, a non-negotiable rule or a
+project id without `adds`, and `pnpm asrun rules` prints the effective set (the AI steps read it before they apply
+anything). A project rule is applied as written: a difference from the baseline is never a question.
 
 An update never overwrites `AGENTS.md`, `CLAUDE.md` or `.claude/skills/**`: `pnpm asrun init --force` refuses them
 without `--reset-rules`. Never edit the framework package itself.

package/docs/cases.md

@@ -110,13 +110,14 @@ report and the trace read like the case.
   choice (an existing document, items), `[email]` for a step that sends email. They are written at the end of the
   step line.
 - **`- Recipe (phase):`** under a tagged step records what a person did in the browser during an attended
-  exploration: positions instead of names of changeable data (`select items #1 to #3`), `[asrun]` names for created
-  data, control labels but no selectors. Several lines per step are normal. A tagged step with no recipe is not
-  generated: `/gen-spec` stops with `needs-input`.
+  exploration: positions instead of names of changeable data (`select items #1 to #3`), created names (project prefix
+  plus run stamp), control labels but no selectors. Several lines per step are normal. A tagged step with no recipe is
+  not generated: `/gen-spec` stops with `needs-input`.
 - **Open questions** go in a `🚫 TODO [blocking]` or `❓ TODO [non-blocking]` block under the sentence they are about,
   with the agent's suggestion written above and a last line `- ✍️ Answer:`. Accepting a question means deleting the
-  whole block; answering means writing after `Answer:`. Hang the block under the sentence that makes the claim, not
-  under a broader one above it, and one claim gets one block.
+  whole block; answering means writing after `Answer:`. In the web panel the two actions are **Keep what the case
+  says** and **Write your answer**. Hang the block under the sentence that makes the claim, not under a broader one
+  above it, and one claim gets one block.
 - **What the AI saw** is marked by what happens if it is wrong: `(seen on <profile>)` is a plain note the run checks by
   itself, and `(observed on <profile>, 🔍 to be confirmed: <what a person must decide>)` is a line that would pass even
   if it were wrong, so a person settles it. A marker may name a screenshot (`evidence: .explore/.../x.png`) so nobody
@@ -173,7 +174,10 @@ anything.
 
 A case may write only in the environments listed under `writes`, and only data of the test account:
 
-- everything it creates is named `[asrun] ...` (the `records` fixture refuses other names);
+- everything it creates is named with the project's prefix and the run stamp, `<prefix> <base> (<run stamp>)`
+  (prefix: `asrun.testDataPrefix` in `package.json`, default `[asrun]`; stamp: the run's UTC time). The spec builds
+  the name with `testDataName()` (`records` refuses a name without the prefix), so two runs never collide and a
+  person can search the product for one run's data. `## Values` holds the base without the stamp;
 - created data is registered with `records.track` and removed after the test, also after a failure;
 - the case's own last step is normally the deletion; `track` is the safety net;
 - staging needs no confirmation. In any other environment a person confirms every run (typing the environment name,

package/docs/commands.md

@@ -10,6 +10,7 @@ thin wrappers, so `pnpm asrun`, `pnpm signin` and the rest work as below. The sa
 | Install the framework in a project | `pnpm dlx @asrunjs/asrun init --install` |
 | Upgrade the framework and migrate the workspace | `pnpm asrun upgrade [--version <v>] [--dry-run]` |
 | Prepare or check the workspace | `pnpm asrun init [--update]`, `pnpm asrun doctor` |
+| See the effective rules and project settings | `pnpm asrun rules [--json] [--case <case-id>]` |
 | See or apply the workspace migrations after a manual install | `pnpm asrun migrate [--list] [--dry-run]` |
 | Start over with fresh dependencies | `pnpm asrun reset [--yes] [--state] [--lockfile]` |
 | Start the web UI | `pnpm go`, `pnpm ui`, `pnpm ui:dev` |
@@ -160,6 +161,21 @@ covers) and `--json` prints the parsed notes for a run that reads them. A note i
 case when it is missing or stale. `--check` fails on a malformed note and warns about a stale one (it prints the current
 `caseSha256`); `--hash` prints that hash. Deleting `.explore/notes/` is always safe.
 
+## Rules
+
+```bash
+pnpm asrun rules
+pnpm asrun rules --json
+pnpm asrun rules --case conduit/publish-article
+```
+
+Prints the effective rules of the workspace: the framework baseline, the project's `AGENTS.md` §2 table (id, effect
+and text), and the project settings the framework needs at run time (`testDataPrefix` and the resulting data-name
+format). `--case <id>` adds that case's `## Rules`. `--json` is the machine-readable form the AI steps read before
+they apply anything. A §2 row that is invalid — an unknown baseline id, a `[non-negotiable]` rule, a duplicate id, a
+project id (`P1`, ...) without `adds` — is printed as an error and the command exits 1; `doctor` shows the same errors.
+The point is that "§2 wins over the baseline" is a fact the tool states, not a judgment an agent has to make.
+
 ## Cleanup
 
 ```bash
@@ -167,10 +183,12 @@ pnpm cleanup --env staging
 pnpm cleanup --env staging --forget
 ```
 
-A write case registers everything it creates (named `[asrun] ...`) and removes it after the test, also after a
-failure. Whatever could not be removed is listed in the report and by `cleanup`. Delete it by hand in the product,
-then run `--forget` so it is not listed again. `--env` is required. `cleanup` is about test data in the product;
-`pnpm asrun reset` (below) is the command that removes workspace files and dependencies.
+A write case registers everything it creates (named with the project's prefix and a run stamp, for example
+`[asrun] Draft CMA (2026-11-09 12-34-56)`) and removes it after the test, also after a failure. Whatever could not be
+removed is listed in the report and by `cleanup`. Delete it by hand in the product, then run `--forget` so it is not
+listed again. The run stamp matches the report folder and the ledger entry, so one run's leftovers are easy to find.
+`--env` is required. `cleanup` is about test data in the product; `pnpm asrun reset` (below) is the command that
+removes workspace files and dependencies.
 
 ## Web UI
 

package/docs/install.md

@@ -163,7 +163,8 @@ Run it after changing profiles, rules or overrides, and after an update. It chec
 - that `.gitignore` ignores `.auth/` and `reports/`;
 - whether the installed version is behind the package's templates, and whether `dist/` is out of date;
 - the workspace migrations: the baseline in `.asrun.json`, what still applies, and the manual steps left open;
-- the project rule table in `AGENTS.md` §2 (unknown ids, a missing `Effect`, a non-negotiable rule);
+- the project rule table in `AGENTS.md` §2 (unknown ids, a missing `Effect`, a duplicate id, a non-negotiable rule, a
+  project id without `adds`) and the project settings in `package.json` `"asrun"` (for example `testDataPrefix`);
 - the framework skills and the project overrides under `.claude/skills/<skill>.md`, and lists the ones it sees.
 
 ## Which workspace a command runs against