@vellumai/assistant 0.10.2 → 0.10.3-dev.202606252046.9075fd5

package/src/daemon/conversation-notices.ts

@@ -0,0 +1,60 @@
+import type { ConversationNoticeEvent } from "../api/events/conversation-notice.js";
+
+export type PendingConversationNotice = Omit<
+  ConversationNoticeEvent,
+  "type" | "conversationId"
+>;
+
+const MAX_TRACKED_CONVERSATIONS = 256;
+
+const pendingNotices = new Map<
+  string,
+  Map<string, PendingConversationNotice>
+>();
+
+function touchConversation(
+  conversationId: string,
+): Map<string, PendingConversationNotice> {
+  const existing = pendingNotices.get(conversationId);
+  if (existing) {
+    pendingNotices.delete(conversationId);
+    pendingNotices.set(conversationId, existing);
+    return existing;
+  }
+  if (pendingNotices.size >= MAX_TRACKED_CONVERSATIONS) {
+    const oldest = pendingNotices.keys().next().value;
+    if (oldest !== undefined) pendingNotices.delete(oldest);
+  }
+  const next = new Map<string, PendingConversationNotice>();
+  pendingNotices.set(conversationId, next);
+  return next;
+}
+
+export function queueConversationNotice(
+  conversationId: string,
+  key: string,
+  notice: PendingConversationNotice,
+): void {
+  touchConversation(conversationId).set(key, notice);
+}
+
+export function drainConversationNotices(
+  conversationId: string,
+): ConversationNoticeEvent[] {
+  const notices = pendingNotices.get(conversationId);
+  if (!notices) return [];
+  pendingNotices.delete(conversationId);
+  return Array.from(notices.values(), (notice) => ({
+    type: "conversation_notice" as const,
+    conversationId,
+    ...notice,
+  }));
+}
+
+export function clearConversationNotices(conversationId: string): void {
+  pendingNotices.delete(conversationId);
+}
+
+export function resetConversationNoticesForTests(): void {
+  pendingNotices.clear();
+}

package/src/daemon/conversation-process.ts

@@ -60,6 +60,21 @@ import { resolveVerificationSessionIntent } from "./verification-session-intent.
 
 const log = getLogger("conversation-process");
 
