vellum 0.2.0 → 0.2.2

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

@@ -6,7 +6,7 @@
  * keeping the constructor body focused on wiring.
  */
 
-import type { ToolDefinition } from '../providers/types.js';
+import type { Message, ToolDefinition } from '../providers/types.js';
 import type { ToolExecutionResult, ToolLifecycleEventHandler } from '../tools/types.js';
 import type { ServerMessage, UiSurfaceShow } from './ipc-protocol.js';
 import type { ToolExecutor } from '../tools/executor.js';
@@ -26,6 +26,7 @@ import type { SurfaceSessionContext } from './session-surfaces.js';
 import { updatePublishedAppDeployment } from '../services/published-app-updater.js';
 import { registerSessionSender } from '../tools/browser/browser-screencast.js';
 import type { ProxyApprovalCallback, ProxyApprovalRequest } from '../tools/network/script-proxy/index.js';
+import { projectSkillTools, type SkillProjectionCache } from './session-skill-tools.js';
 
 // ── Context Interface ────────────────────────────────────────────────
 
@@ -46,6 +47,10 @@ export interface ToolSetupContext extends SurfaceSessionContext {
   memoryPolicy: { scopeId: string; strictSideEffects: boolean };
   /** True when the session has no connected IPC client (HTTP-only path). */
   hasNoClient?: boolean;
+  /** When true, the session is executing a task run and must not become interactive. */
+  headlessLock?: boolean;
+  /** When set, this session is executing a task run. Used to retrieve ephemeral permission rules. */
+  taskRunId?: string;
 }
 
 // ── buildToolDefinitions ─────────────────────────────────────────────
@@ -65,6 +70,59 @@ export function buildToolDefinitions(): ToolDefinition[] {
   ];
 }
 
