@neuralis/brain-core 0.1.0 → 0.2.1

package/app/filesystem/ui/GitCommitGraph.tsx

@@ -431,6 +431,7 @@ export function GitCommitGraph({
    *  E) — two-part `slug:// Name` header render; absent → slug-only fallback. */
   repoName?: string;
 }) {
+  const client = useFilesystemStore((s) => s.client);
   const [page, setPage] = useState<GraphPageState>(emptyGraphPageState);
   const [loading, setLoading] = useState(false);
   const [error, setError] = useState<string | null>(null);
@@ -508,7 +509,7 @@ export function GitCommitGraph({
           ...(repo ? { repo } : {}),
           maxCount,
           skip,
-        });
+        }, client);
         if (mySeq !== seqRef.current) return;
         const fetched = {
           commits: Array.isArray(res?.commits) ? res.commits : [],
@@ -530,7 +531,7 @@ export function GitCommitGraph({
             ...(repo ? { repo } : {}),
             maxCount,
             skip,
-          })
+          }, client)
             .then((stats) => {
               if (mySeq !== seqRef.current) return;
               setCommitStats((cur) => (mode === 'append' ? { ...cur, ...stats.stats } : { ...stats.stats }));
@@ -643,7 +644,7 @@ export function GitCommitGraph({
           source,
           ...(repo ? { repo } : {}),
           sha,
-        });
+        }, client);
         if (epoch !== filesEpochRef.current) return;
         setCommitFiles((prev) =>
           new Map(prev).set(
@@ -702,7 +703,7 @@ export function GitCommitGraph({
           ...(projectId ? { projectId } : {}),
           source,
           ...(repo ? { repo } : {}),
-        });
+        }, client);
         if (epoch !== outgoingEpochRef.current) return;
         // 3b: a deep-fail is a typed `{ok:false,'unavailable'}` refusal now — treat
         // it like no-upstream (nothing to show), never crash on a missing files[].
@@ -812,7 +813,7 @@ export function GitCommitGraph({
           ...(projectId ? { projectId } : {}),
           source,
           ...(repo ? { repo } : {}),
-        });
+        }, client);
         if (epoch !== outgoingEpochRef.current) return;
         // 3b: a deep-fail is a typed `{ok:false,'unavailable'}` refusal now — treat
         // it like no-upstream (nothing to show), never crash on a missing files[].

package/app/filesystem/ui/GitControlPanel.tsx

