@camerontaylor/paseo-server 0.8.0-fork.1

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

@@ -0,0 +1,155 @@
+import path from "node:path";
+import { statSync } from "node:fs";
+import { classifyDirectoryForProjectMembership } from "./workspace-registry-bootstrap-legacy.js";
+import { generateWorkspaceId } from "./workspace-registry-model.js";
+import { backfillWorkspaceIdForLegacyAgents } from "./migrations/backfill-workspace-id.migration.js";
+import { createPersistedProjectRecord, createPersistedWorkspaceRecord, } from "./workspace-registry.js";
+import { pinPaseoWorktreeBranchIdentityIfMissing } from "../utils/worktree-metadata.js";
+function minIsoDate(left, right) {
+    if (!left) {
+        return right;
+    }
+    if (!right) {
+        return left;
+    }
+    return Date.parse(left) <= Date.parse(right) ? left : right;
+}
+function maxIsoDate(left, right) {
+    if (!left) {
+        return right;
+    }
+    if (!right) {
+        return left;
+    }
+    return Date.parse(left) >= Date.parse(right) ? left : right;
+}
+function resolveAgentCreatedAt(record) {
+    return record.createdAt || record.updatedAt || new Date(0).toISOString();
+}
+function resolveAgentUpdatedAt(record) {
+    return record.lastActivityAt || record.updatedAt || record.createdAt || new Date(0).toISOString();
+}
+export async function bootstrapWorkspaceRegistries(options) {
+    const [projectsExists, workspacesExists] = await Promise.all([
+        options.projectRegistry.existsOnDisk(),
+        options.workspaceRegistry.existsOnDisk(),
+    ]);
+    await Promise.all([options.projectRegistry.initialize(), options.workspaceRegistry.initialize()]);
+    // COMPAT(worktree-branch-identity): added in v0.4.0 on 2026-08-15; remove after
+    // 2027-02-15. Older worktrees did not pin branch-off/check-out branch identity.
+    // Seed it from the registry value clients already display, never from live Git.
+    for (const workspace of await options.workspaceRegistry.list()) {
+        if (workspace.archivedAt ||
+            !workspace.isPaseoOwnedWorktree ||
+            !workspace.worktreeRoot ||
+            !workspace.branch) {
+            continue;
+        }
+        try {
+            pinPaseoWorktreeBranchIdentityIfMissing(workspace.worktreeRoot, workspace.branch);
+        }
+        catch (error) {
+            options.logger.warn({ err: error, workspaceId: workspace.workspaceId }, "Failed to pin legacy worktree branch identity; PR association remains disabled");
+        }
+    }
+    if (projectsExists && workspacesExists) {
+        await backfillWorkspaceIdForLegacyAgents(options);
+        return;
+    }
+    const existingWorkspaceIdsByCwd = new Map((await options.workspaceRegistry.list()).map((workspace) => [
+        path.resolve(workspace.cwd),
+        workspace.workspaceId,
+    ]));
+    const records = await options.agentStorage.list();
+    // A legacy agent can outlive its working directory. Reconciliation treats a
+    // missing directory as absent rather than asking Git about it; bootstrap must
+    // do the same before materializing its first workspace record.
+    const activeRecords = records.filter((record) => {
+        if (record.archivedAt)
+            return false;
+        try {
+            return statSync(record.cwd).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    });
+    const recordsByDirectoryKey = new Map();
+    const placements = await Promise.all(activeRecords.map(async (record) => {
+        const normalizedCwd = path.resolve(record.cwd);
+        const checkout = await options.workspaceGitService.getCheckout(normalizedCwd);
+        const membership = classifyDirectoryForProjectMembership({
+            cwd: normalizedCwd,
+            checkout,
+            serverId: options.serverId,
+        });
+        return { record, membership, directoryKey: membership.workspaceDirectoryKey };
+    }));
+    for (const { record, membership, directoryKey } of placements) {
+        const existing = recordsByDirectoryKey.get(directoryKey) ?? { membership, records: [] };
+        existing.records.push(record);
+        recordsByDirectoryKey.set(directoryKey, existing);
+    }
+    const projectRanges = new Map();
+    const workspaceUpsertInputs = [];
+    for (const entry of recordsByDirectoryKey.values()) {
+        const { membership, records: workspaceRecords } = entry;
+        const workspaceCwd = membership.checkout.cwd;
+        let workspaceCreatedAt = null;
+        let workspaceUpdatedAt = null;
+        for (const record of workspaceRecords) {
+            workspaceCreatedAt = minIsoDate(workspaceCreatedAt, resolveAgentCreatedAt(record));
+            workspaceUpdatedAt = maxIsoDate(workspaceUpdatedAt, resolveAgentUpdatedAt(record));
+        }
+        const createdAt = workspaceCreatedAt ?? new Date().toISOString();
+        const updatedAt = workspaceUpdatedAt ?? createdAt;
+        const existingProjectRange = projectRanges.get(membership.projectKey) ?? {
+            createdAt: null,
+            updatedAt: null,
+        };
+        existingProjectRange.createdAt = minIsoDate(existingProjectRange.createdAt, createdAt);
+        existingProjectRange.updatedAt = maxIsoDate(existingProjectRange.updatedAt, updatedAt);
+        projectRanges.set(membership.projectKey, existingProjectRange);
+        workspaceUpsertInputs.push({
+            workspaceId: existingWorkspaceIdsByCwd.get(workspaceCwd) ?? generateWorkspaceId(),
+            membership,
+            workspaceCwd,
+            createdAt,
+            updatedAt,
+        });
+    }
+    await Promise.all(workspaceUpsertInputs.flatMap(({ workspaceId, membership, workspaceCwd, createdAt, updatedAt }) => {
+        const projectRange = projectRanges.get(membership.projectKey) ?? {
+            createdAt: null,
+            updatedAt: null,
+        };
+        return [
+            options.workspaceRegistry.upsert(createPersistedWorkspaceRecord({
+                workspaceId,
+                projectId: membership.projectId,
+                cwd: workspaceCwd,
+                kind: membership.workspaceKind,
+                displayName: membership.workspaceDisplayName,
+                createdAt,
+                updatedAt,
+            })),
+            options.projectRegistry.upsert(createPersistedProjectRecord({
+                projectId: membership.projectId,
+                rootPath: membership.projectRootPath,
+                kind: membership.projectKind,
+                displayName: membership.projectName,
+                projectKey: membership.projectKey,
+                createdAt: projectRange.createdAt ?? createdAt,
+                updatedAt: projectRange.updatedAt ?? updatedAt,
+            })),
+        ];
+    }));
+    await backfillWorkspaceIdForLegacyAgents(options);
+    options.logger.info({
+        projectsFile: path.join(options.paseoHome, "projects", "projects.json"),
+        workspacesFile: path.join(options.paseoHome, "projects", "workspaces.json"),
+        materializedProjects: projectRanges.size,
+        materializedWorkspaces: recordsByDirectoryKey.size,
+    }, "Workspace registries bootstrapped from existing agent storage");
+}
+//# sourceMappingURL=workspace-registry-bootstrap.js.map

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

@@ -0,0 +1,56 @@
+import type { ProjectCheckoutLitePayload, ProjectPlacementPayload } from "@camerontaylor/paseo-protocol/messages";
+import type { PersistedWorkspaceRecord } from "./workspace-registry.js";
+export type PersistedProjectKind = "git" | "non_git";
+export type PersistedWorkspaceKind = "local_checkout" | "worktree" | "directory";
+export declare function generateWorkspaceId(): string;
+export declare function generateProjectId(): string;
+export declare function deriveProjectKind(checkout: ProjectCheckoutLitePayload): PersistedProjectKind;
+export declare function deriveWorkspaceKind(checkout: ProjectCheckoutLitePayload): PersistedWorkspaceKind;
+export declare function deriveWorkspaceDisplayName(input: {
+    cwd: string;
+    checkout: ProjectCheckoutLitePayload;
+}): string;
+export type PersistedWorkspacePlacement = Pick<PersistedWorkspaceRecord, "cwd" | "kind" | "displayName" | "branch" | "worktreeRoot" | "baseBranch" | "isPaseoOwnedWorktree" | "mainRepoRoot">;
+export type MutableWorkspacePlacement = Pick<PersistedWorkspaceRecord, "kind" | "branch" | "worktreeRoot" | "isPaseoOwnedWorktree" | "mainRepoRoot">;
+export type InitialWorkspacePlacementInput = {
+    source: "checkout";
+    cwd: string;
+    checkout: ProjectCheckoutLitePayload;
+} | {
+    source: "created_worktree";
+    cwd: string;
+    worktreeRoot: string;
+    branch: string | null;
+    baseBranch: string | null;
+    mainRepoRoot: string;
+};
+export interface WorkspacePlacementUpdate {
+    workspace: PersistedWorkspaceRecord;
+    fields: Partial<MutableWorkspacePlacement>;
+}
+/** Defines the complete persisted placement for every new workspace. */
+export declare function initialWorkspacePlacement(input: InitialWorkspacePlacementInput): PersistedWorkspacePlacement;
+/**
+ * Applies live placement facts without rewriting the workspace's durable name
+ * or its creation-time base branch.
+ */
+export declare function reconcileWorkspacePlacement(input: {
+    workspace: PersistedWorkspaceRecord;
+    checkout: ProjectCheckoutLitePayload;
+    updatedAt: string;
+}): WorkspacePlacementUpdate | null;
+/** Projects persisted placement onto the checkout shape sent over the wire. */
+export declare function checkoutFromPersistedWorkspacePlacement(input: {
+    workspace: PersistedWorkspaceRecord;
+    fallbackBranch?: string | null;
+    fallbackWorktreeRoot?: string | null;
+}): ProjectPlacementPayload["checkout"];
+export declare function checkoutLiteFromGitSnapshot(cwd: string, git: {
+    isGit: boolean;
+    currentBranch: string | null;
+    remoteUrl: string | null;
+    repoRoot: string | null;
+    isPaseoOwnedWorktree: boolean;
+    mainRepoRoot: string | null;
+}): ProjectCheckoutLitePayload;
+//# sourceMappingURL=workspace-registry-model.d.ts.map

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

@@ -0,0 +1,150 @@
+import { randomBytes } from "node:crypto";
+export function generateWorkspaceId() {
+    return `wks_${randomBytes(8).toString("hex")}`;
+}
+export function generateProjectId() {
+    return `prj_${randomBytes(8).toString("hex")}`;
+}
+export function deriveProjectKind(checkout) {
+    return checkout.isGit ? "git" : "non_git";
+}
+export function deriveWorkspaceKind(checkout) {
+    if (!checkout.isGit) {
+        return "directory";
+    }
+    return checkout.mainRepoRoot ? "worktree" : "local_checkout";
+}
+export function deriveWorkspaceDisplayName(input) {
+    const branch = input.checkout.currentBranch?.trim() ?? null;
+    if (branch && branch.toUpperCase() !== "HEAD")
+        return branch;
+    const segments = input.cwd.replace(/\\/g, "/").split("/").filter(Boolean);
+    return segments[segments.length - 1] ?? input.cwd;
+}
+/** Defines the complete persisted placement for every new workspace. */
+export function initialWorkspacePlacement(input) {
+    if (input.source === "created_worktree") {
+        return {
+            cwd: input.cwd,
+            kind: "worktree",
+            displayName: input.branch || input.cwd,
+            branch: input.branch,
+            worktreeRoot: input.worktreeRoot,
+            baseBranch: input.baseBranch,
+            isPaseoOwnedWorktree: true,
+            mainRepoRoot: input.mainRepoRoot,
+        };
+    }
+    const branch = normalizeBranch(input.checkout.currentBranch);
+    return {
+        cwd: input.cwd,
+        kind: deriveWorkspaceKind(input.checkout),
+        displayName: deriveWorkspaceDisplayName(input),
+        branch,
+        worktreeRoot: input.checkout.isGit ? (input.checkout.worktreeRoot ?? input.cwd) : null,
+        baseBranch: null,
+        isPaseoOwnedWorktree: input.checkout.isGit && input.checkout.isPaseoOwnedWorktree,
+        mainRepoRoot: input.checkout.isGit ? input.checkout.mainRepoRoot : null,
+    };
+}
+/**
+ * Applies live placement facts without rewriting the workspace's durable name
+ * or its creation-time base branch.
+ */
+export function reconcileWorkspacePlacement(input) {
+    const observed = initialWorkspacePlacement({
+        source: "checkout",
+        cwd: input.workspace.cwd,
+        checkout: input.checkout,
+    });
+    const fields = {};
+    if (input.workspace.kind !== observed.kind)
+        fields.kind = observed.kind;
+    if (input.workspace.branch !== observed.branch)
+        fields.branch = observed.branch;
+    if (input.workspace.worktreeRoot !== observed.worktreeRoot)
+        fields.worktreeRoot = observed.worktreeRoot;
+    if (input.workspace.isPaseoOwnedWorktree !== observed.isPaseoOwnedWorktree)
+        fields.isPaseoOwnedWorktree = observed.isPaseoOwnedWorktree;
+    if (input.workspace.mainRepoRoot !== observed.mainRepoRoot)
+        fields.mainRepoRoot = observed.mainRepoRoot;
+    if (Object.keys(fields).length === 0)
+        return null;
+    return {
+        workspace: { ...input.workspace, ...fields, updatedAt: input.updatedAt },
+        fields,
+    };
+}
+/** Projects persisted placement onto the checkout shape sent over the wire. */
+export function checkoutFromPersistedWorkspacePlacement(input) {
+    const { workspace } = input;
+    if (workspace.kind === "directory") {
+        return {
+            cwd: workspace.cwd,
+            isGit: false,
+            currentBranch: null,
+            remoteUrl: null,
+            worktreeRoot: null,
+            isPaseoOwnedWorktree: false,
+            mainRepoRoot: null,
+        };
+    }
+    const checkout = {
+        cwd: workspace.cwd,
+        currentBranch: workspace.branch ?? input.fallbackBranch ?? null,
+        remoteUrl: null,
+        worktreeRoot: workspace.worktreeRoot ?? input.fallbackWorktreeRoot ?? workspace.cwd,
+    };
+    if (workspace.isPaseoOwnedWorktree && workspace.mainRepoRoot) {
+        return {
+            ...checkout,
+            isGit: true,
+            isPaseoOwnedWorktree: true,
+            mainRepoRoot: workspace.mainRepoRoot,
+        };
+    }
+    return {
+        ...checkout,
+        isGit: true,
+        isPaseoOwnedWorktree: false,
+        mainRepoRoot: workspace.mainRepoRoot ?? null,
+    };
+}
+function normalizeBranch(branch) {
+    const normalized = branch?.trim() ?? null;
+    return normalized && normalized.toUpperCase() !== "HEAD" ? normalized : null;
+}
+export function checkoutLiteFromGitSnapshot(cwd, git) {
+    if (!git.isGit) {
+        return {
+            cwd,
+            isGit: false,
+            currentBranch: null,
+            remoteUrl: null,
+            worktreeRoot: null,
+            isPaseoOwnedWorktree: false,
+            mainRepoRoot: null,
+        };
+    }
+    if (git.isPaseoOwnedWorktree && git.mainRepoRoot) {
+        return {
+            cwd,
+            isGit: true,
+            currentBranch: git.currentBranch,
+            remoteUrl: git.remoteUrl,
+            worktreeRoot: git.repoRoot ?? cwd,
+            isPaseoOwnedWorktree: true,
+            mainRepoRoot: git.mainRepoRoot,
+        };
+    }
+    return {
+        cwd,
+        isGit: true,
+        currentBranch: git.currentBranch,
+        remoteUrl: git.remoteUrl,
+        worktreeRoot: git.repoRoot ?? cwd,
+        isPaseoOwnedWorktree: false,
+        mainRepoRoot: git.mainRepoRoot,
+    };
+}
+//# sourceMappingURL=workspace-registry-model.js.map

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

@@ -0,0 +1,228 @@
+import type { Logger } from "pino";
+import { z } from "zod";
+import { type PersistedProjectKind, type PersistedWorkspaceKind } from "./workspace-registry-model.js";
+import type { UntrustedWorkspaceSource } from "./workspace-automation-gate.js";
+declare const PersistedProjectRecordSchema: z.ZodObject<{
+    projectId: z.ZodString;
+    rootPath: z.ZodString;
+    kind: z.ZodEnum<{
+        git: "git";
+        non_git: "non_git";
+    }>;
+    displayName: z.ZodString;
+    projectKey: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | null, string | null | undefined>>;
+    customName: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | null, string | null | undefined>>;
+    customIconRevision: 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>;
+}, z.core.$strip>;
+declare const PersistedWorkspaceRecordSchema: z.ZodObject<{
+    workspaceId: z.ZodString;
+    projectId: z.ZodString;
+    cwd: z.ZodString;
+    kind: z.ZodEnum<{
+        local_checkout: "local_checkout";
+        worktree: "worktree";
+        directory: "directory";
+    }>;
+    displayName: z.ZodString;
+    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>>;
+    worktreeRoot: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    baseBranch: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | null, string | null | undefined>>;
+    isPaseoOwnedWorktree: z.ZodDefault<z.ZodBoolean>;
+    mainRepoRoot: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    archivedAt: z.ZodNullable<z.ZodString>;
+    autoArchivedChangeRequestUrl: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | null, string | null | undefined>>;
+    pinnedAt: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | null, string | null | undefined>>;
+    labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    untrustedSource: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodLiteral<"change_request">;
+        forge: z.ZodString;
+        number: z.ZodNumber;
+        headRepository: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PersistedProjectRecord = z.infer<typeof PersistedProjectRecordSchema>;
+export type PersistedWorkspaceRecord = z.infer<typeof PersistedWorkspaceRecordSchema>;
+export interface WorkspaceMutation {
+    kind: "upsert" | "archive" | "remove";
+    workspaceId: string;
+    workspace: PersistedWorkspaceRecord | null;
+    expectsInitialAgent?: boolean;
+}
+export interface WorkspaceMutationContext {
+    expectsInitialAgent?: boolean;
+}
+export interface WorkspaceArchiveContext {
+    autoArchivedChangeRequestUrl?: string;
+}
+export interface ProjectMutation {
+    kind: "upsert" | "archive" | "remove";
+    projectId: string;
+    project: PersistedProjectRecord | null;
+}
+export interface ProjectRegistry {
+    initialize(): Promise<void>;
+    existsOnDisk(): Promise<boolean>;
+    list(): Promise<PersistedProjectRecord[]>;
+    get(projectId: string): Promise<PersistedProjectRecord | null>;
+    getOrCreateActiveByRoot(input: {
+        rootPath: string;
+        kind: PersistedProjectKind;
+        displayName: string;
+        projectKey?: string;
+        timestamp: string;
+    }): Promise<PersistedProjectRecord>;
+    upsert(record: PersistedProjectRecord): Promise<void>;
+    update(projectId: string, updater: (record: PersistedProjectRecord) => PersistedProjectRecord): Promise<PersistedProjectRecord | null>;
+    archive(projectId: string, archivedAt: string): Promise<void>;
+    remove(projectId: string): Promise<void>;
+    /** Central lifecycle seam for daemon-global project observers. */
+    subscribeToMutations?(listener: (mutation: ProjectMutation) => void | Promise<void>): () => void;
+}
+export interface WorkspaceRegistry {
+    initialize(): Promise<void>;
+    existsOnDisk(): Promise<boolean>;
+    list(): Promise<PersistedWorkspaceRecord[]>;
+    get(workspaceId: string): Promise<PersistedWorkspaceRecord | null>;
+    update(workspaceId: string, updater: (record: PersistedWorkspaceRecord) => PersistedWorkspaceRecord): Promise<PersistedWorkspaceRecord | null>;
+    upsert(record: PersistedWorkspaceRecord, context?: WorkspaceMutationContext): Promise<void>;
+    archive(workspaceId: string, archivedAt: string, context?: WorkspaceArchiveContext): Promise<void>;
+    remove(workspaceId: string): Promise<void>;
+    /** Central lifecycle seam for daemon-global workspace observers. */
+    subscribeToMutations?(listener: (mutation: WorkspaceMutation) => void | Promise<void>): () => void;
+}
+type RegistryRecord = PersistedProjectRecord | PersistedWorkspaceRecord;
+declare class FileBackedRegistry<TRecord extends RegistryRecord> {
+    private readonly filePath;
+    protected readonly logger: Logger;
+    private readonly schema;
+    private readonly getId;
+    private loaded;
+    private readonly cache;
+    private mutationQueue;
+    private mutationsBlockedUntilRestart;
+    private readonly writeRecords;
+    constructor(options: {
+        filePath: string;
+        logger: Logger;
+        schema: z.ZodType<TRecord, unknown>;
+        getId: (record: TRecord) => string;
+        component: string;
+        writeRecords?: (filePath: string, records: readonly TRecord[]) => Promise<void>;
+    });
+    initialize(): Promise<void>;
+    existsOnDisk(): Promise<boolean>;
+    list(): Promise<TRecord[]>;
+    get(id: string): Promise<TRecord | null>;
+    upsert(record: TRecord): Promise<void>;
+    update(id: string, updater: (record: TRecord) => TRecord): Promise<TRecord | null>;
+    archive(id: string, archivedAt: string): Promise<void>;
+    protected archiveIfPresent(id: string, archivedAt: string): Promise<TRecord | null>;
+    protected archiveIfActive(id: string, archivedAt: string): Promise<TRecord | null>;
+    remove(id: string): Promise<void>;
+    protected removeIfPresent(id: string): Promise<TRecord | null>;
+    private load;
+    protected mutateMany(updater: (records: ReadonlyMap<string, TRecord>) => readonly TRecord[]): Promise<TRecord[]>;
+    protected mutateCache<TResult>(updater: (records: Map<string, TRecord>) => TResult, hooks?: {
+        forcePersist?: (result: TResult) => boolean;
+        beforeWrite?: (records: readonly TRecord[]) => Promise<void>;
+        afterWrite?: () => Promise<void>;
+        afterCommit?: () => void;
+    }): Promise<TResult>;
+    protected freezeMutationsUntilRestart(): void;
+}
+export declare class FileBackedProjectRegistry extends FileBackedRegistry<PersistedProjectRecord> implements ProjectRegistry {
+    private allocationQueue;
+    private readonly projectIdFactory;
+    private readonly mutationListeners;
+    constructor(filePath: string, logger: Logger, options?: {
+        projectIdFactory?: () => string;
+        writeRecords?: (filePath: string, records: readonly PersistedProjectRecord[]) => Promise<void>;
+    });
+    getOrCreateActiveByRoot(input: {
+        rootPath: string;
+        kind: PersistedProjectKind;
+        displayName: string;
+        projectKey?: string;
+        timestamp: string;
+    }): Promise<PersistedProjectRecord>;
+    subscribeToMutations(listener: (mutation: {
+        kind: "upsert" | "archive" | "remove";
+        projectId: string;
+        project: PersistedProjectRecord | null;
+    }) => void | Promise<void>): () => void;
+    upsert(record: PersistedProjectRecord): Promise<void>;
+    update(projectId: string, updater: (record: PersistedProjectRecord) => PersistedProjectRecord): Promise<PersistedProjectRecord | null>;
+    archive(projectId: string, archivedAt: string): Promise<void>;
+    remove(projectId: string): Promise<void>;
+    private notifyMutation;
+}
+export declare class FileBackedWorkspaceRegistry extends FileBackedRegistry<PersistedWorkspaceRecord> implements WorkspaceRegistry {
+    private readonly mutationListeners;
+    constructor(filePath: string, logger: Logger, options?: {
+        writeRecords?: (filePath: string, records: readonly PersistedWorkspaceRecord[]) => Promise<void>;
+    });
+    subscribeToMutations(listener: (mutation: WorkspaceMutation) => void | Promise<void>): () => void;
+    update(workspaceId: string, updater: (record: PersistedWorkspaceRecord) => PersistedWorkspaceRecord): Promise<PersistedWorkspaceRecord | null>;
+    upsert(record: PersistedWorkspaceRecord, context?: WorkspaceMutationContext): Promise<void>;
+    archive(workspaceId: string, archivedAt: string, context?: WorkspaceArchiveContext): Promise<void>;
+    remove(workspaceId: string): Promise<void>;
+    commitWorkspaceLabelMutation<TResult>(input: {
+        stage: (records: ReadonlyMap<string, PersistedWorkspaceRecord>) => {
+            updates: readonly PersistedWorkspaceRecord[];
+            result: TResult;
+            forcePersist: boolean;
+        };
+        beforeWorkspaceWrite: (records: readonly PersistedWorkspaceRecord[]) => Promise<void>;
+        afterWorkspaceWrite: () => Promise<void>;
+        afterCommit: () => void;
+        publish?: boolean;
+    }): Promise<TResult>;
+    blockAllMutationsUntilRestart(): void;
+    private notifyMutation;
+}
+export declare function createPersistedProjectRecord(input: {
+    projectId: string;
+    rootPath: string;
+    kind: PersistedProjectKind;
+    displayName: string;
+    customName?: string | null;
+    projectKey?: string | null;
+    customIconRevision?: string | null;
+    createdAt: string;
+    updatedAt: string;
+    archivedAt?: string | null;
+}): PersistedProjectRecord;
+export declare function resolveProjectDisplayName(record: PersistedProjectRecord): string;
+export declare function createPersistedWorkspaceRecord(input: {
+    workspaceId: string;
+    projectId: string;
+    cwd: string;
+    kind: PersistedWorkspaceKind;
+    displayName: string;
+    title?: string | null;
+    branch?: string | null;
+    worktreeRoot?: string | null;
+    baseBranch?: string | null;
+    isPaseoOwnedWorktree?: boolean;
+    mainRepoRoot?: string | null;
+    createdAt: string;
+    updatedAt: string;
+    archivedAt?: string | null;
+    autoArchivedChangeRequestUrl?: string | null;
+    pinnedAt?: string | null;
+    labels?: string[];
+    untrustedSource?: UntrustedWorkspaceSource;
+}): PersistedWorkspaceRecord;
+export declare function resolveWorkspaceName(input: {
+    title: string | null;
+    derivedDisplayName: string;
+}): string;
+export declare function resolveWorkspaceDisplayName(record: PersistedWorkspaceRecord): string;
+export {};
+//# sourceMappingURL=workspace-registry.d.ts.map