@asrunjs/asrun 0.2.0 → 0.5.3

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

@@ -1,42 +1,145 @@
 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;
+const ANSI = /\u001b\[[0-9;?]*[ -/]*[@-~]/g;
 const SANDBOX_ERROR = /listen EPERM|outside of the sandbox|sandbox/i;
-const clock = (at = Date.now()) => new Date(at).toTimeString().slice(0, 8);
+/** A saved login is a password (AGENTS.md F5): never copy what a call read from `.auth` into the log. */
+const SECRET_PATH = /(^|[\\/])\.auth([\\/]|$)/;
 const oneLine = (value, max) => {
     const text = String(value ?? '').replace(/\s+/g, ' ').trim();
     return text.length > max ? `${text.slice(0, max - 1)}…` : text;
 };
+const cap = (text, max) => (text.length > max ? `${text.slice(0, max - 1)}…` : text);
 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`). */
+function firstStatement(code) {
+    const line = code
+        .split('\n')
+        .map((text) => text.trim())
+        .find((text) => text !== '' && !text.startsWith('//') && !text.startsWith('#'));
+    return line ?? '';
+}
 /** `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 most telling argument. */
+/**
+ * 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.
+ */
 function describe(input) {
     if (!input || typeof input !== 'object')
         return '';
     const args = input;
-    const key = ['intent', 'description', 'skill', 'command', 'file_path', 'filename', 'url', 'element', 'query'].find((name) => typeof args[name] === 'string' && args[name]);
-    return key ? oneLine(args[key], MAX_DETAIL) : '';
+    const key = [
+        'intent',
+        'description',
+        'skill',
+        'name',
+        'command',
+        'path',
+        'file_path',
+        'filePath',
+        'filename',
+        'pattern',
+        'query',
+        'url',
+        'element',
+    ].find((name) => typeof args[name] === 'string' && args[name].trim() !== '');
+    if (key)
+        return oneLine(args[key], MAX_DETAIL);
+    if (typeof args.code === 'string')
+        return oneLine(firstStatement(args.code), MAX_DETAIL);
+    // 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,
+});
+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.
+ */
+function previewText(value) {
+    const text = (typeof value === 'string' ? value : value == null ? '' : String(value))
+        .replace(/\r\n?/g, '\n')
+        .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)
+            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;
+        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'})` : '');
 }
-const callLabel = (name, input) => {
-    const detail = describe(input);
-    return detail ? `${toolName(name)}: ${detail}` : toolName(name);
-};
 const HANDOFF_CFG = '__handoffCfg';
