@otto-code/server 0.5.0

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

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

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

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

package/dist/server/server/workspace-auto-name.d.ts

@@ -0,0 +1,55 @@
+import type pino from "pino";
+import type { FirstAgentContext } from "@otto-code/protocol/messages";
+import type { AgentManager } from "./agent/agent-manager.js";
+import type { ProviderSnapshotManager } from "./agent/provider-snapshot-manager.js";
+import type { StructuredGenerationDaemonConfig } from "./agent/structured-generation-providers.js";
+import type { GitMutationService } from "./session/git-mutation/git-mutation-service.js";
+import type { WorkspaceGitService } from "./workspace-git-service.js";
+import type { PersistedWorkspaceRecord, WorkspaceRegistry } from "./workspace-registry.js";
+import { generateBranchNameFromFirstAgentContext, type GenerateBranchNameFromFirstAgentContextOptions } from "./worktree-branch-name-generator.js";
+type WorkspaceNameGenerator = typeof generateBranchNameFromFirstAgentContext;
+type CurrentSelection = GenerateBranchNameFromFirstAgentContextOptions["currentSelection"] | null;
+interface WorkspaceAutoNameOptions {
+    agentManager: AgentManager;
+    workspaceRegistry: Pick<WorkspaceRegistry, "get" | "upsert">;
+    workspaceGitService: WorkspaceGitService;
+    providerSnapshotManager: ProviderSnapshotManager;
+    readDaemonConfig: () => StructuredGenerationDaemonConfig;
+    gitMutation: Pick<GitMutationService, "notifyGitMutation">;
+    emitWorkspaceUpdateForCwd: (cwd: string) => Promise<void>;
+    emitWorkspaceUpdateForWorkspaceId: (workspaceId: string) => Promise<void>;
+    logger: pino.Logger;
+    generateWorkspaceName?: WorkspaceNameGenerator;
+}
+interface ScheduleContext {
+    currentSelection?: CurrentSelection;
+}
+export declare class WorkspaceAutoName {
+    private readonly agentManager;
+    private readonly workspaceRegistry;
+    private readonly workspaceGitService;
+    private readonly providerSnapshotManager;
+    private readonly readDaemonConfig;
+    private readonly gitMutation;
+    private readonly emitWorkspaceUpdateForCwd;
+    private readonly emitWorkspaceUpdateForWorkspaceId;
+    private readonly logger;
+    private readonly generateWorkspaceName;
+    constructor(options: WorkspaceAutoNameOptions);
+    scheduleForWorktree(input: {
+        workspace: PersistedWorkspaceRecord;
+        firstAgentContext: FirstAgentContext;
+    }, context?: ScheduleContext): void;
+    scheduleForDirectory(input: {
+        workspaceId: string;
+        cwd: string;
+        firstAgentContext: FirstAgentContext;
+    }, context?: ScheduleContext): void;
+    private maybeAutoNameWorkspaceBranchForFirstAgent;
+    private maybeAutoNameDirectoryWorkspaceTitle;
+    private applyGeneratedWorkspaceTitle;
+    private generateFromContext;
+    private schedule;
+}
+export {};
+//# sourceMappingURL=workspace-auto-name.d.ts.map

package/dist/server/server/workspace-auto-name.js

