@getpaseo/server 0.1.12 → 0.1.14

package/dist/server/server/session.js

@@ -1,41 +1,41 @@
-import { v4 as uuidv4 } from "uuid";
-import { watch } from "node:fs";
-import { stat } from "fs/promises";
-import { exec } from "child_process";
-import { promisify } from "util";
-import { join, resolve, sep } from "path";
-import { homedir } from "node:os";
-import { z } from "zod";
-import { serializeAgentStreamEvent, } from "./messages.js";
-import { BinaryMuxChannel, TerminalBinaryFlags, TerminalBinaryMessageType, } from "../shared/binary-mux.js";
-import { TTSManager } from "./agent/tts-manager.js";
-import { STTManager } from "./agent/stt-manager.js";
-import { maybePersistTtsDebugAudio } from "./agent/tts-debug.js";
-import { isPaseoDictationDebugEnabled } from "./agent/recordings-debug.js";
-import { DictationStreamManager, } from "./dictation/dictation-stream-manager.js";
-import { buildConfigOverrides, buildSessionConfig, extractTimestamps, } from "./persistence-hooks.js";
-import { experimental_createMCPClient } from "ai";
-import { buildProviderRegistry } from "./agent/provider-registry.js";
-import { scheduleAgentMetadataGeneration } from "./agent/agent-metadata-generator.js";
-import { toAgentPayload } from "./agent/agent-projections.js";
-import { appendTimelineItemIfAgentKnown, emitLiveTimelineItemIfAgentKnown, } from "./agent/timeline-append.js";
-import { projectTimelineRows } from "./agent/timeline-projection.js";
-import { DEFAULT_STRUCTURED_GENERATION_PROVIDERS, StructuredAgentFallbackError, StructuredAgentResponseError, generateStructuredAgentResponseWithFallback, } from "./agent/agent-response-loop.js";
-import { isValidAgentProvider, AGENT_PROVIDER_IDS } from "./agent/provider-manifest.js";
-import { buildVoiceAgentMcpServerConfig, buildVoiceModeSystemPrompt, stripVoiceModeSystemPrompt, } from "./voice-config.js";
-import { isVoicePermissionAllowed } from "./voice-permission-policy.js";
-import { listDirectoryEntries, readExplorerFile, getDownloadableFileInfo, } from "./file-explorer/service.js";
-import { slugify, validateBranchSlug, listPaseoWorktrees, deletePaseoWorktree, isPaseoOwnedWorktreeCwd, resolvePaseoWorktreeRootForCwd, } from "../utils/worktree.js";
-import { createAgentWorktree, runAsyncWorktreeBootstrap, } from "./worktree-bootstrap.js";
-import { getCheckoutDiff, getCheckoutStatus, getCheckoutStatusLite, listBranchSuggestions, NotGitRepoError, MergeConflictError, MergeFromBaseConflictError, commitChanges, mergeToBase, mergeFromBase, pushCurrentBranch, createPullRequest, getPullRequestStatus, } from "../utils/checkout-git.js";
-import { getProjectIcon } from "../utils/project-icon.js";
-import { expandTilde } from "../utils/path.js";
-import { searchHomeDirectories } from "../utils/directory-suggestions.js";
-import { ensureLocalSpeechModels, getLocalSpeechModelDir, listLocalSpeechModels, } from "./speech/providers/local/models.js";
+import { v4 as uuidv4 } from 'uuid';
+import { watch } from 'node:fs';
+import { stat } from 'fs/promises';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { join, resolve, sep } from 'path';
+import { homedir } from 'node:os';
+import { z } from 'zod';
+import { serializeAgentStreamEvent, } from './messages.js';
+import { BinaryMuxChannel, TerminalBinaryFlags, TerminalBinaryMessageType, } from '../shared/binary-mux.js';
+import { TTSManager } from './agent/tts-manager.js';
+import { STTManager } from './agent/stt-manager.js';
+import { maybePersistTtsDebugAudio } from './agent/tts-debug.js';
+import { isPaseoDictationDebugEnabled } from './agent/recordings-debug.js';
+import { DictationStreamManager, } from './dictation/dictation-stream-manager.js';
+import { buildConfigOverrides, buildSessionConfig, extractTimestamps } from './persistence-hooks.js';
+import { experimental_createMCPClient } from 'ai';
+import { buildProviderRegistry } from './agent/provider-registry.js';
+import { scheduleAgentMetadataGeneration } from './agent/agent-metadata-generator.js';
+import { toAgentPayload } from './agent/agent-projections.js';
+import { appendTimelineItemIfAgentKnown, emitLiveTimelineItemIfAgentKnown, } from './agent/timeline-append.js';
+import { projectTimelineRows } from './agent/timeline-projection.js';
+import { DEFAULT_STRUCTURED_GENERATION_PROVIDERS, StructuredAgentFallbackError, StructuredAgentResponseError, generateStructuredAgentResponseWithFallback, } from './agent/agent-response-loop.js';
+import { isValidAgentProvider, AGENT_PROVIDER_IDS } from './agent/provider-manifest.js';
+import { buildVoiceAgentMcpServerConfig, buildVoiceModeSystemPrompt, stripVoiceModeSystemPrompt, } from './voice-config.js';
+import { isVoicePermissionAllowed } from './voice-permission-policy.js';
+import { listDirectoryEntries, readExplorerFile, getDownloadableFileInfo, } from './file-explorer/service.js';
+import { slugify, validateBranchSlug, listPaseoWorktrees, deletePaseoWorktree, isPaseoOwnedWorktreeCwd, resolvePaseoWorktreeRootForCwd, } from '../utils/worktree.js';
+import { createAgentWorktree, runAsyncWorktreeBootstrap } from './worktree-bootstrap.js';
+import { getCheckoutDiff, getCheckoutStatus, getCheckoutStatusLite, listBranchSuggestions, NotGitRepoError, MergeConflictError, MergeFromBaseConflictError, commitChanges, mergeToBase, mergeFromBase, pushCurrentBranch, createPullRequest, getPullRequestStatus, } from '../utils/checkout-git.js';
+import { getProjectIcon } from '../utils/project-icon.js';
+import { expandTilde } from '../utils/path.js';
+import { searchHomeDirectories, searchWorkspaceEntries } from '../utils/directory-suggestions.js';
+import { ensureLocalSpeechModels, getLocalSpeechModelDir, listLocalSpeechModels, } from './speech/providers/local/models.js';
 const execAsync = promisify(exec);
 const READ_ONLY_GIT_ENV = {
     ...process.env,
-    GIT_OPTIONAL_LOCKS: "0",
+    GIT_OPTIONAL_LOCKS: '0',
 };
 const pendingAgentInitializations = new Map();
 let restartRequested = false;
@@ -61,11 +61,11 @@ function deriveRemoteProjectKey(remoteUrl) {
         host = scpLike[1] ?? null;
         path = scpLike[2] ?? null;
     }