-const HANDOFF_CARD = /handoff-card\.js$/;
+const HANDOFF_CARD = /handoff-card\.js/;
+/** What the card returns when it stops waiting (`{outcome: 'done' | 'skip' | 'condition' | 'timeout'}`). */
+const HANDOFF_RESULT = /\\?"outcome\\?"\s*:\s*\\?"(?:done|skip|condition|timeout)\\?"/;
+/**
+ * Said when a card came back that the UI was never told about: only a call of its own that sets the options lets the
+ * UI know a person is needed, so a card that ran with the options of an earlier handoff (or with the options set inside
+ * the call that runs the card) has no badge and no notification.
+ */
+const MISSED_HANDOFF_HINT = 'HINT: this handoff was not announced: the web UI learns a handoff from the call that sets __handoffCfg, and this ' +
+    'card ran without one (see user-handoff.md, "Two calls, every time"), so there was no "Your turn" badge and no ' +
+    'notification.';
+/** The browser tool a handoff runs through: `browser_run_code`, `browser_run_code_unsafe`, ... */
+const BROWSER_RUN_CODE = /browser_run_code/;
+/**
+ * How long "the options are set" survives calls that are not part of the handoff. The agent sets the options and then
+ * runs the card, and in between it may take a screenshot or read a file; the badge (and a notification) must not blink
+ * off and on for that. Long enough for those gaps, short enough that options never followed by a card do not leave the
+ * 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);
     return match ? match[2].replace(/\\(['"`\\])/g, '$1').trim() || null : null;
 }
+const codeOf = (input) => {
+    if (!input || typeof input !== 'object')
+        return '';
+    const code = input.code;
+    return typeof code === 'string' ? code : '';
+};
+/**
+ * Which handoff call this is, if any. The browser tool is called either directly or from a CLI's code mode: OpenCode's
+ * `execute` tool takes a `code` string that holds `tools["playwright-test"].browser_run_code_unsafe({...})`, so the
+ * nested call is only text inside it and the tool name says nothing about the browser.
+ */
 function handoffCall(name, input) {
-    if (!name.includes('browser_run_code') || !input || typeof input !== 'object')
+    if (!input || typeof input !== 'object')
         return null;
     const args = input;
-    if (typeof args.code === 'string' && args.code.includes(HANDOFF_CFG))
-        return 'options';
-    if (typeof args.filename === 'string' && HANDOFF_CARD.test(args.filename))
+    const code = codeOf(input);
+    const filename = typeof args.filename === 'string' ? args.filename : '';
+    // A code-mode call is a handoff only when the browser tool is inside it: it also runs everything else.
+    if (!BROWSER_RUN_CODE.test(name) && !BROWSER_RUN_CODE.test(code))
+        return null;
+    if (HANDOFF_CARD.test(filename) || (HANDOFF_CARD.test(code) && /filename\s*:/.test(code)))
         return 'card';
-    return null;
+    return code.includes(HANDOFF_CFG) ? 'options' : null;
 }
 export class AiStreamFormatter {
     tool;
@@ -44,159 +147,262 @@ 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. */
+    lastHandoffMessage = 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. */
+    lastCall = '';
     sandboxHinted = false;
     constructor(tool) {
         this.tool = tool;
     }
-    /** Lines for a piece of stdout. Incomplete trailing lines wait for the next piece. */
+    /** Blocks for a piece of stdout. Incomplete trailing lines wait for the next piece. */
     feed(text) {
         this.buffer += text;
         const lines = this.buffer.split('\n');
         this.buffer = lines.pop() ?? '';
-        return lines.map((line) => this.line(line)).join('');
+        return lines.flatMap((line) => this.line(line));
     }
     /**
      * Set while a handoff card waits for the person. OpenCode reports a tool call only when it has finished, so the card
      * call itself is not visible while it waits: the options call before it (`__handoffCfg`) starts the state and the end
-     * of the card call, or any other call, ends it. The object changes on every new handoff, so `===` detects a change.
+     * of the card call, or a later call, ends it. The object changes on every new handoff, so `===` detects a change.
      */
     get awaiting() {
         return this.waitingForUser;
     }
-    /** Called once for every tool call the agent makes, with the id the end of that call will carry. */
-    watchHandoff(id, name, input, ended) {
-        const kind = handoffCall(name, input);
-        if (kind === 'options') {
-            const code = String(input.code);
-            this.waitingForUser = { message: handoffMessage(code), since: Date.now() };
+    /**
+     * Called once for every tool call the agent makes, with the id the end of that call will carry. Returns a line for the
+     * log when a card came back that nobody was told about (`MISSED_HANDOFF_HINT`).
+     */
+    watchHandoff(id, name, input, ended, output) {
+        // The card answers `{outcome: ...}` when it stops waiting: that ends the handoff whatever ran it.
+        if (ended && HANDOFF_RESULT.test(String(output ?? ''))) {
+            const announced = this.waitingForUser !== null;
+            this.waitingForUser = null;
+            return announced ? null : { kind: 'hint', at: Date.now(), data: MISSED_HANDOFF_HINT };
         }
-        else if (kind === 'card') {
+        const kind = handoffCall(name, input);
+        if (kind === 'card') {
             if (ended)
                 this.waitingForUser = null;
             else {
                 this.cardCalls.add(id);
-                this.waitingForUser ??= { message: null, since: Date.now() };
+                // `??=` 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() };
             }
+            return null;
         }
-        else {
-            this.waitingForUser = null;
+        if (kind === 'options') {
+            const message = handoffMessage(codeOf(input));
+            if (message)
+                this.lastHandoffMessage = message;
+            // 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 };
+            return null;
         }
+        // Anything else ends the wait, unless it was set too recently to be an abandoned one: the card runs right after it.
+        if (this.waitingForUser && Date.now() - this.waitingForUser.since > HANDOFF_CFG_TTL_MS)
+            this.waitingForUser = null;
+        return null;
     }
     /** What is left when the process ends. */
     end() {
         const rest = this.buffer;
         this.buffer = '';
-        return rest.trim() ? this.line(rest) : '';
+        return rest.trim() ? this.line(rest) : [];
     }
     /**
-     * A line about the oldest tool call that has not returned, when nothing has happened for `quietMs` (and again every
-     * `quietMs` after that).
+     * A block about the oldest tool call that has not returned, when nothing has happened for `quietMs` (and again every
+     * `quietMs` after that). It names the last call that did finish, so a long run never looks stuck.
      */
     waiting(quietMs) {
         const now = Date.now();
         if (now - Math.max(this.lastEventAt, this.lastWaitAt) < quietMs)
-            return '';
+            return null;
         this.lastWaitAt = now;
         const [first] = [...this.pending.values()].sort((a, b) => a.startedAt - b.startedAt);
-        const quiet = seconds(now - this.lastEventAt);
-        return first
-            ? `[${clock(now)}] ... still waiting for ${first.label} (running ${seconds(now - first.startedAt)})\n`
-            : `[${clock(now)}] ... no output from the agent for ${quiet}\n`;
+        const last = this.lastCall ? ` (last: ${this.lastCall})` : '';
+        const data = first
+            ? `... still waiting for ${labelText(first)} (running ${seconds(now - first.startedAt)})`
+            : `... no output from the agent for ${seconds(now - this.lastEventAt)}${last}`;
+        return { kind: 'meta', at: now, data };
     }
     line(raw) {
         const trimmed = raw.trim();
         if (!trimmed)
-            return '';
+            return [];
         let event;
         try {
             event = JSON.parse(trimmed);
         }
         catch {
-            return `${raw}\n`;
+            // Not one of the CLI's events: keep the line as it came, it is the only trace of it.
+            return [{ kind: 'meta', at: Date.now(), data: raw.trimEnd() }];
+        }
+        if (!event || typeof event !== 'object' || typeof event.type !== 'string') {
+            return [{ kind: 'meta', at: Date.now(), data: raw.trimEnd() }];
         }
-        if (!event || typeof event !== 'object' || typeof event.type !== 'string')
-            return `${raw}\n`;
         this.lastEventAt = Date.now();
         return this.tool === 'claude' ? this.claude(event) : this.opencode(event);
     }
-    start(id, label) {
+    /** 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, { label, startedAt: now });
-        return `[${clock(now)}] >> ${label}\n`;
+        this.pending.set(id, { name: call.name, detail: call.detail, startedAt: now });
+        return [{ kind: 'tool', at: now, data: `>> ${labelText(call)}`, tool: call }];
     }
-    end1(id, ok, error, fallbackLabel) {
+    /**
+     * 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.
+     */
+    finishCall(id, ok, output, fallback) {
         const now = Date.now();
         const call = this.pending.get(id);
         this.pending.delete(id);
         if (this.cardCalls.delete(id))
             this.waitingForUser = null;
-        const label = call?.label ?? fallbackLabel ?? 'tool call';
-        const took = call ? ` after ${seconds(now - call.startedAt)}` : '';
-        const head = `[${clock(now)}] ${ok ? 'ok' : 'FAILED'}: ${label}${took}\n`;
-        return !ok && error ? `${head}    ${oneLine(error, MAX_ERROR)}\n` : head;
+        const name = call?.name ?? fallback?.name ?? 'tool';
+        const detail = call?.detail ?? fallback?.detail ?? '';
+        const startedAt = call?.startedAt ?? fallback?.startedAt;
+        const took = startedAt ? seconds(now - startedAt) : undefined;
+        const label = labelText({ name, detail });
+        this.lastCall = label;
+        const parts = [
+            {
+                kind: 'tool',
+                at: now,
+                data: `${ok ? 'ok' : 'FAILED'}: ${label}${took ? ` after ${took}` : ''}`,
+                tool: { name, detail, ok, ...(took && { took }) },
+            },
+        ];
+        if (!ok) {
+            const error = oneLine(output, MAX_ERROR);
+            if (error)
+                parts.push({ kind: 'error', at: now, data: error });
+            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 });
+        return parts;
     }
     /** Said once per run, after the first tool call that Claude Code's sandbox refused (nobody is there to approve it). */
     sandboxHint(isError, body) {
         if (this.sandboxHinted || !isError || !SANDBOX_ERROR.test(String(body ?? '')))
-            return '';
+            return null;
         this.sandboxHinted = true;
-        return (`[${clock()}] HINT: Claude Code's sandbox blocked a command and a one-shot run cannot approve it. Options:\n` +
-            '    - Switch the AI agent to OpenCode in the top bar and run again (it does not use this sandbox).\n' +
-            '    - Or run the command yourself in a terminal and paste the output into the agent.\n' +
-            '    - Or check that the command matches "sandbox.excludedCommands" in .claude/settings.json (every command of a chained call must match).\n');
+        return {
+            kind: 'hint',
+            at: Date.now(),
+            data: "HINT: Claude Code's sandbox blocked a command and a one-shot run cannot approve it. Options:\n" +
+                '  - Switch the AI agent to OpenCode in the top bar and run again (it does not use this sandbox).\n' +
+                '  - Or run the command yourself in a terminal and paste the output into the agent.\n' +
+                '  - Or check that the command matches "sandbox.excludedCommands" in .claude/settings.json (every command of a chained call must match).',
+        };
     }
     claude(event) {
         const content = event.message?.content;
         if (event.type === 'assistant' && Array.isArray(content)) {
-            return content
-                .map((block) => {
-                if (block?.type === 'text' && block.text?.trim())
-                    return `${block.text.trimEnd()}\n`;
+            return content.flatMap((block) => {
+                if (block?.type === 'text' && block.text?.trim()) {
+                    return [{ kind: 'markdown', at: Date.now(), data: block.text.trimEnd() }];
+                }
+                // A thinking block: worth reading while it waits, but never mistaken for the answer (see `--thinking`).
+                if (block?.type === 'thinking' && block.thinking?.trim()) {
+                    return [{ kind: 'reasoning', at: Date.now(), data: cap(block.thinking.trim(), MAX_REASONING) }];
+                }
                 if (block?.type === 'tool_use') {
                     this.watchHandoff(String(block.id), String(block.name), block.input, false);
-                    return this.start(String(block.id), callLabel(String(block.name), block.input));
+                    return this.start(String(block.id), callOf(String(block.name), block.input));
                 }
-                return '';
-            })
-                .join('');
+                return [];
+            });
         }
         if (event.type === 'user' && Array.isArray(content)) {
             return content
                 .filter((block) => block?.type === 'tool_result')
-                .map((block) => {
+                .flatMap((block) => {
                 const body = Array.isArray(block.content)
                     ? block.content.map((part) => part?.text ?? '').join(' ')
                     : block.content;
-                return this.end1(String(block.tool_use_id), !block.is_error, body) + this.sandboxHint(block.is_error, body);
-            })
-                .join('');
+                const hint = this.sandboxHint(block.is_error, body);
+                return [...this.finishCall(String(block.tool_use_id), !block.is_error, body), ...(hint ? [hint] : [])];
+            });
         }
         if (event.type === 'result' && event.is_error) {
-            return `[${clock()}] FAILED: ${oneLine(event.result ?? event.subtype, MAX_ERROR)}\n`;
+            return [{ kind: 'error', at: Date.now(), data: oneLine(event.result ?? event.subtype, MAX_ERROR) }];
         }
-        return '';
+        return [];
     }
     opencode(event) {
         const part = event.part ?? {};
-        if (event.type === 'text' && typeof part.text === 'string' && part.text.trim())
-            return `${part.text.trimEnd()}\n`;
+        // The CLI reports a failed turn (bad model, no credentials, a usage limit, a provider outage) as an error event,
+        // not on stderr: without this branch the log of a run that died at once showed nothing but the exit code.
+        if (event.type === 'error')
+            return this.opencodeError(event.error);
+        // `--thinking` is what makes OpenCode ask the model to think; without it these blocks are never sent.
+        if (event.type === 'reasoning' && typeof part.text === 'string' && part.text.trim()) {
+            return [{ kind: 'reasoning', at: Date.now(), data: cap(part.text.trim(), MAX_REASONING) }];
+        }
+        if (event.type === 'text' && typeof part.text === 'string' && part.text.trim()) {
+            return [{ kind: 'markdown', at: Date.now(), data: part.text.trimEnd() }];
+        }
         if (event.type === 'tool_use') {
             const state = part.state ?? {};
-            const label = callLabel(String(part.tool ?? 'tool'), state.input);
-            const id = String(part.callID ?? part.id ?? label);
+            const call = callOf(String(part.tool ?? 'tool'), state.input);
+            const id = String(part.callID ?? part.id ?? labelText(call));
             const finished = state.status === 'completed' || state.status === 'error';
-            this.watchHandoff(id, String(part.tool ?? ''), state.input, finished);
+            const hint = this.watchHandoff(id, String(part.tool ?? ''), state.input, finished, finished ? (state.error ?? state.output) : undefined);
             if (finished) {
                 const time = state.time ?? {};
-                if (!this.pending.has(id) && typeof time.start === 'number') {
-                    this.pending.set(id, { label, startedAt: time.start });
-                }
-                return this.end1(id, state.status === 'completed', state.error ?? state.output, label);
+                const parts = this.finishCall(id, state.status === 'completed', state.error ?? state.output, {
+                    ...call,
+                    ...(typeof time.start === 'number' && { startedAt: time.start }),
+                });
+                return hint ? [...parts, hint] : parts;
             }
-            return this.start(id, label);
+            const parts = this.start(id, call);
+            return hint ? [...parts, hint] : parts;
         }
-        return '';
+        return [];
     }
+    /** `FAILED: <why>`, plus what to do about the two failures users actually hit. */
+    opencodeError(error) {
+        const body = (error ?? {});
+        const now = Date.now();
+        const message = oneLine(body.message ?? body.type ?? 'the agent failed', MAX_ERROR);
+        const type = String(body.type ?? '');
+        const parts = [{ kind: 'error', at: now, data: `FAILED: ${message}` }];
+        if (type === 'provider.free-limit') {
+            const wait = typeof body.retryAfterMs === 'number' ? ` (it comes back in about ${waitFor(body.retryAfterMs)})` : '';
+            parts.push({
+                kind: 'hint',
+                at: now,
+                data: 'HINT: this run used a free OpenCode model, and its free usage limit is spent' +
+                    `${wait}. Pick a model in the top bar (it has to belong to a provider you are signed in to), ` +
+                    'or switch the AI agent to Claude. A model can also be set as "model" in opencode.jsonc.',
+            });
+        }
+        else if (type === 'provider.no-route' || type === 'provider.no-key' || type === 'provider.auth') {
+            parts.push({
+                kind: 'hint',
+                at: now,
+                data: 'HINT: the model is not available to this OpenCode install. Pick another one in the top bar, ' +
+                    'or sign the provider in with "opencode auth login".',
+            });
+        }
+        return parts;
+    }
+}
+/** A retry delay as a person reads it: `40 s`, `12.5 min`, `15.3 h`. */
+function waitFor(ms) {
+    if (ms < 90_000)
+        return `${Math.max(1, Math.round(ms / 1000))} s`;
+    if (ms < 90 * 60_000)
+        return `${(ms / 60_000).toFixed(1)} min`;
+    return `${(ms / 3_600_000).toFixed(1)} h`;
 }

package/dist/ui/server/app.js

@@ -8,10 +8,11 @@ import { listEnvs } from '../../lib/profiles.js';
 import { listSuites } from '../../lib/cases.js';
 import { FRAMEWORK_ROOT, ROOT } from '../../lib/paths.js';
 import { ActionError, buildJobSpec, planRunCases, previewRun, previewSchema, startJobSchema } from './actions.js';
-import { addProfile, listProfileRows, ProfileError, verifyProfiles } from './profiles.js';
+import { addProfile, deleteProfile, editProfile, forgetSession, listProfileRows, ProfileError, verifyProfiles } from './profiles.js';
 import { CaseError, caseImpact, createCase, deleteCase, isValidCaseId, listCaseIds, listCases, openSpec, readCase, readSpec, renameCase, writeCase, writeSpec, } from './cases.js';
 import { resolveInside, sendFile } from './files.js';
 import { JobConflictError, jobs } from './jobs.js';
+import { listAiModels } from './ai-models.js';
 import { fileEvents } from './watch-files.js';
 const REPORTS_DIR = path.join(ROOT, 'reports');
 // Built by `prepack` and shipped with the package; the framework repository builds it with `pnpm ui`.
@@ -80,21 +81,56 @@ export function createApp({ port }) {
         return c.json({ root: ROOT, envs: listEnvs(), suites, caseIds: listCaseIds() });
     });
     api.get('/profiles', (c) => c.json(listProfileRows()));
-    api.post('/profiles', async (c) => {
-        const body = z
+    const profileFields = {
+        name: z.string().max(100),
+        env: z.string().max(40),
+        baseURL: z.string().max(200),
+        account: z.string().max(200).optional(),
+        tags: z.array(z.string().max(40)).max(20).optional(),
+        startPath: z.string().max(300).optional(),
+        sessionCheckPath: z.string().max(200).optional(),
+        // Optional keys: an omitted one keeps its default. The ranges are checked by lib/profiles.ts, so the
+        // form and a hand-edited profiles.yaml fail with the same message.
+        sessionCheck: z
             .object({
-            id: z.string().max(60),
-            name: z.string().max(100),
-            env: z.string().max(40),
-            baseURL: z.string().max(200),
-            account: z.string().max(200).optional(),
-            tags: z.array(z.string().max(40)).max(20).optional(),
-            sessionCheckPath: z.string().max(200).optional(),
-            email: z.boolean().optional(),
+            loggedOutUrl: z.string().max(300).optional(),
+            loggedInSelector: z.string().max(300).optional(),
+            loggedOutSelector: z.string().max(300).optional(),
+            timeoutMs: z.number().int().optional(),
         })
-            .parse(await c.req.json());
+            .optional(),
+        email: z.boolean().optional(),
+    };
+    api.post('/profiles', async (c) => {
+        const body = z.object({ id: z.string().max(60), ...profileFields }).parse(await c.req.json());
         return c.json(addProfile(body), 201);
     });
+    // A running job read profiles.yaml at its start and uses the session files while it runs, so a profile
+    // cannot change underneath it.
+    const assertProfileIdle = (id) => {
+        const busy = jobs
+            .list()
+            .find((job) => job.status === 'running' &&
+            (job.kind === 'run' ||
+                job.kind === 'ai' ||
+                (job.profile === id && (job.kind === 'signin' || job.kind === 'visit'))));
+        if (busy)
+            throw new ProfileError(`Wait for "${busy.command}" to finish first.`, 409);
+    };
+    // The id is fixed: commands, session files and baseline names use it. Changing the site address logs the profile out.
+    api.put('/profiles/:id', async (c) => {
+        const id = c.req.param('id');
+        assertProfileIdle(id);
+        const body = z.object(profileFields).parse(await c.req.json());
+        return c.json(editProfile({ ...body, id }));
+    });
+    // Removes the entry from profiles.yaml and deletes the saved login. Never reads the session file.
+    api.delete('/profiles/:id', (c) => {
+        const id = c.req.param('id');
+        assertProfileIdle(id);
+        deleteProfile(id);
+        return c.json(listProfileRows());
+    });
     api.post('/profiles/verify', async (c) => {
         const body = z
             .object({ profile: z.string().optional(), env: z.string().optional() })
@@ -104,6 +140,13 @@ export function createApp({ port }) {
         await new Promise((resolve) => setTimeout(resolve, 20));
         return c.json(listProfileRows());
     });
+    // Forgets the saved login of one profile. Never reads it: the file is only deleted.
+    api.post('/profiles/logout', async (c) => {
+        const { profile: id } = z.object({ profile: z.string().min(1).max(60) }).parse(await c.req.json());
+        assertProfileIdle(id);
+        forgetSession(id);
+        return c.json(listProfileRows());
+    });
     api.get('/cases', (c) => c.json(listCases()));
     api.post('/cases', async (c) => {
         const { id } = z.object({ id: z.string() }).parse(await c.req.json());
@@ -172,6 +215,19 @@ export function createApp({ port }) {
         const image = resolveInside(dir, file);
         return image ? sendFile(c, image) : c.notFound();
     });
+    // A reference screenshot of a target card: the case names it as a project-relative path under `.explore/`, which is
+    // local state and git-ignored, so the file may be missing on this machine. Only images, only inside `.explore/`.
+    const REFERENCE_IMAGE = /\.(png|jpe?g|webp)$/i;
+    app.get('/explore-files', (c) => {
+        const file = (c.req.query('file') ?? '').replace(/\\/g, '/');
+        if (!file.startsWith('.explore/') || file.includes('..') || !REFERENCE_IMAGE.test(file))
+            return c.notFound();
+        const base = path.join(ROOT, '.explore');
+        if (!fs.existsSync(base))
+            return c.notFound();
+        const image = resolveInside(base, file.slice('.explore/'.length));
+        return image ? sendFile(c, image) : c.notFound();
+    });
     api.get('/reports', (c) => {
         if (!fs.existsSync(REPORTS_DIR))
             return c.json([]);
@@ -205,6 +261,12 @@ export function createApp({ port }) {
     });
     api.post('/runs/preview', async (c) => c.json(previewRun(previewSchema.parse(await c.req.json()))));
     api.post('/runs/plan', async (c) => c.json(await planRunCases(previewSchema.parse(await c.req.json()))));
+    // The models the chosen AI CLI can be run with here (read from the CLI or its configuration, never from a list
+    // this app ships). `?refresh=1` reads them again instead of using the short cache.
+    api.get('/ai/models', async (c) => {
+        const tool = c.req.query('tool') === 'claude' ? 'claude' : 'opencode';
+        return c.json(await listAiModels(tool, c.req.query('refresh') === '1'));
+    });
     api.get('/jobs', (c) => c.json(jobs.list()));
     api.post('/jobs', async (c) => {
         const request = startJobSchema.parse(await c.req.json());

package/dist/ui/server/jobs.d.ts

@@ -12,7 +12,7 @@ export interface JobSpec {
     env?: string;
     /** Shown to the user. */
     command: string;
-    /** Executable and arguments, spawned without a shell. */
+    /** Executable and arguments: looked up on PATH, spawned without a shell (a Windows `.cmd` shim goes through cmd.exe). */
     file: string;
     args: string[];
     /** Jobs holding the same lock cannot run at the same time. */
@@ -31,6 +31,8 @@ export interface JobSpec {
         caseId: string;
         env: string;
         sessionId: string;
+        model?: string;
+        thinking?: boolean;
     };
     /** The job whose conversation this one continues. */
     continuesJobId?: string;
@@ -65,7 +67,11 @@ declare class JobManager {
     /** Publishes a change of "waiting for the person" (a handoff card) like any other status change. */
     private syncAwaiting;
     private signalGroup;
+    /** A block of an AI run's log, with the time it was produced and how the UI should present it. */
+    private pushPart;
     private push;
+    /** Keeps the chunk for the browser and writes it to the job's log file, which is what is left after the run. */
+    private store;
     private finish;
     private pruneFinished;
     private pruneOldLogs;