@pimote/pimote 0.6.0 → 0.8.0

package/server/dist/session-manager.js

@@ -2,6 +2,7 @@ import { createAgentSessionRuntime, createAgentSessionServices, createAgentSessi
 import { EventBuffer } from './event-buffer.js';
 import { applyPanelMessage, getMergedPanelCards } from './panel-state.js';
 import { getGitBranch } from './git-branch.js';
+import { LoginOrchestrator } from './login-orchestrator.js';
 import { createVoiceExtension } from './voice/index.js';
 import { autoDrainOnAbort } from './auto-drain-on-abort.js';
 // ---- Slot-based helpers (operate on ManagedSlot) ----
@@ -143,12 +144,33 @@ function scheduleSlotPanelPush(state, sessionId, sendEvent) {
         sendEvent({ type: 'panel_update', sessionId, cards });
     }, 200);
 }
+/**
+ * Coalesce concurrent async operations keyed by `key`: while one is in flight,
+ * callers passing the same key share its promise instead of starting a second
+ * run. The map entry is cleared once the operation settles, so a later call
+ * with the same key runs fresh.
+ */
+export async function singleFlight(map, key, run) {
+    const inflight = map.get(key);
+    if (inflight)
+        return inflight;
+    const p = run().finally(() => {
+        map.delete(key);
+    });
+    map.set(key, p);
+    return p;
+}
 export class PimoteSessionManager {
     config;
     pushNotificationService;
     authStorage;
     modelRegistry;
+    loginOrchestrator;
     sessions = new Map();
+    /** In-flight `openSession` promises keyed by session file path, so two
+     *  concurrent opens of the same on-disk session share one runtime instead
+     *  of building (and leaking) a second one over the same file. */
+    inFlightOpens = new Map();
     idleCheckHandle = null;
     gitBranchCheckHandle = null;
     lastKnownGitBranchBySession = new Map();
@@ -159,12 +181,18 @@ export class PimoteSessionManager {
      *  reap, explicit close). Consumers use this to drop external bookkeeping
      *  (e.g. `VoiceOrchestrator.endCall`) while the session is still addressable. */
     onBeforeSessionClose;
+    /** Fired when a re-key collision evicts the slot currently holding the target
+     *  session ID, BEFORE that slot is closed. Consumers notify the evicted slot's
+     *  owning client (e.g. a `session_closed`/displaced event) while it is still
+     *  addressable via getSlot. */
+    onSlotEvicted;
     staticHostFactory;
     constructor(config, pushNotificationService, options = {}) {
         this.config = config;
         this.pushNotificationService = pushNotificationService;
         this.authStorage = AuthStorage.create();
         this.modelRegistry = ModelRegistry.create(this.authStorage);
+        this.loginOrchestrator = new LoginOrchestrator(this.authStorage, this.modelRegistry);
         this.staticHostFactory = options.staticHostFactory;
     }
     /**
@@ -191,7 +219,37 @@ export class PimoteSessionManager {
             defaultWorkerModel: worker,
         });
     }
+    /**
+     * Open (or reopen) a session, returning its id.
+     *
+     * For an existing on-disk session (`sessionFilePath` provided), this guards
+     * against ever binding a SECOND pi runtime to the same session file: it
+     * returns the already-open session's id when it's live in memory, and
+     * coalesces concurrent opens of the same file into a single runtime. Without
+     * this, a reconnect double-fire or two devices opening the same session race
+     * between the (miss) existence check and the eventual `sessions.set`, spawn
+     * two runtimes appending to one file (corrupting history), and leak the
+     * first. New sessions (no file) create a fresh file each time, so they need
+     * no coalescing.
+     */
     async openSession(folderPath, sessionFilePath) {
+        if (!sessionFilePath) {
+            return this.doOpenSession(folderPath);
+        }
+        const alreadyOpenId = this.findSlotIdBySessionFile(sessionFilePath);
+        if (alreadyOpenId)
+            return alreadyOpenId;
+        return singleFlight(this.inFlightOpens, sessionFilePath, () => this.doOpenSession(folderPath, sessionFilePath));
+    }
+    /** Find the id of an open slot bound to the given session file, if any. */
+    findSlotIdBySessionFile(sessionFilePath) {
+        for (const [sid, slot] of this.sessions) {
+            if (slot.session.sessionFile === sessionFilePath)
+                return sid;
+        }
+        return undefined;
+    }
+    async doOpenSession(folderPath, sessionFilePath) {
         const eventBusRef = { current: null };
         const sharedAuthStorage = this.authStorage;
         const sharedModelRegistry = this.modelRegistry;
@@ -271,7 +329,7 @@ export class PimoteSessionManager {
         };
         slotRef.slot = slot;
         this.sessions.set(sessionId, slot);
-        this.lastKnownGitBranchBySession.set(sessionId, getGitBranch(effectiveFolderPath));
+        this.lastKnownGitBranchBySession.set(sessionId, await getGitBranch(effectiveFolderPath));
         return sessionId;
     }
     handleAgentEnd(sessionId, slot) {
@@ -353,6 +411,45 @@ export class PimoteSessionManager {
         this.lastKnownGitBranchBySession.delete(oldId);
         this.lastKnownGitBranchBySession.set(newId, lastKnown);
     }
+    /** Sync read of the cached git branch for a session. Refreshed every 3s by the
+     *  branch-check poll and seeded on open, so hot paths (sidebar broadcasts,
+     *  get_session_meta) read this instead of shelling out to git on the event loop.
+     *  May be up to ~3s stale; branch changes are rare so this is invisible in practice. */
+    getLastKnownGitBranch(sessionId) {
+        return this.lastKnownGitBranchBySession.get(sessionId) ?? null;
+    }
+    /** The single "session was replaced" business operation. Reconciles the session
+     *  map (rebuild state, evict any collision, re-key) ALWAYS — regardless of whether
+     *  a client owns the slot — so a reset triggered with no live owner can never leave
+     *  the map keyed under a stale ID. Then notifies whatever connection currently owns
+     *  the slot (never the issuer). All reset entry points (newSession/fork/navigateTree/
+     *  switchSession, via WS commands or extension command-context) funnel here. */
+    async applySessionReset(slot) {
+        const newId = slot.runtime.session.sessionId;
+        const oldId = slot.sessionState.id;
+        // navigateTree stays in the same file — same session ID, nothing to re-key.
+        if (newId === oldId) {
+            await slot.connection?.onSessionReset?.(slot, { kind: 'unchanged' });
+            return;
+        }
+        // Rebuild session state (tears down old, creates new from runtime.session).
+        // Refreshes slot.folderPath from the new session header cwd (fork-from can
+        // change cwd, e.g. the worktree extension), so read folderPath after this.
+        this.rebuildSessionState(slot);
+        // Collision: another live slot already holds newId. This happens when an
+        // extension calls ctx.switchSession(path) onto a session file already open in
+        // a different slot (the new ID is the target file's existing ID, not a fresh
+        // one like fork's). Without eviction, reKeySession would overwrite the
+        // occupant's map entry and orphan its runtime — two runtimes on one file.
+        // Treat it as a takeover: notify the occupant's owner, then dispose it.
+        const occupant = this.sessions.get(newId);
+        if (occupant && occupant !== slot) {
+            this.onSlotEvicted?.(newId);
+            await this.closeSession(newId);
+        }
+        this.reKeySession(slot, oldId, newId);
+        await slot.connection?.onSessionReset?.(slot, { kind: 'rekeyed', oldId, newId, folderPath: slot.folderPath });
+    }
     /** Rebuild a slot's SessionState after session replacement.
      *  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
@@ -378,6 +475,10 @@ export class PimoteSessionManager {
     getSession(sessionId) {
         return this.sessions.get(sessionId);
     }
+    /** The shared, server-wide login orchestrator (login is global, not session-scoped). */
+    getLoginOrchestrator() {
+        return this.loginOrchestrator;
+    }
     getAllSessions() {
         return Array.from(this.sessions.values());
     }
@@ -402,16 +503,18 @@ 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);
+            // Snapshot connected sessions and refresh their branches in parallel. The
+            // lookups are async (execFile) so the poll never blocks the event loop;
+            // hot-path readers consume the cache via getLastKnownGitBranch.
+            const connected = [...this.sessions].filter(([, slot]) => slot.connection?.connectedClientId);
+            void Promise.all(connected.map(async ([sessionId, slot]) => {
+                const next = await 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() {

package/server/dist/static-host/gc.js

@@ -25,6 +25,19 @@ export async function gcStaticHostStore(args) {
     }
     const suffix = '.json';
     for (const name of entries) {
+        // Orphan write tmp file (`<sessionId>.json.tmp`) left by a crash between
+        // writeFile and rename. GC runs at boot before any write, so a leftover
+        // .tmp is always stale — unlink unconditionally.
+        if (name.endsWith('.json.tmp')) {
+            try {
+                await unlink(join(storeDir, name));
+            }
+            catch (err) {
+                if (err.code !== 'ENOENT')
+                    throw err;
+            }
+            continue;
+        }
         if (!name.endsWith(suffix))
             continue;
         const sessionId = name.slice(0, -suffix.length);

package/server/dist/static-host/http-handler.js

@@ -1,5 +1,5 @@
 import { createReadStream } from 'node:fs';
-import { stat } from 'node:fs/promises';
+import { stat, realpath } from 'node:fs/promises';
 import path from 'node:path';
 const MIME_TYPES = {
     '.html': 'text/html; charset=utf-8',
@@ -126,11 +126,37 @@ export async function serveStaticHostRoute(req, res, registry) {
         send404(res);
         return true;
     }
+    // Symlink containment: stat()/createReadStream() follow symlinks, so a symlink
+    // INSIDE the bundle could point outside it (the `..` and path.resolve checks
+    // above are lexical and cannot see this). Resolve symlinks on both the target
+    // and the registered folder and require the real target to stay within.
+    try {
+        const [realTarget, realFolder] = await Promise.all([realpath(resolved), realpath(folderPath)]);
+        if (realTarget !== realFolder && !realTarget.startsWith(realFolder + path.sep)) {
+            send404(res);
+            return true;
+        }
+    }
+    catch {
+        send404(res);
+        return true;
+    }
     const ext = path.extname(resolved).toLowerCase();
     const mime = MIME_TYPES[ext] || 'application/octet-stream';
     res.writeHead(200, {
         'Content-Type': mime,
         'Cache-Control': 'no-cache, no-store, must-revalidate',
+        // Agent-authored content served same-origin with the control PWA. Two
+        // hardening headers (review finding M4):
+        //  - nosniff: never let the browser MIME-sniff a bundle file into a script.
+        //  - CSP connect-src http:/https: blocks ws:/wss:, so a (prompt-injected)
+        //    bundle cannot open pimote's authenticated WebSocket and drive sessions.
+        //    We stay same-origin (not sandboxed) so bundles keep localStorage and
+        //    same-origin asset fetches; same-origin HTTP fetch + storage reads remain
+        //    possible but are contained by the single-user model + edge auth. Full
+        //    isolation would require serving bundles from a separate origin.
+        'X-Content-Type-Options': 'nosniff',
+        'Content-Security-Policy': 'connect-src http: https:',
     });
     if (req.method === 'HEAD') {
         res.end();

package/server/dist/static-host/index.js

@@ -1,5 +1,5 @@
 import { Type } from 'typebox';
-import { executeRegisterTool, executeRemoveTool } from './tools.js';
+import { executeRegisterTool, executeRemoveTool, resolveSlugCollision } from './tools.js';
 import { STATIC_HOST_TOOL_DESCRIPTION } from './prompt.js';
 export { InMemoryStaticHostRegistry } from './registry.js';
 export { FileStaticHostStore } from './store.js';
@@ -94,23 +94,35 @@ export function createStaticHostExtension(opts) {
             const file = await store.read(sessionId);
             if (!file)
                 return;
+            // Replay persisted entries, re-suffixing any slug already taken (another
+            // session persisted the same slug, or this session reloaded earlier this
+            // boot). Re-suffixing keeps the bundle reachable; the old behaviour left a
+            // phantom entry in the file that the remove tool could never match (its
+            // registry lookup failed) and that got re-appended on every future write.
+            const replayed = [];
+            let mutated = false;
             for (const entry of file.entries) {
+                let slug = entry.slug;
+                if (registry.has(slug)) {
+                    slug = resolveSlugCollision(slug, registry);
+                    mutated = true;
+                }
                 try {
-                    registry.register({
-                        slug: entry.slug,
-                        folderPath: entry.folderPath,
-                        sessionId,
-                        cardMetadata: entry.cardMetadata,
-                    });
+                    registry.register({ slug, folderPath: entry.folderPath, sessionId, cardMetadata: entry.cardMetadata });
+                    replayed.push(slug === entry.slug ? entry : { ...entry, slug });
                 }
                 catch (err) {
-                    // Defensive: a slug conflict (e.g. two sessions persisted the same
-                    // slug, or another session reloaded earlier this boot) must not
-                    // abort the whole replay loop and leave the session partially
-                    // loaded. Skip the conflicting entry and continue.
-                    console.warn(`[static-host] session_start: skipping persisted entry ${entry.slug} for session ${sessionId}`, err);
+                    // Couldn't register even after re-suffixing — drop it from the file so
+                    // it doesn't linger as a phantom on the next write.
+                    mutated = true;
+                    console.warn(`[static-host] session_start: dropping unregisterable entry ${entry.slug} for session ${sessionId}`, err);
                 }
             }
+            // Persist the reconciled list only if something changed, so the common
+            // conflict-free replay performs no write.
+            if (mutated) {
+                await store.write(sessionId, { version: 1, entries: replayed });
+            }
             emitPanelCards(pi, sessionId);
         });
         pi.on('session_shutdown', async (_ev, ctx) => {

package/server/dist/static-host/store.js

@@ -22,7 +22,16 @@ export class FileStaticHostStore {
                 return undefined;
             throw err;
         }
-        return JSON.parse(raw);
+        try {
+            return JSON.parse(raw);
+        }
+        catch (err) {
+            // A truncated/corrupt file must not reject out of the async session_start
+            // handler (which could break session load). Treat it as "no state" — the
+            // next write overwrites it atomically.
+            console.warn(`[static-host] ignoring corrupt store file ${path}:`, err.message ?? err);
+            return undefined;
+        }
     }
     async write(sessionId, file) {
         await mkdir(this.storeDir, { recursive: true });

package/server/dist/static-host/tools.js

@@ -1,5 +1,5 @@
 import { stat } from 'node:fs/promises';
-import { isAbsolute, join } from 'node:path';
+import { isAbsolute, join, resolve } from 'node:path';
 /**
  * Validates and normalises a slug.
  *
@@ -56,6 +56,10 @@ export async function executeRegisterTool(input, deps) {
     if (typeof input.folder !== 'string' || !isAbsolute(input.folder)) {
         throw new Error(`folder must be an absolute path: ${JSON.stringify(input.folder)}`);
     }
+    // Normalize before stat/persist/register: a trailing slash or internal `..`
+    // segment would otherwise break the http-handler's containment check (which
+    // compares a resolved request path against `folderPath + path.sep`).
+    input.folder = resolve(input.folder);
     let folderStat;
     try {
         folderStat = await stat(input.folder);

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

@@ -19,7 +19,7 @@
 //    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 { reduceStreaming, currentStreamingSpeakId } from './reducers/streaming.js';
 import { reduceWalkback, applyWalkbackResult } from './reducers/walkback.js';
 export function reduce(prev, event, reducers) {
     let state = prev;
@@ -53,7 +53,19 @@ export function reduce(prev, event, reducers) {
         }
     }
     // ---- Walkback ----------------------------------------------------------
-    const wb = reduceWalkback(state.walkback, state.lastEmittedSpeakId, event);
+    // Pass:
+    //  - lifecycle kind, so abort/rollback frames arriving when no call is active
+    //    are dropped (e.g. in flight during teardown) — a stray abort would
+    //    otherwise abort a text-mode turn. (H3)
+    //  - the in-flight speak id, so an interrupt targeting a still-streaming
+    //    speak resolves correctly when the frame omits a speak_id. (gap 2)
+    // `state.message` is post-streaming here, so its blocks still hold the
+    // in-flight speak (ws:incoming doesn't clear them).
+    const wb = reduceWalkback(state.walkback, event, {
+        lastEmittedSpeakId: state.lastEmittedSpeakId,
+        currentStreamingSpeakId: currentStreamingSpeakId(state.message),
+        lifecycleKind: state.lifecycle.kind,
+    });
     state = applyWalkbackResult(state, wb);
     actions.push(...wb.actions);
     // Clear lastEmittedSpeakId on full deactivation so a subsequent call

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

@@ -38,7 +38,11 @@ export function reduceLifecycle(prev, event, ctx) {
                     modelId: ctx.config.defaultInterpreterModel.modelId,
                 });
             }
-            actions.push({ kind: 'send_user_message', text: VOICE_CALL_STARTED_SENTINEL });
+            // Steer the start sentinel rather than aborting: if the agent is mid-task
+            // when the call binds, preserve that work. The executor injects into the
+            // running turn when busy, and sends normally (triggering the greeting)
+            // when idle. (M7)
+            actions.push({ kind: 'send_user_message', text: VOICE_CALL_STARTED_SENTINEL, deliverAs: 'steer' });
             actions.push({ kind: 'open_ws', url: event.msg.speechmuxWsUrl });
             return {
                 next: {
@@ -98,21 +102,23 @@ export function reduceLifecycle(prev, event, ctx) {
                 return { next: prev, interpreterAppliedNow: false, actions: [] };
             }
             // Drop any buffered frames; the shell will rebuild from scratch
-            // on the next activate.
+            // on the next activate. Carry the sessionId on the action from the
+            // pre-transition state — after this we're dormant. (M1)
             return {
                 next: { kind: 'dormant' },
                 interpreterAppliedNow: false,
-                actions: [{ kind: 'emit_deactivate_request' }],
+                actions: [{ kind: 'emit_deactivate_request', sessionId: prev.sessionId }],
             };
         }
         case 'ws:disconnected': {
             if (prev.kind === 'dormant') {
                 return { next: prev, interpreterAppliedNow: false, actions: [] };
             }
+            // prev is activating|active here — both carry sessionId. (M1)
             return {
                 next: { kind: 'dormant' },
                 interpreterAppliedNow: false,
-                actions: [{ kind: 'emit_deactivate_request' }],
+                actions: [{ kind: 'emit_deactivate_request', sessionId: prev.sessionId }],
             };
         }
         default:

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

@@ -44,15 +44,41 @@ const noFrames = (next) => ({
 export function reduceStreaming(prev, event) {
     switch (event.type) {
         case 'sdk:message_start':
-            // Assistant message starts → wipe per-block state. (Filtering on
+            // Assistant message starts → wipe per-block state and clear the
+            // interrupt latch (a new turn can emit again). (Filtering on
             // role==='assistant' happens at the dispatcher.)
-            return noFrames({ blocks: new Map() });
+            return noFrames({ blocks: new Map(), interrupted: false });
+        case 'ws:incoming':
+            // A barge-in latches `interrupted` so we stop feeding speechmux tokens
+            // for an utterance it already aborted. Reset on the next message_start.
+            if (event.frame.type === 'abort' || event.frame.type === 'rollback') {
+                return noFrames({ ...prev, interrupted: true });
+            }
+            return noFrames(prev);
         case 'sdk:toolcall_start':
+            if (prev.interrupted)
+                return noFrames(prev);
             return noFrames(setBlock(prev, event.contentIndex, blockFromPartial(event.contentIndex, event.partial)));
         case 'sdk:toolcall_delta':
+            if (prev.interrupted)
+                return noFrames(prev);
             return reduceDelta(prev, event.contentIndex, event.delta, event.partial);
         case 'sdk:toolcall_end':
+            if (prev.interrupted)
+                return noFrames(prev);
             return reduceEnd(prev, event.contentIndex, event.toolCall);
+        case 'sdk:turn_end':
+            // Release the floor for the turn's last spoken utterance. Routed as a
+            // frame so the lifecycle layer buffers it during `activating` and passes
+            // it during `active` — the same discipline as token/end frames. (M2)
+            return {
+                next: prev,
+                frames: [event.lastSpeakToolCallId ? { type: 'floor_released', speak_id: event.lastSpeakToolCallId } : { type: 'floor_released' }],
+                endedSpeakIds: [],
+            };
+        case 'sdk:agent_end':
+            // Surface a harness-side error to speechmux. (M2)
+            return event.error ? { next: prev, frames: [{ type: 'error', message: event.error }], endedSpeakIds: [] } : noFrames(prev);
         default:
             return noFrames(prev);
     }
@@ -165,7 +191,17 @@ function setBlock(state, idx, block) {
         return state;
     const blocks = new Map(state.blocks);
     blocks.set(idx, block);
-    return { blocks };
+    return { ...state, blocks };
+}
+/** Toolcall id of the speak() block currently mid-stream (if any). The most
+ *  likely walkback target when speechmux's frame omits a speak_id: an in-flight
+ *  speak hasn't emitted its `end`, so it isn't in `lastEmittedSpeakId` yet. */
+export function currentStreamingSpeakId(message) {
+    for (const block of message.blocks.values()) {
+        if (block.kind === 'speak_streaming' && block.toolCallId)
+            return block.toolCallId;
+    }
+    return null;
 }
 function partialBlock(partial, idx) {
     const c = partial?.content;

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

@@ -18,27 +18,30 @@
 // such ambiguity.
 import { VOICE_INTERRUPT_CUSTOM_TYPE } from '../../../../../shared/dist/index.js';
 import { walkBack } from '../../walk-back.js';
-/** Resolve which speak() id to walk back to. Prefers what speechmux
- *  echoes; falls back to runtime-tracked latest. Returns null if neither
- *  is available (we'll degrade gracefully — abort the agent but skip
- *  the rewrite). */
-function resolveTarget(frameSpeakId, lastEmittedSpeakId) {
-    if (frameSpeakId)
-        return frameSpeakId;
-    return lastEmittedSpeakId;
+/** Resolve which speak() id to walk back to. Prefers what speechmux echoes;
+ *  then the in-flight speak; then the last fully-emitted one. Returns null if
+ *  none is available (degrade gracefully — abort the agent, skip the rewrite). */
+function resolveTarget(frameSpeakId, ctx) {
+    return frameSpeakId ?? ctx.currentStreamingSpeakId ?? ctx.lastEmittedSpeakId;
 }
-export function reduceWalkback(prev, lastEmittedSpeakId, event) {
+export function reduceWalkback(prev, event, ctx) {
     switch (event.type) {
         case 'ws:incoming': {
             const f = event.frame;
             if (f.type === 'user')
                 return { next: prev, actions: [] };
+            // Only honour barge-in (abort/rollback) while a call is live. A frame
+            // arriving when dormant (e.g. in flight during teardown, or from a
+            // just-discarded client) must not abort an unrelated text-mode turn. (H3)
+            if (ctx.lifecycleKind !== 'active' && ctx.lifecycleKind !== 'activating') {
+                return { next: prev, actions: [] };
+            }
             const heardText = f.type === 'rollback' ? f.heard_text : '';
             const data = {
                 heard_text: heardText,
                 kind: f.type === 'rollback' ? 'rollback' : 'abort',
             };
-            const target = resolveTarget(f.speak_id, lastEmittedSpeakId);
+            const target = resolveTarget(f.speak_id, ctx);
             const actions = [{ kind: 'abort_agent' }, { kind: 'append_custom_entry', customType: VOICE_INTERRUPT_CUSTOM_TYPE, data }];
             if (target === null) {
                 // No target available → can't rewrite. Just abort + record the

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

@@ -13,7 +13,7 @@
 export function initialState() {
     return {
         lifecycle: { kind: 'dormant' },
-        message: { blocks: new Map() },
+        message: { blocks: new Map(), interrupted: false },
         walkback: { kind: 'idle' },
         interpreterApplied: false,
         lastEmittedSpeakId: null,