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

package/README.md

@@ -65,7 +65,7 @@ https://incubator.apache.org/projects/maka.html
 
 ## Requirements
 
-- Node.js 22.19.0 or newer;
+- Node.js 22.19.0 or newer on the 22 line, or 24.0.0 or newer (Node 23 is not supported);
 - a terminal with interactive input for the TUI;
 - a configured model connection for agent turns; first-run setup currently supports API-key
   providers.

package/README.zh-CN.md

@@ -39,7 +39,7 @@ release commit 中的 [DISCLAIMER-WIP](https://github.com/apache/maka/blob/main/
 
 ## 环境要求
 
-- Node.js 22.19.0 或更高版本；
+- Node.js 22.19.0 或更高的 22.x 版本，或 24.0.0 及以上版本（不支持 Node 23）；
 - 使用 TUI 时需要支持交互输入的终端；
 - 执行 Agent Turn 时需要已经配置的模型连接；首次设置目前支持使用 API Key 的供应商。
 

package/node_modules/@maka/runtime/dist/agent-graph-supervisor-wake.js

@@ -83,6 +83,10 @@ export class AgentGraphSupervisorWakeCoordinator {
     #tasks = new Set();
     #tasksBySession = new Map();
     #pendingWakeIds = new Set();
+    #sessionAttention = new Map();
+    #parkedWakeIds = new Map();
+    #activityVersions = new Map();
+    #publishedActivity = new Map();
     #abortController = new AbortController();
     #sessionAbortControllers = new Map();
     #sessionWakeSuppressions = new Map();
@@ -95,18 +99,45 @@ export class AgentGraphSupervisorWakeCoordinator {
             throw new Error('Agent graph supervisor wake attempts must be a positive safe integer');
         }
     }
+    /** Includes queued checkpoint delivery before a supervisor Turn is admitted. */
+    readSessionActivity(rootSessionId) {
+        if (this.#closed || this.#sessionWakesSuppressed(rootSessionId))
+            return 'idle';
+        const attention = this.#sessionAttention.get(rootSessionId);
+        if (attention === 'waiting_for_user')
+            return attention;
+        if (this.#tasksBySession.has(rootSessionId))
+            return 'running';
+        return attention ?? 'idle';
+    }
+    #publishSessionActivity(rootSessionId) {
+        const activity = this.readSessionActivity(rootSessionId);
+        if ((this.#publishedActivity.get(rootSessionId) ?? 'idle') === activity)
+            return;
+        if (activity === 'idle')
+            this.#publishedActivity.delete(rootSessionId);
+        else
+            this.#publishedActivity.set(rootSessionId, activity);
+        try {
+            this.#input.onSessionActivityChanged?.(rootSessionId);
+        }
+        catch {
+            // A catalog observer never controls wake delivery.
+        }
+    }
     notify(rootSessionId, result) {
         if (this.#closed ||
             this.#sessionWakesSuppressed(rootSessionId) ||
             (!this.#input.shouldWake && (!result || !isAgentGraphSupervisorMilestone(result)))) {
             return undefined;
         }
-        return this.#runTracked(rootSessionId, async (abortSignal) => {
+        return this.#runTracked(rootSessionId, async (abortSignal, setAttention) => {
             try {
-                await this.#wake(rootSessionId, abortSignal, result);
+                await this.#wake(rootSessionId, abortSignal, setAttention, result);
             }
             catch (error) {
                 if (!this.#closed && !isAbortError(error)) {
+                    setAttention('blocked');
                     await notifyError(this.#input.onError, rootSessionId, error);
                 }
             }
@@ -122,12 +153,15 @@ export class AgentGraphSupervisorWakeCoordinator {
     notifyPermissionResponse(rootSessionId) {
         if (this.#closed || this.#sessionWakesSuppressed(rootSessionId))
             return undefined;
-        return this.#runTracked(rootSessionId, async (abortSignal) => {
+        this.#sessionAttention.delete(rootSessionId);
+        this.#parkedWakeIds.delete(rootSessionId);
+        return this.#runTracked(rootSessionId, async (abortSignal, setAttention) => {
             try {
-                await this.#settlePermissionResponse(rootSessionId, abortSignal);
+                await this.#settlePermissionResponse(rootSessionId, abortSignal, setAttention);
             }
             catch (error) {
                 if (!this.#closed && !isAbortError(error)) {
+                    setAttention('blocked');
                     await notifyError(this.#input.onError, rootSessionId, error);
                 }
             }
@@ -174,6 +208,11 @@ export class AgentGraphSupervisorWakeCoordinator {
         return this.#input.activityRegistry.whenIdle(rootSessionId) !== undefined;
     }
     async retireSessions(rootSessionIds) {
+        for (const rootSessionId of rootSessionIds) {
+            this.#sessionAttention.delete(rootSessionId);
+            this.#parkedWakeIds.delete(rootSessionId);
+            this.#publishSessionActivity(rootSessionId);
+        }
         return this.#input.wakeStore.supersedeAgentGraphSupervisorWakes({
             rootSessionIds,
             reason: 'session_retired',
@@ -184,19 +223,30 @@ export class AgentGraphSupervisorWakeCoordinator {
             return;
         this.#closed = true;
         this.#abortController.abort();
+        for (const sessionId of [...this.#publishedActivity.keys()])
+            this.#publishSessionActivity(sessionId);
     }
     async close() {
         this.beginDrain();
         await this.waitForIdle();
         this.#sessionAbortControllers.clear();
         this.#tasksBySession.clear();
+        this.#sessionAttention.clear();
+        this.#parkedWakeIds.clear();
+        this.#activityVersions.clear();
     }
-    async #wake(rootSessionId, abortSignal, result) {
+    async #wake(rootSessionId, abortSignal, setAttention, result) {
         abortSignal.throwIfAborted();
         if (!(await this.#isSessionDeliverable(rootSessionId)))
             return;
         const snapshot = await this.#input.readSnapshot(rootSessionId);
         abortSignal.throwIfAborted();
+        const parkedWakeId = this.#parkedWakeIds.get(rootSessionId);
+        if (parkedWakeId &&
+            (snapshot.closed || parkedWakeId !== `${snapshot.graphId}:${snapshot.snapshotVersion}`)) {
+            this.#parkedWakeIds.delete(rootSessionId);
+            setAttention('idle');
+        }
         const wakeDecision = await this.#input.shouldWake?.(rootSessionId, result, snapshot);
         abortSignal.throwIfAborted();
         if (wakeDecision === false ||
@@ -217,12 +267,19 @@ export class AgentGraphSupervisorWakeCoordinator {
                 snapshotVersion: snapshot.snapshotVersion,
                 rootSessionId,
             });
-            if (this.#closed ||
-                claimed.wake.status === 'delivered' ||
-                claimed.wake.status === 'exhausted')
+            if (this.#closed || claimed.wake.status === 'exhausted')
+                return;
+            if (claimed.wake.status === 'delivered') {
+                this.#parkedWakeIds.delete(rootSessionId);
+                setAttention('idle');
                 return;
+            }
+            if (claimed.wake.status === 'waiting_permission') {
+                this.#parkedWakeIds.set(rootSessionId, wakeId);
+                setAttention('waiting_for_user');
+            }
             abortSignal.throwIfAborted();
-            await this.#deliverWake(claimed.wake, snapshot, abortSignal, result);
+            await this.#deliverWake(claimed.wake, snapshot, abortSignal, setAttention, result);
         }
         finally {
             this.#pendingWakeIds.delete(wakeId);
@@ -232,12 +289,13 @@ export class AgentGraphSupervisorWakeCoordinator {
         if (this.#closed || this.#pendingWakeIds.has(wake.wakeId))
             return;
         this.#pendingWakeIds.add(wake.wakeId);
-        void this.#runTracked(wake.rootSessionId, async (abortSignal) => {
+        void this.#runTracked(wake.rootSessionId, async (abortSignal, setAttention) => {
             try {
-                await this.#resumeWake(wake, abortSignal);
+                await this.#resumeWake(wake, abortSignal, setAttention);
             }
             catch (error) {
                 if (!this.#closed && !isAbortError(error)) {
+                    setAttention('blocked');
                     await notifyError(this.#input.onError, wake.rootSessionId, error);
                 }
             }
@@ -247,19 +305,39 @@ export class AgentGraphSupervisorWakeCoordinator {
         });
     }
     #runTracked(rootSessionId, operation) {
+        // Duplicate checkpoint notifications share the in-flight generation. They
+        // cannot invalidate the outcome of the attempt already holding the wake.
+        const version = (this.#activityVersions.get(rootSessionId) ?? 0) +
+            (this.#tasksBySession.has(rootSessionId) ? 0 : 1);
+        this.#activityVersions.set(rootSessionId, version);
+        if (this.#sessionAttention.get(rootSessionId) !== 'waiting_for_user') {
+            this.#sessionAttention.delete(rootSessionId);
+        }
+        const setAttention = (activity) => {
+            if (this.#closed ||
+                this.#sessionWakesSuppressed(rootSessionId) ||
+                this.#activityVersions.get(rootSessionId) !== version)
+                return;
+            if (activity === 'idle')
+                this.#sessionAttention.delete(rootSessionId);
+            else
+                this.#sessionAttention.set(rootSessionId, activity);
+            this.#publishSessionActivity(rootSessionId);
+        };
         const residency = this.#input.acquireResidency?.(rootSessionId);
         const abortSignal = this.#sessionAbortSignal(rootSessionId);
         const task = Promise.resolve()
-            .then(() => operation(abortSignal))
+            .then(() => operation(abortSignal, setAttention))
             .finally(() => residency?.release());
         this.#tasks.add(task);
         const sessionTasks = this.#tasksBySession.get(rootSessionId) ?? new Set();
         sessionTasks.add(task);
         this.#tasksBySession.set(rootSessionId, sessionTasks);
+        this.#publishSessionActivity(rootSessionId);
         void task.then(() => this.#forgetTask(rootSessionId, task), () => this.#forgetTask(rootSessionId, task));
         return task;
     }
-    async #resumeWake(wake, abortSignal) {
+    async #resumeWake(wake, abortSignal, setAttention) {
         abortSignal.throwIfAborted();
         if (!(await this.#isSessionDeliverable(wake.rootSessionId))) {
             await this.#supersedeSession(wake.rootSessionId, 'session_unavailable');
@@ -278,9 +356,9 @@ export class AgentGraphSupervisorWakeCoordinator {
             return;
         }
         abortSignal.throwIfAborted();
-        await this.#deliverWake(wake, snapshot, abortSignal);
+        await this.#deliverWake(wake, snapshot, abortSignal, setAttention);
     }
-    async #deliverWake(wake, snapshot, abortSignal, result) {
+    async #deliverWake(wake, snapshot, abortSignal, setAttention, result) {
         if (wake.status === 'exhausted')
             return;
         if (wake.attemptCount >= this.#maxDeliveryAttempts) {
@@ -323,6 +401,8 @@ export class AgentGraphSupervisorWakeCoordinator {
                     }
                     return;
                 }
+                this.#parkedWakeIds.delete(wake.rootSessionId);
+                setAttention('idle');
                 if (this.#sessionWakesSuppressed(wake.rootSessionId))
                     return;
                 if (this.#closed) {
@@ -351,6 +431,8 @@ export class AgentGraphSupervisorWakeCoordinator {
                             attemptId,
                             status: 'delivered',
                         });
+                        this.#parkedWakeIds.delete(wake.rootSessionId);
+                        setAttention('idle');
                         return;
                     }
                     if (outcome.kind === 'superseded') {
@@ -370,6 +452,8 @@ export class AgentGraphSupervisorWakeCoordinator {
                             attemptId,
                             status: 'waiting_permission',
                         });
+                        this.#parkedWakeIds.set(wake.rootSessionId, wake.wakeId);
+                        setAttention('waiting_for_user');
                         return;
                     }
                     lastFailure = wakeOutcomeFailure(outcome);
@@ -501,6 +585,9 @@ export class AgentGraphSupervisorWakeCoordinator {
             `${snapshot.graphId}:${snapshot.snapshotVersion}` === wake.wakeId);
     }
     #supersedeSession(rootSessionId, reason) {
+        this.#sessionAttention.delete(rootSessionId);
+        this.#parkedWakeIds.delete(rootSessionId);
+        this.#publishSessionActivity(rootSessionId);
         return this.#input.wakeStore.supersedeAgentGraphSupervisorWakes({
             rootSessionIds: [rootSessionId],
             reason,
@@ -527,7 +614,7 @@ export class AgentGraphSupervisorWakeCoordinator {
             : `host_restart:${runStatus}`);
         return 1;
     }
-    async #settlePermissionResponse(rootSessionId, abortSignal) {
+    async #settlePermissionResponse(rootSessionId, abortSignal, setAttention) {
         const activity = await this.#input.activityRegistry.acquire(rootSessionId, abortSignal);
         const retryable = [];
         try {
@@ -548,6 +635,8 @@ export class AgentGraphSupervisorWakeCoordinator {
                         attemptId,
                         status: 'delivered',
                     });
+                    this.#parkedWakeIds.delete(rootSessionId);
+                    setAttention('idle');
                     continue;
                 }
                 retryable.push(await this.#markRetryable(wake.graphId, wake.wakeId, attemptId, `permission_waiter_lost:${runStatus}`));
@@ -562,6 +651,10 @@ export class AgentGraphSupervisorWakeCoordinator {
     #beginSessionWakeSuppression(rootSessionId) {
         const count = this.#sessionWakeSuppressions.get(rootSessionId) ?? 0;
         this.#sessionWakeSuppressions.set(rootSessionId, count + 1);
+        this.#activityVersions.set(rootSessionId, (this.#activityVersions.get(rootSessionId) ?? 0) + 1);
+        this.#sessionAttention.delete(rootSessionId);
+        this.#parkedWakeIds.delete(rootSessionId);
+        this.#publishSessionActivity(rootSessionId);
         if (count === 0) {
             const controller = this.#sessionAbortControllers.get(rootSessionId) ?? new AbortController();
             this.#sessionAbortControllers.set(rootSessionId, controller);
@@ -577,6 +670,7 @@ export class AgentGraphSupervisorWakeCoordinator {
             return;
         }
         this.#sessionWakeSuppressions.delete(rootSessionId);
+        this.#publishSessionActivity(rootSessionId);
         if (!this.#tasksBySession.has(rootSessionId)) {
             this.#sessionAbortControllers.delete(rootSessionId);
         }
@@ -601,11 +695,15 @@ export class AgentGraphSupervisorWakeCoordinator {
         this.#tasks.delete(task);
         const sessionTasks = this.#tasksBySession.get(rootSessionId);
         sessionTasks?.delete(task);
-        if (sessionTasks?.size === 0)
+        if (sessionTasks?.size === 0) {
             this.#tasksBySession.delete(rootSessionId);
+            if (!this.#sessionAttention.has(rootSessionId))
+                this.#activityVersions.delete(rootSessionId);
+        }
         if (!this.#sessionWakesSuppressed(rootSessionId) && !this.#tasksBySession.has(rootSessionId)) {
             this.#sessionAbortControllers.delete(rootSessionId);
         }
+        this.#publishSessionActivity(rootSessionId);
     }
 }
 export function isAgentGraphSupervisorMilestone(result) {

package/node_modules/@maka/runtime/dist/agent-run.js

@@ -328,6 +328,17 @@ export class AgentRun {
         const runStore = this.input.runStore;
         if (!this.input.runtimeEventStore || !runStore)
             return;
+        // A stream may have attempted finalization after an earlier stop failed.
+        // Join that write, but let this explicit retry reuse its reserved fact if
+        // the write failed; a rejected promise is not durable terminal evidence.
+        const previousWrite = this.terminalClaim.write;
+        try {
+            await previousWrite;
+        }
+        catch {
+            if (this.terminalClaim.write === previousWrite)
+                this.terminalClaim.write = undefined;
+        }
         await this.flushRuntimePartialBuffer(true);
         // The claim only fences writers inside this Run. Another owner — a Host
         // recovery, a resumed continuation — may have sealed the ledger already,

package/node_modules/@maka/runtime/dist/computer-use-observation-text.js

@@ -366,8 +366,30 @@ function header(observation, elementCount, query, shownCount) {
     if (observation.truncated === true) {
         parts.push('truncated=true(the tree was cut short; an element you expect may exist but not be listed)');
     }
+    const selectedText = selectedTextCaption(observation);
+    if (selectedText)
+        parts.push(selectedText);
     return parts.join(' ');
 }
+/**
+ * Window selection is application text. A password field that currently holds
+ * keys must not leak that text through this caption; otherwise truncate like
+ * `value` and keep the executor's own truncated flag.
+ */
+function selectedTextCaption(observation) {
+    const selected = observation.selectedText;
+    if (!selected)
+        return undefined;
+    const focused = observation.elements.find((element) => element.focused === true);
+    const role = `${focused?.role ?? ''} ${focused?.subrole ?? ''}`;
+    if (/secure/i.test(role)) {
+        return 'selected_text=withheld(secure_field)';
+    }
+    const shown = truncate(selected.text);
+    return selected.truncated === true
+        ? `selected_text=${quote(shown)}(truncated=true)`
+        : `selected_text=${quote(shown)}`;
+}
 /**
  * A subrole earns its place when it is telling the model something the rest of
  * the line does not.

package/node_modules/@maka/runtime/dist/conversation-copy-agent-output.js

@@ -0,0 +1,227 @@
+/*
+ * 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 { isRecord, isStringArray } from '@maka/core/record-schema';
+import { decodeAgentRunEvent } from '@maka/core/agent-run';
+import { decodeRuntimeEvent, decodeRuntimeInvocationOpened, } from '@maka/core/runtime-event';
+import { runtimeInvocationOutcome } from '@maka/core/runtime-invocation';
+import { stableJsonStringify } from '@maka/core/tool-args-identity';
+import { runtimeInvocationFailureClass } from './runtime-event-read-model.js';
+export function isConversationCopyAgentOutputSnapshot(value) {
+    return (isRecord(value) &&
+        value.kind === 'maka.agent_output_snapshot' &&
+        isResultPayload(value) &&
+        Object.keys(value).every((key) => [
+            'kind',
+            'schemaVersion',
+            'status',
+            'text',
+            'textTruncated',
+            'artifactIds',
+            'omittedArtifactIds',
+            'failureClass',
+        ].includes(key)));
+}
+function isResultPayload(value) {
+    return (value.schemaVersion === 1 &&
+        resultStatus(value.status) &&
+        isStringArray(value.artifactIds) &&
+        value.artifactIds.every(nonempty) &&
+        typeof value.textTruncated === 'boolean' &&
+        typeof value.omittedArtifactIds === 'number' &&
+        Number.isSafeInteger(value.omittedArtifactIds) &&
+        value.omittedArtifactIds >= 0 &&
+        (value.text === undefined || typeof value.text === 'string') &&
+        (value.failureClass === undefined || typeof value.failureClass === 'string'));
+}
+/**
+ * Recognize the defined result envelope, never arbitrary nested JSON ids.
+ * These are reference claims, not authority: the Host still checks them against
+ * the retained child's metadata, invocation ledger, and Artifact ownership.
+ */
+export function conversationCopyAgentOutput(value) {
+    if (!isRecord(value))
+        return undefined;
+    const { execution, invocation, budget } = value;
+    if (!isRecord(execution) ||
+        execution.kind !== 'child_session' ||
+        !nonempty(execution.sessionId) ||
+        !isRecord(invocation) ||
+        invocation.sessionId !== execution.sessionId ||
+        !nonempty(invocation.runId) ||
+        !nonempty(invocation.turnId) ||
+        !nonempty(invocation.invocationId) ||
+        (execution.currentRunId !== undefined && execution.currentRunId !== invocation.runId) ||
+        !isRecord(budget) ||
+        typeof budget.view !== 'string' ||
+        !['result', 'events', 'runtime_events', 'all'].includes(budget.view) ||
+        !Array.isArray(value.events) ||
+        !Array.isArray(value.runtimeEvents) ||
+        !Array.isArray(value.diagnostics) ||
+        !Array.isArray(value.artifacts))
+        return undefined;
+    try {
+        const opening = decodeRuntimeInvocationOpened(invocation.opening);
+        const terminal = invocation.terminalEvent === undefined
+            ? undefined
+            : decodeRuntimeEvent(invocation.terminalEvent);
+        if (terminal &&
+            (terminal.sessionId !== execution.sessionId ||
+                terminal.runId !== invocation.runId ||
+                terminal.turnId !== invocation.turnId ||
+                terminal.invocationId !== invocation.invocationId ||
+                terminal.partial))
+            return undefined;
+        let result = value.result;
+        if (budget.view === 'result') {
+            if (value.events.length ||
+                value.runtimeEvents.length ||
+                value.diagnostics.length ||
+                value.artifacts.length)
+                return undefined;
+        }
+        else {
+            // Diagnostic views have no committed-result field. Their invocation
+            // still identifies the observation, and their Artifact list can contain
+            // outputs omitted by a separately bounded view=result read.
+            if (result !== undefined ||
+                (budget.view === 'events' && value.runtimeEvents.length > 0) ||
+                (budget.view === 'runtime_events' && value.events.length > 0))
+                return undefined;
+            const sameRun = (event) => event.sessionId === execution.sessionId &&
+                event.runId === invocation.runId &&
+                event.turnId === invocation.turnId;
+            const events = value.events.map(decodeAgentRunEvent);
+            const runtimeEvents = value.runtimeEvents.map(decodeRuntimeEvent);
+            if (!events.every(sameRun) ||
+                !runtimeEvents.every((event) => sameRun(event) && event.invocationId === invocation.invocationId) ||
+                !value.diagnostics.every((item) => isRecord(item) &&
+                    item.runId === invocation.runId &&
+                    item.turnId === invocation.turnId &&
+                    nonempty(item.code) &&
+                    typeof item.message === 'string') ||
+                !value.artifacts.every((item) => isRecord(item) &&
+                    nonempty(item.id) &&
+                    item.sessionId === execution.sessionId &&
+                    item.turnId === invocation.turnId))
+                return undefined;
+            const text = [
+                ...runtimeEvents.flatMap(diagnosticRuntimeEventText),
+                ...events.flatMap((event) => (event.message ? [event.message] : [])),
+                ...value.diagnostics.map((item) => item.message),
+            ].join('\n');
+            const failureClass = runtimeInvocationFailureClass({ terminalEvent: terminal });
+            result = {
+                schemaVersion: 1,
+                status: runtimeInvocationOutcome({ terminalEvent: terminal }) ?? 'running',
+                ...(text ? { text } : {}),
+                // The bounded diagnostic view cannot establish a complete final text
+                // or count omitted Artifacts. Retain its readable excerpt and known ids.
+                textTruncated: true,
+                artifactIds: value.artifacts.map((item) => item.id),
+                omittedArtifactIds: 0,
+                ...(failureClass ? { failureClass } : {}),
+            };
+        }
+        if (!isRecord(result) || !isResultPayload(result))
+            return undefined;
+        if (terminal &&
+            (runtimeInvocationOutcome({ terminalEvent: terminal }) !== result.status ||
+                (result.terminalRuntimeEventId !== undefined &&
+                    result.terminalRuntimeEventId !== terminal.id)))
+            return undefined;
+        if (!terminal && result.status !== 'running' && result.status !== 'waiting_for_user')
+            return undefined;
+        let graph;
+        if (result.graph !== undefined) {
+            if (!isRecord(result.graph) ||
+                !nonempty(result.graph.graphId) ||
+                !nonempty(result.graph.workId) ||
+                !nonempty(result.graph.operatorId))
+                return undefined;
+            graph = {
+                graphId: result.graph.graphId,
+                workId: result.graph.workId,
+                operatorId: result.graph.operatorId,
+            };
+        }
+        return {
+            reference: {
+                childSessionId: execution.sessionId,
+                runId: invocation.runId,
+                turnId: invocation.turnId,
+                status: result.status,
+                artifactIds: result.artifactIds,
+                ...(result.failureClass ? { failureClass: result.failureClass } : {}),
+                ...(opening.lineage?.resumedFromRunId
+                    ? { resumedFromRunId: opening.lineage.resumedFromRunId }
+                    : {}),
+                ...(terminal ? { terminalEventId: terminal.id } : {}),
+                ...(graph ? { graph } : {}),
+            },
+            // An independent Side Conversation keeps a result snapshot, without the
+            // original execution, invocation, Graph, or event identities.
+            snapshot: {
+                kind: 'maka.agent_output_snapshot',
+                schemaVersion: 1,
+                status: result.status,
+                ...(typeof result.text === 'string' ? { text: result.text } : {}),
+                textTruncated: result.textTruncated,
+                artifactIds: result.artifactIds,
+                omittedArtifactIds: result.omittedArtifactIds,
+                ...(result.failureClass ? { failureClass: result.failureClass } : {}),
+            },
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Keep tool evidence as static text without copying event or tool-call identities. */
+function diagnosticRuntimeEventText(event) {
+    if (event.partial)
+        return [];
+    const content = event.content;
+    switch (content?.kind) {
+        case 'text':
+            return [content.text];
+        case 'function_call':
+            return [stableJsonStringify({ kind: content.kind, name: content.name, args: content.args })];
+        case 'function_response':
+            return [
+                stableJsonStringify({
+                    kind: content.kind,
+                    name: content.name,
+                    result: content.result,
+                    ...(content.isError !== undefined ? { isError: content.isError } : {}),
+                }),
+            ];
+        default:
+            return [];
+    }
+}
+function nonempty(value) {
+    return typeof value === 'string' && value.length > 0;
+}
+function resultStatus(value) {
+    return (value === 'completed' ||
+        value === 'failed' ||
+        value === 'cancelled' ||
+        value === 'running' ||
+        value === 'waiting_for_user');
+}