@pimote/pimote 0.2.0 → 0.3.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/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) {
@@ -74,6 +76,13 @@ function createSessionState(session, eventBus, config, callbacks, slotRef, folde
             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 +141,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 +186,10 @@ export class PimoteSessionManager {
                 agentDir,
                 authStorage: sharedAuthStorage,
                 modelRegistry: sharedModelRegistry,
-                resourceLoaderOptions: { eventBus },
+                resourceLoaderOptions: {
+                    eventBus,
+                    ...(voiceExtensionFactory ? { extensionFactories: [voiceExtensionFactory] } : {}),
+                },
             });
             return {
                 ...(await createAgentSessionFromServices({ services, sessionManager, sessionStartEvent })),
@@ -187,6 +224,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 +307,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 +332,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 +348,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);
     }

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 };
+}

package/server/dist/voice/fsm/reducers/lifecycle.js

@@ -0,0 +1,146 @@
+// Concern A: Lifecycle reducer.
+//
+// Responsible for:
+// - Activate / deactivate of voice mode.
+// - WS connection lifecycle (opened / failed / disconnected).
+// - Buffering of outgoing speak frames during the `activating` window
+//   and flushing them on `ws:opened`.
+//
+// Holds NO knowledge of the streaming / walkback machines. Those plug in
+// through the top-level dispatcher.
+import { VOICE_CALL_STARTED_SENTINEL } from '../../state-machine.js';
+/**
+ * Pure transition function for the lifecycle slice.
+ *
+ * Emits the bulk of the side-effect actions: model setup, sentinel user
+ * message, WS open/close, deactivate-request.
+ *
+ * Frame emission policy: whenever the streaming machine produces a
+ * `send_frame` action, it goes via the top-level dispatcher into
+ * `bufferOrPassFrame()` below — which either forwards it (Active) or
+ * appends to `pendingFrames` (Activating). On `ws:opened` we flush in
+ * order.
+ */
+export function reduceLifecycle(prev, event, ctx) {
+    switch (event.type) {
+        case 'eb:activate': {
+            if (prev.kind !== 'dormant') {
+                // Re-activation while already active or activating is a no-op
+                // — the orchestrator's bind path is supposed to be the single
+                // owner. We log loudly in the shell; here we just stay put.
+                return { next: prev, interpreterAppliedNow: false, actions: [] };
+            }
+            const actions = [];
+            if (!ctx.interpreterApplied) {
+                actions.push({
+                    kind: 'set_interpreter_model',
+                    provider: ctx.config.defaultInterpreterModel.provider,
+                    modelId: ctx.config.defaultInterpreterModel.modelId,
+                });
+            }
+            actions.push({ kind: 'send_user_message', text: VOICE_CALL_STARTED_SENTINEL });
+            actions.push({ kind: 'open_ws', url: event.msg.speechmuxWsUrl });
+            return {
+                next: {
+                    kind: 'activating',
+                    sessionId: event.msg.sessionId,
+                    wsUrl: event.msg.speechmuxWsUrl,
+                    pendingFrames: [],
+                },
+                interpreterAppliedNow: !ctx.interpreterApplied,
+                actions,
+            };
+        }
+        case 'eb:deactivate': {
+            if (prev.kind === 'dormant') {
+                return { next: prev, interpreterAppliedNow: false, actions: [] };
+            }
+            // Idempotent: close_ws is a no-op if no client is open.
+            return {
+                next: { kind: 'dormant' },
+                interpreterAppliedNow: false,
+                actions: [{ kind: 'close_ws' }],
+            };
+        }
+        case 'ws:opened': {
+            if (prev.kind !== 'activating') {
+                // Stray opened event (e.g. after a deactivate-then-open race).
+                // Close the new connection if we somehow have one.
+                return { next: prev, interpreterAppliedNow: false, actions: [] };
+            }
+            const actions = [];
+            // Flush buffered speak frames in arrival order. Done here, not
+            // in the streaming reducer, so frame ordering is preserved across
+            // the activating→active boundary.
+            for (const frame of prev.pendingFrames) {
+                actions.push({ kind: 'send_frame', frame });
+            }
+            return {
+                next: { kind: 'active', sessionId: prev.sessionId },
+                interpreterAppliedNow: false,
+                actions,
+            };
+        }
+        case 'ws:open_failed': {
+            if (prev.kind !== 'activating') {
+                return { next: prev, interpreterAppliedNow: false, actions: [] };
+            }
+            // Drop any buffered frames; the shell will rebuild from scratch
+            // on the next activate.
+            return {
+                next: { kind: 'dormant' },
+                interpreterAppliedNow: false,
+                actions: [{ kind: 'emit_deactivate_request' }],
+            };
+        }
+        case 'ws:disconnected': {
+            if (prev.kind === 'dormant') {
+                return { next: prev, interpreterAppliedNow: false, actions: [] };
+            }
+            return {
+                next: { kind: 'dormant' },
+                interpreterAppliedNow: false,
+                actions: [{ kind: 'emit_deactivate_request' }],
+            };
+        }
+        default:
+            return { next: prev, interpreterAppliedNow: false, actions: [] };
+    }
+}
+/**
+ * Apply a `send_frame` action against the lifecycle state. Returns
+ * either the same action (to be executed by the shell) or a state
+ * mutation that buffers the frame for later flush.
+ *
+ * Splitting this out keeps the streaming reducer agnostic of the
+ * lifecycle phase — it always emits `send_frame`; this function decides
+ * whether to forward or buffer.
+ */
+export function bufferOrPassFrame(prev, frame) {
+    switch (prev.kind) {
+        case 'dormant':
+            // Frame produced while no call is bound — drop. Streaming reducer
+            // is supposed to no-op while dormant; if we land here it's a
+            // diagnostic the shell will log.
+            return { next: prev, actions: [] };
+        case 'activating':
+            return {
+                next: { ...prev, pendingFrames: [...prev.pendingFrames, frame] },
+                actions: [],
+            };
+        case 'active':
+            return { next: prev, actions: [{ kind: 'send_frame', frame }] };
+    }
+}
+/**
+ * Top-level merge helper used by the dispatcher to splice the lifecycle
+ * sub-state back into the runtime record. Kept here so the dispatcher
+ * stays mechanical.
+ */
+export function applyLifecycleResult(prev, r) {
+    return {
+        ...prev,
+        lifecycle: r.next,
+        interpreterApplied: prev.interpreterApplied || r.interpreterAppliedNow,
+    };
+}