@hienlh/ppm 0.9.86 → 0.9.87

package/docs/project-changelog.md

@@ -2,13 +2,51 @@
 
 All notable changes to PPM are documented here. Format follows [Keep a Changelog](https://keepachangelog.com/).
 
-**Current Version:** v0.9.85
+**Current Version:** v0.9.86
 
 ---
 
-## [Unreleased] — Bundled Extensions + Git-Graph Refinement + Code Quality Improvements
+## [Unreleased] — Git-Graph Stash Management, Rebase, Conflict Resolution + Worktree CRUD
 
 ### Added
+- **Git Stash Management** — Toolbar popover for interactive stash operations
+  - List all stashes with index, hash (abbreviated), and message
+  - Apply/Pop/Drop actions per stash via context menu or action buttons
+  - "Stash Changes" button in main toolbar to stash uncommitted work
+  - Stash list persisted in RepoInfo and refreshed on uncommitted status updates
+  - Keyboard shortcuts for quick access to stash operations
+
+- **Interactive Rebase** — Branch context menu + commit history actions
+  - "Rebase current branch onto..." option in commit context menu
+  - Confirmation dialog shows branch selection and target commit
+  - Rebase state detection and progress tracking (e.g., "3/5" for interactive rebase)
+  - Continue/Skip/Abort controls in merge state banner during rebase
+
+- **Merge/Rebase/Cherry-Pick Conflict Detection** — Visual conflict indicators
+  - Detects merge state from .git sentinel files (MERGE_HEAD, REBASE_MERGE, CHERRY_PICK_HEAD)
+  - Parses git status UU/AA/DD/AU/UA/DU/UD codes for unmerged entries
+  - Conflicted files displayed in "Conflicts" section in uncommitted status
+  - Conflict state banner shows merge state type + progress + action buttons (Continue/Skip/Abort)
+  - Auto-detects merge state only when conflicts exist (performance optimization)
+
+- **Inline Conflict Resolution Editor** — New conflict-editor tab type with Monaco
+  - Dedicated `conflict-editor` tab type for visual conflict resolution
+  - Monaco-based editor with syntax highlighting per file type (JS/TS/Python/etc.)
+  - Conflict regions visually highlighted: green for current, blue for incoming, gray for markers
+  - Accept buttons: Accept Current / Accept Incoming / Accept Both (with proper merging)
+  - Conflict counter in header: "N conflicts remaining" → "All conflicts resolved" on completion
+  - Automatic file save after each resolution; conflict count updates in real-time
+  - Parses 3-way conflict markers (<<<<<<, =======, >>>>>>>) and extracts labels (HEAD/branch names)
+
+- **Worktree Management** — Full CRUD with project integration
+  - Worktree toolbar popover listing all worktrees (with path, branch, HEAD status)
+  - Create worktree from commit context menu ("Create Worktree Here...")
+  - Remove, prune, and auto-lock operations per worktree
+  - Current worktree highlighted with badge and active background
+  - Auto-add unregistered worktrees as projects via confirmation dialog
+  - Branch-already-exists dialog offers force-replace option for branch conflicts
+  - Project switcher integration: switch to worktree branches directly
+
 - **Bundled Extensions Support** — Auto-discover extensions from packages/ext-* directories
   - PPM discovers bundled extensions (e.g., ext-git-graph) without manual installation
   - Bundled extensions available out-of-the-box with all PPM instances
@@ -29,12 +67,13 @@ All notable changes to PPM are documented here. Format follows [Keep a Changelog
   - Path traversal validation for security (assertSafePath in RPC handlers)
   - Fallback guards for all tab type handling (unknown tab types safely ignored)
 
-- **Extension Host Stability** — Worker debugging & error handling improvements
-  - Enhanced error logging in extension host worker
-  - Fixed localHandlers presence check before RPC invocation
-  - Proper disposed flag tracking to prevent polling race conditions
-  - HEAD ref type detection corrected for git operations
-  - Removed unused variable warnings from build
+- **Extension Error Reporting & Logging** — Silent failure debugging & user feedback
+  - Activation error tracking: Map stores `extId → error message` in ExtensionService
+  - Error toasts on command failure: "Extension command failed: {error}" displays in UI
+  - Timeout UX improved: Fallback UI shows activation error + "Retry" button for quick recovery
+  - Breadcrumb logging with tags for debugging: `[ExtService]`, `[ExtHost]`, `[ExtWS]`, `[ext-git-graph]`
+  - Console logs track: activation start/success, command routing, failures with context
+  - Activation errors included in `contributions:update` message sent to browser on WS connect
 
 - **Faithful SVG Graph Rendering** — Port of vscode-git-graph algorithm with deterministic layout
   - Single SVG model with continuous branch paths using Bézier curves
@@ -47,32 +86,54 @@ All notable changes to PPM are documented here. Format follows [Keep a Changelog
   - Removed dot alignment bug that forced rows to 29px
 
 ### Technical Details
+
+**Stash/Rebase/Conflict/Worktree Implementation:**
+- **Files Created:**
+  - `src/web/components/editor/conflict-editor.tsx` — Monaco-based conflict resolution editor with visual highlighting, accept buttons, real-time conflict counter, auto-save on resolution
+
 - **Files Modified:**
+  - `packages/ext-git-graph/src/extension.ts` — Added stash parsing, merge state detection (merge/rebase/cherry-pick), conflict file opening, worktree CRUD operations, branch context menu rebase action
+  - `packages/ext-git-graph/src/types.ts` — Added Stash interface, MergeState interface (type, progress, message), FileChange status "U" for unmerged, Worktree interface, updated UncommittedData with conflicted field
+  - `packages/ext-git-graph/src/webview-html.ts` — Added stash popover UI, rebase context menu item, conflict section in uncommitted panel, merge state banner with Continue/Skip/Abort, worktree popover with CRUD UI
+  - `src/web/stores/tab-store.ts` — Added "conflict-editor" as valid TabType
+  - `src/web/stores/panel-utils.ts` — Added conflict-editor case to deriveTabId() for metadata-driven tab ID generation
+  - `src/web/components/layout/editor-panel.tsx` — Lazy-imported ConflictEditor component with fallback
+  - `src/web/components/layout/tab-content.tsx` — Lazy-imported ConflictEditor component with fallback
+  - `src/web/components/layout/mobile-nav.tsx` — Added conflict-editor icon (conflict/warning icon)
+  - `src/web/components/layout/tab-bar.tsx` — Added conflict-editor icon (conflict/warning icon)
+
+- **Services Modified:**
   - `src/services/extension-manifest.ts` — Added discoverBundledManifests() to scan packages/ext-* dirs
   - `src/services/extension.service.ts` — Added extensionPaths Map, bundledIds Set, isBundled() method; updated discover()/activate()/remove() to handle bundled extensions
   - `src/cli/commands/ext-cmd.ts` — Added "Source" column to `ppm ext list`, calls discover() to populate bundled info
-  - `packages/ext-git-graph/src/webview-html.ts` — UX refinements: branch context menu, dblclick checkout, toast notifications, SVG Lucide icons, 10s auto-fetch option, improved UI responsiveness
-  - `packages/ext-git-graph/src/extension.ts` — 5s uncommitted status polling, openFile/openSourceControl handlers, enhanced error handling
-  - `packages/ext-git-graph/src/types.ts` — Added autoFetchInterval, new message types
   - `src/services/extension-rpc-handlers.ts` — Allow git operations in all registered project paths (not just CWD), improved path validation
   - `src/services/extension-host-worker.ts` — Enhanced error logging, localHandlers check, disposed flag fix for polling race conditions
-  - `src/web/components/layout/tab-bar.tsx` — Fallback guard for unknown tab types
-  - `src/web/components/layout/mobile-nav.tsx` — Fallback guard for unknown tab types
-  - `src/web/components/layout/tab-content.tsx` — Fallback guard for unknown tab types
-  - `src/web/components/layout/editor-panel.tsx` — Fallback guard for unknown tab types
-  - `src/web/hooks/use-extension-ws.ts` — Enhanced RPC integration
-  - `src/types/extension-messages.ts` — New message types for UX events
-- **New Tests:**
-  - `tests/unit/services/extension-manifest.test.ts` — 9 tests for discoverBundledManifests() and manifest parsing
-  - `tests/unit/services/extension-service-bundled.test.ts` — 9 tests for isBundled(), discover(), and removal protection
+
 - **Type Changes:**
-  - Settings: Added `autoFetchInterval: number` option
-  - Messages: New `openFile`, `openSourceControl`, toast notification message types
-  - New type: `BundledManifest` (ExtensionManifest with _dir field)
-  - HEAD ref type detection corrected
+  - New: `Stash` = { index, hash, message }
+  - New: `MergeState` = { type: "merge" | "rebase" | "cherry-pick", progress?, message? }
+  - New: `Worktree` = { path, branch, head, isMain, isDetached, locked, lockReason?, prunable }
+  - Updated: `FileChange.status` now includes "U" for unmerged/conflicted entries (was "A" | "M" | "D" | "R" | "C")
+  - Updated: `UncommittedData` now includes `conflicted: FileChange[]` and optional `mergeState: MergeState`
+  - Updated: `RepoInfo` now includes `stashes: Stash[]` and `currentBranch: string`
+  - Updated: `TabType` now includes "conflict-editor"
+
+- **Git State Detection:**
+  - Merge state determined by .git sentinel files: MERGE_HEAD (merge), rebase-merge/ (interactive rebase), CHERRY_PICK_HEAD (cherry-pick)
+  - Progress tracked: "3/5" format from rebase-merge/msgnum and rebase-merge/end
+  - Conflict detection: UU/AA/DD/AU/UA/DU/UD git status codes parsed as unmerged entries
+  - Only detects merge state when conflicts exist (perf optimization)
+
+- **Conflict Resolution Flow:**
+  - User clicks conflicted file → opens conflict-editor tab
+  - Component parses conflict markers (<<<<<<, =======, >>>>>>>) from file content
+  - Displays visual highlighting + Accept buttons above each conflict region
+  - Resolution applies edit via Monaco, saves file automatically, updates conflict counter
+  - Conflict count reflects real-time resolution progress
+
 - **Security:** Path validation ensures extensions can only operate on registered project paths
 - **Breaking Changes:** None (backward compatible)
-- **Test Coverage:** 129 tests passing (111 extension tests + 18 bundled tests)
+- **Test Coverage:** All changes maintain test suite passing
 
 ---
 

package/docs/project-roadmap.md

@@ -71,6 +71,7 @@ PPM is the **lightest path from phone to code** — a self-hosted, BYOK, multi-d
 - File download feature (v0.9.2) — Single-file + folder-as-zip downloads with short-lived tokens, context menu + toolbar UI
 - Agent Team UI (v0.9.9) — Real-time team monitoring dashboard: REST API + fs.watch inbox events, team activity button with unread pulse, popover/drawer with members + messages, team management in Settings
 - Git-Graph UI Improvements (v0.9.85+) — ✅ Faithful SVG graph rendering (vscode-git-graph port), interactive git workflow (stage/unstage/commit/stash), branch filters, auto-fetch, mobile support, tab system safety guards, UX refinements (branch context menu, dblclick checkout, toast notifications, SVG icons)
+- Git Workflow Enhancements (v0.9.86+) — ✅ Stash management (popover with Apply/Pop/Drop), rebase from context menu, conflict detection (merge/rebase/cherry-pick states), inline conflict resolution editor (Monaco with visual highlighting + Accept buttons), worktree full CRUD (create/remove/prune with project integration)
 
 **Multi-provider — v0.9 scope (reduced):**
 - Tier 1 (full agentic): Claude Agent SDK — file edit, terminal, git, full autonomy
@@ -100,12 +101,12 @@ PPM is the **lightest path from phone to code** — a self-hosted, BYOK, multi-d
 
 ### v0.10.0 — "Enhanced Workflow" (Q3 2026)
 
-**Theme:** Agent collaboration + git workflow. High-impact, independent features that ship fast.
+**Theme:** Agent collaboration + advanced git workflow. High-impact, independent features that ship fast.
 
 | Feature | Priority | Description |
 |---------|----------|-------------|
 | **Agent Team** | High | Multi-agent collaboration within PPM. Spawn agent teams for parallel task execution — lead agent delegates to specialist agents (coder, tester, reviewer). Task coordination, file ownership, progress tracking. |
-| **Worktree management** | Medium | UI to create/switch/delete git worktrees. Use different providers on different branches. Integrated with project switcher. |
+| **Advanced Git Operations** | Medium | Interactive rebase UI, cherry-pick workflow, merge strategy selection. (Worktree management completed in v0.9.86) |
 
 ---
 

package/docs/system-architecture.md

@@ -151,13 +151,14 @@ WS     /ws/project/:name/terminal/:id             → Terminal I/O
 ```
 /project/{name}                          → Project root (project switcher)
 /project/{name}/editor/{filePath}        → Open editor tab (e.g., src/index.ts)
+/project/{name}/conflict-editor/{filePath} → Open conflict resolution editor (during merge/rebase)
 /project/{name}/chat/{provider}/{sessionId} → Open chat tab
 /project/{name}/terminal/{index}         → Open terminal tab
 /project/{name}/database/{connId}/{table} → Open database browser
 /project/{name}/git-graph                → Git history graph (singleton)
 /project/{name}/settings                 → Settings panel (singleton)
 ```
-Tab IDs are deterministic: `{type}:{identifier}` (e.g., `editor:src/index.ts`, `chat:claude/abc123`). Deep links auto-create missing tabs.
+Tab IDs are deterministic: `{type}:{identifier}` (e.g., `editor:src/index.ts`, `conflict-editor:src/file.ts`, `chat:claude/abc123`). Deep links auto-create missing tabs.
 
 ---
 
@@ -1676,6 +1677,48 @@ Main Process                Worker
 
 5. Extension auto-activates based on `activationEvents`, state persists
 
+### Error Handling & Debugging
+
+**Activation Error Tracking:**
+- `ExtensionService.activationErrors` Map tracks `extId → error message` for all failed activations
+- Errors set during `activate()` if worker response indicates failure (`!result.ok`)
+- Errors cleared on successful activation or worker termination
+- Errors included in `contributions:update` message sent via WS to browser on client connect
+
+**User Feedback (UI):**
+- **Command Errors:** When extension command fails, toast shows "Extension command failed: {error}" with error details
+- **Timeout Handling:** If webview panel doesn't load within 10s, fallback UI displays activation error (if available) + "Retry" button
+- **Retry Button:** User can click to re-trigger the command without page reload (re-dispatches `ext:command:execute`)
+
+**Breadcrumb Logging (Console):**
+- **`[ExtService]`** — Main process lifecycle: activation start/success, worker lifecycle, contributions broadcast
+- **`[ExtHost]`** — Worker-side execution: command routing, handler invocation, error context
+- **`[ExtWS]`** — WebSocket bridge: client connect, message handling, error responses
+- **Extension-specific tags** — e.g., `[ext-git-graph]` for extension-specific log context
+
+**Example Log Flow (normal):**
+```
+[ExtService] startup: activating ext-git-graph...
+[ExtWS] Client connected (1 total)
+[ExtHost] activating ext-git-graph from dist/extension.js
+[ExtHost] activated ext-git-graph (1 total)
+[ExtService] activated ext-git-graph successfully
+[ExtWS] command:execute "git-graph.view"
+[ExtHost] command:execute "git-graph.view" (1 extensions active)
+[ExtHost] routing "git-graph.view" → ext-git-graph
+```
+
+**Example Log Flow (error):**
+```
+[ExtService] startup: activating ext-git-graph...
+[ExtHost] activating ext-git-graph from dist/extension.ts
+[ExtHost] ERROR: Cannot find module 'missing-dep'
+[ExtService] Failed to activate ext-git-graph on startup: Cannot find module 'missing-dep'
+→ activationErrors["ext-git-graph"] = "Cannot find module 'missing-dep'"
+→ browser receives { type: "contributions:update", activationErrors: {"ext-git-graph": "..."} }
+→ user sees toast: "Extension "ext-git-graph" failed to activate: Cannot find module..."
+```
+
 ### Crash Safety
 
 **Worker Isolation:**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hienlh/ppm",
-  "version": "0.9.86",
+  "version": "0.9.87",
   "description": "Personal Project Manager — mobile-first web IDE with AI assistance",
   "author": "hienlh",
   "license": "MIT",

package/packages/ext-git-graph/src/extension.ts

@@ -63,12 +63,20 @@ export function activate(context: ExtensionContext, vscode: VscodeApi): void {
   context.subscriptions.push(
     vscode.commands.registerCommand("git-graph.view", async (...args: unknown[]) => {
       const projectPath = args[0] as string | undefined;
+      console.log(`[ext-git-graph] git-graph.view command received, projectPath=${projectPath ?? "(none)"}`);
       const resolvedPath = projectPath || await resolveProjectPath();
       if (!resolvedPath) {
+        console.warn("[ext-git-graph] no project path resolved");
         await vscode.window.showErrorMessage("Git Graph: No project selected. Open a project first, then try again.");
         return;
       }
-      await openGitGraph(vscode, context, resolvedPath);
+      try {
+        await openGitGraph(vscode, context, resolvedPath);
+        console.log("[ext-git-graph] webview panel created");
+      } catch (e) {
+        console.error("[ext-git-graph] openGitGraph failed:", e);
+        throw e;
+      }
     }),
   );
 
@@ -156,6 +164,7 @@ function openGitGraph(
           await handleRequestCommits(vscode, panel, pp, context);
           handleUncommittedStatus(vscode, panel, pp); // fire-and-forget
           handleWorktrees(vscode, panel, pp); // fire-and-forget
+          handleStashes(vscode, panel, pp); // fire-and-forget
           break;
         case "requestRepoInfo":
           await handleRepoInfo(vscode, panel, pp);
@@ -263,6 +272,9 @@ function openGitGraph(
         case "requestWorktrees":
           await handleWorktrees(vscode, panel, pp);
           break;
+        case "requestStashes":
+          await handleStashes(vscode, panel, pp);
+          break;
         case "addWorktree": {
           const addArgs = ["worktree", "add"];
           if (msg.newBranch) {
@@ -333,6 +345,16 @@ function openGitGraph(
           }
           break;
         }
+        case "openConflictFile": {
+          assertSafeFilePaths([msg.filePath], pp);
+          const projectName = await resolveProjectName(pp);
+          // Opens as conflict-editor tab (Phase 4 will wire this properly)
+          await vscode.window.openTab("conflict-editor", `Conflict: ${msg.filePath.split(/[\\/]/).pop()}`, projectName, {
+            projectName,
+            filePath: msg.filePath,
+          });
+          break;
+        }
         case "openSourceControl": {
           await vscode.window.showInformationMessage("Open the Source Control panel from the sidebar.");
           break;
@@ -372,6 +394,7 @@ async function reloadPanelData(
   await handleRequestCommits(vscode, panel, projectPath, context);
   handleUncommittedStatus(vscode, panel, projectPath);
   handleWorktrees(vscode, panel, projectPath);
+  handleStashes(vscode, panel, projectPath);
 }
 
 async function handleRepoInfo(
@@ -453,6 +476,8 @@ async function handleCommitDetails(
   await panel.webview.postMessage({ command: "commitDetails", data: detail });
 }
 
+const UNMERGED_CODES = new Set(["DD", "AU", "UD", "UA", "DU", "AA", "UU"]);
+
 async function handleUncommittedStatus(
   vscode: VscodeApi,
   panel: ReturnType<VscodeApi["window"]["createWebviewPanel"]>,
@@ -466,11 +491,20 @@ async function handleUncommittedStatus(
     }
     const staged: import("./types.ts").FileChange[] = [];
     const unstaged: import("./types.ts").FileChange[] = [];
+    const conflicted: import("./types.ts").FileChange[] = [];
     for (const line of result.stdout.split("\n").filter(Boolean)) {
-      if (staged.length + unstaged.length >= 500) break; // cap total
-      const x = line[0]; // staged status
-      const y = line[1]; // unstaged status
+      if (staged.length + unstaged.length + conflicted.length >= 500) break;
+      const xy = line.substring(0, 2);
       const filePath = line.substring(3);
+
+      // Check for unmerged/conflict entries first
+      if (UNMERGED_CODES.has(xy)) {
+        conflicted.push({ path: filePath, status: "U", additions: 0, deletions: 0 });
+        continue;
+      }
+
+      const x = xy[0]; // staged status
+      const y = xy[1]; // unstaged status
       if (x !== " " && x !== "?") {
         staged.push({ path: filePath, status: mapStatusCode(x), additions: 0, deletions: 0 });
       }
@@ -481,15 +515,72 @@ async function handleUncommittedStatus(
         unstaged.push({ path: filePath, status: "A", additions: 0, deletions: 0 });
       }
     }
+
+    // Only detect merge state when conflicts exist (perf optimization)
+    let mergeState: import("./types.ts").MergeState | undefined;
+    if (conflicted.length > 0) {
+      mergeState = await detectMergeState(vscode, projectPath);
+    }
+
     await panel.webview.postMessage({
       command: "loadUncommitted",
-      data: { staged, unstaged },
+      data: { staged, unstaged, conflicted, mergeState },
     });
   } catch {
     await panel.webview.postMessage({ command: "loadUncommitted", data: null });
   }
 }
 
+async function detectMergeState(
+  vscode: VscodeApi,
+  projectPath: string,
+): Promise<import("./types.ts").MergeState | undefined> {
+  // Resolve the actual GIT_DIR (handles worktrees where .git is a pointer file)
+  const gitDirResult = await spawnGit(vscode, ["rev-parse", "--git-dir"], projectPath, 2000);
+  if (gitDirResult.exitCode !== 0) return undefined;
+  let gitDir = gitDirResult.stdout.trim();
+  // Make absolute if relative
+  if (!gitDir.startsWith("/")) gitDir = `${projectPath}/${gitDir}`;
+
+  // Check rebase-merge (interactive rebase)
+  const rebaseMergeDir = `${gitDir}/rebase-merge`;
+  const checkRebase = await vscode.process.spawn("test", ["-d", rebaseMergeDir], projectPath, { timeout: 2000 });
+  if (checkRebase.exitCode === 0) {
+    const [numResult, endResult, msgResult] = await Promise.all([
+      vscode.process.spawn("cat", [`${rebaseMergeDir}/msgnum`], projectPath, { timeout: 2000 }),
+      vscode.process.spawn("cat", [`${rebaseMergeDir}/end`], projectPath, { timeout: 2000 }),
+      vscode.process.spawn("cat", [`${rebaseMergeDir}/message`], projectPath, { timeout: 2000 }),
+    ]);
+    const current = numResult.stdout.trim();
+    const total = endResult.stdout.trim();
+    return {
+      type: "rebase",
+      progress: current && total ? `${current}/${total}` : undefined,
+      message: msgResult.stdout.trim().split("\n")[0] || undefined,
+    };
+  }
+
+  // Check rebase-apply (non-interactive rebase / am)
+  const checkRebaseApply = await vscode.process.spawn("test", ["-d", `${gitDir}/rebase-apply`], projectPath, { timeout: 2000 });
+  if (checkRebaseApply.exitCode === 0) {
+    return { type: "rebase" };
+  }
+
+  // Check merge
+  const checkMerge = await vscode.process.spawn("test", ["-f", `${gitDir}/MERGE_HEAD`], projectPath, { timeout: 2000 });
+  if (checkMerge.exitCode === 0) {
+    return { type: "merge" };
+  }
+
+  // Check cherry-pick
+  const checkCherry = await vscode.process.spawn("test", ["-f", `${gitDir}/CHERRY_PICK_HEAD`], projectPath, { timeout: 2000 });
+  if (checkCherry.exitCode === 0) {
+    return { type: "cherry-pick" };
+  }
+
+  return undefined;
+}
+
 async function handleWorktrees(
   vscode: VscodeApi,
   panel: ReturnType<VscodeApi["window"]["createWebviewPanel"]>,
@@ -527,6 +618,29 @@ async function handleWorktrees(
   await panel.webview.postMessage({ command: "loadWorktrees", data: worktrees });
 }
 
+async function handleStashes(
+  vscode: VscodeApi,
+  panel: ReturnType<VscodeApi["window"]["createWebviewPanel"]>,
+  projectPath: string,
+): Promise<void> {
+  const result = await spawnGit(vscode, ["stash", "list", "--format=%gd|%H|%s"], projectPath, 10_000);
+  const stashes: import("./types.ts").Stash[] = [];
+  if (result.exitCode === 0 && result.stdout.trim()) {
+    for (const line of result.stdout.split("\n").filter(Boolean)) {
+      const parts = line.split("|");
+      if (parts.length >= 3) {
+        const refMatch = parts[0].match(/\{(\d+)\}/);
+        stashes.push({
+          index: refMatch ? parseInt(refMatch[1]) : stashes.length,
+          hash: parts[1],
+          message: parts.slice(2).join("|"),
+        });
+      }
+    }
+  }
+  await panel.webview.postMessage({ command: "loadStashes", data: stashes });
+}
+
 function mapStatusCode(code: string): "A" | "M" | "D" | "R" {
   if (code === "A" || code === "?") return "A";
   if (code === "D") return "D";
@@ -754,6 +868,13 @@ function buildGitActionArgs(action: string, args: Record<string, unknown>): stri
     case "stashSave": return ["stash", "push", ...(args.message ? ["-m", String(args.message)] : [])];
     case "stashPop": return ["stash", "pop", ...(args.stashRef ? [assertValidRef(args.stashRef, "stashRef")] : [])];
     case "stashDrop": return ["stash", "drop", ...(args.stashRef ? [assertValidRef(args.stashRef, "stashRef")] : [])];
+    case "stashApply": return ["stash", "apply", ...(args.stashRef ? [assertValidRef(args.stashRef, "stashRef")] : [])];
+    case "rebaseContinue": return ["rebase", "--continue"];
+    case "rebaseAbort": return ["rebase", "--abort"];
+    case "rebaseSkip": return ["rebase", "--skip"];
+    case "mergeAbort": return ["merge", "--abort"];
+    case "cherryPickAbort": return ["cherry-pick", "--abort"];
+    case "cherryPickContinue": return ["cherry-pick", "--continue"];
     case "fetch": return ["fetch", ...(args.remote ? [assertValidRemote(args.remote)] : []), ...(args.prune ? ["--prune"] : [])];
     case "pull": return ["pull", ...(args.remote ? [assertValidRemote(args.remote)] : []), ...(args.branch ? [assertValidRef(args.branch, "branch")] : [])];
     case "renameBranch": {

package/packages/ext-git-graph/src/types.ts

@@ -71,11 +71,17 @@ export interface CommitDetail {
 export interface FileChange {
   path: string;
   oldPath?: string;
-  status: "A" | "M" | "D" | "R" | "C";
+  status: "A" | "M" | "D" | "R" | "C" | "U";
   additions: number;
   deletions: number;
 }
 
+export interface MergeState {
+  type: "merge" | "rebase" | "cherry-pick";
+  progress?: string; // e.g. "3/5" for rebase
+  message?: string;  // current commit message being rebased
+}
+
 export interface RepoInfo {
   path: string;
   branches: Branch[];
@@ -94,6 +100,8 @@ export interface ActionResult {
 export interface UncommittedData {
   staged: FileChange[];
   unstaged: FileChange[];
+  conflicted: FileChange[];
+  mergeState?: MergeState;
 }
 
 // --- Settings ---
@@ -152,6 +160,7 @@ export type ExtToWebview =
   | { command: "refresh"; data: GitVertex[]; repoInfo: RepoInfo }
   | { command: "actionResult"; action: string; args?: Record<string, unknown>; result: ActionResult }
   | { command: "loadWorktrees"; data: Worktree[] }
+  | { command: "loadStashes"; data: Stash[] }
   | { command: "error"; message: string };
 
 // --- Webview → Extension messages ---
@@ -178,4 +187,6 @@ export type WebviewToExt =
   | { command: "pruneWorktrees" }
   | { command: "openWorktree"; path: string }
   | { command: "openFile"; filePath: string }
-  | { command: "openSourceControl" };
+  | { command: "openConflictFile"; filePath: string }
+  | { command: "openSourceControl" }
+  | { command: "requestStashes" };