+// ── DoorDash task_progress auto-update ────────────────────────────────
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+interface DoordashStep { label: string; status: string; detail?: string }
+
+/**
+ * Map a `vellum doordash <subcommand>` to the step label it corresponds to.
+ */
+function doordashCommandToStep(cmd: string): string | null {
+  if (/vellum doordash status\b/.test(cmd) || /vellum doordash refresh\b/.test(cmd) || /vellum doordash login\b/.test(cmd)) return 'Check session';
+  if (/vellum doordash search\b/.test(cmd) || /vellum doordash search-items\b/.test(cmd)) return 'Search restaurants';
+  if (/vellum doordash menu\b/.test(cmd) || /vellum doordash item\b/.test(cmd) || /vellum doordash store-search\b/.test(cmd)) return 'Browse menu';
+  if (/vellum doordash cart\b/.test(cmd)) return 'Add to cart';
+  if (/vellum doordash checkout\b/.test(cmd) || /vellum doordash payment-methods\b/.test(cmd)) return 'Add to cart';
+  if (/vellum doordash order\b/.test(cmd)) return 'Place order';
+  return null;
+}
+
+/**
+ * Given a completed DoorDash CLI command, return updated steps array or null if no change.
+ */
+function updateDoordashSteps(cmd: string, steps: DoordashStep[], isError: boolean): DoordashStep[] | null {
+  const stepLabel = doordashCommandToStep(cmd);
+  if (!stepLabel) return null;
+
+  const stepIndex = steps.findIndex(s => s.label === stepLabel);
+  if (stepIndex < 0) return null;
+
+  const updated = steps.map((s, i) => {
+    if (i < stepIndex) {
+      // Steps before current should be completed
+      return s.status === 'completed' ? s : { ...s, status: 'completed' };
+    }
+    if (i === stepIndex) {
+      if (isError) {
+        // If the command failed, mark as in_progress still (will retry)
+        return { ...s, status: 'in_progress' };
+      }
+      return { ...s, status: 'completed' };
+    }
+    if (i === stepIndex + 1 && !isError) {
+      // Next step becomes waiting (user may need to respond before it starts)
+      return { ...s, status: 'waiting' };
+    }
+    return s;
+  });
+
+  return updated;
+}
+
 // ── createToolExecutor ───────────────────────────────────────────────
 
 /**
@@ -85,11 +143,47 @@ export function createToolExecutor(
   registerSessionSender(ctx.conversationId, (msg) => ctx.sendToClient(msg));
 
   return async (name: string, input: Record<string, unknown>, onOutput?: (chunk: string) => void) => {
+    // Pre-execution: mark the current DoorDash step as in_progress when command starts
+    if (name === 'bash' || name === 'host_bash') {
+      const preCmd = input.command as string | undefined;
+      if (preCmd?.includes('vellum doordash')) {
+        const surfaceId = 'doordash-progress';
+        const stored = ctx.surfaceState.get(surfaceId);
+        if (stored && stored.surfaceType === 'card') {
+          const card = stored.data as import('./ipc-contract.js').CardSurfaceData;
+          if (card.template === 'task_progress' && isPlainObject(card.templateData)) {
+            const steps = (card.templateData as Record<string, unknown>).steps;
+            if (Array.isArray(steps)) {
+              const stepLabel = doordashCommandToStep(preCmd);
+              if (stepLabel) {
+                const stepIndex = (steps as DoordashStep[]).findIndex(s => s.label === stepLabel);
+                if (stepIndex >= 0 && (steps as DoordashStep[])[stepIndex].status !== 'in_progress') {
+                  const updatedSteps = (steps as DoordashStep[]).map((s, i) =>
+                    i === stepIndex ? { ...s, status: 'in_progress' } : s
+                  );
+                  const updatedTemplateData = { ...card.templateData as Record<string, unknown>, steps: updatedSteps };
+                  const updatedData = { ...card, templateData: updatedTemplateData };
+                  stored.data = updatedData as import('./ipc-contract.js').CardSurfaceData;
+                  ctx.sendToClient({
+                    type: 'ui_surface_update',
+                    sessionId: ctx.conversationId,
+                    surfaceId,
+                    data: updatedData,
+                  });
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+
     const result = await executor.execute(name, input, {
       workingDir: ctx.workingDir,
       sessionId: ctx.conversationId,
       conversationId: ctx.conversationId,
       requestId: ctx.currentRequestId,
+      taskRunId: ctx.taskRunId,
       onOutput,
       signal: ctx.abortController?.signal,
       sandboxOverride: ctx.sandboxOverride,
@@ -114,7 +208,7 @@ export function createToolExecutor(
           });
         }
       },
-      isInteractive: !ctx.hasNoClient,
+      isInteractive: !ctx.hasNoClient && !ctx.headlessLock,
       proxyToolResolver: (toolName: string, proxyInput: Record<string, unknown>) => surfaceProxyResolver(ctx, toolName, proxyInput),
       proxyApprovalCallback: createProxyApprovalCallback(prompter, ctx),
       requestSecret: async (params) => {
@@ -181,6 +275,12 @@ export function createToolExecutor(
       ctx.sendToClient({ type: 'open_tasks_window' });
     }
 
+    // Broadcast tasks_changed so connected clients (e.g. macOS Tasks window)
+    // auto-refresh when the LLM mutates the task queue via tools
+    if ((name === 'task_list_add' || name === 'task_list_update' || name === 'task_list_remove') && !result.isError) {
+      broadcastToAllClients?.({ type: 'tasks_changed' });
+    }
+
     // Auto-refresh workspace surfaces when app files are edited
     if ((name === 'app_file_edit' || name === 'app_file_write') && !result.isError) {
       const appId = input.app_id as string | undefined;
@@ -192,6 +292,74 @@ export function createToolExecutor(
       }
     }
 
+    // Auto-emit task_progress card on first DoorDash CLI command
+    if (name === 'bash' || name === 'host_bash') {
+      const cmd = input.command as string | undefined;
+      if (cmd?.includes('vellum doordash')) {
+        const surfaceId = 'doordash-progress';
+
+        if (!ctx.surfaceState.has(surfaceId)) {
+          // First DoorDash command — auto-emit the task_progress card
+          const data = {
+            title: 'Ordering from DoorDash',
+            body: '',
+            template: 'task_progress' as const,
+            templateData: {
+              title: 'Ordering from DoorDash',
+              status: 'in_progress',
+              steps: [
+                { label: 'Check session', status: 'in_progress' },
+                { label: 'Search restaurants', status: 'pending' },
+                { label: 'Browse menu', status: 'pending' },
+                { label: 'Add to cart', status: 'pending' },
+                { label: 'Place order', status: 'pending' },
+              ],
+            },
+          } satisfies import('./ipc-contract.js').CardSurfaceData;
+          ctx.surfaceState.set(surfaceId, { surfaceType: 'card', data });
+          ctx.sendToClient({
+            type: 'ui_surface_show',
+            sessionId: ctx.conversationId,
+            surfaceId,
+            surfaceType: 'card',
+            title: 'Ordering from DoorDash',
+            data,
+            display: 'inline',
+          });
+          ctx.currentTurnSurfaces.push({
+            surfaceId,
+            surfaceType: 'card',
+            title: 'Ordering from DoorDash',
+            data,
+            display: 'inline',
+          });
+        }
+
+        // Auto-update step statuses based on the command that just ran
+        const stored = ctx.surfaceState.get(surfaceId);
+        if (stored && stored.surfaceType === 'card') {
+          const card = stored.data as import('./ipc-contract.js').CardSurfaceData;
+          if (card.template === 'task_progress' && isPlainObject(card.templateData)) {
+            const steps = (card.templateData as Record<string, unknown>).steps;
+            if (Array.isArray(steps)) {
+              const updatedSteps = updateDoordashSteps(cmd, steps as Array<{ label: string; status: string; detail?: string }>, result.isError);
+              if (updatedSteps) {
+                const updatedTemplateData = { ...card.templateData as Record<string, unknown>, steps: updatedSteps };
+                const updatedData = { ...card, templateData: updatedTemplateData };
+                stored.data = updatedData as import('./ipc-contract.js').CardSurfaceData;
+                ctx.sendToClient({
+                  type: 'ui_surface_update',
+                  sessionId: ctx.conversationId,
+                  surfaceId,
+                  data: updatedData,
+                });
+              }
+            }
+          }
+        }
+      }
+    }
+
     return result;
   };
 }
@@ -284,3 +452,55 @@ export function createProxyApprovalCallback(
       || response.decision === 'always_allow_high_risk';
   };
 }
+
+// ── createResolveToolsCallback ───────────────────────────────────────
+
+/**
+ * Bundled skills that must always be active regardless of conversation
+ * history or explicit preactivation. Without this, their tools are
+ * unavailable in fresh sessions until `skill_load` is called.
+ */
+const DEFAULT_PREACTIVATED_SKILL_IDS = ['tasks'];
+
+/**
+ * Subset of Session state that the resolveTools callback reads at each
+ * agent turn. Properties are read lazily from this reference.
+ */
+export interface SkillProjectionContext {
+  preactivatedSkillIds?: string[];
+  readonly skillProjectionState: Map<string, string>;
+  readonly skillProjectionCache: SkillProjectionCache;
+  readonly coreToolNames: Set<string>;
+  allowedToolNames?: Set<string>;
+}
+
+/**
+ * Build a resolveTools callback that merges base tool definitions with
+ * dynamically projected skill tools on each agent turn. Also updates
+ * allowedToolNames so newly-activated skill tools aren't blocked by
+ * the executor's stale gate.
+ */
+export function createResolveToolsCallback(
+  toolDefs: ToolDefinition[],
+  ctx: SkillProjectionContext,
+): ((history: Message[]) => ToolDefinition[]) | undefined {
+  if (toolDefs.length === 0) return undefined;
+
+  return (history: Message[]) => {
+    const effectivePreactivated = [
+      ...DEFAULT_PREACTIVATED_SKILL_IDS,
+      ...(ctx.preactivatedSkillIds ?? []),
+    ];
+    const projection = projectSkillTools(history, {
+      preactivatedSkillIds: effectivePreactivated,
+      previouslyActiveSkillIds: ctx.skillProjectionState,
+      cache: ctx.skillProjectionCache,
+    });
+    const turnAllowed = new Set(ctx.coreToolNames);
+    for (const name of projection.allowedToolNames) {
+      turnAllowed.add(name);
+    }
+    ctx.allowedToolNames = turnAllowed;
+    return [...toolDefs, ...projection.toolDefinitions];
+  };
+}

package/src/daemon/session-usage.ts

@@ -11,7 +11,6 @@ const log = getLogger('session-usage');
 export interface UsageContext {
   conversationId: string;
   providerName: string;
-  assistantId: string | null;
   usageStats: UsageStats;
 }
 
@@ -60,7 +59,6 @@ export function recordUsage(
         outputTokens,
         cacheCreationInputTokens: null,
         cacheReadInputTokens: null,
-        assistantId: ctx.assistantId,
         conversationId: ctx.conversationId,
         runId: null,
         requestId,