@sumicom/quicksave 0.8.1 → 0.8.3

package/dist/handlers/messageHandler.js

@@ -6,7 +6,10 @@ import { CommitSummaryCliService, CommitSummaryCliError } from '../ai/commitSumm
 import { CommitSummaryStateStore } from '../ai/commitSummaryStore.js';
 import { SessionManager } from '../ai/sessionManager.js';
 import { ClaudeCodeProvider } from '../ai/claudeCodeProvider.js';
-import { CodexSdkProvider } from '../ai/codexSdkProvider.js';
+import { CodexAppServerProvider } from '../ai/codexAppServer/index.js';
+import { CodexLoginManager } from '../ai/codexLogin.js';
+import { getTerminalManager } from '../terminal/terminalManager.js';
+import { getFileBrowser } from '../files/fileBrowser.js';
 import { getSessionRegistry } from '../ai/sessionRegistry.js';
 import { enrichEntry } from '../ai/enrichEntry.js';
 import { getEventStore } from '../storage/eventStore.js';
@@ -14,11 +17,64 @@ import { readdir, stat, readFile } from 'fs/promises';
 import { existsSync } from 'fs';
 import { join, dirname, basename } from 'path';
 import { homedir } from 'os';
+import { spawnAppServer } from '../ai/codexAppServer/index.js';
 const VERSION_CHECK_INTERVAL_MS = 12 * 60 * 60 * 1000; // 12 hours
