@shepai/cli 1.163.0 → 1.164.0-pr514.db33061

package/dist/packages/core/src/infrastructure/services/interactive/interactive-session.service.js

@@ -44,6 +44,14 @@ export class InteractiveSessionService {
     sessions = new Map();
     /** Cached agentSessionIds from stopped sessions, keyed by featureId. */
     stoppedAgentSessionIds = new Map();
+    /**
+     * Feature-level subscribers that survive session restarts.
+     *
+     * Unlike session-level subscribers (in SessionState.subscribers), these
+     * persist when a session dies and a new one boots. SSE connections
+     * subscribe here so they continue receiving events from new sessions.
+     */
+    featureSubscribers = new Map();
     constructor(sessionRepo, messageRepo, executorFactory, featureRepo, contextBuilder) {
         this.sessionRepo = sessionRepo;
         this.messageRepo = messageRepo;
@@ -181,9 +189,10 @@ export class InteractiveSessionService {
             // Create the interactive executor and session
             const executor = this.executorFactory.createInteractiveExecutor(resolvedAgentType, authConfig);
             let handle;
-            if (state.agentSessionId) {
+            const previousAgentSessionId = state.agentSessionId;
+            if (previousAgentSessionId) {
                 // Resume existing SDK session
-                handle = await executor.resumeSession(state.agentSessionId, {
+                handle = await executor.resumeSession(previousAgentSessionId, {
                     cwd: worktreePath,
                     model: state.model,
                     systemPrompt: context,
@@ -218,7 +227,7 @@ export class InteractiveSessionService {
                             if (event.content) {
                                 greetingText += event.content;
                                 state.currentAssistantBuffer += event.content;
-                                state.subscribers.forEach((sub) => sub({ delta: event.content, done: false }));
+                                this.notify(state, { delta: event.content, done: false });
                             }
                             break;
                         case 'tool_use':
@@ -226,12 +235,12 @@ export class InteractiveSessionService {
                                 const toolLabel = event.label;
                                 const toolDetail = event.detail;
                                 void this.persistToolEvent(state, toolLabel, toolDetail);
-                                state.subscribers.forEach((sub) => sub({
+                                this.notify(state, {
                                     delta: '',
                                     done: false,
                                     log: `Using tool: ${toolLabel}`,
                                     activity: { kind: 'tool_use', label: toolLabel, detail: toolDetail },
-                                }));
+                                });
                             }
                             break;
                         case 'tool_result':
@@ -239,18 +248,18 @@ export class InteractiveSessionService {
                                 const resultLabel = event.label;
                                 const resultDetail = event.detail;
                                 void this.persistToolEvent(state, resultLabel, resultDetail);
-                                state.subscribers.forEach((sub) => sub({
+                                this.notify(state, {
                                     delta: '',
                                     done: false,
                                     log: `Completed: ${resultLabel}`,
                                     activity: { kind: 'tool_result', label: resultLabel, detail: resultDetail },
-                                }));
+                                });
                             }
                             break;
                         case 'status':
                             if (event.content) {
                                 const statusContent = event.content;
-                                state.subscribers.forEach((sub) => sub({ delta: '', done: false, log: statusContent }));
+                                this.notify(state, { delta: '', done: false, log: statusContent });
                             }
                             break;
                         case 'done': {
@@ -259,6 +268,15 @@ export class InteractiveSessionService {
                             // Capture the SDK session ID (available after first message exchange)
                             const sdkSessionId = handle.sessionId;
                             if (sdkSessionId) {
+                                // Detect CWD mismatch: if we tried to resume but got a different
+                                // session ID, the SDK silently created a fresh session (typically
+                                // because the cwd changed or session JSONL was lost).
+                                if (previousAgentSessionId && sdkSessionId !== previousAgentSessionId) {
+                                    // eslint-disable-next-line no-console
+                                    console.warn(`[InteractiveSession] Session resume mismatch for feature ${featureId}: ` +
+                                        `expected ${previousAgentSessionId}, got ${sdkSessionId}. ` +
+                                        `SDK created a fresh session (likely cwd changed or session expired).`);
+                                }
                                 state.agentSessionId = sdkSessionId;
                                 // Persist to DB so it survives service restarts
                                 void this.sessionRepo.updateAgentSessionId(state.sessionId, sdkSessionId);
@@ -283,7 +301,7 @@ export class InteractiveSessionService {
                             state.currentAssistantBuffer = '';
                             state.toolEventsLog = [];
                             // Notify subscribers of end-of-turn
-                            state.subscribers.forEach((sub) => sub({ delta: '', done: true }));
+                            this.notify(state, { delta: '', done: true });
                             // Start idle timer now that the session is live
                             this.resetTimer(state);
                             return; // Boot complete
@@ -434,7 +452,7 @@ export class InteractiveSessionService {
                             if (event.content) {
                                 responseText += event.content;
                                 state.currentAssistantBuffer += event.content;
-                                state.subscribers.forEach((sub) => sub({ delta: event.content, done: false }));
+                                this.notify(state, { delta: event.content, done: false });
                             }
                             break;
                         case 'tool_use':
@@ -442,12 +460,12 @@ export class InteractiveSessionService {
                                 const toolLabel = event.label;
                                 const toolDetail = event.detail;
                                 void this.persistToolEvent(state, toolLabel, toolDetail);
-                                state.subscribers.forEach((sub) => sub({
+                                this.notify(state, {
                                     delta: '',
                                     done: false,
                                     log: `Using tool: ${toolLabel}`,
                                     activity: { kind: 'tool_use', label: toolLabel, detail: toolDetail },
-                                }));
+                                });
                             }
                             break;
                         case 'tool_result':
@@ -455,18 +473,18 @@ export class InteractiveSessionService {
                                 const resultLabel = event.label;
                                 const resultDetail = event.detail;
                                 void this.persistToolEvent(state, resultLabel, resultDetail);
-                                state.subscribers.forEach((sub) => sub({
+                                this.notify(state, {
                                     delta: '',
                                     done: false,
                                     log: `Completed: ${resultLabel}`,
                                     activity: { kind: 'tool_result', label: resultLabel, detail: resultDetail },
-                                }));
+                                });
                             }
                             break;
                         case 'status':
                             if (event.content) {
                                 const statusContent = event.content;
-                                state.subscribers.forEach((sub) => sub({ delta: '', done: false, log: statusContent }));
+                                this.notify(state, { delta: '', done: false, log: statusContent });
                             }
                             break;
                         case 'done': {
@@ -486,17 +504,39 @@ export class InteractiveSessionService {
                             await this.messageRepo.create(msg);
                             state.currentAssistantBuffer = '';
                             state.toolEventsLog = [];
+                            // Accumulate usage from this turn
+                            if (event.usage) {
+                                void this.sessionRepo.accumulateUsage(state.sessionId, {
+                                    costUsd: event.usage.costUsd ?? 0,
+                                    inputTokens: event.usage.inputTokens ?? 0,
+                                    outputTokens: event.usage.outputTokens ?? 0,
+                                    turns: event.usage.numTurns ?? 1,
+                                });
+                            }
                             // Mark as unread — if user has the chat open, the frontend
                             // will immediately call markRead to clear it
                             void this.sessionRepo.updateTurnStatus(state.sessionId, 'unread');
                             // Notify subscribers of end-of-turn
-                            state.subscribers.forEach((sub) => sub({ delta: '', done: true }));
+                            this.notify(state, { delta: '', done: true });
                             return; // Turn complete
                         }
                         case 'error':
                             // eslint-disable-next-line no-console
                             console.error(`[InteractiveSession] agent error during turn for session ${state.sessionId}:`, event.content);
-                            state.subscribers.forEach((sub) => sub({ delta: '', done: true, log: `Error: ${event.content ?? 'unknown'}` }));
+                            // Accumulate usage even on errors — cost was still incurred
+                            if (event.usage) {
+                                void this.sessionRepo.accumulateUsage(state.sessionId, {
+                                    costUsd: event.usage.costUsd ?? 0,
+                                    inputTokens: event.usage.inputTokens ?? 0,
+                                    outputTokens: event.usage.outputTokens ?? 0,
+                                    turns: event.usage.numTurns ?? 1,
+                                });
+                            }
+                            this.notify(state, {
+                                delta: '',
+                                done: true,
+                                log: `Error: ${event.content ?? 'unknown'}`,
+                            });
                             break;
                         case 'init':
                             // The SDK emits init on every turn, but we only show "Session started"
@@ -504,32 +544,36 @@ export class InteractiveSessionService {
                             // spamming the chat with repeated session-started messages.
                             break;
                         case 'api_retry':
-                            state.subscribers.forEach((sub) => sub({ delta: '', done: false, log: event.content ?? 'Retrying API call...' }));
+                            this.notify(state, {
+                                delta: '',
+                                done: false,
+                                log: event.content ?? 'Retrying API call...',
+                            });
                             break;
                         case 'rate_limit':
-                            state.subscribers.forEach((sub) => sub({ delta: '', done: false, log: event.content ?? 'Rate limited' }));
+                            this.notify(state, { delta: '', done: false, log: event.content ?? 'Rate limited' });
                             break;
                         case 'task_started':
                             if (event.content) {
                                 void this.persistToolEvent(state, 'Subtask started', event.content);
-                                state.subscribers.forEach((sub) => sub({
+                                this.notify(state, {
                                     delta: '',
                                     done: false,
                                     log: `Subtask: ${event.content}`,
                                     activity: { kind: 'system', label: 'Subtask started', detail: event.content },
-                                }));
+                                });
                             }
                             break;
                         case 'task_progress':
                             if (event.content) {
-                                state.subscribers.forEach((sub) => sub({ delta: '', done: false, log: `Subtask: ${event.content}` }));
+                                this.notify(state, { delta: '', done: false, log: `Subtask: ${event.content}` });
                             }
                             break;
                         case 'task_done':
                             if (event.content) {
                                 const taskStatus = event.detail ?? 'completed';
                                 void this.persistToolEvent(state, `Subtask ${taskStatus}`, event.content);
-                                state.subscribers.forEach((sub) => sub({
+                                this.notify(state, {
                                     delta: '',
                                     done: false,
                                     log: `Subtask ${taskStatus}: ${event.content}`,
@@ -538,7 +582,7 @@ export class InteractiveSessionService {
                                         label: `Subtask ${taskStatus}`,
                                         detail: event.content,
                                     },
-                                }));
+                                });
                             }
                             break;
                     }
@@ -563,14 +607,18 @@ export class InteractiveSessionService {
                 await this.messageRepo.create(msg);
                 state.currentAssistantBuffer = '';
                 state.toolEventsLog = [];
-                state.subscribers.forEach((sub) => sub({ delta: '', done: true }));
+                this.notify(state, { delta: '', done: true });
             }
             else if (!responseText) {
                 // Stream ended without any response — SDK session likely died.
                 // Mark as error so the next message triggers a fresh session.
                 // eslint-disable-next-line no-console
                 console.error(`[InteractiveSession] stream ended without response for session ${state.sessionId} — session may have died`);
-                state.subscribers.forEach((sub) => sub({ delta: '', done: true, log: 'Session disconnected — will restart on next message' }));
+                this.notify(state, {
+                    delta: '',
+                    done: true,
+                    log: 'Session disconnected — will restart on next message',
+                });
                 if (state.agentSessionId) {
                     this.stoppedAgentSessionIds.set(state.featureId, state.agentSessionId);
                 }
@@ -629,7 +677,7 @@ export class InteractiveSessionService {
     // ---------------------------------------------------------------------------
     // Feature-scoped API (frontend doesn't manage sessions)
     // ---------------------------------------------------------------------------
-    async sendUserMessage(featureId, content, worktreePath) {
+    async sendUserMessage(featureId, content, worktreePath, model, agentType) {
         // 1. Persist user message to DB immediately — this is the source of truth
         const now = new Date();
         const userMsg = {
@@ -642,7 +690,21 @@ export class InteractiveSessionService {
         };
         await this.messageRepo.create(userMsg);
         // 2. Find active session for this feature
-        const state = this.findActiveStateForFeature(featureId);
+        let state = this.findActiveStateForFeature(featureId);
+        // If the caller requested a different model/agent than the running session,
+        // silently stop the current session so a new one boots with the new config.
+        // Also clear the cached agentSessionId so we create a fresh SDK session
+        // instead of resuming the old one (which would keep the old model).
+        if (state && model && state.model !== model) {
+            await this.stopSession(state.sessionId);
+            this.stoppedAgentSessionIds.delete(featureId);
+            state = undefined;
+        }
+        else if (state && agentType && state.agentType !== agentType) {
+            await this.stopSession(state.sessionId);
+            this.stoppedAgentSessionIds.delete(featureId);
+            state = undefined;
+        }
         if (state) {
             const dbSession = await this.sessionRepo.findById(state.sessionId);
             if (dbSession?.status === InteractiveSessionStatus.ready) {
@@ -674,7 +736,7 @@ export class InteractiveSessionService {
                 await this.sessionRepo.updateStatus(dbSession.id, InteractiveSessionStatus.stopped, new Date());
             }
             // Boot a new session — startSession will find the agentSessionId from DB
-            const session = await this.startSession(featureId, worktreePath);
+            const session = await this.startSession(featureId, worktreePath, model, agentType);
             const newState = this.sessions.get(session.id);
             if (newState) {
                 newState.pendingUserContent = content;
@@ -698,6 +760,7 @@ export class InteractiveSessionService {
             }
             // Resolve model display: explicit override > default
             const displayModel = state.model ?? 'claude-sonnet-4-6';
+            const usage = await this.sessionRepo.getUsage(state.sessionId);
             sessionInfo = {
                 pid: null, // SDK manages process internally
                 sessionId: state.agentSessionId ?? state.sessionId,
@@ -709,6 +772,9 @@ export class InteractiveSessionService {
                 lastActivityAt: dbSession?.lastActivityAt
                     ? new Date(dbSession.lastActivityAt).toISOString()
                     : new Date().toISOString(),
+                totalCostUsd: usage?.totalCostUsd ?? null,
+                totalInputTokens: usage?.totalInputTokens ?? null,
+                totalOutputTokens: usage?.totalOutputTokens ?? null,
             };
         }
         else {
@@ -719,6 +785,7 @@ export class InteractiveSessionService {
                 // Show DB info even without live process (process was lost on restart)
                 if (latest.status !== InteractiveSessionStatus.stopped &&
                     latest.status !== InteractiveSessionStatus.error) {
+                    const latestUsage = await this.sessionRepo.getUsage(latest.id);
                     sessionInfo = {
                         pid: null,
                         sessionId: latest.id,
@@ -730,6 +797,9 @@ export class InteractiveSessionService {
                         lastActivityAt: latest.lastActivityAt
                             ? new Date(latest.lastActivityAt).toISOString()
                             : new Date().toISOString(),
+                        totalCostUsd: latestUsage?.totalCostUsd ?? null,
+                        totalInputTokens: latestUsage?.totalInputTokens ?? null,
+                        totalOutputTokens: latestUsage?.totalOutputTokens ?? null,
                     };
                 }
             }
@@ -752,29 +822,26 @@ export class InteractiveSessionService {
         return { messages, sessionStatus, streamingText, sessionInfo, turnStatus };
     }
     subscribeByFeature(featureId, onChunk) {
-        const state = this.findActiveStateForFeature(featureId);
-        if (!state) {
-            // eslint-disable-next-line @typescript-eslint/no-empty-function
-            return () => { };
-        }
-        state.subscribers.add(onChunk);
-        return () => state.subscribers.delete(onChunk);
+        // Subscribe at the feature level so the callback survives session restarts.
+        // When a session dies (idle timeout, error) and a new one boots, the SSE
+        // connection keeps receiving events from the new session automatically.
+        let subs = this.featureSubscribers.get(featureId);
+        if (!subs) {
+            subs = new Set();
+            this.featureSubscribers.set(featureId, subs);
+        }
+        subs.add(onChunk);
+        return () => {
+            subs.delete(onChunk);
+            if (subs.size === 0) {
+                this.featureSubscribers.delete(featureId);
+            }
+        };
     }
     async stopByFeature(featureId) {
         const state = this.findActiveStateForFeature(featureId);
         if (!state)
             return;
-        // Persist a system message before killing
-        const msg = {
-            id: crypto.randomUUID(),
-            featureId,
-            sessionId: state.sessionId,
-            role: InteractiveMessageRole.assistant,
-            content: '**Session stopped by user**',
-            createdAt: new Date(),
-            updatedAt: new Date(),
-        };
-        await this.messageRepo.create(msg);
         await this.stopSession(state.sessionId);
     }
     async markRead(featureId) {
@@ -854,6 +921,23 @@ export class InteractiveSessionService {
         }
     }
     // ---------------------------------------------------------------------------
+    // Event dispatch
+    // ---------------------------------------------------------------------------
+    /**
+     * Dispatch a StreamChunk to all subscribers for a session.
+     *
+     * Sends to both session-level subscribers (legacy, for sessionId-based
+     * subscribe()) and feature-level subscribers (for SSE connections that
+     * must survive session restarts).
+     */
+    notify(state, chunk) {
+        state.subscribers.forEach((sub) => sub(chunk));
+        const featureSubs = this.featureSubscribers.get(state.featureId);
+        if (featureSubs) {
+            featureSubs.forEach((sub) => sub(chunk));
+        }
+    }
+    // ---------------------------------------------------------------------------
     // Timer helpers
     // ---------------------------------------------------------------------------
     /** Start or restart the idle timeout timer for a session. */

package/dist/src/presentation/web/app/actions/get-git-log.d.ts

@@ -0,0 +1,44 @@
+export interface GitLogEntry {
+    hash: string;
+    shortHash: string;
+    subject: string;
+    author: string;
+    relativeDate: string;
+    branch?: string;
+}
+export interface GitBranchInfo {
+    name: string;
+    isCurrent: boolean;
+    lastCommitDate: string;
+}
+export interface GitRemoteInfo {
+    name: string;
+    url: string;
+}
+export interface GitWorkingTreeStatus {
+    staged: number;
+    modified: number;
+    untracked: number;
+}
+export interface GitDiffStats {
+    filesChanged: number;
+    insertions: number;
+    deletions: number;
+}
+export interface GitRepoInfo {
+    commits: GitLogEntry[];
+    branches: GitBranchInfo[];
+    remotes: GitRemoteInfo[];
+    tags: string[];
+    stashCount: number;
+    currentBranch: string;
+    diffStats: GitDiffStats | null;
+    workingTree: GitWorkingTreeStatus;
+    error?: string;
+}
+export declare function getGitRepoInfo(repositoryPath: string, commitLimit?: number): Promise<GitRepoInfo>;
+export declare function getGitLog(repositoryPath: string, limit?: number): Promise<{
+    entries: GitLogEntry[];
+    error?: string;
+}>;
+//# sourceMappingURL=get-git-log.d.ts.map

package/dist/src/presentation/web/app/actions/get-git-log.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-git-log.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/web/app/actions/get-git-log.ts"],"names":[],"mappings":"AAYA,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,OAAO,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,YAAY;IAC3B,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,WAAW,EAAE,CAAC;IACvB,QAAQ,EAAE,aAAa,EAAE,CAAC;IAC1B,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,YAAY,GAAG,IAAI,CAAC;IAC/B,WAAW,EAAE,oBAAoB,CAAC;IAClC,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,wBAAsB,cAAc,CAClC,cAAc,EAAE,MAAM,EACtB,WAAW,SAAI,GACd,OAAO,CAAC,WAAW,CAAC,CAwHtB;AAGD,wBAAsB,SAAS,CAC7B,cAAc,EAAE,MAAM,EACtB,KAAK,SAAK,GACT,OAAO,CAAC;IAAE,OAAO,EAAE,WAAW,EAAE,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAGrD"}

package/dist/src/presentation/web/app/actions/get-git-log.js

@@ -0,0 +1,125 @@
+'use server';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+async function git(cwd, args) {
+    const { stdout } = await execFileAsync('git', args, { cwd, timeout: 5000 });
+    return stdout.trim();
+}
+export async function getGitRepoInfo(repositoryPath, commitLimit = 8) {
+    const empty = {
+        commits: [],
+        branches: [],
+        remotes: [],
+        tags: [],
+        stashCount: 0,
+        currentBranch: '',
+        diffStats: null,
+        workingTree: { staged: 0, modified: 0, untracked: 0 },
+    };
+    if (!repositoryPath.trim()) {
+        return { ...empty, error: 'Repository path is required' };
+    }
+    const results = await Promise.allSettled([
+        // 0: commits
+        git(repositoryPath, [
+            'log',
+            `--max-count=${commitLimit}`,
+            '--format=%H%x00%h%x00%s%x00%an%x00%cr',
+            '--no-color',
+        ]),
+        // 1: current branch
+        git(repositoryPath, ['branch', '--show-current']),
+        // 2: branches with dates
+        git(repositoryPath, [
+            'branch',
+            '--sort=-committerdate',
+            '--format=%(HEAD)%(refname:short)%00%(committerdate:relative)',
+            '--no-color',
+        ]),
+        // 3: remotes
+        git(repositoryPath, ['remote', '-v']),
+        // 4: tags (recent 5)
+        git(repositoryPath, ['tag', '--sort=-creatordate', '-l', '--format=%(refname:short)']),
+        // 5: stash count
+        git(repositoryPath, ['stash', 'list']),
+        // 6: working tree status
+        git(repositoryPath, ['status', '--porcelain']),
+        // 7: diff stats (uncommitted)
+        git(repositoryPath, ['diff', '--shortstat']),
+    ]);
+    const val = (i) => (results[i].status === 'fulfilled' ? results[i].value : '');
+    // Parse commits
+    const commits = val(0)
+        .split('\n')
+        .filter(Boolean)
+        .map((line) => {
+        const [hash, shortHash, subject, author, relativeDate] = line.split('\0');
+        return { hash, shortHash, subject, author, relativeDate };
+    });
+    const currentBranch = val(1);
+    if (commits.length > 0 && currentBranch) {
+        commits[0].branch = currentBranch;
+    }
+    // Parse branches
+    const branches = val(2)
+        .split('\n')
+        .filter(Boolean)
+        .slice(0, 10)
+        .map((line) => {
+        const isCurrent = line.startsWith('*');
+        const clean = isCurrent ? line.slice(1) : line;
+        const [name, lastCommitDate] = clean.split('\0');
+        return { name: name.trim(), isCurrent, lastCommitDate: lastCommitDate?.trim() ?? '' };
+    });
+    // Parse remotes (dedup fetch/push)
+    const remoteMap = new Map();
+    val(3)
+        .split('\n')
+        .filter(Boolean)
+        .forEach((line) => {
+        const match = line.match(/^(\S+)\s+(\S+)\s+\(fetch\)/);
+        if (match) {
+            // Strip credentials/tokens from URL before sending to client
+            const sanitized = match[2].replace(/\/\/[^@]+@/, '//').replace(/x-access-token:[^@]+@/, '');
+            remoteMap.set(match[1], sanitized);
+        }
+    });
+    const remotes = Array.from(remoteMap, ([name, url]) => ({ name, url }));
+    // Parse tags (top 5)
+    const tags = val(4).split('\n').filter(Boolean).slice(0, 5);
+    // Stash count
+    const stashCount = val(5).split('\n').filter(Boolean).length;
+    // Working tree status
+    const statusLines = val(6).split('\n').filter(Boolean);
+    const workingTree = { staged: 0, modified: 0, untracked: 0 };
+    for (const line of statusLines) {
+        const x = line[0];
+        const y = line[1];
+        if (x === '?' && y === '?')
+            workingTree.untracked++;
+        else if (x !== ' ' && x !== '?')
+            workingTree.staged++;
+        if (y !== ' ' && y !== '?')
+            workingTree.modified++;
+    }
+    // Diff stats
+    let diffStats = null;
+    const diffLine = val(7);
+    if (diffLine) {
+        const files = diffLine.match(/(\d+) file/);
+        const ins = diffLine.match(/(\d+) insertion/);
+        const del = diffLine.match(/(\d+) deletion/);
+        diffStats = {
+            filesChanged: files ? parseInt(files[1], 10) : 0,
+            insertions: ins ? parseInt(ins[1], 10) : 0,
+            deletions: del ? parseInt(del[1], 10) : 0,
+        };
+    }
+    return { commits, branches, remotes, tags, stashCount, currentBranch, diffStats, workingTree };
+}
+// Keep backward compat
+export async function getGitLog(repositoryPath, limit = 10) {
+    const info = await getGitRepoInfo(repositoryPath, limit);
+    return { entries: info.commits, error: info.error };
+}

package/dist/src/presentation/web/app/actions/open-folder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"open-folder.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/web/app/actions/open-folder.ts"],"names":[],"mappings":"AAiBA,wBAAsB,UAAU,CAC9B,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CA8B9D"}
+{"version":3,"file":"open-folder.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/web/app/actions/open-folder.ts"],"names":[],"mappings":"AAiBA,wBAAsB,UAAU,CAC9B,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAkC9D"}

package/dist/src/presentation/web/app/actions/open-folder.js

@@ -1,7 +1,7 @@
 'use server';
 import { existsSync } from 'node:fs';
 import { platform } from 'node:os';
-import { isAbsolute } from 'node:path';
+import { isAbsolute, normalize } from 'node:path';
 import { spawn } from 'node:child_process';
 // Use a record lookup instead of if/else to prevent the bundler from
 // tree-shaking platform branches at build time. Turbopack evaluates
@@ -27,7 +27,10 @@ export async function openFolder(repositoryPath) {
                 error: `Unsupported platform: ${platform()}`,
             };
         }
-        const child = spawn(entry.cmd, entry.args(repositoryPath), {
+        // Normalize to platform-native separators — explorer.exe on Windows
+        // does not understand forward-slash paths and falls back to Documents.
+        const nativePath = normalize(repositoryPath);
+        const child = spawn(entry.cmd, entry.args(nativePath), {
             detached: true,
             stdio: 'ignore',
         });

package/dist/src/presentation/web/app/api/interactive/chat/[featureId]/messages/route.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../../../../../../../src/presentation/web/app/api/interactive/chat/[featureId]/messages/route.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAO3C,eAAO,MAAM,OAAO,kBAAkB,CAAC;AAIvC,UAAU,WAAW;IACnB,MAAM,EAAE,OAAO,CAAC;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACxC;AAED,wBAAsB,IAAI,CAAC,OAAO,EAAE,WAAW,EAAE,EAAE,MAAM,EAAE,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC,CAuC/F;AAED,wBAAsB,MAAM,CAC1B,QAAQ,EAAE,WAAW,EACrB,EAAE,MAAM,EAAE,EAAE,WAAW,GACtB,OAAO,CAAC,YAAY,CAAC,CAgBvB;AAED,wBAAsB,GAAG,CAAC,QAAQ,EAAE,WAAW,EAAE,EAAE,MAAM,EAAE,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC,CAe/F"}
+{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../../../../../../../src/presentation/web/app/api/interactive/chat/[featureId]/messages/route.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAO3C,eAAO,MAAM,OAAO,kBAAkB,CAAC;AAIvC,UAAU,WAAW;IACnB,MAAM,EAAE,OAAO,CAAC;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACxC;AAED,wBAAsB,IAAI,CAAC,OAAO,EAAE,WAAW,EAAE,EAAE,MAAM,EAAE,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC,CA8C/F;AAED,wBAAsB,MAAM,CAC1B,QAAQ,EAAE,WAAW,EACrB,EAAE,MAAM,EAAE,EAAE,WAAW,GACtB,OAAO,CAAC,YAAY,CAAC,CAgBvB;AAED,wBAAsB,GAAG,CAAC,QAAQ,EAAE,WAAW,EAAE,EAAE,MAAM,EAAE,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC,CAe/F"}

package/dist/src/presentation/web/app/api/interactive/chat/[featureId]/messages/route.js

@@ -18,7 +18,7 @@ export async function POST(request, { params }) {
     try {
         const { featureId } = await params;
         const body = (await request.json());
-        const { content, worktreePath } = body;
+        const { content, worktreePath, model, agentType } = body;
         if (!content || typeof content !== 'string' || content.trim().length === 0) {
             return NextResponse.json({ error: 'content must be a non-empty string' }, { status: 400 });
         }
@@ -35,6 +35,8 @@ export async function POST(request, { params }) {
             featureId,
             content,
             worktreePath: resolvedWorktreePath,
+            model: typeof model === 'string' ? model : undefined,
+            agentType: typeof agentType === 'string' ? agentType : undefined,
         });
         return NextResponse.json({ message }, { status: 201 });
     }

package/dist/src/presentation/web/components/assistant-ui/thread.js

@@ -152,6 +152,12 @@ function ThinkingIndicator({ booting }) {
 // ── Message metadata (timestamp + relative time) ────────────────────────────
 function MessageMeta() {
     const message = useMessage();
+    // Tick every 30s so relative timestamps stay fresh
+    const [tick, setTick] = useState(0);
+    useEffect(() => {
+        const id = setInterval(() => setTick((t) => t + 1), 30_000);
+        return () => clearInterval(id);
+    }, []);
     const meta = useMemo(() => {
         if (!message?.createdAt)
             return null;
@@ -162,7 +168,8 @@ function MessageMeta() {
             time: date.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' }),
             relative: formatRelativeTime(date),
         };
-    }, [message?.createdAt]);
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [message?.createdAt, tick]);
     if (!meta)
         return null;
     return (_jsx("span", { className: "text-muted-foreground/60 text-[10px]", title: meta.time, children: meta.relative }));