@pimote/pimote 0.5.1 → 0.7.0

package/server/dist/file-references.js

@@ -0,0 +1,123 @@
+import { execFile } from 'node:child_process';
+import { accessSync, constants } from 'node:fs';
+import { homedir } from 'node:os';
+import { delimiter, isAbsolute, join, resolve } from 'node:path';
+/**
+ * Candidate executable names for `fd`. Debian/Ubuntu ship the binary as
+ * `fdfind` to avoid a name clash, so both are tried.
+ */
+const FD_BINARY_NAMES = ['fd', 'fdfind'];
+/**
+ * Common install directories to probe in addition to `PATH`. The server process
+ * is often launched with a minimal `PATH` that omits these, so an `fd` installed
+ * via cargo, Homebrew, or pi's own bin dir would otherwise be invisible.
+ */
+function fdSearchDirs() {
+    const home = homedir();
+    const pathDirs = (process.env.PATH ?? '').split(delimiter).filter((d) => d.length > 0);
+    const extraDirs = [join(home, '.pi', 'agent', 'bin'), join(home, '.cargo', 'bin'), join(home, '.local', 'bin'), '/usr/local/bin', '/usr/bin', '/opt/homebrew/bin'];
+    return [...pathDirs, ...extraDirs];
+}
+/**
+ * Resolve an `fd` executable to an absolute path, probing `PATH` and common
+ * install dirs for both `fd` and `fdfind`. Returns `null` when none is found.
+ */
+export function resolveFdPath(dirs = fdSearchDirs()) {
+    for (const dir of dirs) {
+        for (const name of FD_BINARY_NAMES) {
+            const candidate = join(dir, name);
+            try {
+                accessSync(candidate, constants.X_OK);
+                return candidate;
+            }
+            catch {
+                // Not here; keep probing.
+            }
+        }
+    }
+    return null;
+}
+/** Cap on the number of fd results requested. */
+const MAX_RESULTS = 50;
+/**
+ * Compute `@`-file-path autocomplete suggestions for the given prefix, resolved
+ * against `cwd`. Returns `{ items: [], fdAvailable: false }` when `fd` is
+ * missing so the caller can emit a one-time warning.
+ */
+export async function completeFileRefs(input) {
+    const { cwd, prefix } = input;
+    const fdPath = input.fdPath ?? resolveFdPath() ?? 'fd';
+    const runFd = input.runFd ?? defaultRunFd;
+    const { quoted, scope, query } = parsePrefix(prefix);
+    const baseDir = resolveBaseDir(scope, cwd);
+    const args = ['--type', 'f', '--type', 'd', '--hidden', '--follow', '--exclude', '.git', '--max-results', String(MAX_RESULTS), '--base-directory', baseDir];
+    if (query !== '') {
+        // `--` ends fd's option parsing so a query starting with `-` is treated as a
+        // positional pattern, not a flag (matches the TUI's walkDirectoryWithFd).
+        args.push('--', query);
+    }
+    const invocation = { fdPath, baseDir, query, args };
+    const { available, lines } = await runFd(invocation);
+    if (!available) {
+        return { items: [], fdAvailable: false };
+    }
+    const items = lines.map((line) => mapLineToItem(line, scope, quoted));
+    return { items, fdAvailable: true };
+}
+/**
+ * Parse the raw `@`-token into the quoting flag, the typed directory scope (the
+ * text up to and including the last `/`), and the fd query pattern (the trailing
+ * segment after the last `/`).
+ */
+function parsePrefix(prefix) {
+    let rest = prefix.startsWith('@') ? prefix.slice(1) : prefix;
+    let quoted = false;
+    if (rest.startsWith('"')) {
+        quoted = true;
+        rest = rest.slice(1);
+    }
+    const lastSlash = rest.lastIndexOf('/');
+    if (lastSlash === -1) {
+        return { quoted, scope: '', query: rest };
+    }
+    return { quoted, scope: rest.slice(0, lastSlash + 1), query: rest.slice(lastSlash + 1) };
+}
+/** Resolve the typed scope string to an absolute search root against `cwd`. */
+function resolveBaseDir(scope, cwd) {
+    if (scope === '') {
+        return cwd;
+    }
+    if (scope.startsWith('~/')) {
+        return resolve(homedir(), scope.slice(2));
+    }
+    if (isAbsolute(scope)) {
+        return resolve(scope);
+    }
+    return resolve(cwd, scope);
+}
+/** Map one fd output line to an inserted-token autocomplete item. */
+function mapLineToItem(line, scope, quoted) {
+    const path = scope + line;
+    const needsQuote = quoted || path.includes(' ');
+    const value = needsQuote ? `@"${path}"` : `@${path}`;
+    return { value, label: line };
+}
+/**
+ * Default fd runner: spawns the real `fd` binary. On spawn `ENOENT` reports
+ * `available: false`; on any other failure degrades to `available: true` with no
+ * lines; on success splits stdout into non-empty lines.
+ */
+const defaultRunFd = (invocation) => new Promise((resolvePromise) => {
+    execFile(invocation.fdPath, invocation.args, (error, stdout) => {
+        if (error) {
+            if (error.code === 'ENOENT') {
+                resolvePromise({ available: false, lines: [] });
+                return;
+            }
+            resolvePromise({ available: true, lines: [] });
+            return;
+        }
+        const lines = stdout.split('\n').filter((l) => l.length > 0);
+        resolvePromise({ available: true, lines });
+    });
+});

