@asrunjs/asrun 0.12.0 → 0.14.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 previewText(value) {
-    const text = (typeof value === 'string' ? value : value == null ? '' : String(value))
-        .replace(/\r\n?/g, '\n')
-        .replace(/\t/g, '  ')
-        .trim();
+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 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/;
@@ -112,11 +271,15 @@ const BROWSER_RUN_CODE = /browser_run_code/;
  * badge on.
  */
 const HANDOFF_CFG_TTL_MS = 300_000;
-/** `message: '...'` of the options call that comes right before the card. */
-function handoffMessage(code) {
-    const match = /message\s*:\s*(['"`])((?:\\.|(?!\1)[^\\])*)\1/.exec(code);
+/** A plain string literal of the options call that comes right before the card (`message: '...'`, `finish: '...'`). */
+function handoffText(code, key) {
+    const match = new RegExp(`(?:^|[^\\w$])${key}\\s*:\\s*(['"\`])((?:\\\\.|(?!\\1)[^\\\\])*)\\1`).exec(code);
     return match ? match[2].replace(/\\(['"`\\])/g, '$1').trim() || null : null;
 }
+/** `message: '...'` of the options call that comes right before the card. */
+const handoffMessage = (code) => handoffText(code, 'message');
+/** `finish: '...'` of the options call that comes right before the card. */
+const handoffFinish = (code) => handoffText(code, 'finish');
 const codeOf = (input) => {
     if (!input || typeof input !== 'object')
         return '';
@@ -147,8 +310,12 @@ export class AiStreamFormatter {
     pending = new Map();
     cardCalls = new Set();
     waitingForUser = null;
-    /** The message of the last options call, kept so a card that runs after unrelated calls still carries it. */
+    /**
+     * The message and finish condition of the last options call, kept so a card that runs after unrelated calls still
+     * carries them.
+     */
     lastHandoffMessage = null;
+    lastHandoffFinish = null;
     lastEventAt = Date.now();
     lastWaitAt = 0;
     /** The last call the agent finished, so a quiet spell can say what it is doing instead of only that nothing came. */
@@ -189,18 +356,29 @@ export class AiStreamFormatter {
                 this.waitingForUser = null;
             else {
                 this.cardCalls.add(id);
-                // `??=` on purpose: the options call before it already knows the message and when the wait started.
-                this.waitingForUser ??= { message: handoffMessage(codeOf(input)) ?? this.lastHandoffMessage, since: Date.now() };
+                // `??=` on purpose: the options call before it already knows the message, the finish condition and the start.
+                this.waitingForUser ??= {
+                    message: handoffMessage(codeOf(input)) ?? this.lastHandoffMessage,
+                    finish: handoffFinish(codeOf(input)) ?? this.lastHandoffFinish,
+                    since: Date.now(),
+                };
             }
             return null;
         }
         if (kind === 'options') {
             const message = handoffMessage(codeOf(input));
+            const finish = handoffFinish(codeOf(input));
             if (message)
                 this.lastHandoffMessage = message;
+            if (finish)
+                this.lastHandoffFinish = finish;
             // Keep the start time when the wait is already set: a second report of the same handoff must not announce it twice.
             const since = this.waitingForUser?.since ?? Date.now();
-            this.waitingForUser = { message: message ?? this.lastHandoffMessage, since };
+            this.waitingForUser = {
+                message: message ?? this.lastHandoffMessage,
+                finish: finish ?? this.lastHandoffFinish,
+                since,
+            };
             return null;
         }
         // Anything else ends the wait, unless it was set too recently to be an abandoned one: the card runs right after it.
@@ -251,12 +429,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 +444,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 +454,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 +464,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/server/jobs.d.ts

@@ -102,6 +102,16 @@ declare class JobManager {
     private verifyLeftoverStopped;
     /** Publishes a change of "waiting for the person" (a handoff card) like any other status change. */
     private syncAwaiting;
+    /**
+     * Shows a desktop notification now. Neither the agent (whose shell the CLI may refuse) nor the page (not open, not
+     * focused, not allowed) can be relied on for this, so the server shows it itself.
+     */
+    private notifyWaiting;
+    /**
+     * Why no notification appeared, written where the person reads next: never a reason to fail the job, and the next
+     * run of the same kind leaves no line at all when the notifier works.
+     */
+    private pushNotificationFailure;
     /**
      * Stops a run whose agent has said nothing for `STALL_MS`: a tool call that never returns leaves the CLI waiting for
      * ever, and the log would only keep repeating "still waiting for ...". The block above the cancel names what to do.

package/dist/ui/server/jobs.js

@@ -5,6 +5,7 @@ import fs from 'node:fs';
 import { StringDecoder } from 'node:string_decoder';
 import { ROOT } from '../../lib/paths.js';
 import { spawnTarget } from '../../lib/command.js';
+import { notifyDesktop } from '../../lib/desktop-notify.js';
 import { AiStreamFormatter } from './ai-stream.js';
 import { parseResultState } from './result-state.js';
 import { appendChunkNow, chunksFile, ensureJobDir, logFile, pruneJobs, readChunks, readJobs, writeRecord, } from './job-store.js';
@@ -244,6 +245,11 @@ class JobManager {
             finished = true;
             this.finish(record, code, signal);
         });
+        // A login waits for a person at the browser window it just opened: say so on the desktop, where they are looking.
+        if (spec.kind === 'signin') {
+            this.notifyWaiting(record, 'AsRun — log in', `Log in to ${[spec.profile, spec.env].filter(Boolean).join(' @ ')}, then press "Done, save the session" on ` +
+                'the card in the browser window.');
+        }
         this.events.emit('job', record.info);
         return record.info;
     }
@@ -476,9 +482,39 @@ class JobManager {
             return;
         if (now && before && before.since === new Date(now.since).toISOString())
             return;
-        info.awaitingUser = now ? { message: now.message, since: new Date(now.since).toISOString() } : null;
+        info.awaitingUser = now
+            ? { message: now.message, finish: now.finish, since: new Date(now.since).toISOString() }
+            : null;
         this.persist(record);
         this.events.emit('job', info);
+        // A handoff that starts right now: the person is told on the desktop, because the browser window is somewhere else
+        // and the page may be closed, focused or not allowed to notify. The dedupe keeps one handoff to one notification.
+        if (!before && now) {
+            this.notifyWaiting(record, 'AsRun — your turn', `${info.caseId ? `${info.caseId}: ` : ''}${now.message ?? 'A step in the browser window waits for you.'}` +
+                (now.finish ? ` Done when ${now.finish}.` : ''));
+        }
+    }
+    /**
+     * Shows a desktop notification now. Neither the agent (whose shell the CLI may refuse) nor the page (not open, not
+     * focused, not allowed) can be relied on for this, so the server shows it itself.
+     */
+    notifyWaiting(record, title, body) {
+        notifyDesktop({ title, body, sound: true }, (reason) => this.pushNotificationFailure(record, reason));
+    }
+    /**
+     * Why no notification appeared, written where the person reads next: never a reason to fail the job, and the next
+     * run of the same kind leaves no line at all when the notifier works.
+     */
+    pushNotificationFailure(record, reason) {
+        const line = `\n[no desktop notification shown: ${reason}. "pnpm asrun notify-test" checks the notifier of this machine]\n`;
+        // The job may have ended while the notifier was still running: its log stream is closed then, so the files get the
+        // line directly (a running job is told through its stream, so the page shows it at once).
+        if (record.info.status === 'running' && record.logStream) {
+            this.pushPart(record, { kind: 'hint', at: Date.now(), data: line });
+        }
+        else {
+            this.pushRecovered(record, line);
+        }
     }
     /**
      * Stops a run whose agent has said nothing for `STALL_MS`: a tool call that never returns leaves the CLI waiting for
@@ -586,6 +622,10 @@ class JobManager {
                         : `[process exited with code ${code}]`);
         if (record.spec.ai && info.status === 'succeeded')
             info.resultState = parseResultState(resultText(record));
+        // The agent stopped with questions in the case file: that waits for a person exactly like a handoff card does.
+        if (info.resultState === 'needs-input') {
+            this.notifyWaiting(record, 'AsRun — answers needed', `${info.caseId ? `${info.caseId}: ` : 'The case: '}the agent wrote open questions into the case file.`);
+        }
         this.push(record, 'system', `\n${summary}\n`);
         record.logStream?.end();
         record.chunkStream?.end();

package/dist/ui/shared/ai-commands.js

@@ -134,8 +134,10 @@ const ATTENDED = 'Attended run: a person is at the machine and the browser windo
     'need a choice to them and wait, as the skill describes. Start every handoff (also a second one in the same run) ' +
     'with its own call that sets __handoffCfg, before the call that runs handoff-card.js, and never change those options ' +
     'inside the call that runs the card: the web UI sees that a person is needed only from that call, so without it ' +
-    'there is no "Your turn" badge and no notification. Nobody can answer questions in the chat, so write open ' +
-    `questions into the case file as the skill describes. ${RESULT_LINE_RULE}`;
+    'there is no "Your turn" badge and no notification. Put one action per string in `steps` (the card numbers them), ' +
+    'keep `message` to one sentence, write the finish condition into `finish` as plain text, and set `doneText` to the ' +
+    'exact text that appears when the step is done so the card ends by itself. Nobody can answer ' +
+    `questions in the chat, so write open questions into the case file as the skill describes. ${RESULT_LINE_RULE}`;
 /** The prompt of a one-shot run. Every command may leave open questions in the case, so every one ends with a RESULT line. */
 export function headlessPrompt(command, caseId, options) {
     const slash = slashCommand(command, caseId, options);

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

@@ -60,6 +60,8 @@ export interface JobInfo {
 export interface AwaitingUserInfo {
     /** What the person is asked to do, as the agent wrote it on the card; null when unknown. */
     message: string | null;
+    /** The finish condition the card shows in its "DONE WHEN" block; null when the agent gave none. */
+    finish?: string | null;
     since: string;
 }
 /** `needs-input`: the agent wrote open questions into the case file and cannot go on without answers. */
@@ -67,7 +69,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 +78,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

@@ -94,7 +94,8 @@ Wrong: `- Create a draft named ... and delete it at the end.` (a write → a tag
 - 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
   `(evidence)`; the block ends with `- ✍️ Answer:` at one level deeper and that line is the last line of the block.
-  Hang it under the immediate sentence, never under a broader one above it, and never inside the `## Values` yaml.
+  Hang it under the immediate sentence, never under a broader sentence that merely contains it, and never inside the
+  `## Values` yaml.
   Details: `.claude/skills/exploring-cases/references/open-questions.md`.
 - A marker (`🔍 to be confirmed: <what a person must decide>`) is the alternative to a question, not a companion: it
   says nobody has to decide, only to check. `(seen on <profile>)` is a plain note the run checks by itself. Its

package/docs/ai-workflow.md

@@ -88,10 +88,13 @@ publishes, shares or deletes anything, in staging or in production. It:
   data-call paths it saw. `/gen-spec` reads it to verify instead of rediscovering, and a page that only exists after a
   write step is written from it. Delete it at any time: without it, generation replays the case.
 
-With many profiles, `--profiles a,b` opens only those (ids from `profiles.yaml`, comma-separated). The others are not
-opened and nothing is written about them, so a case can be explored in passes: A and B first, C later. Runs add up; the
-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.
+With many profiles, `--profiles a,b` opens only those (ids from `profiles.yaml`, comma-separated), each in its own
+session; without the flag the agent opens one logged-in profile per domain. Two different hosts are two domains even
+when they serve the same product, so the list is never collapsed into one profile. The profiles the list leaves out are
+not opened and nothing is written about them, so a case can be explored in passes: A and B first, C later. Runs add up;
+the 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 passed to the run and remembered for
+the next one there.
 
 **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
@@ -104,9 +107,10 @@ restarted.
 Use it for a case that creates or edits data, or needs a choice (an existing document, items). Stay at the computer:
 the browser window opens and the agent waits while you do those steps.
 
-- The window shows a small draggable card in the bottom-left corner with what to do, **Done** (hand control back) and
-  **Cannot do this**. The agent also continues by itself when the finish condition it named shows up (for example a
-  "Saved" message); the card turns green when control is back. It waits up to 10 minutes per step.
+- The window shows a small draggable card in the bottom-left corner: one sentence about the step, the steps numbered,
+  the texts to copy, and a green **DONE WHEN** block with the finish condition. **Done** hands control back, and
+  **Cannot do this** gives the step up. The agent also continues by itself when the finish condition shows up (for
+  example a "Saved" message); the card turns green when control is back. It waits up to 10 minutes per step.
 - 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**

package/docs/cases.md

@@ -113,11 +113,11 @@ report and the trace read like the case.
   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:`. 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.
+- **Open questions** go in a `🚫 TODO [blocking]` or `❓ TODO [non-blocking]` block under the sentence they are about:
+  that sentence is the agent's suggestion, and the block's last line is `- ✍️ Answer:`. Accepting a question means
+  deleting the 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 sentence that merely contains 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