@getpaseo/server 0.1.101 → 0.1.102

package/dist/server/server/process-diagnostics.d.ts

@@ -0,0 +1,17 @@
+export interface ProcessMemoryDiagnostics {
+    rss: number;
+    heapTotal: number;
+    heapUsed: number;
+    external: number;
+    arrayBuffers: number;
+}
+export interface ProcessDiagnostics {
+    pid: number;
+    ppid: number;
+    uptimeSeconds: number;
+    memory: ProcessMemoryDiagnostics;
+}
+export declare function getProcessMemoryDiagnostics(): ProcessMemoryDiagnostics;
+export declare function getProcessUptimeSeconds(): number;
+export declare function getProcessDiagnostics(): ProcessDiagnostics;
+//# sourceMappingURL=process-diagnostics.d.ts.map

package/dist/server/server/process-diagnostics.js

@@ -0,0 +1,22 @@
+export function getProcessMemoryDiagnostics() {
+    const memory = process.memoryUsage();
+    return {
+        rss: memory.rss,
+        heapTotal: memory.heapTotal,
+        heapUsed: memory.heapUsed,
+        external: memory.external,
+        arrayBuffers: memory.arrayBuffers,
+    };
+}
+export function getProcessUptimeSeconds() {
+    return Math.round(process.uptime() * 1000) / 1000;
+}
+export function getProcessDiagnostics() {
+    return {
+        pid: process.pid,
+        ppid: process.ppid,
+        uptimeSeconds: getProcessUptimeSeconds(),
+        memory: getProcessMemoryDiagnostics(),
+    };
+}
+//# sourceMappingURL=process-diagnostics.js.map

package/dist/server/server/relay-transport.js

