@getpaseo/server 0.1.95 → 0.1.97-beta.1

package/dist/server/server/migrations/backfill-workspace-id.migration.js

@@ -0,0 +1,60 @@
+// COMPAT(workspaceIdBackfill): one-time legacy backfill, delete after 2026-12-16
+// once floor >= the release that always stamps workspaceId at create time.
+//
+// This is the ONLY place in the codebase that maps a cwd to a workspaceId.
+// Every other code path treats a record's `workspaceId` field as authoritative
+// ownership. Legacy agent records persisted before workspaceId stamping have no
+// owner, so this migration stamps each one with the workspace that owned its
+// directory at the time it was written. It runs once at startup and writes the
+// id back to storage, after which all runtime code can assume the field exists.
+import { homedir } from "node:os";
+import { resolve, sep } from "node:path";
+// Picks the workspace that owned `cwd` for a legacy, unstamped agent record.
+// Prefers an exact-cwd workspace (oldest wins) and otherwise attributes to the
+// deepest enclosing workspace directory, never letting the home directory own
+// descendants. Used only by the one-time backfill below.
+function resolveLegacyWorkspaceOwner(cwd, workspaces) {
+    const normalizedCwd = resolve(cwd);
+    const userHome = resolve(homedir());
+    const activeWorkspaces = Array.from(workspaces).filter((workspace) => !workspace.archivedAt);
+    const exactMatches = activeWorkspaces.filter((workspace) => resolve(workspace.cwd) === normalizedCwd);
+    if (exactMatches.length > 0) {
+        return oldestWorkspace(exactMatches).workspaceId;
+    }
+    const prefixMatches = activeWorkspaces.filter((workspace) => {
+        const workspaceCwd = resolve(workspace.cwd);
+        if (workspaceCwd === userHome) {
+            return false;
+        }
+        return normalizedCwd === workspaceCwd || normalizedCwd.startsWith(`${workspaceCwd}${sep}`);
+    });
+    if (prefixMatches.length === 0) {
+        return null;
+    }
+    const deepestPrefixLength = Math.max(...prefixMatches.map((workspace) => resolve(workspace.cwd).length));
+    return oldestWorkspace(prefixMatches.filter((workspace) => resolve(workspace.cwd).length === deepestPrefixLength)).workspaceId;
+}
+function oldestWorkspace(workspaces) {
+    return workspaces.reduce((oldest, candidate) => candidate.createdAt < oldest.createdAt ? candidate : oldest);
+}
+export async function backfillWorkspaceIdForLegacyAgents(options) {
+    const workspaceRecords = await options.workspaceRegistry.list();
+    const records = await options.agentStorage.list();
+    let migrated = 0;
+    for (const record of records) {
+        if (record.workspaceId) {
+            continue;
+        }
+        const workspaceId = resolveLegacyWorkspaceOwner(record.cwd, workspaceRecords);
+        if (!workspaceId) {
+            continue;
+        }
+        await options.agentStorage.upsert({ ...record, workspaceId });
+        migrated += 1;
+    }
+    if (migrated > 0) {
+        options.logger.info({ migrated }, "Backfilled workspaceId for legacy agent records");
+    }
+    return migrated;
+}
+//# sourceMappingURL=backfill-workspace-id.migration.js.map

package/dist/server/server/paseo-worktree-service.d.ts

@@ -40,4 +40,13 @@ export declare function attemptFirstAgentBranchAutoName(options: {
     renameCurrentBranch?: typeof renameCurrentBranch;
     localBranchExists?: typeof localBranchExists;
 }): Promise<AttemptFirstAgentBranchAutoNameResult>;
+export interface CreateLocalCheckoutWorkspaceDeps {
+    projectRegistry: Pick<ProjectRegistry, "get" | "list" | "upsert">;
+    workspaceRegistry: Pick<WorkspaceRegistry, "list" | "upsert">;
+    workspaceGitService: Pick<WorkspaceGitService, "getCheckout">;
+}
+export declare function createLocalCheckoutWorkspace(options: {
+    cwd: string;
+    title?: string | null;
+}, deps: CreateLocalCheckoutWorkspaceDeps): Promise<PersistedWorkspaceRecord>;
 //# sourceMappingURL=paseo-worktree-service.d.ts.map

package/dist/server/server/paseo-worktree-service.js