+/**
+ * Daemon-injected subagent lifecycle notifications carry `subagentNotification`
+ * metadata. They are persisted into the parent conversation so the orchestrator
+ * wakes and reads the subagent's result, but they are internal scaffolding — the
+ * user sees subagent activity through the inline progress card, not a chat turn.
+ * Skip the `user_message_echo` broadcast for these so they never render as a live
+ * user bubble; the persisted row is filtered from the rendered transcript on the
+ * client.
+ */
+function isSubagentNotificationMessage(
+  metadata: Record<string, unknown> | undefined,
+): boolean {
+  return metadata?.subagentNotification != null;
+}
+
 /** Format the result of a forced compaction into a user-facing message. */
 export function formatCompactResult(result: ContextWindowResult): string {
   const fmt = (n: number | undefined) => (n ?? 0).toLocaleString("en-US");
@@ -853,14 +868,16 @@ async function drainSingleMessage(
 
   // Broadcast the user message to all hub subscribers so passive devices
   // see the user turn before the assistant reply starts streaming.
-  next.onEvent({
-    type: "user_message_echo",
-    text: resolvedContent,
-    conversationId: conversation.conversationId,
-    messageId: userMessageId,
-    requestId: next.requestId,
-    clientMessageId: next.clientMessageId,
-  });
+  if (!isSubagentNotificationMessage(next.metadata)) {
+    next.onEvent({
+      type: "user_message_echo",
+      text: resolvedContent,
+      conversationId: conversation.conversationId,
+      messageId: userMessageId,
+      requestId: next.requestId,
+      clientMessageId: next.clientMessageId,
+    });
+  }
   publishConversationMessagesChanged(conversation.conversationId);
 
   // Set the active surface for the dequeued message so runAgentLoop can inject context
@@ -1204,14 +1221,16 @@ async function drainBatch(
 
     // Broadcast the user message to all hub subscribers so passive devices
     // see each batched user turn before the assistant reply starts streaming.
-    qm.onEvent({
-      type: "user_message_echo",
-      text: qmContent,
-      conversationId: conversation.conversationId,
-      messageId: lastUserMessageId,
-      requestId: qm.requestId,
-      clientMessageId: qm.clientMessageId,
-    });
+    if (!isSubagentNotificationMessage(qm.metadata)) {
+      qm.onEvent({
+        type: "user_message_echo",
+        text: qmContent,
+        conversationId: conversation.conversationId,
+        messageId: lastUserMessageId,
+        requestId: qm.requestId,
+        clientMessageId: qm.clientMessageId,
+      });
+    }
     publishConversationMessagesChanged(conversation.conversationId);
 
     // Persist succeeded. Update last-successful markers so a later tail

package/src/daemon/conversation-surfaces.ts

@@ -3,7 +3,10 @@ import { v4 as uuid } from "uuid";
 import { z } from "zod";
 
 import { SurfaceActionSchema } from "../api/events/ui-surface-show.js";
-import { CardSurfaceDataSchema } from "../api/surfaces.js";
+import {
+  CardSurfaceDataSchema,
+  FileUploadSurfaceDataSchema,
+} from "../api/surfaces.js";
 import { isActivationSession } from "../memory/activation-session-store.js";
 import {
   addAppConversationId,
@@ -56,6 +59,7 @@ import type {
   ConfirmationSurfaceData,
   CopyBlockSurfaceData,
   DynamicPageSurfaceData,
+  FileUploadSurfaceData,
   FormSurfaceData,
   ListSurfaceData,
   OAuthConnectSurfaceData,
@@ -583,12 +587,20 @@ function normalizeCardShowData(
           (typeof input[k] === "string" &&
             (input[k] as string).trim().length > 0),
       );
-      Sentry.addBreadcrumb({
-        category: "card-normalization",
-        message: `alias recovery: ${usedAliases.join(", ")} → body`,
-        level: "info",
-        data: { usedAliases, candidateCount: candidates.length },
-      });
+      try {
+        Sentry.withScope((scope) => {
+          scope.setLevel("info");
+          scope.setTag("card_normalization", "alias_recovery");
+          scope.setTag("target_field", "body");
+          scope.setContext("card_normalization", {
+            used_aliases: usedAliases,
+            candidate_count: candidates.length,
+          });
+          Sentry.captureMessage("card_normalization:alias_recovery:body");
+        });
+      } catch {
+        // Never let telemetry break card rendering.
+      }
     }
   }
   for (const key of bodyAliasKeys) {
@@ -605,11 +617,16 @@ function normalizeCardShowData(
     ]);
     if (aliased !== undefined) {
       normalized.title = aliased;
-      Sentry.addBreadcrumb({
-        category: "card-normalization",
-        message: `alias recovery: title`,
-        level: "info",
-      });
+      try {
+        Sentry.withScope((scope) => {
+          scope.setLevel("info");
+          scope.setTag("card_normalization", "alias_recovery");
+          scope.setTag("target_field", "title");
+          Sentry.captureMessage("card_normalization:alias_recovery:title");
+        });
+      } catch {
+        // Never let telemetry break card rendering.
+      }
     }
   }
   for (const key of titleAliasKeys) {
@@ -634,11 +651,16 @@ function normalizeCardShowData(
     ]);
     if (aliased !== undefined) {
       normalized.subtitle = aliased;
-      Sentry.addBreadcrumb({
-        category: "card-normalization",
-        message: `alias recovery: subtitle`,
-        level: "info",
-      });
+      try {
+        Sentry.withScope((scope) => {
+          scope.setLevel("info");
+          scope.setTag("card_normalization", "alias_recovery");
+          scope.setTag("target_field", "subtitle");
+          Sentry.captureMessage("card_normalization:alias_recovery:subtitle");
+        });
+      } catch {
+        // Never let telemetry break card rendering.
+      }
     }
   }
   for (const key of subtitleAliasKeys) {
@@ -688,12 +710,21 @@ function normalizeCardShowData(
       { droppedKeys },
       "ui_show card data carried keys the card contract does not model; their content will not render",
     );
-    Sentry.addBreadcrumb({
-      category: "card-normalization",
-      message: `dropped keys: ${droppedKeys.join(", ")}`,
-      level: "warning",
-      data: { droppedKeys },
-    });
+    try {
+      Sentry.withScope((scope) => {
+        scope.setLevel("warning");
+        scope.setTag("card_normalization", "dropped_keys");
+        scope.setContext("card_normalization", {
+          dropped_count: droppedKeys.length,
+        });
+        // Key names are model-controlled, so they ride in `extra`, which
+        // beforeSend redacts (it does not scrub `contexts`) — see instrument.ts.
+        scope.setExtra("dropped_keys", droppedKeys);
+        Sentry.captureMessage("card_normalization:dropped_keys");
+      });
+    } catch {
+      // Never let telemetry break card rendering.
+    }
   }
   const parsed = CardSurfaceDataSchema.safeParse(normalized);
   if (parsed.success) {
@@ -829,6 +860,24 @@ function normalizeOAuthConnectShowData(
   };
 }
 
+function normalizeFileUploadShowData(
+  rawData: Record<string, unknown>,
+): FileUploadSurfaceData {
+  // Parse against the canonical schema so the surface carries the shape the
+  // renderer expects. The schema is tolerant (every field optional and coerced)
+  // and recovers the common malformed `acceptedTypes` shapes — a comma-joined or
+  // bare string — into the `string[]` the renderer requires.
+  const parsed = FileUploadSurfaceDataSchema.safeParse(rawData);
+  if (parsed.success) {
+    return parsed.data;
+  }
+  log.warn(
+    { issues: parsed.error.issues },
+    "ui_show file_upload data failed FileUploadSurfaceDataSchema; rendering an empty file_upload surface",
+  );
+  return {};
+}
+
 function buildChoiceActions(data: ChoiceSurfaceData): Array<{
   id: string;
   label: string;
@@ -2895,7 +2944,9 @@ export async function surfaceProxyResolver(
               ? normalizeOAuthConnectShowData(rawData)
               : surfaceType === "dynamic_page"
                 ? normalizeDynamicPageShowData(input, rawData)
-                : (rawData as SurfaceData);
+                : surfaceType === "file_upload"
+                  ? normalizeFileUploadShowData(rawData)
+                  : (rawData as SurfaceData);
     // Parse actions through the schema instead of typecasting raw model output.
     // The model may place actions inside `data` instead of the top-level
     // `actions` param — recover them so they aren't silently dropped.
@@ -2912,18 +2963,27 @@ export async function surfaceProxyResolver(
         if (result.success) {
           valid.push(result.data);
         } else {
-          Sentry.addBreadcrumb({
-            category: "card-normalization",
-            message: "action parse failure (individual)",
-            level: "warning",
-            data: {
-              issuePaths: result.error.issues.map((i) => i.path.join(".")),
-              keys:
+          try {
+            Sentry.withScope((scope) => {
+              scope.setLevel("warning");
+              scope.setTag("card_normalization", "action_parse_failure");
+              scope.setContext("card_normalization", {
+                issue_paths: result.error.issues.map((i) => i.path.join(".")),
+              });
+              // raw object keys are model-controlled, so they ride in `extra`,
+              // which beforeSend redacts (it does not scrub `contexts`) — see
+              // instrument.ts.
+              scope.setExtra(
+                "raw_keys",
                 typeof raw === "object" && raw !== null
                   ? Object.keys(raw)
                   : [typeof raw],
-            },
-          });
+              );
+              Sentry.captureMessage("card_normalization:action_parse_failure");
+            });
+          } catch {
+            // Never let telemetry break card rendering.
+          }
         }
       }
       inputActions = valid.length > 0 ? valid : undefined;
@@ -2961,11 +3021,24 @@ export async function surfaceProxyResolver(
         !hasTemplate &&
         !hasActions
       ) {
-        Sentry.addBreadcrumb({
-          category: "card-normalization",
-          message: "empty card rejected",
-          level: "warning",
-        });
+        try {
+          Sentry.withScope((scope) => {
+            scope.setLevel("warning");
+            scope.setTag("card_normalization", "empty_card_rejected");
+            scope.setContext("card_normalization", {
+              surface_type: surfaceType,
+              has_title: hasTitle,
+              has_body: hasBody,
+              has_subtitle: hasSubtitle,
+              has_metadata: hasMetadata,
+              has_template: hasTemplate,
+              has_actions: hasActions,
+            });
+            Sentry.captureMessage("card_normalization:empty_card_rejected");
+          });
+        } catch {
+          // Never let telemetry break card rendering.
+        }
         return {
           content:
             "Error: ui_show card requires content — provide `data.body`, a `template` (e.g. task_progress with steps), `data.metadata`, `data.subtitle`, a `title`, or `actions`. The surface was not displayed because it carried no renderable content. Resend ui_show with populated card content.",

package/src/daemon/conversation-tool-setup.ts

@@ -17,12 +17,17 @@ import type { LLMCallSite } from "../config/schemas/llm.js";
 import { getBindingByConversation } from "../memory/external-conversation-store.js";
 import type { PermissionPrompter } from "../permissions/prompter.js";
 import type { SecretPrompter } from "../permissions/secret-prompter.js";
-import { advisorEnabledForProfile } from "../plugins/defaults/advisor/advisor-gate.js";
 import type { Message, ToolDefinition } from "../providers/types.js";
 import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import { registerConversationSender } from "../tools/browser/browser-screencast.js";
 import type { ToolExecutor } from "../tools/executor.js";
-import { getMcpToolDefinitions, getTool } from "../tools/registry.js";
+import {
+  getMcpToolDefinitions,
+  getPluginToolDefinitions,
+  getTool,
+  getWorkspaceToolDefinitions,
+  getWorkspaceToolNames,
+} from "../tools/registry.js";
 import {
   ACTIVITY_SKIP_SET,
   injectActivityField,
@@ -41,6 +46,7 @@ import {
   type ToolExecutionResult,
   type ToolLifecycleEventHandler,
 } from "../tools/types.js";
+import { loadWorkspaceTools } from "../tools/workspace-tools/loader.js";
 import {
   resolveUsageAttribution,
   type UsageAttributionSnapshot,
@@ -238,7 +244,10 @@ export function createToolExecutor(
           });
         }
       },
-      isInteractive: !ctx.hasNoClient && !ctx.headlessLock,
+      isInteractive:
+        ctx.currentTurnIsNonInteractive !== undefined
+          ? !ctx.currentTurnIsNonInteractive
+          : !ctx.hasNoClient && !ctx.headlessLock,
       proxyToolResolver: (
         toolName: string,
         proxyInput: Record<string, unknown>,
@@ -506,6 +515,7 @@ const PLATFORM_TOOL_NAMES = new Set(["request_system_permission"]);
  */
 export const SUBAGENT_ONLY_TOOL_NAMES = new Set<string>([
   "file_list",
+  "code_search",
   "notify_parent",
 ]);
 
@@ -564,15 +574,6 @@ export function isToolActiveForContext(
       return true;
     }
   }
-  if (name === "advisor") {
-    // Gated per chat-profile (`ProfileEntry.advisorEnabled`): when the resolved
-    // profile disables the advisor, omit the tool from the wire list so the
-    // model never sees a tool it can only no-op on. Resolves the profile the
-    // same way the advisor's execution-time guard does (the per-turn override,
-    // else the active profile). The wire list is fixed before PRE_MODEL_CALL
-    // hooks run, so later profile changes from hooks are not reflected here.
-    return advisorEnabledForProfile(ctx.currentTurnOverrideProfile ?? null);
-  }
   if (UI_SURFACE_TOOL_NAMES.has(name)) {
     if (
       channelCapabilities?.channel === "slack" &&
@@ -650,11 +651,13 @@ export function isToolActiveForContext(
  * allowedToolNames so newly-activated skill tools aren't blocked by
  * the executor's stale gate.
  *
- * Core (non-MCP) tool definitions are captured at conversation creation and
- * reused on each turn. MCP tool definitions are re-read from the global
- * registry on each turn so that tools registered after conversation creation
- * (e.g. via `vellum mcp reload`) are automatically picked up without
- * requiring conversation disposal or app restart.
+ * Core (non-MCP, non-workspace) tool definitions are captured at conversation
+ * creation and reused on each turn. MCP and workspace tool definitions are
+ * re-read from the global registry on each turn so that tools registered or
+ * changed after conversation creation are automatically picked up without
+ * requiring conversation disposal or app restart — MCP via `vellum mcp
+ * reload`, workspace tools via edits under `<workspaceDir>/tools/` that the
+ * per-turn reconcile (kicked below) folds into the registry.
  */
 export function createResolveToolsCallback(
   toolDefs: ToolDefinition[],
@@ -662,16 +665,30 @@ export function createResolveToolsCallback(
 ): ((history: Message[]) => ToolDefinition[]) | undefined {
   if (toolDefs.length === 0) return undefined;
 
-  // Separate the initial tool defs into core (stable) and MCP (dynamic).
-  // We keep core tools from the snapshot and re-read MCP tools each turn.
+  // Separate the initial tool defs into core (stable) and the dynamic
+  // categories (MCP, workspace, plugin). We keep core tools from the snapshot
+  // and re-read the dynamic categories from the registry each turn. They differ
+  // downstream: plugin tools flow through the same context filter + subagent
+  // allowlist as core, while MCP and workspace tools are added raw.
   const initialMcpDefs = getMcpToolDefinitions();
+  const initialPluginDefs = getPluginToolDefinitions();
   const initialMcpNames = new Set(initialMcpDefs.map((d) => d.name));
-  const coreToolDefs = toolDefs.filter((d) => !initialMcpNames.has(d.name));
+  const initialWorkspaceNames = new Set(getWorkspaceToolNames());
+  const initialPluginNames = new Set(initialPluginDefs.map((d) => d.name));
+  const coreToolDefs = toolDefs.filter(
+    (d) =>
+      !initialMcpNames.has(d.name) &&
+      !initialWorkspaceNames.has(d.name) &&
+      !initialPluginNames.has(d.name),
+  );
   log.debug(
     {
       coreCount: coreToolDefs.length,
       mcpCount: initialMcpDefs.length,
       mcpTools: initialMcpDefs.map((d) => d.name),
+      workspaceCount: initialWorkspaceNames.size,
+      pluginCount: initialPluginDefs.length,
+      pluginTools: initialPluginDefs.map((d) => d.name),
     },
     "Conversation tool resolver initialized",
   );
@@ -685,11 +702,25 @@ export function createResolveToolsCallback(
       return [];
     }
 
-    // Filter core tools based on current conversation context so that tools
-    // irrelevant to this turn (e.g. UI tools when no client is connected)
+    // Reconcile workspace tool overrides under `<workspaceDir>/tools/` into
+    // the registry, then re-read them below — the on-read replacement for a
+    // filesystem watcher. Fire-and-forget: the reconcile is idempotent,
+    // mtime-cached (a no-op costs one readdir + a stat per file) and
+    // serialized, so the registry settles for a subsequent turn to read.
+    void loadWorkspaceTools();
+
+    // Re-read plugin tool definitions from the registry each turn so a plugin
+    // installed/removed at runtime (activated by the per-turn scan in
+    // `plugins/mtime-cache.ts`) is picked up without recreating the
+    // conversation. Plugin tools share core's context filter + allowlist path,
+    // so combine them with the core snapshot before filtering.
+    const currentPluginDefs = getPluginToolDefinitions();
+
+    // Filter core + plugin tools based on current conversation context so that
+    // tools irrelevant to this turn (e.g. UI tools when no client is connected)
     // are omitted from the definitions sent to the provider.
-    const filteredCoreDefs = coreToolDefs.filter((d) =>
-      isToolActiveForContext(d.name, ctx),
+    const filteredCoreDefs = [...coreToolDefs, ...currentPluginDefs].filter(
+      (d) => isToolActiveForContext(d.name, ctx),
     );
 
     // When the conversation is acting as a subagent, restrict core tools to
@@ -705,24 +736,34 @@ export function createResolveToolsCallback(
       ? filteredCoreDefs.filter((d) => wireAllowlist.has(d.name))
       : filteredCoreDefs;
 
-    // Re-read MCP tool definitions from the registry each turn so conversations
-    // automatically pick up tools added/removed by `vellum mcp reload`.
+    // Re-read MCP and workspace tool definitions from the registry each turn
+    // so conversations automatically pick up tools added/removed by `vellum
+    // mcp reload` and workspace-tool edits reconciled from disk, without
+    // recreating the conversation.
     const currentMcpDefs = getMcpToolDefinitions();
+    const currentWorkspaceDefs = getWorkspaceToolDefinitions();
     log.debug(
       {
         coreCount: scopedCoreDefs.length,
         mcpCount: currentMcpDefs.length,
         mcpTools: currentMcpDefs.map((d) => d.name),
+        workspaceCount: currentWorkspaceDefs.length,
+        workspaceTools: currentWorkspaceDefs.map((d) => d.name),
       },
-      "MCP tools resolved for turn",
+      "MCP and workspace tools resolved for turn",
     );
     const scopedMcpDefs = wireAllowlist
       ? currentMcpDefs.filter((d) => wireAllowlist.has(d.name))
       : currentMcpDefs;
+    const scopedWorkspaceDefs = wireAllowlist
+      ? currentWorkspaceDefs.filter((d) => wireAllowlist.has(d.name))
+      : currentWorkspaceDefs;
     const excluded = new Set(getConfig().tools.exclude);
-    const allBaseDefs = [...scopedCoreDefs, ...scopedMcpDefs].filter(
-      (d) => !excluded.has(d.name),
-    );
+    const allBaseDefs = [
+      ...scopedCoreDefs,
+      ...scopedWorkspaceDefs,
+      ...scopedMcpDefs,
+    ].filter((d) => !excluded.has(d.name));
 
     const effectivePreactivated = [
       ...DEFAULT_PREACTIVATED_SKILL_IDS,

package/src/daemon/conversation.ts

@@ -50,6 +50,7 @@ import {
   getMessages,
   resolveOverrideProfile,
   setConversationHistoryStrippedAt,
+  setConversationProcessingStartedAt,
 } from "../memory/conversation-crud.js";
 import { getResolvedConversationDirPath } from "../memory/conversation-directories.js";
 import { ConversationGraphMemory } from "../memory/graph/conversation-graph-memory.js";
@@ -91,7 +92,7 @@ import {
   isActivationMomentParam,
 } from "../telemetry/activation-funnel.js";
 import { ToolExecutor } from "../tools/executor.js";
-import { getAllToolDefinitions } from "../tools/registry.js";
+import { getAllToolDefinitions, getTool } from "../tools/registry.js";
 import type { ToolLifecycleEvent } from "../tools/types.js";
 import type { OnboardingContext } from "../types/onboarding-context.js";
 import type { AbortReason } from "../util/abort-reasons.js";
@@ -242,6 +243,14 @@ export interface ConversationConstructorOptions {
   speedOverride?: Speed;
   cacheTtl?: "5m" | "1h";
   modelOverride?: string;
+  /**
+   * Give this conversation's LLM calls provider-native (server-side) web
+   * search when the resolved provider supports it (see
+   * {@link AgentLoopConfig.enableNativeWebSearch}). Set by the subagent manager
+   * for the tool-less advisor consult so it can ground guidance with live web
+   * access; non-native providers get nothing. Defaults to false.
+   */
+  enableNativeWebSearch?: boolean;
 }
 
 export class Conversation {
@@ -376,6 +385,7 @@ export class Conversation {
    */
   wakePersonaOverride?: SystemPromptPersonaOverride;
   /** @internal */ currentTurnOverrideProfile?: string;
+  /** @internal */ currentTurnIsNonInteractive?: boolean;
   /** @internal */ authContext?: AuthContext;
   /** @internal */ currentTurnAuthContext?: AuthContext;
   /** @internal */ currentTurnSourceActorPrincipalId?: string;
@@ -590,6 +600,7 @@ export class Conversation {
     options?: ConversationConstructorOptions,
   ) {
     const { maxTokens, speedOverride, cacheTtl, modelOverride } = options ?? {};
+    const enableNativeWebSearch = options?.enableNativeWebSearch ?? false;
     this.conversationId = conversationId;
     this.systemPrompt = systemPrompt;
     this.provider = provider;
@@ -688,6 +699,7 @@ export class Conversation {
         ? { speed: resolvedSpeed }
         : {}),
       ...(cacheTtl ? { cacheTtl } : {}),
+      ...(enableNativeWebSearch ? { enableNativeWebSearch: true } : {}),
     };
     if (configuredMaxTokens !== undefined) {
       agentLoopConfig.maxTokens = configuredMaxTokens;
@@ -701,6 +713,9 @@ export class Conversation {
       tools: toolDefs.length > 0 ? toolDefs : undefined,
       toolExecutor: toolDefs.length > 0 ? toolExecutor : undefined,
       resolveTools,
+      // A tool the registry marks exclusive (e.g. `advisor`) runs alone in its
+      // turn; the loop defers any sibling calls until the next turn.
+      isExclusiveTool: (name) => getTool(name)?.exclusive === true,
       resolveConversationDir: () => {
         const conv = getConversation(this.conversationId);
         if (!conv) return null;
@@ -1335,6 +1350,13 @@ export class Conversation {
   setProcessing(value: boolean): void {
     const wasProcessing = this._processing;
     this._processing = value;
+    // Persist the cross-process source of truth so out-of-process callers
+    // (retrospective CLI, future detached workers) can detect mid-turn state
+    // by reading the conversations row directly.
+    setConversationProcessingStartedAt(
+      this.conversationId,
+      value ? Date.now() : null,
+    );
     if (wasProcessing && !value) {
       void publishSyncInvalidation([
         conversationMetadataSyncTag(this.conversationId),

package/src/daemon/disk-pressure-guard.ts

@@ -24,6 +24,12 @@ export const DISK_PRESSURE_CLEAR_THRESHOLD_PERCENT = 90;
 // clears the warning state, which discards the banner's (state-scoped) dismissal
 // so it re-appears the moment usage ticks back up.
 export const DISK_PRESSURE_WARNING_CLEAR_THRESHOLD_PERCENT = 77;
+// Absolute free-space floor (MiB). Regardless of usage percentage, never enter
+// the warning or critical state while at least this much space remains free. A
+// high usage percentage on a large disk can still leave many gigabytes
+// available, where locking is pointless. Small volumes (where a high percentage
+// genuinely means near-full) drop below the floor and remain protected.
+export const DISK_PRESSURE_MIN_FREE_FLOOR_MB = 2048;
 export const DISK_PRESSURE_CHECK_INTERVAL_MS = 60_000;
 export const DISK_PRESSURE_OVERRIDE_CONFIRMATION = "I understand the risks";
 export const DISK_PRESSURE_BLOCKED_CAPABILITIES = [
@@ -219,7 +225,10 @@ export function evaluateDiskPressureNow(): DiskPressureStatus {
   const criticalThreshold = state.status.locked
     ? DISK_PRESSURE_CLEAR_THRESHOLD_PERCENT
     : DISK_PRESSURE_THRESHOLD_PERCENT;
-  const isCritical = usagePercent >= criticalThreshold;
+  // Absolute free-space floor overrides the percentage thresholds: while ample
+  // space remains free, report "ok" no matter how full the volume is by percent.
+  const hasAmpleFreeSpace = usageInfo.freeMb >= DISK_PRESSURE_MIN_FREE_FLOOR_MB;
+  const isCritical = !hasAmpleFreeSpace && usagePercent >= criticalThreshold;
   // Mirror the critical deadband for the warning band: once in an active
   // pressure state (warning or critical), hold warning until usage clears the
   // lower warning-clear threshold. Treating "critical" as active here matters
@@ -235,7 +244,8 @@ export function evaluateDiskPressureNow(): DiskPressureStatus {
   const warningThreshold = inActivePressureState
     ? DISK_PRESSURE_WARNING_CLEAR_THRESHOLD_PERCENT
     : DISK_PRESSURE_WARNING_THRESHOLD_PERCENT;
-  const isWarning = !isCritical && usagePercent >= warningThreshold;
+  const isWarning =
+    !hasAmpleFreeSpace && !isCritical && usagePercent >= warningThreshold;
   const lastCheckedAt = new Date().toISOString();
 
   if (!isCritical && !isWarning) {