-const CODEX_MODELS_CHECK_INTERVAL_MS = 12 * 60 * 60 * 1000; // 12 hours
+// model/list reflects the current authenticated account's available models.
+// 30 min strikes a balance: long enough to avoid spawning a fresh app-server
+// every PWA reload; short enough that plan upgrades / model rollouts surface
+// within the same session day. Force-refreshes still bypass the TTL.
+const CODEX_MODELS_TTL_MS = 30 * 60 * 1000;
+/** Shallow equality on a model list. Used to suppress no-op
+ *  `/codex/models` broadcasts after a TTL refresh that returned the
+ *  same list. */
+function codexModelListsEqual(a, b) {
+    if (a === b)
+        return true;
+    if (!a || !b)
+        return false;
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        const ai = a[i], bi = b[i];
+        if (ai.id !== bi.id || ai.name !== bi.name)
+            return false;
+        if (ai.defaultReasoningEffort !== bi.defaultReasoningEffort)
+            return false;
+        if (ai.isDefault !== bi.isDefault)
+            return false;
+        const aE = ai.reasoningEfforts, bE = bi.reasoningEfforts;
+        if (aE !== bE) {
+            if (!aE || !bE)
+                return false;
+            if (aE.length !== bE.length)
+                return false;
+            for (let j = 0; j < aE.length; j++)
+                if (aE[j] !== bE[j])
+                    return false;
+        }
+    }
+    return true;
+}
+/** Map a single `model/list` entry to the lean `CodexModelInfo` the PWA
+ *  picker consumes. Hidden models (e.g. `codex-auto-review`) are caller-
+ *  filtered before this runs. */
+function projectAppServerModel(m) {
+    const reasoningEfforts = [];
+    for (const opt of m.supportedReasoningEfforts) {
+        if (typeof opt.reasoningEffort === 'string')
+            reasoningEfforts.push(opt.reasoningEffort);
+    }
+    return {
+        id: m.id,
+        name: m.displayName || m.id,
+        reasoningEfforts: reasoningEfforts.length > 0 ? reasoningEfforts : undefined,
+        defaultReasoningEffort: m.defaultReasoningEffort,
+        isDefault: m.isDefault || undefined,
+    };
+}
 export class MessageHandler {
     repos;
-    agentVersion = '0.8.1';
+    agentVersion = '0.8.3';
     defaultRepoPath;
     clientRepos = new Map(); // peerAddress -> repoPath
     repoLocks = new Map(); // repoPath -> peerAddress holding lock
@@ -29,18 +85,22 @@ export class MessageHandler {
     /** Per-repo agent-owned commit summary state. The daemon wires the
      *  `state-updated` event to `connection.broadcast` (see service/run.ts). */
     commitSummaryStore = new CommitSummaryStateStore();
-    claudeService = new SessionManager([
-        new ClaudeCodeProvider(),
-        new CodexSdkProvider(),
-    ]);
+    claudeService;
     pushClient = null;
     latestVersionCache = null;
     versionCheckInFlight = null;
     codexModelsCache = null;
     codexModelsCheckInFlight = null;
+    codexModelsUpdateHandler = null;
+    /** Override for tests; defaults to `~/.codex`. Still consulted by
+     *  `getCodexLoginStatus` to read `auth.json`; no longer used for model
+     *  discovery (that flows through `model/list` against a short-lived
+     *  app-server instance). */
+    codexCacheDir;
+    codexLoginManager = new CodexLoginManager();
     onHistoryUpdated;
     productionBuild;
-    constructor(repos, _license, codingPaths, productionBuild = false) {
+    constructor(repos, _license, codingPaths, productionBuild = false, options) {
         this.repos = new Map();
         for (const repo of repos) {
             this.repos.set(repo.path, new GitOperations(repo.path));
@@ -48,6 +108,9 @@ export class MessageHandler {
         this.availableRepos = repos;
         this.defaultRepoPath = repos.length > 0 ? repos[0].path : '';
         this.productionBuild = productionBuild;
+        this.claudeService = options?.sessionManager
+            ?? new SessionManager([new ClaudeCodeProvider(), new CodexAppServerProvider()]);
+        this.codexCacheDir = options?.codexCacheDir ?? join(homedir(), '.codex');
         // Load explicit coding paths only (repos and coding paths are independent)
         if (codingPaths) {
             for (const p of codingPaths) {
@@ -92,48 +155,44 @@ export class MessageHandler {
         return this.versionCheckInFlight;
     }
     /**
-     * Fetch available Codex models from OpenAI /v1/models. Reads API key from
-     * ~/.codex/auth.json (ChatGPT OAuth token or OPENAI_API_KEY). Cached for 12h
-     * with concurrent-request dedup — same pattern as checkLatestVersion.
+     * Resolve the Codex model list for the current authenticated account.
+     *
+     * Source: `model/list` against a short-lived `codex app-server` instance.
+     * The app-server already enforces account-scoped filtering — what we get
+     * back is exactly the list this user can actually invoke (e.g. ChatGPT
+     * users won't see `claude-*` models, API-key users see the API-tier list).
+     * That's what makes this source authoritative: previously we fell through
+     * three sources (`codex debug models` / on-disk cache file / OpenAI
+     * `/v1/models`) none of which knew the caller's plan, so the picker
+     * surfaced models that would later 400 with `BadRequest`.
+     *
+     * Returns `null` if the spawn fails or no models come back. Concurrent
+     * calls dedup via `codexModelsCheckInFlight`. Cache TTL is single-tier
+     * (30 min) — force-refresh bypasses it.
      */
     async fetchCodexModels(force = false) {
-        if (!force && this.codexModelsCache &&
-            Date.now() - this.codexModelsCache.checkedAt < CODEX_MODELS_CHECK_INTERVAL_MS) {
-            return this.codexModelsCache.models;
+        if (!force && this.codexModelsCache) {
+            if (Date.now() - this.codexModelsCache.checkedAt < CODEX_MODELS_TTL_MS) {
+                return this.codexModelsCache.models;
+            }
         }
         if (this.codexModelsCheckInFlight)
             return this.codexModelsCheckInFlight;
         this.codexModelsCheckInFlight = (async () => {
+            const before = this.codexModelsCache?.models;
             try {
-                // Resolve API key: env var first, then ~/.codex/auth.json
-                let apiKey = process.env.OPENAI_API_KEY;
-                if (!apiKey) {
-                    try {
-                        const authPath = join(homedir(), '.codex', 'auth.json');
-                        const raw = await readFile(authPath, 'utf-8');
-                        const auth = JSON.parse(raw);
-                        apiKey = auth.OPENAI_API_KEY || auth.tokens?.access_token;
+                const fromAppServer = await this.fetchCodexModelsFromAppServer();
+                if (fromAppServer && fromAppServer.length > 0) {
+                    this.codexModelsCache = { models: fromAppServer, checkedAt: Date.now() };
+                    // Broadcast to bus subscribers when the list actually changes.
+                    // Same dedup behavior as the previous file-watcher path so a TTL
+                    // refresh that comes back with the same models is silent.
+                    if (!codexModelListsEqual(before, fromAppServer)) {
+                        this.codexModelsUpdateHandler?.(fromAppServer);
                     }
-                    catch { /* no auth file */ }
+                    return fromAppServer;
                 }
-                if (!apiKey)
-                    return null;
-                const res = await fetch('https://api.openai.com/v1/models', {
-                    headers: { Authorization: `Bearer ${apiKey}` },
-                    signal: AbortSignal.timeout(10_000),
-                });
-                if (!res.ok)
-                    return null;
-                const data = await res.json();
-                if (!Array.isArray(data.data))
-                    return null;
-                // Filter to chat-capable models (gpt-*, o*) and sort descending
-                const models = data.data
-                    .filter((m) => /^(gpt-|o\d)/.test(m.id))
-                    .map((m) => ({ id: m.id, name: m.id }))
-                    .sort((a, b) => b.id.localeCompare(a.id));
-                this.codexModelsCache = { models, checkedAt: Date.now() };
-                return models;
+                return null;
             }
             catch {
                 return null;
@@ -144,6 +203,102 @@ export class MessageHandler {
         })();
         return this.codexModelsCheckInFlight;
     }
+    /**
+     * Spawn a short-lived `codex app-server`, run `initialize` + `model/list`,
+     * shut down. Filters out `hidden: true` models (e.g. `codex-auto-review`)
+     * so they don't leak into the picker. Returns `null` on any failure —
+     * caller treats null as "no source available, picker falls back to
+     * hard-coded defaults".
+     */
+    async fetchCodexModelsFromAppServer() {
+        let handle = null;
+        try {
+            handle = await spawnAppServer({
+                clientInfo: { name: 'quicksave-agent', title: 'Quicksave Agent', version: '0.0.0' },
+                capabilities: { experimentalApi: false, optOutNotificationMethods: null },
+            });
+            const res = await handle.rpc.request('model/list', { cursor: null, limit: null, includeHidden: false });
+            return res.data
+                .filter((m) => !m.hidden)
+                .map((m) => projectAppServerModel(m));
+        }
+        catch (err) {
+            console.warn('[codex-models] model/list failed:', err instanceof Error ? err.message : err);
+            return null;
+        }
+        finally {
+            if (handle) {
+                try {
+                    await handle.shutdown();
+                }
+                catch { /* best-effort */ }
+            }
+        }
+    }
+    /**
+     * Resolve a user-provided model into one the current account actually
+     * supports. If the cache is empty (model/list never succeeded) the
+     * requested value passes through — we'd rather try and let codex 400 than
+     * silently swallow a model the user explicitly chose. If the cache exists
+     * but the requested model isn't in it, we fall back to whichever model
+     * `model/list` flagged as `isDefault` (e.g. ChatGPT account picks `gpt-5.5`).
+     * Non-codex agents are pass-through; their model space is independent.
+     */
+    validateCodexModel(requested, agentId) {
+        if (agentId !== 'codex')
+            return requested;
+        const cached = this.codexModelsCache?.models;
+        if (!cached || cached.length === 0)
+            return requested;
+        if (requested && cached.some((m) => m.id === requested))
+            return requested;
+        const fallback = cached.find((m) => m.isDefault) ?? cached[0];
+        if (requested && fallback?.id !== requested) {
+            console.warn(`[codex-models] requested model "${requested}" not in account list; coercing to "${fallback?.id}"`);
+        }
+        return fallback?.id ?? requested;
+    }
+    /** Snapshot accessor for the bus `/codex/models` subscription. */
+    getCachedCodexModels() {
+        return this.codexModelsCache?.models ?? [];
+    }
+    /**
+     * Wire the daemon's bus broadcast for unsolicited model-list pushes.
+     * Called once during daemon boot; the watcher invokes this on cache change.
+     */
+    setCodexModelsUpdateHandler(handler) {
+        this.codexModelsUpdateHandler = handler;
+    }
+    /**
+     * Prime the in-memory cache at daemon boot. No-op if already cached.
+     * Replaces the previous file-watcher path: there's no on-disk file we
+     * watch any more, so the only refresh trigger is TTL expiry (30 min)
+     * or an explicit `force=true` call. The eager prime keeps the first
+     * `/codex/models` subscriber from getting an empty snapshot.
+     */
+    primeCodexModelsCache() {
+        void this.fetchCodexModels().catch(() => { });
+    }
+    /**
+     * Best-effort check for whether the local Codex CLI has valid auth.
+     * The PWA uses this to prompt for login when it returns false. Does not
+     * validate the token — just checks that a credential source exists.
+     */
+    async getCodexLoginStatus() {
+        if (process.env.OPENAI_API_KEY)
+            return { loggedIn: true, method: 'api-key' };
+        try {
+            const authPath = join(this.codexCacheDir, 'auth.json');
+            const raw = await readFile(authPath, 'utf-8');
+            const auth = JSON.parse(raw);
+            if (auth.OPENAI_API_KEY)
+                return { loggedIn: true, method: 'api-key' };
+            if (auth.tokens?.access_token)
+                return { loggedIn: true, method: 'chatgpt' };
+        }
+        catch { /* no auth file */ }
+        return { loggedIn: false };
+    }
     addRepo(repo) {
         if (this.repos.has(repo.path))
             return;
@@ -159,6 +314,12 @@ export class MessageHandler {
         if (this.defaultRepoPath === path) {
             this.defaultRepoPath = this.availableRepos.length > 0 ? this.availableRepos[0].path : '';
         }
+        // Drop stale per-peer pins to this path so the next handshake-ack
+        // doesn't return a deleted repo.
+        for (const [peer, repo] of this.clientRepos) {
+            if (repo === path)
+                this.clientRepos.delete(peer);
+        }
     }
     getClientRepoPath(peerAddress) {
         return this.clientRepos.get(peerAddress) || this.defaultRepoPath;
@@ -185,7 +346,14 @@ export class MessageHandler {
         }
     }
     removeClient(peerAddress) {
-        this.clientRepos.delete(peerAddress);
+        // Intentionally keep `clientRepos[peer]`: peer identity is a stable
+        // public key, and the PWA keeps its selected repo across reconnects
+        // (e.g., background → resume). Clearing would force the next
+        // handshake-ack to return `defaultRepoPath`, which the PWA would then
+        // hydrate into gitStore before its post-reconnect `agent:switch-repo`
+        // can land — racing `git:status` requests stamped with the default
+        // path would pass the REPO_MISMATCH guard and paint the default
+        // repo's (typically clean) status over the user's real repo view.
         for (const [repoPath, holder] of this.repoLocks) {
             if (holder === peerAddress) {
                 this.repoLocks.delete(repoPath);
@@ -227,7 +395,9 @@ export class MessageHandler {
         return this.aiService;
     }
     async handleMessage(message, peerAddress = 'default') {
-        const isVerbose = message.type.startsWith('claude:') || message.type.startsWith('agent:add');
+        const isVerbose = message.type.startsWith('claude:') ||
+            message.type.startsWith('agent:add') ||
+            message.type.startsWith('project:');
         if (isVerbose) {
             console.log(`[msg] ${message.type} from ${peerAddress.slice(0, 12)}`);
         }
@@ -330,6 +500,12 @@ export class MessageHandler {
                 return this.handleAgentRestart(message);
             case 'codex:list-models':
                 return this.handleCodexListModels(message);
+            case 'codex:login-start':
+                return this.handleCodexLoginStart(message);
+            case 'codex:login-status':
+                return this.handleCodexLoginStatus(message);
+            case 'codex:login-cancel':
+                return this.handleCodexLoginCancel(message);
             // Claude Code SDK
             case 'claude:start':
                 return this.handleClaudeStart(message, peerAddress);
@@ -339,6 +515,8 @@ export class MessageHandler {
                 return this.handleClaudeCancel(message);
             case 'claude:close':
                 return this.handleClaudeClose(message);
+            case 'claude:end-task':
+                return this.handleClaudeEndTask(message);
             case 'claude:user-input-response':
                 return this.handleClaudeUserInputResponse(message);
             case 'claude:set-preferences':
@@ -365,6 +543,20 @@ export class MessageHandler {
                 return this.handleDeleteProject(message);
             case 'push:subscription-offer':
                 return this.handlePushSubscriptionOffer(message);
+            case 'terminal:create':
+                return this.handleTerminalCreate(message);
+            case 'terminal:input':
+                return this.handleTerminalInput(message);
+            case 'terminal:resize':
+                return this.handleTerminalResize(message);
+            case 'terminal:close':
+                return this.handleTerminalClose(message);
+            case 'terminal:rename':
+                return this.handleTerminalRename(message);
+            case 'files:list':
+                return this.handleFilesList(message);
+            case 'files:read':
+                return this.handleFilesRead(message);
             default:
                 return this.createErrorResponse(message.id, 'UNKNOWN_MESSAGE_TYPE', `Unknown message type: ${message.type}`);
         }
@@ -1316,27 +1508,68 @@ export class MessageHandler {
     }
     async handleCodexListModels(message) {
         try {
-            const models = await this.fetchCodexModels(/* force */ true);
-            const response = createMessage('codex:list-models:response', { models: models ?? [] });
+            const [models, auth] = await Promise.all([
+                this.fetchCodexModels(/* force */ true),
+                this.getCodexLoginStatus(),
+            ]);
+            const response = createMessage('codex:list-models:response', { models: models ?? [], loggedIn: auth.loggedIn });
             response.id = message.id;
             return response;
         }
         catch (error) {
-            const response = createMessage('codex:list-models:response', { models: [], error: error instanceof Error ? error.message : 'Failed to fetch models' });
+            const response = createMessage('codex:list-models:response', {
+                models: [],
+                error: error instanceof Error ? error.message : 'Failed to fetch models',
+                loggedIn: false,
+            });
             response.id = message.id;
             return response;
         }
     }
+    /**
+     * Kick off the Codex device-auth OAuth flow on the daemon. Returns the
+     * one-time verification URL + user code so the PWA can display them — the
+     * user typically completes this on a different device (e.g. phone).
+     */
+    async handleCodexLoginStart(message) {
+        const state = await this.codexLoginManager.start();
+        const ok = state.loggedIn || Boolean(state.userCode && state.verificationUrl);
+        const response = createMessage('codex:login-start:response', { ok, ...state });
+        response.id = message.id;
+        return response;
+    }
+    async handleCodexLoginStatus(message) {
+        const state = await this.codexLoginManager.getStatus();
+        const response = createMessage('codex:login-status:response', state);
+        response.id = message.id;
+        return response;
+    }
+    async handleCodexLoginCancel(message) {
+        this.codexLoginManager.cancel();
+        const response = createMessage('codex:login-cancel:response', { ok: true });
+        response.id = message.id;
+        return response;
+    }
+    /** Expose for the daemon to wire login-state updates into bus broadcasts. */
+    getCodexLoginManager() {
+        return this.codexLoginManager;
+    }
     // ============================================================================
     // Claude Code SDK Handlers
     // ============================================================================
     async handleClaudeStart(message, peerAddress) {
-        const { prompt, cwd: payloadCwd, agent, allowedTools, systemPrompt, model, permissionMode, sandboxed } = message.payload;
+        const { prompt, cwd: payloadCwd, agent, allowedTools, systemPrompt, model, permissionMode, sandboxed, reasoningEffort, contextWindow } = message.payload;
         const legacyProvider = message.payload.provider;
         const cwd = payloadCwd || this.getClientRepoPath(peerAddress);
         const streamId = generateMessageId();
         const resolvedAgent = agent ?? (legacyProvider === 'codex-mcp' ? 'codex' : legacyProvider ? 'claude-code' : undefined);
-        console.log(`[agent:start] agent=${resolvedAgent ?? 'default'} model=${model ?? 'default'} cwd=${cwd} prompt=${prompt.slice(0, 80)}${sandboxed ? ' [sandboxed]' : ''}`);
+        // Coerce a Codex model the user's account doesn't actually support
+        // (e.g. they kept `claude-opus-4-7` selected before switching to a
+        // ChatGPT-account Codex session). Without this, codex would 400 on
+        // turn/start with `BadRequest`. Pass-through for non-codex agents and
+        // when the cache hasn't loaded yet.
+        const validatedModel = this.validateCodexModel(model, resolvedAgent ?? 'claude-code');
+        console.log(`[agent:start] agent=${resolvedAgent ?? 'default'} model=${validatedModel ?? 'default'}${validatedModel !== model ? ` (coerced from ${model})` : ''} cwd=${cwd} prompt=${prompt.slice(0, 80)}${sandboxed ? ' [sandboxed]' : ''}`);
         try {
             const sessionId = await this.claudeService.startSession({
                 prompt,
@@ -1345,9 +1578,11 @@ export class MessageHandler {
                 agent: resolvedAgent,
                 allowedTools,
                 systemPrompt,
-                model,
+                model: validatedModel,
                 permissionMode,
                 sandboxed,
+                reasoningEffort,
+                contextWindow,
             });
             console.log(`[agent:start] session created: ${sessionId} agent=${resolvedAgent ?? 'default'}`);
             // Register in session history
@@ -1372,6 +1607,9 @@ export class MessageHandler {
                 lastAccessedAt: now,
                 permissionMode,
                 sandboxed: sandboxed || undefined,
+                model,
+                reasoningEffort,
+                contextWindow,
             });
             this.onHistoryUpdated?.(cwd, registry.getEntry(cwd, sessionId), 'upsert');
             const response = createMessage('claude:start:response', { success: true, sessionId, streamId });
@@ -1450,6 +1688,36 @@ export class MessageHandler {
         response.id = message.id;
         return response;
     }
+    /**
+     * End Task: archive the session's registry entry, then terminate the live
+     * CLI process. Order matters — closeSession emits a session-updated whose
+     * `archived` flag is derived from "no in-memory entry AND no active
+     * registry entry". Archiving first ensures that emit carries archived=true,
+     * which the PWA reads as the "navigate away" signal.
+     *
+     * cwd lookup: prefer the live in-memory entry; fall back to the registry
+     * so users can still archive a stale active entry whose CLI has already
+     * exited (cold-closed sessions still appear in the drawer).
+     */
+    handleClaudeEndTask(message) {
+        const { sessionId } = message.payload;
+        const cwd = this.claudeService.getSessionCwd(sessionId)
+            ?? getSessionRegistry().findBySessionId(sessionId)?.cwd;
+        let archived = false;
+        if (cwd) {
+            const updated = getSessionRegistry().updateEntry(cwd, sessionId, { archived: true });
+            if (updated) {
+                archived = true;
+                this.onHistoryUpdated?.(cwd, updated, 'upsert');
+            }
+        }
+        const closed = this.claudeService.closeSession(sessionId);
+        const success = closed || archived;
+        console.log(`[agent:end-task] session=${sessionId} closed=${closed} archived=${archived} cwd=${cwd ?? 'unknown'}`);
+        const response = createMessage('claude:end-task:response', { success, error: success ? undefined : 'Session not found' });
+        response.id = message.id;
+        return response;
+    }
     handleClaudeUserInputResponse(message) {
         const resolved = this.claudeService.resolveUserInput(message.payload);
         console.log(`[agent:user-input-response] requestId=${message.payload.requestId} action=${message.payload.action} resolved=${resolved}`);
@@ -1501,7 +1769,21 @@ export class MessageHandler {
         return response;
     }
     async handleSetSessionConfig(message) {
-        const { sessionId, key, value } = message.payload;
+        const { sessionId, key } = message.payload;
+        let { value } = message.payload;
+        // Same coercion as handleClaudeStart: if the PWA pushed a model the
+        // current Codex account can't run, swap it for the account default
+        // before the override hits the next turn/start. The `agent` lookup
+        // tolerates inactive sessions (returns the registry-stored agent or
+        // falls back to the default provider).
+        if (key === 'model' && typeof value === 'string') {
+            const agentId = this.claudeService.getSessionAgent(sessionId);
+            const coerced = this.validateCodexModel(value, agentId);
+            if (coerced !== value) {
+                console.log(`[agent:set-config] coerced model "${value}" → "${coerced}" for session=${sessionId.slice(0, 8)}`);
+                value = coerced ?? value;
+            }
+        }
         console.log(`[agent:set-config] session=${sessionId.slice(0, 8)} ${key}=${String(value)}`);
         try {
             const config = await this.claudeService.setSessionConfig(sessionId, key, value);
@@ -1623,19 +1905,24 @@ export class MessageHandler {
         const repos = [];
         const seen = new Set();
         try {
-            // 1. Check if cwd itself is a git repo
-            const rootBranch = await this.getGitBranchQuiet(cwd);
-            if (rootBranch !== undefined) {
+            // 1. Check if cwd itself is a git repo. Use the cheap fs check rather
+            // than spawning `git branch -a` so a transient git failure (EAGAIN
+            // under daemon load, refs being rewritten by a concurrent fetch/gc,
+            // detached HEAD returning empty `current`) doesn't drop the root
+            // and make the PWA's Git section flash empty. Branch + dirty are
+            // filled in best-effort below; undefined just means "unknown".
+            const isRootRepo = existsSync(join(cwd, '.git'));
+            if (isRootRepo) {
                 repos.push({
                     path: cwd,
                     name: basename(cwd),
-                    currentBranch: rootBranch || undefined,
+                    currentBranch: (await this.getGitBranchQuiet(cwd)) || undefined,
                     hasChanges: await this.getGitDirtyQuiet(cwd),
                 });
                 seen.add(cwd);
             }
             // 2. Find submodules via git
-            if (rootBranch !== undefined) {
+            if (isRootRepo) {
                 try {
                     const git = new GitOperations(cwd);
                     const submodules = await git.getSubmodules();
@@ -1725,10 +2012,9 @@ export class MessageHandler {
     handleDeleteProject(message) {
         const { cwd } = message.payload;
         const registry = getSessionRegistry();
-        for (const s of this.claudeService.getActiveSessions()) {
-            if (s.cwd === cwd) {
-                this.claudeService.closeSession(s.sessionId);
-            }
+        const liveHere = this.claudeService.getActiveSessions().filter((s) => s.cwd === cwd);
+        for (const s of liveHere) {
+            this.claudeService.closeSession(s.sessionId);
         }
         const active = registry.getEntriesForProject(cwd);
         let archivedCount = 0;
@@ -1739,10 +2025,12 @@ export class MessageHandler {
                 this.onHistoryUpdated?.(cwd, updated, 'upsert');
             }
         }
-        if (this.codingPaths.has(cwd)) {
+        const hadCodingPath = this.codingPaths.has(cwd);
+        if (hadCodingPath) {
             this.codingPaths.delete(cwd);
             removeManagedCodingPath(cwd);
         }
+        console.log(`[project:delete] cwd=${cwd} closedSessions=${liveHere.length} archived=${archivedCount} removedCodingPath=${hadCodingPath}`);
         const response = createMessage('project:delete:response', { success: true, archivedCount });
         response.id = message.id;
         return response;
@@ -1787,6 +2075,100 @@ export class MessageHandler {
         response.id = message.id;
         return response;
     }
+    // ── Terminal (PTY) handlers ──────────────────────────────────────────────
+    async handleTerminalCreate(message) {
+        let payload;
+        try {
+            const summary = await getTerminalManager().create(message.payload);
+            payload = { success: true, terminal: summary };
+        }
+        catch (err) {
+            payload = {
+                success: false,
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+        const response = createMessage('terminal:create:response', payload);
+        response.id = message.id;
+        return response;
+    }
+    async handleTerminalInput(message) {
+        let payload;
+        try {
+            getTerminalManager().write(message.payload.terminalId, message.payload.data);
+            payload = { success: true };
+        }
+        catch (err) {
+            payload = {
+                success: false,
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+        const response = createMessage('terminal:input:response', payload);
+        response.id = message.id;
+        return response;
+    }
+    async handleTerminalResize(message) {
+        let payload;
+        try {
+            getTerminalManager().resize(message.payload.terminalId, message.payload.cols, message.payload.rows);
+            payload = { success: true };
+        }
+        catch (err) {
+            payload = {
+                success: false,
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+        const response = createMessage('terminal:resize:response', payload);
+        response.id = message.id;
+        return response;
+    }
+    async handleTerminalClose(message) {
+        let payload;
+        try {
+            getTerminalManager().close(message.payload.terminalId, message.payload.force ?? false);
+            payload = { success: true };
+        }
+        catch (err) {
+            payload = {
+                success: false,
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+        const response = createMessage('terminal:close:response', payload);
+        response.id = message.id;
+        return response;
+    }
+    async handleTerminalRename(message) {
+        let payload;
+        try {
+            const summary = getTerminalManager().rename(message.payload.terminalId, message.payload.title);
+            payload = { success: true, terminal: summary };
+        }
+        catch (err) {
+            payload = {
+                success: false,
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+        const response = createMessage('terminal:rename:response', payload);
+        response.id = message.id;
+        return response;
+    }
+    // ── File browser handlers ────────────────────────────────────────────────
+    async handleFilesList(message) {
+        const payload = await getFileBrowser().list(message.payload);
+        const response = createMessage('files:list:response', payload);
+        response.id = message.id;
+        return response;
+    }
+    async handleFilesRead(message) {
+        const payload = await getFileBrowser().read(message.payload);
+        const response = createMessage('files:read:response', payload);
+        response.id = message.id;
+        return response;
+    }
     createErrorResponse(id, code, message) {
         const response = createMessage('error', { code, message });
         response.id = id;