@akiojin/gwt 2.7.4 → 2.8.0

package/src/cli/ui/components/screens/BranchListScreen.tsx

@@ -279,7 +279,12 @@ export function BranchListScreen({
       // Use a small safety margin to avoid terminal-dependent wrapping
       const columns = Math.max(20, context.columns - 1);
       const arrow = isSelected ? ">" : " ";
-      const timestampText = formatLatestCommit(item.latestCommitTimestamp);
+      const commitText = formatLatestCommit(item.latestCommitTimestamp);
+      const infoText =
+        item.lastToolUsage && item.lastToolUsageLabel
+          ? item.lastToolUsageLabel
+          : `${chalk.gray("Unknown")}${commitText !== "---" ? ` | ${commitText}` : ""}`;
+      const timestampText = infoText;
       const timestampWidth = stringWidth(timestampText);
 
       const indicatorInfo = cleanupUI?.indicators?.[item.name];

package/src/cli/ui/hooks/useGitData.ts

@@ -9,6 +9,7 @@ import { listAdditionalWorktrees } from "../../../worktree.js";
 import { getPullRequestByBranch } from "../../../github.js";
 import type { BranchInfo, WorktreeInfo } from "../types.js";
 import type { WorktreeInfo as GitWorktreeInfo } from "../../../worktree.js";
+import { getLastToolUsageMap } from "../../../config/index.js";
 
 export interface UseGitDataOptions {
   enableAutoRefresh?: boolean;
@@ -52,10 +53,17 @@ export function useGitData(options?: UseGitDataOptions): UseGitDataResult {
         }
       }
 
-      const [branchesData, worktreesData] = await Promise.all([
-        getAllBranches(),
-        listAdditionalWorktrees(),
-      ]);
+      const branchesData = await getAllBranches();
+      let worktreesData: GitWorktreeInfo[] = [];
+      try {
+        worktreesData = await listAdditionalWorktrees();
+      } catch (err) {
+        if (process.env.DEBUG) {
+          console.error("Failed to list additional worktrees:", err);
+        }
+        worktreesData = [];
+      }
+      const lastToolUsageMap = await getLastToolUsageMap(repoRoot);
 
       // Store worktrees separately
       setWorktrees(worktreesData);
@@ -117,6 +125,9 @@ export function useGitData(options?: UseGitDataOptions): UseGitDataResult {
                   },
                 }
               : {}),
+            ...(lastToolUsageMap.get(branch.name)
+              ? { lastToolUsage: lastToolUsageMap.get(branch.name) ?? null }
+              : {}),
           };
         }),
       );

package/src/cli/ui/types.ts

@@ -5,8 +5,11 @@ export interface WorktreeInfo {
   isAccessible?: boolean;
 }
 
+import type { LastToolUsage } from "../../types/api.js";
+
 export type AITool = string;
 export type InferenceLevel = "low" | "medium" | "high" | "xhigh";
