@vellumai/assistant 0.3.6 → 0.3.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.3.6",
+  "version": "0.3.8",
   "type": "module",
   "bin": {
     "vellum": "./src/index.ts"

package/src/__tests__/send-endpoint-busy.test.ts

@@ -0,0 +1,284 @@
+/**
+ * Tests for POST /v1/messages queue-if-busy behavior and hub publishing.
+ *
+ * Validates that:
+ * - Messages are accepted (202) when the session is idle, with hub events published.
+ * - Messages are queued (202, queued: true) when the session is busy, not 409.
+ * - SSE subscribers receive events from messages sent via this endpoint.
+ */
+import { describe, test, expect, beforeEach, afterAll, mock } from 'bun:test';
+import { mkdtempSync, rmSync, realpathSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import type { ServerMessage } from '../daemon/ipc-protocol.js';
+import type { Session } from '../daemon/session.js';
+
+const testDir = realpathSync(mkdtempSync(join(tmpdir(), 'send-endpoint-busy-test-')));
+
+mock.module('../util/platform.js', () => ({
+  getRootDir: () => testDir,
+  getDataDir: () => testDir,
+  isMacOS: () => process.platform === 'darwin',
+  isLinux: () => process.platform === 'linux',
+  isWindows: () => process.platform === 'win32',
+  getSocketPath: () => join(testDir, 'test.sock'),
+  getPidPath: () => join(testDir, 'test.pid'),
+  getDbPath: () => join(testDir, 'test.db'),
+  getLogPath: () => join(testDir, 'test.log'),
+  ensureDataDir: () => {},
+}));
+
+mock.module('../util/logger.js', () => ({
+  getLogger: () => new Proxy({} as Record<string, unknown>, {
+    get: () => () => {},
+  }),
+}));
+
+mock.module('../config/loader.js', () => ({
+  getConfig: () => ({
+    model: 'test',
+    provider: 'test',
+    apiKeys: {},
+    memory: { enabled: false },
+    rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
+    secretDetection: { enabled: false },
+  }),
+}));
+
+import { initializeDb, getDb, resetDb } from '../memory/db.js';
+import { RuntimeHttpServer } from '../runtime/http-server.js';
+import { AssistantEventHub } from '../runtime/assistant-event-hub.js';
+import type { AssistantEvent } from '../runtime/assistant-event.js';
+
+initializeDb();
+
+// ---------------------------------------------------------------------------
+// Session helpers
+// ---------------------------------------------------------------------------
+
+/** Session that completes its agent loop quickly and emits a text delta + message_complete. */
+function makeCompletingSession(): Session {
+  let processing = false;
+  return {
+    isProcessing: () => processing,
+    persistUserMessage: (_content: string, _attachments: unknown[], requestId?: string) => {
+      processing = true;
+      return requestId ?? 'msg-1';
+    },
+    memoryPolicy: { scopeId: 'default', includeDefaultFallback: false, strictSideEffects: false },
+    setChannelCapabilities: () => {},
+    setAssistantId: () => {},
+    setGuardianContext: () => {},
+    setCommandIntent: () => {},
+    updateClient: () => {},
+    enqueueMessage: () => ({ queued: false, requestId: 'noop' }),
+    runAgentLoop: async (_content: string, _messageId: string, onEvent: (msg: ServerMessage) => void) => {
+      onEvent({ type: 'assistant_text_delta', text: 'Hello!' });
+      onEvent({ type: 'message_complete', sessionId: 'test-session' });
+      processing = false;
+    },
+    handleConfirmationResponse: () => {},
+    handleSecretResponse: () => {},
+  } as unknown as Session;
+}
+
+/** Session that hangs forever in the agent loop (simulates a busy session). */
+function makeHangingSession(): Session {
+  let processing = false;
+  const enqueuedMessages: Array<{ content: string; onEvent: (msg: ServerMessage) => void; requestId: string }> = [];
+  return {
+    isProcessing: () => processing,
+    persistUserMessage: (_content: string, _attachments: unknown[], requestId?: string) => {
+      processing = true;
+      return requestId ?? 'msg-1';
+    },
+    memoryPolicy: { scopeId: 'default', includeDefaultFallback: false, strictSideEffects: false },
+    setChannelCapabilities: () => {},
+    setAssistantId: () => {},
+    setGuardianContext: () => {},
+    setCommandIntent: () => {},
+    updateClient: () => {},
+    enqueueMessage: (content: string, _attachments: unknown[], onEvent: (msg: ServerMessage) => void, requestId: string) => {
+      enqueuedMessages.push({ content, onEvent, requestId });
+      return { queued: true, requestId };
+    },
+    runAgentLoop: async () => {
+      // Hang forever
+      await new Promise<void>(() => {});
+    },
+    handleConfirmationResponse: () => {},
+    handleSecretResponse: () => {},
+    _enqueuedMessages: enqueuedMessages,
+  } as unknown as Session;
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+const TEST_TOKEN = 'test-bearer-token-send';
+const AUTH_HEADERS = { Authorization: `Bearer ${TEST_TOKEN}` };
+
+describe('POST /v1/messages — queue-if-busy and hub publishing', () => {
+  let server: RuntimeHttpServer;
+  let port: number;
+  let eventHub: AssistantEventHub;
+
+  beforeEach(() => {
+    const db = getDb();
+    db.run('DELETE FROM messages');
+    db.run('DELETE FROM conversations');
+    db.run('DELETE FROM conversation_keys');
+    eventHub = new AssistantEventHub();
+  });
+
+  afterAll(() => {
+    resetDb();
+    try { rmSync(testDir, { recursive: true, force: true }); } catch { /* best effort */ }
+  });
+
+  async function startServer(sessionFactory: () => Session): Promise<void> {
+    port = 19000 + Math.floor(Math.random() * 1000);
+    server = new RuntimeHttpServer({
+      port,
+      bearerToken: TEST_TOKEN,
+      sendMessageDeps: {
+        getOrCreateSession: async () => sessionFactory(),
+        assistantEventHub: eventHub,
+        resolveAttachments: () => [],
+      },
+    });
+    await server.start();
+  }
+
+  async function stopServer(): Promise<void> {
+    await server?.stop();
+  }
+
+  function messagesUrl(): string {
+    return `http://127.0.0.1:${port}/v1/messages`;
+  }
+
+  // ── Idle session: immediate processing ──────────────────────────────
+
+  test('returns 202 with accepted: true and messageId when session is idle', async () => {
+    await startServer(() => makeCompletingSession());
+
+    const res = await fetch(messagesUrl(), {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', ...AUTH_HEADERS },
+      body: JSON.stringify({ conversationKey: 'conv-idle', content: 'Hello', sourceChannel: 'macos' }),
+    });
+    const body = await res.json() as { accepted: boolean; messageId: string };
+
+    expect(res.status).toBe(202);
+    expect(body.accepted).toBe(true);
+    expect(body.messageId).toBeDefined();
+
+    await stopServer();
+  });
+
+  test('publishes events to assistantEventHub when session is idle', async () => {
+    const publishedEvents: AssistantEvent[] = [];
+
+    await startServer(() => makeCompletingSession());
+
+    eventHub.subscribe(
+      { assistantId: 'self' },
+      (event) => { publishedEvents.push(event); },
+    );
+
+    const res = await fetch(messagesUrl(), {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', ...AUTH_HEADERS },
+      body: JSON.stringify({ conversationKey: 'conv-hub', content: 'Hello hub', sourceChannel: 'macos' }),
+    });
+    expect(res.status).toBe(202);
+
+    // Wait for the async agent loop to complete and events to be published
+    await new Promise((r) => setTimeout(r, 100));
+
+    // Should have received assistant_text_delta and message_complete
+    const types = publishedEvents.map((e) => e.message.type);
+    expect(types).toContain('assistant_text_delta');
+    expect(types).toContain('message_complete');
+
+    await stopServer();
+  });
+
+  // ── Busy session: queue-if-busy ─────────────────────────────────────
+
+  test('returns 202 with queued: true when session is busy (not 409)', async () => {
+    const session = makeHangingSession();
+    await startServer(() => session);
+
+    // First message starts the agent loop and makes the session busy
+    const res1 = await fetch(messagesUrl(), {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', ...AUTH_HEADERS },
+      body: JSON.stringify({ conversationKey: 'conv-busy', content: 'First', sourceChannel: 'macos' }),
+    });
+    expect(res1.status).toBe(202);
+    const body1 = await res1.json() as { accepted: boolean; messageId: string };
+    expect(body1.accepted).toBe(true);
+    expect(body1.messageId).toBeDefined();
+
+    // Wait for the agent loop to start
+    await new Promise((r) => setTimeout(r, 30));
+
+    // Second message should be queued, not rejected
+    const res2 = await fetch(messagesUrl(), {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', ...AUTH_HEADERS },
+      body: JSON.stringify({ conversationKey: 'conv-busy', content: 'Second', sourceChannel: 'macos' }),
+    });
+    const body2 = await res2.json() as { accepted: boolean; queued: boolean };
+
+    expect(res2.status).toBe(202);
+    expect(body2.accepted).toBe(true);
+    expect(body2.queued).toBe(true);
+
+    await stopServer();
+  });
+
+  // ── Validation ──────────────────────────────────────────────────────
+
+  test('returns 400 when sourceChannel is missing', async () => {
+    await startServer(() => makeCompletingSession());
+
+    const res = await fetch(messagesUrl(), {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', ...AUTH_HEADERS },
+      body: JSON.stringify({ conversationKey: 'conv-val', content: 'Hello' }),
+    });
+    expect(res.status).toBe(400);
+
+    await stopServer();
+  });
+
+  test('returns 400 when content is empty', async () => {
+    await startServer(() => makeCompletingSession());
+
+    const res = await fetch(messagesUrl(), {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', ...AUTH_HEADERS },
+      body: JSON.stringify({ conversationKey: 'conv-empty', content: '', sourceChannel: 'macos' }),
+    });
+    expect(res.status).toBe(400);
+
+    await stopServer();
+  });
+
+  test('returns 400 when conversationKey is missing', async () => {
+    await startServer(() => makeCompletingSession());
+
+    const res = await fetch(messagesUrl(), {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', ...AUTH_HEADERS },
+      body: JSON.stringify({ content: 'Hello', sourceChannel: 'macos' }),
+    });
+    expect(res.status).toBe(400);
+
+    await stopServer();
+  });
+});

package/src/__tests__/subagent-manager-notify.test.ts

@@ -397,8 +397,8 @@ describe('SubagentManager sendMessage validation', () => {
     const subagentId = 'sub-1';
     injectFakeSubagent(manager, subagentId, makeState(subagentId));
 
-    expect(manager.sendMessage(subagentId, '')).toBe(false);
-    expect(manager.sendMessage(subagentId, '   ')).toBe(false);
-    expect(manager.sendMessage(subagentId, '\n\t')).toBe(false);
+    expect(manager.sendMessage(subagentId, '')).toBe('empty');
+    expect(manager.sendMessage(subagentId, '   ')).toBe('empty');
+    expect(manager.sendMessage(subagentId, '\n\t')).toBe('empty');
   });
 });

package/src/config/bundled-skills/media-processing/SKILL.md

@@ -34,11 +34,11 @@ Preprocess a video asset: detect dead time via mpdecimate, segment the video int
 
 Parameters:
 - `asset_id` (required) — ID of the media asset.
-- `interval_seconds` — Interval between keyframes (default: 3s).
-- `segment_duration` — Duration of each segment window (default: 20s).
+- `interval_seconds` — Interval between keyframes (default: 1s). Use 0.5s for sports/action content where frame density matters.
+- `segment_duration` — Duration of each segment window (default: 15s).
 - `dead_time_threshold` — Sensitivity for dead-time detection (default: 0.02).
 - `section_config` — Path to a JSON file with manual section boundaries.
-- `skip_dead_time` — Whether to detect and skip dead time (default: true).
+- `skip_dead_time` — Whether to detect and skip dead time (default: false). Dead-time detection can be too aggressive for continuous action video like sports — it may incorrectly skip live play. Enable only for content with clear idle periods (e.g., lectures, surveillance footage).
 - `short_edge` — Short edge resolution for downscaled frames in pixels (default: 480).
 
 ### analyze_keyframes
@@ -74,7 +74,7 @@ Get a diagnostic report for a media asset. Returns:
 - **Processing stats**: total keyframes extracted.
 - **Per-stage status and timing**: which stages (preprocess, map, reduce) have run, how long each took, current progress.
 - **Failure reasons**: last error from any failed stage.
-- **Cost estimation**: based on segment count and Gemini 2.5 Flash pricing, plus a note about Claude reduce costs.
+- **Cost estimation**: based on segment count and current Gemini pricing.
 
 ## Services
 
@@ -110,6 +110,82 @@ Limits concurrent API calls during the Map phase to avoid rate limiting.
 
 Tracks estimated API costs during pipeline execution.
 
+## Best Practices
+
+### Map Prompt Strategy: Go Broad, Not Targeted
+
+The single most important insight: **always use a broad, descriptive map prompt** instead of a targeted one.
+
+A targeted prompt like "find turnovers" locks you into one topic. If the user later wants to ask about defense, formations, or specific players, you'd need to reprocess the entire video. Instead, run a general-purpose descriptive prompt that captures everything visible, creating a rich, reusable dataset. Then all follow-up questions can be handled via `query_media` with no reprocessing.
+
+**One map run, many queries.**
+
+The map output will be larger (more tokens per segment), but Gemini Flash is cheap enough that this is a good tradeoff. Only use a targeted prompt if the user explicitly asks for something narrow.
+
+#### Sample General-Purpose Map Prompt
+
+Use this as a starting point for the `system_prompt` parameter in `analyze_keyframes`:
+
+```
+You are analyzing keyframes from a video. For each segment, describe everything you can observe:
+
+- People visible: count, positions, identifying features (jersey numbers, clothing, names if visible)
+- Actions and movements: what people are doing, direction of movement, interactions
+- Objects of interest: ball location, equipment, vehicles, on-screen graphics
+- Environment: setting, lighting, weather if outdoors
+- Text on screen: scores, captions, titles, signs, timestamps
+- Scene composition: camera angle, zoom level, any transitions between shots
+- Any stoppages, pauses, or changes in activity
+
+Be specific and factual. Describe what you see, not what you infer happened between frames.
+```
+
+#### Sample Output Schema
+
+```json
+{
+  "type": "object",
+  "properties": {
+    "scene_description": { "type": "string" },
+    "people": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "description": { "type": "string" },
+          "position": { "type": "string" },
+          "action": { "type": "string" }
+        }
+      }
+    },
+    "objects_of_interest": { "type": "array", "items": { "type": "string" } },
+    "on_screen_text": { "type": "array", "items": { "type": "string" } },
+    "camera": { "type": "string" },
+    "notable_events": { "type": "array", "items": { "type": "string" } }
+  }
+}
+```
+
+### Clip Delivery
+
+The `generate_clip` tool outputs clips as temporary files. These may not deliver reliably via sandbox attachments. For reliable delivery, use `host_bash` + ffmpeg to save clips to a user-specified location as a fallback.
+
+## Known Limitations — Vision Analysis
+
+Gemini performs well at **spatial/descriptive analysis** from static keyframes:
+- Player positions, formations, and spacing
+- Jersey numbers and identifying features
+- Ball location and which team has possession
+- Score and on-screen text
+- Camera angles and scene composition
+
+Gemini **hallucinates when asked to detect fast temporal events** from static frames, regardless of frame density:
+- Turnovers, steals, fouls, and specific plays
+- Fast transitions and split-second actions
+- Causality between frames (what "happened" vs. what's visible)
+
+The model is good at describing **what is there** but bad at detecting **what happened**. Structure your map prompts and queries accordingly — ask the model to describe scenes, then use `query_media` (Claude) to reason about patterns and events across the descriptive data.
+
 ## Operator Runbook
 
 ### Monitoring Progress
@@ -137,16 +213,7 @@ After fixing the root cause, re-run the failed stage. The pipeline is resumable
 
 ### Cost Expectations
 
-The Map phase (Gemini 2.5 Flash) is the primary cost driver. Cost scales with video duration, keyframe interval, and segment size:
-
-| Video Duration | Interval | Keyframes | Segments (~10 frames each) | Estimated Map Cost |
-|----------------|----------|-----------|----------------------------|--------------------|
-| 30 min         | 3s       | ~600      | ~60                        | ~$0.06             |
-| 60 min         | 3s       | ~1,200    | ~120                       | ~$0.12             |
-| 90 min         | 3s       | ~1,800    | ~180                       | ~$0.18             |
-| 90 min         | 5s       | ~1,080    | ~108                       | ~$0.11             |
-
-The Reduce phase (Claude) adds a small additional cost per query. The `media_diagnostics` tool provides per-asset cost estimates.
+Use `media_diagnostics` to get per-asset cost estimates. The Map phase (Gemini) is the primary cost driver — it scales with video duration and keyframe interval. The Q&A phase (Claude) is negligible per query.
 
 ### Known Limitations
 

package/src/config/bundled-skills/media-processing/TOOLS.json

@@ -67,11 +67,11 @@
           },
           "interval_seconds": {
             "type": "number",
-            "description": "Interval between keyframes in seconds. Default: 3"
+            "description": "Interval between keyframes in seconds. Default: 1. Use 0.5 for sports/action content."
           },
           "segment_duration": {
             "type": "number",
-            "description": "Duration of each segment window in seconds. Default: 20"
+            "description": "Duration of each segment window in seconds. Default: 15"
           },
           "dead_time_threshold": {
             "type": "number",
@@ -83,7 +83,7 @@
           },
           "skip_dead_time": {
             "type": "boolean",
-            "description": "Whether to detect and skip dead time. Default: true"
+            "description": "Whether to detect and skip dead time. Default: false. Can be too aggressive for continuous action video like sports."
           },
           "short_edge": {
             "type": "number",

package/src/config/bundled-skills/media-processing/services/preprocess.ts

@@ -355,13 +355,13 @@ export async function preprocessForAsset(
   onProgress?: (msg: string) => void,
 ): Promise<PreprocessManifest> {
   const config: PreprocessConfig = {
-    intervalSeconds: options.intervalSeconds ?? 3,
-    segmentDuration: options.segmentDuration ?? 20,
+    intervalSeconds: options.intervalSeconds ?? 1,
+    segmentDuration: options.segmentDuration ?? 15,
     deadTimeThreshold: options.deadTimeThreshold ?? 0.02,
     shortEdge: options.shortEdge ?? 480,
   };
 
-  const skipDeadTime = options.skipDeadTime ?? true;
+  const skipDeadTime = options.skipDeadTime ?? false;
 
   const asset = getMediaAssetById(assetId);
   if (!asset) {

package/src/config/defaults.ts

@@ -47,7 +47,7 @@ export const DEFAULT_CONFIG: AssistantConfig = {
       injectionFormat: 'markdown' as const,
       injectionStrategy: 'prepend_user_block' as const,
       reranking: {
-        enabled: true,
+        enabled: false,
         model: 'claude-haiku-4-5-20251001',
         topK: 20,
       },

package/src/config/env-registry.ts

@@ -136,11 +136,18 @@ const KNOWN_VELLUM_VARS = new Set([
   'VELLUM_DAEMON_TCP_ENABLED',
   'VELLUM_DAEMON_TCP_HOST',
   'VELLUM_DAEMON_IOS_PAIRING',
+  'VELLUM_DAEMON_NOAUTH',
+  'VELLUM_DAEMON_AUTOSTART',
   'VELLUM_DEBUG',
   'VELLUM_LOG_STDERR',
   'VELLUM_ENABLE_MONITORING',
   'VELLUM_HOOK_EVENT',
   'VELLUM_HOOK_NAME',
+  'VELLUM_HOOK_SETTINGS',
+  'VELLUM_ROOT_DIR',
+  'VELLUM_WORKSPACE_DIR',
+  'VELLUM_CLAUDE_CODE_DEPTH',
+  'VELLUM_ASSISTANT_PLATFORM_URL',
 ]);
 
 /**

package/src/config/memory-schema.ts

@@ -60,7 +60,7 @@ export const QdrantConfigSchema = z.object({
 export const MemoryRerankingConfigSchema = z.object({
   enabled: z
     .boolean({ error: 'memory.retrieval.reranking.enabled must be a boolean' })
-    .default(true),
+    .default(false),
   model: z
     .string({ error: 'memory.retrieval.reranking.model must be a string' })
     .default('claude-haiku-4-5-20251001'),
@@ -186,7 +186,7 @@ export const MemoryRetrievalConfigSchema = z.object({
     })
     .default('prepend_user_block'),
   reranking: MemoryRerankingConfigSchema.default({
-    enabled: true,
+    enabled: false,
     model: 'claude-haiku-4-5-20251001',
     topK: 20,
   }),
@@ -430,7 +430,7 @@ export const MemoryConfigSchema = z.object({
     injectionFormat: 'markdown',
     injectionStrategy: 'prepend_user_block',
     reranking: {
-      enabled: true,
+      enabled: false,
       model: 'claude-haiku-4-5-20251001',
       topK: 20,
     },

package/src/config/schema.ts

@@ -215,7 +215,7 @@ export const AssistantConfigSchema = z.object({
       injectionFormat: 'markdown',
       injectionStrategy: 'prepend_user_block',
       reranking: {
-        enabled: true,
+        enabled: false,
         model: 'claude-haiku-4-5-20251001',
         topK: 20,
       },

package/src/daemon/daemon-control.ts

@@ -5,14 +5,52 @@ import {
   getSocketPath,
   getPidPath,
   getRootDir,
+  getWorkspaceConfigPath,
   removeSocketFile,
 } from '../util/platform.js';
 import { getLogger } from '../util/logger.js';
 import { DaemonError } from '../util/errors.js';
-import { getConfig } from '../config/loader.js';
 
 const log = getLogger('lifecycle');
 
+const DAEMON_TIMEOUT_DEFAULTS = {
+  startupSocketWaitMs: 5000,
+  stopTimeoutMs: 5000,
+  sigkillGracePeriodMs: 2000,
+};
+
+function isPositiveInteger(v: unknown): v is number {
+  return typeof v === 'number' && Number.isInteger(v) && v > 0;
+}
+
+/**
+ * Read daemon timeout values directly from the config JSON file, bypassing
+ * loadConfig() and its ensureMigratedDataDir()/ensureDataDir() side effects.
+ * Falls back to hardcoded defaults on any error (missing file, malformed JSON,
+ * unexpected shape) so daemon stop/start never fails due to config issues.
+ */
+function readDaemonTimeouts(): typeof DAEMON_TIMEOUT_DEFAULTS {
+  try {
+    const raw = JSON.parse(readFileSync(getWorkspaceConfigPath(), 'utf-8'));
+    if (raw.daemon && typeof raw.daemon === 'object') {
+      return {
+        startupSocketWaitMs: isPositiveInteger(raw.daemon.startupSocketWaitMs)
+          ? raw.daemon.startupSocketWaitMs
+          : DAEMON_TIMEOUT_DEFAULTS.startupSocketWaitMs,
+        stopTimeoutMs: isPositiveInteger(raw.daemon.stopTimeoutMs)
+          ? raw.daemon.stopTimeoutMs
+          : DAEMON_TIMEOUT_DEFAULTS.stopTimeoutMs,
+        sigkillGracePeriodMs: isPositiveInteger(raw.daemon.sigkillGracePeriodMs)
+          ? raw.daemon.sigkillGracePeriodMs
+          : DAEMON_TIMEOUT_DEFAULTS.sigkillGracePeriodMs,
+      };
+    }
+  } catch {
+    // Missing file, malformed JSON, etc. — use defaults.
+  }
+  return { ...DAEMON_TIMEOUT_DEFAULTS };
+}
+
 function isProcessRunning(pid: number): boolean {
   try {
     process.kill(pid, 0);
@@ -125,8 +163,8 @@ export async function startDaemon(): Promise<{
   writePid(pid);
 
   // Wait for socket to appear
-  const config = getConfig();
-  const maxWait = config.daemon.startupSocketWaitMs;
+  const timeouts = readDaemonTimeouts();
+  const maxWait = timeouts.startupSocketWaitMs;
   const interval = 100;
   let waited = 0;
   while (waited < maxWait) {
@@ -165,10 +203,10 @@ export async function stopDaemon(): Promise<StopResult> {
 
   process.kill(pid, 'SIGTERM');
 
-  const config = getConfig();
+  const timeouts = readDaemonTimeouts();
 
   // Wait for process to exit
-  const maxWait = config.daemon.stopTimeoutMs;
+  const maxWait = timeouts.stopTimeoutMs;
   const interval = 100;
   let waited = 0;
   while (waited < maxWait) {
@@ -190,7 +228,7 @@ export async function stopDaemon(): Promise<StopResult> {
   // Wait for the process to actually die after SIGKILL. Without this,
   // startDaemon() can race with the dying process's shutdown handler,
   // which removes the socket file and bricks the new daemon.
-  const killMaxWait = config.daemon.sigkillGracePeriodMs;
+  const killMaxWait = timeouts.sigkillGracePeriodMs;
   let killWaited = 0;
   while (killWaited < killMaxWait && isProcessRunning(pid)) {
     await new Promise((r) => setTimeout(r, 100));

package/src/daemon/handlers/sessions.ts

@@ -16,6 +16,7 @@ import type {
   SecretResponse,
   SessionCreateRequest,
   SessionSwitchRequest,
+  SessionRenameRequest,
   CancelRequest,
   DeleteQueuedMessage,
   HistoryRequest,
@@ -352,6 +353,24 @@ export async function handleSessionSwitch(
   });
 }
 
+export function handleSessionRename(
+  msg: SessionRenameRequest,
+  socket: net.Socket,
+  ctx: HandlerContext,
+): void {
+  const conversation = conversationStore.getConversation(msg.sessionId);
+  if (!conversation) {
+    ctx.send(socket, { type: 'error', message: `Session ${msg.sessionId} not found` });
+    return;
+  }
+  conversationStore.updateConversationTitle(msg.sessionId, msg.title);
+  ctx.send(socket, {
+    type: 'session_title_updated',
+    sessionId: msg.sessionId,
+    title: msg.title,
+  });
+}
+
 export function handleCancel(msg: CancelRequest, socket: net.Socket, ctx: HandlerContext): void {
   const sessionId = msg.sessionId || ctx.socketToSession.get(socket);
   if (sessionId) {
@@ -597,6 +616,7 @@ export const sessionHandlers = defineHandlers({
   session_create: handleSessionCreate,
   sessions_clear: (_msg, socket, ctx) => handleSessionsClear(socket, ctx),
   session_switch: handleSessionSwitch,
+  session_rename: handleSessionRename,
   cancel: handleCancel,
   delete_queued_message: handleDeleteQueuedMessage,
   history_request: handleHistoryRequest,