maka-agent 0.2.0-dev.41.20260918 → 0.2.0-dev.43.20260919

package/dist/acp/session-registry.js

@@ -28,6 +28,7 @@ import { RuntimeHostSessionUpdateError, getRuntimeHostSession, requireRuntimeHos
 import { AcpSessionConfigInputError, createAcpSessionConfigPatch, projectAcpSessionConfigOptions, validateAcpSessionConfigOptionRequest, } from './session-configuration.js';
 import { AcpSessionEventMapper } from './session-event-mapper.js';
 import { mapAcpPromptContent, publishAcpPromptAttachments } from './prompt-content.js';
+import { AcpSessionInteractions } from './session-interactions.js';
 const ACP_SESSION_CURSOR_MAX_BYTES = 8 * 1024;
 const ADMISSION_QUERY_MAX_ATTEMPTS = 5;
 const ADMISSION_QUERY_TIMEOUT_MS = 1_000;
@@ -39,6 +40,7 @@ export class AcpSessionRegistry {
     #newTurnId;
     #inFlightOperations = new Set();
     #ownedSessionIds = new Set();
+    #attachmentInteractions = new Map();
     #attachments = new Map();
     #attachmentOpenControllers = new Map();
     #attachmentConfigurations = new Map();
@@ -181,7 +183,7 @@ export class AcpSessionRegistry {
             const connection = await this.#getConnection('subscription.open');
             let attachment;
             try {
-                attachment = await this.#ensureAttachment(params.sessionId, connection, context.notify);
+                attachment = await this.#ensureAttachment(params.sessionId, connection, context);
             }
             catch (error) {
                 if (active.cancelled)
@@ -274,6 +276,11 @@ export class AcpSessionRegistry {
             active.projectionAbort.abort();
             active.reconciliationAbort.abort();
             active.transcript?.dispose();
+            this.#attachmentInteractions.get(active.sessionId)?.settleTurn(active.turnId);
+            const observed = active.attachment?.snapshot.rootTurn;
+            if (observed?.turnId === active.turnId && isRuntimeHostTerminalTurn(observed)) {
+                this.#attachmentInteractions.get(active.sessionId)?.terminalTurn(active.turnId);
+            }
             active.finished = true;
             this.#wake(active);
             this.#removeActivePrompt(active);
@@ -366,6 +373,7 @@ export class AcpSessionRegistry {
         }
         active.projectionAbort.abort();
         active.reconciliationAbort.abort();
+        this.#attachmentInteractions.get(active.sessionId)?.cancelTurn(active.turnId);
         active.stopTask ??= this.#stopPromptWhenObservable(active);
         await Promise.all([
             active.mapper.flush().catch(() => undefined),
@@ -468,14 +476,14 @@ export class AcpSessionRegistry {
         }, 'Runtime Host Turn admission could not be established; Stop could not be confirmed');
         this.#wake(active);
     }
-    async #ensureAttachment(sessionId, connection, notify) {
+    async #ensureAttachment(sessionId, connection, context) {
         const existing = this.#attachments.get(sessionId);
         if (existing)
             return existing;
         const openingController = new AbortController();
         this.#attachmentOpenControllers.set(sessionId, openingController);
         const configuration = {
-            notify,
+            notify: context.notify,
             // Setters can outlive an absent or failed attachment. Their responses
             // must precede refreshes delivered by the new attachment's queue.
             tail: Promise.allSettled([...(this.#pendingConfigSets.get(sessionId) ?? [])]),
@@ -491,6 +499,50 @@ export class AcpSessionRegistry {
             }
             this.#retireFailedAttachment(sessionId, task, attachment, error);
         };
+        const interactions = new AcpSessionInteractions({
+            sessionId,
+            connection,
+            client: context.interactions ?? {
+                capabilities: {},
+                requestPermission: async () => {
+                    throw RequestError.methodNotFound('session/request_permission');
+                },
+                createElicitation: async () => {
+                    throw RequestError.methodNotFound('elicitation/create');
+                },
+            },
+            onPending: async (pending) => {
+                for (const active of this.#activePrompts.get(sessionId) ?? []) {
+                    if (active.turnId === pending.turnId && !active.cancelled) {
+                        await active.mapper.pendingInteraction(pending);
+                    }
+                }
+            },
+            onAnswered: (answered, pending) => attachment?.publishInteractionAnswer(answered, pending),
+            onResolved: async (resolved, pending) => {
+                for (const active of this.#activePrompts.get(sessionId) ?? []) {
+                    if (active.turnId === pending.turnId && !active.cancelled && !active.finished) {
+                        await active.mapper.resolvedInteraction(resolved, pending);
+                    }
+                }
+            },
+            onFailure: (pending, error) => {
+                const active = [...(this.#activePrompts.get(sessionId) ?? [])].find((prompt) => prompt.turnId === pending.turnId && !prompt.finished);
+                if (active?.attachment) {
+                    active.projectionFailure ??= error;
+                    active.attachment.failTurn(active.turnId, error);
+                }
+                else if (!attachment)
+                    failAttachment(error);
+            },
+            onCancelled: (pending) => {
+                for (const active of this.#activePrompts.get(sessionId) ?? []) {
+                    if (active.turnId === pending.turnId)
+                        void this.#cancelPrompt(active).catch(() => undefined);
+                }
+            },
+        });
+        this.#attachmentInteractions.set(sessionId, interactions);
         task = RuntimeHostSessionChannel.open({
             connection,
             signal: openingController.signal,
@@ -501,6 +553,9 @@ export class AcpSessionRegistry {
             onRuntimeResourceChanged: () => undefined,
             onSnapshotChanged: (snapshot) => {
                 this.#wakeSession(sessionId);
+                if (snapshot.rootTurn && isRuntimeHostTerminalTurn(snapshot.rootTurn)) {
+                    interactions.terminalTurn(snapshot.rootTurn.turnId);
+                }
                 if (configuration.metadataRevision === undefined) {
                     configuration.metadataRevision = snapshot.session.metadataRevision;
                     return;
@@ -534,15 +589,20 @@ export class AcpSessionRegistry {
                 }
             },
             onInteractionPending: (pending) => {
-                if (![...(this.#activePrompts.get(sessionId) ?? [])].some((active) => active.turnId === pending.turnId && active.dispatchStarted)) {
-                    // An idle attachment may observe another client's Turn. Retain its
-                    // identity so a later ACP cancel/close can still stop that root.
+                if (!interactions.fencesTurn(pending.turnId) &&
+                    ![...(this.#activePrompts.get(sessionId) ?? [])].some((active) => active.turnId === pending.turnId && active.dispatchStarted)) {
+                    // Idle attachments may observe a Turn started by another client. Do not
+                    // present its interaction through this ACP connection's client.
                     return;
                 }
-                // Interaction mapping is added by the next independently reviewable ACP increment.
-                failAttachment(RequestError.internalError({ source: 'adapter', code: 'unsupported_interaction', kind: pending.request.kind }, 'This ACP adapter does not support interactions yet; the prompt failed'));
+                void interactions.pending(pending);
+            },
+            onInteractionResolved: (pending) => {
+                if (!interactions.fencesTurn(pending.turnId) &&
+                    ![...(this.#activePrompts.get(sessionId) ?? [])].some((active) => active.turnId === pending.turnId && active.dispatchStarted))
+                    return;
+                void interactions.resolved(pending);
             },
-            onInteractionResolved: () => undefined,
             onTranscriptSettlement: (turnId) => {
                 for (const active of this.#activePrompts.get(sessionId) ?? []) {
                     if (active.turnId === turnId)
@@ -583,6 +643,10 @@ export class AcpSessionRegistry {
             return channel;
         })
             .catch((error) => {
+            interactions.close();
+            if (this.#attachmentInteractions.get(sessionId) === interactions) {
+                this.#attachmentInteractions.delete(sessionId);
+            }
             if (this.#attachments.get(sessionId) === task) {
                 this.#attachments.delete(sessionId);
                 this.#attachmentConfigurations.delete(sessionId);
@@ -603,6 +667,8 @@ export class AcpSessionRegistry {
         if (this.#attachments.get(sessionId) === task) {
             this.#attachments.delete(sessionId);
             this.#attachmentConfigurations.delete(sessionId);
+            this.#attachmentInteractions.get(sessionId)?.close();
+            this.#attachmentInteractions.delete(sessionId);
         }
         for (const active of this.#activePrompts.get(sessionId) ?? []) {
             if (active.attachment !== attachment)
@@ -616,6 +682,8 @@ export class AcpSessionRegistry {
     }
     async #closeSession(sessionId, delivery) {
         const cancellation = await this.#cancelSession(sessionId);
+        this.#attachmentInteractions.get(sessionId)?.close();
+        this.#attachmentInteractions.delete(sessionId);
         const attachmentTask = this.#attachments.get(sessionId);
         this.#attachments.delete(sessionId);
         let closeError;
@@ -814,6 +882,9 @@ export class AcpSessionRegistry {
             ...(this.#activePrompts.get(sessionId) ?? []),
         ]);
         const cancellations = [...sessionIds].map((sessionId) => this.#cancelSession(sessionId));
+        for (const interactions of this.#attachmentInteractions.values())
+            interactions.close();
+        this.#attachmentInteractions.clear();
         const attachments = [...this.#attachments.values()];
         this.#attachments.clear();
         const configurations = [...this.#attachmentConfigurations.values()];

package/dist/acp/tool-event-mapper.js

@@ -96,6 +96,59 @@ export class AcpToolEventMapper {
             await this.#result(this.#ensure(message.turnId, message.toolUseId), message.isError, message.content, message.durationMs, false);
         }
     }
+    async pendingInteraction(pending) {
+        const tool = this.#ensure(pending.turnId, interactionToolId(pending));
+        if (pending.request.kind === 'sandbox_boundary')
+            tool.synthetic = true;
+        if (tool.terminal)
+            return;
+        tool.status = 'pending';
+        tool.meta.interaction = {
+            id: pending.interactionId,
+            kind: pending.request.kind,
+            status: 'pending',
+        };
+        if (!tool.name)
+            tool.title = `Awaiting ${pending.request.kind.replaceAll('_', ' ')}`;
+        await this.#publish(tool);
+    }
+    async resolvedInteraction(resolved, pending) {
+        if (resolved.status === 'pending')
+            return;
+        const tool = this.#ensure(pending.turnId, interactionToolId(pending));
+        if (pending.request.kind === 'sandbox_boundary')
+            tool.synthetic = true;
+        const outcome = resolved.outcome;
+        tool.meta.interaction = {
+            id: pending.interactionId,
+            kind: pending.request.kind,
+            status: resolved.status,
+            ...(outcome.kind === 'closure' ? { reason: outcome.reason } : {}),
+            ...('decision' in outcome ? { decision: outcome.decision } : {}),
+            ...('action' in outcome ? { action: outcome.action } : {}),
+        };
+        if (!tool.terminal) {
+            if (pending.request.kind === 'sandbox_boundary') {
+                tool.terminal = true;
+                tool.status =
+                    outcome.kind === 'sandbox_boundary_decision' && outcome.decision === 'allow'
+                        ? 'completed'
+                        : 'failed';
+            }
+            else
+                tool.status = 'in_progress';
+        }
+        const closure = outcome.kind === 'closure' ? `Interaction closed: ${outcome.reason}` : undefined;
+        if (closure && !tool.terminal) {
+            tool.progress ??= progressBuffer();
+            tool.progress.append(closure);
+        }
+        await this.#publish(tool, closure && pending.request.kind === 'sandbox_boundary'
+            ? { content: textContent(closure) }
+            : {});
+        if (tool.terminal)
+            this.#release(tool);
+    }
     /** Called only after authoritative turn settlement and transcript reconciliation. */
     async finishTools(turnId, terminalStatus) {
         let missingResult = false;
@@ -112,8 +165,8 @@ export class AcpToolEventMapper {
             }
             // A live result announcement promises a durable result. A start, delta or
             // progress event alone does not: completed turns can contain unfinished
-            // tool calls, and those should remain visible as interrupted cards.
-            if (terminalStatus === 'completed' && tool.resultAnnounced)
+            // tool calls, and synthetic interaction cards have no tool result.
+            if (terminalStatus === 'completed' && !tool.synthetic && tool.resultAnnounced)
                 missingResult = true;
             this.#release(tool);
         }
@@ -308,6 +361,11 @@ function fixedStateChars(tool) {
 function digestValue(value) {
     return createHash('sha256').update(JSON.stringify(value)).digest('hex');
 }
+function interactionToolId(pending) {
+    return pending.request.kind === 'sandbox_boundary'
+        ? pending.interactionId
+        : pending.request.toolUseId;
+}
 function rawInput(toolName, args) {
     // The shared transcript intentionally projects these two tools' arguments.
     if (args === undefined || toolName === 'WriteStdin' || toolName === 'todo_write')

package/dist/pi-tui-runner.js

@@ -18,6 +18,7 @@
  */
 import { randomUUID } from 'node:crypto';
 import { Key, ProcessTerminal, SelectList, TuiMainScreen, isKeyRelease, isKeyRepeat, matchesKey, } from '@earendil-works/pi-tui';
+import { normalizeExternalSessionQueryText, } from '@maka/core/external-session';
 import { CurrentTodoStore, TodoOverlay, renderTodoIndicator } from './pi-tui-todo.js';
 import { isThinkingLevel } from '@maka/core/model-thinking';
 import { deriveConnectionSlug } from '@maka/core/llm-connections';
@@ -53,6 +54,7 @@ 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';
+const EXTERNAL_SESSION_SEARCH_DEBOUNCE_MS = 120;
 function externalSourceLabel(adapterId) {
     switch (adapterId) {
         case 'claude-code':
@@ -203,6 +205,7 @@ export async function runMakaPiTui(input) {
     let connectionIdentityNotice;
     let busy = false;
     let closed = false;
+    const cancelScheduledExternalSearches = new Set();
     let currentActivityCompletion;
     let permissionResponseInFlightRequestId = null;
     // Session recap (issue #1055): an in-flight lock shared by manual and
@@ -718,6 +721,9 @@ export async function runMakaPiTui(input) {
         attention.reset();
         // Stop asking the terminal for focus reports before handing it back.
         terminal.write(DISABLE_FOCUS_REPORTING);
+        for (const cancel of cancelScheduledExternalSearches)
+            cancel();
+        cancelScheduledExternalSearches.clear();
         tui.stop();
     };
     const beginClose = (error) => {
@@ -2580,17 +2586,41 @@ export async function runMakaPiTui(input) {
         let sessions = [];
         let nextCursor = null;
         let revision = 0;
+        let normalizedQuery = normalizeExternalSessionQueryText(query);
+        let cancelScheduledSearch;
+        let pageClosed = false;
         let overlay;
         let search;
         let byValue = new Map();
-        const closeOverlay = () => overlay?.hide();
+        const dropScheduledSearch = () => {
+            const hadScheduledSearch = cancelScheduledSearch !== undefined;
+            if (cancelScheduledSearch)
+                cancelScheduledExternalSearches.delete(cancelScheduledSearch);
+            cancelScheduledSearch?.();
+            cancelScheduledSearch = undefined;
+            return hadScheduledSearch;
+        };
+        const resetCatalogPage = () => {
+            sessions = [];
+            nextCursor = null;
+            byValue = new Map();
+            render();
+        };
+        const closeOverlay = () => {
+            pageClosed = true;
+            dropScheduledSearch();
+            revision += 1;
+            overlay?.hide();
+        };
         const toggleScope = () => {
             const alternate = input.externalSessions
                 ?.listScopes()
                 .find((candidate) => candidate !== scope);
             if (!alternate)
                 return;
+            dropScheduledSearch();
             scope = alternate;
+            resetCatalogPage();
             void load(false);
         };
         const render = () => {
@@ -2647,8 +2677,29 @@ export async function runMakaPiTui(input) {
                 emptyText: sessions.length === 0 ? copy.externalEmpty : copy.externalUnavailable,
                 notice,
                 onQuery: (text) => {
+                    const nextNormalizedQuery = normalizeExternalSessionQueryText(text);
                     query = text;
-                    void load(false);
+                    if (nextNormalizedQuery === normalizedQuery)
+                        return;
+                    normalizedQuery = nextNormalizedQuery;
+                    dropScheduledSearch();
+                    resetCatalogPage();
+                    // Retire an older in-flight response immediately. Waiting until the
+                    // debounce fires would let it repaint results for the previous query.
+                    const requestRevision = ++revision;
+                    let cancel;
+                    const handle = setTimeout(() => {
+                        if (cancel)
+                            cancelScheduledExternalSearches.delete(cancel);
+                        cancelScheduledSearch = undefined;
+                        if (closed || pageClosed)
+                            return;
+                        void load(false, undefined, requestRevision);
+                    }, EXTERNAL_SESSION_SEARCH_DEBOUNCE_MS);
+                    handle.unref();
+                    cancel = () => clearTimeout(handle);
+                    cancelScheduledSearch = cancel;
+                    cancelScheduledExternalSearches.add(cancel);
                 },
                 onSelect: (item) => {
                     if (item.value === 'external:load-more' && nextCursor) {
@@ -2702,8 +2753,8 @@ export async function runMakaPiTui(input) {
             });
             overlay = showBottomPicker(search);
         };
-        const load = async (append, cursor) => {
-            const requestRevision = ++revision;
+        const load = async (append, cursor, scheduledRevision) => {
+            const requestRevision = scheduledRevision ?? ++revision;
             try {
                 const page = await input.externalSessions.listSessions({
                     adapterId,
@@ -2711,14 +2762,14 @@ export async function runMakaPiTui(input) {
                     ...(cursor ? { cursor } : {}),
                     ...(query ? { text: query } : {}),
                 });
-                if (requestRevision !== revision || closed || turnRunning)
+                if (requestRevision !== revision || pageClosed || closed || turnRunning)
                     return;
                 sessions = append ? [...sessions, ...page.sessions] : page.sessions;
                 nextCursor = page.nextCursor;
                 render();
             }
             catch {
-                if (requestRevision !== revision)
+                if (requestRevision !== revision || pageClosed || closed)
                     return;
                 state.entries.push({ kind: 'notice', level: 'error', text: copy.externalCatalogFailed });
                 requestRender();

package/node_modules/@maka/core/dist/client-plugin-bridge.js

@@ -0,0 +1,19 @@
+/*
+ * 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.
+ */
+export {};

package/node_modules/@maka/core/dist/connection-usage.js

@@ -0,0 +1,27 @@
+/*
+ * 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.
+ */
+/**
+ * The providers Maka can read account usage from. The single source of truth
+ * for both the settings section's visibility and the runtime dispatch, so a
+ * provider that gains a mapper is offered the card in the same change.
+ */
+const USAGE_PROVIDERS = new Set(['commandcode-go']);
+export function providerReportsUsage(providerType) {
+    return USAGE_PROVIDERS.has(providerType);
+}

package/node_modules/@maka/core/dist/events.js

@@ -79,7 +79,16 @@ export function hasMeaningfulMessageContent(content) {
         (content.directoryReferences?.length ?? 0) > 0);
 }
 const ATTACHMENT_REF_SHAPE = defineObjectShape()(['kind', 'name', 'mimeType', 'bytes', 'ref'], []);
-const QUOTE_REF_SHAPE = defineObjectShape()(['text'], ['label', 'sourceTurnId']);
+const QUOTE_REF_SHAPE = defineObjectShape()(['text'], [
+    'label',
+    'sourceTurnId',
+    'sourceSessionId',
+    'sourceSessionName',
+    'sourceCapturedAt',
+    'sourceTruncated',
+]);
+const QUOTE_REF_SESSION_ID_MAX_LENGTH = 512;
+const QUOTE_REF_SESSION_NAME_MAX_LENGTH = 200;
 const INLINE_REFERENCE_SHAPE = defineObjectShape()(['kind', 'value', 'label', 'start'], []);
 const INLINE_SKILL_REFERENCE_VALUE = /^\/skill:[A-Za-z0-9._-]+$/;
 export const INLINE_REFERENCE_MAX_COUNT = 32;
@@ -113,6 +122,22 @@ export function normalizeMessageContent(content) {
                     text: quote.text,
                     ...(quote.label !== undefined ? { label: quote.label } : {}),
                     ...(quote.sourceTurnId !== undefined ? { sourceTurnId: quote.sourceTurnId } : {}),
+                    ...(quote.sourceSessionId !== undefined
+                        ? { sourceSessionId: quote.sourceSessionId }
+                        : {}),
+                    ...(quote.sourceSessionName !== undefined
+                        ? { sourceSessionName: quote.sourceSessionName }
+                        : {}),
+                    ...(quote.sourceCapturedAt !== undefined
+                        ? {
+                            sourceCapturedAt: Object.is(quote.sourceCapturedAt, -0)
+                                ? 0
+                                : quote.sourceCapturedAt,
+                        }
+                        : {}),
+                    ...(quote.sourceTruncated !== undefined
+                        ? { sourceTruncated: quote.sourceTruncated }
+                        : {}),
                 })),
             }
             : {}),
@@ -205,11 +230,33 @@ export function isInlineReference(value) {
                 })));
 }
 export function isQuoteRef(value) {
-    return (isRecord(value) &&
-        hasExactShape(value, QUOTE_REF_SHAPE) &&
-        typeof value.text === 'string' &&
-        (value.label === undefined || typeof value.label === 'string') &&
-        (value.sourceTurnId === undefined || typeof value.sourceTurnId === 'string'));
+    const record = isRecord(value) ? value : undefined;
+    const sourceFields = record
+        ? [
+            record.sourceSessionId,
+            record.sourceSessionName,
+            record.sourceCapturedAt,
+            record.sourceTruncated,
+        ]
+        : [];
+    const hasSourceMetadata = sourceFields.some((field) => field !== undefined);
+    return (record !== undefined &&
+        hasExactShape(record, QUOTE_REF_SHAPE) &&
+        typeof record.text === 'string' &&
+        (record.label === undefined || typeof record.label === 'string') &&
+        (record.sourceTurnId === undefined || typeof record.sourceTurnId === 'string') &&
+        (!hasSourceMetadata ||
+            (typeof record.sourceSessionId === 'string' &&
+                record.sourceSessionId.length > 0 &&
+                record.sourceSessionId.length <= QUOTE_REF_SESSION_ID_MAX_LENGTH &&
+                typeof record.sourceSessionName === 'string' &&
+                record.sourceSessionName.length > 0 &&
+                record.sourceSessionName.length <= QUOTE_REF_SESSION_NAME_MAX_LENGTH &&
+                typeof record.sourceCapturedAt === 'number' &&
+                Number.isFinite(record.sourceCapturedAt) &&
+                record.sourceCapturedAt >= 0 &&
+                record.sourceCapturedAt <= 8.64e15 &&
+                typeof record.sourceTruncated === 'boolean')));
 }
 export function isAttachmentRef(value) {
     return (isRecord(value) &&
@@ -339,7 +386,11 @@ function inlineReferencesEqual(left, right) {
 function quoteRefsEqual(left, right) {
     return (left.text === right.text &&
         left.label === right.label &&
-        left.sourceTurnId === right.sourceTurnId);
+        left.sourceTurnId === right.sourceTurnId &&
+        left.sourceSessionId === right.sourceSessionId &&
+        left.sourceSessionName === right.sourceSessionName &&
+        left.sourceCapturedAt === right.sourceCapturedAt &&
+        left.sourceTruncated === right.sourceTruncated);
 }
 function attachmentRefsEqual(left, right) {
     if (left.kind !== right.kind ||

package/node_modules/@maka/core/dist/external-session.js

@@ -72,8 +72,8 @@ export function externalSessionMatchesQuery(summary, query = {}) {
     const text = normalizeExternalSessionQueryText(query.text);
     if (text === undefined)
         return true;
-    // Title and path, because those are the two things a user remembers about a
-    // conversation they are looking for. Both already sit on the summary, so
+    // Source id, title, and path are the bounded summary fields a user can paste
+    // or remember about a conversation. All already sit on the summary, so
     // matching costs no extra reads. Message content is deliberately excluded:
     // it would mean opening every transcript on every keystroke.
     //
@@ -86,7 +86,8 @@ export function externalSessionMatchesQuery(summary, query = {}) {
     // literal backslash-n, and folding the term without the title would stop
     // `\\n` from finding the very title it names. The path pair has no such
     // ambiguity: a separator there is a separator.
-    return (normalizeExternalSessionMatchText(summary.name).includes(text) ||
+    return (normalizeExternalSessionMatchText(summary.id).includes(text) ||
+        normalizeExternalSessionMatchText(summary.name).includes(text) ||
         foldExternalSessionPathSeparators(normalizeExternalSessionMatchText(summary.cwd)).includes(foldExternalSessionPathSeparators(text)));
 }
 /**