maka-agent 0.2.0-dev.37.20260915 → 0.2.0-dev.39.20260916

package/dist/pi-tui-pickers.js

@@ -558,6 +558,7 @@ export class SessionSearchOverlay {
     list;
     selectedValue;
     scopeLabel;
+    notice;
     constructor(tui, input) {
         this.tui = tui;
         this.input = input;
@@ -565,14 +566,22 @@ export class SessionSearchOverlay {
         this.choices = input.choices;
         this.filtered = input.choices;
         this.scopeLabel = input.scopeLabel;
+        this.notice = input.notice;
         this.list = this.buildList();
         this.searchEditor = new Editor(tui, editorTheme(), { paddingX: 0 });
         this.searchEditor.onChange = (text) => this.applyQuery(text);
     }
-    updateChoices(choices, scopeLabel) {
+    updateChoices(choices, scopeLabel, notice) {
         this.choices = choices;
         this.scopeLabel = scopeLabel;
-        this.applyQuery(this.searchEditor.getText());
+        this.notice = notice;
+        if (this.input.onQuery) {
+            this.filtered = choices;
+            this.list = this.buildList();
+        }
+        else {
+            this.applyQuery(this.searchEditor.getText());
+        }
     }
     buildList() {
         const list = new SelectList(this.filtered.map(({ item }) => item), 10, selectListTheme(), {
@@ -594,6 +603,10 @@ export class SessionSearchOverlay {
     }
     applyQuery(text) {
         const query = text.trim().toLocaleLowerCase();
+        if (this.input.onQuery) {
+            this.input.onQuery(query);
+            return;
+        }
         this.filtered = query
             ? this.choices.filter((choice) => choice.searchText.includes(query))
             : this.choices;
@@ -628,13 +641,14 @@ export class SessionSearchOverlay {
         }
         this.searchEditor.focused = true;
         return [
-            padLine(`${this.copy.resumeSessionTitle} ${ansi.accent(this.scopeLabel)}`, safeWidth),
+            padLine(`${this.input.title ?? this.copy.resumeSessionTitle} ${ansi.accent(this.scopeLabel)}`, safeWidth),
             padLine(ansi.dim(this.copy.sessionSearchHint), safeWidth),
             padLine('', safeWidth),
             ...this.renderFieldRow(safeWidth),
             padLine('', safeWidth),
+            ...(this.notice ? [padLine(ansi.dim(this.notice), safeWidth)] : []),
             ...(this.filtered.length === 0
-                ? [padLine(ansi.dim(this.copy.noMatchingSessions), safeWidth)]
+                ? [padLine(ansi.dim(this.input.emptyText ?? this.copy.noMatchingSessions), safeWidth)]
                 : this.list.render(safeWidth).map((line) => formatPickerItemLine(line, safeWidth))),
             padLine(ansi.accent('-'.repeat(safeWidth)), safeWidth),
         ];

package/dist/pi-tui-runner.js

@@ -25,7 +25,6 @@ import { projectRevisionLinkedSessionTree } from '@maka/core/session-revisions';
 import { slashCommandsForSurface, } from '@maka/core/slash-command-catalog';
 import { latestAssistantModelId, } from '@maka/core/session';
 import { defineUiMessageCatalog, formatUiMessage, resolveUiMessageCatalog, } from '@maka/core/ui-locale';
-import { buildForeignSessionHandoffMessage, foreignSessionHandoffDisplayText, foreignSourceLabel, } from '@maka/core/foreign-session';
 import { listApiKeyOnboardableProviders } from './onboarding-catalog.js';
 import { AUTO_RECAP_DISPLAY_LIMIT_BYTES, shouldAutoRecap } from './session-recap.js';
 import { MakaSkillHighlightEditor } from './skill-highlight-editor.js';
@@ -54,6 +53,37 @@ import { formatMakaResumeCommand } from './cli-invocation.js';
 import { goalAttachedNoticeText, goalPausedNoticeText, goalStatusLabel, goalSummaryLines, isLiveGoalStatus, } from './pi-goal.js';
 import { getTuiPrimaryGuidance } from './tui-primary-guidance.js';
 import { TUI_COPY_RESOURCES } from './tui-copy-catalog.js';
+function externalSourceLabel(adapterId) {
+    switch (adapterId) {
+        case 'claude-code':
+            return 'Claude Code';
+        case 'codex':
+            return 'Codex';
+        case 'opencode':
+            return 'OpenCode';
+        default:
+            return adapterId;
+    }
+}
+function externalImportErrorCode(error) {
+    if (typeof error !== 'object' || error === null)
+        return 'commit_outcome_unknown';
+    const value = error;
+    if (value.operation !== undefined && value.operation !== 'external-session.import') {
+        return undefined;
+    }
+    if (value.mode === 'command' && value.dispatch === 'not_dispatched')
+        return undefined;
+    if (value.mode === 'command' && value.dispatch === 'dispatched') {
+        return 'commit_outcome_unknown';
+    }
+    if (value.code === 'commit_outcome_unknown' ||
+        value.code === 'model_unavailable' ||
+        value.code === 'source_unreadable') {
+        return value.code;
+    }
+    return value.code === undefined ? 'commit_outcome_unknown' : undefined;
+}
 export function resolveTaskbarProgress(setting, environment = {
     platform: process.platform,
     override: process.env.MAKA_TASKBAR_PROGRESS,
@@ -96,6 +126,27 @@ const TUI_REWIND_COPY = resolveUiMessageCatalog(defineUiMessageCatalog()(TUI_COP
 const TUI_SKILLS_COPY = resolveUiMessageCatalog(defineUiMessageCatalog()(TUI_COPY_RESOURCES.skills));
 const TUI_CONNECTION_IDENTITY_COPY = resolveUiMessageCatalog(defineUiMessageCatalog()(TUI_COPY_RESOURCES['connection-identity']));
 const TUI_SESSION_ACTIONS_COPY = resolveUiMessageCatalog(defineUiMessageCatalog()(TUI_COPY_RESOURCES['session-actions']));
+/**
+ * What the exhausted bound is called, in the user's language.
+ *
+ * The limit kinds are protocol tokens; a reader told the session exceeds the
+ * `record_bytes` limit has been handed an implementation detail instead of an
+ * explanation.
+ */
+function externalImportLimitLabel(copy, kind) {
+    switch (kind) {
+        case 'transcript_bytes':
+            return copy.externalImportLimitTranscriptBytes;
+        case 'record_bytes':
+            return copy.externalImportLimitRecordBytes;
+        case 'records':
+            return copy.externalImportLimitRecords;
+        case 'converted_bytes':
+            return copy.externalImportLimitConvertedBytes;
+        case 'messages':
+            return copy.externalImportLimitMessages;
+    }
+}
 function sessionConnectionIdentityNotice(session, identities, locale) {
     if (!identities)
         return undefined;
@@ -2445,14 +2496,258 @@ export async function runMakaPiTui(input) {
             throw error;
         }
     };
+    const openImportedExternalSession = async (sessionId, failureText) => {
+        try {
+            await switchSession(sessionId);
+        }
+        catch {
+            state.entries.push({ kind: 'notice', level: 'error', text: failureText });
+            requestRender();
+            return;
+        }
+        try {
+            await discardCurrentSidePair();
+        }
+        catch (error) {
+            reportError(error);
+        }
+    };
+    const importExternalSession = async (adapterId, source) => {
+        if (!input.externalSessions)
+            return;
+        const copy = TUI_SESSION_ACTIONS_COPY[locale];
+        if (source.importState.isImporting) {
+            state.entries.push({
+                kind: 'notice',
+                level: 'error',
+                text: copy.externalUnavailable,
+            });
+            requestRender();
+            return;
+        }
+        let importedSessionId;
+        try {
+            const result = await input.externalSessions.importSession({
+                adapterId,
+                sourceSessionId: source.id,
+            });
+            if (result.kind === 'source_limit_exceeded') {
+                state.entries.push({
+                    kind: 'notice',
+                    level: 'error',
+                    text: formatUiMessage(copy.externalImportLimit, {
+                        kind: externalImportLimitLabel(copy, result.limit.kind),
+                        max: result.limit.max,
+                    }, locale),
+                });
+                return;
+            }
+            importedSessionId = result.session.id;
+        }
+        catch (error) {
+            const code = externalImportErrorCode(error);
+            if (code === 'model_unavailable') {
+                state.entries.push({
+                    kind: 'notice',
+                    level: 'error',
+                    text: copy.externalImportModelUnavailable,
+                });
+                return;
+            }
+            if (code === 'source_unreadable') {
+                state.entries.push({
+                    kind: 'notice',
+                    level: 'error',
+                    text: copy.externalImportSourceUnreadable,
+                });
+                return;
+            }
+            if (code !== 'commit_outcome_unknown') {
+                state.entries.push({ kind: 'notice', level: 'error', text: copy.externalImportFailed });
+                return;
+            }
+            state.entries.push({ kind: 'notice', level: 'error', text: copy.externalImportUncertain });
+            return;
+        }
+        await openImportedExternalSession(importedSessionId, formatUiMessage(copy.externalOpenFailed, { sessionId: importedSessionId }, locale));
+    };
+    const showExternalSessionPage = async (adapterId, initialScope) => {
+        if (!input.externalSessions || closed)
+            return;
+        const copy = TUI_SESSION_ACTIONS_COPY[locale];
+        let scope = initialScope;
+        let query = '';
+        let sessions = [];
+        let nextCursor = null;
+        let revision = 0;
+        let overlay;
+        let search;
+        let byValue = new Map();
+        const closeOverlay = () => overlay?.hide();
+        const toggleScope = () => {
+            const alternate = input.externalSessions
+                ?.listScopes()
+                .find((candidate) => candidate !== scope);
+            if (!alternate)
+                return;
+            scope = alternate;
+            void load(false);
+        };
+        const render = () => {
+            // SelectList has no disabled-row contract. A Host-owned in-flight import
+            // disables another import, but it does not disable opening an already
+            // published task.
+            const selectable = sessions.filter((session) => !session.importState.isImporting || session.importState.importedSessionIds.length > 0);
+            byValue = new Map(selectable.map((session) => [`external:${adapterId}:${session.id}`, session]));
+            const choices = selectable.map((session) => ({
+                item: {
+                    value: `external:${adapterId}:${session.id}`,
+                    label: session.name,
+                    description: [
+                        session.hostCwd,
+                        session.importState.importedCount > 0
+                            ? formatUiMessage(copy.externalImportedCount, { count: session.importState.importedCount }, locale)
+                            : undefined,
+                    ]
+                        .filter(Boolean)
+                        .join(' · '),
+                },
+                searchText: '',
+            }));
+            if (nextCursor) {
+                choices.push({
+                    item: { value: 'external:load-more', label: copy.externalLoadMore },
+                    searchText: '',
+                });
+            }
+            const alternateScope = input.externalSessions
+                ?.listScopes()
+                .find((candidate) => candidate !== scope);
+            if (alternateScope) {
+                choices.push({
+                    item: {
+                        value: 'external:toggle-workspace',
+                        label: alternateScope === 'all' ? copy.externalAllWorkspaces : copy.externalCurrentWorkspace,
+                    },
+                    searchText: '',
+                });
+            }
+            const scopeLabel = scope === 'all' ? copy.externalAllWorkspaces : copy.externalCurrentWorkspace;
+            const notice = sessions.length > 0 && selectable.length === 0 ? copy.externalUnavailable : undefined;
+            if (search) {
+                search.updateChoices(choices, scopeLabel, notice);
+                search.invalidate();
+                return;
+            }
+            search = new SessionSearchOverlay(tui, {
+                locale,
+                choices,
+                scopeLabel,
+                title: formatUiMessage(copy.externalSessionTitle, { source: externalSourceLabel(adapterId) }, locale),
+                emptyText: sessions.length === 0 ? copy.externalEmpty : copy.externalUnavailable,
+                notice,
+                onQuery: (text) => {
+                    query = text;
+                    void load(false);
+                },
+                onSelect: (item) => {
+                    if (item.value === 'external:load-more' && nextCursor) {
+                        void load(true, nextCursor);
+                        return;
+                    }
+                    if (item.value === 'external:toggle-workspace' && alternateScope) {
+                        toggleScope();
+                        return;
+                    }
+                    const source = byValue.get(item.value);
+                    if (!source)
+                        return;
+                    closeOverlay();
+                    if (busy || turnRunning) {
+                        state.entries.push({ kind: 'notice', level: 'error', text: copy.externalImportBusy });
+                        requestRender();
+                        return;
+                    }
+                    const latestImportedSessionId = source.importState.importedSessionIds[0];
+                    if (latestImportedSessionId === undefined) {
+                        void runControl(() => importExternalSession(adapterId, source));
+                        return;
+                    }
+                    const actionTitle = formatUiMessage(copy.externalImportedActionsTitle, { source: source.name }, locale);
+                    const actions = [
+                        { value: 'open-latest', label: copy.externalOpenLatestImported },
+                        ...(!source.importState.isImporting
+                            ? [{ value: 'import-again', label: copy.externalImportAgain }]
+                            : []),
+                    ];
+                    showSelectPicker(actionTitle, source.name, actions, (action) => {
+                        if (busy || turnRunning) {
+                            state.entries.push({
+                                kind: 'notice',
+                                level: 'error',
+                                text: copy.externalImportBusy,
+                            });
+                            requestRender();
+                            return;
+                        }
+                        if (action.value === 'import-again') {
+                            void runControl(() => importExternalSession(adapterId, source));
+                            return;
+                        }
+                        void runControl(() => openImportedExternalSession(latestImportedSessionId, formatUiMessage(copy.externalOpenLatestFailed, { sessionId: latestImportedSessionId }, locale)));
+                    }, { minPrimaryColumnWidth: 24, maxPrimaryColumnWidth: 48 });
+                },
+                onCancel: closeOverlay,
+                onToggleScope: toggleScope,
+            });
+            overlay = showBottomPicker(search);
+        };
+        const load = async (append, cursor) => {
+            const requestRevision = ++revision;
+            try {
+                const page = await input.externalSessions.listSessions({
+                    adapterId,
+                    scope,
+                    ...(cursor ? { cursor } : {}),
+                    ...(query ? { text: query } : {}),
+                });
+                if (requestRevision !== revision || closed || turnRunning)
+                    return;
+                sessions = append ? [...sessions, ...page.sessions] : page.sessions;
+                nextCursor = page.nextCursor;
+                render();
+            }
+            catch {
+                if (requestRevision !== revision)
+                    return;
+                state.entries.push({ kind: 'notice', level: 'error', text: copy.externalCatalogFailed });
+                requestRender();
+            }
+        };
+        await load(false);
+    };
+    const showExternalSourcePicker = (adapterIds) => {
+        if (!input.externalSessions)
+            return;
+        const initialScope = input.externalSessions.listScopes()[0];
+        if (adapterIds.length === 1) {
+            void showExternalSessionPage(adapterIds[0], initialScope);
+            return;
+        }
+        const copy = TUI_SESSION_ACTIONS_COPY[locale];
+        showSelectPicker(copy.externalSourceTitle, copy.externalSourceTitle, adapterIds.map((adapterId) => ({
+            value: adapterId,
+            label: externalSourceLabel(adapterId),
+        })), (item) => void showExternalSessionPage(item.value, initialScope), { minPrimaryColumnWidth: 20, maxPrimaryColumnWidth: 40 });
+    };
     const showSessionList = async () => {
         const sessions = await input.driver.listSessions();
         const sessionTree = projectRevisionLinkedSessionTree(sessions, input.driver.getSessionId() ?? undefined);
         const projectedSessions = flattenLinkedSessionTree(sessionTree.roots, sessionTree.childrenByParentId);
-        // Maka-session availability and the foreign scan are independent I/O; run
+        // Maka-session availability and Host source discovery are independent I/O; run
         // them concurrently so the picker's open latency is the slower of the two,
         // not their sum.
-        const [availabilityEntries, foreignScan] = await Promise.all([
+        const [availabilityEntries, externalSourceQuery] = await Promise.all([
             Promise.all(sessions.map(async (session) => {
                 return [
                     session.id,
@@ -2460,36 +2755,18 @@ export async function runMakaPiTui(input) {
                         (await inspectSessionResumeAvailability(session)),
                 ];
             })),
-            // Foreign (Claude Code / Codex) rows are an import flow: it starts a NEW
-            // Session and hands off a turn, which cannot detach from the running
-            // one (#3380). Skip the scan mid-turn instead of offering rows whose
-            // selection would silently no-op on importForeignSession's busy guard.
-            input.foreignSessions && !turnRunning
-                ? input.foreignSessions.listSessions({ cwd }).then((summaries) => ({ summaries }), (error) => ({ error }))
-                : Promise.resolve({ summaries: [] }),
+            input.externalSessions && !turnRunning
+                ? input.externalSessions.listSources().then((adapterIds) => ({ adapterIds }), () => ({ error: true }))
+                : Promise.resolve({ adapterIds: [] }),
         ]);
         const availability = new Map(availabilityEntries);
-        // Foreign (Claude Code / Codex) sessions for the current cwd, keyed by a
-        // prefixed select value so they never collide with Maka session ids. A scan
-        // error is surfaced (not silently swallowed): degrade to no rows but tell
-        // the user why, so a real store bug isn't mistaken for "no sessions".
-        // Deliberate #2672 exception: the interpolated detail is a local
-        // file-scan diagnostic (not backend copy) and the TUI has no log channel
-        // to carry it, so dropping it would hide the only debugging signal.
-        const foreignByValue = new Map();
-        if ('error' in foreignScan) {
-            const detail = foreignScan.error instanceof Error ? foreignScan.error.message : String(foreignScan.error);
+        if ('error' in externalSourceQuery) {
             state.entries.push({
                 kind: 'notice',
                 level: 'error',
-                text: formatUiMessage(TUI_SESSION_ACTIONS_COPY[locale].foreignScanFailed, { detail }, locale),
+                text: TUI_SESSION_ACTIONS_COPY[locale].externalCatalogFailed,
             });
         }
-        else {
-            for (const summary of foreignScan.summaries) {
-                foreignByValue.set(`foreign:${summary.source}:${summary.id}`, summary);
-            }
-        }
         let overlay;
         let sessionSearch;
         const renderScope = () => {
@@ -2525,16 +2802,14 @@ export async function runMakaPiTui(input) {
                         .toLocaleLowerCase(),
                 };
             });
-            // Foreign sessions are cwd-scoped; show them in both scope views (they
-            // belong to this project) so a Tab toggle never makes them vanish.
-            for (const [value, summary] of foreignByValue) {
+            if ('adapterIds' in externalSourceQuery && externalSourceQuery.adapterIds.length > 0) {
                 choices.push({
                     item: {
-                        value,
-                        label: summary.title,
-                        description: `↩ resume from ${foreignSourceLabel(summary.source)}`,
+                        value: 'external:import',
+                        label: TUI_SESSION_ACTIONS_COPY[locale].externalImport,
+                        description: TUI_SESSION_ACTIONS_COPY[locale].externalImportDescription,
                     },
-                    searchText: `${summary.title} ${summary.id} ${summary.cwd} ${summary.source}`.toLocaleLowerCase(),
+                    searchText: TUI_SESSION_ACTIONS_COPY[locale].externalImport.toLocaleLowerCase(),
                 });
             }
             const closeOverlay = () => {
@@ -2542,10 +2817,9 @@ export async function runMakaPiTui(input) {
                 overlay?.hide();
             };
             const onSelect = (item) => {
-                const foreign = foreignByValue.get(item.value);
-                if (foreign) {
+                if (item.value === 'external:import' && 'adapterIds' in externalSourceQuery) {
                     closeOverlay();
-                    void importForeignSession(foreign);
+                    showExternalSourcePicker(externalSourceQuery.adapterIds);
                     return;
                 }
                 if (availability.get(item.value)?.available === false)
@@ -2654,46 +2928,6 @@ export async function runMakaPiTui(input) {
         requestRender();
         return true;
     };
-    // Import a foreign (Claude Code / Codex) session: read its digest, open a
-    // fresh Maka session, and seed the first turn with an untrusted handoff
-    // envelope. Mirrors submitPreparedUserPrompt: claim `busy` + an activity lease
-    // SYNCHRONOUSLY before the async read so no other turn (a Goal auto-
-    // continuation, or a user Enter) can start during it and make the import a
-    // silent no-op. runAgentTurn re-asserts busy for the turn; on any failure the
-    // finally releases the lease. The handoff is the model-facing `sendText`; a
-    // short line shows in the transcript.
-    const importForeignSession = async (summary) => {
-        if (busy || input.foreignSessions === undefined)
-            return;
-        busy = true;
-        const activity = beginActivity();
-        editor.disableSubmit = true;
-        let handedOff = false;
-        try {
-            const digest = await input.foreignSessions.readDigest(summary);
-            if (closed)
-                return;
-            if (!(await newSession()))
-                return;
-            submitMessage(foreignSessionHandoffDisplayText(digest), 'current_turn', {
-                modelText: buildForeignSessionHandoffMessage(digest),
-            });
-            handedOff = true;
-        }
-        catch (error) {
-            if (closed)
-                return;
-            reportError(error);
-        }
-        finally {
-            if (!handedOff) {
-                busy = false;
-                editor.disableSubmit = false;
-                requestRender();
-            }
-            activity.finish();
-        }
-    };
     const showHelp = () => {
         // Derive the command list from the registry so /help never drifts from the
         // real commands. Keybindings are not commands, so they are listed by hand.

package/dist/runtime-host-installed-update-bootstrap.js

@@ -51,7 +51,8 @@ export async function runRuntimeHostInstalledUpdateBootstrap(input, overrides =
             if (!(await stat(coordinatorCliPath)).isFile()) {
                 throw new Error('The copied Maka update coordinator has no CLI entry point');
             }
-            return deps.runCoordinator({
+            // The copied entry must outlive the coordinator that is executing it.
+            const exitCode = await deps.runCoordinator({
                 coordinatorCliPath,
                 rootPath: input.rootPath,
                 archivePath,
@@ -66,6 +67,7 @@ export async function runRuntimeHostInstalledUpdateBootstrap(input, overrides =
                 allowInterruptActiveTasks: input.allowInterruptActiveTasks,
                 ...(input.expectedSource ? { expectedSource: input.expectedSource } : {}),
             });
+            return exitCode;
         }
         finally {
             await rm(temporaryRoot, { recursive: true, force: true }).catch(() => undefined);

package/dist/runtime-host-run-command.js

@@ -347,7 +347,10 @@ class RuntimeHostRunRuntime {
         const active = this.#activeTurn;
         if (!active || active.sessionId !== sessionId || active.turnId !== turnId)
             return;
-        active.outcome = classifierFromStoredTurn(messages, turnId, active.runId);
+        // A read of a running Turn stops wherever the transcript has been
+        // committed, so it can restore what the live stream missed but never
+        // proves that what the stream already delivered is gone.
+        acceptStoredTurn(active.outcome, messages, turnId);
     }
     #waitForGraphTurnTerminal(turnId) {
         if (this.#closed)
@@ -409,6 +412,7 @@ class TurnOutcomeClassifier {
     #outcomeId;
     #unresolvedSandboxFailures = new Set();
     #finalOutput;
+    #finalOutputFromLive = false;
     #terminal;
     constructor(outcomeId) {
         this.#outcomeId = outcomeId;
@@ -418,7 +422,14 @@ class TurnOutcomeClassifier {
             case undefined:
                 return;
             case 'output':
+                // A subscriber is delivered in Host order, so the stream's last answer
+                // is the Turn's last answer. A transcript read stops wherever the Host
+                // had committed, so it can supply an answer the stream never carried
+                // but can never overrule one it did.
+                if (observation.source === 'stored' && this.#finalOutputFromLive)
+                    return;
                 this.#finalOutput = observation.text;
+                this.#finalOutputFromLive = observation.source === 'live';
                 return;
             case 'terminal':
                 if (observation.update === 'replace' || this.#terminal === undefined) {
@@ -459,7 +470,7 @@ class TurnOutcomeClassifier {
 }
 function observationFromSessionEvent(event) {
     if (event.type === 'text_complete' && event.text.trim().length > 0) {
-        return { kind: 'output', text: event.text };
+        return { kind: 'output', text: event.text, source: 'live' };
     }
     if (event.type === 'error') {
         return {
@@ -484,7 +495,7 @@ function observationFromSessionEvent(event) {
 }
 function observationFromStoredMessage(message) {
     if (message.type === 'assistant' && message.text.trim().length > 0) {
-        return { kind: 'output', text: message.text };
+        return { kind: 'output', text: message.text, source: 'stored' };
     }
     if (message.type === 'turn_state' && message.status === 'completed') {
         return { kind: 'terminal', update: 'replace', status: 'completed' };
@@ -556,11 +567,14 @@ function outcomeFromStoredTurn(messages, turnId) {
 }
 function classifierFromStoredTurn(messages, turnId, outcomeId) {
     const classifier = new TurnOutcomeClassifier(outcomeId);
+    acceptStoredTurn(classifier, messages, turnId);
+    return classifier;
+}
+function acceptStoredTurn(classifier, messages, turnId) {
     for (const message of messages) {
         if (message.turnId === turnId)
             classifier.accept(observationFromStoredMessage(message));
     }
-    return classifier;
 }
 class NonInteractiveInteractionController {
     #driver;