maka-agent 0.2.0-dev.77.20261009 → 0.2.0-dev.78.20261010

package/README.zh-CN.md

@@ -1,4 +1,4 @@
-> **开发快照：**此 Nightly 不是 Apache Release，不用于生产环境；其版本只对应一个精确的 `apache/maka` commit。
+> **开发快照**：此 Nightly 不是 Apache Release，不用于生产环境；其版本只对应一个精确的 `apache/maka` commit。
 
 <!--
   Licensed to the Apache Software Foundation (ASF) under one
@@ -35,7 +35,7 @@ release commit 中的 [DISCLAIMER-WIP](https://github.com/apache/maka/blob/main/
 [Maka podling 状态页](https://incubator.apache.org/projects/maka.html)。本段仅为中文说明，
 英文免责声明以随包发布的 `DISCLAIMER-WIP` 为准。
 
-> **Beta：**CLI 仍在积极开发中，稳定版发布前，命令和本地数据格式可能发生变化。
+> **Beta**：CLI 仍在积极开发中，稳定版发布前，命令和本地数据格式可能发生变化。
 
 ## 环境要求
 

package/dist/pi-tui-pickers.js

@@ -569,6 +569,7 @@ export class SessionSearchOverlay {
     list;
     selectedValue;
     scopeLabel;
+    emptyText;
     notice;
     constructor(tui, input) {
         this.tui = tui;
@@ -577,15 +578,17 @@ export class SessionSearchOverlay {
         this.choices = input.choices;
         this.filtered = input.choices;
         this.scopeLabel = input.scopeLabel;
+        this.emptyText = input.emptyText;
         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, notice) {
+    updateChoices(choices, scopeLabel, notice, emptyText) {
         this.choices = choices;
         this.scopeLabel = scopeLabel;
         this.notice = notice;
+        this.emptyText = emptyText;
         if (this.input.onQuery) {
             this.filtered = choices;
             this.list = this.buildList();
@@ -659,7 +662,7 @@ export class SessionSearchOverlay {
             padLine('', safeWidth),
             ...(this.notice ? [padLine(ansi.dim(this.notice), safeWidth)] : []),
             ...(this.filtered.length === 0
-                ? [padLine(ansi.dim(this.input.emptyText ?? this.copy.noMatchingSessions), safeWidth)]
+                ? [padLine(ansi.dim(this.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

@@ -31,7 +31,8 @@ import { AUTO_RECAP_DISPLAY_LIMIT_BYTES, shouldAutoRecap } from './session-recap
 import { MakaSkillHighlightEditor } from './skill-highlight-editor.js';
 import { parseGraphCommand } from '@maka/core/graph-command';
 import { parseSwarmCommand } from '@maka/core/swarm-command';
-import { inspectSessionResumeAvailability, } from './session-driver.js';
+import { inspectSessionResumeAvailability, MakaSessionCatalogIncompleteError, } from './session-driver.js';
+import { SESSION_CATALOG_MAX_SCAN_SESSIONS } from './session-catalog-limits.js';
 import { SafeBoundaryResumeParkedError } from './runtime-host-session-driver.js';
 import { appendExpansionCollapseConfirmation, appendTurnFailureToTranscript, appendUserCommandToTranscript, appendUserPrompt, applyMakaSessionEventToTranscript, applyShellRunUpdateToTranscript, createMakaPiTranscriptState, hasRunningUserCommand, activeSandboxBoundaryRequest, activeFormRequest, activeUserQuestionRequest, applyExpansionDefaultToAll, completePendingInteraction, applyShellRunViewUpdateToTranscript, EXPANSION_COLLAPSE_CONFIRM_WINDOW_MS, hasExpandedEntriesAboveViewport, permissionModeLabel, retireCancelledTransientMessages, replaceTranscriptWithStoredMessages, hydrateToolsWithStoredMessages, submitCompactToTranscript, toggleAllThinkingExpansion, toggleAllToolExpansion, } from './pi-transcript.js';
 import { FormInteractionOverlay } from './pi-tui-form-interaction.js';
@@ -169,6 +170,7 @@ function sessionConnectionIdentityNotice(session, identities, locale) {
     }
     return undefined;
 }
+const SESSION_RESUME_AVAILABILITY_CONCURRENCY = 8;
 export async function runMakaPiTui(input) {
     const locale = input.locale ?? 'en';
     const pickerCopy = getTuiPickerCopy(locale);
@@ -1578,25 +1580,34 @@ export async function runMakaPiTui(input) {
             sessionId !== input.driver.getSessionId() &&
             (sessionId === pair.parentSessionId || sessionId === pair.sideSessionId)) {
             await toggleSideConversation();
-            return;
+            return true;
         }
         const leavesPair = pair !== undefined && sessionId !== pair.parentSessionId && sessionId !== pair.sideSessionId;
         if (!turnRunning) {
+            let switched = false;
             await runControl(async () => {
                 await switchSession(sessionId);
+                switched = true;
                 if (leavesPair)
                     await discardCurrentSidePair();
             });
-            return;
+            return switched;
         }
         // One detach at a time (#3380): a second mid-turn switch while the first
         // is still handing the view over would clear `detaching` early, reopen
         // the interrupt window, and double-apply the adoption.
         if (detaching)
-            return;
-        await switchAwayMidTurn(sessionId)
-            .then(() => (leavesPair ? discardCurrentSidePair() : undefined))
-            .catch(reportError);
+            return false;
+        try {
+            await switchAwayMidTurn(sessionId);
+            if (leavesPair)
+                await discardCurrentSidePair();
+            return true;
+        }
+        catch (error) {
+            reportError(error);
+            return false;
+        }
     };
     const openSideConversation = async (prompt) => {
         if (sideConversation) {
@@ -2460,14 +2471,50 @@ export async function runMakaPiTui(input) {
             onChange: requestRender,
         });
     };
+    let sessionListPromise;
+    let activeResumeAvailabilityChecks = 0;
+    const queuedResumeAvailabilityChecks = [];
+    const runResumeAvailabilityCheck = async (task) => {
+        if (activeResumeAvailabilityChecks >= SESSION_RESUME_AVAILABILITY_CONCURRENCY) {
+            await new Promise((resolve) => queuedResumeAvailabilityChecks.push(resolve));
+        }
+        activeResumeAvailabilityChecks += 1;
+        try {
+            return await task();
+        }
+        finally {
+            activeResumeAvailabilityChecks -= 1;
+            queuedResumeAvailabilityChecks.shift()?.();
+        }
+    };
+    const listSessions = (options = {}) => {
+        if (sessionListPromise) {
+            if (sessionListPromise.limit === options.limit && sessionListPromise.cwd === options.cwd) {
+                return sessionListPromise.promise;
+            }
+            return sessionListPromise.promise.then(() => listSessions(options), () => listSessions(options));
+        }
+        {
+            const promise = input.driver.listSessions(options).finally(() => {
+                if (sessionListPromise?.promise === promise)
+                    sessionListPromise = undefined;
+            });
+            sessionListPromise = { limit: options.limit, cwd: options.cwd, promise };
+        }
+        return sessionListPromise.promise;
+    };
     const resumeSession = async () => {
+        if (!input.driver.getSessionId()) {
+            await showSessionList({ onlyResumable: true });
+            return;
+        }
         if (!input.driver.resumeLatest) {
-            throw new Error('Safe-boundary resume is unavailable on this runtime.');
+            throw new Error(pickerCopy.resumeUnavailableNotice);
         }
         state.entries.push({
             kind: 'notice',
             level: 'info',
-            text: 'Resuming from the latest safe boundary…',
+            text: pickerCopy.resumeStartingNotice,
         });
         requestRender();
         try {
@@ -2784,26 +2831,97 @@ export async function runMakaPiTui(input) {
             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);
+    const showSessionCatalogIncompleteNotice = () => {
+        const text = pickerCopy.resumeCatalogIncompleteNotice;
+        state.entries.push({ kind: 'notice', level: 'info', text });
+        requestRender();
+    };
+    const readSessionCatalog = async (sessionOptions = {}, onIncomplete) => {
+        try {
+            return await listSessions(sessionOptions);
+        }
+        catch (error) {
+            if (error instanceof MakaSessionCatalogIncompleteError) {
+                onIncomplete?.();
+                return [...error.sessions];
+            }
+            throw error;
+        }
+    };
+    const showSessionList = async (options = {}) => {
+        let catalogIncompleteNoticeShown = false;
+        const readPickerSessionCatalog = (sessionOptions) => readSessionCatalog(sessionOptions, () => {
+            if (catalogIncompleteNoticeShown)
+                return;
+            catalogIncompleteNoticeShown = true;
+            showSessionCatalogIncompleteNotice();
+        });
+        let sessions = await readPickerSessionCatalog(options.onlyResumable ? { limit: SESSION_CATALOG_MAX_SCAN_SESSIONS, cwd } : {});
+        let sessionTree = projectRevisionLinkedSessionTree(sessions, input.driver.getSessionId() ?? undefined);
+        let projectedSessions = flattenLinkedSessionTree(sessionTree.roots, sessionTree.childrenByParentId);
+        const resumeCandidateCheckFailures = new Set();
+        const checkSessionAvailability = async (session) => {
+            try {
+                const result = await runResumeAvailabilityCheck(async () => {
+                    if (!session.cwd) {
+                        return [session.id, { available: false, reason: 'Missing working directory' }];
+                    }
+                    if (options.onlyResumable) {
+                        if (!input.driver.getSessionResumeCandidateAvailability) {
+                            resumeCandidateCheckFailures.add(session.id);
+                            return [
+                                session.id,
+                                {
+                                    available: false,
+                                    reason: pickerCopy.resumeUnavailableNotice,
+                                },
+                            ];
+                        }
+                        return [
+                            session.id,
+                            await input.driver.getSessionResumeCandidateAvailability(session),
+                        ];
+                    }
+                    const availability = (await input.driver.getSessionResumeAvailability?.(session)) ??
+                        (await inspectSessionResumeAvailability(session));
+                    return [session.id, availability];
+                });
+                if (options.onlyResumable && input.driver.getSessionResumeCandidateAvailability) {
+                    resumeCandidateCheckFailures.delete(session.id);
+                }
+                return result;
+            }
+            catch (error) {
+                if (options.onlyResumable)
+                    resumeCandidateCheckFailures.add(session.id);
+                const detail = error instanceof Error ? error.message : String(error);
+                return [session.id, { available: false, reason: detail }];
+            }
+        };
+        // Recovery starts in the current workspace even for Host profiles whose
+        // normal /session picker starts in All. The user can still opt into the
+        // full catalog with the scope toggle after the current rows are ready.
+        let pickerScope = options.onlyResumable ? 'current' : sessionListScope;
+        const sessionsToCheck = (pickerScope === 'current' ? sessions.filter((session) => session.cwd === cwd) : sessions).slice(0, SESSION_CATALOG_MAX_SCAN_SESSIONS);
         // 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, externalSourceQuery] = await Promise.all([
-            Promise.all(sessions.map(async (session) => {
-                return [
-                    session.id,
-                    (await input.driver.getSessionResumeAvailability?.(session)) ??
-                        (await inspectSessionResumeAvailability(session)),
-                ];
-            })),
-            input.externalSessions && !turnRunning
+            Promise.all(sessionsToCheck.map(checkSessionAvailability)),
+            !options.onlyResumable && input.externalSessions && !turnRunning
                 ? input.externalSessions.listSources().then((adapterIds) => ({ adapterIds }), () => ({ error: true }))
                 : Promise.resolve({ adapterIds: [] }),
         ]);
         const availability = new Map(availabilityEntries);
+        const ensureAvailabilityForScope = async (scope) => {
+            const scopeSessions = (scope === 'current' ? sessions.filter((session) => session.cwd === cwd) : sessions).slice(0, SESSION_CATALOG_MAX_SCAN_SESSIONS);
+            const missingSessions = scopeSessions.filter((session) => !availability.has(session.id));
+            if (missingSessions.length === 0)
+                return;
+            for (const [sessionId, sessionAvailability] of await Promise.all(missingSessions.map(checkSessionAvailability))) {
+                availability.set(sessionId, sessionAvailability);
+            }
+        };
         if ('error' in externalSourceQuery) {
             state.entries.push({
                 kind: 'notice',
@@ -2814,14 +2932,22 @@ export async function runMakaPiTui(input) {
         let overlay;
         let sessionSearch;
         const renderScope = () => {
-            const visibleSessions = sessionListScope === 'current'
+            const visibleSessions = pickerScope === 'current'
                 ? projectedSessions.filter(({ session }) => session.cwd === cwd)
                 : projectedSessions;
-            const choices = visibleSessions.map(({ session, depth }) => {
+            const selectableSessions = options.onlyResumable
+                ? visibleSessions.filter(({ session }) => availability.get(session.id)?.available === true)
+                : visibleSessions;
+            const emptyText = options.onlyResumable &&
+                visibleSessions.length > 0 &&
+                visibleSessions.every(({ session }) => resumeCandidateCheckFailures.has(session.id))
+                ? pickerCopy.resumeCandidateCheckFailed
+                : undefined;
+            const choices = selectableSessions.map(({ session, depth }) => {
                 const state = availability.get(session.id);
                 const statusBadge = sessionStatusBadge(session, locale);
                 const statusDetail = statusBadge ? ` · ${statusBadge}` : '';
-                const location = sessionListScope === 'all' && session.cwd ? ` ${session.cwd}` : '';
+                const location = pickerScope === 'all' && session.cwd ? ` ${session.cwd}` : '';
                 const childDetail = session.subagentRuntime
                     ? ` subagent:${session.subagentRuntime.profile}`
                     : '';
@@ -2846,7 +2972,9 @@ export async function runMakaPiTui(input) {
                         .toLocaleLowerCase(),
                 };
             });
-            if ('adapterIds' in externalSourceQuery && externalSourceQuery.adapterIds.length > 0) {
+            if (!options.onlyResumable &&
+                'adapterIds' in externalSourceQuery &&
+                externalSourceQuery.adapterIds.length > 0) {
                 choices.push({
                     item: {
                         value: 'external:import',
@@ -2866,16 +2994,20 @@ export async function runMakaPiTui(input) {
                     showExternalSourcePicker(externalSourceQuery.adapterIds);
                     return;
                 }
-                if (availability.get(item.value)?.available === false)
+                const selectedSession = sessions.find((session) => session.id === item.value);
+                if (selectedSession && !selectedSession.cwd) {
                     return;
+                }
                 closeOverlay();
-                void goToSession(item.value);
+                void (async () => {
+                    const switched = await goToSession(item.value);
+                    if (switched && options.onlyResumable)
+                        await runControl(resumeSession);
+                })().catch(reportError);
             };
-            const scopeLabel = sessionListScope === 'current'
-                ? pickerCopy.sessionScopeCurrent
-                : pickerCopy.sessionScopeAll;
+            const scopeLabel = pickerScope === 'current' ? pickerCopy.sessionScopeCurrent : pickerCopy.sessionScopeAll;
             if (sessionSearch) {
-                sessionSearch.updateChoices(choices, scopeLabel);
+                sessionSearch.updateChoices(choices, scopeLabel, undefined, emptyText);
                 sessionSearch.invalidate();
                 return;
             }
@@ -2883,11 +3015,28 @@ export async function runMakaPiTui(input) {
                 locale,
                 choices,
                 scopeLabel,
+                emptyText,
                 onSelect,
                 onCancel: closeOverlay,
                 onToggleScope: () => {
-                    sessionListScope = sessionListScope === 'current' ? 'all' : 'current';
-                    renderScope();
+                    const nextScope = pickerScope === 'current' ? 'all' : 'current';
+                    void (async () => {
+                        if (options.onlyResumable) {
+                            sessions = await readPickerSessionCatalog(nextScope === 'current'
+                                ? { limit: SESSION_CATALOG_MAX_SCAN_SESSIONS, cwd }
+                                : { limit: SESSION_CATALOG_MAX_SCAN_SESSIONS });
+                            sessionTree = projectRevisionLinkedSessionTree(sessions, input.driver.getSessionId() ?? undefined);
+                            projectedSessions = flattenLinkedSessionTree(sessionTree.roots, sessionTree.childrenByParentId);
+                        }
+                        await ensureAvailabilityForScope(nextScope);
+                    })()
+                        .then(() => {
+                        pickerScope = nextScope;
+                        if (!options.onlyResumable)
+                            sessionListScope = nextScope;
+                        renderScope();
+                    })
+                        .catch(reportError);
                 },
             });
             sessionPickerOverlayOpen = true;
@@ -2895,6 +3044,34 @@ export async function runMakaPiTui(input) {
         };
         renderScope();
     };
+    const announceResumeAvailability = async () => {
+        const sessionId = input.driver.getSessionId();
+        try {
+            if (!input.driver.getSessionResumeCandidateAvailability)
+                return;
+            const sessions = sessionId
+                ? undefined
+                : await readSessionCatalog({ limit: SESSION_CATALOG_MAX_SCAN_SESSIONS, cwd });
+            const session = sessionId
+                ? ((await input.driver.getSessionSummary?.(sessionId)) ??
+                    (await readSessionCatalog()).find((candidate) => candidate.id === sessionId))
+                : sessions?.find((candidate) => candidate.cwd === cwd);
+            if (!session)
+                return;
+            const availability = await runResumeAvailabilityCheck(() => input.driver.getSessionResumeCandidateAvailability(session));
+            if (availability.available) {
+                state.entries.push({
+                    kind: 'notice',
+                    level: 'info',
+                    text: pickerCopy.resumeAvailabilityNotice,
+                });
+                requestRender();
+            }
+        }
+        catch {
+            // Resume discovery is advisory and must never prevent the TUI from starting.
+        }
+    };
     const showRewindPicker = async () => {
         const targets = await input.driver.listRewindTargets();
         if (targets.length === 0) {
@@ -4283,6 +4460,7 @@ export async function runMakaPiTui(input) {
         terminal.write(ENABLE_FOCUS_REPORTING);
         if (input.firstRun)
             void showSetupWizard();
+        setTimeout(() => void announceResumeAvailability(), 0);
     }
     catch (error) {
         beginClose(error instanceof Error ? error : new Error(String(error)));

package/dist/runtime-host-session-driver.js

@@ -28,14 +28,19 @@ import { mergeShellRunUpdate } from '@maka/core/shell-run-result';
 import { isActiveShellRunStatus } from '@maka/core/shell-run';
 import { executionBoundaryDisplayMode } from '@maka/core/sandbox-boundary';
 import { isRuntimeHostTerminalTurn as isTerminalTurn } from '@maka/runtime-host/adapter';
-import { projectSessionCatalogSummary, readRuntimeHostResources, readRuntimeHostSessions, RuntimeHostOperationError, RuntimeHostRequestInterruptedError, } from '@maka/runtime-host/client';
+import { projectSessionCatalogSummary, readRuntimeHostSessionCatalogPage, readRuntimeHostResources, readRuntimeHostSessions, RuntimeHostSessionCatalogRevisionChangedError, RuntimeHostOperationError, RuntimeHostRequestInterruptedError, } from '@maka/runtime-host/client';
 import { SESSION_TRANSCRIPT_BOOTSTRAP_MAX_BYTES, } from '@maka/runtime-host/protocol';
 import { RuntimeHostSessionChannel } from './runtime-host-session-channel.js';
+import { SESSION_CATALOG_MAX_SCAN_PAGES } from './session-catalog-limits.js';
 import { getRuntimeHostSession, requireRuntimeHostSessionProjection as requireSession, updateRuntimeHostSession, } from './runtime-host-session-update.js';
-import { inspectSessionResumeAvailability, skillInvocationBlockedMessage, } from './session-driver.js';
+import { MakaSessionCatalogIncompleteError, inspectSessionResumeAvailability, skillInvocationBlockedMessage, } from './session-driver.js';
 import { cwdRank, firstLine, inspectGitCwdChanges, resolveMoveCwd, } from './session-driver-policy.js';
 const decodeStoredMessage = (value) => decodePersistedStoredMessage(markPersisted(value));
 const MAX_CATALOG_ATTEMPTS = 3;
+// Sparse cwd or visibility matches must not turn a bounded lookup into a full Host scan.
+const MAX_SESSION_CATALOG_READ_ATTEMPTS = 8;
+const SESSION_CATALOG_READ_RETRY_BASE_DELAY_MS = 8;
+const SESSION_CATALOG_READ_RETRY_MAX_DELAY_MS = 64;
 /**
  * The host declined to start a safe-boundary continuation and explained why.
  * `reason` is the durable park reason from the `turn.resume` protocol, so
@@ -162,14 +167,16 @@ class RuntimeHostMakaSessionDriverImpl {
         const session = await this.#createSession(input.name ?? DEFAULT_SESSION_NAME);
         return projectSessionCatalogSummary(session);
     }
-    async listSessions() {
-        const sessions = (await readRuntimeHostSessions(this.#connection))
-            .flatMap(representableSession)
-            .filter((session) => !isSideConversationSession(session.labels))
-            .map(projectSessionCatalogSummary);
+    async listSessions(options = {}) {
+        const sessions = options.cwd !== undefined || options.limit !== undefined
+            ? await this.#readBoundedSessionCatalog(options.limit, options.cwd)
+            : (await readRuntimeHostSessions(this.#connection))
+                .flatMap(representableSession)
+                .filter((session) => !isSideConversationSession(session.labels));
+        const summaries = sessions.map(projectSessionCatalogSummary);
         if (this.#executionLocation.kind === 'host')
-            return sessions;
-        return sessions
+            return summaries;
+        return summaries
             .map((session, index) => ({ session, index }))
             .sort((left, right) => {
             const cwdDelta = cwdRank(left.session, this.#workspace.hostCwd) -
@@ -178,9 +185,80 @@ class RuntimeHostMakaSessionDriverImpl {
         })
             .map(({ session }) => session);
     }
-    getSessionResumeAvailability(session) {
+    async getSessionSummary(sessionId) {
+        const projection = await getRuntimeHostSession(this.#connection, sessionId);
+        if (!projection)
+            return undefined;
+        const [session] = representableSession(projection);
+        return session ? projectSessionCatalogSummary(session) : undefined;
+    }
+    async #readBoundedSessionCatalog(limit, cwd) {
+        if (limit !== undefined && (!Number.isSafeInteger(limit) || limit < 0)) {
+            throw new Error(`Session catalog limit must be a non-negative safe integer: ${limit}`);
+        }
+        if (limit === 0)
+            return [];
+        for (let attempt = 0; attempt < MAX_SESSION_CATALOG_READ_ATTEMPTS; attempt += 1) {
+            try {
+                const sessions = [];
+                const cursors = new Set();
+                let cursor;
+                let pagesRead = 0;
+                while (pagesRead < SESSION_CATALOG_MAX_SCAN_PAGES) {
+                    const page = await readRuntimeHostSessionCatalogPage(this.#connection, cursor);
+                    pagesRead += 1;
+                    for (const item of page.sessions) {
+                        for (const session of representableSession(item)) {
+                            if ((cwd === undefined || session.workspace.hostCwd === cwd) &&
+                                !isSideConversationSession(session.labels)) {
+                                sessions.push(session);
+                                if (limit !== undefined && sessions.length >= limit)
+                                    break;
+                            }
+                        }
+                        if (limit !== undefined && sessions.length >= limit)
+                            break;
+                    }
+                    if (!page.nextCursor) {
+                        cursor = undefined;
+                        break;
+                    }
+                    cursor = page.nextCursor;
+                    if (limit !== undefined && sessions.length >= limit) {
+                        throw new MakaSessionCatalogIncompleteError(pagesRead, sessions.map(projectSessionCatalogSummary));
+                    }
+                    if (cursors.has(cursor.cursor)) {
+                        throw new Error('Runtime Host Session catalog returned a repeated cursor');
+                    }
+                    cursors.add(cursor.cursor);
+                }
+                if (cursor !== undefined && pagesRead === SESSION_CATALOG_MAX_SCAN_PAGES) {
+                    throw new MakaSessionCatalogIncompleteError(pagesRead, sessions.map(projectSessionCatalogSummary));
+                }
+                return sessions;
+            }
+            catch (error) {
+                if (!(error instanceof RuntimeHostSessionCatalogRevisionChangedError) ||
+                    attempt + 1 === MAX_SESSION_CATALOG_READ_ATTEMPTS) {
+                    throw error;
+                }
+                await new Promise((resolve) => setTimeout(resolve, Math.min(SESSION_CATALOG_READ_RETRY_BASE_DELAY_MS * 2 ** attempt, SESSION_CATALOG_READ_RETRY_MAX_DELAY_MS)));
+            }
+        }
+        throw new Error('Runtime Host Session catalog could not be read consistently');
+    }
+    async getSessionResumeAvailability(session) {
         return inspectRuntimeHostSessionResumeAvailability(session, this.#executionLocation);
     }
+    async getSessionResumeCandidateAvailability(session) {
+        const availability = await inspectRuntimeHostSessionResumeAvailability(session, this.#executionLocation);
+        if (!availability.available)
+            return availability;
+        const plan = await this.#request('turn.resume.query', { sessionId: session.id });
+        return plan.disposition === 'ready'
+            ? { available: true }
+            : { available: false, reason: plan.reason };
+    }
     async preparePrompt(prompt, options = {}) {
         const sessionId = await this.#ensureSession();
         const sessionGeneration = this.#sessionGeneration;
@@ -1496,9 +1574,9 @@ function inspectRuntimeHostSessionResumeAvailability(summary, location) {
     if (!summary.cwd) {
         return Promise.resolve({ available: false, reason: 'Missing working directory' });
     }
-    return location.kind === 'host'
-        ? Promise.resolve({ available: true })
-        : inspectSessionResumeAvailability(summary);
+    if (location.kind !== 'host')
+        return inspectSessionResumeAvailability(summary);
+    return Promise.resolve({ available: true });
 }
 async function assertSessionResumeAvailable(summary, location) {
     const availability = await inspectRuntimeHostSessionResumeAvailability(summary, location);

package/dist/session-catalog-limits.js

@@ -0,0 +1,22 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { SESSION_CATALOG_PAGE_MAX_ITEMS } from '@maka/runtime-host/protocol';
+// Sparse cwd or visibility matches must not turn a bounded lookup into a full Host scan.
+export const SESSION_CATALOG_MAX_SCAN_PAGES = 8;
+export const SESSION_CATALOG_MAX_SCAN_SESSIONS = SESSION_CATALOG_MAX_SCAN_PAGES * SESSION_CATALOG_PAGE_MAX_ITEMS;

package/dist/session-driver.js

@@ -31,6 +31,16 @@ export function skillInvocationBlockedMessage(skillInvocation) {
         ? `Could not resolve the Skill this Turn asked for: ${reasons.join(', ')}`
         : 'Explicit Skill invocation could not be resolved';
 }
+export class MakaSessionCatalogIncompleteError extends Error {
+    scannedPages;
+    sessions;
+    constructor(scannedPages, sessions = []) {
+        super(`Session catalog results may be incomplete after scanning ${scannedPages} pages.`);
+        this.scannedPages = scannedPages;
+        this.sessions = sessions;
+        this.name = 'MakaSessionCatalogIncompleteError';
+    }
+}
 export async function inspectSessionResumeAvailability(session) {
     if (!session.cwd)
         return { available: false, reason: 'Missing working directory' };

package/dist/tui-copy-catalog.js

@@ -638,6 +638,11 @@ export const TUI_COPY_RESOURCES = {
             sessionScopeAll: 'All',
             sessionSearchHint: 'Search name / id / path / model / connection · Tab scope · ↑↓ select · Enter open · Esc close',
             noMatchingSessions: 'No matching sessions',
+            resumeCandidateCheckFailed: 'Could not check whether any sessions can be resumed.',
+            resumeAvailabilityNotice: 'An interrupted run is available — use /resume to continue from a safe boundary.',
+            resumeStartingNotice: 'Resuming from the latest safe boundary…',
+            resumeUnavailableNotice: 'Safe-boundary resume is unavailable on this runtime.',
+            resumeCatalogIncompleteNotice: 'Session discovery stopped before the full catalog was checked. Showing the sessions found so far.',
             selectPickerHint: '↑↓ select · Enter confirm · Esc close',
             providerConfigured: 'configured',
             addAccount: 'add account',
@@ -758,6 +763,11 @@ export const TUI_COPY_RESOURCES = {
             sessionScopeAll: '全部',
             sessionSearchHint: '搜索名称 / ID / 路径 / 模型 / 连接 · Tab 切换范围 · ↑↓ 选择 · Enter 打开 · Esc 关闭',
             noMatchingSessions: '没有匹配的会话',
+            resumeCandidateCheckFailed: '无法检查是否有可恢复的会话。',
+            resumeAvailabilityNotice: '有可恢复的中断会话，可使用 /resume 从安全边界继续。',
+            resumeStartingNotice: '正在从最新的安全边界恢复……',
+            resumeUnavailableNotice: '当前运行环境不支持安全边界恢复。',
+            resumeCatalogIncompleteNotice: '会话目录尚未检查完整。当前显示已找到的会话。',
             selectPickerHint: '↑↓ 选择 · Enter 确认 · Esc 关闭',
             providerConfigured: '已设置',
             addAccount: '添加账号',
@@ -877,6 +887,11 @@ export const TUI_COPY_RESOURCES = {
             sessionScopeAll: '全部',
             sessionSearchHint: '搜尋名稱 / ID / 路徑 / 模型 / 連線 · Tab 切換範圍 · ↑↓ 選取 · Enter 開啟 · Esc 關閉',
             noMatchingSessions: '沒有符合的會話',
+            resumeCandidateCheckFailed: '無法檢查是否有可恢復的會話。',
+            resumeAvailabilityNotice: '有可恢復的中斷會話，可使用 /resume 從安全邊界繼續。',
+            resumeStartingNotice: '正在從最新的安全邊界恢復……',
+            resumeUnavailableNotice: '目前執行環境不支援安全邊界恢復。',
+            resumeCatalogIncompleteNotice: '會話目錄尚未檢查完整。目前顯示已找到的會話。',
             selectPickerHint: '↑↓ 選擇 · Enter 確認 · Esc 關閉',
             providerConfigured: '已設定',
             addAccount: '新增帳號',

package/node_modules/@maka/core/dist/bot-chat-settings.js

@@ -61,12 +61,14 @@ export function createDefaultBotChannel(provider) {
 }
 export function createDefaultBotChatSettings() {
     return {
+        messageHandling: 'task',
         channels: Object.fromEntries(BOT_PROVIDERS.map((provider) => [provider, createDefaultBotChannel(provider)])),
     };
 }
 export function mergeBotChatSettings(current, patch) {
     return {
         ...current,
+        ...(patch?.messageHandling ? { messageHandling: patch.messageHandling } : {}),
         channels: {
             ...current.channels,
             ...Object.fromEntries(Object.entries(patch?.channels ?? {}).map(([provider, channelPatch]) => {
@@ -93,6 +95,7 @@ export function mergeBotChatSettings(current, patch) {
 }
 export function normalizeBotChatSettings(settings, rawSettings) {
     return {
+        messageHandling: rawSettings?.messageHandling === 'workhub' ? 'workhub' : 'task',
         channels: Object.fromEntries(BOT_PROVIDERS.map((provider) => {
             const rawChannel = rawSettings?.channels?.[provider];
             return [provider, normalizeBotChannel(provider, settings.channels[provider], rawChannel)];