@pimote/pimote 0.1.1 → 0.3.0

package/server/dist/session-manager.js

@@ -1,6 +1,9 @@
 import { createAgentSessionRuntime, createAgentSessionServices, createAgentSessionFromServices, createEventBus, AuthStorage, ModelRegistry, getAgentDir, SessionManager as PiSessionManager, } from '@mariozechner/pi-coding-agent';
 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) {
@@ -59,6 +62,7 @@ function createSessionState(session, eventBus, config, callbacks, slotRef, folde
         panelState: new Map(),
         panelListenerUnsubs: [],
         panelThrottleTimer: null,
+        treeNavigationInProgress: false,
     };
     // Subscribe to session events
     const unsubscribe = session.subscribe((event) => {
@@ -72,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]);
     });
@@ -125,18 +136,48 @@ export class PimoteSessionManager {
     modelRegistry;
     sessions = new Map();
     idleCheckHandle = null;
+    gitBranchCheckHandle = null;
+    lastKnownGitBranchBySession = new Map();
     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;
@@ -145,7 +186,10 @@ export class PimoteSessionManager {
                 agentDir,
                 authStorage: sharedAuthStorage,
                 modelRegistry: sharedModelRegistry,
-                resourceLoaderOptions: { eventBus },
+                resourceLoaderOptions: {
+                    eventBus,
+                    ...(voiceExtensionFactory ? { extensionFactories: [voiceExtensionFactory] } : {}),
+                },
             });
             return {
                 ...(await createAgentSessionFromServices({ services, sessionManager, sessionStartEvent })),
@@ -154,9 +198,9 @@ export class PimoteSessionManager {
             };
         };
         const runtime = await createAgentSessionRuntime(factory, {
-            cwd: folderPath,
+            cwd: effectiveFolderPath,
             agentDir: getAgentDir(),
-            sessionManager: sessionFilePath ? PiSessionManager.open(sessionFilePath) : PiSessionManager.create(folderPath),
+            sessionManager,
         });
         const session = runtime.session;
         const sessionId = session.sessionId;
@@ -180,16 +224,22 @@ 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, {
             onStatusChange: (sid, fp) => this.onStatusChange?.(sid, fp),
             onAgentEnd: (sid, s) => this.handleAgentEnd(sid, s),
             sendEvent: (e) => sendSlotEvent(slot, e),
-        }, slotRef, folderPath);
+        }, slotRef, effectiveFolderPath);
         const slot = {
             runtime,
-            folderPath,
+            folderPath: effectiveFolderPath,
             eventBusRef,
             connection: null,
             sessionState,
@@ -199,6 +249,7 @@ export class PimoteSessionManager {
         };
         slotRef.slot = slot;
         this.sessions.set(sessionId, slot);
+        this.lastKnownGitBranchBySession.set(sessionId, getGitBranch(effectiveFolderPath));
         return sessionId;
     }
     handleAgentEnd(sessionId, slot) {
@@ -256,22 +307,40 @@ 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;
         await slot.runtime.dispose();
         this.sessions.delete(sessionId);
+        this.lastKnownGitBranchBySession.delete(sessionId);
         this.onSessionClosed?.(sessionId, folderPath);
     }
     /** Re-key a slot in the session map after session replacement. */
     reKeySession(slot, oldId, newId) {
         this.sessions.delete(oldId);
         this.sessions.set(newId, slot);
+        const lastKnown = this.lastKnownGitBranchBySession.get(oldId) ?? null;
+        this.lastKnownGitBranchBySession.delete(oldId);
+        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),
@@ -279,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);
     }
@@ -289,6 +363,9 @@ export class PimoteSessionManager {
         this.stopIdleCheck();
         this.idleCheckHandle = setInterval(() => {
             for (const [sessionId, slot] of this.sessions) {
+                if (slot.sessionState.treeNavigationInProgress) {
+                    continue;
+                }
                 const clientId = slot.connection?.connectedClientId ?? null;
                 const hasConnectedClient = clientId !== null && (isClientConnected?.(clientId) ?? false);
                 if (!hasConnectedClient && Date.now() - slot.sessionState.lastActivity > idleTimeout) {
@@ -298,12 +375,28 @@ export class PimoteSessionManager {
                 }
             }
         }, 60_000);
+        this.gitBranchCheckHandle = setInterval(() => {
+            for (const [sessionId, slot] of this.sessions) {
+                if (!slot.connection?.connectedClientId)
+                    continue;
+                const next = getGitBranch(slot.folderPath);
+                const prev = this.lastKnownGitBranchBySession.get(sessionId) ?? null;
+                if (next !== prev) {
+                    this.lastKnownGitBranchBySession.set(sessionId, next);
+                    this.onGitBranchChange?.(sessionId, slot.folderPath);
+                }
+            }
+        }, 3000);
     }
     stopIdleCheck() {
         if (this.idleCheckHandle !== null) {
             clearInterval(this.idleCheckHandle);
             this.idleCheckHandle = null;
         }
+        if (this.gitBranchCheckHandle !== null) {
+            clearInterval(this.gitBranchCheckHandle);
+            this.gitBranchCheckHandle = null;
+        }
     }
     async dispose() {
         this.stopIdleCheck();

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