bug: "Panel constraints not found for Panel inspector" error on sidebar panel click

[harshitsinghbhandari]

Bug

Clicking on the side panel in the desktop app surfaces the following error overlay:

Something went wrong!
Panel constraints not found for Panel inspector

Steps to reproduce

1. Launch the Electron app (pnpm run dev in frontend/)
2. Click on any item in the sidebar / side panel
3. Error overlay appears immediately

Expected

Panel opens normally with no error.

Likely area

frontend/src/renderer/ — panel layout / resizable panel wiring. Suspect a missing or mis-keyed panelConstraints entry for the inspector panel in the panel store or layout config.

[harshitsinghbhandari]

RCA: "Panel constraints not found for Panel inspector" — Issue #185

Session: aa-87
Date: 2026-06-11
Repo: aoagents/ReverbCode
Affected commit: e493de6 (feat(renderer): clone agent-orchestrator shell and inspector)

---

1. Symptom

Clicking any session entry in the sidebar immediately shows the error overlay:

Something went wrong!
Panel constraints not found for Panel inspector

The route is unloaded to TanStack Router's CatchBoundary. The session view never renders.

---

2. Error Origin

The error is thrown by react-resizable-panels v4.11.2 (rrp).
It originates from inside rrp's collapsePanel() / expandPanel() / resizePanel()
functions. Those functions look up the panel's constraint entry by ID in an internal
idToConstraintsMap (or equivalent). When the ID "inspector" is absent from that
map at call time, rrp throws:

Panel constraints not found for Panel inspector

The map is populated by rrp's useLayoutEffect inside ResizablePanel when the
panel mounts, and is cleared by that effect's cleanup when the panel unmounts or when
any of the effect's dependencies change.

---

3. Code Path

3a. Where the imperative call happens

SessionView.tsx:84–95:

useEffect(() => {
    const panel = inspectorRef.current;
    if (!panel) return;
    if (isInspectorOpen) {
        panel.expand();
        if (panel.getSize().asPercentage === 0) panel.resize(`${initialSplitPercent()}%`);
    } else {
        panel.collapse();
    }
}, [hasInspector, isInspectorOpen]);

This useEffect fires on mount (both hasInspector and isInspectorOpen are set) and
calls panel.expand() or panel.collapse() on the rrp imperative handle. These are the
calls that reach rrp's constraint-map lookup and throw.

3b. The rrp registration lifecycle

rrp registers a panel's constraints in a useLayoutEffect whose dependency array
includes the props that define the panel's sizing: id, defaultSize, minSize,
maxSize, collapsible, collapsedSize, and — critically — the onResize callback
(many rrp internal effects include callbacks in deps to avoid stale closures).

Registration cleanup (de-register) runs when the effect re-runs. Between cleanup and
re-run, the panel is absent from the constraints map. If panel.expand()/panel.collapse()
is called in that window, rrp throws.

---

4. The Existing Partial Fix

The developer who authored e493de6 recognised a specific instance of this race and
added a useState-frozen defaultSize:

// SessionView.tsx:68
const [inspectorDefaultSize] = useState(() =>
    isInspectorOpen ? `${initialSplitPercent()}%` : "0%"
);

The inline comment says:

"rrp re-registers the panel (a layout effect keyed on defaultSize, among others)
whenever this prop's identity changes, and the imperative collapse()/expand() below
can race that re-registration within the same commit"

This fix prevents rrp from re-registering due to defaultSize changes. It is
correct but incomplete — the comment explicitly acknowledges "among others."

---

5. Root Cause: Unstable onResize Reference

handleInspectorResize is defined as an inline arrow function without useCallback:

// SessionView.tsx:99
const handleInspectorResize = (size: PanelSize) => {
    const open = useUiStore.getState().isInspectorOpen;
    if (size.asPercentage > 0) {
        window.localStorage?.setItem(inspectorSplitStorageKey, String(size.asPercentage));
        if (!open) toggleInspector();
    } else if (open) {
        toggleInspector();
    }
};