+export type { LastToolUsage } from "../../types/api.js";
 
 export interface ModelOption {
   id: string;
@@ -35,6 +38,7 @@ export interface BranchInfo {
   openPR?: { number: number; title: string };
   mergedPR?: { number: number; mergedAt: string };
   latestCommitTimestamp?: number;
+  lastToolUsage?: LastToolUsage | null;
 }
 
 export interface BranchChoice {
@@ -204,6 +208,7 @@ export interface BranchItem extends BranchInfo {
   hasChanges: boolean;
   label: string;
   value: string;
+  lastToolUsageLabel?: string | null;
 }
 
 /**

package/src/cli/ui/utils/branchFormatter.ts

@@ -6,6 +6,7 @@ import type {
   WorktreeInfo,
 } from "../types.js";
 import stringWidth from "string-width";
+import chalk from "chalk";
 
 // Icon mappings
 const branchIcons: Record<BranchType, string> = {
@@ -69,6 +70,51 @@ export interface FormatOptions {
   hasChanges?: boolean;
 }
 
+function mapToolLabel(toolId: string, toolLabel?: string): string {
+  if (toolId === "claude-code") return "Claude";
+  if (toolId === "codex-cli") return "Codex";
+  if (toolId === "gemini-cli") return "Gemini";
+  if (toolId === "qwen-cli") return "Qwen";
+  if (toolLabel) return toolLabel;
+  return "Custom";
+}
+
+function mapModeLabel(
+  mode?: "normal" | "continue" | "resume" | null,
+): string | null {
+  if (mode === "normal") return "New";
+  if (mode === "continue") return "Continue";
+  if (mode === "resume") return "Resume";
+  return null;
+}
+
+function formatTimestamp(ts: number): string {
+  const date = new Date(ts);
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  const hours = String(date.getHours()).padStart(2, "0");
+  const minutes = String(date.getMinutes()).padStart(2, "0");
+  return `${year}-${month}-${day} ${hours}:${minutes}`;
+}
+
+function buildLastToolUsageLabel(
+  usage?: BranchInfo["lastToolUsage"] | null,
+): string | null {
+  if (!usage) return null;
+  const toolText = mapToolLabel(usage.toolId, usage.toolLabel);
+  const modeText = mapModeLabel(usage.mode);
+  const timestamp = usage.timestamp ? formatTimestamp(usage.timestamp) : null;
+  const parts = [toolText];
+  if (modeText) {
+    parts.push(modeText);
+  }
+  if (timestamp) {
+    parts.push(timestamp);
+  }
+  return parts.join(" | ");
+}
+
 /**
  * Converts BranchInfo to BranchItem with display properties
  */
@@ -171,6 +217,7 @@ export function formatBranchItem(
     hasChanges,
     label,
     value: branch.name,
+    lastToolUsageLabel: buildLastToolUsageLabel(branch.lastToolUsage),
   };
 }
 

package/src/config/index.ts

@@ -16,6 +16,20 @@ export interface SessionData {
   lastUsedTool?: string;
   timestamp: number;
   repositoryRoot: string;
+  mode?: "normal" | "continue" | "resume";
+  model?: string | null;
+  toolLabel?: string | null;
+  history?: ToolSessionEntry[];
+}
+
+export interface ToolSessionEntry {
+  branch: string;
+  worktreePath: string | null;
+  toolId: string;
+  toolLabel: string;
+  mode?: "normal" | "continue" | "resume" | null;
+  model?: string | null;
+  timestamp: number;
 }
 
 const DEFAULT_CONFIG: AppConfig = {
@@ -104,7 +118,38 @@ export async function saveSession(sessionData: SessionData): Promise<void> {
     // ディレクトリを作成
     await mkdir(sessionDir, { recursive: true });
 
-    await writeFile(sessionPath, JSON.stringify(sessionData, null, 2), "utf-8");
+    // 既存履歴を読み込み（後方互換のため失敗は無視）
+    let existingHistory: ToolSessionEntry[] = [];
+    try {
+      const currentContent = await readFile(sessionPath, "utf-8");
+      const parsed = JSON.parse(currentContent) as SessionData;
+      if (Array.isArray(parsed.history)) {
+        existingHistory = parsed.history;
+      }
+    } catch {
+      // ignore
+    }
+
+    // 新しい履歴エントリを追加（branch/worktree/toolが揃っている場合のみ）
+    if (sessionData.lastBranch && sessionData.lastWorktreePath) {
+      const entry: ToolSessionEntry = {
+        branch: sessionData.lastBranch,
+        worktreePath: sessionData.lastWorktreePath,
+        toolId: sessionData.lastUsedTool ?? "unknown",
+        toolLabel: sessionData.toolLabel ?? sessionData.lastUsedTool ?? "Custom",
+        mode: sessionData.mode ?? null,
+        model: sessionData.model ?? null,
+        timestamp: sessionData.timestamp,
+      };
+      existingHistory = [...existingHistory, entry].slice(-100); // keep latest 100
+    }
+
+    const payload: SessionData = {
+      ...sessionData,
+      history: existingHistory,
+    };
+
+    await writeFile(sessionPath, JSON.stringify(payload, null, 2), "utf-8");
   } catch (error) {
     // セッション保存の失敗は致命的ではないため、エラーをログに出力するのみ
     if (process.env.DEBUG_SESSION) {
@@ -192,3 +237,44 @@ export async function getAllSessions(): Promise<SessionData[]> {
     return [];
   }
 }
+
+/**
+ * 各ブランチの最新ツール利用履歴を取得
+ */
+export async function getLastToolUsageMap(
+  repositoryRoot: string,
+): Promise<Map<string, ToolSessionEntry>> {
+  const map = new Map<string, ToolSessionEntry>();
+  try {
+    const sessionPath = getSessionFilePath(repositoryRoot);
+    const content = await readFile(sessionPath, "utf-8");
+    const parsed = JSON.parse(content) as SessionData;
+
+    const history: ToolSessionEntry[] = Array.isArray(parsed.history)
+      ? parsed.history
+      : [];
+
+    // 後方互換: historyが無い場合はlastUsedToolを1件扱い
+    if (!history.length && parsed.lastBranch && parsed.lastWorktreePath) {
+      history.push({
+        branch: parsed.lastBranch,
+        worktreePath: parsed.lastWorktreePath,
+        toolId: parsed.lastUsedTool ?? "unknown",
+        toolLabel: parsed.toolLabel ?? parsed.lastUsedTool ?? "Custom",
+        mode: parsed.mode ?? null,
+        model: parsed.model ?? null,
+        timestamp: parsed.timestamp ?? Date.now(),
+      });
+    }
+
+    for (const entry of history) {
+      const existing = map.get(entry.branch);
+      if (!existing || existing.timestamp < entry.timestamp) {
+        map.set(entry.branch, entry);
+      }
+    }
+  } catch {
+    // セッションファイルが無い/壊れている場合は空のMapを返す
+  }
+  return map;
+}

package/src/git.ts

@@ -58,27 +58,103 @@ export async function isGitRepository(): Promise<boolean> {
  * @throws {GitError} リポジトリルートの取得に失敗した場合
  */
 export async function getRepositoryRoot(): Promise<string> {
+  const fs = await import("node:fs");
+  const path = await import("node:path");
+
+  const toExistingDir = (p: string): string => {
+    let current = path.resolve(p);
+    while (!fs.existsSync(current) && path.dirname(current) !== current) {
+      current = path.dirname(current);
+    }
+    if (!fs.existsSync(current)) {
+      return current;
+    }
+    try {
+      const stat = fs.statSync(current);
+      return stat.isDirectory() ? current : path.dirname(current);
+    } catch {
+      return current;
+    }
+  };
+
+  // 1) show-toplevel を最優先
+  try {
+    const { stdout } = await execa("git", ["rev-parse", "--show-toplevel"]);
+    const top = stdout.trim();
+    if (top) {
+      const marker = `${path.sep}.worktrees${path.sep}`;
+      const idx = top.indexOf(marker);
+      if (idx >= 0) {
+        // /repo/.worktrees/<name> → repo root = /repo
+        const parent = top.slice(0, idx);
+        const upTwo = path.resolve(top, "..", "..");
+        if (fs.existsSync(parent)) return toExistingDir(parent);
+        if (fs.existsSync(upTwo)) return toExistingDir(upTwo);
+      }
+      if (fs.existsSync(top)) {
+        return toExistingDir(top);
+      }
+      return toExistingDir(path.resolve(top, ".."));
+    }
+  } catch {
+    // fallback
+  }
+
+  // 2) git-common-dir 経由
   try {
-    // git rev-parse --git-common-dirを使用してメインリポジトリの.gitディレクトリを取得
     const { stdout: gitCommonDir } = await execa("git", [
       "rev-parse",
       "--git-common-dir",
     ]);
-    const gitDir = gitCommonDir.trim();
-
-    // .gitディレクトリの親ディレクトリがリポジトリルート
-    const path = await import("node:path");
-    const repoRoot = path.dirname(gitDir);
-
-    // 相対パスが返された場合（.gitなど）は、現在のディレクトリからの相対パスとして解決
-    if (!path.isAbsolute(repoRoot)) {
-      return path.resolve(repoRoot);
+    const gitDir = path.resolve(gitCommonDir.trim());
+    const parts = gitDir.split(path.sep);
+    const idxWorktrees = parts.lastIndexOf("worktrees");
+    if (idxWorktrees > 0) {
+      const repo = parts.slice(0, idxWorktrees).join(path.sep);
+      if (fs.existsSync(repo)) return toExistingDir(repo);
     }
+    const idxGit = parts.lastIndexOf(".git");
+    if (idxGit > 0) {
+      const repo = parts.slice(0, idxGit).join(path.sep);
+      if (fs.existsSync(repo)) return toExistingDir(repo);
+    }
+    return toExistingDir(path.dirname(gitDir));
+  } catch {
+    // fallback
+  }
 
-    return repoRoot;
-  } catch (error) {
-    throw new GitError("Failed to get repository root", error);
+  // 3) .git を上に辿って探す
+  let current = process.cwd();
+  const root = path.parse(current).root;
+  while (true) {
+    const candidate = path.join(current, ".git");
+    if (fs.existsSync(candidate)) {
+      if (fs.statSync(candidate).isDirectory()) {
+        return toExistingDir(current);
+      }
+      try {
+        const content = fs.readFileSync(candidate, "utf-8");
+        const match = content.match(/gitdir:\s*(.+)\s*/i);
+        const gitDirMatch = match?.[1];
+        if (gitDirMatch) {
+          const gitDirPath = path.resolve(current, gitDirMatch.trim());
+          const parts = gitDirPath.split(path.sep);
+          const idxWT = parts.lastIndexOf("worktrees");
+          if (idxWT > 0) {
+            const repo = parts.slice(0, idxWT).join(path.sep);
+            return toExistingDir(repo);
+          }
+          return toExistingDir(path.dirname(gitDirPath));
+        }
+      } catch {
+        // ignore and continue
+      }
+    }
+    if (current === root) break;
+    current = path.dirname(current);
   }
+
+  throw new GitError("Failed to get repository root");
 }
 
 /**
@@ -97,22 +173,33 @@ export async function getWorktreeRoot(): Promise<string> {
 
 export async function getCurrentBranch(): Promise<string | null> {
   try {
-    const { stdout } = await execa("git", ["branch", "--show-current"]);
+    const repoRoot = await getRepositoryRoot();
+    const { stdout } = await execa(
+      "git",
+      ["branch", "--show-current"],
+      { cwd: repoRoot },
+    );
     return stdout.trim() || null;
   } catch {
-    return null;
+    try {
+      const { stdout } = await execa("git", ["branch", "--show-current"]);
+      return stdout.trim() || null;
+    } catch {
+      return null;
+    }
   }
 }
 
 async function getBranchCommitTimestamps(
   refs: string[],
+  cwd?: string,
 ): Promise<Map<string, number>> {
   try {
-    const { stdout } = await execa("git", [
+    const { stdout = "" } = (await execa("git", [
       "for-each-ref",
       "--format=%(refname:short)%00%(committerdate:unix)",
       ...refs,
-    ]);
+    ], cwd ? { cwd } : undefined)) ?? { stdout: "" };
 
     const map = new Map<string, number>();
 
@@ -135,10 +222,9 @@ async function getBranchCommitTimestamps(
 export async function getLocalBranches(): Promise<BranchInfo[]> {
   try {
     const commitMap = await getBranchCommitTimestamps(["refs/heads"]);
-    const { stdout } = await execa("git", [
-      "branch",
-      "--format=%(refname:short)",
-    ]);
+    const { stdout = "" } =
+      (await execa("git", ["branch", "--format=%(refname:short)"])) ??
+      { stdout: "" };
     return stdout
       .split("\n")
       .filter((line) => line.trim())
@@ -156,19 +242,17 @@ export async function getLocalBranches(): Promise<BranchInfo[]> {
             : {}),
         } satisfies BranchInfo;
       });
-  } catch (error) {
-    throw new GitError("Failed to get local branches", error);
+  } catch (primaryError) {
+    throw new GitError("Failed to get local branches", primaryError);
   }
 }
 
 export async function getRemoteBranches(): Promise<BranchInfo[]> {
   try {
     const commitMap = await getBranchCommitTimestamps(["refs/remotes"]);
-    const { stdout } = await execa("git", [
-      "branch",
-      "-r",
-      "--format=%(refname:short)",
-    ]);
+    const { stdout = "" } =
+      (await execa("git", ["branch", "-r", "--format=%(refname:short)"])) ??
+      { stdout: "" };
     return stdout
       .split("\n")
       .filter((line) => line.trim() && !line.includes("HEAD"))
@@ -187,8 +271,8 @@ export async function getRemoteBranches(): Promise<BranchInfo[]> {
             : {}),
         } satisfies BranchInfo;
       });
-  } catch (error) {
-    throw new GitError("Failed to get remote branches", error);
+  } catch (primaryError) {
+    throw new GitError("Failed to get remote branches", primaryError);
   }
 }
 

package/src/index.ts

@@ -670,6 +670,9 @@ export async function handleAIToolWorkflow(
       lastWorktreePath: worktreePath,
       lastBranch: branch,
       lastUsedTool: tool,
+      toolLabel: toolConfig.displayName ?? tool,
+      mode,
+      model: model ?? null,
       timestamp: Date.now(),
       repositoryRoot: repoRoot,
     });

package/src/types/api.ts

@@ -30,6 +30,7 @@ export interface Branch {
     state: "open" | "merged" | "closed";
     mergedAt?: string | null;
   } | null;
+  lastToolUsage?: LastToolUsage | null;
 }
 
 /**
@@ -46,6 +47,7 @@ export interface Worktree {
   lastAccessedAt?: string | null; // ISO8601
   divergence?: Branch["divergence"];
   prInfo?: Branch["prInfo"];
+  lastToolUsage?: LastToolUsage | null;
 }
 
 /**
@@ -102,6 +104,16 @@ export interface CustomAITool {
   updatedAt?: string | null; // ISO8601
 }
 
+export interface LastToolUsage {
+  branch: string;
+  worktreePath: string | null;
+  toolId: string;
+  toolLabel: string;
+  mode?: "normal" | "continue" | "resume" | null;
+  model?: string | null;
+  timestamp: number; // epoch millis
+}
+
 /**
  * REST API Response wrappers
  */

package/src/web/client/src/pages/BranchDetailPage.tsx

@@ -10,7 +10,11 @@ import {
 import { useConfig } from "../hooks/useConfig";
 import { ApiError } from "../lib/api";
 import { Terminal } from "../components/Terminal";
-import type { Branch, CustomAITool } from "../../../../types/api.js";
+import type {
+  Branch,
+  CustomAITool,
+  LastToolUsage,
+} from "../../../../types/api.js";
 
 type ToolType = "claude-code" | "codex-cli" | "custom";
 type ToolMode = "normal" | "continue" | "resume";
@@ -410,6 +414,29 @@ export function BranchDetailPage() {
       .sort((a, b) => (b.startedAt ?? "").localeCompare(a.startedAt ?? ""));
   }, [sessionsData, branch?.worktreePath]);
 
+  const latestToolUsage: LastToolUsage | null = useMemo(() => {
+    if (branch?.lastToolUsage) {
+      return branch.lastToolUsage;
+    }
+    const first = branchSessions[0];
+    if (!first) return null;
+    return {
+      branch: branch.name,
+      worktreePath: branch.worktreePath ?? null,
+      toolId:
+        first.toolType === "custom"
+          ? first.toolName ?? "custom"
+          : (first.toolType as LastToolUsage["toolId"]),
+      toolLabel:
+        first.toolType === "custom"
+          ? first.toolName ?? "Custom"
+          : toolLabel(first.toolType),
+      mode: first.mode ?? "normal",
+      model: null,
+      timestamp: first.startedAt ? Date.parse(first.startedAt) : Date.now(),
+    };
+  }, [branch?.lastToolUsage, branch?.name, branch?.worktreePath, branchSessions]);
+
   const handleSessionExit = (code: number) => {
     setActiveSessionId(null);
     setIsTerminalFullscreen(false);
@@ -449,6 +476,21 @@ export function BranchDetailPage() {
             {branch.worktreePath ? "Worktreeあり" : "Worktree未作成"}
           </span>
         </div>
+        <div className="badge-group" style={{ marginTop: "0.5rem" }}>
+          {latestToolUsage ? (
+            <>
+              <span className="status-badge status-badge--muted">
+                {renderToolUsage(latestToolUsage)}
+              </span>
+              <span className="status-badge status-badge--muted">
+                {formatUsageTimestamp(latestToolUsage.timestamp)} ・ worktree:{" "}
+                {latestToolUsage.worktreePath ?? branch.worktreePath ?? "N/A"}
+              </span>
+            </>
+          ) : (
+            <span className="status-badge status-badge--muted">Unknown</span>
+          )}
+        </div>
         <div className="page-hero__actions">
           {!canStartSession ? (
             <button
@@ -950,6 +992,32 @@ const SESSION_STATUS_LABEL: Record<
   failed: "failed",
 };
 
+function renderToolUsage(usage: LastToolUsage): string {
+  const modeLabel =
+    usage.mode === "normal"
+      ? "New"
+      : usage.mode === "continue"
+        ? "Continue"
+        : usage.mode === "resume"
+          ? "Resume"
+          : null;
+  const toolText = mapToolLabel(usage.toolId, usage.toolLabel);
+  return [toolText, modeLabel, usage.model].filter(Boolean).join(" | ");
+}
+
+function formatUsageTimestamp(value: number): string {
+  return formatDate(new Date(value).toISOString());
+}
+
+function mapToolLabel(toolId: string, toolLabel?: string | null): string {
+  if (toolId === "claude-code") return "Claude";
+  if (toolId === "codex-cli") return "Codex";
+  if (toolId === "gemini-cli") return "Gemini";
+  if (toolId === "qwen-cli") return "Qwen";
+  if (toolLabel) return toolLabel;
+  return "Custom";
+}
+
 function parseExtraArgs(value: string): string[] {
   return value
     .split(/\s+/)

package/src/web/server/routes/sessions.ts

@@ -11,6 +11,8 @@ import type {
   AIToolSession,
   StartSessionRequest,
 } from "../../../types/api.js";
+import { saveSession } from "../../../config/index.js";
+import { execa } from "execa";
 
 /**
  * セッション関連のルートを登録
@@ -53,6 +55,37 @@ export async function registerSessionRoutes(
         toolName,
       );
 
+      // 履歴を永続化（best-effort）
+      try {
+        const { stdout: repoRoot } = await execa("git", ["rev-parse", "--show-toplevel"], {
+          cwd: worktreePath,
+        });
+        let branchName: string | null = null;
+        try {
+          const { stdout: branchStdout } = await execa(
+            "git",
+            ["rev-parse", "--abbrev-ref", "HEAD"],
+            { cwd: worktreePath },
+          );
+          branchName = branchStdout.trim() || null;
+        } catch {
+          branchName = null;
+        }
+
+        await saveSession({
+          lastWorktreePath: worktreePath,
+          lastBranch: branchName,
+          lastUsedTool: toolType === "custom" ? toolName ?? "custom" : toolType,
+          toolLabel:
+            toolType === "custom" ? toolName ?? "Custom" : toolLabelFromType(toolType),
+          mode,
+          timestamp: Date.now(),
+          repositoryRoot: repoRoot.trim(),
+        });
+      } catch {
+        // ignore persistence errors
+      }
+
       reply.code(201);
       return { success: true, data: session };
     } catch (error) {
@@ -128,3 +161,9 @@ export async function registerSessionRoutes(
     }
   });
 }
+
+function toolLabelFromType(toolType: "claude-code" | "codex-cli" | "custom") {
+  if (toolType === "claude-code") return "Claude";
+  if (toolType === "codex-cli") return "Codex";
+  return "Custom";
+}

package/src/web/server/services/branches.ts

@@ -16,6 +16,7 @@ import {
 import { getPullRequestByBranch } from "../../../github.js";
 import { listAdditionalWorktrees } from "../../../worktree.js";
 import type { Branch, BranchSyncResult } from "../../../types/api.js";
+import { getLastToolUsageMap } from "../../../config/index.js";
 
 type DivergenceStatus = { remoteAhead: number; localAhead: number };
 type DivergenceValue = NonNullable<NonNullable<Branch["divergence"]>>;
@@ -38,6 +39,7 @@ function mapPullRequestState(state: string): "open" | "merged" | "closed" {
  */
 export async function listBranches(): Promise<Branch[]> {
   const repoRoot = await getRepositoryRoot();
+  const lastToolUsageMap = await getLastToolUsageMap(repoRoot);
 
   // リモートブランチの最新情報を取得（失敗してもローカル情報にはフォールバック）
   try {
@@ -103,6 +105,8 @@ export async function listBranches(): Promise<Branch[]> {
         ? mapDivergence(divergenceStatus)
         : null;
 
+      const lastToolUsage = lastToolUsageMap.get(branchInfo.name) ?? null;
+
       return {
         name: branchInfo.name,
         type: branchInfo.type,
@@ -116,6 +120,7 @@ export async function listBranches(): Promise<Branch[]> {
         baseBranch: baseBranch ?? null,
         divergence,
         prInfo,
+        ...(lastToolUsage ? { lastToolUsage } : {}),
       };
     }),
   );