@vellumai/assistant 0.6.2 → 0.6.4

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

@@ -22,10 +22,16 @@ import type {
   TurnChannelContext,
   TurnInterfaceContext,
 } from "../channels/types.js";
+import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
 import { getConfig } from "../config/loader.js";
+import {
+  derefToolResultReReads,
+  postTurnTruncateToolResults,
+} from "../context/post-turn-tool-result-truncation.js";
 import { estimatePromptTokens } from "../context/token-estimator.js";
 import type { ContextWindowManager } from "../context/window-manager.js";
 import type { ToolProfiler } from "../events/tool-profiling-listener.js";
+import { writeRelationshipState } from "../home/relationship-state-writer.js";
 import { getHookManager } from "../hooks/manager.js";
 import {
   clearSentryConversationContext,
@@ -33,17 +39,21 @@ import {
 } from "../instrument.js";
 import { commitAppTurnChanges } from "../memory/app-git-service.js";
 import { getApp, listAppFiles, resolveAppDir } from "../memory/app-store.js";
+import { enqueueAutoAnalysisOnCompaction } from "../memory/auto-analysis-enqueue.js";
 import {
   addMessage,
   deleteMessageById,
   getConversation,
   getConversationOriginChannel,
   getConversationOriginInterface,
+  getLastUserTimestampBefore,
+  getMessageById,
   provenanceFromTrustContext,
   updateConversationContextWindow,
   updateConversationTitle,
   updateMessageMetadata,
 } from "../memory/conversation-crud.js";
+import { getResolvedConversationDirPath } from "../memory/conversation-directories.js";
 import { syncMessageToDisk } from "../memory/conversation-disk-view.js";
 import {
   isReplaceableTitle,
@@ -58,8 +68,10 @@ import type { ContentBlock, Message } from "../providers/types.js";
 import type { Provider } from "../providers/types.js";
 import { resolveActorTrust } from "../runtime/actor-trust-resolver.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
+import { getSubagentManager } from "../subagent/index.js";
 import type { UsageActor } from "../usage/actors.js";
 import { getLogger } from "../util/logger.js";
+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";
@@ -100,9 +112,9 @@ import type {
 } from "./conversation-runtime-assembly.js";
 import {
   applyRuntimeInjections,
+  buildSubagentStatusBlock,
   buildUnifiedTurnContextBlock,
   findLastInjectedNowContent,
-  findLastInjectedPkbContent,
   inboundActorContextFromTrust,
   inboundActorContextFromTrustContext,
   readNowScratchpad,
@@ -230,6 +242,7 @@ export interface AgentLoopConversationContext {
     data: SurfaceData;
     actions?: Array<{ id: string; label: string; style?: string }>;
     display?: string;
+    persistent?: boolean;
   }>;
 
   workingDir: string;
@@ -242,6 +255,8 @@ export interface AgentLoopConversationContext {
   currentTurnChannelCapabilities?: ChannelCapabilities;
   commandIntent?: { type: string; payload?: string; languageCode?: string };
   trustContext?: TrustContext;
+  /** Task-run scope for the current turn. Cleared at turn end so queued/drained turns don't inherit it. */
+  taskRunId?: string;
   assistantId?: string;
   voiceCallControlPrompt?: string;
   transportHints?: string[];
@@ -262,6 +277,8 @@ export interface AgentLoopConversationContext {
   lastAttachmentWarnings: string[];
 
   hasNoClient: boolean;
+  /** True when this conversation is itself a subagent (suppresses subagent status injection). */
+  isSubagent?: boolean;
   headlessLock?: boolean;
   readonly streamThinking: boolean;
   readonly prompter: PermissionPrompter;
@@ -504,6 +521,7 @@ export async function runAgentLoopImpl(
 
     const isFirstMessage = ctx.messages.length === 1;
     let shouldInjectWorkspace = isFirstMessage;
+    let compactedThisTurn = false;
 
     const compactCheck = ctx.contextWindowManager.shouldCompact(ctx.messages);
     if (compactCheck.needed) {
@@ -534,6 +552,13 @@ export async function runAgentLoopImpl(
         compacted.summaryText,
         ctx.contextCompactedMessageCount,
       );
+      // Fire auto-analysis on compaction so the reflective agent can
+      // crystallize anything worth remembering before the context window
+      // narrows further.
+      enqueueAutoAnalysisOnCompaction(
+        ctx.conversationId,
+        ctx.trustContext?.trustClass,
+      );
       onEvent({
         type: "context_compacted",
         previousEstimatedInputTokens: compacted.previousEstimatedInputTokens,
@@ -559,6 +584,9 @@ export async function runAgentLoopImpl(
         collapseRawResponses(compacted.summaryRawResponses),
       );
       shouldInjectWorkspace = true;
+      if (compacted.compactedPersistedMessages > 0) {
+        compactedThisTurn = true;
+      }
     }
 
     const state = createEventHandlerState();
@@ -763,14 +791,35 @@ export async function runAgentLoopImpl(
     const isGuardian =
       resolvedInboundActorContext?.trustClass === "guardian" ||
       !resolvedInboundActorContext;
+
+    // Surface long gaps between user messages so the model can acknowledge
+    // the absence naturally. Gated at >12h to avoid noisy injection during
+    // normal back-and-forth turns.
+    const TWELVE_HOURS_MS = 12 * 60 * 60 * 1000;
+    let timeSinceLastMessage: string | null = null;
+    const currentUserMessage = getMessageById(userMessageId);
+    if (currentUserMessage) {
+      const prevUserTs = getLastUserTimestampBefore(
+        ctx.conversationId,
+        currentUserMessage.createdAt,
+      );
+      if (
+        prevUserTs > 0 &&
+        currentUserMessage.createdAt - prevUserTs > TWELVE_HOURS_MS
+      ) {
+        timeSinceLastMessage = timeAgo(prevUserTs);
+      }
+    }
+
     const unifiedTurnContextStr = buildUnifiedTurnContextBlock(
       isGuardian
-        ? { timestamp, interfaceName, channelName }
+        ? { timestamp, interfaceName, channelName, timeSinceLastMessage }
         : {
             timestamp,
             interfaceName,
             channelName,
             actorContext: resolvedInboundActorContext,
+            timeSinceLastMessage,
           },
     );
 
@@ -779,24 +828,24 @@ export async function runAgentLoopImpl(
     const isInteractiveResolved =
       options?.isInteractive ?? (!ctx.hasNoClient && !ctx.headlessLock);
 
-    // Only inject NOW.md if it changed since the last injection in the
-    // conversation.  Keeping the previous injection in place avoids mutating
-    // historical user messages and preserves the cached prefix.
+    // Inject NOW.md and PKB content only on the first turn (or after
+    // compaction re-strips them).  Old injections persist in history and
+    // are never stripped on normal turns — this preserves the cached prefix.
     const currentNowContent = readNowScratchpad();
-    const lastInjectedNow = findLastInjectedNowContent(ctx.messages);
-    const nowScratchpad =
-      currentNowContent !== lastInjectedNow ? currentNowContent : null;
-
-    // Only inject PKB if it changed since the last injection in the
-    // conversation.  Keeping the previous injection in place avoids mutating
-    // historical user messages and preserves the cached prefix.
-    // Note: injectPkbContext escapes </pkb> sequences before writing to history,
-    // so we must apply the same escaping before comparing to avoid false mismatches.
+    const shouldInjectNowAndPkb = isFirstMessage || compactedThisTurn;
+    const nowScratchpad = shouldInjectNowAndPkb ? currentNowContent : null;
+
     const currentPkbContent = readPkbContext();
-    const lastInjectedPkb = findLastInjectedPkbContent(ctx.messages);
-    const escapedCurrentPkb = currentPkbContent?.replace(/<\/pkb\s*>/gi, "&lt;/pkb&gt;") ?? null;
-    const pkbContext =
-      escapedCurrentPkb !== lastInjectedPkb ? currentPkbContent : null;
+    const pkbContext = shouldInjectNowAndPkb ? currentPkbContent : null;
+    const pkbActive = currentPkbContent !== null;
+
+    // Subagent status injection — gives the parent LLM visibility into active/completed children.
+    // Skipped when this conversation IS a subagent (no nesting) or has no children.
+    const subagentStatusBlock = ctx.isSubagent
+      ? null
+      : buildSubagentStatusBlock(
+          getSubagentManager().getChildrenOf(ctx.conversationId),
+        );
 
     // Shared injection options — reused whenever we need to re-inject after reduction.
     const injectionOpts = {
@@ -808,10 +857,12 @@ export async function runAgentLoopImpl(
       channelCommandContext: ctx.commandIntent ?? null,
       unifiedTurnContext: unifiedTurnContextStr,
       pkbContext,
+      pkbActive,
       nowScratchpad,
       voiceCallControlPrompt: ctx.voiceCallControlPrompt ?? null,
       transportHints: ctx.transportHints ?? null,
       isNonInteractive: !isInteractiveResolved,
+      subagentStatusBlock,
     } as const;
 
     let currentInjectionMode: InjectionMode = "full";
@@ -896,6 +947,11 @@ export async function runAgentLoopImpl(
             step.compactionResult.summaryText,
             ctx.contextCompactedMessageCount,
           );
+          // Fire auto-analysis on compaction — see forceCompact() for rationale.
+          enqueueAutoAnalysisOnCompaction(
+            ctx.conversationId,
+            ctx.trustContext?.trustClass,
+          );
           onEvent({
             type: "context_compacted",
             previousEstimatedInputTokens:
@@ -933,8 +989,12 @@ export async function runAgentLoopImpl(
         // value from injectionOpts to avoid duplicate injection.
         runMessages = applyRuntimeInjections(ctx.messages, {
           ...injectionOpts,
-          ...(step.compactionResult?.compacted && { pkbContext: currentPkbContent }),
-          ...(step.compactionResult?.compacted && { nowScratchpad: currentNowContent }),
+          ...(step.compactionResult?.compacted && {
+            pkbContext: currentPkbContent,
+          }),
+          ...(step.compactionResult?.compacted && {
+            nowScratchpad: currentNowContent,
+          }),
           workspaceTopLevelContext: shouldInjectWorkspace
             ? ctx.workspaceTopLevelContext
             : null,
@@ -1096,6 +1156,11 @@ export async function runAgentLoopImpl(
           midLoopCompact.summaryText,
           ctx.contextCompactedMessageCount,
         );
+        // Fire auto-analysis on compaction — see forceCompact() for rationale.
+        enqueueAutoAnalysisOnCompaction(
+          ctx.conversationId,
+          ctx.trustContext?.trustClass,
+        );
         onEvent({
           type: "context_compacted",
           previousEstimatedInputTokens:
@@ -1139,8 +1204,7 @@ export async function runAgentLoopImpl(
         mode: currentInjectionMode,
       });
       if (isTrustedActor && currentInjectionMode !== "minimal") {
-        const memResult = ctx.graphMemory.reinjectCachedMemory(runMessages);
-        runMessages = memResult.runMessages;
+        ctx.graphMemory.retrackCachedNodes();
       }
       preRepairMessages = runMessages;
       preRunHistoryLength = runMessages.length;
@@ -1213,12 +1277,12 @@ export async function runAgentLoopImpl(
     // limit), incorporate those new messages into ctx.messages so the
     // convergence loop operates on the full (larger) history.
     if (state.contextTooLargeDetected) {
-      // Track whether ctx.messages was actually stripped so we know if
-      // NOW.md (and other injections) need to be re-injected.  When the
-      // provider rejects before adding any messages, the strip is skipped
-      // and ctx.messages still contains the previous injection — blindly
-      // re-injecting would duplicate the NOW.md block.
-      let convergenceStripped = false;
+      // Detect whether ctx.messages currently lacks NOW.md so we know if
+      // it needs to be re-injected.  Mid-loop compaction (line ~1067) may
+      // have already stripped injections before escalating here, so we
+      // check actual message state rather than tracking mutation sites.
+      let convergenceStripped =
+        findLastInjectedNowContent(ctx.messages) === null;
 
       if (updatedHistory.length > preRunHistoryLength) {
         ctx.messages = stripInjectionsForCompaction(updatedHistory);
@@ -1314,6 +1378,11 @@ export async function runAgentLoopImpl(
             step.compactionResult.summaryText,
             ctx.contextCompactedMessageCount,
           );
+          // Fire auto-analysis on compaction — see forceCompact() for rationale.
+          enqueueAutoAnalysisOnCompaction(
+            ctx.conversationId,
+            ctx.trustContext?.trustClass,
+          );
           onEvent({
             type: "context_compacted",
             previousEstimatedInputTokens:
@@ -1358,8 +1427,7 @@ export async function runAgentLoopImpl(
           mode: currentInjectionMode,
         });
         if (isTrustedActor && currentInjectionMode !== "minimal") {
-          const memResult = ctx.graphMemory.reinjectCachedMemory(runMessages);
-          runMessages = memResult.runMessages;
+          ctx.graphMemory.retrackCachedNodes();
         }
         preRepairMessages = runMessages;
         preRunHistoryLength = runMessages.length;
@@ -1438,6 +1506,11 @@ export async function runAgentLoopImpl(
                 emergencyCompact.summaryText,
                 ctx.contextCompactedMessageCount,
               );
+              // Fire auto-analysis on compaction — see forceCompact() for rationale.
+              enqueueAutoAnalysisOnCompaction(
+                ctx.conversationId,
+                ctx.trustContext?.trustClass,
+              );
               onEvent({
                 type: "context_compacted",
                 previousEstimatedInputTokens:
@@ -1481,9 +1554,7 @@ export async function runAgentLoopImpl(
               mode: currentInjectionMode,
             });
             if (isTrustedActor && currentInjectionMode !== "minimal") {
-              const memResult =
-                ctx.graphMemory.reinjectCachedMemory(runMessages);
-              runMessages = memResult.runMessages;
+              ctx.graphMemory.retrackCachedNodes();
             }
             preRepairMessages = runMessages;
             preRunHistoryLength = runMessages.length;
@@ -1558,6 +1629,11 @@ export async function runAgentLoopImpl(
               emergencyCompact.summaryText,
               ctx.contextCompactedMessageCount,
             );
+            // Fire auto-analysis on compaction — see forceCompact() for rationale.
+            enqueueAutoAnalysisOnCompaction(
+              ctx.conversationId,
+              ctx.trustContext?.trustClass,
+            );
             onEvent({
               type: "context_compacted",
               previousEstimatedInputTokens:
@@ -1601,8 +1677,7 @@ export async function runAgentLoopImpl(
             mode: currentInjectionMode,
           });
           if (isTrustedActor && currentInjectionMode !== "minimal") {
-            const memResult = ctx.graphMemory.reinjectCachedMemory(runMessages);
-            runMessages = memResult.runMessages;
+            ctx.graphMemory.retrackCachedNodes();
           }
           preRepairMessages = runMessages;
           preRunHistoryLength = runMessages.length;
@@ -1733,13 +1808,39 @@ export async function runAgentLoopImpl(
       // would create a duplicate plain-text bubble below the alert card.
     }
 
-    const restoredHistory = [...preRepairMessages, ...newMessages];
+    let restoredHistory = [...preRepairMessages, ...newMessages];
 
-    const postLoopContextEstimate = estimatePromptTokens(
-      restoredHistory,
-      ctx.systemPrompt,
-      { providerName: ctx.provider.name, toolTokenBudget },
-    );
+    // Post-turn tool result truncation: save large results to disk and
+    // replace in-context content with a prefix/suffix stub + file pointer.
+    if (isAssistantFeatureFlagEnabled("tool-result-truncation", config)) {
+      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)",
+        );
+      }
+    }
 
     // Persist injections in history: runtime-injected context stays on
     // historical user messages so the conversation prefix is stable for
@@ -1761,7 +1862,7 @@ export async function runAgentLoopImpl(
       state.exchangeProviderName,
       state.exchangeLlmCallCount,
       {
-        tokens: postLoopContextEstimate,
+        tokens: state.lastCallInputTokens,
         maxTokens: config.contextWindow.maxInputTokens,
       },
     );
@@ -1980,6 +2081,12 @@ export async function runAgentLoopImpl(
 
       // Commit app changes (fire-and-forget — apps repo is separate from workspace)
       void commitAppTurnChanges(ctx.conversationId, ctx.turnCount);
+
+      // Recompute relationship-state.json at turn boundary (fire-and-forget).
+      // The writer swallows its own errors, but we still guard with catch()
+      // here so a regression in the writer can never bubble out of the
+      // agent loop and reject an otherwise-complete turn.
+      void writeRelationshipState().catch(() => {});
     }
 
     ctx.profiler.emitSummary(ctx.traceEmitter, reqId);
@@ -1995,6 +2102,10 @@ export async function runAgentLoopImpl(
     // Channel command intents (e.g. Telegram /start) are single-turn metadata.
     // Clear at turn end so they never leak into subsequent unrelated messages.
     ctx.commandIntent = undefined;
+    // taskRunId scopes ephemeral task-run permissions to a single turn. Clear
+    // before drainQueue so queued/drained turns on a reused conversation can't
+    // inherit stale in-task-run scope from the turn that just finished.
+    ctx.taskRunId = undefined;
 
     // Consolidation deferred to compaction: keeping assistant + tool_result
     // messages unconsolidated preserves the exact message structure sent to

package/src/daemon/conversation-attachments.ts

@@ -13,6 +13,11 @@ import {
 import type { PermissionPrompter } from "../permissions/prompter.js";
 import { addRule } from "../permissions/trust-store.js";
 import { isAllowDecision } from "../permissions/types.js";
+import {
+  CONVERSATION_HOST_ACCESS_PROMPT,
+  isConversationHostAccessEnabled,
+  isPermissionControlsV2Enabled,
+} from "../permissions/v2-consent-policy.js";
 import type { ContentBlock } from "../providers/types.js";
 import { getLogger } from "../util/logger.js";
 import {
@@ -45,6 +50,41 @@ export async function approveHostAttachmentRead(
 ): Promise<boolean> {
   const toolName = "host_file_read";
   const input = { path: filePath };
+
+  if (isPermissionControlsV2Enabled()) {
+    if (isConversationHostAccessEnabled(conversationId)) {
+      return true;
+    }
+
+    // HTTP-created sessions use a no-op sendToClient — prompting would
+    // block for the full permission timeout before auto-denying.
+    if (hasNoClient) {
+      log.info(
+        { filePath },
+        "Denying host attachment read: no interactive client connected",
+      );
+      return false;
+    }
+
+    const response = await prompter.prompt(
+      toolName,
+      input,
+      "low",
+      CONVERSATION_HOST_ACCESS_PROMPT.allowlistOptions,
+      CONVERSATION_HOST_ACCESS_PROMPT.scopeOptions,
+      undefined,
+      conversationId,
+      "host",
+      CONVERSATION_HOST_ACCESS_PROMPT.persistentDecisionsAllowed,
+      undefined,
+      CONVERSATION_HOST_ACCESS_PROMPT.temporaryOptionsAvailable,
+      undefined,
+      true,
+    );
+
+    return response.decision === "allow";
+  }
+
   const decision = await check(toolName, input, workingDir);
 
   if (decision.decision === "allow") {

package/src/daemon/conversation-error.ts

@@ -1,4 +1,5 @@
 import { getProviderRoutingSource } from "../providers/registry.js";
+import { isAbortReason } from "../util/abort-reasons.js";
 import { ProviderError, ProviderNotConfiguredError } from "../util/errors.js";
 import type {
   ConversationErrorCode,
@@ -110,11 +111,21 @@ export interface ErrorContext {
  * Returns true if the error looks like a user-initiated cancellation
  * (AbortError or explicit cancel). These should use `generation_cancelled`
  * instead of `conversation_error`.
+ *
+ * Provider SDKs wrap the underlying AbortError in their own error class
+ * (e.g. `ProviderError("Anthropic API error (undefined): Request was aborted.")`),
+ * which erases the `AbortError` name. To compensate, the daemon tags every
+ * `controller.abort(reason)` call with an `AbortReason` object — when the
+ * wrapped `ProviderError` carries that tagged reason, we treat it as a user
+ * cancellation regardless of error class.
  */
 export function isUserCancellation(error: unknown, ctx: ErrorContext): boolean {
   if (!ctx.aborted) return false;
   if (error instanceof DOMException && error.name === "AbortError") return true;
   if (error instanceof Error && error.name === "AbortError") return true;
+  if (error instanceof ProviderError && isAbortReason(error.abortReason)) {
+    return true;
+  }
   return false;
 }
 

package/src/daemon/conversation-history.ts

@@ -15,6 +15,7 @@ import { withQdrantBreaker } from "../memory/qdrant-circuit-breaker.js";
 import { getQdrantClient } from "../memory/qdrant-client.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";
 
@@ -564,10 +565,43 @@ export async function regenerate(
   // in both this.messages and the DB.
   conversation.processing = true;
   conversation.abortController = new AbortController();
-  conversation.currentRequestId = requestId ?? uuid();
-
-  await conversation.runAgentLoop(content, existingUserMessageId, onEvent, {
-    skipPreMessageRollback: true,
-    isUserMessage: true,
-  });
+  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, onEvent, {
+      skipPreMessageRollback: true,
+      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",
+          },
+        },
+      );
+    });
 }