SessionView subscribes to several reactive sources:

• useUiStore (theme, isInspectorOpen)
• useWorkspaceQuery (workspaces list)
• useShell (daemonStatus)

Any update from these sources causes a re-render of SessionView, which creates a new
function reference for handleInspectorResize. If rrp includes onResize in its panel
registration effect's dependency array, every re-render triggers the effect's cleanup
(de-registers "inspector") followed by its re-run (re-registers "inspector").

The Race Window

During an update where both of the following are true in the same React commit:

1. handleInspectorResize gets a new reference (rrp's layout cleanup fires → "inspector"
   is momentarily absent from the constraints map)
2. isInspectorOpen also changes (or hasInspector changes), causing
   SessionView's useEffect to fire

…the panel.expand() / panel.collapse() call can land in the window between rrp's
cleanup (step 2a of React's commit) and rrp's re-run (step 2b of the same commit),
before React has finished processing all layout-effect bodies.

In practice this is most reproducible on initial mount when workspace data resolves:

1. SessionView mounts → rrp registers "inspector" → useEffect fires → panel.expand()
   → OK (this render usually succeeds).
2. The workspace query resolves in a concurrent transition → new render → new
   handleInspectorResize reference → rrp cleanup fires (de-registers "inspector").
3. isInspectorOpen initialisation (localStorage read → store hydration) fires in the
   same batch as step 2 → SessionView's useEffect is scheduled to re-run.
4. panel.expand() fires while "inspector" is de-registered → throw.

With React 19's concurrent renderer and automatic batching, steps 2–4 are frequently
batched into one commit, making the race deterministic on every sidebar click.

---

6. Secondary Concern: panelRef vs ref API

SessionView passes the imperative ref via:

<ResizablePanel panelRef={inspectorRef} ...>

rrp v4's Panel is a React.forwardRef component — the standard way to retrieve the
imperative handle is via the ref prop. If rrp v4.11.2 does not expose panelRef as a
named prop, the ref is never populated by rrp, inspectorRef.current remains null, and
the if (!panel) return; guard exits early — meaning SessionView's effect is NOT the
source of the throw.

In that scenario, the error originates from rrp internally during layout computation
(e.g., when ResizablePanelGroup tries to resize panels after a collapse/expand triggered
by rrp's own drag or animation logic) and "inspector" isn't in the map because rrp's
effect cleanup ran but the re-registration has not yet committed.

Either way, the unstable handleInspectorResize reference is the proximate trigger.

---

7. Contributing Factors

Factor	Status	Notes
defaultSize instability	Fixed by useState	Correct fix, implemented in e493de6
onResize (handleInspectorResize) instability	Not fixed	Needs useCallback
panelRef vs ref API	Unverified	rrp v4 types not available in worktree; needs check
React 19 automatic batching	Exacerbating	Makes the race deterministic

---

8. Recommended Fix

Primary fix — wrap handleInspectorResize in useCallback:

const handleInspectorResize = useCallback(
    (size: PanelSize) => {
        const open = useUiStore.getState().isInspectorOpen;
        if (size.asPercentage > 0) {
            window.localStorage?.setItem(inspectorSplitStorageKey, String(size.asPercentage));
            if (!open) toggleInspector();
        } else if (open) {
            toggleInspector();
        }
    },
    [toggleInspector],
);

This stabilises the onResize reference across renders, preventing rrp from
continuously re-registering the panel.

Secondary check — verify whether rrp v4.11.2 uses panelRef or ref:

pnpm install  # restore node_modules
grep -r "panelRef" node_modules/react-resizable-panels/dist/ | head -5

If panelRef is not exported, change:

panelRef={inspectorRef}

to:

ref={inspectorRef}

---

9. Files to Change

• frontend/src/renderer/components/SessionView.tsx
  • handleInspectorResize: add useCallback([toggleInspector])
  • panelRef → ref if rrp v4 doesn't expose panelRef