@@ -1,5 +1,6 @@
+import { resolve } from "node:path";
 import { createPersistedProjectRecord, createPersistedWorkspaceRecord, } from "./workspace-registry.js";
-import { deriveProjectGroupingName, normalizeWorkspaceId } from "./workspace-registry-model.js";
+import { classifyDirectoryForProjectMembership, deriveProjectGroupingName, generateWorkspaceId, } from "./workspace-registry-model.js";
 import { createWorktreeCore, } from "./worktree-core.js";
 import { validateBranchSlug } from "../utils/worktree.js";
 import { getCurrentBranch, localBranchExists, renameCurrentBranch } from "../utils/checkout-git.js";
@@ -107,18 +108,20 @@ function maybeMarkFirstAgentBranchAutoNameEligible(options) {
     });
 }
 async function upsertWorkspaceForWorktree(options) {
-    const normalizedCwd = normalizeWorkspaceId(options.worktree.worktreePath);
-    const normalizedInputCwd = normalizeWorkspaceId(options.inputCwd);
-    const normalizedRepoRoot = normalizeWorkspaceId(options.repoRoot);
-    const existingWorkspace = await findWorkspaceByDirectory(normalizedCwd, options.deps.workspaceRegistry);
+    const normalizedCwd = resolve(options.worktree.worktreePath);
+    const normalizedInputCwd = resolve(options.inputCwd);
+    const normalizedRepoRoot = resolve(options.repoRoot);
+    // Creation never deduplicates by directory: a worktree directory may back
+    // more than one workspace. We still resolve the source project from the
+    // originating checkout, but always mint a fresh workspace record.
     const sourceProject = await resolveSourceProjectForWorktree({
         inputCwd: normalizedInputCwd,
         projectId: options.projectId,
         repoRoot: normalizedRepoRoot,
-        existingWorkspace,
+        existingWorkspace: null,
         deps: options.deps,
     });
-    const workspaceId = normalizedCwd;
+    const workspaceId = generateWorkspaceId();
     const now = new Date().toISOString();
     await options.deps.projectRegistry.upsert(createPersistedProjectRecord({
         projectId: sourceProject.projectId,
@@ -136,13 +139,73 @@ async function upsertWorkspaceForWorktree(options) {
         cwd: normalizedCwd,
         kind: "worktree",
         displayName: options.worktree.branchName || normalizedCwd,
-        createdAt: existingWorkspace?.createdAt ?? now,
+        branch: options.worktree.branchName || null,
+        createdAt: now,
         updatedAt: now,
         archivedAt: null,
     });
     await options.deps.workspaceRegistry.upsert(workspace);
     return (await options.deps.workspaceRegistry.get(workspace.workspaceId)) ?? workspace;
 }
+// Always create a NEW workspace record backed by the existing directory `cwd`.
+// Never reuses a same-cwd record: a directory may back any number of
+// workspaces. Used by explicit user creation.
+export async function createLocalCheckoutWorkspace(options, deps) {
+    const normalizedCwd = resolve(options.cwd);
+    const checkout = await deps.workspaceGitService.getCheckout(normalizedCwd);
+    const membership = classifyDirectoryForProjectMembership({ cwd: normalizedCwd, checkout });
+    const now = new Date().toISOString();
+    const projectRecord = await resolveProjectRecordForMembership({
+        membership,
+        timestamp: now,
+        projectRegistry: deps.projectRegistry,
+    });
+    await deps.projectRegistry.upsert(projectRecord);
+    const trimmedTitle = options.title?.trim();
+    // Persist the live git branch into the dedicated `branch` field so
+    // buildWorkspaceCheckout reports the real branch for directory/local_checkout
+    // workspaces too (it reads workspace.branch). Same source deriveWorkspaceDisplayName
+    // reads. HEAD/detached resolves to null — there is no branch to report.
+    const currentBranch = checkout.currentBranch?.trim() ?? null;
+    const branch = currentBranch && currentBranch.toUpperCase() !== "HEAD" ? currentBranch : null;
+    const workspace = createPersistedWorkspaceRecord({
+        workspaceId: generateWorkspaceId(),
+        projectId: projectRecord.projectId,
+        cwd: normalizedCwd,
+        kind: membership.workspaceKind,
+        displayName: membership.workspaceDisplayName,
+        branch,
+        title: trimmedTitle ? trimmedTitle : null,
+        createdAt: now,
+        updatedAt: now,
+    });
+    await deps.workspaceRegistry.upsert(workspace);
+    return workspace;
+}
+async function resolveProjectRecordForMembership(options) {
+    const rootPath = options.membership.projectRootPath;
+    const projects = await options.projectRegistry.list();
+    const existingProject = projects.find((project) => !project.archivedAt && project.rootPath === rootPath) ??
+        projects.find((project) => project.rootPath === rootPath) ??
+        null;
+    if (!existingProject) {
+        return createPersistedProjectRecord({
+            projectId: options.membership.projectKey,
+            rootPath,
+            kind: options.membership.projectKind,
+            displayName: options.membership.projectName,
+            createdAt: options.timestamp,
+            updatedAt: options.timestamp,
+        });
+    }
+    return {
+        ...existingProject,
+        rootPath,
+        kind: options.membership.projectKind,
+        archivedAt: null,
+        updatedAt: options.timestamp,
+    };
+}
 function sourceProjectFromRecord(record) {
     return {
         projectId: record.projectId,
@@ -211,8 +274,4 @@ async function findWorkspaceForSource(options) {
         workspaces.find((workspace) => workspace.cwd === options.repoRoot && !workspace.archivedAt) ??
         null);
 }
-async function findWorkspaceByDirectory(cwd, workspaceRegistry) {
-    const workspaces = await workspaceRegistry.list();
-    return workspaces.find((workspace) => workspace.cwd === cwd) ?? null;
-}
 //# sourceMappingURL=paseo-worktree-service.js.map

package/dist/server/server/path-utils.d.ts

@@ -1,3 +1,4 @@
+export declare function assertAbsolutePath(cwd: string): void;
 export declare function expandUserPath(value: string): string;
 export declare function resolvePathFromBase(baseCwd: string, requestedPath: string): string;
 export declare function isSameOrDescendantPath(basePath: string, candidatePath: string): boolean;

package/dist/server/server/path-utils.js

@@ -1,5 +1,10 @@
 import { homedir } from "node:os";
-import { isAbsolute, resolve } from "node:path";
+import { isAbsolute, posix, resolve, win32 } from "node:path";
+export function assertAbsolutePath(cwd) {
+    if (!posix.isAbsolute(cwd) && !win32.isAbsolute(cwd)) {
+        throw new Error("cwd must be absolute path");
+    }
+}
 function hasHomePrefix(value) {
     return value === "~" || value.startsWith("~/");
 }

package/dist/server/server/persisted-config.d.ts

@@ -20,6 +20,7 @@ export declare const PersistedConfigSchema: z.ZodObject<{
             injectIntoAgents: z.ZodOptional<z.ZodBoolean>;
         }, z.ZodTypeAny, "passthrough">>>;
         autoArchiveAfterMerge: z.ZodOptional<z.ZodBoolean>;
+        enableTerminalAgentHooks: z.ZodOptional<z.ZodBoolean>;
         appendSystemPrompt: z.ZodOptional<z.ZodString>;
         terminalProfiles: z.ZodOptional<z.ZodArray<z.ZodObject<{
             id: z.ZodString;
@@ -98,6 +99,7 @@ export declare const PersistedConfigSchema: z.ZodObject<{
         hostnames?: true | string[] | undefined;
         allowedHosts?: true | string[] | undefined;
         autoArchiveAfterMerge?: boolean | undefined;
+        enableTerminalAgentHooks?: boolean | undefined;
         appendSystemPrompt?: string | undefined;
         terminalProfiles?: z.objectOutputType<{
             id: z.ZodString;
@@ -133,6 +135,7 @@ export declare const PersistedConfigSchema: z.ZodObject<{
         hostnames?: true | string[] | undefined;
         allowedHosts?: true | string[] | undefined;
         autoArchiveAfterMerge?: boolean | undefined;
+        enableTerminalAgentHooks?: boolean | undefined;
         appendSystemPrompt?: string | undefined;
         terminalProfiles?: z.objectInputType<{
             id: z.ZodString;
@@ -167,6 +170,7 @@ export declare const PersistedConfigSchema: z.ZodObject<{
         listen?: string | undefined;
         hostnames?: true | string[] | undefined;
         autoArchiveAfterMerge?: boolean | undefined;
+        enableTerminalAgentHooks?: boolean | undefined;
         appendSystemPrompt?: string | undefined;
         terminalProfiles?: z.objectOutputType<{
             id: z.ZodString;
@@ -202,6 +206,7 @@ export declare const PersistedConfigSchema: z.ZodObject<{
         hostnames?: true | string[] | undefined;
         allowedHosts?: true | string[] | undefined;
         autoArchiveAfterMerge?: boolean | undefined;
+        enableTerminalAgentHooks?: boolean | undefined;
         appendSystemPrompt?: string | undefined;
         terminalProfiles?: z.objectInputType<{
             id: z.ZodString;
@@ -899,6 +904,7 @@ export declare const PersistedConfigSchema: z.ZodObject<{
         listen?: string | undefined;
         hostnames?: true | string[] | undefined;
         autoArchiveAfterMerge?: boolean | undefined;
+        enableTerminalAgentHooks?: boolean | undefined;
         appendSystemPrompt?: string | undefined;
         terminalProfiles?: z.objectOutputType<{
             id: z.ZodString;
@@ -1045,6 +1051,7 @@ export declare const PersistedConfigSchema: z.ZodObject<{
         hostnames?: true | string[] | undefined;
         allowedHosts?: true | string[] | undefined;
         autoArchiveAfterMerge?: boolean | undefined;
+        enableTerminalAgentHooks?: boolean | undefined;
         appendSystemPrompt?: string | undefined;
         terminalProfiles?: z.objectInputType<{
             id: z.ZodString;

package/dist/server/server/persisted-config.js

@@ -187,6 +187,7 @@ export const PersistedConfigSchema = z
             .passthrough()
             .optional(),
         autoArchiveAfterMerge: z.boolean().optional(),
+        enableTerminalAgentHooks: z.boolean().optional(),
         appendSystemPrompt: z.string().optional(),
         terminalProfiles: z.array(TerminalProfileSchema).optional(),
         cors: z

package/dist/server/server/persistence-hooks.d.ts

@@ -24,6 +24,7 @@ export declare function extractTimestamps(record: StoredAgentRecord): {
     updatedAt: Date;
     lastUserMessageAt: Date | null;
     labels?: Record<string, string>;
+    workspaceId?: string;
 };
 export declare function toAgentPersistenceHandle(registeredProviders: Iterable<AgentProvider>, handle: StoredAgentRecord["persistence"]): AgentPersistenceHandle | null;
 export {};

package/dist/server/server/persistence-hooks.js

@@ -2,6 +2,15 @@ import { stripInternalPaseoMcpServer } from "./agent/runtime-mcp-config.js";
 function getLogger(logger) {
     return logger.child({ module: "persistence" });
 }
+function isProviderRegistered(validProviders, provider) {
+    if (!validProviders) {
+        return true;
+    }
+    if (validProviders instanceof Set) {
+        return validProviders.has(provider);
+    }
+    return new Set(validProviders).has(provider);
+}
 /**
  * Attach AgentStorage persistence to an AgentManager instance so every
  * agent_state snapshot is flushed to disk.
@@ -35,9 +44,7 @@ export function buildConfigOverrides(record) {
     });
 }
 export function buildSessionConfig(record, options) {
-    const validProviders = options?.validProviders;
-    const isValidProvider = validProviders ? new Set(validProviders).has(record.provider) : true;
-    if (!isValidProvider) {
+    if (!isProviderRegistered(options?.validProviders, record.provider)) {
         return null;
     }
     const overrides = buildConfigOverrides(record);
@@ -54,7 +61,7 @@ export function buildSessionConfig(record, options) {
     });
 }
 export function isStoredAgentProviderAvailable(record, validProviders) {
-    return buildSessionConfig(record, { validProviders }) !== null;
+    return isProviderRegistered(validProviders, record.provider);
 }
 export function extractTimestamps(record) {
     return {
@@ -62,6 +69,7 @@ export function extractTimestamps(record) {
         updatedAt: new Date(record.lastActivityAt ?? record.updatedAt),
         lastUserMessageAt: record.lastUserMessageAt ? new Date(record.lastUserMessageAt) : null,
         labels: record.labels,
+        workspaceId: record.workspaceId,
     };
 }
 export function toAgentPersistenceHandle(registeredProviders, handle) {
@@ -69,7 +77,7 @@ export function toAgentPersistenceHandle(registeredProviders, handle) {
         return null;
     }
     const provider = handle.provider;
-    if (!new Set(registeredProviders).has(provider)) {
+    if (!isProviderRegistered(registeredProviders, provider)) {
         return null;
     }
     if (!handle.sessionId) {

package/dist/server/server/resolve-workspace-id-for-path.d.ts

@@ -0,0 +1,3 @@
+import type { PersistedWorkspaceRecord } from "./workspace-registry.js";
+export declare function resolveWorkspaceIdForPath(cwd: string, workspaces: Iterable<PersistedWorkspaceRecord>): string | null;
+//# sourceMappingURL=resolve-workspace-id-for-path.d.ts.map

package/dist/server/server/resolve-workspace-id-for-path.js

@@ -0,0 +1,41 @@
+import { homedir } from "node:os";
+import { resolve, sep } from "node:path";
+// external path→workspace adapter, not ownership.
+//
+// Resolves a raw filesystem path to a single workspace id ONLY at the boundary
+// where a client hands the daemon a bare worktree path with no id:
+// archive-by-path (old client / CLI), auto-archive-after-merge, and the MCP
+// `archive_worktree` tool. It is NEVER used to attribute agent status or place
+// agents under a workspace — those are keyed by `workspaceId`, and git facts
+// derive from a workspace's OWN cwd (id → cwd).
+//
+// Resolution: an exact directory match wins; otherwise the deepest enclosing
+// workspace directory, never the home directory; null when nothing encloses it.
+export function resolveWorkspaceIdForPath(cwd, workspaces) {
+    const workspaceRecords = Array.from(workspaces);
+    const resolvedCwd = resolve(cwd);
+    const exactMatch = workspaceRecords.find((workspace) => resolve(workspace.cwd) === resolvedCwd);
+    if (exactMatch) {
+        return exactMatch.workspaceId;
+    }
+    const userHome = resolve(homedir());
+    let bestMatchLength = 0;
+    let bestMatch = null;
+    for (const workspace of workspaceRecords) {
+        if (workspace.archivedAt)
+            continue;
+        const workspaceCwd = resolve(workspace.cwd);
+        if (workspaceCwd === userHome)
+            continue;
+        const prefix = workspaceCwd.endsWith(sep) ? workspaceCwd : `${workspaceCwd}${sep}`;
+        if (!resolvedCwd.startsWith(prefix)) {
+            continue;
+        }
+        if (workspaceCwd.length > bestMatchLength) {
+            bestMatchLength = workspaceCwd.length;
+            bestMatch = workspace;
+        }
+    }
+    return bestMatch?.workspaceId ?? null;
+}
+//# sourceMappingURL=resolve-workspace-id-for-path.js.map

package/dist/server/server/script-proxy.d.ts

@@ -1,3 +1,3 @@
-export { createScriptProxyMiddleware, createScriptProxyUpgradeHandler, findFreePort, ScriptRouteStore, } from "./service-proxy.js";
+export { createScriptProxyMiddleware, createScriptProxyUpgradeHandler, findFreePort, ScriptRouteStore, ServiceProxyRouteCollisionError, } from "./service-proxy.js";
 export type { ScriptRoute, ScriptRouteEntry } from "./service-proxy.js";
 //# sourceMappingURL=script-proxy.d.ts.map

package/dist/server/server/script-proxy.js

@@ -1,2 +1,2 @@
-export { createScriptProxyMiddleware, createScriptProxyUpgradeHandler, findFreePort, ScriptRouteStore, } from "./service-proxy.js";
+export { createScriptProxyMiddleware, createScriptProxyUpgradeHandler, findFreePort, ScriptRouteStore, ServiceProxyRouteCollisionError, } from "./service-proxy.js";
 //# sourceMappingURL=script-proxy.js.map

package/dist/server/server/service-proxy.js

@@ -187,7 +187,7 @@ function sameRouteOwner(left, right) {
 }
 export class ServiceProxyRouteCollisionError extends Error {
     constructor(hostname, existing, incoming) {
-        super(`Service proxy hostname collision for ${hostname}: ${existing.workspaceId}/${existing.scriptName} already owns it`);
+        super(`Another workspace is already serving "${incoming.scriptName}" at ${hostname}. Stop that service or run this one on a different branch to free the address.`);
         this.hostname = hostname;
         this.existing = existing;
         this.incoming = incoming;

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

@@ -16,6 +16,7 @@ import { type PersistedWorkspaceRecord, type ProjectRegistry, type WorkspaceRegi
 import { DownloadTokenStore } from "./file-download/token-store.js";
 import { PushTokenStore } from "./push/token-store.js";
 import type { ServiceProxySubsystem } from "./service-proxy.js";
+import { renameCurrentBranch as renameCurrentBranchDefault } from "../utils/checkout-git.js";
 import { CheckoutDiffManager } from "./checkout-diff-manager.js";
 import { type Resolvable } from "./speech/provider-resolver.js";
 import type { SpeechReadinessSnapshot } from "./speech/speech-runtime.js";
@@ -24,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 { generateBranchNameFromFirstAgentContext } from "./worktree-branch-name-generator.js";
 export declare function resolveWaitForFinishError(options: {
     status: "permission" | "error" | "idle";
     final: AgentSnapshotPayload | null;
@@ -44,6 +46,7 @@ export interface SessionOptions {
     clientCapabilities?: Record<string, unknown> | null;
     onMessage: (msg: SessionOutboundMessage) => void;
     onBinaryMessage?: (frame: Uint8Array) => void;
+    getTransportBufferedAmount?: () => number | null;
     onLifecycleIntent?: (intent: SessionLifecycleIntent) => void;
     logger: pino.Logger;
     downloadTokenStore: DownloadTokenStore;
@@ -61,6 +64,8 @@ export interface SessionOptions {
     checkoutDiffManager: CheckoutDiffManager;
     github?: GitHubService;
     createAgentMcpTransport?: AgentMcpTransportFactory;
+    renameCurrentBranch?: typeof renameCurrentBranchDefault;
+    generateWorkspaceName?: typeof generateBranchNameFromFirstAgentContext;
     workspaceGitService: WorkspaceGitService;
     daemonConfigStore: DaemonConfigStore;
     mcpBaseUrl?: string | null;
@@ -96,6 +101,7 @@ export interface SessionOptions {
     daemonVersion?: string;
     daemonRuntimeConfig?: {
         listen: string | null;
+        appBaseUrl?: string;
         relay: {
             enabled: boolean;
             endpoint: string;
@@ -127,6 +133,7 @@ export declare class Session {
     private readonly sessionId;
     private readonly onMessage;
     private readonly onBinaryMessage;
+    private readonly getTransportBufferedAmount;
     private readonly onLifecycleIntent;
     private readonly sessionLogger;
     private readonly paseoHome;
@@ -159,12 +166,15 @@ export declare class Session {
     private readonly loopService;
     private readonly checkoutDiffManager;
     private readonly github;
+    private readonly renameCurrentBranch;
+    private readonly generateWorkspaceName;
     private readonly workspaceGitService;
     private readonly daemonConfigStore;
     private readonly mcpBaseUrl;
     private readonly downloadTokenStore;
     private readonly pushTokenStore;
     private unsubscribeAgentEvents;
+    private unsubscribeTerminalWorkspaceContributionEvents;
     private agentUpdatesSubscription;
     private workspaceUpdatesSubscription;
     private clientActivity;
@@ -212,7 +222,6 @@ export declare class Session {
     markWorkspaceArchivingForExternalMutation(workspaceIds: Iterable<string>, archivingAt: string): void;
     clearWorkspaceArchivingForExternalMutation(workspaceIds: Iterable<string>): void;
     emitWorkspaceUpdatesForExternalWorkspaceIds(workspaceIds: Iterable<string>): Promise<void>;
-    emitWorkspaceUpdatesForExternalCwds(cwds: Iterable<string>): Promise<void>;
     warmWorkspaceGitDataForWorkspace(workspace: PersistedWorkspaceRecord): Promise<void>;
     /**
      * Get the client's current activity state
@@ -220,6 +229,7 @@ export declare class Session {
     getClientActivity(): {
         deviceType: "web" | "mobile";
         focusedAgentId: string | null;
+        focusedTerminalId: string | null;
         lastActivityAt: Date;
         appVisible: boolean;
         appVisibilityChangedAt: Date;
@@ -264,11 +274,10 @@ export declare class Session {
     private getAgentUpdateTargetId;
     private bufferOrEmitAgentUpdate;
     private flushBootstrappedAgentUpdates;
-    private findWorkspaceByDirectory;
     private findExactWorkspaceByDirectory;
     private resolveWorkspaceDirectory;
     private buildProjectPlacementForWorkspace;
-    private buildProjectPlacementForCwd;
+    private buildProjectPlacementForWorkspaceId;
     private forwardAgentUpdate;
     /**
      * Main entry point for processing session messages
@@ -303,6 +312,7 @@ export declare class Session {
     private unarchiveAgentByHandle;
     private handleUpdateAgentRequest;
     private handleProjectRenameRequest;
+    private handleWorkspaceTitleSetRequest;
     private toVoiceFeatureUnavailableContext;
     private resolveModeReadinessState;
     private getVoiceFeatureUnavailableResponseMetadata;
@@ -326,7 +336,6 @@ export declare class Session {
      * Handle create agent request
      */
     private handleCreateAgentRequest;
-    private resolveCreateAgentWorkspace;
     private handleResumeAgentRequest;
     private handleImportAgentRequest;
     private handleRefreshAgentRequest;
@@ -335,6 +344,10 @@ export declare class Session {
     private buildAgentSessionConfig;
     private scheduleAutoNameWorkspaceBranchForFirstAgent;
     private maybeAutoNameWorkspaceBranchForFirstAgent;
+    private applyGeneratedWorkspaceTitle;
+    private generateWorkspaceTitleFromContext;
+    private maybeAutoNameDirectoryWorkspaceTitle;
+    private scheduleAutoNameLocalWorkspaceTitleForFirstAgent;
     private emitProviderDisabledResponse;
     private handleListProviderModelsRequest;
     private handleListProviderModesRequest;
@@ -372,6 +385,7 @@ export declare class Session {
      * Handle client heartbeat for activity tracking
      */
     private handleClientHeartbeat;
+    private clearFocusedTerminalAttention;
     /**
      * Handle push token registration
      */
@@ -393,6 +407,7 @@ export declare class Session {
     private removeWorkspaceGitWatchTarget;
     private removeWorkspaceGitSubscription;
     private workspaceGitDescriptorStateKey;
+    private resolveWorkspaceGitWatchTarget;
     private shouldSkipWorkspaceGitWatchUpdate;
     private rememberWorkspaceGitDescriptorState;
     private handleWorkspaceGitBranchSnapshot;
@@ -437,13 +452,14 @@ export declare class Session {
      * Handle file download token request scoped to a workspace cwd
      */
     private handleFileDownloadTokenRequest;
+    private listTerminalActivityContributions;
     /**
      * Build the current agent list payload (live + persisted), optionally filtered by labels.
      */
     private listAgentPayloads;
     private resolveAgentIdentifier;
     private getAgentPayloadById;
-    private buildActiveProjectPlacementsByWorkspaceCwd;
+    private buildActiveProjectPlacementsByWorkspaceId;
     private collectFetchAgentsEntries;
     private listFetchAgentsEntries;
     private readonly agentsPager;
@@ -457,7 +473,7 @@ export declare class Session {
     markWorkspaceArchiving(workspaceIds: Iterable<string>, archivingAt: string): void;
     clearWorkspaceArchiving(workspaceIds: Iterable<string>): void;
     private buildWorkspaceDescriptorMap;
-    private resolveRegisteredWorkspaceIdForCwd;
+    private findWorkspaceIdForCwd;
     private matchesWorkspaceFilter;
     private listFetchWorkspacesEntries;
     private bufferOrEmitWorkspaceUpdate;
@@ -468,10 +484,14 @@ export declare class Session {
     private resolveProjectRecordForPlacement;
     private ensureWorkspaceRecordUnarchived;
     private createPaseoWorktree;
+    private listActiveWorkspaceRefs;
     private archiveWorkspaceRecord;
+    private teardownArchivedWorkspace;
     private reconcileAndEmitWorkspaceUpdates;
     private reconcileActiveWorkspaceRecords;
     private emitWorkspaceUpdatesForWorkspaceIds;
+    private resolveEmptyProjectForArchivedWorkspace;
+    private emitWorkspaceUpdateForTerminalContribution;
     private emitWorkspaceUpdateForCwd;
     private handleFetchAgents;
     private handleFetchAgentHistory;
@@ -479,6 +499,11 @@ export declare class Session {
     private handleFetchWorkspacesRequest;
     private buildBootstrapSnapshot;
     private registerWorkspaceForImportedAgent;
+    private handleWorkspaceCreateRequest;
+    private handleWorkspaceCreateLocal;
+    private scheduleWorkspaceNaming;
+    private handleWorkspaceCreateWorktree;
+    private resolveWorktreeSourceCwd;
     private handleOpenProjectRequest;
     private buildWorkspaceScriptPayloadSnapshot;
     private resolveWorkspaceScriptGitMetadata;