@sumicom/quicksave 0.6.2 → 0.6.4

package/dist/handlers/messageHandler.js

@@ -2,28 +2,37 @@ import { createMessage, generateMessageId, } from '@sumicom/quicksave-shared';
 import { GitOperations } from '../git/operations.js';
 import { getAnthropicApiKey, setAnthropicApiKey, hasAnthropicApiKey, addManagedRepo, removeManagedRepo, addManagedCodingPath, removeManagedCodingPath } from '../config.js';
 import { CommitSummaryService } from '../ai/commitSummary.js';
+import { CommitSummaryCliService, CommitSummaryCliError } from '../ai/commitSummaryCli.js';
+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 { getSessionRegistry } from '../ai/sessionRegistry.js';
+import { getEventStore } from '../storage/eventStore.js';
 import { readdir, stat, readFile } from 'fs/promises';
+import { existsSync } from 'fs';
 import { join, dirname, basename } from 'path';
 import { homedir } from 'os';
 const VERSION_CHECK_INTERVAL_MS = 12 * 60 * 60 * 1000; // 12 hours
 const CODEX_MODELS_CHECK_INTERVAL_MS = 12 * 60 * 60 * 1000; // 12 hours
 export class MessageHandler {
     repos;
-    agentVersion = '0.6.2';
+    agentVersion = '0.6.4';
     defaultRepoPath;
     clientRepos = new Map(); // peerAddress -> repoPath
     repoLocks = new Map(); // repoPath -> peerAddress holding lock
     availableRepos;
     codingPaths = new Map(); // path -> CodingPath
     aiService = null;
+    aiCliService = null;
+    /** 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(),
     ]);
+    pushClient = null;
     latestVersionCache = null;
     versionCheckInFlight = null;
     codexModelsCache = null;
@@ -192,9 +201,22 @@ export class MessageHandler {
     getActiveSessionCount() {
         return this.claudeService.getActiveSessionCount();
     }
+    /** Exposed so the daemon can wire state-updated events to broadcasts. */
+    getCommitSummaryStore() {
+        return this.commitSummaryStore;
+    }
     getClaudeService() {
         return this.claudeService;
     }
+    /** Daemon wires this after construction so push:subscription-offer can
+     *  forward to the relay. Absent in tests or when VAPID/signaling aren't
+     *  configured — offer responses will report an error in that case. */
+    setPushClient(client) {
+        this.pushClient = client;
+    }
+    getPushClient() {
+        return this.pushClient;
+    }
     getAiService() {
         const apiKey = getAnthropicApiKey();
         if (!apiKey)
@@ -210,125 +232,155 @@ export class MessageHandler {
         if (isVerbose) {
             console.log(`[msg] ${message.type} from ${peerAddress.slice(0, 12)}`);
         }
-        try {
-            switch (message.type) {
-                case 'handshake':
-                    return this.handleHandshake(message, peerAddress);
-                case 'ping':
-                    return createMessage('pong', { timestamp: Date.now() });
-                case 'git:status':
-                    return this.handleStatus(message, peerAddress);
-                case 'git:diff':
-                    return this.handleDiff(message, peerAddress);
-                case 'git:stage':
-                    return this.handleStage(message, peerAddress);
-                case 'git:unstage':
-                    return this.handleUnstage(message, peerAddress);
-                case 'git:stage-patch':
-                    return this.handleStagePatch(message, peerAddress);
-                case 'git:unstage-patch':
-                    return this.handleUnstagePatch(message, peerAddress);
-                case 'git:commit':
-                    return this.handleCommit(message, peerAddress);
-                case 'git:log':
-                    return this.handleLog(message, peerAddress);
-                case 'git:branches':
-                    return this.handleBranches(peerAddress);
-                case 'git:checkout':
-                    return this.handleCheckout(message, peerAddress);
-                case 'git:discard':
-                    return this.handleDiscard(message, peerAddress);
-                case 'git:untrack':
-                    return this.handleUntrack(message, peerAddress);
-                case 'git:submodules':
-                    return this.handleSubmodules(message, peerAddress);
-                case 'git:config-get':
-                    return this.handleGitConfigGet(message, peerAddress);
-                case 'git:config-set':
-                    return this.handleGitConfigSet(message, peerAddress);
-                case 'git:gitignore-add':
-                    return this.handleGitignoreAdd(message, peerAddress);
-                case 'git:gitignore-read':
-                    return this.handleGitignoreRead(message, peerAddress);
-                case 'git:gitignore-write':
-                    return this.handleGitignoreWrite(message, peerAddress);
-                case 'ai:generate-commit-summary':
-                    return this.handleGenerateCommitSummary(message, peerAddress);
-                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);
-                case 'agent:browse-directory':
-                    return this.handleBrowseDirectory(message);
-                case 'agent:add-repo':
-                    return this.handleAddRepo(message);
-                case 'agent:remove-repo':
-                    return this.handleRemoveRepo(message);
-                case 'agent:clone-repo':
-                    return this.handleCloneRepo(message);
-                case 'agent:list-coding-paths':
-                    return this.handleListCodingPaths(message);
-                case 'agent:add-coding-path':
-                    return this.handleAddCodingPath(message);
-                case 'agent:remove-coding-path':
-                    return this.handleRemoveCodingPath(message);
-                case 'agent:check-update':
-                    return this.handleAgentCheckUpdate(message);
-                case 'agent:update':
-                    return this.handleAgentUpdate(message);
-                case 'agent:restart':
-                    return this.handleAgentRestart(message);
-                case 'codex:list-models':
-                    return this.handleCodexListModels(message);
-                // Claude Code SDK
-                case 'claude:list-sessions':
-                    return this.handleClaudeListSessions(message, peerAddress);
-                case 'claude:start':
-                    return this.handleClaudeStart(message, peerAddress);
-                case 'claude:resume':
-                    return this.handleClaudeResume(message, peerAddress);
-                case 'claude:cancel':
-                    return this.handleClaudeCancel(message);
-                case 'claude:close':
-                    return this.handleClaudeClose(message);
-                case 'claude:user-input-response':
-                    return this.handleClaudeUserInputResponse(message);
-                case 'claude:get-preferences':
-                    return this.handleGetPreferences(message);
-                case 'claude:set-preferences':
-                    return this.handleSetPreferences(message);
-                case 'claude:set-session-permission':
-                    return this.handleSetSessionPermission(message);
-                case 'claude:active-sessions':
-                    return this.handleGetActiveSessions(message);
-                case 'claude:get-cards':
-                    return this.handleClaudeGetCards(message, peerAddress);
-                case 'claude:unsubscribe': {
-                    const unsub = message.payload;
-                    this.onPeerUnsubscribed?.(peerAddress, unsub.sessionId);
-                    return createMessage('claude:unsubscribe:response', { ok: true });
-                }
-                case 'session:get-config':
-                    return this.handleGetSessionConfig(message);
-                case 'session:set-config':
-                    return this.handleSetSessionConfig(message);
-                case 'session:list-history':
-                    return this.handleListHistory(message, peerAddress);
-                case 'session:update-history':
-                    return this.handleUpdateHistory(message);
-                case 'session:delete-history':
-                    return this.handleDeleteHistory(message);
-                default:
-                    return this.createErrorResponse(message.id, 'UNKNOWN_MESSAGE_TYPE', `Unknown message type: ${message.type}`);
+        // 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;
             }
         }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            return this.createErrorResponse(message.id, 'HANDLER_ERROR', errorMessage);
+        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);
+        }
+        return response;
+    }
+    async dispatch(message, peerAddress) {
+        switch (message.type) {
+            case 'handshake':
+                return this.handleHandshake(message, peerAddress);
+            case 'ping':
+                return createMessage('pong', { timestamp: Date.now() });
+            case 'git:status':
+                return this.handleStatus(message, peerAddress);
+            case 'git:diff':
+                return this.handleDiff(message, peerAddress);
+            case 'git:stage':
+                return this.handleStage(message, peerAddress);
+            case 'git:unstage':
+                return this.handleUnstage(message, peerAddress);
+            case 'git:stage-patch':
+                return this.handleStagePatch(message, peerAddress);
+            case 'git:unstage-patch':
+                return this.handleUnstagePatch(message, peerAddress);
+            case 'git:commit':
+                return this.handleCommit(message, peerAddress);
+            case 'git:log':
+                return this.handleLog(message, peerAddress);
+            case 'git:branches':
+                return this.handleBranches(peerAddress);
+            case 'git:checkout':
+                return this.handleCheckout(message, peerAddress);
+            case 'git:discard':
+                return this.handleDiscard(message, peerAddress);
+            case 'git:untrack':
+                return this.handleUntrack(message, peerAddress);
+            case 'git:submodules':
+                return this.handleSubmodules(message, peerAddress);
+            case 'git:config-get':
+                return this.handleGitConfigGet(message, peerAddress);
+            case 'git:config-set':
+                return this.handleGitConfigSet(message, peerAddress);
+            case 'git:gitignore-add':
+                return this.handleGitignoreAdd(message, peerAddress);
+            case 'git:gitignore-read':
+                return this.handleGitignoreRead(message, peerAddress);
+            case 'git:gitignore-write':
+                return this.handleGitignoreWrite(message, peerAddress);
+            case 'ai:generate-commit-summary':
+                return this.handleGenerateCommitSummary(message, peerAddress);
+            case 'ai:commit-summary:get':
+                return this.handleGetCommitSummary(message, peerAddress);
+            case 'ai:commit-summary:clear':
+                return this.handleClearCommitSummary(message, peerAddress);
+            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);
+            case 'agent:browse-directory':
+                return this.handleBrowseDirectory(message);
+            case 'agent:add-repo':
+                return this.handleAddRepo(message);
+            case 'agent:remove-repo':
+                return this.handleRemoveRepo(message);
+            case 'agent:clone-repo':
+                return this.handleCloneRepo(message);
+            case 'agent:list-coding-paths':
+                return this.handleListCodingPaths(message);
+            case 'agent:add-coding-path':
+                return this.handleAddCodingPath(message);
+            case 'agent:remove-coding-path':
+                return this.handleRemoveCodingPath(message);
+            case 'agent:check-update':
+                return this.handleAgentCheckUpdate(message);
+            case 'agent:update':
+                return this.handleAgentUpdate(message);
+            case 'agent:restart':
+                return this.handleAgentRestart(message);
+            case 'codex:list-models':
+                return this.handleCodexListModels(message);
+            // Claude Code SDK
+            case 'claude:list-sessions':
+                return this.handleClaudeListSessions(message, peerAddress);
+            case 'claude:start':
+                return this.handleClaudeStart(message, peerAddress);
+            case 'claude:resume':
+                return this.handleClaudeResume(message, peerAddress);
+            case 'claude:cancel':
+                return this.handleClaudeCancel(message);
+            case 'claude:close':
+                return this.handleClaudeClose(message);
+            case 'claude:user-input-response':
+                return this.handleClaudeUserInputResponse(message);
+            case 'claude:get-preferences':
+                return this.handleGetPreferences(message);
+            case 'claude:set-preferences':
+                return this.handleSetPreferences(message);
+            case 'claude:set-session-permission':
+                return this.handleSetSessionPermission(message);
+            case 'claude:active-sessions':
+                return this.handleGetActiveSessions(message);
+            case 'claude:get-cards':
+                return this.handleClaudeGetCards(message, peerAddress);
+            case 'claude:unsubscribe': {
+                const unsub = message.payload;
+                this.onPeerUnsubscribed?.(peerAddress, unsub.sessionId);
+                return createMessage('claude:unsubscribe:response', { ok: true });
+            }
+            case 'session:get-config':
+                return this.handleGetSessionConfig(message);
+            case 'session:set-config':
+                return this.handleSetSessionConfig(message);
+            case 'session:control-request':
+                return this.handleControlRequest(message);
+            case 'session:list-history':
+                return this.handleListHistory(message, peerAddress);
+            case 'session:update-history':
+                return this.handleUpdateHistory(message);
+            case 'session:delete-history':
+                return this.handleDeleteHistory(message);
+            case 'project:list-summaries':
+                return this.handleListProjectSummaries(message);
+            case 'project:list-repos':
+                return await this.handleListProjectRepos(message);
+            case 'push:subscription-offer':
+                return this.handlePushSubscriptionOffer(message);
+            default:
+                return this.createErrorResponse(message.id, 'UNKNOWN_MESSAGE_TYPE', `Unknown message type: ${message.type}`);
         }
     }
     handleHandshake(message, peerAddress) {
@@ -487,6 +539,9 @@ export class MessageHandler {
         try {
             const { message: commitMessage, description, attribution } = message.payload;
             const hash = await this.getGit(peerAddress).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);
             const response = createMessage('git:commit:response', {
                 success: true,
                 hash,
@@ -706,69 +761,170 @@ export class MessageHandler {
             this.releaseRepoLock(repoPath, peerAddress);
         }
     }
+    /**
+     * Kick off AI commit-summary generation. Generation runs asynchronously and
+     * streams progress + result via the `ai:commit-summary:updated` broadcast;
+     * 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) {
-        const aiService = this.getAiService();
-        if (!aiService) {
-            const response = createMessage('ai:generate-commit-summary:response', {
-                success: false,
-                error: 'Configure your API key in Settings',
-                errorCode: 'NO_API_KEY',
-            });
-            response.id = message.id;
-            return response;
+        const source = message.payload.source ?? 'api';
+        const repoPath = this.getClientRepoPath(peerAddress);
+        const respond = (payload) => {
+            const r = createMessage('ai:generate-commit-summary:response', payload);
+            r.id = message.id;
+            return r;
+        };
+        // API source requires an Anthropic key; CLI source does not.
+        let aiService = null;
+        if (source === 'api') {
+            aiService = this.getAiService();
+            if (!aiService) {
+                return respond({
+                    success: false,
+                    error: 'Configure your API key in Settings',
+                    errorCode: 'NO_API_KEY',
+                });
+            }
         }
+        // Validate staged changes exist before flipping the state into
+        // `generating` — we don't want to show "generating…" just to immediately
+        // error out on the same tick.
         try {
-            const git = this.getGit(peerAddress);
-            const status = await git.getStatus();
+            const status = await this.getGit(peerAddress).getStatus();
             if (status.staged.length === 0) {
-                const response = createMessage('ai:generate-commit-summary:response', {
+                return respond({
                     success: false,
                     error: 'No staged changes to summarize',
                     errorCode: 'NO_STAGED_CHANGES',
                 });
-                response.id = message.id;
-                return response;
             }
-            // Collect diffs and context in parallel
-            const [diffs, recentLog, branchInfo, conventions] = await Promise.all([
-                Promise.all(status.staged.map((file) => git.getDiff(file.path, true))),
+        }
+        catch (error) {
+            return respond({
+                success: false,
+                error: error instanceof Error ? error.message : 'Failed to inspect working tree',
+                errorCode: 'API_ERROR',
+            });
+        }
+        // Register the generation with the state store. The returned token lets
+        // us detect supersession (the caller fired off a fresh generation while
+        // this one was still running, or the state was cleared).
+        let aborted = false;
+        let cliChild;
+        const token = this.commitSummaryStore.startGenerating(repoPath, source, message.payload.model, () => {
+            aborted = true;
+            try {
+                cliChild?.kill('SIGTERM');
+            }
+            catch { /* ignore */ }
+        });
+        // 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) => {
+            cliChild = child;
+            if (aborted) {
+                try {
+                    child.kill('SIGTERM');
+                }
+                catch { /* ignore */ }
+            }
+        });
+        return respond({ success: true, state: this.commitSummaryStore.get(repoPath) });
+    }
+    /**
+     * Background worker that actually runs the generation. Reports success,
+     * 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) {
+        try {
+            const git = this.getGit(peerAddress);
+            const [recentLog, branchInfo, conventions] = await Promise.all([
                 git.getLog(10).catch(() => []),
                 git.getBranches().catch(() => ({ current: '' })),
                 git.readCommitConventions().catch(() => undefined),
             ]);
             const recentCommits = recentLog.map((c) => c.message);
             const branchName = branchInfo.current;
-            // Generate summary (uses internal queue and cache)
+            if (source === 'claude-cli') {
+                const cliService = this.getAiCliService();
+                const result = await cliService.generateSummary({
+                    repoPath,
+                    context: payload.context,
+                    model: payload.model,
+                    recentCommits: recentCommits.length > 0 ? recentCommits : undefined,
+                    branchName: branchName || undefined,
+                    conventions,
+                    attribution: payload.attribution,
+                    onProgress: (progress) => {
+                        this.commitSummaryStore.updateProgress(repoPath, token, progress);
+                    },
+                    onSpawn: (child) => {
+                        onSpawn(child);
+                    },
+                });
+                this.commitSummaryStore.setResult(repoPath, token, {
+                    summary: result.summary,
+                    description: result.description,
+                    tokenUsage: result.tokenUsage,
+                });
+                return;
+            }
+            // API path — fetch staged diffs fresh. No per-step progress today;
+            // the single Anthropic round-trip is fast enough that phase updates add
+            // little value. We still flip to `generating` so the UI shows a spinner.
+            this.commitSummaryStore.updateProgress(repoPath, token, { phase: 'generating' });
+            const status = await git.getStatus();
+            const diffs = await Promise.all(status.staged.map((file) => git.getDiff(file.path, true)));
             const result = await aiService.generateSummary({
                 diffs,
-                context: message.payload.context,
-                model: message.payload.model,
+                context: payload.context,
+                model: payload.model,
                 recentCommits: recentCommits.length > 0 ? recentCommits : undefined,
                 branchName: branchName || undefined,
                 conventions,
-                attribution: message.payload.attribution,
+                attribution: payload.attribution,
             });
-            const response = createMessage('ai:generate-commit-summary:response', {
-                success: true,
+            this.commitSummaryStore.setResult(repoPath, token, {
                 summary: result.summary,
                 description: result.description,
                 tokenUsage: result.tokenUsage,
                 cached: result.cached,
             });
-            response.id = message.id;
-            return response;
         }
         catch (error) {
+            if (error instanceof CommitSummaryCliError) {
+                this.commitSummaryStore.setError(repoPath, token, error.message, error.errorCode);
+                return;
+            }
             const errorMessage = error instanceof Error ? error.message : 'Failed to generate summary';
             const isRateLimit = errorMessage.includes('rate_limit');
-            const response = createMessage('ai:generate-commit-summary:response', {
-                success: false,
-                error: errorMessage,
-                errorCode: isRateLimit ? 'RATE_LIMITED' : 'API_ERROR',
-            });
-            response.id = message.id;
-            return response;
+            this.commitSummaryStore.setError(repoPath, token, errorMessage, isRateLimit ? 'RATE_LIMITED' : 'API_ERROR');
+        }
+    }
+    handleGetCommitSummary(message, peerAddress) {
+        const repoPath = message.payload.repoPath || this.getClientRepoPath(peerAddress);
+        const state = this.commitSummaryStore.get(repoPath);
+        const response = createMessage('ai:commit-summary:get:response', { state });
+        response.id = message.id;
+        return response;
+    }
+    handleClearCommitSummary(message, peerAddress) {
+        const repoPath = message.payload.repoPath || this.getClientRepoPath(peerAddress);
+        const state = this.commitSummaryStore.clear(repoPath);
+        const response = createMessage('ai:commit-summary:clear:response', {
+            success: true,
+            state,
+        });
+        response.id = message.id;
+        return response;
+    }
+    getAiCliService() {
+        if (!this.aiCliService) {
+            this.aiCliService = new CommitSummaryCliService();
         }
+        return this.aiCliService;
     }
     handleSetApiKey(message) {
         try {
@@ -1215,7 +1371,7 @@ export class MessageHandler {
         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'} cwd=${cwd} prompt=${prompt.slice(0, 80)}${sandboxed ? ' [sandboxed]' : ''}`);
+        console.log(`[agent:start] agent=${resolvedAgent ?? 'default'} model=${model ?? 'default'} cwd=${cwd} prompt=${prompt.slice(0, 80)}${sandboxed ? ' [sandboxed]' : ''}`);
         try {
             const sessionId = await this.claudeService.startSession({
                 prompt,
@@ -1232,6 +1388,13 @@ export class MessageHandler {
             this.onPeerSubscribed?.(peerAddress, sessionId);
             // Register in session history
             const now = Date.now();
+            getEventStore().record({
+                type: 'prompt_sent',
+                sessionId,
+                cwd,
+                time: now,
+                data: { kind: 'start', promptLength: prompt.length, model, agent: resolvedAgent },
+            });
             const registry = getSessionRegistry();
             const gitBranch = await this.getGitBranchQuiet(cwd);
             const actualAgent = this.claudeService.getSessionAgent(sessionId, cwd);
@@ -1264,7 +1427,8 @@ export class MessageHandler {
         const cwd = payloadCwd || this.getClientRepoPath(peerAddress);
         const streamId = generateMessageId();
         const resolvedAgent = agent ?? (legacyProvider === 'codex-mcp' ? 'codex' : legacyProvider ? 'claude-code' : undefined);
-        console.log(`[agent:resume] session=${requestedId} agent=${resolvedAgent ?? 'stored'} cwd=${cwd} prompt=${prompt.slice(0, 80)}`);
+        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)}`);
         // Subscribe before resumeSession starts streaming — hot resume emits events
         // immediately (user_message, then assistant turns), so we must be subscribed
         // before session.send() fires, not after resumeSession() returns.
@@ -1282,6 +1446,12 @@ export class MessageHandler {
             if (actualSessionId !== requestedId) {
                 this.onPeerSubscribed?.(peerAddress, actualSessionId);
             }
+            getEventStore().record({
+                type: 'prompt_sent',
+                sessionId: actualSessionId,
+                cwd,
+                data: { kind: 'resume', promptLength: prompt.length, agent: resolvedAgent },
+            });
             // Update session history
             const registry = getSessionRegistry();
             const existing = registry.getEntry(cwd, requestedId) ?? registry.getEntry(cwd, actualSessionId);
@@ -1309,6 +1479,9 @@ export class MessageHandler {
     async handleClaudeCancel(message) {
         const { sessionId } = message.payload;
         const success = await this.claudeService.cancelSession(sessionId);
+        if (success) {
+            getEventStore().record({ type: 'session_cancelled', sessionId });
+        }
         const response = createMessage('claude:cancel:response', { success, error: success ? undefined : 'Session not found or already ended' });
         response.id = message.id;
         return response;
@@ -1361,10 +1534,18 @@ export class MessageHandler {
         response.id = message.id;
         return response;
     }
-    handleSetSessionPermission(message) {
+    async handleSetSessionPermission(message) {
         const { sessionId, permissionMode } = message.payload;
-        const validModes = ['default', 'acceptEdits', 'bypassPermissions', 'plan'];
-        const success = validModes.includes(permissionMode) && this.claudeService.setPermissionLevel(sessionId, permissionMode);
+        const validModes = ['default', 'acceptEdits', 'bypassPermissions', 'plan', 'auto'];
+        let success = false;
+        if (validModes.includes(permissionMode)) {
+            try {
+                success = await this.claudeService.setPermissionLevel(sessionId, permissionMode);
+            }
+            catch {
+                success = false;
+            }
+        }
         const response = createMessage('claude:set-session-permission:response', { success, sessionId, permissionMode });
         response.id = message.id;
         return response;
@@ -1376,12 +1557,43 @@ export class MessageHandler {
         response.id = message.id;
         return response;
     }
-    handleSetSessionConfig(message) {
+    async handleSetSessionConfig(message) {
         const { sessionId, key, value } = message.payload;
-        const config = this.claudeService.setSessionConfig(sessionId, key, value);
-        const response = createMessage('session:set-config:response', { success: true, sessionId, config });
-        response.id = message.id;
-        return response;
+        console.log(`[agent:set-config] session=${sessionId.slice(0, 8)} ${key}=${String(value)}`);
+        try {
+            const config = await this.claudeService.setSessionConfig(sessionId, key, value);
+            const response = createMessage('session:set-config:response', { success: true, sessionId, config });
+            response.id = message.id;
+            return response;
+        }
+        catch (err) {
+            const config = this.claudeService.getSessionConfig(sessionId);
+            const response = createMessage('session:set-config:response', {
+                success: false,
+                sessionId,
+                config,
+                error: err instanceof Error ? err.message : String(err),
+            });
+            response.id = message.id;
+            return response;
+        }
+    }
+    async handleControlRequest(message) {
+        const { sessionId, subtype, params } = message.payload;
+        console.log(`[agent:control-request] session=${sessionId.slice(0, 8)} subtype=${subtype} params=${JSON.stringify(params ?? {})}`);
+        try {
+            const result = await this.claudeService.sendControlRequest(sessionId, subtype, params);
+            const response = createMessage('session:control-request:response', { success: true, sessionId, response: result });
+            response.id = message.id;
+            return response;
+        }
+        catch (error) {
+            const errMsg = error instanceof Error ? error.message : String(error);
+            console.error(`[agent:control-request] error:`, errMsg);
+            const response = createMessage('session:control-request:response', { success: false, sessionId, error: errMsg });
+            response.id = message.id;
+            return response;
+        }
     }
     handleGetActiveSessions(message) {
         const sessions = this.claudeService.getActiveSessions();
@@ -1392,7 +1604,8 @@ export class MessageHandler {
     // ── Session Registry (History) ──────────────────────────────────────
     handleListHistory(message, peerAddress) {
         const cwd = message.payload.cwd || this.getClientRepoPath(peerAddress);
-        const entries = getSessionRegistry().getEntriesForProject(cwd);
+        const entries = getSessionRegistry().getEntriesForProject(cwd)
+            .filter(e => !e.archived);
         const response = createMessage('session:list-history:response', { entries });
         response.id = message.id;
         return response;
@@ -1418,6 +1631,130 @@ export class MessageHandler {
         }
         return response;
     }
+    handleListProjectSummaries(message) {
+        const allEntries = getSessionRegistry().getEntriesForProject()
+            .filter(e => !e.archived);
+        // Group by cwd
+        const byCwd = new Map();
+        for (const entry of allEntries) {
+            let group = byCwd.get(entry.cwd);
+            if (!group) {
+                group = [];
+                byCwd.set(entry.cwd, group);
+            }
+            group.push(entry);
+        }
+        // Build active session set from session manager
+        const activeSessions = this.claudeService.getActiveSessions();
+        const activeCwds = new Set();
+        for (const s of activeSessions) {
+            activeCwds.add(s.cwd);
+        }
+        const projects = [];
+        for (const [cwd, entries] of byCwd) {
+            // entries are already sorted by lastAccessedAt desc from getEntriesForProject
+            const latest = entries[0];
+            projects.push({
+                cwd,
+                sessionCount: entries.length,
+                lastActivityAt: latest.lastAccessedAt,
+                lastSessionTitle: latest.title ?? latest.firstPrompt?.slice(0, 100),
+                hasActiveSession: activeCwds.has(cwd),
+                isGitRepo: existsSync(join(cwd, '.git')),
+            });
+        }
+        // Sort by lastActivityAt desc
+        projects.sort((a, b) => b.lastActivityAt - a.lastActivityAt);
+        const response = createMessage('project:list-summaries:response', { projects });
+        response.id = message.id;
+        return response;
+    }
+    async handleListProjectRepos(message) {
+        const { cwd } = message.payload;
+        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) {
+                repos.push({
+                    path: cwd,
+                    name: basename(cwd),
+                    currentBranch: rootBranch || undefined,
+                });
+                seen.add(cwd);
+            }
+            // 2. Find submodules via git
+            if (rootBranch !== undefined) {
+                try {
+                    const git = new GitOperations(cwd);
+                    const submodules = await git.getSubmodules();
+                    for (const sub of submodules) {
+                        const subPath = join(cwd, sub.path);
+                        if (seen.has(subPath))
+                            continue;
+                        seen.add(subPath);
+                        const branch = await this.getGitBranchQuiet(subPath);
+                        repos.push({
+                            path: subPath,
+                            name: sub.path,
+                            currentBranch: branch || undefined,
+                            isSubmodule: true,
+                        });
+                    }
+                }
+                catch {
+                    // git submodule may fail — ignore
+                }
+            }
+            // 3. Scan for nested git repos (depth-limited, skips node_modules etc.)
+            const MAX_DEPTH = 3;
+            const SKIP_DIRS = new Set(['node_modules', '.git', 'vendor', 'dist', 'build', '.next', '__pycache__']);
+            const scan = async (dir, depth) => {
+                if (depth > MAX_DEPTH)
+                    return;
+                let names;
+                try {
+                    names = await readdir(dir);
+                }
+                catch {
+                    return;
+                }
+                for (const name of names) {
+                    if (name.startsWith('.') || SKIP_DIRS.has(name))
+                        continue;
+                    const full = join(dir, name);
+                    try {
+                        const s = await stat(full);
+                        if (!s.isDirectory())
+                            continue;
+                    }
+                    catch {
+                        continue;
+                    }
+                    if (existsSync(join(full, '.git')) && !seen.has(full)) {
+                        seen.add(full);
+                        const branch = await this.getGitBranchQuiet(full);
+                        repos.push({
+                            path: full,
+                            name: full.slice(cwd.length + 1),
+                            currentBranch: branch || undefined,
+                        });
+                    }
+                    await scan(full, depth + 1);
+                }
+            };
+            await scan(cwd, 0);
+        }
+        catch (error) {
+            const response = createMessage('project:list-repos:response', { repos: [], error: error instanceof Error ? error.message : 'Failed to scan repos' });
+            response.id = message.id;
+            return response;
+        }
+        const response = createMessage('project:list-repos:response', { repos });
+        response.id = message.id;
+        return response;
+    }
     async getGitBranchQuiet(cwd) {
         try {
             const git = new GitOperations(cwd);
@@ -1428,6 +1765,21 @@ export class MessageHandler {
             return undefined;
         }
     }
+    async handlePushSubscriptionOffer(message) {
+        const client = this.pushClient;
+        let payload;
+        if (!client) {
+            payload = { success: false, error: 'push-not-configured' };
+        }
+        else {
+            const { subscription, relayHttpUrl } = message.payload;
+            const result = await client.register(subscription, relayHttpUrl);
+            payload = result.ok ? { success: true } : { success: false, error: result.error ?? `http-${result.status}` };
+        }
+        const response = createMessage('push:subscription-offer:response', payload);
+        response.id = message.id;
+        return response;
+    }
     createErrorResponse(id, code, message) {
         const response = createMessage('error', { code, message });
         response.id = id;