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

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');
+}

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

@@ -40,6 +40,8 @@ import { baseToolResultProjection, decodeLedgerTransition, reduceEffectiveModelP
 import { archivedToolResultProjection } from './tool-result-archive-transition.js';
 import { serializeToolResultProjectionV1 } from './tool-result-archive-encoding.js';
 import { createHash } from 'node:crypto';
+import { encodeCanonicalRuntimeEvent } from '@maka/core/canonical-runtime-event';
+import { conversationCopyAgentOutput, isConversationCopyAgentOutputSnapshot, } from './conversation-copy-agent-output.js';
 import { readToolResultPage, readableToolResult, resolveReadInput, READ_PAGE_MAX_BYTES, } from './read-page.js';
 /** Walks every typed StorageRef site reached by conversation-copy rewriting. */
 function collectConversationCopyStorageRefs(input) {
@@ -52,7 +54,7 @@ function collectConversationCopyStorageRefs(input) {
         if (isArchivedToolResultPlaceholder(value))
             return;
         try {
-            addContent(decodePersistedToolResultContent(markPersisted(value)));
+            addContent(decodeConversationCopyToolResult(value));
         }
         catch {
             // Opaque tool results carry no typed StorageRef.
@@ -141,7 +143,7 @@ export function rewriteConversationCopyMessage(message, references) {
     if (message.type === 'tool_result') {
         return {
             ...message,
-            content: rewriteToolResultContent(message.content, references),
+            content: rewriteToolResultContent(message.content, references, references.toolNamesByCall?.get(conversationCopyToolCallKey(message.turnId, message.toolUseId))),
         };
     }
     if (message.type === 'token_usage' && message.providerRequestTraceId) {
@@ -153,7 +155,8 @@ export function rewriteConversationCopyMessage(message, references) {
     return message;
 }
 function rewriteAttachmentResourceRefs(text, artifactIds) {
-    return text.replace(/maka:\/\/runtime\/attachments\/[^\s)\]}>`'",;:!]+/g, (candidate) => {
+    // Snapshot tool evidence can contain JSON-escaped quotes and newlines.
+    return text.replace(/maka:\/\/runtime\/attachments\/[^\\\s)\]}>`'",;:!]+/g, (candidate) => {
         const parsed = parseAttachmentResourceRef(candidate);
         const artifactId = parsed ? artifactIds.get(parsed.artifactId) : undefined;
         return artifactId ? `maka://runtime/attachments/${artifactId}` : candidate;
@@ -320,6 +323,10 @@ export async function cloneConversationRuntimeLedger(input) {
     const operationIds = toolOperationIdMap(flattenedPlans, targetInvocationIds);
     const references = {
         ...input.referenceMap,
+        toolNamesByCall: conversationCopyToolNames({
+            messages: input.copiedMessages,
+            runtimeEvents: flattenedPlans.flatMap((plan) => plan.events),
+        }),
         runIds,
         invocationIds,
         operationIds,
@@ -589,6 +596,14 @@ function rewriteReadInput(input, references, clonedEvents) {
         : rewriteLedgerArchiveText(rewriteAttachmentResourceRefs(original, references.artifactIds), references);
     if (!input.path.startsWith('maka://read/'))
         return { ...input, path };
+    if (path !== original &&
+        !eventId &&
+        references.ledgerArchives?.has(original) &&
+        parseToolResultArchiveResourceRef(original)?.storage !== 'ledger') {
+        // A retired v1 body has become a rewritten ledger snapshot. Its previous
+        // byte offset and digest cannot address the new resource.
+        return { path };
+    }
     const url = new URL(input.path);
     if (eventId && path !== original) {
         const copied = clonedEvents.get(eventId);
@@ -674,7 +689,21 @@ async function loadConversationCopyRunEvents(sourceRuns, sourceEvents, copyTurnI
         ];
     }));
 }
-export function conversationCopyLinkedChildReferences(content) {
+// Legacy archive bodies and provider projections can store the raw result;
+// RuntimeEvents and transcript messages normally carry the JSON wrapper.
+function decodeConversationCopyToolResult(value, toolName) {
+    if (toolName === 'agent_output' &&
+        (conversationCopyAgentOutput(value) || isConversationCopyAgentOutputSnapshot(value)))
+        return { kind: 'json', value };
+    return decodePersistedToolResultContent(markPersisted(value));
+}
+export function conversationCopyLinkedChildReferences(content, toolName) {
+    if (content.kind === 'json') {
+        if (toolName !== 'agent_output')
+            return [];
+        const output = conversationCopyAgentOutput(content.value);
+        return output ? [output.reference] : [];
+    }
     if (content.kind === 'subagent') {
         if (!content.childSessionId)
             return [];
@@ -706,27 +735,56 @@ export function conversationCopyLinkedChildReferences(content) {
         : []);
 }
 export function collectConversationCopyLinkedChildReferences(input) {
-    const references = [];
-    const add = (value) => {
+    return conversationCopyToolResults(input).flatMap(({ content, toolName }) => conversationCopyLinkedChildReferences(content, toolName));
+}
+/** Pair transcript results with call metadata, including historical ledger-only calls. */
+function conversationCopyToolNames(input) {
+    const names = new Map();
+    const add = (turnId, callId, name) => {
+        const key = conversationCopyToolCallKey(turnId, callId);
+        names.set(key, names.has(key) && names.get(key) !== name ? undefined : name);
+    };
+    for (const message of input.messages) {
+        if (message.type === 'tool_call')
+            add(message.turnId, message.id, message.toolName);
+    }
+    for (const event of input.runtimeEvents) {
+        if (event.content?.kind === 'function_call' || event.content?.kind === 'function_response') {
+            add(event.turnId, event.content.id, event.content.name);
+        }
+    }
+    return names;
+}
+function conversationCopyToolCallKey(turnId, callId) {
+    return JSON.stringify([turnId, callId]);
+}
+function conversationCopyToolResults(input) {
+    const results = [];
+    const toolNames = conversationCopyToolNames(input);
+    const add = (value, toolName) => {
         if (isArchivedToolResultPlaceholder(value))
             return;
         try {
-            references.push(...conversationCopyLinkedChildReferences(decodePersistedToolResultContent(markPersisted(value))));
+            results.push({ content: decodeConversationCopyToolResult(value, toolName), toolName });
         }
         catch {
-            // Opaque tool results have no typed linked-child references.
+            // Opaque tool results have no typed conversation-copy references.
         }
     };
     for (const message of input.messages) {
         if (message.type === 'tool_result') {
-            references.push(...conversationCopyLinkedChildReferences(message.content));
+            results.push({
+                content: message.content,
+                toolName: toolNames.get(conversationCopyToolCallKey(message.turnId, message.toolUseId)),
+            });
         }
     }
     for (const event of input.runtimeEvents) {
-        if (event.content?.kind === 'function_response')
-            add(event.content.result);
+        if (event.content?.kind === 'function_response') {
+            add(event.content.result, toolNames.get(conversationCopyToolCallKey(event.turnId, event.content.id)));
+        }
     }
-    return references;
+    return results;
 }
 /**
  * Collects the `relativePath` of every `session_file` StorageRef that the copied
@@ -737,6 +795,8 @@ export function collectConversationCopyLinkedChildReferences(input) {
  * their refs resolve in `rewriteStorageRef`. Walks exactly the ref sites reached
  * by `rewriteStorageRef`: user-message attachments, tool_result image refs, text
  * runtime-event attachments, and function_response / archived tool-result images.
+ * Static agent_output snapshots also own their Artifacts; those can retain a
+ * child Turn id outside the copied parent's turn closure and need explicit inclusion.
  */
 export function collectConversationCopySessionFileRefs(input) {
     const refs = new Set();
@@ -745,6 +805,14 @@ export function collectConversationCopySessionFileRefs(input) {
             refs.add(ref.relativePath);
         }
     }
+    for (const { content, toolName } of conversationCopyToolResults(input)) {
+        if (toolName === 'agent_output' &&
+            content.kind === 'json' &&
+            isConversationCopyAgentOutputSnapshot(content.value)) {
+            for (const artifactId of content.value.artifactIds)
+                refs.add(artifactId);
+        }
+    }
     return refs;
 }
 function cloneAgentRunEvent(event, ids, references, sourceCompactableEvents, clonedRuntimeEvents, checkpointIds, providerTraceIds, logicalCallIds, clonedTransitions) {
@@ -830,10 +898,9 @@ function cloneAgentRunEvent(event, ids, references, sourceCompactableEvents, clo
     }
     else if (event.type === MODEL_PROJECTION_TRANSITION_EVENT_TYPE) {
         const cloned = clonedTransitions.get(event);
-        // Every transition whose target is in the copied slice was gathered into
-        // this run's ledger, wherever it was recorded. So a transition that finds no
-        // cloned target has genuinely lost its target as well, and dropping it
-        // cannot bring replaced content back.
+        // A transition is omitted only when its target was excluded or its archive
+        // wrapper was collapsed into an already copied archive. Neither case can
+        // bring replaced content back into the model-visible history.
         if (!cloned)
             return null;
         data = { ...event.data, transition: cloned, runtimeEventId: cloned.target.runtimeEventId };
@@ -873,37 +940,57 @@ function cloneModelProjectionTransition(event, references, clonedRuntimeEvents,
     }
     const placeholder = rawPlaceholder;
     const existing = transitionState.get(clonedTarget.id);
-    const sourceProjection = existing?.projection ?? baseToolResultProjection(clonedTarget);
+    // RuntimeEvent storage canonicalizes JSON key order. Hash the bytes a later
+    // archive read will reconstruct, including newly built snapshot projections.
+    const sourceProjection = existing?.projection ??
+        baseToolResultProjection(encodeCanonicalRuntimeEvent(clonedTarget).event);
     if (!sourceProjection) {
         throw new Error(`Cannot copy model projection transition ${event.id} onto its target`);
     }
-    // The copied event already holds the target's rewritten result, so every
-    // archive, including a legacy Artifact-backed one, is rebuilt as a ledger
-    // archive of that event instead of pointing at the source's archived body.
+    const previousTransitionId = source.previousTransitionId
+        ? requiredMappedId(transitionIds, source.previousTransitionId, 'model projection transition')
+        : undefined;
+    // Persisted placeholders can use a public event address or an exact legacy
+    // ledger identity. Both must resolve to the same rebuilt archive on recopy.
+    const sourceRefs = new Set([
+        buildToolResultArchiveResourceRef(placeholder),
+        ...(placeholder.resourceRef ? [placeholder.resourceRef] : []),
+    ]);
+    const previousPlaceholder = existing?.projection.kind === 'json' ? existing.projection.value : undefined;
+    if (existing &&
+        isArchivedToolResultPlaceholder(previousPlaceholder) &&
+        previousPlaceholder.rewriteVersion === 2) {
+        if (previousTransitionId !== existing.transitionId)
+            throw new Error(`Cannot collapse disconnected archive transition ${event.id}`);
+        // Public Read addresses identify an event, not a transition. Archiving
+        // this placeholder again would make that address return itself. Keep the
+        // first archive of the copied body and alias every later wrapper to it.
+        for (const sourceRef of sourceRefs)
+            references.ledgerArchives?.set(sourceRef, previousPlaceholder);
+        transitionIds.set(source.transitionId, existing.transitionId);
+        return null;
+    }
+    if (clonedTarget.content?.kind === 'function_response' && !clonedTarget.content.modelProjection)
+        clonedTarget.content.modelProjection = sourceProjection;
+    // Rebuild every archive over the copied ledger, including legacy v1 bodies.
     const serialized = serializeToolResultProjectionV1(sourceProjection);
     const rewritten = buildLedgerArchivedToolResultPlaceholder({
         storage: 'ledger',
         runtimeEventId: clonedTarget.id,
         toolCallId: placeholder.toolCallId,
         toolName: placeholder.toolName,
+        originalEstimatedTokens: placeholder.originalEstimatedTokens,
+        reason: placeholder.reason,
         sourceProjectionDigest: durableToolResultProjectionDigest(sourceProjection),
         bodySha256: createHash('sha256').update(serialized).digest('hex'),
         originalBytes: Buffer.byteLength(serialized),
-        originalEstimatedTokens: placeholder.originalEstimatedTokens,
-        reason: placeholder.reason,
-        ...(source.previousTransitionId
-            ? {
-                previousTransitionId: requiredMappedId(transitionIds, source.previousTransitionId, 'model projection transition'),
-            }
-            : {}),
+        ...(previousTransitionId ? { previousTransitionId } : {}),
     });
     if (placeholder.page) {
         rewritten.page = readToolResultPage(serialized, { path: rewritten.resourceRef }, READ_PAGE_MAX_BYTES - Buffer.byteLength(JSON.stringify(rewritten)) - 32);
     }
-    // Earlier Reads of a legacy archive keep naming its copied Artifact.
-    if (placeholder.rewriteVersion === 2) {
-        references.ledgerArchives?.set(placeholder.resourceRef ?? buildToolResultArchiveResourceRef(placeholder), rewritten);
-    }
+    for (const sourceRef of sourceRefs)
+        references.ledgerArchives?.set(sourceRef, rewritten);
     const transition = buildModelProjectionTransition({
         sessionId: references.targetSessionId,
         target: {
@@ -917,11 +1004,7 @@ function cloneModelProjectionTransition(event, references, clonedRuntimeEvents,
         // The applied chain is copied in fold order, so a predecessor is always
         // rebuilt before its successor. An unmapped one means the chain broke, and
         // rooting the successor instead would change what the fold decides.
-        ...(source.previousTransitionId
-            ? {
-                previousTransitionId: requiredMappedId(transitionIds, source.previousTransitionId, 'model projection transition'),
-            }
-            : {}),
+        ...(previousTransitionId ? { previousTransitionId } : {}),
         now: source.createdAt,
     });
     transitionIds.set(source.transitionId, transition.transitionId);
@@ -1135,6 +1218,9 @@ function rewriteInvocationOpening(opening, references) {
     };
 }
 function rewriteRuntimeEventReferences(event, references) {
+    const toolName = event.content?.kind === 'function_response'
+        ? references.toolNamesByCall?.get(conversationCopyToolCallKey(event.turnId, event.content.id))
+        : undefined;
     const content = event.content?.kind === 'text'
         ? {
             ...event.content,
@@ -1151,10 +1237,10 @@ function rewriteRuntimeEventReferences(event, references) {
         : event.content?.kind === 'function_response'
             ? {
                 ...event.content,
-                result: rewriteRuntimeToolResult(event.content.result, references),
+                result: rewriteRuntimeToolResult(event.content.result, references, toolName),
                 ...(event.content.modelProjection
                     ? {
-                        modelProjection: rewriteDurableToolResultProjectionArtifactRefs(event.content.modelProjection, (ref) => rewriteProjectionArtifactRef(ref, references)),
+                        modelProjection: rewriteConversationCopyModelProjection(event.content.modelProjection, references, toolName),
                     }
                     : {}),
             }
@@ -1249,7 +1335,24 @@ function rewriteToolRecoveryFact(recovery, operationId, references) {
         },
     };
 }
-function rewriteToolResultContent(content, references) {
+function rewriteToolResultContent(content, references, toolName) {
+    if (toolName === 'agent_output' && content.kind === 'json') {
+        if (isConversationCopyAgentOutputSnapshot(content.value)) {
+            return rewriteAgentOutputSnapshot(content.value, references);
+        }
+        const output = conversationCopyAgentOutput(content.value);
+        if (output) {
+            const shared = sharedChild(output.reference.childSessionId, references);
+            if (!shared) {
+                return rewriteAgentOutputSnapshot(output.snapshot, references);
+            }
+            // Revision children remain owned by their original physical Session.
+            // Validate those external references without rewriting their identities.
+            rewriteLinkedRunId(output.reference.runId, shared, references, 'AgentRun');
+            rewriteLinkedArtifactIds(output.reference.artifactIds, shared, references);
+            return content;
+        }
+    }
     if (content.kind === 'image') {
         return { ...content, ref: rewriteStorageRef(content.ref, references) };
     }
@@ -1320,17 +1423,44 @@ function rewriteToolResultContent(content, references) {
     }
     return content;
 }
-function rewriteRuntimeToolResult(value, references) {
+function rewriteAgentOutputSnapshot(snapshot, references) {
+    return {
+        kind: 'json',
+        value: {
+            ...snapshot,
+            ...(snapshot.text !== undefined
+                ? { text: rewriteAttachmentResourceRefs(snapshot.text, references.artifactIds) }
+                : {}),
+            artifactIds: rewriteArtifactIds(snapshot.artifactIds, references),
+        },
+    };
+}
+function rewriteConversationCopyModelProjection(projection, references, toolName) {
+    if (toolName === 'agent_output' &&
+        projection.kind === 'json' &&
+        (conversationCopyAgentOutput(projection.value) ||
+            isConversationCopyAgentOutputSnapshot(projection.value))) {
+        const content = rewriteToolResultContent({ kind: 'json', value: projection.value }, references, toolName);
+        if (content.kind === 'json')
+            return { ...projection, value: content.value };
+    }
+    return rewriteDurableToolResultProjectionArtifactRefs(projection, (ref) => rewriteProjectionArtifactRef(ref, references));
+}
+function rewriteRuntimeToolResult(value, references, toolName) {
     if (isArchivedToolResultPlaceholder(value))
         return rewriteArchivedToolResult(value, references);
     let content;
     try {
-        content = decodePersistedToolResultContent(markPersisted(value));
+        content = decodeConversationCopyToolResult(value, toolName);
     }
     catch {
         return value;
     }
-    return rewriteToolResultContent(content, references);
+    const rewritten = rewriteToolResultContent(content, references, toolName);
+    return (conversationCopyAgentOutput(value) || isConversationCopyAgentOutputSnapshot(value)) &&
+        rewritten.kind === 'json'
+        ? rewritten.value
+        : rewritten;
 }
 function rewriteArtifactIds(artifactIds, references) {
     return artifactIds.flatMap((artifactId) => {
@@ -1401,11 +1531,11 @@ function rewriteProjectionArtifactRef(ref, references) {
     return rewritten;
 }
 function rewriteArchivedToolResult(value, references) {
+    const migrated = references.ledgerArchives?.get(buildToolResultArchiveResourceRef(value));
+    if (migrated)
+        return migrated;
     if (value.rewriteVersion === 2) {
-        const rewritten = references.ledgerArchives?.get(buildToolResultArchiveResourceRef(value));
-        if (!rewritten)
-            throw new Error('Cannot copy ledger archive without its committed transition');
-        return rewritten;
+        throw new Error('Cannot copy ledger archive without its committed transition');
     }
     const artifactId = rewriteOwnedArtifactId(value.artifactId, references);
     const resource = value.resourceRef