Skip to content

Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS

fix: show FableLoom hosted-session errors and reset the turn phase when a guest turn fails (#11661)

[._.]/ Adam Eivy9191ac3242f6
diff --git a/client/src/components/fableloom/LoomPlayPanel.jsx b/client/src/components/fableloom/LoomPlayPanel.jsx
index 1fd1c5a841..0de26971c0 100644
--- a/client/src/components/fableloom/LoomPlayPanel.jsx
+++ b/client/src/components/fableloom/LoomPlayPanel.jsx
@@ -142,6 +142,10 @@ export default function LoomPlayPanel({ loom, episode: initialEpisode, onClose }
setHostedTurnPhase(data.phase || 'idle');
});
+ socket.on('hosted:error', (data) => {
+ toast.error(data?.message || 'Hosted session error');
+ });
+
socket.on('hosted:turn:transcript', (item) => {
setTranscript((prev) => [...prev, { role: item.role === 'audience' ? 'reader' : 'narrator', text: item.text }]);
});
diff --git a/client/src/components/fableloom/LoomPlayPanel.test.jsx b/client/src/components/fableloom/LoomPlayPanel.test.jsx
index 8c8e5c4599..c0f46100d3 100644
--- a/client/src/components/fableloom/LoomPlayPanel.test.jsx
+++ b/client/src/components/fableloom/LoomPlayPanel.test.jsx
@@ -454,6 +454,20 @@ describe('LoomPlayPanel', () => {
expect(toast.error).toHaveBeenCalledWith(expect.stringContaining('Episode 2'));
});
+ it('toasts hosted:error frames so the operator sees refused host actions', async () => {
+ const user = userEvent.setup();
+ render(<LoomPlayPanel loom={loom} episode={episode} />);
+
+ await user.click(screen.getByRole('button', { name: 'Host (QR)' }));
+ await user.click(screen.getByRole('button', { name: 'Start hosted session' }));
+
+ const hostedSocket = io.mock.results.at(-1).value;
+ const errorHandler = hostedSocket.on.mock.calls.find(([event]) => event === 'hosted:error')?.[1];
+ act(() => { errorHandler({ code: 'NODE_NOT_IN_EPISODE', message: 'node is not in this episode' }); });
+
+ expect(toast.error).toHaveBeenCalledWith('node is not in this episode');
+ });
+
// #8112: the server rejects a second hosted:episode:switch sent while an
// earlier one is still in flight (409 EPISODE_SWITCH_IN_PROGRESS). A host
// who advances past the in-flight target before it settles would otherwise
diff --git a/client/src/pages/FableLoomHostedJoin.jsx b/client/src/pages/FableLoomHostedJoin.jsx
index ee48390a31..4d2036c004 100644
--- a/client/src/pages/FableLoomHostedJoin.jsx
+++ b/client/src/pages/FableLoomHostedJoin.jsx
@@ -19,6 +19,16 @@ import {
Volume2,
} from 'lucide-react';
+// Guest-facing wording for the live-conversation gates; any other code falls
+// back to the server's own message.
+const HOSTED_ERROR_MESSAGES = {
+ PLAYBACK_NOT_IN_HOLD_PHASE: 'The scene is still playing — wait for it to pause, then try again.',
+ PROTAGONIST_ONSCREEN: 'The protagonist is on screen right now — wait until they finish.',
+ HOLD_ASSET_OCCUPIED_BY_DIALOGUE: 'The protagonist is mid-line — wait until they finish.',
+ TURN_IN_PROGRESS: 'A reply is already in progress — wait a moment, then try again.',
+ EPISODE_SWITCH_IN_PROGRESS: 'The host is switching episodes — try again in a moment.',
+};
+
export default function FableLoomHostedJoin() {
const [sessionId, setSessionId] = useState(null);
const [token, setToken] = useState(null);
@@ -39,6 +49,9 @@ export default function FableLoomHostedJoin() {
const mountedRef = useMounted();
const transcriptScrollRef = useRef(null);
const audioPlayerRef = useRef(null);
+ // The socket effect closes over its first render; this ref keeps its
+ // `hosted:error` handler pointed at the current recorder state.
+ const discardRecordingRef = useRef(null);
// 1. Parse session and token from URL fragment (#session=...&token=...)
useEffect(() => {
@@ -91,6 +104,13 @@ export default function FableLoomHostedJoin() {
}
});
+ // The server refuses or fails a turn with this frame; without it a refused
+ // mic keeps "recording" into a turn the server already dropped.
+ s.on('hosted:error', (data) => {
+ discardRecordingRef.current?.();
+ setRecordingError(HOSTED_ERROR_MESSAGES[data?.code] || data?.message || 'Something went wrong. Please try again.');
+ });
+
s.on('hosted:turn:transcript', (item) => {
setTranscript((prev) => [...prev, item]);
});
@@ -203,6 +223,21 @@ export default function FableLoomHostedJoin() {
}
};
+ // Retire the generation first so the recorder's onstop never ships the
+ // audio of a turn the server already refused.
+ discardRecordingRef.current = () => {
+ pressedRef.current = false;
+ ++startGenRef.current;
+ ++recordingGenRef.current;
+ const active = mediaRecorderRef.current;
+ mediaRecorderRef.current = null;
+ if (active) {
+ if (active.recorder.state !== 'inactive') active.recorder.stop();
+ active.stopTracks();
+ }
+ setIsRecording(false);
+ };
+
useEffect(() => () => {
++recordingGenRef.current;
pressedRef.current = false;
diff --git a/client/src/pages/FableLoomHostedJoin.test.jsx b/client/src/pages/FableLoomHostedJoin.test.jsx
index 55709f7d04..d6f139bcff 100644
--- a/client/src/pages/FableLoomHostedJoin.test.jsx
+++ b/client/src/pages/FableLoomHostedJoin.test.jsx
@@ -266,4 +266,54 @@ describe('FableLoomHostedJoin', () => {
expect(tracks.every((track) => track.stop.mock.calls.length === 1)).toBe(true);
vi.unstubAllGlobals();
});
+
+ const socketHandler = (event) => mockSocket.on.mock.calls.find(([name]) => name === event)?.[1];
+
+ it('discards an in-progress recording and shows the mapped message when the mic is refused', async () => {
+ window.location.hash = '#session=sess-123&token=tok-abc';
+ const track = { stop: vi.fn() };
+ Object.defineProperty(navigator, 'mediaDevices', {
+ configurable: true,
+ value: { getUserMedia: vi.fn().mockResolvedValue({ getTracks: () => [track] }) },
+ });
+ let recorder;
+ vi.stubGlobal('MediaRecorder', class {
+ constructor() { this.state = 'inactive'; this.mimeType = 'audio/webm'; recorder = this; }
+ start() { this.state = 'recording'; }
+ stop() { this.state = 'inactive'; queueMicrotask(() => this.onstop?.()); }
+ });
+
+ render(<FableLoomHostedJoin />);
+ fireEvent.pointerDown(screen.getByRole('button', { name: /hold talk/i }));
+ await waitFor(() => expect(recorder?.state).toBe('recording'));
+ expect(screen.getByText(/release when done/i)).toBeInTheDocument();
+
+ act(() => { socketHandler('hosted:error')({ code: 'PROTAGONIST_ONSCREEN', message: 'raw server text' }); });
+
+ expect(recorder.state).toBe('inactive');
+ expect(track.stop).toHaveBeenCalled();
+ expect(screen.queryByText(/release when done/i)).not.toBeInTheDocument();
+ expect(screen.getByRole('alert')).toHaveTextContent(/protagonist is on screen/i);
+ await act(async () => { await Promise.resolve(); });
+ expect(mockSocket.emit).not.toHaveBeenCalledWith('hosted:mic:stop', expect.anything());
+ vi.unstubAllGlobals();
+ });
+
+ it('falls back to the server message and re-enables input after a failed turn returns to idle', () => {
+ window.location.hash = '#session=sess-123&token=tok-abc';
+ render(<FableLoomHostedJoin />);
+
+ act(() => { socketHandler('hosted:turn:phase')({ phase: 'thinking' }); });
+ expect(screen.getByRole('button', { name: /hold talk/i })).toBeDisabled();
+ expect(screen.getByPlaceholderText('Or type a message…')).toBeDisabled();
+
+ act(() => {
+ socketHandler('hosted:error')({ code: 'TURN_FAILED', message: 'loom read failed' });
+ socketHandler('hosted:turn:phase')({ phase: 'idle' });
+ });
+
+ expect(screen.getByRole('alert')).toHaveTextContent('loom read failed');
+ expect(screen.getByRole('button', { name: /hold talk/i })).not.toBeDisabled();
+ expect(screen.getByPlaceholderText('Or type a message…')).not.toBeDisabled();
+ });
});
diff --git a/server/services/fableLoom/hostedSession.js b/server/services/fableLoom/hostedSession.js
index 8c5ac6f8dc..fbb2605038 100644
--- a/server/services/fableLoom/hostedSession.js
+++ b/server/services/fableLoom/hostedSession.js
@@ -878,8 +878,13 @@ export async function processHostedUtterance(sessionId, {
code: err?.code || 'TURN_FAILED',
message: err?.message || String(err),
});
+ // Without a phase frame every client stays in `thinking` (mic and text
+ // input disabled) until a reload resyncs.
session.turnPhase = 'idle';
+ emitIfLive('hosted:turn:phase', { phase: 'idle', turnId: turn.id });
session.activeTurn = null;
+ // Tells the socket handlers this failure already reached the room.
+ if (err && typeof err === 'object') err.hostedReported = true;
throw err;
}
}
diff --git a/server/sockets/fableLoomHosted.js b/server/sockets/fableLoomHosted.js
index 946147b5a2..9d64fb8d3f 100644
--- a/server/sockets/fableLoomHosted.js
+++ b/server/sockets/fableLoomHosted.js
@@ -277,7 +277,7 @@ export function registerFableLoomHostedNamespace(io) {
try {
await processHostedUtterance(sessionId, { audioBuffer: finalAudio, io });
} catch (err) {
- socket.emit('hosted:error', { code: err.code || 'UTTERANCE_FAILED', message: err.message });
+ if (!err?.hostedReported) socket.emit('hosted:error', { code: err.code || 'UTTERANCE_FAILED', message: err.message });
}
});
@@ -288,7 +288,7 @@ export function registerFableLoomHostedNamespace(io) {
try {
await processHostedUtterance(sessionId, { textMessage: data?.text, io });
} catch (err) {
- socket.emit('hosted:error', { code: err.code || 'TEXT_FAILED', message: err.message });
+ if (!err?.hostedReported) socket.emit('hosted:error', { code: err.code || 'TEXT_FAILED', message: err.message });
}
});
diff --git a/server/sockets/fableLoomHosted.test.js b/server/sockets/fableLoomHosted.test.js
index d061e8693b..10d202985a 100644
--- a/server/sockets/fableLoomHosted.test.js
+++ b/server/sockets/fableLoomHosted.test.js
@@ -453,14 +453,21 @@ describe('fableLoomHosted Socket.IO namespace', () => {
expect(roomEvent('hosted:story:transition')).toBeUndefined();
});
- it('emits hosted:error to the audience when the turn fails', async () => {
+ it('reports a failed turn once to the room, then returns every client to idle', async () => {
await audience.listeners['hosted:mic:start']();
records.getLoom.mockRejectedValueOnce(new Error('loom read failed'));
await audience.listeners['hosted:turn:text']({ text: 'go next' });
- expect(audience.emitted.find((e) => e.event === 'hosted:error')?.data)
- .toMatchObject({ code: 'TEXT_FAILED', message: 'loom read failed' });
+ const errors = roomEvents.filter((e) => e.event === 'hosted:error');
+ expect(errors).toHaveLength(1);
+ expect(errors[0].data).toMatchObject({ code: 'TURN_FAILED', message: 'loom read failed' });
+ expect(audience.emitted.find((e) => e.event === 'hosted:error')).toBeUndefined();
+ const names = roomEvents.map((e) => e.event);
+ const phaseAfterError = roomEvents.slice(names.indexOf('hosted:error') + 1)
+ .find((e) => e.event === 'hosted:turn:phase');
+ expect(phaseAfterError?.data).toMatchObject({ phase: 'idle' });
+ expect(getHostedSession(session.id).turnPhase).toBe('idle');
});
it('ignores hosted:turn:text when the session is not listening', async () => {