@dxos/plugin-transcription 0.9.1-main.c7dcc2e112 → 0.10.0

package/src/capabilities/transcription-driver.tsx

@@ -0,0 +1,263 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import React, { Fragment, useCallback, useEffect, useMemo, useRef, useState } from 'react';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { useAtomCapability, useAtomCapabilityState, useCapabilities } from '@dxos/app-framework/ui';
+import { log } from '@dxos/log';
+import { MarkdownCapabilities } from '@dxos/plugin-markdown/types';
+import { useAudioTrack, useTranscriber } from '@dxos/react-ui-transcription';
+import { linkEntities } from '@dxos/transcription-pipeline';
+import { type ContentBlock } from '@dxos/types';
+import { PendingTextStreamer, cancelPendingText, editorPendingTextSink, pendingTextState } from '@dxos/ui-editor';
+
+import { meta } from '#meta';
+import { TranscriptionCapabilities } from '#types';
+
+// Recorder chunk interval; the transcriber's chunk threshold is derived from the buffering setting.
+const RECORDER_INTERVAL_MS = 200;
+
+/**
+ * Headless controller driving live transcription into a Markdown editor. Reads the active recording
+ * session, captures audio while recording, and dispatches the transcribed text into the target
+ * editor as pending-text effects. The user confirms or discards the pending text via the editor's
+ * inline affordances. Mounted once, app-wide, via `Capabilities.ReactContext`.
+ */
+const TranscriptionDriver = () => {
+  const [session, setSession] = useAtomCapabilityState(TranscriptionCapabilities.RecordingSession);
+  // `useCapabilities` (not `useCapability`) so the driver does not throw when plugin-markdown is absent.
+  const [editorViews] = useCapabilities(MarkdownCapabilities.EditorViews);
+  // Injected entity resolver (full-text/vector/…); the driver stays decoupled from the database.
+  const [lookup] = useCapabilities(TranscriptionCapabilities.EntityLookup);
+  const settings = useAtomCapability(TranscriptionCapabilities.Settings);
+
+  const [, setStatus] = useAtomCapabilityState(TranscriptionCapabilities.PipelineStatus);
+
+  const recording = session?.recording ?? false;
+  const liveSessionId = session?.id;
+
+  // Only this driver's editor-backed sessions are captured here: if no editor view is registered for
+  // the session there is nowhere to stream transcription, so the driver stays idle and leaves the
+  // mic to whoever owns that session (e.g. a non-editor consumer running its own transcriber).
+  const hasEditorForSession = !!(liveSessionId && editorViews?.get(liveSessionId));
+
+  // Lifecycle phase. Driven from `recording` via an effect (not derived synchronously) so that when
+  // the mic switches off the phase is still 'recording' for that commit — nothing tears down until
+  // the drain finishes and sets 'idle'. This lets the final transcription + enrichment complete.
+  const [phase, setPhase] = useState<'idle' | 'recording' | 'draining'>('idle');
+  const active = phase !== 'idle';
+
+  // The toolbar clears the RecordingSession on stop, but the driver must keep targeting the same
+  // editor through the drain — capture the session id for the lifetime of the active phase (the
+  // editor stays open). Cleared once the phase returns to idle.
+  const [sessionId, setSessionId] = useState<string>();
+  useEffect(() => {
+    if (recording && liveSessionId && hasEditorForSession) {
+      setSessionId(liveSessionId);
+    }
+  }, [recording, liveSessionId, hasEditorForSession]);
+
+  useEffect(() => {
+    setPhase((current) =>
+      recording && hasEditorForSession ? 'recording' : current === 'recording' ? 'draining' : current,
+    );
+  }, [recording, hasEditorForSession]);
+
+  useEffect(() => {
+    if (phase === 'idle') {
+      setSessionId(undefined);
+    }
+  }, [phase]);
+
+  // Publish the phase so the toolbar / testbench can reflect mic + pipeline state in real time.
+  useEffect(() => {
+    setStatus(() => ({ phase }));
+  }, [phase, setStatus]);
+
+  // `ideal` (not `exact`) so an unavailable device falls back to the default rather than failing.
+  const audioConstraints = useMemo<MediaTrackConstraints | undefined>(
+    () => (settings?.audioDeviceId ? { deviceId: { ideal: settings.audioDeviceId } } : undefined),
+    [settings?.audioDeviceId],
+  );
+
+  // Keep the track (and thus the transcriber) alive across the whole active session — including the
+  // drain — so the transcriber can flush its buffered audio before teardown. Released at idle. The
+  // mic indicator therefore lingers for the brief drain after stop.
+  const track = useAudioTrack(active, audioConstraints);
+
+  // Refs so `handleSegments` stays stable (changing it would recreate the transcriber).
+  const sessionIdRef = useRef(sessionId);
+  sessionIdRef.current = sessionId;
+  const editorViewsRef = useRef(editorViews);
+  editorViewsRef.current = editorViews;
+
+  // The user cancelled (✕) if the pending decoration was cleared mid-session; guards against
+  // resurrecting it with late transcription / post-process writes during the drain.
+  const isCancelled = useCallback(() => {
+    const id = sessionIdRef.current;
+    const view = id ? editorViewsRef.current?.get(id)?.view : undefined;
+    return view ? view.state.field(pendingTextState, false) == null : false;
+  }, []);
+
+  // Streams transcribed text into the editor's pending-text block (buffering + word-by-word reveal).
+  // Kept alive across the whole session (incl. drain); disposed only when the phase returns to idle.
+  const streamerRef = useRef<PendingTextStreamer | null>(null);
+
+  useEffect(() => {
+    if (!active || !editorViews || !sessionId) {
+      return;
+    }
+    const entry = editorViews.get(sessionId);
+    if (!entry) {
+      return;
+    }
+
+    // Clicking the toolbar blurs the editor and hides the caret, so anchor + placeholder give
+    // immediate feedback while the first transcription is buffered.
+    // When entity extraction is enabled and a lookup is available, rewrite settled text with inline
+    // `[noun](echo:/<id>)` links — decorated as dx-anchors by the markdown editor's preview extension.
+    const entityExtraction = settings?.entityExtraction !== false;
+    const streamer = new PendingTextStreamer(editorPendingTextSink(entry.view), {
+      mode: settings?.streamMode ?? 'word',
+      wordIntervalMs: settings?.wordIntervalMs ?? 80,
+      postProcess: entityExtraction && lookup ? (text) => linkEntities(text, lookup) : undefined,
+    });
+    streamer.start({ anchor: entry.view.state.selection.main.head, placeholder: 'Recording…' });
+    streamerRef.current = streamer;
+
+    return () => {
+      streamer.dispose();
+      streamerRef.current = null;
+      // On teardown, drop the placeholder if nothing was transcribed; otherwise leave it for review.
+      const current = editorViews.get(sessionId);
+      const pending = current?.view.state.field(pendingTextState, false);
+      if (current && pending && pending.final.length === 0) {
+        current.view.dispatch({ effects: cancelPendingText.of() });
+      }
+    };
+  }, [
+    active,
+    sessionId,
+    editorViews,
+    lookup,
+    settings?.streamMode,
+    settings?.wordIntervalMs,
+    settings?.entityExtraction,
+  ]);
+
+  const handleSegments = useCallback(
+    async (segments: ContentBlock.Transcript[]) => {
+      const text = segments
+        .map((segment) => segment.text)
+        .join(' ')
+        .trim();
+      if (text.length > 0 && !isCancelled()) {
+        streamerRef.current?.push(text);
+      }
+    },
+    [isCancelled],
+  );
+
+  // Derive the transcriber's chunk threshold from the configured initial buffering time.
+  const transcriberConfig = useMemo(
+    () => ({
+      transcribeAfterChunksAmount: Math.max(
+        1,
+        Math.round((settings?.transcribeAfterMs ?? 4000) / RECORDER_INTERVAL_MS),
+      ),
+    }),
+    [settings?.transcribeAfterMs],
+  );
+
+  // Stable identity: a fresh object would change useTranscriber's memo deps every render, recreating
+  // (and reopening) the transcriber and discarding its buffered audio.
+  const recorderConfig = useMemo(() => ({ interval: RECORDER_INTERVAL_MS }), []);
+  const transcriber = useTranscriber({
+    audioStreamTrack: track,
+    onSegments: handleSegments,
+    transcriberConfig,
+    recorderConfig,
+  });
+  const transcriberRef = useRef(transcriber);
+  transcriberRef.current = transcriber;
+
+  useEffect(() => {
+    if (!transcriber) {
+      return;
+    }
+    let cancelled = false;
+    // Clear the session if `open()` rejects (e.g. mic permission denied) so the toolbar does not
+    // report "stop" forever while nothing is captured.
+    void transcriber.open().then(
+      () => {
+        if (!cancelled && phase === 'recording') {
+          transcriber.startChunksRecording();
+        }
+      },
+      (err) => {
+        if (!cancelled) {
+          log.catch(err);
+          setSession(() => null);
+        }
+      },
+    );
+    return () => {
+      cancelled = true;
+    };
+  }, [transcriber, phase, setSession]);
+
+  // Drain on stop: flush buffered audio (final transcription) and the streamer's post-process
+  // (entity linking) before tearing down — so the tail of speech and its enrichment are not lost.
+  useEffect(() => {
+    if (phase !== 'draining') {
+      return;
+    }
+    let cancelled = false;
+    // Hard-abort the in-flight transcription request if the user cancels (✕) during the drain.
+    const abortTimer = setInterval(() => {
+      if (isCancelled()) {
+        transcriberRef.current?.abort();
+      }
+    }, 150);
+    void (async () => {
+      try {
+        // Flush buffered audio (final transcription) then settle the streamer's post-process, unless
+        // the user cancelled (✕) — in which case skip the writes so the decoration stays cleared.
+        await transcriberRef.current?.flush();
+        if (!isCancelled()) {
+          await streamerRef.current?.flush();
+        }
+      } catch (err) {
+        log.catch(err);
+      } finally {
+        clearInterval(abortTimer);
+        if (!cancelled) {
+          setPhase((current) => (current === 'draining' ? 'idle' : current));
+        }
+      }
+    })();
+    return () => {
+      cancelled = true;
+      clearInterval(abortTimer);
+    };
+  }, [phase, isCancelled]);
+
+  return null;
+};
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    return Capability.contributes(Capabilities.ReactContext, {
+      id: meta.profile.key,
+      context: ({ children }) => (
+        <Fragment>
+          {children}
+          <TranscriptionDriver />
+        </Fragment>
+      ),
+    });
+  }),
+);

