@sumicom/quicksave 0.8.18 → 0.8.20

package/dist/handlers/messageHandler.js

@@ -93,11 +93,35 @@ function projectAppServerModel(m) {
         isDefault: m.isDefault || undefined,
     };
 }
+function isRepoScopedRequest(message) {
+    if (message.type.startsWith('git:') && !message.type.endsWith(':response'))
+        return true;
+    return message.type === 'ai:generate-commit-summary' || message.type === 'ai:commit-summary:clear';
+}
+function payloadRepoPath(payload) {
+    if (typeof payload !== 'object' || payload === null)
+        return undefined;
+    const value = payload.repoPath;
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+async function hasPlausibleGitMarker(path) {
+    try {
+        const gitPath = join(path, '.git');
+        const marker = await stat(gitPath);
+        if (marker.isFile())
+            return true;
+        if (!marker.isDirectory())
+            return false;
+        return (await readdir(gitPath)).length > 0;
+    }
+    catch {
+        return false;
+    }
+}
 export class MessageHandler {
     repos;
     agentVersion = '0.8.18';
     defaultRepoPath;
-    clientRepos = new Map(); // peerAddress -> repoPath
     repoLocks = new Map(); // repoPath -> peerAddress holding lock
     availableRepos;
     codingPaths = new Map(); // path -> CodingPath
@@ -364,24 +388,23 @@ 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;
+    getRequiredRepoPath(message) {
+        if (!message.repoPath) {
+            throw new Error('Missing repoPath for repo-scoped request');
+        }
+        return message.repoPath;
     }
-    getGit(peerAddress) {
-        const repoPath = this.getClientRepoPath(peerAddress);
+    getGitForRepoPath(repoPath) {
         const git = this.repos.get(repoPath);
         if (!git) {
-            throw new Error('No repository selected. Please add a repository first.');
+            throw new Error(`Repository not available: ${repoPath}`);
         }
         return git;
     }
+    getGit(message) {
+        return this.getGitForRepoPath(this.getRequiredRepoPath(message));
+    }
     acquireRepoLock(repoPath, peerAddress) {
         const holder = this.repoLocks.get(repoPath);
         if (holder && holder !== peerAddress) {
@@ -396,14 +419,6 @@ export class MessageHandler {
         }
     }
     removeClient(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);
@@ -464,39 +479,36 @@ export class MessageHandler {
         if (isVerbose) {
             console.log(`[msg] ${message.type} from ${peerAddress.slice(0, 12)}`);
         }
-        // Repo-scoped guard for git:* requests. The PWA stamps `repoPath` on
-        // each request so a response can't be misapplied if the user has since
-        // switched repos. If the envelope's repoPath differs from the peer's
-        // current repo, reject with REPO_MISMATCH so the client can discard
-        // rather than render stale data.
-        if (message.type.startsWith('git:') &&
-            !message.type.endsWith(':response') &&
-            typeof message.repoPath === 'string') {
-            const currentRepo = this.getClientRepoPath(peerAddress);
-            if (message.repoPath !== currentRepo) {
-                const err = this.createErrorResponse(message.id, 'REPO_MISMATCH', `Repo mismatch: request expected ${message.repoPath}, peer is on ${currentRepo}`);
-                err.repoPath = currentRepo;
-                return err;
+        const repoScoped = isRepoScopedRequest(message);
+        if (repoScoped) {
+            const requestedRepoPath = message.repoPath ?? payloadRepoPath(message.payload);
+            if (!requestedRepoPath) {
+                return this.createErrorResponse(message.id, 'MISSING_REPO_PATH', `${message.type} requires repoPath`);
+            }
+            const repo = await this.ensureRepoAvailableForPath(requestedRepoPath);
+            if (!repo || !this.repos.has(repo.path)) {
+                return this.createErrorResponse(message.id, 'REPO_NOT_AVAILABLE', `Repository not available: ${requestedRepoPath}`);
             }
+            message.repoPath = repo.path;
         }
         const response = await this.dispatch(message, peerAddress);
-        // Stamp git:* responses with the repo the agent actually used so the
-        // PWA can validate before applying to the store.
-        if (response.type.startsWith('git:') && response.type.endsWith(':response')) {
-            response.repoPath = this.getClientRepoPath(peerAddress);
+        // Stamp repo-scoped responses with the repo the agent actually used so
+        // clients can validate before applying the result to local UI state.
+        if (repoScoped && response.type !== 'error') {
+            response.repoPath = message.repoPath;
         }
         return response;
     }
     async dispatch(message, peerAddress) {
         switch (message.type) {
             case 'handshake':
-                return this.handleHandshake(message, peerAddress);
+                return this.handleHandshake(message);
             case 'ping':
                 return createMessage('pong', { timestamp: Date.now() });
             case 'git:status':
-                return this.handleStatus(message, peerAddress);
+                return this.handleStatus(message);
             case 'git:diff':
-                return this.handleDiff(message, peerAddress);
+                return this.handleDiff(message);
             case 'git:stage':
                 return this.handleStage(message, peerAddress);
             case 'git:unstage':
@@ -508,9 +520,9 @@ export class MessageHandler {
             case 'git:commit':
                 return this.handleCommit(message, peerAddress);
             case 'git:log':
-                return this.handleLog(message, peerAddress);
+                return this.handleLog(message);
             case 'git:branches':
-                return this.handleBranches(peerAddress);
+                return this.handleBranches(message);
             case 'git:checkout':
                 return this.handleCheckout(message, peerAddress);
             case 'git:discard':
@@ -518,29 +530,27 @@ export class MessageHandler {
             case 'git:untrack':
                 return this.handleUntrack(message, peerAddress);
             case 'git:submodules':
-                return this.handleSubmodules(message, peerAddress);
+                return this.handleSubmodules(message);
             case 'git:config-get':
-                return this.handleGitConfigGet(message, peerAddress);
+                return this.handleGitConfigGet(message);
             case 'git:config-set':
-                return this.handleGitConfigSet(message, peerAddress);
+                return this.handleGitConfigSet(message);
             case 'git:gitignore-add':
                 return this.handleGitignoreAdd(message, peerAddress);
             case 'git:gitignore-read':
-                return this.handleGitignoreRead(message, peerAddress);
+                return this.handleGitignoreRead(message);
             case 'git:gitignore-write':
                 return this.handleGitignoreWrite(message, peerAddress);
             case 'ai:generate-commit-summary':
-                return this.handleGenerateCommitSummary(message, peerAddress);
+                return this.handleGenerateCommitSummary(message);
             case 'ai:commit-summary:clear':
-                return this.handleClearCommitSummary(message, peerAddress);
+                return this.handleClearCommitSummary(message);
             case 'ai:set-api-key':
                 return this.handleSetApiKey(message);
             case 'ai:get-api-key-status':
                 return this.handleGetApiKeyStatus(message);
             case 'agent:list-repos':
-                return this.handleListRepos(message, peerAddress);
-            case 'agent:switch-repo':
-                return this.handleSwitchRepo(message, peerAddress);
+                return this.handleListRepos(message);
             case 'agent:browse-directory':
                 return this.handleBrowseDirectory(message);
             case 'agent:add-repo':
@@ -601,7 +611,7 @@ export class MessageHandler {
             case 'claude:set-session-permission':
                 return this.handleSetSessionPermission(message);
             case 'claude:get-cards':
-                return this.handleClaudeGetCards(message, peerAddress);
+                return this.handleClaudeGetCards(message);
             case 'voice-agent:attach':
                 return this.handleVoiceAgentAttach(message);
             case 'voice-agent:detach':
@@ -668,7 +678,7 @@ export class MessageHandler {
                 return this.createErrorResponse(message.id, 'UNKNOWN_MESSAGE_TYPE', `Unknown message type: ${message.type}`);
         }
     }
-    async handleHandshake(message, peerAddress) {
+    async handleHandshake(message) {
         // Fire-and-forget: check npm registry + OpenAI models (12h dedup each)
         this.checkLatestVersion().catch(() => { });
         this.fetchCodexModels().catch(() => { });
@@ -676,7 +686,7 @@ export class MessageHandler {
         const response = createMessage('handshake:ack', {
             success: true,
             agentVersion: this.agentVersion,
-            repoPath: this.getClientRepoPath(peerAddress),
+            repoPath: this.defaultRepoPath,
             availableRepos: this.availableRepos,
             availableCodingPaths: [...this.codingPaths.values()],
             preferences: this.claudeService.getPreferences(),
@@ -690,21 +700,21 @@ export class MessageHandler {
         response.id = message.id;
         return response;
     }
-    async handleStatus(message, peerAddress) {
-        const status = await this.getGit(peerAddress).getStatus();
+    async handleStatus(message) {
+        const status = await this.getGit(message).getStatus();
         const response = createMessage('git:status:response', status);
         response.id = message.id;
         return response;
     }
-    async handleDiff(message, peerAddress) {
+    async handleDiff(message) {
         const { path, staged } = message.payload;
-        const diff = await this.getGit(peerAddress).getDiff(path, staged);
+        const diff = await this.getGit(message).getDiff(path, staged);
         const response = createMessage('git:diff:response', diff);
         response.id = message.id;
         return response;
     }
     async handleStage(message, peerAddress) {
-        const repoPath = this.getClientRepoPath(peerAddress);
+        const repoPath = this.getRequiredRepoPath(message);
         if (!this.acquireRepoLock(repoPath, peerAddress)) {
             const response = createMessage('git:stage:response', {
                 success: false,
@@ -714,7 +724,7 @@ export class MessageHandler {
             return response;
         }
         try {
-            await this.getGit(peerAddress).stage(message.payload.paths);
+            await this.getGit(message).stage(message.payload.paths);
             const response = createMessage('git:stage:response', { success: true });
             response.id = message.id;
             return response;
@@ -732,7 +742,7 @@ export class MessageHandler {
         }
     }
     async handleUnstage(message, peerAddress) {
-        const repoPath = this.getClientRepoPath(peerAddress);
+        const repoPath = this.getRequiredRepoPath(message);
         if (!this.acquireRepoLock(repoPath, peerAddress)) {
             const response = createMessage('git:unstage:response', {
                 success: false,
@@ -742,7 +752,7 @@ export class MessageHandler {
             return response;
         }
         try {
-            await this.getGit(peerAddress).unstage(message.payload.paths);
+            await this.getGit(message).unstage(message.payload.paths);
             const response = createMessage('git:unstage:response', { success: true });
             response.id = message.id;
             return response;
@@ -760,7 +770,7 @@ export class MessageHandler {
         }
     }
     async handleStagePatch(message, peerAddress) {
-        const repoPath = this.getClientRepoPath(peerAddress);
+        const repoPath = this.getRequiredRepoPath(message);
         if (!this.acquireRepoLock(repoPath, peerAddress)) {
             const response = createMessage('git:stage-patch:response', {
                 success: false,
@@ -770,7 +780,7 @@ export class MessageHandler {
             return response;
         }
         try {
-            await this.getGit(peerAddress).stagePatch(message.payload.patch);
+            await this.getGit(message).stagePatch(message.payload.patch);
             const response = createMessage('git:stage-patch:response', { success: true });
             response.id = message.id;
             return response;
@@ -788,7 +798,7 @@ export class MessageHandler {
         }
     }
     async handleUnstagePatch(message, peerAddress) {
-        const repoPath = this.getClientRepoPath(peerAddress);
+        const repoPath = this.getRequiredRepoPath(message);
         if (!this.acquireRepoLock(repoPath, peerAddress)) {
             const response = createMessage('git:unstage-patch:response', {
                 success: false,
@@ -798,7 +808,7 @@ export class MessageHandler {
             return response;
         }
         try {
-            await this.getGit(peerAddress).unstagePatch(message.payload.patch);
+            await this.getGit(message).unstagePatch(message.payload.patch);
             const response = createMessage('git:unstage-patch:response', { success: true });
             response.id = message.id;
             return response;
@@ -816,7 +826,7 @@ export class MessageHandler {
         }
     }
     async handleCommit(message, peerAddress) {
-        const repoPath = this.getClientRepoPath(peerAddress);
+        const repoPath = this.getRequiredRepoPath(message);
         if (!this.acquireRepoLock(repoPath, peerAddress)) {
             const response = createMessage('git:commit:response', {
                 success: false,
@@ -827,7 +837,7 @@ export class MessageHandler {
         }
         try {
             const { message: commitMessage, description, attribution } = message.payload;
-            const hash = await this.getGit(peerAddress).commit(commitMessage, description, attribution ?? true);
+            const hash = await this.getGit(message).commit(commitMessage, description, attribution ?? true);
             // The pending AI suggestion describes the diff we just committed, so
             // it's stale now — clear it (also broadcasts state → idle to all peers).
             this.commitSummaryStore.clear(repoPath);
@@ -850,22 +860,22 @@ export class MessageHandler {
             this.releaseRepoLock(repoPath, peerAddress);
         }
     }
-    async handleLog(message, peerAddress) {
+    async handleLog(message) {
         const limit = message.payload.limit || 50;
-        const commits = await this.getGit(peerAddress).getLog(limit);
+        const commits = await this.getGit(message).getLog(limit);
         const response = createMessage('git:log:response', { commits });
         response.id = message.id;
         return response;
     }
-    async handleBranches(peerAddress) {
-        const { branches, current } = await this.getGit(peerAddress).getBranches();
+    async handleBranches(message) {
+        const { branches, current } = await this.getGit(message).getBranches();
         return createMessage('git:branches:response', {
             branches,
             current,
         });
     }
     async handleCheckout(message, peerAddress) {
-        const repoPath = this.getClientRepoPath(peerAddress);
+        const repoPath = this.getRequiredRepoPath(message);
         if (!this.acquireRepoLock(repoPath, peerAddress)) {
             const response = createMessage('git:checkout:response', {
                 success: false,
@@ -876,7 +886,7 @@ export class MessageHandler {
         }
         try {
             const { branch, create } = message.payload;
-            await this.getGit(peerAddress).checkout(branch, create);
+            await this.getGit(message).checkout(branch, create);
             const response = createMessage('git:checkout:response', { success: true });
             response.id = message.id;
             return response;
@@ -894,7 +904,7 @@ export class MessageHandler {
         }
     }
     async handleDiscard(message, peerAddress) {
-        const repoPath = this.getClientRepoPath(peerAddress);
+        const repoPath = this.getRequiredRepoPath(message);
         if (!this.acquireRepoLock(repoPath, peerAddress)) {
             const response = createMessage('git:discard:response', {
                 success: false,
@@ -904,7 +914,7 @@ export class MessageHandler {
             return response;
         }
         try {
-            await this.getGit(peerAddress).discard(message.payload.paths);
+            await this.getGit(message).discard(message.payload.paths);
             const response = createMessage('git:discard:response', { success: true });
             response.id = message.id;
             return response;
@@ -922,7 +932,7 @@ export class MessageHandler {
         }
     }
     async handleUntrack(message, peerAddress) {
-        const repoPath = this.getClientRepoPath(peerAddress);
+        const repoPath = this.getRequiredRepoPath(message);
         if (!this.acquireRepoLock(repoPath, peerAddress)) {
             const response = createMessage('git:untrack:response', {
                 success: false,
@@ -932,7 +942,7 @@ export class MessageHandler {
             return response;
         }
         try {
-            await this.getGit(peerAddress).untrack(message.payload.paths);
+            await this.getGit(message).untrack(message.payload.paths);
             const response = createMessage('git:untrack:response', { success: true });
             response.id = message.id;
             return response;
@@ -949,10 +959,10 @@ export class MessageHandler {
             this.releaseRepoLock(repoPath, peerAddress);
         }
     }
-    async handleSubmodules(message, peerAddress) {
-        const git = this.getGit(peerAddress);
+    async handleSubmodules(message) {
+        const git = this.getGit(message);
         const subs = await git.getSubmodules();
-        // Auto-register submodule paths so switch-repo works
+        // Auto-register submodule paths so later explicit repoPath requests work.
         for (const sub of subs) {
             if (!this.repos.has(sub.path)) {
                 this.repos.set(sub.path, new GitOperations(sub.path));
@@ -965,16 +975,16 @@ export class MessageHandler {
         response.id = message.id;
         return response;
     }
-    async handleGitConfigGet(message, peerAddress) {
-        const identity = await this.getGit(peerAddress).getIdentity();
+    async handleGitConfigGet(message) {
+        const identity = await this.getGit(message).getIdentity();
         const response = createMessage('git:config-get:response', identity);
         response.id = message.id;
         return response;
     }
-    async handleGitConfigSet(message, peerAddress) {
+    async handleGitConfigSet(message) {
         try {
             const { name, email } = message.payload;
-            await this.getGit(peerAddress).setIdentity(name, email);
+            await this.getGit(message).setIdentity(name, email);
             const response = createMessage('git:config-set:response', { success: true });
             response.id = message.id;
             return response;
@@ -989,7 +999,7 @@ export class MessageHandler {
         }
     }
     async handleGitignoreAdd(message, peerAddress) {
-        const repoPath = this.getClientRepoPath(peerAddress);
+        const repoPath = this.getRequiredRepoPath(message);
         if (!this.acquireRepoLock(repoPath, peerAddress)) {
             const response = createMessage('git:gitignore-add:response', {
                 success: false,
@@ -999,7 +1009,7 @@ export class MessageHandler {
             return response;
         }
         try {
-            await this.getGit(peerAddress).addToGitignore(message.payload.pattern);
+            await this.getGit(message).addToGitignore(message.payload.pattern);
             const response = createMessage('git:gitignore-add:response', { success: true });
             response.id = message.id;
             return response;
@@ -1016,14 +1026,14 @@ export class MessageHandler {
             this.releaseRepoLock(repoPath, peerAddress);
         }
     }
-    async handleGitignoreRead(message, peerAddress) {
-        const { content, exists } = await this.getGit(peerAddress).readGitignore();
+    async handleGitignoreRead(message) {
+        const { content, exists } = await this.getGit(message).readGitignore();
         const response = createMessage('git:gitignore-read:response', { content, exists });
         response.id = message.id;
         return response;
     }
     async handleGitignoreWrite(message, peerAddress) {
-        const repoPath = this.getClientRepoPath(peerAddress);
+        const repoPath = this.getRequiredRepoPath(message);
         if (!this.acquireRepoLock(repoPath, peerAddress)) {
             const response = createMessage('git:gitignore-write:response', {
                 success: false,
@@ -1033,7 +1043,7 @@ export class MessageHandler {
             return response;
         }
         try {
-            await this.getGit(peerAddress).writeGitignore(message.payload.content);
+            await this.getGit(message).writeGitignore(message.payload.content);
             const response = createMessage('git:gitignore-write:response', { success: true });
             response.id = message.id;
             return response;
@@ -1056,9 +1066,9 @@ export class MessageHandler {
      * the request-response just confirms the kickoff (or reports a validation
      * failure that keeps the state idle, e.g. missing API key / no staged changes).
      */
-    async handleGenerateCommitSummary(message, peerAddress) {
+    async handleGenerateCommitSummary(message) {
         const source = message.payload.source ?? 'api';
-        const repoPath = this.getClientRepoPath(peerAddress);
+        const repoPath = this.getRequiredRepoPath(message);
         const respond = (payload) => {
             const r = createMessage('ai:generate-commit-summary:response', payload);
             r.id = message.id;
@@ -1080,7 +1090,7 @@ export class MessageHandler {
         // `generating` — we don't want to show "generating…" just to immediately
         // error out on the same tick.
         try {
-            const status = await this.getGit(peerAddress).getStatus();
+            const status = await this.getGit(message).getStatus();
             if (status.staged.length === 0) {
                 return respond({
                     success: false,
@@ -1110,7 +1120,7 @@ export class MessageHandler {
         });
         // Run generation asynchronously. Errors flow through the state store,
         // NOT through the kickoff response — the response has already been sent.
-        void this.runCommitSummary(peerAddress, repoPath, token, source, message.payload, aiService, (child) => {
+        void this.runCommitSummary(repoPath, token, source, message.payload, aiService, (child) => {
             cliChild = child;
             if (aborted) {
                 try {
@@ -1126,9 +1136,9 @@ export class MessageHandler {
      * progress, or failure through the CommitSummaryStateStore (which in turn
      * broadcasts `ai:commit-summary:updated` to all peers).
      */
-    async runCommitSummary(peerAddress, repoPath, token, source, payload, aiService, onSpawn) {
+    async runCommitSummary(repoPath, token, source, payload, aiService, onSpawn) {
         try {
-            const git = this.getGit(peerAddress);
+            const git = this.getGitForRepoPath(repoPath);
             const [recentLog, branchInfo, conventions] = await Promise.all([
                 git.getLog(10).catch(() => []),
                 git.getBranches().catch(() => ({ current: '' })),
@@ -1192,8 +1202,8 @@ export class MessageHandler {
             this.commitSummaryStore.setError(repoPath, token, errorMessage, isRateLimit ? 'RATE_LIMITED' : 'API_ERROR');
         }
     }
-    handleClearCommitSummary(message, peerAddress) {
-        const repoPath = message.payload.repoPath || this.getClientRepoPath(peerAddress);
+    handleClearCommitSummary(message) {
+        const repoPath = this.getRequiredRepoPath(message);
         const state = this.commitSummaryStore.clear(repoPath);
         const response = createMessage('ai:commit-summary:clear:response', {
             success: true,
@@ -1290,7 +1300,7 @@ export class MessageHandler {
         response.id = message.id;
         return response;
     }
-    async handleListRepos(message, peerAddress) {
+    async handleListRepos(message) {
         // Refresh branch info for all repos
         const repos = [];
         for (const repo of this.availableRepos) {
@@ -1305,30 +1315,45 @@ export class MessageHandler {
         }
         const response = createMessage('agent:list-repos:response', {
             repos,
-            current: this.getClientRepoPath(peerAddress),
+            current: this.defaultRepoPath,
         });
         response.id = message.id;
         return response;
     }
-    handleSwitchRepo(message, peerAddress) {
-        const { path } = message.payload;
-        // Check if the requested repo is in our available repos
-        if (!this.repos.has(path)) {
-            const response = createMessage('agent:switch-repo:response', {
-                success: false,
-                newPath: this.getClientRepoPath(peerAddress),
-                error: `Repository not available: ${path}`,
-            });
-            response.id = message.id;
-            return response;
+    async ensureRepoAvailableForPath(path) {
+        const configured = this.availableRepos.find((repo) => repo.path === path);
+        if (configured && this.repos.has(path))
+            return configured;
+        try {
+            const requestedGit = new GitOperations(path);
+            if (!(await requestedGit.isValidRepo()))
+                return null;
+            const rootPath = await requestedGit.getGitRoot();
+            const existing = this.availableRepos.find((repo) => repo.path === rootPath);
+            if (existing) {
+                if (!this.repos.has(rootPath)) {
+                    this.repos.set(rootPath, new GitOperations(rootPath));
+                }
+                return existing;
+            }
+            const git = new GitOperations(rootPath);
+            const { current } = await git.getBranches();
+            const repo = {
+                path: rootPath,
+                name: basename(rootPath),
+                currentBranch: current,
+            };
+            this.repos.set(rootPath, git);
+            this.availableRepos.push(repo);
+            if (!this.defaultRepoPath) {
+                this.defaultRepoPath = rootPath;
+            }
+            addManagedRepo(rootPath);
+            return repo;
+        }
+        catch {
+            return null;
         }
-        this.clientRepos.set(peerAddress, path);
-        const response = createMessage('agent:switch-repo:response', {
-            success: true,
-            newPath: path,
-        });
-        response.id = message.id;
-        return response;
     }
     async handleBrowseDirectory(message) {
         const requestedPath = message.payload.path || homedir();
@@ -1803,7 +1828,7 @@ export class MessageHandler {
     async handleClaudeStart(message, peerAddress) {
         const { prompt, cwd: payloadCwd, agent, allowedTools, systemPrompt, model, permissionMode, sandboxed, reasoningEffort, contextWindow, attachmentIds } = message.payload;
         const legacyProvider = message.payload.provider;
-        const cwd = payloadCwd || this.getClientRepoPath(peerAddress);
+        const cwd = payloadCwd || this.defaultRepoPath;
         const resolvedAgent = agent ?? (legacyProvider === 'codex-mcp' ? 'codex' : legacyProvider ? 'claude-code' : undefined);
         // 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
@@ -1882,7 +1907,7 @@ export class MessageHandler {
     async handleClaudeResume(message, peerAddress) {
         const { sessionId: requestedId, prompt, cwd: payloadCwd, agent, attachmentIds, interruptCurrentTurn } = message.payload;
         const legacyProvider = message.payload.provider;
-        const cwd = payloadCwd || this.getClientRepoPath(peerAddress);
+        const cwd = payloadCwd || this.defaultRepoPath;
         const resolvedAgent = agent ?? (legacyProvider === 'codex-mcp' ? 'codex' : legacyProvider ? 'claude-code' : undefined);
         const activeCfg = this.claudeService.getSessionConfig(requestedId);
         console.log(`[agent:resume] session=${requestedId} agent=${resolvedAgent ?? 'stored'} model=${activeCfg.model ?? 'default'} cwd=${cwd} prompt=${prompt.slice(0, 80)}${attachmentIds && attachmentIds.length > 0 ? ` [+${attachmentIds.length} attachments]` : ''}`);
@@ -2037,9 +2062,9 @@ export class MessageHandler {
         response.id = message.id;
         return response;
     }
-    async handleClaudeGetCards(message, peerAddress) {
+    async handleClaudeGetCards(message) {
         const { sessionId, cwd: payloadCwd, offset = 0, limit = 50 } = message.payload;
-        const cwd = payloadCwd || this.getClientRepoPath(peerAddress);
+        const cwd = payloadCwd || this.defaultRepoPath;
         try {
             const result = await this.claudeService.getCards(sessionId, cwd, offset, limit);
             const response = createMessage('claude:get-cards:response', result);
@@ -2462,7 +2487,7 @@ export class MessageHandler {
             // 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'));
+            const isRootRepo = await hasPlausibleGitMarker(cwd);
             if (isRootRepo) {
                 repos.push({
                     path: cwd,
@@ -2521,7 +2546,7 @@ export class MessageHandler {
                     catch {
                         continue;
                     }
-                    if (existsSync(join(full, '.git')) && !seen.has(full)) {
+                    if ((await hasPlausibleGitMarker(full)) && !seen.has(full)) {
                         seen.add(full);
                         const branch = await this.getGitBranchQuiet(full);
                         repos.push({