aimeat 1.30.2 → 1.32.0

package/dist/public/views/profile/inbox-tab.js

@@ -8,9 +8,54 @@
  *   Toast UI editor used by workspace documents (Markdown⇄WYSIWYG toggle, lazy-loaded), with a
  *   markdown-textarea + live-preview fallback. First contact is gated as a request (accept/block).
  *   Re-fetches on SSE updates.
- * @structure InboxTab (default) · Composer (Toast UI) · MessageBubble · Avatar · helpers
+ * @structure InboxTab (default) · Composer (Toast UI) · MessageBubble · InteractiveForm · Avatar · helpers
  * @usage Lazy-loaded profile tab; registered in profile.js TABS as id `messages`.
  * @version-history
+ *   v1.14.0 -- 2026-06-23 -- Per-message 📓 action parks a message straight into the notebook for later
+ *     processing (instant copy via parkMessageToNotebook — keeps the source link + reply intent; no AI step).
+ *   v1.13.0 -- 2026-06-23 -- Agent capabilities in chat: (A) a peer agent's public `chat.commands` render
+ *     as fill-in command chips above the composer — pick one, fill the params, the filled template drops
+ *     into the composer to review + send; (B) for the human's OWN agents, a 📅 schedule panel lists the
+ *     agent's scheduled tasks and creates a recurring agent_task (node scheduler scoped to the agent).
+ *   v1.12.1 -- 2026-06-23 -- Operator broadcast audience is now a select: All node users OR All federation
+ *     users (genesis operator → every owner across the federation; delegated per-peer fan-out server-side).
+ *   v1.12.0 -- 2026-06-23 -- Operator broadcast: an operator sees an "📣 All node users" audience in the
+ *     broadcast compose (sends audience:'node-users', gated operator-only server-side) — e.g. a node-wide
+ *     announcement. Announcement read stats are in the existing Results view (delivered/read per recipient).
+ *   v1.11.0 -- 2026-06-23 -- Inbox-links: the tab reads ?to=<id[,id]>&subject= on mount and opens a
+ *     prefilled compose (single) or broadcast (multiple), then clears the URL. Pairs with the reusable
+ *     <InboxLink> component (mailto-style one-click DM), wired into the agent profile.
+ *   v1.10.0 -- 2026-06-23 -- Drafts: the composer auto-saves its text (debounced) to localStorage keyed by
+ *     conversation (or `new`), restoring it when you reopen the thread/compose so an in-progress message
+ *     isn't lost when switching threads; cleared on send. A suggested reply (Tracked Response) still wins.
+ *   v1.9.0 -- 2026-06-23 -- Polls: the broadcast compose gains a Message/Poll toggle + a PollBuilder
+ *     (questions, options, multi/Other/required) that fans out an interactive AskUserQuestion to the
+ *     audience; a Results view aggregates per-option tallies + delivered/read/answered counts. Sent
+ *     broadcasts are tracked in localStorage so results stay re-accessible (📊 Results).
+ *   v1.8.1 -- 2026-06-23 -- Perf: cache resolved attachment URLs per conversation. A refresh / new message
+ *     reused to re-resolve EVERY attachment (fresh presigned URL each time → new <img src> → the whole
+ *     image gallery re-downloaded on every send/reply — hundreds of MB on an image-heavy thread). Now only
+ *     not-yet-resolved attachments are fetched; existing URLs stay stable so the browser doesn't re-fetch.
+ *   v1.8.0 -- 2026-06-23 -- Send-to-many (broadcast): a 📢 Broadcast compose with a recipient-chip picker
+ *     (+ Share Group audience) and a mode toggle — Message (repliable) vs Announcement (read-only). An
+ *     announcement thread hides the reply composer for the recipient.
+ *   v1.7.4 -- 2026-06-23 -- Recipient suggestions when composing: the "to" field autocompletes (datalist)
+ *     with your own agents (GAIIs, labelled) + everyone you have a thread with — no retyping long GAIIs.
+ *   v1.7.3 -- 2026-06-23 -- Show an AGENT's own presence dot on its conversation row (a nested agent row
+ *     now renders <PresenceDot> for the agent GAII — connected = available, recently-seen = away, else
+ *     offline — instead of nothing). The owner group header still shows the human's presence.
+ *   v1.7.2 -- 2026-06-23 -- Delivery ticks now distinguish delivered from sent: delivered = ✓✓ (grey,
+ *     "reached the mailbox" — incl. agent threads, which never send a read receipt), read = ✓✓ coloured,
+ *     sent = ✓, queued = clock. Previously delivered rendered as a single ✓ identical to sent, so an
+ *     agent DM never showed a "got there" confirmation.
+ *   v1.7.1 -- 2026-06-23 -- Fix thread-splitting: a reply in an open thread now pins to that
+ *     conversationId. Without it, replying in a SUBJECT thread fell back to the default per-pair thread,
+ *     so the reply spawned a brand-new thread named after the agent (e.g. "concierge") and the subject
+ *     thread was abandoned.
+ *   v1.7.0 -- 2026-06-23 -- Interactive messages (federated AskUserQuestion): a question message renders
+ *     inline as a form (radio/checkbox + "Other" + Submit, gated on required); submitting sends a normal
+ *     reply carrying a human-readable summary + machine-readable `interactive.answers`. Answered questions
+ *     show a read-only summary. (InteractiveForm/InteractiveAnswered + submitInteractiveAnswers.)
  *   v1.6.2 -- 2026-06-21 -- Fix live-update request storm: the SSE payload's `domains` is a Set, but
  *     the handler tested `Array.isArray(domains)` (always false) so the domain filter never matched and
  *     the inbox re-fetched its whole state on EVERY change (memory/organism/task churn from dozens of
@@ -53,6 +98,12 @@ import { minidenticon } from '/lib/minidenticons.min.js';
 import { PresenceDot } from '/components/PresenceDot.js';
 import * as messages from '/js/services/messages.js';
 import * as tracked from '/js/services/tracked-responses.js';
+import * as agentsSvc from '/js/services/agents.js';
+import * as schedules from '/js/services/schedules.js';
+import { parkMessageToNotebook } from '/js/services/notebook.js';
+import { firstLine } from './notebook-helpers.js';
+import { apiGet } from '/js/api.js';
+import { getSession } from '/js/services/auth.js';
 import { TrackResponseModal } from './track-response-modal.js';
 
 /* Lazy-load the vendored Toast UI Editor (MIT, /lib/toastui/) — the same editor the workspace
@@ -118,7 +169,10 @@ function Avatar({ seed, size = 36 }) {
     dangerouslySetInnerHTML=${{ __html: svg }}></span>`;
 }
 
-const TICK = { sent: '✓', delivered: '✓', read: '✓✓', queued: '🕒', failed: '⚠', undeliverable: '⚠' };
+// WhatsApp-style ticks: sent = one ✓; delivered (reached the recipient's mailbox, incl. an agent's) =
+// two ✓✓ (grey); read (read receipt — humans send one, agents don't yet) = two ✓✓ coloured via
+// inbox-tick--read; queued (cross-node, peer unreachable) = a clock.
+const TICK = { sent: '✓', delivered: '✓✓', read: '✓✓', queued: '🕒', failed: '⚠', undeliverable: '⚠' };
 function statusTick(status) { return TICK[status] || ''; }
 
 function timeShort(s) {
@@ -246,7 +300,171 @@ function MarkdownViewer({ url, name, onClose }) {
     </div>`;
 }
 
-function MessageBubble({ msg, mine, urlMap, starred, onStar, onTrack, tracked, onOpenMarkdown }) {
+// Sentinel option id for the freeform "Other" choice (never collides with a real option id).
+const IFORM_OTHER = '__other__';
+
+/** Build the human-readable markdown summary that becomes the reply body (so the thread + un-upgraded
+ *  peers read the answer naturally, alongside the machine-readable `interactive.answers`). */
+function buildAnswerSummary(spec, answers) {
+  const lines = [`**${t('inbox.answer.summaryTitle')}**`];
+  for (const q of (spec?.questions || [])) {
+    const a = answers[q.id] || { selected: [], other: null };
+    const labels = (q.options || []).filter(o => a.selected.includes(o.id)).map(o => o.label);
+    if (a.other) labels.push(`${t('inbox.answer.other')}: ${a.other}`);
+    lines.push(`- ${q.header || q.prompt}: ${labels.length ? labels.join(', ') : '—'}`);
+  }
+  return lines.join('\n');
+}
+
+/** The interactive question form rendered inline in the thread (a federated AskUserQuestion): radio
+ *  groups (single-select), checkbox groups (multiSelect), an always-available "Other" freeform, and a
+ *  Submit button gated until every `required` question is answered. */
+function InteractiveForm({ spec, submitting, onSubmit }) {
+  const questions = spec?.questions || [];
+  const [sel, setSel] = useState(() => {
+    const init = {};
+    for (const q of questions) init[q.id] = { picks: new Set(), other: '' };
+    return init;
+  });
+  const setQ = (qid, updater) => setSel(prev => ({ ...prev, [qid]: updater(prev[qid] || { picks: new Set(), other: '' }) }));
+  const pickSingle = (qid, optId) => setQ(qid, s => ({ picks: new Set([optId]), other: optId === IFORM_OTHER ? s.other : '' }));
+  const toggleMulti = (qid, optId) => setQ(qid, s => {
+    const picks = new Set(s.picks);
+    if (picks.has(optId)) picks.delete(optId); else picks.add(optId);
+    return { picks, other: picks.has(IFORM_OTHER) ? s.other : '' };
+  });
+  const setOther = (qid, text) => setQ(qid, s => ({ picks: s.picks, other: text }));
+
+  const answeredOk = (q) => {
+    const s = sel[q.id]; if (!s) return false;
+    const realPicks = [...s.picks].filter(p => p !== IFORM_OTHER);
+    const otherOk = s.picks.has(IFORM_OTHER) && s.other.trim().length > 0;
+    return realPicks.length > 0 || otherOk;
+  };
+  const canSubmit = questions.every(q => !q.required || answeredOk(q));
+
+  const submit = () => {
+    if (!canSubmit || submitting) return;
+    const answers = {};
+    for (const q of questions) {
+      const s = sel[q.id] || { picks: new Set(), other: '' };
+      const selected = [...s.picks].filter(p => p !== IFORM_OTHER);
+      const other = (s.picks.has(IFORM_OTHER) && s.other.trim()) ? s.other.trim() : null;
+      answers[q.id] = { selected, other };
+    }
+    onSubmit?.(answers);
+  };
+
+  const renderOpt = (q, optId, label) => {
+    const multi = !!q.multiSelect;
+    const on = sel[q.id]?.picks.has(optId);
+    return html`
+      <label class=${`inbox-iform-opt${on ? ' inbox-iform-opt--on' : ''}`} key=${optId}>
+        <input type=${multi ? 'checkbox' : 'radio'} name=${`q-${q.id}`} checked=${!!on}
+          onChange=${() => multi ? toggleMulti(q.id, optId) : pickSingle(q.id, optId)} />
+        <span class="inbox-iform-opt-label">${escHtml(label)}</span>
+      </label>`;
+  };
+
+  return html`
+    <div class="inbox-iform">
+      ${questions.map(q => html`
+        <div class="inbox-iform-q" key=${q.id}>
+          ${q.header ? html`<span class="inbox-iform-chip">${escHtml(q.header)}</span>` : null}
+          <div class="inbox-iform-prompt">${escHtml(q.prompt)}${q.required ? html`<span class="inbox-iform-req"> *</span>` : null}</div>
+          <div class="inbox-iform-opts" role=${q.multiSelect ? 'group' : 'radiogroup'}>
+            ${(q.options || []).map(o => renderOpt(q, o.id, o.label))}
+            ${q.allowOther !== false ? html`
+              ${renderOpt(q, IFORM_OTHER, t('inbox.answer.other'))}
+              ${sel[q.id]?.picks.has(IFORM_OTHER) ? html`
+                <input class="inbox-iform-other" type="text" value=${sel[q.id]?.other || ''}
+                  placeholder=${t('inbox.answer.otherPlaceholder')} onInput=${e => setOther(q.id, e.target.value)} />` : null}` : null}
+          </div>
+        </div>`)}
+      <button class="btn-primary btn-sm inbox-iform-submit" disabled=${!canSubmit || submitting} onClick=${submit}>
+        ${submitting ? t('inbox.sending') : (spec?.submitLabel || t('inbox.answer.send'))}
+      </button>
+    </div>`;
+}
+
+/** Read-only summary shown on a question bubble once it has been answered. */
+function InteractiveAnswered({ spec, answers }) {
+  return html`
+    <div class="inbox-iform inbox-iform--done">
+      ${(spec?.questions || []).map(q => {
+        const a = answers[q.id] || { selected: [], other: null };
+        const labels = (q.options || []).filter(o => a.selected.includes(o.id)).map(o => o.label);
+        if (a.other) labels.push(`${t('inbox.answer.other')}: ${a.other}`);
+        return html`
+          <div class="inbox-iform-q" key=${q.id}>
+            <span class="inbox-iform-chip">${escHtml(q.header || q.prompt)}</span>
+            <div class="inbox-iform-answered">✓ ${labels.length ? escHtml(labels.join(', ')) : '—'}</div>
+          </div>`;
+      })}
+    </div>`;
+}
+
+/** Compose the questions for a poll broadcast (a fanned-out AskUserQuestion). Controlled — owns no state;
+ *  edits go through setQuestions. */
+function PollBuilder({ questions, setQuestions }) {
+  const uid = () => 'q' + Math.random().toString(36).slice(2, 8);
+  const oid = () => 'o' + Math.random().toString(36).slice(2, 8);
+  const update = (i, patch) => setQuestions(questions.map((q, j) => (j === i ? { ...q, ...patch } : q)));
+  const addQ = () => setQuestions([...questions, {
+    id: uid(), header: '', prompt: '', options: [{ id: oid(), label: '' }, { id: oid(), label: '' }],
+    multiSelect: false, allowOther: true, required: false,
+  }]);
+  const removeQ = (i) => setQuestions(questions.filter((_, j) => j !== i));
+  const updateOpt = (qi, oi, label) => update(qi, { options: questions[qi].options.map((o, j) => (j === oi ? { ...o, label } : o)) });
+  const addOpt = (qi) => update(qi, { options: [...questions[qi].options, { id: oid(), label: '' }] });
+  const removeOpt = (qi, oi) => update(qi, { options: questions[qi].options.filter((_, j) => j !== oi) });
+
+  return html`
+    <div class="inbox-poll-builder">
+      ${questions.map((q, qi) => html`
+        <div class="inbox-poll-q" key=${q.id}>
+          <div class="inbox-poll-q-head">
+            <span class="inbox-poll-q-n">${qi + 1}.</span>
+            <input class="inbox-input" placeholder=${t('inbox.pollHeader')} value=${q.header} onInput=${(e) => update(qi, { header: e.target.value })} />
+            <button class="inbox-bc-chip-x" title=${t('inbox.pollRemoveQ')} onClick=${() => removeQ(qi)}>✕</button>
+          </div>
+          <input class="inbox-input" placeholder=${t('inbox.pollPrompt')} value=${q.prompt} onInput=${(e) => update(qi, { prompt: e.target.value })} />
+          <div class="inbox-poll-opts">
+            ${q.options.map((o, oi) => html`<div class="inbox-poll-opt" key=${o.id}>
+              <input class="inbox-input" placeholder=${`${t('inbox.pollOption')} ${oi + 1}`} value=${o.label} onInput=${(e) => updateOpt(qi, oi, e.target.value)} />
+              ${q.options.length > 1 ? html`<button class="inbox-bc-chip-x" onClick=${() => removeOpt(qi, oi)}>✕</button>` : null}
+            </div>`)}
+            <button class="btn-ghost btn-sm" onClick=${() => addOpt(qi)}>+ ${t('inbox.pollAddOption')}</button>
+          </div>
+          <div class="inbox-poll-flags">
+            <label><input type="checkbox" checked=${q.multiSelect} onChange=${(e) => update(qi, { multiSelect: e.target.checked })} /> ${t('inbox.pollMulti')}</label>
+            <label><input type="checkbox" checked=${q.allowOther} onChange=${(e) => update(qi, { allowOther: e.target.checked })} /> ${t('inbox.pollAllowOther')}</label>
+            <label><input type="checkbox" checked=${q.required} onChange=${(e) => update(qi, { required: e.target.checked })} /> ${t('inbox.pollRequired')}</label>
+          </div>
+        </div>`)}
+      <button class="btn-outline btn-sm" onClick=${addQ}>+ ${t('inbox.pollAddQuestion')}</button>
+    </div>`;
+}
+
+/** Aggregate poll answers across a broadcast's recipients into per-option tallies for the results view. */
+function tallyPoll(spec, recipients) {
+  const out = [];
+  for (const q of (spec?.questions || [])) {
+    const counts = {};
+    const others = [];
+    for (const o of (q.options || [])) counts[o.id] = 0;
+    for (const r of recipients) {
+      const a = r.answers?.[q.id];
+      if (!a) continue;
+      for (const sel of (a.selected || [])) if (sel in counts) counts[sel]++;
+      if (a.other) others.push(a.other);
+    }
+    out.push({ q, counts, others });
+  }
+  return out;
+}
+
+function MessageBubble({ msg, mine, urlMap, starred, onStar, onTrack, onPark, tracked, onOpenMarkdown, answeredWith, onAnswer, submitting }) {
   const nonInline = (msg.attachments || []).filter(a => !a.inline);
   const expiredIds = new Set((msg.attachments || []).filter(a => a.expired).map(a => a.id));
   const trk = tracked ? trackStateLabel(tracked.state) : null;
@@ -260,8 +478,16 @@ function MessageBubble({ msg, mine, urlMap, starred, onStar, onTrack, tracked, o
           <button class=${`inbox-bubble-act${tracked ? ' inbox-bubble-act--on' : ''}`}
             title=${tracked ? `${t('inbox.trackResponse')} — ${trk.text}` : t('inbox.trackResponse')}
             onClick=${() => onTrack?.(msg)}>🔗</button>
+          <button class="inbox-bubble-act" title=${t('inbox.parkToNotebook')}
+            onClick=${() => onPark?.(msg)}>📓</button>
         </div>
         <div class="inbox-bubble-body"><${Markdown} text=${prepareBody(msg.body, urlMap, expiredIds)} /></div>
+        ${msg.interactive?.role === 'questions' ? (
+          answeredWith
+            ? html`<${InteractiveAnswered} spec=${msg.interactive} answers=${answeredWith.answers || {}} />`
+            : html`<${InteractiveForm} spec=${msg.interactive} submitting=${submitting}
+                onSubmit=${(answers) => onAnswer?.(msg, answers)} />`
+        ) : null}
         ${nonInline.length > 0 && html`
           <div class="inbox-attach-row">
             ${nonInline.map(a => html`<${AttachmentItem} key=${a.id} a=${a} url=${urlMap[a.id]} onOpenMarkdown=${onOpenMarkdown} />`)}
@@ -279,13 +505,26 @@ function MessageBubble({ msg, mine, urlMap, starred, onStar, onTrack, tracked, o
  * markdown-textarea + live-preview fallback if the editor can't load. Owns its own draft + file
  * state; calls onSend(recipient, markdown, files, reset). Remount it (via key) per conversation so
  * the draft doesn't leak between threads. */
-function Composer({ recipient, sendLabel, sending, onSend, initialText = '' }) {
+function Composer({ recipient, sendLabel, sending, onSend, initialText = '', draftKey = '' }) {
+  // Restore an in-progress draft for this conversation/compose (localStorage), or the passed initialText.
+  const readDraft = () => { try { return draftKey ? (localStorage.getItem(draftKey) || '') : ''; } catch { return ''; } };
+  const seeded = initialText || readDraft();   // an explicit suggested reply wins; else restore a draft
   const [mode, setMode] = useState('rich');     // 'rich' = Toast UI; 'markdown' = fallback textarea
-  const [md, setMd] = useState(initialText);
+  const [md, setMd] = useState(seeded);
   const [files, setFiles] = useState([]);
   const containerRef = useRef(null);
   const editorRef = useRef(null);
   const fileRef = useRef(null);
+  const saveTimer = useRef(null);
+  // Debounced auto-save of the draft (skipped when there's no key). Empty text clears the draft.
+  const saveDraft = (text) => {
+    if (!draftKey) return;
+    if (saveTimer.current) clearTimeout(saveTimer.current);
+    saveTimer.current = setTimeout(() => {
+      try { if (text && text.trim()) localStorage.setItem(draftKey, text); else localStorage.removeItem(draftKey); } catch { /* quota */ }
+    }, 400);
+  };
+  const clearDraft = () => { try { if (draftKey) localStorage.removeItem(draftKey); } catch { /* noop */ } };
 
   useEffect(() => {
     if (mode !== 'rich') return undefined;
@@ -300,8 +539,11 @@ function Composer({ recipient, sendLabel, sending, onSend, initialText = '' }) {
         height: '160px',
         initialEditType: 'markdown',     // open in markdown mode; the built-in toggle switches to WYSIWYG
         previewStyle: 'tab',
-        initialValue: initialText || '', // seed the suggested reply (Composer remounts via key on change)
+        initialValue: seeded,            // seed from a saved draft / suggested reply (remounts via key)
         usageStatistics: false,
+        // editorRef is set only AFTER construction, so the constructor's own change (initialValue) is
+        // skipped — only real user edits auto-save the draft.
+        events: { change: () => { if (editorRef.current) saveDraft(editorRef.current.getMarkdown()); } },
         toolbarItems: [
           ['bold', 'italic', 'strike'],
           ['ul', 'ol', 'task'],
@@ -329,6 +571,7 @@ function Composer({ recipient, sendLabel, sending, onSend, initialText = '' }) {
   const reset = () => {
     try { editorRef.current?.setMarkdown(''); } catch { /* noop */ }
     setMd(''); setFiles([]); if (fileRef.current) fileRef.current.value = '';
+    clearDraft();   // a sent message is no longer a draft
   };
   const submit = () => onSend(recipient, getText(), files, reset);
 
@@ -341,7 +584,7 @@ function Composer({ recipient, sendLabel, sending, onSend, initialText = '' }) {
         ? html`<div class="inbox-editor" ref=${containerRef}></div>`
         : html`<div class="inbox-md-fallback">
             <textarea class="inbox-textarea" rows="3" placeholder=${t('inbox.bodyPlaceholder')}
-              value=${md} onInput=${(e) => setMd(e.target.value)}></textarea>
+              value=${md} onInput=${(e) => { setMd(e.target.value); saveDraft(e.target.value); }}></textarea>
             <div class="inbox-md-preview"><${Markdown} text=${md} /></div>
           </div>`}
       <div class="inbox-composer-bar">
@@ -355,6 +598,87 @@ function Composer({ recipient, sendLabel, sending, onSend, initialText = '' }) {
     </div>`;
 }
 
+/* ── Agent chat commands (Phase A) — a peer agent advertises fill-in templates via its public
+ *    `chat.commands` memory key ([{id,label,description,template,params:[{name,type,required,placeholder,
+ *    default,options}]}]). We render a chip per command; the human fills the params; the resulting prose
+ *    drops into the composer to review + send. The agent receives the filled template it advertised. ── */
+function CommandBar({ commands, onPick }) {
+  return html`<div class="inbox-cmdbar">
+    <span class="inbox-cmdbar-label">⚡ ${t('inbox.cmdTitle')}</span>
+    ${commands.map(c => html`<button class="inbox-cmd-chip" key=${c.id} title=${c.description || ''}
+      onClick=${() => onPick(c)}>${escHtml(c.label || c.id)}</button>`)}
+  </div>`;
+}
+
+function CommandFill({ command, onInsert, onCancel }) {
+  const [values, setValues] = useState({});
+  const params = Array.isArray(command.params) ? command.params : [];
+  const valOf = (p) => String(values[p.name] ?? p.default ?? '');
+  const missing = params.some(p => p.required && !valOf(p).trim());
+  return html`<div class="inbox-cmdfill">
+    <div class="inbox-cmdfill-head">⚡ ${escHtml(command.label || command.id)}
+      <button class="btn-ghost btn-sm" onClick=${onCancel} title=${t('inbox.close')}>✕</button></div>
+    ${command.description ? html`<div class="inbox-cmdfill-desc">${escHtml(command.description)}</div>` : null}
+    ${params.map(p => html`<label class="inbox-cmdfill-field" key=${p.name}>
+      <span class="inbox-cmdfill-pname">${escHtml(p.name)}${p.required ? ' *' : ''}</span>
+      ${p.type === 'select' && Array.isArray(p.options)
+        ? html`<select class="inbox-input" value=${valOf(p)}
+            onChange=${e => setValues(v => ({ ...v, [p.name]: e.target.value }))}>
+            ${p.options.map(o => html`<option key=${o} value=${o}>${escHtml(String(o))}</option>`)}</select>`
+        : html`<input class="inbox-input" type=${p.type === 'number' ? 'number' : 'text'}
+            placeholder=${p.placeholder || ''} value=${valOf(p)}
+            onInput=${e => setValues(v => ({ ...v, [p.name]: e.target.value }))} />`}
+    </label>`)}
+    <button class="btn-primary btn-sm inbox-cmdfill-go" disabled=${missing}
+      onClick=${() => onInsert(command, values)}>${t('inbox.cmdInsert')}</button>
+  </div>`;
+}
+
+/* ── Agent schedule (Phase B) — surfaces the node scheduler scoped to one of YOUR OWN agents
+ *    (GET/POST /v1/agents/:name/schedules, which always resolve under the caller's owner). List the
+ *    agent's managed jobs + create a recurring agent_task. Only shown for the human's own agents. ── */
+function SchedulePanel({ agentName, onClose, showToast }) {
+  const [jobs, setJobs] = useState(null);
+  const [title, setTitle] = useState('');
+  const [cron, setCron] = useState('0 9 * * *');
+  const [desc, setDesc] = useState('');
+  const [busy, setBusy] = useState(false);
+  const load = async () => {
+    try { const r = await schedules.listAgentSchedules(agentName); setJobs(r?.data?.managed || []); }
+    catch { setJobs([]); }
+  };
+  useEffect(() => { setJobs(null); load(); /* eslint-disable-next-line */ }, [agentName]);
+  const create = async () => {
+    if (!title.trim() || !cron.trim() || busy) return;
+    setBusy(true);
+    try {
+      await schedules.createAgentSchedule(agentName, {
+        kind: 'agent_task', cron: cron.trim(), task_title: title.trim(),
+        task_description: desc.trim(), display_name: title.trim(),
+      });
+      setTitle(''); setDesc(''); showToast?.(t('inbox.schedCreated'));
+      await load();
+    } catch (e) { showToast?.(e?.message || t('inbox.schedError'), true); }
+    finally { setBusy(false); }
+  };
+  return html`<div class="inbox-sched">
+    <div class="inbox-sched-head">📅 ${t('inbox.schedTitle')}
+      <button class="btn-ghost btn-sm" onClick=${onClose} title=${t('inbox.close')}>✕</button></div>
+    ${jobs == null ? html`<div class="inbox-empty-sm">${t('inbox.loading')}</div>`
+      : jobs.length === 0 ? html`<div class="inbox-empty-sm">${t('inbox.schedNone')}</div>`
+      : html`<ul class="inbox-sched-list">${jobs.map(j => html`<li class="inbox-sched-item" key=${j.id}>
+          <span class="inbox-sched-name">${escHtml(j.displayName || j.input?.taskTemplate?.title || j.id)}</span>
+          <span class="inbox-sched-cron">${escHtml(j.cron)}${j.enabled === false ? ' · ' + t('inbox.schedOff') : ''}</span>
+        </li>`)}</ul>`}
+    <div class="inbox-sched-new">
+      <input class="inbox-input" placeholder=${t('inbox.schedTaskPh')} value=${title} onInput=${e => setTitle(e.target.value)} />
+      <input class="inbox-input" placeholder="0 9 * * *" value=${cron} onInput=${e => setCron(e.target.value)} />
+      <textarea class="inbox-input inbox-sched-desc" placeholder=${t('inbox.schedDescPh')} value=${desc} onInput=${e => setDesc(e.target.value)}></textarea>
+      <button class="btn-primary btn-sm" disabled=${busy || !title.trim() || !cron.trim()} onClick=${create}>${t('inbox.schedCreate')}</button>
+    </div>
+  </div>`;
+}
+
 export default function InboxTab({ showToast }) {
   const [requests, setRequests] = useState([]);
   const [conversations, setConversations] = useState([]);
@@ -365,14 +689,34 @@ export default function InboxTab({ showToast }) {
   const [composeSubject, setComposeSubject] = useState(''); // optional subject → opens a new topic thread
   const [mode, setMode] = useState('idle');               // 'idle' | 'compose' | 'thread'
   const [to, setTo] = useState('');
+  const [myAgents, setMyAgents] = useState([]);           // the owner's own agents (recipient suggestions)
+  const [bcRecipients, setBcRecipients] = useState([]);   // broadcast: selected recipient ids
+  const [bcInput, setBcInput] = useState('');             // broadcast: add-recipient field
+  const [bcMode, setBcMode] = useState('broadcast');      // broadcast: 'broadcast' | 'announcement'
+  const [bcGroupId, setBcGroupId] = useState('');         // broadcast: optional Share Group audience
+  const [bcType, setBcType] = useState('message');        // broadcast content: 'message' | 'poll'
+  const [bcQuestions, setBcQuestions] = useState([]);     // poll: the questions being built
+  const [bcAudience, setBcAudience] = useState('');       // broadcast: '' | 'node-users' | 'federation-users' (operator)
+  const isOperator = (getSession()?.roles || []).includes('operator');
+  const [myGroups, setMyGroups] = useState([]);           // the owner's Share Groups (audiences)
+  const [resultsId, setResultsId] = useState(null);       // broadcast id whose results are shown
+  const [results, setResults] = useState(null);           // fetched broadcast results
+  const [recentBroadcasts, setRecentBroadcasts] = useState([]); // localStorage-tracked sent broadcasts
   const [sending, setSending] = useState(false);
   const [important, setImportant] = useState(new Set());  // message ids flagged important (Tier 1)
   const [trackedList, setTrackedList] = useState([]);     // active Tracked Responses (Tier 2)
   const [trackMsg, setTrackMsg] = useState(null);         // message being tracked (opens modal)
-  const [draftPrefill, setDraftPrefill] = useState('');   // suggested reply seeded into the composer
+  const [draftPrefill, setDraftPrefill] = useState('');   // suggested reply / filled command seeded into the composer
+  const [prefillNonce, setPrefillNonce] = useState(0);    // bump to force a composer remount on each insert
+  const [agentCommands, setAgentCommands] = useState(null); // peer agent's chat.commands (Phase A)
+  const [cmdFill, setCmdFill] = useState(null);           // a command being filled in (param form)
+  const [schedOpen, setSchedOpen] = useState(false);      // schedule panel open (own agent, Phase B)
   const [replyingTrId, setReplyingTrId] = useState(null); // contract id whose approved reply is being sent
   const [awaitingDrafts, setAwaitingDrafts] = useState({}); // tr.id → suggested reply body (for the bubble)
   const msgsRef = useRef(null);
+  // Resolved attachment URLs cached per conversation, so a refresh / new message reuses them instead of
+  // re-resolving (re-downloading) every image. { convId, map: { attachmentId → presignedUrl } }.
+  const urlCacheRef = useRef({ convId: null, map: {} });
   // Ids the user just cancelled — kept so a stale re-fetch (replica lag on a multi-node node) can't
   // re-add a row the user already dismissed until the cancel has propagated.
   const dismissedRef = useRef(new Set());
@@ -428,6 +772,15 @@ export default function InboxTab({ showToast }) {
     setTrackMsg(msg);
   };
 
+  // Clicking 📓: copy the message straight into the notebook for later processing (no AI step) — keeps the
+  // source link + reply intent so it can be replied to or enriched/filed from the notebook later.
+  const onParkMsg = async (msg) => {
+    try {
+      await parkMessageToNotebook(msg, { title: firstLine(msg.body) });
+      showToast?.(t('inbox.parkedToNotebook'));
+    } catch (e) { showToast?.(e?.message || t('inbox.trackFailed'), true); }
+  };
+
   const cancelTracked = async (tr) => {
     let resp;
     try { resp = await tracked.cancelTrackedResponse(tr.id); }
@@ -490,10 +843,16 @@ export default function InboxTab({ showToast }) {
     if (!conv) return;
     const msgs = (await messages.getConversation(conv.conversationId).catch(() => [])).slice().reverse();
     setThread(msgs);
+    // REUSE already-resolved attachment URLs for the SAME conversation: a refresh / new message must NOT
+    // re-resolve (and thus re-download via a fresh presigned URL) every existing image. Only fetch URLs
+    // for attachments we haven't resolved yet. A different conversation starts a fresh cache.
+    const sameConv = urlCacheRef.current.convId === conv.conversationId;
+    const prev = sameConv ? urlCacheRef.current.map : {};
     const map = {};
     await Promise.all(msgs.flatMap(m => (m.attachments || [])
       .filter(a => !a.inline)
       .map(async a => {
+        if (prev[a.id]) { map[a.id] = prev[a.id]; return; } // keep the stable URL → browser won't re-fetch
         // Inbound: only the recipient's duplicated local copy is fetchable (after accept). Outbound:
         // the sender owns the original storage key, so resolve that — you can view/download what you sent.
         const key = (a.mode === 'duplicate' && a.localKey) ? a.localKey
@@ -502,11 +861,74 @@ export default function InboxTab({ showToast }) {
         const u = await messages.attachmentUrl(key).catch(() => null);
         if (u) map[a.id] = u;
       })));
+    urlCacheRef.current = { convId: conv.conversationId, map };
     setUrlMap(map);
     if (markRead) await messages.markConversationRead(conv.conversationId).catch(() => {});
   }, []);
 
   useEffect(() => { loadLists(); }, [loadLists]);
+  // The owner's own agents — recipient suggestions when composing (so you don't retype long GAIIs).
+  useEffect(() => { agentsSvc.listAgents().then(a => setMyAgents(a || [])).catch(() => {}); }, []);
+
+  // Phase A: when the active thread is with an AGENT, read its public `chat.commands` so the composer can
+  // offer fill-in command chips. Absent/empty key → no chips (graceful). Reset per-thread UI on switch.
+  const activePeer = activeConv?.peerGhii;
+  useEffect(() => {
+    setAgentCommands(null); setCmdFill(null); setSchedOpen(false);
+    if (!activePeer || !isAgentPeer(activePeer)) return;
+    let cancelled = false;
+    apiGet(`/v1/memory/${encodeURIComponent(activePeer)}/${encodeURIComponent('chat.commands')}`)
+      .then(r => {
+        const val = r?.data?.value;
+        const cmds = val && Array.isArray(val.commands) ? val.commands.filter(c => c && c.id) : [];
+        if (!cancelled && cmds.length) setAgentCommands(cmds);
+      })
+      .catch(() => { /* no commands published — fine */ });
+    return () => { cancelled = true; };
+  }, [activePeer]);
+  // The owner's Share Groups — reusable broadcast audiences (distribution lists).
+  useEffect(() => { apiGet('/v1/groups').then(r => setMyGroups(r?.data?.groups || [])).catch(() => {}); }, []);
+
+  // Recent broadcasts/polls the user sent — tracked in localStorage so results stay re-accessible.
+  const BC_STORE = 'aimeat.inbox.broadcasts';
+  useEffect(() => { try { setRecentBroadcasts(JSON.parse(localStorage.getItem(BC_STORE) || '[]')); } catch { /* none */ } }, []);
+  const trackBroadcast = (entry) => setRecentBroadcasts(prev => {
+    const next = [entry, ...prev.filter(b => b.id !== entry.id)].slice(0, 30);
+    try { localStorage.setItem(BC_STORE, JSON.stringify(next)); } catch { /* quota */ }
+    return next;
+  });
+  const openResults = async (id) => {
+    setMode('results'); setResultsId(id); setResults(null); setActiveConv(null);
+    setResults(await messages.getBroadcastResults(id).catch(() => null));
+  };
+
+  // Inbox-link (mailto-style): /v1/profile?tab=messages&to=<id>[,<id>]&subject=<s> opens a prefilled
+  // compose (single recipient) or broadcast (multiple). Cleared from the URL so a refresh doesn't re-open.
+  useEffect(() => {
+    const params = new URLSearchParams(window.location.search);
+    const toParam = (params.get('to') || '').trim();
+    if (!toParam) return;
+    const recips = toParam.split(',').map(s => s.trim()).filter(Boolean);
+    const subject = params.get('subject') || '';
+    if (recips.length > 1) {
+      setMode('broadcast'); setActiveConv(null); setBcRecipients(recips); setBcMode('broadcast'); setBcType('message'); setBcGroupId('');
+    } else {
+      setMode('compose'); setActiveConv(null); setTo(recips[0]); setComposeSubject(subject);
+    }
+    try { window.history.replaceState({}, '', '/v1/profile?tab=messages'); } catch { /* noop */ }
+  }, []);
+
+  // Recipient suggestions for a new message: your own agents (GAIIs) + everyone you've a thread with.
+  const contactOptions = (() => {
+    const map = new Map();
+    for (const a of myAgents) {
+      if (a?.gaii) map.set(a.gaii, `${a.name || a.gaii} ${t('inbox.contactAgentSuffix')}`);
+    }
+    for (const c of conversations) {
+      if (c?.peerGhii && !map.has(c.peerGhii)) map.set(c.peerGhii, peerName(c.peerGhii));
+    }
+    return [...map.entries()].map(([id, label]) => ({ id, label }));
+  })();
 
   const liveRef = useRef(null);
   liveRef.current = () => { loadLists(); if (activeConv) loadThread(activeConv); };
@@ -550,6 +972,64 @@ export default function InboxTab({ showToast }) {
     loadLists();
   };
   const startCompose = () => { setMode('compose'); setActiveConv(null); setTo(''); setComposeSubject(''); };
+  const startBroadcast = () => { setMode('broadcast'); setActiveConv(null); setBcRecipients([]); setBcInput(''); setBcMode('broadcast'); setBcGroupId(''); setBcType('message'); setBcQuestions([]); setBcAudience(''); };
+  const addBcRecipient = (id) => {
+    const v = (id ?? bcInput).trim();
+    if (v && !bcRecipients.includes(v)) setBcRecipients([...bcRecipients, v]);
+    setBcInput('');
+  };
+  const removeBcRecipient = (id) => setBcRecipients(bcRecipients.filter(r => r !== id));
+
+  // Send one message to many: explicit recipients and/or a Share Group audience. doBroadcast is the
+  // Composer's onSend for the broadcast panel.
+  const doBroadcast = async (_recipient, text, files, reset) => {
+    if (sending) return;
+    const body = (text || '').trim();
+    if (bcRecipients.length === 0 && !bcGroupId && !bcAudience) { showToast?.(t('inbox.bcNoRecipients'), true); return; }
+
+    let interactive;
+    if (bcType === 'poll') {
+      const questions = bcQuestions
+        .map(q => ({ ...q, options: (q.options || []).filter(o => o.label.trim()) }))
+        .filter(q => q.prompt.trim() && q.options.length >= 1)
+        .map(q => ({
+          id: q.id, header: (q.header || q.prompt).slice(0, 80), prompt: q.prompt.trim(),
+          options: q.options.map(o => ({ id: o.id, label: o.label.trim() })),
+          multiSelect: !!q.multiSelect, allowOther: q.allowOther !== false, required: !!q.required,
+        }));
+      if (!questions.length) { showToast?.(t('inbox.pollNeedQuestion'), true); return; }
+      interactive = { role: 'questions', v: 1, questions };
+    } else if (!body && files.length === 0) { return; }
+
+    setSending(true);
+    try {
+      const attachments = [];
+      for (let i = 0; i < files.length; i++) {
+        const desc = await messages.uploadAttachment(files[i]);
+        attachments.push({ ...desc, inline: false, id: `at${i}` });
+      }
+      const resp = await messages.sendBroadcast({
+        to: bcRecipients, groupId: bcGroupId || undefined, audience: bcAudience || undefined,
+        mode: bcType === 'poll' ? 'broadcast' : bcMode,   // a poll must be repliable (recipients answer)
+        body, attachments, interactive,
+      });
+      if (resp?.ok === false) { showToast?.(resp?.error?.message || t('inbox.failed'), true); }
+      else {
+        reset?.();
+        const id = resp?.data?.broadcast_id;
+        const titleSrc = (bcType === 'poll' ? (interactive.questions[0]?.prompt || '') : body) || '';
+        if (id) trackBroadcast({
+          id, type: bcType,
+          title: titleSrc.slice(0, 60) || t('inbox.broadcast'),
+          createdAt: new Date().toISOString(),
+        });
+        showToast?.(`${t('inbox.bcSent')} (${resp?.data?.sent ?? 0})`);
+        loadLists();
+        if (id) openResults(id); else setMode('idle');
+      }
+    } catch { showToast?.(t('inbox.failed'), true); }
+    setSending(false);
+  };
 
   // Open the conversation for a tracked response, then (for awaiting-approval) seed the suggested reply.
   const openTracked = async (tr) => {
@@ -589,6 +1069,35 @@ export default function InboxTab({ showToast }) {
     if (activeConv?.peerGhii === contactId) { setActiveConv(null); setThread([]); setMode('idle'); }
   };
 
+  // Submit answers to an interactive question: send a normal reply (so it threads + reads naturally on
+  // any peer) carrying both a human-readable summary body AND the machine-readable answers payload.
+  const submitInteractiveAnswers = async (questionMsg, answers) => {
+    if (sending || !activeConv) return;
+    setSending(true);
+    try {
+      const resp = await messages.send({
+        to: activeConv.peerGhii, replyTo: questionMsg.id, conversationId: activeConv.conversationId,
+        body: buildAnswerSummary(questionMsg.interactive, answers),
+        interactive: { role: 'answers', v: 1, answersFor: questionMsg.id, answers },
+      });
+      if (resp?.ok === false) showToast?.(resp?.error?.message || t('inbox.failed'), true);
+      else { await loadThread(activeConv); loadLists(); }
+    } catch { showToast?.(t('inbox.failed'), true); }
+    setSending(false);
+  };
+
+  // Phase A: substitute a command's {{param}} placeholders and drop the resulting prose into the
+  // composer (the human reviews + sends it). Bump the nonce so the composer remounts on every insert.
+  const insertCommand = (cmd, values) => {
+    let text = cmd.template || '';
+    for (const p of (Array.isArray(cmd.params) ? cmd.params : [])) {
+      const raw = values[p.name];
+      const v = (raw == null || raw === '') ? (p.default ?? '') : raw;
+      text = text.split(`{{${p.name}}}`).join(String(v));
+    }
+    setCmdFill(null); setDraftPrefill(text); setPrefillNonce(n => n + 1);
+  };
+
   const doSend = async (recipient, text, files, reset) => {
     if (sending) return;
     const body = (text || '').trim();
@@ -600,9 +1109,12 @@ export default function InboxTab({ showToast }) {
         const desc = await messages.uploadAttachment(files[i]);
         attachments.push({ ...desc, inline: false, id: `at${i}` });
       }
-      // A subject (compose mode only) opens a new topic thread; replies stay in the active thread.
+      // A subject (compose mode only) opens a new topic thread. When REPLYING in an open thread, pin the
+      // send to that exact conversationId — without it the server derives the default per-pair thread, so
+      // a reply to a subject thread (e.g. "keskustelu") spawned a brand-new thread named after the agent.
       const subject = (mode === 'compose' && composeSubject.trim()) ? composeSubject.trim() : undefined;
-      const resp = await messages.send({ to: recipient, body, attachments, subject });
+      const conversationId = (mode === 'thread' && activeConv) ? activeConv.conversationId : undefined;
+      const resp = await messages.send({ to: recipient, body, attachments, subject, conversationId });
       if (resp?.ok === false) { showToast?.(resp?.error?.message || t('inbox.failed'), true); }
       else {
         reset?.();
@@ -675,7 +1187,7 @@ export default function InboxTab({ showToast }) {
         ${nested ? html`<span class="inbox-conv-subico">${icon}</span>` : html`<${Avatar} seed=${c.peerGhii} size=${40} />`}
         <div class="inbox-conv-main">
           <div class="inbox-conv-line1">
-            <span class="inbox-name">${escHtml(label)} ${nested ? '' : html`<${PresenceDot} ghii=${c.peerGhii} />`}</span>
+            <span class="inbox-name">${escHtml(label)} ${(!nested || c.peerGhii?.includes('#')) ? html`<${PresenceDot} ghii=${c.peerGhii} />` : ''}</span>
             <span class="inbox-conv-time">${c.updatedAt ? timeShort(c.updatedAt) : ''}</span>
           </div>
           <div class="inbox-conv-line2">
@@ -689,6 +1201,19 @@ export default function InboxTab({ showToast }) {
 
   const renderThread = () => {
     let lastDay = '';
+    // Map each interactive QUESTION message id → the answers reply that fulfils it, so an answered
+    // question renders its read-only summary instead of the (already-used) form.
+    const answersByQ = {};
+    for (const m of thread) {
+      if (m.interactive?.role === 'answers' && m.interactive.answersFor) answersByQ[m.interactive.answersFor] = m.interactive;
+    }
+    // An announcement (a non-respondable broadcast) is read-only for the recipient — hide the composer.
+    const isAnnouncement = thread.some(m => m.direction === 'inbound' && m.respondable === false);
+    // Agent capabilities in chat: command chips for any agent peer (public chat.commands); the schedule
+    // panel only for the human's OWN agents (the scheduler routes resolve under the caller's owner).
+    const peerIsAgent = isAgentPeer(activeConv.peerGhii);
+    const peerAgentName = peerIsAgent ? subThreadLabel(activeConv.peerGhii) : null;
+    const peerIsMyAgent = peerIsAgent && ownerDisplayName(ownerKeyOf(activeConv.peerGhii)) === getSession()?.owner;
     return html`
       <div class="inbox-panel">
         <div class="inbox-thread-head">
@@ -698,6 +1223,8 @@ export default function InboxTab({ showToast }) {
             ${activeConv.subject ? html`<div class="inbox-thread-subject">🏷 ${escHtml(activeConv.subject)}</div>` : null}
             <div class="inbox-sub">${escHtml(activeConv.peerGhii)}</div>
           </div>
+          ${peerIsMyAgent ? html`<button class=${`btn-ghost btn-sm inbox-sched-btn${schedOpen ? ' inbox-sched-btn--on' : ''}`}
+            onClick=${() => setSchedOpen(o => !o)} title=${t('inbox.schedTitle')}>📅</button>` : null}
         </div>
         <div class="inbox-msgs" ref=${msgsRef}>
           ${thread.length === 0 ? html`<div class="inbox-empty-sm">${t('inbox.noThread')}</div>` : null}
@@ -707,7 +1234,9 @@ export default function InboxTab({ showToast }) {
             return html`
               ${showDay ? html`<div class="inbox-day" key=${'d' + m.id}><span>${dayLabel(m.createdAt)}</span></div>` : null}
               <${MessageBubble} key=${m.id + m.direction} msg=${m} mine=${m.direction === 'outbound'} urlMap=${urlMap}
-                starred=${important.has(m.id)} onStar=${toggleImportant} onTrack=${onTrackMsg} tracked=${trackedByMsg[m.id]}
+                starred=${important.has(m.id)} onStar=${toggleImportant} onTrack=${onTrackMsg} onPark=${onParkMsg} tracked=${trackedByMsg[m.id]}
+                answeredWith=${m.interactive?.role === 'questions' ? answersByQ[m.id] : null}
+                onAnswer=${submitInteractiveAnswers} submitting=${sending}
                 onOpenMarkdown=${(url, name) => setMdViewer({ url, name })} />`;
           })}
         </div>
@@ -723,8 +1252,18 @@ export default function InboxTab({ showToast }) {
               </div>
             </div>
           </div>`)}
-        <${Composer} key=${'c-' + activeConv.conversationId + (draftPrefill ? '-d' : '')} recipient=${activeConv.peerGhii}
-          sendLabel=${t('inbox.reply')} sending=${sending} onSend=${doSend} initialText=${draftPrefill} />
+        ${peerIsMyAgent && schedOpen
+          ? html`<${SchedulePanel} agentName=${peerAgentName} showToast=${showToast} onClose=${() => setSchedOpen(false)} />` : null}
+        ${!isAnnouncement && cmdFill
+          ? html`<${CommandFill} command=${cmdFill} onInsert=${insertCommand} onCancel=${() => setCmdFill(null)} />`
+          : (!isAnnouncement && agentCommands
+            ? html`<${CommandBar} commands=${agentCommands} onPick=${(c) =>
+                (Array.isArray(c.params) && c.params.length) ? setCmdFill(c) : insertCommand(c, {})} />` : null)}
+        ${isAnnouncement
+          ? html`<div class="inbox-announce-note">📢 ${t('inbox.announcementNote')}</div>`
+          : html`<${Composer} key=${'c-' + activeConv.conversationId + (draftPrefill ? '-d' + prefillNonce : '')} recipient=${activeConv.peerGhii}
+              sendLabel=${t('inbox.reply')} sending=${sending} onSend=${doSend} initialText=${draftPrefill}
+              draftKey=${'aimeat.inbox.draft.' + activeConv.conversationId} />`}
       </div>`;
   };
 
@@ -772,6 +1311,59 @@ export default function InboxTab({ showToast }) {
       </div>
     </div>`;
 
+  // Broadcast/poll results: a list of recent broadcasts, or the tallies for the selected one.
+  const renderResults = () => {
+    if (!resultsId) {
+      return html`<div class="inbox-panel">
+        <div class="inbox-thread-head"><div class="inbox-name">📊 ${t('inbox.resultsTitle')}</div></div>
+        <div class="inbox-tracked-list">
+          ${recentBroadcasts.length === 0 ? html`<div class="inbox-empty-sm">${t('inbox.resultsEmpty')}</div>` : null}
+          ${recentBroadcasts.map(b => html`
+            <button class="inbox-conv" key=${b.id} onClick=${() => openResults(b.id)}>
+              <div class="inbox-conv-main">
+                <div class="inbox-conv-line1">
+                  <span class="inbox-name">${b.type === 'poll' ? '📊' : '📨'} ${escHtml(b.title)}</span>
+                  <span class="inbox-conv-time">${b.createdAt ? timeShort(b.createdAt) : ''}</span>
+                </div>
+              </div>
+            </button>`)}
+        </div>
+      </div>`;
+    }
+    const r = results;
+    const isPoll = r?.interactive?.role === 'questions';
+    const tallies = isPoll ? tallyPoll(r.interactive, r.recipients || []) : [];
+    return html`<div class="inbox-panel">
+      <div class="inbox-thread-head">
+        <button class="btn-ghost btn-sm" onClick=${() => { setResultsId(null); setResults(null); }}>←</button>
+        <div class="inbox-name">📊 ${t('inbox.resultsTitle')}</div>
+      </div>
+      <div class="inbox-msgs">
+        ${!r ? html`<div class="inbox-empty-sm">…</div>` : html`
+          <div class="inbox-results-summary">
+            ${t('inbox.resultsRecipients')}: ${r.total} · ${t('inbox.resultsDelivered')}: ${r.delivered} · ${t('inbox.resultsRead')}: ${r.read}${isPoll ? ` · ${t('inbox.resultsAnswered')}: ${r.answered}` : ''}
+          </div>
+          ${tallies.map(({ q, counts, others }) => html`
+            <div class="inbox-results-q" key=${q.id}>
+              <div class="inbox-results-prompt">${escHtml(q.prompt)}</div>
+              ${(q.options || []).map(o => {
+                const n = counts[o.id] || 0;
+                const pct = r.answered ? Math.round((n / r.answered) * 100) : 0;
+                return html`<div class="inbox-results-bar" key=${o.id}>
+                  <div class="inbox-results-bar-label"><span>${escHtml(o.label)}</span><span>${n}</span></div>
+                  <div class="inbox-results-bar-track"><div class="inbox-results-bar-fill" style=${`--w:${pct}%`}></div></div>
+                </div>`;
+              })}
+              ${others.length ? html`<div class="inbox-results-others">${t('inbox.answer.other')}: ${others.map(o => escHtml(o)).join(', ')}</div>` : null}
+            </div>`)}
+          ${!isPoll ? html`<div class="inbox-results-reclist">
+            ${(r.recipients || []).map(rec => html`<div class="inbox-results-rec" key=${rec.recipient}><span>${escHtml(peerName(rec.recipient))}</span><span>${rec.status}</span></div>`)}
+          </div>` : null}
+        `}
+      </div>
+    </div>`;
+  };
+
   return html`
     <div class="inbox">
       <div class="inbox-head">
@@ -784,9 +1376,14 @@ export default function InboxTab({ showToast }) {
             title=${awaitingCount ? t('inbox.trackReady') : ''}>
             🔗 ${t('inbox.trackedTitle')}${activeTracked.length ? html` <span class="inbox-count">${activeTracked.length}</span>` : ''}
           </button>
+          ${recentBroadcasts.length ? html`<button class=${`btn-outline${mode === 'results' ? ' btn-outline--active' : ''}`} onClick=${() => { setMode('results'); setResultsId(null); setActiveConv(null); }}>📊 ${t('inbox.results')}</button>` : null}
+          <button class=${`btn-outline${mode === 'broadcast' ? ' btn-outline--active' : ''}`} onClick=${startBroadcast}>📢 ${t('inbox.broadcast')}</button>
           <button class="btn-primary" onClick=${startCompose}>✉️ ${t('inbox.new')}</button>
         </div>
       </div>
+      <datalist id="inbox-contact-suggest">
+        ${contactOptions.map(c => html`<option value=${c.id} key=${c.id}>${c.label}</option>`)}
+      </datalist>
 
       <div class="inbox-body">
         ${renderList()}
@@ -796,14 +1393,64 @@ export default function InboxTab({ showToast }) {
             <div class="inbox-thread-head"><div class="inbox-name">${t('inbox.new')}</div></div>
             <div class="inbox-compose-fields">
               <input class="inbox-input" type="text" placeholder=${t('inbox.toPlaceholder')}
-                value=${to} onInput=${(e) => setTo(e.target.value)} />
+                list="inbox-contact-suggest" value=${to} onInput=${(e) => setTo(e.target.value)} />
               <input class="inbox-input" type="text" placeholder=${t('inbox.subjectPlaceholder')}
                 value=${composeSubject} onInput=${(e) => setComposeSubject(e.target.value)} />
             </div>
             <${Composer} key="c-new" recipient=${to.trim()} sendLabel=${t('inbox.send')}
-              sending=${sending} onSend=${doSend} />
+              sending=${sending} onSend=${doSend} draftKey="aimeat.inbox.draft.new" />
           </div>` : null}
 
+        ${mode === 'broadcast' ? html`
+          <div class="inbox-panel">
+            <div class="inbox-thread-head"><div class="inbox-name">📢 ${t('inbox.broadcastTitle')}</div></div>
+            <div class="inbox-compose-fields">
+              <div class="inbox-bc-mode">
+                <label class=${`inbox-bc-modeopt${bcType === 'message' ? ' inbox-bc-modeopt--on' : ''}`}>
+                  <input type="radio" name="bctype" checked=${bcType === 'message'} onChange=${() => setBcType('message')} />
+                  <span>📨 ${t('inbox.bcTypeMessage')}</span>
+                </label>
+                <label class=${`inbox-bc-modeopt${bcType === 'poll' ? ' inbox-bc-modeopt--on' : ''}`}>
+                  <input type="radio" name="bctype" checked=${bcType === 'poll'} onChange=${() => setBcType('poll')} />
+                  <span>📊 ${t('inbox.bcTypePoll')}</span>
+                </label>
+              </div>
+              ${bcType === 'message' ? html`<div class="inbox-bc-mode">
+                <label class=${`inbox-bc-modeopt${bcMode === 'broadcast' ? ' inbox-bc-modeopt--on' : ''}`}>
+                  <input type="radio" name="bcmode" checked=${bcMode === 'broadcast'} onChange=${() => setBcMode('broadcast')} />
+                  <span>${t('inbox.bcModeBroadcast')}</span>
+                </label>
+                <label class=${`inbox-bc-modeopt${bcMode === 'announcement' ? ' inbox-bc-modeopt--on' : ''}`}>
+                  <input type="radio" name="bcmode" checked=${bcMode === 'announcement'} onChange=${() => setBcMode('announcement')} />
+                  <span>${t('inbox.bcModeAnnouncement')}</span>
+                </label>
+              </div>` : html`<${PollBuilder} questions=${bcQuestions} setQuestions=${setBcQuestions} />`}
+              ${bcRecipients.length ? html`<div class="inbox-bc-chips">
+                ${bcRecipients.map(r => html`<span class="inbox-bc-chip" key=${r}>${escHtml(peerName(r))}
+                  <button class="inbox-bc-chip-x" title=${t('inbox.bcRemove')} onClick=${() => removeBcRecipient(r)}>✕</button></span>`)}
+              </div>` : null}
+              <div class="inbox-bc-add">
+                <input class="inbox-input" type="text" list="inbox-contact-suggest" placeholder=${t('inbox.bcAddPlaceholder')}
+                  value=${bcInput} onInput=${(e) => setBcInput(e.target.value)}
+                  onKeyDown=${(e) => { if (e.key === 'Enter') { e.preventDefault(); addBcRecipient(); } }} />
+                <button class="btn-outline btn-sm" onClick=${() => addBcRecipient()}>${t('inbox.bcAdd')}</button>
+              </div>
+              ${myGroups.length ? html`<select class="inbox-input" value=${bcGroupId} onChange=${(e) => setBcGroupId(e.target.value)}>
+                <option value="">${t('inbox.bcNoGroup')}</option>
+                ${myGroups.map(g => html`<option value=${g.id} key=${g.id}>${escHtml(g.name)} (${(g.members || []).length})</option>`)}
+              </select>` : null}
+              ${isOperator ? html`<select class=${`inbox-input${bcAudience ? ' inbox-bc-audience--on' : ''}`} value=${bcAudience} onChange=${(e) => setBcAudience(e.target.value)}>
+                <option value="">${t('inbox.bcNoAudience')}</option>
+                <option value="node-users">📣 ${t('inbox.bcNodeUsers')}</option>
+                <option value="federation-users">🌐 ${t('inbox.bcFederationUsers')}</option>
+              </select>` : null}
+            </div>
+            <${Composer} key="c-bc" recipient=${(bcRecipients.length || bcGroupId || bcAudience) ? 'bc' : ''}
+              sendLabel=${bcType === 'poll' ? t('inbox.pollSend') : t('inbox.bcSend')} sending=${sending} onSend=${doBroadcast} />
+          </div>` : null}
+
+        ${mode === 'results' ? renderResults() : null}
+
         ${mode === 'thread' && activeConv ? renderThread() : null}
 
         ${mode === 'tracked' ? renderTrackedList() : null}