package/src/components/Mic/Mic.stories.tsx

@@ -0,0 +1,66 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import React, { useState } from 'react';
+
+import { MicButton, Toolbar } from '@dxos/react-ui';
+import { type AudioInputDevice, MicSettings, type RecordMode } from '@dxos/react-ui-transcription';
+import { withLayout, withTheme } from '@dxos/react-ui/testing';
+
+import { meta as pluginMeta } from '#meta';
+import { translations } from '#translations';
+
+const DEVICES: AudioInputDevice[] = [
+  { deviceId: 'default', label: 'Default — MacBook Pro Microphone' },
+  { deviceId: 'usb-1', label: 'USB Audio Interface' },
+  { deviceId: 'bt-1', label: 'AirPods Pro' },
+];
+
+// Drives the presentational pieces from local state so the dropdown, mode switch, and
+// press-and-hold can be exercised without capabilities.
+const DefaultStory = () => {
+  const [recording, setRecording] = useState(false);
+  const [recordMode, setRecordMode] = useState<RecordMode>('toggle');
+  const [entityExtraction, setEntityExtraction] = useState(true);
+  const [selectedDeviceId, setSelectedDeviceId] = useState('');
+
+  return (
+    <Toolbar.Root>
+      <MicButton
+        iconOnly
+        variant='ghost'
+        label={recording ? 'Stop recording' : recordMode === 'hold' ? 'Hold to record' : 'Start recording'}
+        recording={recording}
+        mode={recordMode}
+        onToggle={() => setRecording((value) => !value)}
+        onPressStart={() => setRecording(true)}
+        onPressEnd={() => setRecording(false)}
+      />
+      <MicSettings
+        translationNs={pluginMeta.profile.key}
+        recordMode={recordMode}
+        entityExtraction={entityExtraction}
+        devices={DEVICES}
+        selectedDeviceId={selectedDeviceId}
+        onRecordModeChange={setRecordMode}
+        onEntityExtractionChange={setEntityExtraction}
+        onSelectDevice={setSelectedDeviceId}
+      />
+    </Toolbar.Root>
+  );
+};
+
+const meta = {
+  title: 'plugins/plugin-transcription/components/Mic',
+  render: DefaultStory,
+  decorators: [withTheme(), withLayout({ layout: 'centered' })],
+  parameters: { translations },
+} satisfies Meta<typeof DefaultStory>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {};

