@asrunjs/asrun 0.2.0 → 0.5.2

package/dist/ui/server/jobs.js

@@ -1,10 +1,11 @@
-import { spawn } from 'node:child_process';
+import { spawn, spawnSync } from 'node:child_process';
 import { EventEmitter } from 'node:events';
 import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 import { StringDecoder } from 'node:string_decoder';
 import { ROOT } from '../../lib/paths.js';
+import { spawnTarget } from '../../lib/command.js';
 import { AiStreamFormatter } from './ai-stream.js';
 const LOG_DIR = path.join(ROOT, '.tmp', 'ui-jobs');
 const MAX_BUFFERED_CHARS = 4_000_000;
@@ -17,16 +18,36 @@ const HEARTBEAT_MS = 15_000;
 export class JobConflictError extends Error {
 }
 const ANSI = /\u001b\[[0-9;?]*[ -/]*[@-~]/g;
-/** The last `RESULT: ready|needs-input` line of what the agent printed (markdown emphasis around it is fine). */
+/** The last `RESULT: ready|needs-input` line the agent said (markdown emphasis around it is fine). */
 function parseResultState(record) {
     const text = record.chunks
-        .filter((chunk) => chunk.stream !== 'system')
+        // Only what the agent said counts: a file it read or a page it dumped may quote the same words.
+        .filter((chunk) => (chunk.kind ? chunk.kind === 'markdown' : chunk.stream !== 'system'))
         .map((chunk) => chunk.data)
-        .join('')
+        .join('\n')
         .replace(ANSI, '');
     const matches = [...text.matchAll(/^[\s*`>_-]*RESULT:\s*(ready|needs-input)\b/gm)];
     return matches.at(-1)?.[1] ?? null;
 }
+/**
+ * A block of an AI run as the log file keeps it: the same text the UI shows, with the timestamp the UI styles written
+ * out, and the output of a call indented under the call it belongs to. The file is read in a terminal or an editor, so
+ * it has to make sense without the colors.
+ */
+function logFileText(part) {
+    const stamp = `[${new Date(part.at).toTimeString().slice(0, 8)}] `;
+    // What the agent said is separated by a blank line: it is the answer, not another line of the action above it.
+    if (part.kind === 'markdown')
+        return `\n${part.data}\n`;
+    if (part.kind === 'result' || part.kind === 'reasoning') {
+        const mark = part.kind === 'reasoning' ? '~ ' : '';
+        return part.data
+            .split('\n')
+            .map((line, index) => `    ${index === 0 ? mark : ''}${line}\n`)
+            .join('');
+    }
+    return `${stamp}${part.data}\n`;
+}
 class JobManager {
     jobs = new Map();
     /** Emits `job` with a JobInfo on every status change of any job. */
@@ -71,6 +92,7 @@ class JobManager {
                     caseId: spec.ai.caseId,
                     aiCommand: spec.ai.command,
                     sessionId: spec.ai.sessionId,
+                    ...(spec.ai.model && { aiModel: spec.ai.model }),
                     resultState: null,
                 }),
                 ...(spec.continuesJobId && { continuesJobId: spec.continuesJobId }),
@@ -89,13 +111,23 @@ class JobManager {
         record.emitter.setMaxListeners(0);
         this.jobs.set(id, record);
         this.push(record, 'system', `$ ${spec.command}\n`);
+        // A CLI installed globally is a `.cmd` shim on Windows, which spawn cannot start on its own (see lib/command.ts).
+        const target = spawnTarget(spec.file, spec.args);
+        if (target === null) {
+            this.finish(record, null, null, `Failed to start: "${spec.file}" was not found on PATH. Install it, or choose the other tool.`);
+            return record.info;
+        }
         let child;
         try {
-            child = spawn(spec.file, spec.args, {
+            child = spawn(target.file, target.args, {
                 cwd: ROOT,
-                detached: true,
+                // Off Windows the group is what `cancel` signals. On Windows a detached child loses the output of a `.cmd`
+                // shim, and the tree is ended with taskkill instead (see signalGroup).
+                detached: process.platform !== 'win32',
                 stdio: [spec.acceptsInput ? 'pipe' : 'ignore', 'pipe', 'pipe'],
                 env: { ...process.env, FORCE_COLOR: '1', NO_COLOR: undefined },
+                windowsHide: true,
+                ...(target.throughShell && { windowsVerbatimArguments: true }),
             });
         }
         catch (error) {
@@ -107,9 +139,10 @@ class JobManager {
             const decoder = new StringDecoder('utf8');
             const formatted = stream === 'stdout' ? record.formatter : null;
             const emit = (text) => {
-                const out = formatted ? formatted.feed(text) : text;
-                if (out)
-                    this.push(record, stream, out);
+                if (formatted)
+                    formatted.feed(text).forEach((part) => this.pushPart(record, part));
+                else
+                    this.push(record, stream, text);
                 this.syncAwaiting(record);
             };
             child[stream]?.on('data', (buffer) => {
@@ -121,9 +154,7 @@ class JobManager {
                 const rest = decoder.end();
                 if (rest)
                     emit(rest);
-                const tail = formatted?.end();
-                if (tail)
-                    this.push(record, stream, tail);
+                formatted?.end().forEach((part) => this.pushPart(record, part));
             });
         }
         if (record.formatter) {
@@ -131,7 +162,7 @@ class JobManager {
             record.heartbeat = setInterval(() => {
                 const line = formatter.waiting(QUIET_MS);
                 if (line)
-                    this.push(record, 'system', line);
+                    this.pushPart(record, line);
             }, HEARTBEAT_MS);
             record.heartbeat.unref();
         }
@@ -194,6 +225,12 @@ class JobManager {
         this.events.emit('job', info);
     }
     signalGroup(pid, signal) {
+        if (process.platform === 'win32') {
+            // Windows has no process groups (a negative pid throws ESRCH), so the whole tree is ended at once:
+            // cmd.exe, the agent CLI it started, and anything below them.
+            spawnSync('taskkill', ['/pid', String(pid), '/T', '/F'], { stdio: 'ignore', windowsHide: true });
+            return;
+        }
         try {
             process.kill(-pid, signal);
         }
@@ -201,14 +238,31 @@ class JobManager {
             // Already gone.
         }
     }
+    /** A block of an AI run's log, with the time it was produced and how the UI should present it. */
+    pushPart(record, part) {
+        const stream = part.kind === 'error' ? 'stderr' : part.kind === 'markdown' || part.kind === 'result' ? 'stdout' : 'system';
+        const chunk = {
+            seq: record.nextSeq++,
+            stream,
+            data: part.data,
+            kind: part.kind,
+            at: new Date(part.at).toISOString(),
+            ...(part.tool && { tool: part.tool }),
+        };
+        this.store(record, chunk, logFileText(part));
+    }
     push(record, stream, data) {
         const chunk = { seq: record.nextSeq++, stream, data };
+        this.store(record, chunk, stream === 'stderr' ? `[stderr] ${data}` : data);
+    }
+    /** Keeps the chunk for the browser and writes it to the job's log file, which is what is left after the run. */
+    store(record, chunk, fileText) {
         record.chunks.push(chunk);
-        record.bufferedChars += data.length;
+        record.bufferedChars += chunk.data.length;
         while (record.bufferedChars > MAX_BUFFERED_CHARS && record.chunks.length > 1) {
             record.bufferedChars -= record.chunks.shift().data.length;
         }
-        record.logStream.write(stream === 'stderr' ? `[stderr] ${data}` : data);
+        record.logStream.write(fileText);
         record.emitter.emit('chunk', chunk);
     }
     finish(record, code, signal, note) {

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

@@ -1,4 +1,4 @@
-import type { AddProfileRequest, ProfileInfo, ProfilesResponse } from '../shared/types.js';
+import type { AddProfileRequest, EditProfileRequest, EditProfileResult, ProfileInfo, ProfilesResponse } from '../shared/types.js';
 export declare function listProfileRows(): ProfilesResponse;
 /** Opens each saved session on the real site (read-only) and records whether it is still logged in. */
 export declare function verifyProfiles(only?: {
@@ -14,3 +14,22 @@ export declare class ProfileError extends Error {
  * existing entries stay as they are.
  */
 export declare function addProfile(request: AddProfileRequest, file?: string): ProfileInfo;
+/**
+ * Deletes the saved login of one profile, so it has to log in again. The file holds the session cookies
+ * and is never read here, only removed.
+ */
+export declare function forgetSession(id: string, file?: string): ProfileInfo;
+/**
+ * Removes one profile from profiles.yaml and deletes its saved login. Only that entry is written, so the
+ * comments and the other entries stay in the file. Screenshot baselines named after the id stay on disk:
+ * they are files of the cases, not of the profile.
+ */
+export declare function deleteProfile(id: string, file?: string): void;
+/**
+ * Changes the fields of one existing profile. Only the fields that actually changed are written, so
+ * comments on the others stay in the file. When the site address changes, the saved login belongs to
+ * the old site and is deleted: the profile has to log in again on the new one.
+ */
+export declare function editProfile(request: EditProfileRequest & {
+    id: string;
+}, file?: string): EditProfileResult;

package/dist/ui/server/profiles.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import { chromium } from '@playwright/test';
 import { isMap, isSeq, parseDocument } from 'yaml';
-import { listEnvs, listProfiles, loadProfiles, PROFILES_FILE } from '../../lib/profiles.js';
+import { DEFAULT_SESSION_CHECK_PATH, DEFAULT_SESSION_CHECK, listEnvs, listProfiles, loadProfiles, PROFILES_FILE, validateSessionCheck } from '../../lib/profiles.js';
 import { authFile } from '../../lib/paths.js';
 import { checkSession } from '../../lib/session.js';
 import { withScheme } from '../shared/site-address.js';
@@ -16,10 +16,13 @@ function savedAt(profileId) {
 const toInfo = (profile) => {
     const saved = savedAt(profile.id);
     const verification = verifications.get(profile.id);
+    // A session file saved after the check (a new login from the CLI, another browser tab) makes the old
+    // result stale, so the row shows "unverified" until it is checked again.
+    const stale = Boolean(saved && verification && saved > verification.checkedAt);
     let status;
     if (!saved)
         status = 'missing';
-    else if (!verification)
+    else if (!verification || stale)
         status = 'unverified';
     else
         status = verification.status === 'missing' ? 'unverified' : verification.status;
@@ -30,6 +33,10 @@ const toInfo = (profile) => {
         baseURL: profile.baseURL,
         account: profile.account,
         tags: profile.tags,
+        startPath: profile.startPath,
+        sessionCheckPath: profile.sessionCheckPath,
+        sessionCheck: profile.sessionCheck,
+        email: profile.email,
         status,
         verifying: verifying.has(profile.id),
         savedAt: saved,
@@ -113,20 +120,14 @@ function parseSiteAddress(text, label) {
     return url;
 }
 const normalTags = (tags) => [...new Set((tags ?? []).map((tag) => tag.trim()).filter(Boolean))];
-/**
- * Appends one profile to profiles.yaml. The file is edited as a YAML document, so comments and the
- * existing entries stay as they are.
- */
-export function addProfile(request, file = PROFILES_FILE) {
-    const id = request.id.trim();
+function readFields(request) {
     const name = request.name.trim();
     const env = request.env.trim();
     const account = request.account?.trim() || undefined;
+    const startPath = request.startPath?.trim() || undefined;
     const sessionCheckPath = request.sessionCheckPath?.trim() || undefined;
-    const tags = normalTags(request.tags);
-    if (!PROFILE_ID.test(id)) {
-        throw new ProfileError('Profile id must be lowercase letters and digits, separated by single dashes (e.g. "example-staging").', 400);
-    }
+    // Same rules as the loader, so the file the form writes is one `pnpm asrun` accepts.
+    const sessionCheck = validateSessionCheck('Session check', request.sessionCheck ?? null);
     if (!name)
         throw new ProfileError('Name is required.', 400);
     if (!ENV_NAME.test(env)) {
@@ -136,9 +137,68 @@ export function addProfile(request, file = PROFILES_FILE) {
         throw new ProfileError('email: true is not allowed. Tests never send email in production.', 400);
     }
     const baseURL = parseSiteAddress(request.baseURL, 'Base URL').origin;
+    if (startPath && (!startPath.startsWith('/') || startPath.startsWith('//') || /\s/.test(startPath))) {
+        throw new ProfileError('Start path must be empty (the site root) or a path on the site that starts with a single "/" and contains no spaces.', 400);
+    }
     if (sessionCheckPath && (!sessionCheckPath.startsWith('/') || /\s/.test(sessionCheckPath))) {
         throw new ProfileError('Session check path must start with "/" and contain no spaces.', 400);
     }
+    return {
+        name,
+        env,
+        baseURL,
+        account,
+        tags: normalTags(request.tags),
+        startPath,
+        sessionCheckPath,
+        sessionCheck,
+        email: request.email === true,
+    };
+}
+/** The `sessionCheck` keys that differ from the defaults, or null when the profile can rely on them. */
+function sessionCheckEntry(check) {
+    const entry = {};
+    if (check.loggedOutUrl !== DEFAULT_SESSION_CHECK.loggedOutUrl)
+        entry.loggedOutUrl = check.loggedOutUrl;
+    if (check.loggedInSelector)
+        entry.loggedInSelector = check.loggedInSelector;
+    if (check.loggedOutSelector)
+        entry.loggedOutSelector = check.loggedOutSelector;
+    if (check.timeoutMs !== DEFAULT_SESSION_CHECK.timeoutMs)
+        entry.timeoutMs = check.timeoutMs;
+    return Object.keys(entry).length > 0 ? entry : null;
+}
+const sameSessionCheck = (a, b) => a.loggedOutUrl === b.loggedOutUrl &&
+    a.loggedInSelector === b.loggedInSelector &&
+    a.loggedOutSelector === b.loggedOutSelector &&
+    a.timeoutMs === b.timeoutMs;
+/**
+ * Writes the edited YAML document and restores the old file when the result cannot be loaded, so a
+ * failed save never leaves a profiles.yaml behind that the test runner cannot read.
+ */
+function saveDocument(file, doc, original, action) {
+    const temp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(temp, doc.toString());
+    fs.renameSync(temp, file);
+    try {
+        loadProfiles(file);
+    }
+    catch (error) {
+        fs.writeFileSync(file, original);
+        throw new ProfileError(`Could not ${action}: ${error.message}`, 400);
+    }
+}
+const sameList = (a, b) => a.length === b.length && a.every((value, index) => value === b[index]);
+/**
+ * Appends one profile to profiles.yaml. The file is edited as a YAML document, so comments and the
+ * existing entries stay as they are.
+ */
+export function addProfile(request, file = PROFILES_FILE) {
+    const id = request.id.trim();
+    const fields = readFields(request);
+    if (!PROFILE_ID.test(id)) {
+        throw new ProfileError('Profile id must be lowercase letters and digits, separated by single dashes (e.g. "example-staging").', 400);
+    }
     if (loadProfiles(file).some((profile) => profile.id === id)) {
         throw new ProfileError(`Profile "${id}" already exists.`, 409);
     }
@@ -153,43 +213,159 @@ export function addProfile(request, file = PROFILES_FILE) {
     // `profiles: []` is a flow sequence; adding a map entry to it would render `[ { ... } ]`. Keep the file block-style.
     profiles.flow = false;
     const hadEntries = profiles.items.length > 0;
+    const check = sessionCheckEntry(fields.sessionCheck);
     const entry = doc.createNode({
         id,
-        name,
-        env,
-        baseURL,
-        ...(account && { account }),
-        ...(tags.length > 0 && { tags }),
-        ...(sessionCheckPath && { sessionCheckPath }),
+        name: fields.name,
+        env: fields.env,
+        baseURL: fields.baseURL,
+        ...(fields.account && { account: fields.account }),
+        ...(fields.tags.length > 0 && { tags: fields.tags }),
+        ...(fields.startPath && { startPath: fields.startPath }),
+        ...(fields.sessionCheckPath && { sessionCheckPath: fields.sessionCheckPath }),
+        ...(check && { sessionCheck: check }),
         // Never send email from a new profile until a human has checked that a mailbox is connected.
-        email: request.email === true ? true : false,
+        email: fields.email,
     });
     if (isMap(entry)) {
         entry.spaceBefore = hadEntries;
         entry.flow = false;
     }
     profiles.add(entry);
-    const temp = `${file}.${process.pid}.tmp`;
-    fs.writeFileSync(temp, doc.toString());
-    fs.renameSync(temp, file);
-    // Never leave a file behind that the test runner cannot load.
-    try {
-        loadProfiles(file);
+    saveDocument(file, doc, original, 'add the profile');
+    return toInfo(loadProfiles(file).find((profile) => profile.id === id));
+}
+/**
+ * Deletes the saved login of one profile, so it has to log in again. The file holds the session cookies
+ * and is never read here, only removed.
+ */
+export function forgetSession(id, file = PROFILES_FILE) {
+    const profile = loadProfiles(file).find((candidate) => candidate.id === id);
+    if (!profile)
+        throw new ProfileError(`Profile "${id}" is not in profiles.yaml any more. Reload the page.`, 409);
+    fs.rmSync(authFile(id), { force: true });
+    verifications.delete(id);
+    return toInfo(profile);
+}
+/**
+ * Removes one profile from profiles.yaml and deletes its saved login. Only that entry is written, so the
+ * comments and the other entries stay in the file. Screenshot baselines named after the id stay on disk:
+ * they are files of the cases, not of the profile.
+ */
+export function deleteProfile(id, file = PROFILES_FILE) {
+    const profile = loadProfiles(file).find((candidate) => candidate.id === id);
+    if (!profile)
+        throw new ProfileError(`Profile "${id}" is not in profiles.yaml any more. Reload the page.`, 409);
+    const original = fs.readFileSync(file, 'utf8');
+    const doc = parseDocument(original, { merge: true });
+    if (doc.errors.length > 0) {
+        throw new ProfileError('profiles.yaml has syntax errors; fix it by hand first.', 400);
     }
-    catch (error) {
-        fs.writeFileSync(file, original);
-        throw new ProfileError(`Could not add the profile: ${error.message}`, 400);
+    const profiles = doc.get('profiles');
+    if (!isSeq(profiles))
+        throw new ProfileError('profiles.yaml has no "profiles" list.', 400);
+    const index = profiles.items.findIndex((item) => isMap(item) && item.get('id') === id);
+    if (index < 0)
+        throw new ProfileError(`Profile "${id}" is not in profiles.yaml any more. Reload the page.`, 409);
+    profiles.delete(index);
+    // The entry that is first now keeps the blank line of the one before it; drop it so `profiles:` is followed
+    // directly by the entry, like a hand-written file.
+    const first = profiles.items[0];
+    if (isMap(first))
+        first.spaceBefore = false;
+    // A `profiles:` with nothing under it is null; the loader needs a list (it may be empty while the suite is
+    // set up), so an emptied list is written as `[]`.
+    if (profiles.items.length === 0)
+        profiles.flow = true;
+    saveDocument(file, doc, original, 'delete the profile');
+    // The saved login belonged to this profile. The file is never read here, only removed.
+    fs.rmSync(authFile(id), { force: true });
+    verifications.delete(id);
+}
+/**
+ * Changes the fields of one existing profile. Only the fields that actually changed are written, so
+ * comments on the others stay in the file. When the site address changes, the saved login belongs to
+ * the old site and is deleted: the profile has to log in again on the new one.
+ */
+export function editProfile(request, file = PROFILES_FILE) {
+    const id = request.id.trim();
+    if (!PROFILE_ID.test(id)) {
+        throw new ProfileError('Profile id must be lowercase letters and digits, separated by single dashes (e.g. "example-staging").', 400);
+    }
+    const fields = readFields(request);
+    const before = loadProfiles(file).find((profile) => profile.id === id);
+    if (!before)
+        throw new ProfileError(`Profile "${id}" is not in profiles.yaml any more. Reload the page.`, 409);
+    const original = fs.readFileSync(file, 'utf8');
+    const doc = parseDocument(original, { merge: true });
+    if (doc.errors.length > 0) {
+        throw new ProfileError('profiles.yaml has syntax errors; fix it by hand first.', 400);
+    }
+    const profiles = doc.get('profiles');
+    if (!isSeq(profiles))
+        throw new ProfileError('profiles.yaml has no "profiles" list.', 400);
+    const entry = profiles.items.find((item) => isMap(item) && item.get('id') === id);
+    if (!isMap(entry))
+        throw new ProfileError(`Profile "${id}" is not in profiles.yaml any more. Reload the page.`, 409);
+    if (fields.name !== before.name)
+        entry.set('name', fields.name);
+    if (fields.env !== before.env)
+        entry.set('env', fields.env);
+    if (fields.baseURL !== before.baseURL)
+        entry.set('baseURL', fields.baseURL);
+    if (fields.account) {
+        if (fields.account !== before.account)
+            entry.set('account', fields.account);
+    }
+    else if (entry.has('account')) {
+        entry.delete('account');
+    }
+    if (!sameList(fields.tags, before.tags)) {
+        if (fields.tags.length > 0)
+            entry.set('tags', fields.tags);
+        else
+            entry.delete('tags');
+    }
+    // An empty path means the site root; drop an explicit key instead of writing an empty one.
+    if (fields.startPath) {
+        if (fields.startPath !== before.startPath || !entry.has('startPath')) {
+            entry.set('startPath', fields.startPath);
+        }
+    }
+    else if (entry.has('startPath')) {
+        entry.delete('startPath');
+    }
+    // An omitted path means the default; drop an explicit key instead of writing the default out.
+    if (fields.sessionCheckPath && fields.sessionCheckPath !== DEFAULT_SESSION_CHECK_PATH) {
+        if (fields.sessionCheckPath !== before.sessionCheckPath || !entry.has('sessionCheckPath')) {
+            entry.set('sessionCheckPath', fields.sessionCheckPath);
+        }
+    }
+    else if (entry.has('sessionCheckPath')) {
+        entry.delete('sessionCheckPath');
+    }
+    // The same for the session check signals: write only what differs from the defaults, so the entry
+    // stays readable (and a comment above it stays in place when nothing about it changed).
+    if (!sameSessionCheck(fields.sessionCheck, before.sessionCheck)) {
+        const check = sessionCheckEntry(fields.sessionCheck);
+        if (check)
+            entry.set('sessionCheck', check);
+        else
+            entry.delete('sessionCheck');
+    }
+    if (fields.email !== before.email)
+        entry.set('email', fields.email);
+    saveDocument(file, doc, original, 'save the profile');
+    const siteChanged = fields.baseURL !== before.baseURL;
+    const hadSession = siteChanged && fs.existsSync(authFile(id));
+    if (siteChanged) {
+        // The saved login holds cookies of the old site. Deleting the file (never reading it) makes the
+        // profile log in again on the new address.
+        fs.rmSync(authFile(id), { force: true });
+        verifications.delete(id);
     }
     return {
-        id,
-        name,
-        env,
-        baseURL,
-        account: account ?? null,
-        tags,
-        status: 'missing',
-        verifying: false,
-        savedAt: null,
-        checkedAt: null,
+        profile: toInfo(loadProfiles(file).find((profile) => profile.id === id)),
+        sessionCleared: hadSession,
     };
 }

package/dist/ui/shared/ai-commands.d.ts

@@ -21,10 +21,17 @@ export declare const AI_ENV_HINT: Record<AiCommand, string>;
 export interface AiRunOptions {
     /** The environment to explore. There is no default. */
     env: string;
+    /**
+     * The model to run the agent with, as `provider/model` (`#variant` for OpenCode) or a Claude alias/name.
+     * Omitted = whatever the CLI would pick by itself, which for OpenCode is its built-in free model.
+     */
+    model?: string;
     /** `gen-spec` only: regenerate and overwrite an existing spec instead of leaving it alone. */
     force?: boolean;
     /** `explore-case` only: a person is at the machine, so steps that write data are handed to them in the browser. */
     attended?: boolean;
+    /** Show the agent's reasoning in the log (`--thinking` for OpenCode). Off by default: it costs tokens and time. */
+    thinking?: boolean;
     /** `heal-spec` only: the profiles to heal. Omitted = every profile that is logged in in `env`. */
     profiles?: string[];
     /** `heal-spec` only: file (relative to the project root) with the user's description and clues. */
@@ -53,26 +60,29 @@ export declare function headlessCommandLine(tool: AiTool, command: AiCommand, ca
 /** Folder (relative to the AsRun root, git-ignored) where the clues typed into the Heal dialog are stored. */
 export declare const HINTS_DIR = ".tmp/hints";
 export declare const HINTS_MAX_CHARS = 8000;
+/** Folder (relative to the AsRun root, git-ignored) where the answers typed into the Continue box are stored. */
+export declare const REPLY_DIR = ".tmp/replies";
 export declare const REPLY_MAX_CHARS = 4000;
 export declare const USE_DEFAULTS_REPLY = "Accept the suggestion of every open question: delete its TODO block and keep the sentence above it as confirmed text.";
 /**
  * The next turn of a run that ended with `RESULT: needs-input`: the user's answers. They go into the case file, which
- * stays the record of truth, and the task of the original command is finished.
+ * stays the record of truth, and the task of the original command is finished. The answers come from a file
+ * (`.tmp/replies/…md`) rather than from the prompt, so a line break or a quote in them cannot break the command line.
  */
-export declare function replyPrompt(command: AiCommand, reply: string): string;
+export declare function replyPrompt(command: AiCommand, replyFile: string): string;
 /** The next turn of an earlier run, in its session and with exactly the permissions of the first turn. */
-export declare function continueInvocation(tool: AiTool, command: AiCommand, reply: string, sessionId: string): {
+export declare function continueInvocation(tool: AiTool, command: AiCommand, replyFile: string, sessionId: string, model?: string, thinking?: boolean): {
     file: string;
     args: string[];
 };
-export declare const continueCommandLine: (tool: AiTool, command: AiCommand, reply: string, sessionId: string) => string;
+export declare const continueCommandLine: (tool: AiTool, command: AiCommand, replyFile: string, sessionId: string, model?: string, thinking?: boolean) => string;
 /** Folder (relative to the AsRun root, git-ignored) where memos from the Cases page are stored. */
 export declare const MEMO_DIR = ".tmp/memos";
 export declare const MEMO_MAX_CHARS = 100000;
 /** /make-case is interactive by design; a one-shot run cannot answer questions, so it must use the defaults. */
 export declare const makeCasePrompt: (memoPath: string) => string;
-export declare const makeCaseInvocation: (tool: AiTool, memoPath: string) => {
+export declare const makeCaseInvocation: (tool: AiTool, memoPath: string, model?: string, thinking?: boolean) => {
     file: string;
     args: string[];
 };
-export declare const makeCaseCommandLine: (tool: AiTool, memoPath: string) => string;
+export declare const makeCaseCommandLine: (tool: AiTool, memoPath: string, model?: string, thinking?: boolean) => string;