-    else if (trimmed.includes("://")) {
+    else if (trimmed.includes('://')) {
         try {
             const parsed = new URL(trimmed);
             host = parsed.hostname || null;
-            path = parsed.pathname ? parsed.pathname.replace(/^\//, "") : null;
+            path = parsed.pathname ? parsed.pathname.replace(/^\//, '') : null;
         }
         catch {
             return null;
@@ -74,15 +74,15 @@ function deriveRemoteProjectKey(remoteUrl) {
     if (!host || !path) {
         return null;
     }
-    let cleanedPath = path.trim().replace(/^\/+/, "").replace(/\/+$/, "");
-    if (cleanedPath.endsWith(".git")) {
+    let cleanedPath = path.trim().replace(/^\/+/, '').replace(/\/+$/, '');
+    if (cleanedPath.endsWith('.git')) {
         cleanedPath = cleanedPath.slice(0, -4);
     }
-    if (!cleanedPath.includes("/")) {
+    if (!cleanedPath.includes('/')) {
         return null;
     }
     const cleanedHost = host.toLowerCase();
-    if (cleanedHost === "github.com") {
+    if (cleanedHost === 'github.com') {
         return `remote:github.com/${cleanedPath}`;
     }
     return `remote:${cleanedHost}/${cleanedPath}`;
@@ -92,15 +92,15 @@ function deriveProjectGroupingKey(options) {
     if (remoteKey) {
         return remoteKey;
     }
-    const worktreeMarker = ".paseo/worktrees/";
+    const worktreeMarker = '.paseo/worktrees/';
     const idx = options.cwd.indexOf(worktreeMarker);
     if (idx !== -1) {
-        return options.cwd.slice(0, idx).replace(/\/$/, "");
+        return options.cwd.slice(0, idx).replace(/\/$/, '');
     }
     return options.cwd;
 }
 function deriveProjectGroupingName(projectKey) {
-    const githubRemotePrefix = "remote:github.com/";
+    const githubRemotePrefix = 'remote:github.com/';
     if (projectKey.startsWith(githubRemotePrefix)) {
         return projectKey.slice(githubRemotePrefix.length) || projectKey;
     }
@@ -111,7 +111,7 @@ class SessionRequestError extends Error {
     constructor(code, message) {
         super(message);
         this.code = code;
-        this.name = "SessionRequestError";
+        this.name = 'SessionRequestError';
     }
 }
 const PCM_SAMPLE_RATE = 16000;
@@ -121,14 +121,14 @@ const PCM_BYTES_PER_MS = (PCM_SAMPLE_RATE * PCM_CHANNELS * (PCM_BITS_PER_SAMPLE
 const MIN_STREAMING_SEGMENT_DURATION_MS = 1000;
 const MIN_STREAMING_SEGMENT_BYTES = Math.round(PCM_BYTES_PER_MS * MIN_STREAMING_SEGMENT_DURATION_MS);
 const VOICE_MODE_INACTIVITY_FLUSH_MS = 4500;
-const VOICE_INTERNAL_DICTATION_ID_PREFIX = "__voice_turn__:";
+const VOICE_INTERNAL_DICTATION_ID_PREFIX = '__voice_turn__:';
 const SAFE_GIT_REF_PATTERN = /^[A-Za-z0-9._\/-]+$/;
 const AgentIdSchema = z.string().uuid();
-const VOICE_MCP_SERVER_NAME = "paseo_voice";
+const VOICE_MCP_SERVER_NAME = 'paseo_voice';
 class VoiceFeatureUnavailableError extends Error {
     constructor(context) {
         super(context.message);
-        this.name = "VoiceFeatureUnavailableError";
+        this.name = 'VoiceFeatureUnavailableError';
         this.reasonCode = context.reasonCode;
         this.retryable = context.retryable;
         this.missingModelIds = [...context.missingModelIds];
@@ -139,10 +139,10 @@ function convertPCMToWavBuffer(pcmBuffer, sampleRate, channels, bitsPerSample) {
     const wavBuffer = Buffer.alloc(headerSize + pcmBuffer.length);
     const byteRate = (sampleRate * channels * bitsPerSample) / 8;
     const blockAlign = (channels * bitsPerSample) / 8;
-    wavBuffer.write("RIFF", 0);
+    wavBuffer.write('RIFF', 0);
     wavBuffer.writeUInt32LE(36 + pcmBuffer.length, 4);
-    wavBuffer.write("WAVE", 8);
-    wavBuffer.write("fmt ", 12);
+    wavBuffer.write('WAVE', 8);
+    wavBuffer.write('fmt ', 12);
     wavBuffer.writeUInt32LE(16, 16);
     wavBuffer.writeUInt16LE(1, 20);
     wavBuffer.writeUInt16LE(channels, 22);
@@ -150,7 +150,7 @@ function convertPCMToWavBuffer(pcmBuffer, sampleRate, channels, bitsPerSample) {
     wavBuffer.writeUInt32LE(byteRate, 28);
     wavBuffer.writeUInt16LE(blockAlign, 32);
     wavBuffer.writeUInt16LE(bitsPerSample, 34);
-    wavBuffer.write("data", 36);
+    wavBuffer.write('data', 36);
     wavBuffer.writeUInt32LE(pcmBuffer.length, 40);
     pcmBuffer.copy(wavBuffer, 44);
     return wavBuffer;
@@ -159,7 +159,7 @@ function coerceAgentProvider(logger, value, agentId) {
     if (isValidAgentProvider(value)) {
         return value;
     }
-    logger.warn({ value, agentId, defaultProvider: DEFAULT_AGENT_PROVIDER }, `Unknown provider '${value}' for agent ${agentId ?? "unknown"}; defaulting to '${DEFAULT_AGENT_PROVIDER}'`);
+    logger.warn({ value, agentId, defaultProvider: DEFAULT_AGENT_PROVIDER }, `Unknown provider '${value}' for agent ${agentId ?? 'unknown'}; defaulting to '${DEFAULT_AGENT_PROVIDER}'`);
     return DEFAULT_AGENT_PROVIDER;
 }
 function toAgentPersistenceHandle(logger, handle) {
@@ -172,7 +172,7 @@ function toAgentPersistenceHandle(logger, handle) {
         return null;
     }
     if (!handle.sessionId) {
-        logger.warn("Ignoring persistence handle missing sessionId");
+        logger.warn('Ignoring persistence handle missing sessionId');
         return null;
     }
     return {
@@ -189,7 +189,7 @@ function toAgentPersistenceHandle(logger, handle) {
  */
 export class Session {
     constructor(options) {
-        this.processingPhase = "idle";
+        this.processingPhase = 'idle';
         // Voice mode state
         this.isVoiceMode = false;
         this.speechInProgress = false;
@@ -246,11 +246,11 @@ export class Session {
         this.localSpeechModelsDir =
             configuredModelsDir && configuredModelsDir.length > 0
                 ? configuredModelsDir
-                : join(this.paseoHome, "models", "local-speech");
+                : join(this.paseoHome, 'models', 'local-speech');
         this.defaultLocalSpeechModelIds =
             dictation?.localModels?.defaultModelIds && dictation.localModels.defaultModelIds.length > 0
                 ? [...new Set(dictation.localModels.defaultModelIds)]
-                : ["parakeet-tdt-0.6b-v2-int8", "kokoro-en-v0_19"];
+                : ['parakeet-tdt-0.6b-v2-int8', 'kokoro-en-v0_19'];
         this.registerVoiceSpeakHandler = voiceBridge?.registerVoiceSpeakHandler;
         this.unregisterVoiceSpeakHandler = voiceBridge?.unregisterVoiceSpeakHandler;
         this.registerVoiceCallerContext = voiceBridge?.registerVoiceCallerContext;
@@ -261,7 +261,7 @@ export class Session {
         this.agentProviderRuntimeSettings = agentProviderRuntimeSettings;
         this.abortController = new AbortController();
         this.sessionLogger = logger.child({
-            module: "session",
+            module: 'session',
             clientId: this.clientId,
             sessionId: this.sessionId,
         });
@@ -279,7 +279,7 @@ export class Session {
             finalTimeoutMs: dictation?.finalTimeoutMs,
         });
         this.voiceStreamManager = new DictationStreamManager({
-            logger: this.sessionLogger.child({ stream: "voice-internal" }),
+            logger: this.sessionLogger.child({ stream: 'voice-internal' }),
             sessionId: this.sessionId,
             emit: (msg) => this.handleDictationManagerMessage(msg),
             stt: stt,
@@ -288,7 +288,7 @@ export class Session {
         // Initialize agent MCP client asynchronously
         void this.initializeAgentMcp();
         this.subscribeToAgentEvents();
-        this.sessionLogger.trace("Session created");
+        this.sessionLogger.trace('Session created');
     }
     /**
      * Get the client's current activity state
@@ -306,16 +306,16 @@ export class Session {
      * Normalize a user prompt (with optional image metadata) for AgentManager
      */
     buildAgentPrompt(text, images) {
-        const normalized = text?.trim() ?? "";
+        const normalized = text?.trim() ?? '';
         if (!images || images.length === 0) {
             return normalized;
         }
         const blocks = [];
         if (normalized.length > 0) {
-            blocks.push({ type: "text", text: normalized });
+            blocks.push({ type: 'text', text: normalized });
         }
         for (const image of images) {
-            blocks.push({ type: "image", data: image.data, mimeType: image.mimeType });
+            blocks.push({ type: 'image', data: image.data, mimeType: image.mimeType });
         }
         return blocks;
     }
@@ -328,17 +328,17 @@ export class Session {
         if (!snapshot) {
             throw new Error(`Agent ${agentId} not found`);
         }
-        if (snapshot.lifecycle !== "running" && !snapshot.pendingRun) {
-            this.sessionLogger.debug({ agentId, lifecycle: snapshot.lifecycle, pendingRun: Boolean(snapshot.pendingRun) }, "interruptAgentIfRunning: not running, skipping");
+        if (snapshot.lifecycle !== 'running' && !snapshot.pendingRun) {
+            this.sessionLogger.debug({ agentId, lifecycle: snapshot.lifecycle, pendingRun: Boolean(snapshot.pendingRun) }, 'interruptAgentIfRunning: not running, skipping');
             return;
         }
-        this.sessionLogger.debug({ agentId, lifecycle: snapshot.lifecycle, pendingRun: Boolean(snapshot.pendingRun) }, "interruptAgentIfRunning: interrupting");
+        this.sessionLogger.debug({ agentId, lifecycle: snapshot.lifecycle, pendingRun: Boolean(snapshot.pendingRun) }, 'interruptAgentIfRunning: interrupting');
         try {
             const t0 = Date.now();
             const cancelled = await this.agentManager.cancelAgentRun(agentId);
-            this.sessionLogger.debug({ agentId, cancelled, durationMs: Date.now() - t0 }, "interruptAgentIfRunning: cancelAgentRun completed");
+            this.sessionLogger.debug({ agentId, cancelled, durationMs: Date.now() - t0 }, 'interruptAgentIfRunning: cancelAgentRun completed');
             if (!cancelled) {
-                this.sessionLogger.warn({ agentId }, "interruptAgentIfRunning: reported running but no active run was cancelled");
+                this.sessionLogger.warn({ agentId }, 'interruptAgentIfRunning: reported running but no active run was cancelled');
             }
         }
         catch (error) {
@@ -353,7 +353,7 @@ export class Session {
         if (!snapshot) {
             return false;
         }
-        return snapshot.lifecycle === "running" || Boolean(snapshot.pendingRun);
+        return snapshot.lifecycle === 'running' || Boolean(snapshot.pendingRun);
     }
     /**
      * Start streaming an agent run and forward results via the websocket broadcast
@@ -365,8 +365,8 @@ export class Session {
             iterator = this.agentManager.streamAgent(agentId, prompt, runOptions);
         }
         catch (error) {
-            this.handleAgentRunError(agentId, error, "Failed to start agent run");
-            const message = error instanceof Error ? error.message : typeof error === "string" ? error : "Unknown error";
+            this.handleAgentRunError(agentId, error, 'Failed to start agent run');
+            const message = error instanceof Error ? error.message : typeof error === 'string' ? error : 'Unknown error';
             return { ok: false, error: message };
         }
         void (async () => {
@@ -376,20 +376,20 @@ export class Session {
                 }
             }
             catch (error) {
-                this.handleAgentRunError(agentId, error, "Agent stream failed");
+                this.handleAgentRunError(agentId, error, 'Agent stream failed');
             }
         })();
         return { ok: true };
     }
     handleAgentRunError(agentId, error, context) {
-        const message = error instanceof Error ? error.message : typeof error === "string" ? error : "Unknown error";
+        const message = error instanceof Error ? error.message : typeof error === 'string' ? error : 'Unknown error';
         this.sessionLogger.error({ err: error, agentId, context }, `${context} for agent ${agentId}`);
         this.emit({
-            type: "activity_log",
+            type: 'activity_log',
             payload: {
                 id: uuidv4(),
                 timestamp: new Date(),
-                type: "error",
+                type: 'error',
                 content: `${context}: ${message}`,
             },
         });
@@ -409,7 +409,7 @@ export class Session {
             this.sessionLogger.trace({ agentToolCount }, `Agent MCP initialized with ${agentToolCount} tools`);
         }
         catch (error) {
-            this.sessionLogger.error({ err: error }, "Failed to initialize Agent MCP");
+            this.sessionLogger.error({ err: error }, 'Failed to initialize Agent MCP');
         }
     }
     /**
@@ -420,32 +420,32 @@ export class Session {
             this.unsubscribeAgentEvents();
         }
         this.unsubscribeAgentEvents = this.agentManager.subscribe((event) => {
-            if (event.type === "agent_state") {
+            if (event.type === 'agent_state') {
                 void this.forwardAgentUpdate(event.agent);
                 return;
             }
             if (this.isVoiceMode &&
                 this.voiceModeAgentId === event.agentId &&
-                event.event.type === "permission_requested" &&
+                event.event.type === 'permission_requested' &&
                 isVoicePermissionAllowed(event.event.request)) {
                 const requestId = event.event.request.id;
                 void this.agentManager
                     .respondToPermission(event.agentId, requestId, {
-                    behavior: "allow",
+                    behavior: 'allow',
                 })
                     .catch((error) => {
                     this.sessionLogger.warn({
                         err: error,
                         agentId: event.agentId,
                         requestId,
-                    }, "Failed to auto-allow speak tool permission in voice mode");
+                    }, 'Failed to auto-allow speak tool permission in voice mode');
                 });
             }
             // Reduce bandwidth/CPU on mobile: only forward high-frequency agent stream events
             // for the focused agent, with a short grace window while backgrounded.
             // History catch-up is handled via pull-based `fetch_agent_timeline_request`.
             const activity = this.clientActivity;
-            if (activity?.deviceType === "mobile") {
+            if (activity?.deviceType === 'mobile') {
                 if (!activity.focusedAgentId) {
                     return;
                 }
@@ -467,25 +467,25 @@ export class Session {
                 agentId: event.agentId,
                 event: serializedEvent,
                 timestamp: new Date().toISOString(),
-                ...(typeof event.seq === "number" ? { seq: event.seq } : {}),
-                ...(typeof event.epoch === "string" ? { epoch: event.epoch } : {}),
+                ...(typeof event.seq === 'number' ? { seq: event.seq } : {}),
+                ...(typeof event.epoch === 'string' ? { epoch: event.epoch } : {}),
             };
             this.emit({
-                type: "agent_stream",
+                type: 'agent_stream',
                 payload,
             });
-            if (event.event.type === "permission_requested") {
+            if (event.event.type === 'permission_requested') {
                 this.emit({
-                    type: "agent_permission_request",
+                    type: 'agent_permission_request',
                     payload: {
                         agentId: event.agentId,
                         request: event.event.request,
                     },
                 });
             }
-            else if (event.event.type === "permission_resolved") {
+            else if (event.event.type === 'permission_resolved') {
                 this.emit({
-                    type: "agent_permission_resolved",
+                    type: 'agent_permission_resolved',
                     payload: {
                         agentId: event.agentId,
                         requestId: event.event.requestId,
@@ -514,9 +514,7 @@ export class Session {
         };
         const createdAt = new Date(record.createdAt);
         const updatedAt = new Date(record.lastActivityAt ?? record.updatedAt);
-        const lastUserMessageAt = record.lastUserMessageAt
-            ? new Date(record.lastUserMessageAt)
-            : null;
+        const lastUserMessageAt = record.lastUserMessageAt ? new Date(record.lastUserMessageAt) : null;
         const provider = coerceAgentProvider(this.sessionLogger, record.provider, record.id);
         return {
             id: record.id,
@@ -561,12 +559,12 @@ export class Session {
             let snapshot;
             if (handle) {
                 snapshot = await this.agentManager.resumeAgentFromPersistence(handle, buildConfigOverrides(record), agentId, extractTimestamps(record));
-                this.sessionLogger.info({ agentId, provider: record.provider }, "Agent resumed from persistence");
+                this.sessionLogger.info({ agentId, provider: record.provider }, 'Agent resumed from persistence');
             }
             else {
                 const config = buildSessionConfig(record);
                 snapshot = await this.agentManager.createAgent(config, agentId, { labels: record.labels });
-                this.sessionLogger.info({ agentId, provider: record.provider }, "Agent created from stored config");
+                this.sessionLogger.info({ agentId, provider: record.provider }, 'Agent created from stored config');
             }
             await this.agentManager.hydrateTimelineFromProvider(agentId);
             return this.agentManager.getAgent(agentId) ?? snapshot;
@@ -582,14 +580,74 @@ export class Session {
             }
         }
     }
-    matchesAgentFilter(agent, filter) {
-        if (filter?.agentId && agent.id !== filter.agentId) {
+    matchesAgentFilter(options) {
+        const { agent, project, filter } = options;
+        if (filter?.labels) {
+            const matchesLabels = Object.entries(filter.labels).every(([key, value]) => agent.labels[key] === value);
+            if (!matchesLabels) {
+                return false;
+            }
+        }
+        const includeArchived = filter?.includeArchived ?? false;
+        if (!includeArchived && agent.archivedAt) {
             return false;
         }
-        if (!filter?.labels) {
-            return true;
+        if (filter?.statuses && filter.statuses.length > 0) {
+            const statuses = new Set(filter.statuses);
+            if (!statuses.has(agent.status)) {
+                return false;
+            }
+        }
+        if (typeof filter?.requiresAttention === 'boolean') {
+            const requiresAttention = agent.requiresAttention ?? false;
+            if (requiresAttention !== filter.requiresAttention) {
+                return false;
+            }
+        }
+        if (filter?.projectKeys && filter.projectKeys.length > 0) {
+            const projectKeys = new Set(filter.projectKeys.filter((item) => item.trim().length > 0));
+            if (projectKeys.size > 0 && !projectKeys.has(project.projectKey)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    getAgentUpdateTargetId(update) {
+        return update.kind === 'remove' ? update.agentId : update.agent.id;
+    }
+    bufferOrEmitAgentUpdate(subscription, payload) {
+        if (subscription.isBootstrapping) {
+            subscription.pendingUpdatesByAgentId.set(this.getAgentUpdateTargetId(payload), payload);
+            return;
+        }
+        this.emit({
+            type: 'agent_update',
+            payload,
+        });
+    }
+    flushBootstrappedAgentUpdates(options) {
+        const subscription = this.agentUpdatesSubscription;
+        if (!subscription || !subscription.isBootstrapping) {
+            return;
+        }
+        subscription.isBootstrapping = false;
+        const pending = Array.from(subscription.pendingUpdatesByAgentId.values());
+        subscription.pendingUpdatesByAgentId.clear();
+        for (const payload of pending) {
+            if (payload.kind === 'upsert') {
+                const snapshotUpdatedAt = options?.snapshotUpdatedAtByAgentId?.get(payload.agent.id);
+                if (typeof snapshotUpdatedAt === 'number') {
+                    const updateUpdatedAt = Date.parse(payload.agent.updatedAt);
+                    if (!Number.isNaN(updateUpdatedAt) && updateUpdatedAt <= snapshotUpdatedAt) {
+                        continue;
+                    }
+                }
+            }
+            this.emit({
+                type: 'agent_update',
+                payload,
+            });
         }
-        return Object.entries(filter.labels).every(([key, value]) => agent.labels[key] === value);
     }
     buildFallbackProjectCheckout(cwd) {
         return {
@@ -645,43 +703,27 @@ export class Session {
                 return;
             }
             const payload = await this.buildAgentPayload(agent);
-            const matches = this.matchesAgentFilter(payload, subscription.filter);
+            const project = await this.buildProjectPlacement(payload.cwd);
+            const matches = this.matchesAgentFilter({
+                agent: payload,
+                project,
+                filter: subscription.filter,
+            });
             if (matches) {
-                const project = await this.buildProjectPlacement(payload.cwd);
-                this.emit({
-                    type: "agent_update",
-                    payload: { kind: "upsert", agent: payload, project },
+                this.bufferOrEmitAgentUpdate(subscription, {
+                    kind: 'upsert',
+                    agent: payload,
+                    project,
                 });
                 return;
             }
-            this.emit({
-                type: "agent_update",
-                payload: { kind: "remove", agentId: payload.id },
-            });
-        }
-        catch (error) {
-            this.sessionLogger.error({ err: error }, "Failed to emit agent update");
-        }
-    }
-    async emitCurrentAgentUpdatesForSubscription() {
-        const subscription = this.agentUpdatesSubscription;
-        if (!subscription) {
-            return;
-        }
-        try {
-            const agents = await this.listAgentPayloads({
-                labels: subscription.filter?.labels,
+            this.bufferOrEmitAgentUpdate(subscription, {
+                kind: 'remove',
+                agentId: payload.id,
             });
-            for (const agent of agents) {
-                const project = await this.buildProjectPlacement(agent.cwd);
-                this.emit({
-                    type: "agent_update",
-                    payload: { kind: "upsert", agent, project },
-                });
-            }
         }
         catch (error) {
-            this.sessionLogger.error({ err: error }, "Failed to emit current agent updates for subscription bootstrap");
+            this.sessionLogger.error({ err: error }, 'Failed to emit agent update');
         }
     }
     /**
@@ -690,57 +732,45 @@ export class Session {
     async handleMessage(msg) {
         try {
             switch (msg.type) {
-                case "voice_audio_chunk":
+                case 'voice_audio_chunk':
                     await this.handleAudioChunk(msg);
                     break;
-                case "abort_request":
+                case 'abort_request':
                     await this.handleAbort();
                     break;
-                case "audio_played":
+                case 'audio_played':
                     this.handleAudioPlayed(msg.id);
                     break;
-                case "fetch_agents_request":
+                case 'fetch_agents_request':
                     await this.handleFetchAgents(msg);
                     break;
-                case "fetch_agent_request":
+                case 'fetch_agent_request':
                     await this.handleFetchAgent(msg.agentId, msg.requestId);
                     break;
-                case "subscribe_agent_updates":
-                    this.agentUpdatesSubscription = {
-                        subscriptionId: msg.subscriptionId,
-                        filter: msg.filter,
-                    };
-                    await this.emitCurrentAgentUpdatesForSubscription();
-                    break;
-                case "unsubscribe_agent_updates":
-                    if (this.agentUpdatesSubscription?.subscriptionId === msg.subscriptionId) {
-                        this.agentUpdatesSubscription = null;
-                    }
-                    break;
-                case "delete_agent_request":
+                case 'delete_agent_request':
                     await this.handleDeleteAgentRequest(msg.agentId, msg.requestId);
                     break;
-                case "archive_agent_request":
+                case 'archive_agent_request':
                     await this.handleArchiveAgentRequest(msg.agentId, msg.requestId);
                     break;
-                case "update_agent_request":
+                case 'update_agent_request':
                     await this.handleUpdateAgentRequest(msg.agentId, msg.name, msg.labels, msg.requestId);
                     break;
-                case "set_voice_mode":
+                case 'set_voice_mode':
                     await this.handleSetVoiceMode(msg.enabled, msg.agentId, msg.requestId);
                     break;
-                case "send_agent_message_request":
+                case 'send_agent_message_request':
                     await this.handleSendAgentMessageRequest(msg);
                     break;
-                case "wait_for_finish_request":
+                case 'wait_for_finish_request':
                     await this.handleWaitForFinish(msg.agentId, msg.requestId, msg.timeoutMs);
                     break;
-                case "dictation_stream_start":
+                case 'dictation_stream_start':
                     {
-                        const unavailable = this.resolveVoiceFeatureUnavailableContext("dictation");
+                        const unavailable = this.resolveVoiceFeatureUnavailableContext('dictation');
                         if (unavailable) {
                             this.emit({
-                                type: "dictation_stream_error",
+                                type: 'dictation_stream_error',
                                 payload: {
                                     dictationId: msg.dictationId,
                                     error: unavailable.message,
@@ -754,7 +784,7 @@ export class Session {
                     }
                     await this.dictationStreamManager.handleStart(msg.dictationId, msg.format);
                     break;
-                case "dictation_stream_chunk":
+                case 'dictation_stream_chunk':
                     await this.dictationStreamManager.handleChunk({
                         dictationId: msg.dictationId,
                         seq: msg.seq,
@@ -762,115 +792,115 @@ export class Session {
                         format: msg.format,
                     });
                     break;
-                case "dictation_stream_finish":
+                case 'dictation_stream_finish':
                     await this.dictationStreamManager.handleFinish(msg.dictationId, msg.finalSeq);
                     break;
-                case "dictation_stream_cancel":
+                case 'dictation_stream_cancel':
                     this.dictationStreamManager.handleCancel(msg.dictationId);
                     break;
-                case "create_agent_request":
+                case 'create_agent_request':
                     await this.handleCreateAgentRequest(msg);
                     break;
-                case "resume_agent_request":
+                case 'resume_agent_request':
                     await this.handleResumeAgentRequest(msg);
                     break;
-                case "refresh_agent_request":
+                case 'refresh_agent_request':
                     await this.handleRefreshAgentRequest(msg);
                     break;
-                case "cancel_agent_request":
+                case 'cancel_agent_request':
                     await this.handleCancelAgentRequest(msg.agentId);
                     break;
-                case "restart_server_request":
+                case 'restart_server_request':
                     await this.handleRestartServerRequest(msg.requestId, msg.reason);
                     break;
-                case "fetch_agent_timeline_request":
+                case 'fetch_agent_timeline_request':
                     await this.handleFetchAgentTimelineRequest(msg);
                     break;
-                case "set_agent_mode_request":
+                case 'set_agent_mode_request':
                     await this.handleSetAgentModeRequest(msg.agentId, msg.modeId, msg.requestId);
                     break;
-                case "set_agent_model_request":
+                case 'set_agent_model_request':
                     await this.handleSetAgentModelRequest(msg.agentId, msg.modelId, msg.requestId);
                     break;
-                case "set_agent_thinking_request":
+                case 'set_agent_thinking_request':
                     await this.handleSetAgentThinkingRequest(msg.agentId, msg.thinkingOptionId, msg.requestId);
                     break;
-                case "agent_permission_response":
+                case 'agent_permission_response':
                     await this.handleAgentPermissionResponse(msg.agentId, msg.requestId, msg.response);
                     break;
-                case "checkout_status_request":
+                case 'checkout_status_request':
                     await this.handleCheckoutStatusRequest(msg);
                     break;
-                case "validate_branch_request":
+                case 'validate_branch_request':
                     await this.handleValidateBranchRequest(msg);
                     break;
-                case "branch_suggestions_request":
+                case 'branch_suggestions_request':
                     await this.handleBranchSuggestionsRequest(msg);
                     break;
-                case "directory_suggestions_request":
+                case 'directory_suggestions_request':
                     await this.handleDirectorySuggestionsRequest(msg);
                     break;
-                case "subscribe_checkout_diff_request":
+                case 'subscribe_checkout_diff_request':
                     await this.handleSubscribeCheckoutDiffRequest(msg);
                     break;
-                case "unsubscribe_checkout_diff_request":
+                case 'unsubscribe_checkout_diff_request':
                     this.handleUnsubscribeCheckoutDiffRequest(msg);
                     break;
-                case "checkout_commit_request":
+                case 'checkout_commit_request':
                     await this.handleCheckoutCommitRequest(msg);
                     break;
-                case "checkout_merge_request":
+                case 'checkout_merge_request':
                     await this.handleCheckoutMergeRequest(msg);
                     break;
-                case "checkout_merge_from_base_request":
+                case 'checkout_merge_from_base_request':
                     await this.handleCheckoutMergeFromBaseRequest(msg);
                     break;
-                case "checkout_push_request":
+                case 'checkout_push_request':
                     await this.handleCheckoutPushRequest(msg);
                     break;
-                case "checkout_pr_create_request":
+                case 'checkout_pr_create_request':
                     await this.handleCheckoutPrCreateRequest(msg);
                     break;
-                case "checkout_pr_status_request":
+                case 'checkout_pr_status_request':
                     await this.handleCheckoutPrStatusRequest(msg);
                     break;
-                case "paseo_worktree_list_request":
+                case 'paseo_worktree_list_request':
                     await this.handlePaseoWorktreeListRequest(msg);
                     break;
-                case "paseo_worktree_archive_request":
+                case 'paseo_worktree_archive_request':
                     await this.handlePaseoWorktreeArchiveRequest(msg);
                     break;
-                case "file_explorer_request":
+                case 'file_explorer_request':
                     await this.handleFileExplorerRequest(msg);
                     break;
-                case "project_icon_request":
+                case 'project_icon_request':
                     await this.handleProjectIconRequest(msg);
                     break;
-                case "file_download_token_request":
+                case 'file_download_token_request':
                     await this.handleFileDownloadTokenRequest(msg);
                     break;
-                case "list_provider_models_request":
+                case 'list_provider_models_request':
                     await this.handleListProviderModelsRequest(msg);
                     break;
-                case "list_available_providers_request":
+                case 'list_available_providers_request':
                     await this.handleListAvailableProvidersRequest(msg);
                     break;
-                case "speech_models_list_request":
+                case 'speech_models_list_request':
                     await this.handleSpeechModelsListRequest(msg);
                     break;
-                case "speech_models_download_request":
+                case 'speech_models_download_request':
                     await this.handleSpeechModelsDownloadRequest(msg);
                     break;
-                case "clear_agent_attention":
+                case 'clear_agent_attention':
                     await this.handleClearAgentAttention(msg.agentId);
                     break;
-                case "client_heartbeat":
+                case 'client_heartbeat':
                     this.handleClientHeartbeat(msg);
                     break;
-                case "ping": {
+                case 'ping': {
                     const now = Date.now();
                     this.emit({
-                        type: "pong",
+                        type: 'pong',
                         payload: {
                             requestId: msg.requestId,
                             clientSentAt: msg.clientSentAt,
@@ -880,73 +910,70 @@ export class Session {
                     });
                     break;
                 }
-                case "list_commands_request":
-                    await this.handleListCommandsRequest(msg.agentId, msg.requestId);
-                    break;
-                case "execute_command_request":
-                    await this.handleExecuteCommandRequest(msg.agentId, msg.commandName, msg.args, msg.requestId);
+                case 'list_commands_request':
+                    await this.handleListCommandsRequest(msg);
                     break;
-                case "register_push_token":
+                case 'register_push_token':
                     this.handleRegisterPushToken(msg.token);
                     break;
-                case "subscribe_terminals_request":
+                case 'subscribe_terminals_request':
                     this.handleSubscribeTerminalsRequest(msg);
                     break;
-                case "unsubscribe_terminals_request":
+                case 'unsubscribe_terminals_request':
                     this.handleUnsubscribeTerminalsRequest(msg);
                     break;
-                case "list_terminals_request":
+                case 'list_terminals_request':
                     await this.handleListTerminalsRequest(msg);
                     break;
-                case "create_terminal_request":
+                case 'create_terminal_request':
                     await this.handleCreateTerminalRequest(msg);
                     break;
-                case "subscribe_terminal_request":
+                case 'subscribe_terminal_request':
                     await this.handleSubscribeTerminalRequest(msg);
                     break;
-                case "unsubscribe_terminal_request":
+                case 'unsubscribe_terminal_request':
                     this.handleUnsubscribeTerminalRequest(msg);
                     break;
-                case "terminal_input":
+                case 'terminal_input':
                     this.handleTerminalInput(msg);
                     break;
-                case "kill_terminal_request":
+                case 'kill_terminal_request':
                     await this.handleKillTerminalRequest(msg);
                     break;
-                case "attach_terminal_stream_request":
+                case 'attach_terminal_stream_request':
                     await this.handleAttachTerminalStreamRequest(msg);
                     break;
-                case "detach_terminal_stream_request":
+                case 'detach_terminal_stream_request':
                     this.handleDetachTerminalStreamRequest(msg);
                     break;
             }
         }
         catch (error) {
             const err = error instanceof Error ? error : new Error(String(error));
-            this.sessionLogger.error({ err }, "Error handling message");
+            this.sessionLogger.error({ err }, 'Error handling message');
             const requestId = msg.requestId;
-            if (typeof requestId === "string") {
+            if (typeof requestId === 'string') {
                 try {
                     this.emit({
-                        type: "rpc_error",
+                        type: 'rpc_error',
                         payload: {
                             requestId,
                             requestType: msg.type,
-                            error: "Request failed",
-                            code: "handler_error",
+                            error: 'Request failed',
+                            code: 'handler_error',
                         },
                     });
                 }
                 catch (emitError) {
-                    this.sessionLogger.error({ err: emitError }, "Failed to emit rpc_error");
+                    this.sessionLogger.error({ err: emitError }, 'Failed to emit rpc_error');
                 }
             }
             this.emit({
-                type: "activity_log",
+                type: 'activity_log',
                 payload: {
                     id: uuidv4(),
                     timestamp: new Date(),
-                    type: "error",
+                    type: 'error',
                     content: `Error: ${err.message}`,
                 },
             });
@@ -958,7 +985,7 @@ export class Session {
                 this.handleTerminalBinaryFrame(frame);
                 break;
             default:
-                this.sessionLogger.warn({ channel: frame.channel, messageType: frame.messageType }, "Unhandled binary mux channel");
+                this.sessionLogger.warn({ channel: frame.channel, messageType: frame.messageType }, 'Unhandled binary mux channel');
                 break;
         }
     }
@@ -966,7 +993,7 @@ export class Session {
         if (frame.messageType === TerminalBinaryMessageType.InputUtf8) {
             const binding = this.terminalStreams.get(frame.streamId);
             if (!binding) {
-                this.sessionLogger.warn({ streamId: frame.streamId }, "Terminal stream not found for input");
+                this.sessionLogger.warn({ streamId: frame.streamId }, 'Terminal stream not found for input');
                 return;
             }
             if (!this.terminalManager) {
@@ -981,11 +1008,11 @@ export class Session {
             if (payload.byteLength === 0) {
                 return;
             }
-            const text = Buffer.from(payload).toString("utf8");
+            const text = Buffer.from(payload).toString('utf8');
             if (!text) {
                 return;
             }
-            session.send({ type: "input", data: text });
+            session.send({ type: 'input', data: text });
             return;
         }
         if (frame.messageType === TerminalBinaryMessageType.Ack) {
@@ -1002,30 +1029,30 @@ export class Session {
             }
             return;
         }
-        this.sessionLogger.warn({ streamId: frame.streamId, messageType: frame.messageType }, "Unhandled terminal binary frame");
+        this.sessionLogger.warn({ streamId: frame.streamId, messageType: frame.messageType }, 'Unhandled terminal binary frame');
     }
     async handleRestartServerRequest(requestId, reason) {
         if (restartRequested) {
-            this.sessionLogger.debug("Restart already requested, ignoring duplicate");
+            this.sessionLogger.debug('Restart already requested, ignoring duplicate');
             return;
         }
         restartRequested = true;
         const payload = {
-            status: "restart_requested",
+            status: 'restart_requested',
             clientId: this.clientId,
         };
         if (reason && reason.trim().length > 0) {
             payload.reason = reason;
         }
         payload.requestId = requestId;
-        this.sessionLogger.warn({ reason }, "Restart requested via websocket");
+        this.sessionLogger.warn({ reason }, 'Restart requested via websocket');
         this.emit({
-            type: "status",
+            type: 'status',
             payload,
         });
-        if (typeof process.send === "function") {
+        if (typeof process.send === 'function') {
             process.send({
-                type: "paseo:restart",
+                type: 'paseo:restart',
                 ...(reason ? { reason } : {}),
             });
             return;
@@ -1051,56 +1078,75 @@ export class Session {
             this.sessionLogger.error({ err: error, agentId }, `Failed to remove agent ${agentId} from registry`);
         }
         this.emit({
-            type: "agent_deleted",
+            type: 'agent_deleted',
             payload: {
                 agentId,
                 requestId,
             },
         });
         if (this.agentUpdatesSubscription) {
-            this.emit({
-                type: "agent_update",
-                payload: { kind: "remove", agentId },
+            this.bufferOrEmitAgentUpdate(this.agentUpdatesSubscription, {
+                kind: 'remove',
+                agentId,
             });
         }
     }
     async handleArchiveAgentRequest(agentId, requestId) {
         this.sessionLogger.info({ agentId }, `Archiving agent ${agentId}`);
         const archivedAt = new Date().toISOString();
-        try {
-            const existing = await this.agentStorage.get(agentId);
-            if (existing) {
-                await this.agentStorage.upsert({
-                    ...existing,
-                    archivedAt,
-                });
+        const existing = await this.agentStorage.get(agentId);
+        let archivedRecord = existing;
+        if (!archivedRecord) {
+            const liveAgent = this.agentManager.getAgent(agentId);
+            if (!liveAgent) {
+                throw new Error(`Agent not found: ${agentId}`);
+            }
+            await this.agentStorage.applySnapshot(liveAgent, {
+                title: liveAgent.config.title ?? null,
+                internal: liveAgent.internal,
+            });
+            archivedRecord = await this.agentStorage.get(agentId);
+            if (!archivedRecord) {
+                throw new Error(`Agent not found in storage after snapshot: ${agentId}`);
             }
-            this.agentManager.notifyAgentState(agentId);
-        }
-        catch (error) {
-            this.sessionLogger.error({ err: error, agentId }, `Failed to archive agent ${agentId}`);
         }
+        archivedRecord = {
+            ...archivedRecord,
+            archivedAt,
+        };
+        await this.agentStorage.upsert(archivedRecord);
+        this.agentManager.notifyAgentState(agentId);
         this.emit({
-            type: "agent_archived",
+            type: 'agent_archived',
             payload: {
                 agentId,
                 archivedAt,
                 requestId,
             },
         });
+        await this.maybeArchiveWorktreeAfterLastAgentArchived({
+            archivedAgentId: agentId,
+            archivedAgentCwd: archivedRecord.cwd,
+            requestId,
+        });
     }
     async handleUpdateAgentRequest(agentId, name, labels, requestId) {
-        this.sessionLogger.info({ agentId, requestId, hasName: typeof name === "string", labelCount: labels ? Object.keys(labels).length : 0 }, "session: update_agent_request");
+        this.sessionLogger.info({
+            agentId,
+            requestId,
+            hasName: typeof name === 'string',
+            labelCount: labels ? Object.keys(labels).length : 0,
+        }, 'session: update_agent_request');
         const normalizedName = name?.trim();
         const normalizedLabels = labels && Object.keys(labels).length > 0 ? labels : undefined;
         if (!normalizedName && !normalizedLabels) {
             this.emit({
-                type: "update_agent_response",
+                type: 'update_agent_response',
                 payload: {
                     requestId,
                     agentId,
                     accepted: false,
-                    error: "Nothing to update (provide name and/or labels)",
+                    error: 'Nothing to update (provide name and/or labels)',
                 },
             });
             return;
@@ -1123,34 +1169,32 @@ export class Session {
                 await this.agentStorage.upsert({
                     ...existing,
                     ...(normalizedName ? { title: normalizedName } : {}),
-                    ...(normalizedLabels
-                        ? { labels: { ...existing.labels, ...normalizedLabels } }
-                        : {}),
+                    ...(normalizedLabels ? { labels: { ...existing.labels, ...normalizedLabels } } : {}),
                 });
             }
             this.emit({
-                type: "update_agent_response",
+                type: 'update_agent_response',
                 payload: { requestId, agentId, accepted: true, error: null },
             });
         }
         catch (error) {
-            this.sessionLogger.error({ err: error, agentId, requestId }, "session: update_agent_request error");
+            this.sessionLogger.error({ err: error, agentId, requestId }, 'session: update_agent_request error');
             this.emit({
-                type: "activity_log",
+                type: 'activity_log',
                 payload: {
                     id: uuidv4(),
                     timestamp: new Date(),
-                    type: "error",
+                    type: 'error',
                     content: `Failed to update agent: ${error.message}`,
                 },
             });
             this.emit({
-                type: "update_agent_response",
+                type: 'update_agent_response',
                 payload: {
                     requestId,
                     agentId,
                     accepted: false,
-                    error: error?.message ? String(error.message) : "Failed to update agent",
+                    error: error?.message ? String(error.message) : 'Failed to update agent',
                 },
             });
         }
@@ -1164,7 +1208,7 @@ export class Session {
         };
     }
     resolveModeReadinessState(readiness, mode) {
-        if (mode === "voice_mode") {
+        if (mode === 'voice_mode') {
             return readiness.realtimeVoice;
         }
         return readiness.dictation;
@@ -1202,11 +1246,11 @@ export class Session {
     async handleSetVoiceMode(enabled, agentId, requestId) {
         try {
             if (enabled) {
-                const unavailable = this.resolveVoiceFeatureUnavailableContext("voice_mode");
+                const unavailable = this.resolveVoiceFeatureUnavailableContext('voice_mode');
                 if (unavailable) {
                     throw new VoiceFeatureUnavailableError(unavailable);
                 }
-                const normalizedAgentId = this.parseVoiceTargetAgentId(agentId ?? "", "set_voice_mode");
+                const normalizedAgentId = this.parseVoiceTargetAgentId(agentId ?? '', 'set_voice_mode');
                 if (this.isVoiceMode &&
                     this.voiceModeAgentId &&
                     this.voiceModeAgentId !== normalizedAgentId) {
@@ -1219,10 +1263,10 @@ export class Session {
                 this.isVoiceMode = true;
                 this.sessionLogger.info({
                     agentId: this.voiceModeAgentId,
-                }, "Voice mode enabled for existing agent");
+                }, 'Voice mode enabled for existing agent');
                 if (requestId) {
                     this.emit({
-                        type: "set_voice_mode_response",
+                        type: 'set_voice_mode_response',
                         payload: {
                             requestId,
                             enabled: true,
@@ -1236,10 +1280,10 @@ export class Session {
             }
             await this.disableVoiceModeForActiveAgent(true);
             this.isVoiceMode = false;
-            this.sessionLogger.info("Voice mode disabled");
+            this.sessionLogger.info('Voice mode disabled');
             if (requestId) {
                 this.emit({
-                    type: "set_voice_mode_response",
+                    type: 'set_voice_mode_response',
                     payload: {
                         requestId,
                         enabled: false,
@@ -1251,16 +1295,16 @@ export class Session {
             }
         }
         catch (error) {
-            const errorMessage = error instanceof Error ? error.message : "Failed to set voice mode";
+            const errorMessage = error instanceof Error ? error.message : 'Failed to set voice mode';
             const unavailable = this.getVoiceFeatureUnavailableResponseMetadata(error);
             this.sessionLogger.error({
                 err: error,
                 enabled,
                 requestedAgentId: agentId ?? null,
-            }, "set_voice_mode failed");
+            }, 'set_voice_mode failed');
             if (requestId) {
                 this.emit({
-                    type: "set_voice_mode_response",
+                    type: 'set_voice_mode_response',
                     payload: {
                         requestId,
                         enabled: this.isVoiceMode,
@@ -1291,7 +1335,7 @@ export class Session {
     buildVoiceModeMcpServers(existing, socketPath) {
         const mcpStdio = this.voiceAgentMcpStdio;
         if (!mcpStdio) {
-            throw new Error("Voice MCP stdio bridge is not configured");
+            throw new Error('Voice MCP stdio bridge is not configured');
         }
         return {
             ...(existing ?? {}),
@@ -1306,7 +1350,7 @@ export class Session {
     async enableVoiceModeForAgent(agentId) {
         const ensureVoiceSocket = this.ensureVoiceMcpSocketForAgent;
         if (!ensureVoiceSocket) {
-            throw new Error("Voice MCP socket bridge is not configured");
+            throw new Error('Voice MCP socket bridge is not configured');
         }
         const existing = await this.ensureAgentLoaded(agentId);
         const socketPath = await ensureVoiceSocket(agentId);
@@ -1334,7 +1378,7 @@ export class Session {
     }
     async disableVoiceModeForActiveAgent(restoreAgentConfig) {
         this.clearVoiceModeInactivityTimeout();
-        this.cancelActiveVoiceDictationStream("voice mode disabled");
+        this.cancelActiveVoiceDictationStream('voice mode disabled');
         const agentId = this.voiceModeAgentId;
         if (!agentId) {
             this.voiceModeBaseConfig = null;
@@ -1343,7 +1387,7 @@ export class Session {
         this.unregisterVoiceSpeakHandler?.(agentId);
         this.unregisterVoiceCallerContext?.(agentId);
         await this.removeVoiceMcpSocketForAgent?.(agentId).catch((error) => {
-            this.sessionLogger.warn({ err: error, agentId }, "Failed to remove voice MCP socket bridge on disable");
+            this.sessionLogger.warn({ err: error, agentId }, 'Failed to remove voice MCP socket bridge on disable');
         });
         if (restoreAgentConfig && this.voiceModeBaseConfig) {
             const baseConfig = this.voiceModeBaseConfig;
@@ -1354,7 +1398,7 @@ export class Session {
                 });
             }
             catch (error) {
-                this.sessionLogger.warn({ err: error, agentId }, "Failed to restore agent config while disabling voice mode");
+                this.sessionLogger.warn({ err: error, agentId }, 'Failed to restore agent config while disabling voice mode');
             }
         }
         this.voiceModeBaseConfig = null;
@@ -1364,9 +1408,9 @@ export class Session {
         return dictationId.startsWith(VOICE_INTERNAL_DICTATION_ID_PREFIX);
     }
     handleDictationManagerMessage(msg) {
-        if (msg.type === "activity_log") {
+        if (msg.type === 'activity_log') {
             const metadata = msg.payload.metadata;
-            const dictationId = metadata && typeof metadata.dictationId === "string" ? metadata.dictationId : null;
+            const dictationId = metadata && typeof metadata.dictationId === 'string' ? metadata.dictationId : null;
             if (dictationId && this.isInternalVoiceDictationId(dictationId)) {
                 return;
             }
@@ -1374,14 +1418,14 @@ export class Session {
             return;
         }
         const payloadWithDictationId = msg.payload;
-        const dictationId = payloadWithDictationId && typeof payloadWithDictationId.dictationId === "string"
+        const dictationId = payloadWithDictationId && typeof payloadWithDictationId.dictationId === 'string'
             ? payloadWithDictationId.dictationId
             : null;
         if (!dictationId || !this.isInternalVoiceDictationId(dictationId)) {
             this.emit(msg);
             return;
         }
-        if (msg.type === "dictation_stream_final") {
+        if (msg.type === 'dictation_stream_final') {
             if (dictationId !== this.activeVoiceDictationId || !this.activeVoiceDictationResolve) {
                 return;
             }
@@ -1393,7 +1437,7 @@ export class Session {
             });
             return;
         }
-        if (msg.type === "dictation_stream_error") {
+        if (msg.type === 'dictation_stream_error') {
             if (dictationId !== this.activeVoiceDictationId || !this.activeVoiceDictationReject) {
                 return;
             }
@@ -1417,7 +1461,7 @@ export class Session {
         if (!dictationId) {
             return;
         }
-        this.sessionLogger.debug({ dictationId, reason }, "Cancelling active internal voice dictation stream");
+        this.sessionLogger.debug({ dictationId, reason }, 'Cancelling active internal voice dictation stream');
         if (this.activeVoiceDictationReject) {
             this.activeVoiceDictationReject(new Error(`Voice dictation cancelled: ${reason}`));
         }
@@ -1432,7 +1476,7 @@ export class Session {
             return;
         }
         if (this.activeVoiceDictationId) {
-            await this.finalizeActiveVoiceDictationStream("voice format changed");
+            await this.finalizeActiveVoiceDictationStream('voice format changed');
         }
         const dictationId = `${VOICE_INTERNAL_DICTATION_ID_PREFIX}${uuidv4()}`;
         let resolve = null;
@@ -1450,14 +1494,14 @@ export class Session {
         this.activeVoiceDictationResultPromise = resultPromise;
         this.activeVoiceDictationResolve = resolve;
         this.activeVoiceDictationReject = reject;
-        this.setPhase("transcribing");
+        this.setPhase('transcribing');
         this.emit({
-            type: "activity_log",
+            type: 'activity_log',
             payload: {
                 id: uuidv4(),
                 timestamp: new Date(),
-                type: "system",
-                content: "Transcribing audio...",
+                type: 'system',
+                content: 'Transcribing audio...',
             },
         });
         const startPromise = this.voiceStreamManager.handleStart(dictationId, format);
@@ -1482,7 +1526,7 @@ export class Session {
         await this.ensureActiveVoiceDictationStream(format);
         const dictationId = this.activeVoiceDictationId;
         if (!dictationId) {
-            throw new Error("Voice dictation stream did not initialize");
+            throw new Error('Voice dictation stream did not initialize');
         }
         const seq = this.activeVoiceDictationNextSeq;
         this.activeVoiceDictationNextSeq += 1;
@@ -1513,7 +1557,7 @@ export class Session {
             return;
         }
         this.activeVoiceDictationFinalizePromise = (async () => {
-            this.sessionLogger.debug({ dictationId, finalSeq, reason }, "Finalizing internal voice dictation stream");
+            this.sessionLogger.debug({ dictationId, finalSeq, reason }, 'Finalizing internal voice dictation stream');
             await this.voiceStreamManager.handleFinish(dictationId, finalSeq);
             const result = await resultPromise;
             this.resetActiveVoiceDictationState();
@@ -1524,12 +1568,12 @@ export class Session {
                 isVoiceMode: this.isVoiceMode,
                 transcriptLength: transcriptText.length,
                 transcript: transcriptText,
-            }, "Transcription result");
+            }, 'Transcription result');
             await this.handleTranscriptionResultPayload({
                 text: result.text,
                 requestId,
                 ...(result.debugRecordingPath
-                    ? { debugRecordingPath: result.debugRecordingPath, format: "audio/wav" }
+                    ? { debugRecordingPath: result.debugRecordingPath, format: 'audio/wav' }
                     : {}),
             });
         })();
@@ -1538,14 +1582,14 @@ export class Session {
         }
         catch (error) {
             this.resetActiveVoiceDictationState();
-            this.setPhase("idle");
-            this.clearSpeechInProgress("transcription error");
+            this.setPhase('idle');
+            this.clearSpeechInProgress('transcription error');
             this.emit({
-                type: "activity_log",
+                type: 'activity_log',
                 payload: {
                     id: uuidv4(),
                     timestamp: new Date(),
-                    type: "error",
+                    type: 'error',
                     content: `Transcription error: ${error instanceof Error ? error.message : String(error)}`,
                 },
             });
@@ -1561,14 +1605,14 @@ export class Session {
             await this.ensureAgentLoaded(agentId);
         }
         catch (error) {
-            this.handleAgentRunError(agentId, error, "Failed to initialize agent before sending prompt");
+            this.handleAgentRunError(agentId, error, 'Failed to initialize agent before sending prompt');
             return;
         }
         try {
             await this.interruptAgentIfRunning(agentId);
         }
         catch (error) {
-            this.handleAgentRunError(agentId, error, "Failed to interrupt running agent before sending prompt");
+            this.handleAgentRunError(agentId, error, 'Failed to interrupt running agent before sending prompt');
             return;
         }
         const prompt = this.buildAgentPrompt(text, images);
@@ -1588,7 +1632,7 @@ export class Session {
      */
     async handleCreateAgentRequest(msg) {
         const { config, worktreeName, requestId, initialPrompt, outputSchema, git, images, labels } = msg;
-        this.sessionLogger.info({ cwd: config.cwd, provider: config.provider, worktreeName }, `Creating agent in ${config.cwd} (${config.provider})${worktreeName ? ` with worktree ${worktreeName}` : ""}`);
+        this.sessionLogger.info({ cwd: config.cwd, provider: config.provider, worktreeName }, `Creating agent in ${config.cwd} (${config.provider})${worktreeName ? ` with worktree ${worktreeName}` : ''}`);
         try {
             const { sessionConfig, worktreeConfig } = await this.buildAgentSessionConfig(config, git, worktreeName, labels);
             const snapshot = await this.agentManager.createAgent(sessionConfig, undefined, { labels });
@@ -1610,11 +1654,11 @@ export class Session {
                 catch (promptError) {
                     this.sessionLogger.error({ err: promptError, agentId: snapshot.id }, `Failed to run initial prompt for agent ${snapshot.id}`);
                     this.emit({
-                        type: "activity_log",
+                        type: 'activity_log',
                         payload: {
                             id: uuidv4(),
                             timestamp: new Date(),
-                            type: "error",
+                            type: 'error',
                             content: `Initial prompt failed: ${promptError?.message ?? promptError}`,
                         },
                     });
@@ -1626,9 +1670,9 @@ export class Session {
                     throw new Error(`Agent ${snapshot.id} not found after creation`);
                 }
                 this.emit({
-                    type: "status",
+                    type: 'status',
                     payload: {
-                        status: "agent_created",
+                        status: 'agent_created',
                         agentId: snapshot.id,
                         requestId,
                         agent: agentPayload,
@@ -1656,23 +1700,23 @@ export class Session {
             this.sessionLogger.info({ agentId: snapshot.id, provider: snapshot.provider }, `Created agent ${snapshot.id} (${snapshot.provider})`);
         }
         catch (error) {
-            this.sessionLogger.error({ err: error }, "Failed to create agent");
+            this.sessionLogger.error({ err: error }, 'Failed to create agent');
             if (requestId) {
                 this.emit({
-                    type: "status",
+                    type: 'status',
                     payload: {
-                        status: "agent_create_failed",
+                        status: 'agent_create_failed',
                         requestId,
                         error: error?.message ?? String(error),
                     },
                 });
             }
             this.emit({
-                type: "activity_log",
+                type: 'activity_log',
                 payload: {
                     id: uuidv4(),
                     timestamp: new Date(),
-                    type: "error",
+                    type: 'error',
                     content: `Failed to create agent: ${error.message}`,
                 },
             });
@@ -1681,14 +1725,14 @@ export class Session {
     async handleResumeAgentRequest(msg) {
         const { handle, overrides, requestId } = msg;
         if (!handle) {
-            this.sessionLogger.warn("Resume request missing persistence handle");
+            this.sessionLogger.warn('Resume request missing persistence handle');
             this.emit({
-                type: "activity_log",
+                type: 'activity_log',
                 payload: {
                     id: uuidv4(),
                     timestamp: new Date(),
-                    type: "error",
-                    content: "Unable to resume agent: missing persistence handle",
+                    type: 'error',
+                    content: 'Unable to resume agent: missing persistence handle',
                 },
             });
             return;
@@ -1705,9 +1749,9 @@ export class Session {
                     throw new Error(`Agent ${snapshot.id} not found after resume`);
                 }
                 this.emit({
-                    type: "status",
+                    type: 'status',
                     payload: {
-                        status: "agent_resumed",
+                        status: 'agent_resumed',
                         agentId: snapshot.id,
                         requestId,
                         timelineSize,
@@ -1717,13 +1761,13 @@ export class Session {
             }
         }
         catch (error) {
-            this.sessionLogger.error({ err: error }, "Failed to resume agent");
+            this.sessionLogger.error({ err: error }, 'Failed to resume agent');
             this.emit({
-                type: "activity_log",
+                type: 'activity_log',
                 payload: {
                     id: uuidv4(),
                     timestamp: new Date(),
-                    type: "error",
+                    type: 'error',
                     content: `Failed to resume agent: ${error.message}`,
                 },
             });
@@ -1760,9 +1804,9 @@ export class Session {
             const timelineSize = this.agentManager.getTimeline(agentId).length;
             if (requestId) {
                 this.emit({
-                    type: "status",
+                    type: 'status',
                     payload: {
-                        status: "agent_refreshed",
+                        status: 'agent_refreshed',
                         agentId,
                         requestId,
                         timelineSize,
@@ -1773,11 +1817,11 @@ export class Session {
         catch (error) {
             this.sessionLogger.error({ err: error, agentId }, `Failed to refresh agent ${agentId}`);
             this.emit({
-                type: "activity_log",
+                type: 'activity_log',
                 payload: {
                     id: uuidv4(),
                     timestamp: new Date(),
-                    type: "error",
+                    type: 'error',
                     content: `Failed to refresh agent: ${error.message}`,
                 },
             });
@@ -1789,7 +1833,7 @@ export class Session {
             await this.interruptAgentIfRunning(agentId);
         }
         catch (error) {
-            this.handleAgentRunError(agentId, error, "Failed to cancel running agent on request");
+            this.handleAgentRunError(agentId, error, 'Failed to cancel running agent on request');
         }
     }
     async buildAgentSessionConfig(config, gitOptions, legacyWorktreeName, _labels) {
@@ -1811,14 +1855,14 @@ export class Session {
             }
             else {
                 // Resolve current branch name from HEAD
-                const { stdout } = await execAsync("git rev-parse --abbrev-ref HEAD", {
+                const { stdout } = await execAsync('git rev-parse --abbrev-ref HEAD', {
                     cwd,
                     env: READ_ONLY_GIT_ENV,
                 });
                 targetBranch = stdout.trim();
             }
             if (!targetBranch) {
-                throw new Error("A branch name is required when creating a worktree.");
+                throw new Error('A branch name is required when creating a worktree.');
             }
             this.sessionLogger.info({ worktreeSlug: normalized.worktreeSlug ?? targetBranch, branch: targetBranch }, `Creating worktree '${normalized.worktreeSlug ?? targetBranch}' for branch ${targetBranch}`);
             const createdWorktree = await createAgentWorktree({
@@ -1856,7 +1900,7 @@ export class Session {
                 cwd: msg.cwd ? expandTilde(msg.cwd) : undefined,
             });
             this.emit({
-                type: "list_provider_models_response",
+                type: 'list_provider_models_response',
                 payload: {
                     provider: msg.provider,
                     models,
@@ -1869,7 +1913,7 @@ export class Session {
         catch (error) {
             this.sessionLogger.error({ err: error, provider: msg.provider }, `Failed to list models for ${msg.provider}`);
             this.emit({
-                type: "list_provider_models_response",
+                type: 'list_provider_models_response',
                 payload: {
                     provider: msg.provider,
                     error: error?.message ?? String(error),
@@ -1884,7 +1928,7 @@ export class Session {
         try {
             const providers = await this.agentManager.listProviderAvailability();
             this.emit({
-                type: "list_available_providers_response",
+                type: 'list_available_providers_response',
                 payload: {
                     providers,
                     error: null,
@@ -1894,9 +1938,9 @@ export class Session {
             });
         }
         catch (error) {
-            this.sessionLogger.error({ err: error }, "Failed to list provider availability");
+            this.sessionLogger.error({ err: error }, 'Failed to list provider availability');
             this.emit({
-                type: "list_available_providers_response",
+                type: 'list_available_providers_response',
                 payload: {
                     providers: [],
                     error: error?.message ?? String(error),
@@ -1936,7 +1980,7 @@ export class Session {
             };
         }));
         this.emit({
-            type: "speech_models_list_response",
+            type: 'speech_models_list_response',
             payload: {
                 modelsDir,
                 models,
@@ -1946,18 +1990,16 @@ export class Session {
     }
     async handleSpeechModelsDownloadRequest(msg) {
         const modelsDir = this.localSpeechModelsDir;
-        const modelIdsRaw = msg.modelIds && msg.modelIds.length > 0
-            ? msg.modelIds
-            : this.defaultLocalSpeechModelIds;
+        const modelIdsRaw = msg.modelIds && msg.modelIds.length > 0 ? msg.modelIds : this.defaultLocalSpeechModelIds;
         const allModelIds = new Set(listLocalSpeechModels().map((m) => m.id));
         const invalid = modelIdsRaw.filter((id) => !allModelIds.has(id));
         if (invalid.length > 0) {
             this.emit({
-                type: "speech_models_download_response",
+                type: 'speech_models_download_response',
                 payload: {
                     modelsDir,
                     downloadedModelIds: [],
-                    error: `Unknown speech model id(s): ${invalid.join(", ")}`,
+                    error: `Unknown speech model id(s): ${invalid.join(', ')}`,
                     requestId: msg.requestId,
                 },
             });
@@ -1971,7 +2013,7 @@ export class Session {
                 logger: this.sessionLogger,
             });
             this.emit({
-                type: "speech_models_download_response",
+                type: 'speech_models_download_response',
                 payload: {
                     modelsDir,
                     downloadedModelIds: modelIds,
@@ -1981,9 +2023,9 @@ export class Session {
             });
         }
         catch (error) {
-            this.sessionLogger.error({ err: error, modelIds }, "Failed to download speech models");
+            this.sessionLogger.error({ err: error, modelIds }, 'Failed to download speech models');
             this.emit({
-                type: "speech_models_download_response",
+                type: 'speech_models_download_response',
                 payload: {
                     modelsDir,
                     downloadedModelIds: [],
@@ -2009,9 +2051,7 @@ export class Session {
         const baseBranch = merged.baseBranch?.trim() || undefined;
         const createWorktree = Boolean(merged.createWorktree);
         const createNewBranch = Boolean(merged.createNewBranch);
-        const normalizedBranchName = merged.newBranchName
-            ? slugify(merged.newBranchName)
-            : undefined;
+        const normalizedBranchName = merged.newBranchName ? slugify(merged.newBranchName) : undefined;
         const normalizedWorktreeSlug = merged.worktreeSlug
             ? slugify(merged.worktreeSlug)
             : normalizedBranchName;
@@ -2019,17 +2059,17 @@ export class Session {
             return null;
         }
         if (baseBranch) {
-            this.assertSafeGitRef(baseBranch, "base branch");
+            this.assertSafeGitRef(baseBranch, 'base branch');
         }
         if (createWorktree && !baseBranch) {
-            throw new Error("Base branch is required when creating a worktree");
+            throw new Error('Base branch is required when creating a worktree');
         }
         if (createNewBranch && !baseBranch) {
-            throw new Error("Base branch is required when creating a new branch");
+            throw new Error('Base branch is required when creating a new branch');
         }
         if (createNewBranch) {
             if (!normalizedBranchName) {
-                throw new Error("New branch name is required");
+                throw new Error('New branch name is required');
             }
             const validation = validateBranchSlug(normalizedBranchName);
             if (!validation.valid) {
@@ -2051,24 +2091,24 @@ export class Session {
         };
     }
     assertSafeGitRef(ref, label) {
-        if (!SAFE_GIT_REF_PATTERN.test(ref) || ref.includes("..") || ref.includes("@{")) {
+        if (!SAFE_GIT_REF_PATTERN.test(ref) || ref.includes('..') || ref.includes('@{')) {
             throw new Error(`Invalid ${label}: ${ref}`);
         }
     }
     toCheckoutError(error) {
         if (error instanceof NotGitRepoError) {
-            return { code: "NOT_GIT_REPO", message: error.message };
+            return { code: 'NOT_GIT_REPO', message: error.message };
         }
         if (error instanceof MergeConflictError) {
-            return { code: "MERGE_CONFLICT", message: error.message };
+            return { code: 'MERGE_CONFLICT', message: error.message };
         }
         if (error instanceof MergeFromBaseConflictError) {
-            return { code: "MERGE_CONFLICT", message: error.message };
+            return { code: 'MERGE_CONFLICT', message: error.message };
         }
         if (error instanceof Error) {
-            return { code: "UNKNOWN", message: error.message };
+            return { code: 'UNKNOWN', message: error.message };
         }
-        return { code: "UNKNOWN", message: String(error) };
+        return { code: 'UNKNOWN', message: String(error) };
     }
     isPathWithinRoot(rootPath, candidatePath) {
         const resolvedRoot = resolve(rootPath);
@@ -2079,47 +2119,47 @@ export class Session {
         return resolvedCandidate.startsWith(resolvedRoot + sep);
     }
     async generateCommitMessage(cwd) {
-        const diff = await getCheckoutDiff(cwd, { mode: "uncommitted", includeStructured: true }, { paseoHome: this.paseoHome });
+        const diff = await getCheckoutDiff(cwd, { mode: 'uncommitted', includeStructured: true }, { paseoHome: this.paseoHome });
         const schema = z.object({
             message: z
                 .string()
                 .min(1)
                 .max(72)
-                .describe("Concise git commit message, imperative mood, no trailing period."),
+                .describe('Concise git commit message, imperative mood, no trailing period.'),
         });
         const fileList = diff.structured && diff.structured.length > 0
             ? [
-                "Files changed:",
+                'Files changed:',
                 ...diff.structured.map((file) => {
-                    const changeType = file.isNew ? "A" : file.isDeleted ? "D" : "M";
-                    const status = file.status && file.status !== "ok" ? ` [${file.status}]` : "";
+                    const changeType = file.isNew ? 'A' : file.isDeleted ? 'D' : 'M';
+                    const status = file.status && file.status !== 'ok' ? ` [${file.status}]` : '';
                     return `${changeType}\t${file.path}\t(+${file.additions} -${file.deletions})${status}`;
                 }),
-            ].join("\n")
-            : "Files changed: (unknown)";
+            ].join('\n')
+            : 'Files changed: (unknown)';
         const maxPatchChars = 120000;
         const patch = diff.diff.length > maxPatchChars
             ? `${diff.diff.slice(0, maxPatchChars)}\n\n... (diff truncated to ${maxPatchChars} chars)\n`
             : diff.diff;
         const prompt = [
-            "Write a concise git commit message for the changes below.",
+            'Write a concise git commit message for the changes below.',
             "Return JSON only with a single field 'message'.",
-            "",
+            '',
             fileList,
-            "",
-            patch.length > 0 ? patch : "(No diff available)",
-        ].join("\n");
+            '',
+            patch.length > 0 ? patch : '(No diff available)',
+        ].join('\n');
         try {
             const result = await generateStructuredAgentResponseWithFallback({
                 manager: this.agentManager,
                 cwd,
                 prompt,
                 schema,
-                schemaName: "CommitMessage",
+                schemaName: 'CommitMessage',
                 maxRetries: 2,
                 providers: DEFAULT_STRUCTURED_GENERATION_PROVIDERS,
                 agentConfigOverrides: {
-                    title: "Commit generator",
+                    title: 'Commit generator',
                     internal: true,
                 },
             });
@@ -2128,14 +2168,14 @@ export class Session {
         catch (error) {
             if (error instanceof StructuredAgentResponseError ||
                 error instanceof StructuredAgentFallbackError) {
-                return "Update files";
+                return 'Update files';
             }
             throw error;
         }
     }
     async generatePullRequestText(cwd, baseRef) {
         const diff = await getCheckoutDiff(cwd, {
-            mode: "base",
+            mode: 'base',
             baseRef,
             includeStructured: true,
         }, { paseoHome: this.paseoHome });
@@ -2145,37 +2185,37 @@ export class Session {
         });
         const fileList = diff.structured && diff.structured.length > 0
             ? [
-                "Files changed:",
+                'Files changed:',
                 ...diff.structured.map((file) => {
-                    const changeType = file.isNew ? "A" : file.isDeleted ? "D" : "M";
-                    const status = file.status && file.status !== "ok" ? ` [${file.status}]` : "";
+                    const changeType = file.isNew ? 'A' : file.isDeleted ? 'D' : 'M';
+                    const status = file.status && file.status !== 'ok' ? ` [${file.status}]` : '';
                     return `${changeType}\t${file.path}\t(+${file.additions} -${file.deletions})${status}`;
                 }),
-            ].join("\n")
-            : "Files changed: (unknown)";
+            ].join('\n')
+            : 'Files changed: (unknown)';
         const maxPatchChars = 200000;
         const patch = diff.diff.length > maxPatchChars
             ? `${diff.diff.slice(0, maxPatchChars)}\n\n... (diff truncated to ${maxPatchChars} chars)\n`
             : diff.diff;
         const prompt = [
-            "Write a pull request title and body for the changes below.",
+            'Write a pull request title and body for the changes below.',
             "Return JSON only with fields 'title' and 'body'.",
-            "",
+            '',
             fileList,
-            "",
-            patch.length > 0 ? patch : "(No diff available)",
-        ].join("\n");
+            '',
+            patch.length > 0 ? patch : '(No diff available)',
+        ].join('\n');
         try {
             return await generateStructuredAgentResponseWithFallback({
                 manager: this.agentManager,
                 cwd,
                 prompt,
                 schema,
-                schemaName: "PullRequest",
+                schemaName: 'PullRequest',
                 maxRetries: 2,
                 providers: DEFAULT_STRUCTURED_GENERATION_PROVIDERS,
                 agentConfigOverrides: {
-                    title: "PR generator",
+                    title: 'PR generator',
                     internal: true,
                 },
             });
@@ -2184,8 +2224,8 @@ export class Session {
             if (error instanceof StructuredAgentResponseError ||
                 error instanceof StructuredAgentFallbackError) {
                 return {
-                    title: "Update changes",
-                    body: "Automated PR generated by Paseo.",
+                    title: 'Update changes',
+                    body: 'Automated PR generated by Paseo.',
                 };
             }
             throw error;
@@ -2194,12 +2234,12 @@ export class Session {
     async ensureCleanWorkingTree(cwd) {
         const dirty = await this.isWorkingTreeDirty(cwd);
         if (dirty) {
-            throw new Error("Working directory has uncommitted changes. Commit or stash before switching branches.");
+            throw new Error('Working directory has uncommitted changes. Commit or stash before switching branches.');
         }
     }
     async isWorkingTreeDirty(cwd) {
         try {
-            const { stdout } = await execAsync("git status --porcelain", {
+            const { stdout } = await execAsync('git status --porcelain', {
                 cwd,
                 env: READ_ONLY_GIT_ENV,
             });
@@ -2210,14 +2250,14 @@ export class Session {
         }
     }
     async checkoutExistingBranch(cwd, branch) {
-        this.assertSafeGitRef(branch, "branch");
+        this.assertSafeGitRef(branch, 'branch');
         try {
             await execAsync(`git rev-parse --verify ${branch}`, { cwd });
         }
         catch (error) {
             throw new Error(`Branch not found: ${branch}`);
         }
-        const { stdout } = await execAsync("git rev-parse --abbrev-ref HEAD", {
+        const { stdout } = await execAsync('git rev-parse --abbrev-ref HEAD', {
             cwd,
         });
         const current = stdout.trim();
@@ -2229,7 +2269,7 @@ export class Session {
     }
     async createBranchFromBase(params) {
         const { cwd, baseBranch, newBranchName } = params;
-        this.assertSafeGitRef(baseBranch, "base branch");
+        this.assertSafeGitRef(baseBranch, 'base branch');
         try {
             await execAsync(`git rev-parse --verify ${baseBranch}`, { cwd });
         }
@@ -2260,99 +2300,97 @@ export class Session {
      * Handle set agent mode request
      */
     async handleSetAgentModeRequest(agentId, modeId, requestId) {
-        this.sessionLogger.info({ agentId, modeId, requestId }, "session: set_agent_mode_request");
+        this.sessionLogger.info({ agentId, modeId, requestId }, 'session: set_agent_mode_request');
         try {
             await this.agentManager.setAgentMode(agentId, modeId);
-            this.sessionLogger.info({ agentId, modeId, requestId }, "session: set_agent_mode_request success");
+            this.sessionLogger.info({ agentId, modeId, requestId }, 'session: set_agent_mode_request success');
             this.emit({
-                type: "set_agent_mode_response",
+                type: 'set_agent_mode_response',
                 payload: { requestId, agentId, accepted: true, error: null },
             });
         }
         catch (error) {
-            this.sessionLogger.error({ err: error, agentId, modeId, requestId }, "session: set_agent_mode_request error");
+            this.sessionLogger.error({ err: error, agentId, modeId, requestId }, 'session: set_agent_mode_request error');
             this.emit({
-                type: "activity_log",
+                type: 'activity_log',
                 payload: {
                     id: uuidv4(),
                     timestamp: new Date(),
-                    type: "error",
+                    type: 'error',
                     content: `Failed to set agent mode: ${error.message}`,
                 },
             });
             this.emit({
-                type: "set_agent_mode_response",
+                type: 'set_agent_mode_response',
                 payload: {
                     requestId,
                     agentId,
                     accepted: false,
-                    error: error?.message ? String(error.message) : "Failed to set agent mode",
+                    error: error?.message ? String(error.message) : 'Failed to set agent mode',
                 },
             });
         }
     }
     async handleSetAgentModelRequest(agentId, modelId, requestId) {
-        this.sessionLogger.info({ agentId, modelId, requestId }, "session: set_agent_model_request");
+        this.sessionLogger.info({ agentId, modelId, requestId }, 'session: set_agent_model_request');
         try {
             await this.agentManager.setAgentModel(agentId, modelId);
-            this.sessionLogger.info({ agentId, modelId, requestId }, "session: set_agent_model_request success");
+            this.sessionLogger.info({ agentId, modelId, requestId }, 'session: set_agent_model_request success');
             this.emit({
-                type: "set_agent_model_response",
+                type: 'set_agent_model_response',
                 payload: { requestId, agentId, accepted: true, error: null },
             });
         }
         catch (error) {
-            this.sessionLogger.error({ err: error, agentId, modelId, requestId }, "session: set_agent_model_request error");
+            this.sessionLogger.error({ err: error, agentId, modelId, requestId }, 'session: set_agent_model_request error');
             this.emit({
-                type: "activity_log",
+                type: 'activity_log',
                 payload: {
                     id: uuidv4(),
                     timestamp: new Date(),
-                    type: "error",
+                    type: 'error',
                     content: `Failed to set agent model: ${error.message}`,
                 },
             });
             this.emit({
-                type: "set_agent_model_response",
+                type: 'set_agent_model_response',
                 payload: {
                     requestId,
                     agentId,
                     accepted: false,
-                    error: error?.message ? String(error.message) : "Failed to set agent model",
+                    error: error?.message ? String(error.message) : 'Failed to set agent model',
                 },
             });
         }
     }
     async handleSetAgentThinkingRequest(agentId, thinkingOptionId, requestId) {
-        this.sessionLogger.info({ agentId, thinkingOptionId, requestId }, "session: set_agent_thinking_request");
+        this.sessionLogger.info({ agentId, thinkingOptionId, requestId }, 'session: set_agent_thinking_request');
         try {
             await this.agentManager.setAgentThinkingOption(agentId, thinkingOptionId);
-            this.sessionLogger.info({ agentId, thinkingOptionId, requestId }, "session: set_agent_thinking_request success");
+            this.sessionLogger.info({ agentId, thinkingOptionId, requestId }, 'session: set_agent_thinking_request success');
             this.emit({
-                type: "set_agent_thinking_response",
+                type: 'set_agent_thinking_response',
                 payload: { requestId, agentId, accepted: true, error: null },
             });
         }
         catch (error) {
-            this.sessionLogger.error({ err: error, agentId, thinkingOptionId, requestId }, "session: set_agent_thinking_request error");
+            this.sessionLogger.error({ err: error, agentId, thinkingOptionId, requestId }, 'session: set_agent_thinking_request error');
             this.emit({
-                type: "activity_log",
+                type: 'activity_log',
                 payload: {
                     id: uuidv4(),
                     timestamp: new Date(),
-                    type: "error",
+                    type: 'error',
                     content: `Failed to set agent thinking option: ${error.message}`,
                 },
             });
             this.emit({
-                type: "set_agent_thinking_response",
+                type: 'set_agent_thinking_response',
                 payload: {
                     requestId,
                     agentId,
                     accepted: false,
-                    error: error?.message
-                        ? String(error.message)
-                        : "Failed to set agent thinking option",
+                    error: error?.message ? String(error.message) : 'Failed to set agent thinking option',
                 },
             });
         }
@@ -2362,12 +2400,12 @@ export class Session {
      */
     async handleClearAgentAttention(agentId) {
         const agentIds = Array.isArray(agentId) ? agentId : [agentId];
-        this.sessionLogger.debug({ agentIds }, `Clearing attention for ${agentIds.length} agent(s): ${agentIds.join(", ")}`);
+        this.sessionLogger.debug({ agentIds }, `Clearing attention for ${agentIds.length} agent(s): ${agentIds.join(', ')}`);
         try {
             await Promise.all(agentIds.map((id) => this.agentManager.clearAgentAttention(id)));
         }
         catch (error) {
-            this.sessionLogger.error({ err: error, agentIds }, "Failed to clear agent attention");
+            this.sessionLogger.error({ err: error, agentIds }, 'Failed to clear agent attention');
             // Don't throw - this is not critical
         }
     }
@@ -2391,116 +2429,69 @@ export class Session {
      */
     handleRegisterPushToken(token) {
         this.pushTokenStore.addToken(token);
-        this.sessionLogger.info("Registered push token");
+        this.sessionLogger.info('Registered push token');
     }
     /**
      * Handle list commands request for an agent
      */
-    async handleListCommandsRequest(agentId, requestId) {
-        this.sessionLogger.debug({ agentId }, `Handling list commands request for agent ${agentId}`);
+    async handleListCommandsRequest(msg) {
+        const { agentId, requestId, draftConfig } = msg;
+        this.sessionLogger.debug({ agentId, draftConfig }, `Handling list commands request for agent ${agentId}`);
         try {
             const agents = this.agentManager.listAgents();
             const agent = agents.find((a) => a.id === agentId);
-            if (!agent) {
+            if (agent?.session?.listCommands) {
+                const commands = await agent.session.listCommands();
                 this.emit({
-                    type: "list_commands_response",
+                    type: 'list_commands_response',
                     payload: {
                         agentId,
-                        commands: [],
-                        error: `Agent not found: ${agentId}`,
+                        commands,
+                        error: null,
                         requestId,
                     },
                 });
                 return;
             }
-            const session = agent.session;
-            if (!session || !session.listCommands) {
+            if (!agent && draftConfig) {
+                const sessionConfig = {
+                    provider: draftConfig.provider,
+                    cwd: expandTilde(draftConfig.cwd),
+                    ...(draftConfig.modeId ? { modeId: draftConfig.modeId } : {}),
+                    ...(draftConfig.model ? { model: draftConfig.model } : {}),
+                    ...(draftConfig.thinkingOptionId
+                        ? { thinkingOptionId: draftConfig.thinkingOptionId }
+                        : {}),
+                };
+                const commands = await this.agentManager.listDraftCommands(sessionConfig);
                 this.emit({
-                    type: "list_commands_response",
+                    type: 'list_commands_response',
                     payload: {
                         agentId,
-                        commands: [],
-                        error: `Agent does not support listing commands`,
+                        commands,
+                        error: null,
                         requestId,
                     },
                 });
                 return;
             }
-            const commands = await session.listCommands();
-            this.emit({
-                type: "list_commands_response",
-                payload: {
-                    agentId,
-                    commands,
-                    error: null,
-                    requestId,
-                },
-            });
-        }
-        catch (error) {
-            this.sessionLogger.error({ err: error, agentId }, "Failed to list commands");
             this.emit({
-                type: "list_commands_response",
+                type: 'list_commands_response',
                 payload: {
                     agentId,
                     commands: [],
-                    error: error.message,
-                    requestId,
-                },
-            });
-        }
-    }
-    /**
-     * Handle execute command request for an agent
-     */
-    async handleExecuteCommandRequest(agentId, commandName, args, requestId) {
-        this.sessionLogger.debug({ agentId, commandName }, `Handling execute command request for agent ${agentId}`);
-        try {
-            const agents = this.agentManager.listAgents();
-            const agent = agents.find((a) => a.id === agentId);
-            if (!agent) {
-                this.emit({
-                    type: "execute_command_response",
-                    payload: {
-                        agentId,
-                        result: null,
-                        error: `Agent not found: ${agentId}`,
-                        requestId,
-                    },
-                });
-                return;
-            }
-            const session = agent.session;
-            if (!session || !session.executeCommand) {
-                this.emit({
-                    type: "execute_command_response",
-                    payload: {
-                        agentId,
-                        result: null,
-                        error: `Agent does not support executing commands`,
-                        requestId,
-                    },
-                });
-                return;
-            }
-            const result = await session.executeCommand(commandName, args);
-            this.emit({
-                type: "execute_command_response",
-                payload: {
-                    agentId,
-                    result,
-                    error: null,
+                    error: agent ? `Agent does not support listing commands` : `Agent not found: ${agentId}`,
                     requestId,
                 },
             });
         }
         catch (error) {
-            this.sessionLogger.error({ err: error, agentId, commandName }, "Failed to execute command");
+            this.sessionLogger.error({ err: error, agentId, draftConfig }, 'Failed to list commands');
             this.emit({
-                type: "execute_command_response",
+                type: 'list_commands_response',
                 payload: {
                     agentId,
-                    result: null,
+                    commands: [],
                     error: error.message,
                     requestId,
                 },
@@ -2517,13 +2508,13 @@ export class Session {
             this.sessionLogger.debug({ agentId }, `Permission response forwarded to agent ${agentId}`);
         }
         catch (error) {
-            this.sessionLogger.error({ err: error, agentId, requestId }, "Failed to respond to permission");
+            this.sessionLogger.error({ err: error, agentId, requestId }, 'Failed to respond to permission');
             this.emit({
-                type: "activity_log",
+                type: 'activity_log',
                 payload: {
                     id: uuidv4(),
                     timestamp: new Date(),
-                    type: "error",
+                    type: 'error',
                     content: `Failed to respond to permission: ${error.message}`,
                 },
             });
@@ -2537,7 +2528,7 @@ export class Session {
             const status = await getCheckoutStatus(resolvedCwd, { paseoHome: this.paseoHome });
             if (!status.isGit) {
                 this.emit({
-                    type: "checkout_status_response",
+                    type: 'checkout_status_response',
                     payload: {
                         cwd,
                         isGit: false,
@@ -2547,6 +2538,7 @@ export class Session {
                         baseRef: null,
                         aheadBehind: null,
                         aheadOfOrigin: null,
+                        behindOfOrigin: null,
                         hasRemote: false,
                         remoteUrl: null,
                         isPaseoOwnedWorktree: false,
@@ -2558,7 +2550,7 @@ export class Session {
             }
             if (status.isPaseoOwnedWorktree) {
                 this.emit({
-                    type: "checkout_status_response",
+                    type: 'checkout_status_response',
                     payload: {
                         cwd,
                         isGit: true,
@@ -2569,6 +2561,7 @@ export class Session {
                         baseRef: status.baseRef,
                         aheadBehind: status.aheadBehind ?? null,
                         aheadOfOrigin: status.aheadOfOrigin ?? null,
+                        behindOfOrigin: status.behindOfOrigin ?? null,
                         hasRemote: status.hasRemote,
                         remoteUrl: status.remoteUrl,
                         isPaseoOwnedWorktree: true,
@@ -2579,7 +2572,7 @@ export class Session {
                 return;
             }
             this.emit({
-                type: "checkout_status_response",
+                type: 'checkout_status_response',
                 payload: {
                     cwd,
                     isGit: true,
@@ -2589,6 +2582,7 @@ export class Session {
                     baseRef: status.baseRef ?? null,
                     aheadBehind: status.aheadBehind ?? null,
                     aheadOfOrigin: status.aheadOfOrigin ?? null,
+                    behindOfOrigin: status.behindOfOrigin ?? null,
                     hasRemote: status.hasRemote,
                     remoteUrl: status.remoteUrl,
                     isPaseoOwnedWorktree: false,
@@ -2599,7 +2593,7 @@ export class Session {
         }
         catch (error) {
             this.emit({
-                type: "checkout_status_response",
+                type: 'checkout_status_response',
                 payload: {
                     cwd,
                     isGit: false,
@@ -2609,6 +2603,7 @@ export class Session {
                     baseRef: null,
                     aheadBehind: null,
                     aheadOfOrigin: null,
+                    behindOfOrigin: null,
                     hasRemote: false,
                     remoteUrl: null,
                     isPaseoOwnedWorktree: false,
@@ -2629,7 +2624,7 @@ export class Session {
                     env: READ_ONLY_GIT_ENV,
                 });
                 this.emit({
-                    type: "validate_branch_response",
+                    type: 'validate_branch_response',
                     payload: {
                         exists: true,
                         resolvedRef: branchName,
@@ -2650,7 +2645,7 @@ export class Session {
                     env: READ_ONLY_GIT_ENV,
                 });
                 this.emit({
-                    type: "validate_branch_response",
+                    type: 'validate_branch_response',
                     payload: {
                         exists: true,
                         resolvedRef: `origin/${branchName}`,
@@ -2666,7 +2661,7 @@ export class Session {
             }
             // Branch not found anywhere
             this.emit({
-                type: "validate_branch_response",
+                type: 'validate_branch_response',
                 payload: {
                     exists: false,
                     resolvedRef: null,
@@ -2678,7 +2673,7 @@ export class Session {
         }
         catch (error) {
             this.emit({
-                type: "validate_branch_response",
+                type: 'validate_branch_response',
                 payload: {
                     exists: false,
                     resolvedRef: null,
@@ -2695,7 +2690,7 @@ export class Session {
             const resolvedCwd = expandTilde(cwd);
             const branches = await listBranchSuggestions(resolvedCwd, { query, limit });
             this.emit({
-                type: "branch_suggestions_response",
+                type: 'branch_suggestions_response',
                 payload: {
                     branches,
                     error: null,
@@ -2705,7 +2700,7 @@ export class Session {
         }
         catch (error) {
             this.emit({
-                type: "branch_suggestions_response",
+                type: 'branch_suggestions_response',
                 payload: {
                     branches: [],
                     error: error instanceof Error ? error.message : String(error),
@@ -2715,17 +2710,30 @@ export class Session {
         }
     }
     async handleDirectorySuggestionsRequest(msg) {
-        const { query, limit, requestId } = msg;
+        const { query, limit, requestId, cwd, includeFiles, includeDirectories } = msg;
         try {
-            const directories = await searchHomeDirectories({
-                homeDir: process.env.HOME ?? homedir(),
-                query,
-                limit,
-            });
+            const workspaceCwd = cwd?.trim();
+            const entries = workspaceCwd
+                ? await searchWorkspaceEntries({
+                    cwd: expandTilde(workspaceCwd),
+                    query,
+                    limit,
+                    includeFiles,
+                    includeDirectories,
+                })
+                : (await searchHomeDirectories({
+                    homeDir: process.env.HOME ?? homedir(),
+                    query,
+                    limit,
+                })).map((path) => ({ path, kind: 'directory' }));
+            const directories = entries
+                .filter((entry) => entry.kind === 'directory')
+                .map((entry) => entry.path);
             this.emit({
-                type: "directory_suggestions_response",
+                type: 'directory_suggestions_response',
                 payload: {
                     directories,
+                    entries,
                     error: null,
                     requestId,
                 },
@@ -2733,9 +2741,10 @@ export class Session {
         }
         catch (error) {
             this.emit({
-                type: "directory_suggestions_response",
+                type: 'directory_suggestions_response',
                 payload: {
                     directories: [],
+                    entries: [],
                     error: error instanceof Error ? error.message : String(error),
                     requestId,
                 },
@@ -2743,19 +2752,17 @@ export class Session {
         }
     }
     normalizeCheckoutDiffCompare(compare) {
-        if (compare.mode === "uncommitted") {
-            return { mode: "uncommitted" };
+        if (compare.mode === 'uncommitted') {
+            return { mode: 'uncommitted' };
         }
         const trimmedBaseRef = compare.baseRef?.trim();
-        return trimmedBaseRef
-            ? { mode: "base", baseRef: trimmedBaseRef }
-            : { mode: "base" };
+        return trimmedBaseRef ? { mode: 'base', baseRef: trimmedBaseRef } : { mode: 'base' };
     }
     buildCheckoutDiffTargetKey(cwd, compare) {
         return JSON.stringify([
             cwd,
             compare.mode,
-            compare.mode === "base" ? (compare.baseRef ?? "") : "",
+            compare.mode === 'base' ? (compare.baseRef ?? '') : '',
         ]);
     }
     closeCheckoutDiffWatchTarget(target) {
@@ -2790,7 +2797,7 @@ export class Session {
     }
     async resolveCheckoutGitDir(cwd) {
         try {
-            const { stdout } = await execAsync("git rev-parse --absolute-git-dir", {
+            const { stdout } = await execAsync('git rev-parse --absolute-git-dir', {
                 cwd,
                 env: READ_ONLY_GIT_ENV,
             });
@@ -2803,7 +2810,7 @@ export class Session {
     }
     async resolveCheckoutWatchRoot(cwd) {
         try {
-            const { stdout } = await execAsync("git rev-parse --path-format=absolute --show-toplevel", {
+            const { stdout } = await execAsync('git rev-parse --path-format=absolute --show-toplevel', {
                 cwd,
                 env: READ_ONLY_GIT_ENV,
             });
@@ -2829,7 +2836,7 @@ export class Session {
         }
         for (const subscriptionId of target.subscriptions) {
             this.emit({
-                type: "checkout_diff_update",
+                type: 'checkout_diff_update',
                 payload: {
                     subscriptionId,
                     ...snapshot,
@@ -2876,7 +2883,9 @@ export class Session {
         target.refreshPromise = (async () => {
             do {
                 target.refreshQueued = false;
-                const snapshot = await this.computeCheckoutDiffSnapshot(target.cwd, target.compare, { diffCwd: target.diffCwd });
+                const snapshot = await this.computeCheckoutDiffSnapshot(target.cwd, target.compare, {
+                    diffCwd: target.diffCwd,
+                });
                 target.latestPayload = snapshot;
                 const fingerprint = this.checkoutDiffSnapshotFingerprint(snapshot);
                 if (fingerprint !== target.latestFingerprint) {
@@ -2920,7 +2929,7 @@ export class Session {
             watchPaths.add(gitDir);
         }
         let hasRecursiveRepoCoverage = false;
-        const allowRecursiveRepoWatch = process.platform !== "linux";
+        const allowRecursiveRepoWatch = process.platform !== 'linux';
         for (const watchPath of watchPaths) {
             const shouldTryRecursive = watchPath === repoWatchPath && allowRecursiveRepoWatch;
             const createWatcher = (recursive) => watch(watchPath, { recursive }, () => {
@@ -2941,21 +2950,21 @@ export class Session {
                 if (shouldTryRecursive) {
                     try {
                         watcher = createWatcher(false);
-                        this.sessionLogger.warn({ err: error, watchPath, cwd, compare }, "Checkout diff recursive watch unavailable; using non-recursive fallback");
+                        this.sessionLogger.warn({ err: error, watchPath, cwd, compare }, 'Checkout diff recursive watch unavailable; using non-recursive fallback');
                     }
                     catch (fallbackError) {
-                        this.sessionLogger.warn({ err: fallbackError, watchPath, cwd, compare }, "Failed to start checkout diff watcher");
+                        this.sessionLogger.warn({ err: fallbackError, watchPath, cwd, compare }, 'Failed to start checkout diff watcher');
                     }
                 }
                 else {
-                    this.sessionLogger.warn({ err: error, watchPath, cwd, compare }, "Failed to start checkout diff watcher");
+                    this.sessionLogger.warn({ err: error, watchPath, cwd, compare }, 'Failed to start checkout diff watcher');
                 }
             }
             if (!watcher) {
                 continue;
             }
-            watcher.on("error", (error) => {
-                this.sessionLogger.warn({ err: error, watchPath, cwd, compare }, "Checkout diff watcher error");
+            watcher.on('error', (error) => {
+                this.sessionLogger.warn({ err: error, watchPath, cwd, compare }, 'Checkout diff watcher error');
             });
             target.watchers.push(watcher);
             if (watchPath === repoWatchPath && watcherIsRecursive) {
@@ -2971,10 +2980,8 @@ export class Session {
                 cwd,
                 compare,
                 intervalMs: CHECKOUT_DIFF_FALLBACK_REFRESH_MS,
-                reason: target.watchers.length === 0
-                    ? "no_watchers"
-                    : "missing_recursive_repo_root_coverage",
-            }, "Checkout diff watchers unavailable; using timed refresh fallback");
+                reason: target.watchers.length === 0 ? 'no_watchers' : 'missing_recursive_repo_root_coverage',
+            }, 'Checkout diff watchers unavailable; using timed refresh fallback');
         }
         this.checkoutDiffTargets.set(targetKey, target);
         return target;
@@ -2995,7 +3002,7 @@ export class Session {
         target.latestPayload = snapshot;
         target.latestFingerprint = this.checkoutDiffSnapshotFingerprint(snapshot);
         this.emit({
-            type: "subscribe_checkout_diff_response",
+            type: 'subscribe_checkout_diff_response',
             payload: {
                 subscriptionId: msg.subscriptionId,
                 ...snapshot,
@@ -3018,12 +3025,12 @@ export class Session {
     async handleCheckoutCommitRequest(msg) {
         const { cwd, requestId } = msg;
         try {
-            let message = msg.message?.trim() ?? "";
+            let message = msg.message?.trim() ?? '';
             if (!message) {
                 message = await this.generateCommitMessage(cwd);
             }
             if (!message) {
-                throw new Error("Commit message is required");
+                throw new Error('Commit message is required');
             }
             await commitChanges(cwd, {
                 message,
@@ -3031,7 +3038,7 @@ export class Session {
             });
             this.scheduleCheckoutDiffRefreshForCwd(cwd);
             this.emit({
-                type: "checkout_commit_response",
+                type: 'checkout_commit_response',
                 payload: {
                     cwd,
                     success: true,
@@ -3042,7 +3049,7 @@ export class Session {
         }
         catch (error) {
             this.emit({
-                type: "checkout_commit_response",
+                type: 'checkout_commit_response',
                 payload: {
                     cwd,
                     success: false,
@@ -3058,13 +3065,13 @@ export class Session {
             const status = await getCheckoutStatus(cwd, { paseoHome: this.paseoHome });
             if (!status.isGit) {
                 try {
-                    await execAsync("git rev-parse --is-inside-work-tree", {
+                    await execAsync('git rev-parse --is-inside-work-tree', {
                         cwd,
                         env: READ_ONLY_GIT_ENV,
                     });
                 }
                 catch (error) {
-                    const details = typeof error?.stderr === "string"
+                    const details = typeof error?.stderr === 'string'
                         ? String(error.stderr).trim()
                         : error instanceof Error
                             ? error.message
@@ -3073,28 +3080,28 @@ export class Session {
                 }
             }
             if (msg.requireCleanTarget) {
-                const { stdout } = await execAsync("git status --porcelain", {
+                const { stdout } = await execAsync('git status --porcelain', {
                     cwd,
                     env: READ_ONLY_GIT_ENV,
                 });
                 if (stdout.trim().length > 0) {
-                    throw new Error("Working directory has uncommitted changes.");
+                    throw new Error('Working directory has uncommitted changes.');
                 }
             }
             let baseRef = msg.baseRef ?? (status.isGit ? status.baseRef : null);
             if (!baseRef) {
-                throw new Error("Base branch is required for merge");
+                throw new Error('Base branch is required for merge');
             }
-            if (baseRef.startsWith("origin/")) {
-                baseRef = baseRef.slice("origin/".length);
+            if (baseRef.startsWith('origin/')) {
+                baseRef = baseRef.slice('origin/'.length);
             }
             await mergeToBase(cwd, {
                 baseRef,
-                mode: msg.strategy === "squash" ? "squash" : "merge",
+                mode: msg.strategy === 'squash' ? 'squash' : 'merge',
             }, { paseoHome: this.paseoHome });
             this.scheduleCheckoutDiffRefreshForCwd(cwd);
             this.emit({
-                type: "checkout_merge_response",
+                type: 'checkout_merge_response',
                 payload: {
                     cwd,
                     success: true,
@@ -3105,7 +3112,7 @@ export class Session {
         }
         catch (error) {
             this.emit({
-                type: "checkout_merge_response",
+                type: 'checkout_merge_response',
                 payload: {
                     cwd,
                     success: false,
@@ -3119,12 +3126,12 @@ export class Session {
         const { cwd, requestId } = msg;
         try {
             if (msg.requireCleanTarget ?? true) {
-                const { stdout } = await execAsync("git status --porcelain", {
+                const { stdout } = await execAsync('git status --porcelain', {
                     cwd,
                     env: READ_ONLY_GIT_ENV,
                 });
                 if (stdout.trim().length > 0) {
-                    throw new Error("Working directory has uncommitted changes.");
+                    throw new Error('Working directory has uncommitted changes.');
                 }
             }
             await mergeFromBase(cwd, {
@@ -3133,7 +3140,7 @@ export class Session {
             });
             this.scheduleCheckoutDiffRefreshForCwd(cwd);
             this.emit({
-                type: "checkout_merge_from_base_response",
+                type: 'checkout_merge_from_base_response',
                 payload: {
                     cwd,
                     success: true,
@@ -3144,7 +3151,7 @@ export class Session {
         }
         catch (error) {
             this.emit({
-                type: "checkout_merge_from_base_response",
+                type: 'checkout_merge_from_base_response',
                 payload: {
                     cwd,
                     success: false,
@@ -3159,7 +3166,7 @@ export class Session {
         try {
             await pushCurrentBranch(cwd);
             this.emit({
-                type: "checkout_push_response",
+                type: 'checkout_push_response',
                 payload: {
                     cwd,
                     success: true,
@@ -3170,7 +3177,7 @@ export class Session {
         }
         catch (error) {
             this.emit({
-                type: "checkout_push_response",
+                type: 'checkout_push_response',
                 payload: {
                     cwd,
                     success: false,
@@ -3183,8 +3190,8 @@ export class Session {
     async handleCheckoutPrCreateRequest(msg) {
         const { cwd, requestId } = msg;
         try {
-            let title = msg.title?.trim() ?? "";
-            let body = msg.body?.trim() ?? "";
+            let title = msg.title?.trim() ?? '';
+            let body = msg.body?.trim() ?? '';
             if (!title || !body) {
                 const generated = await this.generatePullRequestText(cwd, msg.baseRef);
                 if (!title)
@@ -3198,7 +3205,7 @@ export class Session {
                 base: msg.baseRef,
             });
             this.emit({
-                type: "checkout_pr_create_response",
+                type: 'checkout_pr_create_response',
                 payload: {
                     cwd,
                     url: result.url ?? null,
@@ -3210,7 +3217,7 @@ export class Session {
         }
         catch (error) {
             this.emit({
-                type: "checkout_pr_create_response",
+                type: 'checkout_pr_create_response',
                 payload: {
                     cwd,
                     url: null,
@@ -3226,7 +3233,7 @@ export class Session {
         try {
             const prStatus = await getPullRequestStatus(cwd);
             this.emit({
-                type: "checkout_pr_status_response",
+                type: 'checkout_pr_status_response',
                 payload: {
                     cwd,
                     status: prStatus.status,
@@ -3238,7 +3245,7 @@ export class Session {
         }
         catch (error) {
             this.emit({
-                type: "checkout_pr_status_response",
+                type: 'checkout_pr_status_response',
                 payload: {
                     cwd,
                     status: null,
@@ -3254,10 +3261,10 @@ export class Session {
         const cwd = msg.repoRoot ?? msg.cwd;
         if (!cwd) {
             this.emit({
-                type: "paseo_worktree_list_response",
+                type: 'paseo_worktree_list_response',
                 payload: {
                     worktrees: [],
-                    error: { code: "UNKNOWN", message: "cwd or repoRoot is required" },
+                    error: { code: 'UNKNOWN', message: 'cwd or repoRoot is required' },
                     requestId,
                 },
             });
@@ -3266,7 +3273,7 @@ export class Session {
         try {
             const worktrees = await listPaseoWorktrees({ cwd, paseoHome: this.paseoHome });
             this.emit({
-                type: "paseo_worktree_list_response",
+                type: 'paseo_worktree_list_response',
                 payload: {
                     worktrees: worktrees.map((entry) => ({
                         worktreePath: entry.path,
@@ -3280,7 +3287,7 @@ export class Session {
         }
         catch (error) {
             this.emit({
-                type: "paseo_worktree_list_response",
+                type: 'paseo_worktree_list_response',
                 payload: {
                     worktrees: [],
                     error: this.toCheckoutError(error),
@@ -3289,6 +3296,115 @@ export class Session {
             });
         }
     }
+    async maybeArchiveWorktreeAfterLastAgentArchived(options) {
+        try {
+            const ownership = await isPaseoOwnedWorktreeCwd(options.archivedAgentCwd, {
+                paseoHome: this.paseoHome,
+            });
+            if (!ownership.allowed) {
+                return;
+            }
+            const resolvedWorktree = await resolvePaseoWorktreeRootForCwd(options.archivedAgentCwd, {
+                paseoHome: this.paseoHome,
+            });
+            if (!resolvedWorktree) {
+                return;
+            }
+            const records = await this.agentStorage.list();
+            const recordsById = new Map(records.map((record) => [record.id, record]));
+            const targetPath = resolvedWorktree.worktreePath;
+            const hasRemainingNonArchivedRecord = records.some((record) => {
+                if (record.id === options.archivedAgentId || record.archivedAt) {
+                    return false;
+                }
+                return this.isPathWithinRoot(targetPath, record.cwd);
+            });
+            if (hasRemainingNonArchivedRecord) {
+                return;
+            }
+            const hasUnknownLiveAgent = this.agentManager.listAgents().some((agent) => {
+                if (agent.id === options.archivedAgentId) {
+                    return false;
+                }
+                if (!this.isPathWithinRoot(targetPath, agent.cwd)) {
+                    return false;
+                }
+                return !recordsById.has(agent.id);
+            });
+            if (hasUnknownLiveAgent) {
+                return;
+            }
+            const repoRoot = ownership.repoRoot;
+            if (!repoRoot) {
+                this.sessionLogger.warn({ agentId: options.archivedAgentId, worktreePath: targetPath }, 'Unable to resolve repo root for auto-archive after agent archive');
+                return;
+            }
+            await this.archivePaseoWorktree({
+                targetPath,
+                repoRoot,
+                requestId: options.requestId,
+            });
+        }
+        catch (error) {
+            this.sessionLogger.warn({ err: error, agentId: options.archivedAgentId, cwd: options.archivedAgentCwd }, 'Failed to auto-archive worktree after agent archive');
+        }
+    }
+    async archivePaseoWorktree(options) {
+        let targetPath = options.targetPath;
+        const resolvedWorktree = await resolvePaseoWorktreeRootForCwd(targetPath, {
+            paseoHome: this.paseoHome,
+        });
+        if (resolvedWorktree) {
+            targetPath = resolvedWorktree.worktreePath;
+        }
+        const removedAgents = new Set();
+        const agents = this.agentManager.listAgents();
+        for (const agent of agents) {
+            if (this.isPathWithinRoot(targetPath, agent.cwd)) {
+                removedAgents.add(agent.id);
+                try {
+                    await this.agentManager.closeAgent(agent.id);
+                }
+                catch {
+                    // ignore cleanup errors
+                }
+                try {
+                    await this.agentStorage.remove(agent.id);
+                }
+                catch {
+                    // ignore cleanup errors
+                }
+            }
+        }
+        const registryRecords = await this.agentStorage.list();
+        for (const record of registryRecords) {
+            if (this.isPathWithinRoot(targetPath, record.cwd)) {
+                removedAgents.add(record.id);
+                try {
+                    await this.agentStorage.remove(record.id);
+                }
+                catch {
+                    // ignore cleanup errors
+                }
+            }
+        }
+        await this.killTerminalsUnderPath(targetPath);
+        await deletePaseoWorktree({
+            cwd: options.repoRoot,
+            worktreePath: targetPath,
+            paseoHome: this.paseoHome,
+        });
+        for (const agentId of removedAgents) {
+            this.emit({
+                type: 'agent_deleted',
+                payload: {
+                    agentId,
+                    requestId: options.requestId,
+                },
+            });
+        }
+        return Array.from(removedAgents);
+    }
     async handlePaseoWorktreeArchiveRequest(msg) {
         const { requestId } = msg;
         let targetPath = msg.worktreePath;
@@ -3296,7 +3412,7 @@ export class Session {
         try {
             if (!targetPath) {
                 if (!repoRoot || !msg.branchName) {
-                    throw new Error("worktreePath or repoRoot+branchName is required");
+                    throw new Error('worktreePath or repoRoot+branchName is required');
                 }
                 const worktrees = await listPaseoWorktrees({ cwd: repoRoot, paseoHome: this.paseoHome });
                 const match = worktrees.find((entry) => entry.branchName === msg.branchName);
@@ -3305,16 +3421,18 @@ export class Session {
                 }
                 targetPath = match.path;
             }
-            const ownership = await isPaseoOwnedWorktreeCwd(targetPath, { paseoHome: this.paseoHome });
+            const ownership = await isPaseoOwnedWorktreeCwd(targetPath, {
+                paseoHome: this.paseoHome,
+            });
             if (!ownership.allowed) {
                 this.emit({
-                    type: "paseo_worktree_archive_response",
+                    type: 'paseo_worktree_archive_response',
                     payload: {
                         success: false,
                         removedAgents: [],
                         error: {
-                            code: "NOT_ALLOWED",
-                            message: "Worktree is not a Paseo-owned worktree",
+                            code: 'NOT_ALLOWED',
+                            message: 'Worktree is not a Paseo-owned worktree',
                         },
                         requestId,
                     },
@@ -3323,64 +3441,18 @@ export class Session {
             }
             repoRoot = ownership.repoRoot ?? repoRoot ?? null;
             if (!repoRoot) {
-                throw new Error("Unable to resolve repo root for worktree");
-            }
-            const resolvedWorktree = await resolvePaseoWorktreeRootForCwd(targetPath, {
-                paseoHome: this.paseoHome,
-            });
-            if (resolvedWorktree) {
-                targetPath = resolvedWorktree.worktreePath;
-            }
-            const removedAgents = new Set();
-            const agents = this.agentManager.listAgents();
-            for (const agent of agents) {
-                if (this.isPathWithinRoot(targetPath, agent.cwd)) {
-                    removedAgents.add(agent.id);
-                    try {
-                        await this.agentManager.closeAgent(agent.id);
-                    }
-                    catch {
-                        // ignore cleanup errors
-                    }
-                    try {
-                        await this.agentStorage.remove(agent.id);
-                    }
-                    catch {
-                        // ignore cleanup errors
-                    }
-                }
+                throw new Error('Unable to resolve repo root for worktree');
             }
-            const registryRecords = await this.agentStorage.list();
-            for (const record of registryRecords) {
-                if (this.isPathWithinRoot(targetPath, record.cwd)) {
-                    removedAgents.add(record.id);
-                    try {
-                        await this.agentStorage.remove(record.id);
-                    }
-                    catch {
-                        // ignore cleanup errors
-                    }
-                }
-            }
-            await deletePaseoWorktree({
-                cwd: repoRoot,
-                worktreePath: targetPath,
-                paseoHome: this.paseoHome,
+            const removedAgents = await this.archivePaseoWorktree({
+                targetPath,
+                repoRoot,
+                requestId,
             });
-            for (const agentId of removedAgents) {
-                this.emit({
-                    type: "agent_deleted",
-                    payload: {
-                        agentId,
-                        requestId,
-                    },
-                });
-            }
             this.emit({
-                type: "paseo_worktree_archive_response",
+                type: 'paseo_worktree_archive_response',
                 payload: {
                     success: true,
-                    removedAgents: Array.from(removedAgents),
+                    removedAgents,
                     error: null,
                     requestId,
                 },
@@ -3388,7 +3460,7 @@ export class Session {
         }
         catch (error) {
             this.emit({
-                type: "paseo_worktree_archive_response",
+                type: 'paseo_worktree_archive_response',
                 payload: {
                     success: false,
                     removedAgents: [],
@@ -3402,14 +3474,14 @@ export class Session {
      * Handle read-only file explorer requests scoped to an agent's cwd
      */
     async handleFileExplorerRequest(request) {
-        const { agentId, path: requestedPath = ".", mode, requestId } = request;
+        const { agentId, path: requestedPath = '.', mode, requestId } = request;
         this.sessionLogger.debug({ agentId, mode, path: requestedPath }, `Handling file explorer request for agent ${agentId} (${mode} ${requestedPath})`);
         try {
             const agents = this.agentManager.listAgents();
             const agent = agents.find((a) => a.id === agentId);
             if (!agent) {
                 this.emit({
-                    type: "file_explorer_response",
+                    type: 'file_explorer_response',
                     payload: {
                         agentId,
                         path: requestedPath,
@@ -3422,13 +3494,13 @@ export class Session {
                 });
                 return;
             }
-            if (mode === "list") {
+            if (mode === 'list') {
                 const directory = await listDirectoryEntries({
                     root: agent.cwd,
                     relativePath: requestedPath,
                 });
                 this.emit({
-                    type: "file_explorer_response",
+                    type: 'file_explorer_response',
                     payload: {
                         agentId,
                         path: directory.path,
@@ -3446,7 +3518,7 @@ export class Session {
                     relativePath: requestedPath,
                 });
                 this.emit({
-                    type: "file_explorer_response",
+                    type: 'file_explorer_response',
                     payload: {
                         agentId,
                         path: file.path,
@@ -3462,7 +3534,7 @@ export class Session {
         catch (error) {
             this.sessionLogger.error({ err: error, agentId, path: requestedPath }, `Failed to fulfill file explorer request for agent ${agentId}`);
             this.emit({
-                type: "file_explorer_response",
+                type: 'file_explorer_response',
                 payload: {
                     agentId,
                     path: requestedPath,
@@ -3483,7 +3555,7 @@ export class Session {
         try {
             const icon = await getProjectIcon(cwd);
             this.emit({
-                type: "project_icon_response",
+                type: 'project_icon_response',
                 payload: {
                     cwd,
                     icon,
@@ -3494,7 +3566,7 @@ export class Session {
         }
         catch (error) {
             this.emit({
-                type: "project_icon_response",
+                type: 'project_icon_response',
                 payload: {
                     cwd,
                     icon: null,
@@ -3515,7 +3587,7 @@ export class Session {
             const agent = agents.find((a) => a.id === agentId);
             if (!agent) {
                 this.emit({
-                    type: "file_download_token_response",
+                    type: 'file_download_token_response',
                     payload: {
                         agentId,
                         path: requestedPath,
@@ -3542,7 +3614,7 @@ export class Session {
                 size: info.size,
             });
             this.emit({
-                type: "file_download_token_response",
+                type: 'file_download_token_response',
                 payload: {
                     agentId,
                     path: info.path,
@@ -3558,7 +3630,7 @@ export class Session {
         catch (error) {
             this.sessionLogger.error({ err: error, agentId, path: requestedPath }, `Failed to issue download token for agent ${agentId}`);
             this.emit({
-                type: "file_download_token_response",
+                type: 'file_download_token_response',
                 payload: {
                     agentId,
                     path: requestedPath,
@@ -3597,7 +3669,7 @@ export class Session {
     async resolveAgentIdentifier(identifier) {
         const trimmed = identifier.trim();
         if (!trimmed) {
-            return { ok: false, error: "Agent identifier cannot be empty" };
+            return { ok: false, error: 'Agent identifier cannot be empty' };
         }
         const stored = await this.agentStorage.list();
         const storedRecords = stored.filter((record) => !record.internal);
@@ -3621,7 +3693,7 @@ export class Session {
                 error: `Agent identifier "${trimmed}" is ambiguous (${prefixMatches
                     .slice(0, 5)
                     .map((id) => id.slice(0, 8))
-                    .join(", ")}${prefixMatches.length > 5 ? ", …" : ""})`,
+                    .join(', ')}${prefixMatches.length > 5 ? ', …' : ''})`,
             };
         }
         const titleMatches = storedRecords.filter((record) => record.title === trimmed);
@@ -3634,7 +3706,7 @@ export class Session {
                 error: `Agent title "${trimmed}" is ambiguous (${titleMatches
                     .slice(0, 5)
                     .map((r) => r.id.slice(0, 8))
-                    .join(", ")}${titleMatches.length > 5 ? ", …" : ""})`,
+                    .join(', ')}${titleMatches.length > 5 ? ', …' : ''})`,
             };
         }
         return { ok: false, error: `Agent not found: ${trimmed}` };
@@ -3651,9 +3723,7 @@ export class Session {
         return this.buildStoredAgentPayload(record);
     }
     normalizeFetchAgentsSort(sort) {
-        const fallback = [
-            { key: "updated_at", direction: "desc" },
-        ];
+        const fallback = [{ key: 'updated_at', direction: 'desc' }];
         if (!sort || sort.length === 0) {
             return fallback;
         }
@@ -3671,30 +3741,30 @@ export class Session {
     getStatusPriority(agent) {
         const requiresAttention = agent.requiresAttention ?? false;
         const attentionReason = agent.attentionReason ?? null;
-        if (requiresAttention && attentionReason === "permission") {
+        if (requiresAttention && attentionReason === 'permission') {
             return 0;
         }
-        if (agent.status === "error" || attentionReason === "error") {
+        if (agent.status === 'error' || attentionReason === 'error') {
             return 1;
         }
-        if (agent.status === "running") {
+        if (agent.status === 'running') {
             return 2;
         }
-        if (agent.status === "initializing") {
+        if (agent.status === 'initializing') {
             return 3;
         }
         return 4;
     }
     getFetchAgentsSortValue(entry, key) {
         switch (key) {
-            case "status_priority":
+            case 'status_priority':
                 return this.getStatusPriority(entry.agent);
-            case "created_at":
+            case 'created_at':
                 return Date.parse(entry.agent.createdAt);
-            case "updated_at":
+            case 'updated_at':
                 return Date.parse(entry.agent.updatedAt);
-            case "title":
-                return entry.agent.title?.toLocaleLowerCase() ?? "";
+            case 'title':
+                return entry.agent.title?.toLocaleLowerCase() ?? '';
         }
     }
     compareSortValues(left, right) {
@@ -3707,7 +3777,7 @@ export class Session {
         if (right === null) {
             return 1;
         }
-        if (typeof left === "number" && typeof right === "number") {
+        if (typeof left === 'number' && typeof right === 'number') {
             return left < right ? -1 : 1;
         }
         return String(left).localeCompare(String(right));
@@ -3720,7 +3790,7 @@ export class Session {
             if (base === 0) {
                 continue;
             }
-            return spec.direction === "asc" ? base : -base;
+            return spec.direction === 'asc' ? base : -base;
         }
         return left.agent.id.localeCompare(right.agent.id);
     }
@@ -3733,49 +3803,48 @@ export class Session {
             sort,
             values,
             id: entry.agent.id,
-        }), "utf8").toString("base64url");
+        }), 'utf8').toString('base64url');
     }
     decodeFetchAgentsCursor(cursor, sort) {
         let parsed;
         try {
-            parsed = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
+            parsed = JSON.parse(Buffer.from(cursor, 'base64url').toString('utf8'));
         }
         catch {
-            throw new SessionRequestError("invalid_cursor", "Invalid fetch_agents cursor");
+            throw new SessionRequestError('invalid_cursor', 'Invalid fetch_agents cursor');
         }
-        if (!parsed || typeof parsed !== "object") {
-            throw new SessionRequestError("invalid_cursor", "Invalid fetch_agents cursor");
+        if (!parsed || typeof parsed !== 'object') {
+            throw new SessionRequestError('invalid_cursor', 'Invalid fetch_agents cursor');
         }
         const payload = parsed;
-        if (!Array.isArray(payload.sort) || typeof payload.id !== "string") {
-            throw new SessionRequestError("invalid_cursor", "Invalid fetch_agents cursor");
+        if (!Array.isArray(payload.sort) || typeof payload.id !== 'string') {
+            throw new SessionRequestError('invalid_cursor', 'Invalid fetch_agents cursor');
         }
-        if (!payload.values || typeof payload.values !== "object") {
-            throw new SessionRequestError("invalid_cursor", "Invalid fetch_agents cursor");
+        if (!payload.values || typeof payload.values !== 'object') {
+            throw new SessionRequestError('invalid_cursor', 'Invalid fetch_agents cursor');
         }
         const cursorSort = [];
         for (const item of payload.sort) {
             if (!item ||
-                typeof item !== "object" ||
-                typeof item.key !== "string" ||
-                typeof item.direction !== "string") {
-                throw new SessionRequestError("invalid_cursor", "Invalid fetch_agents cursor");
+                typeof item !== 'object' ||
+                typeof item.key !== 'string' ||
+                typeof item.direction !== 'string') {
+                throw new SessionRequestError('invalid_cursor', 'Invalid fetch_agents cursor');
             }
             const key = item.key;
             const direction = item.direction;
-            if ((key !== "status_priority" &&
-                key !== "created_at" &&
-                key !== "updated_at" &&
-                key !== "title") ||
-                (direction !== "asc" && direction !== "desc")) {
-                throw new SessionRequestError("invalid_cursor", "Invalid fetch_agents cursor");
+            if ((key !== 'status_priority' &&
+                key !== 'created_at' &&
+                key !== 'updated_at' &&
+                key !== 'title') ||
+                (direction !== 'asc' && direction !== 'desc')) {
+                throw new SessionRequestError('invalid_cursor', 'Invalid fetch_agents cursor');
             }
             cursorSort.push({ key, direction });
         }
         if (cursorSort.length !== sort.length ||
-            cursorSort.some((entry, index) => entry.key !== sort[index]?.key ||
-                entry.direction !== sort[index]?.direction)) {
-            throw new SessionRequestError("invalid_cursor", "fetch_agents cursor does not match current sort");
+            cursorSort.some((entry, index) => entry.key !== sort[index]?.key || entry.direction !== sort[index]?.direction)) {
+            throw new SessionRequestError('invalid_cursor', 'fetch_agents cursor does not match current sort');
         }
         return {
             sort: cursorSort,
@@ -3786,32 +3855,21 @@ export class Session {
     compareEntryWithCursor(entry, cursor, sort) {
         for (const spec of sort) {
             const leftValue = this.getFetchAgentsSortValue(entry, spec.key);
-            const rightValue = cursor.values[spec.key] !== undefined ? cursor.values[spec.key] ?? null : null;
+            const rightValue = cursor.values[spec.key] !== undefined ? (cursor.values[spec.key] ?? null) : null;
             const base = this.compareSortValues(leftValue, rightValue);
             if (base === 0) {
                 continue;
             }
-            return spec.direction === "asc" ? base : -base;
+            return spec.direction === 'asc' ? base : -base;
         }
         return entry.agent.id.localeCompare(cursor.id);
     }
     async listFetchAgentsEntries(request) {
         const filter = request.filter;
         const sort = this.normalizeFetchAgentsSort(request.sort);
-        const includeArchived = filter?.includeArchived ?? false;
-        let agents = await this.listAgentPayloads({
+        const agents = await this.listAgentPayloads({
             labels: filter?.labels,
         });
-        if (!includeArchived) {
-            agents = agents.filter((agent) => !agent.archivedAt);
-        }
-        if (filter?.statuses && filter.statuses.length > 0) {
-            const statuses = new Set(filter.statuses);
-            agents = agents.filter((agent) => statuses.has(agent.status));
-        }
-        if (typeof filter?.requiresAttention === "boolean") {
-            agents = agents.filter((agent) => (agent.requiresAttention ?? false) === filter.requiresAttention);
-        }
         const placementByCwd = new Map();
         const getPlacement = (cwd) => {
             const existing = placementByCwd.get(cwd);
@@ -3826,10 +3884,11 @@ export class Session {
             agent,
             project: await getPlacement(agent.cwd),
         })));
-        if (filter?.projectKeys && filter.projectKeys.length > 0) {
-            const projectKeys = new Set(filter.projectKeys.filter((item) => item.trim().length > 0));
-            entries = entries.filter((entry) => projectKeys.has(entry.project.projectKey));
-        }
+        entries = entries.filter((entry) => this.matchesAgentFilter({
+            agent: entry.agent,
+            project: entry.project,
+            filter,
+        }));
         entries.sort((left, right) => this.compareFetchAgentsEntries(left, right, sort));
         const cursorToken = request.page?.cursor;
         if (cursorToken) {
@@ -3852,22 +3911,50 @@ export class Session {
         };
     }
     async handleFetchAgents(request) {
+        const requestedSubscriptionId = request.subscribe?.subscriptionId?.trim();
+        const subscriptionId = request.subscribe
+            ? requestedSubscriptionId && requestedSubscriptionId.length > 0
+                ? requestedSubscriptionId
+                : uuidv4()
+            : null;
         try {
+            if (subscriptionId) {
+                this.agentUpdatesSubscription = {
+                    subscriptionId,
+                    filter: request.filter,
+                    isBootstrapping: true,
+                    pendingUpdatesByAgentId: new Map(),
+                };
+            }
             const payload = await this.listFetchAgentsEntries(request);
+            const snapshotUpdatedAtByAgentId = new Map();
+            for (const entry of payload.entries) {
+                const parsedUpdatedAt = Date.parse(entry.agent.updatedAt);
+                if (!Number.isNaN(parsedUpdatedAt)) {
+                    snapshotUpdatedAtByAgentId.set(entry.agent.id, parsedUpdatedAt);
+                }
+            }
             this.emit({
-                type: "fetch_agents_response",
+                type: 'fetch_agents_response',
                 payload: {
                     requestId: request.requestId,
+                    ...(subscriptionId ? { subscriptionId } : {}),
                     ...payload,
                 },
             });
+            if (subscriptionId && this.agentUpdatesSubscription?.subscriptionId === subscriptionId) {
+                this.flushBootstrappedAgentUpdates({ snapshotUpdatedAtByAgentId });
+            }
         }
         catch (error) {
-            const code = error instanceof SessionRequestError ? error.code : "fetch_agents_failed";
-            const message = error instanceof Error ? error.message : "Failed to fetch agents";
-            this.sessionLogger.error({ err: error }, "Failed to handle fetch_agents_request");
+            if (subscriptionId && this.agentUpdatesSubscription?.subscriptionId === subscriptionId) {
+                this.agentUpdatesSubscription = null;
+            }
+            const code = error instanceof SessionRequestError ? error.code : 'fetch_agents_failed';
+            const message = error instanceof Error ? error.message : 'Failed to fetch agents';
+            this.sessionLogger.error({ err: error }, 'Failed to handle fetch_agents_request');
             this.emit({
-                type: "rpc_error",
+                type: 'rpc_error',
                 payload: {
                     requestId: request.requestId,
                     requestType: request.type,
@@ -3881,7 +3968,7 @@ export class Session {
         const resolved = await this.resolveAgentIdentifier(agentIdOrIdentifier);
         if (!resolved.ok) {
             this.emit({
-                type: "fetch_agent_response",
+                type: 'fetch_agent_response',
                 payload: { requestId, agent: null, error: resolved.error },
             });
             return;
@@ -3889,20 +3976,20 @@ export class Session {
         const agent = await this.getAgentPayloadById(resolved.agentId);
         if (!agent) {
             this.emit({
-                type: "fetch_agent_response",
+                type: 'fetch_agent_response',
                 payload: { requestId, agent: null, error: `Agent not found: ${resolved.agentId}` },
             });
             return;
         }
         this.emit({
-            type: "fetch_agent_response",
+            type: 'fetch_agent_response',
             payload: { requestId, agent, error: null },
         });
     }
     async handleFetchAgentTimelineRequest(msg) {
-        const direction = msg.direction ?? (msg.cursor ? "after" : "tail");
-        const projection = msg.projection ?? "projected";
-        const limit = msg.limit ?? (direction === "after" ? 0 : undefined);
+        const direction = msg.direction ?? (msg.cursor ? 'after' : 'tail');
+        const projection = msg.projection ?? 'projected';
+        const limit = msg.limit ?? (direction === 'after' ? 0 : undefined);
         const cursor = msg.cursor
             ? {
                 epoch: msg.cursor.epoch,
@@ -3919,14 +4006,10 @@ export class Session {
             const projected = projectTimelineRows(timeline.rows, snapshot.provider, projection);
             const firstRow = timeline.rows[0];
             const lastRow = timeline.rows[timeline.rows.length - 1];
-            const startCursor = firstRow
-                ? { epoch: timeline.epoch, seq: firstRow.seq }
-                : null;
-            const endCursor = lastRow
-                ? { epoch: timeline.epoch, seq: lastRow.seq }
-                : null;
+            const startCursor = firstRow ? { epoch: timeline.epoch, seq: firstRow.seq } : null;
+            const endCursor = lastRow ? { epoch: timeline.epoch, seq: lastRow.seq } : null;
             this.emit({
-                type: "fetch_agent_timeline_response",
+                type: 'fetch_agent_timeline_response',
                 payload: {
                     requestId: msg.requestId,
                     agentId: msg.agentId,
@@ -3947,15 +4030,15 @@ export class Session {
             });
         }
         catch (error) {
-            this.sessionLogger.error({ err: error, agentId: msg.agentId }, "Failed to handle fetch_agent_timeline_request");
+            this.sessionLogger.error({ err: error, agentId: msg.agentId }, 'Failed to handle fetch_agent_timeline_request');
             this.emit({
-                type: "fetch_agent_timeline_response",
+                type: 'fetch_agent_timeline_response',
                 payload: {
                     requestId: msg.requestId,
                     agentId: msg.agentId,
                     direction,
                     projection,
-                    epoch: "",
+                    epoch: '',
                     reset: false,
                     staleCursor: false,
                     gap: false,
@@ -3974,7 +4057,7 @@ export class Session {
         const resolved = await this.resolveAgentIdentifier(msg.agentId);
         if (!resolved.ok) {
             this.emit({
-                type: "send_agent_message_response",
+                type: 'send_agent_message_response',
                 payload: {
                     requestId: msg.requestId,
                     agentId: msg.agentId,
@@ -3995,13 +4078,13 @@ export class Session {
                 });
             }
             catch (error) {
-                this.sessionLogger.error({ err: error, agentId }, "Failed to record user message for send_agent_message_request");
+                this.sessionLogger.error({ err: error, agentId }, 'Failed to record user message for send_agent_message_request');
             }
             const prompt = this.buildAgentPrompt(msg.text, msg.images);
             const started = this.startAgentStream(agentId, prompt);
             if (!started.ok) {
                 this.emit({
-                    type: "send_agent_message_response",
+                    type: 'send_agent_message_response',
                     payload: {
                         requestId: msg.requestId,
                         agentId,
@@ -4013,14 +4096,18 @@ export class Session {
             }
             const startAbort = new AbortController();
             const startTimeoutMs = 15000;
-            const startTimeout = setTimeout(() => startAbort.abort("timeout"), startTimeoutMs);
+            const startTimeout = setTimeout(() => startAbort.abort('timeout'), startTimeoutMs);
             try {
                 await this.agentManager.waitForAgentRunStart(agentId, { signal: startAbort.signal });
             }
             catch (error) {
-                const message = error instanceof Error ? error.message : typeof error === "string" ? error : "Unknown error";
+                const message = error instanceof Error
+                    ? error.message
+                    : typeof error === 'string'
+                        ? error
+                        : 'Unknown error';
                 this.emit({
-                    type: "send_agent_message_response",
+                    type: 'send_agent_message_response',
                     payload: {
                         requestId: msg.requestId,
                         agentId,
@@ -4034,7 +4121,7 @@ export class Session {
                 clearTimeout(startTimeout);
             }
             this.emit({
-                type: "send_agent_message_response",
+                type: 'send_agent_message_response',
                 payload: {
                     requestId: msg.requestId,
                     agentId,
@@ -4044,9 +4131,9 @@ export class Session {
             });
         }
         catch (error) {
-            const message = error instanceof Error ? error.message : typeof error === "string" ? error : "Unknown error";
+            const message = error instanceof Error ? error.message : typeof error === 'string' ? error : 'Unknown error';
             this.emit({
-                type: "send_agent_message_response",
+                type: 'send_agent_message_response',
                 payload: {
                     requestId: msg.requestId,
                     agentId: resolved.agentId,
@@ -4060,8 +4147,14 @@ export class Session {
         const resolved = await this.resolveAgentIdentifier(agentIdOrIdentifier);
         if (!resolved.ok) {
             this.emit({
-                type: "wait_for_finish_response",
-                payload: { requestId, status: "error", final: null, error: resolved.error, lastMessage: null },
+                type: 'wait_for_finish_response',
+                payload: {
+                    requestId,
+                    status: 'error',
+                    final: null,
+                    error: resolved.error,
+                    lastMessage: null,
+                },
             });
             return;
         }
@@ -4071,10 +4164,10 @@ export class Session {
             const record = await this.agentStorage.get(agentId);
             if (!record || record.internal) {
                 this.emit({
-                    type: "wait_for_finish_response",
+                    type: 'wait_for_finish_response',
                     payload: {
                         requestId,
-                        status: "error",
+                        status: 'error',
                         final: null,
                         error: `Agent not found: ${agentId}`,
                         lastMessage: null,
@@ -4083,13 +4176,13 @@ export class Session {
                 return;
             }
             const final = this.buildStoredAgentPayload(record);
-            const status = record.attentionReason === "permission"
-                ? "permission"
-                : record.lastStatus === "error"
-                    ? "error"
-                    : "idle";
+            const status = record.attentionReason === 'permission'
+                ? 'permission'
+                : record.lastStatus === 'error'
+                    ? 'error'
+                    : 'idle';
             this.emit({
-                type: "wait_for_finish_response",
+                type: 'wait_for_finish_response',
                 payload: { requestId, status, final, error: null, lastMessage: null },
             });
             return;
@@ -4097,7 +4190,7 @@ export class Session {
         const abortController = new AbortController();
         const effectiveTimeoutMs = timeoutMs ?? 600000; // 10 minutes default
         const timeoutHandle = setTimeout(() => {
-            abortController.abort("timeout");
+            abortController.abort('timeout');
         }, effectiveTimeoutMs);
         try {
             const result = await this.agentManager.waitForAgentEvent(agentId, {
@@ -4107,28 +4200,28 @@ export class Session {
             if (!final) {
                 throw new Error(`Agent ${agentId} disappeared while waiting`);
             }
-            const status = result.permission
-                ? "permission"
-                : result.status === "error"
-                    ? "error"
-                    : "idle";
+            const status = result.permission ? 'permission' : result.status === 'error' ? 'error' : 'idle';
             this.emit({
-                type: "wait_for_finish_response",
+                type: 'wait_for_finish_response',
                 payload: { requestId, status, final, error: null, lastMessage: result.lastMessage },
             });
         }
         catch (error) {
             const isAbort = error instanceof Error &&
-                (error.name === "AbortError" || error.message.toLowerCase().includes("aborted"));
+                (error.name === 'AbortError' || error.message.toLowerCase().includes('aborted'));
             if (!isAbort) {
-                const message = error instanceof Error ? error.message : typeof error === "string" ? error : "Unknown error";
-                this.sessionLogger.error({ err: error, agentId }, "wait_for_finish_request failed");
+                const message = error instanceof Error
+                    ? error.message
+                    : typeof error === 'string'
+                        ? error
+                        : 'Unknown error';
+                this.sessionLogger.error({ err: error, agentId }, 'wait_for_finish_request failed');
                 const final = await this.getAgentPayloadById(agentId);
                 this.emit({
-                    type: "wait_for_finish_response",
+                    type: 'wait_for_finish_response',
                     payload: {
                         requestId,
-                        status: "error",
+                        status: 'error',
                         final,
                         error: message,
                         lastMessage: null,
@@ -4141,8 +4234,8 @@ export class Session {
                 throw new Error(`Agent ${agentId} disappeared while waiting`);
             }
             this.emit({
-                type: "wait_for_finish_response",
-                payload: { requestId, status: "timeout", final, error: null, lastMessage: null },
+                type: 'wait_for_finish_response',
+                payload: { requestId, status: 'timeout', final, error: null, lastMessage: null },
             });
         }
         finally {
@@ -4154,24 +4247,24 @@ export class Session {
      */
     async handleAudioChunk(msg) {
         if (!this.isVoiceMode) {
-            this.sessionLogger.warn("Received voice_audio_chunk while voice mode is disabled; transcript will be emitted but voice assistant turn is skipped");
+            this.sessionLogger.warn('Received voice_audio_chunk while voice mode is disabled; transcript will be emitted but voice assistant turn is skipped');
         }
         await this.handleVoiceSpeechStart();
-        const chunkFormat = msg.format || "audio/wav";
+        const chunkFormat = msg.format || 'audio/wav';
         if (this.isVoiceMode) {
             await this.appendToActiveVoiceDictationStream(msg.audio, chunkFormat);
             if (!msg.isLast) {
                 this.setVoiceModeInactivityTimeout();
-                this.sessionLogger.debug("Voice mode: streaming chunk, waiting for speech end");
+                this.sessionLogger.debug('Voice mode: streaming chunk, waiting for speech end');
                 return;
             }
             this.clearVoiceModeInactivityTimeout();
-            this.sessionLogger.debug("Voice mode: speech ended, finalizing streaming transcription");
-            await this.finalizeActiveVoiceDictationStream("speech ended");
+            this.sessionLogger.debug('Voice mode: speech ended, finalizing streaming transcription');
+            await this.finalizeActiveVoiceDictationStream('speech ended');
             return;
         }
-        const chunkBuffer = Buffer.from(msg.audio, "base64");
-        const isPCMChunk = chunkFormat.toLowerCase().includes("pcm");
+        const chunkBuffer = Buffer.from(msg.audio, 'base64');
+        const isPCMChunk = chunkFormat.toLowerCase().includes('pcm');
         if (!this.audioBuffer) {
             this.audioBuffer = {
                 chunks: [],
@@ -4182,7 +4275,10 @@ export class Session {
         }
         // If the format changes mid-stream, flush what we have first
         if (this.audioBuffer.isPCM !== isPCMChunk) {
-            this.sessionLogger.debug({ oldFormat: this.audioBuffer.isPCM ? "pcm" : this.audioBuffer.format, newFormat: chunkFormat }, `Audio format changed mid-stream, flushing current buffer`);
+            this.sessionLogger.debug({
+                oldFormat: this.audioBuffer.isPCM ? 'pcm' : this.audioBuffer.format,
+                newFormat: chunkFormat,
+            }, `Audio format changed mid-stream, flushing current buffer`);
             const finalized = this.finalizeBufferedAudio();
             if (finalized) {
                 await this.processCompletedAudio(finalized.audio, finalized.format);
@@ -4215,7 +4311,10 @@ export class Session {
             return;
         }
         if (!msg.isLast && reachedStreamingThreshold) {
-            this.sessionLogger.debug({ minDuration: MIN_STREAMING_SEGMENT_DURATION_MS, pcmBytes: bufferedState?.totalPCMBytes ?? 0 }, `Minimum chunk duration reached (~${MIN_STREAMING_SEGMENT_DURATION_MS}ms, ${bufferedState?.totalPCMBytes ?? 0} PCM bytes) – triggering STT`);
+            this.sessionLogger.debug({
+                minDuration: MIN_STREAMING_SEGMENT_DURATION_MS,
+                pcmBytes: bufferedState?.totalPCMBytes ?? 0,
+            }, `Minimum chunk duration reached (~${MIN_STREAMING_SEGMENT_DURATION_MS}ms, ${bufferedState?.totalPCMBytes ?? 0} PCM bytes) – triggering STT`);
         }
         else {
             this.sessionLogger.debug({ audioBytes: finalized.audio.length, chunks: bufferedState?.chunks.length ?? 0 }, `Complete audio segment (${finalized.audio.length} bytes, ${bufferedState?.chunks.length ?? 0} chunk(s))`);
@@ -4233,7 +4332,7 @@ export class Session {
             const wavBuffer = convertPCMToWavBuffer(pcmBuffer, PCM_SAMPLE_RATE, PCM_CHANNELS, PCM_BITS_PER_SAMPLE);
             return {
                 audio: wavBuffer,
-                format: "audio/wav",
+                format: 'audio/wav',
             };
         }
         return {
@@ -4242,8 +4341,7 @@ export class Session {
         };
     }
     async processCompletedAudio(audio, format) {
-        const shouldBuffer = this.processingPhase === "transcribing" &&
-            this.pendingAudioSegments.length === 0;
+        const shouldBuffer = this.processingPhase === 'transcribing' && this.pendingAudioSegments.length === 0;
         if (shouldBuffer) {
             this.sessionLogger.debug({ phase: this.processingPhase }, `Buffering audio segment (phase: ${this.processingPhase})`);
             this.pendingAudioSegments.push({
@@ -4273,21 +4371,21 @@ export class Session {
      * Process audio through STT and then LLM
      */
     async processAudio(audio, format) {
-        this.setPhase("transcribing");
+        this.setPhase('transcribing');
         this.emit({
-            type: "activity_log",
+            type: 'activity_log',
             payload: {
                 id: uuidv4(),
                 timestamp: new Date(),
-                type: "system",
-                content: "Transcribing audio...",
+                type: 'system',
+                content: 'Transcribing audio...',
             },
         });
         try {
             const requestId = uuidv4();
             const result = await this.sttManager.transcribe(audio, format, {
                 requestId,
-                label: this.isVoiceMode ? "voice" : "buffered",
+                label: this.isVoiceMode ? 'voice' : 'buffered',
             });
             const transcriptText = result.text.trim();
             this.sessionLogger.info({
@@ -4295,7 +4393,7 @@ export class Session {
                 isVoiceMode: this.isVoiceMode,
                 transcriptLength: transcriptText.length,
                 transcript: transcriptText,
-            }, "Transcription result");
+            }, 'Transcription result');
             await this.handleTranscriptionResultPayload({
                 text: result.text,
                 language: result.language,
@@ -4309,14 +4407,14 @@ export class Session {
             });
         }
         catch (error) {
-            this.setPhase("idle");
-            this.clearSpeechInProgress("transcription error");
+            this.setPhase('idle');
+            this.clearSpeechInProgress('transcription error');
             this.emit({
-                type: "activity_log",
+                type: 'activity_log',
                 payload: {
                     id: uuidv4(),
                     timestamp: new Date(),
-                    type: "error",
+                    type: 'error',
                     content: `Transcription error: ${error.message}`,
                 },
             });
@@ -4326,34 +4424,36 @@ export class Session {
     async handleTranscriptionResultPayload(result) {
         const transcriptText = result.text.trim();
         this.emit({
-            type: "transcription_result",
+            type: 'transcription_result',
             payload: {
                 text: result.text,
                 ...(result.language ? { language: result.language } : {}),
                 ...(result.duration !== undefined ? { duration: result.duration } : {}),
                 requestId: result.requestId,
                 ...(result.avgLogprob !== undefined ? { avgLogprob: result.avgLogprob } : {}),
-                ...(result.isLowConfidence !== undefined ? { isLowConfidence: result.isLowConfidence } : {}),
+                ...(result.isLowConfidence !== undefined
+                    ? { isLowConfidence: result.isLowConfidence }
+                    : {}),
                 ...(result.byteLength !== undefined ? { byteLength: result.byteLength } : {}),
                 ...(result.format ? { format: result.format } : {}),
                 ...(result.debugRecordingPath ? { debugRecordingPath: result.debugRecordingPath } : {}),
             },
         });
         if (!transcriptText) {
-            this.sessionLogger.debug("Empty transcription (false positive), not aborting");
-            this.setPhase("idle");
-            this.clearSpeechInProgress("empty transcription");
+            this.sessionLogger.debug('Empty transcription (false positive), not aborting');
+            this.setPhase('idle');
+            this.clearSpeechInProgress('empty transcription');
             return;
         }
         // Has content - abort any in-progress stream now
         this.createAbortController();
         if (result.debugRecordingPath) {
             this.emit({
-                type: "activity_log",
+                type: 'activity_log',
                 payload: {
                     id: uuidv4(),
                     timestamp: new Date(),
-                    type: "system",
+                    type: 'system',
                     content: `Saved input audio: ${result.debugRecordingPath}`,
                     metadata: {
                         recordingPath: result.debugRecordingPath,
@@ -4364,11 +4464,11 @@ export class Session {
             });
         }
         this.emit({
-            type: "activity_log",
+            type: 'activity_log',
             payload: {
                 id: uuidv4(),
                 timestamp: new Date(),
-                type: "transcript",
+                type: 'transcript',
                 content: result.text,
                 metadata: {
                     ...(result.language ? { language: result.language } : {}),
@@ -4376,15 +4476,15 @@ export class Session {
                 },
             },
         });
-        this.clearSpeechInProgress("transcription complete");
-        this.setPhase("idle");
+        this.clearSpeechInProgress('transcription complete');
+        this.setPhase('idle');
         if (!this.isVoiceMode) {
-            this.sessionLogger.debug({ requestId: result.requestId }, "Skipping voice agent processing because voice mode is disabled");
+            this.sessionLogger.debug({ requestId: result.requestId }, 'Skipping voice agent processing because voice mode is disabled');
             return;
         }
         const agentId = this.voiceModeAgentId;
         if (!agentId) {
-            this.sessionLogger.warn({ requestId: result.requestId }, "Skipping voice agent processing because no agent is currently voice-enabled");
+            this.sessionLogger.warn({ requestId: result.requestId }, 'Skipping voice agent processing because no agent is currently voice-enabled');
             return;
         }
         // Route voice utterances through the same send path as regular text input:
@@ -4397,22 +4497,22 @@ export class Session {
                 agentId,
                 textLength: text.length,
                 preview: text.slice(0, 160),
-            }, "Voice speak tool call received by session handler");
+            }, 'Voice speak tool call received by session handler');
             const abortSignal = signal ?? this.abortController.signal;
             await this.ttsManager.generateAndWaitForPlayback(text, (msg) => this.emit(msg), abortSignal, true);
-            this.sessionLogger.info({ agentId, textLength: text.length }, "Voice speak tool call finished playback");
+            this.sessionLogger.info({ agentId, textLength: text.length }, 'Voice speak tool call finished playback');
             this.emit({
-                type: "activity_log",
+                type: 'activity_log',
                 payload: {
                     id: uuidv4(),
                     timestamp: new Date(),
-                    type: "assistant",
+                    type: 'assistant',
                     content: text,
                 },
             });
         });
         this.registerVoiceCallerContext?.(agentId, {
-            childAgentDefaultLabels: { ui: "true" },
+            childAgentDefaultLabels: { ui: 'true' },
             allowCustomCwd: false,
             enableVoiceTools: true,
         });
@@ -4423,24 +4523,24 @@ export class Session {
     async handleAbort() {
         this.sessionLogger.info({ phase: this.processingPhase }, `Abort request, phase: ${this.processingPhase}`);
         this.abortController.abort();
-        this.ttsManager.cancelPendingPlaybacks("abort request");
+        this.ttsManager.cancelPendingPlaybacks('abort request');
         // Voice abort should always interrupt active agent output immediately.
         if (this.isVoiceMode && this.voiceModeAgentId) {
             try {
                 await this.interruptAgentIfRunning(this.voiceModeAgentId);
             }
             catch (error) {
-                this.sessionLogger.warn({ err: error, agentId: this.voiceModeAgentId }, "Failed to interrupt active voice-mode agent on abort");
+                this.sessionLogger.warn({ err: error, agentId: this.voiceModeAgentId }, 'Failed to interrupt active voice-mode agent on abort');
             }
         }
-        if (this.processingPhase === "transcribing") {
+        if (this.processingPhase === 'transcribing') {
             // Still in STT phase - we'll buffer the next audio
-            this.sessionLogger.debug("Will buffer next audio (currently transcribing)");
+            this.sessionLogger.debug('Will buffer next audio (currently transcribing)');
             // Phase stays as 'transcribing', handleAudioChunk will handle buffering
             return;
         }
         // Reset phase to idle and clear pending non-voice buffers.
-        this.setPhase("idle");
+        this.setPhase('idle');
         this.pendingAudioSegments = [];
         this.clearBufferTimeout();
     }
@@ -4461,24 +4561,22 @@ export class Session {
         const phaseBeforeAbort = this.processingPhase;
         const hadActiveStream = this.hasActiveAgentRun(this.voiceModeAgentId);
         this.speechInProgress = true;
-        this.sessionLogger.debug("Voice speech detected – aborting playback and active agent run");
+        this.sessionLogger.debug('Voice speech detected – aborting playback and active agent run');
         if (this.pendingAudioSegments.length > 0) {
             this.sessionLogger.debug({ segmentCount: this.pendingAudioSegments.length }, `Dropping ${this.pendingAudioSegments.length} buffered audio segment(s) due to voice speech`);
             this.pendingAudioSegments = [];
         }
         if (this.audioBuffer) {
-            this.sessionLogger.debug({ chunks: this.audioBuffer.chunks.length, pcmBytes: this.audioBuffer.totalPCMBytes }, `Clearing partial audio buffer (${this.audioBuffer.chunks.length} chunk(s)${this.audioBuffer.isPCM
-                ? `, ${this.audioBuffer.totalPCMBytes} PCM bytes`
-                : ""})`);
+            this.sessionLogger.debug({ chunks: this.audioBuffer.chunks.length, pcmBytes: this.audioBuffer.totalPCMBytes }, `Clearing partial audio buffer (${this.audioBuffer.chunks.length} chunk(s)${this.audioBuffer.isPCM ? `, ${this.audioBuffer.totalPCMBytes} PCM bytes` : ''})`);
             this.audioBuffer = null;
         }
-        this.cancelActiveVoiceDictationStream("new speech turn started");
+        this.cancelActiveVoiceDictationStream('new speech turn started');
         this.clearVoiceModeInactivityTimeout();
         this.clearBufferTimeout();
         this.abortController.abort();
         await this.handleAbort();
         const latencyMs = Date.now() - chunkReceivedAt;
-        this.sessionLogger.debug({ latencyMs, phaseBeforeAbort, hadActiveStream }, "[Telemetry] barge_in.llm_abort_latency");
+        this.sessionLogger.debug({ latencyMs, phaseBeforeAbort, hadActiveStream }, '[Telemetry] barge_in.llm_abort_latency');
     }
     /**
      * Clear speech-in-progress flag once the user turn has completed
@@ -4512,7 +4610,7 @@ export class Session {
     setBufferTimeout() {
         this.clearBufferTimeout();
         this.bufferTimeout = setTimeout(async () => {
-            this.sessionLogger.debug("Buffer timeout reached, processing pending segments");
+            this.sessionLogger.debug('Buffer timeout reached, processing pending segments');
             if (this.pendingAudioSegments.length > 0) {
                 const segments = [...this.pendingAudioSegments];
                 this.pendingAudioSegments = [];
@@ -4536,9 +4634,9 @@ export class Session {
                 timeoutMs: VOICE_MODE_INACTIVITY_FLUSH_MS,
                 dictationId: this.activeVoiceDictationId,
                 nextSeq: this.activeVoiceDictationNextSeq,
-            }, "Voice mode inactivity timeout reached without isLast; finalizing active voice dictation stream");
-            void this.finalizeActiveVoiceDictationStream("inactivity timeout").catch((error) => {
-                this.sessionLogger.error({ err: error }, "Failed to finalize voice dictation stream after inactivity timeout");
+            }, 'Voice mode inactivity timeout reached without isLast; finalizing active voice dictation stream');
+            void this.finalizeActiveVoiceDictationStream('inactivity timeout').catch((error) => {
+                this.sessionLogger.error({ err: error }, 'Failed to finalize voice dictation stream after inactivity timeout');
             });
         }, VOICE_MODE_INACTIVITY_FLUSH_MS);
     }
@@ -4561,15 +4659,15 @@ export class Session {
      * Emit a message to the client
      */
     emit(msg) {
-        if (msg.type === "audio_output" &&
+        if (msg.type === 'audio_output' &&
             (process.env.TTS_DEBUG_AUDIO_DIR || isPaseoDictationDebugEnabled()) &&
             msg.payload.groupId &&
-            typeof msg.payload.audio === "string") {
+            typeof msg.payload.audio === 'string') {
             const groupId = msg.payload.groupId;
             const existing = this.ttsDebugStreams.get(groupId) ??
                 { format: msg.payload.format, chunks: [] };
             try {
-                existing.chunks.push(Buffer.from(msg.payload.audio, "base64"));
+                existing.chunks.push(Buffer.from(msg.payload.audio, 'base64'));
                 existing.format = msg.payload.format;
                 this.ttsDebugStreams.set(groupId, existing);
             }
@@ -4584,11 +4682,11 @@ export class Session {
                         const recordingPath = await maybePersistTtsDebugAudio(Buffer.concat(final.chunks), { sessionId: this.sessionId, groupId, format: final.format }, this.sessionLogger);
                         if (recordingPath) {
                             this.onMessage({
-                                type: "activity_log",
+                                type: 'activity_log',
                                 payload: {
                                     id: uuidv4(),
                                     timestamp: new Date(),
-                                    type: "system",
+                                    type: 'system',
                                     content: `Saved TTS audio: ${recordingPath}`,
                                     metadata: { recordingPath, format: final.format, groupId },
                                 },
@@ -4608,14 +4706,14 @@ export class Session {
             this.onBinaryMessage(frame);
         }
         catch (error) {
-            this.sessionLogger.error({ err: error }, "Failed to emit binary frame");
+            this.sessionLogger.error({ err: error }, 'Failed to emit binary frame');
         }
     }
     /**
      * Clean up session resources
      */
     async cleanup() {
-        this.sessionLogger.trace("Cleaning up");
+        this.sessionLogger.trace('Cleaning up');
         if (this.unsubscribeAgentEvents) {
             this.unsubscribeAgentEvents();
             this.unsubscribeAgentEvents = null;
@@ -4626,7 +4724,7 @@ export class Session {
         this.clearVoiceModeInactivityTimeout();
         this.clearBufferTimeout();
         // Clear buffers
-        this.cancelActiveVoiceDictationStream("session cleanup");
+        this.cancelActiveVoiceDictationStream('session cleanup');
         this.pendingAudioSegments = [];
         this.audioBuffer = null;
         // Cleanup managers
@@ -4638,10 +4736,10 @@ export class Session {
         if (this.agentMcpClient) {
             try {
                 await this.agentMcpClient.close();
-                this.sessionLogger.debug("Agent MCP client closed");
+                this.sessionLogger.debug('Agent MCP client closed');
             }
             catch (error) {
-                this.sessionLogger.error({ err: error }, "Failed to close Agent MCP client");
+                this.sessionLogger.error({ err: error }, 'Failed to close Agent MCP client');
             }
             this.agentMcpClient = null;
             this.agentTools = null;
@@ -4693,18 +4791,18 @@ export class Session {
                 unsubscribe();
             }
             catch (error) {
-                this.sessionLogger.warn({ err: error, terminalId }, "Failed to unsubscribe terminal after process exit");
+                this.sessionLogger.warn({ err: error, terminalId }, 'Failed to unsubscribe terminal after process exit');
             }
             this.terminalSubscriptions.delete(terminalId);
         }
         const streamId = this.terminalStreamByTerminalId.get(terminalId);
-        if (typeof streamId === "number") {
+        if (typeof streamId === 'number') {
             this.detachTerminalStream(streamId, { emitExit: true });
         }
     }
     emitTerminalsChangedSnapshot(input) {
         this.emit({
-            type: "terminals_changed",
+            type: 'terminals_changed',
             payload: {
                 cwd: input.cwd,
                 terminals: input.terminals,
@@ -4734,9 +4832,7 @@ export class Session {
         if (!this.terminalManager || !this.subscribedTerminalDirectories.has(cwd)) {
             return;
         }
-        const hadDirectoryBeforeSubscribe = this.terminalManager
-            .listDirectories()
-            .includes(cwd);
+        const hadDirectoryBeforeSubscribe = this.terminalManager.listDirectories().includes(cwd);
         try {
             const terminals = await this.terminalManager.getTerminals(cwd);
             for (const terminal of terminals) {
@@ -4759,13 +4855,13 @@ export class Session {
             });
         }
         catch (error) {
-            this.sessionLogger.warn({ err: error, cwd }, "Failed to emit initial terminal snapshot");
+            this.sessionLogger.warn({ err: error, cwd }, 'Failed to emit initial terminal snapshot');
         }
     }
     async handleListTerminalsRequest(msg) {
         if (!this.terminalManager) {
             this.emit({
-                type: "list_terminals_response",
+                type: 'list_terminals_response',
                 payload: {
                     cwd: msg.cwd,
                     terminals: [],
@@ -4780,7 +4876,7 @@ export class Session {
                 this.ensureTerminalExitSubscription(terminal);
             }
             this.emit({
-                type: "list_terminals_response",
+                type: 'list_terminals_response',
                 payload: {
                     cwd: msg.cwd,
                     terminals: terminals.map((t) => ({ id: t.id, name: t.name })),
@@ -4789,9 +4885,9 @@ export class Session {
             });
         }
         catch (error) {
-            this.sessionLogger.error({ err: error, cwd: msg.cwd }, "Failed to list terminals");
+            this.sessionLogger.error({ err: error, cwd: msg.cwd }, 'Failed to list terminals');
             this.emit({
-                type: "list_terminals_response",
+                type: 'list_terminals_response',
                 payload: {
                     cwd: msg.cwd,
                     terminals: [],
@@ -4803,10 +4899,10 @@ export class Session {
     async handleCreateTerminalRequest(msg) {
         if (!this.terminalManager) {
             this.emit({
-                type: "create_terminal_response",
+                type: 'create_terminal_response',
                 payload: {
                     terminal: null,
-                    error: "Terminal manager not available",
+                    error: 'Terminal manager not available',
                     requestId: msg.requestId,
                 },
             });
@@ -4819,7 +4915,7 @@ export class Session {
             });
             this.ensureTerminalExitSubscription(session);
             this.emit({
-                type: "create_terminal_response",
+                type: 'create_terminal_response',
                 payload: {
                     terminal: { id: session.id, name: session.name, cwd: session.cwd },
                     error: null,
@@ -4828,9 +4924,9 @@ export class Session {
             });
         }
         catch (error) {
-            this.sessionLogger.error({ err: error, cwd: msg.cwd }, "Failed to create terminal");
+            this.sessionLogger.error({ err: error, cwd: msg.cwd }, 'Failed to create terminal');
             this.emit({
-                type: "create_terminal_response",
+                type: 'create_terminal_response',
                 payload: {
                     terminal: null,
                     error: error.message,
@@ -4842,11 +4938,11 @@ export class Session {
     async handleSubscribeTerminalRequest(msg) {
         if (!this.terminalManager) {
             this.emit({
-                type: "subscribe_terminal_response",
+                type: 'subscribe_terminal_response',
                 payload: {
                     terminalId: msg.terminalId,
                     state: null,
-                    error: "Terminal manager not available",
+                    error: 'Terminal manager not available',
                     requestId: msg.requestId,
                 },
             });
@@ -4855,11 +4951,11 @@ export class Session {
         const session = this.terminalManager.getTerminal(msg.terminalId);
         if (!session) {
             this.emit({
-                type: "subscribe_terminal_response",
+                type: 'subscribe_terminal_response',
                 payload: {
                     terminalId: msg.terminalId,
                     state: null,
-                    error: "Terminal not found",
+                    error: 'Terminal not found',
                     requestId: msg.requestId,
                 },
             });
@@ -4873,9 +4969,9 @@ export class Session {
         }
         // Subscribe to terminal updates
         const unsubscribe = session.subscribe((serverMsg) => {
-            if (serverMsg.type === "full") {
+            if (serverMsg.type === 'full') {
                 this.emit({
-                    type: "terminal_output",
+                    type: 'terminal_output',
                     payload: {
                         terminalId: msg.terminalId,
                         state: serverMsg.state,
@@ -4886,7 +4982,7 @@ export class Session {
         this.terminalSubscriptions.set(msg.terminalId, unsubscribe);
         // Send initial state
         this.emit({
-            type: "subscribe_terminal_response",
+            type: 'subscribe_terminal_response',
             payload: {
                 terminalId: msg.terminalId,
                 state: session.getState(),
@@ -4908,16 +5004,55 @@ export class Session {
         }
         const session = this.terminalManager.getTerminal(msg.terminalId);
         if (!session) {
-            this.sessionLogger.warn({ terminalId: msg.terminalId }, "Terminal not found for input");
+            this.sessionLogger.warn({ terminalId: msg.terminalId }, 'Terminal not found for input');
             return;
         }
         this.ensureTerminalExitSubscription(session);
         session.send(msg.message);
     }
+    killTrackedTerminal(terminalId, options) {
+        const unsubscribe = this.terminalSubscriptions.get(terminalId);
+        if (unsubscribe) {
+            unsubscribe();
+            this.terminalSubscriptions.delete(terminalId);
+        }
+        const streamId = this.terminalStreamByTerminalId.get(terminalId);
+        if (typeof streamId === 'number') {
+            this.detachTerminalStream(streamId, { emitExit: options?.emitExit ?? true });
+        }
+        this.terminalManager?.killTerminal(terminalId);
+    }
+    async killTerminalsUnderPath(rootPath) {
+        if (!this.terminalManager) {
+            return;
+        }
+        const cleanupErrors = [];
+        const terminalDirectories = [...this.terminalManager.listDirectories()];
+        for (const terminalCwd of terminalDirectories) {
+            if (!this.isPathWithinRoot(rootPath, terminalCwd)) {
+                continue;
+            }
+            try {
+                const terminals = await this.terminalManager.getTerminals(terminalCwd);
+                for (const terminal of [...terminals]) {
+                    this.killTrackedTerminal(terminal.id, { emitExit: true });
+                }
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                cleanupErrors.push({ cwd: terminalCwd, message });
+                this.sessionLogger.warn({ err: error, cwd: terminalCwd }, 'Failed to clean up worktree terminals during archive');
+            }
+        }
+        if (cleanupErrors.length > 0) {
+            const details = cleanupErrors.map((entry) => `${entry.cwd}: ${entry.message}`).join('; ');
+            throw new Error(`Failed to clean up worktree terminals during archive (${details})`);
+        }
+    }
     async handleKillTerminalRequest(msg) {
         if (!this.terminalManager) {
             this.emit({
-                type: "kill_terminal_response",
+                type: 'kill_terminal_response',
                 payload: {
                     terminalId: msg.terminalId,
                     success: false,
@@ -4926,19 +5061,9 @@ export class Session {
             });
             return;
         }
-        // Unsubscribe first
-        const unsubscribe = this.terminalSubscriptions.get(msg.terminalId);
-        if (unsubscribe) {
-            unsubscribe();
-            this.terminalSubscriptions.delete(msg.terminalId);
-        }
-        const streamId = this.terminalStreamByTerminalId.get(msg.terminalId);
-        if (typeof streamId === "number") {
-            this.detachTerminalStream(streamId, { emitExit: true });
-        }
-        this.terminalManager.killTerminal(msg.terminalId);
+        this.killTrackedTerminal(msg.terminalId, { emitExit: true });
         this.emit({
-            type: "kill_terminal_response",
+            type: 'kill_terminal_response',
             payload: {
                 terminalId: msg.terminalId,
                 success: true,
@@ -4949,7 +5074,7 @@ export class Session {
     async handleAttachTerminalStreamRequest(msg) {
         if (!this.terminalManager || !this.onBinaryMessage) {
             this.emit({
-                type: "attach_terminal_stream_response",
+                type: 'attach_terminal_stream_response',
                 payload: {
                     terminalId: msg.terminalId,
                     streamId: null,
@@ -4957,7 +5082,7 @@ export class Session {
                     currentOffset: 0,
                     earliestAvailableOffset: 0,
                     reset: true,
-                    error: "Terminal streaming not available",
+                    error: 'Terminal streaming not available',
                     requestId: msg.requestId,
                 },
             });
@@ -4966,7 +5091,7 @@ export class Session {
         const session = this.terminalManager.getTerminal(msg.terminalId);
         if (!session) {
             this.emit({
-                type: "attach_terminal_stream_response",
+                type: 'attach_terminal_stream_response',
                 payload: {
                     terminalId: msg.terminalId,
                     streamId: null,
@@ -4974,7 +5099,7 @@ export class Session {
                     currentOffset: 0,
                     earliestAvailableOffset: 0,
                     reset: true,
-                    error: "Terminal not found",
+                    error: 'Terminal not found',
                     requestId: msg.requestId,
                 },
             });
@@ -4983,13 +5108,13 @@ export class Session {
         if (msg.rows || msg.cols) {
             const state = session.getState();
             session.send({
-                type: "resize",
+                type: 'resize',
                 rows: msg.rows ?? state.rows,
                 cols: msg.cols ?? state.cols,
             });
         }
         const existingStreamId = this.terminalStreamByTerminalId.get(msg.terminalId);
-        if (typeof existingStreamId === "number") {
+        if (typeof existingStreamId === 'number') {
             this.detachTerminalStream(existingStreamId, { emitExit: false });
         }
         const streamId = this.allocateTerminalStreamId();
@@ -5031,7 +5156,7 @@ export class Session {
         }
         this.flushPendingTerminalStreamChunks(streamId, binding);
         this.emit({
-            type: "attach_terminal_stream_response",
+            type: 'attach_terminal_stream_response',
             payload: {
                 terminalId: msg.terminalId,
                 streamId,
@@ -5051,7 +5176,7 @@ export class Session {
         return chunk.startOffset < binding.lastAckOffset + TERMINAL_STREAM_WINDOW_BYTES;
     }
     emitTerminalStreamChunk(streamId, binding, chunk) {
-        const payload = new Uint8Array(Buffer.from(chunk.data, "utf8"));
+        const payload = new Uint8Array(Buffer.from(chunk.data, 'utf8'));
         this.emitBinary({
             channel: BinaryMuxChannel.Terminal,
             messageType: TerminalBinaryMessageType.OutputUtf8,
@@ -5072,7 +5197,7 @@ export class Session {
                     pendingChunks: binding.pendingChunks.length,
                     pendingBytes: binding.pendingBytes,
                     chunkBytes,
-                }, "Terminal stream pending buffer overflow; closing stream");
+                }, 'Terminal stream pending buffer overflow; closing stream');
                 this.detachTerminalStream(streamId, { emitExit: true });
                 return;
             }
@@ -5099,7 +5224,7 @@ export class Session {
     handleDetachTerminalStreamRequest(msg) {
         const success = this.detachTerminalStream(msg.streamId, { emitExit: false });
         this.emit({
-            type: "detach_terminal_stream_response",
+            type: 'detach_terminal_stream_response',
             payload: {
                 streamId: msg.streamId,
                 success,
@@ -5121,7 +5246,7 @@ export class Session {
             binding.unsubscribe();
         }
         catch (error) {
-            this.sessionLogger.warn({ err: error, streamId }, "Failed to unsubscribe terminal stream");
+            this.sessionLogger.warn({ err: error, streamId }, 'Failed to unsubscribe terminal stream');
         }
         this.terminalStreams.delete(streamId);
         if (this.terminalStreamByTerminalId.get(binding.terminalId) === streamId) {
@@ -5129,7 +5254,7 @@ export class Session {
         }
         if (options?.emitExit) {
             this.emit({
-                type: "terminal_stream_exit",
+                type: 'terminal_stream_exit',
                 payload: {
                     streamId,
                     terminalId: binding.terminalId,
@@ -5152,7 +5277,7 @@ export class Session {
             }
             attempts += 1;
         }
-        throw new Error("Unable to allocate terminal stream id");
+        throw new Error('Unable to allocate terminal stream id');
     }
 }
 //# sourceMappingURL=session.js.map