aimeat 2.5.0 → 2.6.0

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

@@ -6,6 +6,11 @@
  *   chat.commands), SchedulePanel (own-agent scheduler), and ReplyWithAiPopover (TARGET-031). Each is
  *   self-contained (owns its own hooks). Extracted from inbox-tab.js to satisfy max-file-lines.
  * @version-history
+ *   v1.11.0 — 2026-08-01 — Voice messages. AttachmentItem hands an audio attachment to AudioAttachment
+ *     (./voice-parts.js) so it plays in the bubble instead of opening in a browser tab, which is a
+ *     download and not a conversation. The Composer gains a 🎤 recorder feeding the SAME attachment
+ *     queue as 📎 (one upload path), and a recording's chip carries a player + its length so a bad
+ *     take is caught here rather than in the other person's mailbox.
  *   v1.10.0 — 2026-07-31 — MessageBubble gets a 🔊 read-aloud action (BubbleSpeakButton from
  *     ./read-aloud.js): speaks that one message via the Web Speech API, like the Sanomat app's per-article
  *     "Puhu". Hidden when the browser can't speak or the message has no speakable body.
@@ -51,6 +56,8 @@ import * as schedules from '/js/services/schedules.js';
 import { MODES } from '/js/services/messages-ai-prompts.js';
 import { loadToastUI, prepareBody, quoteSnippet, statusTick, timeShort, trackStateLabel, ATTACH_ICO, attachKind, IFORM_OTHER } from './helpers.js';
 import { BubbleSpeakButton } from './read-aloud.js';
+import { AudioAttachment, fmtClock, stopOtherAudio } from './voice-parts.js';
+import { VoiceRecorder } from '/components/VoiceRecorder.js';
 import { swallowed } from '/js/swallowed.js';
 
 export function Avatar({ seed, size = 36 }) {
@@ -59,10 +66,12 @@ export function Avatar({ seed, size = 36 }) {
     dangerouslySetInnerHTML=${{ __html: svg }}></span>`;
 }
 
+
 /** One received/sent attachment. Images render as a thumbnail (click → full-size in a new tab);
- *  PDF/audio/video/file open natively in a new tab; markdown opens the in-app rendered viewer. Every
- *  ready attachment gets a download button. Not-yet-duplicated / expired attachments show their state. */
-export function AttachmentItem({ a, url, onOpenMarkdown }) {
+ *  audio plays in place; PDF/video/file open natively in a new tab; markdown opens the in-app
+ *  rendered viewer. Every ready attachment gets a download button. Not-yet-duplicated / expired
+ *  attachments show their state. */
+export function AttachmentItem({ a, url, onOpenMarkdown, msgId, onTranscribe, canTranscribe }) {
   const kind = attachKind(a);
   const name = a.name || a.storageKey;
   const ready = !!url && !a.expired;
@@ -93,7 +102,11 @@ export function AttachmentItem({ a, url, onOpenMarkdown }) {
       </button>${download}
     </div>`;
   }
-  // pdf / audio / video / file — let the browser open it in a new tab.
+  if (kind === 'audio') {
+    return html`<${AudioAttachment} a=${a} url=${url} name=${name} download=${download}
+      msgId=${msgId} onTranscribe=${onTranscribe} canTranscribe=${canTranscribe} />`;
+  }
+  // pdf / video / file — let the browser open it in a new tab.
   return html`<div class="inbox-attach-chip">
     <a class="inbox-attach-open" href=${url} target="_blank" rel="noopener" title=${t('inbox.attachmentOpen')}>
       <span class="inbox-attach-ico">${ATTACH_ICO[kind]}</span><span class="inbox-attach-name">${escHtml(name)}</span>
@@ -261,7 +274,7 @@ export function PollBuilder({ questions, setQuestions }) {
     </div>`;
 }
 
