vellum 0.2.0 → 0.2.1

package/src/daemon/handlers/config.ts

@@ -10,6 +10,7 @@ import { postToSlackWebhook } from '../../slack/slack-webhook.js';
 import { getApp } from '../../memory/app-store.js';
 import type {
   ModelSetRequest,
+  ImageGenModelSetRequest,
   AddTrustRule,
   RemoveTrustRule,
   UpdateTrustRule,
@@ -126,6 +127,35 @@ export function handleModelSet(
   }
 }
 
+export function handleImageGenModelSet(
+  msg: ImageGenModelSetRequest,
+  _socket: net.Socket,
+  ctx: HandlerContext,
+): void {
+  try {
+    const raw = loadRawConfig();
+    raw.imageGenModel = msg.model;
+
+    ctx.setSuppressConfigReload(true);
+    try {
+      saveRawConfig(raw);
+    } catch (err) {
+      ctx.setSuppressConfigReload(false);
+      throw err;
+    }
+    const existingSuppressTimer = ctx.debounceTimers.get('__suppress_reset__');
+    if (existingSuppressTimer) clearTimeout(existingSuppressTimer);
+    const resetTimer = setTimeout(() => { ctx.setSuppressConfigReload(false); }, 300);
+    ctx.debounceTimers.set('__suppress_reset__', resetTimer);
+
+    ctx.updateConfigFingerprint();
+    log.info({ model: msg.model }, 'Image generation model updated');
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    log.error({ err }, `Failed to set image gen model: ${message}`);
+  }
+}
+
 export function handleAddTrustRule(
   msg: AddTrustRule,
   _socket: net.Socket,

package/src/daemon/handlers/index.ts

@@ -55,6 +55,7 @@ import {
 import {
   handleModelGet,
   handleModelSet,
+  handleImageGenModelSet,
   handleAddTrustRule,
   handleTrustRulesList,
   handleRemoveTrustRule,
@@ -103,7 +104,9 @@ import {
   handleWorkItemCreate,
   handleWorkItemUpdate,
   handleWorkItemComplete,
+  handleWorkItemDelete,
   handleWorkItemRunTask,
+  handleWorkItemOutput,
 } from './work-items.js';
 
 import {
@@ -152,6 +155,7 @@ const handlers: DispatchMap = {
   delete_queued_message: handleDeleteQueuedMessage,
   model_get: (_msg, socket, ctx) => handleModelGet(socket, ctx),
   model_set: handleModelSet,
+  image_gen_model_set: handleImageGenModelSet,
   history_request: handleHistoryRequest,
   undo: handleUndo,
   regenerate: handleRegenerate,
@@ -329,7 +333,9 @@ const handlers: DispatchMap = {
   work_item_create: handleWorkItemCreate,
   work_item_update: handleWorkItemUpdate,
   work_item_complete: handleWorkItemComplete,
+  work_item_delete: handleWorkItemDelete,
   work_item_run_task: handleWorkItemRunTask,
+  work_item_output: handleWorkItemOutput,
 
   subagent_abort: handleSubagentAbort,
   subagent_status: handleSubagentStatus,

package/src/daemon/handlers/work-items.ts

@@ -5,18 +5,22 @@ import type {
   WorkItemCreateRequest,
   WorkItemUpdateRequest,
   WorkItemCompleteRequest,
+  WorkItemDeleteRequest,
   WorkItemRunTaskRequest,
+  WorkItemOutputRequest,
 } from '../ipc-protocol.js';
 import { log, type HandlerContext } from './shared.js';
 import {
   createWorkItem,
+  deleteWorkItem,
   getWorkItem,
   listWorkItems,
   updateWorkItem,
   type WorkItemStatus,
 } from '../../work-items/work-item-store.js';
-import { getTask } from '../../tasks/task-store.js';
+import { getTask, getTaskRun } from '../../tasks/task-store.js';
 import { runTask } from '../../tasks/task-runner.js';
+import { getMessages } from '../../memory/conversation-store.js';
 
 export function handleWorkItemsList(
   msg: WorkItemsListRequest,
@@ -57,6 +61,7 @@ export function handleWorkItemCreate(
 
   // Notify all connected clients so open Task Queue views refresh immediately
   broadcastWorkItemStatus(ctx, item.id);
+  ctx.broadcast({ type: 'tasks_changed' });
 }
 
 export function handleWorkItemUpdate(
@@ -78,6 +83,7 @@ export function handleWorkItemUpdate(
   // (e.g. priority/sort changes made by one client are reflected everywhere)
   if (item) {
     broadcastWorkItemStatus(ctx, item.id);
+    ctx.broadcast({ type: 'tasks_changed' });
   }
 }
 
@@ -86,6 +92,18 @@ export function handleWorkItemComplete(
   socket: net.Socket,
   ctx: HandlerContext,
 ): void {
+  // Only allow completion from the 'awaiting_review' state — this ensures
+  // items go through the full run lifecycle before being marked done.
+  const existing = getWorkItem(msg.id);
+  if (!existing) {
+    ctx.send(socket, { type: 'error', message: `Work item not found: ${msg.id}` });
+    return;
+  }
+  if (existing.status !== 'awaiting_review') {
+    ctx.send(socket, { type: 'error', message: `Cannot complete work item: status is '${existing.status}', expected 'awaiting_review'` });
+    return;
+  }
+
   const item = updateWorkItem(msg.id, { status: 'done' }) ?? null;
   ctx.send(socket, { type: 'work_item_update_response', item });
   if (item) {
@@ -102,9 +120,25 @@ export function handleWorkItemComplete(
         updatedAt: item.updatedAt,
       },
     });
+    ctx.broadcast({ type: 'tasks_changed' });
   }
 }
 
+export function handleWorkItemDelete(
+  msg: WorkItemDeleteRequest,
+  socket: net.Socket,
+  ctx: HandlerContext,
+): void {
+  const existing = getWorkItem(msg.id);
+  if (!existing) {
+    ctx.send(socket, { type: 'work_item_delete_response', id: msg.id, success: false });
+    return;
+  }
+  deleteWorkItem(msg.id);
+  ctx.send(socket, { type: 'work_item_delete_response', id: msg.id, success: true });
+  ctx.broadcast({ type: 'tasks_changed' });
+}
+
 function broadcastWorkItemStatus(ctx: HandlerContext, id: string): void {
   const item = getWorkItem(id);
   if (item) {
@@ -124,6 +158,92 @@ function broadcastWorkItemStatus(ctx: HandlerContext, id: string): void {
   }
 }
 
+export function handleWorkItemOutput(
+  msg: WorkItemOutputRequest,
+  socket: net.Socket,
+  ctx: HandlerContext,
+): void {
+  try {
+    const workItem = getWorkItem(msg.id);
+    if (!workItem) {
+      ctx.send(socket, { type: 'work_item_output_response', id: msg.id, success: false, error: 'Work item not found' });
+      return;
+    }
+
+    // If the work item has never been run, return an error so the client
+    // can show "No output yet" instead of an empty loaded state.
+    if (!workItem.lastRunConversationId) {
+      ctx.send(socket, { type: 'work_item_output_response', id: msg.id, success: false, error: 'This task has not been run yet. No output is available.' });
+      return;
+    }
+
+    let summary = '';
+    const highlights: string[] = [];
+
+    const msgs = getMessages(workItem.lastRunConversationId);
+    // Find the last assistant message with text content (not tool calls)
+    for (let i = msgs.length - 1; i >= 0; i--) {
+      const m = msgs[i];
+      if (m.role !== 'assistant') continue;
+
+      let text = m.content;
+      // Content may be JSON array of content blocks — extract text blocks only
+      try {
+        const parsed = JSON.parse(text);
+        if (Array.isArray(parsed)) {
+          text = parsed
+            .filter((b: { type: string }) => b.type === 'text')
+            .map((b: { text: string }) => b.text)
+            .join('\n');
+        }
+      } catch {
+        // Plain text content — use as-is
+      }
+
+      if (!text.trim()) continue;
+
+      summary = text.length > 2000 ? text.slice(0, 2000) : text;
+
+      // Extract up to 5 notable lines (bullet points or key findings)
+      const lines = text.split('\n');
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if ((trimmed.startsWith('-') || trimmed.startsWith('*')) && trimmed.length > 2) {
+          highlights.push(trimmed);
+          if (highlights.length >= 5) break;
+        }
+      }
+      break;
+    }
+
+    // Convert finishedAt from milliseconds (Date.now()) to seconds for the
+    // client, which uses Date(timeIntervalSince1970:) expecting seconds.
+    let completedAt: number | null = null;
+    if (workItem.lastRunId) {
+      const run = getTaskRun(workItem.lastRunId);
+      completedAt = run?.finishedAt != null ? Math.floor(run.finishedAt / 1000) : null;
+    }
+
+    ctx.send(socket, {
+      type: 'work_item_output_response',
+      id: msg.id,
+      success: true,
+      output: {
+        title: workItem.title,
+        status: workItem.lastRunStatus ?? workItem.status,
+        runId: workItem.lastRunId,
+        conversationId: workItem.lastRunConversationId,
+        completedAt,
+        summary,
+        highlights,
+      },
+    });
+  } catch (err) {
+    log.error({ err, workItemId: msg.id }, 'handleWorkItemOutput failed');
+    ctx.send(socket, { type: 'work_item_output_response', id: msg.id, success: false, error: 'Failed to load task output' });
+  }
+}
+
 export async function handleWorkItemRunTask(
   msg: WorkItemRunTaskRequest,
   socket: net.Socket,
@@ -131,7 +251,24 @@ export async function handleWorkItemRunTask(
 ): Promise<void> {
   const workItem = getWorkItem(msg.id);
   if (!workItem) {
-    ctx.send(socket, { type: 'work_item_run_task_response', id: msg.id, lastRunId: '', success: false, error: 'Work item not found' });
+    ctx.send(socket, { type: 'work_item_run_task_response', id: msg.id, lastRunId: '', success: false, error: 'Work item not found', errorCode: 'not_found' });
+    return;
+  }
+
+  if (workItem.status === 'running') {
+    ctx.send(socket, { type: 'work_item_run_task_response', id: msg.id, lastRunId: workItem.lastRunId ?? '', success: false, error: 'Work item is already running', errorCode: 'already_running' });
+    return;
+  }
+
+  const NON_RUNNABLE_STATUSES: readonly string[] = ['done', 'archived'];
+  if (NON_RUNNABLE_STATUSES.includes(workItem.status)) {
+    ctx.send(socket, { type: 'work_item_run_task_response', id: msg.id, lastRunId: workItem.lastRunId ?? '', success: false, error: `Work item has status '${workItem.status}' and cannot be run`, errorCode: 'invalid_status' });
+    return;
+  }
+
+  const task = getTask(workItem.taskId);
+  if (!task) {
+    ctx.send(socket, { type: 'work_item_run_task_response', id: msg.id, lastRunId: '', success: false, error: `Associated task not found: ${workItem.taskId}`, errorCode: 'no_task' });
     return;
   }
 
@@ -143,6 +280,7 @@ export async function handleWorkItemRunTask(
 
   // Broadcast the running state
   broadcastWorkItemStatus(ctx, msg.id);
+  ctx.broadcast({ type: 'tasks_changed' });
 
   // Execute task asynchronously — create a session and wire processMessage
   try {
@@ -165,6 +303,7 @@ export async function handleWorkItemRunTask(
     });
 
     broadcastWorkItemStatus(ctx, msg.id);
+    ctx.broadcast({ type: 'tasks_changed' });
   } catch (err) {
     log.error({ err, workItemId: msg.id }, 'work_item_run_task failed');
     updateWorkItem(msg.id, {
@@ -172,5 +311,6 @@ export async function handleWorkItemRunTask(
       lastRunStatus: 'failed',
     });
     broadcastWorkItemStatus(ctx, msg.id);
+    ctx.broadcast({ type: 'tasks_changed' });
   }
 }

package/src/daemon/ipc-contract-inventory.json

@@ -31,6 +31,7 @@
     "GetSigningIdentityResponse",
     "HistoryRequest",
     "HomeBaseGetRequest",
+    "ImageGenModelSetRequest",
     "IntegrationConnectRequest",
     "IntegrationDisconnectRequest",
     "IntegrationListRequest",
@@ -90,7 +91,9 @@
     "WatchObservation",
     "WorkItemCompleteRequest",
     "WorkItemCreateRequest",
+    "WorkItemDeleteRequest",
     "WorkItemGetRequest",
+    "WorkItemOutputRequest",
     "WorkItemRunTaskRequest",
     "WorkItemUpdateRequest",
     "WorkItemsListRequest"
@@ -174,6 +177,7 @@
     "SubagentStatusChanged",
     "SuggestionResponse",
     "TaskRouted",
+    "TasksChanged",
     "ToolInputDelta",
     "ToolOutputChunk",
     "ToolResult",
@@ -196,7 +200,9 @@
     "WatcherEscalation",
     "WatcherNotification",
     "WorkItemCreateResponse",
+    "WorkItemDeleteResponse",
     "WorkItemGetResponse",
+    "WorkItemOutputResponse",
     "WorkItemRunTaskResponse",
     "WorkItemStatusChanged",
     "WorkItemUpdateResponse",
@@ -234,6 +240,7 @@
     "get_signing_identity_response",
     "history_request",
     "home_base_get",
+    "image_gen_model_set",
     "integration_connect",
     "integration_disconnect",
     "integration_list",
@@ -293,7 +300,9 @@
     "watch_observation",
     "work_item_complete",
     "work_item_create",
+    "work_item_delete",
     "work_item_get",
+    "work_item_output",
     "work_item_run_task",
     "work_item_update",
     "work_items_list"
@@ -377,6 +386,7 @@
     "subagent_status_changed",
     "suggestion_response",
     "task_routed",
+    "tasks_changed",
     "tool_input_delta",
     "tool_output_chunk",
     "tool_result",
@@ -398,7 +408,9 @@
     "watcher_escalation",
     "watcher_notification",
     "work_item_create_response",
+    "work_item_delete_response",
     "work_item_get_response",
+    "work_item_output_response",
     "work_item_run_task_response",
     "work_item_status_changed",
     "work_item_update_response",

package/src/daemon/ipc-contract.ts

@@ -125,6 +125,11 @@ export interface ModelSetRequest {
   model: string;
 }
 
+export interface ImageGenModelSetRequest {
+  type: 'image_gen_model_set';
+  model: string;
+}
+
 export interface HistoryRequest {
   type: 'history_request';
   sessionId: string;
@@ -793,11 +798,21 @@ export interface WorkItemCompleteRequest {
   id: string;
 }
 
+export interface WorkItemDeleteRequest {
+  type: 'work_item_delete';
+  id: string;
+}
+
 export interface WorkItemRunTaskRequest {
   type: 'work_item_run_task';
   id: string;
 }
 
+export interface WorkItemOutputRequest {
+  type: 'work_item_output';
+  id: string;
+}
+
 export type ClientMessage =
   | AuthMessage
   | UserMessage
@@ -811,6 +826,7 @@ export type ClientMessage =
   | DeleteQueuedMessage
   | ModelGetRequest
   | ModelSetRequest
+  | ImageGenModelSetRequest
   | HistoryRequest
   | UndoRequest
   | RegenerateRequest
@@ -889,7 +905,9 @@ export type ClientMessage =
   | WorkItemCreateRequest
   | WorkItemUpdateRequest
   | WorkItemCompleteRequest
+  | WorkItemDeleteRequest
   | WorkItemRunTaskRequest
+  | WorkItemOutputRequest
   | SubagentAbortRequest
   | SubagentStatusRequest
   | SubagentMessageRequest;
@@ -1914,12 +1932,38 @@ export interface WorkItemUpdateResponse {
   } | null;
 }
 
+export interface WorkItemDeleteResponse {
+  type: 'work_item_delete_response';
+  id: string;
+  success: boolean;
+}
+
+export type WorkItemRunTaskErrorCode = 'not_found' | 'already_running' | 'invalid_status' | 'no_task';
+
 export interface WorkItemRunTaskResponse {
   type: 'work_item_run_task_response';
   id: string;
   lastRunId: string;
   success: boolean;
   error?: string;
+  /** Structured error code so the client can deterministically re-enable buttons or show contextual UI. */
+  errorCode?: WorkItemRunTaskErrorCode;
+}
+
+export interface WorkItemOutputResponse {
+  type: 'work_item_output_response';
+  id: string;
+  success: boolean;
+  error?: string;
+  output?: {
+    title: string;
+    status: string;
+    runId: string | null;
+    conversationId: string | null;
+    completedAt: number | null;
+    summary: string;
+    highlights: string[];
+  };
 }
 
 /** Server push — tells the client to open/focus the tasks window. */
@@ -1927,6 +1971,11 @@ export interface OpenTasksWindow {
   type: 'open_tasks_window';
 }
 
+/** Server push — lightweight invalidation signal: the task queue has been mutated, refetch your list. */
+export interface TasksChanged {
+  type: 'tasks_changed';
+}
+
 /** Server push — broadcast when a work item status changes (e.g. running -> awaiting_review). */
 export interface WorkItemStatusChanged {
   type: 'work_item_status_changed';
@@ -2042,8 +2091,11 @@ export type ServerMessage =
   | WorkItemGetResponse
   | WorkItemCreateResponse
   | WorkItemUpdateResponse
+  | WorkItemDeleteResponse
   | WorkItemRunTaskResponse
+  | WorkItemOutputResponse
   | WorkItemStatusChanged
+  | TasksChanged
   | OpenTasksWindow
   | SubagentSpawned
   | SubagentStatusChanged

package/src/daemon/lifecycle.ts

@@ -22,6 +22,7 @@ import { initializeTools } from '../tools/registry.js';
 import { loadConfig } from '../config/loader.js';
 import { ensurePromptFiles } from '../config/system-prompt.js';
 import { DaemonServer } from './server.js';
+import { listWorkItems, updateWorkItem } from '../work-items/work-item-store.js';
 import { getLogger, initLogger } from '../util/logger.js';
 import { DaemonError } from '../util/errors.js';
 import { initSentry } from '../instrument.js';
@@ -43,6 +44,7 @@ import { RuntimeHttpServer } from '../runtime/http-server.js';
 import { getHookManager } from '../hooks/manager.js';
 import { installTemplates } from '../hooks/templates.js';
 import { HeartbeatService } from '../workspace/heartbeat-service.js';
+import { getEnrichmentService } from '../workspace/commit-message-enrichment-service.js';
 
 const log = getLogger('lifecycle');
 
@@ -279,6 +281,17 @@ export async function runDaemon(): Promise<void> {
   initializeDb();
   log.info('Daemon startup: DB initialized');
 
+  // Recover orphaned work items that were left in 'running' state when the
+  // daemon previously crashed or was killed mid-task.
+  const orphanedRunning = listWorkItems({ status: 'running' });
+  if (orphanedRunning.length > 0) {
+    for (const item of orphanedRunning) {
+      updateWorkItem(item.id, { status: 'failed', lastRunStatus: 'interrupted' });
+      log.info({ workItemId: item.id, title: item.title }, 'Recovered orphaned running work item → failed (interrupted)');
+    }
+    log.info({ count: orphanedRunning.length }, 'Recovered orphaned running work items');
+  }
+
   log.info('Daemon startup: loading config');
   const config = loadConfig();
 
@@ -328,7 +341,7 @@ export async function runDaemon(): Promise<void> {
 
   const scheduler = startScheduler(
     async (conversationId, message) => {
-      await server.processMessage('schedule', conversationId, message);
+      await server.processMessage(conversationId, message);
     },
     (reminder) => {
       server.broadcast({
@@ -382,10 +395,10 @@ export async function runDaemon(): Promise<void> {
         port,
         hostname,
         bearerToken,
-        processMessage: (assistantId, conversationId, content, attachmentIds, options, sourceChannel) =>
-          server.processMessage(assistantId, conversationId, content, attachmentIds, options, sourceChannel),
-        persistAndProcessMessage: (assistantId, conversationId, content, attachmentIds, options, sourceChannel) =>
-          server.persistAndProcessMessage(assistantId, conversationId, content, attachmentIds, options, sourceChannel),
+        processMessage: (conversationId, content, attachmentIds, options, sourceChannel) =>
+          server.processMessage(conversationId, content, attachmentIds, options, sourceChannel),
+        persistAndProcessMessage: (conversationId, content, attachmentIds, options, sourceChannel) =>
+          server.persistAndProcessMessage(conversationId, content, attachmentIds, options, sourceChannel),
         runOrchestrator: server.createRunOrchestrator(),
         interfacesDir: getInterfacesDir(),
       });
@@ -477,6 +490,15 @@ export async function runDaemon(): Promise<void> {
     } catch (err) {
       log.warn({ err, phase: 'post_stop' }, 'Post-stop workspace commit failed');
     }
+
+    // Flush in-flight enrichment jobs so shutdown commit notes are not dropped.
+    // The enrichment service's shutdown() drains active jobs and discards pending ones.
+    try {
+      await getEnrichmentService().shutdown();
+    } catch (err) {
+      log.warn({ err }, 'Enrichment service shutdown failed (non-fatal)');
+    }
+
     if (runtimeHttp) await runtimeHttp.stop();
     await browserManager.closeAllPages();
     scheduler.stop();

package/src/daemon/server.ts

@@ -967,7 +967,6 @@ export class DaemonServer {
    * is not blocked for the duration of the agent loop.
    */
   async persistAndProcessMessage(
-    assistantId: string,
     conversationId: string,
     content: string,
     attachmentIds?: string[],
@@ -988,14 +987,14 @@ export class DaemonServer {
       throw new Error('Session is already processing a message');
     }
 
-    // Set assistantId AFTER the isProcessing check so a rejected request
-    // doesn't mutate the session state visible to an in-flight request.
-    session.setAssistantId(assistantId);
+    // Set the session identity AFTER the isProcessing check so a rejected
+    // request doesn't mutate the session state visible to an in-flight request.
+    session.setAssistantId('self');
     session.setChannelCapabilities(resolveChannelCapabilities(sourceChannel));
 
     // Resolve attachment IDs to full attachment data for the session
     const attachments = attachmentIds
-      ? attachmentsStore.getAttachmentsByIds(assistantId, attachmentIds).map((a) => ({
+      ? attachmentsStore.getAttachmentsByIds('self', attachmentIds).map((a) => ({
           id: a.id,
           filename: a.originalFilename,
           mimeType: a.mimeType,
@@ -1022,7 +1021,6 @@ export class DaemonServer {
    * Used by the channel inbound endpoint which needs the assistant reply.
    */
   async processMessage(
-    assistantId: string,
     conversationId: string,
     content: string,
     attachmentIds?: string[],
@@ -1041,14 +1039,14 @@ export class DaemonServer {
       throw new Error('Session is already processing a message');
     }
 
-    // Set assistantId AFTER the isProcessing check so a rejected request
-    // doesn't mutate the session state visible to an in-flight request.
-    session.setAssistantId(assistantId);
+    // Set the session identity AFTER the isProcessing check so a rejected
+    // request doesn't mutate the session state visible to an in-flight request.
+    session.setAssistantId('self');
     session.setChannelCapabilities(resolveChannelCapabilities(sourceChannel));
 
     // Resolve attachment IDs to full attachment data for the session
     const attachments = attachmentIds
-      ? attachmentsStore.getAttachmentsByIds(assistantId, attachmentIds).map((a) => ({
+      ? attachmentsStore.getAttachmentsByIds('self', attachmentIds).map((a) => ({
           id: a.id,
           filename: a.originalFilename,
           mimeType: a.mimeType,
@@ -1072,8 +1070,8 @@ export class DaemonServer {
     return new RunOrchestrator({
       getOrCreateSession: (conversationId) =>
         this.getOrCreateSession(conversationId),
-      resolveAttachments: (assistantId, attachmentIds) =>
-        attachmentsStore.getAttachmentsByIds(assistantId, attachmentIds).map((a) => ({
+      resolveAttachments: (attachmentIds) =>
+        attachmentsStore.getAttachmentsByIds('self', attachmentIds).map((a) => ({
           id: a.id,
           filename: a.originalFilename,
           mimeType: a.mimeType,

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

@@ -181,6 +181,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;

package/src/daemon/session.ts

@@ -1422,7 +1422,21 @@ export class Session {
       // the agent loop started, even if post-processing threw.
       if (turnStarted) {
         this.turnCount++;
-        await commitTurnChanges(this.workingDir, this.conversationId, this.turnCount);
+        const config = getConfig();
+        const maxWait = config.workspaceGit?.turnCommitMaxWaitMs ?? 4000;
+        const deadlineMs = Date.now() + maxWait;
+        const commitPromise = commitTurnChanges(
+          this.workingDir, this.conversationId, this.turnCount,
+          undefined, // use default commit message provider
+          deadlineMs,
+        );
+        const outcome = await raceWithTimeout(commitPromise, maxWait);
+        if (outcome === 'timed_out') {
+          rlog.warn(
+            { turnNumber: this.turnCount, maxWaitMs: maxWait, conversationId: this.conversationId },
+            'Turn-boundary commit timed out — continuing without waiting (commit still runs in background)',
+          );
+        }
       }
 
       this.profiler.emitSummary(this.traceEmitter, reqId);
@@ -1649,3 +1663,28 @@ function isToolResultOnlyMessage(message: Message): boolean {
   return message.content.length > 0
     && message.content.every((block) => block.type === 'tool_result');
 }
+
+/**
+ * Race a promise against a timeout. Returns 'completed' if the promise
+ * resolves/rejects within the budget, or 'timed_out' if the timeout fires
+ * first. The timer is always cleared in `finally` to prevent handle leaks.
+ */
+async function raceWithTimeout<T>(
+  promise: Promise<T>,
+  timeoutMs: number,
+): Promise<'completed' | 'timed_out'> {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  try {
+    const result = await Promise.race([
+      promise.then(() => 'completed' as const),
+      new Promise<'timed_out'>((resolve) => {
+        timer = setTimeout(() => resolve('timed_out'), timeoutMs);
+      }),
+    ]);
+    return result;
+  } finally {
+    if (timer !== undefined) {
+      clearTimeout(timer);
+    }
+  }
+}