@@ -0,0 +1,128 @@
+import { resolveFirstAgentPromptTitle } from "./agent/create-agent-title.js";
+import { attemptFirstAgentBranchAutoName, } from "./otto-worktree-service.js";
+import { generateBranchNameFromFirstAgentContext, } from "./worktree-branch-name-generator.js";
+export class WorkspaceAutoName {
+    constructor(options) {
+        this.agentManager = options.agentManager;
+        this.workspaceRegistry = options.workspaceRegistry;
+        this.workspaceGitService = options.workspaceGitService;
+        this.providerSnapshotManager = options.providerSnapshotManager;
+        this.readDaemonConfig = options.readDaemonConfig;
+        this.gitMutation = options.gitMutation;
+        this.emitWorkspaceUpdateForCwd = options.emitWorkspaceUpdateForCwd;
+        this.emitWorkspaceUpdateForWorkspaceId = options.emitWorkspaceUpdateForWorkspaceId;
+        this.logger = options.logger;
+        this.generateWorkspaceName =
+            options.generateWorkspaceName ?? generateBranchNameFromFirstAgentContext;
+    }
+    scheduleForWorktree(input, context = {}) {
+        this.schedule(() => this.maybeAutoNameWorkspaceBranchForFirstAgent({
+            ...input,
+            currentSelection: context.currentSelection ?? null,
+        }), {
+            cwd: input.workspace.cwd,
+            message: "Failed to auto-name worktree branch",
+        });
+    }
+    scheduleForDirectory(input, context = {}) {
+        this.schedule(() => this.maybeAutoNameDirectoryWorkspaceTitle({
+            ...input,
+            currentSelection: context.currentSelection ?? null,
+        }), { cwd: input.cwd, message: "Failed to auto-name directory workspace title" });
+    }
+    async maybeAutoNameWorkspaceBranchForFirstAgent(input) {
+        let generated = null;
+        const result = await attemptFirstAgentBranchAutoName({
+            cwd: input.workspace.cwd,
+            firstAgentContext: input.firstAgentContext,
+            generateBranchNameFromContext: ({ cwd, firstAgentContext }) => {
+                return this.generateFromContext({
+                    cwd,
+                    firstAgentContext,
+                    currentSelection: input.currentSelection,
+                }).then((nextGenerated) => {
+                    generated = nextGenerated;
+                    return nextGenerated?.branch ?? null;
+                });
+            },
+        });
+        if (!generated) {
+            generated = await this.generateFromContext({
+                cwd: input.workspace.cwd,
+                firstAgentContext: input.firstAgentContext,
+                currentSelection: input.currentSelection,
+            });
+        }
+        const generatedTitle = generated?.title ?? null;
+        if (!generatedTitle) {
+            return;
+        }
+        // K4: re-read from the registry before writing so any concurrent upsert
+        // that happened between workspace creation and this async path is not clobbered.
+        // When the first-agent rename changed the git branch too, persist that branch
+        // alongside the title — both are this path's own fields.
+        await this.applyGeneratedWorkspaceTitle(input.workspace.workspaceId, {
+            title: generatedTitle,
+            ...(result.renamed ? { branch: result.branchName } : {}),
+            promptTitle: resolveFirstAgentPromptTitle(input.firstAgentContext),
+        });
+        if (result.renamed) {
+            await this.gitMutation.notifyGitMutation(input.workspace.cwd, "rename-branch");
+        }
+        await this.emitWorkspaceUpdateForCwd(input.workspace.cwd);
+    }
+    async maybeAutoNameDirectoryWorkspaceTitle(input) {
+        const generated = await this.generateFromContext({
+            cwd: input.cwd,
+            firstAgentContext: input.firstAgentContext,
+            currentSelection: input.currentSelection,
+        });
+        const title = generated?.title ?? null;
+        if (!title) {
+            return;
+        }
+        // K4: applyGeneratedWorkspaceTitle re-reads from the registry before writing.
+        // Directory workspaces have no branch — write only the title.
+        await this.applyGeneratedWorkspaceTitle(input.workspaceId, {
+            title,
+            promptTitle: resolveFirstAgentPromptTitle(input.firstAgentContext),
+        });
+        await this.emitWorkspaceUpdateForWorkspaceId(input.workspaceId);
+    }
+    async applyGeneratedWorkspaceTitle(workspaceId, input) {
+        const current = await this.workspaceRegistry.get(workspaceId);
+        if (!current) {
+            return;
+        }
+        let title = current.title;
+        if (!title || (input.promptTitle && title === input.promptTitle)) {
+            title = input.title;
+        }
+        await this.workspaceRegistry.upsert({
+            ...current,
+            title,
+            ...(input.branch ? { branch: input.branch } : {}),
+            updatedAt: new Date().toISOString(),
+        });
+    }
+    generateFromContext(input) {
+        return this.generateWorkspaceName({
+            agentManager: this.agentManager,
+            cwd: input.cwd,
+            workspaceGitService: this.workspaceGitService,
+            providerSnapshotManager: this.providerSnapshotManager,
+            daemonConfig: this.readDaemonConfig(),
+            currentSelection: input.currentSelection ?? undefined,
+            firstAgentContext: input.firstAgentContext,
+            logger: this.logger,
+        });
+    }
+    schedule(run, context) {
+        setTimeout(() => {
+            void run().catch((error) => {
+                this.logger.warn({ err: error, cwd: context.cwd }, context.message);
+            });
+        }, 0);
+    }
+}
+//# sourceMappingURL=workspace-auto-name.js.map

