@vellumai/assistant 0.7.2 → 0.8.0

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

@@ -73,7 +73,10 @@ import type { ConversationGraphMemory } from "../memory/graph/conversation-graph
 import { recordMemoryRecallLog } from "../memory/memory-recall-log-store.js";
 import { PKB_WORKSPACE_SCOPE } from "../memory/pkb/types.js";
 import type { QdrantSparseVector } from "../memory/qdrant-client.js";
-import { readMemoryV2StaticContent } from "../memory/v2/static-context.js";
+import {
+  readMemoryV2StaticContent,
+  shouldLoadMemoryV2Static,
+} from "../memory/v2/static-context.js";
 import type { PermissionPrompter } from "../permissions/prompter.js";
 import { defaultCompactionTerminal } from "../plugins/defaults/compaction.js";
 import { defaultHistoryRepairTerminal } from "../plugins/defaults/history-repair.js";
@@ -106,6 +109,11 @@ import type {
   TurnContext as PluginTurnContext,
 } from "../plugins/types.js";
 import { PluginExecutionError, PluginTimeoutError } from "../plugins/types.js";
+import {
+  hasProactiveArtifactCompleted,
+  runProactiveArtifactJob,
+  tryClaimProactiveArtifactTrigger,
+} from "../proactive-artifact/index.js";
 import type {
   ContentBlock,
   Message,
@@ -113,6 +121,7 @@ import type {
 } from "../providers/types.js";
 import type { Provider } from "../providers/types.js";
 import { resolveActorTrust } from "../runtime/actor-trust-resolver.js";
+import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
 import { redactSecrets } from "../security/secret-scanner.js";
 import { getSubagentManager } from "../subagent/index.js";
@@ -175,7 +184,12 @@ import type { SkillProjectionCache } from "./conversation-skill-tools.js";
 import { markSurfaceCompleted } from "./conversation-surfaces.js";
 import { resolveTrustClass } from "./conversation-tool-setup.js";
 import { recordUsage } from "./conversation-usage.js";
-import { formatTurnTimestamp } from "./date-context.js";
+import {
+  formatTurnTimestamp,
+  resolveTurnTimezoneContext,
+} from "./date-context.js";
+import { getDiskPressureStatus } from "./disk-pressure-guard.js";
+import { classifyDiskPressureTurnPolicy } from "./disk-pressure-policy.js";
 import { deepRepairHistory } from "./history-repair.js";
 import type {
   DynamicPageSurfaceData,
@@ -192,6 +206,8 @@ import type { TrustContext } from "./trust-context.js";
 import { stripHistoricalWebSearchResults } from "./web-search-history.js";
 
 const log = getLogger("conversation-agent-loop");
+const DISK_PRESSURE_ERROR_CODE = "DISK_SPACE_CRITICAL" as const;
+const DISK_PRESSURE_ERROR_CATEGORY = "disk_pressure";
 
 /** Title-cased friendly labels for tool names, used in confirmation chips. */
 const TOOL_FRIENDLY_LABEL: Record<string, string> = {
@@ -211,6 +227,10 @@ type GitServiceInitializer = {
   ensureInitialized(): Promise<void>;
 };
 
+function formatDiskPressureBlockedMessage(): string {
+  return "Storage is critically low, so background processes are paused and remote messages are ignored until the guardian frees enough space. Remote senders should try again later.";
+}
+
 // ── Compaction circuit-breaker pipeline helpers ─────────────────────
 //
 // The circuit-breaker behavior (3 consecutive summary-LLM failures trips a
@@ -438,7 +458,6 @@ export interface AgentLoopConversationContext {
   /** Timestamp (ms since epoch) until which the circuit breaker is open. */
   compactionCircuitOpenUntil: number | null;
 
-  readonly memoryPolicy: { scopeId: string; includeDefaultFallback: boolean };
   readonly graphMemory: ConversationGraphMemory;
 
   currentActiveSurfaceId?: string;
@@ -495,9 +514,11 @@ export interface AgentLoopConversationContext {
   voiceCallControlPrompt?: string;
   transportHints?: string[];
   slackRuntimeContextNotice?: string;
+  clientTimezone?: string;
 
   readonly coreToolNames: Set<string>;
   allowedToolNames?: Set<string>;
+  diskPressureCleanupModeActive?: boolean;
   toolsDisabledDepth: number;
   preactivatedSkillIds?: string[];
   readonly skillProjectionState: Map<string, string>;
@@ -707,19 +728,39 @@ export async function runAgentLoopImpl(
     };
   })();
 
+  const isInteractiveResolved =
+    options?.isInteractive ?? (!ctx.hasNoClient && !ctx.headlessLock);
+  const diskPressureDecision = classifyDiskPressureTurnPolicy(
+    getDiskPressureStatus(),
+    {
+      conversationType: turnStartConversation?.conversationType ?? null,
+      conversationSource: turnStartConversation?.source ?? null,
+      callSite: turnCallSite,
+      isInteractive: isInteractiveResolved,
+      sourceChannel:
+        ctx.trustContext?.sourceChannel ??
+        capturedTurnChannelContext.userMessageChannel,
+      sourceInterface:
+        ctx.channelCapabilities?.clientOS ??
+        capturedTurnInterfaceContext.userMessageInterface,
+      trustContext: ctx.trustContext
+        ? {
+            sourceChannel: ctx.trustContext.sourceChannel,
+            trustClass: ctx.trustContext.trustClass,
+          }
+        : null,
+    },
+  );
+  const diskPressureContext =
+    diskPressureDecision.action === "allow-cleanup-mode"
+      ? { cleanupModeActive: true }
+      : null;
+  ctx.diskPressureCleanupModeActive =
+    diskPressureDecision.action === "allow-cleanup-mode";
+
   ctx.lastAssistantAttachments = [];
   ctx.lastAttachmentWarnings = [];
 
-  // Ensure workspace git repo is initialized before any tools run.
-  try {
-    const getWorkspaceGitServiceFn =
-      ctx.getWorkspaceGitService ?? getWorkspaceGitService;
-    const gitService = getWorkspaceGitServiceFn(ctx.workingDir);
-    await gitService.ensureInitialized();
-  } catch (err) {
-    rlog.warn({ err }, "Failed to initialize workspace git repo (non-fatal)");
-  }
-
   ctx.profiler.startRequest();
   let turnStarted = false;
 
@@ -736,6 +777,52 @@ export async function runAgentLoopImpl(
   });
 
   try {
+    if (diskPressureDecision.action === "block") {
+      const message = formatDiskPressureBlockedMessage();
+      rlog.warn(
+        { reason: diskPressureDecision.reason },
+        "Blocked turn during disk pressure cleanup mode",
+      );
+      ctx.emitActivityState("idle", "error_terminal", "global", reqId);
+      ctx.traceEmitter.emit("request_error", message, {
+        requestId: reqId,
+        status: "error",
+        attributes: {
+          errorCategory: DISK_PRESSURE_ERROR_CATEGORY,
+          errorCode: DISK_PRESSURE_ERROR_CODE,
+          diskPressureReason: diskPressureDecision.reason,
+        },
+      });
+      onEvent({
+        type: "error",
+        conversationId: ctx.conversationId,
+        requestId: reqId,
+        code: DISK_PRESSURE_ERROR_CODE,
+        message,
+        category: DISK_PRESSURE_ERROR_CATEGORY,
+        errorCategory: DISK_PRESSURE_ERROR_CATEGORY,
+      });
+      onEvent({
+        type: "conversation_error",
+        conversationId: ctx.conversationId,
+        code: DISK_PRESSURE_ERROR_CODE,
+        userMessage: message,
+        retryable: true,
+        errorCategory: DISK_PRESSURE_ERROR_CATEGORY,
+      });
+      return;
+    }
+
+    // Ensure workspace git repo is initialized before any tools run.
+    try {
+      const getWorkspaceGitServiceFn =
+        ctx.getWorkspaceGitService ?? getWorkspaceGitService;
+      const gitService = getWorkspaceGitServiceFn(ctx.workingDir);
+      await gitService.ensureInitialized();
+    } catch (err) {
+      rlog.warn({ err }, "Failed to initialize workspace git repo (non-fatal)");
+    }
+
     // Auto-complete stale interactive surfaces from previous turns.
     // Only dismiss when the user sends a new message (not a surface action
     // response), so internal turns (subagent notifications, lifecycle
@@ -899,7 +986,7 @@ export async function runAgentLoopImpl(
         compactableStartIndex: 1,
       };
     };
-    const applySuccessfulCompaction = (
+    const applySuccessfulCompaction = async (
       result: Awaited<ReturnType<typeof ctx.contextWindowManager.maybeCompact>>,
       compactedBasis?: Message[],
     ) => {
@@ -913,7 +1000,7 @@ export async function runAgentLoopImpl(
         provenanceContext,
         result.compactedMessages,
       );
-      applyCompactionResult(ctx, result, onEvent, reqId, {
+      await applyCompactionResult(ctx, result, onEvent, reqId, {
         slackContextCompactionWatermarkTs: slackWatermarkTs,
       });
       currentSlackContextSummary = result.summaryText;
@@ -1000,7 +1087,10 @@ export async function runAgentLoopImpl(
       await trackCompactionOutcome(ctx, compacted.summaryFailed, onEvent);
     }
     if (compacted?.compacted) {
-      applySuccessfulCompaction(compacted, messagesForStartOfTurnCompaction);
+      await applySuccessfulCompaction(
+        compacted,
+        messagesForStartOfTurnCompaction,
+      );
       shouldInjectWorkspace = true;
       if (compacted.compactedPersistedMessages > 0) {
         compactedThisTurn = true;
@@ -1238,14 +1328,16 @@ export async function runAgentLoopImpl(
 
     // Compute fresh turn timestamp for date grounding.
     // Absolute "now" is always anchored to assistant host clock, while local
-    // date semantics prefer configured user timezone, then recalled memory.
+    // date semantics prefer configured user timezone, then device timezones.
     const hostTimeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
-    const configuredUserTimeZone = getConfig().ui.userTimezone ?? null;
-    const recalledUserTimeZone = null;
-    const timestamp = formatTurnTimestamp({
+    const timezoneContext = resolveTurnTimezoneContext({
+      configuredUserTimeZone: config.ui.userTimezone ?? null,
+      clientTimezone: ctx.clientTimezone ?? null,
+      detectedTimezone: config.ui.detectedTimezone ?? null,
       hostTimeZone,
-      configuredUserTimeZone,
-      userTimeZone: recalledUserTimeZone,
+    });
+    const timestamp = formatTurnTimestamp({
+      timeZone: timezoneContext.effectiveTimezone,
     });
 
     // Resolve the inbound actor context for the unified <turn_context> block.
@@ -1299,23 +1391,26 @@ export async function runAgentLoopImpl(
       }
     }
 
+    const baseTurnContext = {
+      timestamp,
+      interfaceName,
+      channelName,
+      configuredUserTimezone: timezoneContext.configuredUserTimezone,
+      clientTimezone: timezoneContext.clientTimezone,
+      detectedTimezone: timezoneContext.detectedTimezone,
+      timeSinceLastMessage,
+    };
     const unifiedTurnContextStr = buildUnifiedTurnContextBlock(
       isGuardian
-        ? { timestamp, interfaceName, channelName, timeSinceLastMessage }
+        ? baseTurnContext
         : {
-            timestamp,
-            interfaceName,
-            channelName,
+            ...baseTurnContext,
             actorContext: resolvedInboundActorContext,
-            timeSinceLastMessage,
           },
     );
 
     // The `remember` tool handles scratchpad-style memory writes directly to the graph.
 
-    const isInteractiveResolved =
-      options?.isInteractive ?? (!ctx.hasNoClient && !ctx.headlessLock);
-
     // 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.
@@ -1330,10 +1425,16 @@ export async function runAgentLoopImpl(
     const pkbActive = currentPkbContent !== null;
 
     // V2 static memory block (essentials/threads/recent/buffer). Same
-    // first-turn / post-compaction cadence as PKB — `readMemoryV2StaticContent`
-    // self-gates on the v2 flag + config, returning null when v2 is off.
-    // Skip the file reads entirely on non-injection turns.
-    const currentMemoryV2Static = shouldInjectNowAndPkb
+    // first-turn / post-compaction cadence as PKB. `shouldLoadMemoryV2Static`
+    // also blocks remote-channel non-guardian actors from inducing the
+    // model to recite private memory; `readMemoryV2StaticContent` self-gates
+    // on the v2 flag + config and returns null when v2 is off, so the file
+    // reads are skipped on non-injection turns.
+    const currentMemoryV2Static = shouldLoadMemoryV2Static({
+      shouldInjectNowAndPkb,
+      sourceChannel: ctx.trustContext?.sourceChannel,
+      isTrustedActor,
+    })
       ? readMemoryV2StaticContent()
       : null;
     const memoryV2Static = currentMemoryV2Static;
@@ -1349,8 +1450,8 @@ export async function runAgentLoopImpl(
     // `getInContextPkbPaths` re-reads `conversation.messages` on each call,
     // so post-compaction re-injects see the updated history.
     const pkbConversation = pkbActive ? ctx : undefined;
-    // PKB points live under a single workspace sentinel scope, not the
-    // conversation's memoryPolicy.scopeId. See `PKB_WORKSPACE_SCOPE` for why.
+    // PKB points live under a single workspace sentinel scope.
+    // See `PKB_WORKSPACE_SCOPE` for why.
     const pkbScopeId = pkbActive ? PKB_WORKSPACE_SCOPE : undefined;
 
     // Subagent status injection — gives the parent LLM visibility into active/completed children.
@@ -1417,6 +1518,7 @@ export async function runAgentLoopImpl(
 
     // Shared injection options — reused whenever we need to re-inject after reduction.
     const injectionOpts = {
+      diskPressureContext,
       activeSurface,
       workspaceTopLevelContext: shouldInjectWorkspace
         ? ctx.workspaceTopLevelContext
@@ -1691,7 +1793,7 @@ export async function runAgentLoopImpl(
             await trackCompactionOutcome(ctx, result.summaryFailed, onEvent);
           }
           if (result.compacted) {
-            applySuccessfulCompaction(result, compactedBasis);
+            await applySuccessfulCompaction(result, compactedBasis);
             shouldInjectWorkspace = true;
           }
         },
@@ -2020,7 +2122,7 @@ export async function runAgentLoopImpl(
         );
       }
       if (midLoopCompact.compacted) {
-        applySuccessfulCompaction(midLoopCompact, rawHistory);
+        await applySuccessfulCompaction(midLoopCompact, rawHistory);
         reducerCompacted = true;
         shouldInjectWorkspace = true;
       }
@@ -2272,7 +2374,7 @@ export async function runAgentLoopImpl(
         }
 
         if (step.compactionResult?.compacted) {
-          applySuccessfulCompaction(
+          await applySuccessfulCompaction(
             step.compactionResult,
             convergenceCompactionBasis,
           );
@@ -2438,7 +2540,7 @@ export async function runAgentLoopImpl(
             );
           }
           if (emergencyCompact?.compacted) {
-            applySuccessfulCompaction(emergencyCompact, ctx.messages);
+            await applySuccessfulCompaction(emergencyCompact, ctx.messages);
             reducerCompacted = true;
             shouldInjectWorkspace = true;
           }
@@ -2874,6 +2976,42 @@ export async function runAgentLoopImpl(
             "Failed to build home-feed event for background conversation",
           );
         }
+
+        // Proactive artifact: fire once when the processed turn was the 4th user message.
+        // Only trigger for real user-authored turns (not subagent/system messages).
+        {
+          const paConv = getConversation(ctx.conversationId);
+          if (
+            paConv &&
+            paConv.conversationType === "standard" &&
+            options?.isUserMessage
+          ) {
+            void (async () => {
+              try {
+                if (hasProactiveArtifactCompleted()) return;
+                const userMsg = getMessageById(
+                  userMessageId,
+                  ctx.conversationId,
+                );
+                if (!userMsg) return;
+                if (!tryClaimProactiveArtifactTrigger(userMsg.createdAt))
+                  return;
+                await runProactiveArtifactJob({
+                  conversationId: ctx.conversationId,
+                  userMessageCutoff: userMsg.createdAt,
+                  assistantMessageId: state.lastAssistantMessageId,
+                  suppressAppBuild: state.appBuildToolUsedThisRun,
+                  broadcastMessage,
+                });
+              } catch (err) {
+                log.warn(
+                  { err, conversationId: ctx.conversationId },
+                  "Proactive artifact trigger failed",
+                );
+              }
+            })();
+          }
+        }
       }
     }
 
@@ -2937,6 +3075,7 @@ export async function runAgentLoopImpl(
         conversationId: ctx.conversationId,
         code: classified.code,
         message: classified.userMessage,
+        errorCategory: classified.errorCategory,
       });
       onEvent(buildConversationErrorMessage(ctx.conversationId, classified));
     }
@@ -2988,6 +3127,7 @@ export async function runAgentLoopImpl(
     ctx.currentRequestId = undefined;
     ctx.currentActiveSurfaceId = undefined;
     ctx.allowedToolNames = undefined;
+    ctx.diskPressureCleanupModeActive = false;
     ctx.preactivatedSkillIds = undefined;
     ctx.currentTurnOverrideProfile = undefined;
     ctx.slackRuntimeContextNotice = undefined;
@@ -3086,7 +3226,7 @@ export interface CompactionApplyContext {
  * truth for the UI indicator after compaction. Emitting both caused a
  * redundant SwiftUI invalidation on every compaction.
  */
-export function applyCompactionResult(
+export async function applyCompactionResult(
   ctx: CompactionApplyContext,
   result: {
     messages: Message[];
@@ -3112,12 +3252,12 @@ export function applyCompactionResult(
   options: {
     slackContextCompactionWatermarkTs?: string | null;
   } = {},
-): void {
+): Promise<void> {
   ctx.messages = result.messages;
   ctx.contextCompactedMessageCount += result.compactedPersistedMessages;
   const compactedAt = Date.now();
   ctx.contextCompactedAt = compactedAt;
-  ctx.graphMemory.onCompacted(result.compactedPersistedMessages);
+  await ctx.graphMemory.onCompacted(result.compactedPersistedMessages);
   updateConversationContextWindow(
     ctx.conversationId,
     result.summaryText,

package/src/daemon/conversation-error.ts

@@ -36,6 +36,23 @@ const NETWORK_PATTERNS = [
 // Rate limit patterns (HTTP 429 or explicit rate limit messages)
 const RATE_LIMIT_PATTERNS = [/429/, /rate.?limit/i, /too many requests/i];
 
+// Managed usage-limit responses are generated by Vellum, even though they can
+// travel through provider SDKs and get wrapped as ProviderError.
+const MANAGED_USAGE_LIMIT_PATTERNS = [
+  /"code"\s*:\s*"daily_quota_exceeded"/i,
+  /"code"\s*:\s*"rate_limit_exceeded"/i,
+  /system credential proxy rate limit/i,
+  /you've reached your usage limit for today/i,
+  /current plan allows/i,
+];
+
+const PROVIDER_BILLING_PATTERNS = [
+  /credit balance is too low/i,
+  /insufficient.*credits?/i,
+  /requires more credits/i,
+  /can only afford/i,
+];
+
 // Overloaded patterns — provider is capacity-constrained (distinct from rate limiting)
 const OVERLOADED_PATTERNS = [/overloaded/i];
 
@@ -259,15 +276,21 @@ function classifyCore(
       };
     }
     if (error.statusCode === 402) {
-      return {
-        code: "PROVIDER_BILLING",
-        userMessage:
-          "You've run out of credits. Add funds to continue using the assistant.",
-        retryable: false,
-        errorCategory: "credits_exhausted",
-      };
+      if (isManagedBalanceError(error)) {
+        return managedBalanceClassification();
+      }
+      return providerBillingClassification();
     }
     if (error.statusCode === 429) {
+      if (isManagedUsageLimitError(error, message)) {
+        return {
+          code: "MANAGED_USAGE_LIMIT",
+          userMessage:
+            "Vellum managed inference is rate limited. This is a Vellum-side usage limit, not an AI provider outage.",
+          retryable: true,
+          errorCategory: "managed_usage_limit",
+        };
+      }
       return {
         code: "PROVIDER_RATE_LIMIT",
         userMessage:
@@ -331,13 +354,8 @@ function classifyCore(
           errorCategory: "tool_ordering",
         };
       }
-      if (/credit balance is too low|insufficient.*credits?/i.test(message)) {
-        return {
-          code: "PROVIDER_BILLING",
-          userMessage: "Your API key has insufficient credits.",
-          retryable: false,
-          errorCategory: "provider_billing",
-        };
+      if (isProviderBillingError(message)) {
+        return providerBillingClassification();
       }
       if (
         /invalid.*api.?key|invalid.*x-api-key|authentication.?error|invalid.authentication/i.test(
@@ -362,7 +380,7 @@ function classifyCore(
   }
 
   // Regex fallback for non-ProviderError or ProviderError without statusCode
-  return classifyByMessage(message);
+  return classifyByMessage(error, message);
 }
 
 /** Check whether an error message indicates a context-too-large failure. */
@@ -394,7 +412,52 @@ function isStreamingError(message: string): boolean {
   return STREAMING_ERROR_PATTERNS.some((p) => p.test(message));
 }
 
+function isManagedUsageLimitError(error: unknown, message: string): boolean {
+  if (
+    error instanceof ProviderError &&
+    getProviderRoutingSource(error.provider) === "managed-proxy"
+  ) {
+    return true;
+  }
+  return MANAGED_USAGE_LIMIT_PATTERNS.some((p) => p.test(message));
+}
+
+function isManagedBalanceError(error: ProviderError): boolean {
+  return getProviderRoutingSource(error.provider) === "managed-proxy";
+}
+
+function isProviderBillingError(message: string): boolean {
+  return PROVIDER_BILLING_PATTERNS.some((p) => p.test(message));
+}
+
+function managedBalanceClassification(): Omit<
+  ClassifiedConversationError,
+  "debugDetails"
+> {
+  return {
+    code: "PROVIDER_BILLING",
+    userMessage:
+      "You've run out of credits. Add funds to continue using the assistant.",
+    retryable: false,
+    errorCategory: "credits_exhausted",
+  };
+}
+
+function providerBillingClassification(): Omit<
+  ClassifiedConversationError,
+  "debugDetails"
+> {
+  return {
+    code: "PROVIDER_BILLING",
+    userMessage:
+      "Your API provider account or key needs credits. Add funds with the provider or update the key in Settings.",
+    retryable: false,
+    errorCategory: "provider_billing",
+  };
+}
+
 function classifyByMessage(
+  error: unknown,
   message: string,
 ): Omit<ClassifiedConversationError, "debugDetails"> {
   // Check context-too-large before other patterns
@@ -411,6 +474,15 @@ function classifyByMessage(
   // Check rate limit first (before network, since 429 could match both)
   for (const pattern of RATE_LIMIT_PATTERNS) {
     if (pattern.test(message)) {
+      if (isManagedUsageLimitError(error, message)) {
+        return {
+          code: "MANAGED_USAGE_LIMIT",
+          userMessage:
+            "Vellum managed inference is rate limited. This is a Vellum-side usage limit, not an AI provider outage.",
+          retryable: true,
+          errorCategory: "managed_usage_limit",
+        };
+      }
       return {
         code: "PROVIDER_RATE_LIMIT",
         userMessage:

package/src/daemon/conversation-lifecycle.ts

@@ -4,6 +4,7 @@
  * can delegate without exposing its full surface.
  */
 
+import { getConfig } from "../config/loader.js";
 import { createContextSummaryMessage } from "../context/window-manager.js";
 import type { EventBus } from "../events/bus.js";
 import type { AssistantDomainEvents } from "../events/domain-events.js";
@@ -153,8 +154,6 @@ export interface DisposeContext extends AbortContext {
   trustContext?: { trustClass: TrustClass };
   /** Active memory node IDs snapshotted from the conversation's InContextTracker before disposal. */
   activeContextNodeIds?: string[];
-  /** Memory scope for extraction — defaults to "default" if omitted. */
-  memoryScopeId?: string;
   abort(): void;
 }
 
@@ -375,16 +374,29 @@ export function disposeConversation(ctx: DisposeContext): void {
       // Best-effort — don't block conversation disposal
     }
     if (!isAutoAnalysis) {
+      // Suppress v1 graph extraction when memory v2 is active — v2 reads
+      // from buffer.md and concept pages, so the v1 graph would be stale
+      // data nobody consumes. Mirrors the gate applied in `indexer.ts`
+      // for the per-message indexing path. Fail open to v1 if config
+      // can't load, since the worker handler also short-circuits.
+      let v2Enabled = false;
       try {
-        enqueueMemoryJob("graph_extract", {
-          conversationId: ctx.conversationId,
-          scopeId: ctx.memoryScopeId ?? "default",
-          ...(ctx.activeContextNodeIds?.length
-            ? { activeContextNodeIds: ctx.activeContextNodeIds }
-            : {}),
-        });
+        v2Enabled = getConfig().memory.v2.enabled;
       } catch {
-        // Best-effort — don't block conversation disposal
+        // Best-effort — fall through to legacy v1 enqueue
+      }
+      if (!v2Enabled) {
+        try {
+          enqueueMemoryJob("graph_extract", {
+            conversationId: ctx.conversationId,
+            scopeId: "default",
+            ...(ctx.activeContextNodeIds?.length
+              ? { activeContextNodeIds: ctx.activeContextNodeIds }
+              : {}),
+          });
+        } catch {
+          // Best-effort — don't block conversation disposal
+        }
       }
     }
 

package/src/daemon/conversation-process.ts

@@ -182,6 +182,8 @@ export interface ProcessConversationContext {
   forceCompact(): Promise<ContextWindowResult>;
   /** Set transport-derived hints for the conversation. */
   setTransportHints(hints: string[] | undefined): void;
+  /** IANA timezone reported by the active client for the current turn. */
+  clientTimezone?: string;
   /**
    * Apply client-reported host env (home dir, username) from transport
    * metadata, gating on `supportsHostProxy` so non-host-proxy interfaces
@@ -189,6 +191,10 @@ export interface ProcessConversationContext {
    * `DaemonServer.applyTransportMetadata` and the queue-drain path below.
    */
   applyHostEnvFromTransport(transport: ConversationTransportMetadata): void;
+  /** Apply the per-turn client timezone reported by transport metadata. */
+  applyClientTimezoneFromTransport(
+    transport: ConversationTransportMetadata,
+  ): void;
 }
 
 function resolveQueuedTurnContext(
@@ -423,6 +429,7 @@ async function drainSingleMessage(
     // setter used by DaemonServer.applyTransportMetadata so create/reuse
     // and queue-drain stay in sync without duplicating the gate logic.
     conversation.applyHostEnvFromTransport(next.transport);
+    conversation.applyClientTimezoneFromTransport(next.transport);
   }
 
   // Re-preactivate host-proxy skills for interactive desktop turns. The
@@ -865,6 +872,7 @@ async function drainBatch(
   if (head.transport) {
     conversation.setTransportHints(buildTransportHints(head.transport));
     conversation.applyHostEnvFromTransport(head.transport);
+    conversation.applyClientTimezoneFromTransport(head.transport);
   }
 
   // Re-preactivate host-proxy skills for interactive desktop turns.