package/src/components/Mic/Mic.tsx

@@ -0,0 +1,136 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import React, { useCallback, useEffect, useRef, useState } from 'react';
+
+import { useAtomCapabilityState } from '@dxos/app-framework/ui';
+import { MicButton, useTranslation } from '@dxos/react-ui';
+import { useSoundEffect } from '@dxos/react-ui-audio';
+import { type AudioInputDevice, MicSettings } from '@dxos/react-ui-transcription';
+
+import { meta } from '#meta';
+import { type Settings, TranscriptionCapabilities } from '#types';
+
+export type MicProps = {
+  /** Attendable id of the target editor; keys the recording session. */
+  docId: string;
+};
+
+/**
+ * Connects the {@link MicButton} and {@link MicSettings} to the recording session and settings
+ * capabilities, and enumerates available audio inputs. Mounted from the toolbar's custom action, so
+ * capability hooks resolve.
+ */
+export const Mic = ({ docId }: MicProps) => {
+  const { t } = useTranslation(meta.profile.key);
+  const [session, setSession] = useAtomCapabilityState(TranscriptionCapabilities.RecordingSession);
+  const [settings, setSettings] = useAtomCapabilityState(TranscriptionCapabilities.Settings);
+
+  const recording = !!session?.recording && session.id === docId;
+
+  // Play start/stop cues as this session's recording flag flips (skip the initial mount).
+  const soundStart = useSoundEffect('StartRecording');
+  const soundStop = useSoundEffect('StopRecording');
+  const wasRecording = useRef(recording);
+  useEffect(() => {
+    if (wasRecording.current === recording) {
+      return;
+    }
+    wasRecording.current = recording;
+    void (recording ? soundStart : soundStop).play();
+  }, [recording, soundStart, soundStop]);
+
+  const recordMode: Settings.RecordMode = settings?.recordMode ?? 'toggle';
+  const entityExtraction = settings?.entityExtraction !== false;
+  const selectedDeviceId = settings?.audioDeviceId ?? '';
+
+  const [devices, setDevices] = useState<AudioInputDevice[]>([]);
+  useEffect(() => {
+    if (!navigator.mediaDevices?.enumerateDevices) {
+      return;
+    }
+    let cancelled = false;
+    const refresh = async () => {
+      const all = await navigator.mediaDevices.enumerateDevices();
+      if (cancelled) {
+        return;
+      }
+      // Labels are blank until microphone permission is granted; fall back to an ordinal name.
+      setDevices(
+        all
+          .filter((device) => device.kind === 'audioinput' && device.deviceId)
+          .map((device, index) => ({
+            deviceId: device.deviceId,
+            label: device.label || `Microphone ${index + 1}`,
+          })),
+      );
+    };
+    void refresh();
+    navigator.mediaDevices.addEventListener('devicechange', refresh);
+    return () => {
+      cancelled = true;
+      navigator.mediaDevices.removeEventListener('devicechange', refresh);
+    };
+  }, []);
+
+  const handleToggle = useCallback(() => {
+    setSession((current) => (current?.recording && current.id === docId ? null : { id: docId, recording: true }));
+  }, [setSession, docId]);
+
+  const handlePressStart = useCallback(() => {
+    setSession(() => ({ id: docId, recording: true }));
+  }, [setSession, docId]);
+
+  const handlePressEnd = useCallback(() => {
+    // Only stop our own session; a stray release must not clear another editor's recording.
+    setSession((current) => (current?.id === docId ? null : current));
+  }, [setSession, docId]);
+
+  const handleRecordModeChange = useCallback(
+    (mode: Settings.RecordMode) => setSettings((current) => ({ ...current, recordMode: mode })),
+    [setSettings],
+  );
+
+  const handleEntityExtractionChange = useCallback(
+    (value: boolean) => setSettings((current) => ({ ...current, entityExtraction: value })),
+    [setSettings],
+  );
+
+  const handleSelectDevice = useCallback(
+    (deviceId: string) => setSettings((current) => ({ ...current, audioDeviceId: deviceId || undefined })),
+    [setSettings],
+  );
+
+  const recordLabel = recording
+    ? t('stop-recording.label')
+    : recordMode === 'hold'
+      ? t('hold-to-record.label')
+      : t('start-recording.label');
+
+  return (
+    <div className='flex items-center'>
+      <MicButton
+        iconOnly
+        variant='ghost'
+        label={recordLabel}
+        recording={recording}
+        mode={recordMode}
+        onToggle={handleToggle}
+        onPressStart={handlePressStart}
+        onPressEnd={handlePressEnd}
+        data-testid='transcription.record'
+      />
+      <MicSettings
+        translationNs={meta.profile.key}
+        recordMode={recordMode}
+        entityExtraction={entityExtraction}
+        devices={devices}
+        selectedDeviceId={selectedDeviceId}
+        onRecordModeChange={handleRecordModeChange}
+        onEntityExtractionChange={handleEntityExtractionChange}
+        onSelectDevice={handleSelectDevice}
+      />
+    </div>
+  );
+};