@@ -335,6 +335,7 @@ export function startRelayTransport({ logger, attachSocket, relayEndpoint, relay
             const externalMetadata = {
                 transport: "relay",
                 externalSessionKey: `session:${connectionId}`,
+                relayConnectionId: connectionId,
             };
             if (daemonKeyPair) {
                 void attachEncryptedSocket(socket, daemonKeyPair, relayLogger.child({ connectionId }), attachSocket, externalMetadata);

package/dist/server/server/resolve-worktree-creation-intent.js

@@ -64,9 +64,10 @@ async function resolveGitHubPrCheckoutIntent(params) {
     const baseRefName = checkoutTarget?.baseRefName?.trim() ||
         (await resolveDefaultBranch(params.repoRoot, params.deps));
     const localBranchName = buildGitHubPrLocalBranchName({ headRef, checkoutTarget });
-    const pushRemoteUrl = checkoutTarget
+    const pushRemoteUrl = checkoutTarget?.isCrossRepository
         ? checkoutTarget.headRepositorySshUrl || checkoutTarget.headRepositoryUrl || undefined
         : undefined;
+    const trackOriginHead = checkoutTarget ? !checkoutTarget.isCrossRepository : false;
     return {
         kind: "checkout-github-pr",
         githubPrNumber: params.githubPrNumber,
@@ -74,6 +75,7 @@ async function resolveGitHubPrCheckoutIntent(params) {
         baseRefName,
         ...(localBranchName !== headRef ? { localBranchName } : {}),
         ...(pushRemoteUrl ? { pushRemoteUrl } : {}),
+        ...(trackOriginHead ? { trackOriginHead } : {}),
     };
 }
 async function resolveGitHubPrCheckoutTarget(params) {

package/dist/server/server/session/daemon/daemon-self-update-session-controller.d.ts

@@ -0,0 +1,32 @@
+import type pino from "pino";
+import type { SessionInboundMessage, SessionOutboundMessage } from "../../messages.js";
+import { type DaemonSelfUpdater } from "./daemon-self-updater.js";
+interface DaemonSelfUpdateRestartIntent {
+    type: "restart";
+    clientId: string;
+    requestId: string;
+    reason: string;
+}
+export interface DaemonSelfUpdateSessionControllerOptions {
+    clientId: string;
+    daemonVersion: string | null;
+    emit: (msg: SessionOutboundMessage) => void;
+    emitLifecycleIntent: (intent: DaemonSelfUpdateRestartIntent) => void;
+    sessionLogger: pino.Logger;
+    updater?: Pick<DaemonSelfUpdater, "update">;
+}
+export declare class DaemonSelfUpdateSessionController {
+    private readonly clientId;
+    private readonly daemonVersion;
+    private readonly emit;
+    private readonly emitLifecycleIntent;
+    private readonly sessionLogger;
+    private readonly updater;
+    constructor(options: DaemonSelfUpdateSessionControllerOptions);
+    dispatch(msg: SessionInboundMessage): Promise<void> | undefined;
+    private handleDaemonUpdateRequest;
+    private emitProgress;
+    private emitResponse;
+}
+export {};
+//# sourceMappingURL=daemon-self-update-session-controller.d.ts.map

package/dist/server/server/session/daemon/daemon-self-update-session-controller.js

@@ -0,0 +1,88 @@
+import { daemonSelfUpdater, DaemonSelfUpdateInProgressError, } from "./daemon-self-updater.js";
+import { getErrorMessage } from "@getpaseo/protocol/error-utils";
+const DAEMON_SELF_UPDATE_MESSAGE_TYPES = new Set([
+    "daemon.update.request",
+]);
+function isDaemonSelfUpdateMessage(msg) {
+    return DAEMON_SELF_UPDATE_MESSAGE_TYPES.has(msg.type);
+}
+export class DaemonSelfUpdateSessionController {
+    constructor(options) {
+        this.clientId = options.clientId;
+        this.daemonVersion = options.daemonVersion;
+        this.emit = options.emit;
+        this.emitLifecycleIntent = options.emitLifecycleIntent;
+        this.sessionLogger = options.sessionLogger;
+        this.updater = options.updater ?? daemonSelfUpdater;
+    }
+    dispatch(msg) {
+        if (!isDaemonSelfUpdateMessage(msg)) {
+            return undefined;
+        }
+        return this.handleDaemonUpdateRequest(msg);
+    }
+    async handleDaemonUpdateRequest(msg) {
+        const previousVersion = this.daemonVersion;
+        try {
+            const result = await this.updater.update({
+                daemonVersion: previousVersion,
+                onProgress: (phase) => this.emitProgress(msg.requestId, phase),
+                logger: this.sessionLogger,
+            });
+            this.emitResponse({
+                requestId: msg.requestId,
+                success: result.success,
+                error: result.error,
+                previousVersion,
+                newVersion: result.newVersion,
+            });
+            if (!result.success) {
+                return;
+            }
+            this.emitLifecycleIntent({
+                type: "restart",
+                clientId: this.clientId,
+                requestId: msg.requestId,
+                reason: "daemon_update",
+            });
+        }
+        catch (error) {
+            if (error instanceof DaemonSelfUpdateInProgressError) {
+                this.emit({
+                    type: "rpc_error",
+                    payload: {
+                        requestId: msg.requestId,
+                        requestType: "daemon.update.request",
+                        error: error.message,
+                        code: "already_updating",
+                    },
+                });
+                return;
+            }
+            this.sessionLogger.error({ err: error }, "Daemon update failed with exception");
+            this.emitResponse({
+                requestId: msg.requestId,
+                success: false,
+                error: getErrorMessage(error),
+                previousVersion,
+                newVersion: null,
+            });
+        }
+    }
+    emitProgress(requestId, phase) {
+        this.emit({
+            type: "daemon.update.progress",
+            payload: {
+                requestId,
+                phase,
+            },
+        });
+    }
+    emitResponse(payload) {
+        this.emit({
+            type: "daemon.update.response",
+            payload,
+        });
+    }
+}
+//# sourceMappingURL=daemon-self-update-session-controller.js.map

package/dist/server/server/session/daemon/daemon-self-updater.d.ts

@@ -0,0 +1,32 @@
+import { type DaemonInstallOriginRuntime } from "./install-origin.js";
+import { type NpmGlobalPaseoCli } from "./npm-global-cli.js";
+export type DaemonSelfUpdatePhase = "starting" | "downloading" | "installing" | "complete";
+export interface DaemonSelfUpdateResult {
+    success: boolean;
+    error: string | null;
+    newVersion: string | null;
+}
+export interface DaemonSelfUpdateInput {
+    daemonVersion: string | null;
+    onProgress: (phase: DaemonSelfUpdatePhase) => void;
+    logger: DaemonSelfUpdateLogger;
+}
+export interface DaemonSelfUpdateLogger {
+    error(obj: object, msg?: string): void;
+    warn(obj: object, msg?: string): void;
+}
+export interface DaemonSelfUpdateRuntime {
+    npm: NpmGlobalPaseoCli;
+    installOrigin: DaemonInstallOriginRuntime;
+}
+export declare class DaemonSelfUpdateInProgressError extends Error {
+    constructor();
+}
+export declare class DaemonSelfUpdater {
+    private readonly runtime;
+    private inProgress;
+    constructor(runtime?: DaemonSelfUpdateRuntime);
+    update(input: DaemonSelfUpdateInput): Promise<DaemonSelfUpdateResult>;
+}
+export declare const daemonSelfUpdater: DaemonSelfUpdater;
+//# sourceMappingURL=daemon-self-updater.d.ts.map

package/dist/server/server/session/daemon/daemon-self-updater.js

@@ -0,0 +1,56 @@
+import { getErrorMessage } from "@getpaseo/protocol/error-utils";
+import { daemonInstallOriginRuntime, validateDaemonInstallOrigin, } from "./install-origin.js";
+import { npmGlobalPaseoCli } from "./npm-global-cli.js";
+export class DaemonSelfUpdateInProgressError extends Error {
+    constructor() {
+        super("An update is already in progress");
+        this.name = "DaemonSelfUpdateInProgressError";
+    }
+}
+const defaultRuntime = {
+    npm: npmGlobalPaseoCli,
+    installOrigin: daemonInstallOriginRuntime,
+};
+export class DaemonSelfUpdater {
+    constructor(runtime = defaultRuntime) {
+        this.runtime = runtime;
+        this.inProgress = false;
+    }
+    async update(input) {
+        if (this.inProgress) {
+            throw new DaemonSelfUpdateInProgressError();
+        }
+        this.inProgress = true;
+        try {
+            input.onProgress("starting");
+            const install = await this.runtime.npm.inspect();
+            const unsupportedReason = validateDaemonInstallOrigin(install, input.daemonVersion, this.runtime.installOrigin);
+            if (unsupportedReason) {
+                return { success: false, error: unsupportedReason, newVersion: null };
+            }
+            input.onProgress("downloading");
+            input.onProgress("installing");
+            const result = await this.runtime.npm.installLatest();
+            if (result.exitCode !== 0) {
+                const error = result.stderr.trim() || result.stdout.trim() || `npm exited with code ${result.exitCode}`;
+                input.logger.error({ exitCode: result.exitCode, stderr: result.stderr }, "Daemon self-update failed");
+                return { success: false, error, newVersion: null };
+            }
+            const updatedInstall = await this.runtime.npm.inspect().catch((error) => {
+                input.logger.warn({ err: error }, "Unable to read updated npm package version");
+                return null;
+            });
+            input.onProgress("complete");
+            return { success: true, error: null, newVersion: updatedInstall?.version ?? null };
+        }
+        catch (error) {
+            input.logger.error({ err: error }, "Daemon self-update failed with exception");
+            return { success: false, error: getErrorMessage(error), newVersion: null };
+        }
+        finally {
+            this.inProgress = false;
+        }
+    }
+}
+export const daemonSelfUpdater = new DaemonSelfUpdater();
+//# sourceMappingURL=daemon-self-updater.js.map

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

@@ -17,9 +17,16 @@ export interface DaemonRuntimeConfig {
 }
 export interface DaemonSessionHost {
     emit(msg: SessionOutboundMessage): void;
+    emitLifecycleIntent(intent: {
+        type: "restart";
+        clientId: string;
+        requestId: string;
+        reason: string;
+    }): void;
 }
 export interface DaemonSessionOptions {
     host: DaemonSessionHost;
+    clientId: string;
     paseoHome: string;
     serverId: string | undefined;
     daemonVersion: string | undefined;
@@ -40,6 +47,7 @@ export interface DaemonSessionOptions {
  */
 export declare class DaemonSession {
     private readonly host;
+    private readonly clientId;
     private readonly paseoHome;
     private readonly serverId;
     private readonly daemonVersion;
@@ -50,6 +58,7 @@ export declare class DaemonSession {
     private readonly listProviderAvailability;
     private readonly getWebSocketRuntimeMetrics;
     private readonly logger;
+    private readonly selfUpdate;
     constructor(options: DaemonSessionOptions);
     handleGetStatusRequest(msg: Extract<SessionInboundMessage, {
         type: "daemon.get_status.request";
@@ -60,5 +69,8 @@ export declare class DaemonSession {
     handleDiagnosticsRequest(msg: Extract<SessionInboundMessage, {
         type: "diagnostics.request";
     }>): Promise<void>;
+    handleUpdateRequest(msg: Extract<SessionInboundMessage, {
+        type: "daemon.update.request";
+    }>): Promise<void>;
 }
 //# sourceMappingURL=daemon-session.d.ts.map

package/dist/server/server/session/daemon/daemon-session.js

@@ -1,6 +1,7 @@
 import { getPidLockInfo } from "../../pid-lock.js";
 import { generateLocalPairingOffer } from "../../pairing-offer.js";
 import { collectDaemonDiagnostics, } from "./diagnostics.js";
+import { DaemonSelfUpdateSessionController } from "./daemon-self-update-session-controller.js";
 /**
  * A client's read surface for the daemon process itself: its runtime status
  * (pid-lock start time, listen address, relay config, provider availability) and
@@ -11,6 +12,7 @@ import { collectDaemonDiagnostics, } from "./diagnostics.js";
 export class DaemonSession {
     constructor(options) {
         this.host = options.host;
+        this.clientId = options.clientId;
         this.paseoHome = options.paseoHome;
         this.serverId = options.serverId;
         this.daemonVersion = options.daemonVersion;
@@ -21,6 +23,13 @@ export class DaemonSession {
         this.listProviderAvailability = options.listProviderAvailability;
         this.getWebSocketRuntimeMetrics = options.getWebSocketRuntimeMetrics ?? (() => null);
         this.logger = options.logger;
+        this.selfUpdate = new DaemonSelfUpdateSessionController({
+            clientId: this.clientId,
+            daemonVersion: this.daemonVersion ?? null,
+            emit: (msg) => this.host.emit(msg),
+            emitLifecycleIntent: (intent) => this.host.emitLifecycleIntent(intent),
+            sessionLogger: this.logger,
+        });
     }
     async handleGetStatusRequest(msg) {
         try {
@@ -132,5 +141,8 @@ export class DaemonSession {
             });
         }
     }
+    async handleUpdateRequest(msg) {
+        await this.selfUpdate.dispatch(msg);
+    }
 }
 //# sourceMappingURL=daemon-session.js.map

package/dist/server/server/session/daemon/diagnostics.js

@@ -154,6 +154,16 @@ function collectWebSocketRuntimeEntries(options) {
     return [
         { label: "Collected at", value: snapshot.collectedAt },
         { label: "Window", value: formatDurationMs(snapshot.windowMs) },
+        { label: "Process uptime", value: formatDurationMs(snapshot.uptimeSeconds * 1000) },
+        {
+            label: "Process memory",
+            value: [
+                `rss=${formatBytes(snapshot.memory.rss)}`,
+                `heap=${formatBytes(snapshot.memory.heapUsed)} / ${formatBytes(snapshot.memory.heapTotal)}`,
+                `external=${formatBytes(snapshot.memory.external)}`,
+                `arrayBuffers=${formatBytes(snapshot.memory.arrayBuffers)}`,
+            ].join(", "),
+        },
         { label: "Final", value: String(snapshot.final) },
         {
             label: "Sessions",

package/dist/server/server/session/daemon/install-origin.d.ts

@@ -0,0 +1,7 @@
+import { type NpmGlobalPaseoInstall } from "./npm-global-cli.js";
+export interface DaemonInstallOriginRuntime {
+    resolveCurrentServerPackageRoot(): string | null;
+}
+export declare const daemonInstallOriginRuntime: DaemonInstallOriginRuntime;
+export declare function validateDaemonInstallOrigin(install: NpmGlobalPaseoInstall, daemonVersion: string | null, runtime?: DaemonInstallOriginRuntime): string | null;
+//# sourceMappingURL=install-origin.d.ts.map

package/dist/server/server/session/daemon/install-origin.js

@@ -0,0 +1,64 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { z } from "zod";
+import { isRealpathInsideRoot } from "../../../utils/path.js";
+import { PASEO_CLI_PACKAGE } from "./npm-global-cli.js";
+const PackageJsonSchema = z.object({ name: z.string().optional() }).passthrough();
+export const daemonInstallOriginRuntime = {
+    resolveCurrentServerPackageRoot,
+};
+export function validateDaemonInstallOrigin(install, daemonVersion, runtime = daemonInstallOriginRuntime) {
+    if (install.isLinked) {
+        return `The global ${PASEO_CLI_PACKAGE} install is linked; self-update only supports normal npm global installs.`;
+    }
+    if (daemonVersion && install.version !== daemonVersion) {
+        return `This daemon is not running from the npm global ${PASEO_CLI_PACKAGE} install (global npm has ${install.version}, daemon is ${daemonVersion}).`;
+    }
+    const currentServerPackageRoot = runtime.resolveCurrentServerPackageRoot();
+    if (!currentServerPackageRoot) {
+        return "Unable to verify that this daemon is running from an npm global install.";
+    }
+    if (!isCurrentServerUnderNpmInstall(currentServerPackageRoot, install)) {
+        return `This daemon is not running from the npm global ${PASEO_CLI_PACKAGE} install.`;
+    }
+    return null;
+}
+function isCurrentServerUnderNpmInstall(currentServerPackageRoot, install) {
+    const roots = install.globalRootPath
+        ? [install.packagePath, globalNodeModulesPath(install.globalRootPath)]
+        : [install.packagePath];
+    return roots.some((root) => isRealpathInsideRoot(root, currentServerPackageRoot));
+}
+function globalNodeModulesPath(globalRootPath) {
+    const normalized = path.normalize(globalRootPath);
+    return path.basename(normalized) === "node_modules"
+        ? normalized
+        : path.join(normalized, "node_modules");
+}
+function resolveCurrentServerPackageRoot() {
+    return resolvePackageRootFrom(fileURLToPath(import.meta.url), "@getpaseo/server");
+}
+function resolvePackageRootFrom(startPath, packageName) {
+    let currentDir = path.dirname(startPath);
+    while (true) {
+        const packageJsonPath = path.join(currentDir, "package.json");
+        if (existsSync(packageJsonPath)) {
+            try {
+                const packageJson = PackageJsonSchema.parse(JSON.parse(readFileSync(packageJsonPath, "utf8")));
+                if (packageJson.name === packageName) {
+                    return currentDir;
+                }
+            }
+            catch {
+                return null;
+            }
+        }
+        const parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir) {
+            return null;
+        }
+        currentDir = parentDir;
+    }
+}
+//# sourceMappingURL=install-origin.js.map

package/dist/server/server/session/daemon/npm-global-cli.d.ts

@@ -0,0 +1,29 @@
+export declare const PASEO_CLI_PACKAGE = "@getpaseo/cli";
+export interface CommandOptions {
+    timeout?: number;
+    maxBuffer?: number;
+}
+export interface CommandResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+export interface NpmGlobalPaseoInstall {
+    version: string;
+    packagePath: string;
+    globalRootPath: string | null;
+    isLinked: boolean;
+}
+export interface NpmGlobalPaseoCli {
+    inspect(): Promise<NpmGlobalPaseoInstall>;
+    installLatest(): Promise<CommandResult>;
+}
+export type CommandRunner = (command: string, args: string[], options?: CommandOptions) => Promise<CommandResult>;
+export declare class DefaultNpmGlobalPaseoCli implements NpmGlobalPaseoCli {
+    private readonly runCommand;
+    constructor(runCommand?: CommandRunner);
+    inspect(): Promise<NpmGlobalPaseoInstall>;
+    installLatest(): Promise<CommandResult>;
+}
+export declare const npmGlobalPaseoCli: DefaultNpmGlobalPaseoCli;
+//# sourceMappingURL=npm-global-cli.d.ts.map

package/dist/server/server/session/daemon/npm-global-cli.js

@@ -0,0 +1,98 @@
+import { getErrorMessage } from "@getpaseo/protocol/error-utils";
+import { z } from "zod";
+import { execCommand } from "../../../utils/spawn.js";
+export const PASEO_CLI_PACKAGE = "@getpaseo/cli";
+const NPM_PROBE_TIMEOUT_MS = 10000;
+const NPM_INSTALL_TIMEOUT_MS = 300000;
+const NPM_MAX_BUFFER_BYTES = 10 * 1024 * 1024;
+const NpmGlobalListSchema = z
+    .object({
+    path: z.string().optional(),
+    dependencies: z.record(z.string(), z.unknown()).optional(),
+})
+    .passthrough();
+const NpmGlobalCliPackageSchema = z
+    .object({
+    version: z.string(),
+    path: z.string(),
+    link: z.boolean().optional(),
+})
+    .passthrough();
+const CommandErrorSchema = z
+    .object({
+    code: z.union([z.number(), z.string()]).optional(),
+    stdout: z.string().optional(),
+    stderr: z.string().optional(),
+})
+    .passthrough();
+async function runExternalCommand(command, args, options) {
+    try {
+        const { stdout, stderr } = await execCommand(command, args, {
+            timeout: options?.timeout,
+            maxBuffer: options?.maxBuffer,
+        });
+        return { exitCode: 0, stdout, stderr };
+    }
+    catch (error) {
+        const parsed = CommandErrorSchema.safeParse(error);
+        if (!parsed.success) {
+            return { exitCode: 1, stdout: "", stderr: getErrorMessage(error) };
+        }
+        return {
+            exitCode: typeof parsed.data.code === "number" ? parsed.data.code : 1,
+            stdout: parsed.data.stdout ?? "",
+            stderr: parsed.data.stderr || getErrorMessage(error),
+        };
+    }
+}
+function parseNpmGlobalPaseoInstall(stdout) {
+    let parsedJson;
+    try {
+        parsedJson = JSON.parse(stdout);
+    }
+    catch {
+        return null;
+    }
+    const list = NpmGlobalListSchema.safeParse(parsedJson);
+    if (!list.success) {
+        return null;
+    }
+    const rawCliPackage = list.data.dependencies?.[PASEO_CLI_PACKAGE];
+    const cliPackage = NpmGlobalCliPackageSchema.safeParse(rawCliPackage);
+    if (!cliPackage.success) {
+        return null;
+    }
+    return {
+        version: cliPackage.data.version,
+        packagePath: cliPackage.data.path,
+        globalRootPath: list.data.path ?? null,
+        isLinked: cliPackage.data.link === true,
+    };
+}
+export class DefaultNpmGlobalPaseoCli {
+    constructor(runCommand = runExternalCommand) {
+        this.runCommand = runCommand;
+    }
+    async inspect() {
+        const result = await this.runCommand("npm", ["-g", "ls", PASEO_CLI_PACKAGE, "--json", "--depth=0", "--long"], {
+            timeout: NPM_PROBE_TIMEOUT_MS,
+            maxBuffer: NPM_MAX_BUFFER_BYTES,
+        });
+        if (result.exitCode !== 0 && result.stdout.trim().length === 0) {
+            throw new Error(result.stderr.trim() || "npm is not available on this host");
+        }
+        const install = parseNpmGlobalPaseoInstall(result.stdout);
+        if (!install) {
+            throw new Error(`${PASEO_CLI_PACKAGE} is not installed with npm -g on this host`);
+        }
+        return install;
+    }
+    installLatest() {
+        return this.runCommand("npm", ["install", "-g", `${PASEO_CLI_PACKAGE}@latest`], {
+            timeout: NPM_INSTALL_TIMEOUT_MS,
+            maxBuffer: NPM_MAX_BUFFER_BYTES,
+        });
+    }
+}
+export const npmGlobalPaseoCli = new DefaultNpmGlobalPaseoCli();
+//# sourceMappingURL=npm-global-cli.js.map

package/dist/server/server/session/provider/provider-catalog-session.js

@@ -1,5 +1,5 @@
 import { getErrorMessage } from "@getpaseo/protocol/error-utils";
-import { resolveSnapshotCwd, } from "../../agent/provider-snapshot-manager.js";
+import { isGlobalProviderSnapshotKey, } from "../../agent/provider-snapshot-manager.js";
 import { expandTilde } from "../../../utils/path.js";
 // COMPAT(customModeIcons): the only mode icons known to clients before v0.1.84. Any
 // other icon name is downgraded to "ShieldCheck" for those clients.
@@ -28,7 +28,7 @@ export class ProviderCatalogSession {
         const handleProviderSnapshotChange = (entries, cwd) => {
             // COMPAT(providersSnapshot): keep provider visibility gating for older clients.
             const visibleEntries = entries.filter((entry) => this.host.isProviderVisibleToClient(entry.provider));
-            const snapshotCwd = cwd === resolveSnapshotCwd() ? undefined : cwd;
+            const snapshotCwd = isGlobalProviderSnapshotKey(cwd) ? undefined : cwd;
             this.host.emit({
                 type: "providers_snapshot_update",
                 payload: {
@@ -77,7 +77,7 @@ export class ProviderCatalogSession {
         }
     }
     async handleListProviderModelsRequest(msg) {
-        const cwd = resolveSnapshotCwd(msg.cwd ? expandTilde(msg.cwd) : undefined);
+        const cwd = resolveCatalogRequestCwd(msg.cwd);
         const fetchedAt = new Date().toISOString();
         const entry = await this.getProviderSnapshotEntryForRead(cwd, msg.provider);
         if (!entry) {
@@ -124,7 +124,7 @@ export class ProviderCatalogSession {
     }
     async handleListProviderModesRequest(msg) {
         const fetchedAt = new Date().toISOString();
-        const cwd = resolveSnapshotCwd(msg.cwd ? expandTilde(msg.cwd) : undefined);
+        const cwd = resolveCatalogRequestCwd(msg.cwd);
         const entry = await this.getProviderSnapshotEntryForRead(cwd, msg.provider);
         if (!entry) {
             this.host.emit({
@@ -336,4 +336,8 @@ export class ProviderCatalogSession {
         }
     }
 }
+function resolveCatalogRequestCwd(cwd) {
+    const trimmed = cwd?.trim();
+    return trimmed ? expandTilde(trimmed) : undefined;
+}
 //# sourceMappingURL=provider-catalog-session.js.map

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

@@ -110,11 +110,12 @@ export type SessionLifecycleIntent = {
     type: "shutdown";
     clientId: string;
     requestId: string;
+    reason: string;
 } | {
     type: "restart";
     clientId: string;
     requestId: string;
-    reason?: string;
+    reason: string;
 };
 /**
  * Session represents a single connected client session.
@@ -227,7 +228,6 @@ export declare class Session {
     private isProviderVisibleToClient;
     private buildProjectPlacementForWorkspace;
     private buildProjectPlacementForWorkspaceId;
-    private buildProjectPlacementForExistingWorkspaceProject;
     /**
      * Main entry point for processing session messages
      */
@@ -236,6 +236,7 @@ export declare class Session {
     private dispatchVoiceAndControlMessage;
     private dispatchAgentRewindMessage;
     private dispatchAgentRelationshipMessage;
+    private dispatchAgentTimelineMessage;
     private dispatchAgentLifecycleMessage;
     private dispatchAgentConfigMessage;
     private dispatchCheckoutMessage;
@@ -245,6 +246,7 @@ export declare class Session {
     private dispatchChatScheduleLoopMessage;
     private dispatchMiscMessage;
     resetPeakInflight(): void;
+    getSessionId(): string;
     handleBinaryFrame(binaryFrame: BinaryFrame): Promise<void>;
     private handleRestartServerRequest;
     private handleShutdownServerRequest;
@@ -276,7 +278,6 @@ export declare class Session {
     private scheduleAutoNameWorkspaceBranchForFirstAgent;
     private maybeAutoNameWorkspaceBranchForFirstAgent;
     private applyGeneratedWorkspaceTitle;
-    private writeInitialWorkspaceTitleIfUntitled;
     private generateWorkspaceTitleFromContext;
     private maybeAutoNameDirectoryWorkspaceTitle;
     private scheduleAutoNameLocalWorkspaceTitleForFirstAgent;
@@ -374,6 +375,7 @@ export declare class Session {
     private selectProjectedTimelineProjection;
     private selectTimelineProjection;
     private handleFetchAgentTimelineRequest;
+    private handleAgentForkContextRequest;
     private handleSendAgentMessageRequest;
     private handleWaitForFinish;
     /**