@songsid/agend 2.1.12 → 2.2.0-alpha.2

package/dist/ui/chat-store.js

@@ -0,0 +1,318 @@
+// #1408 §5: the web chat's state, for the life of the page — every instance's messages, drafts, files waiting to go,
+// failed sends, prompts and turn state. It is fed by the app's one stream from the first frame, whatever panel is on
+// screen, so leaving the chat and coming back loses nothing (draft, scroll, files) and re-reads nothing.
+//
+// What it does is what the dashboard did (#1307, #1306, #1313, #1316, #1317); only where it lives changed. No DOM:
+// the chat panel renders it; tests drive it directly.
+//
+// Requests and #1374: the history of an instance is read once per page, when a person first opens its chat (a
+// navigation — it counts as use, as the old click did). Coming back to it reads nothing; the stream keeps it current.
+import "./chat-render.js";
+
+const R = () => globalThis.AgendChatRender;
+
+/** Build a store. `deps` (fetch, toast, announce, t, now) are injected so tests can drive every path. */
+export function createChatStore(deps) {
+  const s = {
+    msgs: {}, drafts: {}, failedSends: {}, pendingFiles: {}, sending: {}, inFlightFiles: {},
+    prompts: {}, workingSince: {}, stopping: {}, cancelling: {}, scrollMemo: {}, historyRead: new Set(),
+    exec: {}, awaiting: {}, current: null,
+    // #1269: the last chat command per instance — { command, busy, text?, error?, choices? } — shown above the composer.
+    commands: {},
+  };
+  const subs = new Set();
+  const pastedTexts = new WeakMap();
+  const now = deps.now || (() => (typeof performance !== "undefined" ? performance.now() : Date.now()));
+  const t = deps.t, tf = deps.t;
+
+  /** Tell subscribers what changed: `kind` "msgs" (the thread redraws) or "state" (everything else). */
+  function changed(instance, kind = "state") { for (const fn of [...subs]) fn(instance, kind); }
+  async function api(method, path, body) {
+    const o = { method, headers: { "Content-Type": "application/json" } };
+    if (body) o.body = JSON.stringify(body);
+    const r = await deps.fetch(path, o);
+    return r.json();
+  }
+  const isUser = (x, instance) => x.sender === "web-user" || (!x.sender.startsWith("agend") && x.sender !== instance && x.sender !== "general");
+
+  // ── The turn (#1307): when this page saw the agent start working (its own monotonic clock, so approximate), a Stop
+  // on its way, and an instance waiting on a terminal prompt.
+  function noteExec(name, state) {
+    const was = R().isBusy(s.exec[name]), busy = R().isBusy(state);
+    const known = Object.prototype.hasOwnProperty.call(s.exec, name);
+    s.exec[name] = state;
+    if (busy && !was) s.workingSince[name] = now();
+    if (!busy) { delete s.workingSince[name]; delete s.stopping[name]; }
+    if (known && name === s.current && busy !== was) deps.announce(tf(busy ? "chat.a11yWorking" : "chat.a11yIdle", name));
+  }
+  function applyStatus(d) {
+    if (!d || !Array.isArray(d.instances)) return;
+    for (const i of d.instances) {
+      noteExec(i.name, (i.execution_state !== undefined ? i.execution_state : i.state) ?? null);
+      const waits = i.state === "awaiting_input" ? (typeof i.interaction_summary === "string" ? i.interaction_summary : "") : null;
+      if (i.name === s.current && waits != null && s.awaiting[i.name] == null) deps.announce(tf("chat.awaiting", i.name));
+      s.awaiting[i.name] = waits;
+    }
+    changed(null);
+  }
+  function applyActivity(d) {
+    if (!d || typeof d.instance !== "string") return;
+    noteExec(d.instance, d.state ?? null);
+    changed(d.instance);
+  }
+
+  // ── Messages: one way in, from the stream, a poll or the history; one entry per boot+id.
+  function ingest(m) {
+    if (!m || typeof m.instance !== "string") return;
+    const before = s.msgs[m.instance];
+    s.msgs[m.instance] = R().mergeMessages(before, [m], 500);
+    if (m.instance === s.current && s.msgs[m.instance] !== before && !isUser(m, m.instance) && (s.msgs[m.instance] || []).length > (before || []).length) deps.announce(tf("chat.a11yReplied", m.sender));
+    if (s.msgs[m.instance] !== before) changed(m.instance, "msgs");
+  }
+  function applyDeliveries(list) {
+    if (!Array.isArray(list)) return;
+    const touched = new Set();
+    for (const d of list) {
+      if (!d || typeof d.instance !== "string") continue;
+      const before = s.msgs[d.instance];
+      s.msgs[d.instance] = R().applyDelivery(before, d.messageId, d.delivery);
+      if (s.msgs[d.instance] !== before) touched.add(d.instance);
+    }
+    for (const i of touched) changed(i, "msgs");
+  }
+  /** Read an instance's history once per page (the first time a person opens its chat). */
+  async function openHistory(name, lease) {
+    if (s.historyRead.has(name)) return false;
+    s.historyRead.add(name);
+    try {
+      const r = await api("GET", `/ui/history?instance=${encodeURIComponent(name)}&limit=200`);
+      if (!r || !Array.isArray(r.messages)) { s.historyRead.delete(name); return true; }
+      // Kept even when the person has moved on: the store is page-lived, and the answer belongs to `name`.
+      s.msgs[name] = R().mergeMessages(s.msgs[name], r.messages, 500);
+      changed(name, "msgs");
+    } catch { s.historyRead.delete(name); /* the live stream still works; the next visit tries again */ }
+    void lease;
+    return true;
+  }
+
+  // ── Prompts the fleet has open (hang / clean exit / interactive input): the same buttons the platform shows.
+  function onPrompt(p) {
+    if (!p || typeof p.nonce !== "string") return;
+    const had = s.prompts[p.nonce];
+    const fresh = !had;
+    // A prompt already held (being answered, or claimed from Needs you) keeps its busy/answered state: a repeat of it
+    // only refreshes its text and buttons (#1463 review).
+    if (!had) s.prompts[p.nonce] = { ...p, resolved: false, busy: false };
+    else if (!had.resolved) Object.assign(had, { text: p.text, actions: p.actions, expiresAt: p.expiresAt });
+    if (p.instance === s.current) changed(p.instance);
+    else if (fresh) deps.toast(tf("chat.promptFor", p.instance, p.text), false);
+  }
+  /** The open prompts, on every stream (re)connect and with every poll: a prompt answered or expired while this page
+   *  was not listening is caught up here, and no timer ever re-reads anything. */
+  function applyPrompts(list) {
+    if (!Array.isArray(list)) return;
+    const open = new Set(list.map(p => p.nonce));
+    for (const p of list) {
+      const had = s.prompts[p.nonce];
+      if (!had) s.prompts[p.nonce] = { ...p, resolved: false, busy: false };
+      else if (!had.resolved) Object.assign(had, { text: p.text, actions: p.actions, expiresAt: p.expiresAt });
+    }
+    for (const n of Object.keys(s.prompts)) if (!s.prompts[n].resolved && !open.has(n)) s.prompts[n].resolved = true;
+    changed(null);
+  }
+  function resolvePrompt(d) {
+    const p = d && s.prompts[d.nonce];
+    if (!p) return;
+    p.resolved = true; p.busy = false;
+    if (d.outcome) p.outcome = d.outcome;
+    deps.setTimeout(() => { if (s.prompts[d.nonce] === p) { delete s.prompts[d.nonce]; changed(p.instance); } }, 60000);
+    changed(p.instance);
+  }
+  async function answerPrompt(p, action) {
+    if (p.busy || p.resolved) return;
+    p.busy = true; changed(p.instance);
+    let r;
+    try { r = await api("POST", "/ui/prompt", { instance: p.instance, nonce: p.nonce, action }); }
+    catch (err) { r = { error: err && err.message ? err.message : t("chat.disconnected") }; }
+    if (r && r.answered) return;   // the outcome arrives as prompt_resolved
+    const latest = s.prompts[p.nonce];
+    for (const q of latest && latest !== p ? [p, latest] : [p]) { q.busy = false; if (r && r.gone) q.resolved = true; }
+    changed(p.instance);
+    deps.toast(r && r.error ? r.error : t("chat.disconnected"), false);
+  }
+  /**
+   * Answer a prompt known only by its nonce (Needs you, #1386): the page's one claim on it. A prompt this store does not
+   * hold yet is entered now, busy, so the chat, a second click and a later hydration all see the same claim; the next
+   * prompts list or prompt_resolved settles it, as for any prompt.
+   */
+  function answerByNonce(item, action) {
+    if (!item || typeof item.nonce !== "string") return Promise.resolve();
+    let p = s.prompts[item.nonce];
+    if (!p) p = s.prompts[item.nonce] = { instance: item.instance, nonce: item.nonce, text: item.text || item.detail || "", actions: item.actions || [], resolved: false, busy: false };
+    return answerPrompt(p, action);
+  }
+  /** A claim taken elsewhere before this store existed (Needs you, before Chat booted): held here from now on. */
+  function holdPrompt(item) {
+    if (!item || typeof item.nonce !== "string") return;
+    let p = s.prompts[item.nonce];
+    if (!p) p = s.prompts[item.nonce] = { instance: item.instance, nonce: item.nonce, text: item.text || item.detail || "", actions: item.actions || [], resolved: false, busy: false };
+    if (!p.resolved) { p.busy = true; changed(p.instance); }
+  }
+  /** That claim's answer was refused: the prompt can be answered again (unless it was settled meanwhile). */
+  function releasePrompt(nonce) {
+    const p = s.prompts[nonce];
+    if (p && !p.resolved) { p.busy = false; changed(p.instance); }
+  }
+  const promptsFor = (instance) => Object.values(s.prompts).filter(p => p.instance === instance);
+
+  // ── Sending. Never lose anything: a failed send's files go back to that chat's list and its text back into its own
+  // composer when that is empty, otherwise it is kept for its chat and offered back (Put back).
+  async function uploadFile(target, file) {
+    const r = await deps.fetch(`/ui/upload?instance=${encodeURIComponent(target)}`, {
+      method: "POST",
+      headers: { "Content-Type": file.type || "application/octet-stream", "X-Agend-Filename": encodeURIComponent(file.name || "file") },
+      body: file,
+    });
+    let body = {};
+    try { body = await r.json(); } catch { /* not JSON */ }
+    if (!r.ok || !body || typeof body.id !== "string") throw new Error(body && body.error ? `${file.name}: ${body.error}` : `${file.name}: upload failed (${r.status})`);
+    return body;
+  }
+  async function send(target) {
+    const txt = (s.drafts[target] || "").trim();
+    const files = (s.pendingFiles[target] || []).slice();
+    if ((!txt && !files.length) || !target || s.sending[target]) return;
+    s.sending[target] = true;
+    s.drafts[target] = "";
+    s.pendingFiles[target] = []; s.inFlightFiles[target] = files;
+    changed(target);
+    changed(target, "sent");          // your own message: the thread goes to the bottom
+    let r;
+    try {
+      const ids = [];
+      for (const f of files) ids.push((await uploadFile(target, f)).id);
+      r = await api("POST", "/ui/send", ids.length ? { instance: target, message: txt, attachments: ids } : { instance: target, message: txt });
+    } catch (err) { r = { error: err && err.message ? err.message : t("chat.disconnected") }; }
+    s.sending[target] = false;
+    delete s.inFlightFiles[target];
+    if (r && !r.error) { changed(target); return; }
+    if (files.length) s.pendingFiles[target] = R().checkFiles(files, s.pendingFiles[target] || []).kept;
+    if (txt) {
+      const shown = s.current === target;
+      if (R().settleFailedSend(target, s.current, shown, shown ? (s.drafts[target] || "") : "") === "restore") s.drafts[target] = txt;
+      else s.failedSends[target] = s.failedSends[target] ? `${s.failedSends[target]}\n${txt}` : txt;
+    }
+    changed(target);
+    deps.toast(r && r.error ? r.error : t("chat.disconnected"), false);
+  }
+  function addFiles(target, list) {
+    if (!target) return;
+    const inFlight = s.inFlightFiles[target] || [];
+    const res = R().checkFiles(inFlight.concat(s.pendingFiles[target] || []), [...(list || [])]);
+    s.pendingFiles[target] = res.kept.slice(inFlight.length);
+    for (const x of res.rejected) deps.toast(`${x.name}: ${t(`chat.file_${x.reason.replace(/-/g, "_")}`)}`, false);
+    changed(target);
+  }
+  function removeFile(target, index) { (s.pendingFiles[target] || []).splice(index, 1); changed(target); }
+  /** A long paste as a .txt file when it fits beside what is attached; true when it was attached. */
+  function attachPastedText(target, text) {
+    if (!target) return false;
+    const stamp = new Date().toISOString().slice(0, 19).replace(/[-:T]/g, "");
+    const f = new File([text], `pasted-${stamp}.txt`, { type: "text/plain" });
+    const taken = (s.inFlightFiles[target] || []).concat(s.pendingFiles[target] || []);
+    if (R().checkFiles(taken, [f]).rejected.length) { deps.toast(t("chat.pasteKeptAsText")); return false; }
+    pastedTexts.set(f, text);
+    addFiles(target, [f]);
+    deps.toast(tf("chat.pasteAttached", text.length.toLocaleString()));
+    return true;
+  }
+  /** A pasted file back into the composer as text. */
+  function fileBackAsText(target, index) {
+    const f = (s.pendingFiles[target] || [])[index];
+    if (!f || !pastedTexts.has(f)) return;
+    s.pendingFiles[target].splice(index, 1);
+    const draft = s.drafts[target] || "";
+    s.drafts[target] = draft ? `${draft}\n${pastedTexts.get(f)}` : pastedTexts.get(f);
+    changed(target);
+  }
+  const isPasted = (f) => pastedTexts.has(f);
+  function putBack(target) {
+    const kept = s.failedSends[target];
+    if (!kept) return;
+    s.drafts[target] = R().putBack(kept, s.drafts[target] || "");
+    delete s.failedSends[target];
+    changed(target);
+  }
+  function discardFailed(target) { delete s.failedSends[target]; changed(target); }
+  /** Typing: kept for its chat, no redraw (the composer already shows it). */
+  function setDraft(target, value) { s.drafts[target] = value; }
+
+  // ── Stop the reply under way (the composer's Stop, or Esc). Set before the request goes, so a held Esc or a second
+  // click sends nothing more (#1317); "Stopping…" until the agent goes idle, or a minute passes.
+  async function cancelReply(target) {
+    if (!target || s.cancelling[target]) return;
+    s.cancelling[target] = true;
+    changed(target);
+    let r;
+    try { r = await api("POST", `/ui/cancel/${encodeURIComponent(target)}`); }
+    catch (err) { r = { error: err && err.message ? err.message : t("chat.disconnected") }; }
+    delete s.cancelling[target];
+    if (r && !r.error) {
+      if (R().isBusy(s.exec[target])) {
+        s.stopping[target] = true;
+        deps.setTimeout(() => { if (s.stopping[target]) { delete s.stopping[target]; changed(target); } }, 60000);
+      }
+      deps.toast(`${target}: ${t("chat.stopSent")}`);
+    } else deps.toast(r && r.error ? r.error : t("chat.disconnected"), false);
+    changed(target);
+  }
+
+  // ── Chat commands (#1269): the instance's own /ctx, /compact, /clear, /model … through POST /ui/command. One command
+  // at a time per instance, claimed before the request goes (a double Enter sends nothing more). /clear answers with a
+  // confirmation first: asked in the app's dialog, and a yes counts only while `alive()` (the chat that asked is still
+  // the one on screen) — the token is the server's, used once, for the instance as it was when asked.
+  async function runCommand(target, command, args, opts = {}) {
+    if (!target || !commandFree(target)) return;
+    const alive = opts.alive || (() => true);
+    s.commands[target] = { command, busy: true };
+    changed(target);
+    const post = async (extra) => {
+      try { return await api("POST", "/ui/command", { instance: target, command, ...(args ? { args } : {}), ...extra }); }
+      catch (err) { return { error: err && err.message ? err.message : t("chat.disconnected") }; }
+    };
+    let r = await post({});
+    if (r && r.confirm) {
+      const yes = deps.confirm ? await deps.confirm({ title: `/${command}`, message: r.confirm.message, confirmLabel: t("chat.cmdConfirm"), danger: true }) : false;
+      if (!yes || !alive()) { delete s.commands[target]; changed(target); return; }
+      r = await post({ confirm: r.confirm.token });
+    }
+    s.commands[target] = r && r.choices ? { command, busy: false, choices: r.choices }
+      : r && r.error ? { command, busy: false, error: r.error } : { command, busy: false, text: (r && r.text) || "" };
+    changed(target);
+  }
+  function dismissCommand(target) { delete s.commands[target]; changed(target); }
+  /** Whether a command can start for `target` now (none is out): checked before a typed command line is consumed. */
+  const commandFree = (target) => !(s.commands[target] && s.commands[target].busy);
+
+  /** Wire the store to the app's stream, for the life of the page. */
+  function attach(stream) {
+    stream.on("status", applyStatus);
+    stream.on("activity", applyActivity);
+    stream.on("message", ingest);
+    stream.on("delivery", (d) => applyDeliveries([d]));
+    stream.on("deliveries", applyDeliveries);
+    stream.on("prompt", onPrompt);
+    stream.on("prompts", applyPrompts);
+    stream.on("prompt_resolved", resolvePrompt);
+  }
+
+  return {
+    state: s,
+    subscribe(fn) { subs.add(fn); return () => subs.delete(fn); },
+    setCurrent(name) { s.current = name; },
+    attach, applyStatus, applyActivity, ingest, applyDeliveries, openHistory,
+    onPrompt, applyPrompts, resolvePrompt, answerPrompt, answerByNonce, holdPrompt, releasePrompt, promptsFor,
+    uploadFile, send, addFiles, removeFile, attachPastedText, fileBackAsText, isPasted, putBack, discardFailed, setDraft,
+    cancelReply, isUser, runCommand, dismissCommand, commandFree,
+  };
+}

