@getpaseo/server 0.1.97-beta.3 → 0.1.97

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

@@ -213,7 +213,7 @@ export const PersistedConfigSchema = z
             // localhost service proxying remains always enabled.
             enabled: z.boolean().optional(),
             listen: z.string().optional(),
-            publicBaseUrl: z.string().url().optional(),
+            publicBaseUrl: z.url().optional(),
         })
             .strict()
             .optional(),

package/dist/server/server/pid-lock.d.ts

@@ -6,21 +6,7 @@ export declare const pidLockInfoSchema: z.ZodObject<{
     uid: z.ZodNumber;
     listen: z.ZodNullable<z.ZodString>;
     desktopManaged: z.ZodOptional<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    hostname: string;
-    uid: number;
-    startedAt: string;
-    listen: string | null;
-    pid: number;
-    desktopManaged?: boolean | undefined;
-}, {
-    hostname: string;
-    uid: number;
-    startedAt: string;
-    listen: string | null;
-    pid: number;
-    desktopManaged?: boolean | undefined;
-}>;
+}, z.core.$strip>;
 export interface PidLockInfo extends z.infer<typeof pidLockInfoSchema> {
 }
 export declare class PidLockError extends Error {

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

@@ -278,6 +278,7 @@ export declare class Session {
     private resolveWorkspaceDirectory;
     private buildProjectPlacementForWorkspace;
     private buildProjectPlacementForWorkspaceId;
+    private buildProjectPlacementForExistingWorkspaceProject;
     private forwardAgentUpdate;
     /**
      * Main entry point for processing session messages
@@ -312,6 +313,7 @@ export declare class Session {
     private unarchiveAgentByHandle;
     private handleUpdateAgentRequest;
     private handleProjectRenameRequest;
+    private handleProjectRemoveRequest;
     private handleWorkspaceTitleSetRequest;
     private toVoiceFeatureUnavailableContext;
     private resolveModeReadinessState;
@@ -484,6 +486,8 @@ export declare class Session {
     private createWorkspaceForDirectory;
     private reclassifyOrUnarchiveWorkspaceForDirectory;
     private resolveProjectRecordForPlacement;
+    private unarchiveOwningWorkspaceForAgent;
+    private recreateOwningWorktreeForRestore;
     private ensureWorkspaceRecordUnarchived;
     private createPaseoWorktree;
     private listActiveWorkspaceRefs;
@@ -492,6 +496,8 @@ export declare class Session {
     private reconcileAndEmitWorkspaceUpdates;
     private reconcileActiveWorkspaceRecords;
     private emitWorkspaceUpdatesForWorkspaceIds;
+    private recordWorkspaceGitDescriptorState;
+    private buildWorkspaceRemoveUpdatePayload;
     private resolveEmptyProjectForArchivedWorkspace;
     private emitWorkspaceUpdateForTerminalContribution;
     private emitWorkspaceUpdateForCwd;

package/dist/server/server/session.js

@@ -2,7 +2,7 @@ import equal from "fast-deep-equal";
 import { v4 as uuidv4 } from "uuid";
 import { realpathSync } from "node:fs";
 import { stat } from "node:fs/promises";
-import { resolve, sep } from "path";
+import { basename, normalize, resolve, sep } from "path";
 import { homedir } from "node:os";
 import { z } from "zod";
 import { CLIENT_CAPS } from "@getpaseo/protocol/client-capabilities";
@@ -50,7 +50,7 @@ import { isVoicePermissionAllowed } from "./voice-permission-policy.js";
 import { listDirectoryEntries, readExplorerFile, readExplorerFileBytes, getDownloadableFileInfo, } from "./file-explorer/service.js";
 import { readPaseoConfigForEdit, writePaseoConfigForEdit, } from "../utils/paseo-config-file.js";
 import { buildMetadataPrompt } from "../utils/build-metadata-prompt.js";
-import { archivePersistedWorkspaceRecord } from "./workspace-archive-service.js";
+import { archivePersistedWorkspaceRecord, archiveWorkspaceContents, } from "./workspace-archive-service.js";
 import { WorkspaceReconciliationService } from "./workspace-reconciliation-service.js";
 import { checkoutResolvedBranch, commitChanges, mergeToBase, mergeFromBase, pullCurrentBranch, pushCurrentBranch, createPullRequest, renameCurrentBranch as renameCurrentBranchDefault, } from "../utils/checkout-git.js";
 import { validateBranchSlug } from "@getpaseo/protocol/branch-slug";
@@ -70,7 +70,9 @@ import { attemptFirstAgentBranchAutoName, createLocalCheckoutWorkspace, createPa
 import { generateBranchNameFromFirstAgentContext, } from "./worktree-branch-name-generator.js";
 import { assertSafeGitRef as assertWorktreeSafeGitRef, buildAgentSessionConfig as buildWorktreeAgentSessionConfig, createPaseoWorktreeWorkflow as createWorktreeWorkflow, handleCreatePaseoWorktreeRequest as handleCreateWorktreeRequest, handlePaseoWorktreeArchiveRequest as handleWorktreeArchiveRequest, handlePaseoWorktreeListRequest as handleWorktreeListRequest, handleWorkspaceSetupStatusRequest as handleWorkspaceSetupStatusRequestMessage, } from "./worktree-session.js";
 import { archiveByScope } from "./workspace-archive-service.js";
-import { toWorktreeWireError } from "./worktree-errors.js";
+import { WorktreeRequestError, toWorktreeRequestError, toWorktreeWireError, } from "./worktree-errors.js";
+import { createWorktree } from "../utils/worktree.js";
+import { runGitCommand } from "../utils/run-git-command.js";
 import { CreateAgentLifecycleDispatch } from "./agent/create-agent-lifecycle-dispatch.js";
 const WORKSPACE_GIT_WATCH_REMOVED_STATE_KEY = "__removed__";
 async function resolveKnownProjectRootForConfig(input) {
@@ -223,7 +225,7 @@ const PCM_BITS_PER_SAMPLE = 16;
 const PCM_BYTES_PER_MS = (PCM_SAMPLE_RATE * PCM_CHANNELS * (PCM_BITS_PER_SAMPLE / 8)) / 1000;
 const MIN_STREAMING_SEGMENT_DURATION_MS = 1000;
 const MIN_STREAMING_SEGMENT_BYTES = Math.round(PCM_BYTES_PER_MS * MIN_STREAMING_SEGMENT_DURATION_MS);
-const AgentIdSchema = z.string().uuid();
+const AgentIdSchema = z.guid();
 const nodeSessionFileSystem = {
     async isDirectory(path) {
         const stats = await stat(path).catch(() => null);
@@ -382,12 +384,7 @@ export class Session {
             hasBinaryChannel: () => this.onBinaryMessage !== null,
             isPathWithinRoot: (rootPath, candidatePath) => this.isPathWithinRoot(rootPath, candidatePath),
             sessionLogger: this.sessionLogger,
-            listTerminalWorkspaceRoots: async () => {
-                const workspaces = await this.workspaceRegistry.list();
-                return workspaces
-                    .filter((workspace) => !workspace.archivedAt)
-                    .map((workspace) => workspace.cwd);
-            },
+            listTerminalWorkspaceRefs: () => this.listActiveWorkspaceRefs(),
             clientSupportsWrapReflow: () => this.clientCapabilities.has(CLIENT_CAPS.terminalReflowableSnapshot),
             getClientBufferedAmount: () => this.getTransportBufferedAmount(),
         });
@@ -911,6 +908,7 @@ export class Session {
         return {
             projectKey: project.projectId,
             projectName: resolveProjectDisplayName(project),
+            workspaceName: resolveWorkspaceDisplayName(workspace),
             checkout,
         };
     }
@@ -920,6 +918,15 @@ export class Session {
             return null;
         return this.buildProjectPlacementForWorkspace(workspace);
     }
+    async buildProjectPlacementForExistingWorkspaceProject(workspaceId) {
+        const workspace = await this.workspaceRegistry.get(workspaceId);
+        if (!workspace)
+            return null;
+        const project = await this.projectRegistry.get(workspace.projectId);
+        if (!project)
+            return null;
+        return this.buildProjectPlacementForWorkspace(workspace, project);
+    }
     async forwardAgentUpdate(agent) {
         try {
             const subscription = this.agentUpdatesSubscription;
@@ -1345,6 +1352,8 @@ export class Session {
                 return this.handleOpenProjectRequest(msg);
             case "archive_workspace_request":
                 return this.handleArchiveWorkspaceRequest(msg);
+            case "project.remove.request":
+                return this.handleProjectRemoveRequest(msg);
             case "workspace.create.request":
                 return this.handleWorkspaceCreateRequest(msg);
             case "workspace.clear_attention.request":
@@ -1764,6 +1773,80 @@ export class Session {
             });
         }
     }
+    async handleProjectRemoveRequest(request) {
+        const { projectId, requestId } = request;
+        this.sessionLogger.info({ projectId, requestId }, "session: project.remove.request");
+        try {
+            const projectWorkspaces = (await this.workspaceRegistry.list()).filter((workspace) => workspace.projectId === projectId);
+            const activeWorkspaceIds = projectWorkspaces
+                .filter((workspace) => !workspace.archivedAt)
+                .map((workspace) => workspace.workspaceId);
+            if (activeWorkspaceIds.length > 0) {
+                this.markWorkspaceArchiving(activeWorkspaceIds, new Date().toISOString());
+                await this.emitWorkspaceUpdatesForWorkspaceIds(activeWorkspaceIds, {
+                    skipReconcile: true,
+                });
+            }
+            const removedWorkspaceIds = [];
+            try {
+                for (const workspaceId of activeWorkspaceIds) {
+                    await archiveWorkspaceContents({
+                        agentManager: this.agentManager,
+                        agentStorage: this.agentStorage,
+                        killTerminalsForWorkspace: (id) => this.terminalController.killTerminalsForWorkspace(id),
+                        sessionLogger: this.sessionLogger,
+                    }, workspaceId);
+                    await this.archiveWorkspaceRecord(workspaceId);
+                    removedWorkspaceIds.push(workspaceId);
+                }
+                await this.projectRegistry.remove(projectId);
+            }
+            finally {
+                if (activeWorkspaceIds.length > 0) {
+                    this.clearWorkspaceArchiving(activeWorkspaceIds);
+                }
+            }
+            const updateIds = removedWorkspaceIds.length > 0
+                ? removedWorkspaceIds
+                : [projectWorkspaces[0]?.workspaceId ?? projectId];
+            await this.emitWorkspaceUpdatesForWorkspaceIds(updateIds, {
+                skipReconcile: true,
+                removedProjectId: projectId,
+            });
+            this.emit({
+                type: "project.remove.response",
+                payload: {
+                    requestId,
+                    projectId,
+                    accepted: true,
+                    removedWorkspaceIds,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.sessionLogger.error({ err: error, projectId, requestId }, "session: project.remove.request error");
+            this.emit({
+                type: "activity_log",
+                payload: {
+                    id: uuidv4(),
+                    timestamp: new Date(),
+                    type: "error",
+                    content: `Failed to remove project: ${getErrorMessage(error)}`,
+                },
+            });
+            this.emit({
+                type: "project.remove.response",
+                payload: {
+                    requestId,
+                    projectId,
+                    accepted: false,
+                    removedWorkspaceIds: [],
+                    error: getErrorMessageOr(error, "Failed to remove project"),
+                },
+            });
+        }
+    }
     async handleWorkspaceTitleSetRequest(workspaceId, title, requestId) {
         this.sessionLogger.info({ workspaceId, requestId, hasTitle: typeof title === "string" }, "session: workspace.title.set.request");
         try {
@@ -2412,6 +2495,7 @@ export class Session {
         this.sessionLogger.info({ agentId }, `Refreshing agent ${agentId} from persistence`);
         try {
             await unarchiveAgentState(this.agentStorage, this.agentManager, agentId);
+            await this.unarchiveOwningWorkspaceForAgent(agentId);
             let snapshot;
             const existing = this.agentManager.getAgent(agentId);
             if (existing) {
@@ -2460,7 +2544,7 @@ export class Session {
                         requestId,
                         requestType: msg.type,
                         error: message,
-                        code: "agent_refresh_failed",
+                        code: error instanceof WorktreeRequestError ? error.code : "agent_refresh_failed",
                     },
                 });
             }
@@ -4962,7 +5046,9 @@ export class Session {
             if (existing) {
                 return existing;
             }
-            const placementPromise = this.buildProjectPlacementForWorkspaceId(workspaceId);
+            const placementPromise = request.type === "fetch_agent_history_request"
+                ? this.buildProjectPlacementForExistingWorkspaceProject(workspaceId)
+                : this.buildProjectPlacementForWorkspaceId(workspaceId);
             placementByWorkspaceId.set(workspaceId, placementPromise);
             return placementPromise;
         };
@@ -5299,6 +5385,9 @@ export class Session {
         if (input.workspace.projectId === projectId &&
             input.workspace.kind === kind &&
             input.workspace.displayName === displayName) {
+            if (!input.project) {
+                await this.projectRegistry.upsert(projectRecord);
+            }
             return this.ensureWorkspaceRecordUnarchived(input.workspace);
         }
         await this.projectRegistry.upsert(projectRecord);
@@ -5340,6 +5429,78 @@ export class Session {
             updatedAt: input.timestamp,
         };
     }
+    async unarchiveOwningWorkspaceForAgent(agentId) {
+        const record = await this.agentStorage.get(agentId);
+        if (!record?.workspaceId) {
+            return;
+        }
+        const workspace = await this.workspaceRegistry.get(record.workspaceId);
+        if (!workspace?.archivedAt) {
+            return;
+        }
+        const directoryExists = await this.filesystem.isDirectory(record.cwd).catch(() => false);
+        if (!directoryExists) {
+            if (workspace.kind !== "worktree" || !workspace.branch) {
+                return;
+            }
+            // Recreate the worktree directory from its kept branch BEFORE clearing
+            // archivedAt — the reconciler re-archives workspaces whose directory is
+            // missing, so the record must point at a real directory first.
+            await this.recreateOwningWorktreeForRestore(workspace, workspace.branch);
+        }
+        await this.ensureWorkspaceRecordUnarchived(workspace);
+        await this.emitWorkspaceUpdatesForWorkspaceIds([workspace.workspaceId]);
+    }
+    async recreateOwningWorktreeForRestore(workspace, branch) {
+        const project = await this.projectRegistry.get(workspace.projectId);
+        if (!project) {
+            throw new WorktreeRequestError({
+                code: "unknown",
+                message: `Project ${workspace.projectId} not found for workspace ${workspace.workspaceId}`,
+            });
+        }
+        const projectRootExists = await this.filesystem
+            .isDirectory(project.rootPath)
+            .catch(() => false);
+        if (!projectRootExists) {
+            throw new WorktreeRequestError({
+                code: "unknown",
+                message: `Project root is missing for ${workspace.projectId}: ${project.rootPath}`,
+            });
+        }
+        // Archiving through the default path (scope "workspace", worktreePath only)
+        // resolves repoRoot=null, so deletePaseoWorktree's `git worktree remove`/
+        // `prune` is skipped and the admin registration survives — pinning the
+        // branch as "already checked out". Prune here frees any stale registration
+        // whose working dir is missing (a no-op for live worktrees) so the recreate
+        // below succeeds regardless of how the worktree was archived.
+        try {
+            await runGitCommand(["worktree", "prune"], { cwd: project.rootPath, timeout: 30000 });
+        }
+        catch {
+            // not critical; git will prune lazily
+        }
+        let result;
+        try {
+            result = await createWorktree({
+                cwd: project.rootPath,
+                worktreeSlug: basename(workspace.cwd),
+                source: { kind: "checkout-branch", branchName: branch },
+                runSetup: false,
+                paseoHome: this.paseoHome,
+                worktreesRoot: this.worktreesRoot,
+            });
+        }
+        catch (error) {
+            throw toWorktreeRequestError(error);
+        }
+        if (normalize(result.worktreePath) !== normalize(workspace.cwd)) {
+            throw new WorktreeRequestError({
+                code: "unknown",
+                message: `Recreated worktree diverged from ${workspace.cwd}: ${result.worktreePath}`,
+            });
+        }
+    }
     async ensureWorkspaceRecordUnarchived(workspace) {
         const project = await this.projectRegistry.get(workspace.projectId);
         if (!workspace.archivedAt && (!project || !project.archivedAt)) {
@@ -5501,21 +5662,10 @@ export class Session {
                 this.shouldSkipWorkspaceGitWatchUpdate(workspaceId, nextWorkspace)) {
                 continue;
             }
-            const watchTarget = this.resolveWorkspaceGitWatchTarget(workspaceId);
-            if (watchTarget && this.onBranchChanged) {
-                const newBranchName = nextWorkspace?.name ?? null;
-                if (newBranchName !== watchTarget.lastBranchName) {
-                    this.onBranchChanged(workspaceId, watchTarget.lastBranchName, newBranchName);
-                }
-            }
-            this.rememberWorkspaceGitDescriptorState(workspaceId, nextWorkspace);
+            this.recordWorkspaceGitDescriptorState(workspaceId, nextWorkspace);
             if (!nextWorkspace) {
                 subscription.lastEmittedByWorkspaceId.delete(workspaceId);
-                this.bufferOrEmitWorkspaceUpdate(subscription, {
-                    kind: "remove",
-                    id: workspaceId,
-                    ...(await this.resolveEmptyProjectForArchivedWorkspace(workspaceId)),
-                });
+                this.bufferOrEmitWorkspaceUpdate(subscription, await this.buildWorkspaceRemoveUpdatePayload(workspaceId, options?.removedProjectId));
                 continue;
             }
             const nextPayload = {
@@ -5534,6 +5684,26 @@ export class Session {
             void this.reconcileAndEmitWorkspaceUpdates();
         }
     }
+    recordWorkspaceGitDescriptorState(workspaceId, nextWorkspace) {
+        const watchTarget = this.resolveWorkspaceGitWatchTarget(workspaceId);
+        if (watchTarget && this.onBranchChanged) {
+            const newBranchName = nextWorkspace?.name ?? null;
+            if (newBranchName !== watchTarget.lastBranchName) {
+                this.onBranchChanged(workspaceId, watchTarget.lastBranchName, newBranchName);
+            }
+        }
+        this.rememberWorkspaceGitDescriptorState(workspaceId, nextWorkspace);
+    }
+    async buildWorkspaceRemoveUpdatePayload(workspaceId, removedProjectId) {
+        if (removedProjectId) {
+            return { kind: "remove", id: workspaceId, removedProjectId };
+        }
+        return {
+            kind: "remove",
+            id: workspaceId,
+            ...(await this.resolveEmptyProjectForArchivedWorkspace(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.

package/dist/server/server/speech/providers/local/sherpa/model-catalog.d.ts

@@ -45,8 +45,8 @@ export declare const LOCAL_STT_MODEL_IDS: LocalSttModelId[];
 export declare const LOCAL_TTS_MODEL_IDS: LocalTtsModelId[];
 export declare const DEFAULT_LOCAL_STT_MODEL: LocalSttModelId;
 export declare const DEFAULT_LOCAL_TTS_MODEL: "kokoro-en-v0_19";
-export declare const LocalSttModelIdSchema: z.ZodType<LocalSttModelId, z.ZodTypeDef, string>;
-export declare const LocalTtsModelIdSchema: z.ZodType<"kokoro-en-v0_19", z.ZodTypeDef, string>;
+export declare const LocalSttModelIdSchema: z.ZodType<LocalSttModelId, string, z.core.$ZodTypeInternals<LocalSttModelId, string>>;
+export declare const LocalTtsModelIdSchema: z.ZodType<"kokoro-en-v0_19", string, z.core.$ZodTypeInternals<"kokoro-en-v0_19", string>>;
 export type SherpaOnnxModelSpec = SherpaOnnxCatalogEntry & {
     id: SherpaOnnxModelId;
 };

package/dist/server/server/speech/speech-types.d.ts

@@ -1,19 +1,17 @@
 import { z } from "zod";
-export declare const SpeechProviderIdSchema: z.ZodEnum<["openai", "local"]>;
+export declare const SpeechProviderIdSchema: z.ZodEnum<{
+    local: "local";
+    openai: "openai";
+}>;
 export type SpeechProviderId = z.infer<typeof SpeechProviderIdSchema>;
 export declare const RequestedSpeechProviderSchema: z.ZodObject<{
-    provider: z.ZodEnum<["openai", "local"]>;
+    provider: z.ZodEnum<{
+        local: "local";
+        openai: "openai";
+    }>;
     explicit: z.ZodBoolean;
     enabled: z.ZodOptional<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    provider: "local" | "openai";
-    explicit: boolean;
-    enabled?: boolean | undefined;
-}, {
-    provider: "local" | "openai";
-    explicit: boolean;
-    enabled?: boolean | undefined;
-}>;
+}, z.core.$strip>;
 export type RequestedSpeechProvider = z.infer<typeof RequestedSpeechProviderSchema>;
 export interface RequestedSpeechProviders {
     dictationStt: RequestedSpeechProvider;

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

@@ -807,6 +807,10 @@ export class VoiceAssistantWebSocketServer {
                 checkoutRefresh: true,
                 // COMPAT(workspaceMultiplicity): added in v0.1.97, drop the gate when floor >= v0.1.97
                 workspaceMultiplicity: true,
+                // COMPAT(projectRemove): added in v0.1.97, drop the gate when floor >= v0.1.97.
+                projectRemove: true,
+                // COMPAT(worktreeRestore): added in v0.1.97, drop the gate when floor >= v0.1.97
+                worktreeRestore: true,
             },
         };
     }

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

@@ -4,65 +4,33 @@ import type { PersistedProjectKind, PersistedWorkspaceKind } from "./workspace-r
 declare const PersistedProjectRecordSchema: z.ZodObject<{
     projectId: z.ZodString;
     rootPath: z.ZodString;
-    kind: z.ZodEnum<["git", "non_git"]>;
+    kind: z.ZodEnum<{
+        git: "git";
+        non_git: "non_git";
+    }>;
     displayName: z.ZodString;
-    customName: z.ZodEffects<z.ZodOptional<z.ZodNullable<z.ZodString>>, string | null, string | null | undefined>;
+    customName: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | null, string | null | undefined>>;
     createdAt: z.ZodString;
     updatedAt: z.ZodString;
     archivedAt: z.ZodNullable<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    kind: "git" | "non_git";
-    createdAt: string;
-    updatedAt: string;
-    archivedAt: string | null;
-    projectId: string;
-    displayName: string;
-    rootPath: string;
-    customName: string | null;
-}, {
-    kind: "git" | "non_git";
-    createdAt: string;
-    updatedAt: string;
-    archivedAt: string | null;
-    projectId: string;
-    displayName: string;
-    rootPath: string;
-    customName?: string | null | undefined;
-}>;
+}, z.core.$strip>;
 declare const PersistedWorkspaceRecordSchema: z.ZodObject<{
     workspaceId: z.ZodString;
     projectId: z.ZodString;
     cwd: z.ZodString;
-    kind: z.ZodEnum<["local_checkout", "worktree", "directory"]>;
+    kind: z.ZodEnum<{
+        local_checkout: "local_checkout";
+        worktree: "worktree";
+        directory: "directory";
+    }>;
     displayName: z.ZodString;
-    title: z.ZodEffects<z.ZodOptional<z.ZodNullable<z.ZodString>>, string | null, string | null | undefined>;
-    branch: z.ZodEffects<z.ZodOptional<z.ZodNullable<z.ZodString>>, string | null, string | null | undefined>;
+    title: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | null, string | null | undefined>>;
+    branch: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | null, string | null | undefined>>;
+    baseBranch: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | null, string | null | undefined>>;
     createdAt: z.ZodString;
     updatedAt: z.ZodString;
     archivedAt: z.ZodNullable<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    kind: "local_checkout" | "worktree" | "directory";
-    workspaceId: string;
-    cwd: string;
-    title: string | null;
-    createdAt: string;
-    updatedAt: string;
-    archivedAt: string | null;
-    projectId: string;
-    displayName: string;
-    branch: string | null;
-}, {
-    kind: "local_checkout" | "worktree" | "directory";
-    workspaceId: string;
-    cwd: string;
-    createdAt: string;
-    updatedAt: string;
-    archivedAt: string | null;
-    projectId: string;
-    displayName: string;
-    title?: string | null | undefined;
-    branch?: string | null | undefined;
-}>;
+}, z.core.$strip>;
 export type PersistedProjectRecord = z.infer<typeof PersistedProjectRecordSchema>;
 export type PersistedWorkspaceRecord = z.infer<typeof PersistedWorkspaceRecordSchema>;
 export interface ProjectRegistry {
@@ -95,7 +63,7 @@ declare class FileBackedRegistry<TRecord extends RegistryRecord> {
     constructor(options: {
         filePath: string;
         logger: Logger;
-        schema: z.ZodType<TRecord, z.ZodTypeDef, unknown>;
+        schema: z.ZodType<TRecord, unknown>;
         getId: (record: TRecord) => string;
         component: string;
     });
@@ -135,6 +103,7 @@ export declare function createPersistedWorkspaceRecord(input: {
     displayName: string;
     title?: string | null;
     branch?: string | null;
+    baseBranch?: string | null;
     createdAt: string;
     updatedAt: string;
     archivedAt?: string | null;

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

@@ -39,6 +39,14 @@ const PersistedWorkspaceRecordSchema = z.object({
         .nullable()
         .optional()
         .transform((value) => value ?? null),
+    // The base branch the worktree was created from (normalized like worktree.json's
+    // baseRefName). Only worktree workspaces carry a base branch; checkout-branch
+    // worktrees and directory/local_checkout workspaces leave it null.
+    baseBranch: z
+        .string()
+        .nullable()
+        .optional()
+        .transform((value) => value ?? null),
     createdAt: z.string(),
     updatedAt: z.string(),
     archivedAt: z.string().nullable(),
@@ -170,6 +178,7 @@ export function createPersistedWorkspaceRecord(input) {
         ...input,
         title: input.title ?? null,
         branch: input.branch ?? null,
+        baseBranch: input.baseBranch ?? null,
         archivedAt: input.archivedAt ?? null,
     });
 }

package/dist/server/terminal/terminal-session-controller.d.ts

@@ -9,10 +9,15 @@ export interface TerminalSessionControllerOptions {
     hasBinaryChannel: () => boolean;
     isPathWithinRoot: (rootPath: string, candidatePath: string) => boolean;
     sessionLogger: pino.Logger;
+    listTerminalWorkspaceRefs?: () => Promise<readonly TerminalWorkspaceRef[]>;
     listTerminalWorkspaceRoots?: () => Promise<readonly string[]>;
     clientSupportsWrapReflow?: () => boolean;
     getClientBufferedAmount?: () => number | null;
 }
+interface TerminalWorkspaceRef {
+    workspaceId: string;
+    cwd: string;
+}
 export interface TerminalSessionControllerMetrics {
     directorySubscriptionCount: number;
     streamSubscriptionCount: number;
@@ -24,6 +29,7 @@ export declare class TerminalSessionController {
     private readonly hasBinaryChannel;
     private readonly isPathWithinRoot;
     private readonly sessionLogger;
+    private readonly listTerminalWorkspaceRefs;
     private readonly listTerminalWorkspaceRoots;
     private readonly clientSupportsWrapReflow;
     private readonly getClientBufferedAmount;
@@ -59,6 +65,7 @@ export declare class TerminalSessionController {
     private resolveTerminalOwnerRoot;
     private isSamePath;
     private handleCreateTerminalRequest;
+    private resolveLegacyTerminalWorkspaceId;
     private handleRenameTerminalRequest;
     private handleSubscribeTerminalRequest;
     private handleUnsubscribeTerminalRequest;
@@ -74,4 +81,5 @@ export declare class TerminalSessionController {
     private allocateSlot;
     private detachStream;
 }
+export {};
 //# sourceMappingURL=terminal-session-controller.d.ts.map

package/dist/server/terminal/terminal-session-controller.js

@@ -34,7 +34,10 @@ export class TerminalSessionController {
         this.hasBinaryChannel = options.hasBinaryChannel;
         this.isPathWithinRoot = options.isPathWithinRoot;
         this.sessionLogger = options.sessionLogger;
-        this.listTerminalWorkspaceRoots = options.listTerminalWorkspaceRoots ?? (async () => []);
+        this.listTerminalWorkspaceRefs = options.listTerminalWorkspaceRefs ?? (async () => []);
+        this.listTerminalWorkspaceRoots =
+            options.listTerminalWorkspaceRoots ??
+                (async () => (await this.listTerminalWorkspaceRefs()).map((workspace) => workspace.cwd));
         this.clientSupportsWrapReflow = options.clientSupportsWrapReflow ?? (() => false);
         this.getClientBufferedAmount = options.getClientBufferedAmount ?? (() => 0);
     }
@@ -331,7 +334,8 @@ export class TerminalSessionController {
                 });
                 return;
             }
-            if (!msg.workspaceId) {
+            const workspaceId = msg.workspaceId ?? (await this.resolveLegacyTerminalWorkspaceId(msg.cwd));
+            if (!workspaceId) {
                 this.emit({
                     type: "create_terminal_response",
                     payload: {
@@ -344,7 +348,7 @@ export class TerminalSessionController {
             }
             const session = await this.terminalManager.createTerminal({
                 cwd: msg.cwd,
-                workspaceId: msg.workspaceId,
+                workspaceId,
                 name: msg.name,
                 command: msg.command,
                 args: msg.args,
@@ -378,6 +382,22 @@ export class TerminalSessionController {
             });
         }
     }
+    async resolveLegacyTerminalWorkspaceId(cwd) {
+        const workspaceRefs = await this.listTerminalWorkspaceRefs();
+        if (workspaceRefs.length === 0) {
+            return null;
+        }
+        const exactMatch = workspaceRefs.find((workspace) => this.isSamePath(workspace.cwd, cwd));
+        if (exactMatch) {
+            return exactMatch.workspaceId;
+        }
+        const ownerRoot = this.resolveTerminalOwnerRoot(cwd, workspaceRefs.map((workspace) => workspace.cwd));
+        if (!ownerRoot) {
+            return null;
+        }
+        return (workspaceRefs.find((workspace) => this.isSamePath(workspace.cwd, ownerRoot))?.workspaceId ??
+            null);
+    }
     async handleRenameTerminalRequest(msg) {
         const respond = (success, error) => {
             this.emit({