vellum 0.2.0 → 0.2.1

package/src/calls/twilio-routes.ts

@@ -0,0 +1,236 @@
+/**
+ * HTTP route handlers for Twilio voice webhooks.
+ *
+ * - handleVoiceWebhook: initial voice webhook; returns TwiML to connect ConversationRelay
+ * - handleStatusCallback: call status updates (ringing, in-progress, completed, etc.)
+ * - handleConnectAction: called when the ConversationRelay connection ends
+ */
+
+import { getLogger } from '../util/logger.js';
+import {
+  getCallSession,
+  getCallSessionByCallSid,
+  updateCallSession,
+  recordCallEvent,
+  expirePendingQuestions,
+  getPendingQuestion,
+  answerPendingQuestion,
+} from './call-store.js';
+import type { CallStatus } from './types.js';
+import { getCallOrchestrator } from './call-state.js';
+
+const log = getLogger('twilio-routes');
+
+// ── Helpers ──────────────────────────────────────────────────────────
+
+function escapeXml(str: string): string {
+  return str
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&apos;');
+}
+
+function generateTwiML(callSessionId: string, wssBaseUrl: string, welcomeGreeting: string): string {
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<Response>
+  <Connect>
+    <ConversationRelay
+      url="${escapeXml(wssBaseUrl)}/v1/calls/relay?callSessionId=${escapeXml(callSessionId)}"
+      welcomeGreeting="${escapeXml(welcomeGreeting)}"
+      voice="Google.en-US-Journey-O"
+      language="en-US"
+      transcriptionProvider="Deepgram"
+      ttsProvider="Google"
+      interruptible="true"
+      dtmfDetection="true"
+    />
+  </Connect>
+</Response>`;
+}
+
+/**
+ * Map Twilio call status strings to our internal CallStatus.
+ */
+function mapTwilioStatus(twilioStatus: string): CallStatus | null {
+  switch (twilioStatus) {
+    case 'queued':
+    case 'ringing':
+      return 'ringing';
+    case 'in-progress':
+      return 'in_progress';
+    case 'completed':
+      return 'completed';
+    case 'failed':
+    case 'busy':
+    case 'no-answer':
+    case 'canceled':
+      return 'failed';
+    default:
+      return null;
+  }
+}
+
+// ── Route handlers ───────────────────────────────────────────────────
+
+/**
+ * Receives the initial voice webhook when Twilio connects the call.
+ * Returns TwiML XML that tells Twilio to open a ConversationRelay WebSocket.
+ */
+export async function handleVoiceWebhook(req: Request): Promise<Response> {
+  const url = new URL(req.url);
+  const callSessionId = url.searchParams.get('callSessionId');
+
+  if (!callSessionId) {
+    log.warn('Voice webhook called without callSessionId');
+    return new Response('Missing callSessionId', { status: 400 });
+  }
+
+  const session = getCallSession(callSessionId);
+  if (!session) {
+    log.warn({ callSessionId }, 'Voice webhook: call session not found');
+    return new Response('Call session not found', { status: 404 });
+  }
+
+  // Parse the Twilio POST body to capture CallSid immediately, so status
+  // callbacks (keyed by CallSid) can locate this session even if the
+  // WebSocket relay hasn't been set up yet.
+  const formBody = new URLSearchParams(await req.text());
+  const callSid = formBody.get('CallSid');
+  if (callSid && callSid !== session.providerCallSid) {
+    updateCallSession(callSessionId, { providerCallSid: callSid });
+    log.info({ callSessionId, callSid }, 'Stored CallSid from voice webhook');
+  }
+
+  const wssBaseUrl = process.env.WSS_BASE_URL ?? process.env.BASE_URL ?? 'wss://localhost:7821';
+  const welcomeGreeting = process.env.CALL_WELCOME_GREETING ?? 'Hello, how can I help you today?';
+
+  const twiml = generateTwiML(callSessionId, wssBaseUrl, welcomeGreeting);
+
+  log.info({ callSessionId }, 'Returning ConversationRelay TwiML');
+
+  return new Response(twiml, {
+    status: 200,
+    headers: { 'Content-Type': 'text/xml' },
+  });
+}
+
+/**
+ * Receives call status updates from Twilio (POST with form-urlencoded body).
+ * Updates the call session status and records events.
+ */
+export async function handleStatusCallback(req: Request): Promise<Response> {
+  const formBody = new URLSearchParams(await req.text());
+  const callSid = formBody.get('CallSid');
+  const callStatus = formBody.get('CallStatus');
+
+  if (!callSid || !callStatus) {
+    log.warn({ callSid, callStatus }, 'Status callback missing CallSid or CallStatus');
+    return new Response(null, { status: 200 });
+  }
+
+  log.info({ callSid, callStatus }, 'Twilio status callback received');
+
+  const session = getCallSessionByCallSid(callSid);
+  if (!session) {
+    log.warn({ callSid, callStatus }, 'Status callback: no call session found for CallSid');
+    return new Response(null, { status: 200 });
+  }
+
+  const mappedStatus = mapTwilioStatus(callStatus);
+  if (!mappedStatus) {
+    log.warn({ callSid, callStatus }, 'Status callback: unknown Twilio status');
+    return new Response(null, { status: 200 });
+  }
+
+  // Build updates
+  const updates: Parameters<typeof updateCallSession>[1] = {
+    status: mappedStatus,
+  };
+
+  if (mappedStatus === 'in_progress' && !session.startedAt) {
+    updates.startedAt = Date.now();
+  }
+
+  const isTerminal = mappedStatus === 'completed' || mappedStatus === 'failed';
+  if (isTerminal) {
+    updates.endedAt = Date.now();
+  }
+
+  updateCallSession(session.id, updates);
+
+  // Record event
+  const eventType = isTerminal
+    ? (mappedStatus === 'completed' ? 'call_ended' : 'call_failed')
+    : (mappedStatus === 'in_progress' ? 'call_connected' : 'call_started');
+
+  recordCallEvent(session.id, eventType, {
+    twilioStatus: callStatus,
+    callSid,
+  });
+
+  // Expire pending questions on terminal status
+  if (isTerminal) {
+    expirePendingQuestions(session.id);
+  }
+
+  return new Response(null, { status: 200 });
+}
+
+/**
+ * Called when the ConversationRelay connection ends.
+ * Returns empty TwiML to acknowledge.
+ */
+export async function handleConnectAction(_req: Request): Promise<Response> {
+  log.info('ConversationRelay connect-action callback received');
+  return new Response(
+    '<?xml version="1.0" encoding="UTF-8"?><Response/>',
+    {
+      status: 200,
+      headers: { 'Content-Type': 'text/xml' },
+    },
+  );
+}
+
+/**
+ * Answer a pending question for an active call.
+ * POST /v1/calls/:callSessionId/answer
+ * Body: { answer: string }
+ */
+export async function handleCallAnswer(req: Request, callSessionId: string): Promise<Response> {
+  const body = await req.json() as { answer?: string };
+  if (!body.answer) {
+    return Response.json({ error: 'Missing answer' }, { status: 400 });
+  }
+
+  const question = getPendingQuestion(callSessionId);
+  if (!question) {
+    return Response.json({ error: 'No pending question found' }, { status: 404 });
+  }
+
+  // Verify the orchestrator exists before attempting to route the answer.
+  const orchestrator = getCallOrchestrator(callSessionId);
+  if (!orchestrator) {
+    log.warn({ callSessionId }, 'handleCallAnswer: no active orchestrator for call session');
+    return Response.json({ error: 'No active orchestrator for this call' }, { status: 409 });
+  }
+
+  // Route answer to the orchestrator FIRST — it atomically checks whether it is
+  // in the `waiting_on_user` state and transitions to `processing`. Only persist
+  // the answer to the DB if the orchestrator actually accepted it, preventing a
+  // race where the consultation timer expires between our check and the persist.
+  const accepted = await orchestrator.handleUserAnswer(body.answer);
+  if (!accepted) {
+    log.warn(
+      { callSessionId },
+      'handleCallAnswer: orchestrator rejected the answer (not in waiting_on_user state)',
+    );
+    return Response.json({ error: 'Orchestrator is not waiting for an answer' }, { status: 409 });
+  }
+
+  // Mark question as answered — only after the orchestrator has accepted
+  answerPendingQuestion(question.id, body.answer);
+
+  return Response.json({ ok: true, questionId: question.id });
+}

package/src/calls/types.ts

@@ -0,0 +1,37 @@
+export type CallStatus = 'initiated' | 'ringing' | 'in_progress' | 'waiting_on_user' | 'completed' | 'failed';
+export type CallEventType = 'call_started' | 'call_connected' | 'caller_spoke' | 'assistant_spoke' | 'user_question_asked' | 'user_answered' | 'call_ended' | 'call_failed';
+export type PendingQuestionStatus = 'pending' | 'answered' | 'expired' | 'cancelled';
+
+export interface CallSession {
+  id: string;
+  conversationId: string;
+  provider: string;
+  providerCallSid: string | null;
+  fromNumber: string;
+  toNumber: string;
+  task: string | null;
+  status: CallStatus;
+  startedAt: number | null;
+  endedAt: number | null;
+  lastError: string | null;
+  createdAt: number;
+  updatedAt: number;
+}
+
+export interface CallEvent {
+  id: string;
+  callSessionId: string;
+  eventType: CallEventType;
+  payloadJson: string;
+  createdAt: number;
+}
+
+export interface CallPendingQuestion {
+  id: string;
+  callSessionId: string;
+  questionText: string;
+  status: PendingQuestionStatus;
+  askedAt: number;
+  answeredAt: number | null;
+  answerText: string | null;
+}

package/src/calls/voice-provider.ts

@@ -0,0 +1,14 @@
+export interface InitiateCallOptions {
+  from: string;
+  to: string;
+  webhookUrl: string;
+  statusCallbackUrl: string;
+  customParams?: Record<string, string>;
+}
+
+export interface VoiceProvider {
+  name: string;
+  initiateCall(opts: InitiateCallOptions): Promise<{ callSid: string }>;
+  endCall(callSid: string): Promise<void>;
+  getCallStatus(callSid: string): Promise<string>;
+}

package/src/cli/doordash.ts

@@ -139,8 +139,8 @@ export function registerDoordashCommand(program: Command): void {
   dd.command('refresh')
     .description(
       'Start a Ride Shotgun learn session to capture fresh DoorDash cookies. ' +
-      'Opens doordash.com in Chrome — sign in when prompted. ' +
-      'NOTE: Chrome will restart with debugging enabled; your tabs will be restored.',
+      'Opens doordash.com in a separate Chrome window — sign in when prompted. ' +
+      'Your existing Chrome and tabs are not affected.',
     )
     .option('--duration <seconds>', 'Recording duration in seconds', '180')
     .action(async (opts: { duration: string }, cmd: Command) => {
@@ -664,7 +664,7 @@ export function registerDoordashCommand(program: Command): void {
 // Chrome CDP restart helper
 // ---------------------------------------------------------------------------
 
-import { execSync, spawn as spawnChild } from 'node:child_process';
+import { spawn as spawnChild } from 'node:child_process';
 import { homedir } from 'node:os';
 import { join as pathJoin } from 'node:path';
 
@@ -687,27 +687,8 @@ async function ensureChromeWithCDP(): Promise<void> {
   // Already running with CDP?
   if (await isCdpReady()) return;
 
-  // Kill existing Chrome gracefully
-  try {
-    execSync('osascript -e \'tell application "Google Chrome" to quit\'', {
-      timeout: 5000,
-      stdio: 'ignore',
-    });
-  } catch {
-    // Chrome might not be running
-  }
-
-  // Wait for Chrome to quit
-  for (let i = 0; i < 30; i++) {
-    try {
-      execSync('pgrep -x "Google Chrome"', { stdio: 'ignore' });
-      await new Promise(r => setTimeout(r, 200));
-    } catch {
-      break; // Not running
-    }
-  }
-
-  // Relaunch Chrome with CDP flags
+  // Launch a separate Chrome instance with CDP flags alongside any existing Chrome.
+  // Using a dedicated --user-data-dir allows coexistence without killing the user's browser.
   const chromeApp =
     '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome';
   spawnChild(chromeApp, [

package/src/config/bundled-skills/doordash/SKILL.md

@@ -0,0 +1,104 @@
+---
+name: "DoorDash"
+description: "Order food, groceries, and convenience items from DoorDash using the built-in CLI integration"
+user-invocable: true
+metadata: {"vellum": {"emoji": "\uD83C\uDF55"}}
+---
+
+You can order food from DoorDash for the user using the `vellum doordash` CLI.
+
+## Task Progress Widget
+
+When executing a food ordering flow, show live progress using the `task_progress` card template. Before starting, call `ui_show` with:
+```json
+{
+  "surface_type": "card",
+  "template": "task_progress",
+  "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" }
+    ]
+  }
+}
+```
+As each step completes, call `ui_update` with the same surface ID to update step statuses. Add `detail` to completed steps (e.g. `"detail": "Found Andiamo's"`). Adapt the steps to the actual flow (e.g. skip "Search restaurants" if the user named a specific store).
+
+## Typical Flow
+
+When the user asks you to order food (e.g. "Order pizza from Andiamo's"):
+
+1. **Check session** — run `vellum doordash status --json`. If `loggedIn` is false or the session is expired, tell the user: "I need to capture your DoorDash session. A separate Chrome window will open — your existing Chrome and tabs are not affected. Please sign in to DoorDash when it opens, and I'll take it from there." Then run `vellum doordash refresh --json`. This starts a Ride Shotgun learn session that records your login and auto-stops once it detects you've signed in. The session is imported automatically. **This command blocks until login is complete — just wait for it.**
+
+2. **Search** — run `vellum doordash search "<query>" --json` to find matching restaurants. Present the top results to the user with name, rating, and delivery info. If the user named a specific restaurant, pick the best match. If ambiguous, ask.
+
+3. **Browse menu** — run `vellum doordash menu <storeId> --json` to get the menu. Show the user the categories and items with prices. If the user already said what they want (e.g. "pepperoni pizza"), find the matching item(s). **For convenience/pharmacy stores** (CVS, Duane Reade, Walgreens etc.), the response will have `isRetail: true` and empty items — use `store-search` instead (see step 3b).
+
+3b. **Search within a retail store** — for convenience/pharmacy stores, run `vellum doordash store-search <storeId> "<query>" --json` to find specific products. This returns items with IDs, prices, and menuIds that can be added to cart directly.
+
+4. **Get item details** (if needed) — run `vellum doordash item <storeId> <itemId> --json` to see options/customizations. If the item has required options (like size or toppings), ask the user or pick sensible defaults.
+
+5. **Add to cart** — run `vellum doordash cart add --store-id <id> --menu-id <id> --item-id <id> --item-name "<name>" --unit-price <cents> --json`. For subsequent items at the same store, pass `--cart-id <id>` from the first add response.
+
+6. **Review cart** — run `vellum doordash cart view <cartId> --json` and show the user what's in their cart with prices. Ask if they want to add anything else or proceed.
+
+7. **Checkout** — run `vellum doordash checkout <cartId> --json` to get delivery options. Present them to the user.
+
+8. **Payment methods** — run `vellum doordash payment-methods --json` to see saved cards. Show the user which card will be used (the default one).
+
+9. **Place order** — after the user explicitly confirms, run `vellum doordash order place --cart-id <id> --store-id <id> --total <cents> [--tip <cents>] [--dropoff-option <id>] --json`. The command auto-selects the default payment method if `--payment-uuid` is not provided. The response contains `orderUuid` on success.
+
+## Important Behavior
+
+- **Always confirm before checkout.** Never place an order without explicit user approval.
+- **Be proactive.** If the user says "order pizza from Andiamo's", don't ask clarifying questions upfront — search, find the store, show the menu, and suggest items. Only ask when you need a choice the user hasn't specified.
+- **Handle expired sessions gracefully.** If any command returns `"error": "session_expired"`, run `vellum doordash refresh --json` to re-capture the session.
+- **Show prices.** Always show prices when presenting items or the cart summary.
+- **Use `--json` flag** on all commands for reliable parsing.
+- **Do NOT use the browser skill.** All DoorDash interaction goes through the CLI, not browser automation.
+
+## Command Reference
+
+```
+vellum doordash status --json              # Check if logged in
+vellum doordash refresh --json             # Capture fresh session via Ride Shotgun (auto-stops after login)
+vellum doordash login --recording <path>   # Import session from a recording file manually
+vellum doordash logout --json              # Clear session
+vellum doordash search "<query>" --json    # Search restaurants
+vellum doordash menu <storeId> --json      # Get store menu (auto-detects retail stores)
+vellum doordash store-search <storeId> "<query>" --json  # Search items within a convenience/pharmacy store
+vellum doordash item <storeId> <itemId> --json  # Get item details + options
+vellum doordash cart add --store-id <id> --menu-id <id> --item-id <id> --item-name "<name>" --unit-price <cents> [--quantity <n>] [--cart-id <id>] --json
+vellum doordash cart remove --cart-id <id> --item-id <orderItemId> --json
+vellum doordash cart view <cartId> --json
+vellum doordash cart list [--store-id <id>] --json
+vellum doordash checkout <cartId> [--address-id <id>] --json
+vellum doordash payment-methods --json     # List saved payment methods
+vellum doordash order place --cart-id <id> --store-id <id> --total <cents> [--tip <cents>] [--delivery-option <type>] [--dropoff-option <id>] [--payment-uuid <uuid>] --json
+```
+
+## Example Interaction
+
+**User**: "Order a pepperoni pizza from Andiamo's"
+
+1. `vellum doordash status --json` -> logged in
+2. `vellum doordash search "Andiamo's" --json` -> finds store 22926474
+3. `vellum doordash menu 22926474 --json` -> finds "Pepperoni Pizza Pie" (item 2956709006, $28.00)
+4. Tell user: "I found Pepperoni Pizza Pie at Andiamo's for $28.00. Adding it to your cart."
+5. `vellum doordash cart add --store-id 22926474 --menu-id 12847574 --item-id 2956709006 --item-name "Pepperoni Pizza Pie" --unit-price 2800 --json`
+6. `vellum doordash cart view <cartId> --json` -> show summary
+7. "Your cart has 1x Pepperoni Pizza Pie ($28.00), total $28.00. Ready to check out?"
+
+**User**: "I need Tylenol from CVS"
+
+1. `vellum doordash status --json` -> logged in
+2. `vellum doordash search "CVS" --json` -> finds store 1231787
+3. `vellum doordash menu 1231787 --json` -> isRetail: true, categories but no items
+4. `vellum doordash store-search 1231787 "tylenol" --json` -> finds results
+5. Show top results: "Tylenol Extra Strength Gelcaps (24 ct) - $8.79, Tylenol Extra Strength Caplets (100 ct) - $13.49..."
+6. User picks one -> add to cart with the item's `id`, `menuId`, and `unitAmount`

package/src/config/bundled-skills/image-studio/TOOLS.json

@@ -25,8 +25,8 @@
           },
           "model": {
             "type": "string",
-            "enum": ["gemini-2.5-flash-image", "gemini-3-pro-image"],
-            "description": "Which model to use for generation (default: gemini-2.5-flash-image)"
+            "enum": ["gemini-2.5-flash-image", "gemini-3-pro-image", "gemini-3-pro-image-preview"],
+            "description": "Which model to use for generation. If omitted, uses the user's configured preference."
           },
           "variants": {
             "type": "number",

package/src/config/bundled-skills/image-studio/tools/media-generate-image.ts

@@ -57,7 +57,7 @@ export async function run(
   const prompt = input.prompt as string;
   const mode = (input.mode as 'generate' | 'edit') ?? 'generate';
   const attachmentIds = input.attachment_ids as string[] | undefined;
-  const model = input.model as string | undefined;
+  const model = (input.model as string | undefined) ?? config.imageGenModel;
   const variants = input.variants as number | undefined;
 
   // Resolve source images from attachments for edit mode

package/src/config/defaults.ts

@@ -4,6 +4,7 @@ import type { AssistantConfig } from './types.js';
 export const DEFAULT_CONFIG: AssistantConfig = {
   provider: 'anthropic',
   model: 'claude-opus-4-6', // alias: claude-opus-4
+  imageGenModel: 'gemini-2.5-flash-image',
   apiKeys: {},
   webSearchProvider: 'perplexity',
   providerOrder: [],
@@ -183,4 +184,14 @@ export const DEFAULT_CONFIG: AssistantConfig = {
     install: { nodeManager: 'npm' },
     allowBundled: null,
   },
+  workspaceGit: {
+    turnCommitMaxWaitMs: 4000,
+    failureBackoffBaseMs: 2000,
+    failureBackoffMaxMs: 60000,
+    interactiveGitTimeoutMs: 10000,
+    enrichmentQueueSize: 50,
+    enrichmentConcurrency: 1,
+    enrichmentJobTimeoutMs: 30000,
+    enrichmentMaxRetries: 2,
+  },
 };

package/src/config/schema.ts

@@ -703,6 +703,49 @@ export const SkillsInstallConfigSchema = z.object({
   }).default('npm'),
 });
 
+export const WorkspaceGitConfigSchema = z.object({
+  turnCommitMaxWaitMs: z
+    .number({ error: 'workspaceGit.turnCommitMaxWaitMs must be a number' })
+    .int('workspaceGit.turnCommitMaxWaitMs must be an integer')
+    .positive('workspaceGit.turnCommitMaxWaitMs must be a positive integer')
+    .default(4000),
+  failureBackoffBaseMs: z
+    .number({ error: 'workspaceGit.failureBackoffBaseMs must be a number' })
+    .int('workspaceGit.failureBackoffBaseMs must be an integer')
+    .positive('workspaceGit.failureBackoffBaseMs must be a positive integer')
+    .default(2000),
+  failureBackoffMaxMs: z
+    .number({ error: 'workspaceGit.failureBackoffMaxMs must be a number' })
+    .int('workspaceGit.failureBackoffMaxMs must be an integer')
+    .positive('workspaceGit.failureBackoffMaxMs must be a positive integer')
+    .default(60000),
+  interactiveGitTimeoutMs: z
+    .number({ error: 'workspaceGit.interactiveGitTimeoutMs must be a number' })
+    .int('workspaceGit.interactiveGitTimeoutMs must be an integer')
+    .positive('workspaceGit.interactiveGitTimeoutMs must be a positive integer')
+    .default(10000),
+  enrichmentQueueSize: z
+    .number({ error: 'workspaceGit.enrichmentQueueSize must be a number' })
+    .int('workspaceGit.enrichmentQueueSize must be an integer')
+    .positive('workspaceGit.enrichmentQueueSize must be a positive integer')
+    .default(50),
+  enrichmentConcurrency: z
+    .number({ error: 'workspaceGit.enrichmentConcurrency must be a number' })
+    .int('workspaceGit.enrichmentConcurrency must be an integer')
+    .positive('workspaceGit.enrichmentConcurrency must be a positive integer')
+    .default(1),
+  enrichmentJobTimeoutMs: z
+    .number({ error: 'workspaceGit.enrichmentJobTimeoutMs must be a number' })
+    .int('workspaceGit.enrichmentJobTimeoutMs must be an integer')
+    .positive('workspaceGit.enrichmentJobTimeoutMs must be a positive integer')
+    .default(30000),
+  enrichmentMaxRetries: z
+    .number({ error: 'workspaceGit.enrichmentMaxRetries must be a number' })
+    .int('workspaceGit.enrichmentMaxRetries must be an integer')
+    .nonnegative('workspaceGit.enrichmentMaxRetries must be non-negative')
+    .default(2),
+});
+
 export const SwarmConfigSchema = z.object({
   enabled: z
     .boolean({ error: 'swarm.enabled must be a boolean' })
@@ -754,6 +797,9 @@ export const AssistantConfigSchema = z.object({
   model: z
     .string({ error: 'model must be a string' })
     .default('claude-opus-4-6'),
+  imageGenModel: z
+    .string({ error: 'imageGenModel must be a string' })
+    .default('gemini-2.5-flash-image'),
   apiKeys: z
     .record(z.string(), z.string({ error: 'Each apiKeys value must be a string' }))
     .default({}),
@@ -947,6 +993,16 @@ export const AssistantConfigSchema = z.object({
     install: { nodeManager: 'npm' },
     allowBundled: null,
   }),
+  workspaceGit: WorkspaceGitConfigSchema.default({
+    turnCommitMaxWaitMs: 4000,
+    failureBackoffBaseMs: 2000,
+    failureBackoffMaxMs: 60000,
+    interactiveGitTimeoutMs: 10000,
+    enrichmentQueueSize: 50,
+    enrichmentConcurrency: 1,
+    enrichmentJobTimeoutMs: 30000,
+    enrichmentMaxRetries: 2,
+  }),
 }).superRefine((config, ctx) => {
   if (config.contextWindow.targetInputTokens >= config.contextWindow.maxInputTokens) {
     ctx.addIssue({
@@ -1002,3 +1058,4 @@ export type SkillsLoadConfig = z.infer<typeof SkillsLoadConfigSchema>;
 export type SkillsInstallConfig = z.infer<typeof SkillsInstallConfigSchema>;
 export type SwarmConfig = z.infer<typeof SwarmConfigSchema>;
 export type SkillsConfig = z.infer<typeof SkillsConfigSchema>;
+export type WorkspaceGitConfig = z.infer<typeof WorkspaceGitConfigSchema>;

package/src/config/system-prompt.ts

@@ -200,14 +200,26 @@ function buildTaskScheduleReminderRoutingSection(): string {
     '',
     'These three systems serve different purposes. Choose the right one based on user intent:',
     '',
-    '### Task Queue (task_list_add / task_list_show)',
+    '### Task Queue (task_list_add / task_list_show / task_list_update / task_list_remove)',
     'For tracking things the user wants to do or remember. Use when the user says:',
     '- "Add to my tasks", "add to my queue", "put this on my task list"',
     '- "Track this", "I need to do X", "queue this up"',
     '- Any request to add a one-off item to their personal to-do list',
     '',
+    'To modify an existing task, use `task_list_update`:',
+    '- "Bump the priority on X", "make X high priority", "move this up"',
+    '- "Change the status of X", "mark X as done"',
+    '- "Update the notes on X"',
+    'Do NOT use `task_list_add` for updates — it will detect duplicates and suggest using `task_list_update` instead.',
+    '',
+    'To remove a task from the queue, use `task_list_remove`:',
+    '- "Remove X from my tasks", "delete that task", "clean up the duplicate"',
+    '- "Take this off the list", "drop this task"',
+    '',
     'You can create ad-hoc work items by providing just a `title` to `task_list_add` — no existing task template is needed. A lightweight template is auto-created behind the scenes. For reusable task definitions with templates and input schemas, use `task_save` first.',
     '',
+    '**IMPORTANT:** When you call `task_list_show`, the Tasks window opens automatically on the client. Do NOT also create a separate surface/UI (via `ui_show` or `app_create`) to display the task queue. Doing so causes duplicate Task Queue windows. Just call `task_list_show` and let the native window handle the presentation.',
+    '',
     '### Schedules (schedule_create / schedule_list / schedule_update / schedule_delete)',
     'For recurring automated jobs that run on a cron schedule. Use ONLY when the user explicitly wants:',
     '- Recurring automation: "every day at 9am", "weekly on Mondays", "every hour"',
@@ -224,6 +236,25 @@ function buildTaskScheduleReminderRoutingSection(): string {
     '- "Remind me to buy groceries" without a time → task_list_add (it\'s a task, not a timed reminder)',
     '- "Remind me at 5pm to buy groceries" → reminder (explicit time trigger)',
     '- "Check my inbox every morning at 8am" → schedule_create (recurring automation)',
+    '- "Bump priority on X" → task_list_update (NOT task_list_add)',
+    '- "Move this up" / "change this task priority" → task_list_update (NOT task_list_add)',
+    '- "Mark X as done" → task_list_update (NOT task_list_add)',
+    '- "Remove X from my tasks" → task_list_remove (NOT task_list_update)',
+    '- "Delete that task" / "clean up the duplicate" → task_list_remove',
+    '',
+    '### Entity type routing: work items vs task templates',
+    '',
+    'There are two entity types with separate ID spaces:',
+    '- **Work items** (the user\'s task queue) — managed by task_list_add, task_list_show, task_list_update, task_list_remove',
+    '- **Task templates** (reusable definitions) — managed by task_save, task_list, task_run, task_delete',
+    '',
+    'Do NOT pass a work item ID to a task template tool or vice versa:',
+    '- Deleting a work item from the queue → task_list_remove (NOT task_delete)',
+    '- Deleting a task template → task_delete (NOT task_list_remove)',
+    '- Running a task template → task_run with task_id (NOT a work item ID)',
+    '- Updating a work item → task_list_update with work_item_id (NOT a task template ID)',
+    '',
+    'If an error says "entity mismatch", read the corrective action and selector fields it provides to pick the right tool.',
   ].join('\n');
 }
 
@@ -277,6 +308,7 @@ function buildDynamicUiSection(): string {
     '- **Tool auto-emissions** (e.g. `get_weather`): handled automatically — do nothing extra',
     '- **Predefined domain data** (flights, stocks): `ui_show` with `surface_type: "dynamic_page"` and domain component classes',
     '- **Simple structured data** (key-value, table, list): `ui_show` with `card`/`table`/`list`/`form` surface_type',
+    '- **Multi-step tasks** (ordering food, booking, purchasing, multi-phase workflows): `ui_show` with `card` surface_type + `template: "task_progress"` (see below)',
     '- **Interactive apps only**: `app_create` (calculators, dashboards, tools - NOT text content)',
     '',
     '### Loading app tools',
@@ -379,6 +411,23 @@ function buildDynamicUiSection(): string {
     '- **Data review/selection**: Use a `table` surface with selectable rows',
     '',
     'Interactive surfaces provide a better user experience than asking your user to type their choice. Only fall back to plain text when the interaction is conversational or doesn\'t fit a structured format.',
+    '',
+    '### Task progress for multi-step workflows',
+    'When executing a multi-step task (ordering food, booking a flight, purchasing, research with multiple phases), show live progress using the `task_progress` card template:',
+    '',
+    '1. **Before starting**, call `ui_show` with `surface_type: "card"`, `template: "task_progress"`, and `templateData`:',
+    '   ```json',
+    '   { "title": "Ordering from DoorDash", "status": "in_progress", "steps": [',
+    '     { "label": "Search restaurants", "status": "in_progress" },',
+    '     { "label": "Browse menu", "status": "pending" },',
+    '     { "label": "Add to cart", "status": "pending" },',
+    '     { "label": "Place order", "status": "pending" }',
+    '   ] }',
+    '   ```',
+    '2. **As each step completes**, call `ui_update` with the same surface ID to update step statuses and move to the next step. Add `detail` to completed steps (e.g. `"detail": "Found 3 nearby stores"`).',
+    '3. **On completion**, set the top-level `status` to `"completed"`. On failure, set it to `"failed"` and mark the failing step accordingly.',
+    '',
+    'Use this for ANY multi-step workflow where the user benefits from seeing structured progress instead of just "Running a command...".',
   ].join('\n');
 }
 

package/src/config/types.ts

@@ -29,4 +29,5 @@ export type {
   SkillsInstallConfig,
   SwarmConfig,
   SkillsConfig,
+  WorkspaceGitConfig,
 } from './schema.js';