@getpaseo/server 0.1.96 → 0.1.97-beta.1

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

@@ -1,9 +1,9 @@
-import { homedir } from "node:os";
-import { sep } from "node:path";
+import { resolve } from "node:path";
 import { deriveAgentStateBucket, getWorkspaceStateBucketPriority, } from "@getpaseo/protocol/agent-state-bucket";
 import { getParentAgentIdFromLabels, isDelegatedAgent } from "@getpaseo/protocol/agent-labels";
 import { SortablePager } from "./pagination/sortable-pager.js";
-import { normalizeWorkspaceId } from "./workspace-registry-model.js";
+import { resolveProjectDisplayName } from "./workspace-registry.js";
+import { deriveTerminalActivityStatusBucket, } from "@getpaseo/protocol/terminal-activity";
 const FETCH_WORKSPACES_SORT_KEYS = [
     "status_priority",
     "activity_at",
@@ -31,6 +31,19 @@ export function summarizeFetchWorkspacesEntries(entries) {
         workspaces,
     };
 }
+/**
+ * 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 function workspaceIdsOnCheckout(workspaces, cwd) {
+    const resolvedCwd = resolve(cwd);
+    return Array.from(workspaces)
+        .filter((workspace) => !workspace.archivedAt && resolve(workspace.cwd) === resolvedCwd)
+        .map((workspace) => workspace.workspaceId);
+}
 export class WorkspaceDirectory {
     constructor(deps) {
         this.deps = deps;
@@ -73,10 +86,11 @@ export class WorkspaceDirectory {
         }
     }
     async buildDescriptorMap(options) {
-        const [agents, persistedWorkspaces, persistedProjects] = await Promise.all([
+        const [agents, persistedWorkspaces, persistedProjects, terminalContributions] = await Promise.all([
             this.deps.listAgentPayloads(),
             this.deps.workspaceRegistry.list(),
             this.deps.projectRegistry.list(),
+            this.deps.listTerminalActivityContributions(),
         ]);
         const activeProjects = new Map(persistedProjects
             .filter((project) => !project.archivedAt)
@@ -85,8 +99,9 @@ export class WorkspaceDirectory {
         const activeRecords = persistedWorkspaces.filter((workspace) => !workspace.archivedAt && !archivedProjectIds.has(workspace.projectId));
         const descriptorsByWorkspaceId = new Map();
         const workspaceIds = options.workspaceIds ? new Set(options.workspaceIds) : null;
-        const workspaceIdsByDirectory = new Map(activeRecords.map((workspace) => [normalizeWorkspaceId(workspace.cwd), workspace.workspaceId]));
+        const activeWorkspaceIds = new Set(activeRecords.map((workspace) => workspace.workspaceId));
         const includedWorkspaces = activeRecords.filter((workspace) => !workspaceIds || workspaceIds.has(workspace.workspaceId));
+        const activeRecordsByWorkspaceId = new Map(activeRecords.map((workspace) => [workspace.workspaceId, workspace]));
         const workspaceDescriptors = await Promise.all(includedWorkspaces.map((workspace) => this.deps.buildWorkspaceDescriptor({
             workspace,
             projectRecord: activeProjects.get(workspace.projectId) ?? null,
@@ -100,6 +115,44 @@ export class WorkspaceDirectory {
             });
         }
         const activeAgents = agents.filter((agent) => !agent.archivedAt && this.deps.isProviderVisibleToClient(agent.provider));
+        this.applyAgentBucketContributions({
+            activeAgents,
+            descriptorsByWorkspaceId,
+        });
+        // Terminal activity contributions: working terminal → running bucket.
+        const terminalEntriesByWorkspaceId = this.applyTerminalContributions(terminalContributions, descriptorsByWorkspaceId);
+        const contributingAgentsByWorkspaceId = groupAgentsByWorkspaceId(activeAgents, activeWorkspaceIds);
+        // Resolve the workspace-level `statusEnteredAt` (see aggregate semantics
+        // on `resolveStatusEnteredAt`).
+        const nowIso = new Date().toISOString();
+        for (const [workspaceId, descriptor] of descriptorsByWorkspaceId) {
+            const contributingAgents = contributingAgentsByWorkspaceId.get(workspaceId) ?? [];
+            const terminalEntries = terminalEntriesByWorkspaceId.get(workspaceId) ?? [];
+            const result = this.resolveStatusEnteredAt({
+                workspaceId,
+                winningBucket: descriptor.status,
+                contributingAgents,
+                terminalEntries,
+                previous: this.bucketHistoryByWorkspaceId.get(workspaceId) ?? null,
+                workspaceCreatedAt: activeRecordsByWorkspaceId.get(workspaceId)?.createdAt ?? null,
+                nowIso,
+            });
+            descriptor.statusEnteredAt = result.statusEnteredAt;
+            if (result.recordUpdate) {
+                this.bucketHistoryByWorkspaceId.set(workspaceId, result.recordUpdate);
+            }
+            else if (result.recordDelete) {
+                this.bucketHistoryByWorkspaceId.delete(workspaceId);
+            }
+        }
+        return descriptorsByWorkspaceId;
+    }
+    // Aggregate each agent's state bucket into its owning workspace descriptor,
+    // keeping the highest-priority bucket. A record's owner IS its `workspaceId`;
+    // status never fans out to same-cwd siblings. Delegated agents contribute to
+    // their delegation root's workspace; their own status is ignored unless running.
+    applyAgentBucketContributions(params) {
+        const { activeAgents, descriptorsByWorkspaceId } = params;
         const activeAgentsById = new Map(activeAgents.map((agent) => [agent.id, agent]));
         for (const agent of activeAgents) {
             let workspaceAgent = agent;
@@ -123,8 +176,8 @@ export class WorkspaceDirectory {
                     attentionReason: agent.attentionReason ?? null,
                 });
             }
-            const workspaceId = workspaceIdsByDirectory.get(normalizeWorkspaceId(workspaceAgent.cwd));
-            if (workspaceId === undefined) {
+            const workspaceId = workspaceAgent.workspaceId;
+            if (!workspaceId) {
                 continue;
             }
             const existing = descriptorsByWorkspaceId.get(workspaceId);
@@ -135,46 +188,55 @@ export class WorkspaceDirectory {
                 existing.status = bucket;
             }
         }
-        // Resolve the workspace-level `statusEnteredAt` (see aggregate semantics
-        // on `resolveStatusEnteredAt`).
-        const nowIso = new Date().toISOString();
-        for (const [workspaceId, descriptor] of descriptorsByWorkspaceId) {
-            const contributingAgents = agents.filter((agent) => !agent.archivedAt &&
-                this.deps.isProviderVisibleToClient(agent.provider) &&
-                workspaceIdsByDirectory.get(normalizeWorkspaceId(agent.cwd)) === workspaceId);
-            const result = this.resolveStatusEnteredAt({
-                workspaceId,
-                winningBucket: descriptor.status,
-                contributingAgents,
-                previous: this.bucketHistoryByWorkspaceId.get(workspaceId) ?? null,
-                nowIso,
-            });
-            descriptor.statusEnteredAt = result.statusEnteredAt;
-            if (result.recordUpdate) {
-                this.bucketHistoryByWorkspaceId.set(workspaceId, result.recordUpdate);
+    }
+    // Apply working terminal contributions to descriptor statuses and build a map
+    // of terminal timestamp entries per workspace for use in `resolveStatusEnteredAt`.
+    // A terminal contributes only to the workspace it carries; same-cwd siblings
+    // are untouched.
+    applyTerminalContributions(terminalContributions, descriptorsByWorkspaceId) {
+        const terminalEntriesByWorkspaceId = new Map();
+        for (const { workspaceId, activity } of terminalContributions) {
+            if (!activity || !workspaceId) {
+                continue;
             }
-            else if (result.recordDelete) {
-                this.bucketHistoryByWorkspaceId.delete(workspaceId);
+            const bucket = deriveTerminalActivityStatusBucket(activity);
+            if (!bucket)
+                continue;
+            const existing = descriptorsByWorkspaceId.get(workspaceId);
+            if (!existing) {
+                continue;
+            }
+            if (getWorkspaceStateBucketPriority(bucket) < getWorkspaceStateBucketPriority(existing.status)) {
+                existing.status = bucket;
             }
+            const entries = terminalEntriesByWorkspaceId.get(workspaceId) ?? [];
+            entries.push({ bucket, changedAtIso: new Date(activity.changedAt).toISOString() });
+            terminalEntriesByWorkspaceId.set(workspaceId, entries);
         }
-        return descriptorsByWorkspaceId;
+        return terminalEntriesByWorkspaceId;
     }
     // Aggregate the workspace-level `statusEnteredAt` from its contributing
-    // agents. Aggregate semantics:
-    //   - winning bucket = highest-priority across contributing agents;
-    //   - entry time = best-effort timestamp from agents in the winning bucket;
+    // agents and terminals. Aggregate semantics:
+    //   - winning bucket = highest-priority across contributing agents and terminals;
+    //   - entry time = best-effort timestamp from agents/terminals in the winning bucket;
     //   - priority unmasking: when the winning bucket transitions (e.g. a
     //     higher-priority bucket cleared), the new entry time is "now";
     //   - same-bucket emits reuse the previous entered-at;
-    //   - empty workspaces that never had contributing agents get
-    //     `statusEnteredAt: null`.
+    //   - empty workspaces that never had contributing agents or terminals use
+    //     their workspace creation time as their initial `done` entry time.
     //   - when archived agents leave a previously active workspace empty, keep
     //     the previous done timestamp or stamp the transition to done now.
     resolveStatusEnteredAt(params) {
-        const { winningBucket, contributingAgents, previous, nowIso } = params;
-        if (contributingAgents.length === 0) {
+        const { winningBucket, contributingAgents, terminalEntries, previous, workspaceCreatedAt, nowIso, } = params;
+        if (contributingAgents.length === 0 && terminalEntries.length === 0) {
             if (!previous) {
-                return { statusEnteredAt: null };
+                if (!workspaceCreatedAt) {
+                    return { statusEnteredAt: null };
+                }
+                return {
+                    statusEnteredAt: workspaceCreatedAt,
+                    recordUpdate: { bucket: "done", enteredAt: workspaceCreatedAt },
+                };
             }
             const enteredAt = previous.bucket === "done" ? previous.enteredAt : nowIso;
             return {
@@ -183,7 +245,7 @@ export class WorkspaceDirectory {
             };
         }
         if (!previous) {
-            const newestInWinningBucket = this.findNewestAgentTimestampInBucket(contributingAgents, winningBucket);
+            const newestInWinningBucket = this.findNewestTimestampInBucket(contributingAgents, terminalEntries, winningBucket);
             const enteredAt = newestInWinningBucket ?? nowIso;
             return {
                 statusEnteredAt: enteredAt,
@@ -201,13 +263,13 @@ export class WorkspaceDirectory {
             recordUpdate: previous,
         };
     }
-    // Best-effort newest timestamp across contributing agents whose derived
-    // bucket matches `winningBucket`. Uses available agent fields:
+    // Best-effort newest timestamp across contributing agents and terminal entries
+    // whose bucket matches `winningBucket`. For agents, uses:
     //   - `attentionTimestamp` when attention is set (covers attention/failed)
     //   - `updatedAt` as a general fallback for any bucket
-    // Returns `null` if no matching agent has a parseable timestamp.
-    findNewestAgentTimestampInBucket(contributingAgents, winningBucket) {
-        const candidates = contributingAgents
+    // Returns `null` if no matching contributor has a parseable timestamp.
+    findNewestTimestampInBucket(contributingAgents, terminalEntries, winningBucket) {
+        const agentTimestamps = contributingAgents
             .filter((agent) => {
             const derived = deriveAgentStateBucket({
                 status: agent.status,
@@ -226,32 +288,33 @@ export class WorkspaceDirectory {
             // Fall back to updatedAt as a general proxy for recent activity.
             return agent.updatedAt;
         })
-            .filter((value) => typeof value === "string" && value.length > 0)
-            .sort();
+            .filter((value) => typeof value === "string" && value.length > 0);
+        const terminalTimestamps = terminalEntries
+            .filter((entry) => entry.bucket === winningBucket)
+            .map((entry) => entry.changedAtIso);
+        const candidates = [...agentTimestamps, ...terminalTimestamps].sort();
         return candidates.at(-1) ?? null;
     }
-    resolveRegisteredWorkspaceIdForCwd(cwd, workspaces) {
-        const normalizedCwd = normalizeWorkspaceId(cwd);
-        const exact = workspaces.find((workspace) => workspace.cwd === normalizedCwd);
-        if (exact) {
-            return exact.workspaceId;
-        }
-        const userHome = homedir();
-        let bestMatch = null;
-        for (const workspace of workspaces) {
-            if (workspace.cwd === userHome)
-                continue;
-            if (workspace.archivedAt)
-                continue;
-            const prefix = workspace.cwd.endsWith(sep) ? workspace.cwd : `${workspace.cwd}${sep}`;
-            if (!normalizedCwd.startsWith(prefix)) {
-                continue;
-            }
-            if (!bestMatch || workspace.cwd.length > bestMatch.cwd.length) {
-                bestMatch = workspace;
-            }
-        }
-        return bestMatch?.workspaceId ?? normalizedCwd;
+    // Project parents that have no active workspaces. These persist as first-class
+    // empty projects so the sidebar can render an empty project row with a
+    // "+ New workspace" affordance.
+    async listEmptyProjects() {
+        const [persistedWorkspaces, persistedProjects] = await Promise.all([
+            this.deps.workspaceRegistry.list(),
+            this.deps.projectRegistry.list(),
+        ]);
+        const projectIdsWithActiveWorkspaces = new Set(persistedWorkspaces
+            .filter((workspace) => !workspace.archivedAt)
+            .map((workspace) => workspace.projectId));
+        return persistedProjects
+            .filter((project) => !project.archivedAt && !projectIdsWithActiveWorkspaces.has(project.projectId))
+            .map((project) => ({
+            projectId: project.projectId,
+            projectDisplayName: resolveProjectDisplayName(project),
+            projectCustomName: project.customName ?? null,
+            projectRootPath: project.rootPath,
+            projectKind: project.kind,
+        }));
     }
     async listDescriptors() {
         return Array.from((await this.buildDescriptorMap({
@@ -268,11 +331,6 @@ export class WorkspaceDirectory {
                 return false;
             }
         }
-        if (filter.idPrefix && filter.idPrefix.trim().length > 0) {
-            if (!workspace.id.startsWith(filter.idPrefix.trim())) {
-                return false;
-            }
-        }
         if (filter.query && filter.query.trim().length > 0) {
             const query = filter.query.trim().toLocaleLowerCase();
             const haystacks = [workspace.name, workspace.projectId, workspace.id];
@@ -301,6 +359,12 @@ export class WorkspaceDirectory {
         const nextCursor = hasMore && pagedEntries.length > 0
             ? this.pager.encode(pagedEntries[pagedEntries.length - 1], sort)
             : null;
+        // Empty project parents ride only on the first page so the sidebar can render
+        // them without them being duplicated across pagination.
+        const projectIdFilter = filter?.projectId?.trim();
+        const emptyProjects = cursorToken
+            ? []
+            : (await this.listEmptyProjects()).filter((project) => !projectIdFilter || project.projectId === projectIdFilter);
         this.deps.logger.debug({
             requestId: request.requestId,
             filter: request.filter ?? null,
@@ -314,6 +378,7 @@ export class WorkspaceDirectory {
         }, "fetch_workspaces_entries_listed");
         return {
             entries: pagedEntries,
+            emptyProjects,
             pageInfo: {
                 nextCursor,
                 prevCursor: request.page?.cursor ?? null,
@@ -322,6 +387,19 @@ export class WorkspaceDirectory {
         };
     }
 }
+function groupAgentsByWorkspaceId(agents, activeWorkspaceIds) {
+    const byWorkspaceId = new Map();
+    for (const agent of agents) {
+        const workspaceId = agent.workspaceId;
+        if (!workspaceId || !activeWorkspaceIds.has(workspaceId)) {
+            continue;
+        }
+        const entries = byWorkspaceId.get(workspaceId) ?? [];
+        entries.push(agent);
+        byWorkspaceId.set(workspaceId, entries);
+    }
+    return byWorkspaceId;
+}
 function resolveDelegationRootAgent(agent, activeAgentsById) {
     const seen = new Set([agent.id]);
     let current = agent;

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

@@ -1,6 +1,6 @@
 import { watch } from "node:fs";
 import { readFile, readdir } from "node:fs/promises";
-import { join, resolve } from "node:path";
+import { basename, join, resolve } from "node:path";
 import { LRUCache } from "lru-cache";
 import pLimit from "p-limit";
 import { getCheckoutDiff, getCheckoutSnapshotFacts, getCheckoutShortstat, getCheckoutStatus, getPullRequestStatus, hasOriginRemote, listBranchSuggestions, resolveRepositoryDefaultBranch, resolveBranchCheckout, resolveAbsoluteGitDir, } from "../utils/checkout-git.js";
@@ -11,7 +11,7 @@ import { resolveGitHubRemote } from "../utils/github-remote.js";
 import { listPaseoWorktrees } from "../utils/worktree.js";
 import { READ_ONLY_GIT_ENV } from "./checkout-git-utils.js";
 import { buildWorkspaceGitMetadataFromSnapshot, } from "./workspace-git-metadata.js";
-import { checkoutLiteFromGitSnapshot, normalizeWorkspaceId } from "./workspace-registry-model.js";
+import { checkoutLiteFromGitSnapshot } from "./workspace-registry-model.js";
 const WORKSPACE_GIT_WATCH_DEBOUNCE_MS = 1000;
 const BACKGROUND_GIT_FETCH_INTERVAL_MS = 180000;
 export const WORKSPACE_GIT_SELF_HEAL_INTERVAL_MS = 60000;
@@ -75,7 +75,7 @@ export class WorkspaceGitServiceImpl {
         this.deps = resolveWorkspaceGitServiceDeps(options.deps);
     }
     registerWorkspace(params, listener) {
-        const cwd = normalizeWorkspaceId(params.cwd);
+        const cwd = resolve(params.cwd);
         const target = this.ensureWorkspaceTarget(cwd);
         target.listeners.add(listener);
         if (target.listeners.size === 1) {
@@ -100,7 +100,7 @@ export class WorkspaceGitServiceImpl {
         };
     }
     async getSnapshot(cwd, options) {
-        cwd = normalizeWorkspaceId(cwd);
+        cwd = resolve(cwd);
         const request = this.normalizeRefreshRequest(options, "getSnapshot", true);
         const target = this.ensureWorkspaceTarget(cwd);
         if (!request.force && target.latestSnapshot) {
@@ -109,7 +109,7 @@ export class WorkspaceGitServiceImpl {
         return this.requestWorkspaceSnapshot(target, request);
     }
     async getCheckout(cwd) {
-        const normalizedCwd = normalizeWorkspaceId(cwd);
+        const normalizedCwd = resolve(cwd);
         try {
             const status = await this.deps.getCheckoutStatus(normalizedCwd, {
                 paseoHome: this.paseoHome,
@@ -147,11 +147,11 @@ export class WorkspaceGitServiceImpl {
         }
     }
     peekSnapshot(cwd) {
-        cwd = normalizeWorkspaceId(cwd);
+        cwd = resolve(cwd);
         return this.workspaceTargets.get(cwd)?.latestSnapshot ?? null;
     }
     getCheckoutDiff(cwd, options, readOptions) {
-        const normalizedCwd = normalizeWorkspaceId(cwd);
+        const normalizedCwd = resolve(cwd);
         const normalizedOptions = this.normalizeCheckoutDiffOptions(options);
         const key = this.buildCheckoutDiffCacheKey(normalizedCwd, normalizedOptions);
         return this.readAuxiliaryCache(this.checkoutDiffCache, key, readOptions, () => this.deps.getCheckoutDiff(normalizedCwd, normalizedOptions, {
@@ -182,13 +182,13 @@ export class WorkspaceGitServiceImpl {
         ]);
     }
     validateBranchRef(cwd, ref, options) {
-        const normalizedCwd = normalizeWorkspaceId(cwd);
+        const normalizedCwd = resolve(cwd);
         const normalizedRef = ref.trim();
         const key = JSON.stringify(["branch-validation", normalizedCwd, normalizedRef]);
         return this.readAuxiliaryCache(this.branchValidationCache, key, options, () => this.deps.resolveBranchCheckout(normalizedCwd, normalizedRef));
     }
     hasLocalBranch(cwd, branch, options) {
-        const normalizedCwd = normalizeWorkspaceId(cwd);
+        const normalizedCwd = resolve(cwd);
         const normalizedBranch = branch.trim();
         const ref = `refs/heads/${normalizedBranch}`;
         const key = JSON.stringify(["local-branch", normalizedCwd, ref]);
@@ -202,14 +202,14 @@ export class WorkspaceGitServiceImpl {
         });
     }
     suggestBranchesForCwd(cwd, options, readOptions) {
-        const normalizedCwd = normalizeWorkspaceId(cwd);
+        const normalizedCwd = resolve(cwd);
         const query = options?.query ?? "";
         const limit = options?.limit;
         const key = JSON.stringify(["branch-suggestions", normalizedCwd, query, limit ?? null]);
         return this.readAuxiliaryCache(this.branchSuggestionsCache, key, readOptions, () => this.deps.listBranchSuggestions(normalizedCwd, options));
     }
     listStashes(cwd, options, readOptions) {
-        const normalizedCwd = normalizeWorkspaceId(cwd);
+        const normalizedCwd = resolve(cwd);
         const paseoOnly = options?.paseoOnly !== false;
         const key = JSON.stringify(["stashes", normalizedCwd, paseoOnly]);
         return this.readAuxiliaryCache(this.stashListCache, key, readOptions, async () => {
@@ -235,11 +235,11 @@ export class WorkspaceGitServiceImpl {
             throw new Error("Create worktree requires a git repository");
         }
         return snapshot.git.isPaseoOwnedWorktree
-            ? (snapshot.git.mainRepoRoot ?? snapshot.git.repoRoot ?? normalizeWorkspaceId(cwd))
-            : (snapshot.git.repoRoot ?? normalizeWorkspaceId(cwd));
+            ? (snapshot.git.mainRepoRoot ?? snapshot.git.repoRoot ?? resolve(cwd))
+            : (snapshot.git.repoRoot ?? resolve(cwd));
     }
     async resolveDefaultBranch(cwdOrRepoRoot, options) {
-        const cwd = normalizeWorkspaceId(cwdOrRepoRoot);
+        const cwd = resolve(cwdOrRepoRoot);
         const key = JSON.stringify(["default-branch", cwd]);
         return this.readAuxiliaryCache(this.defaultBranchCache, key, options, async () => {
             const defaultBranch = await this.deps.resolveRepositoryDefaultBranch(cwd);
@@ -251,9 +251,9 @@ export class WorkspaceGitServiceImpl {
     }
     async getWorkspaceGitMetadata(cwd, options) {
         const snapshot = await this.getSnapshot(cwd, options);
-        const directoryName = options?.directoryName ?? normalizeWorkspaceId(cwd).split(/[\\/]/).findLast(Boolean) ?? cwd;
+        const directoryName = options?.directoryName ?? basename(cwd) ?? cwd;
         return buildWorkspaceGitMetadataFromSnapshot({
-            cwd: normalizeWorkspaceId(cwd),
+            cwd: resolve(cwd),
             directoryName,
             isGit: snapshot.git.isGit,
             repoRoot: snapshot.git.repoRoot,
@@ -267,7 +267,7 @@ export class WorkspaceGitServiceImpl {
         return snapshot.git.remoteUrl;
     }
     async refresh(cwd, _options) {
-        cwd = normalizeWorkspaceId(cwd);
+        cwd = resolve(cwd);
         const target = this.ensureWorkspaceTarget(cwd);
         await this.refreshWorkspaceTarget(target, {
             force: false,
@@ -278,7 +278,7 @@ export class WorkspaceGitServiceImpl {
         this.scheduleWorkspaceObservationSetup(target);
     }
     async requestWorkingTreeWatch(cwd, onChange) {
-        cwd = normalizeWorkspaceId(cwd);
+        cwd = resolve(cwd);
         const target = await this.ensureWorkingTreeWatchTarget(cwd);
         target.listeners.add(onChange);
         return {
@@ -289,14 +289,14 @@ export class WorkspaceGitServiceImpl {
         };
     }
     scheduleRefreshForCwd(cwd) {
-        cwd = normalizeWorkspaceId(cwd);
+        cwd = resolve(cwd);
         const target = this.workspaceTargets.get(cwd);
         if (target) {
             this.scheduleWorkspaceRefresh(target);
         }
     }
     onWorkspaceStateMayHaveChanged(cwd) {
-        const normalizedCwd = normalizeWorkspaceId(cwd);
+        const normalizedCwd = resolve(cwd);
         const target = this.workspaceTargets.get(normalizedCwd);
         if (!target || target.closed) {
             return;
@@ -649,7 +649,7 @@ export class WorkspaceGitServiceImpl {
     }
     scheduleWorkspaceRefresh(targetOrCwd, options) {
         const target = typeof targetOrCwd === "string"
-            ? this.workspaceTargets.get(normalizeWorkspaceId(targetOrCwd))
+            ? this.workspaceTargets.get(resolve(targetOrCwd))
             : targetOrCwd;
         if (!target || target.closed || this.workspaceTargets.get(target.cwd) !== target) {
             return;

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

@@ -20,7 +20,7 @@ export type ReconciliationChange = {
     kind: "workspace_updated";
     workspaceId: string;
     directory: string;
-    fields: Partial<Pick<PersistedWorkspaceRecord, "projectId" | "displayName" | "kind">>;
+    fields: Partial<Pick<PersistedWorkspaceRecord, "projectId" | "branch" | "kind">>;
 };
 export interface ReconciliationResult {
     changesApplied: ReconciliationChange[];

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

@@ -1,5 +1,5 @@
 import { existsSync } from "node:fs";
-import { normalizeWorkspaceId } from "./workspace-registry-model.js";
+import { resolve } from "node:path";
 const DEFAULT_RECONCILE_INTERVAL_MS = 60000;
 function deriveWorkspaceKindFromMetadata(metadata) {
     if (metadata.projectKind !== "git")
@@ -97,27 +97,18 @@ export class WorkspaceReconciliationService {
         }));
         // 2. Merge duplicate active project records that point at the same repo root.
         await this.mergeDuplicateProjectsByRoot(activeProjects, workspacesByProject, changes);
-        // 3. Archive orphaned projects (all workspaces archived/removed)
-        const orphanedProjects = activeProjects.filter((project) => {
-            const siblings = workspacesByProject.get(project.projectId) ?? [];
-            return siblings.length === 0;
-        });
-        await Promise.all(orphanedProjects.map(async (project) => {
-            const timestamp = new Date().toISOString();
-            await this.projectRegistry.archive(project.projectId, timestamp);
-            changes.push({
-                kind: "project_archived",
-                projectId: project.projectId,
-                directory: project.rootPath,
-                reason: "no_active_workspaces",
-            });
-        }));
-        // 4. Reconcile git metadata for active projects whose directories still exist
+        // 3. Reconcile git metadata for active projects whose directories still exist.
+        //    A project with zero active workspaces is a first-class empty project — it
+        //    persists until explicitly removed and still reconciles its own metadata.
+        //    Skip projects archived earlier in this pass (e.g. merged duplicates) so we
+        //    don't resurrect them by upserting a stale, non-archived copy.
+        const archivedProjectIds = new Set(changes
+            .filter((change) => change.kind === "project_archived")
+            .map((change) => change.projectId));
         const projectsToReconcile = activeProjects.filter((project) => {
             if (project.archivedAt)
                 return false;
-            const siblings = workspacesByProject.get(project.projectId) ?? [];
-            if (siblings.length === 0)
+            if (archivedProjectIds.has(project.projectId))
                 return false;
             if (!existsSync(project.rootPath))
                 return false;
@@ -143,7 +134,7 @@ export class WorkspaceReconciliationService {
             if (project.kind !== "git") {
                 continue;
             }
-            const rootKey = normalizeWorkspaceId(project.rootPath);
+            const rootKey = resolve(project.rootPath);
             const group = projectsByRoot.get(rootKey) ?? [];
             group.push(project);
             projectsByRoot.set(rootKey, group);
@@ -177,6 +168,14 @@ export class WorkspaceReconciliationService {
             })));
             for (const project of duplicateProjects) {
                 workspacesByProject.set(project.projectId, []);
+                const timestamp = new Date().toISOString();
+                await this.projectRegistry.archive(project.projectId, timestamp);
+                changes.push({
+                    kind: "project_archived",
+                    projectId: project.projectId,
+                    directory: project.rootPath,
+                    reason: "merged_duplicate",
+                });
             }
         }
     }
@@ -236,8 +235,8 @@ export class WorkspaceReconciliationService {
             const wsGit = await this.readWorkspaceGitMetadata(workspace.cwd, wsDirName);
             const expectedKind = deriveWorkspaceKindFromMetadata(wsGit);
             const workspaceUpdates = {};
-            if (wsGit.projectKind === "git" && workspace.displayName !== wsGit.workspaceDisplayName) {
-                workspaceUpdates.displayName = wsGit.workspaceDisplayName;
+            if (wsGit.projectKind === "git" && workspace.branch !== wsGit.currentBranch) {
+                workspaceUpdates.branch = wsGit.currentBranch;
             }
             if (workspace.kind !== expectedKind) {
                 workspaceUpdates.kind = expectedKind;