@getpaseo/server 0.1.96 → 0.1.97-beta.2

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

@@ -90,13 +90,16 @@ export declare class VoiceAssistantWebSocketServer {
     private serverCapabilities;
     private readonly runtimeMetrics;
     private runtimeMetricsInterval;
+    private eventLoopDelayMonitor;
     private unsubscribeSpeechReadiness;
     private unsubscribeDaemonConfigChange;
+    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;
     }, daemonVersion?: string, onLifecycleIntent?: (intent: SessionLifecycleIntent) => void, projectRegistry?: ProjectRegistry, workspaceRegistry?: WorkspaceRegistry, chatService?: FileBackedChatService, loopService?: LoopService, scheduleService?: ScheduleService, checkoutDiffManager?: CheckoutDiffManager, serviceProxy?: ServiceProxySubsystem | null, scriptRuntimeStore?: WorkspaceScriptRuntimeStore | null, onBranchChanged?: (workspaceId: string, oldBranch: string | null, newBranch: string | null) => void, getDaemonTcpPort?: () => number | null, getDaemonTcpHost?: () => string | null, resolveScriptHealth?: (hostname: string) => ScriptHealthState | null, workspaceGitService?: WorkspaceGitService, github?: GitHubService, pushNotificationSender?: PushNotificationSender, providerSnapshotManager?: ProviderSnapshotManager, daemonRuntimeConfig?: {
         listen: string | null;
         worktreesRoot?: string;
+        appBaseUrl?: string;
         relay: {
             enabled: boolean;
             endpoint: string;
@@ -108,6 +111,7 @@ export declare class VoiceAssistantWebSocketServer {
     private assignOptionalServices;
     private createWebSocketServer;
     private startRuntimeMetricsInterval;
+    private snapshotEventLoopDelay;
     private verifyWsUpgrade;
     private attachAuthenticatedSocket;
     broadcast(message: WSOutboundMessage): void;
@@ -150,6 +154,7 @@ export declare class VoiceAssistantWebSocketServer {
     private flushRuntimeMetrics;
     private getClientActivityState;
     private broadcastAgentAttention;
+    private broadcastTerminalAttention;
 }
 export {};
 //# sourceMappingURL=websocket-server.d.ts.map

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

@@ -1,6 +1,7 @@
 import { WebSocketServer } from "ws";
 import { basename, join } from "path";
 import { hostname as getHostname } from "node:os";
+import { monitorEventLoopDelay } from "node:perf_hooks";
 import { WSInboundMessageSchema, wrapSessionMessage, } from "./messages.js";
 import { asUint8Array, decodeBinaryFrame } from "@getpaseo/protocol/binary-frames/index";
 import { isHostnameAllowed } from "./hostnames.js";
@@ -8,12 +9,26 @@ import { Session } from "./session.js";
 import { buildWorkspaceGitMetadataFromSnapshot } from "./workspace-git-metadata.js";
 import { PushTokenStore } from "./push/token-store.js";
 import { createPushNotificationSender } from "./push/notifications.js";
-import { computeNotificationPlan } from "./agent-attention-policy.js";
+import { computeNotificationPlan, isPushEligibleAttentionReason, } from "./agent-attention-policy.js";
 import { buildAgentAttentionNotificationPayload, findLatestPermissionRequest, } from "@getpaseo/protocol/agent-attention-notification";
 import { createGitHubService } from "../services/github-service.js";
 import { extractWsBearerProtocol, extractWsBearerToken, isBearerTokenValid, } from "./auth.js";
 import { WebSocketRuntimeMetricsWindow, } from "./websocket/runtime-metrics.js";
 const WS_CLOSE_DAEMON_AUTH_FAILED = 4401;
+function resolveTerminalAttentionReason(input) {
+    if (input.attentionReason === "finished")
+        return "finished";
+    if (input.attentionReason === "needs_input")
+        return "needs_input";
+    if (input.state === "attention")
+        return "needs_input";
+    if (input.previousState === "working" && input.state === "idle")
+        return "finished";
+    return null;
+}
+function terminalAttentionTitle(reason) {
+    return reason === "needs_input" ? "Terminal needs input" : "Terminal finished";
+}
 function createFallbackWorkspaceGitSnapshot(cwd) {
     return {
         cwd,
@@ -213,8 +228,10 @@ export class VoiceAssistantWebSocketServer {
         this.workspaceSetupSnapshots = new Map();
         this.runtimeMetrics = new WebSocketRuntimeMetricsWindow();
         this.runtimeMetricsInterval = null;
+        this.eventLoopDelayMonitor = null;
         this.unsubscribeSpeechReadiness = null;
         this.unsubscribeDaemonConfigChange = null;
+        this.unsubscribeTerminalActivity = null;
         this.logger = logger.child({ module: "websocket-server" });
         this.serverId = serverId;
         if (typeof daemonVersion !== "string" || daemonVersion.trim().length === 0) {
@@ -288,6 +305,27 @@ export class VoiceAssistantWebSocketServer {
     assignOptionalServices(params) {
         this.speech = params.speech ?? null;
         this.terminalManager = params.terminalManager ?? null;
+        if (this.terminalManager) {
+            this.unsubscribeTerminalActivity = this.terminalManager.subscribeTerminalActivity((event) => {
+                const reason = resolveTerminalAttentionReason({
+                    attentionReason: event.activity?.attentionReason,
+                    previousState: event.previous?.state ?? null,
+                    state: event.activity?.state ?? null,
+                });
+                if (!reason) {
+                    return;
+                }
+                void this.broadcastTerminalAttention({
+                    terminalId: event.terminalId,
+                    cwd: event.cwd,
+                    ...(event.workspaceId ? { workspaceId: event.workspaceId } : {}),
+                    terminalName: event.name,
+                    reason,
+                }).catch((err) => {
+                    this.logger.warn({ err, terminalId: event.terminalId }, "Failed to broadcast terminal attention");
+                });
+            });
+        }
         this.dictation = params.dictation ?? null;
         this.onLifecycleIntent = params.onLifecycleIntent ?? null;
         this.serviceProxy = params.serviceProxy ?? null;
@@ -315,12 +353,30 @@ export class VoiceAssistantWebSocketServer {
         return wss;
     }
     startRuntimeMetricsInterval() {
+        this.eventLoopDelayMonitor = monitorEventLoopDelay({ resolution: 10 });
+        this.eventLoopDelayMonitor.enable();
         const runtimeMetricsInterval = setInterval(() => {
             this.flushRuntimeMetrics();
         }, WS_RUNTIME_METRICS_FLUSH_MS);
         this.runtimeMetricsInterval = runtimeMetricsInterval;
         runtimeMetricsInterval.unref?.();
     }
+    // Main-loop stall visibility: terminal frames and agent traffic share one event
+    // loop, so delay percentiles here are the ground truth for "the daemon is busy".
+    snapshotEventLoopDelay() {
+        const monitor = this.eventLoopDelayMonitor;
+        if (!monitor) {
+            return null;
+        }
+        const toMs = (nanoseconds) => Math.round(nanoseconds / 1e5) / 10;
+        const snapshot = {
+            p50Ms: toMs(monitor.percentile(50)),
+            p99Ms: toMs(monitor.percentile(99)),
+            maxMs: toMs(monitor.max),
+        };
+        monitor.reset();
+        return snapshot;
+    }
     verifyWsUpgrade(req, allowedOrigins, hostnames, callback) {
         const requestMetadata = extractSocketRequestMetadata(req);
         const origin = requestMetadata.origin;
@@ -393,11 +449,15 @@ export class VoiceAssistantWebSocketServer {
         this.unsubscribeSpeechReadiness = null;
         this.unsubscribeDaemonConfigChange?.();
         this.unsubscribeDaemonConfigChange = null;
+        this.unsubscribeTerminalActivity?.();
+        this.unsubscribeTerminalActivity = null;
         if (this.runtimeMetricsInterval) {
             clearInterval(this.runtimeMetricsInterval);
             this.runtimeMetricsInterval = null;
         }
         this.flushRuntimeMetrics({ final: true });
+        this.eventLoopDelayMonitor?.disable();
+        this.eventLoopDelayMonitor = null;
         const uniqueConnections = new Set([
             ...this.sessions.values(),
             ...this.externalSessionsByKey.values(),
@@ -548,6 +608,22 @@ export class VoiceAssistantWebSocketServer {
                 }
                 this.sendBinaryToConnection(connection, frame);
             },
+            getTransportBufferedAmount: () => {
+                if (!connection) {
+                    return null;
+                }
+                // Relay-attached sockets are a WebSocketLike that doesn't expose
+                // bufferedAmount. Return null when no socket gives a signal so the
+                // terminal fallback can't mistake "no signal" for "client keeping up";
+                // a direct ws reports its real buffered bytes (0 when drained).
+                let maxBuffered = null;
+                for (const socket of connection.sockets) {
+                    if (typeof socket.bufferedAmount === "number") {
+                        maxBuffered = Math.max(maxBuffered ?? 0, socket.bufferedAmount);
+                    }
+                }
+                return maxBuffered;
+            },
             onLifecycleIntent: (intent) => {
                 this.onLifecycleIntent?.(intent);
             },
@@ -729,6 +805,8 @@ export class VoiceAssistantWebSocketServer {
                 rewind: true,
                 // COMPAT(checkoutRefresh): added in v0.1.86, remove gate after 2026-11-29.
                 checkoutRefresh: true,
+                // COMPAT(workspaceMultiplicity): added in v0.1.97, drop the gate when floor >= v0.1.97
+                workspaceMultiplicity: true,
             },
         };
     }
@@ -1164,6 +1242,7 @@ export class VoiceAssistantWebSocketServer {
             outboundAgentStreamAgentsTop: runtimeMetrics.outboundAgentStreamAgentsTop,
             outboundBinaryFrameTypesTop: runtimeMetrics.outboundBinaryFrameTypesTop,
             bufferedAmount: runtimeMetrics.bufferedAmount,
+            eventLoopDelay: this.snapshotEventLoopDelay(),
             runtime: sessionMetrics,
             latency: runtimeMetrics.latency,
             agents: agentSnapshot,
@@ -1175,12 +1254,14 @@ export class VoiceAssistantWebSocketServer {
             return {
                 appVisible: false,
                 focusedAgentId: null,
+                focusedTerminalId: null,
                 lastActivityAtMs: null,
             };
         }
         return {
             appVisible: activity.appVisible,
             focusedAgentId: activity.focusedAgentId,
+            focusedTerminalId: activity.focusedTerminalId,
             lastActivityAtMs: activity.lastActivityAt.getTime(),
         };
     }
@@ -1205,8 +1286,8 @@ export class VoiceAssistantWebSocketServer {
         });
         const plan = computeNotificationPlan({
             allStates,
-            agentId: params.agentId,
-            reason: params.reason,
+            focusTarget: { kind: "agent", id: params.agentId },
+            pushEligible: isPushEligibleAttentionReason(params.reason),
             nowMs,
         });
         if (plan.shouldPush) {
@@ -1235,6 +1316,59 @@ export class VoiceAssistantWebSocketServer {
             this.sendToClient(ws, message);
         }
     }
+    async broadcastTerminalAttention(params) {
+        const clientEntries = [];
+        for (const [ws, connection] of this.sessions) {
+            clientEntries.push({
+                ws,
+                state: this.getClientActivityState(connection.session),
+            });
+        }
+        const allStates = clientEntries.map((e) => e.state);
+        const nowMs = Date.now();
+        const workspaceId = params.workspaceId;
+        const plan = computeNotificationPlan({
+            allStates,
+            focusTarget: { kind: "terminal", id: params.terminalId },
+            pushEligible: true,
+            nowMs,
+        });
+        const title = terminalAttentionTitle(params.reason);
+        const body = params.terminalName;
+        if (plan.shouldPush) {
+            void this.pushNotificationSender
+                .send({
+                title,
+                body,
+                data: {
+                    serverId: this.serverId,
+                    terminalId: params.terminalId,
+                    cwd: params.cwd,
+                    ...(workspaceId ? { workspaceId } : {}),
+                },
+            })
+                .catch((err) => {
+                this.logger.warn({ err, terminalId: params.terminalId }, "Failed to send push notification");
+            });
+        }
+        for (const [clientIndex, { ws }] of clientEntries.entries()) {
+            const shouldNotify = clientIndex === plan.inAppRecipientIndex;
+            const message = wrapSessionMessage({
+                type: "terminal_attention_required",
+                payload: {
+                    serverId: this.serverId,
+                    terminalId: params.terminalId,
+                    cwd: params.cwd,
+                    ...(workspaceId ? { workspaceId } : {}),
+                    reason: params.reason,
+                    title,
+                    body,
+                    shouldNotify,
+                },
+            });
+            this.sendToClient(ws, message);
+        }
+    }
 }
 function extractSocketRequestMetadata(request) {
     if (!request || typeof request !== "object") {

package/dist/server/server/workspace-archive-service.d.ts

@@ -1,8 +1,65 @@
-import type { PersistedWorkspaceRecord, ProjectRegistry, WorkspaceRegistry } from "./workspace-registry.js";
+import type { Logger } from "pino";
+import type { AgentManager } from "./agent/agent-manager.js";
+import type { AgentStorage } from "./agent/agent-storage.js";
+import type { WorkspaceGitService } from "./workspace-git-service.js";
+import type { GitHubService } from "../services/github-service.js";
+import type { TerminalManager } from "../terminal/terminal-manager.js";
+import type { PersistedWorkspaceRecord, WorkspaceRegistry } from "./workspace-registry.js";
+export interface ActiveWorkspaceRef {
+    workspaceId: string;
+    cwd: string;
+    kind?: "local_checkout" | "worktree" | "directory";
+}
+export interface ArchiveDependencies {
+    paseoHome?: string;
+    paseoWorktreesBaseRoot?: string;
+    github: GitHubService;
+    workspaceGitService: Pick<WorkspaceGitService, "getSnapshot">;
+    agentManager: Pick<AgentManager, "listAgents" | "archiveAgent" | "archiveSnapshot">;
+    agentStorage: Pick<AgentStorage, "list">;
+    findWorkspaceIdForCwd: (cwd: string) => Promise<string | null>;
+    listActiveWorkspaces: () => Promise<ActiveWorkspaceRef[]>;
+    archiveWorkspaceRecord: (workspaceId: string) => Promise<void>;
+    emitWorkspaceUpdatesForWorkspaceIds: (workspaceIds: Iterable<string>) => Promise<void>;
+    markWorkspaceArchiving: (workspaceIds: Iterable<string>, archivingAt: string) => void;
+    clearWorkspaceArchiving: (workspaceIds: Iterable<string>) => void;
+    killTerminalsForWorkspace: (workspaceId: string) => Promise<void>;
+    sessionLogger?: Logger;
+}
+export interface KillTerminalsForWorkspaceDependencies {
+    detachTerminalStream?: (terminalId: string, options: {
+        emitExit: boolean;
+    }) => void;
+    sessionLogger: Logger;
+    terminalManager: TerminalManager | null;
+}
+export type ArchiveScope = {
+    kind: "workspace";
+    workspaceId: string;
+} | {
+    kind: "worktree";
+    targetPath: string;
+};
+export interface ArchiveResult {
+    archivedAgentIds: string[];
+    archivedWorkspaceIds: string[];
+    removedDirectory: boolean;
+}
+export interface ArchiveByScopeRequest {
+    scope: ArchiveScope;
+    repoRoot: string | null;
+    repoWorktreesRoot?: string;
+    paseoWorktreesBaseRoot?: string;
+    requestId: string;
+}
+export declare function resolveWorkspaceIdAtPath(dependencies: Pick<ArchiveDependencies, "findWorkspaceIdForCwd" | "listActiveWorkspaces">, targetPath: string): Promise<string | null>;
+export declare function archiveByScope(dependencies: ArchiveDependencies, request: ArchiveByScopeRequest): Promise<ArchiveResult>;
+export type ArchiveWorkspaceContentsDependencies = Pick<ArchiveDependencies, "agentManager" | "agentStorage" | "killTerminalsForWorkspace" | "sessionLogger">;
+export declare function archiveWorkspaceContents(dependencies: ArchiveWorkspaceContentsDependencies, workspaceId: string): Promise<Set<string>>;
+export declare function killTerminalsForWorkspace(dependencies: KillTerminalsForWorkspaceDependencies, workspaceId: string): Promise<void>;
 export declare function archivePersistedWorkspaceRecord(input: {
     workspaceId: string;
-    workspaceRegistry: Pick<WorkspaceRegistry, "get" | "list" | "archive">;
-    projectRegistry: Pick<ProjectRegistry, "archive">;
+    workspaceRegistry: Pick<WorkspaceRegistry, "get" | "archive">;
     archivedAt?: string;
 }): Promise<PersistedWorkspaceRecord | null>;
 //# sourceMappingURL=workspace-archive-service.d.ts.map

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

@@ -1,3 +1,220 @@
+import { resolve } from "node:path";
+import { deletePaseoWorktree, isPaseoOwnedWorktreeCwd, resolvePaseoWorktreeRootForCwd, WorktreeTeardownError, } from "../utils/worktree.js";
+export async function resolveWorkspaceIdAtPath(dependencies, targetPath) {
+    const targetDir = resolve(targetPath);
+    const activeWorkspaces = await dependencies.listActiveWorkspaces();
+    const exactMatches = activeWorkspaces.filter((workspace) => resolve(workspace.cwd) === targetDir);
+    const worktreeMatch = exactMatches.find((workspace) => workspace.kind === "worktree");
+    if (worktreeMatch) {
+        return worktreeMatch.workspaceId;
+    }
+    return dependencies.findWorkspaceIdForCwd(targetPath);
+}
+// THE single archive entry. Resolves the in-scope record set, tears each down
+// (agents + terminals + record), then removes the backing directory iff it is
+// Paseo-owned AND no active workspace still references it.
+export async function archiveByScope(dependencies, request) {
+    const { targetDir, targetWorkspaceIds } = await resolveArchiveTargets(dependencies, request.scope, request.paseoWorktreesBaseRoot);
+    if (targetWorkspaceIds.length > 0) {
+        dependencies.markWorkspaceArchiving(targetWorkspaceIds, new Date().toISOString());
+    }
+    let removedDirectory = false;
+    try {
+        if (targetWorkspaceIds.length > 0) {
+            await dependencies.emitWorkspaceUpdatesForWorkspaceIds(targetWorkspaceIds);
+        }
+        const { archivedAgents, archivedWorkspaceIds } = await archiveTargetRecords(dependencies, targetWorkspaceIds, request.requestId);
+        if (request.repoRoot) {
+            try {
+                await dependencies.workspaceGitService.getSnapshot(request.repoRoot, {
+                    force: true,
+                    reason: "archive-worktree",
+                });
+            }
+            catch (error) {
+                dependencies.sessionLogger?.warn({ err: error, cwd: request.repoRoot, requestId: request.requestId }, "Failed to force-refresh workspace git snapshot after archiving");
+            }
+        }
+        if (targetDir !== null) {
+            removedDirectory = await maybeRemoveDirectory(dependencies, request, targetDir, archivedWorkspaceIds);
+        }
+        return {
+            archivedAgentIds: Array.from(archivedAgents),
+            archivedWorkspaceIds,
+            removedDirectory,
+        };
+    }
+    finally {
+        if (targetWorkspaceIds.length > 0) {
+            dependencies.clearWorkspaceArchiving(targetWorkspaceIds);
+            await dependencies.emitWorkspaceUpdatesForWorkspaceIds(targetWorkspaceIds);
+        }
+    }
+}
+async function resolveArchiveTargets(dependencies, scope, paseoWorktreesBaseRoot) {
+    const activeWorkspaces = await dependencies.listActiveWorkspaces();
+    if (scope.kind === "workspace") {
+        const workspaceId = scope.workspaceId;
+        const record = activeWorkspaces.find((workspace) => workspace.workspaceId === workspaceId);
+        if (!record) {
+            dependencies.sessionLogger?.warn({ workspaceId }, "Workspace not found for archive-by-scope; skipping");
+            return { targetDir: null, targetWorkspaceIds: [] };
+        }
+        return { targetDir: resolve(record.cwd), targetWorkspaceIds: [workspaceId] };
+    }
+    let targetPath = scope.targetPath;
+    const resolvedWorktree = await resolvePaseoWorktreeRootForCwd(targetPath, {
+        paseoHome: dependencies.paseoHome,
+        worktreesRoot: paseoWorktreesBaseRoot ?? dependencies.paseoWorktreesBaseRoot,
+    });
+    if (resolvedWorktree) {
+        targetPath = resolvedWorktree.worktreePath;
+    }
+    const targetDir = resolve(targetPath);
+    const targetWorkspaceIds = activeWorkspaces
+        .filter((workspace) => resolve(workspace.cwd) === targetDir)
+        .map((workspace) => workspace.workspaceId);
+    return { targetDir, targetWorkspaceIds };
+}
+async function archiveTargetRecords(dependencies, targetWorkspaceIds, requestId) {
+    const archivedAgents = new Set();
+    const archivedWorkspaceIds = [];
+    const results = await Promise.allSettled(targetWorkspaceIds.map(async (workspaceId) => {
+        const agents = await archiveWorkspaceContents(dependencies, workspaceId);
+        await dependencies.archiveWorkspaceRecord(workspaceId);
+        return { workspaceId, agents };
+    }));
+    for (const result of results) {
+        if (result.status === "fulfilled") {
+            archivedWorkspaceIds.push(result.value.workspaceId);
+            for (const agentId of result.value.agents) {
+                archivedAgents.add(agentId);
+            }
+        }
+        else {
+            dependencies.sessionLogger?.warn({ err: result.reason, requestId }, "archiveByScope workspace teardown failed; continuing");
+        }
+    }
+    return { archivedAgents, archivedWorkspaceIds };
+}
+async function maybeRemoveDirectory(dependencies, request, targetDir, archivedWorkspaceIds) {
+    const ownership = await isPaseoOwnedWorktreeCwd(targetDir, {
+        paseoHome: dependencies.paseoHome,
+        worktreesRoot: request.paseoWorktreesBaseRoot ?? dependencies.paseoWorktreesBaseRoot,
+    });
+    if (!ownership.allowed) {
+        return false;
+    }
+    const remainingActive = await dependencies.listActiveWorkspaces();
+    if (!isDirectoryUnreferenced(remainingActive, targetDir, new Set(archivedWorkspaceIds))) {
+        return false;
+    }
+    try {
+        await deletePaseoWorktree({
+            cwd: request.repoRoot,
+            worktreePath: targetDir,
+            worktreesRoot: request.repoWorktreesRoot ?? ownership.worktreeRoot,
+            paseoHome: dependencies.paseoHome,
+            worktreesBaseRoot: request.paseoWorktreesBaseRoot ?? dependencies.paseoWorktreesBaseRoot,
+        });
+        dependencies.github.invalidate({ cwd: targetDir });
+        return true;
+    }
+    catch (error) {
+        if (error instanceof WorktreeTeardownError) {
+            dependencies.sessionLogger?.warn({ err: error, targetPath: targetDir, requestId: request.requestId }, "Worktree disk removal failed during archive; workspace already archived");
+            return false;
+        }
+        throw error;
+    }
+}
+// Tears down everything OWNED by a single workspace record: its live agents,
+// its persisted-but-not-running agent snapshots, and its terminals. Scoped by
+// workspaceId so a sibling workspace sharing the same directory is untouched.
+// Returns the set of archived agent ids.
+export async function archiveWorkspaceContents(dependencies, workspaceId) {
+    const archivedAgents = new Set();
+    const liveAgents = dependencies.agentManager
+        .listAgents()
+        .filter((agent) => agent.workspaceId === workspaceId);
+    for (const agent of liveAgents) {
+        archivedAgents.add(agent.id);
+    }
+    let storedRecords = [];
+    try {
+        storedRecords = await dependencies.agentStorage.list();
+    }
+    catch (error) {
+        dependencies.sessionLogger?.warn({ err: error, workspaceId }, "Failed to list stored agents during workspace archive; continuing");
+    }
+    const liveAgentIds = new Set(liveAgents.map((agent) => agent.id));
+    const matchingStoredRecords = storedRecords.filter((record) => record.workspaceId === workspaceId);
+    for (const record of matchingStoredRecords) {
+        archivedAgents.add(record.id);
+    }
+    const archivedAt = new Date().toISOString();
+    const archiveResults = await Promise.allSettled([
+        ...liveAgents.map((agent) => dependencies.agentManager.archiveAgent(agent.id)),
+        ...matchingStoredRecords
+            .filter((record) => !liveAgentIds.has(record.id) && !record.archivedAt)
+            .map((record) => dependencies.agentManager.archiveSnapshot(record.id, archivedAt)),
+        dependencies.killTerminalsForWorkspace(workspaceId),
+    ]);
+    for (const result of archiveResults) {
+        if (result.status === "rejected") {
+            dependencies.sessionLogger?.warn({ err: result.reason, workspaceId }, "Workspace archive teardown step failed; continuing");
+        }
+    }
+    return archivedAgents;
+}
+// EXACTLY one last-reference predicate in the module. True when, after archiving
+// the in-scope records, no active workspace still points at targetDir. Derived
+// from records each call — no stored counter.
+function isDirectoryUnreferenced(activeWorkspaces, targetDir, archivedWorkspaceIds) {
+    const target = resolve(targetDir);
+    return !activeWorkspaces.some((workspace) => !archivedWorkspaceIds.has(workspace.workspaceId) && resolve(workspace.cwd) === target);
+}
+export async function killTerminalsForWorkspace(dependencies, workspaceId) {
+    const terminalManager = dependencies.terminalManager;
+    if (!terminalManager) {
+        return;
+    }
+    const terminalIds = [];
+    const terminalLists = await Promise.all(terminalManager.listDirectories().map(async (terminalCwd) => {
+        try {
+            return await terminalManager.getTerminals(terminalCwd, { workspaceId });
+        }
+        catch (error) {
+            dependencies.sessionLogger.warn({ err: error, cwd: terminalCwd }, "Failed to enumerate workspace terminals during archive");
+            return [];
+        }
+    }));
+    for (const terminals of terminalLists) {
+        for (const terminal of terminals) {
+            if (terminal.workspaceId === workspaceId) {
+                terminalIds.push(terminal.id);
+            }
+        }
+    }
+    if (terminalIds.length === 0) {
+        return;
+    }
+    await Promise.allSettled(terminalIds.map(async (terminalId) => {
+        try {
+            dependencies.detachTerminalStream?.(terminalId, { emitExit: true });
+            await terminalManager.killTerminalAndWait(terminalId, {
+                gracefulTimeoutMs: 2000,
+                forceTimeoutMs: 1500,
+            });
+        }
+        catch (error) {
+            dependencies.sessionLogger.warn({ err: error, terminalId }, "Terminal kill escalation failed during archive; proceeding anyway");
+        }
+    }));
+}
+// 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.
 export async function archivePersistedWorkspaceRecord(input) {
     const existingWorkspace = await input.workspaceRegistry.get(input.workspaceId);
     if (!existingWorkspace) {
@@ -8,10 +225,6 @@ export async function archivePersistedWorkspaceRecord(input) {
     }
     const archivedAt = input.archivedAt ?? new Date().toISOString();
     await input.workspaceRegistry.archive(input.workspaceId, archivedAt);
-    const activeSiblings = (await input.workspaceRegistry.list()).filter((workspace) => workspace.projectId === existingWorkspace.projectId && !workspace.archivedAt);
-    if (activeSiblings.length === 0) {
-        await input.projectRegistry.archive(existingWorkspace.projectId, archivedAt);
-    }
     return existingWorkspace;
 }
 //# sourceMappingURL=workspace-archive-service.js.map

package/dist/server/server/workspace-directory.d.ts

@@ -1,6 +1,7 @@
 import type pino from "pino";
 import type { AgentSnapshotPayload, SessionInboundMessage, SessionOutboundMessage, WorkspaceDescriptorPayload } from "./messages.js";
 import type { PersistedProjectRecord, PersistedWorkspaceRecord } from "./workspace-registry.js";
+import { type TerminalActivity } from "@getpaseo/protocol/terminal-activity";
 type FetchWorkspacesRequestMessage = Extract<SessionInboundMessage, {
     type: "fetch_workspaces_request";
 }>;
@@ -10,6 +11,7 @@ type FetchWorkspacesResponsePayload = Extract<SessionOutboundMessage, {
 }>["payload"];
 type FetchWorkspacesResponseEntry = FetchWorkspacesResponsePayload["entries"][number];
 type FetchWorkspacesResponsePageInfo = FetchWorkspacesResponsePayload["pageInfo"];
+type WorkspaceProjectDescriptor = FetchWorkspacesResponsePayload["emptyProjects"][number];
 export type WorkspaceUpdatesFilter = FetchWorkspacesRequestFilter;
 export interface WorkspaceDirectoryDeps {
     logger: pino.Logger;
@@ -20,6 +22,11 @@ export interface WorkspaceDirectoryDeps {
         list(): Promise<PersistedWorkspaceRecord[]>;
     };
     listAgentPayloads(): Promise<AgentSnapshotPayload[]>;
+    listTerminalActivityContributions(): Promise<Array<{
+        cwd: string;
+        workspaceId?: string;
+        activity: TerminalActivity | null;
+    }>>;
     isProviderVisibleToClient(provider: string): boolean;
     buildWorkspaceDescriptor(input: {
         workspace: PersistedWorkspaceRecord;
@@ -41,6 +48,14 @@ export declare function summarizeFetchWorkspacesEntries(entries: Iterable<FetchW
         activityAt: string | null;
     }>;
 };
+/**
+ * Git facts (branch, diff, dirty, PR) belong to a checkout on disk, not to a
+ * workspace identity. Every workspace whose own cwd is that checkout re-derives
+ * its git facts from the same folder. This returns the ids of those workspaces
+ * so a git change can fan out to all of them. This is git-fact display, NOT
+ * ownership: do not use it to decide which workspace owns an arbitrary path.
+ */
+export declare function workspaceIdsOnCheckout(workspaces: Iterable<PersistedWorkspaceRecord>, cwd: string): string[];
 export declare class WorkspaceDirectory {
     private readonly deps;
     private readonly archivingByWorkspaceId;
@@ -58,9 +73,11 @@ export declare class WorkspaceDirectory {
         includeGitData: boolean;
         workspaceIds?: Iterable<string>;
     }): Promise<Map<string, WorkspaceDescriptorPayload>>;
+    private applyAgentBucketContributions;
+    private applyTerminalContributions;
     private resolveStatusEnteredAt;
-    private findNewestAgentTimestampInBucket;
-    resolveRegisteredWorkspaceIdForCwd(cwd: string, workspaces: PersistedWorkspaceRecord[]): string;
+    private findNewestTimestampInBucket;
+    listEmptyProjects(): Promise<WorkspaceProjectDescriptor[]>;
     listDescriptors(): Promise<WorkspaceDescriptorPayload[]>;
     matchesFilter(input: {
         workspace: WorkspaceDescriptorPayload;
@@ -68,6 +85,7 @@ export declare class WorkspaceDirectory {
     }): boolean;
     listFetchEntries(request: FetchWorkspacesRequestMessage): Promise<{
         entries: FetchWorkspacesResponseEntry[];
+        emptyProjects: WorkspaceProjectDescriptor[];
         pageInfo: FetchWorkspacesResponsePageInfo;
     }>;
 }