nolo-cli 0.8.0-alpha.21 → 0.8.0-alpha.24

package/{chunk-4QEWT7KD.js → chunk-AISLHYDB.js}

@@ -2,23 +2,17 @@ import {
   buildCurrentTimeBlock,
   buildIdentityBlock,
   buildRuntimeGuidanceBlocks
-} from "./chunk-AGFH73SK.js";
+} from "./chunk-G7KM6BBZ.js";
 import {
   canonicalizeToolNames
-} from "./chunk-P3PKED2I.js";
+} from "./chunk-FZ2G3I4B.js";
 import {
   clipCompactText
 } from "./chunk-5MMAK75Q.js";
 import {
   findModelConfig,
   getProviderByModelName
-} from "./chunk-BBYVOSU2.js";
-import {
-  compactWhitespace
-} from "./chunk-DWLEOOGR.js";
-import {
-  toErrorMessage
-} from "./chunk-HNMXYYJR.js";
+} from "./chunk-S3UTETIC.js";
 import {
   asRecordOrEmpty
 } from "./chunk-KX6YBIHG.js";
@@ -26,11 +20,14 @@ import {
   asTrimmedLowercaseString
 } from "./chunk-QSJ3HFEF.js";
 import {
-  asOptionalTrimmedString
-} from "./chunk-G3SUCT4W.js";
+  toErrorMessage
+} from "./chunk-HNMXYYJR.js";
 import {
   isRecord
 } from "./chunk-KUG52IAP.js";
+import {
+  asOptionalTrimmedString
+} from "./chunk-G3SUCT4W.js";
 
 // packages/agent-runtime/actionGate.ts
 function readCommandActionGatePayload(payload) {
@@ -273,6 +270,20 @@ function summarizeToolArguments(toolName, rawArgs) {
   );
 }
 
+// packages/agent-runtime/contextBlockScope.ts
+var isContextBlockScope = (value) => {
+  if (typeof value !== "object" || value === null) return false;
+  const candidate = value;
+  return typeof candidate.content === "string" && (candidate.cacheScope === "session" || candidate.cacheScope === "turn");
+};
+var normalizeContextBlockScopes = (legacyBlocks = void 0, scopes = void 0) => {
+  const trimmedScopes = (Array.isArray(scopes) ? scopes : []).filter(isContextBlockScope).map((scope) => ({ content: scope.content.trim(), cacheScope: scope.cacheScope })).filter((scope) => scope.content.length > 0);
+  if (trimmedScopes.length > 0) {
+    return trimmedScopes;
+  }
+  return (Array.isArray(legacyBlocks) ? legacyBlocks : []).filter((block) => typeof block === "string").map((block) => block.trim()).filter((block) => block.length > 0).map((block) => ({ content: block, cacheScope: "turn" }));
+};
+
 // packages/agent-runtime/localLoop.ts
 var LOCAL_AGENT_CONFIG_MISSING_CODE = "LOCAL_AGENT_CONFIG_MISSING";
 var EMPTY_ASSISTANT_REPAIR_PROMPT = "\u8BF7\u7ED9\u51FA\u660E\u786E\u7684\u6587\u5B57\u56DE\u7B54\u6216\u6267\u884C\u4E0B\u4E00\u6B65\uFF1A\u5982\u679C\u4EFB\u52A1\u5DF2\u5B8C\u6210\uFF0C\u8BF7\u76F4\u63A5\u603B\u7ED3\u7ED3\u679C\uFF1B\u5982\u679C\u9700\u8981\u8C03\u7528\u5DE5\u5177\uFF0C\u8BF7\u76F4\u63A5\u8F93\u51FA tool_calls\u3002\u8BF7\u5207\u52FF\u8FD4\u56DE\u7A7A\u5185\u5BB9\u3002";