package/dist/ui/chat-strings.js

@@ -0,0 +1,89 @@
+// The chat's words (the chat.* namespace of the app's one dictionary, #1408 §4), in English and zh-TW.
+import { register } from "/assets/app-i18n.js";
+
+register("chat", {
+  en: {
+    cmdConfirm: "Clear", cmdRunning: "Running /{0}…", cmdNotCommand: "Not a command here — Enter sends it as a message.", cmdDismiss: "Dismiss", cmdCommands: "Commands",
+    cmdChoose: "Choose", cmdCurrent: "current", chipCompact: "Compact", chipClear: "Clear…", chipContext: "Context {0}% used",
+    chipModel: "Model: {0} — choose another", chipEffort: "Effort: {0} — choose another",
+    cmd_ctx: "Context use, model and effort", cmd_compact: "Compact the conversation", cmd_clear: "Clear the conversation (asks first)",
+    cmd_model: "Show or switch the model", cmd_effort: "Show or set the reasoning effort", cmd_cancel: "Stop the current reply",
+    cmd_btw: "A side question that does not interrupt", cmd_steer: "Send into the current turn", cmd_pause: "Pause the instance",
+    cmd_wake: "Wake a paused instance", cmd_save: "Save the conversation to a file",
+    tourTitle: "Welcome to web chat", tourStep: "{0} of {1}", tourBack: "Back", tourNext: "Next", tourDone: "Got it", tourSkip: "Skip",
+    tour1: "Pick an instance in the list to chat with it. On a phone, ☰ opens the list.",
+    tour2: "It is the same conversation as its Telegram or Discord chat: what you send here shows up there too, and the agent's replies show up in both.",
+    tour3: "Attach files and images with 📎, or paste or drop them on the chat.",
+    tour4: "While the agent works, Stop reply appears in the message box: it interrupts the current reply. The instance itself keeps running.",
+    tour5: "A “needs you” badge means the agent is waiting on its terminal, for example a permission question. Answer it from the buttons in its chat.",
+    a11yWorking: "{0} started working", a11yIdle: "{0} finished", a11yReplied: "{0} replied", conversationWith: "Conversation with {0}",
+    stopping: "Stopping {0}…", awaiting: "{0} is waiting for your input", approxNote: "Read from the terminal, so approximate", elapsedTitle: "Time since this page saw it start (approximate)",
+    dropHere: "Drop files to attach them", asText: "As text", pasteAttached: "A long paste ({0} characters) was attached as a text file", pasteKeptAsText: "No room for another attachment: the long paste stays as text",
+    send: "Send", composerPlaceholder: "Message {0}…", composerHint: "Enter to send · Shift+Enter for a new line · / for commands · Esc stops the reply", attachTitle: "Attach files (images, PDF, text — or paste / drop them)",
+    pvPreview: "Preview", pvStop: "Stop", pvDownload: "Download", pvMenu: "Preview options", pvHtml: "HTML",
+    pvAllowButton: "Allow previews", pvAllow: "Allow HTML previews on this device — they may be able to send data out", pvDisallow: "Stop allowing HTML previews on this device",
+    pvConfirm: "Allow HTML previews on this device?\n\nA preview runs the agent's HTML in an isolated frame. It cannot use your login, but it may be able to send data out, and it can slow or freeze this tab. You still click Preview each time.",
+    pvNever: "Never preview HTML on this device", pvNeverUndo: "Let this device preview HTML again", pvStarting: "Starting the preview…",
+    pvChanged: "Preview stopped — the message changed. Preview again.", pvTruncated: "Truncated — ask the agent to send it as a .html file.",
+    pvOpenPanel: "Open in panel", pvInPanel: "Shown in the panel.", pvPanel: "HTML preview", pvSource: "From {0}, {1} — show the message",
+    pvPage: "Page", pvCode: "Code", pvReload: "Reload", pvClose: "Close the panel", pvBack: "Back to the chat", pvResize: "Resize the preview panel",
+    pvNewer: "A newer version is in the reply from {0}.", pvNewerShow: "Show it", pvPanelIdle: "Click Preview to run it here.",
+    previews: "Allow HTML previews on this device",
+    copy: "Copy", copyMessage: "Copy this reply", copied: "Copied", copyFailed: "Copy failed", wrap: "Wrap", showAll: "Show all {0} lines", showLess: "Show less", jumpLatest: "Latest", newBelow: "{0} new",
+    disconnected: "disconnected", tick_queued: "Waiting behind another message", tick_processing: "Handed to the agent", tick_delivered: "The agent has it", tick_failed: "Not delivered", tick_cancelled: "Dropped by Stop",
+    promptAnswering: "Answering…", promptGone: "This prompt is no longer open", promptFor: "{0}: {1}",
+    working: "{0} is working…", stuck: "{0} looks stuck", stopReply: "Stop reply", stopReplyTitle: "Stop the current reply (like Esc) and drop the messages still waiting. The instance keeps running.", stopSent: "Stopped",
+    file_empty: "empty file", file_too_large: "over 10 MB", file_too_many: "at most 5 files per message", file_too_much: "the files together would be over 25 MB", removeFile: "Remove", notSent: "Not sent:", putBack: "Put back", discard: "Discard",
+    noMessages: "No messages yet", sendFirst: "Send a message to start the conversation",
+    pick: "Pick an instance to start", pickHint: "Choose one in the list, or create a new one.", notFound: "No instance called “{0}”", notFoundHint: "It may have been deleted or renamed.", backToList: "Open the instance list",
+    details: "Instance details", start: "Start instance", stopInstance: "Stop instance", restart: "Restart instance", delete: "Delete instance…",
+    started: "{0} started", stoppedInst: "{0} stopped", restarted: "{0} restarted", instanceDeleted: "{0} was deleted",
+    deleteTitle: "Delete {0}?", deleteHelp: "This removes the instance from the fleet and stops it. Its working directory is kept. Type “delete {0}” to confirm.", deleteGo: "Delete", cancel: "Cancel",
+    loadFailed: "Failed to load", tour: "Tour", tourBtnTitle: "Show the web chat tour again",
+    dName: "Name", dStatus: "Status", dDisplay: "Display name", dDescription: "Description", dDirectory: "Directory", dBackend: "Backend", dModel: "Model", dEffort: "Effort",
+    dCost: "Cost", dCostNote: "(session accumulated)", dContext: "Context", dRate5: "Rate 5h", dRate7: "Rate 7d", dActivity: "Recent activity", dInstance: "Instance", dRuntime: "Runtime",
+    configured: "(configured)", fleetDefault: "(fleet default)",
+  },
+  "zh-TW": {
+    cmdConfirm: "清空", cmdRunning: "執行 /{0} 中…", cmdNotCommand: "這裡沒有這個指令——按 Enter 會當成一般訊息送出。", cmdDismiss: "關閉", cmdCommands: "指令",
+    cmdChoose: "選擇", cmdCurrent: "目前", chipCompact: "壓縮", chipClear: "清空…", chipContext: "已用 {0}% 的 context",
+    chipModel: "模型：{0}——選擇其他", chipEffort: "推理強度：{0}——選擇其他",
+    cmd_ctx: "context 用量、模型與推理強度", cmd_compact: "壓縮對話", cmd_clear: "清空對話（會先確認）",
+    cmd_model: "查看或切換模型", cmd_effort: "查看或設定推理強度", cmd_cancel: "停止目前的回覆",
+    cmd_btw: "不打斷目前工作的旁問", cmd_steer: "送進目前這一輪", cmd_pause: "暫停 instance",
+    cmd_wake: "喚醒已暫停的 instance", cmd_save: "把對話存成檔案",
+    tourTitle: "歡迎使用網頁聊天", tourStep: "{0} / {1}", tourBack: "上一步", tourNext: "下一步", tourDone: "知道了", tourSkip: "略過",
+    tour1: "在清單裡選一個 instance，就能跟它對話。手機上請按 ☰ 打開清單。",
+    tour2: "這和它在 Telegram 或 Discord 上的是同一段對話：在這裡送出的訊息那邊也看得到，Agent 的回覆兩邊都會出現。",
+    tour3: "按 📎 附上檔案和圖片，也可以直接貼上或拖到聊天裡。",
+    tour4: "Agent 工作時，輸入框會出現「中止回覆」：中斷目前的回覆，instance 本身會繼續運行。",
+    tour5: "看到「等你回應」標記，表示 Agent 在終端機上等你，例如權限詢問。到它的聊天裡按按鈕回應即可。",
+    a11yWorking: "{0} 開始工作", a11yIdle: "{0} 已完成", a11yReplied: "{0} 已回覆", conversationWith: "與 {0} 的對話",
+    stopping: "正在中止 {0}…", awaiting: "{0} 正在等你回應", approxNote: "從終端畫面判讀，僅供參考", elapsedTitle: "從這個頁面看到它開始工作起算（約略）",
+    dropHere: "放開即可附加檔案", asText: "改為文字", pasteAttached: "貼上的長文字（{0} 個字元）已改為文字檔附加", pasteKeptAsText: "附件已滿，貼上的長文字保留為一般文字",
+    send: "送出", composerPlaceholder: "傳訊息給 {0}…", composerHint: "Enter 送出 · Shift+Enter 換行 · / 叫出指令 · Esc 中止回覆", attachTitle: "附加檔案（圖片、PDF、文字檔，也可以貼上或拖曳）",
+    pvPreview: "預覽", pvStop: "停止", pvDownload: "下載", pvMenu: "預覽選項", pvHtml: "HTML",
+    pvAllowButton: "允許預覽", pvAllow: "允許這台裝置預覽 HTML（預覽可能把資料傳出去）", pvDisallow: "不再允許這台裝置預覽 HTML",
+    pvConfirm: "要允許這台裝置預覽 HTML 嗎？\n\n預覽會在隔離的框架裡執行 agent 的 HTML。它無法使用你的登入，但可能把資料傳出去，也可能讓這個分頁變慢或卡住。每次仍需要你按「預覽」。",
+    pvNever: "這台裝置永不預覽 HTML", pvNeverUndo: "讓這台裝置再次可以預覽 HTML", pvStarting: "正在啟動預覽…",
+    pvChanged: "預覽已停止——訊息內容變了。請再預覽一次。", pvTruncated: "內容被截斷——請 agent 改用 .html 檔案傳送。",
+    pvOpenPanel: "在面板中開啟", pvInPanel: "已在面板中顯示。", pvPanel: "HTML 預覽", pvSource: "來自 {0}，{1}——顯示該訊息",
+    pvPage: "頁面", pvCode: "程式碼", pvReload: "重新載入", pvClose: "關閉面板", pvBack: "回到對話", pvResize: "調整預覽面板寬度",
+    pvNewer: "{0} 的回覆裡有較新的版本。", pvNewerShow: "顯示", pvPanelIdle: "按「預覽」在這裡執行。",
+    previews: "允許這台裝置預覽 HTML",
+    copy: "複製", copyMessage: "複製這則回覆", copied: "已複製", copyFailed: "複製失敗", wrap: "換行", showAll: "展開全部 {0} 行", showLess: "收合", jumpLatest: "最新", newBelow: "{0} 則新訊息",
+    disconnected: "已斷線", tick_queued: "排在前一則訊息之後", tick_processing: "已交給 agent", tick_delivered: "agent 已收到", tick_failed: "未送達", tick_cancelled: "已被中止取消",
+    promptAnswering: "回覆中…", promptGone: "這個提示已經結束", promptFor: "{0}：{1}",
+    working: "{0} 處理中…", stuck: "{0} 似乎卡住了", stopReply: "中止回覆", stopReplyTitle: "中止目前的回覆（同 Esc），並取消還在排隊的訊息。instance 會繼續運行。", stopSent: "已中止",
+    file_empty: "空檔案", file_too_large: "超過 10 MB", file_too_many: "每則訊息最多 5 個檔案", file_too_much: "檔案合計會超過 25 MB", removeFile: "移除", notSent: "未送出：", putBack: "放回輸入框", discard: "捨棄",
+    noMessages: "尚無訊息", sendFirst: "傳送訊息以開始對話",
+    pick: "選一個 instance 開始", pickHint: "在清單裡選一個，或建立新的。", notFound: "沒有叫「{0}」的 instance", notFoundHint: "它可能已被刪除或改名。", backToList: "打開 instance 清單",
+    details: "Instance 詳細資料", start: "啟動 instance", stopInstance: "停止 instance", restart: "重新啟動 instance", delete: "刪除 instance…",
+    started: "{0} 已啟動", stoppedInst: "{0} 已停止", restarted: "{0} 已重新啟動", instanceDeleted: "{0} 已刪除",
+    deleteTitle: "要刪除 {0} 嗎？", deleteHelp: "這會把 instance 從 fleet 移除並停止它，工作目錄會保留。請輸入「delete {0}」確認。", deleteGo: "刪除", cancel: "取消",
+    loadFailed: "載入失敗", tour: "導覽", tourBtnTitle: "再看一次網頁聊天導覽",
+    dName: "名稱", dStatus: "狀態", dDisplay: "顯示名稱", dDescription: "說明", dDirectory: "目錄", dBackend: "Backend", dModel: "模型", dEffort: "Effort",
+    dCost: "花費", dCostNote: "（本次 session 累計）", dContext: "Context", dRate5: "5 小時額度", dRate7: "7 天額度", dActivity: "最近活動", dInstance: "Instance", dRuntime: "執行環境",
+    configured: "（設定值）", fleetDefault: "（fleet 預設）",
+  },
+});