package/dist/server/server/workspace-bootstrap-dedupe.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Pure dedupe decision for the bootstrap flush.
+ *
+ * During the bootstrap window the session buffers workspace updates that
+ * race with the initial `fetch_workspaces_response`. The flush step decides
+ * which buffered updates still carry new information and which are
+ * redundant with what the client just received in the snapshot.
+ *
+ * Returns `true` (emit) when ANY of:
+ *   - the status changed from the snapshot
+ *   - the statusEnteredAt changed from the snapshot (including the
+ *     null↔value transition that the unmask case produces)
+ *   - the update's activityAtMs is strictly newer than the snapshot's
+ *   - the snapshot has no activityAtMs and the update has one (new activity
+ *     where there was none)
+ *
+ * Returns `false` (drop) when the status pair is unchanged AND the update
+ * is not strictly newer than the snapshot in activity. The both-null
+ * activity case falls through to drop — there is genuinely no new info.
+ */
+export interface BootstrapUpdateSnapshot {
+    status: string;
+    statusEnteredAt: string | null;
+    activityAtMs: number | null;
+}
+export interface BootstrapUpdateCheckInput {
+    /** Snapshot captured from the fetch_workspaces_response. `null` means
+     * the workspace was not in the snapshot (first-time subscription). */
+    snapshot: BootstrapUpdateSnapshot | null;
+    /** Pending update buffered during the bootstrap window. */
+    update: BootstrapUpdateSnapshot;
+}
+export declare function shouldEmitPendingBootstrapUpdate(input: BootstrapUpdateCheckInput): boolean;
+//# sourceMappingURL=workspace-bootstrap-dedupe.d.ts.map

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

@@ -0,0 +1,23 @@
+export function shouldEmitPendingBootstrapUpdate(input) {
+    const { snapshot, update } = input;
+    if (!snapshot) {
+        return true;
+    }
+    if (snapshot.status !== update.status) {
+        return true;
+    }
+    const snapshotEnteredAt = snapshot.statusEnteredAt ?? null;
+    const updateEnteredAt = update.statusEnteredAt ?? null;
+    if (snapshotEnteredAt !== updateEnteredAt) {
+        return true;
+    }
+    // Status pair is unchanged. The only remaining signal is activity.
+    if (update.activityAtMs === null) {
+        return false;
+    }
+    if (snapshot.activityAtMs === null) {
+        return true;
+    }
+    return update.activityAtMs > snapshot.activityAtMs;
+}
+//# sourceMappingURL=workspace-bootstrap-dedupe.js.map

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