@@ -341,14 +352,43 @@ function buildAbortedError() {
 function throwIfAborted(input) {
   if (input.abortSignal?.aborted) throw buildAbortedError();
 }
+async function raceWithAbort(input, promise, pendingToolName) {
+  const signal = input.abortSignal;
+  if (!signal) return promise;
+  let abortListener;
+  const abortPromise = new Promise((_resolve, reject) => {
+    abortListener = () => {
+      const error = buildAbortedError();
+      if (pendingToolName) error.pendingToolName = pendingToolName;
+      promise.catch(() => {
+      });
+      reject(error);
+    };
+    if (signal.aborted) {
+      abortListener();
+      return;
+    }
+    signal.addEventListener("abort", abortListener, { once: true });
+  });
+  try {
+    return await Promise.race([promise, abortPromise]);
+  } finally {
+    if (signal && abortListener) signal.removeEventListener("abort", abortListener);
+  }
+}
 function resolveLlmRequestTimeoutMs(input) {
   const raw = input.llmRequestTimeoutMs ?? input.timeoutMs;
   if (typeof raw !== "number" || !Number.isFinite(raw) || raw <= 0) return void 0;
   return raw;
 }
 async function runCompleteWithTimeout(args) {
-  const { provider, messages, options, timeoutMs, round, input } = args;
-  emitLoopEvent(input, { kind: "llm-start", round, atMs: Date.now() });
+  const { provider, messages, options, timeoutMs, round, input, context } = args;
+  emitLoopEvent(input, {
+    kind: "llm-start",
+    round,
+    atMs: Date.now(),
+    ...context ? { context } : {}
+  });
   const complete = provider.complete(messages, options);
   let ok = false;
   const signal = input.abortSignal;
@@ -513,50 +553,209 @@ function buildActionGate(args) {
 }
 var MAX_HISTORICAL_TOOL_CONTENT_CHARS = 1600;
 var MAX_IN_TURN_TOOL_CONTENT_CHARS = 4e3;
-function summarizeToolContentForProvider(content, maxChars, label) {
+var DEFAULT_TOOL_OUTPUT_PROFILE = {
+  maxChars: MAX_IN_TURN_TOOL_CONTENT_CHARS,
+  headRatio: 0.5
+};
+var TOOL_OUTPUT_PROFILES = {
+  readFile: { maxChars: 4800, headRatio: 0.68 },
+  read_file: { maxChars: 4800, headRatio: 0.68 },
+  readWorkspaceFile: { maxChars: 4800, headRatio: 0.68 },
+  searchFiles: { maxChars: 3600, headRatio: 0.78 },
+  search_files: { maxChars: 3600, headRatio: 0.78 },
+  listFiles: { maxChars: 2800, headRatio: 0.85 },
+  globFiles: { maxChars: 2800, headRatio: 0.85 },
+  execShell: { maxChars: 4e3, headRatio: 0.35 },
+  runCommand: { maxChars: 4e3, headRatio: 0.35 },
+  launchProcess: { maxChars: 2800, headRatio: 0.35 },
+  editFile: { maxChars: 2800, headRatio: 0.62 },
+  writeFile: { maxChars: 2400, headRatio: 0.62 },
+  readPastedText: { maxChars: 4800, headRatio: 0.5 }
+};
+var TOOL_METADATA_KEYS = [
+  "path",
+  "query",
+  "effectivePattern",
+  "startLine",
+  "endLine",
+  "totalLines",
+  "totalBytes",
+  "bytes",
+  "totalChars",
+  "count",
+  "matchCount",
+  "matchedFiles",
+  "truncated",
+  "limitedByMaxResults",
+  "limitedByMaxDepth",
+  "visitedEntries",
+  "maxResults",
+  "exitCode",
+  "status",
+  "timedOut",
+  "aborted",
+  "replacements",
+  "code",
+  "error",
+  "message",
+  "pasteId",
+  "source"
+];
+function resolveToolOutputProfile(toolName) {
+  return (toolName ? TOOL_OUTPUT_PROFILES[toolName] : void 0) ?? DEFAULT_TOOL_OUTPUT_PROFILE;
+}
+function contentCharCount(content) {
+  if (typeof content === "string") return content.length;
+  if (!Array.isArray(content)) return 0;
+  return content.reduce((total, part) => {
+    if (part?.type === "text") return total + part.text.length;
+    if (part?.type === "image_url") return total + part.image_url.url.length;
+    return total;
+  }, 0);
+}
+function compactToolMetadata(metadata) {
+  if (!metadata) return "";
+  const selected = {};
+  for (const key of TOOL_METADATA_KEYS) {
+    const value = metadata[key];
+    if (value === void 0) continue;
+    if (typeof value === "string") {
+      selected[key] = clipCompactText(value, 240);
+      continue;
+    }
+    if (Array.isArray(value)) {
+      selected[key] = value.slice(0, 20).map(
+        (item) => typeof item === "string" ? clipCompactText(item, 180) : clipCompactText(JSON.stringify(item), 180)
+      );
+      continue;
+    }
+    selected[key] = value;
+  }
+  return Object.keys(selected).length > 0 ? clipCompactText(JSON.stringify(selected), 1200) : "";
+}
+function clipToolText(content, maxChars, headRatio) {
+  const normalized = content.replace(/\r\n/g, "\n").trim();
+  if (normalized.length <= maxChars) return normalized;
+  const marker = "\n\n[... tool output middle omitted; head/tail preserved ...]\n\n";
+  if (maxChars <= marker.length + 2) return normalized.slice(0, maxChars);
+  const available = maxChars - marker.length;
+  const headChars = Math.max(1, Math.floor(available * headRatio));
+  const tailChars = Math.max(1, available - headChars);
+  return `${normalized.slice(0, headChars)}${marker}${normalized.slice(-tailChars)}`;
+}
+function projectToolContentForProvider(args) {
+  const content = args.content;
   if (typeof content !== "string") return content;
-  if (content.length <= maxChars) return content;
-  const compact = compactWhitespace(content);
-  const clipped = compact.length > maxChars ? compact.slice(0, maxChars - 160) : compact;
-  return [
-    `[${label}]`,
-    `originalChars=${content.length}`,
-    clipped
-  ].join("\n");
-}
-function summarizeHistoricalToolContent(content) {
-  return summarizeToolContentForProvider(
-    content,
-    MAX_HISTORICAL_TOOL_CONTENT_CHARS,
-    "historical tool result truncated for the next turn"
+  const metadataText = compactToolMetadata(args.metadata);
+  const embeddedMetadataIndex = metadataText ? content.indexOf("\n\n[tool metadata]\n") : -1;
+  const contentForProjection = embeddedMetadataIndex >= 0 ? content.slice(0, embeddedMetadataIndex) : content;
+  const metadataSuffix = metadataText ? `
+
+[tool metadata]
+${metadataText}` : "";
+  if (embeddedMetadataIndex >= 0 && content.length <= args.maxChars) {
+    return content;
+  }
+  const headRatio = resolveToolOutputProfile(args.toolName).headRatio;
+  const diagnostic = (clippedLength) => `[${args.label}; originalChars=${content.length}; omittedChars=${Math.max(
+    0,
+    content.length - clippedLength
+  )}]`;
+  const suffix = (clippedLength) => [diagnostic(clippedLength), metadataSuffix.trimStart()].filter(Boolean).join("\n\n");
+  const initialBudget = Math.max(
+    1,
+    args.maxChars - suffix(contentForProjection.length).length - 2
   );
+  let clipped = clipToolText(contentForProjection, initialBudget, headRatio);
+  const wasClipped = clipped.length < contentForProjection.trim().length;
+  const needsProjection = wasClipped || Boolean(metadataSuffix) || embeddedMetadataIndex >= 0;
+  if (!needsProjection) return args.content;
+  let projected = wasClipped || metadataSuffix ? `${clipped}
+
+${suffix(clipped.length)}` : clipped;
+  if (projected.length > args.maxChars) {
+    const boundedBudget = Math.max(
+      1,
+      args.maxChars - suffix(clipped.length).length - 2
+    );
+    clipped = clipToolText(contentForProjection, boundedBudget, headRatio);
+    projected = `${clipped}
+
+${suffix(clipped.length)}`;
+  }
+  return projected.length <= args.maxChars ? projected : projected.slice(0, args.maxChars);
+}
+function summarizeHistoricalToolContent(content, toolName, metadata) {
+  const profile = resolveToolOutputProfile(toolName);
+  return projectToolContentForProvider({
+    content,
+    toolName,
+    metadata,
+    maxChars: Math.min(profile.maxChars, MAX_HISTORICAL_TOOL_CONTENT_CHARS),
+    label: "historical tool result truncated for the next turn"
+  });
 }
 function prepareMessagesForProviderCall(messages) {
   const paired = sanitizeToolCallPairing(messages);
-  return paired.map((message) => {
-    const sanitizedContent = message.content == null ? "" : typeof message.content === "string" ? message.content : message.content;
-    if (message.role !== "tool") {
+  let toolMessageCount = 0;
+  let rawToolContentChars = 0;
+  let projectedToolContentChars = 0;
+  let truncatedToolResults = 0;
+  const projected = paired.map((message) => {
+    const { context_reference: _contextReference, ...providerMessage } = message;
+    const sanitizedContent = providerMessage.content == null ? "" : typeof providerMessage.content === "string" ? providerMessage.content : providerMessage.content;
+    if (providerMessage.role !== "tool") {
       return {
-        ...message,
+        ...providerMessage,
         content: sanitizedContent
       };
     }
+    toolMessageCount += 1;
+    rawToolContentChars += contentCharCount(sanitizedContent);
+    const profile = resolveToolOutputProfile(providerMessage.toolName);
+    const projectedContent = projectToolContentForProvider({
+      content: sanitizedContent,
+      toolName: providerMessage.toolName,
+      metadata: providerMessage.tool_result_metadata,
+      maxChars: profile.maxChars,
+      label: "in-turn tool result truncated/projected before next provider call"
+    });
+    projectedToolContentChars += contentCharCount(projectedContent);
+    if (contentCharCount(projectedContent) < contentCharCount(sanitizedContent)) {
+      truncatedToolResults += 1;
+    }
     return {
-      ...message,
-      content: summarizeToolContentForProvider(
-        sanitizedContent,
-        MAX_IN_TURN_TOOL_CONTENT_CHARS,
-        "in-turn tool result truncated before next provider call"
-      )
+      ...providerMessage,
+      content: projectedContent
     };
   });
+  return {
+    messages: projected,
+    metrics: {
+      messageCount: projected.length,
+      contentChars: projected.reduce((total, message) => total + contentCharCount(message.content), 0),
+      toolMessageCount,
+      rawToolContentChars,
+      projectedToolContentChars,
+      truncatedToolResults,
+      stableContextChars: 0,
+      dynamicContextChars: 0
+    }
+  };
 }
-function prepareHistoryForNextTurn(history) {
+function prepareHistoryForNextTurn(history, contextReferenceResolver) {
   return history.map((message) => {
+    if (message.role === "user" && message.context_reference !== void 0 && contextReferenceResolver?.(message.context_reference)) {
+      return { ...message, content: message.context_reference };
+    }
     if (message.role !== "tool") return message;
     return {
       ...message,
-      content: summarizeHistoricalToolContent(message.content)
+      content: summarizeHistoricalToolContent(
+        message.content,
+        message.toolName,
+        message.tool_result_metadata
+      )
     };
   });
 }
@@ -578,25 +777,33 @@ function buildMessages(args) {
   if (args.contextBlockScopes?.length) {
     const blocks2 = args.contextBlockScopes.filter((b) => b.content.trim());
     const stableParts = [args.prompt?.trim(), ...blocks2.filter((b) => b.cacheScope === "session").map((b) => b.content)].filter(Boolean);
-    const dynamicParts = blocks2.filter((b) => b.cacheScope === "turn").map((b) => b.content).filter(Boolean);
+    const dynamicParts = blocks2.filter((b) => b.cacheScope === "turn").map((b) => b.content).map((block) => block.trim()).filter(Boolean);
     const stableContent = stableParts.join("\n\n");
     const dynamicContent = dynamicParts.join("\n\n");
     const systemContent2 = dynamicContent ? `${stableContent}
 
 ${dynamicContent}` : stableContent;
-    return [
-      ...systemContent2 ? [{ role: "system", content: systemContent2 }] : [],
-      ...prepareHistoryForNextTurn(args.history),
-      { role: "user", content: args.input }
-    ];
+    return {
+      messages: [
+        ...systemContent2 ? [{ role: "system", content: systemContent2 }] : [],
+        ...prepareHistoryForNextTurn(args.history, args.contextReferenceResolver),
+        { role: "user", content: args.input }
+      ],
+      stableContextChars: stableContent.length,
+      dynamicContextChars: dynamicContent.length
+    };
   }
   const blocks = (args.contextBlocks ?? []).map((block) => block.trim()).filter(Boolean);
   const systemContent = [args.prompt?.trim(), ...blocks].filter(Boolean).join("\n\n");
-  return [
-    ...systemContent ? [{ role: "system", content: systemContent }] : [],
-    ...prepareHistoryForNextTurn(args.history),
-    { role: "user", content: args.input }
-  ];
+  return {
+    messages: [
+      ...systemContent ? [{ role: "system", content: systemContent }] : [],
+      ...prepareHistoryForNextTurn(args.history, args.contextReferenceResolver),
+      { role: "user", content: args.input }
+    ],
+    stableContextChars: (args.prompt?.trim() ?? "").length,
+    dynamicContextChars: blocks.join("\n\n").length
+  };
 }
 function mergeTurnUsage(current, next) {
   if (!next) return current;
@@ -624,6 +831,52 @@ function extractUserInputText(content) {
   if (!Array.isArray(content)) return "";
   return content.flatMap((part) => part?.type === "text" && part.text ? [part.text] : []).join("\n").trim();
 }
+function attachDialogIdToError(error, dialogId) {
+  if (!dialogId) return;
+  if (typeof error === "object" && error !== null) {
+    error.dialogId = dialogId;
+  }
+}
+async function persistFailedLocalTurn(args) {
+  const errorMessage = toErrorMessage(args.error);
+  try {
+    const saved = await args.adapter.saveTurn({
+      agentKey: args.agentKey,
+      messages: args.messages,
+      result: {
+        content: args.partialContent || `[nolo] Agent run failed: ${errorMessage}`,
+        model: args.model ?? "unknown",
+        toolCallCount: args.toolCallCount ?? 0,
+        error: true,
+        errorMessage
+      },
+      ...args.input.runtimeContext ? { runtimeContext: args.input.runtimeContext } : {},
+      ...args.input.continueDialogId ? { continueDialogId: args.input.continueDialogId } : {},
+      ...args.input.spaceId ? { spaceId: args.input.spaceId } : {},
+      ...args.input.category ? { category: args.input.category } : {},
+      ...args.input.inheritedFromDialogKey ? { inheritedFromDialogKey: args.input.inheritedFromDialogKey } : {},
+      ...args.input.parentDialogId ? { parentDialogId: args.input.parentDialogId } : {}
+    });
+    return saved?.dialogId;
+  } catch {
+    return args.input.continueDialogId;
+  }
+}
+function applyPersistedTurnInput(messages, persistedInput, persistedInputReference) {
+  if (persistedInput === void 0 && persistedInputReference === void 0) {
+    return messages;
+  }
+  let replaced = false;
+  return messages.map((message) => {
+    if (replaced || message.role !== "user") return message;
+    replaced = true;
+    return {
+      ...message,
+      ...persistedInput !== void 0 ? { content: persistedInput } : {},
+      ...persistedInputReference !== void 0 ? { context_reference: persistedInputReference } : {}
+    };
+  });
+}
 async function runLocalAgentTurn(input) {
   const agentConfig = await input.adapter.loadAgentConfig(input.agentRef);
   if (!agentConfig) {
@@ -632,7 +885,21 @@ async function runLocalAgentTurn(input) {
     error.agentRef = input.agentRef;
     throw error;
   }
-  const history = input.continueDialogId ? await input.adapter.loadDialogHistory(input.continueDialogId) : [];
+  let history = [];
+  try {
+    history = input.continueDialogId ? await input.adapter.loadDialogHistory(input.continueDialogId) : [];
+  } catch (error) {
+    const dialogId = await persistFailedLocalTurn({
+      adapter: input.adapter,
+      agentKey: agentConfig.key,
+      messages: [{ role: "user", content: input.input }],
+      error,
+      model: agentConfig.model,
+      input
+    });
+    attachDialogIdToError(error, dialogId);
+    throw error;
+  }
   const identityBlock = buildIdentityBlock({
     agentName: agentConfig.name,
     agentId: agentConfig.key,
@@ -649,27 +916,27 @@ async function runLocalAgentTurn(input) {
   const currentTimeScope = [
     { content: buildCurrentTimeBlock(/* @__PURE__ */ new Date(), void 0), cacheScope: "turn" }
   ];
+  const callerScopes = normalizeContextBlockScopes(
+    input.contextBlocks,
+    input.contextBlockScopes
+  );
   const mergedContextBlockScopes = [
     { content: identityBlock, cacheScope: "session" },
     ...guidanceScopes,
     ...currentTimeScope,
-    ...input.contextBlockScopes ?? []
+    ...callerScopes
   ];
-  const hasContextBlocks = (input.contextBlocks ?? []).some(
-    (block) => block.trim()
-  ) || mergedContextBlockScopes.some(
-    (block) => block.content.trim()
-  );
+  const hasContextBlocks = callerScopes.some((block) => block.content.trim()) || mergedContextBlockScopes.some((block) => block.content.trim());
   const promptMessageCount = agentConfig.prompt?.trim() || hasContextBlocks ? 1 : 0;
   const turnStartIndex = promptMessageCount + history.length;
-  const messages = buildMessages({
+  const builtMessages = buildMessages({
     prompt: agentConfig.prompt,
-    contextBlocks: input.contextBlocks,
     contextBlockScopes: mergedContextBlockScopes,
     history,
-    input: input.input
+    input: input.input,
+    contextReferenceResolver: input.adapter.host === "cli" ? input.contextReferenceResolver : void 0
   });
-  const provider = await input.adapter.resolveProvider(agentConfig);
+  const messages = builtMessages.messages;
   const supportsImages = resolveAgentImageInputSupport({
     apiSource: agentConfig.apiSource,
     provider: agentConfig.provider,
@@ -688,11 +955,13 @@ async function runLocalAgentTurn(input) {
   let skipFinalAppend = false;
   let partialContent = "";
   try {
+    const provider = await input.adapter.resolveProvider(agentConfig);
     while (true) {
       partialContent = "";
       throwIfAborted(input);
+      const preparedMessages = prepareMessagesForProviderCall(messages);
       const baseRequestMessages = filterImagePartsFromMessages(
-        prepareMessagesForProviderCall(messages),
+        preparedMessages.messages,
         supportsImages
       );
       if (!supportsImages && !imageDowngradeNotified && messages.some((m) => Array.isArray(m.content) && m.content.some((p) => p?.type === "image_url"))) {
@@ -704,6 +973,16 @@ async function runLocalAgentTurn(input) {
         });
       }
       const requestMessages = emptyAssistantRepairPending ? [...baseRequestMessages, { role: "user", content: EMPTY_ASSISTANT_REPAIR_PROMPT }] : baseRequestMessages;
+      const contextMetrics = {
+        ...preparedMessages.metrics,
+        messageCount: requestMessages.length,
+        contentChars: requestMessages.reduce(
+          (total, message) => total + contentCharCount(message.content),
+          0
+        ),
+        stableContextChars: builtMessages.stableContextChars,
+        dynamicContextChars: builtMessages.dynamicContextChars
+      };
       emptyAssistantRepairPending = false;
       result = await runCompleteWithTimeout({
         provider,
@@ -720,7 +999,8 @@ async function runLocalAgentTurn(input) {
         },
         timeoutMs: resolveLlmRequestTimeoutMs(input),
         round,
-        input
+        input,
+        context: contextMetrics
       });
       turnUsage = mergeTurnUsage(turnUsage, result.usage);
       const toolCalls = result.tool_calls ?? [];
@@ -790,13 +1070,14 @@ async function runLocalAgentTurn(input) {
           argumentsPreview: summarizeToolArguments(toolName, toolCall.function.arguments)
         });
         try {
-          toolResult = await input.adapter.executeTool({
+          const executePromise = input.adapter.executeTool({
             id: toolCall.id,
             name: toolName,
             arguments: toolCall.function.arguments,
             ...userInputText ? { userInput: userInputText } : {},
             ...input.abortSignal ? { abortSignal: input.abortSignal } : {}
           });
+          toolResult = await raceWithAbort(input, executePromise, toolName);
           const actionGate = buildActionGate({
             toolName,
             toolCallId: toolCall.id,
@@ -821,6 +1102,9 @@ async function runLocalAgentTurn(input) {
           });
         } catch (error) {
           emitLoopEvent(input, { kind: "tool-end", name: toolName, atMs: Date.now(), ok: false });
+          if (error && typeof error === "object" && error.code === LOCAL_TURN_ABORTED_CODE) {
+            throw error;
+          }
           if (!shouldReturnToolExecutionErrors(input.adapter)) throw error;
           emitToolEvent(input, {
             type: "tool-error",
@@ -858,28 +1142,22 @@ async function runLocalAgentTurn(input) {
     loopError = error;
   }
   if (loopError) {
-    const errorMessage = toErrorMessage(loopError);
-    const turnMessages2 = messages.slice(turnStartIndex);
-    const saved2 = await input.adapter.saveTurn({
+    const turnMessages2 = applyPersistedTurnInput(
+      messages.slice(turnStartIndex),
+      input.persistedInput,
+      input.persistedInputReference
+    );
+    const dialogId = await persistFailedLocalTurn({
+      adapter: input.adapter,
       agentKey: agentConfig.key,
       messages: turnMessages2,
-      result: {
-        content: partialContent || `[nolo] Agent run failed: ${errorMessage}`,
-        model: agentConfig.model ?? "unknown",
-        toolCallCount,
-        error: true,
-        errorMessage
-      },
-      ...input.runtimeContext ? { runtimeContext: input.runtimeContext } : {},
-      ...input.continueDialogId ? { continueDialogId: input.continueDialogId } : {},
-      ...input.spaceId ? { spaceId: input.spaceId } : {},
-      ...input.category ? { category: input.category } : {},
-      ...input.inheritedFromDialogKey ? { inheritedFromDialogKey: input.inheritedFromDialogKey } : {},
-      ...input.parentDialogId ? { parentDialogId: input.parentDialogId } : {}
+      error: loopError,
+      model: agentConfig.model,
+      toolCallCount,
+      partialContent,
+      input
     });
-    if (saved2?.dialogId && typeof loopError === "object" && loopError !== null) {
-      loopError.dialogId = saved2.dialogId;
-    }
+    attachDialogIdToError(loopError, dialogId);
     throw loopError;
   }
   result = result;
@@ -892,7 +1170,11 @@ async function runLocalAgentTurn(input) {
       ...result.reasoning_content ? { reasoning_content: result.reasoning_content } : {}
     });
   }
-  const turnMessages = messages.slice(turnStartIndex);
+  const turnMessages = applyPersistedTurnInput(
+    messages.slice(turnStartIndex),
+    input.persistedInput,
+    input.persistedInputReference
+  );
   const saved = await input.adapter.saveTurn({
     agentKey: agentConfig.key,
     messages: turnMessages,

package/{chunk-2FTTDCD4.js → chunk-AMJ7LA5D.js}

@@ -1,7 +1,7 @@
 import {
   isCompiledBinary,
   resolveCliEntrypointPath
-} from "./chunk-ISNCLGUZ.js";
+} from "./chunk-AVMJVOQY.js";
 
 // packages/cli/agentRunControl.ts
 import { homedir as nodeHomedir } from "node:os";

package/{chunk-I6XMPTMR.js → chunk-BFDWXLFF.js}

@@ -4,12 +4,12 @@ import {
 import {
   patch,
   read
-} from "./chunk-URUUZLPA.js";
+} from "./chunk-L3KWEH3V.js";
 import {
   DEVICE_LOCAL_OWNER_ID,
   isDeviceLocalSpaceBody,
   selectIdentityUserId
-} from "./chunk-UTLZINAP.js";
+} from "./chunk-DVRHHFEA.js";
 
 // packages/create/space/utils/permissions.ts
 var checkSpaceMembership = (spaceData, userId) => {

package/{chunk-RL776AGR.js → chunk-BKGNXJAM.js}

@@ -2,7 +2,7 @@ import {
   deleteDbRecord,
   queryUserRecords,
   readDbRecord
-} from "./chunk-SDJDLO5W.js";
+} from "./chunk-SBVUZC2E.js";
 import {
   mergeAndDedupUserData
 } from "./chunk-KQHGZWSV.js";