-export function MessageBubble({ msg, mine, urlMap, starred, onStar, onTrack, onPark, onReplyAi, onQuote, quoted, quotedName, onJumpTo, domId, tracked, onOpenMarkdown, answeredWith, onAnswer, submitting, showLinkPreviews }) {
+export function MessageBubble({ msg, mine, urlMap, starred, onStar, onTrack, onPark, onReplyAi, onQuote, quoted, quotedName, onJumpTo, domId, tracked, onOpenMarkdown, answeredWith, onAnswer, submitting, showLinkPreviews, onTranscribe, canTranscribe }) {
   // Copy the message text to the clipboard (the raw markdown the sender wrote — that's what pastes
   // usefully into an AI chat or a document; the rendered body's presigned image URLs are transient).
   const [copied, setCopied] = useState(false);
@@ -319,7 +332,9 @@ export function MessageBubble({ msg, mine, urlMap, starred, onStar, onTrack, onP
         ) : null}
         ${nonInline.length > 0 && html`
           <div class="inbox-attach-row">
-            ${nonInline.map(a => html`<${AttachmentItem} key=${a.id} a=${a} url=${urls[a.id]} onOpenMarkdown=${onOpenMarkdown} />`)}
+            ${nonInline.map(a => html`<${AttachmentItem} key=${a.id} a=${a} url=${urls[a.id]}
+              onOpenMarkdown=${onOpenMarkdown} msgId=${msg.id}
+              onTranscribe=${onTranscribe} canTranscribe=${canTranscribe} />`)}
           </div>`}
         <div class="inbox-bubble-meta">
           ${trk ? html`<span class=${`inbox-track-badge inbox-track-badge--${trk.tone}`} title=${t('inbox.trackResponse')}>🔗 ${trk.text}</span>` : null}
@@ -334,7 +349,10 @@ export function MessageBubble({ msg, mine, urlMap, starred, onStar, onTrack, onP
  * 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. */
-export function Composer({ recipient, sendLabel, sending, onSend, initialText = '', draftKey = '', focusNonce = 0 }) {
+export function Composer({
+  recipient, sendLabel, sending, onSend, initialText = '', draftKey = '', focusNonce = 0,
+  voiceMaxSeconds = 300,
+}) {
   // Restore an in-progress draft for this conversation/compose (localStorage), or the passed initialText.
   const readDraft = () => { try { return draftKey ? (localStorage.getItem(draftKey) || '') : ''; } catch { return ''; } };   // eslint-disable-line aimeat/no-silent-catch -- a browser API refusing here IS the answer
   const seeded = initialText || readDraft();   // an explicit suggested reply wins; else restore a draft
@@ -379,6 +397,21 @@ export function Composer({ recipient, sendLabel, sending, onSend, initialText =
     const file = (blob instanceof File && !generic) ? blob : new File([blob], name, { type: blob.type || 'image/png' });
     setFiles((prev) => [...prev, file]);
   };
+  // A finished recording joins the same attachment queue as a picked file, so it travels the one
+  // upload path (presigned PUT) everything else uses. The measured length rides ON the File: the
+  // send path reads it back as `duration_seconds`, which lets the recipient's thread show "0:14"
+  // before a single byte of audio has been fetched.
+  const addRecording = (file, durationSeconds) => {
+    file.durationSeconds = durationSeconds;
+    // Minted ONCE here, not in render: createObjectURL in a render body allocates a new blob URL on
+    // every re-render and never releases the old ones.
+    file.previewUrl = URL.createObjectURL(file);
+    setFiles((prev) => [...prev, file]);
+  };
+  const releasePreview = (file) => {
+    if (file?.previewUrl) { URL.revokeObjectURL(file.previewUrl); file.previewUrl = null; }
+  };
+
   // Pull image files out of a clipboard/drop event; returns true if any were handled (caller preventDefaults).
   const handleImagePaste = (e) => {
     const items = Array.from(e.clipboardData?.items || e.dataTransfer?.items || []);
@@ -479,7 +512,9 @@ export function Composer({ recipient, sendLabel, sending, onSend, initialText =
   const getText = () => (mode === 'rich' && editorRef.current) ? editorRef.current.getMarkdown() : md;
   const reset = () => {
     try { editorRef.current?.setMarkdown(''); } catch (err) { swallowed('components: reset', err); }
-    setMd(''); setFiles([]); if (fileRef.current) fileRef.current.value = '';
+    setMd('');
+    setFiles((prev) => { prev.forEach(releasePreview); return []; });
+    if (fileRef.current) fileRef.current.value = '';
     if (mode === 'simple' && taRef.current) taRef.current.style.height = 'auto';
     clearDraft();   // a sent message is no longer a draft
   };
@@ -487,6 +522,7 @@ export function Composer({ recipient, sendLabel, sending, onSend, initialText =
   // Remove one queued attachment before sending (a mis-paste shouldn't force starting the message over).
   // Also clear the hidden file input when the last chip goes, so re-picking the same file fires onChange.
   const removeFile = (idx) => setFiles((prev) => {
+    releasePreview(prev[idx]);
     const next = prev.filter((_, j) => j !== idx);
     if (next.length === 0 && fileRef.current) fileRef.current.value = '';
     return next;
@@ -495,8 +531,20 @@ export function Composer({ recipient, sendLabel, sending, onSend, initialText =
   return html`
     <div class="inbox-composer ${expanded ? 'inbox-composer--tall' : ''}">
       ${files.length > 0 ? html`<div class="inbox-file-chips">
-        ${files.map((f, i) => html`<span class="inbox-file-chip" key=${f.name + i}>📎 ${escHtml(f.name)}
-          <button class="inbox-bc-chip-x" title=${t('inbox.attachmentRemove')} onClick=${() => removeFile(i)}>✕</button></span>`)}
+        ${files.map((f, i) => {
+          // A recording gets its own chip with a player: a bad take should be caught here, not in
+          // the other person's mailbox.
+          const isVoice = (f.type || '').startsWith('audio/') && f.durationSeconds;
+          return html`<span class=${`inbox-file-chip${isVoice ? ' inbox-file-chip--voice' : ''}`} key=${f.name + i}>
+            ${isVoice
+              ? html`<span class="inbox-chip-voice">🎤 ${fmtClock(f.durationSeconds)}
+                  <audio class="inbox-audio inbox-audio--chip" controls preload="metadata"
+                         src=${f.previewUrl}
+                         onPlay=${(e) => stopOtherAudio(e.currentTarget)}></audio></span>`
+              : html`<span>📎 ${escHtml(f.name)}</span>`}
+            <button class="inbox-bc-chip-x" title=${t('inbox.attachmentRemove')} onClick=${() => removeFile(i)}>✕</button>
+          </span>`;
+        })}
       </div>` : null}
       ${mode === 'rich'
         ? html`<div class="inbox-editor" ref=${containerRef}></div>`
@@ -515,6 +563,8 @@ export function Composer({ recipient, sendLabel, sending, onSend, initialText =
           <label class="inbox-attach-btn" title=${t('inbox.attach')}>
             📎<input ref=${fileRef} type="file" multiple hidden onChange=${(e) => setFiles(Array.from(e.target.files || []))} />
           </label>
+          <${VoiceRecorder} maxSeconds=${voiceMaxSeconds} className="inbox-attach-btn"
+            onRecorded=${addRecording} />
           <button type="button" class="inbox-attach-btn" title=${expanded ? t('inbox.collapse') : t('inbox.expand')}
             aria-pressed=${expanded} onClick=${() => setExpanded((v) => !v)}>${expanded ? '⤡' : '⤢'}</button>
         </div>

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

@@ -5,6 +5,9 @@
  *   pixel defense), tracked-state labels, attachment classification, the interactive-answer summary +
  *   poll tally, and the lazy Toast UI editor loader. Extracted from inbox-tab.js to satisfy max-file-lines.
  * @version-history
+ *   v1.4.0 — 2026-08-01 — parkMessage() + openTrackedRecord() moved here from inbox-tab.js: two
+ *     self-contained actions that needed nothing from the tab's state beyond a toast, pulled out to
+ *     keep the tab under max-file-lines while voice messages were added to it.
  *   v1.3.0 — 2026-07-27 — sendFailure(): pick the toast text for a failed send, preferring the thrown
  *     reason (attachment too large, out of quota) over the generic "could not send".
  *   v1.2.0 — 2026-07-21 — resolveThreadAttachmentUrls(): resolve non-inline attachment URLs for a loaded
@@ -14,6 +17,36 @@
  */
 import { t, getLocale } from '/js/i18n.js';
 import { swallowed } from '/js/swallowed.js';
+import { parkMessageToNotebook } from '/js/services/notebook.js';
+import { firstLine } from '../notebook-helpers.js';
+
+/** 📓 on a message: copy it straight into the notebook for later processing (no AI step), keeping the
+ *  source link + reply intent so it can be replied to or filed from there. */
+export async function parkMessage(msg, showToast) {
+  try {
+    await parkMessageToNotebook(msg, { title: firstLine(msg.body) });
+    showToast?.(t('inbox.parkedToNotebook'));
+  } catch (e) {
+    showToast?.(e?.message || t('inbox.trackFailed'), true);
+  }
+}
+
+/** Open the workspace record a tracked response watches. Sets BOTH the saved tab (so the profile
+ *  loads onto Organisms) and the workspace deep-link (so that exact workspace opens), then navigates. */
+export function openTrackedRecord(tr, showToast) {
+  const r = tr.references || {};
+  if (!r.organismId || !r.workspaceId) { showToast?.(t('inbox.trackNoRecord'), true); return; }
+  try {
+    sessionStorage.setItem('aimeat-profile-tab', 'organisms');
+    sessionStorage.setItem('aimeat.ws.openId', r.organismId);
+    sessionStorage.setItem('aimeat.ws.openWs', r.workspaceId);
+  } catch (err) {
+    // Storage refused (private mode, quota): the navigation below still happens, it just lands on
+    // the Organisms tab without pre-opening the workspace.
+    swallowed('inbox helpers: openTrackedRecord deep-link', err);
+  }
+  window.location.assign('/v1/profile?tab=organisms');
+}
 
 /**
  * Toast text for a failed send. An attachment upload throws for reasons the sender can act on: the file

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

@@ -6,6 +6,9 @@
  *   (broadcast/poll results). Each is a presentational component driven entirely by props from InboxTab;
  *   the stateful container keeps all hooks. Extracted from inbox-tab.js to satisfy max-file-lines.
  * @version-history
+ *   v1.6.0 — 2026-08-01 — Voice messages threaded through: ThreadPanel passes onTranscribe /
+ *     canTranscribe to each bubble and voiceMaxSeconds to the Composer. An agent-owned ("via
+ *     <agent>") thread is read-only for the owner, so it gets no transcribe action.
  *   v1.5.0 — 2026-07-31 — ThreadPanel head hosts ThreadReadAloud (./read-aloud.js): reads the whole open
  *     conversation aloud (Listen / Pause / Continue + ✕), the thread-level twin of the per-bubble 🔊.
  *   v1.4.0 — 2026-07-21 — ThreadPanel head: "Show all messages / Last 50" toggle (threadAll/
@@ -109,7 +112,7 @@ export function ThreadPanel({
   peerDisplay, showToast, toggleImportant, onTrackMsg, onParkMsg, openMessageAi, submitInteractiveAnswers,
   setMdViewer, openConversationAi, openConversationNotebook, insertCommand, setCmdFill, cancelTracked, openRecord, startSuggestedReply, doSend,
   replyQuote, setReplyQuote, onQuoteReply, composerFocus, showLinkPreviews, toggleLinkPreviews,
-  threadAll, toggleThreadAll,
+  threadAll, toggleThreadAll, onTranscribe, canTranscribe, voiceMaxSeconds,
 }) {
   let lastDay = '';
   // Reply-to quotes: resolve a message's `replyToId` to the original within the loaded page (a parent
@@ -179,6 +182,7 @@ export function ThreadPanel({
               starred=${important.has(m.id)} onStar=${toggleImportant} onTrack=${onTrackMsg} onPark=${onParkMsg} onReplyAi=${openMessageAi} tracked=${trackedByMsg[m.id]}
               answeredWith=${m.interactive?.role === 'questions' ? answersByQ[m.id] : null}
               onAnswer=${submitInteractiveAnswers} submitting=${sending} showLinkPreviews=${showLinkPreviews}
+              onTranscribe=${activeConv.viaAgent ? null : onTranscribe} canTranscribe=${canTranscribe}
               onOpenMarkdown=${(url, name) => setMdViewer({ url, name })} />`;
         })}
       </div>
@@ -214,6 +218,7 @@ export function ThreadPanel({
           </div>` : null}
           <${Composer} key=${'c-' + activeConv.conversationId + (draftPrefill ? '-d' + prefillNonce : '')} recipient=${activeConv.peerGhii}
             sendLabel=${t('inbox.reply')} sending=${sending} onSend=${doSend} initialText=${draftPrefill}
+            voiceMaxSeconds=${voiceMaxSeconds}
             focusNonce=${composerFocus} draftKey=${'aimeat.inbox.draft.' + activeConv.conversationId} />`}
     </div>`;
 }

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

@@ -0,0 +1,50 @@
+/**
+ * @file public/views/profile/inbox-tab/use-voice.js
+ * @description The Inbox tab's voice-message state: whether this owner can transcribe at all, how
+ *   long the node lets a recording run, and the call that turns one voice attachment into text.
+ *   Extracted from inbox-tab.js to keep it under the max-file-lines rule.
+ * @structure useVoiceMessages(loadThread, activeConvRef) → { canTranscribe, voiceMaxSeconds, transcribeVoice }
+ * @usage const { canTranscribe, voiceMaxSeconds, transcribeVoice } = useVoiceMessages(loadThread, activeConvRef);
+ * @version-history
+ *   v1.0.0 — 2026-08-01 — Extracted from inbox-tab.js (voice messages).
+ */
+import { useState, useEffect, useCallback } from 'preact/hooks';
+import { t } from '/js/i18n.js';
+import { apiGet } from '/js/api.js';
+import * as messages from '/js/services/messages.js';
+import { swallowed } from '/js/swallowed.js';
+
+/**
+ * @param {(conv: any, markRead?: boolean) => Promise<void>} loadThread
+ * @param {{ current: any }} activeConvRef  the OPEN conversation, read at call time
+ */
+export function useVoiceMessages(loadThread, activeConvRef) {
+  // canTranscribe answers "has this owner chosen a transcription model", which decides whether a
+  // voice bubble offers a Transcribe button or explains why it cannot. Read once per mount: an owner
+  // does not change it mid-thread, and polling it would be a request per render for one boolean.
+  const [canTranscribe, setCanTranscribe] = useState(null);
+  // Served by the node so the recorder stops at the operator's number rather than one compiled in.
+  const [voiceMaxSeconds, setVoiceMaxSeconds] = useState(300);
+
+  useEffect(() => {
+    apiGet('/v1/openrouter/settings')
+      .then((r) => {
+        setCanTranscribe(!!(r?.data?.sttModel));
+        const n = Number(r?.data?.limits?.voice_msg_max_seconds);
+        if (n > 0) setVoiceMaxSeconds(n);
+      })
+      .catch((err) => { swallowed('inbox-tab: stt settings', err); setCanTranscribe(false); });
+  }, []);
+
+  /** Transcribe one voice attachment on the caller's OWN copy, then reload the thread so the text
+   *  appears where the audio is. Errors are rethrown so the bubble can show them in place. */
+  const transcribeVoice = useCallback(async (msgId, attId) => {
+    const r = await messages.transcribeAttachment(msgId, attId);
+    if (r?.ok === false) throw new Error(r?.error?.message || t('inbox.transcribeFailed'));
+    const conv = activeConvRef.current;
+    if (conv) await loadThread(conv);
+    return r?.data;
+  }, [loadThread, activeConvRef]);
+
+  return { canTranscribe, voiceMaxSeconds, transcribeVoice };
+}

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

@@ -0,0 +1,111 @@
+/**
+ * @file public/views/profile/inbox-tab/voice-parts.js
+ * @description The voice-message pieces of a message bubble: the in-place audio player and the
+ *   transcript row under it. Extracted from components.js purely to keep that file under the
+ *   max-file-lines rule; behaviour is unchanged.
+ *
+ *   Two rules live here. Only one player runs at a time (and starting one silences the read-aloud
+ *   engine, so a synthetic voice never talks over a human one). And transcription is never automatic:
+ *   it spends the owner's own AI budget, so it is always a click, and the button says what it will do.
+ * @structure fmtClock · stopOtherAudio · AudioAttachment · TranscriptPanel
+ * @usage import { AudioAttachment } from './voice-parts.js';
+ * @version-history
+ *   v1.0.0 — 2026-08-01 — Extracted from components.js (voice messages).
+ */
+import { h } from 'preact';
+import { useState } from 'preact/hooks';
+import htm from 'htm';
+const html = htm.bind(h);
+import { t } from '/js/i18n.js';
+import { escHtml } from '/js/utils.js';
+import { stop as stopSpeech } from '/js/services/speech-reader.js';
+
+/** Seconds → "0:14". */
+export function fmtClock(seconds) {
+  const s = Math.max(0, Math.round(Number(seconds) || 0));
+  return `${Math.floor(s / 60)}:${String(s % 60).padStart(2, '0')}`;
+}
+
+/** One voice message at a time. Two playing at once is noise, and a screen reader talking over a
+ *  recording is worse — so starting one stops every other player AND the read-aloud engine. */
+export function stopOtherAudio(current) {
+  document.querySelectorAll('audio.inbox-audio').forEach((el) => {
+    const player = /** @type {HTMLAudioElement} */ (el);
+    if (player !== current && !player.paused) player.pause();
+  });
+  stopSpeech();
+}
+
+/**
+ * The text of a voice message, and the button that produces it.
+ *
+ * Three states, none of them hidden: a transcript that came WITH the message (the sender wrote it,
+ * so reading it costs nothing), a transcript this reader produced, or an offer to produce one. With
+ * no transcription model configured the row says so and points at the settings instead of quietly
+ * rendering nothing — an empty space reads as broken.
+ */
+export function TranscriptPanel({ att, msgId, onTranscribe, canTranscribe }) {
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState(null);
+  const [open, setOpen] = useState(false);
+  const tr = att.transcript;
+
+  async function run() {
+    setBusy(true); setError(null);
+    try {
+      await onTranscribe(msgId, att.id);
+      setOpen(true);
+    } catch (e) {
+      // Shown in place, not as a toast: "no model configured" and "daily budget spent" are both
+      // things the reader can act on, and they belong next to the button that produced them.
+      setError(e?.message || t('inbox.transcribeFailed'));
+    }
+    setBusy(false);
+  }
+
+  if (tr?.text) {
+    return html`
+      <div class="inbox-transcript">
+        <button class="inbox-transcript-toggle" onClick=${() => setOpen((v) => !v)} aria-expanded=${open}>
+          ${open ? '▾' : '▸'} ${t('inbox.transcript')}
+          <span class="inbox-transcript-src">
+            ${tr.by === 'sender' ? t('inbox.transcriptBySender') : t('inbox.transcriptByYou', { model: tr.model || '' })}
+          </span>
+        </button>
+        ${open ? html`<div class="inbox-transcript-text">${escHtml(tr.text)}</div>` : null}
+      </div>`;
+  }
+
+  if (!onTranscribe) return null;
+
+  return html`
+    <div class="inbox-transcript">
+      ${canTranscribe === false
+        ? html`<span class="inbox-transcript-hint">${t('inbox.transcribeNoModel')}</span>`
+        : html`
+          <button class="inbox-transcript-btn" onClick=${run} disabled=${busy}>
+            ${busy ? t('inbox.transcribing') : t('inbox.transcribe')}
+          </button>`}
+      ${error ? html`<span class="inbox-transcript-err">${error}</span>` : null}
+    </div>`;
+}
+
+/**
+ * A voice message in a bubble: it plays here rather than opening in a browser tab, which is a
+ * download and not a conversation.
+ *
+ * preload="metadata" is deliberate — a thread with ten voice messages must not fetch all ten on
+ * open. The duration is all that is needed until someone presses play.
+ */
+export function AudioAttachment({ a, url, name, download, msgId, onTranscribe, canTranscribe }) {
+  return html`<div class="inbox-attach-audio">
+    <audio class="inbox-audio" controls preload="metadata" src=${url}
+           onPlay=${(e) => stopOtherAudio(e.currentTarget)}></audio>
+    <div class="inbox-attach-cap">
+      <span class="inbox-attach-name">${escHtml(name)}</span>
+      ${a.durationSeconds ? html`<span class="inbox-audio-dur">${fmtClock(a.durationSeconds)}</span>` : null}
+      ${download}
+    </div>
+    <${TranscriptPanel} att=${a} msgId=${msgId} onTranscribe=${onTranscribe} canTranscribe=${canTranscribe} />
+  </div>`;
+}

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

@@ -14,6 +14,11 @@
  *   (./inbox-tab/use-thread-ux.js)
  * @usage Lazy-loaded profile tab; registered in profile.js TABS as id `messages`.
  * @version-history
+ *   v1.27.0 -- 2026-08-01 -- Voice messages: 🎤 in the composer records a clip that travels the normal
+ *     attachment path, an audio bubble plays in place, and a voice attachment can be turned into text
+ *     with the owner's own key (useVoiceMessages → POST /v1/messages/:id/attachments/:attId/transcribe).
+ *     Never automatic — transcription spends the owner's AI budget, so it is always a click. parkMessage
+ *     and openTrackedRecord moved to helpers.js to stay under max-file-lines.
  *   v1.26.0 -- 2026-07-27 -- Failed sends toast the thrown REASON (helpers.sendFailure); the flat generic line hid every actionable attachment error.
  *   v1.25.0 -- 2026-07-21 -- Thread history is no longer capped at the newest 50: threads open showing
  *     their FULL history by default (getConversation(all)); a header "Show last 50 / all" toggle
@@ -130,17 +135,16 @@ import { escHtml } from '/js/utils.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 { 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';
 import { peerLabel } from '/js/services/messages-ai-prompts.js';
-import { peerName, ownerKeyOf, isAgentPeer, buildAnswerSummary, resolveThreadAttachmentUrls, sendFailure } from './inbox-tab/helpers.js';
+import { peerName, ownerKeyOf, isAgentPeer, buildAnswerSummary, resolveThreadAttachmentUrls, sendFailure, parkMessage, openTrackedRecord } from './inbox-tab/helpers.js';
 import { Composer, PollBuilder, MarkdownViewer, ReplyWithAiPopover, ConversationToNotebookPopover } from './inbox-tab/components.js';
 import { buildConversationReplyProps, buildMessageReplyProps, buildConversationNotebookProps } from './inbox-tab/ai-actions.js';
 import { ListPanel, ThreadPanel, TrackedPanel, ResultsPanel } from './inbox-tab/panels.js';
 import { useThreadAutoScroll, useMobileComposerKeyboard, useLinkPreviewToggle } from './inbox-tab/use-thread-ux.js';
+import { useVoiceMessages } from './inbox-tab/use-voice.js';
 import { ContactPicker } from '/components/ContactPicker.js';
 import { swallowed } from '/js/swallowed.js';
 
@@ -148,6 +152,9 @@ export default function InboxTab({ showToast }) {
   const [requests, setRequests] = useState([]);
   const [conversations, setConversations] = useState([]);
   const [activeConv, setActiveConv] = useState(null);     // { conversationId, peerGhii }
+  // Mirrored into a ref so []-memoized callbacks (transcribeVoice) can reload the OPEN thread
+  // without taking activeConv as a dependency and being rebuilt on every thread switch.
+  const activeConvRef = useRef(null); activeConvRef.current = activeConv;
   const [thread, setThread] = useState([]);
   const [urlMap, setUrlMap] = useState({});
   const { showLinkPreviews, toggleLinkPreviews } = useLinkPreviewToggle(); const [mdViewer, setMdViewer] = useState(null); // link-preview toggle (persisted) + markdown viewer state
@@ -266,12 +273,7 @@ export default function InboxTab({ showToast }) {
 
   // 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 onParkMsg = (msg) => parkMessage(msg, showToast);
 
   const cancelTracked = async (tr) => {
     let resp;
@@ -299,20 +301,8 @@ export default function InboxTab({ showToast }) {
     setReplyingTrId(tr.id);
   };
 
-  // Open the workspace record this tracked response watches (so you can jump straight to the bug). Set
-  // BOTH the saved-tab (so the profile loads straight onto Organisms) and the workspace deep-link
-  // (so the Organisms tab opens that exact workspace), then hard-navigate.
-  const openRecord = (tr) => {
-    const r = tr.references || {};
-    if (!r.organismId || !r.workspaceId) { showToast?.(t('inbox.trackNoRecord'), true); return; }
-    try {
-      sessionStorage.setItem('aimeat-profile-tab', 'organisms');
-      sessionStorage.setItem('aimeat.ws.openId', r.organismId);
-      sessionStorage.setItem('aimeat.ws.openWs', r.workspaceId);
-    // eslint-disable-next-line aimeat/no-silent-catch -- noop
-    } catch { /* noop */ }
-    window.location.assign('/v1/profile?tab=organisms');
-  };
+  // Jump to the workspace record this tracked response watches (straight to the bug it is about).
+  const openRecord = (tr) => openTrackedRecord(tr, showToast);
 
   // Fetch the suggested-reply body for each awaiting contract in the open conversation (for the bubble).
   const awaitingIds = awaitingForConv.map(t => t.id).join(',');
@@ -356,6 +346,9 @@ export default function InboxTab({ showToast }) {
   }, []);
   const toggleThreadAll = () => setThreadAll(v => { const nv = !v; threadAllRef.current = nv; if (activeConv) loadThread(activeConv); return nv; });
 
+  // Voice messages: can this owner transcribe, how long may a recording run, and the call that does it.
+  const { canTranscribe, voiceMaxSeconds, transcribeVoice } = useVoiceMessages(loadThread, activeConvRef);
+
   // Mount: one composite call seeds all six sections (requests/conversations/important/tracked/agents/groups).
   useEffect(() => { loadOverview(); }, [loadOverview]);
 
@@ -774,7 +767,8 @@ export default function InboxTab({ showToast }) {
           onTrackMsg=${onTrackMsg} onParkMsg=${onParkMsg} openMessageAi=${openMessageAi} submitInteractiveAnswers=${submitInteractiveAnswers}
           setMdViewer=${setMdViewer} openConversationAi=${openConversationAi} openConversationNotebook=${openConversationNotebook} insertCommand=${insertCommand} setCmdFill=${setCmdFill}
           cancelTracked=${cancelTracked} openRecord=${openRecord} startSuggestedReply=${startSuggestedReply} doSend=${doSend} showLinkPreviews=${showLinkPreviews} toggleLinkPreviews=${toggleLinkPreviews}
-          threadAll=${threadAll} toggleThreadAll=${toggleThreadAll} />` : null}
+          threadAll=${threadAll} toggleThreadAll=${toggleThreadAll}
+          onTranscribe=${transcribeVoice} canTranscribe=${canTranscribe} voiceMaxSeconds=${voiceMaxSeconds} />` : null}
 
         ${mode === 'tracked' ? html`<${TrackedPanel} activeTracked=${activeTracked} doneCount=${doneCount}
           openRecord=${openRecord} openTracked=${openTracked} cancelTracked=${cancelTracked} />` : null}