@@ -0,0 +1,93 @@
+import type pino from "pino";
+import type { AgentSnapshotPayload, SessionInboundMessage, SessionOutboundMessage, WorkspaceDescriptorPayload } from "./messages.js";
+import type { PersistedProjectRecord, PersistedWorkspaceRecord } from "./workspace-registry.js";
+import { type TerminalActivity } from "@otto-code/protocol/terminal-activity";
+type FetchWorkspacesRequestMessage = Extract<SessionInboundMessage, {
+    type: "fetch_workspaces_request";
+}>;
+type FetchWorkspacesRequestFilter = NonNullable<FetchWorkspacesRequestMessage["filter"]>;
+type FetchWorkspacesResponsePayload = Extract<SessionOutboundMessage, {
+    type: "fetch_workspaces_response";
+}>["payload"];
+type FetchWorkspacesResponseEntry = FetchWorkspacesResponsePayload["entries"][number];
+type FetchWorkspacesResponsePageInfo = FetchWorkspacesResponsePayload["pageInfo"];
+type WorkspaceProjectDescriptor = FetchWorkspacesResponsePayload["emptyProjects"][number];
+export type WorkspaceUpdatesFilter = FetchWorkspacesRequestFilter;
+export interface WorkspaceDirectoryDeps {
+    logger: pino.Logger;
+    projectRegistry: {
+        list(): Promise<PersistedProjectRecord[]>;
+    };
+    workspaceRegistry: {
+        list(): Promise<PersistedWorkspaceRecord[]>;
+    };
+    listAgentPayloads(): Promise<AgentSnapshotPayload[]>;
+    listTerminalActivityContributions(): Promise<Array<{
+        cwd: string;
+        workspaceId?: string;
+        activity: TerminalActivity | null;
+    }>>;
+    isProviderVisibleToClient(provider: string): boolean;
+    buildWorkspaceDescriptor(input: {
+        workspace: PersistedWorkspaceRecord;
+        projectRecord?: PersistedProjectRecord | null;
+        includeGitData: boolean;
+    }): Promise<WorkspaceDescriptorPayload>;
+}
+export declare function summarizeFetchWorkspacesEntries(entries: Iterable<FetchWorkspacesResponseEntry>): {
+    count: number;
+    projectIds: string[];
+    statusCounts: Record<string, number>;
+    workspaces: Array<{
+        id: string;
+        projectId: string;
+        projectDisplayName: string;
+        name: string;
+        status: FetchWorkspacesResponseEntry["status"];
+        workspaceKind: FetchWorkspacesResponseEntry["workspaceKind"];
+        activityAt: string | null;
+    }>;
+};
+/**
+ * Git facts (branch, diff, dirty, PR) belong to a checkout on disk, not to a
+ * workspace identity. Every workspace whose own cwd is that checkout re-derives
+ * its git facts from the same folder. This returns the ids of those workspaces
+ * so a git change can fan out to all of them. This is git-fact display, NOT
+ * ownership: do not use it to decide which workspace owns an arbitrary path.
+ */
+export declare function workspaceIdsOnCheckout(workspaces: Iterable<PersistedWorkspaceRecord>, cwd: string): string[];
+export declare class WorkspaceDirectory {
+    private readonly deps;
+    private readonly archivingByWorkspaceId;
+    /**
+     * Per-workspace last-seen winning bucket + entered-at. Persists across
+     * `buildDescriptorMap` calls inside the daemon process; reset on cold start.
+     * Server-internal; never crosses the wire.
+     */
+    private readonly bucketHistoryByWorkspaceId;
+    private readonly pager;
+    constructor(deps: WorkspaceDirectoryDeps);
+    markArchiving(workspaceIds: Iterable<string>, archivingAt: string): void;
+    clearArchiving(workspaceIds: Iterable<string>): void;
+    buildDescriptorMap(options: {
+        includeGitData: boolean;
+        workspaceIds?: Iterable<string>;
+    }): Promise<Map<string, WorkspaceDescriptorPayload>>;
+    private applyAgentBucketContributions;
+    private applyTerminalContributions;
+    private resolveStatusEnteredAt;
+    private findNewestTimestampInBucket;
+    listEmptyProjects(): Promise<WorkspaceProjectDescriptor[]>;
+    listDescriptors(): Promise<WorkspaceDescriptorPayload[]>;
+    matchesFilter(input: {
+        workspace: WorkspaceDescriptorPayload;
+        filter: FetchWorkspacesRequestFilter | undefined;
+    }): boolean;
+    listFetchEntries(request: FetchWorkspacesRequestMessage): Promise<{
+        entries: FetchWorkspacesResponseEntry[];
+        emptyProjects: WorkspaceProjectDescriptor[];
+        pageInfo: FetchWorkspacesResponsePageInfo;
+    }>;
+}
+export {};
+//# sourceMappingURL=workspace-directory.d.ts.map