Release v0.11.0

Co-Authored-By: Claude Opus 5.5 <[email protected]>

AGENTS.md

@@ -54,7 +54,7 @@ Enables SQLite foreign keys (`enableForeignKeys`), `bunextInit()`, `ensureDocker
 
 ### Auth
 
-- **Guard:** `src/pages/__root.server.ts` on every request. No public pages: anything outside `AdminSections` (`src/dict/admin-sections-dict.ts`) and `/auth` redirects to `/admin/bots`. No users -> `/auth/signup` (first-run super admin only); unauthenticated `/admin/*` -> `/auth/login`; authenticated `/auth/*` (not logout) -> `/admin/bots`; unknown `/admin/settings/*` -> `/admin/settings/general`.
+- **Guard:** `src/pages/__root.server.ts` on every request. No public pages: anything outside `AdminSections` (`src/dict/admin-sections-dict.ts`) and `/auth` redirects to `/admin/bots`. No users -> `/auth/signup` (first-run super admin only, which then opens the skippable guided setup `/admin/settings/setup`: app name, provider, models, where to go next; it stays under Settings); unauthenticated `/admin/*` -> `/auth/login`; authenticated `/auth/*` (not logout) -> `/admin/bots`; unknown `/admin/settings/*` -> `/admin/settings/general`.
 - **Session:** AES-256-GCM cookie (key from `ENCRYPTION_KEY`/`ENCRYPTION_SALT`) plus CSRF cookie, `Secure` only over HTTPS (`isSecureRequest`, honours `X-Forwarded-Proto`). `userAuth` (`src/functions/backend/auth/user-auth.ts`) checks expiry (60 days), CSRF (constant-time) and re-reads `user_types` every request.
 - **Login:** email/username + password (`api/auth/password-login.ts`, rate limited). No emailed codes or resets. Google login only for existing accounts, when `GOOGLE_CLIENT_ID` is set. Sessions issued by `login-user.ts`.
 - **Passwords:** bcrypt in `user_passwords` (never in `users`; blocked from CRUD via `src/dict/private-tables.ts`).
@@ -88,14 +88,17 @@ Enables SQLite foreign keys (`enableForeignKeys`), `bunextInit()`, `ensureDocker
 ### Bots, sessions, chat
 
 - **Tables:** `bots` (`kind`, `color` `#rrggbb`, `stone`, `role`, `system_prompt`; `hue` is a legacy fallback), `bot_user_faces`, `bot_sessions`, `bot_messages`, `bot_tasks`, `bot_task_steps` (unused yet). Enums in `src/dict/bot-dict.ts`.
-- **Sessions:** one thread per user per bot in its own chat plus one per workspace; split into `bot_sessions` (rollover at the app setting `bot_session_max_messages`, default `AppData.BotSessionMaxMessages`, via `grabBotSessionMaxMessages`; titled and summarised by `name-bot-session.ts` from the session's opening (`grabSessionOpening`; `grabBotMessages` reads the latest), summary carried into the next session only when they're linked by `previous_session_id`, which only a carry-over sets; older implicit links are cleared at boot by `clearImplicitSessionLinks`). New session (`startBotSession`) and a conversation with no active session always start fresh. The rollover carries over like the bot does (`rollOverBotSession` -> `continueBotSession`, falling back to the stored summary; kept for the next message while a job is open in the full session or there's nothing to carry), inside send-message, so the user's message lands under the summary. Helpers in `src/functions/backend/db/bot-sessions/`. Job results land in the job's own session, even after it closes, except a reply that called `continue_in_new_session` (`carryOverBotSession`; the menu's and sessions modal's Continue in new session does the same through `continueBotSession`, the model writing title and summary, refused while a job is open in the session): its summary is kept on the closed session and opens the new one as a bot message (`carried_from_session_id`), the job's `session_id` moves so the answer follows, the new session is titled by the bot then (it has no first exchange to be named from), and the old one can never be reopened (`reopenBotSession` refuses; a thread showing it swaps its composer for a link to the new one). Session lists (rail, sessions modal) reopen a session on click, as before; a carried-over one can't be, so it opens to read (`?session_id=`, `conversationHref`). The page tells them which session it shows (`announceShownSession` -> `useShownSession`): they reload, mark it Current (greyed out; without `?session_id=` the active one is), list it even when it's older than the rail's latest, and the active row then leads back. From half the session length the reply prompt suggests moving on (`longSessionNote`). Earlier sessions never enter the prompt (only the last one's summary): the thread can open them above a session (`useOlderMessages.loadPrevious`, a divider per session, quote and reply as usual), and replies get `search_past_sessions`/`read_past_session` (scoped to that user, bot and place, never the current session) when the conversation has any.
+- **Sessions:** one thread per user per bot in its own chat plus one per workspace; split into `bot_sessions` (rollover at the app setting `bot_session_max_messages`, default `AppData.BotSessionMaxMessages`, via `grabBotSessionMaxMessages`; titled and summarised by `name-bot-session.ts` from the session's opening after a reply or a task (a session with no user message, work handed to the bot, is named from the bot's own messages; `grabSessionOpening`; `grabBotMessages` reads the latest), summary carried into the next session only when they're linked by `previous_session_id`, which only a carry-over sets; older implicit links are cleared at boot by `clearImplicitSessionLinks`). New session (`startBotSession`) and a conversation with no active session always start fresh. The rollover carries over like the bot does (`rollOverBotSession` -> `continueBotSession`, falling back to the stored summary; kept for the next message while a job is open in the full session or there's nothing to carry), inside send-message, so the user's message lands under the summary. Helpers in `src/functions/backend/db/bot-sessions/`. Job results land in the job's own session, even after it closes, except a reply that called `continue_in_new_session` (`carryOverBotSession`; the menu's and sessions modal's Continue in new session does the same through `continueBotSession`, the model writing title and summary, refused while a job is open in the session): its summary is kept on the closed session and opens the new one as a bot message (`carried_from_session_id`), the job's `session_id` moves so the answer follows, the new session is titled by the bot then (it has no first exchange to be named from), and the old one can never be reopened (`reopenBotSession` refuses; a thread showing it swaps its composer for a link to the new one). Session lists (rail, sessions modal) reopen a session on click, as before; a carried-over one can't be, so it opens to read (`?session_id=`, `conversationHref`). The page tells them which session it shows (`announceShownSession` -> `useShownSession`): they reload, mark it Current (greyed out; without `?session_id=` the active one is), list it even when it's older than the rail's latest, and the active row then leads back. From half the session length the reply prompt suggests moving on (`longSessionNote`). Earlier sessions never enter the prompt (only the last one's summary): the thread can open them above a session (`useOlderMessages.loadPrevious`, a divider per session, quote and reply as usual), and replies get `search_past_sessions`/`read_past_session` (scoped to that user, bot and place, never the current session) when the conversation has any.
 - **Coordinator:** exactly one, the super admin's alone, created idempotently by `ensureCoordinatorBot`. Default prompt `src/data/coordinator-system-prompt.ts`, backfilled only when empty.
 - **Routes:** `/admin/bots` reopens the last visited bot (cookie `cobble_last_visited_bot_id`, never a workspace conversation) if still reachable, else coordinator (super admin) / latest bot / first workspace / empty. `/admin/bots/[bot_id]` conversation (header, thread and composer at 760px, no right panel; `?session_id=` opens another of the user's sessions there: a closed one is reopened, except a carried-over one, which shows with `SessionMovedBar` instead of the composer, pointing where the conversation went on); `/admin/bots/[bot_id]/models`; `/admin/workspaces/[id]` dashboard; `/admin/workspaces/[id]/chatrooms` that workspace's chatrooms; `/admin/workspaces/[id]/bots/[bot_id]` same conversation scoped to the workspace.
+- **No model:** while the bot has no text model there (`bot_text_model` null, kept live by the models modal), the thread shows `NoModelNotice` (centred when empty): super admins get Connect a provider / Guided setup, others are told the super admin sets it up.
 - **Conversation loading:** pages render everything server-side (`grabConversationProps`) **except the history**, which the client loads (`api/admin/bots/conversation-history`, merged with what's already shown, refetched on bfcache restore) and pages older messages on scroll. Rail lists go through `railBots`/`railWorkspaces` (no prompts/memory, previews cut). While a reply is due (read with the live face, never the page's) the page polls `session-messages` (`use-reply-catch-up`, also at once when the page comes back into view or online) in case a push was missed, replaying the messages and the bot's face and task as their pushes.
 - **Sending:** `api/admin/bots/send-message.ts` -> `enqueueBotReply` -> `wakeBotsQueue`. **Never import `src/bots-queue/index.ts` from a page or API route** (pulls the bunext runtime into page bundles). Optimistic bubble in `pending_messages` until the saved message replaces it.
 - **Composer:** Tiptap editor reading/writing markdown, drafts in `localStorage`, `@` bots / `#` workspaces written as `[bot:ID]`/`[workspace:ID]`. Enter sends (Mod+Enter in lists/code). `@tiptap/react` needs `use-sync-external-store`; the app ships an ESM stand-in in `packages/use-sync-external-store-esm` (file dependency + override; the Dockerfile copies `packages/` before `bun install`).
-- **Rendering:** markdown via `react-markdown` + `remark-gfm`, raw HTML never rendered, component map in `[bot_id]/(data)/message-markdown-components.tsx`. Inline refs, all linked by `link-computer-refs.ts` and rendered by chips in `(partials)/`: `[bot:ID]`, `[workspace:ID]`, `[computer:ID]`, `[file:ID]` (a saved file), `[folder:<volume>:<owner>:<path>]` (opens `/admin/files`), `[take-over:ID:mode]`, `[proposal:ID]`, `[hook-proposal:ID]`, `[secret:ID]` (masked env, Reveal/Copy), `[secret-request:ID]` (masked input card), `[graphic:ID]` (a bot graphic, framed inline), `[room:ID]` (a chatroom). Parsers in `src/utils/*-ref.ts`. A ref quoted alone in a code span still links; one inside longer code stays literal (`linkComputerRefs` splits out code first). A file chip opens a file from another bot's folder for a user who reaches that folder (`userReachesFileScope`, the same rule as its bytes), so answers passed on from chatrooms keep working.
+- **Rendering:** markdown via `react-markdown` + `remark-gfm`, raw HTML never rendered, component map in `[bot_id]/(data)/message-markdown-components.tsx`. Inline refs, all linked by `link-computer-refs.ts` and rendered by chips in `(partials)/`: `[bot:ID]`, `[workspace:ID]`, `[computer:ID]`, `[file:ID]` (a saved file), `[folder:<volume>:<owner>:<path>]` (opens `/admin/files`), `[take-over:ID:mode]`, `[proposal:ID]`, `[hook-proposal:ID]`, `[secret:ID]` (masked env, Reveal/Copy), `[secret-request:ID]` (masked input card), `[question:ID]` (a bot's questions), `[graphic:ID]` (a bot graphic, framed inline), `[room:ID]` (a chatroom). Parsers in `src/utils/*-ref.ts`. A ref quoted alone in a code span still links; one inside longer code stays literal (`linkComputerRefs` splits out code first). A file chip opens a file from another bot's folder for a user who reaches that folder (`userReachesFileScope`, the same rule as its bytes), so answers passed on from chatrooms keep working.
+- **File preview:** every file link (chips, attachments, files modal, task files, `/admin/files`) is a `FilePreviewLink`: a plain click opens `FilePreviewModal` (markdown rendered with the message elements, CSV/TSV as a table via `parseCsv`, images/PDF/audio/video in place, HTML in a frame with `sandbox=""` (plus the media server's `sandbox` CSP), other text as code, the kind from `filePreviewKind`; Download and Open in a new tab), a modified click still opens a tab. Text is read up to `AppData.FilePreviewMaxTextBytes`. Never render a file's HTML on the app's origin or with scripts.
 - **Copy chat** (header menu): the active session (the one on screen) as one markdown document (`api/admin/bots/conversation-export` -> `conversationMarkdown`, refs as names, message headings demoted). The clipboard write starts on the click with a pending `ClipboardItem` (`copyPendingText`), since Safari drops the gesture after a fetch.
+- **Asking before acting:** `ask_user` (`QuestionsNote`) puts up to `AppData.BotQuestionMaxQuestions` multiple-choice questions (`single` = radios, `multiple` = checkboxes, optional typed "Other") on one card, once per run -> `bot_questions` -> `[question:ID]` chip opening `BotQuestionCard`; the message needs the user. Answers are checked against the questions (`checkBotQuestionAnswers`) and stored, then sent as the user's chat message (`botQuestionAnswersText`); Skip says so. Replies and user-started tasks only: never routines, hook calls or chatroom sessions (no one sees those).
 - **Replies/reactions:** `reply_to_message_id` (not an FK); reactions from the fixed `BotMessageReactions`, toggled by `react-message.ts` and the `react_to_message` tool, pushed as `server:bot-reaction`.
 - **Attachments:** uploaded on pick (`upload-attachment.ts`, private `media`, no text kept: a reply reads a document's text from the file), linked via `bot_message_media`. Replies read files of the last `BotReplyAttachmentMessages` messages. Tasks don't get files yet.
 - **Thinking row / stop:** `bot-busy-state.ts` decides the row's line and whether Stop shows. Stop (`api/admin/bots/stop.ts`, `stop-bot-jobs`) fails every open job of that bot for the user, aborts the running handler (`job-abort-registry`) and drops late face updates.
@@ -196,7 +199,8 @@ Read-only browser of every volume (`src/utils/storage-volumes.ts`: bots, workspa
 
 ### Harness (the model layer, `src/harness/`)
 
-- **Harnesses** (`src/dict/harness-dict.ts`): `text` (always on), `vision`, `transcription`, `speech`, `image`, `embedding`. One `harness_settings` row each (provider, pinned model or automatic, `fallback`, `enabled`, `options`). Transcription, speech and embedding have no automatic picks: unavailable until a model is picked.
+- **Harnesses** (`src/dict/harness-dict.ts`): `text` (always on), `vision`, `transcription`, `speech`, `image`, `image_edit`, `embedding`. One `harness_settings` row each (provider, pinned model or automatic, `fallback`, `enabled`, `options`). Transcription, speech and embedding have no automatic picks: unavailable until a model is picked.
+- **Images:** `generate_image` takes reference images (`references` as `[file:ID]`, `reference_media_ids` for uploads, checked like a picture source by `loadReferenceImages`). With references the call goes to `image_edit` (no automatic picks; `HarnessFallbacks` hands it to `image` while unpicked or off, and after its pick fails when `fallback` is on), and only models that take image input are tried (`orderImageCandidates`), never one that would drop them. OpenRouter takes references on `/images` (`input_references`), other providers as multipart on `image_edit_path` (`/images/edits`).
 - **Providers** (`src/dict/harness-provider-dict.ts`): OpenRouter default plus OpenAI-compatible ones; one adapter today (`src/harness/providers/openai-compatible/`). Keys encrypted in private `harness_providers`, falling back to the preset env.
 - **Catalog:** `harness_models`, synced hourly. OpenRouter "free" means `:free` or `openrouter/free`, never zero prices. Auto picks: `rank-auto-models`.
 - **Calling:** `resolveHarnessCandidates` -> `withCandidates` with process-wide cooldowns; errors are `HarnessError`. Entry points under `text/`, `media/`, `audio/`, `image/`, `embeddings/`. `run-text-loop.ts` sticks to one model, caps steps (`grabHarnessMaxToolSteps`, `grabReplyMaxToolSteps`), trims old tool output to fit context. Models that can't take an image/audio part get it read by vision/transcription first.
@@ -225,7 +229,7 @@ Read-only browser of every volume (`src/utils/storage-volumes.ts`: bots, workspa
 `AdminSections`: `/admin/bots`, `/admin/workspaces`, `/admin/chatrooms`, `/admin/routines`, `/admin/logs`, `/admin/help`, `/admin/settings`. `/admin` -> `/admin/bots`. Every `/admin/*` page renders in the bots layout (`src/layouts/bots/`); there is no separate admin layout.
 
 - **Rail pages** (`src/dict/rail-pages-dict.ts`): Routines, Files, Usage (crew managers), Activity (`/admin/logs`, super admin), Help (`(data)/help-topics.ts`). Visibility via `canSeeRailItem` for both the popover and the aside.
-- **Settings** (`src/dict/settings-pages-dict.ts`; add a sub page = folder + dict entry): `general` (theme per device, plus super-admin app settings: prompt append, run limits, skill limits; crew-manager storage quota; running version), `profile`, `notifications`, `change-password`, `secrets`, `models`, `environment`, `backups` and `database` (super admin), `bots`, `workspaces`, `computers`, `mcps`, `tools`, `skills`, `knowledgebases` (crew managers), `users` (`canListUsers`).
+- **Settings** (`src/dict/settings-pages-dict.ts`; add a sub page = folder + dict entry): `general` (theme per device, plus super-admin app settings: prompt append, run limits, skill limits; crew-manager storage quota; running version), `setup` (super admin; shares the Models page's server props and `useModelsOverview`), `profile`, `notifications`, `change-password`, `secrets`, `models`, `environment`, `backups` and `database` (super admin), `bots`, `workspaces`, `computers`, `mcps`, `tools`, `skills`, `knowledgebases` (crew managers), `users` (`canListUsers`).
 - Settings pages use `SettingsShell` (breadcrumbs via `admin-breadcrumbs.tsx`), `SettingsGroup` blocks (no cards) and the sticky `SettingsSaveBar`. Saves don't reload. Keep save notices in component state (`useFormInit` clears `status` on change). Lists share `SettingsList`/`SettingsListRow`/`SettingsRowAction`. Row actions are icon-only (`RowIconButton`).
 - **Backups:** DB snapshots (synchronous) and whole-data archives of `DATA_DIR` into `BACKUP_ARCHIVE_DIR`. Archives and restores outlast a request, so the route only starts the run (`startDataBackupRun`, which holds `with-backup-run-lock.ts`) and the page polls `data-status`. A restore takes a safety archive first, then restarts the process.
 - **Database browser:** strictly read-only; values cut in SQL; state in the address via `databaseHref`.

db/schema.ts

@@ -35,6 +35,7 @@ import {
 } from "@/src/dict/bot-file-dict";
 import type { BUN_SQLITE_DatabaseSchemaType } from "@moduletrace/bun-sqlite/types";
 import { EnvParadigms, SecretRequestStatuses } from "@/src/dict/env-dict";
+import { BotQuestionStatuses } from "@/src/dict/bot-question-dict";
 import { McpServerStatuses, McpTransports } from "@/src/dict/mcp-dict";
 import {
     CustomToolKinds,
@@ -1652,6 +1653,63 @@ const schema: BUN_SQLITE_DatabaseSchemaType = {
                 },
             ],
         },
+        {
+            tableName: "bot_questions",
+            tableDescription: `Questions a bot asked a user in their conversation before acting (\`ask_user\`), each answered by picking one option (radios) or several (checkboxes), optionally with a typed "Other". The user answers them in the card, and the answers go to the bot as their chat message`,
+            fields: [
+                {
+                    fieldName: "title",
+                    fieldDescription: `A short heading for the card, in the bot's words`,
+                    dataType: "TEXT",
+                },
+                {
+                    fieldName: "questions",
+                    fieldDescription: `JSON array of { question, kind (single | multiple), options, allow_other }`,
+                    dataType: "TEXT",
+                },
+                {
+                    fieldName: "answers",
+                    fieldDescription: `JSON array, one per question, of { choices (option indexes), other }; null until answered`,
+                    dataType: "TEXT",
+                },
+                {
+                    fieldName: "status",
+                    dataType: "TEXT",
+                    options: [...BotQuestionStatuses],
+                    defaultValue: "pending",
+                },
+                {
+                    fieldName: "decided_at",
+                    dataType: "INTEGER",
+                },
+                {
+                    fieldName: "user_id",
+                    fieldDescription: `The user they were asked of, who alone answers them. Not a foreign key`,
+                    dataType: "INTEGER",
+                },
+                {
+                    fieldName: "bot_id",
+                    fieldDescription: `The bot that asked. Not a foreign key`,
+                    dataType: "INTEGER",
+                },
+                {
+                    fieldName: "session_id",
+                    fieldDescription: `The conversation they were asked in. Not a foreign key`,
+                    dataType: "INTEGER",
+                },
+                {
+                    fieldName: "workspace_id",
+                    fieldDescription: `The session's workspace; null for the bot's own chat. Not a foreign key`,
+                    dataType: "INTEGER",
+                },
+            ],
+            indexes: [
+                {
+                    indexName: "idx_bot_questions_session_id",
+                    indexTableFields: ["session_id"],
+                },
+            ],
+        },
         {
             tableName: "bot_graphics",
             tableDescription: `A visual a bot made for a user (a chart, diagram, timeline or report) as one self-contained HTML document. Served by the app at \`/graphics/<id>\` in a sandbox with no network and an origin of its own, so it never runs with the viewer's session. Per user like the conversation it was made in; an edit replaces the HTML and bumps \`version\``,

db/types/db.ts

@@ -22,6 +22,7 @@ export const BunSQLiteTables = [
     "bot_hook_events",
     "hook_proposals",
     "secret_requests",
+    "bot_questions",
     "bot_graphics",
     "workspaces",
     "workspace_bots",
@@ -1046,6 +1047,51 @@ export type BUN_SQLITE_COBBLE_SECRET_REQUESTS = {
     workspace_id?: number | "";
 }
 
+export type BUN_SQLITE_COBBLE_BOT_QUESTIONS = {
+    /** 
+     * The unique identifier of the record.
+     */
+    id?: number | "";
+    /** 
+     * The time when the record was created. (Unix Timestamp)
+     */
+    created_at?: number | "";
+    /** 
+     * The time when the record was updated. (Unix Timestamp)
+     */
+    updated_at?: number | "";
+    /** 
+     * A short heading for the card, in the bot's words
+     */
+    title?: string;
+    /** 
+     * JSON array of { question, kind (single | multiple), options, allow_other }
+     */
+    questions?: string;
+    /** 
+     * JSON array, one per question, of { choices (option indexes), other }; null until answered
+     */
+    answers?: string;
+    status?: "pending" | "answered" | "skipped" | "";
+    decided_at?: number | "";
+    /** 
+     * The user they were asked of, who alone answers them. Not a foreign key
+     */
+    user_id?: number | "";
+    /** 
+     * The bot that asked. Not a foreign key
+     */
+    bot_id?: number | "";
+    /** 
+     * The conversation they were asked in. Not a foreign key
+     */
+    session_id?: number | "";
+    /** 
+     * The session's workspace; null for the bot's own chat. Not a foreign key
+     */
+    workspace_id?: number | "";
+}
+
 export type BUN_SQLITE_COBBLE_BOT_GRAPHICS = {
     /** 
      * The unique identifier of the record.
@@ -1521,7 +1567,7 @@ export type BUN_SQLITE_COBBLE_HARNESS_SETTINGS = {
      * The time when the record was updated. (Unix Timestamp)
      */
     updated_at?: number | "";
-    harness?: "text" | "vision" | "transcription" | "speech" | "image" | "embedding" | "";
+    harness?: "text" | "vision" | "transcription" | "speech" | "image" | "image_edit" | "embedding" | "";
     /** 
      * harness_models row picked by a super admin. Null picks automatically. Not a foreign key, so removing a provider leaves the setting
      */
@@ -1561,7 +1607,7 @@ export type BUN_SQLITE_COBBLE_BOT_HARNESS_SETTINGS = {
      * The worker bot that overrides the default. The coordinator always uses the defaults
      */
     bot_id?: number | "";
-    harness?: "text" | "vision" | "transcription" | "speech" | "image" | "embedding" | "";
+    harness?: "text" | "vision" | "transcription" | "speech" | "image" | "image_edit" | "embedding" | "";
     /** 
      * harness_models row picked for this bot. Null picks automatically. Not a foreign key, like harness_settings
      */
@@ -1601,7 +1647,7 @@ export type BUN_SQLITE_COBBLE_WORKSPACE_HARNESS_SETTINGS = {
      * The workspace
      */
     workspace_id?: number | "";
-    harness?: "text" | "vision" | "transcription" | "speech" | "image" | "embedding" | "";
+    harness?: "text" | "vision" | "transcription" | "speech" | "image" | "image_edit" | "embedding" | "";
     /** 
      * harness_models row picked for this workspace. Null picks automatically. Not a foreign key, like harness_settings
      */
@@ -2375,7 +2421,7 @@ export type BUN_SQLITE_COBBLE_TOKEN_USAGES = {
     /** 
      * What the model was used for: a chat turn, reading media, transcribing, speaking, making an image, embedding
      */
-    harness?: "text" | "vision" | "transcription" | "speech" | "image" | "embedding" | "";
+    harness?: "text" | "vision" | "transcription" | "speech" | "image" | "image_edit" | "embedding" | "";
     /** 
      * The provider that served it. Not a foreign key: it stays readable after the provider is deleted
      */
@@ -2470,4 +2516,4 @@ export type BUN_SQLITE_COBBLE_APP_SETTINGS = {
     value?: string;
 }
 
-export type BUN_SQLITE_COBBLE_ALL_TYPEDEFS = BUN_SQLITE_COBBLE_USERS & BUN_SQLITE_COBBLE_USER_TYPES & BUN_SQLITE_COBBLE_SSO_LOGIN_CODES & BUN_SQLITE_COBBLE_USER_PASSWORDS & BUN_SQLITE_COBBLE_MEDIA & BUN_SQLITE_COBBLE_MEDIA_PARADIGMS & BUN_SQLITE_COBBLE_BOTS & BUN_SQLITE_COBBLE_CHATROOMS & BUN_SQLITE_COBBLE_BOT_SESSIONS & BUN_SQLITE_COBBLE_BOT_MESSAGES & BUN_SQLITE_COBBLE_BOT_MESSAGE_REACTIONS & BUN_SQLITE_COBBLE_BOT_TASKS & BUN_SQLITE_COBBLE_BOT_TASK_STEPS & BUN_SQLITE_COBBLE_TASKS & BUN_SQLITE_COBBLE_TASK_MEDIA & BUN_SQLITE_COBBLE_TASK_NOTES & BUN_SQLITE_COBBLE_BOTS_QUEUE & BUN_SQLITE_COBBLE_BOTS_QUEUE_UPDATES & BUN_SQLITE_COBBLE_CRON_JOBS & BUN_SQLITE_COBBLE_BOT_HOOKS & BUN_SQLITE_COBBLE_BOT_HOOK_EVENTS & BUN_SQLITE_COBBLE_HOOK_PROPOSALS & BUN_SQLITE_COBBLE_SECRET_REQUESTS & BUN_SQLITE_COBBLE_BOT_GRAPHICS & BUN_SQLITE_COBBLE_WORKSPACES & BUN_SQLITE_COBBLE_WORKSPACE_BOTS & BUN_SQLITE_COBBLE_BOT_TYPES & BUN_SQLITE_COBBLE_WORKSPACE_USERS & BUN_SQLITE_COBBLE_BOT_USERS & BUN_SQLITE_COBBLE_BOT_USER_MEMORIES & BUN_SQLITE_COBBLE_BOT_USER_FACES & BUN_SQLITE_COBBLE_BOT_MESSAGE_MEDIA & BUN_SQLITE_COBBLE_CONTAINERS & BUN_SQLITE_COBBLE_COMPUTERS & BUN_SQLITE_COBBLE_BOT_COMPUTERS & BUN_SQLITE_COBBLE_WORKSPACE_COMPUTERS & BUN_SQLITE_COBBLE_HARNESS_PROVIDERS & BUN_SQLITE_COBBLE_HARNESS_MODELS & BUN_SQLITE_COBBLE_HARNESS_SETTINGS & BUN_SQLITE_COBBLE_BOT_HARNESS_SETTINGS & BUN_SQLITE_COBBLE_WORKSPACE_HARNESS_SETTINGS & BUN_SQLITE_COBBLE_MCP_SERVERS & BUN_SQLITE_COBBLE_CUSTOM_TOOLS & BUN_SQLITE_COBBLE_SKILLS & BUN_SQLITE_COBBLE_EXTENSION_PROPOSALS & BUN_SQLITE_COBBLE_BOT_MCP_SERVERS & BUN_SQLITE_COBBLE_WORKSPACE_MCP_SERVERS & BUN_SQLITE_COBBLE_BOT_CUSTOM_TOOLS & BUN_SQLITE_COBBLE_WORKSPACE_CUSTOM_TOOLS & BUN_SQLITE_COBBLE_BOT_SKILLS & BUN_SQLITE_COBBLE_WORKSPACE_SKILLS & BUN_SQLITE_COBBLE_KNOWLEDGEBASES & BUN_SQLITE_COBBLE_KNOWLEDGEBASE_DOCUMENTS & BUN_SQLITE_COBBLE_KNOWLEDGEBASE_CHUNKS & BUN_SQLITE_COBBLE_KNOWLEDGEBASE_VECTORS & BUN_SQLITE_COBBLE_BOT_KNOWLEDGEBASES & BUN_SQLITE_COBBLE_WORKSPACE_KNOWLEDGEBASES & BUN_SQLITE_COBBLE_LOGS & BUN_SQLITE_COBBLE_USER_PRESENCE & BUN_SQLITE_COBBLE_PUSH_SUBSCRIPTIONS & BUN_SQLITE_COBBLE_ENVS & BUN_SQLITE_COBBLE_BOT_FILES & BUN_SQLITE_COBBLE_TOKEN_USAGES & BUN_SQLITE_COBBLE_FILE_INGEST_QUEUE & BUN_SQLITE_COBBLE_APP_SETTINGS
+export type BUN_SQLITE_COBBLE_ALL_TYPEDEFS = BUN_SQLITE_COBBLE_USERS & BUN_SQLITE_COBBLE_USER_TYPES & BUN_SQLITE_COBBLE_SSO_LOGIN_CODES & BUN_SQLITE_COBBLE_USER_PASSWORDS & BUN_SQLITE_COBBLE_MEDIA & BUN_SQLITE_COBBLE_MEDIA_PARADIGMS & BUN_SQLITE_COBBLE_BOTS & BUN_SQLITE_COBBLE_CHATROOMS & BUN_SQLITE_COBBLE_BOT_SESSIONS & BUN_SQLITE_COBBLE_BOT_MESSAGES & BUN_SQLITE_COBBLE_BOT_MESSAGE_REACTIONS & BUN_SQLITE_COBBLE_BOT_TASKS & BUN_SQLITE_COBBLE_BOT_TASK_STEPS & BUN_SQLITE_COBBLE_TASKS & BUN_SQLITE_COBBLE_TASK_MEDIA & BUN_SQLITE_COBBLE_TASK_NOTES & BUN_SQLITE_COBBLE_BOTS_QUEUE & BUN_SQLITE_COBBLE_BOTS_QUEUE_UPDATES & BUN_SQLITE_COBBLE_CRON_JOBS & BUN_SQLITE_COBBLE_BOT_HOOKS & BUN_SQLITE_COBBLE_BOT_HOOK_EVENTS & BUN_SQLITE_COBBLE_HOOK_PROPOSALS & BUN_SQLITE_COBBLE_SECRET_REQUESTS & BUN_SQLITE_COBBLE_BOT_QUESTIONS & BUN_SQLITE_COBBLE_BOT_GRAPHICS & BUN_SQLITE_COBBLE_WORKSPACES & BUN_SQLITE_COBBLE_WORKSPACE_BOTS & BUN_SQLITE_COBBLE_BOT_TYPES & BUN_SQLITE_COBBLE_WORKSPACE_USERS & BUN_SQLITE_COBBLE_BOT_USERS & BUN_SQLITE_COBBLE_BOT_USER_MEMORIES & BUN_SQLITE_COBBLE_BOT_USER_FACES & BUN_SQLITE_COBBLE_BOT_MESSAGE_MEDIA & BUN_SQLITE_COBBLE_CONTAINERS & BUN_SQLITE_COBBLE_COMPUTERS & BUN_SQLITE_COBBLE_BOT_COMPUTERS & BUN_SQLITE_COBBLE_WORKSPACE_COMPUTERS & BUN_SQLITE_COBBLE_HARNESS_PROVIDERS & BUN_SQLITE_COBBLE_HARNESS_MODELS & BUN_SQLITE_COBBLE_HARNESS_SETTINGS & BUN_SQLITE_COBBLE_BOT_HARNESS_SETTINGS & BUN_SQLITE_COBBLE_WORKSPACE_HARNESS_SETTINGS & BUN_SQLITE_COBBLE_MCP_SERVERS & BUN_SQLITE_COBBLE_CUSTOM_TOOLS & BUN_SQLITE_COBBLE_SKILLS & BUN_SQLITE_COBBLE_EXTENSION_PROPOSALS & BUN_SQLITE_COBBLE_BOT_MCP_SERVERS & BUN_SQLITE_COBBLE_WORKSPACE_MCP_SERVERS & BUN_SQLITE_COBBLE_BOT_CUSTOM_TOOLS & BUN_SQLITE_COBBLE_WORKSPACE_CUSTOM_TOOLS & BUN_SQLITE_COBBLE_BOT_SKILLS & BUN_SQLITE_COBBLE_WORKSPACE_SKILLS & BUN_SQLITE_COBBLE_KNOWLEDGEBASES & BUN_SQLITE_COBBLE_KNOWLEDGEBASE_DOCUMENTS & BUN_SQLITE_COBBLE_KNOWLEDGEBASE_CHUNKS & BUN_SQLITE_COBBLE_KNOWLEDGEBASE_VECTORS & BUN_SQLITE_COBBLE_BOT_KNOWLEDGEBASES & BUN_SQLITE_COBBLE_WORKSPACE_KNOWLEDGEBASES & BUN_SQLITE_COBBLE_LOGS & BUN_SQLITE_COBBLE_USER_PRESENCE & BUN_SQLITE_COBBLE_PUSH_SUBSCRIPTIONS & BUN_SQLITE_COBBLE_ENVS & BUN_SQLITE_COBBLE_BOT_FILES & BUN_SQLITE_COBBLE_TOKEN_USAGES & BUN_SQLITE_COBBLE_FILE_INGEST_QUEUE & BUN_SQLITE_COBBLE_APP_SETTINGS

package.json

@@ -1,6 +1,6 @@
 {
     "name": "cobble",
-    "version": "0.7.5",
+    "version": "0.11.0",
     "module": "index.ts",
     "type": "module",
     "private": true,

src/bots-queue/name-bot-session.ts

@@ -7,6 +7,7 @@ import generateText from "@/src/harness/text/generate-text";
 import { runWithHarnessUsageScope } from "@/src/harness/usage/harness-usage-scope";
 import parseSessionName from "./parse-session-name";
 import sessionNameTranscript from "./session-name-transcript";
+import sessionReadyToName from "./session-ready-to-name";
 
 type Params = {
     session_id: number | string;
@@ -16,7 +17,8 @@ type Params = {
 };
 
 /**
- * Names a session once its first exchange is in: the bot writes the title
+ * Names a session once its first exchange is in (or, with no user message,
+ * once the bot has written in it: work handed to it): the bot writes the title
  * the rail and sessions list show and a short summary of it, from the
  * session's first messages (however late the first reply came). The summary
  * says how many messages it covers (`summary_message_count`), so
@@ -51,12 +53,7 @@ export default async function nameBotSession({
         limit: AppData.BotSessionNameMessages,
     });
 
-    if (
-        !messages.some((message) => message.author == "user") ||
-        !messages.some((message) => message.author == "bot" && !message.carried_from_session_id)
-    ) {
-        return false;
-    }
+    if (!sessionReadyToName({ messages })) return false;
 
     const transcript = sessionNameTranscript({ messages });
 

src/bots-queue/process-bot-job.ts

@@ -235,9 +235,10 @@ export default async function processBotJob({
          * Once the first exchange is sent, the bot names the session and
          * previews it. After the reply is pushed, so it never waits on it;
          * a model that can't answer now leaves the session for the next
-         * reply to name.
+         * job to name. Tasks name too: a session the coordinator's
+         * delegation or a routine opened has no reply to name it.
          */
-        if (job.kind == "reply" && !in_room && completion.message?.session_id) {
+        if (!in_room && completion.message?.session_id) {
             /**
              * The message's session, not the job's as it was claimed: a
              * reply that moved the conversation on answered in the new one.

src/bots-queue/run-bot-reply.ts

@@ -3,6 +3,7 @@ import { grabSkillBodyShownChars } from "@/src/functions/backend/db/app-settings
 import { AppData } from "@/src/data/app-data";
 import {
     ActionCheckNote,
+    QuestionsNote,
     AskCrewNote,
     SecretsNote,
     GraphicsNote,
@@ -53,6 +54,7 @@ import grabAnsweredMessageId from "@/src/functions/backend/db/bots-queue/grab-an
 import markReplyAnswered from "@/src/functions/backend/db/bots-queue/mark-reply-answered";
 import sendMessageTool from "@/src/harness/tools/bot/send-message-tool";
 import grabBotSecretTools from "@/src/harness/tools/bot/secrets/grab-bot-secret-tools";
+import askUserTool from "@/src/harness/tools/bot/questions/ask-user-tool";
 import type { BotMessageWithAttachments } from "@/src/types";
 import type { HarnessMessage } from "@/src/harness/types";
 import type { BotJobContext, BotJobOutcome } from "./types";
@@ -324,6 +326,7 @@ export default async function runBotReply({
                 TasksNote,
                 TaskReminderNote,
                 ActionCheckNote,
+                QuestionsNote,
                 SecretsNote,
                 composeEnvsNote({ ...envs, has_computer: computers.length > 0 }),
                 GraphicsNote,
@@ -366,6 +369,13 @@ export default async function runBotReply({
                     onRequest: ({ ref }) => proposals.push(ref),
                     onShow: ({ ref }) => shown.push(ref),
                 }),
+                askUserTool({
+                    user_id,
+                    bot_id: bot.id,
+                    session_id,
+                    workspace_id,
+                    onAsk: ({ ref }) => proposals.push(ref),
+                }),
                 ...(has_past_sessions
                     ? [searchPastSessionsTool(past_scope), readPastSessionTool(past_scope)]
                     : []),

src/bots-queue/run-bot-task.ts

@@ -5,6 +5,7 @@ import workspaceAdminsNote from "./workspace-admins-note";
 import type { BUN_SQLITE_COBBLE_BOTS } from "@/db/types/db";
 import {
     ActionCheckNote,
+    QuestionsNote,
     SecretsNote,
     GraphicsNote,
     botFilesNote,
@@ -27,6 +28,7 @@ import openBotSkills, { type OpenBotSkills } from "@/src/harness/tools/skills/op
 import openBotKnowledgebases from "@/src/harness/tools/knowledgebases/open-bot-knowledgebases";
 import grabBotTools from "@/src/harness/tools/bot/grab-bot-tools";
 import grabBotSecretTools from "@/src/harness/tools/bot/secrets/grab-bot-secret-tools";
+import askUserTool from "@/src/harness/tools/bot/questions/ask-user-tool";
 import createWorkspaceTool from "@/src/harness/tools/bot/create-workspace-tool";
 import updateWorkspaceTool from "@/src/harness/tools/bot/update-workspace-tool";
 import askToTakeOverTool from "@/src/harness/tools/computer/ask-to-take-over-tool";
@@ -134,6 +136,12 @@ export default async function runBotTask({
          * like a routine, and treats the call's payload as data.
          */
         const hooked = Boolean(params.hook_id);
+        /**
+         * Only a task the user follows in their conversation asks them
+         * questions: routines and hook calls act on their own, and a
+         * chatroom's session is hidden from them.
+         */
+        const can_ask = Boolean(session_id) && !scheduled && !hooked && !params.chatroom_id;
         let failure = null as string | null;
 
         /**
@@ -207,6 +215,18 @@ export default async function runBotTask({
                 onRequest: hooked ? undefined : ({ ref }) => take_overs.push(ref),
                 onShow: ({ ref }) => shown.push(ref),
             }),
+            ...(can_ask
+                ? [
+                      askUserTool({
+                          user_id,
+                          bot_id: bot.id,
+                          session_id,
+                          workspace_id,
+                          in_task: true,
+                          onAsk: ({ ref }) => take_overs.push(ref),
+                      }),
+                  ]
+                : []),
             ...(scheduled || hooked ? [reportRunFailedTool({ onFail: ({ reason }) => (failure = reason) })] : []),
             ...(computer?.tools || []),
             ...(job.computer_id
@@ -270,6 +290,7 @@ export default async function runBotTask({
                 ComputerFilesNote({ computer_id: job.computer_id || 0, dirs }),
                 TasksNote,
                 ActionCheckNote,
+                can_ask ? QuestionsNote : "",
                 SecretsNote,
                 GraphicsNote,
                 workspace_id ? WorkspaceLearningNote : "",

src/bots-queue/session-ready-to-name.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, test } from "bun:test";
+import sessionReadyToName from "./session-ready-to-name";
+
+describe("sessionReadyToName", () => {
+    test("waits for the bot to answer the user", () => {
+        expect(sessionReadyToName({ messages: [{ id: 1, author: "user", text: "Hi" }] })).toBe(false);
+    });
+
+    test("names a first exchange", () => {
+        expect(
+            sessionReadyToName({
+                messages: [
+                    { id: 1, author: "user", text: "Hi" },
+                    { id: 2, author: "bot", text: "Hello" },
+                ],
+            }),
+        ).toBe(true);
+    });
+
+    test("names work handed to the bot, with no user message", () => {
+        expect(
+            sessionReadyToName({
+                messages: [{ id: 1, author: "bot", text: "Coordinator asked me to: **SEO lookup**" }],
+            }),
+        ).toBe(true);
+    });
+
+    test("a carried summary alone is not the bot's answer", () => {
+        expect(
+            sessionReadyToName({
+                messages: [
+                    { id: 1, author: "bot", text: "- Crew set up", carried_from_session_id: 9 },
+                    { id: 2, author: "user", text: "Continue here" },
+                ],
+            }),
+        ).toBe(false);
+        expect(
+            sessionReadyToName({
+                messages: [{ id: 1, author: "bot", text: "- Crew set up", carried_from_session_id: 9 }],
+            }),
+        ).toBe(false);
+    });
+});

src/bots-queue/session-ready-to-name.ts

@@ -0,0 +1,28 @@
+import type { SessionOpeningMessage } from "@/src/functions/backend/db/bot-sessions/grab-session-opening";
+
+type Params = {
+    messages: SessionOpeningMessage[];
+};
+
+/**
+ * Whether a session's opening says enough to name it: the bot has said
+ * something of its own (a carried summary doesn't count), and, when the
+ * user wrote, after the user's first message. A session with no user
+ * message at all is work handed to the bot (the coordinator's delegations,
+ * routines, hooks), named from the bot's own messages.
+ */
+export default function sessionReadyToName({ messages }: Params) {
+    const has_bot_message = messages.some(
+        (message) => message.author == "bot" && !message.carried_from_session_id,
+    );
+
+    if (!has_bot_message) return false;
+
+    const first_user = messages.findIndex((message) => message.author == "user");
+
+    if (first_user < 0) return true;
+
+    return messages
+        .slice(first_user + 1)
+        .some((message) => message.author == "bot" && !message.carried_from_session_id);
+}

src/components/general/file-preview-body.tsx

@@ -0,0 +1,61 @@
+import Img from "@moduletrace/twui/layout/Img";
+import Stack from "@moduletrace/twui/layout/Stack";
+import type { FilePreviewKind } from "@/src/utils/file-preview-kind";
+import FilePreviewNotice from "./file-preview-notice";
+import FilePreviewText from "./file-preview-text";
+
+type Props = {
+    kind: FilePreviewKind;
+    name: string;
+    url: string;
+    size?: number;
+};
+
+/**
+ * The preview itself, by kind. Media the browser draws itself (images,
+ * PDFs, audio, video) load from the file's URL; text kinds are read into
+ * the page (`FilePreviewText`). Nothing here runs the file: an SVG shows
+ * through `<img>`, which runs no script, and an HTML page in a frame
+ * sandboxed twice (the attribute here and the `sandbox` CSP the media
+ * server sends with it, `servedFileHeaders`): no script, no forms, an
+ * origin of its own.
+ */
+export default function FilePreviewBody({ kind, name, url, size }: Props) {
+    if (kind == "image") {
+        return (
+            <Stack className="grow min-h-0 w-full items-center justify-center p-4 overflow-auto bg-sunken">
+                <Img src={url} alt={name} className="max-w-full max-h-full object-contain" />
+            </Stack>
+        );
+    }
+
+    if (kind == "pdf") {
+        return <iframe src={url} title={name} className="block grow w-full border-0 bg-paper" />;
+    }
+
+    if (kind == "html") {
+        return <iframe src={url} title={name} sandbox="" referrerPolicy="no-referrer" className="block grow w-full border-0 bg-paper" />;
+    }
+
+    if (kind == "audio") {
+        return (
+            <Stack className="grow w-full items-center justify-center p-6">
+                <audio src={url} controls preload="metadata" className="w-full max-w-xl" />
+            </Stack>
+        );
+    }
+
+    if (kind == "video") {
+        return (
+            <Stack className="grow min-h-0 w-full items-center justify-center p-4 bg-sunken">
+                <video src={url} controls preload="metadata" className="max-w-full max-h-full" />
+            </Stack>
+        );
+    }
+
+    if (kind == "none") {
+        return <FilePreviewNotice message="This kind of file can't be previewed here. Download it to open it." />;
+    }
+
+    return <FilePreviewText kind={kind} url={url} size={size} />;
+}

src/components/general/file-preview-code.tsx

@@ -0,0 +1,28 @@
+import CodeBlock from "@moduletrace/twui/elements/CodeBlock";
+import Stack from "@moduletrace/twui/layout/Stack";
+
+type Props = {
+    text: string;
+};
+
+/**
+ * A plain text file in the preview, as it is, on the sunken surface with
+ * twui's copy button.
+ */
+export default function FilePreviewCode({ text }: Props) {
+    return (
+        <Stack className="grow min-h-0 w-full overflow-auto p-4 items-stretch">
+            <CodeBlock
+                singleBlock
+                backgroundColor="var(--color-sunken)"
+                wrapperProps={{
+                    className:
+                        "max-w-full! outline-hairline dark:outline-hairline [&_.twui-code-block-header_svg]:stroke-ink-secondary",
+                }}
+                className="font-mono text-[13px] leading-5 text-ink py-2 pl-2 pr-10 whitespace-pre-wrap wrap-anywhere"
+            >
+                {text}
+            </CodeBlock>
+        </Stack>
+    );
+}

src/components/general/file-preview-link.tsx

@@ -0,0 +1,52 @@
+import { useState, type ReactNode } from "react";
+import Link from "@moduletrace/twui/layout/Link";
+import isPlainClick from "@/src/utils/is-plain-click";
+import FilePreviewModal from "./file-preview-modal";
+
+type Props = {
+    name: string;
+    url: string;
+    media_type?: string | null;
+    size?: number;
+    title?: string;
+    className?: string;
+    children: ReactNode;
+};
+
+/**
+ * A link to a file that opens it in the preview (`FilePreviewModal`) on a
+ * plain click. It stays a real link to the bytes, so a middle click or
+ * Ctrl/Cmd click still opens the file in a new tab.
+ */
+export default function FilePreviewLink({ name, url, media_type, size, title, className, children }: Props) {
+    const [open, setOpen] = useState(false);
+
+    return (
+        <>
+            <Link
+                href={url}
+                target="_blank"
+                rel="noopener noreferrer"
+                title={title || `Preview ${name}`}
+                onClick={(event) => {
+                    if (!isPlainClick({ event })) return;
+
+                    event.preventDefault();
+                    setOpen(true);
+                }}
+                className={className}
+            >
+                {children}
+            </Link>
+            {open ? (
+                <FilePreviewModal
+                    name={name}
+                    url={url}
+                    media_type={media_type}
+                    size={size}
+                    onClose={() => setOpen(false)}
+                />
+            ) : null}
+        </>
+    );
+}

src/components/general/file-preview-markdown.tsx

@@ -0,0 +1,47 @@
+import Markdown, { type Components } from "react-markdown";
+import remarkGfm from "remark-gfm";
+import { twMerge } from "tailwind-merge";
+import H2 from "@moduletrace/twui/layout/H2";
+import H3 from "@moduletrace/twui/layout/H3";
+import H4 from "@moduletrace/twui/layout/H4";
+import H5 from "@moduletrace/twui/layout/H5";
+import Stack from "@moduletrace/twui/layout/Stack";
+import { MessageMarkdownComponents } from "@/src/pages/admin/bots/[bot_id]/(data)/message-markdown-components";
+
+type Props = {
+    text: string;
+};
+
+const RemarkPlugins = [remarkGfm];
+
+const HeadingClassName = "my-0! tracking-normal! font-bold text-ink";
+
+/**
+ * A message's markdown elements, with headings sized for a document
+ * rather than a chat line.
+ */
+const DocumentComponents: Components = {
+    ...MessageMarkdownComponents,
+    h1: ({ children }) => <H2 className={twMerge(HeadingClassName, "text-2xl! leading-8! mt-2!")}>{children}</H2>,
+    h2: ({ children }) => <H3 className={twMerge(HeadingClassName, "text-xl! leading-7! mt-2!")}>{children}</H3>,
+    h3: ({ children }) => <H4 className={twMerge(HeadingClassName, "text-[17px]! leading-6! mt-1!")}>{children}</H4>,
+    h4: ({ children }) => <H5 className={twMerge(HeadingClassName, "text-[15px]! leading-6!")}>{children}</H5>,
+    h5: ({ children }) => <H5 className={twMerge(HeadingClassName, "text-sm! leading-5!")}>{children}</H5>,
+    h6: ({ children }) => <H5 className={twMerge(HeadingClassName, "text-sm! leading-5! text-ink-secondary")}>{children}</H5>,
+};
+
+/**
+ * A markdown file rendered in the preview, through the same elements as a
+ * bot's messages (raw HTML never rendered), in a readable column.
+ */
+export default function FilePreviewMarkdown({ text }: Props) {
+    return (
+        <Stack className="grow min-h-0 w-full overflow-auto items-center">
+            <Stack className="w-full max-w-[760px] gap-3! items-stretch px-6 py-5">
+                <Markdown remarkPlugins={RemarkPlugins} components={DocumentComponents}>
+                    {text}
+                </Markdown>
+            </Stack>
+        </Stack>
+    );
+}

src/components/general/file-preview-modal.tsx

@@ -0,0 +1,88 @@
+import Modal from "@moduletrace/twui/elements/Modal";
+import H2 from "@moduletrace/twui/layout/H2";
+import Link from "@moduletrace/twui/layout/Link";
+import Row from "@moduletrace/twui/layout/Row";
+import Span from "@moduletrace/twui/layout/Span";
+import Stack from "@moduletrace/twui/layout/Stack";
+import { Download, SquareArrowOutUpRight } from "lucide-react";
+import filePreviewKind from "@/src/utils/file-preview-kind";
+import formatBytes from "@/src/utils/format-bytes";
+import FilePreviewBody from "./file-preview-body";
+
+type Props = {
+    name: string;
+    url: string;
+    media_type?: string | null;
+    size?: number;
+    onClose: () => void;
+};
+
+const ActionClassName =
+    "shrink-0 inline-flex items-center gap-1.5 px-2 py-1.5 text-[13px] leading-[18px] text-ink-secondary hover:text-ink rounded-default hover:bg-sunken no-underline";
+
+/**
+ * A file over the page: markdown rendered, a CSV as a table, an image,
+ * PDF, audio or video in place, other text as code, with ways to download
+ * it or open it in a new tab. A file it can't show offers those only.
+ */
+export default function FilePreviewModal({
+    name,
+    url,
+    media_type,
+    size,
+    onClose,
+}: Props) {
+    const kind = filePreviewKind({ name, media_type });
+    const base_name = name.split("/").pop() || name;
+
+    return (
+        <Modal
+            open
+            setOpen={(next_open) => {
+                if (!next_open) onClose();
+            }}
+            className="max-w-[95vw]! w-[95vw] h-[90vh] p-0 bg-paper flex flex-col overflow-hidden"
+        >
+            <Row className="w-full gap-3! flex-nowrap items-center pl-5 pr-14 py-3 border-0 border-b border-solid border-hairline">
+                <Stack className="min-w-0 grow gap-0! items-start">
+                    <H2
+                        title={name}
+                        className="text-base! leading-6! tracking-normal! font-bold text-ink truncate w-full"
+                    >
+                        {base_name}
+                    </H2>
+                    {size ? (
+                        <Span className="text-[13px] leading-[18px] text-ink-secondary">
+                            {formatBytes({ bytes: size })}
+                        </Span>
+                    ) : null}
+                </Stack>
+                <Link
+                    href={url}
+                    download={base_name}
+                    title={`Download ${base_name}`}
+                    className={ActionClassName}
+                >
+                    <Download size={16} aria-hidden />
+                    <Span className="hidden sm:inline">Download</Span>
+                </Link>
+                <Link
+                    href={url}
+                    target="_blank"
+                    rel="noopener noreferrer"
+                    title="Open in a new tab"
+                    aria-label="Open in a new tab"
+                    className={ActionClassName}
+                >
+                    <SquareArrowOutUpRight size={16} aria-hidden />
+                </Link>
+            </Row>
+            <FilePreviewBody
+                kind={kind}
+                name={base_name}
+                url={url}
+                size={size}
+            />
+        </Modal>
+    );
+}

src/components/general/file-preview-notice.tsx

@@ -0,0 +1,19 @@
+import P from "@moduletrace/twui/layout/P";
+import Stack from "@moduletrace/twui/layout/Stack";
+
+type Props = {
+    message: string;
+};
+
+/**
+ * What the preview says instead of a file it doesn't show.
+ */
+export default function FilePreviewNotice({ message }: Props) {
+    return (
+        <Stack className="grow w-full items-center justify-center p-6">
+            <P noMargin className="text-sm leading-5 text-ink-secondary text-center max-w-md">
+                {message}
+            </P>
+        </Stack>
+    );
+}

src/components/general/file-preview-table-cell.tsx

@@ -0,0 +1,20 @@
+import { twMerge } from "tailwind-merge";
+
+type Props = {
+    value: string;
+    header?: boolean;
+};
+
+/**
+ * One cell of a previewed CSV, its text kept to one readable width.
+ */
+export default function FilePreviewTableCell({ value, header }: Props) {
+    const className = twMerge(
+        "px-3 py-1.5 max-w-80 text-left align-top whitespace-pre-wrap wrap-break-word border-0 border-b border-r border-solid border-hairline",
+        header && "font-bold border-hairline-strong",
+    );
+
+    if (header) return <th className={className}>{value}</th>;
+
+    return <td className={className}>{value}</td>;
+}

src/components/general/file-preview-table-row.tsx

@@ -0,0 +1,19 @@
+import FilePreviewTableCell from "./file-preview-table-cell";
+
+type Props = {
+    cells: string[];
+    header?: boolean;
+};
+
+/**
+ * One row of a previewed CSV.
+ */
+export default function FilePreviewTableRow({ cells, header }: Props) {
+    return (
+        <tr>
+            {cells.map((value, index) => (
+                <FilePreviewTableCell key={index} value={value} header={header} />
+            ))}
+        </tr>
+    );
+}

src/components/general/file-preview-table.tsx

@@ -0,0 +1,54 @@
+import { useMemo } from "react";
+import P from "@moduletrace/twui/layout/P";
+import Stack from "@moduletrace/twui/layout/Stack";
+import { AppData } from "@/src/data/app-data";
+import parseCsv from "@/src/utils/parse-csv";
+import FilePreviewNotice from "./file-preview-notice";
+import FilePreviewTableRow from "./file-preview-table-row";
+
+type Props = {
+    text: string;
+    delimiter: string;
+};
+
+/**
+ * A CSV or TSV file as a table: its first row the header (kept in view
+ * while scrolling), up to `AppData.FilePreviewMaxTableRows` rows. Cells
+ * are text only. Tables have no children-based twui equivalent, so they're
+ * styled elements, as in a message.
+ */
+export default function FilePreviewTable({ text, delimiter }: Props) {
+    const { rows, truncated } = useMemo(
+        () => parseCsv({ text, delimiter, max_rows: AppData.FilePreviewMaxTableRows + 1 }),
+        [text, delimiter],
+    );
+
+    if (!rows.length) return <FilePreviewNotice message="This file is empty." />;
+
+    const [header, ...body] = rows;
+
+    return (
+        <Stack className="grow min-h-0 w-full items-stretch gap-0!">
+            <Stack className="grow min-h-0 w-full overflow-auto items-start">
+                <table className="text-[13px] leading-5 text-ink border-separate border-spacing-0">
+                    <thead className="sticky top-0 bg-surface">
+                        <FilePreviewTableRow cells={header!} header />
+                    </thead>
+                    <tbody>
+                        {body.map((cells, index) => (
+                            <FilePreviewTableRow key={index} cells={cells} />
+                        ))}
+                    </tbody>
+                </table>
+            </Stack>
+            <P
+                noMargin
+                className="shrink-0 px-5 py-2 text-[12px] leading-4 text-ink-secondary border-0 border-t border-solid border-hairline"
+            >
+                {truncated
+                    ? `Showing the first ${body.length} rows. Download the file for the rest.`
+                    : `${body.length} ${body.length == 1 ? "row" : "rows"}`}
+            </P>
+        </Stack>
+    );
+}

src/components/general/file-preview-text.tsx

@@ -0,0 +1,50 @@
+import Loading from "@moduletrace/twui/elements/Loading";
+import Stack from "@moduletrace/twui/layout/Stack";
+import useFileText from "@/src/hooks/use-file-text";
+import formatBytes from "@/src/utils/format-bytes";
+import { AppData } from "@/src/data/app-data";
+import type { FilePreviewKind } from "@/src/utils/file-preview-kind";
+import FilePreviewCode from "./file-preview-code";
+import FilePreviewMarkdown from "./file-preview-markdown";
+import FilePreviewNotice from "./file-preview-notice";
+import FilePreviewTable from "./file-preview-table";
+
+type Props = {
+    kind: FilePreviewKind;
+    url: string;
+    size?: number;
+};
+
+/**
+ * A text file read into the preview: markdown rendered, CSV or TSV as a
+ * table, anything else as code.
+ */
+export default function FilePreviewText({ kind, url, size }: Props) {
+    const { text, loading, error, too_large } = useFileText({ url, size });
+
+    if (loading) {
+        return (
+            <Stack className="grow w-full items-center justify-center">
+                <Loading />
+            </Stack>
+        );
+    }
+
+    if (too_large) {
+        return (
+            <FilePreviewNotice
+                message={`This file is bigger than ${formatBytes({ bytes: AppData.FilePreviewMaxTextBytes })}, too big to preview. Download it to open it.`}
+            />
+        );
+    }
+
+    if (error || text == null) {
+        return <FilePreviewNotice message={error || "The file couldn't be read."} />;
+    }
+
+    if (kind == "markdown") return <FilePreviewMarkdown text={text} />;
+    if (kind == "csv") return <FilePreviewTable text={text} delimiter="," />;
+    if (kind == "tsv") return <FilePreviewTable text={text} delimiter={"\t"} />;
+
+    return <FilePreviewCode text={text} />;
+}

src/components/general/file-preview.render.test.tsx

@@ -0,0 +1,53 @@
+import { expect, test } from "bun:test";
+import { renderToString } from "react-dom/server";
+import { AppData } from "@/src/data/app-data";
+import FilePreviewBody from "./file-preview-body";
+import FilePreviewLink from "./file-preview-link";
+import FilePreviewMarkdown from "./file-preview-markdown";
+import FilePreviewTable from "./file-preview-table";
+
+test("a markdown file renders as a document, raw HTML left out", () => {
+    const html = renderToString(
+        <FilePreviewMarkdown text={"# Report\n\nSome **bold** text.\n\n| a | b |\n| - | - |\n| 1 | 2 |\n\n<script>alert(1)</script>"} />,
+    );
+
+    expect(html).toContain("Report");
+    expect(html).toContain("<h2");
+    expect(html).toContain("font-bold");
+    expect(html).toContain("<table");
+    expect(html).not.toContain("<script");
+});
+
+test("a CSV renders as a table with its header row", () => {
+    const html = renderToString(<FilePreviewTable text={'name,city\n"Smith, J",Lagos\n'} delimiter="," />);
+
+    expect(html).toContain("<thead");
+    expect(html).toContain("<th");
+    expect(html).toContain("Smith, J");
+    expect(html).toContain("1 row");
+});
+
+test("a long CSV says it was cut", () => {
+    const rows = Array.from({ length: AppData.FilePreviewMaxTableRows + 5 }, (_, i) => `${i}`).join("\n");
+    const html = renderToString(<FilePreviewTable text={`n\n${rows}`} delimiter="," />);
+
+    expect(html).toContain(`Showing the first ${AppData.FilePreviewMaxTableRows} rows`);
+});
+
+test("media previews load from the file's URL, unknown files offer a download", () => {
+    expect(renderToString(<FilePreviewBody kind="image" name="a.png" url="/media/1" />)).toContain('src="/media/1"');
+    expect(renderToString(<FilePreviewBody kind="pdf" name="a.pdf" url="/media/2" />)).toContain("<iframe");
+    expect(renderToString(<FilePreviewBody kind="html" name="a.html" url="/media/4" />)).toContain('sandbox=""');
+    expect(renderToString(<FilePreviewBody kind="none" name="a.zip" url="/media/3" />)).toContain("can&#x27;t be previewed");
+});
+
+test("a file link stays a real link to the bytes until clicked", () => {
+    const html = renderToString(
+        <FilePreviewLink name="report.md" url="/media/9">
+            report.md
+        </FilePreviewLink>,
+    );
+
+    expect(html).toContain('href="/media/9"');
+    expect(html).toContain("Preview report.md");
+});

src/components/general/task-file-row.tsx

@@ -1,9 +1,9 @@
 import Row from "@moduletrace/twui/layout/Row";
-import Link from "@moduletrace/twui/layout/Link";
 import { FileText, Image as ImageIcon } from "lucide-react";
 import Span from "@moduletrace/twui/layout/Span";
 import type { TaskFile } from "@/src/types";
 import fileRef from "@/src/utils/file-ref";
+import FilePreviewLink from "./file-preview-link";
 
 type Props = {
     file: TaskFile;
@@ -15,8 +15,8 @@ type Props = {
 };
 
 /**
- * One file on a task: its name, opening the bytes at `/media/<id>` (private,
- * so only someone who reaches the task can load it), and its file ref (built by `fileRef`) when it
+ * One file on a task: its name, opening it in the file preview (its bytes at
+ * `/media/<id>`, private, so only someone who reaches the task can load them), and its file ref (built by `fileRef`) when it
  * lives in a bot's or workspace's folder (so the file's real home is
  * reachable too).
  */
@@ -39,15 +39,14 @@ export default function TaskFileRow({ file, onDetach, busy }: Props) {
             ) : (
                 <FileText size={16} className="shrink-0 text-ink-secondary" aria-hidden />
             )}
-            <Link
-                href={`/media/${file.media_id}`}
-                target="_blank"
-                rel="noreferrer"
-                title={file.name || "Open the file"}
+            <FilePreviewLink
+                name={file.name || `File ${file.media_id}`}
+                url={`/media/${file.media_id}`}
+                media_type={file.media_type}
                 className="grow min-w-0 text-[13px] leading-[18px] text-ink truncate hover:underline"
             >
                 {file.name || `File ${file.media_id}`}
-            </Link>
+            </FilePreviewLink>
             {file.kind == "reference" ? (
                 <Span className="shrink-0 text-[11px] leading-4 text-ink-secondary">reference</Span>
             ) : null}

src/data/app-data.ts

@@ -353,6 +353,12 @@ export const AppData = {
      * Upload cap for audio sent to transcription.
      */
     HarnessMaxAudioBytes: 25 * 1024 * 1024,
+    /**
+     * Reference images one `generate_image` call passes on, and the
+     * largest each may be.
+     */
+    ImageReferenceMaxCount: 4,
+    ImageReferenceMaxBytes: 10 * 1024 * 1024,
     /**
      * Connecting to an MCP server (a computer) gives up after this long.
      */
@@ -591,6 +597,27 @@ export const AppData = {
      * inside its frame.
      */
     BotGraphicInlineMaxHeight: 640,
+    /**
+     * Largest text file (markdown, CSV, plain text) the file preview reads
+     * into the page (bytes); a bigger one is only offered to download.
+     */
+    FilePreviewMaxTextBytes: 2 * 1024 * 1024,
+    /**
+     * Most rows of a CSV the file preview draws.
+     */
+    FilePreviewMaxTableRows: 1000,
+    /**
+     * Most questions one `ask_user` card holds.
+     */
+    BotQuestionMaxQuestions: 6,
+    /**
+     * Most options one question offers (its "Other" not counted).
+     */
+    BotQuestionMaxOptions: 8,
+    /**
+     * Longest answer a user may type into a question's "Other".
+     */
+    BotQuestionOtherMaxChars: 1000,
     /**
      * Longest dictation the composer records before it stops on its own.
      */

src/data/harness-prompts.ts

@@ -164,6 +164,14 @@ Anything you read or write goes to your model provider, so secret values (passwo
 - Never print, cat or echo a secret on a computer. To show one to the user, use show_secret for an env you have, or in a task on a computer capture it with capture_secret: either gives you a [secret:ID] ref to put in your message.
 - Use secrets by key ($KEY in the shell, {{env.KEY}} in tools), never by value. A value you see as [KEY] in output was redacted: that's expected.`;
 
+/**
+ * Added to chat replies and to tasks the user started: before acting on
+ * something unclear, a bot asks (`ask_user`) rather than guesses.
+ */
+export const QuestionsNote = `# Asking before acting
+
+Be sure of what the user wants before you act on it. When a request could mean more than one thing, when a choice is theirs to make, or before work that is hard to undo, costly or seen by others, and you can't tell what they'd pick, ask with ask_user: a card of multiple-choice questions (one pick or several, with "Other" for their own words) they answer in a click. Give options that are concrete and distinct, put the one you'd suggest first and say so in it ("Staging (suggested)"). Ask everything you need in one card, then wait for their answers before acting on what you asked. Don't ask about what they already said, what you can find out yourself, or small choices any sensible answer settles: just do those. If they skip the questions, don't guess: do only the part that's clear and say what you still need.`;
+
 /**
  * Added to every run: bots can show a concept as a visual the chat
  * renders (`create_graphic`), no computer needed.
@@ -279,8 +287,8 @@ update_memory and update_instructions save to this workspace by default: what yo
 export const SessionNamePrompt = `Name and summarize this conversation from its first exchange. Answer with a JSON object only, no markdown fence and no other text:
 {"title": "...", "summary": "..."}
 
-- title: what the conversation is about, at most 60 characters, no quotes and no trailing period. Say what the user wanted, not that it is a conversation. When it opens with a summary of an earlier session, name what this one carries on with, not every topic the summary recaps.
-- summary: what the user wanted and what was done so far. Keep names, numbers, paths and links exactly. Plain markdown bullets, no preamble.`;
+- title: what the conversation is about, at most 60 characters, no quotes and no trailing period. Say what the user wanted, not that it is a conversation. With no user message, it is work handed to you (by the coordinator, a schedule or a hook): name that work. When it opens with a summary of an earlier session, name what this one carries on with, not every topic the summary recaps.
+- summary: what the user (or whoever handed you the work) wanted and what was done so far. Keep names, numbers, paths and links exactly. Plain markdown bullets, no preamble.`;
 
 /**
  * Asks the text model to carry a conversation into a new session when the

src/dict/bot-question-dict.ts

@@ -0,0 +1,15 @@
+/**
+ * Where questions a bot asked a user stand (`bot_questions.status`):
+ * `pending` until the user answers them (`answered`) or skips them.
+ */
+export const BotQuestionStatuses = ["pending", "answered", "skipped"] as const;
+
+export type BotQuestionStatus = (typeof BotQuestionStatuses)[number];
+
+/**
+ * How a question is answered: `single` picks one option (radios),
+ * `multiple` any number of them, at least one (checkboxes).
+ */
+export const BotQuestionKinds = ["single", "multiple"] as const;
+
+export type BotQuestionKind = (typeof BotQuestionKinds)[number];

src/dict/bot-queue-dict.ts

@@ -110,6 +110,7 @@ export const JobStepToolLabels: Record<string, string> = {
     hand_over_schedule: "Handing a routine to the crew",
     propose_hook: "Proposing a hook",
     request_secret: "Asking for a secret",
+    ask_user: "Asking you",
     capture_secret: "Saving a secret",
     show_secret: "Showing a secret",
     pause_hook: "Pausing a hook",

src/dict/custom-tool-dict.ts

@@ -58,6 +58,7 @@ export type CustomToolScriptLanguage = (typeof CustomToolScriptLanguages)[number
  */
 export const ReservedToolNames = [
     "add_bot_to_workspace",
+    "ask_user",
     "ask_user_to_take_over",
     "assign_computer",
     "capture_secret",

src/dict/harness-dict.ts

@@ -49,6 +49,14 @@ export const Harnesses = [
         required: false,
         install_wide: false,
     },
+    {
+        title: "Image editing",
+        value: "image_edit",
+        automatic: false,
+        description: `Makes images from reference images a bot passes on: a logo to rework, a style to follow, a photo to change. Until a model is picked here (or while it's off), image generation takes them.`,
+        required: false,
+        install_wide: false,
+    },
     {
         title: "Embeddings",
         value: "embedding",
@@ -68,6 +76,31 @@ export function isInstallWideHarness({ harness }: { harness: HarnessKind }) {
     return Boolean(Harnesses.find((h) => h.value == harness)?.install_wide);
 }
 
+/**
+ * Harnesses that hand their work to another one instead of picking
+ * models automatically: image editing goes to image generation while it
+ * has no model (or is off), and after its model fails when fallback is on.
+ */
+export const HarnessFallbacks: Partial<Record<HarnessKind, HarnessKind>> = {
+    image_edit: "image",
+};
+
+/**
+ * The harness this one falls back to, if any.
+ */
+export function harnessFallsBackTo({ harness }: { harness: HarnessKind }) {
+    return HarnessFallbacks[harness];
+}
+
+/**
+ * The title of the harness this one falls back to, if any.
+ */
+export function harnessFallbackTitle({ harness }: { harness: HarnessKind }) {
+    const to = HarnessFallbacks[harness];
+
+    return to ? Harnesses.find((h) => h.value == to)?.title : undefined;
+}
+
 /**
  * The `app_settings` key holding the install's own limit on model turns in
  * one run (a task). Unset means `AppData.HarnessMaxToolSteps`.

src/dict/harness-provider-dict.ts

@@ -9,6 +9,9 @@
  *   capabilities are guessed from the names
  * - `local`: runs on the user's own hardware, so its models count as free
  * - `image_path`: image generation endpoint
+ * - `image_edit_path`: where images made from reference images go. OpenRouter
+ *   takes them on `image_path` (`input_references`); the others take a
+ *   multipart upload at `/images/edits`
  */
 export const HarnessProviderKinds = [
     {
@@ -20,6 +23,7 @@ export const HarnessProviderKinds = [
         catalog: "openrouter",
         local: false,
         image_path: "/images",
+        image_edit_path: "/images",
     },
     {
         title: "OpenAI",
@@ -30,6 +34,7 @@ export const HarnessProviderKinds = [
         catalog: "openai-compatible",
         local: false,
         image_path: "/images/generations",
+        image_edit_path: "/images/edits",
     },
     {
         title: "Anthropic",
@@ -40,6 +45,7 @@ export const HarnessProviderKinds = [
         catalog: "openai-compatible",
         local: false,
         image_path: "/images/generations",
+        image_edit_path: "/images/edits",
     },
     {
         title: "Google Gemini",
@@ -50,6 +56,7 @@ export const HarnessProviderKinds = [
         catalog: "openai-compatible",
         local: false,
         image_path: "/images/generations",
+        image_edit_path: "/images/edits",
     },
     {
         title: "DeepSeek",
@@ -60,6 +67,7 @@ export const HarnessProviderKinds = [
         catalog: "openai-compatible",
         local: false,
         image_path: "/images/generations",
+        image_edit_path: "/images/edits",
     },
     {
         title: "Groq",
@@ -70,6 +78,7 @@ export const HarnessProviderKinds = [
         catalog: "openai-compatible",
         local: false,
         image_path: "/images/generations",
+        image_edit_path: "/images/edits",
     },
     {
         title: "Mistral",
@@ -80,6 +89,7 @@ export const HarnessProviderKinds = [
         catalog: "openai-compatible",
         local: false,
         image_path: "/images/generations",
+        image_edit_path: "/images/edits",
     },
     {
         title: "xAI",
@@ -90,6 +100,7 @@ export const HarnessProviderKinds = [
         catalog: "openai-compatible",
         local: false,
         image_path: "/images/generations",
+        image_edit_path: "/images/edits",
     },
     {
         title: "Ollama",
@@ -100,6 +111,7 @@ export const HarnessProviderKinds = [
         catalog: "openai-compatible",
         local: true,
         image_path: "/images/generations",
+        image_edit_path: "/images/edits",
     },
     {
         title: "Other (OpenAI-compatible)",
@@ -110,6 +122,7 @@ export const HarnessProviderKinds = [
         catalog: "openai-compatible",
         local: false,
         image_path: "/images/generations",
+        image_edit_path: "/images/edits",
     },
 ] as const;
 

src/dict/settings-pages-dict.ts

@@ -10,6 +10,7 @@ import {
     LockKeyhole,
     Monitor,
     Plug,
+    Rocket,
     Users,
     SlidersHorizontal,
     UserRound,
@@ -38,6 +39,8 @@ export type SettingsPage = {
 export const SettingsComputersPath = "/admin/settings/computers";
 export const SettingsBackupsPath = "/admin/settings/backups";
 export const SettingsDatabasePath = "/admin/settings/database";
+export const SettingsSetupPath = "/admin/settings/setup";
+export const SettingsModelsPath = "/admin/settings/models";
 
 /**
  * The `/admin/settings/*` sub pages, listed in the rail on every settings
@@ -49,6 +52,12 @@ export const SettingsPages: SettingsPage[] = [
         url: "/admin/settings/general",
         Icon: SlidersHorizontal,
     },
+    {
+        title: "Setup",
+        url: SettingsSetupPath,
+        Icon: Rocket,
+        super_admin_only: true,
+    },
     { title: "Profile", url: "/admin/settings/profile", Icon: UserRound },
     {
         title: "Change password",
@@ -71,7 +80,7 @@ export const SettingsPages: SettingsPage[] = [
     },
     {
         title: "Models",
-        url: "/admin/settings/models",
+        url: SettingsModelsPath,
         Icon: CpuAi,
         super_admin_only: true,
     },

src/functions/backend/db/bot-questions/answer-bot-question.ts

@@ -0,0 +1,33 @@
+import BunSQLite from "@moduletrace/bun-sqlite";
+import AppError from "@/src/utils/app-error";
+import checkBotQuestionAnswers from "@/src/utils/check-bot-question-answers";
+import parseBotQuestionRow from "@/src/utils/parse-bot-question-row";
+import grabBotQuestion from "./grab-bot-question";
+
+type Params = {
+    question_id: number | string;
+    user_id: number | string;
+    answers: { choices: number[]; other?: string }[];
+};
+
+/**
+ * The user answered questions a bot asked in its card: checked against the
+ * questions (`checkBotQuestionAnswers`), then stored once (only pending
+ * questions move, so a double click answers once).
+ */
+export default async function answerBotQuestion({ question_id, user_id, answers }: Params) {
+    const row = await grabBotQuestion({ question_id, user_id });
+    const { questions } = parseBotQuestionRow({ row });
+    const checked = checkBotQuestionAnswers({ questions, answers });
+    const now = Date.now();
+
+    const claimed = await BunSQLite.sql<{ id: number }>({
+        sql: `UPDATE bot_questions SET status = 'answered', answers = ?, decided_at = ?, updated_at = ?
+            WHERE id = ? AND status = 'pending' RETURNING id`,
+        values: [JSON.stringify(checked), now, now, Number(row.id)],
+    });
+
+    if (!claimed.payload?.[0]) throw new AppError(`These questions were already ${row.status}.`);
+
+    return row;
+}

src/functions/backend/db/bot-questions/create-bot-question.ts

@@ -0,0 +1,39 @@
+import BunSQLite from "@moduletrace/bun-sqlite";
+import type { BUN_SQLITE_COBBLE_BOT_QUESTIONS, BunSQLiteTables } from "@/db/types/db";
+import type { BotQuestionItem } from "@/src/types";
+
+type Params = {
+    user_id: number | string;
+    bot_id: number | string;
+    session_id: number | string;
+    workspace_id?: number | string | null;
+    title: string;
+    questions: BotQuestionItem[];
+};
+
+/**
+ * Stores questions a bot asks the user, pending until they answer or skip
+ * them in its card. Returns its id.
+ */
+export default async function createBotQuestion({ user_id, bot_id, session_id, workspace_id, title, questions }: Params) {
+    const res = await BunSQLite.insert<BUN_SQLITE_COBBLE_BOT_QUESTIONS, (typeof BunSQLiteTables)[number]>({
+        table: "bot_questions",
+        data: [
+            {
+                title,
+                questions: JSON.stringify(questions),
+                status: "pending",
+                user_id: Number(user_id),
+                bot_id: Number(bot_id),
+                session_id: Number(session_id),
+                workspace_id: workspace_id ? Number(workspace_id) : undefined,
+            },
+        ],
+    });
+
+    const id = Number(res.singleRes?.id || res.postInsertReturn?.insertId);
+
+    if (!res.success || !id) throw new Error(`Couldn't store the questions: ${res.msg}`);
+
+    return id;
+}

src/functions/backend/db/bot-questions/grab-bot-question-view.ts

@@ -0,0 +1,36 @@
+import BunSQLite from "@moduletrace/bun-sqlite";
+import type { BotQuestionStatus } from "@/src/dict/bot-question-dict";
+import type { BotQuestionView } from "@/src/types";
+import parseBotQuestionRow from "@/src/utils/parse-bot-question-row";
+import grabBotQuestion from "./grab-bot-question";
+
+type Params = {
+    question_id: number | string;
+    user_id: number | string;
+};
+
+/**
+ * Questions a bot asked the user as their chip and card show them: the
+ * questions, their options and, once answered, what the user picked.
+ */
+export default async function grabBotQuestionView({ question_id, user_id }: Params): Promise<BotQuestionView> {
+    const row = await grabBotQuestion({ question_id, user_id });
+    const { questions, answers } = parseBotQuestionRow({ row });
+
+    const bot = (
+        await BunSQLite.sql<{ name: string }>({
+            sql: `SELECT name FROM bots WHERE id = ? LIMIT 1`,
+            values: [row.bot_id || 0],
+        })
+    ).payload?.[0];
+
+    return {
+        id: Number(row.id),
+        title: row.title || "",
+        questions,
+        answers,
+        status: (row.status || "pending") as BotQuestionStatus,
+        bot_id: Number(row.bot_id),
+        bot_name: bot?.name || "The bot",
+    };
+}

src/functions/backend/db/bot-questions/grab-bot-question.ts

@@ -0,0 +1,28 @@
+import BunSQLite from "@moduletrace/bun-sqlite";
+import type { BUN_SQLITE_COBBLE_BOT_QUESTIONS } from "@/db/types/db";
+import AppError from "@/src/utils/app-error";
+
+type Params = {
+    question_id: number | string;
+    /**
+     * Only the user they were asked of reads them.
+     */
+    user_id: number | string;
+};
+
+/**
+ * Questions a bot asked, only for the user they were asked of. Throws
+ * otherwise.
+ */
+export default async function grabBotQuestion({ question_id, user_id }: Params) {
+    const row = (
+        await BunSQLite.sql<BUN_SQLITE_COBBLE_BOT_QUESTIONS>({
+            sql: `SELECT * FROM bot_questions WHERE id = ? AND user_id = ? LIMIT 1`,
+            values: [Number(question_id), Number(user_id)],
+        })
+    ).payload?.[0];
+
+    if (!row?.id) throw new AppError(`Those questions aren't yours or no longer exist.`);
+
+    return row;
+}

src/functions/backend/db/bot-questions/skip-bot-question.ts

@@ -0,0 +1,26 @@
+import BunSQLite from "@moduletrace/bun-sqlite";
+import AppError from "@/src/utils/app-error";
+import grabBotQuestion from "./grab-bot-question";
+
+type Params = {
+    question_id: number | string;
+    user_id: number | string;
+};
+
+/**
+ * The user skipped questions a bot asked: nothing is answered.
+ */
+export default async function skipBotQuestion({ question_id, user_id }: Params) {
+    const row = await grabBotQuestion({ question_id, user_id });
+    const now = Date.now();
+
+    const claimed = await BunSQLite.sql<{ id: number }>({
+        sql: `UPDATE bot_questions SET status = 'skipped', decided_at = ?, updated_at = ?
+            WHERE id = ? AND status = 'pending' RETURNING id`,
+        values: [now, now, Number(row.id)],
+    });
+
+    if (!claimed.payload?.[0]) throw new AppError(`These questions were already ${row.status}.`);
+
+    return row;
+}

src/functions/backend/db/bots/delete-bot.ts

@@ -55,6 +55,7 @@ export default async function deleteBot({ user_id, bot_id }: Params) {
 
     await BunSQLite.sql({ sql: `DELETE FROM envs WHERE bot_id = ?`, values: [bot.id] });
     await BunSQLite.sql({ sql: `DELETE FROM secret_requests WHERE bot_id = ?`, values: [bot.id] });
+    await BunSQLite.sql({ sql: `DELETE FROM bot_questions WHERE bot_id = ?`, values: [bot.id] });
     await BunSQLite.sql({ sql: `DELETE FROM bot_graphics WHERE bot_id = ?`, values: [bot.id] });
 
     const res = await BunSQLite.sql({ sql: `DELETE FROM bots WHERE id = ?`, values: [bot.id] });

src/functions/backend/db/users/delete-user.ts

@@ -74,7 +74,7 @@ export default async function deleteUser({ actor_user_id, actor_user_types, user
     /**
      * These point at the user without a foreign key, so nothing cascades.
      */
-    for (const table of ["user_types", "user_passwords", "sso_login_codes", "secret_requests", "bot_graphics"]) {
+    for (const table of ["user_types", "user_passwords", "sso_login_codes", "secret_requests", "bot_questions", "bot_graphics"]) {
         await BunSQLite.sql({ sql: `DELETE FROM ${table} WHERE user_id = ?`, values: [user.id] });
     }
 

src/functions/backend/db/workspaces/grab-workspace-activity.ts

@@ -10,8 +10,8 @@ type Params = {
 
 /**
  * The user's latest conversations in a workspace, most recent first, each
- * with the bot it's with (its face as the user sees it), its message count and latest message. Empty
- * sessions are left out unless active.
+ * with the bot it's with (its face as the user sees it), its message count, first and latest message. Sessions
+ * with no messages yet are left out, active or not.
  */
 export default async function grabWorkspaceActivity({
     user_id,
@@ -28,11 +28,12 @@ export default async function grabWorkspaceActivity({
                 b.stone AS bot_stone,
                 ${face.sql},
                 (SELECT COUNT(*) FROM bot_messages m WHERE m.session_id = s.id) AS message_count,
-                (SELECT m.text FROM bot_messages m WHERE m.session_id = s.id ORDER BY m.created_at DESC, m.id DESC LIMIT 1) AS last_message_text
+                (SELECT m.text FROM bot_messages m WHERE m.session_id = s.id ORDER BY m.created_at DESC, m.id DESC LIMIT 1) AS last_message_text,
+                (SELECT m.text FROM bot_messages m WHERE m.session_id = s.id ORDER BY m.created_at ASC, m.id ASC LIMIT 1) AS first_message_text
             FROM bot_sessions s
             JOIN bots b ON b.id = s.bot_id
             WHERE s.workspace_id = ? AND s.user_id = ? AND s.chatroom_id IS NULL
-            AND (s.status = 'active' OR EXISTS (SELECT 1 FROM bot_messages m WHERE m.session_id = s.id))
+            AND EXISTS (SELECT 1 FROM bot_messages m WHERE m.session_id = s.id)
             AND (b.kind = 'coordinator' OR EXISTS (
                 SELECT 1 FROM workspace_bots wb WHERE wb.workspace_id = s.workspace_id AND wb.bot_id = s.bot_id
             ))

src/harness/catalog/guess-model-modalities.ts

@@ -11,7 +11,7 @@ type Guess = Pick<
 
 const Transcription = /whisper|transcri|(?:^|[-_/])(stt|asr)(?=$|[-_:.])|scribe/i;
 const Speech = /(?:^|[-_/])tts(?=$|[-_:.])|speech|voice/i;
-const ImageOut = /dall-e|gpt-image|imagen|flux|stable-diffusion|sdxl|image-gen/i;
+const ImageOut = /dall-e|gpt-image|imagen|flux|stable-diffusion|sdxl|image-gen|qwen-image|kontext|seedream|image-edit/i;
 const Embedding = /embed/i;
 /**
  * Chat families that read images.

src/harness/catalog/model-serves-harness.test.ts

@@ -72,4 +72,19 @@ describe("modelServesHarness", () => {
             }),
         ).toBe(true);
     });
+
+    test("image editing takes and makes images", () => {
+        expect(
+            modelServesHarness({
+                model: { ...chat, output_modalities: ["image"] },
+                harness: "image_edit",
+            }),
+        ).toBe(false);
+        expect(
+            modelServesHarness({
+                model: { ...chat, input_modalities: ["text", "image"], output_modalities: ["image"] },
+                harness: "image_edit",
+            }),
+        ).toBe(true);
+    });
 });

src/harness/catalog/model-serves-harness.ts

@@ -17,6 +17,7 @@ type Params = {
  *   audio: free ones often drop it)
  * - speech: a text-to-speech model
  * - image: makes images
+ * - image_edit: makes images from reference images (takes and makes them)
  * - embedding: turns text into vectors (never a chat model)
  */
 export default function modelServesHarness({ model, harness }: Params) {
@@ -41,6 +42,9 @@ export default function modelServesHarness({ model, harness }: Params) {
         case "image":
             return output.has("image");
 
+        case "image_edit":
+            return input.has("image") && output.has("image");
+
         case "embedding":
             return output.has("embeddings");
     }

src/harness/image/generate-image.ts

@@ -1,9 +1,12 @@
+import grabHarnessSetting from "@/src/functions/backend/db/harness/grab-harness-setting";
+import HarnessError from "../harness-error";
 import grabHarnessAdapter from "../providers/grab-harness-adapter";
 import resolveHarnessCandidates from "../resolve/resolve-harness-candidates";
 import withCandidates from "../resolve/with-candidates";
 import type { HarnessImageOutput, HarnessUsage } from "../types";
 import buildUsageCall from "../usage/build-usage-call";
 import recordHarnessUsage from "../usage/record-harness-usage";
+import orderImageCandidates from "./order-image-candidates";
 
 type Params = {
     prompt: string;
@@ -25,7 +28,9 @@ type Params = {
 };
 
 /**
- * Makes images with the image generation harness. Returns their bytes.
+ * Makes images with the image generation harness, or with image editing
+ * when there are reference images (`orderImageCandidates` decides who
+ * tries). Returns their bytes.
  */
 export default async function generateImage({
     prompt,
@@ -36,15 +41,36 @@ export default async function generateImage({
     bot_id,
     workspace_id,
 }: Params) {
-    const candidates = await resolveHarnessCandidates({ harness: "image", bot_id, workspace_id });
+    const has_references = Boolean(references?.length);
+    const edit = has_references ? await grabEdit({ bot_id, workspace_id }) : undefined;
+    /**
+     * Image generation turned off still leaves an image editing pick to
+     * work with.
+     */
+    const image = await resolveHarnessCandidates({ harness: "image", bot_id, workspace_id }).catch(
+        (error: unknown) => {
+            if (edit?.candidates.length) return [];
+            throw error;
+        },
+    );
+    const ordered = orderImageCandidates({ references: has_references, image, edit });
+
+    if (has_references && !ordered.length && image.length) {
+        throw new HarnessError({
+            message: `None of the image models here takes reference images. A super admin can pick one under Image editing in Settings, under Models.`,
+            code: "unavailable",
+        });
+    }
+
+    const harness_of = new Map(ordered.map(({ candidate, harness }) => [candidate.key, harness]));
 
     const { result } = await withCandidates<{ images: HarnessImageOutput[]; usage?: HarnessUsage }>({
-        harness: "image",
-        candidates,
+        harness: edit?.picked ? "image_edit" : "image",
+        candidates: ordered.map(({ candidate }) => candidate),
         on_success: async ({ candidate, result: made, failed }): Promise<void> =>
             await recordHarnessUsage({
                 call: buildUsageCall({
-                    harness: "image",
+                    harness: harness_of.get(candidate.key) || "image",
                     candidate,
                     failed,
                     usage: made.usage,
@@ -65,3 +91,26 @@ export default async function generateImage({
 
     return result.images;
 }
+
+/**
+ * Image editing's setting and candidates, or undefined while it's off.
+ */
+async function grabEdit({
+    bot_id,
+    workspace_id,
+}: {
+    bot_id?: number | string;
+    workspace_id?: number | string | null;
+}) {
+    const setting = await grabHarnessSetting({ harness: "image_edit", bot_id, workspace_id });
+
+    if (!setting.enabled) return undefined;
+
+    return {
+        picked: Boolean(setting.model_id),
+        fallback: setting.fallback,
+        candidates: setting.model_id
+            ? await resolveHarnessCandidates({ harness: "image_edit", bot_id, workspace_id })
+            : [],
+    };
+}

src/harness/image/load-reference-images.ts

@@ -0,0 +1,82 @@
+import { AppData } from "@/src/data/app-data";
+import grabPictureSource from "@/src/functions/backend/db/profile-images/grab-picture-source";
+import AppError from "@/src/utils/app-error";
+import mediaFilePath from "@/src/utils/media-file-path";
+import type { StorageScope } from "@/src/utils/storage-access";
+
+/**
+ * Image types every image model takes as a reference.
+ */
+const ReferenceImageTypes = ["png", "jpeg", "jpg", "webp", "gif"];
+
+type Params = {
+    user_id: number | string;
+    /**
+     * The files the run reaches, so a reference is only ever a file the
+     * bot could already read.
+     */
+    scopes: StorageScope[];
+    /**
+     * Files by `[file:ID]` id.
+     */
+    file_ids?: number[];
+    /**
+     * The user's own uploads, by media id.
+     */
+    media_ids?: number[];
+};
+
+/**
+ * The reference images an image call passes on, as `data:` URLs. Each is
+ * checked the way a picture is (`grabPictureSource`: a file in the run's
+ * directories or the user's own upload), then to be a raster image within
+ * `AppData.ImageReferenceMaxBytes`. Throws on the first one that isn't.
+ */
+export default async function loadReferenceImages({
+    user_id,
+    scopes,
+    file_ids = [],
+    media_ids = [],
+}: Params): Promise<string[]> {
+    const sources: { file_id?: number; media_id?: number }[] = [
+        ...file_ids.map((file_id) => ({ file_id })),
+        ...media_ids.map((media_id) => ({ media_id })),
+    ];
+
+    if (sources.length > AppData.ImageReferenceMaxCount) {
+        throw new AppError(`Pass at most ${AppData.ImageReferenceMaxCount} reference images.`);
+    }
+
+    const urls: string[] = [];
+
+    for (const source of sources) {
+        const media = await grabPictureSource({ user_id, scopes, ...source });
+        const label = source.file_id ? `[file:${source.file_id}]` : `media id ${source.media_id}`;
+        const type = (media?.mime_type || "").replace(/^image\//, "").toLowerCase();
+
+        if (!media || media.media_type != "image" || !ReferenceImageTypes.includes(type)) {
+            throw new AppError(
+                `${label} can't be a reference: use a PNG, JPEG, WebP or GIF image.`,
+            );
+        }
+
+        const absolute = mediaFilePath({ write_path: media.media_write_path });
+        const disk = absolute ? Bun.file(absolute) : null;
+
+        if (!disk || !(await disk.exists())) {
+            throw new AppError(`${label} is missing on the server.`);
+        }
+
+        if (disk.size > AppData.ImageReferenceMaxBytes) {
+            throw new AppError(
+                `${label} is too large to pass on (at most ${Math.round(AppData.ImageReferenceMaxBytes / (1024 * 1024))} MB).`,
+            );
+        }
+
+        const base64 = Buffer.from(await disk.arrayBuffer()).toString("base64");
+
+        urls.push(`data:image/${type == "jpg" ? "jpeg" : type};base64,${base64}`);
+    }
+
+    return urls;
+}

src/harness/image/order-image-candidates.test.ts

@@ -0,0 +1,105 @@
+import { describe, expect, test } from "bun:test";
+import type { HarnessCandidate } from "../types";
+import orderImageCandidates from "./order-image-candidates";
+
+function candidate({ slug, takes_images }: { slug: string; takes_images: boolean }): HarnessCandidate {
+    return {
+        key: `1:${slug}`,
+        provider: { id: 1, kind: "openrouter", base_url: "", name: "OpenRouter" } as HarnessCandidate["provider"],
+        model: {
+            slug,
+            input_modalities: takes_images ? ["text", "image"] : ["text"],
+            output_modalities: ["image"],
+            supports_tools: false,
+        },
+        source: "pinned",
+    };
+}
+
+const flux = candidate({ slug: "flux", takes_images: true });
+const recraft = candidate({ slug: "recraft", takes_images: false });
+const qwen_edit = candidate({ slug: "qwen-image-edit", takes_images: true });
+
+function slugs(list: ReturnType<typeof orderImageCandidates>) {
+    return list.map(({ candidate, harness }) => `${harness}:${candidate.model.slug}`);
+}
+
+describe("orderImageCandidates", () => {
+    test("without references, image generation's models as they are", () => {
+        expect(
+            slugs(
+                orderImageCandidates({
+                    references: false,
+                    image: [recraft, flux],
+                    edit: { picked: true, fallback: true, candidates: [qwen_edit] },
+                }),
+            ),
+        ).toEqual(["image:recraft", "image:flux"]);
+    });
+
+    test("with references and no edit pick, only image models that take images", () => {
+        expect(
+            slugs(
+                orderImageCandidates({
+                    references: true,
+                    image: [recraft, flux],
+                    edit: { picked: false, fallback: true, candidates: [] },
+                }),
+            ),
+        ).toEqual(["image:flux"]);
+    });
+
+    test("image editing off goes to image generation", () => {
+        expect(
+            slugs(orderImageCandidates({ references: true, image: [recraft, flux] })),
+        ).toEqual(["image:flux"]);
+    });
+
+    test("the edit pick first, then image generation with fallback on", () => {
+        expect(
+            slugs(
+                orderImageCandidates({
+                    references: true,
+                    image: [flux, recraft],
+                    edit: { picked: true, fallback: true, candidates: [qwen_edit] },
+                }),
+            ),
+        ).toEqual(["image_edit:qwen-image-edit", "image:flux"]);
+    });
+
+    test("fallback off keeps to the edit pick", () => {
+        expect(
+            slugs(
+                orderImageCandidates({
+                    references: true,
+                    image: [flux],
+                    edit: { picked: true, fallback: false, candidates: [qwen_edit] },
+                }),
+            ),
+        ).toEqual(["image_edit:qwen-image-edit"]);
+    });
+
+    test("an edit pick that can't run falls to image generation", () => {
+        expect(
+            slugs(
+                orderImageCandidates({
+                    references: true,
+                    image: [flux],
+                    edit: { picked: true, fallback: false, candidates: [] },
+                }),
+            ),
+        ).toEqual(["image:flux"]);
+    });
+
+    test("a model in both lists is tried once, as the edit pick", () => {
+        expect(
+            slugs(
+                orderImageCandidates({
+                    references: true,
+                    image: [flux],
+                    edit: { picked: true, fallback: true, candidates: [flux] },
+                }),
+            ),
+        ).toEqual(["image_edit:flux"]);
+    });
+});

src/harness/image/order-image-candidates.ts

@@ -0,0 +1,65 @@
+import type { HarnessCandidate } from "../types";
+
+export type ImageCandidate = {
+    candidate: HarnessCandidate;
+    /**
+     * The harness it was picked for, for its usage row.
+     */
+    harness: "image" | "image_edit";
+};
+
+type Params = {
+    /**
+     * Whether the call passes reference images.
+     */
+    references: boolean;
+    /**
+     * Image generation's candidates.
+     */
+    image: HarnessCandidate[];
+    /**
+     * Image editing's setting and candidates; undefined when it's off.
+     */
+    edit?: {
+        /**
+         * Whether a model is picked for it.
+         */
+        picked: boolean;
+        fallback: boolean;
+        candidates: HarnessCandidate[];
+    };
+};
+
+/**
+ * The models an image call tries, in order. Without references: image
+ * generation's. With them: image editing's pick, then (with fallback on)
+ * the image generation models that take images; only those while image
+ * editing has no usable model or is off. A model that can't take an image
+ * is never tried with references, since it would drop them unseen.
+ */
+export default function orderImageCandidates({ references, image, edit }: Params): ImageCandidate[] {
+    if (!references) {
+        return image.map((candidate) => ({ candidate, harness: "image" }));
+    }
+
+    const takes_images = image
+        .filter((candidate) => candidate.model.input_modalities.includes("image"))
+        .map((candidate) => ({ candidate, harness: "image" as const }));
+
+    const edits = edit?.picked
+        ? edit.candidates.map((candidate) => ({ candidate, harness: "image_edit" as const }))
+        : [];
+
+    const ordered = !edits.length
+        ? takes_images
+        : [...edits, ...(edit?.fallback ? takes_images : [])];
+
+    const seen = new Set<string>();
+
+    return ordered.filter(({ candidate }) => {
+        if (seen.has(candidate.key)) return false;
+        seen.add(candidate.key);
+
+        return true;
+    });
+}

src/harness/providers/openai-compatible/generate-image.ts

@@ -1,4 +1,5 @@
 import { AppData } from "@/src/data/app-data";
+import bufferFromBase64 from "@/src/utils/buffer-from-base-64";
 import HarnessError from "../../harness-error";
 import type { HarnessAdapter, HarnessImageOutput } from "../../types";
 import grabProviderPreset from "../grab-provider-preset";
@@ -6,8 +7,10 @@ import providerRequest from "./provider-request";
 
 /**
  * Image generation at the provider's `image_path` (`/images` on
- * OpenRouter, `/images/generations` elsewhere). Images come back as
- * base64, or as URLs that are downloaded here.
+ * OpenRouter, `/images/generations` elsewhere). With reference images,
+ * OpenRouter takes them on the same call (`input_references`); the others
+ * get them as a multipart upload at `image_edit_path` (`/images/edits`).
+ * Images come back as base64, or as URLs that are downloaded here.
  */
 const generateImage: HarnessAdapter["generateImage"] = async ({
     candidate,
@@ -20,29 +23,45 @@ const generateImage: HarnessAdapter["generateImage"] = async ({
     const { provider, model } = candidate;
     const preset = grabProviderPreset({ kind: provider.kind });
     const is_openrouter = provider.kind == "openrouter";
+    const edits = Boolean(references?.length) && !is_openrouter;
 
-    const res = await providerRequest({
-        provider,
-        path: preset.image_path,
-        json: {
-            model: model.slug,
-            prompt,
-            ...(n ? { n } : {}),
-            ...(size ? { size } : {}),
-            ...(is_openrouter
-                ? references?.length
-                    ? {
-                          input_references: references.map((url) => ({
-                              type: "image_url",
-                              image_url: { url },
-                          })),
-                      }
-                    : {}
-                : { response_format: "b64_json" }),
-        },
-        signal,
-        candidate_key: candidate.key,
-    });
+    const res = edits
+        ? await providerRequest({
+              provider,
+              path: preset.image_edit_path,
+              form: await editForm({
+                  model: model.slug,
+                  prompt,
+                  n,
+                  size,
+                  references: references || [],
+                  signal,
+              }),
+              signal,
+              candidate_key: candidate.key,
+          })
+        : await providerRequest({
+              provider,
+              path: preset.image_path,
+              json: {
+                  model: model.slug,
+                  prompt,
+                  ...(n ? { n } : {}),
+                  ...(size ? { size } : {}),
+                  ...(is_openrouter
+                      ? references?.length
+                          ? {
+                                input_references: references.map((url) => ({
+                                    type: "image_url",
+                                    image_url: { url },
+                                })),
+                            }
+                          : {}
+                      : { response_format: "b64_json" }),
+              },
+              signal,
+              candidate_key: candidate.key,
+          });
 
     const json = await res.json().catch(() => null);
     const items: any[] = Array.isArray(json?.data) ? json.data : [];
@@ -98,3 +117,59 @@ const generateImage: HarnessAdapter["generateImage"] = async ({
 };
 
 export default generateImage;
+
+type EditFormParams = {
+    model: string;
+    prompt: string;
+    n?: number;
+    size?: string;
+    references: string[];
+    signal: AbortSignal;
+};
+
+/**
+ * The `/images/edits` upload: the prompt and every reference image as a
+ * file (`image[]` when there are several, as gpt-image takes them).
+ */
+async function editForm({ model, prompt, n, size, references, signal }: EditFormParams) {
+    const form = new FormData();
+
+    form.append("model", model);
+    form.append("prompt", prompt);
+    if (n) form.append("n", String(n));
+    if (size) form.append("size", size);
+
+    const field = references.length > 1 ? "image[]" : "image";
+
+    for (let index = 0; index < references.length; index++) {
+        const { blob, ext } = await referenceBlob({ url: references[index]!, signal });
+
+        form.append(field, blob, `reference-${index + 1}.${ext}`);
+    }
+
+    return form;
+}
+
+/**
+ * A reference's bytes: decoded from a `data:` URL, downloaded otherwise.
+ */
+async function referenceBlob({ url, signal }: { url: string; signal: AbortSignal }) {
+    if (url.startsWith("data:")) {
+        const { buffer, ext } = await bufferFromBase64(url);
+        const type = url.slice(5, url.indexOf(";")) || "image/png";
+
+        return { blob: new Blob([new Uint8Array(buffer)], { type }), ext };
+    }
+
+    const download = await fetch(url, {
+        signal: AbortSignal.any([signal, AbortSignal.timeout(AppData.HarnessRequestTimeoutMs)]),
+    });
+
+    if (!download.ok) {
+        throw new HarnessError({ message: `A reference image couldn't be downloaded.` });
+    }
+
+    const type = download.headers.get("content-type")?.split(";")[0] || "image/png";
+
+    return { blob: new Blob([await download.arrayBuffer()], { type }), ext: type.split("/")[1] || "png" };
+}

src/harness/tools/bot/questions/ask-user-tool.test.ts

@@ -0,0 +1,26 @@
+import { describe, expect, test } from "bun:test";
+import askUserTool from "./ask-user-tool";
+
+const tool = askUserTool({ user_id: 1, bot_id: 2, session_id: 3, onAsk: () => {} });
+
+const question = { question: "Which environment?", kind: "single", options: ["Staging", "Production"] };
+
+describe("askUserTool", () => {
+    test("takes a set of questions", () => {
+        expect(tool.schema?.safeParse({ title: "Before I deploy", questions: [question] }).success).toBe(true);
+    });
+
+    test("needs at least two distinct options", () => {
+        expect(tool.schema?.safeParse({ questions: [{ ...question, options: ["Staging"] }] }).success).toBe(false);
+        expect(tool.schema?.safeParse({ questions: [{ ...question, options: ["Staging", "staging"] }] }).success).toBe(false);
+    });
+
+    test("needs a known kind and at least one question", () => {
+        expect(tool.schema?.safeParse({ questions: [{ ...question, kind: "ranked" }] }).success).toBe(false);
+        expect(tool.schema?.safeParse({ questions: [] }).success).toBe(false);
+    });
+
+    test("caps how many questions one card holds", () => {
+        expect(tool.schema?.safeParse({ questions: Array.from({ length: 7 }, () => question) }).success).toBe(false);
+    });
+});

src/harness/tools/bot/questions/ask-user-tool.ts

@@ -0,0 +1,81 @@
+import { z } from "zod";
+import createBotQuestion from "@/src/functions/backend/db/bot-questions/create-bot-question";
+import { BotQuestionItemsSchema } from "@/src/schemas/bot-question-schema";
+import botQuestionRef from "@/src/utils/bot-question-ref";
+import type { HarnessTool } from "../../../types";
+
+type Params = {
+    user_id: number | string;
+    bot_id: number | string;
+    /**
+     * The conversation they're asked in, where their card shows.
+     */
+    session_id: number | string;
+    workspace_id?: number | string | null;
+    /**
+     * Whether the run is a task, which stops and reports rather than waits.
+     */
+    in_task?: boolean;
+    /**
+     * Called with the questions' ref, so the message always carries their
+     * card.
+     */
+    onAsk: (params: { ref: string }) => void;
+};
+
+type Args = {
+    title?: string;
+    questions: z.infer<typeof BotQuestionItemsSchema>;
+};
+
+/**
+ * Lets a bot make sure of what the user wants before it acts: it asks a
+ * few multiple-choice questions, the user answers them in a card (radios
+ * for one pick, checkboxes for several, "Other" to type their own), and
+ * the answers come back as the user's next message. Once per run, so every
+ * question goes on one card.
+ */
+export default function askUserTool({ user_id, bot_id, session_id, workspace_id, in_task, onAsk }: Params): HarnessTool<Args> {
+    let asked = false;
+
+    return {
+        name: "ask_user",
+        description: `Ask the user multiple-choice questions to be sure what they want before you act, shown as a card in the chat they answer by picking options. Use it when the request is ambiguous or open to more than one reading, when a choice is theirs to make (which target, which items, how far to go), or before something that is hard to undo, costly or visible to others, and you can't tell what they'd pick. Don't ask what they already told you, what you can find out yourself, or what any sensible choice would settle. Put every question in one call (at most one per reply). Their answers arrive as their next message${
+            in_task ? `. In a task, ask, then stop and report that you're waiting for their answers.` : `: after asking, end your reply and wait; don't act on what you asked about until they answer.`
+        }`,
+        schema: z.object({
+            title: z.string().trim().max(120).optional().describe("A short heading for the card, e.g. \"Before I deploy\""),
+            questions: BotQuestionItemsSchema.describe("The questions, in the order to answer them"),
+        }),
+        run: async ({ args }) => {
+            if (asked) {
+                throw new Error(`You already asked the user in this run. Put every question in one ask_user call, then wait for their answers.`);
+            }
+
+            const id = await createBotQuestion({
+                user_id,
+                bot_id,
+                session_id,
+                workspace_id,
+                title: args.title?.trim() || "",
+                questions: args.questions.map((item) => ({
+                    question: item.question,
+                    kind: item.kind,
+                    options: item.options,
+                    allow_other: Boolean(item.allow_other),
+                })),
+            });
+
+            asked = true;
+            onAsk({ ref: botQuestionRef({ id }) });
+
+            const count = args.questions.length;
+
+            return `Asked the user ${count} question${count == 1 ? "" : "s"}: the card is on your message. ${
+                in_task
+                    ? `Stop here and report that you're waiting for their answers.`
+                    : `End your reply now with a short line saying what you need settled; their answers arrive as their next message.`
+            } Don't repeat the questions or options in your text.`;
+        },
+    };
+}

src/harness/tools/storage/generate-image-tool.ts

@@ -1,6 +1,9 @@
 import { z } from "zod";
 import recordBotFile from "@/src/functions/backend/db/bot-files/record-bot-file";
+import { AppData } from "@/src/data/app-data";
 import generateImage from "@/src/harness/image/generate-image";
+import loadReferenceImages from "@/src/harness/image/load-reference-images";
+import parseFileRef from "@/src/utils/parse-file-ref";
 import type { HarnessTool } from "../../types";
 import {
     describeScope,
@@ -12,6 +15,8 @@ import {
 
 type Args = {
     prompt: string;
+    references?: (string | number)[];
+    reference_media_ids?: number[];
     path?: string;
     size?: string;
     attach?: boolean;
@@ -19,18 +24,30 @@ type Args = {
 };
 
 /**
- * Makes an image with the image generation harness and saves it in the
- * bot's files, so it can be sent, shown again later or used by another
- * run. The bytes stay in the app's storage, never on a computer.
+ * Makes an image with the image generation harness (image editing when it
+ * passes reference images: files the run reaches or the user's uploads)
+ * and saves it in the bot's files, so it can be sent, shown again later or
+ * used by another run. The bytes stay in the app's storage, never on a
+ * computer.
  */
 export default function generateImageTool(context: StorageToolContext): HarnessTool<Args> {
     const own = context.scopes[0];
 
     return {
         name: "generate_image",
-        description: `Make an image from a description and save it in your files. Describe what should be in it, in one clear prompt. The image is saved (so you can send it now and show it later) and can ride on this reply with "attach".`,
+        description: `Make an image from a description and save it in your files. Describe what should be in it, in one clear prompt. To work from existing images (a logo to rework, a style or palette to follow, a photo to change), pass them as "references" ([file:ID] refs from list_files) or "reference_media_ids" (images the user uploaded), up to ${AppData.ImageReferenceMaxCount}, and say in the prompt what to take from each. The image is saved (so you can send it now and show it later) and can ride on this reply with "attach".`,
         schema: z.object({
             prompt: z.string().min(3).max(4000),
+            references: z
+                .array(z.union([z.string().max(60), z.number().int().positive()]))
+                .max(AppData.ImageReferenceMaxCount)
+                .optional()
+                .describe(`Images in your files to work from, by [file:ID] ref, e.g. ["[file:12]"]`),
+            reference_media_ids: z
+                .array(z.number().int().positive())
+                .max(AppData.ImageReferenceMaxCount)
+                .optional()
+                .describe(`Images the user uploaded to work from, by media id`),
             path: z
                 .string()
                 .max(300)
@@ -55,8 +72,22 @@ export default function generateImageTool(context: StorageToolContext): HarnessT
                     .join(", ")}.`;
             }
 
+            const file_ids = (args.references || []).map((ref) => parseFileRef({ ref }));
+
+            if (file_ids.some((id) => !id)) {
+                return `Give each reference as its [file:ID] ref, e.g. "[file:12]". list_files lists them.`;
+            }
+
+            const references = await loadReferenceImages({
+                user_id: context.user_id,
+                scopes: context.scopes,
+                file_ids: file_ids as number[],
+                media_ids: args.reference_media_ids,
+            });
+
             const images = await generateImage({
                 prompt: args.prompt,
+                references,
                 size: args.size,
                 signal,
                 bot_id: context.bot_id,

src/harness/types.ts

@@ -157,6 +157,7 @@ export type HarnessUsageKind =
     | "transcription"
     | "speech"
     | "image"
+    | "image_edit"
     | "embedding";
 
 export type HarnessChatParams = {

src/harness/usage/types.ts

@@ -58,7 +58,7 @@ export type HarnessCallSettings = {
 };
 
 export type HarnessUsageCall = {
-    harness: "text" | "vision" | "transcription" | "speech" | "image" | "embedding";
+    harness: "text" | "vision" | "transcription" | "speech" | "image" | "image_edit" | "embedding";
     provider_id?: number;
     provider_name?: string;
     model_id?: number;

src/hooks/use-file-text.ts

@@ -0,0 +1,89 @@
+import { useEffect, useState } from "react";
+import { AppData } from "@/src/data/app-data";
+
+type Params = {
+    url: string;
+    /**
+     * Read nothing (a preview that isn't text).
+     */
+    skip?: boolean;
+    /**
+     * The file's size when known, so a big one isn't fetched at all.
+     */
+    size?: number;
+};
+
+type FileText = {
+    text: string | null;
+    loading: boolean;
+    error: string | null;
+    /**
+     * Bigger than `AppData.FilePreviewMaxTextBytes`: offered to download only.
+     */
+    too_large: boolean;
+};
+
+/**
+ * A file's bytes read as text for the preview, once per URL, up to
+ * `AppData.FilePreviewMaxTextBytes`.
+ */
+export default function useFileText({ url, skip, size }: Params): FileText {
+    const max = AppData.FilePreviewMaxTextBytes;
+    const known_too_large = Boolean(size && size > max);
+    const [state, setState] = useState<FileText>({
+        text: null,
+        loading: !skip && !known_too_large,
+        error: null,
+        too_large: known_too_large,
+    });
+
+    useEffect(() => {
+        if (skip || known_too_large) return;
+
+        let live = true;
+
+        setState({ text: null, loading: true, error: null, too_large: false });
+
+        (async () => {
+            try {
+                const res = await fetch(url, { credentials: "same-origin" });
+
+                if (!res.ok) throw new Error(`The file couldn't be read (${res.status}).`);
+
+                const length = Number(res.headers.get("content-length")) || 0;
+
+                if (length > max) {
+                    res.body?.cancel();
+                    if (live) setState({ text: null, loading: false, error: null, too_large: true });
+                    return;
+                }
+
+                const blob = await res.blob();
+
+                if (blob.size > max) {
+                    if (live) setState({ text: null, loading: false, error: null, too_large: true });
+                    return;
+                }
+
+                const text = await blob.text();
+
+                if (live) setState({ text, loading: false, error: null, too_large: false });
+            } catch (error: any) {
+                if (live) {
+                    setState({
+                        text: null,
+                        loading: false,
+                        error: error?.message || "The file couldn't be read.",
+                        too_large: false,
+                    });
+                }
+            }
+        })();
+
+        return () => {
+            live = false;
+        };
+    }, [url, skip, known_too_large, max]);
+
+    return state;
+}

src/pages/admin/bots/[bot_id]/(functions)/decide-bot-question.ts

@@ -0,0 +1,22 @@
+import fetchApi from "@moduletrace/twui/utils/fetch/fetchApi";
+import type { APIResponseObject } from "@moduletrace/bunext/types";
+import type { BotQuestionAnswer, BotQuestionView } from "@/src/types";
+
+type Params = {
+    question_id: number;
+    /**
+     * One per question; none skips them.
+     */
+    answers?: BotQuestionAnswer[];
+};
+
+/**
+ * Answers questions a bot asked from their card, or skips them, returning
+ * the questions as they now stand.
+ */
+export default async function decideBotQuestion({ question_id, answers }: Params) {
+    return await fetchApi<{ question_id: number; answers?: BotQuestionAnswer[] }, APIResponseObject<BotQuestionView>>(
+        `/api/admin/bot-questions/${answers ? "answer" : "skip"}-question`,
+        { method: "POST", body: answers ? { question_id, answers } : { question_id } },
+    );
+}

src/pages/admin/bots/[bot_id]/(hooks)/use-bot-question.ts

@@ -0,0 +1,65 @@
+import fetchApi from "@moduletrace/twui/utils/fetch/fetchApi";
+import type { APIResponseObject } from "@moduletrace/bunext/types";
+import { useCallback, useEffect, useState } from "react";
+import type { BotQuestionView } from "@/src/types";
+
+type Params = {
+    question_id: number;
+};
+
+/**
+ * Questions already read, by id, so a thread naming them twice asks once.
+ * An answer replaces their entry.
+ */
+const loaded = new Map<number, Promise<BotQuestionView | null>>();
+
+function loadQuestion({ question_id }: Params) {
+    const cached = loaded.get(question_id);
+
+    if (cached) return cached;
+
+    const pending = fetchApi<{}, APIResponseObject<BotQuestionView>>(
+        `/api/admin/bot-questions/get-question?question_id=${question_id}`,
+        { method: "GET" },
+    )
+        .then((res) => (res?.success && res.singleRes ? res.singleRes : null))
+        .catch(() => null);
+
+    loaded.set(question_id, pending);
+
+    return pending;
+}
+
+/**
+ * Questions a bot asked (`[question:ID]`), for their chip and card: read
+ * when the chip renders, so it shows whether they're still waiting. Only
+ * the user they were asked of can read them; anyone else gets null.
+ */
+export default function useBotQuestion({ question_id }: Params) {
+    const [view, setViewState] = useState<BotQuestionView | null>(null);
+    const [loading, setLoading] = useState(true);
+
+    useEffect(() => {
+        let live = true;
+
+        loadQuestion({ question_id }).then((result) => {
+            if (!live) return;
+            setViewState(result);
+            setLoading(false);
+        });
+
+        return () => {
+            live = false;
+        };
+    }, [question_id]);
+
+    const setView = useCallback(
+        (next: BotQuestionView) => {
+            loaded.set(question_id, Promise.resolve(next));
+            setViewState(next);
+        },
+        [question_id],
+    );
+
+    return { view, loading, setView };
+}

src/pages/admin/bots/[bot_id]/(partials)/bot-question-card.render.test.tsx

@@ -0,0 +1,57 @@
+import { describe, expect, test } from "bun:test";
+import { renderToString } from "react-dom/server";
+import type { BotQuestionView } from "@/src/types";
+import BotQuestionCard from "./bot-question-card";
+
+const deploy: BotQuestionView = {
+    id: 4,
+    title: "Before I deploy",
+    questions: [
+        { question: "Which environment?", kind: "single", options: ["Staging (suggested)", "Production"], allow_other: true },
+        { question: "Which checks should run first?", kind: "multiple", options: ["Lint", "Tests"], allow_other: false },
+    ],
+    answers: null,
+    status: "pending",
+    bot_id: 6,
+    bot_name: "Ada",
+};
+
+function render({ view }: { view: BotQuestionView }) {
+    return renderToString(<BotQuestionCard view={view} onDecided={() => {}} onDone={() => {}} />);
+}
+
+describe("BotQuestionCard", () => {
+    test("asks each question with radios for one pick and checkboxes for several", () => {
+        const html = render({ view: deploy });
+
+        expect(html).toContain("Which environment?");
+        expect(html).toContain(`type="radio"`);
+        expect(html).toContain("Staging (suggested)");
+        expect(html).toContain(">Other<");
+        expect(html).toContain("twui-checkbox");
+        expect(html).toContain("Pick any");
+        expect(html).toContain(">Send answers<");
+    });
+
+    test("once answered, shows what was picked and offers no inputs", () => {
+        const html = render({
+            view: {
+                ...deploy,
+                status: "answered",
+                answers: [
+                    { choices: [], other: "QA box" },
+                    { choices: [0, 1], other: "" },
+                ],
+            },
+        });
+
+        expect(html).not.toContain(`type="radio"`);
+        expect(html).not.toContain(">Send answers<");
+        expect(html).toContain("Other: QA box");
+        expect(html).toContain("Lint; Tests");
+    });
+
+    test("once skipped, says so", () => {
+        expect(render({ view: { ...deploy, status: "skipped" } })).toContain("Nothing was answered");
+    });
+});

src/pages/admin/bots/[bot_id]/(partials)/bot-question-card.tsx

@@ -0,0 +1,137 @@
+import { useContext, useState } from "react";
+import Button from "@moduletrace/twui/layout/Button";
+import Row from "@moduletrace/twui/layout/Row";
+import Span from "@moduletrace/twui/layout/Span";
+import Stack from "@moduletrace/twui/layout/Stack";
+import { AppContext } from "@/src/pages/__root";
+import type { BotQuestionView } from "@/src/types";
+import botQuestionAnswersText from "@/src/utils/bot-question-answers-text";
+import checkBotQuestionAnswers from "@/src/utils/check-bot-question-answers";
+import decideBotQuestion from "../(functions)/decide-bot-question";
+import sendBotMessage from "../(functions)/send-bot-message";
+import botQuestionDraftAnswer, { type BotQuestionDraft } from "../(utils)/bot-question-draft-answer";
+import BotQuestionField from "./bot-question-field";
+
+type Props = {
+    view: BotQuestionView;
+    onDecided: (view: BotQuestionView) => void;
+    onDone: () => void;
+};
+
+/**
+ * The card a user answers a bot's questions in: each question with its
+ * options (radios for one pick, checkboxes for several, "Other" to type
+ * their own). Sending or skipping tells the bot in chat, as the user's
+ * message; once decided it shows what they answered.
+ */
+export default function BotQuestionCard({ view, onDecided, onDone }: Props) {
+    const { pageProps } = useContext(AppContext);
+    const [drafts, setDrafts] = useState<BotQuestionDraft[]>(() =>
+        view.questions.map(() => ({ choices: [], other_on: false, other: "" })),
+    );
+    const [busy, setBusy] = useState<"answer" | "skip">();
+    const [error, setError] = useState<string>();
+
+    const open = view.status == "pending";
+
+    const setDraft = ({ index, draft }: { index: number; draft: BotQuestionDraft }) => {
+        setError(undefined);
+        setDrafts((current) => current.map((item, i) => (i == index ? draft : item)));
+    };
+
+    const decide = async (decision: "answer" | "skip") => {
+        const answers = drafts.map((draft) => botQuestionDraftAnswer({ draft }));
+
+        if (decision == "answer") {
+            try {
+                checkBotQuestionAnswers({ questions: view.questions, answers });
+            } catch (e: unknown) {
+                setError(e instanceof Error ? e.message : `Answer every question.`);
+                return;
+            }
+        }
+
+        const question =
+            decision == "answer"
+                ? `Send your answers to ${view.bot_name}?`
+                : `Skip these questions? ${view.bot_name} is told you didn't answer them.`;
+
+        if (!window.confirm(question)) return;
+
+        setBusy(decision);
+        setError(undefined);
+
+        const res = await decideBotQuestion({
+            question_id: view.id,
+            answers: decision == "answer" ? answers : undefined,
+        }).catch(() => null);
+
+        if (!res?.success || !res.singleRes) {
+            setBusy(undefined);
+            setError(res?.msg || `Couldn't ${decision == "answer" ? "send your answers" : "skip them"}.`);
+            return;
+        }
+
+        onDecided(res.singleRes);
+
+        await sendBotMessage({
+            bot_id: Number(pageProps?.bot?.id) || 0,
+            workspace_id: pageProps?.workspace?.id || null,
+            text: botQuestionAnswersText({ view: res.singleRes }),
+            media_ids: [],
+        }).catch(() => null);
+
+        setBusy(undefined);
+        onDone();
+    };
+
+    return (
+        <Stack className="w-full gap-0! items-stretch">
+            {view.questions.map((item, index) => (
+                <BotQuestionField
+                    key={index}
+                    question_id={view.id}
+                    index={index}
+                    item={item}
+                    draft={drafts[index]!}
+                    answer={view.answers?.[index] || null}
+                    open={open}
+                    onChange={(draft) => setDraft({ index, draft })}
+                />
+            ))}
+
+            {view.status == "skipped" ? (
+                <Span className="mt-4 text-[13px] leading-5 text-ink">Skipped. Nothing was answered.</Span>
+            ) : null}
+
+            {error ? <Span className="mt-3 text-[13px] leading-5 text-ink">{error}</Span> : null}
+
+            {open ? (
+                <Row className="mt-5 w-full gap-2! justify-end">
+                    <Button
+                        type="button"
+                        variant="outlined"
+                        color="gray"
+                        size="small"
+                        title="Skip: the bot is told you didn't answer"
+                        loading={busy == "skip"}
+                        disabled={Boolean(busy)}
+                        onClick={() => decide("skip")}
+                    >
+                        Skip
+                    </Button>
+                    <Button
+                        type="button"
+                        size="small"
+                        title="Send your answers"
+                        loading={busy == "answer"}
+                        disabled={Boolean(busy)}
+                        onClick={() => decide("answer")}
+                    >
+                        Send answers
+                    </Button>
+                </Row>
+            ) : null}
+        </Stack>
+    );
+}

src/pages/admin/bots/[bot_id]/(partials)/bot-question-field.tsx

@@ -0,0 +1,112 @@
+import Input from "@moduletrace/twui/form/Input";
+import Radios from "@moduletrace/twui/form/Radios";
+import Span from "@moduletrace/twui/layout/Span";
+import Stack from "@moduletrace/twui/layout/Stack";
+import { AppData } from "@/src/data/app-data";
+import type { BotQuestionAnswer, BotQuestionItem } from "@/src/types";
+import type { BotQuestionDraft } from "../(utils)/bot-question-draft-answer";
+import BotQuestionOption from "./bot-question-option";
+import MessageDetailsHeading from "./message-details-heading";
+
+type Props = {
+    question_id: number;
+    index: number;
+    item: BotQuestionItem;
+    draft: BotQuestionDraft;
+    /**
+     * What the user answered, once they did.
+     */
+    answer: BotQuestionAnswer | null;
+    /**
+     * Whether it still takes answers.
+     */
+    open: boolean;
+    onChange: (draft: BotQuestionDraft) => void;
+};
+
+/**
+ * Value of the "Other" radio, beside the options' indexes.
+ */
+const OtherValue = "other";
+
+/**
+ * One of a bot's questions in its card: the question, then its options as
+ * radios (one pick) or checkboxes (several), with "Other" and a field to
+ * type into when the bot allows it. Once answered, what the user picked.
+ */
+export default function BotQuestionField({ question_id, index, item, draft, answer, open, onChange }: Props) {
+    const single = item.kind == "single";
+    const picked = answer
+        ? [...answer.choices.map((choice) => item.options[choice]), answer.other ? `Other: ${answer.other}` : ""].filter(Boolean)
+        : [];
+
+    return (
+        <Stack className="w-full gap-0! items-stretch">
+            <MessageDetailsHeading>{`${index + 1}. ${single ? "Pick one" : "Pick any"}`}</MessageDetailsHeading>
+            <Span className="whitespace-pre-wrap text-[13px] leading-5 font-bold text-ink break-words">{item.question}</Span>
+
+            {open ? (
+                <Stack className="mt-2 w-full gap-2! items-stretch">
+                    {single ? (
+                        <Radios
+                            name={`question-${question_id}-${index}`}
+                            values={[
+                                ...item.options.map((option, choice) => ({ value: String(choice), title: option })),
+                                ...(item.allow_other ? [{ value: OtherValue, title: "Other" }] : []),
+                            ]}
+                            wrapperProps={{ className: "w-full flex-col items-start gap-2!" }}
+                            labelProps={{ className: "text-[13px] leading-5 text-ink break-words cursor-pointer" }}
+                            changeHandler={(value) =>
+                                onChange(
+                                    value == OtherValue
+                                        ? { ...draft, choices: [], other_on: true }
+                                        : { ...draft, choices: [Number(value)], other_on: false },
+                                )
+                            }
+                        />
+                    ) : (
+                        <Stack className="w-full gap-2! items-stretch">
+                            {item.options.map((option, choice) => (
+                                <BotQuestionOption
+                                    key={choice}
+                                    label={option}
+                                    checked={draft.choices.includes(choice)}
+                                    onChange={(checked) =>
+                                        onChange({
+                                            ...draft,
+                                            choices: checked
+                                                ? [...new Set([...draft.choices, choice])]
+                                                : draft.choices.filter((c) => c != choice),
+                                        })
+                                    }
+                                />
+                            ))}
+                            {item.allow_other ? (
+                                <BotQuestionOption
+                                    label="Other"
+                                    checked={draft.other_on}
+                                    onChange={(checked) => onChange({ ...draft, other_on: checked })}
+                                />
+                            ) : null}
+                        </Stack>
+                    )}
+
+                    {draft.other_on ? (
+                        <Input
+                            id={`question-${question_id}-${index}-other`}
+                            title="Your answer"
+                            placeholder="Your own answer"
+                            maxLength={AppData.BotQuestionOtherMaxChars}
+                            value={draft.other}
+                            onChange={(e) => onChange({ ...draft, other: e.target.value })}
+                        />
+                    ) : null}
+                </Stack>
+            ) : answer ? (
+                <Span className="mt-1 whitespace-pre-wrap text-[13px] leading-5 text-ink-secondary break-words">
+                    {picked.join("; ")}
+                </Span>
+            ) : null}
+        </Stack>
+    );
+}

src/pages/admin/bots/[bot_id]/(partials)/bot-question-option.tsx

@@ -0,0 +1,26 @@
+import Checkbox from "@moduletrace/twui/form/Checkbox";
+
+type Props = {
+    label: string;
+    checked: boolean;
+    onChange: (checked: boolean) => void;
+};
+
+/**
+ * One option of a multiple-choice question in a bot's question card.
+ */
+export default function BotQuestionOption({ label, checked, onChange }: Props) {
+    return (
+        <Checkbox
+            title={label}
+            label={label}
+            size={18}
+            checked={checked}
+            changeHandler={(value) => {
+                if (value != checked) onChange(value);
+            }}
+            wrapperClassName="flex-nowrap! md:flex-nowrap items-start! cursor-pointer"
+            labelProps={{ className: "whitespace-normal md:whitespace-normal text-[13px] leading-5 text-ink break-words" }}
+        />
+    );
+}

src/pages/admin/bots/[bot_id]/(partials)/bot-question-ref-chip.tsx

@@ -0,0 +1,84 @@
+import { useState } from "react";
+import { twMerge } from "tailwind-merge";
+import Modal from "@moduletrace/twui/elements/Modal";
+import Button from "@moduletrace/twui/layout/Button";
+import H2 from "@moduletrace/twui/layout/H2";
+import Span from "@moduletrace/twui/layout/Span";
+import Stack from "@moduletrace/twui/layout/Stack";
+import { MessageCircleQuestion } from "lucide-react";
+import useBotQuestion from "../(hooks)/use-bot-question";
+import BotQuestionCard from "./bot-question-card";
+
+type Props = {
+    question_id: number;
+};
+
+const StatusLabels = {
+    pending: "waiting for you",
+    answered: "answered",
+    skipped: "skipped",
+} as const;
+
+/**
+ * Questions a bot asked before acting (`botQuestionRef`): a chip naming
+ * them and where they stand, which opens the card the user answers them
+ * in. Anyone they weren't asked of sees their number only.
+ */
+export default function BotQuestionRefChip({ question_id }: Props) {
+    const { view, loading, setView } = useBotQuestion({ question_id });
+    const [open, setOpen] = useState(false);
+
+    if (!view) {
+        return (
+            <Span className="font-bold">
+                {loading ? `questions ${question_id}` : `questions ${question_id} (not available)`}
+            </Span>
+        );
+    }
+
+    const count = view.questions.length;
+    const name = view.title || (count == 1 ? "1 question" : `${count} questions`);
+    const status = StatusLabels[view.status];
+    const pending = view.status == "pending";
+
+    return (
+        <Modal
+            target={
+                <Button
+                    type="button"
+                    variant={pending ? undefined : "outlined"}
+                    color={pending ? undefined : "gray"}
+                    size="smaller"
+                    title={pending ? `Answer ${name}` : `${name}: ${status}`}
+                    className={twMerge(
+                        "inline-flex h-6 max-w-full gap-1.5! flex-nowrap align-middle px-2! text-[13px] font-bold whitespace-nowrap",
+                        !pending && "text-ink",
+                        "[&_.twui-button-content-wrapper]:min-w-0",
+                    )}
+                >
+                    <MessageCircleQuestion size={14} aria-hidden className="shrink-0" />
+                    <Span className="min-w-0 truncate">{`${name} · ${status}`}</Span>
+                </Button>
+            }
+            targetWrapperProps={{ className: "inline-flex max-w-full align-middle" }}
+            open={open}
+            setOpen={setOpen}
+            className="max-w-xl bg-paper p-6"
+        >
+            <Stack className="w-full gap-1! items-stretch">
+                <H2 className="text-lg! leading-6! tracking-normal! font-bold text-ink">
+                    {view.title || `${view.bot_name} asks before going on`}
+                </H2>
+                <Span className="text-[13px] leading-[18px] text-ink-secondary">
+                    {pending
+                        ? `${view.bot_name} wants to be sure what you want before it acts. Your answers go to it as your message.`
+                        : `What ${view.bot_name} asked before going on.`}
+                </Span>
+            </Stack>
+
+            <Stack className="mt-2 max-h-[65vh] w-full gap-0! items-stretch overflow-y-auto">
+                <BotQuestionCard view={view} onDecided={setView} onDone={() => setOpen(false)} />
+            </Stack>
+        </Modal>
+    );
+}

src/pages/admin/bots/[bot_id]/(partials)/conversation-header.tsx

@@ -8,7 +8,7 @@ import Dropdown from "@moduletrace/twui/elements/Dropdown";
 import useStatus from "@moduletrace/twui/hooks/useStatus";
 import { CpuAi, EllipsisVertical, Monitor } from "lucide-react";
 import type { BUN_SQLITE_COBBLE_WORKSPACES } from "@/db/types/db";
-import type { BotWithLastMessage } from "@/src/types";
+import type { BotTextModel, BotWithLastMessage } from "@/src/types";
 import { AppContext } from "@/src/pages/__root";
 import WorkspaceAvatar from "@/src/components/general/workspace-avatar";
 import RailDrawerButton from "@/src/layouts/bots/(partials)/rail-drawer-button";
@@ -27,6 +27,12 @@ type Props = {
      */
     workspace?: BUN_SQLITE_COBBLE_WORKSPACES | null;
     has_other_unread?: boolean;
+    /**
+     * The text model the bot runs on, kept by the conversation (which
+     * shows a notice while there's none).
+     */
+    model?: BotTextModel | null;
+    onModelChange: (model: BotTextModel | null) => void;
 };
 
 /**
@@ -40,10 +46,11 @@ export default function ConversationHeader({
     bot,
     workspace,
     has_other_unread,
+    model,
+    onModelChange,
 }: Props) {
     const { computers } = useContext(BotComputersContext);
     const { pageProps } = useContext(AppContext);
-    const [model, setModel] = useState(pageProps?.bot_text_model);
     /**
      * The menu's toggle shows its change at once; a push (here or from
      * another tab) brings the live bot's.
@@ -143,7 +150,7 @@ export default function ConversationHeader({
                                 (h) => h.harness == "text",
                             )?.current;
 
-                            setModel(
+                            onModelChange(
                                 current
                                     ? {
                                           name: current.name,

src/pages/admin/bots/[bot_id]/(partials)/file-ref-chip.tsx

@@ -1,10 +1,10 @@
 import { useContext, useEffect, useState } from "react";
-import Link from "@moduletrace/twui/layout/Link";
 import Span from "@moduletrace/twui/layout/Span";
 import fetchApi from "@moduletrace/twui/utils/fetch/fetchApi";
 import type { APIResponseObject } from "@moduletrace/bunext/types";
 import { AppContext } from "@/src/pages/__root";
 import type { BotFileScopesPayload, MediaType, PublicBotFile } from "@/src/types";
+import FilePreviewLink from "@/src/components/general/file-preview-link";
 import AttachmentIcon from "./attachment-icon";
 
 type Props = {
@@ -50,8 +50,8 @@ function fetchFile({
 
 /**
  * A file a bot named in a message (`fileRef`): the name it is saved under,
- * linked to its bytes at `/media/<id>` (private: only someone who reaches
- * the file's folder can load it). A folder the bot named is a `folderRef`
+ * opening it in the file preview (its bytes at `/media/<id>`, private: only
+ * someone who reaches the file's folder can load them). A folder the bot named is a `folderRef`
  * instead, and its chip opens the files browser. The conversation's files come with the page, so most
  * chips need no request; one that isn't among them (older than the page's
  * first page) is fetched by id. A file the user doesn't reach, or one
@@ -85,15 +85,15 @@ export default function FileRefChip({ file_id }: Props) {
     }
 
     return (
-        <Link
-            href={file.url}
-            target="_blank"
-            rel="noopener noreferrer"
-            title={`Open ${file.name}`}
+        <FilePreviewLink
+            name={file.name}
+            url={file.url}
+            media_type={file.media_type}
+            size={file.size}
             className="inline-flex h-6 max-w-full gap-1.5 items-center px-1.5 align-middle rounded-default-xs border-0 bg-sunken text-[13px] font-bold leading-4 text-ink hover:opacity-80"
         >
             <AttachmentIcon media_type={file.media_type as MediaType} />
             <Span className="truncate">{file.name}</Span>
-        </Link>
+        </FilePreviewLink>
     );
 }

src/pages/admin/bots/[bot_id]/(partials)/file-row.tsx

@@ -1,4 +1,3 @@
-import Link from "@moduletrace/twui/layout/Link";
 import Row from "@moduletrace/twui/layout/Row";
 import Span from "@moduletrace/twui/layout/Span";
 import Stack from "@moduletrace/twui/layout/Stack";
@@ -6,6 +5,7 @@ import Button from "@moduletrace/twui/layout/Button";
 import { Trash2 } from "lucide-react";
 import type { MediaType, PublicBotFile } from "@/src/types";
 import relativeTime from "@/src/utils/relative-time";
+import FilePreviewLink from "@/src/components/general/file-preview-link";
 import AttachmentIcon from "./attachment-icon";
 
 type Props = {
@@ -29,15 +29,15 @@ export default function FileRow({ file, can_manage, busy, onDelete }: Props) {
                 <AttachmentIcon media_type={file.media_type as MediaType} size={16} />
             </Row>
             <Stack className="min-w-0 flex-1 gap-0.5!">
-                <Link
-                    href={file.url}
-                    target="_blank"
-                    rel="noopener noreferrer"
-                    title={`Open ${file.name}`}
+                <FilePreviewLink
+                    name={file.path || file.name}
+                    url={file.url}
+                    media_type={file.media_type}
+                    size={file.size}
                     className="text-[13px] font-bold leading-5 text-ink break-words hover:opacity-80"
                 >
                     {file.path || file.name}
-                </Link>
+                </FilePreviewLink>
                 <Span className="text-[12px] leading-4 text-ink-secondary">
                     {[
                         file.scope == "workspace" ? "Workspace" : "Bot files",

src/pages/admin/bots/[bot_id]/(partials)/markdown-link.tsx

@@ -13,8 +13,10 @@ import {
     WorkspaceRefHrefPrefix,
 } from "@/src/utils/link-computer-refs";
 import { parseFolderRefHref } from "@/src/utils/folder-ref";
+import { botQuestionRefId } from "@/src/utils/bot-question-ref";
 import { graphicRefId } from "@/src/utils/graphic-ref";
 import { chatroomRefId } from "@/src/utils/chatroom-ref";
+import BotQuestionRefChip from "./bot-question-ref-chip";
 import BotRefChip from "./bot-ref-chip";
 import ChatroomRefChip from "./chatroom-ref-chip";
 import ComputerRefChip from "./computer-ref-chip";
@@ -32,11 +34,12 @@ import WorkspaceRefChip from "./workspace-ref-chip";
  * A link in a bot message. A computer the bot named (`linkComputerRefs`)
  * becomes its switch button, a take-over request a button that opens the
  * computer, a bot it named a link to that bot's conversation, a workspace
- * a link to that workspace, a file it saved a chip that downloads it, a
+ * a link to that workspace, a file it saved a chip that previews it, a
  * folder it named a chip that opens it in the files browser, an MCP server,
  * tool, skill or hook it proposed a chip that opens the confirm card, a
  * secret it showed a masked chip, a secret it asked for a chip that opens
- * the card it's typed into, a graphic it made the graphic itself, a
+ * the card it's typed into, questions it asked a chip that opens the card
+ * they're answered in, a graphic it made the graphic itself, a
  * chatroom a chip that opens it;
  * anything else opens in a new tab.
  */
@@ -104,6 +107,10 @@ export default function MarkdownLink({ href, children }: ComponentProps<"a">) {
         if (request_id) return <SecretRequestRefChip request_id={request_id} />;
     }
 
+    const question_id = botQuestionRefId({ href });
+
+    if (question_id) return <BotQuestionRefChip question_id={question_id} />;
+
     const chatroom_id = chatroomRefId({ href });
 
     if (chatroom_id) return <ChatroomRefChip chatroom_id={chatroom_id} />;

src/pages/admin/bots/[bot_id]/(partials)/message-attachment.tsx

@@ -1,12 +1,12 @@
 import Img from "@moduletrace/twui/layout/Img";
-import Link from "@moduletrace/twui/layout/Link";
 import Span from "@moduletrace/twui/layout/Span";
 import type { BotMessageAttachment } from "@/src/types";
+import FilePreviewLink from "@/src/components/general/file-preview-link";
 import AttachmentIcon from "./attachment-icon";
 
 /**
  * One file on a message: an image as a thumbnail, anything else as a
- * named chip. Both open the file in a new tab.
+ * named chip. Both open the file in the preview.
  */
 export default function MessageAttachment({
     name,
@@ -16,25 +16,26 @@ export default function MessageAttachment({
 }: BotMessageAttachment) {
     if (media_type == "image") {
         return (
-            <Link href={url} target="_blank" title={name} className="block">
+            <FilePreviewLink name={name} url={url} media_type={media_type} title={name} className="block">
                 <Img
                     src={thumbnail_url || url}
                     alt={name}
                     className="max-h-48 max-w-64 rounded-default-lg border border-solid border-hairline object-cover"
                 />
-            </Link>
+            </FilePreviewLink>
         );
     }
 
     return (
-        <Link
-            href={url}
-            target="_blank"
+        <FilePreviewLink
+            name={name}
+            url={url}
+            media_type={media_type}
             title={name}
             className="flex max-w-64 items-center gap-2 rounded-default-lg border border-solid border-hairline bg-surface px-3 py-2 text-[13px] leading-[18px] text-ink no-underline hover:border-hairline-strong"
         >
             <AttachmentIcon media_type={media_type} />
             <Span className="truncate">{name}</Span>
-        </Link>
+        </FilePreviewLink>
     );
 }

src/pages/admin/bots/[bot_id]/(partials)/message-thread.tsx

@@ -1,4 +1,5 @@
-import { useMemo, type RefObject } from "react";
+import { useMemo, type ReactNode, type RefObject } from "react";
+import { twMerge } from "tailwind-merge";
 import isAwaitingReply from "../(utils)/is-awaiting-reply";
 import Stack from "@moduletrace/twui/layout/Stack";
 import type {
@@ -37,6 +38,11 @@ type Props = {
      * The conversation went on in another session: no reply is due here.
      */
     moved_on?: boolean;
+    /**
+     * Shown after the messages, or in the middle of an empty thread, e.g.
+     * that the bot has no model to answer with.
+     */
+    notice?: ReactNode;
     /**
      * Quotes text selected in a message in the composer.
      */
@@ -78,6 +84,7 @@ export default function MessageThread({
     receiving,
     has_task,
     moved_on,
+    notice,
     onQuote,
     older,
 }: Props) {
@@ -97,7 +104,10 @@ export default function MessageThread({
                     role="log"
                     aria-live="polite"
                     aria-label={`Conversation with ${bot.name}`}
-                    className="w-full max-w-container mx-auto gap-4! items-stretch px-3 md:px-6 pt-6 pb-6"
+                    className={twMerge(
+                        "w-full max-w-container mx-auto gap-4! items-stretch px-3 md:px-6 pt-6 pb-6",
+                        notice && !messages.length && "grow justify-center",
+                    )}
                 >
                     {older?.has_more ? (
                         <OlderMessagesLoader
@@ -121,6 +131,7 @@ export default function MessageThread({
                             group={group}
                         />
                     ))}
+                    {notice}
                     <BotThinkingRow
                         bot={bot}
                         progress={progress}

src/pages/admin/bots/[bot_id]/(partials)/no-model-notice.tsx

@@ -0,0 +1,66 @@
+import { useContext } from "react";
+import Button from "@moduletrace/twui/layout/Button";
+import Row from "@moduletrace/twui/layout/Row";
+import Span from "@moduletrace/twui/layout/Span";
+import Stack from "@moduletrace/twui/layout/Stack";
+import { ArrowRight, CpuAi } from "lucide-react";
+import { SettingsModelsPath, SettingsSetupPath } from "@/src/dict/settings-pages-dict";
+import { AppContext } from "@/src/pages/__root";
+import IconTile from "@/src/components/general/icon-tile";
+import isPassThroughUser from "@/src/utils/rbac/is-pass-through-user";
+
+type Props = {
+    bot_name: string;
+};
+
+/**
+ * Shown in the conversation while the bot has no text model to run on
+ * (nothing would answer a message). A super admin is sent to connect a
+ * provider, or to the guided setup; anyone else is told who can.
+ */
+export default function NoModelNotice({ bot_name }: Props) {
+    const { pageProps } = useContext(AppContext);
+    const can_set_up = isPassThroughUser({ user_types: pageProps?.user_types });
+
+    return (
+        <Stack
+            role="status"
+            className="w-full max-w-[440px] mx-auto gap-3! items-start rounded-default border border-solid border-hairline bg-surface px-5 py-4"
+        >
+            <Row className="gap-3! flex-nowrap items-center">
+                <IconTile Icon={CpuAi} />
+                <Span className="text-sm font-bold leading-5 text-ink">
+                    {can_set_up ? "Connect a model provider" : "No model set up yet"}
+                </Span>
+            </Row>
+            <Span className="text-[13px] leading-5 text-ink-secondary">
+                {can_set_up
+                    ? `${bot_name} has no model to think with, so nothing would answer yet. Add a provider key (OpenRouter has free models) and pick what your bots run on.`
+                    : `${bot_name} has no model to think with, so nothing would answer yet. The super admin connects one in Settings.`}
+            </Span>
+            {can_set_up ? (
+                <Row className="w-full gap-2! justify-end">
+                    <Button
+                        title="Open the guided setup"
+                        type="button"
+                        variant="outlined"
+                        color="gray"
+                        size="small"
+                        href={SettingsSetupPath}
+                    >
+                        Guided setup
+                    </Button>
+                    <Button
+                        title="Connect a provider"
+                        type="button"
+                        size="small"
+                        href={SettingsModelsPath}
+                        afterIcon={<ArrowRight size={14} aria-hidden />}
+                    >
+                        Connect a provider
+                    </Button>
+                </Row>
+            ) : null}
+        </Stack>
+    );
+}

src/pages/admin/bots/[bot_id]/(sections)/conversation.tsx

@@ -39,6 +39,7 @@ import useConversationHistory from "../(hooks)/use-conversation-history";
 import mergeLoadedHistory from "../(utils)/merge-loaded-history";
 import LoadingLine from "@/src/components/general/loading-line";
 import SessionMovedBar from "../(partials)/session-moved-bar";
+import NoModelNotice from "../(partials)/no-model-notice";
 import syncSessionQuery from "../(utils)/sync-session-query";
 import announceShownSession from "@/src/functions/frontend/announce-shown-session";
 
@@ -85,6 +86,11 @@ export default function Conversation() {
      */
     const [moved_to_session_id, setMovedToSessionId] = useState<number | null>(null);
     const [has_other_unread, setHasOtherUnread] = useState(false);
+    /**
+     * The text model the bot runs on here; none shows a notice in the
+     * thread. A save in the models modal updates it.
+     */
+    const [text_model, setTextModel] = useState(pageProps?.bot_text_model || null);
     const [reply_to, setReplyTo] = useState<BotMessageWithAttachments | null>(
         null,
     );
@@ -391,6 +397,8 @@ export default function Conversation() {
                                     bot={live_bot}
                                     workspace={workspace}
                                     has_other_unread={has_other_unread}
+                                    model={text_model}
+                                    onModelChange={setTextModel}
                                 />
                                 {history.loading ? (
                                     <LoadingLine label="Loading the conversation" />
@@ -409,6 +417,11 @@ export default function Conversation() {
                                     receiving={pending_messages.length > 0}
                                     has_task={Boolean(progress.task_id)}
                                     moved_on={Boolean(moved_to_session_id)}
+                                    notice={
+                                        !text_model && !history.loading ? (
+                                            <NoModelNotice bot_name={live_bot.name || "This bot"} />
+                                        ) : null
+                                    }
                                     older={older}
                                     onQuote={({ text }) =>
                                         composer.current?.insertQuote({ text })

src/pages/admin/bots/[bot_id]/(utils)/bot-question-draft-answer.ts

@@ -0,0 +1,22 @@
+import type { BotQuestionAnswer } from "@/src/types";
+
+/**
+ * One question's answer while the user fills in the card: the options
+ * picked, whether "Other" is picked, and what's typed into it.
+ */
+export type BotQuestionDraft = {
+    choices: number[];
+    other_on: boolean;
+    other: string;
+};
+
+type Params = {
+    draft: BotQuestionDraft;
+};
+
+/**
+ * A question's draft as the answer sent: "Other" counts only while picked.
+ */
+export default function botQuestionDraftAnswer({ draft }: Params): BotQuestionAnswer {
+    return { choices: draft.choices, other: draft.other_on ? draft.other.trim() : "" };
+}

src/pages/admin/files/(partials)/storage-entry-row.tsx

@@ -8,6 +8,7 @@ import type { MediaType, StorageEntry } from "@/src/types";
 import formatBytes from "@/src/utils/format-bytes";
 import relativeTime from "@/src/utils/relative-time";
 import AttachmentIcon from "@/src/pages/admin/bots/[bot_id]/(partials)/attachment-icon";
+import FilePreviewLink from "@/src/components/general/file-preview-link";
 
 type Props = {
     entry: StorageEntry;
@@ -16,8 +17,8 @@ type Props = {
 };
 
 /**
- * One entry in the open folder: a folder opens in place, a file opens in a
- * new tab (its own media record when it is one of the bot's files, else
+ * One entry in the open folder: a folder opens in place, a file opens in the
+ * file preview (its own media record when it is one of the bot's files, else
  * the browser's streaming route).
  */
 export default function StorageEntryRow({ entry, selected, onOpenFolder }: Props) {
@@ -51,15 +52,15 @@ export default function StorageEntryRow({ entry, selected, onOpenFolder }: Props
                         {entry.name}
                     </Link>
                 ) : (
-                    <Link
-                        href={entry.url}
-                        target="_blank"
-                        rel="noopener noreferrer"
-                        title={`Open ${entry.name}`}
+                    <FilePreviewLink
+                        name={entry.name}
+                        url={entry.url || ""}
+                        media_type={entry.media_type}
+                        size={entry.size}
                         className="text-[13px] font-bold leading-5 text-ink break-words hover:opacity-80"
                     >
                         {entry.name}
-                    </Link>
+                    </FilePreviewLink>
                 )}
                 <Span className="text-[12px] leading-4 text-ink-secondary">
                     {[

src/pages/admin/settings/(partials)/settings-list-row.tsx

@@ -32,7 +32,7 @@ type Props = {
  */
 export default function SettingsListRow({ avatar, title, href, badge, title_icon, subtitle, children }: Props) {
     const title_content = (
-        <Span className="text-sm font-bold leading-5 text-ink truncate w-full">
+        <Span className="block text-sm font-bold leading-5 text-ink truncate w-full">
             {title}
             {title_icon ? <Span className="ml-1.5 inline-flex align-middle">{title_icon}</Span> : null}
             {badge ? <Span className="ml-2 text-[11px] font-bold leading-4 text-ink-secondary">{badge}</Span> : null}
@@ -47,7 +47,7 @@ export default function SettingsListRow({ avatar, title, href, badge, title_icon
                     <Link
                         href={href}
                         title={title}
-                        className="block min-w-0 border-0 leading-normal hover:opacity-100 hover:underline focus-visible:ring-2 focus-visible:ring-ink focus-visible:ring-offset-2 focus-visible:ring-offset-surface rounded-default-sm"
+                        className="block w-full min-w-0 border-0 leading-normal hover:opacity-100 hover:underline focus-visible:ring-2 focus-visible:ring-ink focus-visible:ring-offset-2 focus-visible:ring-offset-surface rounded-default-sm"
                     >
                         {title_content}
                     </Link>

src/pages/admin/settings/models/(hooks)/use-models-overview.ts

@@ -0,0 +1,45 @@
+import { useContext, useState } from "react";
+import { AppContext } from "@/src/pages/__root";
+import type { HarnessOverviewPayload } from "@/src/types";
+import postHarnessApi from "../(functions)/post-harness-api";
+import type changedHarnessSettings from "../(utils)/changed-harness-settings";
+
+/**
+ * The providers and harness settings a page edits (the Models settings
+ * and the setup), starting from the page's props and updated from the
+ * fresh data every save returns. `version` remounts the harness form when
+ * the data changes under it; `notice` is the last save's message, kept
+ * across that remount.
+ */
+export default function useModelsOverview() {
+    const { pageProps } = useContext(AppContext);
+    const [overview, setOverview] = useState(pageProps?.harness_overview);
+    const [version, setVersion] = useState(0);
+    const [notice, setNotice] = useState<string>();
+
+    const update = (next: HarnessOverviewPayload) => {
+        setOverview(next);
+        setNotice(undefined);
+        setVersion((prev) => prev + 1);
+    };
+
+    const saveSettings = async ({
+        settings,
+    }: {
+        settings: ReturnType<typeof changedHarnessSettings>;
+    }) => {
+        const res = await postHarnessApi({
+            path: "save-settings",
+            body: { settings },
+        });
+
+        if (res.success && res.singleRes) {
+            update(res.singleRes);
+            setNotice(res.msg || "Saved.");
+        }
+
+        return res;
+    };
+
+    return { overview, version, notice, update, saveSettings };
+}

src/pages/admin/settings/models/(partials)/harness-current-model.tsx

@@ -1,4 +1,5 @@
 import Span from "@moduletrace/twui/layout/Span";
+import { harnessFallbackTitle } from "@/src/dict/harness-dict";
 import type { HarnessOverview } from "@/src/types";
 
 type Props = {
@@ -9,8 +10,11 @@ type Props = {
  * What the harness runs on right now, as saved, in one line.
  */
 export default function HarnessCurrentModel({ harness }: Props) {
+    const falls_back_title = harnessFallbackTitle({ harness: harness.harness });
     const text = !harness.enabled
-        ? "Turned off."
+        ? falls_back_title
+            ? `Turned off: ${falls_back_title.toLowerCase()} does it.`
+            : "Turned off."
         : harness.current
           ? `Now using ${harness.current.name} on ${harness.current.provider_name}${
                 harness.current.source == "auto" ? ", picked automatically" : ""
@@ -21,7 +25,9 @@ export default function HarnessCurrentModel({ harness }: Props) {
             }`
           : harness.required
             ? "Nothing to run on yet: no provider has a usable key."
-            : !harness.automatic
+            : falls_back_title && !harness.model_id
+              ? `${falls_back_title} does it until a model is picked.`
+              : !harness.automatic
               ? "Not available until a model is picked."
               : "No free model can do this right now. Pick one to turn it on.";
 

src/pages/admin/settings/models/(partials)/harness-model-select.tsx

@@ -13,6 +13,7 @@ type Props = {
     model_id: number | null;
     provider_name?: string;
     automatic: boolean;
+    falls_back_title?: string;
     onChange: (model_id: number | null) => void;
 };
 
@@ -26,6 +27,7 @@ export default function HarnessModelSelect({
     model_id,
     provider_name,
     automatic,
+    falls_back_title,
     onChange,
 }: Props) {
     return (
@@ -35,7 +37,13 @@ export default function HarnessModelSelect({
             label="Model"
             showLabel
             placeholder="Search models"
-            options={harnessModelSelectOptions({ models, model_id, provider_name, automatic })}
+            options={harnessModelSelectOptions({
+                models,
+                model_id,
+                provider_name,
+                automatic,
+                falls_back_title,
+            })}
             defaultValues={[model_id ? String(model_id) : AutoModelValue]}
             changeHandler={(value) => {
                 const picked = Array.isArray(value) ? value[0] : value;

src/pages/admin/settings/models/(partials)/harness-setting-group.tsx

@@ -1,4 +1,5 @@
 import Checkbox from "@moduletrace/twui/form/Checkbox";
+import { harnessFallbackTitle } from "@/src/dict/harness-dict";
 import { HarnessParameterHarnesses } from "@/src/dict/harness-parameter-dict";
 import type { HarnessFormValue, HarnessOverview } from "@/src/types";
 import SettingsGroup from "../../(partials)/settings-group";
@@ -40,11 +41,14 @@ export default function HarnessSettingGroup({ harness, value, onChange }: Props)
             harness.harness as (typeof HarnessParameterHarnesses)[number],
         );
     const on_bot_page = harness.default !== undefined;
+    const falls_back_title = harnessFallbackTitle({ harness: harness.harness });
     const default_name = harness.default?.enabled === false
         ? "turned off"
         : harness.default?.current
           ? `${harness.default.current.name} on ${harness.default.current.provider_name}`
-          : "not available";
+          : falls_back_title
+            ? `same as ${falls_back_title.toLowerCase()}`
+            : "not available";
 
     return (
         <SettingsGroup title={harness.title} description={harness.description}>
@@ -74,6 +78,7 @@ export default function HarnessSettingGroup({ harness, value, onChange }: Props)
                     model_id={value.model_id}
                     provider_name={provider?.name}
                     automatic={harness.automatic}
+                    falls_back_title={falls_back_title}
                     onChange={(model_id) => onChange({ ...value, model_id, voice: undefined })}
                 />
             )}
@@ -90,6 +95,14 @@ export default function HarnessSettingGroup({ harness, value, onChange }: Props)
                     changeHandler={(fallback) => onChange({ ...value, fallback })}
                 />
             ) : null}
+            {!value.inherit && value.model_id && falls_back_title ? (
+                <Checkbox
+                    title={`Fall back to ${falls_back_title.toLowerCase()} if this model fails`}
+                    label={`Fall back to ${falls_back_title.toLowerCase()} if this model fails`}
+                    checked={value.fallback}
+                    changeHandler={(fallback) => onChange({ ...value, fallback })}
+                />
+            ) : null}
             {shows_params && params_model ? (
                 <HarnessParameterModal
                     id={id}

src/pages/admin/settings/models/(sections)/models-settings-section.tsx

@@ -1,30 +1,16 @@
-import { useContext, useState } from "react";
-import { AppContext } from "@/src/pages/__root";
 import HarnessSettingsForm from "../(partials)/harness-settings-form";
 import ProvidersGroup from "../(partials)/providers-group";
-import postHarnessApi from "../(functions)/post-harness-api";
+import useModelsOverview from "../(hooks)/use-models-overview";
 
 /**
  * Providers first (where models come from), then what each harness uses.
  * Both update from the fresh data every save returns.
  */
 export default function ModelsSettingsSection() {
-    const { pageProps } = useContext(AppContext);
-    const [overview, setOverview] = useState(pageProps?.harness_overview);
-    /**
-     * Remounts the harness form when the data changes under it.
-     */
-    const [version, setVersion] = useState(0);
-    const [notice, setNotice] = useState<string>();
+    const { overview, version, notice, update, saveSettings } = useModelsOverview();
 
     if (!overview) return null;
 
-    const update = (next: typeof overview) => {
-        setOverview(next);
-        setNotice(undefined);
-        setVersion((prev) => prev + 1);
-    };
-
     return (
         <>
             <ProvidersGroup providers={overview.providers} onChanged={update} />
@@ -32,19 +18,7 @@ export default function ModelsSettingsSection() {
                 key={version}
                 harnesses={overview.harnesses}
                 notice={notice}
-                save={async ({ settings }) => {
-                    const res = await postHarnessApi({
-                        path: "save-settings",
-                        body: { settings },
-                    });
-
-                    if (res.success && res.singleRes) {
-                        update(res.singleRes);
-                        setNotice(res.msg || "Saved.");
-                    }
-
-                    return res;
-                }}
+                save={saveSettings}
             />
         </>
     );

src/pages/admin/settings/models/(utils)/harness-model-select-options.ts

@@ -18,26 +18,35 @@ type Params = {
      * available".
      */
     automatic: boolean;
+    /**
+     * The harness that does the work while none is picked (image
+     * generation, for image editing): the empty choice names it.
+     */
+    falls_back_title?: string;
 };
 
 /**
  * The model picker's options: automatic (the best free model, on the
  * picked provider if there is one), then every model that can do the job
  * (free ones first, as the server sorts them). A harness without
- * automatic picks starts with "Not available" instead.
+ * automatic picks starts with "Not available" instead, or with the
+ * harness it falls back to.
  */
 export default function harnessModelSelectOptions({
     models,
     model_id,
     provider_name,
     automatic,
+    falls_back_title,
 }: Params): TWUISelectOptionObject[] {
     const has_free = models.some((model) => model.free);
 
     return [
         {
             value: AutoModelValue,
-            title: !automatic
+            title: falls_back_title
+                ? `Same as ${falls_back_title.toLowerCase()} (pick a model to use its own)`
+                : !automatic
                 ? "Not available (pick a model to turn it on)"
                 : provider_name
                 ? has_free

src/pages/admin/settings/setup/(data)/setup-next-links.ts

@@ -0,0 +1,41 @@
+import { Bot, Monitor, SlidersHorizontal, Users, Variable } from "lucide-react";
+import { AdminHomePath } from "@/src/dict/admin-sections-dict";
+import { SettingsComputersPath, SettingsDefaultPath } from "@/src/dict/settings-pages-dict";
+import type { SetupLink } from "../(partials)/setup-link-row";
+
+/**
+ * Where to go once the models are in: the rest is set up from the pages
+ * themselves.
+ */
+export const SetupNextLinks: SetupLink[] = [
+    {
+        title: "Meet the coordinator",
+        description: "Ask it to put a crew together, or just say hello.",
+        href: AdminHomePath,
+        Icon: Bot,
+    },
+    {
+        title: "Computers",
+        description: "The main computer starts by itself. Add more, or check it's running.",
+        href: SettingsComputersPath,
+        Icon: Monitor,
+    },
+    {
+        title: "Users",
+        description: "Add the people who'll work with your bots.",
+        href: "/admin/settings/users",
+        Icon: Users,
+    },
+    {
+        title: "Environment",
+        description: "Keys and settings your bots' tools need on their computers.",
+        href: "/admin/settings/environment",
+        Icon: Variable,
+    },
+    {
+        title: "General",
+        description: "The app's name and icon, run limits and how long things are kept.",
+        href: SettingsDefaultPath,
+        Icon: SlidersHorizontal,
+    },
+];

src/pages/admin/settings/setup/(data)/setup-steps.ts

@@ -0,0 +1,11 @@
+/**
+ * The setup's steps, in order. Every one can be skipped.
+ */
+export const SetupSteps = [
+    { key: "welcome", title: "Welcome" },
+    { key: "provider", title: "Provider" },
+    { key: "models", title: "Models" },
+    { key: "ready", title: "Ready" },
+] as const;
+
+export type SetupStepKey = (typeof SetupSteps)[number]["key"];

src/pages/admin/settings/setup/(partials)/setup-link-row.tsx

@@ -0,0 +1,24 @@
+import type { LucideIcon } from "lucide-react";
+import IconTile from "@/src/components/general/icon-tile";
+import SettingsListRow from "../../(partials)/settings-list-row";
+
+export type SetupLink = {
+    title: string;
+    description: string;
+    href: string;
+    Icon: LucideIcon;
+};
+
+/**
+ * One place to go on from the setup.
+ */
+export default function SetupLinkRow({ title, description, href, Icon }: SetupLink) {
+    return (
+        <SettingsListRow
+            avatar={<IconTile Icon={Icon} />}
+            title={title}
+            href={href}
+            subtitle={description}
+        />
+    );
+}

src/pages/admin/settings/setup/(partials)/setup-step-item.tsx

@@ -0,0 +1,42 @@
+import { twMerge } from "tailwind-merge";
+import Button from "@moduletrace/twui/layout/Button";
+import Span from "@moduletrace/twui/layout/Span";
+
+type Props = {
+    title: string;
+    number: number;
+    current: boolean;
+    done: boolean;
+    onSelect: () => void;
+};
+
+/**
+ * One step in the setup's trail: its number and name. Any step can be
+ * opened, in any order.
+ */
+export default function SetupStepItem({ title, number, current, done, onSelect }: Props) {
+    return (
+        <Button
+            title={`Step ${number}: ${title}`}
+            type="button"
+            variant="ghost"
+            color="text"
+            aria-current={current ? "step" : undefined}
+            className={twMerge(
+                "gap-2! px-2! py-1! rounded-default-sm text-ink-secondary dark:text-ink-secondary hover:text-ink hover:dark:text-ink hover:bg-sunken hover:dark:bg-sunken focus-visible:ring-2 focus-visible:ring-ink",
+                current && "text-ink dark:text-ink font-bold",
+            )}
+            onClick={onSelect}
+        >
+            <Span
+                className={twMerge(
+                    "size-5 shrink-0 flex items-center justify-center rounded-full border border-solid border-hairline-strong text-[11px] leading-none",
+                    (current || done) && "bg-ink text-on-ink border-ink",
+                )}
+            >
+                {number}
+            </Span>
+            <Span className="text-[13px] leading-5">{title}</Span>
+        </Button>
+    );
+}

src/pages/admin/settings/setup/(partials)/setup-step-nav.tsx

@@ -0,0 +1,72 @@
+import Button from "@moduletrace/twui/layout/Button";
+import Row from "@moduletrace/twui/layout/Row";
+import { ArrowLeft, ArrowRight } from "lucide-react";
+import { AdminHomePath } from "@/src/dict/admin-sections-dict";
+
+type Props = {
+    is_first: boolean;
+    is_last: boolean;
+    onBack: () => void;
+    onNext: () => void;
+};
+
+/**
+ * Under each step: skip the whole setup, go back, or go on. The last step
+ * goes to the bots.
+ */
+export default function SetupStepNav({ is_first, is_last, onBack, onNext }: Props) {
+    return (
+        <Row className="w-full gap-2! items-center justify-between py-6">
+            {is_last ? (
+                <Row />
+            ) : (
+                <Button
+                    title="Skip the setup"
+                    type="button"
+                    variant="ghost"
+                    color="gray"
+                    size="small"
+                    href={AdminHomePath}
+                >
+                    Skip setup
+                </Button>
+            )}
+            <Row className="gap-2! ml-auto">
+                {is_first ? null : (
+                    <Button
+                        title="Back"
+                        type="button"
+                        variant="outlined"
+                        color="gray"
+                        size="small"
+                        beforeIcon={<ArrowLeft size={14} aria-hidden />}
+                        onClick={onBack}
+                    >
+                        Back
+                    </Button>
+                )}
+                {is_last ? (
+                    <Button
+                        title="Go to your bots"
+                        type="button"
+                        size="small"
+                        href={AdminHomePath}
+                        afterIcon={<ArrowRight size={14} aria-hidden />}
+                    >
+                        Start chatting
+                    </Button>
+                ) : (
+                    <Button
+                        title="Next step"
+                        type="button"
+                        size="small"
+                        afterIcon={<ArrowRight size={14} aria-hidden />}
+                        onClick={onNext}
+                    >
+                        Next
+                    </Button>
+                )}
+            </Row>
+        </Row>
+    );
+}

src/pages/admin/settings/setup/(partials)/setup-steps-trail.tsx

@@ -0,0 +1,31 @@
+import Row from "@moduletrace/twui/layout/Row";
+import { SetupSteps } from "../(data)/setup-steps";
+import SetupStepItem from "./setup-step-item";
+
+type Props = {
+    index: number;
+    onSelect: (index: number) => void;
+};
+
+/**
+ * Where the setup is: every step, the current one marked.
+ */
+export default function SetupStepsTrail({ index, onSelect }: Props) {
+    return (
+        <Row
+            aria-label="Setup steps"
+            className="w-full gap-1! md:gap-2! pt-6 pb-2 border-0 border-b border-solid border-hairline"
+        >
+            {SetupSteps.map((step, i) => (
+                <SetupStepItem
+                    key={step.key}
+                    title={step.title}
+                    number={i + 1}
+                    current={i == index}
+                    done={i < index}
+                    onSelect={() => onSelect(i)}
+                />
+            ))}
+        </Row>
+    );
+}

src/pages/admin/settings/setup/(partials)/setup-text-model-status.tsx

@@ -0,0 +1,30 @@
+import Row from "@moduletrace/twui/layout/Row";
+import Span from "@moduletrace/twui/layout/Span";
+import { CircleCheck, CircleAlert } from "lucide-react";
+import type { HarnessOverview } from "@/src/types";
+
+type Props = {
+    text?: HarnessOverview;
+};
+
+/**
+ * Whether the bots have a model to think with yet, and which.
+ */
+export default function SetupTextModelStatus({ text }: Props) {
+    const current = text?.current;
+
+    return (
+        <Row className="w-full gap-2! flex-nowrap items-start rounded-default border border-solid border-hairline bg-surface px-4 py-3">
+            {current ? (
+                <CircleCheck size={16} aria-hidden className="shrink-0 mt-0.5" />
+            ) : (
+                <CircleAlert size={16} aria-hidden className="shrink-0 mt-0.5" />
+            )}
+            <Span className="text-[13px] leading-5 text-ink">
+                {current
+                    ? `Your bots think with ${current.name || current.slug} on ${current.provider_name}.`
+                    : "Your bots have no model to think with yet. Add a key to a provider (OpenRouter has free models) or add another provider."}
+            </Span>
+        </Row>
+    );
+}

src/pages/admin/settings/setup/(sections)/setup-section.tsx

@@ -0,0 +1,109 @@
+import { useContext, useState } from "react";
+import Span from "@moduletrace/twui/layout/Span";
+import { SiteData } from "@/src/data/site-data";
+import { AppContext } from "@/src/pages/__root";
+import SettingsGroup from "../../(partials)/settings-group";
+import SettingsList from "../../(partials)/settings-list";
+import InstallNameForm from "../../general/(partials)/install-name-form";
+import HarnessSettingsForm from "../../models/(partials)/harness-settings-form";
+import ProvidersGroup from "../../models/(partials)/providers-group";
+import useModelsOverview from "../../models/(hooks)/use-models-overview";
+import { SetupSteps } from "../(data)/setup-steps";
+import { SetupNextLinks } from "../(data)/setup-next-links";
+import SetupLinkRow from "../(partials)/setup-link-row";
+import SetupStepNav from "../(partials)/setup-step-nav";
+import SetupStepsTrail from "../(partials)/setup-steps-trail";
+import SetupTextModelStatus from "../(partials)/setup-text-model-status";
+
+/**
+ * The guided setup a new install opens on after the super admin signs
+ * up, and that stays under Settings to come back to: name the app,
+ * connect a provider, pick the models, then where to go next. Each step
+ * saves on its own and any can be skipped; the provider and model steps
+ * share their data, so a key added shows in the models at once.
+ */
+export default function SetupSection() {
+    const { pageProps } = useContext(AppContext);
+    const { overview, version, notice, update, saveSettings } = useModelsOverview();
+    const [index, setIndex] = useState(0);
+
+    if (!overview) return null;
+
+    const step = SetupSteps[index]!.key;
+    const text = overview.harnesses.find((harness) => harness.harness == "text");
+
+    const go = (next: number) => {
+        setIndex(Math.max(0, Math.min(SetupSteps.length - 1, next)));
+    };
+
+    return (
+        <>
+            <SetupStepsTrail index={index} onSelect={go} />
+            {step == "welcome" ? (
+                <>
+                    <SettingsGroup title={`Welcome to ${SiteData["SiteName"]}`}>
+                        <Span className="text-sm leading-6 text-ink">
+                            {`A few steps get your crew working: connect where models come from, then pick what your bots think, see, hear and speak with. Every step saves on its own, and you can skip any of them. This setup stays under Settings to come back to.`}
+                        </Span>
+                    </SettingsGroup>
+                    <SettingsGroup
+                        title="App name"
+                        description="The name this install goes by when it's added to a home screen or app list. Optional."
+                    >
+                        <InstallNameForm install_name={pageProps?.install_name} />
+                    </SettingsGroup>
+                </>
+            ) : null}
+            {step == "provider" ? (
+                <>
+                    <SettingsGroup
+                        title="Connect a provider"
+                        description="Your bots need at least one model provider. OpenRouter is already added: give it a key and its free models work right away."
+                    >
+                        <SetupTextModelStatus text={text} />
+                    </SettingsGroup>
+                    <ProvidersGroup providers={overview.providers} onChanged={update} />
+                </>
+            ) : null}
+            {step == "models" ? (
+                <>
+                    <SettingsGroup
+                        title="Pick models"
+                        description="Text picks a free model by itself until you choose one. Transcription, Speech and Embeddings (knowledgebase search) need a model picked before they work."
+                    >
+                        <SetupTextModelStatus text={text} />
+                    </SettingsGroup>
+                    <HarnessSettingsForm
+                        key={version}
+                        harnesses={overview.harnesses}
+                        notice={notice}
+                        save={saveSettings}
+                    />
+                </>
+            ) : null}
+            {step == "ready" ? (
+                <>
+                    <SettingsGroup title="You're set">
+                        <SetupTextModelStatus text={text} />
+                    </SettingsGroup>
+                    <SettingsGroup
+                        title="Next"
+                        description="Everything else is set up from its own page, whenever you need it."
+                    >
+                        <SettingsList>
+                            {SetupNextLinks.map((link) => (
+                                <SetupLinkRow key={link.href} {...link} />
+                            ))}
+                        </SettingsList>
+                    </SettingsGroup>
+                </>
+            ) : null}
+            <SetupStepNav
+                is_first={index == 0}
+                is_last={index == SetupSteps.length - 1}
+                onBack={() => go(index - 1)}
+                onNext={() => go(index + 1)}
+            />
+        </>
+    );
+}

src/pages/admin/settings/setup/index.server.ts

@@ -0,0 +1,10 @@
+import type { PagePropsType } from "@/src/types";
+import type { BunextPageServerFn } from "@moduletrace/bunext/types";
+import { server as modelsServer } from "../models/index.server";
+
+/**
+ * Super admins only, with the same data as the Models page: the setup's
+ * provider and model steps edit it.
+ */
+export const server: BunextPageServerFn<PagePropsType> = async (params) =>
+    await modelsServer(params);

src/pages/admin/settings/setup/index.tsx

@@ -0,0 +1,17 @@
+import { SiteData } from "@/src/data/site-data";
+import SetupSection from "./(sections)/setup-section";
+import SettingsShell from "../(partials)/settings-shell";
+import settingsPageMeta from "../(functions)/settings-page-meta";
+
+export default function AdminSettingsSetupPage() {
+    return (
+        <SettingsShell
+            title="Setup"
+            description={`Get ${SiteData["SiteName"]} ready to work, a step at a time.`}
+        >
+            <SetupSection />
+        </SettingsShell>
+    );
+}
+
+export const meta = settingsPageMeta({ label: "Setup" });

src/pages/admin/usage/(data)/usage-harness-titles.ts

@@ -8,5 +8,6 @@ export const UsageHarnessTitles: Record<string, string> = {
     transcription: "Transcription",
     speech: "Speech",
     image: "Image generation",
+    image_edit: "Image editing",
     embedding: "Embeddings",
 };

src/pages/admin/workspaces/[workspace_id]/(partials)/workspace-activity-row.tsx

@@ -1,5 +1,6 @@
 import Span from "@moduletrace/twui/layout/Span";
 import BotAvatar from "@/src/components/general/bot-avatar";
+import { AppData } from "@/src/data/app-data";
 import type { BotFace } from "@/src/dict/bot-dict";
 import botStoneProps from "@/src/utils/bot-stone-props";
 import SettingsListRow from "@/src/pages/admin/settings/(partials)/settings-list-row";
@@ -13,14 +14,18 @@ type Props = {
 };
 
 /**
- * One recent conversation in the workspace: the bot, the session's title,
- * a preview of its latest message and when it last moved.
+ * One recent conversation in the workspace: the bot, the session's title
+ * (what it opened with until it's named), a preview of its latest message
+ * and when it last moved.
  */
 export default function WorkspaceActivityRow({ workspace_id, item }: Props) {
     const at = item.last_activity_at || item.created_at;
     const preview = item.last_message_text
         ? messagePreview({ text: item.last_message_text })
         : "";
+    const opening = item.first_message_text
+        ? messagePreview({ text: item.first_message_text }).slice(0, AppData.BotSessionTitleMaxChars)
+        : "";
 
     return (
         <SettingsListRow
@@ -31,7 +36,7 @@ export default function WorkspaceActivityRow({ workspace_id, item }: Props) {
                     face={(item.bot_face || "idle") as BotFace}
                 />
             }
-            title={item.title || "Untitled conversation"}
+            title={item.title || opening || "Untitled conversation"}
             href={`/admin/workspaces/${workspace_id}/bots/${item.bot_id}`}
             badge={item.unread ? "New" : undefined}
             subtitle={`${item.bot_name || "A bot"}${preview ? ` · ${preview}` : ""}`}

src/pages/api/admin/bot-questions/answer-question.ts

@@ -0,0 +1,40 @@
+import userAuth from "@/src/functions/backend/auth/user-auth";
+import answerBotQuestion from "@/src/functions/backend/db/bot-questions/answer-bot-question";
+import grabBotQuestionView from "@/src/functions/backend/db/bot-questions/grab-bot-question-view";
+import { AnswerBotQuestionSchema } from "@/src/schemas/bot-question-schema";
+import type { BotQuestionView } from "@/src/types";
+import AppError from "@/src/utils/app-error";
+import parseWithSchema from "@/src/utils/parse-with-schema";
+import isReadOnlyUser from "@/src/utils/rbac/is-read-only-user";
+import safeErrorMessage from "@/src/utils/safe-error-message";
+import type { APIResponseObject, BunextAPIRouteHandler } from "@moduletrace/bunext/types";
+
+/**
+ * The session user answered questions a bot asked them in its card.
+ * Answers with the questions as they now stand.
+ */
+export const handler: BunextAPIRouteHandler<APIResponseObject<BotQuestionView>> = async ({ req, body }) => {
+    try {
+        if (req.method != "POST") {
+            throw new AppError(`Method not allowed`);
+        }
+
+        const { user, user_types } = await userAuth({ req });
+
+        if (!user?.logged_in_status || !user.id) {
+            return { success: false, msg: `Unauthorized`, logoutUser: true };
+        }
+
+        if (isReadOnlyUser({ user_types: user_types || [] })) {
+            throw new AppError(`This user can only read records.`);
+        }
+
+        const { question_id, answers } = parseWithSchema({ schema: AnswerBotQuestionSchema, data: body });
+
+        await answerBotQuestion({ question_id, user_id: user.id, answers });
+
+        return { success: true, singleRes: await grabBotQuestionView({ question_id, user_id: user.id }) };
+    } catch (error: unknown) {
+        return { success: false, msg: safeErrorMessage({ error }) };
+    }
+};

src/pages/api/admin/bot-questions/get-question.ts

@@ -0,0 +1,32 @@
+import userAuth from "@/src/functions/backend/auth/user-auth";
+import grabBotQuestionView from "@/src/functions/backend/db/bot-questions/grab-bot-question-view";
+import { BotQuestionIdSchema } from "@/src/schemas/bot-question-schema";
+import type { BotQuestionView } from "@/src/types";
+import AppError from "@/src/utils/app-error";
+import parseWithSchema from "@/src/utils/parse-with-schema";
+import safeErrorMessage from "@/src/utils/safe-error-message";
+import type { APIResponseObject, BunextAPIRouteHandler } from "@moduletrace/bunext/types";
+
+/**
+ * `GET ?question_id=`: questions a bot asked the session user, as their
+ * chip and card show them. Nobody else reads them.
+ */
+export const handler: BunextAPIRouteHandler<APIResponseObject<BotQuestionView>> = async ({ req, query }) => {
+    try {
+        if (req.method != "GET") {
+            throw new AppError(`Method not allowed`);
+        }
+
+        const { user } = await userAuth({ req });
+
+        if (!user?.logged_in_status || !user.id) {
+            return { success: false, msg: `Unauthorized`, logoutUser: true };
+        }
+
+        const { question_id } = parseWithSchema({ schema: BotQuestionIdSchema, data: query });
+
+        return { success: true, singleRes: await grabBotQuestionView({ question_id, user_id: user.id }) };
+    } catch (error: unknown) {
+        return { success: false, msg: safeErrorMessage({ error }) };
+    }
+};

src/pages/api/admin/bot-questions/skip-question.ts

@@ -0,0 +1,39 @@
+import userAuth from "@/src/functions/backend/auth/user-auth";
+import grabBotQuestionView from "@/src/functions/backend/db/bot-questions/grab-bot-question-view";
+import skipBotQuestion from "@/src/functions/backend/db/bot-questions/skip-bot-question";
+import { BotQuestionIdSchema } from "@/src/schemas/bot-question-schema";
+import type { BotQuestionView } from "@/src/types";
+import AppError from "@/src/utils/app-error";
+import parseWithSchema from "@/src/utils/parse-with-schema";
+import isReadOnlyUser from "@/src/utils/rbac/is-read-only-user";
+import safeErrorMessage from "@/src/utils/safe-error-message";
+import type { APIResponseObject, BunextAPIRouteHandler } from "@moduletrace/bunext/types";
+
+/**
+ * The session user skipped questions a bot asked them: nothing answered.
+ */
+export const handler: BunextAPIRouteHandler<APIResponseObject<BotQuestionView>> = async ({ req, body }) => {
+    try {
+        if (req.method != "POST") {
+            throw new AppError(`Method not allowed`);
+        }
+
+        const { user, user_types } = await userAuth({ req });
+
+        if (!user?.logged_in_status || !user.id) {
+            return { success: false, msg: `Unauthorized`, logoutUser: true };
+        }
+
+        if (isReadOnlyUser({ user_types: user_types || [] })) {
+            throw new AppError(`This user can only read records.`);
+        }
+
+        const { question_id } = parseWithSchema({ schema: BotQuestionIdSchema, data: body });
+
+        await skipBotQuestion({ question_id, user_id: user.id });
+
+        return { success: true, singleRes: await grabBotQuestionView({ question_id, user_id: user.id }) };
+    } catch (error: unknown) {
+        return { success: false, msg: safeErrorMessage({ error }) };
+    }
+};

src/pages/auth/signup/(functions)/submit-signup-form.ts

@@ -1,5 +1,5 @@
 import fetchApi from "@moduletrace/twui/utils/fetch/fetchApi";
-import { AdminHomePath } from "@/src/dict/admin-sections-dict";
+import { SettingsSetupPath } from "@/src/dict/settings-pages-dict";
 import type useFormInit from "@/src/hooks/use-form-init";
 import type { ApiReqParams, SignupFormObject } from "@/src/types";
 import type { APIResponseObject } from "@moduletrace/bunext/types";
@@ -42,8 +42,12 @@ export default async function submitSignupForm({
         },
     );
 
+    /**
+     * The first (super admin) account opens on the guided setup, which
+     * can be skipped.
+     */
     if (res.success) {
-        window.location.pathname = AdminHomePath;
+        window.location.pathname = SettingsSetupPath;
     } else {
         setStatus({
             error: true,

src/schemas/bot-question-schema.ts

@@ -0,0 +1,47 @@
+import { z } from "zod";
+import { AppData } from "@/src/data/app-data";
+import { BotQuestionKinds } from "@/src/dict/bot-question-dict";
+
+/**
+ * One question as a bot writes it (`ask_user`) and as it's stored.
+ */
+export const BotQuestionItemSchema = z.object({
+    question: z.string().trim().min(3, "Write the question").max(300).describe("The question, e.g. \"Which environment should I deploy to?\""),
+    kind: z
+        .enum(BotQuestionKinds)
+        .describe("single: the user picks exactly one option (radios). multiple: any number, at least one (checkboxes)."),
+    options: z
+        .array(z.string().trim().min(1).max(200))
+        .min(2, "Give at least two options")
+        .max(AppData.BotQuestionMaxOptions, `Give at most ${AppData.BotQuestionMaxOptions} options`)
+        .refine((options) => new Set(options.map((option) => option.toLowerCase())).size == options.length, "Options must differ")
+        .describe("The answers to choose from, each short and distinct"),
+    allow_other: z
+        .boolean()
+        .optional()
+        .describe("Let the user type an answer of their own besides the options. Set it unless the options cover every case."),
+});
+
+export const BotQuestionItemsSchema = z
+    .array(BotQuestionItemSchema)
+    .min(1, "Ask at least one question")
+    .max(AppData.BotQuestionMaxQuestions, `Ask at most ${AppData.BotQuestionMaxQuestions} questions at once`);
+
+export const BotQuestionIdSchema = z.object({
+    question_id: z.coerce.number().int().positive("Pick the questions"),
+});
+
+export const AnswerBotQuestionSchema = z.object({
+    question_id: z.coerce.number().int().positive("Pick the questions"),
+    answers: z
+        .array(
+            z.object({
+                choices: z.array(z.number().int().min(0)).max(AppData.BotQuestionMaxOptions),
+                other: z.string().max(AppData.BotQuestionOtherMaxChars, `Keep answers under ${AppData.BotQuestionOtherMaxChars} characters`).optional(),
+            }),
+        )
+        .max(AppData.BotQuestionMaxQuestions),
+});
+
+export type BotQuestionIdRequest = z.infer<typeof BotQuestionIdSchema>;
+export type AnswerBotQuestionRequest = z.infer<typeof AnswerBotQuestionSchema>;

src/types/index.ts

@@ -34,6 +34,7 @@ import type { ImageInputToBase64FunctionReturn } from "@moduletrace/twui/utils/f
 import type { HarnessKind } from "../dict/harness-dict";
 import type { HarnessProviderKind } from "../dict/harness-provider-dict";
 import type { EnvParadigm, KnownEnv, SecretRequestStatus } from "../dict/env-dict";
+import type { BotQuestionKind, BotQuestionStatus } from "../dict/bot-question-dict";
 import type { ContainerStatus } from "../dict/computer-dict";
 import type { BotFace, BotKind, BotMessageReactionEmoji } from "../dict/bot-dict";
 import type { HarnessCallSettings, TokenUsageSummary } from "../harness/usage/types";
@@ -275,6 +276,10 @@ export type WorkspaceWithActivity = BUN_SQLITE_COBBLE_WORKSPACES & {
  */
 export type WorkspaceActivityItem = BUN_SQLITE_COBBLE_BOT_SESSIONS & {
     message_count: number;
+    /**
+     * What the session opened with, shown while it has no title yet.
+     */
+    first_message_text?: string | null;
     last_message_text?: string | null;
     bot_name?: string | null;
     bot_image_media_id?: number | null;
@@ -734,6 +739,45 @@ export type BotGraphicView = {
     updated_at: number;
 };
 
+/**
+ * One question a bot asks the user before acting (`ask_user`).
+ */
+export type BotQuestionItem = {
+    question: string;
+    kind: BotQuestionKind;
+    options: string[];
+    /**
+     * Whether the user may type an answer of their own ("Other").
+     */
+    allow_other: boolean;
+};
+
+/**
+ * The user's answer to one question: the options they picked (by index)
+ * and what they typed into "Other" (empty if nothing).
+ */
+export type BotQuestionAnswer = {
+    choices: number[];
+    other: string;
+};
+
+/**
+ * Questions a bot asked the user (`[question:ID]`), as their chip and card
+ * show them.
+ */
+export type BotQuestionView = {
+    id: number;
+    title: string;
+    questions: BotQuestionItem[];
+    /**
+     * One per question once answered, else null.
+     */
+    answers: BotQuestionAnswer[] | null;
+    status: BotQuestionStatus;
+    bot_id: number;
+    bot_name: string;
+};
+
 export type SecretRequestView = {
     id: number;
     key: string;

src/utils/bot-question-answers-text.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, test } from "bun:test";
+import type { BotQuestionView } from "@/src/types";
+import botQuestionAnswersText from "./bot-question-answers-text";
+
+const view: BotQuestionView = {
+    id: 4,
+    title: "Before I deploy",
+    questions: [
+        { question: "Which environment?", kind: "single", options: ["Staging", "Production"], allow_other: false },
+        { question: "Which checks?", kind: "multiple", options: ["Lint", "Tests", "Build"], allow_other: true },
+    ],
+    answers: [
+        { choices: [0], other: "" },
+        { choices: [0, 2], other: "e2e" },
+    ],
+    status: "answered",
+    bot_id: 2,
+    bot_name: "Ember",
+};
+
+describe("botQuestionAnswersText", () => {
+    test("names each question with what was picked", () => {
+        expect(botQuestionAnswersText({ view })).toBe(
+            [
+                "My answers (questions #4):",
+                "- **Which environment?** Staging",
+                "- **Which checks?** Lint; Build; other: e2e",
+            ].join("\n"),
+        );
+    });
+
+    test("says when the questions were skipped", () => {
+        expect(botQuestionAnswersText({ view: { ...view, status: "skipped", answers: null } })).toBe(
+            "I skipped your questions (questions #4) without answering them.",
+        );
+    });
+});

src/utils/bot-question-answers-text.ts

@@ -0,0 +1,26 @@
+import type { BotQuestionView } from "@/src/types";
+
+type Params = {
+    view: BotQuestionView;
+};
+
+/**
+ * What the chat tells the bot once the user answered (or skipped) its
+ * questions, so it carries on from their answers: each question with the
+ * options picked and anything typed into "Other".
+ */
+export default function botQuestionAnswersText({ view }: Params) {
+    if (view.status == "skipped" || !view.answers) {
+        return `I skipped your questions (questions #${view.id}) without answering them.`;
+    }
+
+    const lines = view.questions.map((item, index) => {
+        const answer = view.answers?.[index];
+        const picked = (answer?.choices || []).map((choice) => item.options[choice]).filter(Boolean);
+        const other = answer?.other ? `other: ${answer.other}` : "";
+
+        return `- **${item.question}** ${[...picked, other].filter(Boolean).join("; ")}`;
+    });
+
+    return [`My answers (questions #${view.id}):`, ...lines].join("\n");
+}

src/utils/bot-question-ref.ts

@@ -0,0 +1,28 @@
+type Params = {
+    id: number | string;
+};
+
+/**
+ * How a bot names questions it asked the user: `[question:4]`. The chat
+ * turns it into a link (`linkComputerRefs`) that renders as a chip opening
+ * the card the user answers them in.
+ */
+export default function botQuestionRef({ id }: Params) {
+    return `[question:${id}]`;
+}
+
+/**
+ * The link target a question ref becomes, e.g. `#question-4`.
+ */
+export const BotQuestionRefHrefPrefix = "#question-";
+
+/**
+ * The id in a question ref's link target, or null.
+ */
+export function botQuestionRefId({ href }: { href?: string | null }) {
+    if (!href?.startsWith(BotQuestionRefHrefPrefix)) return null;
+
+    const id = Number(href.slice(BotQuestionRefHrefPrefix.length));
+
+    return Number.isInteger(id) && id > 0 ? id : null;
+}

src/utils/check-bot-question-answers.test.ts

@@ -0,0 +1,57 @@
+import { describe, expect, test } from "bun:test";
+import type { BotQuestionItem } from "@/src/types";
+import checkBotQuestionAnswers from "./check-bot-question-answers";
+
+const questions: BotQuestionItem[] = [
+    { question: "Which environment?", kind: "single", options: ["Staging", "Production"], allow_other: false },
+    { question: "Which checks?", kind: "multiple", options: ["Lint", "Tests", "Build"], allow_other: true },
+];
+
+describe("checkBotQuestionAnswers", () => {
+    test("tidies valid answers", () => {
+        expect(
+            checkBotQuestionAnswers({
+                questions,
+                answers: [{ choices: [1] }, { choices: [2, 0, 2], other: "  e2e  " }],
+            }),
+        ).toEqual([
+            { choices: [1], other: "" },
+            { choices: [0, 2], other: "e2e" },
+        ]);
+    });
+
+    test("takes Other alone where it's allowed", () => {
+        expect(checkBotQuestionAnswers({ questions, answers: [{ choices: [0] }, { choices: [], other: "None" }] })[1]).toEqual({
+            choices: [],
+            other: "None",
+        });
+    });
+
+    test("needs one answer per question", () => {
+        expect(() => checkBotQuestionAnswers({ questions, answers: [{ choices: [0] }] })).toThrow("Answer every question.");
+    });
+
+    test("needs every question answered", () => {
+        expect(() => checkBotQuestionAnswers({ questions, answers: [{ choices: [0] }, { choices: [], other: "  " }] })).toThrow(
+            "Answer question 2.",
+        );
+    });
+
+    test("takes one pick for a single-choice question", () => {
+        expect(() => checkBotQuestionAnswers({ questions, answers: [{ choices: [0, 1] }, { choices: [0] }] })).toThrow(
+            "Question 1 takes one answer.",
+        );
+    });
+
+    test("refuses options that don't exist", () => {
+        expect(() => checkBotQuestionAnswers({ questions, answers: [{ choices: [2] }, { choices: [0] }] })).toThrow(
+            "Question 1 has an option that doesn't exist.",
+        );
+    });
+
+    test("refuses Other where it isn't allowed", () => {
+        expect(() =>
+            checkBotQuestionAnswers({ questions, answers: [{ choices: [], other: "QA" }, { choices: [0] }] }),
+        ).toThrow("Question 1 only takes its options.");
+    });
+});

src/utils/check-bot-question-answers.ts

@@ -0,0 +1,46 @@
+import type { BotQuestionAnswer, BotQuestionItem } from "@/src/types";
+import AppError from "./app-error";
+
+type Params = {
+    questions: BotQuestionItem[];
+    answers: { choices: number[]; other?: string }[];
+};
+
+/**
+ * The user's answers checked against the questions they answer: one per
+ * question, only options that exist, "Other" only where it's allowed,
+ * exactly one pick for a single-choice question and at least one for a
+ * multiple-choice one. Returns them tidied (choices sorted and unique,
+ * "Other" trimmed); throws an `AppError` naming the first question that
+ * isn't answered right.
+ */
+export default function checkBotQuestionAnswers({ questions, answers }: Params): BotQuestionAnswer[] {
+    if (answers.length != questions.length) {
+        throw new AppError(`Answer every question.`);
+    }
+
+    return questions.map((item, index) => {
+        const answer = answers[index]!;
+        const choices = [...new Set(answer.choices)].sort((a, b) => a - b);
+        const other = (answer.other || "").trim();
+        const label = `Question ${index + 1}`;
+
+        if (choices.some((choice) => !Number.isInteger(choice) || choice < 0 || choice >= item.options.length)) {
+            throw new AppError(`${label} has an option that doesn't exist.`);
+        }
+
+        if (other && !item.allow_other) {
+            throw new AppError(`${label} only takes its options.`);
+        }
+
+        const picked = choices.length + (other ? 1 : 0);
+
+        if (!picked) throw new AppError(`Answer ${label.toLowerCase()}.`);
+
+        if (item.kind == "single" && picked > 1) {
+            throw new AppError(`${label} takes one answer.`);
+        }
+
+        return { choices, other };
+    });
+}

src/utils/export-message-text.test.ts

@@ -20,6 +20,10 @@ describe("exportMessageText", () => {
         );
     });
 
+    test("words questions by number", () => {
+        expect(exportMessageText({ text: "Pick: [question:4]", ...names, heading_offset: 0 })).toBe("Pick: (questions 4)");
+    });
+
     test("words graphics by number", () => {
         expect(exportMessageText({ text: "See [graphic:5]", ...names, heading_offset: 0 })).toBe("See (graphic 5)");
     });