@nuvin/session 0.2.1-rc.1 → 0.3.0-rc.3

package/dist/{chunk-B6S3CWQX.js → chunk-CAMZK5FN.js}

@@ -42,14 +42,114 @@ function removeApproval(state, matches) {
   return pending.length === state.pending.length ? state : { ...state, pending };
 }
 
+// src/state/display-text.ts
+var DISPLAY_TEXT_MAX_BYTES = 512;
+var textEncoder = new TextEncoder();
+function isControlCodePoint(codePoint) {
+  return codePoint <= 31 || codePoint >= 127 && codePoint <= 159;
+}
+function sanitizeBoundedDisplayText(text) {
+  let output = "";
+  let outputBytes = 0;
+  let terminalState = "normal";
+  for (const codePointText of text) {
+    const codePoint = codePointText.codePointAt(0);
+    if (codePoint === void 0) continue;
+    if (terminalState === "osc") {
+      if (codePoint === 7 || codePoint === 156) {
+        terminalState = "normal";
+      } else if (codePoint === 27) {
+        terminalState = "osc-escape";
+      }
+      continue;
+    }
+    if (terminalState === "osc-escape") {
+      if (codePoint === 92 || codePoint === 7 || codePoint === 156) {
+        terminalState = "normal";
+      } else if (codePoint !== 27) {
+        terminalState = "osc";
+      }
+      continue;
+    }
+    if (terminalState === "st-string") {
+      if (codePoint === 156) {
+        terminalState = "normal";
+      } else if (codePoint === 27) {
+        terminalState = "st-string-escape";
+      }
+      continue;
+    }
+    if (terminalState === "st-string-escape") {
+      if (codePoint === 92 || codePoint === 156) {
+        terminalState = "normal";
+      } else if (codePoint !== 27) {
+        terminalState = "st-string";
+      }
+      continue;
+    }
+    if (codePoint === 27) {
+      terminalState = "escape";
+      continue;
+    }
+    if (codePoint === 155) {
+      terminalState = "csi";
+      continue;
+    }
+    if (codePoint === 157) {
+      terminalState = "osc";
+      continue;
+    }
+    if (codePoint === 144 || codePoint === 152 || codePoint === 158 || codePoint === 159) {
+      terminalState = "st-string";
+      continue;
+    }
+    if (codePoint === 156) {
+      terminalState = "normal";
+      continue;
+    }
+    if (terminalState === "csi") {
+      if (codePoint >= 64 && codePoint <= 126) {
+        terminalState = "normal";
+      }
+      continue;
+    }
+    if (terminalState === "escape-intermediate") {
+      if (codePoint >= 48 && codePoint <= 126) {
+        terminalState = "normal";
+      }
+      continue;
+    }
+    if (terminalState === "escape") {
+      if (codePoint === 91) {
+        terminalState = "csi";
+      } else if (codePoint === 93) {
+        terminalState = "osc";
+      } else if (codePoint === 80 || codePoint === 88 || codePoint === 94 || codePoint === 95) {
+        terminalState = "st-string";
+      } else if (codePoint >= 32 && codePoint <= 47) {
+        terminalState = "escape-intermediate";
+      } else {
+        terminalState = "normal";
+      }
+      continue;
+    }
+    if (isControlCodePoint(codePoint)) continue;
+    const codePointBytes = textEncoder.encode(codePointText).byteLength;
+    if (outputBytes + codePointBytes > DISPLAY_TEXT_MAX_BYTES) break;
+    output += codePointText;
+    outputBytes += codePointBytes;
+  }
+  return output;
+}
+
 // src/state/json.ts
 function asJsonObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
 }
 
 // src/state/tool-key.ts
-function scopedToolKey(parentToolCallId, toolCallId) {
-  return JSON.stringify([parentToolCallId ?? null, toolCallId]);
+function scopedToolKey(toolCallPath, toolCallId) {
+  return JSON.stringify([...toolCallPath ?? [], toolCallId]);
 }
 
 // src/state/messages.ts
@@ -73,8 +173,11 @@ function addMessage(state, message) {
     nextId: state.nextId + 1
   };
 }