package/server/dist/git-branch.js

@@ -1,19 +1,22 @@
-import { execFileSync } from 'node:child_process';
-/** Resolve the current git branch for a directory. Returns null if not a git repo or detached. */
-export function getGitBranch(cwd) {
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+/** Resolve the current git branch for a directory. Returns null if not a git repo or detached.
+ *  Async (non-blocking): callers must not run this on the event loop synchronously. */
+export async function getGitBranch(cwd) {
     // Guard against inherited Git env vars forcing resolution to another repo.
     const env = { ...process.env };
     delete env.GIT_DIR;
     delete env.GIT_WORK_TREE;
-    const runGit = (args) => {
+    const runGit = async (args) => {
         try {
-            const value = execFileSync('git', args, {
+            const { stdout } = await execFileAsync('git', args, {
                 cwd,
                 env,
                 encoding: 'utf-8',
                 timeout: 2000,
-                stdio: ['ignore', 'pipe', 'ignore'],
-            }).trim();
+            });
+            const value = stdout.trim();
             return value || null;
         }
         catch {
@@ -21,11 +24,11 @@ export function getGitBranch(cwd) {
         }
     };
     // Best signal for the checked-out branch (works with linked worktrees).
-    const current = runGit(['branch', '--show-current']);
+    const current = await runGit(['branch', '--show-current']);
     if (current)
         return current;
     // Fallback for older Git versions / unusual setups.
-    const abbrevRef = runGit(['rev-parse', '--abbrev-ref', 'HEAD']);
+    const abbrevRef = await runGit(['rev-parse', '--abbrev-ref', 'HEAD']);
     if (!abbrevRef || abbrevRef === 'HEAD')
         return null;
     return abbrevRef;

package/server/dist/login-orchestrator.js

@@ -0,0 +1,105 @@
+// LoginOrchestrator — server singleton driving interactive OAuth provider login.
+//
+// See docs/plans/provider-login.md → "Login Orchestrator". Owns references to
+// the shared pi-SDK AuthStorage + ModelRegistry. Responsibilities:
+//   - list OAuth providers with logged-in status
+//   - run a single login flow at a time (in-flight guard → "busy")
+//   - translate a connection-bound transport into pi's OAuthLoginCallbacks
+//   - on success call modelRegistry.refresh()
+//
+// Pure-ish and unit-testable: the AuthStorage / ModelRegistry dependencies are
+// expressed as the narrow structural seams below (LoginAuthStorage /
+// LoginModelRegistry), which the real pi-SDK classes satisfy. Tests inject
+// in-memory fakes plus a fake LoginTransport.
+/** Thrown by runLogin when a flow is already in progress. */
+export class LoginBusyError extends Error {
+    constructor() {
+        super('A login flow is already in progress');
+        this.name = 'LoginBusyError';
+    }
+}
+export class LoginOrchestrator {
+    authStorage;
+    modelRegistry;
+    busy = false;
+    requestCounter = 0;
+    constructor(authStorage, modelRegistry) {
+        this.authStorage = authStorage;
+        this.modelRegistry = modelRegistry;
+    }
+    /** List OAuth providers with logged-in status (from getOAuthProviders + getAuthStatus). */
+    listProviders() {
+        return this.authStorage.getOAuthProviders().map((p) => ({
+            id: p.id,
+            name: p.name,
+            loggedIn: this.authStorage.getAuthStatus(p.id).configured,
+        }));
+    }
+    /** Whether a login flow is currently running. */
+    isBusy() {
+        return this.busy;
+    }
+    /**
+     * Run a login flow for `providerId`, driving the transport. Resolves when the
+     * flow ends; emits a terminal `done` step itself (success or failure). Throws
+     * LoginBusyError if a flow is already in progress.
+     */
+    async runLogin(providerId, transport) {
+        // Synchronous in-flight guard (before the first await) so a concurrent
+        // runLogin issued in the same tick rejects while the first is in flight.
+        if (this.busy) {
+            throw new LoginBusyError();
+        }
+        this.busy = true;
+        const providerName = this.authStorage.getOAuthProviders().find((p) => p.id === providerId)?.name ?? providerId;
+        const nextRequestId = () => `login-${++this.requestCounter}`;
+        const callbacks = {
+            onAuth: (info) => {
+                transport.emit({ kind: 'auth', url: info.url, instructions: info.instructions });
+            },
+            onDeviceCode: (info) => {
+                transport.emit({
+                    kind: 'device_code',
+                    userCode: info.userCode,
+                    verificationUri: info.verificationUri,
+                    expiresInSeconds: info.expiresInSeconds,
+                });
+            },
+            onProgress: (message) => {
+                transport.emit({ kind: 'progress', message });
+            },
+            onPrompt: (prompt) => transport.requestInput({
+                requestId: nextRequestId(),
+                message: prompt.message,
+                placeholder: prompt.placeholder,
+                allowEmpty: prompt.allowEmpty,
+            }),
+            onManualCodeInput: () => transport.requestInput({
+                requestId: nextRequestId(),
+                message: 'Paste the authorization code',
+            }),
+            onSelect: (prompt) => transport.requestSelect({
+                requestId: nextRequestId(),
+                message: prompt.message,
+                options: prompt.options,
+            }),
+            signal: transport.signal,
+        };
+        try {
+            await this.authStorage.login(providerId, callbacks);
+            this.modelRegistry.refresh();
+            transport.emit({ kind: 'done', success: true, providerName });
+        }
+        catch (err) {
+            transport.emit({
+                kind: 'done',
+                success: false,
+                providerName,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+        finally {
+            this.busy = false;
+        }
+    }
+}

package/server/dist/push-infrastructure.js

@@ -67,7 +67,18 @@ export class WebPushSender {
         webpush.setVapidDetails('mailto:' + vapidEmail, vapidPublicKey, vapidPrivateKey);
     }
     async sendNotification(subscription, payload) {
-        const response = await webpush.sendNotification(subscription, payload);
-        return { statusCode: response.statusCode };
+        try {
+            const response = await webpush.sendNotification(subscription, payload);
+            return { statusCode: response.statusCode };
+        }
+        catch (err) {
+            // web-push rejects with a WebPushError for any non-2xx status (including
+            // 404/410 for dead subscriptions). Surface the status code so callers can
+            // prune expired subscriptions; rethrow anything that isn't an HTTP error.
+            if (err instanceof webpush.WebPushError) {
+                return { statusCode: err.statusCode };
+            }
+            throw err;
+        }
     }
 }

package/server/dist/push-notification.js

@@ -46,21 +46,28 @@ export class PushNotificationService {
         if (this.suppressionPredicate?.(payload.sessionId)) {
             return;
         }
-        const expiredEndpoints = [];
         const payloadStr = JSON.stringify(payload);
-        for (const sub of this.subscriptions) {
-            try {
-                const result = await this.sender.sendNotification(sub, payloadStr);
-                if (result.statusCode === 410) {
-                    expiredEndpoints.push(sub.endpoint);
+        // Snapshot deliberately: `this.subscriptions` is reassigned by add/remove,
+        // and we hold this list across awaits. Fan out in parallel rather than
+        // serializing behind the slowest endpoint.
+        const subs = this.subscriptions;
+        const results = await Promise.allSettled(subs.map((sub) => this.sender.sendNotification(sub, payloadStr)));
+        const expired = new Set();
+        results.forEach((result, i) => {
+            if (result.status === 'fulfilled') {
+                // 404 Not Found and 410 Gone both mean the subscription is dead.
+                if (result.value.statusCode === 404 || result.value.statusCode === 410) {
+                    expired.add(subs[i].endpoint);
                 }
             }
-            catch (err) {
-                console.warn('[PushNotificationService] Failed to send notification:', err.message ?? err);
+            else {
+                console.warn('[PushNotificationService] Failed to send notification:', result.reason?.message ?? result.reason);
             }
-        }
-        if (expiredEndpoints.length > 0) {
-            this.subscriptions = this.subscriptions.filter((s) => !expiredEndpoints.includes(s.endpoint));
+        });
+        if (expired.size > 0) {
+            // Prune against the CURRENT array (which may have changed during the
+            // awaits), removing only the endpoints we just found dead.
+            this.subscriptions = this.subscriptions.filter((s) => !expired.has(s.endpoint));
             await this.store.save(this.subscriptions);
         }
     }

package/server/dist/server.js

@@ -132,10 +132,26 @@ export async function createServer(config, sessionManager, folderIndex, pushNoti
     sessionManager.onGitBranchChange = (sessionId, folderPath) => {
         WsHandler.broadcastSidebarUpdate(sessionId, folderPath, sessionManager, clientRegistry);
     };
+    // A re-key collision is about to evict the slot holding this ID. Tell its
+    // owning client its session went away before the runtime is disposed.
+    sessionManager.onSlotEvicted = (sessionId) => {
+        const ownerClientId = sessionManager.getSlot(sessionId)?.connection?.connectedClientId;
+        if (ownerClientId)
+            clientRegistry.get(ownerClientId)?.sendDisplacedEvent(sessionId);
+    };
     const wss = new WebSocketServer({ noServer: true });
     const clientRegistry = new Map();
     httpServer.on('upgrade', (req, socket, head) => {
-        const url = new URL(req.url ?? '', `http://${req.headers.host}`);
+        // Only pathname/searchParams are read, so a fixed base is sufficient — and
+        // avoids an uncaught `new URL` throw when a malformed Host header arrives.
+        let url;
+        try {
+            url = new URL(req.url ?? '/', 'http://localhost');
+        }
+        catch {
+            socket.destroy();
+            return;
+        }
         if (url.pathname === '/ws') {
             wss.handleUpgrade(req, socket, head, (ws) => {
                 wss.emit('connection', ws, req);
@@ -146,7 +162,14 @@ export async function createServer(config, sessionManager, folderIndex, pushNoti
         }
     });
     wss.on('connection', (ws, req) => {
-        const url = new URL(req.url ?? '', `http://${req.headers.host}`);
+        let url;
+        try {
+            url = new URL(req.url ?? '/', 'http://localhost');
+        }
+        catch {
+            ws.close();
+            return;
+        }
         const clientId = url.searchParams.get('clientId') ?? crypto.randomUUID();
         console.log(`[pimote] WebSocket client connected (clientId=${clientId})`);
         // Version check — if the client's build version doesn't match the server's,

package/server/dist/session-cost.js

@@ -1,9 +1,33 @@
 /**
  * Pure cost summation helper for the per-session lifetime dollar cost surfaced
  * in the pimote StatusBar. No I/O, no SDK session coupling beyond a structural
- * (duck-typed) view of the session branch entries.
+ * (duck-typed) view of the session entries.
  *
- * See docs/plans/cost-accumulation.md.
+ * Callers pass the session manager's full entry log (getEntries()), so the
+ * figure spans ALL branches in the session file — not just the current leaf's
+ * branch. Because it is a pure fold recomputed on every get_session_meta call,
+ * it is correct across live session switches and reload-from-disk without any
+ * stateful accumulator: the session manager rehydrates every entry from the
+ * JSONL on load, and the sum is derived fresh from those entries.
+ *
+ * What this figure CAPTURES:
+ * - Every assistant turn across every branch, counted exactly once (branching
+ *   is append-only, so prior turns are never duplicated).
+ * - Tool-call token cost: a tool result is billed as input on the FOLLOWING
+ *   assistant turn, so it is already inside that turn's usage.cost.total. The
+ *   toolResult/user entries themselves carry no usage and are correctly skipped.
+ * - Cache-aware pricing: usage.cost.total is pi's pre-computed dollar amount
+ *   that already prices input/output/cacheRead/cacheWrite at their own model
+ *   rates. We sum total, so we inherit cache pricing rather than re-deriving it.
+ *
+ * What this figure EXCLUDES (cannot be recovered from the session file):
+ * - Compaction and branch-summary LLM calls. Those are billed API calls, but
+ *   CompactionEntry / BranchSummaryEntry carry no usage/cost field, so their
+ *   spend is invisible here.
+ * - Any assistant turn whose provider did not populate usage.cost.total (e.g. a
+ *   model with no pricing metadata): that turn contributes 0 (silent undercount).
+ *
+ * See docs/plans/cost-accumulation.md and docs/reviews/codebase-audit.md.
  */
 /**
  * Sum usage.cost.total over assistant message entries in the branch.

package/server/dist/session-manager.js

@@ -2,6 +2,7 @@ import { createAgentSessionRuntime, createAgentSessionServices, createAgentSessi
 import { EventBuffer } from './event-buffer.js';
 import { applyPanelMessage, getMergedPanelCards } from './panel-state.js';
 import { getGitBranch } from './git-branch.js';
+import { LoginOrchestrator } from './login-orchestrator.js';
 import { createVoiceExtension } from './voice/index.js';
 import { autoDrainOnAbort } from './auto-drain-on-abort.js';
 // ---- Slot-based helpers (operate on ManagedSlot) ----
@@ -71,7 +72,13 @@ function createSessionState(session, eventBus, config, callbacks, slotRef, folde
             state.idleSince = null;
             callbacks.onStatusChange?.(sessionId, folderPath);
         }
-        else if (event.type === 'agent_end' && state.status !== 'idle') {
+        else if (event.type === 'agent_end' && !event.willRetry && state.status !== 'idle') {
+            // `willRetry` agent_end is not a real end — the SDK detected a retryable
+            // error and will re-run the prompt after backoff (a fresh agent_start
+            // follows). Treating it as idle here would fire a spurious completion
+            // push notification and start the idle-reap clock for a session that is
+            // still working. Skip it; the terminal (willRetry=false) agent_end will
+            // drive the real idle transition.
             state.status = 'idle';
             state.idleSince = Date.now();
             state.needsAttention = true;
@@ -137,12 +144,33 @@ function scheduleSlotPanelPush(state, sessionId, sendEvent) {
         sendEvent({ type: 'panel_update', sessionId, cards });
     }, 200);
 }
+/**
+ * Coalesce concurrent async operations keyed by `key`: while one is in flight,
+ * callers passing the same key share its promise instead of starting a second
+ * run. The map entry is cleared once the operation settles, so a later call
+ * with the same key runs fresh.
+ */
+export async function singleFlight(map, key, run) {
+    const inflight = map.get(key);
+    if (inflight)
+        return inflight;
+    const p = run().finally(() => {
+        map.delete(key);
+    });
+    map.set(key, p);
+    return p;
+}
 export class PimoteSessionManager {
     config;
     pushNotificationService;
     authStorage;
     modelRegistry;
+    loginOrchestrator;
     sessions = new Map();
+    /** In-flight `openSession` promises keyed by session file path, so two
+     *  concurrent opens of the same on-disk session share one runtime instead
+     *  of building (and leaking) a second one over the same file. */
+    inFlightOpens = new Map();
     idleCheckHandle = null;
     gitBranchCheckHandle = null;
     lastKnownGitBranchBySession = new Map();
@@ -153,12 +181,18 @@ export class PimoteSessionManager {
      *  reap, explicit close). Consumers use this to drop external bookkeeping
      *  (e.g. `VoiceOrchestrator.endCall`) while the session is still addressable. */
     onBeforeSessionClose;
+    /** Fired when a re-key collision evicts the slot currently holding the target
+     *  session ID, BEFORE that slot is closed. Consumers notify the evicted slot's
+     *  owning client (e.g. a `session_closed`/displaced event) while it is still
+     *  addressable via getSlot. */
+    onSlotEvicted;
     staticHostFactory;
     constructor(config, pushNotificationService, options = {}) {
         this.config = config;
         this.pushNotificationService = pushNotificationService;
         this.authStorage = AuthStorage.create();
         this.modelRegistry = ModelRegistry.create(this.authStorage);
+        this.loginOrchestrator = new LoginOrchestrator(this.authStorage, this.modelRegistry);
         this.staticHostFactory = options.staticHostFactory;
     }
     /**
@@ -185,7 +219,37 @@ export class PimoteSessionManager {
             defaultWorkerModel: worker,
         });
     }
+    /**
+     * Open (or reopen) a session, returning its id.
+     *
+     * For an existing on-disk session (`sessionFilePath` provided), this guards
+     * against ever binding a SECOND pi runtime to the same session file: it
+     * returns the already-open session's id when it's live in memory, and
+     * coalesces concurrent opens of the same file into a single runtime. Without
+     * this, a reconnect double-fire or two devices opening the same session race
+     * between the (miss) existence check and the eventual `sessions.set`, spawn
+     * two runtimes appending to one file (corrupting history), and leak the
+     * first. New sessions (no file) create a fresh file each time, so they need
+     * no coalescing.
+     */
     async openSession(folderPath, sessionFilePath) {
+        if (!sessionFilePath) {
+            return this.doOpenSession(folderPath);
+        }
+        const alreadyOpenId = this.findSlotIdBySessionFile(sessionFilePath);
+        if (alreadyOpenId)
+            return alreadyOpenId;
+        return singleFlight(this.inFlightOpens, sessionFilePath, () => this.doOpenSession(folderPath, sessionFilePath));
+    }
+    /** Find the id of an open slot bound to the given session file, if any. */
+    findSlotIdBySessionFile(sessionFilePath) {
+        for (const [sid, slot] of this.sessions) {
+            if (slot.session.sessionFile === sessionFilePath)
+                return sid;
+        }
+        return undefined;
+    }
+    async doOpenSession(folderPath, sessionFilePath) {
         const eventBusRef = { current: null };
         const sharedAuthStorage = this.authStorage;
         const sharedModelRegistry = this.modelRegistry;
@@ -265,7 +329,7 @@ export class PimoteSessionManager {
         };
         slotRef.slot = slot;
         this.sessions.set(sessionId, slot);
-        this.lastKnownGitBranchBySession.set(sessionId, getGitBranch(effectiveFolderPath));
+        this.lastKnownGitBranchBySession.set(sessionId, await getGitBranch(effectiveFolderPath));
         return sessionId;
     }
     handleAgentEnd(sessionId, slot) {
@@ -347,6 +411,45 @@ export class PimoteSessionManager {
         this.lastKnownGitBranchBySession.delete(oldId);
         this.lastKnownGitBranchBySession.set(newId, lastKnown);
     }
+    /** Sync read of the cached git branch for a session. Refreshed every 3s by the
+     *  branch-check poll and seeded on open, so hot paths (sidebar broadcasts,
+     *  get_session_meta) read this instead of shelling out to git on the event loop.
+     *  May be up to ~3s stale; branch changes are rare so this is invisible in practice. */
+    getLastKnownGitBranch(sessionId) {
+        return this.lastKnownGitBranchBySession.get(sessionId) ?? null;
+    }
+    /** The single "session was replaced" business operation. Reconciles the session
+     *  map (rebuild state, evict any collision, re-key) ALWAYS — regardless of whether
+     *  a client owns the slot — so a reset triggered with no live owner can never leave
+     *  the map keyed under a stale ID. Then notifies whatever connection currently owns
+     *  the slot (never the issuer). All reset entry points (newSession/fork/navigateTree/
+     *  switchSession, via WS commands or extension command-context) funnel here. */
+    async applySessionReset(slot) {
+        const newId = slot.runtime.session.sessionId;
+        const oldId = slot.sessionState.id;
+        // navigateTree stays in the same file — same session ID, nothing to re-key.
+        if (newId === oldId) {
+            await slot.connection?.onSessionReset?.(slot, { kind: 'unchanged' });
+            return;
+        }
+        // Rebuild session state (tears down old, creates new from runtime.session).
+        // Refreshes slot.folderPath from the new session header cwd (fork-from can
+        // change cwd, e.g. the worktree extension), so read folderPath after this.
+        this.rebuildSessionState(slot);
+        // Collision: another live slot already holds newId. This happens when an
+        // extension calls ctx.switchSession(path) onto a session file already open in
+        // a different slot (the new ID is the target file's existing ID, not a fresh
+        // one like fork's). Without eviction, reKeySession would overwrite the
+        // occupant's map entry and orphan its runtime — two runtimes on one file.
+        // Treat it as a takeover: notify the occupant's owner, then dispose it.
+        const occupant = this.sessions.get(newId);
+        if (occupant && occupant !== slot) {
+            this.onSlotEvicted?.(newId);
+            await this.closeSession(newId);
+        }
+        this.reKeySession(slot, oldId, newId);
+        await slot.connection?.onSessionReset?.(slot, { kind: 'rekeyed', oldId, newId, folderPath: slot.folderPath });
+    }
     /** Rebuild a slot's SessionState after session replacement.
      *  Tears down the old state and creates a new one from the current runtime.session.
      *  Also refreshes slot.folderPath from the new session's header cwd, since fork-from
@@ -372,6 +475,10 @@ export class PimoteSessionManager {
     getSession(sessionId) {
         return this.sessions.get(sessionId);
     }
+    /** The shared, server-wide login orchestrator (login is global, not session-scoped). */
+    getLoginOrchestrator() {
+        return this.loginOrchestrator;
+    }
     getAllSessions() {
         return Array.from(this.sessions.values());
     }
@@ -396,16 +503,18 @@ export class PimoteSessionManager {
             }
         }, 60_000);
         this.gitBranchCheckHandle = setInterval(() => {
-            for (const [sessionId, slot] of this.sessions) {
-                if (!slot.connection?.connectedClientId)
-                    continue;
-                const next = getGitBranch(slot.folderPath);
+            // Snapshot connected sessions and refresh their branches in parallel. The
+            // lookups are async (execFile) so the poll never blocks the event loop;
+            // hot-path readers consume the cache via getLastKnownGitBranch.
+            const connected = [...this.sessions].filter(([, slot]) => slot.connection?.connectedClientId);
+            void Promise.all(connected.map(async ([sessionId, slot]) => {
+                const next = await getGitBranch(slot.folderPath);
                 const prev = this.lastKnownGitBranchBySession.get(sessionId) ?? null;
                 if (next !== prev) {
                     this.lastKnownGitBranchBySession.set(sessionId, next);
                     this.onGitBranchChange?.(sessionId, slot.folderPath);
                 }
-            }
+            }));
         }, 3000);
     }
     stopIdleCheck() {

package/server/dist/static-host/gc.js

@@ -25,6 +25,19 @@ export async function gcStaticHostStore(args) {
     }
     const suffix = '.json';
     for (const name of entries) {
+        // Orphan write tmp file (`<sessionId>.json.tmp`) left by a crash between
+        // writeFile and rename. GC runs at boot before any write, so a leftover
+        // .tmp is always stale — unlink unconditionally.
+        if (name.endsWith('.json.tmp')) {
+            try {
+                await unlink(join(storeDir, name));
+            }
+            catch (err) {
+                if (err.code !== 'ENOENT')
+                    throw err;
+            }
+            continue;
+        }
         if (!name.endsWith(suffix))
             continue;
         const sessionId = name.slice(0, -suffix.length);