CB-587: seed the snapshot's temp index from the worktree's real index

--skip-worktree is an index flag. GitWorktrees.snapshot staged into a fresh
empty temp index, which carried none of the real index's skip-worktree bits,
so add -A staged local on-disk content for files git status correctly hides
(e.g. .mcp.json). Copy the real index (resolved via git rev-parse --git-path
index, correct for linked worktrees) into the temp index before staging, so
add -A skips exactly what git status skips.

bridged/src/main/java/dev/ltms/bridged/session/GitWorktrees.java

@@ -220,20 +220,26 @@ public final class GitWorktrees implements Worktrees {
     }
 
     /**
-     * CB-578 stage C. Stages into a <em>temporary</em> index (never the worktree's real one, which
-     * the worker may still be writing to), writes that index to a tree, commits the tree on top of
-     * the worktree's current HEAD, and points {@code refs/wip/<branch>} at the result:
+     * CB-578 stage C, fixed by CB-587. Stages into a <em>temporary</em> index (never the worktree's
+     * real one, which the worker may still be writing to) — but that temp index is first <em>seeded</em>
+     * from the worktree's real one, rather than starting empty:
      *
      * <pre>
+     * cp $(git -C worktree rev-parse --git-path index) &lt;temp&gt;
      * GIT_INDEX_FILE=&lt;temp&gt; git -C worktree add -A
      * tree=$(GIT_INDEX_FILE=&lt;temp&gt; git -C worktree write-tree)
      * commit=$(git -C worktree commit-tree $tree -p HEAD -m message)
      * git -C worktree update-ref refs/wip/branch $commit
      * </pre>
      *
-     * {@code add -A} (never {@code -f}) respects {@code .gitignore} exactly as it would in the real
-     * index — a gitignored file staying ignored is what keeps secrets and local config out of the
-     * snapshot's tree. The temporary index file is removed afterwards regardless of outcome.
+     * A fresh empty index carries none of the real index's {@code --skip-worktree} /
+     * {@code --assume-unchanged} bits, so {@code add -A} into it stages a skip-worktree file's local
+     * on-disk content even though {@code git status --porcelain} correctly hides that file (CB-587).
+     * Seeding from the real index preserves those bits, so {@code add -A} then skips exactly what
+     * {@code git status} skips. {@code add -A} (never {@code -f}) also still respects
+     * {@code .gitignore} exactly as it would in the real index — a gitignored file staying ignored is
+     * what keeps secrets and local config out of the snapshot's tree. The temporary index file is
+     * removed afterwards regardless of outcome; the worker's real index is never opened for writing.
      */
     @Override
     public Optional<String> snapshot(String worktreePath, String branch, String message) {
@@ -244,13 +250,18 @@ public final class GitWorktrees implements Worktrees {
         Path tempIndex;
         try {
             tempIndex = Files.createTempFile("bridged-wip-index-", ".tmp");
-            Files.delete(tempIndex); // git creates it fresh under GIT_INDEX_FILE; a stale empty
-                                      // file at that path is otherwise treated as a corrupt index.
         } catch (IOException e) {
             throw new WorktreeException("cannot create a temporary index for snapshot: " + e.getMessage(), e);
         }
         Map<String, String> indexEnv = Map.of("GIT_INDEX_FILE", tempIndex.toAbsolutePath().toString());
         try {
+            Path realIndex = resolveRealIndex(worktreePath);
+            try {
+                Files.copy(realIndex, tempIndex, StandardCopyOption.REPLACE_EXISTING);
+            } catch (IOException e) {
+                throw new WorktreeException("cannot copy the worktree's real index (" + realIndex
+                        + ") into the temporary snapshot index: " + e.getMessage(), e);
+            }
             exec(indexEnv, "git", "-C", worktreePath, "add", "-A");
             String tree = exec(indexEnv, "git", "-C", worktreePath, "write-tree").trim();
             String commit = exec("git", "-C", worktreePath, "commit-tree", tree, "-p", "HEAD", "-m", message).trim();
@@ -266,6 +277,28 @@ public final class GitWorktrees implements Worktrees {
         }
     }
 
+    /**
+     * Resolve the path of {@code worktreePath}'s real index. Never assume {@code <worktree>/.git/index}:
+     * in a linked worktree {@code .git} is a <em>file</em> pointing at the main repo's
+     * {@code worktrees/<name>/} directory, and that is where the real per-worktree index lives.
+     * {@code git rev-parse --git-path index} resolves this correctly for both a linked worktree and
+     * the main checkout. Throws {@link WorktreeException} — same as every other failure in this
+     * class — if the command fails or the resolved path does not exist, rather than silently
+     * snapshotting from an empty index.
+     */
+    private Path resolveRealIndex(String worktreePath) {
+        String out = exec("git", "-C", worktreePath, "rev-parse", "--git-path", "index").trim();
+        Path index = Path.of(out);
+        if (!index.isAbsolute()) {
+            index = Path.of(worktreePath).resolve(index).normalize();
+        }
+        if (!Files.exists(index)) {
+            throw new WorktreeException("worktree's real index not found at resolved path " + index
+                    + " (git rev-parse --git-path index reported '" + out + "')");
+        }
+        return index;
+    }
+
     /** Resolve the directory that will hold per-session worktree checkouts. */
     private Path resolveRoot(String repoRoot) {
         if (configuredRoot != null && !configuredRoot.isBlank()) {