@@ -453,6 +453,7 @@ type ConfirmState = { title: string; message: string; confirmLabel: string; onCo
 type RescueState = { message: string; rescue: GitRescue };
 
 export function GitControlPanel({ agentId }: { agentId: string }) {
+  const client = useFilesystemStore((s) => s.client);
   const sources = useFilesystemStore((s) => s.sources);
   const projectId = useFilesystemStore((s) => s.activeProjectId);
   const activeSource = useFilesystemStore((s) => s.activeSource);
@@ -554,7 +555,7 @@ export function GitControlPanel({ agentId }: { agentId: string }) {
       if (cached && (cached instanceof Promise || !opts?.force)) return cached;
       const task = (async () => {
         try {
-          const res = await getGitRepos({ agentId, ...(projectId ? { projectId } : {}), source: slug });
+          const res = await getGitRepos({ agentId, ...(projectId ? { projectId } : {}), source: slug }, client);
           const repos = Array.isArray(res?.repos) ? res.repos : [];
           repoListsRef.current.set(slug, repos);
           setRepoLists((prev) => new Map(prev).set(slug, repos));
@@ -799,7 +800,7 @@ export function GitControlPanel({ agentId }: { agentId: string }) {
   const handleStage = useCallback(
     (paths: string[]) => {
       if (paths.length === 0) return;
-      void doWrite(() => stagePaths({ agentId, ...p, source: selectedSlug, paths }));
+      void doWrite(() => stagePaths({ agentId, ...p, source: selectedSlug, paths }, client));
     },
     [doWrite, agentId, p, selectedSlug],
   );
@@ -807,7 +808,7 @@ export function GitControlPanel({ agentId }: { agentId: string }) {
   const handleUnstage = useCallback(
     (paths: string[]) => {
       if (paths.length === 0) return;
-      void doWrite(() => unstagePaths({ agentId, ...p, source: selectedSlug, paths }));
+      void doWrite(() => unstagePaths({ agentId, ...p, source: selectedSlug, paths }, client));
     },
     [doWrite, agentId, p, selectedSlug],
   );
@@ -815,7 +816,7 @@ export function GitControlPanel({ agentId }: { agentId: string }) {
   const runDiscard = useCallback(
     (paths: string[]) => {
       void (async () => {
-        const res = await doWrite(() => discardPaths({ agentId, ...p, source: selectedSlug, paths }));
+        const res = await doWrite(() => discardPaths({ agentId, ...p, source: selectedSlug, paths }, client));
         if (res && res.rescue) {
           setRescue({
             message: `Discarded ${paths.length} file${paths.length === 1 ? '' : 's'} — recoverable`,
@@ -875,7 +876,7 @@ export function GitControlPanel({ agentId }: { agentId: string }) {
     const message = commitMessage.trim();
     if (!message) return;
     void (async () => {
-      const res = await doWrite(() => commitGit({ agentId, ...p, source: selectedSlug, message, amend }));
+      const res = await doWrite(() => commitGit({ agentId, ...p, source: selectedSlug, message, amend }, client));
       if (res && res.ok) {
         setCommitMessage('');
         setAmend(false);
@@ -901,7 +902,7 @@ export function GitControlPanel({ agentId }: { agentId: string }) {
     (ref: string) => {
       setBranchPickerOpen(false);
       void (async () => {
-        const res = await doWrite(() => checkoutGitBranch({ agentId, ...p, source: selectedSlug, ref }));
+        const res = await doWrite(() => checkoutGitBranch({ agentId, ...p, source: selectedSlug, ref }, client));
         if (res)
           void loadGitBranches({ agentId, projectId: projectId ?? null, source: selectedSlug, repo: activeRepoRel });
       })();
@@ -920,10 +921,10 @@ export function GitControlPanel({ agentId }: { agentId: string }) {
     void (async () => {
       // Create then switch to it (VS-Code "Create new branch" also checks out).
       const created = await doWrite(() =>
-        createGitBranch({ agentId, ...p, source: selectedSlug, name, ...(from ? { startPoint: from } : {}) }),
+        createGitBranch({ agentId, ...p, source: selectedSlug, name, ...(from ? { startPoint: from } : {}) }, client),
       );
       if (created) {
-        await doWrite(() => checkoutGitBranch({ agentId, ...p, source: selectedSlug, ref: name }));
+        await doWrite(() => checkoutGitBranch({ agentId, ...p, source: selectedSlug, ref: name }, client));
         void loadGitBranches({ agentId, projectId: projectId ?? null, source: selectedSlug, repo: activeRepoRel });
       }
     })();
@@ -932,7 +933,7 @@ export function GitControlPanel({ agentId }: { agentId: string }) {
   const runDeleteBranch = useCallback(
     (name: string) => {
       void (async () => {
-        const res = await doWrite(() => deleteGitBranch({ agentId, ...p, source: selectedSlug, name }));
+        const res = await doWrite(() => deleteGitBranch({ agentId, ...p, source: selectedSlug, name }, client));
         if (res && res.rescue) {
           setRescue({ message: `Deleted branch "${name}" — recoverable`, rescue: res.rescue });
         }
@@ -966,7 +967,7 @@ export function GitControlPanel({ agentId }: { agentId: string }) {
     if (!rescue) return;
     const carrier = rescue.rescue;
     setRescue(null);
-    void doWrite(() => restoreGit({ agentId, ...p, source: selectedSlug, rescue: carrier }));
+    void doWrite(() => restoreGit({ agentId, ...p, source: selectedSlug, rescue: carrier }, client));
   }, [rescue, doWrite, agentId, p, selectedSlug]);
 
   // --- Remote operations (G4 keyring-kestrel Slice 2) ------------------------
@@ -976,17 +977,17 @@ export function GitControlPanel({ agentId }: { agentId: string }) {
 
   const handleFetch = useCallback(() => {
     setRemotePickerOpen(false);
-    void doWrite(() => fetchGit({ agentId, ...p, source: selectedSlug }));
+    void doWrite(() => fetchGit({ agentId, ...p, source: selectedSlug }, client));
   }, [doWrite, agentId, p, selectedSlug]);
 
   const handlePull = useCallback(() => {
     setRemotePickerOpen(false);
-    void doWrite(() => pullGit({ agentId, ...p, source: selectedSlug }));
+    void doWrite(() => pullGit({ agentId, ...p, source: selectedSlug }, client));
   }, [doWrite, agentId, p, selectedSlug]);
 
   const handlePush = useCallback(() => {
     setRemotePickerOpen(false);
-    void doWrite(() => pushGit({ agentId, ...p, source: selectedSlug }));
+    void doWrite(() => pushGit({ agentId, ...p, source: selectedSlug }, client));
   }, [doWrite, agentId, p, selectedSlug]);
 
   const unstagedChanges = gitStatus?.unstaged ?? [];

package/app/filesystem/ui/GitDiffView.tsx

@@ -26,11 +26,12 @@ export function GitDiffView({
   agentId: string | null;
   projectId: string | null;
 }): React.ReactElement {
+  const client = useFilesystemStore((s) => s.client);
   const [canWrite, setCanWrite] = useState(false);
   const revision = useFilesystemStore(state => state.sourceChangeRevision[target.source] ?? 0);
   useEffect(() => {
     let alive = true; setCanWrite(false);
-    if (agentId) void getGitRepos({ agentId, ...(projectId ? { projectId } : {}), source: target.source }).then(result => {
+    if (agentId) void getGitRepos({ agentId, ...(projectId ? { projectId } : {}), source: target.source }, client).then(result => {
       if (alive) setCanWrite(result.repos.find(repo => repo.rel === (target.repo ?? ''))?.canWrite === true);
     }).catch(() => { if (alive) setCanWrite(false); });
     return () => { alive = false; };

package/app/filesystem/ui/GitFileDiff.tsx

@@ -36,7 +36,7 @@ import {
 import { computeGitDiffTokens, renderShikiToken } from './gitDiffShikiTokenizer';
 import { resolveShikiLang, isShikiReady, ensureLanguage, getHighlighter } from './codeEditor/shikiHighlighter';
 import { detectCodeLanguage } from '../lib/detectLanguage';
-import { useContainerWidth } from '../hooks/useContainerWidth';
+import { useContainerWidth } from '@neuralis/package-system/client';
 import type { VisibleDiffQueue } from '../hooks/useVisibleDiffCards';
 import { DiffModeToggle } from './DiffModeToggle';
 
@@ -156,6 +156,7 @@ export function GitFileDiff({
   /** The lane's synchronous cache read: a re-mounted card paints its last answer on its first frame. */
   peekContent?: VisibleDiffQueue['peek'];
 }): React.ReactElement {
+  const client = useFilesystemStore((s) => s.client);
   const [initial] = useState(() => peekContent?.<DiffAnswer>(`${diffFamily(source, repo, path, mode)}\u0000${revision}`, diffFamily(source, repo, path, mode)));
   const [raw, setRaw] = useState<string | null>(() => initial === undefined ? null : initial && initial.ok !== false ? initial.diff : '');
   const [loading, setLoading] = useState(false);
@@ -262,7 +263,7 @@ export function GitFileDiff({
           path,
           // ONE mode per request — the server 400s any combination.
           ...diffRequestParams(normalizedMode),
-        });
+        }, client);
         // Keyed on everything the answer depends on; after a hunk apply the refetch
         // replaces the cached answer instead of reading it.
         const family = diffFamily(source, repo, path, normalizedMode);
@@ -364,7 +365,7 @@ export function GitFileDiff({
           ...(repo ? { repo } : {}),
           path,
           rev: expanderSrc.rev,
-        });
+        }, client);
         const res = runContent ? await runContent(fetchSource, () => mySeq === seqRef.current) : await fetchSource();
         if (!res || mySeq !== seqRef.current) return null;
         return settle(res.ok ? { ok: true, content: res.content } : { ok: false });
@@ -376,7 +377,7 @@ export function GitFileDiff({
         agentId,
         ...(projectId ? { projectId } : {}),
         files: [`${source}://${repo ? `${repo}/` : ''}${path}`],
-      });
+      }, client);
       const res = runContent ? await runContent(fetchSource, () => mySeq === seqRef.current) : await fetchSource();
       if (!res || mySeq !== seqRef.current) return null;
       const file = extractReadFilesPayload(res)[0];
@@ -467,9 +468,9 @@ export function GitFileDiff({
       setHunkError(null);
       try {
         if (staged) {
-          await unstageHunk({ agentId, ...(projectId ? { projectId } : {}), source, ...(repo ? { repo } : {}), hunk: patch });
+          await unstageHunk({ agentId, ...(projectId ? { projectId } : {}), source, ...(repo ? { repo } : {}), hunk: patch }, client);
         } else {
-          await stageHunk({ agentId, ...(projectId ? { projectId } : {}), source, ...(repo ? { repo } : {}), hunk: patch });
+          await stageHunk({ agentId, ...(projectId ? { projectId } : {}), source, ...(repo ? { repo } : {}), hunk: patch }, client);
         }
         // The index changed → the cached `rev=index` source is stale (the WT
         // entry would survive, but a whole-map clear is cheap and race-free).

package/app/filesystem/ui/PendingChangesPanel.tsx

@@ -23,7 +23,7 @@ import {
   ChevronLeft, CheckCheck, X, XCircle, Wrench, Unlink, ShieldAlert,
 } from 'lucide-react';
 import { SkillLauncher } from '@neuralis/package-system/client';
-import { useFilesystemStore } from '../store/filesystemStore';
+import { useFilesystemStore, useFilesystemStoreApi } from '../store/filesystemStore';
 import {
   listPendingChanges, previewPendingChange, discardPendingChange, discardOrphanedPending,
   type PendingChangeRecord, type PendingPreview,
@@ -98,18 +98,24 @@ export function CurrentGitDiffs({ uri, rows: gitRows, agentId, projectId, canWri
   </div>)}</React.Fragment>)}</>;
 }
 
+/** The lane key one card's answer belongs to: the record and its source revision. */
+const previewKey = (rec: PendingChangeRecord, revision: number): string => `preview\u0000${rec.id}\u0000${rec.updatedAt}\u0000${revision}`;
+
 const previewBytes = (p: PendingPreview): number =>
   2 * ((p.baseline.state === 'text' ? p.baseline.text.length : 0) + (p.current.state === 'text' ? p.current.text.length : 0)) + 256;
 
 
 export const PendingDiffCard = memo(function PendingDiffCard({
-  rec, agentId, projectId, focused, orphaned, onOpen, onApprove, onRevert, onDiscard, onDismiss, onFocus, busy, queue, revision, canWrite, onPreview, peekPreview, extra,
+  rec, agentId, projectId, focused, orphaned, onOpen, onApprove, onRevert, onDiscard, onDismiss, onFocus, busy, queue, revision, canWrite, onPreview, peekPreview, takeRefetch, extra,
 }: {
   rec: PendingChangeRecord; agentId: string; projectId: string | null; focused: boolean; orphaned: boolean;
   onOpen: (uri: string) => void; onApprove: () => void; onRevert: () => void; onDiscard: () => void; onDismiss: () => void;
   onFocus: () => void; busy: boolean; queue: VisibleDiffQueue; revision: number; canWrite: boolean;
-  onPreview: (preview: PendingPreview) => void; peekPreview: (id: string) => PendingPreview | undefined; extra?: React.ReactNode;
+  onPreview: (preview: PendingPreview) => void; peekPreview: (id: string) => PendingPreview | undefined;
+  /** The dialog's post-409 refetch: `'wait'` while in flight, then its answer ONCE for the key it was taken for. */
+  takeRefetch: (id: string, key: string) => PendingPreview | 'wait' | undefined; extra?: React.ReactNode;
 }) {
+  const client = useFilesystemStore((s) => s.client);
   // Cards open inline by default — the diff is the review unit.
   const [expanded, setExpanded] = useState(true);
   // The last answer this record had (a remount or a new source revision) stays on screen
@@ -126,13 +132,16 @@ export const PendingDiffCard = memo(function PendingDiffCard({
   active.current = expanded && shown;
   // The record + source revision this card's answer belongs to; leaving the viewport
   // keeps it (the lane cache answers a re-entry).
-  const cacheKey = `preview\u0000${rec.id}\u0000${rec.updatedAt}\u0000${revision}`;
+  const cacheKey = previewKey(rec, revision);
   const loadedKey = useRef('');
   useEffect(() => {
     const generation = ++seq.current;
     if (!expanded || !shown || loadedKey.current === cacheKey) { setLoading(false); return; }
+    const adopted = takeRefetch(rec.id, cacheKey);
+    if (adopted === 'wait') { setLoading(true); return; }
+    if (adopted) { setPreview(adopted); setLoadError(null); setAnswerKey(cacheKey); loadedKey.current = cacheKey; setLoading(false); return; }
     setLoading(true);
-    void queue.run(() => previewPendingChange({ agentId, ...(projectId ? { projectId } : {}), id: rec.id }),
+    void queue.run(() => previewPendingChange({ agentId, ...(projectId ? { projectId } : {}), id: rec.id }, client),
       () => generation === seq.current && active.current, { key: cacheKey, bytes: previewBytes }).then(next => {
       if (!next || generation !== seq.current || !active.current) return;
       onPreview(next);
@@ -204,10 +213,19 @@ const NO_FILTERS: ChangeFilters = { kind: 'all', source: '', repo: '', branch: '
 /** One bulk pass (the sweep and the grouped dialog) covers at most this many records. */ const REVIEW_BATCH = 100;
 
 export function PendingChangesPanel({ agentId, projectId }: Props) {
+  const client = useFilesystemStore((s) => s.client);
   const host = useFilesystemHost();
   const canWrite = hasFeature({ grantedFeatures: [...(host.grantedFeatures ?? [])] }, 'drive.write');
+  const storeApi = useFilesystemStoreApi();
   const sources = useFilesystemStore(s => s.sources);
-  const revisions = useFilesystemStore(s => s.sourceChangeRevision);
+  const liveRevisions = useFilesystemStore(s => s.sourceChangeRevision);
+  // A review batch (the sweep, a dialog group) HOLDS the revisions its own writes bump: one re-list
+  // at its end (`afterMutation`) instead of a re-list and every visible card's re-preview per write.
+  const [held, setHeld] = useState<typeof liveRevisions | null>(null);
+  const revisions = held ?? liveRevisions;
+  const liveRef = useRef(liveRevisions); liveRef.current = liveRevisions;
+  const listedRevisions = useRef(liveRevisions);
+  const holdRevisions = useCallback(() => setHeld(prev => prev ?? liveRef.current), []);
   const pendingPanelFilter = useFilesystemStore((s) => s.pendingPanelFilter);
   const setPendingPanelFilter = useFilesystemStore((s) => s.setPendingPanelFilter);
   const openFile = useFilesystemStore((s) => s.openFile);
@@ -220,6 +238,16 @@ export function PendingChangesPanel({ agentId, projectId }: Props) {
   const queue = useVisibleDiffCards(scrollRoot);
   const previews = useRef(new Map<string, PendingPreview>());
   const peekPreview = useCallback((id: string) => previews.current.get(id), []);
+  // ONE fetch per dialog 409: the dialog's refetch waits for the re-list; the record's card
+  // holds (`null`) until it lands, then adopts it under the key the final nonce gives it.
+  const refetches = useRef(new Map<string, { key: string; preview: PendingPreview } | null>());
+  const relisted = useRef(Promise.withResolvers<PendingChangeRecord[] | undefined>());
+  const takeRefetch = useCallback((id: string, key: string): PendingPreview | 'wait' | undefined => {
+    const entry = refetches.current.get(id);
+    if (entry === null) return 'wait';
+    if (entry) refetches.current.delete(id);
+    return entry?.key === key ? entry.preview : undefined;
+  }, []);
   const [filters, setFilters] = useState<ChangeFilters>(NO_FILTERS);
   const setFilter = (key: keyof ChangeFilters) => (event: React.ChangeEvent<HTMLSelectElement>) =>
     setFilters(f => ({ ...f, [key]: event.target.value }));
@@ -229,7 +257,21 @@ export function PendingChangesPanel({ agentId, projectId }: Props) {
   const [loading, setLoading] = useState(false);
   const [error, setError] = useState<string | null>(null);
   const [busyId, setBusyId] = useState<string | null>(null);
-  const [nonce, setNonce] = useState(0);
+  // Per record: a refused review refetches only ITS card's preview.
+  const [nonces, setNonces] = useState<Readonly<Record<string, number>>>({});
+  const latest = useRef({ nonces, revisions }); latest.current = { nonces, revisions };
+  const refetch = useCallback(async (rec: PendingChangeRecord): Promise<PendingPreview> => {
+    refetches.current.set(rec.id, null);
+    try {
+      const listed = (await relisted.current.promise)?.find(r => r.id === rec.id) ?? rec;
+      const fresh = await previewPendingChange({ agentId, ...(projectId ? { projectId } : {}), id: rec.id }, client);
+      const revision = (latest.current.nonces[rec.id] ?? 0) + 1 + (latest.current.revisions[listed.sourceSlug] ?? 0);
+      refetches.current.set(rec.id, { key: previewKey(listed, revision), preview: fresh });
+      previews.current.set(rec.id, fresh);
+      return fresh;
+    } catch (failure) { refetches.current.delete(rec.id); throw failure; }
+    finally { setNonces(prev => ({ ...prev, [rec.id]: (prev[rec.id] ?? 0) + 1 })); }
+  }, [agentId, projectId]);
   const [focusIndex, setFocusIndex] = useState(0);
   const [review, setReview] = useState<ReviewRequest | null>(null);
   const [results, setResults] = useState<ReviewResult[]>([]);
@@ -250,7 +292,7 @@ export function PendingChangesPanel({ agentId, projectId }: Props) {
     setLoading(true); setError(null);
     try {
       const list = await listPendingChanges({ agentId, ...(projectId ? { projectId } : {}),
-        ...(convFilter ? { conversationId: convFilter } : {}), ...(withOrphans ? { include_orphans: true } : {}) });
+        ...(convFilter ? { conversationId: convFilter } : {}), ...(withOrphans ? { include_orphans: true } : {}) }, client);
       if (mine !== listSeq.current) return undefined;
       const ids = new Set(list.changes.map(rec => rec.id));
       setChanges(list.changes);
@@ -277,6 +319,7 @@ export function PendingChangesPanel({ agentId, projectId }: Props) {
   const firstRevision = useRef(true);
   useEffect(() => {
     if (firstRevision.current) { firstRevision.current = false; return; }
+    if (revisions === listedRevisions.current) return;
     void fetchPendingRef.current(false);
   }, [revisions]);
 
@@ -291,7 +334,11 @@ export function PendingChangesPanel({ agentId, projectId }: Props) {
   const groupsVisible = useMemo(() => visibleGitGroups(gitGroups, filters), [gitGroups, filters]);
   const gitRows = useMemo(() => currentGitRows(groupsVisible), [groupsVisible]);
   const items = useMemo(() => buildChangeItems(visible, gitRows, filters.kind, view), [visible, gitRows, filters.kind, view]);
-  const { approvable, needsAck } = useMemo(() => splitApprovable(visible, orphanIds, REVIEW_BATCH), [visible, orphanIds]);
+  // A landed preview that needs an acknowledgement moves its record into the count (no fetch of its own).
+  const [ackPreviews, setAckPreviews] = useState(0);
+  const { approvable, needsAck } = useMemo(() => splitApprovable(visible, orphanIds, REVIEW_BATCH, peekPreview),
+    // eslint-disable-next-line react-hooks/exhaustive-deps -- `ackPreviews` re-reads the preview map
+    [visible, orphanIds, peekPreview, ackPreviews]);
   // The records one review session already acted on: the next batch starts after them,
   // so a refused record does not come straight back.
   const reviewed = useRef(new Set<string>());
@@ -328,28 +375,33 @@ export function PendingChangesPanel({ agentId, projectId }: Props) {
    */
   const dropResolvedDeleteRow = useCallback((rec: PendingChangeRecord) => {
     if (rec.op !== 'delete' || !rec.uri) return;
-    const node = useFilesystemStore.getState().files[rec.uri];
+    const node = storeApi.getState().files[rec.uri];
     if (!node || node.status === 'deleted') removeFilePath(rec.uri);
-  }, [removeFilePath]);
+  }, [removeFilePath, storeApi]);
 
   const afterMutation = useCallback(async (done: ReviewResult[]) => {
     for (const result of done) {
       const rec = changes.find(c => c.id === result.id);
       if (rec && result.outcome === 'ok' && result.action !== 'revert') dropResolvedDeleteRow(rec);
-      if (result.outcome !== 'ok') previews.current.delete(result.id);
+      // A `needs-ack` answer came from a still-valid preview: it stays cached (the header counts it).
+      if (result.outcome !== 'ok' && result.outcome !== 'needs-ack' && !refetches.current.has(result.id)) previews.current.delete(result.id);
     }
-    if (done.some(r => r.outcome !== 'ok')) setNonce(value => value + 1);
+    const refused = done.filter(r => r.outcome !== 'ok' && r.outcome !== 'needs-ack' && !refetches.current.has(r.id));
+    if (refused.length) setNonces(prev => { const next = { ...prev }; for (const r of refused) next[r.id] = (next[r.id] ?? 0) + 1; return next; });
     setResults(done);
-    await fetchPending(false);
+    const after = await fetchPending(false);
+    // The STORE's value, not the last render's: the batch's own bumps may not have rendered yet.
+    listedRevisions.current = storeApi.getState().sourceChangeRevision; setHeld(null);
+    relisted.current.resolve(after); relisted.current = Promise.withResolvers();
     void refreshPendingCount({ agentId, projectId });
-  }, [changes, dropResolvedDeleteRow, fetchPending, refreshPendingCount, agentId, projectId]);
+  }, [changes, dropResolvedDeleteRow, fetchPending, refreshPendingCount, agentId, projectId, storeApi]);
 
   const resolveReview = useCallback(async (rec: PendingChangeRecord, action: ReviewAction) => {
     if (!canWrite) return;
     const preview = previews.current.get(rec.id);
     if (!preview || preview.requiresAcknowledgement.length) { setReview({ kind: 'single', rec, action, ...(preview ? { preview } : {}) }); return; }
     setBusyId(rec.id);
-    try { await afterMutation([await applyReview({ agentId, projectId }, rec, preview, action, false)]); }
+    try { await afterMutation([await applyReview({ agentId, projectId, client }, rec, preview, action, false)]); }
     finally { setBusyId(null); }
   }, [canWrite, agentId, projectId, afterMutation]);
 
@@ -357,7 +409,7 @@ export function PendingChangesPanel({ agentId, projectId }: Props) {
   const discard = useCallback(async (rec: PendingChangeRecord) => {
     setBusyId(rec.id);
     try {
-      const res = await discardPendingChange({ agentId, ...(projectId ? { projectId } : {}), id: rec.id });
+      const res = await discardPendingChange({ agentId, ...(projectId ? { projectId } : {}), id: rec.id }, client);
       if (!res.ok) setError(res.error || 'Discard failed'); else dropResolvedDeleteRow(rec);
       await fetchPending(false);
       void refreshPendingCount({ agentId, projectId });
@@ -370,7 +422,7 @@ export function PendingChangesPanel({ agentId, projectId }: Props) {
     if (repairTimer.current) { clearTimeout(repairTimer.current); repairTimer.current = null; }
     setRepairing(true); setConfirmRepair(false); setError(null);
     try {
-      await discardOrphanedPending({ agentId, ...(projectId ? { projectId } : {}), ...(convFilter ? { conversationId: convFilter } : {}) });
+      await discardOrphanedPending({ agentId, ...(projectId ? { projectId } : {}), ...(convFilter ? { conversationId: convFilter } : {}) }, client);
       const candidates = changes.filter((rec) => orphanIds.has(rec.id));
       const after = await fetchPending(true);
       if (after) {
@@ -388,22 +440,30 @@ export function PendingChangesPanel({ agentId, projectId }: Props) {
   }, [confirmRepair, repair]); useEffect(() => () => { if (repairTimer.current) clearTimeout(repairTimer.current); }, []);
 
   // Approve the visible records whose own fields need no acknowledgement (two-step
-  // confirm). A record whose fresh preview turns out to need one is reported, not skipped silently.
+  // confirm). A record whose fresh preview turns out to need one is reported AND handed
+  // to the grouped review dialog, where it is approved or dismissed with its acknowledgement.
   const approveAll = useCallback(async () => {
-    setApprovingAll(true); setConfirmAll(false); setError(null);
+    setApprovingAll(true); setConfirmAll(false); setError(null); holdRevisions();
     const done: ReviewResult[] = [];
     try {
       for (const rec of approvable) {
         let preview = previews.current.get(rec.id);
         if (!preview) {
-          try { preview = await previewPendingChange({ agentId, ...(projectId ? { projectId } : {}), id: rec.id }); }
+          try { preview = await previewPendingChange({ agentId, ...(projectId ? { projectId } : {}), id: rec.id }, client); }
           catch (e) { done.push({ id: rec.id, uri: rec.uri, action: 'approve', outcome: 'error', detail: e instanceof Error ? e.message : 'Preview failed' }); continue; }
+          previews.current.set(rec.id, preview);
         }
         if (preview.requiresAcknowledgement.length) { done.push({ id: rec.id, uri: rec.uri, action: 'approve', outcome: 'needs-ack' }); continue; }
-        done.push(await applyReview({ agentId, projectId }, rec, preview, 'approve', false));
+        done.push(await applyReview({ agentId, projectId, client }, rec, preview, 'approve', false));
       }
-    } finally { setApprovingAll(false); await afterMutation(done); }
-  }, [approvable, agentId, projectId, afterMutation]);
+    } finally {
+      setApprovingAll(false);
+      const handed = approvable.filter(rec => done.some(r => r.id === rec.id && r.outcome === 'needs-ack'));
+      if (handed.length) setAckPreviews(n => n + 1);
+      await afterMutation(done);
+      if (handed.length && canWrite) { reviewed.current.clear(); setReview({ kind: 'group', records: handed.slice(0, REVIEW_BATCH), total: handed.length }); }
+    }
+  }, [approvable, agentId, projectId, afterMutation, canWrite]);
 
   const move = useCallback((delta: number) => setFocusIndex((i) => (visible.length === 0 ? 0
     : Math.max(0, Math.min(visible.length - 1, i + delta)))), [visible.length]);
@@ -437,8 +497,8 @@ export function PendingChangesPanel({ agentId, projectId }: Props) {
     if (item.kind === 'pending-card') {
       return <PendingDiffCard rec={rec} agentId={agentId} projectId={projectId} focused={index === focusIndex} orphaned={orphaned}
         onOpen={openInTree} {...handlers} onFocus={() => setFocusIndex(index)} busy={busyId === rec.id} queue={queue}
-        revision={nonce + (revisions[rec.sourceSlug] ?? 0)} canWrite={canWrite}
-        onPreview={preview => { previews.current.set(rec.id, preview); }} peekPreview={peekPreview}
+        revision={(nonces[rec.id] ?? 0) + (revisions[rec.sourceSlug] ?? 0)} canWrite={canWrite}
+        onPreview={preview => { previews.current.set(rec.id, preview); if (preview.requiresAcknowledgement.length) setAckPreviews(n => n + 1); }} peekPreview={peekPreview} takeRefetch={takeRefetch}
         extra={filters.kind === 'all' ? <CurrentGitDiffs uri={rec.uri} rows={gitRows} agentId={agentId} projectId={projectId} canWrite={canWrite} revisions={revisions} queue={queue} /> : null} />;
     }
     return <div onMouseDown={() => setFocusIndex(index)} className={`group h-8 flex items-center gap-2 px-2 rounded-lg ${
@@ -461,7 +521,7 @@ export function PendingChangesPanel({ agentId, projectId }: Props) {
       {canWrite && review ? <PendingReviewDialog request={review} agentId={agentId} projectId={projectId} run={queue.run}
         key={review.kind === 'group' ? `group\u0000${review.records[0]?.id ?? ''}` : `single\u0000${review.rec.id}`}
         onClose={() => setReview(null)} next={review.kind === 'group' ? unreviewed.filter(rec => !review.records.some(r => r.id === rec.id)).length : 0}
-        onNext={openReviewBatch}
+        onNext={openReviewBatch} refetch={refetch} onBatchStart={holdRevisions}
         onDone={done => { for (const result of done) reviewed.current.add(result.id); void afterMutation(done); }} /> : null}
       {/* Header: title + nav cursor + approve-all + view toggle + refresh */}
       <div className="flex flex-wrap items-center gap-1.5 px-3 py-2 border-b border-white/5 shrink-0">
@@ -548,7 +608,7 @@ export function PendingChangesPanel({ agentId, projectId }: Props) {
         <div className="mx-3 mt-2 max-h-28 overflow-auto overlay-scroll rounded-lg border border-amber-500/25 bg-amber-500/[0.06] px-2.5 py-1.5 text-[10.5px] text-amber-100/85 shrink-0">
           <div className="flex items-center gap-2 font-semibold">{results.length - failed.length} done · {failed.length} not done
             <button type="button" onClick={() => setResults([])} className="ml-auto rounded hover:bg-white/10" title="Dismiss"><X className="w-3 h-3" /></button></div>
-          {failed.map(r => <div key={r.id} className="truncate font-mono" title={r.detail}>{r.action} {r.uri}: {r.outcome === 'changed' ? 'changed since the preview (409)' : r.outcome === 'needs-ack' ? 'needs confirmation' : r.detail ?? 'refused'}</div>)}
+          {failed.map(r => <div key={r.id} className="truncate font-mono" title={r.detail}>{r.action} {r.uri}: {r.outcome === 'changed' ? 'changed since the preview (409)' : r.outcome === 'needs-ack' ? 'needs confirmation — opened in the review dialog' : r.detail ?? 'refused'}</div>)}
         </div>
       ) : null}