-function scopedRegistryKey(scope, id) {
-  return scope ? `${scope}::${id}` : id;
+function cloneToolCallPath(toolCallPath) {
+  return toolCallPath && toolCallPath.length > 0 ? [...toolCallPath] : void 0;
+}
+function scopedRegistryKey(toolCallPath, id) {
+  return scopedToolKey(toolCallPath, id);
 }
 function compactError(error) {
   const normalized = error.trim().replace(/\s+/g, " ");
@@ -91,9 +194,9 @@ function retryReasonText(event) {
 function formatProviderRetryText(event) {
   return `${retryReasonText(event)}: ${compactError(event.error)} \xB7 ${retryDelayText(event.delayMs)} \xB7 attempt ${event.attempt + 1}/${event.maxAttempts}`;
 }
-function removeProviderStreamMessages(state, assistantMessageId, reasoningMessageId, parentToolCallId) {
-  const assistantKey = scopedRegistryKey(parentToolCallId, assistantMessageId);
-  const reasoningKey = scopedRegistryKey(parentToolCallId, reasoningMessageId);
+function removeProviderStreamMessages(state, assistantMessageId, reasoningMessageId, toolCallPath) {
+  const assistantKey = scopedRegistryKey(toolCallPath, assistantMessageId);
+  const reasoningKey = scopedRegistryKey(toolCallPath, reasoningMessageId);
   const assistantRowId = state.assistantMessageIds[assistantKey];
   const reasoningRowId = state.reasoningMessageIds[reasoningKey];
   if (!assistantRowId && !reasoningRowId) {
@@ -121,8 +224,8 @@ function removeProviderStreamMessages(state, assistantMessageId, reasoningMessag
     messages: state.messages.filter((message) => !removedIds.has(message.id))
   };
 }
-function upsertProviderRetryMessage(state, event, parentToolCallId, now) {
-  const trackingKey = scopedRegistryKey(parentToolCallId, event.assistantMessageId);
+function upsertProviderRetryMessage(state, event, toolCallPath, now) {
+  const trackingKey = scopedRegistryKey(toolCallPath, event.assistantMessageId);
   const existingId = state.providerRetryMessageIds[trackingKey];
   const attempt = {
     failedAttempt: event.attempt,
@@ -150,11 +253,12 @@ function upsertProviderRetryMessage(state, event, parentToolCallId, now) {
     });
   }
   const id = createMessageId(state);
+  const storedToolCallPath = cloneToolCallPath(toolCallPath);
   const nextState = addMessage(state, {
     id,
     role: "warning",
     text,
-    ...parentToolCallId ? { parentToolCallId } : {},
+    ...storedToolCallPath ? { toolCallPath: storedToolCallPath } : {},
     providerRetry: {
       assistantMessageId: event.assistantMessageId,
       attempts: [attempt]
@@ -168,8 +272,8 @@ function upsertProviderRetryMessage(state, event, parentToolCallId, now) {
     }
   };
 }
-function upsertTrackedTextMessage(state, registryKey, messageId, role, text, mode, live, parentToolCallId, timing) {
-  const trackingKey = scopedRegistryKey(parentToolCallId, messageId);
+function upsertTrackedTextMessage(state, registryKey, messageId, role, text, mode, live, toolCallPath, timing) {
+  const trackingKey = scopedRegistryKey(toolCallPath, messageId);
   const existingId = state[registryKey][trackingKey];
   if (existingId) {
     return withUpdatedMessage(state, existingId, (message) => {
@@ -188,12 +292,13 @@ function upsertTrackedTextMessage(state, registryKey, messageId, role, text, mod
     });
   }
   const id = createMessageId(state);
+  const storedToolCallPath = cloneToolCallPath(toolCallPath);
   const nextState = addMessage(state, {
     id,
     role,
     text,
     live,
-    ...parentToolCallId ? { parentToolCallId } : {},
+    ...storedToolCallPath ? { toolCallPath: storedToolCallPath } : {},
     ...timing !== void 0 ? { startedAt: timing } : {},
     // A reasoning message that arrives already-settled stamps completedAt too.
     ...timing !== void 0 && !live ? { completedAt: timing } : {}
@@ -206,10 +311,11 @@ function upsertTrackedTextMessage(state, registryKey, messageId, role, text, mod
     }
   };
 }
-function settleLiveReasoning(state, parentToolCallId, now) {
+function settleLiveReasoning(state, toolCallPath, now) {
+  const scopeKey = scopedRegistryKey(toolCallPath, "");
   let changed = false;
   const messages = state.messages.map((message) => {
-    if (message.role === "reasoning" && message.live && message.parentToolCallId === parentToolCallId) {
+    if (message.role === "reasoning" && message.live && scopedRegistryKey(message.toolCallPath, "") === scopeKey) {
       changed = true;
       return { ...message, live: false, completedAt: message.completedAt ?? now };
     }
@@ -228,20 +334,22 @@ function settleAllLiveReasoning(state, now) {
   });
   return changed ? { ...state, messages } : state;
 }
-function summarizeToolInput(input) {
+function summarizeToolCallInput(toolName, input) {
   const objectInput = asJsonObject(input);
-  if (!objectInput) {
-    return JSON.stringify(input);
-  }
-  const command = objectInput.command;
-  if (typeof command === "string") {
-    return command;
+  if (toolName === "Program") {
+    const description = objectInput && typeof objectInput.description === "string" ? objectInput.description : "";
+    return sanitizeBoundedDisplayText(description);
   }
-  const entries = Object.entries(objectInput);
-  if (entries.length === 1 && typeof entries[0]?.[1] === "string") {
-    return String(entries[0][1]);
+  let summary;
+  if (!objectInput) {
+    summary = JSON.stringify(input);
+  } else if (typeof objectInput.command === "string") {
+    summary = objectInput.command;
+  } else {
+    const entries = Object.entries(objectInput);
+    summary = entries.length === 1 && typeof entries[0]?.[1] === "string" ? String(entries[0][1]) : JSON.stringify(objectInput);
   }
-  return JSON.stringify(objectInput);
+  return sanitizeBoundedDisplayText(summary);
 }
 var BASH_STREAMING_PREVIEW_LINES = 5;
 var STREAM_TAIL_BUDGET = 64 * 1024;
@@ -320,8 +428,8 @@ function mergeToolResultText(currentText, result) {
   }
   return currentText;
 }
-function ensureToolMessage(state, toolCall, parentToolCallId) {
-  const toolKey = scopedToolKey(parentToolCallId, toolCall.id);
+function ensureToolMessage(state, toolCall, toolCallPath) {
+  const toolKey = scopedToolKey(toolCallPath, toolCall.id);
   const existingId = state.toolMessageIds[toolKey];
   if (existingId) {
     return withUpdatedMessage(state, existingId, (message) => {
@@ -330,21 +438,23 @@ function ensureToolMessage(state, toolCall, parentToolCallId) {
       }
       return {
         ...message,
-        input: asJsonObject(toolCall.input)
+        input: asJsonObject(toolCall.input),
+        summary: summarizeToolCallInput(toolCall.name, toolCall.input)
       };
     });
   }
   const id = createMessageId(state);
+  const storedToolCallPath = cloneToolCallPath(toolCallPath);
   const nextState = addMessage(state, {
     id,
     role: "tool",
     toolName: toolCall.name,
     toolCallId: toolCall.id,
-    summary: summarizeToolInput(toolCall.input),
+    summary: summarizeToolCallInput(toolCall.name, toolCall.input),
     text: "",
     status: "pending",
     input: asJsonObject(toolCall.input),
-    ...parentToolCallId ? { parentToolCallId } : {}
+    ...storedToolCallPath ? { toolCallPath: storedToolCallPath } : {}
   });
   return {
     ...nextState,
@@ -354,8 +464,8 @@ function ensureToolMessage(state, toolCall, parentToolCallId) {
     }
   };
 }
-function setToolMessageStatus(state, toolCallId, status, parentToolCallId) {
-  const toolMessageId = state.toolMessageIds[scopedToolKey(parentToolCallId, toolCallId)];
+function setToolMessageStatus(state, toolCallId, status, toolCallPath) {
+  const toolMessageId = state.toolMessageIds[scopedToolKey(toolCallPath, toolCallId)];
   if (!toolMessageId) {
     return state;
   }
@@ -369,8 +479,8 @@ function setToolMessageStatus(state, toolCallId, status, parentToolCallId) {
     };
   });
 }
-function setToolMessageApprovalKind(state, toolCallId, approvalKind, parentToolCallId) {
-  const toolMessageId = state.toolMessageIds[scopedToolKey(parentToolCallId, toolCallId)];
+function setToolMessageApprovalKind(state, toolCallId, approvalKind, toolCallPath) {
+  const toolMessageId = state.toolMessageIds[scopedToolKey(toolCallPath, toolCallId)];
   if (!toolMessageId) {
     return state;
   }
@@ -384,8 +494,8 @@ function setToolMessageApprovalKind(state, toolCallId, approvalKind, parentToolC
     };
   });
 }
-function setToolMessageHidden(state, toolCallId, hidden, parentToolCallId) {
-  const toolMessageId = state.toolMessageIds[scopedToolKey(parentToolCallId, toolCallId)];
+function setToolMessageHidden(state, toolCallId, hidden, toolCallPath) {
+  const toolMessageId = state.toolMessageIds[scopedToolKey(toolCallPath, toolCallId)];
   if (!toolMessageId) {
     return state;
   }
@@ -399,12 +509,13 @@ function setToolMessageHidden(state, toolCallId, hidden, parentToolCallId) {
     };
   });
 }
-function applyToolResult(state, result, now, parentToolCallId) {
+function applyToolResult(state, result, now, toolCallPath) {
   const status = asJsonObject(result.structured)?.error === "tool_rejected" ? "rejected" : result.status;
-  const toolKey = scopedToolKey(parentToolCallId, result.callId);
+  const toolKey = scopedToolKey(toolCallPath, result.callId);
   const toolMessageId = state.toolMessageIds[toolKey];
   if (!toolMessageId) {
     const id = createMessageId(state);
+    const storedToolCallPath = cloneToolCallPath(toolCallPath);
     const next = addMessage(state, {
       id,
       completedAt: now,
@@ -415,7 +526,7 @@ function applyToolResult(state, result, now, parentToolCallId) {
       summary: "",
       text: result.output,
       structured: result.structured,
-      ...parentToolCallId ? { parentToolCallId } : {}
+      ...storedToolCallPath ? { toolCallPath: storedToolCallPath } : {}
     });
     return {
       ...next,
@@ -451,24 +562,33 @@ function createMessageState() {
   };
 }
 function createMessageStateFromMessages(messages) {
-  const nextId = messages.reduce((max, message) => {
+  const normalizedMessages = messages.map((message) => {
+    const toolCallPath = cloneToolCallPath(message.toolCallPath);
+    if (toolCallPath) return { ...message, toolCallPath };
+    if (message.toolCallPath !== void 0) {
+      const { toolCallPath: _toolCallPath, ...rootMessage } = message;
+      return rootMessage;
+    }
+    return message;
+  });
+  const nextId = normalizedMessages.reduce((max, message) => {
     const match = /^message-(\d+)$/.exec(message.id);
     if (!match) return max;
     return Math.max(max, Number(match[1]) + 1);
-  }, 1) + messages.length;
+  }, 1) + normalizedMessages.length;
   const toolMessageIds = {};
   const providerRetryMessageIds = {};
-  for (const message of messages) {
+  for (const message of normalizedMessages) {
     if (message.role === "tool") {
-      toolMessageIds[scopedToolKey(message.parentToolCallId, message.toolCallId)] = message.id;
+      toolMessageIds[scopedToolKey(message.toolCallPath, message.toolCallId)] = message.id;
     }
     if (isProviderRetryMessage(message)) {
-      providerRetryMessageIds[scopedRegistryKey(message.parentToolCallId, message.providerRetry.assistantMessageId)] = message.id;
+      providerRetryMessageIds[scopedRegistryKey(message.toolCallPath, message.providerRetry.assistantMessageId)] = message.id;
     }
   }
   return {
     assistantMessageIds: {},
-    messages,
+    messages: normalizedMessages,
     nextId,
     providerRetryMessageIds,
     reasoningMessageIds: {},
@@ -505,21 +625,21 @@ function appendWarningMessage(state, text) {
     text
   });
 }
-function applyAgentEvent(state, event, parentToolCallId, now = Date.now()) {
+function applyAgentEvent(state, event, toolCallPath, now = Date.now()) {
   switch (event.type) {
     case "assistant_chunk":
       if (!event.chunk.text) {
         return state;
       }
       return upsertTrackedTextMessage(
-        settleLiveReasoning(state, parentToolCallId, now),
+        settleLiveReasoning(state, toolCallPath, now),
         "assistantMessageIds",
         event.messageId,
         "assistant",
         event.chunk.text,
         "append",
         true,
-        parentToolCallId
+        toolCallPath
       );
     case "assistant_message": {
       const text = getTextFromMessage(event.message).trim();
@@ -527,14 +647,14 @@ function applyAgentEvent(state, event, parentToolCallId, now = Date.now()) {
         return state;
       }
       return upsertTrackedTextMessage(
-        settleLiveReasoning(state, parentToolCallId, now),
+        settleLiveReasoning(state, toolCallPath, now),
         "assistantMessageIds",
         event.message.id,
         "assistant",
         text,
         "replace",
         false,
-        parentToolCallId
+        toolCallPath
       );
     }
     case "reasoning_chunk":
@@ -549,7 +669,7 @@ function applyAgentEvent(state, event, parentToolCallId, now = Date.now()) {
         event.text,
         "append",
         true,
-        parentToolCallId,
+        toolCallPath,
         now
       );
     case "reasoning_message": {
@@ -565,7 +685,7 @@ function applyAgentEvent(state, event, parentToolCallId, now = Date.now()) {
         text,
         "replace",
         false,
-        parentToolCallId,
+        toolCallPath,
         now
       );
     }
@@ -575,21 +695,21 @@ function applyAgentEvent(state, event, parentToolCallId, now = Date.now()) {
         return state;
       }
       return upsertTrackedTextMessage(
-        settleLiveReasoning(state, parentToolCallId, now),
+        settleLiveReasoning(state, toolCallPath, now),
         "assistantMessageIds",
         event.message.id,
         "assistant",
         text,
         "replace",
         false,
-        parentToolCallId
+        toolCallPath
       );
     }
     case "tool_call":
-      return ensureToolMessage(state, event.toolCall, parentToolCallId);
+      return ensureToolMessage(state, event.toolCall, toolCallPath);
     case "tool_started": {
-      const toolState = ensureToolMessage(state, event.toolCall, parentToolCallId);
-      const toolMessageId = toolState.toolMessageIds[scopedToolKey(parentToolCallId, event.toolCall.id)];
+      const toolState = ensureToolMessage(state, event.toolCall, toolCallPath);
+      const toolMessageId = toolState.toolMessageIds[scopedToolKey(toolCallPath, event.toolCall.id)];
       return withUpdatedMessage(toolState, toolMessageId, (message) => {
         if (message.role !== "tool") {
           return message;
@@ -602,8 +722,8 @@ function applyAgentEvent(state, event, parentToolCallId, now = Date.now()) {
       });
     }
     case "tool_output_chunk": {
-      const toolState = ensureToolMessage(state, event.toolCall, parentToolCallId);
-      const toolMessageId = toolState.toolMessageIds[scopedToolKey(parentToolCallId, event.toolCall.id)];
+      const toolState = ensureToolMessage(state, event.toolCall, toolCallPath);
+      const toolMessageId = toolState.toolMessageIds[scopedToolKey(toolCallPath, event.toolCall.id)];
       return withUpdatedMessage(toolState, toolMessageId, (message) => {
         if (message.role !== "tool") {
           return message;
@@ -622,14 +742,14 @@ function applyAgentEvent(state, event, parentToolCallId, now = Date.now()) {
       });
     }
     case "tool_completed": {
-      const toolState = ensureToolMessage(state, event.toolCall, parentToolCallId);
-      return applyToolResult(toolState, event.result, now, parentToolCallId);
+      const toolState = ensureToolMessage(state, event.toolCall, toolCallPath);
+      return applyToolResult(toolState, event.result, now, toolCallPath);
     }
     case "tool_result":
-      return applyToolResult(state, event.result, now, parentToolCallId);
+      return applyToolResult(state, event.result, now, toolCallPath);
     case "tool_rejected": {
-      const toolState = ensureToolMessage(state, event.toolCall, parentToolCallId);
-      const toolMessageId = toolState.toolMessageIds[scopedToolKey(parentToolCallId, event.toolCall.id)];
+      const toolState = ensureToolMessage(state, event.toolCall, toolCallPath);
+      const toolMessageId = toolState.toolMessageIds[scopedToolKey(toolCallPath, event.toolCall.id)];
       return withUpdatedMessage(toolState, toolMessageId, (message) => {
         if (message.role !== "tool") {
           return message;
@@ -648,31 +768,48 @@ function applyAgentEvent(state, event, parentToolCallId, now = Date.now()) {
         state,
         event.assistantMessageId,
         event.reasoningMessageId,
-        parentToolCallId
+        toolCallPath
       );
     case "provider_retry":
-      return upsertProviderRetryMessage(state, event, parentToolCallId, now);
+      return upsertProviderRetryMessage(state, event, toolCallPath, now);
     default:
       return state;
   }
 }
 
 // src/state/questions.ts
+function cloneQuestion(question) {
+  if (question.toolCallPath && question.toolCallPath.length > 0) {
+    return { ...question, toolCallPath: [...question.toolCallPath] };
+  }
+  if (question.toolCallPath !== void 0) {
+    const { toolCallPath: _toolCallPath, ...rootQuestion } = question;
+    return rootQuestion;
+  }
+  return question;
+}
+function questionKey(questionId, toolCallPath) {
+  return scopedToolKey(toolCallPath, questionId);
+}
 function createQuestionQueueState() {
   return { active: null, pending: [] };
 }
 function enqueueQuestion(state, question) {
+  const queuedQuestion = cloneQuestion(question);
   if (state.active === null) {
-    return { ...state, active: question };
+    return { ...state, active: queuedQuestion };
   }
-  return { ...state, pending: [...state.pending, question] };
+  return { ...state, pending: [...state.pending, queuedQuestion] };
 }
-function removeQuestion(state, questionId) {
-  if (state.active?.questionId === questionId) {
+function removeQuestion(state, questionId, toolCallPath) {
+  const settledKey = questionKey(questionId, toolCallPath);
+  if (state.active && questionKey(state.active.questionId, state.active.toolCallPath) === settledKey) {
     const [active, ...pending2] = state.pending;
     return { active: active ?? null, pending: pending2 };
   }
-  const pending = state.pending.filter((question) => question.questionId !== questionId);
+  const pending = state.pending.filter(
+    (question) => questionKey(question.questionId, question.toolCallPath) !== settledKey
+  );
   return pending.length === state.pending.length ? state : { ...state, pending };
 }
 
@@ -732,6 +869,41 @@ function foldWorkflowDelta(state, delta) {
 }
 
 // src/state/session.ts
+function cloneApproval(approval) {
+  const { toolCallPath, ...rootApproval } = approval;
+  return toolCallPath && toolCallPath.length > 0 ? { ...rootApproval, toolCallPath: [...toolCallPath] } : rootApproval;
+}
+function cloneQuestion2(question) {
+  const { toolCallPath, ...rootQuestion } = question;
+  return toolCallPath && toolCallPath.length > 0 ? { ...rootQuestion, toolCallPath: [...toolCallPath] } : rootQuestion;
+}
+function cloneMessage(message) {
+  const { toolCallPath, ...rootMessage } = message;
+  return toolCallPath && toolCallPath.length > 0 ? { ...rootMessage, toolCallPath: [...toolCallPath] } : rootMessage;
+}
+function normalizeResetState(state) {
+  return {
+    ...state,
+    approval: {
+      ...state.approval,
+      active: state.approval.active ? cloneApproval(state.approval.active) : null,
+      pending: state.approval.pending.map(cloneApproval)
+    },
+    messages: {
+      ...state.messages,
+      assistantMessageIds: { ...state.messages.assistantMessageIds },
+      messages: state.messages.messages.map(cloneMessage),
+      providerRetryMessageIds: { ...state.messages.providerRetryMessageIds },
+      reasoningMessageIds: { ...state.messages.reasoningMessageIds },
+      toolMessageIds: { ...state.messages.toolMessageIds }
+    },
+    question: {
+      ...state.question,
+      active: state.question.active ? cloneQuestion2(state.question.active) : null,
+      pending: state.question.pending.map(cloneQuestion2)
+    }
+  };
+}
 function createSessionViewState() {
   return {
     approval: createApprovalQueueState(),
@@ -753,7 +925,7 @@ function reduceSessionEvent(state, event) {
       let messages = applyAgentEvent(
         state.messages,
         event.event,
-        event.scope?.parentToolCallId,
+        event.scope?.toolCallPath,
         event.at
       );
       if (event.toolStatus && event.event.type === "tool_call") {
@@ -761,14 +933,14 @@ function reduceSessionEvent(state, event) {
           messages,
           event.event.toolCall.id,
           event.toolStatus,
-          event.scope?.parentToolCallId
+          event.scope?.toolCallPath
         );
         if (event.toolStatus === "approved") {
           messages = setToolMessageApprovalKind(
             messages,
             event.event.toolCall.id,
             "auto",
-            event.scope?.parentToolCallId
+            event.scope?.toolCallPath
           );
         }
       }
@@ -782,12 +954,12 @@ function reduceSessionEvent(state, event) {
     case "approval-requested":
       return {
         ...state,
-        approval: enqueueApproval(state.approval, event.approval),
+        approval: enqueueApproval(state.approval, cloneApproval(event.approval)),
         messages: setToolMessageHidden(
           state.messages,
           event.approval.toolCallId,
           true,
-          event.approval.parentToolCallId
+          event.approval.toolCallPath
         )
       };
     case "approval-settled": {
@@ -795,31 +967,30 @@ function reduceSessionEvent(state, event) {
         state.messages,
         event.toolCallId,
         event.status,
-        event.parentToolCallId
+        event.toolCallPath
       );
       if (event.status === "approved" && event.by === "client") {
-        stamped = setToolMessageApprovalKind(
-          stamped,
-          event.toolCallId,
-          "user",
-          event.parentToolCallId
-        );
+        stamped = setToolMessageApprovalKind(stamped, event.toolCallId, "user", event.toolCallPath);
       }
+      const settledKey = scopedToolKey(event.toolCallPath, event.toolCallId);
       return {
         ...state,
         approval: removeApproval(
           state.approval,
-          (item) => item.toolCallId === event.toolCallId && item.parentToolCallId === event.parentToolCallId
+          (item) => scopedToolKey(item.toolCallPath, item.toolCallId) === settledKey
         ),
         // Approved tools materialize as a transcript row; rejected ones never
         // ran and stay hidden.
-        messages: event.status === "approved" ? setToolMessageHidden(stamped, event.toolCallId, false, event.parentToolCallId) : stamped
+        messages: event.status === "approved" ? setToolMessageHidden(stamped, event.toolCallId, false, event.toolCallPath) : stamped
       };
     }
     case "question-asked":
       return { ...state, question: enqueueQuestion(state.question, event.question) };
     case "question-settled":
-      return { ...state, question: removeQuestion(state.question, event.questionId) };
+      return {
+        ...state,
+        question: removeQuestion(state.question, event.questionId, event.toolCallPath)
+      };
     case "turn-status": {
       const messages = event.busy ? state.messages : settleAllLiveReasoning(state.messages, event.at);
       return {
@@ -856,7 +1027,7 @@ function reduceSessionEvent(state, event) {
       };
     }
     case "state-reset":
-      return event.state;
+      return normalizeResetState(event.state);
     default:
       return state;
   }
@@ -869,10 +1040,13 @@ export {
   enqueueApproval,
   dequeueActiveApproval,
   removeApproval,
+  DISPLAY_TEXT_MAX_BYTES,
+  sanitizeBoundedDisplayText,
   asJsonObject,
   scopedToolKey,
   isProviderRetryMessage,
   settleAllLiveReasoning,
+  summarizeToolCallInput,
   setToolMessageStatus,
   setToolMessageApprovalKind,
   setToolMessageHidden,