package/src/components/Mic/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+export * from './Mic';

package/src/components/index.ts

@@ -2,5 +2,4 @@
 // Copyright 2025 DXOS.org
 //
 
-export * from './Oracle';
-export * from './Transcription';
+export * from './Mic';

package/src/containers/TranscriptionArticle/TranscriptionArticle.stories.tsx

@@ -7,6 +7,7 @@ import * as Effect from 'effect/Effect';
 import React from 'react';
 
 import { withPluginManager } from '@dxos/app-framework/testing';
+import { AppActivationEvents } from '@dxos/app-toolkit';
 import { Feed, Query, Ref } from '@dxos/echo';
 import { ClientPlugin, initializeIdentity } from '@dxos/plugin-client/testing';
 import { corePlugins } from '@dxos/plugin-testing';
@@ -36,6 +37,9 @@ const meta = {
   decorators: [
     withLayout({ layout: 'column' }),
     withPluginManager({
+      // The app-wide TranscriptionDriver (ReactContext) reads the recording-session/settings
+      // capabilities, which activate on SetupSettings — fire it so the driver does not throw.
+      setupEvents: [AppActivationEvents.SetupSettings],
       plugins: [
         ...corePlugins(),
         ClientPlugin({

package/src/containers/TranscriptionArticle/TranscriptionArticle.tsx

@@ -9,14 +9,12 @@ import { Filter, Obj, Query } from '@dxos/echo';
 import { useMembers, useQuery } from '@dxos/react-client/echo';
 import { Panel } from '@dxos/react-ui';
 import { Menu, MenuBuilder, useMenuBuilder } from '@dxos/react-ui-menu';
+import { Transcription, renderByline, useFeedModelAdapter } from '@dxos/react-ui-transcription';
 import { Message, type Transcript } from '@dxos/types';
 
-import { Transcription } from '#components';
-import { useFeedModelAdapter, useTranscriptionRecording } from '#hooks';
+import { useTranscriptionRecording } from '#hooks';
 import { meta } from '#meta';
 
-import { renderByline } from '../../util';
-
 export type TranscriptionArticleProps = AppSurface.ObjectArticleProps<Transcript.Transcript>;
 
 export const TranscriptionArticle = ({ role, subject: transcript, attendableId }: TranscriptionArticleProps) => {
@@ -28,8 +26,9 @@ export const TranscriptionArticle = ({ role, subject: transcript, attendableId }
     feed ? Query.select(Filter.type(Message.Message)).from(feed) : Query.select(Filter.nothing()),
   );
   const model = useFeedModelAdapter(renderByline(members), messages);
-  const { recording, toggleRecording } = useTranscriptionRecording(transcript);
 
+  // TODO(burdon): Remove if not mutable. E.g., finalized transcript.
+  const { recording, toggleRecording } = useTranscriptionRecording(transcript);
   const menuActions = useMenuBuilder(
     () =>
       MenuBuilder.make()

package/src/hooks/index.ts

@@ -2,9 +2,4 @@
 // Copyright 2025 DXOS.org
 //
 
-export * from './useAudioFile';
-export * from './useAudioTrack';
-export * from './useFeedModelAdapter';
-export * from './useTranscriber';
 export * from './useTranscriptionRecording';
-export * from './useVoiceInput';

package/src/hooks/useTranscriptionRecording.ts

@@ -6,18 +6,15 @@ import * as Effect from 'effect/Effect';
 import { useCallback, useEffect, useState } from 'react';
 
 import { useAtomCapability, useOperationInvoker } from '@dxos/app-framework/ui';
-import { createFeedServiceLayer } from '@dxos/client/echo';
-import { Feed, Obj } from '@dxos/echo';
+import { Database, Feed, Obj } from '@dxos/echo';
 import { EffectEx } from '@dxos/effect';
 import { log } from '@dxos/log';
 import { getSpace } from '@dxos/react-client/echo';
 import { useIdentity } from '@dxos/react-client/halo';
+import { useAudioTrack, useTranscriber } from '@dxos/react-ui-transcription';
 import { Message, type Transcript } from '@dxos/types';
 
-import { TranscriptOperation, TranscriptionCapabilities } from '#types';
-
-import { useAudioTrack } from './useAudioTrack';
-import { useTranscriber } from './useTranscriber';
+import { TranscriptionCapabilities, TranscriptOperation } from '#types';
 
 export type TranscriptionRecording = {
   recording: boolean;
@@ -68,8 +65,7 @@ export const useTranscriptionRecording = (transcript: Transcript.Transcript): Tr
         }
       }
 
-      const feedServiceLayer = createFeedServiceLayer(space.db);
-      await Feed.append(feed, [message]).pipe(Effect.provide(feedServiceLayer), EffectEx.runAndForwardErrors);
+      await Feed.append(feed, [message]).pipe(Effect.provide(Database.layer(space.db)), EffectEx.runAndForwardErrors);
     },
     [space, feed, identity, invokePromise, settings],
   );

package/src/index.ts

@@ -2,10 +2,6 @@
 // Copyright 2025 DXOS.org
 //
 
-// TODO(wittjosiah): Hooks should not be exported from the plugin package at all.
-//   Either refactor callers to not need them or factor them out to a shared package.
-export * from './blueprints';
-export * from './hooks';
 export * from './meta';
-export * from './transcriber';
+export * from './skills';
 export * from './types';

package/src/normalization/message-normalizer.ts

@@ -7,7 +7,7 @@ import type * as Runtime from 'effect/Runtime';
 
 import { DeferredTask, asyncTimeout } from '@dxos/async';
 import { LifecycleState, Resource } from '@dxos/context';
-import { Feed, Filter } from '@dxos/echo';
+import { Database, Feed, Filter } from '@dxos/echo';
 import { EffectEx } from '@dxos/effect';
 import { type FunctionExecutor } from '@dxos/functions-runtime';
 import { log } from '@dxos/log';
@@ -22,7 +22,7 @@ const MAX_RANGE_ID_COUNT = 10;
 export type SegmentsNormalizerProps = {
   functionExecutor: FunctionExecutor;
   feed: Feed.Feed;
-  feedRuntime: Runtime.Runtime<Feed.FeedService>;
+  feedRuntime: Runtime.Runtime<Database.Service>;
   startingCursor: QueueCursor;
 };
 
@@ -36,7 +36,7 @@ export class MessageNormalizer extends Resource {
   private readonly _functionExecutor: FunctionExecutor;
 
   private _feed: Feed.Feed;
-  private _feedRuntime: Runtime.Runtime<Feed.FeedService>;
+  private _feedRuntime: Runtime.Runtime<Database.Service>;
   private _cursor: QueueCursor;
   private _messagesToProcess: MessageWithRangeId[] = [];
   private _normalizationTask?: DeferredTask;

package/src/normalization/normalization.ts

@@ -7,6 +7,9 @@ import * as Schema from 'effect/Schema';
 
 import { Operation } from '@dxos/compute';
 import { log } from '@dxos/log';
+// Imported so TypeScript can name these types in the emitted .d.ts.
+// eslint-disable-next-line unused-imports/no-unused-imports
+import { type Message, type Person } from '@dxos/types';
 import { trim } from '@dxos/util';
 
 import { TranscriptOperation } from '../types';

package/src/operations/open.ts

@@ -6,17 +6,17 @@ import * as Effect from 'effect/Effect';
 
 import { Operation } from '@dxos/compute';
 import { Database, Feed, Filter } from '@dxos/echo';
+import { renderByline } from '@dxos/react-ui-transcription';
 import { Message } from '@dxos/types';
 
 import { TranscriptOperation } from '../types';
-import { renderByline } from '../util';
 
 const handler: Operation.WithHandler<typeof TranscriptOperation.Open> = TranscriptOperation.Open.pipe(
   Operation.withHandler(
     Effect.fn(function* ({ transcript }) {
       const transcriptObj = yield* Database.load(transcript);
       const feed = yield* Database.load(transcriptObj.feed);
-      const messages = yield* Feed.runQuery(feed, Filter.type(Message.Message));
+      const messages = yield* Feed.query(feed, Filter.type(Message.Message)).run;
       const content = messages
         .flatMap((message: Message.Message, index: number) => renderByline([])(message, index))
         .join('\n\n');

package/src/operations/summarize.ts

@@ -10,7 +10,7 @@ import * as Option from 'effect/Option';
 
 import { AiService, ConsolePrinter, ToolExecutionService, ToolResolverService } from '@dxos/ai';
 import { AiRequest, GenerationObserver } from '@dxos/assistant';
-import { Trace, Operation } from '@dxos/compute';
+import { Operation, Trace } from '@dxos/compute';
 import { Database } from '@dxos/echo';
 import { registryLayerNoop } from '@dxos/echo/testing';
 import { trim } from '@dxos/util';
@@ -49,7 +49,7 @@ const handler: Operation.WithHandler<typeof TranscriptOperation.Summarize> = Tra
       },
       Effect.provide(
         Layer.mergeAll(
-          AiService.model('ai.claude.model.claude-sonnet-4-6'),
+          AiService.model('com.anthropic.model.claude-sonnet-4-6.default'),
           ToolResolverService.layerEmpty,
           ToolExecutionService.layerEmpty,
           Trace.writerLayerNoop,

package/src/skills/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export { default as TranscriptionSkill } from './transcription-skill';