@pimote/pimote 0.2.0 → 0.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pimote/pimote",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Web client and embedded server for pi with multi-session browser access, streaming, and extension UI support",
   "type": "module",
   "license": "MIT",
@@ -29,6 +29,8 @@
     "bin/pimote.js",
     "client/build/**",
     "server/dist/**/*.js",
+    "shared/dist/**/*.js",
+    "shared/dist/**/*.d.ts",
     "scripts/postinstall-patches.mjs",
     "patches/@mariozechner+pi-coding-agent+0.67.6.patch",
     "README.md",
@@ -38,13 +40,13 @@
     "node": ">=22.0.0"
   },
   "workspaces": [
-    "shared",
     "server",
     "client",
     "packages/panels"
   ],
   "scripts": {
-    "build": "npm run build --workspace=shared && npm run build --workspace=@pimote/server && npm run build --workspace=client",
+    "build": "npm run build:shared && npm run build --workspace=@pimote/server && npm run build --workspace=client",
+    "build:shared": "node --input-type=module -e \"import { rmSync } from 'node:fs'; rmSync('shared/dist', { recursive: true, force: true }); rmSync('shared/tsconfig.tsbuildinfo', { force: true });\" && tsc -b shared --force",
     "start": "node ./bin/pimote.js start",
     "format": "prettier --write .",
     "format:check": "prettier --check .",
@@ -74,6 +76,8 @@
   "dependencies": {
     "@fontsource-variable/jetbrains-mono": "^5.2.8",
     "@mariozechner/pi-coding-agent": "0.67.6",
+    "@sinclair/typebox": "^0.34.49",
+    "@streamparser/json": "^0.0.22",
     "patch-package": "^8.0.1",
     "web-push": "^3.6.7",
     "ws": "^8.20.0"

package/server/dist/auto-drain-on-abort.js

@@ -0,0 +1,49 @@
+// Auto-drain queued steering / follow-up messages after an aborted run.
+//
+// pi-agent-core's `runLoop` exits without polling the steering queue when
+// an abort signal fires mid-stream (see `agent-loop.js` — the
+// `stopReason === 'aborted'` branch returns immediately, before the
+// trailing `getSteeringMessages` poll). Any messages queued before / during
+// the abort would otherwise sit in the queue until something else calls
+// `agent.prompt()` or `agent.continue()`.
+//
+// In pimote this surfaces as silently-dropped user messages whenever a
+// queued steer races with an abort — most visibly during voice-mode
+// barge-in, but also for typed-mode users who queue a follow-up while the
+// agent is streaming and then hit the abort button.
+//
+// The fix is to call `agent.continue()` after the run settles: from the
+// pi-agent-core source, `continue()` explicitly drains the steering queue
+// (and falls back to follow-up if steering is empty) and replays the
+// drained messages as a fresh prompt.
+/**
+ * If `lastMessage` is the aborted-assistant synthetic that pi appends on
+ * abort and the session has queued messages, wait for the current run to
+ * settle and then drain the queue via `agent.continue()`.
+ *
+ * Idempotent: after `continue()` runs, the queue is empty so a re-entry
+ * (e.g. another agent_end) becomes a no-op. Errors from `continue()`
+ * (notably "Agent is already processing" when something else races us to
+ * a new prompt) are swallowed via `onError` — losing the auto-drain in
+ * that case is acceptable because the racing prompt itself will drain
+ * the queue inside `runLoop`'s initial `getSteeringMessages` poll.
+ */
+export async function autoDrainOnAbort(session, lastMessage, onError = (err) => console.warn('[pimote] auto-drain after abort failed', err)) {
+    if (!lastMessage || lastMessage.stopReason !== 'aborted') {
+        return;
+    }
+    try {
+        // The `agent_end` listener fires before `finishRun()` clears the
+        // run's `activeRun` reference. `waitForIdle()` resolves on the same
+        // promise that `finishRun` resolves, so awaiting it parks us until
+        // `agent.continue()` is safe to call without throwing
+        // "Agent is already processing".
+        await session.agent.waitForIdle();
+        if (session.pendingMessageCount === 0)
+            return;
+        await session.agent.continue();
+    }
+    catch (err) {
+        onError(err);
+    }
+}

package/server/dist/config.js

@@ -48,11 +48,32 @@ export async function loadConfig() {
         defaultProvider: typeof obj.defaultProvider === 'string' ? obj.defaultProvider : undefined,
         defaultModel: typeof obj.defaultModel === 'string' ? obj.defaultModel : undefined,
         defaultThinkingLevel: typeof obj.defaultThinkingLevel === 'string' ? obj.defaultThinkingLevel : undefined,
+        defaultInterpreterModel: parseModelRef(obj.defaultInterpreterModel),
+        defaultWorkerModel: parseModelRef(obj.defaultWorkerModel),
+        voice: parseVoiceConfig(obj.voice),
         vapidPublicKey: typeof obj.vapidPublicKey === 'string' ? obj.vapidPublicKey : undefined,
         vapidPrivateKey: typeof obj.vapidPrivateKey === 'string' ? obj.vapidPrivateKey : undefined,
         vapidEmail: typeof obj.vapidEmail === 'string' ? obj.vapidEmail : undefined,
     };
 }
+function parseModelRef(v) {
+    if (!v || typeof v !== 'object')
+        return undefined;
+    const o = v;
+    if (typeof o.provider !== 'string' || typeof o.modelId !== 'string')
+        return undefined;
+    return { provider: o.provider, modelId: o.modelId };
+}
+function parseVoiceConfig(v) {
+    if (!v || typeof v !== 'object')
+        return undefined;
+    const o = v;
+    return {
+        speechmuxBinary: typeof o.speechmuxBinary === 'string' ? o.speechmuxBinary : undefined,
+        speechmuxSignalUrl: typeof o.speechmuxSignalUrl === 'string' ? o.speechmuxSignalUrl : undefined,
+        speechmuxLlmWsUrl: typeof o.speechmuxLlmWsUrl === 'string' ? o.speechmuxLlmWsUrl : undefined,
+    };
+}
 export async function ensureVapidKeys(config) {
     if (config.vapidPublicKey && config.vapidPrivateKey) {
         return config;

package/server/dist/extension-ui-bridge.js

@@ -1,3 +1,4 @@
+import { UI_BRIDGE_DISABLED_IN_VOICE_MODE } from '../../shared/dist/index.js';
 import { sendSlotEvent, waitForSlotUiResponse } from './session-manager.js';
 /**
  * Creates an ExtensionUIContext implementation that bridges pi extension UI calls
@@ -12,7 +13,11 @@ import { sendSlotEvent, waitForSlotUiResponse } from './session-manager.js';
  * is updated and the bridge automatically routes to the new connection.
  * Pending UI promises survive reconnects and are replayed to the new client.
  */
-export function createExtensionUIBridge(slot, pushNotificationService) {
+export function createExtensionUIBridge(slot, pushNotificationService, options) {
+    const isVoice = () => options?.isVoiceModeActive?.() ?? false;
+    function voiceDisabledError() {
+        return new Error(UI_BRIDGE_DISABLED_IN_VOICE_MODE);
+    }
     function notifyInteraction(method, fields) {
         if (!pushNotificationService)
             return;
@@ -72,24 +77,32 @@ export function createExtensionUIBridge(slot, pushNotificationService) {
     const ui = {
         // ---- Dialog methods (send + wait for response) ----
         async select(title, options, opts) {
+            if (isVoice())
+                throw voiceDisabledError();
             const requestId = crypto.randomUUID();
             const event = sendRequest(requestId, { method: 'select', title, options });
             notifyInteraction('select', { title, options });
             return dialogWithTimeout(requestId, event, opts, undefined);
         },
         async confirm(title, message, opts) {
+            if (isVoice())
+                throw voiceDisabledError();
             const requestId = crypto.randomUUID();
             const event = sendRequest(requestId, { method: 'confirm', title, message });
             notifyInteraction('confirm', { title, message });
             return dialogWithTimeout(requestId, event, opts, false);
         },
         async input(title, placeholder, opts) {
+            if (isVoice())
+                throw voiceDisabledError();
             const requestId = crypto.randomUUID();
             const event = sendRequest(requestId, { method: 'input', title, placeholder });
             notifyInteraction('input', { title });
             return dialogWithTimeout(requestId, event, opts, undefined);
         },
         async editor(title, prefill) {
+            if (isVoice())
+                throw voiceDisabledError();
             const requestId = crypto.randomUUID();
             const event = sendRequest(requestId, { method: 'editor', title, prefill });
             notifyInteraction('editor', { title });

package/server/dist/index.js

@@ -8,6 +8,7 @@ import { PushNotificationService } from './push-notification.js';
 import { FilePushSubscriptionStore, WebPushSender, migratePushSubscriptionStore } from './push-infrastructure.js';
 import { LEGACY_PIMOTE_PUSH_SUBSCRIPTIONS_PATH, PIMOTE_PUSH_SUBSCRIPTIONS_PATH, PIMOTE_SESSION_METADATA_PATH } from './paths.js';
 import { FileSessionMetadataStore } from './session-metadata.js';
+import { buildVoiceOrchestrator } from './voice-orchestrator-boot.js';
 export async function main(options = {}) {
     let config = await loadConfig();
     config = await ensureVapidKeys(config);
@@ -23,7 +24,40 @@ export async function main(options = {}) {
     const sessionMetadataStore = new FileSessionMetadataStore(PIMOTE_SESSION_METADATA_PATH);
     await sessionMetadataStore.initialize();
     const sessionManager = new PimoteSessionManager(config, pushNotificationService);
-    const server = await createServer(config, sessionManager, folderIndex, pushNotificationService, sessionMetadataStore);
+    // Build the voice orchestrator before createServer so each WsHandler can be
+    // handed a reference. The orchestrator needs a client-registry lookup, but
+    // the real registry is created inside createServer below — so we hand it a
+    // small forwarding shim whose backing map is swapped in after createServer
+    // returns (see review finding 6: previously a Proxy-over-Map).
+    const clientRegistryRef = { current: new Map() };
+    const voiceBoot = buildVoiceOrchestrator({
+        config,
+        sessionManager,
+        clientRegistry: {
+            get: (clientId) => clientRegistryRef.current.get(clientId),
+        },
+    });
+    const server = await createServer(config, sessionManager, folderIndex, pushNotificationService, sessionMetadataStore, voiceBoot.orchestrator);
+    clientRegistryRef.current = server.clientRegistry;
+    // Suppress push notifications for sessions currently owned by a voice call.
+    // The user is on the line — we don't need to ping their phone for idle
+    // signals or extension UI prompts. Pushes resume automatically once the
+    // call ends and `isCallActive` flips back to false.
+    pushNotificationService.setSuppressionPredicate((sessionId) => voiceBoot.orchestrator.isCallActive(sessionId));
+    // Tear down orchestrator bookkeeping when a session is being closed (idle
+    // reap, explicit close). Emits call_ended{server_ended} to the owner.
+    sessionManager.onBeforeSessionClose = async (sessionId) => {
+        if (!voiceBoot.orchestrator.isCallActive(sessionId))
+            return;
+        const slot = sessionManager.getSlot(sessionId);
+        const ownerClientId = slot?.connection?.connectedClientId;
+        await voiceBoot.orchestrator.endCall({ sessionId, reason: 'server_ended' });
+        if (ownerClientId) {
+            const handler = server.clientRegistry.get(ownerClientId);
+            handler?.sendCallEndedEvent(sessionId, 'server_ended');
+        }
+    };
+    await voiceBoot.orchestrator.start();
     // Start idle session reaping with client connectivity check
     sessionManager.startIdleCheck(config.idleTimeout, (clientId) => server.clientRegistry.has(clientId));
     await server.start(port);
@@ -36,6 +70,7 @@ export async function main(options = {}) {
     // Graceful shutdown
     const shutdown = async () => {
         console.log('\n[pimote] Shutting down...');
+        await voiceBoot.shutdown();
         await sessionManager.dispose();
         await server.close();
         process.exit(0);

package/server/dist/message-mapper.js

@@ -55,13 +55,36 @@ export function extractMessageEntryIds(branch) {
     }
     return ids;
 }
+/**
+ * True when the message is pi-agent-core's synthetic aborted placeholder
+ * (pushed into agent.state.messages on session.abort() but never persisted
+ * via message_end). Identifying these lets entryId alignment skip over them.
+ */
+export function isAbortedPlaceholderMessage(msg) {
+    if (msg.role !== 'assistant')
+        return false;
+    if (msg.aborted !== true)
+        return false;
+    return msg.content.every((c) => c.type === 'text' && !c.text);
+}
 /**
  * Apply entry IDs from the session manager onto mapped messages.
- * Zips by index — both arrays must correspond 1:1.
+ *
+ * Subtle alignment: `messages` comes from `agent.state.messages`, which
+ * includes pi-agent-core's synthetic aborted placeholders (abort pushes an
+ * empty assistant into state but never persists an entry for it).
+ * `entryIds` comes from persisted session entries, which do NOT include
+ * those placeholders. We walk the messages and skip aborted placeholders
+ * so the persisted IDs land on the correct real messages.
  */
 export function applyEntryIds(messages, entryIds) {
-    for (let i = 0; i < messages.length && i < entryIds.length; i++) {
-        messages[i].entryId = entryIds[i];
+    let idIdx = 0;
+    for (let i = 0; i < messages.length; i++) {
+        if (isAbortedPlaceholderMessage(messages[i]))
+            continue;
+        if (idIdx >= entryIds.length)
+            break;
+        messages[i].entryId = entryIds[idIdx++];
     }
 }
 export function mapAgentMessage(msg) {
@@ -104,8 +127,12 @@ export function mapAgentMessage(msg) {
         console.warn('[message-mapper] Content value:', msg.content);
         content.push({ type: 'text', text: `[Unexpected content type: ${typeof msg.content}]` });
     }
-    // Log empty content for debugging
-    if (content.length === 0) {
+    // Aborted assistant turns are a real signal in voice mode (every barge-in
+    // produces one via pi-agent-core's handleRunFailure) and shouldn't be
+    // confused with malformed messages. Log the empty-content warning only
+    // when it's NOT an expected aborted turn.
+    const aborted = role === 'assistant' && msg.stopReason === 'aborted';
+    if (content.length === 0 && !aborted) {
         console.warn('[message-mapper] Empty content array for message:', { role, content: msg.content });
     }
     // Handle custom messages — preserve customType and display flag for the client
@@ -139,5 +166,10 @@ export function mapAgentMessage(msg) {
     // Note: msg.id is typically undefined for standard SDK messages (UserMessage,
     // AssistantMessage, ToolResultMessage).  Entry IDs are applied separately via
     // applyEntryIds() using the session manager's branch entries.
-    return { role, content, ...(msg.id ? { entryId: msg.id } : {}) };
+    return {
+        role,
+        content,
+        ...(msg.id ? { entryId: msg.id } : {}),
+        ...(aborted ? { aborted: true } : {}),
+    };
 }

package/server/dist/push-notification.js

@@ -2,10 +2,18 @@ export class PushNotificationService {
     sender;
     store;
     subscriptions = [];
+    suppressionPredicate;
     constructor(sender, store) {
         this.sender = sender;
         this.store = store;
     }
+    /** Install a predicate that suppresses notifications for a given session.
+     *  Used to silence pushes while a voice call owns the session — pushes
+     *  resume automatically once the predicate stops returning true (call
+     *  hangs up). Pass `undefined` to clear. */
+    setSuppressionPredicate(predicate) {
+        this.suppressionPredicate = predicate;
+    }
     /** Load subscriptions from store on startup */
     async initialize() {
         this.subscriptions = await this.store.load();
@@ -35,6 +43,9 @@ export class PushNotificationService {
     }
     /** Send push notification to all subscriptions */
     async notify(payload) {
+        if (this.suppressionPredicate?.(payload.sessionId)) {
+            return;
+        }
         const expiredEndpoints = [];
         const payloadStr = JSON.stringify(payload);
         for (const sub of this.subscriptions) {

package/server/dist/server.js

@@ -79,7 +79,7 @@ async function serveFallback(res) {
         res.end(JSON.stringify({ error: 'not found' }));
     }
 }
-export async function createServer(config, sessionManager, folderIndex, pushNotificationService, sessionMetadataStore) {
+export async function createServer(config, sessionManager, folderIndex, pushNotificationService, sessionMetadataStore, voiceOrchestrator) {
     const clientVersion = await loadClientVersion();
     if (clientVersion) {
         console.log(`[pimote] Client build version: ${clientVersion}`);
@@ -157,7 +157,7 @@ export async function createServer(config, sessionManager, folderIndex, pushNoti
         // The close handler skips cleanup when the registry already points to a
         // different handler, so this is the only place it runs.
         const existing = clientRegistry.get(clientId);
-        const handler = new WsHandler(sessionManager, folderIndex, ws, pushNotificationService, sessionMetadataStore, clientId, clientRegistry);
+        const handler = new WsHandler(sessionManager, folderIndex, ws, pushNotificationService, sessionMetadataStore, clientId, clientRegistry, voiceOrchestrator);
         clientRegistry.set(clientId, handler);
         if (existing) {
             existing.cleanup();

package/server/dist/session-manager.js

@@ -2,6 +2,8 @@ import { createAgentSessionRuntime, createAgentSessionServices, createAgentSessi
 import { EventBuffer } from './event-buffer.js';
 import { applyPanelMessage, getMergedPanelCards } from './panel-state.js';
 import { getGitBranch } from './git-branch.js';
+import { createVoiceExtension } from './voice/index.js';
+import { autoDrainOnAbort } from './auto-drain-on-abort.js';
 // ---- Slot-based helpers (operate on ManagedSlot) ----
 /** Send an event to the client connected to this slot. No-op if disconnected. */
 export function sendSlotEvent(slot, event) {
@@ -53,7 +55,7 @@ function createSessionState(session, eventBus, config, callbacks, slotRef, folde
         eventBuffer,
         status: session.isStreaming ? 'working' : 'idle',
         needsAttention: false,
-        lastActivity: Date.now(),
+        idleSince: session.isStreaming ? null : Date.now(),
         unsubscribe: () => { },
         pendingUiResponses: new Map(),
         extensionsBound: false,
@@ -66,14 +68,23 @@ function createSessionState(session, eventBus, config, callbacks, slotRef, folde
     const unsubscribe = session.subscribe((event) => {
         if (event.type === 'agent_start' && state.status !== 'working') {
             state.status = 'working';
+            state.idleSince = null;
             callbacks.onStatusChange?.(sessionId, folderPath);
         }
         else if (event.type === 'agent_end' && state.status !== 'idle') {
             state.status = 'idle';
+            state.idleSince = Date.now();
             state.needsAttention = true;
             if (slotRef.slot)
                 callbacks.onAgentEnd?.(sessionId, slotRef.slot);
             callbacks.onStatusChange?.(sessionId, folderPath);
+            // If the run ended via abort and there are queued steering /
+            // follow-up messages, drain them — pi-agent-core's runLoop skips
+            // its trailing queue poll on the abort exit path, so without this
+            // queued messages would sit until the next prompt() call. Universal
+            // across pimote (not voice-specific) so typed-mode users also
+            // benefit. See `auto-drain-on-abort.ts` for rationale.
+            void autoDrainOnAbort(session, event.messages[event.messages.length - 1]);
         }
         eventBuffer.onEvent(event, sessionId, (e) => callbacks.sendEvent(e), () => session.messages[session.messages.length - 1]);
     });
@@ -132,18 +143,43 @@ export class PimoteSessionManager {
     onStatusChange;
     onSessionClosed;
     onGitBranchChange;
+    /** Fired synchronously before a session's state is torn down (e.g. idle
+     *  reap, explicit close). Consumers use this to drop external bookkeeping
+     *  (e.g. `VoiceOrchestrator.endCall`) while the session is still addressable. */
+    onBeforeSessionClose;
     constructor(config, pushNotificationService) {
         this.config = config;
         this.pushNotificationService = pushNotificationService;
         this.authStorage = AuthStorage.create();
         this.modelRegistry = ModelRegistry.create(this.authStorage);
     }
+    /**
+     * Build the voice extension factory for this server's config, if possible.
+     * Returns undefined (and logs a warning) when neither voice-specific model
+     * refs nor fallback defaultProvider/defaultModel are configured — existing
+     * non-voice deployments continue to work unchanged.
+     */
+    buildVoiceExtensionFactory() {
+        const interpreter = this.config.defaultInterpreterModel ??
+            (this.config.defaultProvider && this.config.defaultModel ? { provider: this.config.defaultProvider, modelId: this.config.defaultModel } : undefined);
+        const worker = this.config.defaultWorkerModel ??
+            (this.config.defaultProvider && this.config.defaultModel ? { provider: this.config.defaultProvider, modelId: this.config.defaultModel } : undefined);
+        if (!interpreter || !worker) {
+            console.warn('[pimote] voice extension disabled: no defaultInterpreterModel/defaultWorkerModel or fallback defaultProvider/defaultModel in config');
+            return undefined;
+        }
+        return createVoiceExtension({
+            defaultInterpreterModel: interpreter,
+            defaultWorkerModel: worker,
+        });
+    }
     async openSession(folderPath, sessionFilePath) {
         const eventBusRef = { current: null };
         const sharedAuthStorage = this.authStorage;
         const sharedModelRegistry = this.modelRegistry;
         const sessionManager = sessionFilePath ? PiSessionManager.open(sessionFilePath) : PiSessionManager.create(folderPath);
         const effectiveFolderPath = sessionFilePath ? sessionManager.getCwd() : folderPath;
+        const voiceExtensionFactory = this.buildVoiceExtensionFactory();
         const factory = async ({ cwd, agentDir, sessionManager, sessionStartEvent }) => {
             const eventBus = createEventBus();
             eventBusRef.current = eventBus;
@@ -152,7 +188,10 @@ export class PimoteSessionManager {
                 agentDir,
                 authStorage: sharedAuthStorage,
                 modelRegistry: sharedModelRegistry,
-                resourceLoaderOptions: { eventBus },
+                resourceLoaderOptions: {
+                    eventBus,
+                    ...(voiceExtensionFactory ? { extensionFactories: [voiceExtensionFactory] } : {}),
+                },
             });
             return {
                 ...(await createAgentSessionFromServices({ services, sessionManager, sessionStartEvent })),
@@ -187,6 +226,12 @@ export class PimoteSessionManager {
             session.setThinkingLevel(this.config.defaultThinkingLevel);
             console.log(`[pimote] Set default thinking level: ${this.config.defaultThinkingLevel}`);
         }
+        // Pimote convention: drain the entire steering / follow-up queue into a
+        // single consolidated run rather than one message per run. Matches the
+        // UX expectation that queued messages are delivered together when the
+        // agent next processes, not metered out across multiple turns.
+        session.setSteeringMode('all');
+        session.setFollowUpMode('all');
         // Create the slot object. Use a slotRef so createSessionState callbacks can reference the slot.
         const slotRef = { slot: null };
         const sessionState = createSessionState(session, eventBusRef.current, this.config, {
@@ -264,6 +309,14 @@ export class PimoteSessionManager {
         const slot = this.sessions.get(sessionId);
         if (!slot)
             return;
+        if (this.onBeforeSessionClose) {
+            try {
+                await this.onBeforeSessionClose(sessionId, slot.folderPath);
+            }
+            catch (err) {
+                console.warn('[pimote] onBeforeSessionClose threw:', err);
+            }
+        }
         teardownSessionState(slot.sessionState);
         slot.eventBusRef.current?.clear();
         const folderPath = slot.folderPath;
@@ -281,9 +334,15 @@ export class PimoteSessionManager {
         this.lastKnownGitBranchBySession.set(newId, lastKnown);
     }
     /** Rebuild a slot's SessionState after session replacement.
-     *  Tears down the old state and creates a new one from the current runtime.session. */
+     *  Tears down the old state and creates a new one from the current runtime.session.
+     *  Also refreshes slot.folderPath from the new session's header cwd, since fork-from
+     *  (e.g. the worktree extension) can rebind the slot to a session whose cwd differs
+     *  from the original. */
     rebuildSessionState(slot) {
         teardownSessionState(slot.sessionState);
+        const newCwd = slot.runtime.session.sessionManager.getCwd();
+        if (newCwd)
+            slot.folderPath = newCwd;
         const slotRef = { slot: slot };
         slot.sessionState = createSessionState(slot.runtime.session, slot.eventBusRef.current, this.config, {
             onStatusChange: (sid, fp) => this.onStatusChange?.(sid, fp),
@@ -291,6 +350,11 @@ export class PimoteSessionManager {
             sendEvent: (e) => sendSlotEvent(slot, e),
         }, slotRef, slot.folderPath);
     }
+    /** Alias for getSession that returns null (not undefined) for consumers
+     *  that expect nullable pointers (e.g. VoiceSessionBusResolver). */
+    getSlot(sessionId) {
+        return this.sessions.get(sessionId) ?? null;
+    }
     getSession(sessionId) {
         return this.sessions.get(sessionId);
     }
@@ -306,7 +370,11 @@ export class PimoteSessionManager {
                 }
                 const clientId = slot.connection?.connectedClientId ?? null;
                 const hasConnectedClient = clientId !== null && (isClientConnected?.(clientId) ?? false);
-                if (!hasConnectedClient && Date.now() - slot.sessionState.lastActivity > idleTimeout) {
+                // Only idle (non-streaming) sessions are eligible for reaping. `idleSince` is set on
+                // `agent_end` and cleared on `agent_start`, so a working session can never be reaped
+                // here, regardless of how long it's been since a client was connected.
+                const idleSince = slot.sessionState.idleSince;
+                if (!hasConnectedClient && idleSince !== null && Date.now() - idleSince > idleTimeout) {
                     this.closeSession(sessionId).catch(() => {
                         // Best-effort cleanup — swallow errors during idle reaping
                     });

package/server/dist/voice/fsm/actions.js

@@ -0,0 +1,6 @@
+// Actions emitted by the voice FSM reducer.
+//
+// The reducer is pure: every side effect is encoded as one of these
+// values. The shell in `index.ts` interprets each into an actual call
+// against the pi SDK / speechmux WS / EventBus.
+export {};

package/server/dist/voice/fsm/events.js

@@ -0,0 +1,7 @@
+// Events the voice FSM consumes.
+//
+// Every external stimulus (EventBus, WS lifecycle, WS frames, SDK hooks)
+// is normalized into one of these typed events before reaching the
+// reducer. The shell in `index.ts` is the only place where ad-hoc input
+// translation lives.
+export {};

package/server/dist/voice/fsm/reducer.js

@@ -0,0 +1,74 @@
+// Top-level voice FSM reducer.
+//
+// Folds the three sub-reducers (lifecycle, streaming, walkback) into a
+// single transition. Every event is fanned out to the sub-reducers
+// that care about it; results are merged.
+//
+// The sub-reducers don't know about each other. Two cross-cutting bits
+// are handled here:
+//
+// 1. Frame buffering. The streaming reducer emits raw `OutgoingFrame`
+//    values; we route each through `bufferOrPassFrame` against the
+//    current lifecycle state to either forward (Active) or buffer
+//    (Activating). The buffered case mutates the lifecycle slice; the
+//    forwarded case becomes a `send_frame` action.
+//
+// 2. The `ws:incoming` `user` frame turns into a `send_user_message`
+//    action — and only when lifecycle is `active`. (The walkback
+//    reducer intentionally ignores user frames; this is the right
+//    place to handle them because it lives at the boundary between
+//    "do we even have a connection" and "what should the agent do".)
+import { reduceLifecycle, applyLifecycleResult, bufferOrPassFrame } from './reducers/lifecycle.js';
+import { reduceStreaming } from './reducers/streaming.js';
+import { reduceWalkback, applyWalkbackResult } from './reducers/walkback.js';
+export function reduce(prev, event, reducers) {
+    let state = prev;
+    const actions = [];
+    // ---- Lifecycle ---------------------------------------------------------
+    const life = reduceLifecycle(state.lifecycle, event, {
+        interpreterApplied: state.interpreterApplied,
+        config: reducers.config,
+    });
+    state = applyLifecycleResult(state, life);
+    actions.push(...life.actions);
+    // ---- Streaming ---------------------------------------------------------
+    // Only meaningful when activating or active. Dormant means we can't
+    // emit frames anywhere, so skip the work and any accidental frames.
+    if (state.lifecycle.kind !== 'dormant') {
+        const stream = reduceStreaming(state.message, event);
+        state = { ...state, message: stream.next };
+        for (const frame of stream.frames) {
+            const routed = bufferOrPassFrame(state.lifecycle, frame);
+            state = { ...state, lifecycle: routed.next };
+            actions.push(...routed.actions);
+        }
+        // Fold the latest ended speak id into runtime so walkback has a
+        // fallback target if speechmux's rollback/abort doesn't echo a
+        // speak_id (e.g. older speechmux build).
+        if (stream.endedSpeakIds.length > 0) {
+            state = {
+                ...state,
+                lastEmittedSpeakId: stream.endedSpeakIds[stream.endedSpeakIds.length - 1] ?? state.lastEmittedSpeakId,
+            };
+        }
+    }
+    // ---- Walkback ----------------------------------------------------------
+    const wb = reduceWalkback(state.walkback, state.lastEmittedSpeakId, event);
+    state = applyWalkbackResult(state, wb);
+    actions.push(...wb.actions);
+    // Clear lastEmittedSpeakId on full deactivation so a subsequent call
+    // doesn't carry it over.
+    if (event.type === 'eb:deactivate') {
+        state = { ...state, lastEmittedSpeakId: null };
+    }
+    // ---- Cross-cutting: incoming `user` frame → sendUserMessage ------------
+    if (event.type === 'ws:incoming' && event.frame.type === 'user') {
+        if (state.lifecycle.kind === 'active') {
+            actions.push({ kind: 'send_user_message', text: event.frame.text });
+        }
+        // If lifecycle isn't active, drop. The shell will log this — it
+        // means a user frame arrived after we tore down (or before we
+        // wired the WS), both of which are bugs upstream.
+    }
+    return { next: state, actions };
+}