@getpaseo/server 0.1.97 → 0.1.98

package/dist/server/server/session.d.ts

@@ -25,6 +25,7 @@ import { FileBackedChatService } from "./chat/chat-service.js";
 import { LoopService } from "./loop-service.js";
 import { ScheduleService } from "./schedule/service.js";
 import { type GitHubService } from "../services/github-service.js";
+import type { ProviderUsageService } from "../services/quota-fetcher/service.js";
 import { generateBranchNameFromFirstAgentContext } from "./worktree-branch-name-generator.js";
 export declare function resolveWaitForFinishError(options: {
     status: "permission" | "error" | "idle";
@@ -74,6 +75,7 @@ export interface SessionOptions {
     tts: Resolvable<TextToSpeechProvider | null>;
     terminalManager: TerminalManager | null;
     providerSnapshotManager: ProviderSnapshotManager;
+    providerUsageService: ProviderUsageService;
     serviceProxy?: ServiceProxySubsystem;
     scriptRuntimeStore?: WorkspaceScriptRuntimeStore;
     workspaceSetupSnapshots?: Map<string, WorkspaceSetupSnapshot>;
@@ -180,6 +182,7 @@ export declare class Session {
     private clientActivity;
     private readonly terminalManager;
     private readonly providerSnapshotManager;
+    private readonly providerUsageService;
     private unsubscribeProviderSnapshotEvents;
     private readonly serviceProxy;
     private readonly scriptRuntimeStore;
@@ -273,6 +276,7 @@ export declare class Session {
     private matchesAgentFilter;
     private getAgentUpdateTargetId;
     private bufferOrEmitAgentUpdate;
+    private emitStoredAgentUpdate;
     private flushBootstrappedAgentUpdates;
     private findExactWorkspaceByDirectory;
     private resolveWorkspaceDirectory;
@@ -287,6 +291,7 @@ export declare class Session {
     private dispatchInboundMessage;
     private dispatchVoiceAndControlMessage;
     private dispatchAgentRewindMessage;
+    private dispatchAgentRelationshipMessage;
     private handleDictationStreamStart;
     private dispatchAgentLifecycleMessage;
     private dispatchAgentConfigMessage;
@@ -309,6 +314,7 @@ export declare class Session {
     private handleDeleteAgentRequest;
     private handleArchiveAgentRequest;
     private archiveAgentForClose;
+    private handleDetachAgentRequest;
     private handleCloseItemsRequest;
     private unarchiveAgentByHandle;
     private handleUpdateAgentRequest;
@@ -363,6 +369,7 @@ export declare class Session {
     private handleGetProvidersSnapshotRequest;
     private handleRefreshProvidersSnapshotRequest;
     private handleProviderDiagnosticRequest;
+    private handleProviderUsageListRequest;
     private assertSafeGitRef;
     private isPathWithinRoot;
     private generateCommitMessage;
@@ -462,6 +469,7 @@ export declare class Session {
     private listAgentPayloads;
     private resolveAgentIdentifier;
     private getAgentPayloadById;
+    private resolveDelegationRootWorkspaceId;
     private buildActiveProjectPlacementsByWorkspaceId;
     private collectFetchAgentsEntries;
     private listFetchAgentsEntries;
@@ -484,6 +492,8 @@ export declare class Session {
     private findOrCreateWorkspaceForDirectory;
     private resolveOrCreateWorkspaceIdForCreateAgent;
     private createWorkspaceForDirectory;
+    private findOrCreateProjectForDirectory;
+    private buildProjectDescriptor;
     private reclassifyOrUnarchiveWorkspaceForDirectory;
     private resolveProjectRecordForPlacement;
     private unarchiveOwningWorkspaceForAgent;
@@ -498,7 +508,7 @@ export declare class Session {
     private emitWorkspaceUpdatesForWorkspaceIds;
     private recordWorkspaceGitDescriptorState;
     private buildWorkspaceRemoveUpdatePayload;
-    private resolveEmptyProjectForArchivedWorkspace;
+    private resolveProjectWithoutActiveWorkspacesForArchivedWorkspace;
     private emitWorkspaceUpdateForTerminalContribution;
     private emitWorkspaceUpdateForCwd;
     private handleFetchAgents;
@@ -513,6 +523,7 @@ export declare class Session {
     private handleWorkspaceCreateWorktree;
     private resolveWorktreeSourceCwd;
     private handleOpenProjectRequest;
+    private handleProjectAddRequest;
     private buildWorkspaceScriptPayloadSnapshot;
     private resolveWorkspaceScriptGitMetadata;
     private emitWorkspaceScriptStatusUpdate;

package/dist/server/server/session.js

@@ -32,9 +32,10 @@ import { deriveProjectSlug } from "./workspace-git-metadata.js";
 import { spawnWorkspaceScript } from "./worktree-bootstrap.js";
 import { getErrorMessage, getErrorMessageOr } from "@getpaseo/protocol/error-utils";
 import { getAgentStatusPriority } from "@getpaseo/protocol/agent-state-bucket";
+import { getParentAgentIdFromLabels } from "@getpaseo/protocol/agent-labels";
 import { resolveSnapshotCwd } from "./agent/provider-snapshot-manager.js";
 import { createAgentCommand } from "./agent/create-agent/create.js";
-import { archiveAgentCommand, cancelAgentRunCommand, closeAgentCommand, setAgentModeCommand, updateAgentCommand, } from "./agent/lifecycle-command.js";
+import { archiveAgentCommand, cancelAgentRunCommand, closeAgentCommand, detachAgentCommand, setAgentModeCommand, updateAgentCommand, } from "./agent/lifecycle-command.js";
 import { buildStoredAgentPayload, resolveEffectiveThinkingOptionId, resolveStoredAgentPayloadUpdatedAt, toAgentPayload, } from "./agent/agent-projections.js";
 import { appendTimelineItemIfAgentKnown, emitLiveTimelineItemIfAgentKnown, } from "./agent/timeline-append.js";
 import { projectTimelineRows, selectProjectedTimelinePage, } from "./agent/timeline-projection.js";
@@ -342,7 +343,7 @@ export class Session {
                 }
             },
         });
-        const { clientId, appVersion, clientCapabilities, onMessage, onBinaryMessage, getTransportBufferedAmount, onLifecycleIntent, logger, downloadTokenStore, pushTokenStore, paseoHome, worktreesRoot, agentManager, agentStorage, projectRegistry, workspaceRegistry, filesystem, chatService, scheduleService, loopService, checkoutDiffManager, github, renameCurrentBranch, generateWorkspaceName, workspaceGitService, daemonConfigStore, mcpBaseUrl, stt, sttLanguage, tts, terminalManager, providerSnapshotManager, serviceProxy, scriptRuntimeStore, workspaceSetupSnapshots, onBranchChanged, getDaemonTcpPort, getDaemonTcpHost, serviceProxyPublicBaseUrl, resolveScriptHealth, voice, voiceBridge, dictation, serverId, daemonVersion, daemonRuntimeConfig, } = options;
+        const { clientId, appVersion, clientCapabilities, onMessage, onBinaryMessage, getTransportBufferedAmount, onLifecycleIntent, logger, downloadTokenStore, pushTokenStore, paseoHome, worktreesRoot, agentManager, agentStorage, projectRegistry, workspaceRegistry, filesystem, chatService, scheduleService, loopService, checkoutDiffManager, github, renameCurrentBranch, generateWorkspaceName, workspaceGitService, daemonConfigStore, mcpBaseUrl, stt, sttLanguage, tts, terminalManager, providerSnapshotManager, providerUsageService, serviceProxy, scriptRuntimeStore, workspaceSetupSnapshots, onBranchChanged, getDaemonTcpPort, getDaemonTcpHost, serviceProxyPublicBaseUrl, resolveScriptHealth, voice, voiceBridge, dictation, serverId, daemonVersion, daemonRuntimeConfig, } = options;
         this.clientId = clientId;
         this.appVersion = appVersion ?? null;
         this.clientCapabilities = parseClientCapabilities(clientCapabilities);
@@ -416,6 +417,7 @@ export class Session {
             logger: this.sessionLogger,
         });
         this.providerSnapshotManager = providerSnapshotManager;
+        this.providerUsageService = providerUsageService;
         this.serviceProxy = serviceProxy ?? null;
         this.scriptRuntimeStore = scriptRuntimeStore ?? null;
         this.workspaceSetupSnapshots = workspaceSetupSnapshots ?? new Map();
@@ -860,6 +862,39 @@ export class Session {
             payload,
         });
     }
+    async emitStoredAgentUpdate(record) {
+        const payload = this.buildStoredAgentPayload(record);
+        const subscription = this.agentUpdatesSubscription;
+        if (!subscription) {
+            return payload;
+        }
+        const project = payload.workspaceId
+            ? await this.buildProjectPlacementForWorkspaceId(payload.workspaceId)
+            : null;
+        if (!project) {
+            this.bufferOrEmitAgentUpdate(subscription, {
+                kind: "remove",
+                agentId: payload.id,
+            });
+            return payload;
+        }
+        const matches = this.matchesAgentFilter({
+            agent: payload,
+            project,
+            filter: subscription.filter,
+        });
+        this.bufferOrEmitAgentUpdate(subscription, matches
+            ? {
+                kind: "upsert",
+                agent: payload,
+                project,
+            }
+            : {
+                kind: "remove",
+                agentId: payload.id,
+            });
+        return payload;
+    }
     flushBootstrappedAgentUpdates(options) {
         const subscription = this.agentUpdatesSubscription;
         if (!subscription || !subscription.isBootstrapping) {
@@ -1026,6 +1061,7 @@ export class Session {
     async dispatchInboundMessage(msg) {
         const promise = this.dispatchVoiceAndControlMessage(msg) ??
             this.dispatchAgentRewindMessage(msg) ??
+            this.dispatchAgentRelationshipMessage(msg) ??
             this.dispatchAgentLifecycleMessage(msg) ??
             this.dispatchAgentConfigMessage(msg) ??
             this.dispatchCheckoutMessage(msg) ??
@@ -1094,6 +1130,14 @@ export class Session {
                 return undefined;
         }
     }
+    dispatchAgentRelationshipMessage(msg) {
+        switch (msg.type) {
+            case "agent.detach.request":
+                return this.handleDetachAgentRequest(msg.agentId, msg.requestId);
+            default:
+                return undefined;
+        }
+    }
     async handleDictationStreamStart(msg) {
         const unavailable = this.resolveVoiceFeatureUnavailableContext("dictation");
         if (unavailable) {
@@ -1350,6 +1394,8 @@ export class Session {
                 return this.handleLegacyOpenInEditorRequest(msg);
             case "open_project_request":
                 return this.handleOpenProjectRequest(msg);
+            case "project.add.request":
+                return this.handleProjectAddRequest(msg);
             case "archive_workspace_request":
                 return this.handleArchiveWorkspaceRequest(msg);
             case "project.remove.request":
@@ -1389,6 +1435,8 @@ export class Session {
                 return this.handleRefreshProvidersSnapshotRequest(msg);
             case "provider_diagnostic_request":
                 return this.handleProviderDiagnosticRequest(msg);
+            case "provider.usage.list.request":
+                return this.handleProviderUsageListRequest(msg);
             default:
                 return undefined;
         }
@@ -1580,39 +1628,60 @@ export class Session {
             logger: this.sessionLogger,
         }, agentId);
         if (this.agentUpdatesSubscription) {
-            const payload = this.buildStoredAgentPayload(archivedRecord);
-            const project = payload.workspaceId
-                ? await this.buildProjectPlacementForWorkspaceId(payload.workspaceId)
-                : null;
-            if (project) {
-                const matches = this.matchesAgentFilter({
-                    agent: payload,
-                    project,
-                    filter: this.agentUpdatesSubscription.filter,
-                });
-                this.bufferOrEmitAgentUpdate(this.agentUpdatesSubscription, matches
-                    ? {
-                        kind: "upsert",
-                        agent: payload,
-                        project,
-                    }
-                    : {
-                        kind: "remove",
-                        agentId,
-                    });
-            }
-            else {
-                this.bufferOrEmitAgentUpdate(this.agentUpdatesSubscription, {
-                    kind: "remove",
-                    agentId,
-                });
-            }
+            const payload = await this.emitStoredAgentUpdate(archivedRecord);
             if (payload.workspaceId) {
                 await this.emitWorkspaceUpdateForWorkspaceId(payload.workspaceId);
             }
         }
         return { agentId, archivedAt };
     }
+    async handleDetachAgentRequest(agentId, requestId) {
+        this.sessionLogger.info({ agentId, requestId }, "Detaching agent from parent");
+        try {
+            const result = await detachAgentCommand({ agentManager: this.agentManager }, agentId);
+            const affectedWorkspaceIds = new Set();
+            if (!result.live) {
+                const payload = await this.emitStoredAgentUpdate(result.record);
+                if (payload.workspaceId) {
+                    affectedWorkspaceIds.add(payload.workspaceId);
+                }
+            }
+            else if (result.record.workspaceId) {
+                affectedWorkspaceIds.add(result.record.workspaceId);
+            }
+            if (result.previousParentAgentId) {
+                const rootWorkspaceId = await this.resolveDelegationRootWorkspaceId(result.previousParentAgentId);
+                if (rootWorkspaceId) {
+                    affectedWorkspaceIds.add(rootWorkspaceId);
+                }
+            }
+            await this.emitWorkspaceUpdatesForWorkspaceIds(affectedWorkspaceIds, {
+                skipReconcile: true,
+            });
+            this.emit({
+                type: "agent.detach.response",
+                payload: {
+                    requestId,
+                    agentId,
+                    accepted: true,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            const message = getErrorMessageOr(error, "Failed to detach agent");
+            this.sessionLogger.error({ err: error, agentId, requestId }, "Failed to detach agent");
+            this.emit({
+                type: "agent.detach.response",
+                payload: {
+                    requestId,
+                    agentId,
+                    accepted: false,
+                    error: message,
+                },
+            });
+        }
+    }
     async handleCloseItemsRequest(msg) {
         const archiveResults = await Promise.allSettled(msg.agentIds.map((agentId) => this.archiveAgentForClose(agentId)));
         const agents = [];
@@ -3075,6 +3144,32 @@ export class Session {
             });
         }
     }
+    async handleProviderUsageListRequest(msg) {
+        try {
+            const usage = await this.providerUsageService.listUsage();
+            this.emit({
+                type: "provider.usage.list.response",
+                payload: {
+                    requestId: msg.requestId,
+                    fetchedAt: usage.fetchedAt,
+                    providers: usage.providers,
+                },
+            });
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.sessionLogger.error({ err }, "Failed to list provider usage");
+            this.emit({
+                type: "rpc_error",
+                payload: {
+                    requestId: msg.requestId,
+                    requestType: msg.type,
+                    error: `Failed to list provider usage: ${err.message}`,
+                    code: "provider_usage_list_failed",
+                },
+            });
+        }
+    }
     assertSafeGitRef(ref, label) {
         if (!/^[A-Za-z0-9._/-]+$/.test(ref)) {
             throw new Error(`Invalid ${label}: ${ref}`);
@@ -3309,11 +3404,11 @@ export class Session {
     async handleSetAgentModeRequest(agentId, modeId, requestId) {
         this.sessionLogger.info({ agentId, modeId, requestId }, "session: set_agent_mode_request");
         try {
-            await setAgentModeCommand({ agentManager: this.agentManager }, { agentId, modeId });
+            const result = await setAgentModeCommand({ agentManager: this.agentManager }, { agentId, modeId });
             this.sessionLogger.info({ agentId, modeId, requestId }, "session: set_agent_mode_request success");
             this.emit({
                 type: "set_agent_mode_response",
-                payload: { requestId, agentId, accepted: true, error: null },
+                payload: { requestId, agentId, accepted: true, error: null, notice: result.notice },
             });
         }
         catch (error) {
@@ -3405,11 +3500,11 @@ export class Session {
     async handleSetAgentThinkingRequest(agentId, thinkingOptionId, requestId) {
         this.sessionLogger.info({ agentId, thinkingOptionId, requestId }, "session: set_agent_thinking_request");
         try {
-            await this.agentManager.setAgentThinkingOption(agentId, thinkingOptionId);
+            const notice = await this.agentManager.setAgentThinkingOption(agentId, thinkingOptionId);
             this.sessionLogger.info({ agentId, thinkingOptionId, requestId }, "session: set_agent_thinking_request success");
             this.emit({
                 type: "set_agent_thinking_response",
-                payload: { requestId, agentId, accepted: true, error: null },
+                payload: { requestId, agentId, accepted: true, error: null, notice },
             });
         }
         catch (error) {
@@ -4964,6 +5059,29 @@ export class Session {
         const payload = this.buildStoredAgentPayload(record);
         return this.isProviderVisibleToClient(payload.provider) ? payload : null;
     }
+    async resolveDelegationRootWorkspaceId(agentId) {
+        const seen = new Set();
+        let currentAgentId = agentId;
+        while (true) {
+            if (seen.has(currentAgentId)) {
+                return null;
+            }
+            seen.add(currentAgentId);
+            const live = this.agentManager.getAgent(currentAgentId);
+            const source = live ?? (await this.agentStorage.get(currentAgentId));
+            if (!source) {
+                return null;
+            }
+            if ("archivedAt" in source && source.archivedAt) {
+                return null;
+            }
+            const parentAgentId = getParentAgentIdFromLabels(source.labels);
+            if (!parentAgentId) {
+                return source.workspaceId ?? null;
+            }
+            currentAgentId = parentAgentId;
+        }
+    }
     async buildActiveProjectPlacementsByWorkspaceId() {
         const [persistedWorkspaces, persistedProjects] = await Promise.all([
             this.workspaceRegistry.list(),
@@ -5371,6 +5489,26 @@ export class Session {
         await this.workspaceRegistry.upsert(workspaceRecord);
         return workspaceRecord;
     }
+    async findOrCreateProjectForDirectory(cwd) {
+        const normalizedCwd = resolve(cwd);
+        const checkout = await this.workspaceGitService.getCheckout(normalizedCwd);
+        const membership = classifyDirectoryForProjectMembership({ cwd: normalizedCwd, checkout });
+        const projectRecord = await this.resolveProjectRecordForPlacement({
+            membership,
+            timestamp: new Date().toISOString(),
+        });
+        await this.projectRegistry.upsert(projectRecord);
+        return projectRecord;
+    }
+    buildProjectDescriptor(project) {
+        return {
+            projectId: project.projectId,
+            projectDisplayName: resolveProjectDisplayName(project),
+            projectCustomName: project.customName ?? null,
+            projectRootPath: project.rootPath,
+            projectKind: project.kind,
+        };
+    }
     async reclassifyOrUnarchiveWorkspaceForDirectory(input) {
         const checkout = await this.workspaceGitService.getCheckout(input.cwd);
         const membership = classifyDirectoryForProjectMembership({ cwd: input.cwd, checkout });
@@ -5701,19 +5839,19 @@ export class Session {
         return {
             kind: "remove",
             id: workspaceId,
-            ...(await this.resolveEmptyProjectForArchivedWorkspace(workspaceId)),
+            ...(await this.resolveProjectWithoutActiveWorkspacesForArchivedWorkspace(workspaceId)),
         };
     }
-    // When a workspace is archived its project may become empty. Resolve the
-    // now-empty project parent so the `remove` update can carry it, keeping the
-    // sidebar's empty project row in sync without a full re-hydration.
-    async resolveEmptyProjectForArchivedWorkspace(workspaceId) {
+    // When a workspace is archived its project may have no active workspaces left.
+    // Resolve that project parent so the `remove` update can carry it, keeping the
+    // sidebar in sync without a full re-hydration.
+    async resolveProjectWithoutActiveWorkspacesForArchivedWorkspace(workspaceId) {
         const archivedWorkspace = await this.workspaceRegistry.get(workspaceId);
         if (!archivedWorkspace) {
             return null;
         }
-        const emptyProject = (await this.workspaceDirectory.listEmptyProjects()).find((project) => project.projectId === archivedWorkspace.projectId);
-        return emptyProject ? { emptyProject } : null;
+        const projectWithoutActiveWorkspaces = (await this.workspaceDirectory.listEmptyProjects()).find((project) => project.projectId === archivedWorkspace.projectId);
+        return projectWithoutActiveWorkspaces ? { emptyProject: projectWithoutActiveWorkspaces } : null;
     }
     async emitWorkspaceUpdateForTerminalContribution(event) {
         // A terminal's activity contributes only to the workspace it carries. A
@@ -6159,6 +6297,58 @@ export class Session {
             });
         }
     }
+    async handleProjectAddRequest(request) {
+        const requestedCwd = request.cwd;
+        const cwd = expandTilde(requestedCwd);
+        const directoryExists = await this.filesystem.isDirectory(cwd).catch(() => false);
+        if (!directoryExists) {
+            this.sessionLogger.info({ requestedCwd, resolvedCwd: cwd, reason: "directory_not_found" }, "Add project rejected");
+            this.emit({
+                type: "project.add.response",
+                payload: {
+                    requestId: request.requestId,
+                    project: null,
+                    error: `Directory not found: ${cwd}`,
+                    errorCode: "directory_not_found",
+                },
+            });
+            return;
+        }
+        try {
+            const projectsBefore = new Map();
+            for (const project of await this.projectRegistry.list()) {
+                projectsBefore.set(project.projectId, project);
+            }
+            const project = await this.findOrCreateProjectForDirectory(cwd);
+            this.sessionLogger.info({
+                requestedCwd,
+                resolvedCwd: cwd,
+                projectId: project.projectId,
+                projectKind: project.kind,
+                projectTransition: describeRegistryTransition(projectsBefore.get(project.projectId) ?? null),
+            }, "Project added");
+            this.emit({
+                type: "project.add.response",
+                payload: {
+                    requestId: request.requestId,
+                    project: this.buildProjectDescriptor(project),
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "Failed to add project";
+            this.sessionLogger.error({ err: error, cwd }, "Failed to add project");
+            this.emit({
+                type: "project.add.response",
+                payload: {
+                    requestId: request.requestId,
+                    project: null,
+                    error: message,
+                },
+            });
+        }
+    }
     buildWorkspaceScriptPayloadSnapshot(workspaceId, workspaceDirectory) {
         if (!this.serviceProxy || !this.scriptRuntimeStore) {
             return [];

package/dist/server/server/speech/providers/openai/runtime.js

@@ -38,15 +38,14 @@ export function validateOpenAiCredentialRequirements(params) {
         missingOpenAiCredentialsFor.push("dictation.stt");
     }
     if (missingOpenAiCredentialsFor.length > 0) {
-        logger.error({
+        logger.warn({
             requestedProviders: {
                 dictationStt: providers.dictationStt.provider,
                 voiceStt: providers.voiceStt.provider,
                 voiceTts: providers.voiceTts.provider,
             },
             missingOpenAiCredentialsFor,
-        }, "Invalid speech configuration: OpenAI provider selected but credentials are missing");
-        throw new Error(`Missing OpenAI credentials for configured speech features: ${missingOpenAiCredentialsFor.join(", ")}`);
+        }, "Invalid speech configuration: OpenAI provider selected but credentials are missing — speech features will be unavailable");
     }
 }
 function createOpenAiStt(apiKey, openaiConfig, logger) {
@@ -105,7 +104,7 @@ export function initializeOpenAiSpeechServices(params) {
         }
     }
     else if (needsAnyOpenAi) {
-        logger.warn("OpenAI speech providers are configured but credentials are missing");
+        // validateOpenAiCredentialRequirements already warned about missing credentials
     }
     return {
         turnDetectionService,

package/dist/server/server/websocket-server.d.ts

@@ -93,6 +93,7 @@ export declare class VoiceAssistantWebSocketServer {
     private eventLoopDelayMonitor;
     private unsubscribeSpeechReadiness;
     private unsubscribeDaemonConfigChange;
+    private readonly providerUsageService;
     private unsubscribeTerminalActivity;
     constructor(server: HTTPServer, logger: pino.Logger, serverId: string, agentManager: AgentManager, agentStorage: AgentStorage, downloadTokenStore: DownloadTokenStore, paseoHome: string, daemonConfigStore: DaemonConfigStore, mcpBaseUrl: string | null, wsConfig: WebSocketServerConfig, auth?: DaemonAuthConfig, speech?: SpeechService | null, terminalManager?: TerminalManager | null, dictation?: {
         finalTimeoutMs?: number;

package/dist/server/server/websocket-server.js

@@ -14,6 +14,7 @@ import { buildAgentAttentionNotificationPayload, findLatestPermissionRequest, }
 import { createGitHubService } from "../services/github-service.js";
 import { extractWsBearerProtocol, extractWsBearerToken, isBearerTokenValid, } from "./auth.js";
 import { WebSocketRuntimeMetricsWindow, } from "./websocket/runtime-metrics.js";
+import { ProviderUsageService } from "../services/quota-fetcher/service.js";
 const WS_CLOSE_DAEMON_AUTH_FAILED = 4401;
 function resolveTerminalAttentionReason(input) {
     if (input.attentionReason === "finished")
@@ -298,6 +299,9 @@ export class VoiceAssistantWebSocketServer {
                 this.logger.warn({ err, agentId: params.agentId }, "Failed to broadcast agent attention");
             });
         });
+        this.providerUsageService = new ProviderUsageService({
+            logger: this.logger,
+        });
         this.wss = this.createWebSocketServer(server, wsConfig, auth);
         this.startRuntimeMetricsInterval();
         this.logger.info("WebSocket server initialized on /ws");
@@ -649,6 +653,7 @@ export class VoiceAssistantWebSocketServer {
             tts: () => this.speech?.resolveTts() ?? null,
             terminalManager: this.terminalManager,
             providerSnapshotManager: this.providerSnapshotManager,
+            providerUsageService: this.providerUsageService,
             serviceProxy: this.serviceProxy ?? undefined,
             scriptRuntimeStore: this.scriptRuntimeStore ?? undefined,
             workspaceSetupSnapshots: this.workspaceSetupSnapshots,
@@ -809,8 +814,14 @@ export class VoiceAssistantWebSocketServer {
                 workspaceMultiplicity: true,
                 // COMPAT(projectRemove): added in v0.1.97, drop the gate when floor >= v0.1.97.
                 projectRemove: true,
+                // COMPAT(projectAdd): added in v0.1.97, drop the gate when floor >= v0.1.97.
+                projectAdd: true,
                 // COMPAT(worktreeRestore): added in v0.1.97, drop the gate when floor >= v0.1.97
                 worktreeRestore: true,
+                // COMPAT(providerUsageList): added in v0.1.98, drop the gate when daemon floor >= v0.1.98.
+                providerUsageList: true,
+                // COMPAT(agentDetach): added in v0.1.98, remove gate after 2026-12-19 once daemon floor >= v0.1.98.
+                agentDetach: true,
             },
         };
     }

package/dist/server/server/workspace-archive-service.js

@@ -212,9 +212,8 @@ export async function killTerminalsForWorkspace(dependencies, workspaceId) {
         }
     }));
 }
-// Archiving the last workspace of a project leaves the project as a first-class
-// empty project — it persists until explicitly removed, so we never archive the
-// parent project here.
+// Archiving the last workspace of a project leaves the project record active.
+// The user removes the project explicitly, so we never archive the parent here.
 export async function archivePersistedWorkspaceRecord(input) {
     const existingWorkspace = await input.workspaceRegistry.get(input.workspaceId);
     if (!existingWorkspace) {

package/dist/server/server/workspace-directory.js

@@ -295,9 +295,9 @@ export class WorkspaceDirectory {
         const candidates = [...agentTimestamps, ...terminalTimestamps].sort();
         return candidates.at(-1) ?? null;
     }
-    // Project parents that have no active workspaces. These persist as first-class
-    // empty projects so the sidebar can render an empty project row with a
-    // "+ New workspace" affordance.
+    // Project parents that have no active workspaces. The wire field is the
+    // sidebar projection bucket for projects whose workspace list is currently
+    // empty; it is not a separate domain record.
     async listEmptyProjects() {
         const [persistedWorkspaces, persistedProjects] = await Promise.all([
             this.deps.workspaceRegistry.list(),
@@ -359,8 +359,8 @@ export class WorkspaceDirectory {
         const nextCursor = hasMore && pagedEntries.length > 0
             ? this.pager.encode(pagedEntries[pagedEntries.length - 1], sort)
             : null;
-        // Empty project parents ride only on the first page so the sidebar can render
-        // them without them being duplicated across pagination.
+        // Project parents with no active workspaces ride only on the first page so
+        // the sidebar can render them without duplicating them across pagination.
         const projectIdFilter = filter?.projectId?.trim();
         const emptyProjects = cursorToken
             ? []

package/dist/server/server/workspace-reconciliation-service.js

@@ -98,8 +98,8 @@ export class WorkspaceReconciliationService {
         // 2. Merge duplicate active project records that point at the same repo root.
         await this.mergeDuplicateProjectsByRoot(activeProjects, workspacesByProject, changes);
         // 3. Reconcile git metadata for active projects whose directories still exist.
-        //    A project with zero active workspaces is a first-class empty project — it
-        //    persists until explicitly removed and still reconciles its own metadata.
+        //    Projects persist until explicitly removed, even when they currently have
+        //    zero active workspaces, so they still reconcile their own metadata.
         //    Skip projects archived earlier in this pass (e.g. merged duplicates) so we
         //    don't resurrect them by upserting a stale, non-archived copy.
         const archivedProjectIds = new Set(changes

package/dist/server/server/worktree-core.d.ts

@@ -6,6 +6,7 @@ import type { WorkspaceGitService } from "./workspace-git-service.js";
 export interface CreateWorktreeCoreInput {
     cwd: string;
     worktreeSlug?: string;
+    branchName?: string;
     refName?: string;
     action?: "branch-off" | "checkout";
     githubPrNumber?: number;

package/dist/server/server/worktree-core.js

@@ -6,6 +6,9 @@ export async function createWorktreeCore(input, deps) {
     const requestedWorktreeSlug = input.worktreeSlug
         ? normalizeWorktreeSlug(input.worktreeSlug)
         : undefined;
+    const requestedBranchName = input.branchName
+        ? validateWorktreeSlug(input.branchName.trim())
+        : undefined;
     let intentInput;
     if (input.action === "checkout") {
         intentInput = {
@@ -27,6 +30,7 @@ export async function createWorktreeCore(input, deps) {
         intentInput = {
             action: "branch-off",
             refName: input.refName,
+            branchName: requestedBranchName,
             worktreeSlug,
         };
     }
@@ -37,7 +41,7 @@ export async function createWorktreeCore(input, deps) {
     let normalizedSlug;
     switch (intent.kind) {
         case "branch-off": {
-            normalizedSlug = intent.branchName;
+            normalizedSlug = requestedWorktreeSlug ?? normalizeWorktreeSlug(intent.branchName);
             break;
         }
         case "checkout-branch": {

package/dist/server/services/quota-fetcher/manifest.d.ts

@@ -0,0 +1,4 @@
+import type { ProviderUsageFetcher, ProviderUsageFetcherFactoryOptions, ProviderUsageFetcherManifestEntry } from "./provider.js";
+export declare const PROVIDER_USAGE_FETCHERS: readonly ProviderUsageFetcherManifestEntry[];
+export declare function createProviderUsageFetchers(options: ProviderUsageFetcherFactoryOptions): ProviderUsageFetcher[];
+//# sourceMappingURL=manifest.d.ts.map