@vellumai/assistant 0.10.4 → 0.10.5-dev.202607022329.d89bf2f

package/src/daemon/conversation-agent-loop.ts

@@ -34,10 +34,6 @@ import {
 } from "../config/llm-resolver.js";
 import { getConfig } from "../config/loader.js";
 import type { LLMCallSite } from "../config/schemas/llm.js";
-import {
-  derefToolResultReReads,
-  postTurnTruncateToolResults,
-} from "../context/post-turn-tool-result-truncation.js";
 import { writeRelationshipState } from "../home/relationship-state-writer.js";
 import {
   clearSentryConversationContext,
@@ -56,8 +52,6 @@ import {
   updateConversationContextWindow,
   updateConversationSlackContextWatermark,
 } from "../persistence/conversation-crud.js";
-import { getResolvedConversationDirPath } from "../persistence/conversation-directories.js";
-import { syncMessageToDisk } from "../persistence/conversation-disk-view.js";
 import { isReplaceableTitle } from "../persistence/conversation-title-service.js";
 import {
   backfillMessageIdOnLogs,
@@ -81,6 +75,7 @@ import { timeAgo } from "../util/time.js";
 import { truncate } from "../util/truncate.js";
 import { getWorkspaceGitService } from "../workspace/git-service.js";
 import { commitTurnChanges } from "../workspace/turn-commit.js";
+import { ABORT_WATCHDOG_MS } from "./abort-watchdog.js";
 import { cleanAssistantContent } from "./assistant-attachments.js";
 import { conversationSupportsDynamicUi } from "./channel-ui-capability.js";
 import type { Conversation } from "./conversation.js";
@@ -113,6 +108,7 @@ import {
   type SlackChronologicalContext,
 } from "./conversation-runtime-assembly.js";
 import { markSurfaceCompleted } from "./conversation-surfaces.js";
+import { runDeferredTurnTail } from "./conversation-turn-finalize.js";
 import { recordUsage } from "./conversation-usage.js";
 import { resolveTurnTimezoneContext } from "./date-context.js";
 import { getDiskPressureStatus } from "./disk-pressure-guard.js";
@@ -197,28 +193,25 @@ export interface AssistantSurface {
 // ── abort watchdog ───────────────────────────────────────────────────
 
 /**
- * Backstop that drives an aborted turn to its `finally` even if some awaited
- * operation fails to observe the abort signal.
+ * Race `work` against an abort watchdog. The watchdog is a backstop that drives
+ * an aborted turn to its `finally` even if some awaited operation fails to
+ * observe the abort signal. Abort is otherwise cooperative and already wired
+ * into the slow paths: the provider call forwards the signal to its
+ * HTTP/streaming fetch, and tool execution races the signal so a stuck tool
+ * can't block cancellation. The watchdog only fires when a future code path
+ * silently ignores abort — without it, such a path would hang the loop forever
+ * and latch the conversation's `processing` flag true (the wedged "Thinking…"
+ * indicator). It is defense-in-depth, not the primary mechanism: in the common
+ * case abort settles in-flight work in well under a second, so ABORT_WATCHDOG_MS
+ * is ample headroom for a cooperative unwind while still releasing a genuinely
+ * wedged turn promptly.
  *
- * Abort is otherwise cooperative and already wired into the slow paths: the
- * provider call forwards the signal to its HTTP/streaming fetch, and tool
- * execution races the signal so a stuck tool can't block cancellation. This
- * watchdog only fires when a future code path silently ignores abort — without
- * it, such a path would hang the loop forever and latch the conversation's
- * `processing` flag true (the wedged "Thinking…" indicator). It is
- * defense-in-depth, not the primary mechanism: in the common case abort settles
- * in-flight work in well under a second, so a few seconds is ample headroom for
- * a cooperative unwind while still releasing a genuinely wedged turn promptly.
- */
-const ABORT_WATCHDOG_MS = 5_000;
-
-/**
- * Race `work` against an abort watchdog. The watchdog stays disarmed until the
- * signal fires; once it does, the turn has `timeoutMs` to settle before the
- * watchdog rejects with the signal's own abort reason so the caller unwinds to
- * its `finally` and the reason classifies as a user cancellation downstream.
- * The abandoned `work` promise keeps running detached — its eventual rejection
- * is swallowed so it can't surface as an unhandled rejection.
+ * The watchdog stays disarmed until the signal fires; once it does, the turn has
+ * `timeoutMs` to settle before the watchdog rejects with the signal's own abort
+ * reason so the caller unwinds to its `finally` and the reason classifies as a
+ * user cancellation downstream. The abandoned `work` promise keeps running
+ * detached — its eventual rejection is swallowed so it can't surface as an
+ * unhandled rejection.
  */
 async function withAbortWatchdog<T>(
   work: Promise<T>,
@@ -267,6 +260,13 @@ export async function runAgentLoopImpl(
     isInteractive?: boolean;
     isUserMessage?: boolean;
     titleText?: string;
+    /**
+     * True when the triggering message is a transcript-suppressed machine
+     * signal (`metadata.hidden`). Forwarded to the user-prompt-submit hook
+     * context so prompt-as-user-speech consumers (title generation) skip
+     * the turn.
+     */
+    isHiddenPrompt?: boolean;
     /**
      * LLM call-site identifier threaded into the per-call provider config.
      * Adapter callers (heartbeat, filing, scheduler, etc.) pass their own
@@ -317,6 +317,13 @@ export async function runAgentLoopImpl(
   ctx.currentTurnTrustContext = ctx.trustContext;
   ctx.currentTurnChannelCapabilities = ctx.channelCapabilities;
 
+  // Re-resolve the system prompt under the snapshots just set and push it into
+  // the loop when the persona changed. The loop reuses the prompt frozen at
+  // construction otherwise, so a flow that binds trust after construction (a
+  // voice call resolves the caller only after `getOrCreateConversation`) would
+  // run the whole conversation under the construction-time persona.
+  ctx.syncLoopSystemPrompt();
+
   const abortController = ctx.abortController;
   const reqId = ctx.currentRequestId ?? uuid();
   // First-token latency instrumentation for this turn. Stamped here at the
@@ -846,6 +853,13 @@ export async function runAgentLoopImpl(
       timeSinceLastMessage,
     };
 
+    // Freeze the turn-start client OS for the same anti-race reason as the
+    // timezone above: the live `ctx.clientOs` is re-applied from transport
+    // whenever a newer message for this conversation arrives mid-turn, so the
+    // assembly reads this frozen copy to avoid leaking a queued message's
+    // `client_os` into the in-flight turn.
+    ctx.currentTurnClientOs = ctx.clientOs ?? undefined;
+
     // Resolve the effective profile key for this turn and detect changes.
     // `modelProfileKey` is the actual profile used for this turn. The
     // notice key is narrower: it only marks turns where runtime context should
@@ -895,6 +909,7 @@ export async function runAgentLoopImpl(
       userMessageId,
       requestId: reqId,
       prompt: options?.titleText ?? content,
+      isHiddenPrompt: options?.isHiddenPrompt === true,
       originalMessages: ctx.messages,
       latestMessages: ctx.messages,
       logger: rlog,
@@ -1031,6 +1046,10 @@ export async function runAgentLoopImpl(
     };
 
     const updatedHistory = await runAgentLoop(runMessages, true);
+    // Generation is done streaming. Anything awaited between here and the
+    // terminal SSE is what the user perceives as the gap between the last
+    // token and the composer re-enabling, so keep that window minimal.
+    const generationCompletedAt = Date.now();
 
     rlog.info(
       { resultMessageCount: updatedHistory.length },
@@ -1290,39 +1309,18 @@ export async function runAgentLoopImpl(
       0,
       updatedHistory.length - lastRunNewMessages.length,
     );
-    let restoredHistory = [...loopBase, ...newMessages];
-
-    // Post-turn tool result truncation: save large results to disk and
-    // replace in-context content with a prefix/suffix stub + file pointer.
-    try {
-      const conv = getConversation(ctx.conversationId);
-      if (conv) {
-        const convDir = getResolvedConversationDirPath(
-          ctx.conversationId,
-          conv.createdAt,
-        );
-        const { messages: derefMessages, dereferencedCount } =
-          derefToolResultReReads(restoredHistory);
-        const { messages: truncatedMessages, truncatedCount } =
-          postTurnTruncateToolResults(derefMessages, {
-            conversationDir: convDir,
-          });
-        if (truncatedCount > 0 || dereferencedCount > 0) {
-          rlog.info(
-            { truncatedCount, dereferencedCount },
-            "Post-turn tool result truncation applied",
-          );
-        }
-        restoredHistory = truncatedMessages;
-      }
-    } catch (err) {
-      rlog.warn({ err }, "Post-turn tool result truncation failed (non-fatal)");
-    }
+    const restoredHistory = [...loopBase, ...newMessages];
 
     // Persist injections in history: runtime-injected context stays on
     // historical user messages so the conversation prefix is stable for
     // Anthropic's prefix caching.  Stripping only happens during
     // compaction/overflow recovery (where a cache miss is expected).
+    //
+    // Post-turn tool-result truncation (spooling large results to disk and
+    // shrinking the next turn's context) is deferred to `runDeferredTurnTail`
+    // below. It only rewrites the in-memory history the NEXT turn is built
+    // from — never the just-delivered reply — so it must not sit on the
+    // critical path to the terminal SSE that re-enables the composer.
     ctx.messages = restoredHistory;
 
     emitUsage(
@@ -1349,21 +1347,11 @@ export async function runAgentLoopImpl(
       turnCronRunId,
     );
 
-    const syncLastAssistantMessageToDisk = (): void => {
-      if (!state.lastAssistantMessageId) return;
-      const convForDisk = getConversation(ctx.conversationId);
-      if (!convForDisk) return;
-      syncMessageToDisk(
-        ctx.conversationId,
-        state.lastAssistantMessageId,
-        convForDisk.createdAt,
-      );
-    };
     // Fast-path: when the user cancelled, skip expensive post-loop work
     // (attachment resolution) and emit the cancellation event immediately
-    // so the client can re-enable the UI without delay.
+    // so the client can re-enable the UI without delay. Disk sync and the rest
+    // of the bookkeeping run in `runDeferredTurnTail` after this SSE.
     if (abortController.signal.aborted) {
-      syncLastAssistantMessageToDisk();
       ctx.emitActivityState("idle", "generation_cancelled", {
         anchor: "global",
         requestId: reqId,
@@ -1403,7 +1391,6 @@ export async function runAgentLoopImpl(
 
       ctx.lastAssistantAttachments = assistantAttachments;
       ctx.lastAttachmentWarnings = attachmentResult.directiveWarnings;
-      syncLastAssistantMessageToDisk();
 
       // Re-check: the user may have cancelled during attachment resolution
       if (abortController.signal.aborted) {
@@ -1484,6 +1471,12 @@ export async function runAgentLoopImpl(
         publishLoopMessagesChanged();
       }
     }
+
+    // The terminal SSE for this turn has now been emitted (message_complete,
+    // generation_handoff, or generation_cancelled), so the composer is already
+    // re-enabling. Drain the deferred bookkeeping now — after the SSE, before
+    // the `finally` commits and drains the queue for the next turn.
+    await runDeferredTurnTail({ ctx, state, rlog, generationCompletedAt });
   } catch (err) {
     clearConversationNotices(ctx.conversationId);
     const errorCtx = {

package/src/daemon/conversation-error.ts

@@ -156,7 +156,7 @@ const CANCEL_PATTERNS = [/abort/i, /cancel/i];
  */
 export interface ErrorContext {
   /** Where in the processing pipeline the error occurred. */
-  phase: "agent_loop" | "regenerate" | "handler" | "persist";
+  phase: "agent_loop" | "handler" | "persist";
   /** Whether the abort signal was active when the error occurred. */
   aborted?: boolean;
   /**
@@ -266,20 +266,6 @@ export function classifyConversationError(
     };
   }
 
-  // Phase-specific overrides
-  if (ctx.phase === "regenerate") {
-    const base = classifyCore(error, message, attribution);
-    return {
-      code: "REGENERATE_FAILED",
-      userMessage: `Could not regenerate the response. ${base.userMessage}`,
-      retryable: true,
-      debugDetails,
-      errorCategory: `regenerate:${base.errorCategory}`,
-      ...(base.connectionName ? { connectionName: base.connectionName } : {}),
-      ...(base.profileName ? { profileName: base.profileName } : {}),
-    };
-  }
-
   // Classify using statusCode (if ProviderError) then regex fallback
   const classified = classifyCore(error, message, attribution);
   return {

package/src/daemon/conversation-history.ts

@@ -1,5 +1,3 @@
-import { v4 as uuid } from "uuid";
-
 import {
   deleteLastExchange,
   deleteMessageById,
@@ -10,14 +8,12 @@ import {
 import { isLastUserMessageToolResult } from "../persistence/conversation-queries.js";
 import { withQdrantBreaker } from "../persistence/embeddings/qdrant-circuit-breaker.js";
 import { getQdrantClient } from "../persistence/embeddings/qdrant-client.js";
+import { enqueueLexicalIndexForMessage } from "../persistence/job-handlers/message-lexical.js";
 import { enqueueMemoryJob } from "../persistence/jobs-store.js";
 import { relinkLlmRequestLogs } from "../persistence/llm-request-log-store.js";
 import { getSummaryFromContextMessage } from "../plugins/defaults/compaction/window-manager.js";
 import type { ContentBlock, Message } from "../providers/types.js";
 import { getLogger } from "../util/logger.js";
-import { truncate } from "../util/truncate.js";
-import type { ServerMessage } from "./message-protocol.js";
-import type { TraceEmitter } from "./trace-emitter.js";
 
 const log = getLogger("conversation-history");
 
@@ -34,7 +30,9 @@ export function isToolResultBlock(
 function isSystemNoticeBlock(
   block: ContentBlock | Record<string, unknown>,
 ): boolean {
-  if (block.type !== "text") return false;
+  if (block.type !== "text") {
+    return false;
+  }
   const text = (block as { text?: string }).text ?? "";
   return (
     text.startsWith("<system_notice>") && text.endsWith("</system_notice>")
@@ -42,8 +40,12 @@ function isSystemNoticeBlock(
 }
 
 function isUndoableUserMessage(message: Message): boolean {
-  if (message.role !== "user") return false;
-  if (getSummaryFromContextMessage(message) != null) return false;
+  if (message.role !== "user") {
+    return false;
+  }
+  if (getSummaryFromContextMessage(message) != null) {
+    return false;
+  }
   // A user message is undoable if it contains user-authored content (non-tool_result
   // blocks). Messages that contain ONLY tool_result blocks (e.g. automated tool
   // responses) are not undoable. Messages that have both tool_result and text blocks
@@ -53,7 +55,9 @@ function isUndoableUserMessage(message: Message): boolean {
   const hasNonToolResultContent = message.content.some(
     (block) => !isToolResultBlock(block) && !isSystemNoticeBlock(block),
   );
-  if (!hasNonToolResultContent) return false;
+  if (!hasNonToolResultContent) {
+    return false;
+  }
   return true;
 }
 
@@ -84,7 +88,9 @@ async function cleanupQdrantVectors(
     return; // Qdrant not initialized — nothing to clean up.
   }
 
-  if (segmentIds.length === 0) return;
+  if (segmentIds.length === 0) {
+    return;
+  }
 
   const targets: Array<{ targetType: string; targetId: string }> = [];
   for (const segId of segmentIds) {
@@ -122,7 +128,7 @@ async function cleanupQdrantVectors(
         failed,
         segments: segmentIds.length,
       },
-      "Cleaned up Qdrant vectors after regenerate",
+      "Cleaned up Qdrant vectors after undo",
     );
   }
 }
@@ -142,7 +148,9 @@ export function consolidateAssistantMessages(
 ): boolean {
   const allMessages = getMessages(conversationId);
   const userMsgIndex = allMessages.findIndex((m) => m.id === userMessageId);
-  if (userMsgIndex === -1) return false;
+  if (userMsgIndex === -1) {
+    return false;
+  }
 
   const messagesToConsolidate: typeof allMessages = [];
   const internalToolResultMessages: typeof allMessages = [];
@@ -285,6 +293,11 @@ export function consolidateAssistantMessages(
     firstAssistantMsg.id,
     JSON.stringify(consolidatedContent),
   );
+  // Consolidation changed the retained message's searchable text (merged in the
+  // other rows' blocks); `updateMessageContent` is CRUD-only, so reindex it into
+  // the lexical index. The merged-away rows' points are removed by
+  // `deleteMessageById` below.
+  enqueueLexicalIndexForMessage(firstAssistantMsg.id);
 
   // Re-link attachments and LLM request logs from messages about to be
   // deleted to the consolidated message. Without this, ON DELETE CASCADE on
@@ -345,26 +358,12 @@ export function consolidateAssistantMessages(
 // ── Undo ─────────────────────────────────────────────────────────────
 
 /**
- * Subset of Conversation state that undo/regenerate need access to.
+ * Subset of Conversation state that undo needs access to.
  */
 export interface HistoryConversationContext {
   readonly conversationId: string;
-  readonly traceEmitter: TraceEmitter;
-  /** @internal */ sendToClient: (msg: ServerMessage) => void;
   messages: Message[];
   isProcessing(): boolean;
-  setProcessing(value: boolean): void;
-  abortController: AbortController | null;
-  currentRequestId?: string;
-  runAgentLoop(
-    content: string,
-    userMessageId: string,
-    options?: {
-      onEvent?: (msg: ServerMessage) => void;
-      isUserMessage?: boolean;
-      titleText?: string;
-    },
-  ): Promise<void>;
 }
 
 /**
@@ -372,10 +371,14 @@ export interface HistoryConversationContext {
  * Returns the number of messages removed.
  */
 export function undo(conversation: HistoryConversationContext): number {
-  if (conversation.isProcessing()) return 0;
+  if (conversation.isProcessing()) {
+    return 0;
+  }
 
   const lastUserIdx = findLastUndoableUserMessageIndex(conversation.messages);
-  if (lastUserIdx === -1) return 0;
+  if (lastUserIdx === -1) {
+    return 0;
+  }
 
   const removed = conversation.messages.length - lastUserIdx;
   conversation.messages = conversation.messages.slice(0, lastUserIdx);
@@ -406,210 +409,3 @@ export function undo(conversation: HistoryConversationContext): number {
 
   return removed;
 }
-
-// ── Regenerate ───────────────────────────────────────────────────────
-
-/**
- * Regenerate the last assistant response: remove the assistant's reply
- * (and any intermediate tool_result messages) from memory, DB, and
- * Qdrant, then re-run the agent loop with the same user message.
- */
-export async function regenerate(
-  conversation: HistoryConversationContext,
-  requestId?: string,
-): Promise<void> {
-  if (conversation.isProcessing()) {
-    conversation.sendToClient({
-      type: "error",
-      conversationId: conversation.conversationId,
-      message: "Cannot regenerate while processing",
-    });
-    if (requestId) {
-      conversation.traceEmitter.emit(
-        "request_error",
-        "Cannot regenerate while processing",
-        {
-          requestId,
-          status: "error",
-          attributes: { reason: "already_processing" },
-        },
-      );
-    }
-    return;
-  }
-
-  // Find the last undoable user message — everything after it is the
-  // assistant's exchange that we want to regenerate.
-  const lastUserIdx = findLastUndoableUserMessageIndex(conversation.messages);
-  if (lastUserIdx === -1) {
-    conversation.sendToClient({
-      type: "error",
-      conversationId: conversation.conversationId,
-      message: "No messages to regenerate",
-    });
-    if (requestId) {
-      conversation.traceEmitter.emit(
-        "request_error",
-        "No messages to regenerate",
-        {
-          requestId,
-          status: "error",
-          attributes: { reason: "no_messages" },
-        },
-      );
-    }
-    return;
-  }
-
-  // There must be at least one message after the user message (the assistant reply).
-  if (lastUserIdx >= conversation.messages.length - 1) {
-    conversation.sendToClient({
-      type: "error",
-      conversationId: conversation.conversationId,
-      message: "No assistant response to regenerate",
-    });
-    if (requestId) {
-      conversation.traceEmitter.emit(
-        "request_error",
-        "No assistant response to regenerate",
-        {
-          requestId,
-          status: "error",
-          attributes: { reason: "no_assistant_response" },
-        },
-      );
-    }
-    return;
-  }
-
-  // Remove the assistant's exchange from in-memory history (keep the user message).
-  conversation.messages = conversation.messages.slice(0, lastUserIdx + 1);
-
-  // Find DB message IDs to delete: get all messages from the DB, then
-  // identify the ones that come after the last user message.
-  const dbMessages = getMessages(conversation.conversationId);
-
-  // Walk backwards to find the last real (non-tool_result) user message in the DB.
-  let dbUserMsgIdx = -1;
-  for (let i = dbMessages.length - 1; i >= 0; i--) {
-    if (dbMessages[i].role !== "user") continue;
-    try {
-      const parsed = JSON.parse(dbMessages[i].content);
-      if (
-        Array.isArray(parsed) &&
-        parsed.length > 0 &&
-        parsed.every((b: Record<string, unknown>) => isToolResultBlock(b))
-      ) {
-        continue; // Skip tool_result-only user messages
-      }
-    } catch {
-      /* plain text = real user message */
-    }
-    dbUserMsgIdx = i;
-    break;
-  }
-
-  if (dbUserMsgIdx === -1) {
-    conversation.sendToClient({
-      type: "error",
-      conversationId: conversation.conversationId,
-      message: "No user message found in DB",
-    });
-    if (requestId) {
-      conversation.traceEmitter.emit(
-        "request_error",
-        "No user message found in DB",
-        {
-          requestId,
-          status: "error",
-          attributes: { reason: "no_db_user_message" },
-        },
-      );
-    }
-    return;
-  }
-
-  // Capture the existing DB user message ID so we can pass it to
-  // runAgentLoop without re-persisting the user message.
-  const existingUserMessageId = dbMessages[dbUserMsgIdx].id;
-
-  // Everything after the user message needs to be deleted.
-  const messagesToDelete = dbMessages.slice(dbUserMsgIdx + 1);
-
-  // Delete each message via deleteMessageById and collect IDs for Qdrant cleanup.
-  const allSegmentIds: string[] = [];
-  for (const msg of messagesToDelete) {
-    const deleted = deleteMessageById(msg.id);
-    allSegmentIds.push(...deleted.segmentIds);
-  }
-
-  // Clean up Qdrant vectors (fire-and-forget).
-  cleanupQdrantVectors(conversation.conversationId, allSegmentIds).catch(
-    (err) => {
-      log.warn(
-        { err, conversationId: conversation.conversationId },
-        "Qdrant cleanup after regenerate failed (non-fatal)",
-      );
-    },
-  );
-
-  // Re-extract the user message content for the agent loop.
-  // Use all content blocks (text, image, file) so attachments are
-  // preserved — not just text blocks.
-  const userMessage = conversation.messages[lastUserIdx];
-  const textBlocks = userMessage.content.filter((b) => b.type === "text");
-  const content = textBlocks
-    .map((b) => (b as { type: "text"; text: string }).text)
-    .join("");
-
-  // Notify client that the old response has been removed.
-  conversation.sendToClient({
-    type: "undo_complete",
-    removedCount: messagesToDelete.length,
-    conversationId: conversation.conversationId,
-  });
-
-  // Set up processing state manually and call runAgentLoop directly,
-  // bypassing processMessage to avoid duplicating the user message
-  // in both this.messages and the DB.
-  conversation.setProcessing(true);
-  conversation.abortController = new AbortController();
-  const resolvedRequestId = requestId ?? uuid();
-  conversation.currentRequestId = resolvedRequestId;
-
-  // Fire-and-forget: matches the /v1/messages pattern so the HTTP handler
-  // returns 202 immediately rather than blocking on the full agent turn.
-  // Otherwise the client's 15s POST timeout fires on any non-trivial
-  // regenerate and surfaces a misleading "Failed to regenerate message"
-  // banner even though the response streams in normally via SSE.
-  //
-  // runAgentLoop catches most errors internally and emits `request_error`
-  // itself, but anything thrown from its `finally` block (commit, drain,
-  // profiler) would otherwise escape silently because the caller does
-  // not await the agent loop. Emit a structured trace event so the
-  // observability contract is preserved on those paths too.
-  void conversation
-    .runAgentLoop(content, existingUserMessageId, {
-      isUserMessage: true,
-    })
-    .catch((err) => {
-      const message = err instanceof Error ? err.message : String(err);
-      log.error(
-        { err, conversationId: conversation.conversationId },
-        "runAgentLoop after regenerate failed",
-      );
-      conversation.traceEmitter.emit(
-        "request_error",
-        truncate(message, 200, ""),
-        {
-          requestId: resolvedRequestId,
-          status: "error",
-          attributes: {
-            errorClass: err instanceof Error ? err.constructor.name : "Error",
-            message: truncate(message, 500, ""),
-            source: "regenerate_fire_and_forget",
-          },
-        },
-      );
-    });
-}