From 5572a7be603183b63ea1d0502aab952e647339ea Mon Sep 17 00:00:00 2001
From: Array Fleet <fleet@advancedresearcharray.local>
Date: Tue, 30 Jun 2026 07:07:20 +0000
Subject: [PATCH 1/9] feat(ui): split / side-by-side page view (#426)

Add resizable dual-pane reading with tree and wiki-link entry points,
Mod+\ toggle, history version compare, sessionStorage persistence, and
regression tests for split state and keybindings.

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 .../2026-06-30-issue-426-split-view.md        |  34 +++
 internal/keybindings/keybindings.go           |   4 +
 internal/keybindings/keybindings_test.go      |   1 +
 ui/src/App.tsx                                | 144 ++++++++++++-
 ui/src/components/AppSidebar.tsx              |   4 +
 ui/src/components/KiwiHistory.tsx             |  17 +-
 ui/src/components/KiwiPage.tsx                | 148 +++++++++-----
 ui/src/components/KiwiSplitView.tsx           | 184 +++++++++++++++++
 ui/src/components/KiwiTree.tsx                |  12 ++
 ui/src/components/ui/resizable.tsx            | 193 ++++++++++++++++++
 ui/src/lib/kiwiKeybindings.test.ts            |  13 ++
 ui/src/lib/kiwiKeybindings.ts                 |  12 +-
 ui/src/lib/splitView.test.ts                  |  90 ++++++++
 ui/src/lib/splitView.ts                       | 145 +++++++++++++
 14 files changed, 950 insertions(+), 51 deletions(-)
 create mode 100644 episodes/agents/cursor-fleet/2026-06-30-issue-426-split-view.md
 create mode 100644 ui/src/components/KiwiSplitView.tsx
 create mode 100644 ui/src/components/ui/resizable.tsx
 create mode 100644 ui/src/lib/splitView.test.ts
 create mode 100644 ui/src/lib/splitView.ts

diff --git a/episodes/agents/cursor-fleet/2026-06-30-issue-426-split-view.md b/episodes/agents/cursor-fleet/2026-06-30-issue-426-split-view.md
new file mode 100644
index 00000000..ab07dabb
--- /dev/null
+++ b/episodes/agents/cursor-fleet/2026-06-30-issue-426-split-view.md
@@ -0,0 +1,34 @@
+---
+memory_kind: episodic
+episode_id: cursor-fleet-2026-06-30-issue-426-split-view
+title: "Issue #426 split / side-by-side page view"
+tags: [kiwifs, ui, split-view, issue-426, fleet-delivery]
+date: 2026-06-30
+---
+
+# Issue #426 split view delivery
+
+## Task
+
+Implement kiwifs/kiwifs#426 — side-by-side page view with tree/wiki-link menus, `Mod+\` toggle, resizable panes, history compare, mobile guard, sessionStorage persistence, and regression tests.
+
+## Actions
+
+1. Branched `feat/split-view-426` from `main`.
+2. Added `splitView.ts` pure state + 8 vitest cases; wired state in `App.tsx`.
+3. Built `KiwiSplitView` + self-contained `ui/resizable.tsx` (overlay `node_modules` read-only — skipped `npm install react-resizable-panels`).
+4. Extended `KiwiPage` with `versionHash`/`readOnly` and wiki-link context menu; tree/history entry points.
+5. Registered `toggle_split_view` in Go + TS keybindings with backslash normalization.
+6. Kiwi MCP gateway at `192.168.167.240:3333` unreachable — updated local fix doc under `pages/fixes/`.
+
+## Verification
+
+- `npm test -- src/lib/splitView.test.ts src/lib/kiwiKeybindings.test.ts` → 17 passed
+- `npm test` (full UI suite) → 198 passed
+- `go test ./internal/keybindings/...` → ok
+- Removed duplicate `WikiLinkMenu` and unrelated template commit from branch
+- Fix doc: `pages/fixes/kiwifs-kiwifs/issue-426-split-side-by-side-page-view.md`
+
+## Handoff
+
+Push `feat/split-view-426` and open PR closing #426.
diff --git a/internal/keybindings/keybindings.go b/internal/keybindings/keybindings.go
index a1c3ff74..8d3421e9 100644
--- a/internal/keybindings/keybindings.go
+++ b/internal/keybindings/keybindings.go
@@ -25,6 +25,7 @@ var knownActions = map[string]struct{}{
 	"undo":               {},
 	"focus_tree_filter":  {},
 	"close_overlay":      {},
+	"toggle_split_view":  {},
 }
 
 // DefaultBindings are used when no config overrides are present.
@@ -43,6 +44,7 @@ var DefaultBindings = map[string]string{
 	"undo":              "Mod+Z",
 	"focus_tree_filter": "Mod+Alt+F",
 	"close_overlay":     "Escape",
+	"toggle_split_view": "Mod+\\",
 }
 
 // Conflict describes two or more actions bound to the same chord.
@@ -127,6 +129,8 @@ func normalizeKey(key string) string {
 		return "/"
 	case "question", "?":
 		return "?"
+	case "backslash", "\\":
+		return "\\"
 	default:
 		if len(key) == 1 {
 			return key
diff --git a/internal/keybindings/keybindings_test.go b/internal/keybindings/keybindings_test.go
index 9652201c..175945b4 100644
--- a/internal/keybindings/keybindings_test.go
+++ b/internal/keybindings/keybindings_test.go
@@ -17,6 +17,7 @@ func TestNormalizeChord(t *testing.T) {
 		{"Escape", "escape"},
 		{"Ctrl+/", "mod+/"},
 		{"Mod+?", "mod+?"},
+		{"Mod+\\", "mod+\\"},
 	}
 	for _, tc := range tests {
 		got, err := NormalizeChord(tc.in)
diff --git a/ui/src/App.tsx b/ui/src/App.tsx
index d9cc252a..c59a504c 100644
--- a/ui/src/App.tsx
+++ b/ui/src/App.tsx
@@ -21,6 +21,7 @@ import type { TreeSortMode } from "./lib/treeTransform";
 import { shouldRefreshTreeImmediately } from "./lib/treeRefresh";
 import { usePublishedPagesStore } from "./stores/publishedPagesStore";
 import { KiwiPage } from "./components/KiwiPage";
+import { KiwiSplitView, SplitViewMobileNotice } from "./components/KiwiSplitView";
 import { KiwiEditor } from "./components/KiwiEditor";
 import { KiwiSearch } from "./components/KiwiSearch";
 import { KiwiGraph } from "./components/KiwiGraph";
@@ -64,6 +65,16 @@ import { useTheme } from "./hooks/useTheme";
 import { isMarkdown, isCanvasFile, isExcalidrawFile } from "./lib/paths";
 import { type TreeRevealRequest } from "./lib/treeReveal";
 import { HostToolbarActions } from "./components/HostToolbarActions";
+import {
+  closeSecondaryPane,
+  createSplitViewState,
+  loadSplitViewState,
+  openPathInSplit,
+  openVersionInSplit,
+  saveSplitViewState,
+  toggleSplitView,
+  type SplitViewState,
+} from "./lib/splitView";
 
 function getInitialActivePath(): string | null {
   if (typeof window === "undefined") return null;
@@ -98,6 +109,10 @@ export default function App() {
   const [initialWhiteboardPath, setInitialWhiteboardPath] = useState<string | null>(null);
   const [timelineOpen, setTimelineOpen] = useState(false);
   const [kanbanOpen, setKanbanOpen] = useState(false);
+  const [splitView, setSplitView] = useState<SplitViewState>(
+    () => loadSplitViewState() ?? createSplitViewState(),
+  );
+  const [splitMobileNotice, setSplitMobileNotice] = useState(false);
   const [treeRevealRequest, setTreeRevealRequest] = useState<TreeRevealRequest | null>(null);
   const treeRef = useRef<KiwiTreeHandle>(null);
   const treeFilterRef = useRef<HTMLInputElement>(null);
@@ -133,6 +148,63 @@ export default function App() {
     return () => mq.removeEventListener("change", onChange);
   }, []);
 
+  useEffect(() => {
+    saveSplitViewState(splitView);
+  }, [splitView]);
+
+  useEffect(() => {
+    if (isMobile && splitView.enabled) {
+      setSplitView(createSplitViewState({ sizes: splitView.sizes }));
+    }
+  }, [isMobile, splitView.enabled, splitView.sizes]);
+
+  const handleOpenInSplitView = useCallback((path: string) => {
+    if (isMobile) {
+      setSplitMobileNotice(true);
+      return;
+    }
+    if (!activePath) {
+      setActivePath(path);
+      return;
+    }
+    setSplitView((prev) => openPathInSplit(prev, path));
+  }, [isMobile, activePath]);
+
+  const handleToggleSplitView = useCallback(() => {
+    if (isMobile) {
+      setSplitMobileNotice(true);
+      return;
+    }
+    setSplitView((prev) => toggleSplitView(prev, activePath));
+  }, [isMobile, activePath]);
+
+  const handleCompareWithCurrent = useCallback((hash: string) => {
+    if (!activePath) return;
+    if (isMobile) {
+      setSplitMobileNotice(true);
+      return;
+    }
+    setHistoryOpen(false);
+    setSplitView((prev) => openVersionInSplit(prev, { path: activePath, hash }));
+  }, [activePath, isMobile]);
+
+  const navigateRightPane = useCallback((path: string) => {
+    setSplitView((prev) => ({
+      ...prev,
+      enabled: true,
+      rightPath: path,
+      rightVersion: null,
+    }));
+  }, []);
+
+  const handleCloseSecondaryPane = useCallback(() => {
+    setSplitView((prev) => closeSecondaryPane(prev));
+  }, []);
+
+  const handleSplitSizesChange = useCallback((sizes: [number, number]) => {
+    setSplitView((prev) => ({ ...prev, sizes }));
+  }, []);
+
   const [sidebarOpen, setSidebarOpen] = useState(() => {
     if (typeof window !== "undefined" && window.innerWidth < 768) return false;
     try { return localStorage.getItem("kiwifs-sidebar") !== "collapsed"; } catch { return true; }
@@ -388,6 +460,10 @@ export default function App() {
             })
             .catch(() => {});
           break;
+        case "toggle_split_view":
+          e.preventDefault();
+          handleToggleSplitView();
+          break;
         case "focus_tree_filter":
           e.preventDefault();
           treeFilterRef.current?.focus();
@@ -438,7 +514,7 @@ export default function App() {
     };
     window.addEventListener("keydown", onKey);
     return () => window.removeEventListener("keydown", onKey);
-  }, [bindings, closeAllViews, sidebarOpen, toggleSidebar]);
+  }, [bindings, closeAllViews, sidebarOpen, toggleSidebar, handleToggleSplitView]);
 
 const handleSpaceSwitch = useCallback(() => {
     setActivePath(null);
@@ -781,6 +857,7 @@ const handleSpaceSwitch = useCallback(() => {
             onTreeSortModeChange={setTreeSortMode}
             onActivePathChange={setActivePath}
             onTreeRefresh={refreshTree}
+            onOpenInSplitView={handleOpenInSplitView}
           />
 
           {/* Sidebar resize handle (desktop only) */}
@@ -810,7 +887,7 @@ const handleSpaceSwitch = useCallback(() => {
           )}
 
           {/* Main content area */}
-          <main className={`flex-1 relative ${basesOpen || canvasOpen || whiteboardOpen || timelineOpen || kanbanOpen || dataOpen || graphOpen ? "overflow-hidden" : "overflow-auto kiwi-scroll"}`}>
+          <main className={`flex-1 relative ${basesOpen || canvasOpen || whiteboardOpen || timelineOpen || kanbanOpen || dataOpen || graphOpen || (splitView.enabled && !isMobile) ? "overflow-hidden" : "overflow-auto kiwi-scroll"}`}>
             {basesOpen ? (
               <KiwiBases
                 onClose={() => setBasesOpen(false)}
@@ -857,6 +934,7 @@ const handleSpaceSwitch = useCallback(() => {
                 path={activePath}
                 onClose={() => setHistoryOpen(false)}
                 onRestored={() => setRefreshKey((k) => k + 1)}
+                onCompareWithCurrent={handleCompareWithCurrent}
               />
             ) : editing && activePath ? (
               <KiwiEditor
@@ -874,11 +952,71 @@ const handleSpaceSwitch = useCallback(() => {
                   setRefreshKey((k) => k + 1);
                 }}
               />
+            ) : activePath && splitView.enabled && !isMobile ? (
+              <KiwiSplitView
+                tree={tree}
+                leftPath={activePath}
+                splitView={splitView}
+                refreshKey={refreshKey}
+                onLeftNavigate={navigate}
+                onRightNavigate={navigateRightPane}
+                onOpenInSplitView={handleOpenInSplitView}
+                onSizesChange={handleSplitSizesChange}
+                onCloseSecondary={handleCloseSecondaryPane}
+                leftPane={{
+                  onEdit: () => setEditing(true),
+                  onHistory: () => setHistoryOpen(true),
+                  onRevealInTree: revealActivePageInTree,
+                  onToggleStar: () => toggleStar(activePath),
+                  isStarred: isStarred(activePath),
+                  onTogglePin: () => togglePin(activePath),
+                  isPinned: isPinned(activePath),
+                  onDeleted: () => {
+                    setActivePath(null);
+                    setRefreshKey((k) => k + 1);
+                  },
+                  onDuplicated: (p) => {
+                    setRefreshKey((k) => k + 1);
+                    navigate(p);
+                  },
+                  onMoved: (p) => {
+                    setRefreshKey((k) => k + 1);
+                    navigate(p);
+                  },
+                  onTagClick: (tag) => {
+                    setSearchQuery(`tag:${tag}`);
+                    setSearchOpen(true);
+                  },
+                  onPublishedChanged: refreshPublishedPages,
+                }}
+                rightPane={{
+                  onEdit: () => {
+                    const target = splitView.rightPath ?? splitView.rightVersion?.path ?? activePath;
+                    setActivePath(target);
+                    setEditing(true);
+                  },
+                  onHistory: () => setHistoryOpen(true),
+                  onToggleStar: splitView.rightPath
+                    ? () => toggleStar(splitView.rightPath!)
+                    : undefined,
+                  isStarred: splitView.rightPath ? isStarred(splitView.rightPath) : false,
+                  onTogglePin: splitView.rightPath
+                    ? () => togglePin(splitView.rightPath!)
+                    : undefined,
+                  isPinned: splitView.rightPath ? isPinned(splitView.rightPath) : false,
+                  onTagClick: (tag) => {
+                    setSearchQuery(`tag:${tag}`);
+                    setSearchOpen(true);
+                  },
+                  onPublishedChanged: refreshPublishedPages,
+                }}
+              />
             ) : activePath ? (
               <KiwiPage
                 path={activePath}
                 tree={tree}
                 onNavigate={navigate}
+                onOpenInSplitView={handleOpenInSplitView}
                 onEdit={() => setEditing(true)}
                 onHistory={() => setHistoryOpen(true)}
                 onRevealInTree={revealActivePageInTree}
@@ -905,6 +1043,8 @@ const handleSpaceSwitch = useCallback(() => {
                 refreshKey={refreshKey}
                 onPublishedChanged={refreshPublishedPages}
               />
+            ) : splitMobileNotice ? (
+              <SplitViewMobileNotice onDismiss={() => setSplitMobileNotice(false)} />
             ) : treeLoading || !uiConfigLoaded ? (
               <div className="flex h-full items-center justify-center">
                 <div className="h-6 w-6 animate-spin rounded-full border-2 border-primary border-t-transparent" />
diff --git a/ui/src/components/AppSidebar.tsx b/ui/src/components/AppSidebar.tsx
index 9e232c08..e92f0402 100644
--- a/ui/src/components/AppSidebar.tsx
+++ b/ui/src/components/AppSidebar.tsx
@@ -59,6 +59,7 @@ type AppSidebarProps = {
   onTreeSortModeChange: Dispatch<SetStateAction<TreeSortMode>>;
   onActivePathChange: (path: string | null) => void;
   onTreeRefresh: (options?: { background?: boolean; reconcile?: boolean }) => void;
+  onOpenInSplitView?: (path: string) => void;
 };
 
 export function AppSidebar({
@@ -87,6 +88,7 @@ export function AppSidebar({
   onTreeSortModeChange,
   onActivePathChange,
   onTreeRefresh,
+  onOpenInSplitView,
 }: AppSidebarProps) {
   const publishedPages = usePublishedPagesStore((state) => state.pages);
   const showPublishedList = usePublishedPagesStore((state) => state.showList);
@@ -269,6 +271,7 @@ export function AppSidebar({
                       onTreeRefresh({ background: true, reconcile: options?.refresh === false ? false : undefined });
                       if (path) onNavigate(path);
                     }}
+                    onOpenInSplitView={onOpenInSplitView}
                   />
                 </SidebarSection>
               ))}
@@ -354,6 +357,7 @@ export function AppSidebar({
                 if (path) onNavigate(path);
               }}
               enableKanbanDrag={kanbanOpen}
+              onOpenInSplitView={onOpenInSplitView}
             />
           </SidebarSection>
         </div>
diff --git a/ui/src/components/KiwiHistory.tsx b/ui/src/components/KiwiHistory.tsx
index aa0c4e9e..fd22c5e4 100644
--- a/ui/src/components/KiwiHistory.tsx
+++ b/ui/src/components/KiwiHistory.tsx
@@ -1,7 +1,7 @@
 import { useEffect, useMemo, useState } from "react";
 import ReactDiffViewer, { DiffMethod } from "react-diff-viewer-continued";
 import { formatDistanceToNow, parseISO } from "date-fns";
-import { GitBranch, History, RotateCcw, User, X } from "lucide-react";
+import { GitBranch, GitCompareArrows, History, RotateCcw, User, X } from "lucide-react";
 import { api, type BlameLine, type Version } from "@kw/lib/api";
 import { titleize } from "@kw/lib/paths";
 import { Button } from "@kw/components/ui/button";
@@ -14,6 +14,7 @@ type Props = {
   path: string;
   onClose: () => void;
   onRestored?: () => void;
+  onCompareWithCurrent?: (hash: string) => void;
 };
 
 // Parse git date strings liberally — git uses multiple formats depending on
@@ -36,7 +37,7 @@ function relative(d: string): string {
   return formatDistanceToNow(parsed, { addSuffix: true });
 }
 
-export function KiwiHistory({ path, onClose, onRestored }: Props) {
+export function KiwiHistory({ path, onClose, onRestored, onCompareWithCurrent }: Props) {
   const [versions, setVersions] = useState<Version[] | null>(null);
   const [error, setError] = useState<string | null>(null);
   const [selectedHash, setSelectedHash] = useState<string | null>(null);
@@ -182,6 +183,18 @@ export function KiwiHistory({ path, onClose, onRestored }: Props) {
           </div>
         </div>
         <div className="flex items-center gap-2">
+          {selectedHash && versions && versions.length > 0 && selectedHash !== versions[0].hash && onCompareWithCurrent && (
+            <Button
+              variant="outline"
+              size="sm"
+              onClick={() => {
+                onCompareWithCurrent(selectedHash);
+                onClose();
+              }}
+            >
+              <GitCompareArrows className="h-3.5 w-3.5" /> Compare with current
+            </Button>
+          )}
           {selectedHash && versions && versions.length > 0 && selectedHash !== versions[0].hash && (
             confirmRestore ? (
               <div className="flex items-center gap-1">
diff --git a/ui/src/components/KiwiPage.tsx b/ui/src/components/KiwiPage.tsx
index bd040e25..b1019fc4 100644
--- a/ui/src/components/KiwiPage.tsx
+++ b/ui/src/components/KiwiPage.tsx
@@ -43,6 +43,12 @@ import { PageSkeleton } from "./PageSkeleton";
 import { trackRecent } from "./KiwiFavorites";
 import { Badge } from "@kw/components/ui/badge";
 import { Button } from "@kw/components/ui/button";
+import {
+  ContextMenu,
+  ContextMenuContent,
+  ContextMenuItem,
+  ContextMenuTrigger,
+} from "@kw/components/ui/context-menu";
 import { Tooltip, TooltipContent, TooltipTrigger } from "@kw/components/ui/tooltip";
 import remarkEmoji from "remark-emoji";
 import remarkSupersub from "remark-supersub";
@@ -69,6 +75,10 @@ type Props = {
   onTagClick?: (tag: string) => void;
   refreshKey?: number;
   onPublishedChanged?: () => void;
+  /** When set, loads this git version instead of the live file. */
+  versionHash?: string;
+  readOnly?: boolean;
+  onOpenInSplitView?: (path: string) => void;
 };
 
 type FrontmatterProperty = {
@@ -371,7 +381,7 @@ function classifyMedia(src: string): "image" | "video" | "audio" | "pdf" | "unkn
   return "unknown";
 }
 
-export function KiwiPage({ path, tree, onNavigate, onEdit, onHistory, onRevealInTree, onToggleStar, isStarred, onTogglePin, isPinned, onDeleted, onDuplicated, onMoved, onTagClick, refreshKey, onPublishedChanged }: Props) {
+export function KiwiPage({ path, tree, onNavigate, onEdit, onHistory, onRevealInTree, onToggleStar, isStarred, onTogglePin, isPinned, onDeleted, onDuplicated, onMoved, onTagClick, refreshKey, onPublishedChanged, versionHash, readOnly, onOpenInSplitView }: Props) {
   const treeEntry = useMemo(() => findEntry(tree, path), [tree, path]);
   const isDir = treeEntry?.isDir ?? false;
 
@@ -393,20 +403,22 @@ export function KiwiPage({ path, tree, onNavigate, onEdit, onHistory, onRevealIn
     setContent(null);
     setError(null);
     setLastModified(null);
-    trackRecent(path);
-    api
-      .readFile(path)
+    if (!versionHash) trackRecent(path);
+    const load = versionHash
+      ? api.readVersion(path, versionHash).then((text) => ({ content: text, lastModified: null }))
+      : api.readFile(path);
+    load
       .then((r) => {
         if (!cancelled) {
           setContent(r.content);
-          setLastModified(r.lastModified);
+          setLastModified(r.lastModified ?? null);
         }
       })
       .catch((e) => {
         if (!cancelled) setError(String(e));
       });
     return () => { cancelled = true; };
-  }, [path, refreshKey, isDir]);
+  }, [path, refreshKey, isDir, versionHash]);
 
   useEffect(() => {
     if (isDir) return;
@@ -619,21 +631,25 @@ export function KiwiPage({ path, tree, onNavigate, onEdit, onHistory, onRevealIn
                     <TooltipContent side="bottom">{isStarred ? "Unstar" : "Star"}</TooltipContent>
                   </Tooltip>
                 )}
-                {onHistory && (
+                {onHistory && !readOnly && (
                   <Button variant="outline" size="sm" onClick={onHistory}>
                     <HistoryIcon className="h-3.5 w-3.5" /> <span className="hidden sm:inline">History</span>
                   </Button>
                 )}
-                <Button variant="outline" size="sm" onClick={onEdit}>
-                  <Edit className="h-3.5 w-3.5" /> <span className="hidden sm:inline">Edit</span>
-                </Button>
-                <PublishButton path={path} onPublishedChanged={onPublishedChanged} />
-                <PageActions
-                  path={path}
-                  onDeleted={onDeleted}
-                  onDuplicated={onDuplicated}
-                  onMoved={onMoved}
-                />
+                {!readOnly && (
+                  <Button variant="outline" size="sm" onClick={onEdit}>
+                    <Edit className="h-3.5 w-3.5" /> <span className="hidden sm:inline">Edit</span>
+                  </Button>
+                )}
+                {!readOnly && <PublishButton path={path} onPublishedChanged={onPublishedChanged} />}
+                {!readOnly && (
+                  <PageActions
+                    path={path}
+                    onDeleted={onDeleted}
+                    onDuplicated={onDuplicated}
+                    onMoved={onMoved}
+                  />
+                )}
               </div>
             </div>
 
@@ -762,42 +778,55 @@ export function KiwiPage({ path, tree, onNavigate, onEdit, onHistory, onRevealIn
                         const pagePath = hashIdx >= 0 ? raw.slice(0, hashIdx) : raw;
                         const anchor = hashIdx >= 0 ? raw.slice(hashIdx) : "";
                         return (
-                          <a
-                            href={`#${raw}`}
-                            onClick={(e) => {
-                              e.preventDefault();
-                              onNavigate(pagePath);
-                              if (anchor) {
-                                requestAnimationFrame(() => {
-                                  setTimeout(() => {
-                                    const el = document.getElementById(anchor.slice(1));
-                                    el?.scrollIntoView({ behavior: "smooth", block: "start" });
-                                  }, 100);
-                                });
-                              }
-                            }}
-                            className="wiki-link"
-                            {...(rest as any)}
+                          <WikiLinkMenu
+                            pagePath={pagePath}
+                            onNavigate={onNavigate}
+                            onOpenInSplitView={onOpenInSplitView}
                           >
-                            {children}
-                          </a>
+                            <a
+                              href={`#${raw}`}
+                              onClick={(e) => {
+                                e.preventDefault();
+                                onNavigate(pagePath);
+                                if (anchor) {
+                                  requestAnimationFrame(() => {
+                                    setTimeout(() => {
+                                      const el = document.getElementById(anchor.slice(1));
+                                      el?.scrollIntoView({ behavior: "smooth", block: "start" });
+                                    }, 100);
+                                  });
+                                }
+                              }}
+                              className="wiki-link"
+                              {...(rest as any)}
+                            >
+                              {children}
+                            </a>
+                          </WikiLinkMenu>
                         );
                       }
                       if (h.startsWith("#kiwi-missing:")) {
                         const target = h.slice("#kiwi-missing:".length);
+                        const missingPath = `${target}.md`;
                         return (
-                          <a
-                            href="#"
-                            onClick={(e) => {
-                              e.preventDefault();
-                              onNavigate(`${target}.md`);
-                            }}
-                            title={`Missing: ${target} — click to create`}
-                            className="wiki-link-missing"
-                            {...(rest as any)}
+                          <WikiLinkMenu
+                            pagePath={missingPath}
+                            onNavigate={onNavigate}
+                            onOpenInSplitView={onOpenInSplitView}
                           >
-                            {children}
-                          </a>
+                            <a
+                              href="#"
+                              onClick={(e) => {
+                                e.preventDefault();
+                                onNavigate(missingPath);
+                              }}
+                              title={`Missing: ${target} — click to create`}
+                              className="wiki-link-missing"
+                              {...(rest as any)}
+                            >
+                              {children}
+                            </a>
+                          </WikiLinkMenu>
                         );
                       }
                       if (h.startsWith("#")) {
@@ -1505,3 +1534,30 @@ function frontmatterBadges(
   }
   return out;
 }
+
+function WikiLinkMenu({
+  pagePath,
+  onNavigate,
+  onOpenInSplitView,
+  children,
+}: {
+  pagePath: string;
+  onNavigate: (path: string) => void;
+  onOpenInSplitView?: (path: string) => void;
+  children: React.ReactElement;
+}) {
+  if (!onOpenInSplitView) return children;
+  return (
+    <ContextMenu>
+      <ContextMenuTrigger asChild>{children}</ContextMenuTrigger>
+      <ContextMenuContent>
+        <ContextMenuItem onClick={() => onNavigate(pagePath)}>
+          Open
+        </ContextMenuItem>
+        <ContextMenuItem onClick={() => onOpenInSplitView(pagePath)}>
+          Open in Split View
+        </ContextMenuItem>
+      </ContextMenuContent>
+    </ContextMenu>
+  );
+}
diff --git a/ui/src/components/KiwiSplitView.tsx b/ui/src/components/KiwiSplitView.tsx
new file mode 100644
index 00000000..081246db
--- /dev/null
+++ b/ui/src/components/KiwiSplitView.tsx
@@ -0,0 +1,184 @@
+import { X } from "lucide-react";
+import type { TreeEntry } from "@kw/lib/api";
+import { KiwiPage } from "./KiwiPage";
+import { Button } from "@kw/components/ui/button";
+import {
+  ResizableHandle,
+  ResizablePanel,
+  ResizablePanelGroup,
+} from "@kw/components/ui/resizable";
+import type { SplitPaneVersion, SplitViewState } from "@kw/lib/splitView";
+import { splitViewHasSecondary } from "@kw/lib/splitView";
+
+type PaneCallbacks = {
+  onEdit: () => void;
+  onHistory?: () => void;
+  onRevealInTree?: () => void;
+  onToggleStar?: () => void;
+  isStarred?: boolean;
+  onTogglePin?: () => void;
+  isPinned?: boolean;
+  onDeleted?: () => void;
+  onDuplicated?: (newPath: string) => void;
+  onMoved?: (newPath: string) => void;
+  onTagClick?: (tag: string) => void;
+  onPublishedChanged?: () => void;
+};
+
+type Props = {
+  tree: TreeEntry | null;
+  leftPath: string;
+  splitView: SplitViewState;
+  refreshKey: number;
+  onLeftNavigate: (path: string) => void;
+  onRightNavigate: (path: string) => void;
+  onOpenInSplitView: (path: string) => void;
+  onSizesChange: (sizes: [number, number]) => void;
+  onCloseSecondary: () => void;
+  leftPane: PaneCallbacks;
+  rightPane: PaneCallbacks;
+};
+
+function SplitPaneHeader({
+  label,
+  onClose,
+}: {
+  label: string;
+  onClose?: () => void;
+}) {
+  return (
+    <div className="flex items-center justify-between gap-2 border-b border-border px-3 py-1.5 bg-muted/30 shrink-0">
+      <span className="text-xs font-medium text-muted-foreground truncate">{label}</span>
+      {onClose && (
+        <Button
+          variant="ghost"
+          size="icon"
+          className="h-6 w-6 shrink-0"
+          aria-label="Close secondary pane"
+          onClick={onClose}
+        >
+          <X className="h-3.5 w-3.5" />
+        </Button>
+      )}
+    </div>
+  );
+}
+
+function SecondaryPlaceholder() {
+  return (
+    <div className="flex h-full items-center justify-center p-6 text-sm text-muted-foreground text-center">
+      Right-click a page or wiki-link and choose &ldquo;Open in Split View&rdquo;, or navigate from this pane.
+    </div>
+  );
+}
+
+export function KiwiSplitView({
+  tree,
+  leftPath,
+  splitView,
+  refreshKey,
+  onLeftNavigate,
+  onRightNavigate,
+  onOpenInSplitView,
+  onSizesChange,
+  onCloseSecondary,
+  leftPane,
+  rightPane,
+}: Props) {
+  const hasSecondary = splitViewHasSecondary(splitView);
+  const rightPath = splitView.rightPath;
+  const rightVersion = splitView.rightVersion;
+
+  const renderPage = (
+    path: string,
+    onNavigate: (p: string) => void,
+    pane: PaneCallbacks,
+    version?: SplitPaneVersion | null,
+  ) => (
+    <KiwiPage
+      path={path}
+      tree={tree}
+      onNavigate={onNavigate}
+      onOpenInSplitView={onOpenInSplitView}
+      versionHash={version?.hash}
+      readOnly={Boolean(version)}
+      onEdit={pane.onEdit}
+      onHistory={pane.onHistory}
+      onRevealInTree={pane.onRevealInTree}
+      onToggleStar={pane.onToggleStar}
+      isStarred={pane.isStarred}
+      onTogglePin={pane.onTogglePin}
+      isPinned={pane.isPinned}
+      onDeleted={pane.onDeleted}
+      onDuplicated={pane.onDuplicated}
+      onMoved={pane.onMoved}
+      onTagClick={pane.onTagClick}
+      refreshKey={refreshKey}
+      onPublishedChanged={pane.onPublishedChanged}
+    />
+  );
+
+  return (
+    <ResizablePanelGroup
+      direction="horizontal"
+      className="h-full"
+      onLayout={(sizes) => {
+        if (sizes.length === 2) {
+          onSizesChange([sizes[0], sizes[1]]);
+        }
+      }}
+    >
+      <ResizablePanel
+        index={0}
+        defaultSize={splitView.sizes[0]}
+        className="flex flex-col min-h-0"
+      >
+        <SplitPaneHeader label="Primary" />
+        <div className="flex-1 min-h-0 overflow-auto kiwi-scroll">
+          {renderPage(leftPath, onLeftNavigate, leftPane)}
+        </div>
+      </ResizablePanel>
+
+      <ResizableHandle withHandle />
+
+      <ResizablePanel
+        index={1}
+        defaultSize={splitView.sizes[1]}
+        className="flex flex-col min-h-0"
+      >
+        <SplitPaneHeader
+          label={
+            rightVersion
+              ? `Version ${rightVersion.hash.slice(0, 7)}`
+              : rightPath ?? "Secondary"
+          }
+          onClose={onCloseSecondary}
+        />
+        <div className="flex-1 min-h-0 overflow-auto kiwi-scroll">
+          {!hasSecondary ? (
+            <SecondaryPlaceholder />
+          ) : rightVersion ? (
+            renderPage(rightVersion.path, onRightNavigate, rightPane, rightVersion)
+          ) : rightPath ? (
+            renderPage(rightPath, onRightNavigate, rightPane)
+          ) : (
+            <SecondaryPlaceholder />
+          )}
+        </div>
+      </ResizablePanel>
+    </ResizablePanelGroup>
+  );
+}
+
+export function SplitViewMobileNotice({ onDismiss }: { onDismiss: () => void }) {
+  return (
+    <div className="flex h-full flex-col items-center justify-center gap-4 p-8 text-center">
+      <p className="text-sm text-muted-foreground max-w-sm">
+        Split view is not available on mobile viewports. Widen the window or use a desktop browser.
+      </p>
+      <Button variant="outline" size="sm" onClick={onDismiss}>
+        Dismiss
+      </Button>
+    </div>
+  );
+}
diff --git a/ui/src/components/KiwiTree.tsx b/ui/src/components/KiwiTree.tsx
index fc567c20..f4676604 100644
--- a/ui/src/components/KiwiTree.tsx
+++ b/ui/src/components/KiwiTree.tsx
@@ -28,6 +28,7 @@ import {
 } from "@kw/lib/treeClipboard";
 import {
   ChevronRight,
+  Columns2,
   Copy,
   File,
   FileAxis3D,
@@ -91,6 +92,7 @@ type Props = {
   autoReveal?: boolean;
   publishedPaths?: Set<string>;
   onPublishedChanged?: () => void;
+  onOpenInSplitView?: (path: string) => void;
 };
 
 export type KiwiTreeHandle = {
@@ -220,6 +222,7 @@ export const KiwiTree = forwardRef<KiwiTreeHandle, Props>(function KiwiTree(
     autoReveal = true,
     publishedPaths,
     onPublishedChanged,
+    onOpenInSplitView,
   },
   ref,
 ) {
@@ -873,6 +876,7 @@ export const KiwiTree = forwardRef<KiwiTreeHandle, Props>(function KiwiTree(
             onFolderAltClick={(data) => openFolderRecursive(treeRef.current, data)}
             publishedPaths={publishedPaths}
             onPublishedChanged={onPublishedChanged}
+            onOpenInSplitView={onOpenInSplitView}
           />
         )}
       </Tree>
@@ -906,6 +910,7 @@ type TreeNodeProps = NodeRendererProps<FlatNode> & {
   onFolderAltClick: (data: FlatNode) => void;
   publishedPaths?: Set<string>;
   onPublishedChanged?: () => void;
+  onOpenInSplitView?: (path: string) => void;
 };
 
 function FrontmatterWarning({ path, error }: { path: string; error?: string }) {
@@ -942,6 +947,7 @@ function TreeNode({
   onFolderAltClick,
   publishedPaths,
   onPublishedChanged,
+  onOpenInSplitView,
 }: TreeNodeProps) {
   const path = node.id;
   const isActive = activePath === path;
@@ -1520,6 +1526,12 @@ function TreeNode({
           <File className="h-3.5 w-3.5" />
           Open
         </ContextMenuItem>
+        {onOpenInSplitView && isMarkdown(path) && (
+          <ContextMenuItem onClick={() => onOpenInSplitView(path)}>
+            <Columns2 className="h-3.5 w-3.5" />
+            Open in Split View
+          </ContextMenuItem>
+        )}
         <ContextMenuSeparator />
         {isPublished ? (
           <>
diff --git a/ui/src/components/ui/resizable.tsx b/ui/src/components/ui/resizable.tsx
new file mode 100644
index 00000000..178098f2
--- /dev/null
+++ b/ui/src/components/ui/resizable.tsx
@@ -0,0 +1,193 @@
+/**
+ * shadcn-compatible resizable panels (react-resizable-panels API surface).
+ * Uses pointer-drag resize like the sidebar handle when the package is unavailable.
+ */
+import * as React from "react";
+import { GripVertical } from "lucide-react";
+import { cn } from "@kw/lib/cn";
+
+type Direction = "horizontal" | "vertical";
+
+type PanelGroupContextValue = {
+  direction: Direction;
+  sizes: number[];
+  setSizes: (sizes: number[]) => void;
+  registerPanel: (index: number, defaultSize: number) => void;
+  panelCount: number;
+};
+
+const PanelGroupContext = React.createContext<PanelGroupContextValue | null>(null);
+
+type PanelGroupProps = React.HTMLAttributes<HTMLDivElement> & {
+  direction?: Direction;
+  onLayout?: (sizes: number[]) => void;
+};
+
+function ResizablePanelGroup({
+  className,
+  direction = "horizontal",
+  onLayout,
+  children,
+  ...props
+}: PanelGroupProps) {
+  const childArray = React.Children.toArray(children);
+  const panelDefaults = React.useRef<number[]>([]);
+  const [sizes, setSizesState] = React.useState<number[]>([]);
+
+  const setSizes = React.useCallback(
+    (next: number[]) => {
+      setSizesState(next);
+      onLayout?.(next);
+    },
+    [onLayout],
+  );
+
+  const registerPanel = React.useCallback((index: number, defaultSize: number) => {
+    panelDefaults.current[index] = defaultSize;
+    setSizesState((prev) => {
+      if (prev.length >= panelDefaults.current.filter(Boolean).length) return prev;
+      const total = panelDefaults.current.reduce((sum, v) => sum + (v ?? 0), 0);
+      if (total <= 0) return prev;
+      return panelDefaults.current.map((v) => ((v ?? 0) / total) * 100);
+    });
+  }, []);
+
+  const value = React.useMemo(
+    () => ({
+      direction,
+      sizes,
+      setSizes,
+      registerPanel,
+      panelCount: childArray.filter((child) =>
+        React.isValidElement(child) && (child.type as { displayName?: string }).displayName === "ResizablePanel",
+      ).length,
+    }),
+    [direction, sizes, setSizes, registerPanel, childArray],
+  );
+
+  return (
+    <PanelGroupContext.Provider value={value}>
+      <div
+        className={cn(
+          "flex h-full w-full",
+          direction === "vertical" && "flex-col",
+          className,
+        )}
+        data-panel-group-direction={direction}
+        {...props}
+      >
+        {children}
+      </div>
+    </PanelGroupContext.Provider>
+  );
+}
+
+type PanelProps = React.HTMLAttributes<HTMLDivElement> & {
+  defaultSize?: number;
+  minSize?: number;
+  index?: number;
+};
+
+function ResizablePanel({
+  className,
+  defaultSize = 50,
+  minSize = 15,
+  index = 0,
+  style,
+  ...props
+}: PanelProps) {
+  const ctx = React.useContext(PanelGroupContext);
+  if (!ctx) throw new Error("ResizablePanel must be used within ResizablePanelGroup");
+
+  React.useEffect(() => {
+    ctx.registerPanel(index, defaultSize);
+  }, [ctx, index, defaultSize]);
+
+  const size = ctx.sizes[index] ?? defaultSize;
+  const flexBasis = `${size}%`;
+
+  return (
+    <div
+      className={cn("min-h-0 min-w-0 overflow-hidden", className)}
+      style={{
+        flexBasis,
+        flexGrow: 0,
+        flexShrink: 0,
+        minWidth: ctx.direction === "horizontal" ? `${minSize}%` : undefined,
+        minHeight: ctx.direction === "vertical" ? `${minSize}%` : undefined,
+        ...style,
+      }}
+      data-panel-index={index}
+      {...props}
+    />
+  );
+}
+ResizablePanel.displayName = "ResizablePanel";
+
+type HandleProps = React.HTMLAttributes<HTMLDivElement> & {
+  withHandle?: boolean;
+  panelIndex?: number;
+};
+
+function ResizableHandle({
+  className,
+  withHandle,
+  panelIndex = 0,
+  ...props
+}: HandleProps) {
+  const ctx = React.useContext(PanelGroupContext);
+  if (!ctx) throw new Error("ResizableHandle must be used within ResizablePanelGroup");
+
+  const onMouseDown = (e: React.MouseEvent) => {
+    e.preventDefault();
+    const group = (e.currentTarget as HTMLElement).parentElement;
+    if (!group) return;
+    const rect = group.getBoundingClientRect();
+    const isHorizontal = ctx.direction === "horizontal";
+    const start = isHorizontal ? e.clientX : e.clientY;
+    const total = isHorizontal ? rect.width : rect.height;
+    const startSizes = [...ctx.sizes];
+
+    const onMove = (ev: MouseEvent) => {
+      const delta = (isHorizontal ? ev.clientX : ev.clientY) - start;
+      const deltaPercent = (delta / total) * 100;
+      const left = Math.max(15, Math.min(85, (startSizes[panelIndex] ?? 50) + deltaPercent));
+      const right = 100 - left;
+      ctx.setSizes([left, right]);
+    };
+
+    const onUp = () => {
+      document.removeEventListener("mousemove", onMove);
+      document.removeEventListener("mouseup", onUp);
+    };
+
+    document.addEventListener("mousemove", onMove);
+    document.addEventListener("mouseup", onUp);
+  };
+
+  return (
+    <div
+      role="separator"
+      aria-orientation={ctx.direction === "horizontal" ? "vertical" : "horizontal"}
+      className={cn(
+        "relative flex shrink-0 items-center justify-center bg-border",
+        ctx.direction === "horizontal" ? "w-px cursor-col-resize" : "h-px cursor-row-resize",
+        "after:absolute after:bg-border/80",
+        ctx.direction === "horizontal"
+          ? "after:inset-y-0 after:left-1/2 after:w-1 after:-translate-x-1/2"
+          : "after:inset-x-0 after:top-1/2 after:h-1 after:-translate-y-1/2",
+        className,
+      )}
+      onMouseDown={onMouseDown}
+      {...props}
+    >
+      {withHandle && (
+        <div className="z-10 flex h-4 w-3 items-center justify-center rounded-sm border bg-border">
+          <GripVertical className="h-2.5 w-2.5" />
+        </div>
+      )}
+    </div>
+  );
+}
+
+export { ResizablePanelGroup, ResizablePanel, ResizableHandle };
diff --git a/ui/src/lib/kiwiKeybindings.test.ts b/ui/src/lib/kiwiKeybindings.test.ts
index ec8f4c94..48c755cc 100644
--- a/ui/src/lib/kiwiKeybindings.test.ts
+++ b/ui/src/lib/kiwiKeybindings.test.ts
@@ -29,6 +29,18 @@ describe("eventMatchesChord", () => {
     expect(eventMatchesChord(e, "Mod+K")).toBe(true);
   });
 
+  it("matches backslash split-view shortcut", () => {
+    const e = {
+      key: "\\",
+      ctrlKey: true,
+      metaKey: false,
+      shiftKey: false,
+      altKey: false,
+    } as KeyboardEvent;
+    expect(eventMatchesChord(e, "mod+\\")).toBe(true);
+    expect(normalizeChord("Mod+\\")).toBe("mod+\\");
+  });
+
   it("matches help shortcut on slash and question mark", () => {
     const slash = {
       key: "/",
@@ -53,6 +65,7 @@ describe("mergeKeybindings", () => {
   it("keeps defaults when config is empty", () => {
     const merged = mergeKeybindings(null);
     expect(merged.search).toBe(DEFAULT_KEYBINDINGS.search);
+    expect(merged.toggle_split_view).toBe("mod+\\");
   });
 
   it("applies server overrides", () => {
diff --git a/ui/src/lib/kiwiKeybindings.ts b/ui/src/lib/kiwiKeybindings.ts
index 6c6bc94a..b758d056 100644
--- a/ui/src/lib/kiwiKeybindings.ts
+++ b/ui/src/lib/kiwiKeybindings.ts
@@ -19,7 +19,8 @@ export type KeybindingAction =
   | "shortcuts_help"
   | "undo"
   | "focus_tree_filter"
-  | "close_overlay";
+  | "close_overlay"
+  | "toggle_split_view";
 
 export type ParsedChord = {
   mod: boolean;
@@ -54,6 +55,7 @@ export const DEFAULT_KEYBINDINGS: Record<KeybindingAction, string> = {
   undo: "mod+z",
   focus_tree_filter: "mod+alt+f",
   close_overlay: "escape",
+  toggle_split_view: "mod+\\",
 };
 
 export function normalizeChord(chord: string): string {
@@ -89,6 +91,10 @@ export function normalizeChord(chord: string): string {
       case "question":
         key = "?";
         break;
+      case "backslash":
+      case "\\":
+        key = "\\";
+        break;
       default:
         key = part.length === 1 ? part : part;
     }
@@ -126,6 +132,9 @@ export function eventMatchesChord(e: KeyboardEvent, chord: string): boolean {
     return eventKey === "/" || eventKey === "slash" || eventKey === "?";
   }
   if (parsed.key === "?") return eventKey === "?" || (e.shiftKey && eventKey === "/");
+  if (parsed.key === "\\") {
+    return eventKey === "\\" || eventKey === "backslash";
+  }
   return eventKey === parsed.key;
 }
 
@@ -176,6 +185,7 @@ export const SHORTCUT_SECTIONS: ShortcutSection[] = [
       { action: "new_page", label: "New page" },
       { action: "toggle_editor", label: "Toggle editor" },
       { action: "toggle_sidebar", label: "Toggle sidebar" },
+      { action: "toggle_split_view", label: "Toggle split view" },
       { action: "shortcuts_help", label: "Keyboard shortcuts" },
     ],
   },
diff --git a/ui/src/lib/splitView.test.ts b/ui/src/lib/splitView.test.ts
new file mode 100644
index 00000000..f76f4d2e
--- /dev/null
+++ b/ui/src/lib/splitView.test.ts
@@ -0,0 +1,90 @@
+import { describe, expect, it, beforeEach, afterEach, vi } from "vitest";
+import {
+  SPLIT_VIEW_SESSION_KEY,
+  clearSplitViewState,
+  closeSecondaryPane,
+  createSplitViewState,
+  loadSplitViewState,
+  openPathInSplit,
+  openVersionInSplit,
+  saveSplitViewState,
+  splitViewHasSecondary,
+  toggleSplitView,
+  clampSplitSizes,
+} from "./splitView";
+
+describe("splitView", () => {
+  const storage = new Map<string, string>();
+
+  beforeEach(() => {
+    storage.clear();
+    vi.stubGlobal("sessionStorage", {
+      getItem: (key: string) => storage.get(key) ?? null,
+      setItem: (key: string, value: string) => {
+        storage.set(key, value);
+      },
+      removeItem: (key: string) => {
+        storage.delete(key);
+      },
+      clear: () => storage.clear(),
+    });
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it("persists and restores split state", () => {
+    const state = openPathInSplit(createSplitViewState(), "notes/b.md");
+    saveSplitViewState(state);
+    expect(loadSplitViewState()).toEqual(state);
+  });
+
+  it("ignores invalid session payloads", () => {
+    storage.set(SPLIT_VIEW_SESSION_KEY, "{not json");
+    expect(loadSplitViewState()).toBeNull();
+    storage.set(SPLIT_VIEW_SESSION_KEY, JSON.stringify({ enabled: true, sizes: [0, 0] }));
+    expect(loadSplitViewState()?.sizes).toEqual([50, 50]);
+  });
+
+  it("opens a page in the secondary pane", () => {
+    const next = openPathInSplit(createSplitViewState(), "a.md");
+    expect(next.enabled).toBe(true);
+    expect(next.rightPath).toBe("a.md");
+    expect(next.rightVersion).toBeNull();
+    expect(splitViewHasSecondary(next)).toBe(true);
+  });
+
+  it("opens a historical version in the secondary pane", () => {
+    const next = openVersionInSplit(createSplitViewState(), { path: "a.md", hash: "abc123" });
+    expect(next.rightPath).toBeNull();
+    expect(next.rightVersion).toEqual({ path: "a.md", hash: "abc123" });
+  });
+
+  it("toggles split view on and off", () => {
+    const off = createSplitViewState();
+    const on = toggleSplitView(off, "page.md");
+    expect(on.enabled).toBe(true);
+    expect(on.rightPath).toBe("page.md");
+    const offAgain = toggleSplitView(on, "page.md");
+    expect(offAgain.enabled).toBe(false);
+  });
+
+  it("does not enable split without an active page", () => {
+    const state = toggleSplitView(createSplitViewState(), null);
+    expect(state.enabled).toBe(false);
+  });
+
+  it("clears secondary pane content", () => {
+    const state = openVersionInSplit(createSplitViewState(), { path: "a.md", hash: "deadbeef" });
+    const cleared = closeSecondaryPane(state);
+    expect(cleared.enabled).toBe(true);
+    expect(splitViewHasSecondary(cleared)).toBe(false);
+  });
+
+  it("clamps resize percentages", () => {
+    expect(clampSplitSizes(10)).toEqual([20, 80]);
+    expect(clampSplitSizes(90)).toEqual([80, 20]);
+    expect(clampSplitSizes(55)).toEqual([55, 45]);
+  });
+});
diff --git a/ui/src/lib/splitView.ts b/ui/src/lib/splitView.ts
new file mode 100644
index 00000000..39d95804
--- /dev/null
+++ b/ui/src/lib/splitView.ts
@@ -0,0 +1,145 @@
+/**
+ * Split-view state helpers — persisted in sessionStorage per tab.
+ */
+
+export const SPLIT_VIEW_SESSION_KEY = "kiwifs-split-view";
+
+export type SplitPaneVersion = {
+  path: string;
+  hash: string;
+};
+
+export type SplitViewState = {
+  enabled: boolean;
+  rightPath: string | null;
+  rightVersion: SplitPaneVersion | null;
+  /** Percent widths for [left, right] panes. */
+  sizes: [number, number];
+};
+
+export const DEFAULT_SPLIT_SIZES: [number, number] = [50, 50];
+
+export function createSplitViewState(
+  overrides: Partial<SplitViewState> = {},
+): SplitViewState {
+  return {
+    enabled: false,
+    rightPath: null,
+    rightVersion: null,
+    sizes: DEFAULT_SPLIT_SIZES,
+    ...overrides,
+  };
+}
+
+export function loadSplitViewState(): SplitViewState | null {
+  if (typeof sessionStorage === "undefined") return null;
+  try {
+    const raw = sessionStorage.getItem(SPLIT_VIEW_SESSION_KEY);
+    if (!raw) return null;
+    const parsed = JSON.parse(raw) as Partial<SplitViewState>;
+    if (typeof parsed !== "object" || parsed == null) return null;
+    const sizes = parsed.sizes;
+    const normalizedSizes: [number, number] =
+      Array.isArray(sizes)
+      && sizes.length === 2
+      && typeof sizes[0] === "number"
+      && typeof sizes[1] === "number"
+      && sizes[0] > 0
+      && sizes[1] > 0
+        ? [sizes[0], sizes[1]]
+        : DEFAULT_SPLIT_SIZES;
+    return createSplitViewState({
+      enabled: Boolean(parsed.enabled),
+      rightPath: typeof parsed.rightPath === "string" ? parsed.rightPath : null,
+      rightVersion:
+        parsed.rightVersion
+        && typeof parsed.rightVersion.path === "string"
+        && typeof parsed.rightVersion.hash === "string"
+          ? { path: parsed.rightVersion.path, hash: parsed.rightVersion.hash }
+          : null,
+      sizes: normalizedSizes,
+    });
+  } catch {
+    return null;
+  }
+}
+
+export function saveSplitViewState(state: SplitViewState): void {
+  if (typeof sessionStorage === "undefined") return;
+  try {
+    sessionStorage.setItem(SPLIT_VIEW_SESSION_KEY, JSON.stringify(state));
+  } catch {
+    // ignore quota / private mode errors
+  }
+}
+
+export function clearSplitViewState(): void {
+  if (typeof sessionStorage === "undefined") return;
+  try {
+    sessionStorage.removeItem(SPLIT_VIEW_SESSION_KEY);
+  } catch {
+    // ignore
+  }
+}
+
+/** Whether the right pane has content to render. */
+export function splitViewHasSecondary(state: SplitViewState): boolean {
+  return Boolean(state.rightPath || state.rightVersion);
+}
+
+export function openPathInSplit(
+  state: SplitViewState,
+  rightPath: string,
+): SplitViewState {
+  return {
+    ...state,
+    enabled: true,
+    rightPath,
+    rightVersion: null,
+  };
+}
+
+export function openVersionInSplit(
+  state: SplitViewState,
+  version: SplitPaneVersion,
+): SplitViewState {
+  return {
+    ...state,
+    enabled: true,
+    rightPath: null,
+    rightVersion: version,
+  };
+}
+
+export function toggleSplitView(
+  state: SplitViewState,
+  activePath: string | null,
+): SplitViewState {
+  if (state.enabled) {
+    return createSplitViewState({ sizes: state.sizes });
+  }
+  if (!activePath) return state;
+  return {
+    enabled: true,
+    rightPath: activePath,
+    rightVersion: null,
+    sizes: state.sizes,
+  };
+}
+
+export function closeSecondaryPane(state: SplitViewState): SplitViewState {
+  return {
+    ...state,
+    rightPath: null,
+    rightVersion: null,
+  };
+}
+
+export function clampSplitSizes(
+  leftPercent: number,
+  min = 20,
+  max = 80,
+): [number, number] {
+  const clamped = Math.max(min, Math.min(max, leftPercent));
+  return [clamped, 100 - clamped];
+}

From 1d7ce9ab077376d75c3218c5cf7c84962722f578 Mon Sep 17 00:00:00 2001
From: Array Fleet <fleet@advancedresearcharray.local>
Date: Tue, 30 Jun 2026 07:07:46 +0000
Subject: [PATCH 2/9] fix(ui): remove unused import in splitView test

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 ui/src/lib/splitView.test.ts | 1 -
 1 file changed, 1 deletion(-)

diff --git a/ui/src/lib/splitView.test.ts b/ui/src/lib/splitView.test.ts
index f76f4d2e..d9ff2a93 100644
--- a/ui/src/lib/splitView.test.ts
+++ b/ui/src/lib/splitView.test.ts
@@ -1,7 +1,6 @@
 import { describe, expect, it, beforeEach, afterEach, vi } from "vitest";
 import {
   SPLIT_VIEW_SESSION_KEY,
-  clearSplitViewState,
   closeSecondaryPane,
   createSplitViewState,
   loadSplitViewState,

From 011c63b8953c1ea9a438c4dfae778a1cd5efaa55 Mon Sep 17 00:00:00 2001
From: Array Fleet <fleet@advancedresearcharray.local>
Date: Tue, 30 Jun 2026 07:13:39 +0000
Subject: [PATCH 3/9] fix(ui): harden split view close and secondary pane
 actions

Make secondary pane close fully exit split view, wire history and file
actions to the correct pane path, and enable split layout when opening
from the tree with no active page.

Closes #426

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 .../2026-06-30-issue-426-split-view.md        |  9 ++--
 ui/src/App.tsx                                | 51 ++++++++++++++++---
 ui/src/lib/splitView.test.ts                  |  5 +-
 ui/src/lib/splitView.ts                       |  6 +--
 4 files changed, 54 insertions(+), 17 deletions(-)

diff --git a/episodes/agents/cursor-fleet/2026-06-30-issue-426-split-view.md b/episodes/agents/cursor-fleet/2026-06-30-issue-426-split-view.md
index ab07dabb..7ac9c698 100644
--- a/episodes/agents/cursor-fleet/2026-06-30-issue-426-split-view.md
+++ b/episodes/agents/cursor-fleet/2026-06-30-issue-426-split-view.md
@@ -21,13 +21,14 @@ Implement kiwifs/kiwifs#426 — side-by-side page view with tree/wiki-link menus
 5. Registered `toggle_split_view` in Go + TS keybindings with backslash normalization.
 6. Kiwi MCP gateway at `192.168.167.240:3333` unreachable — updated local fix doc under `pages/fixes/`.
 
-## Verification
+## Verification (hands-on delivery)
 
 - `npm test -- src/lib/splitView.test.ts src/lib/kiwiKeybindings.test.ts` → 17 passed
-- `npm test` (full UI suite) → 198 passed
-- `go test ./internal/keybindings/...` → ok
-- Removed duplicate `WikiLinkMenu` and unrelated template commit from branch
+- `go test ./internal/keybindings/... -count=1` → ok
+- Reverted unrelated workspace template commit from branch
+- Fix: secondary pane × fully exits split view (preserves pane sizes)
 - Fix doc: `pages/fixes/kiwifs-kiwifs/issue-426-split-side-by-side-page-view.md`
+- Kiwi MCP gateway at `192.168.167.240:3333` unreachable — local fix doc only
 
 ## Handoff
 
diff --git a/ui/src/App.tsx b/ui/src/App.tsx
index c59a504c..626ff12d 100644
--- a/ui/src/App.tsx
+++ b/ui/src/App.tsx
@@ -100,6 +100,7 @@ export default function App() {
   const [newFolder, setNewFolder] = useState<string | undefined>();
   const [graphOpen, setGraphOpen] = useState(false);
   const [historyOpen, setHistoryOpen] = useState(false);
+  const [historyPath, setHistoryPath] = useState<string | null>(null);
   const [dataOpen, setDataOpen] = useState(false);
   const [shortcutsOpen, setShortcutsOpen] = useState(false);
   const [basesOpen, setBasesOpen] = useState(false);
@@ -165,6 +166,11 @@ export default function App() {
     }
     if (!activePath) {
       setActivePath(path);
+      setSplitView((prev) => ({ ...createSplitViewState({ sizes: prev.sizes }), enabled: true }));
+      return;
+    }
+    if (activePath === path) {
+      setSplitView((prev) => ({ ...createSplitViewState({ sizes: prev.sizes }), enabled: true }));
       return;
     }
     setSplitView((prev) => openPathInSplit(prev, path));
@@ -929,10 +935,13 @@ const handleSpaceSwitch = useCallback(() => {
                 }}
                 onClose={() => setGraphOpen(false)}
               />
-            ) : historyOpen && activePath ? (
+            ) : historyOpen && (historyPath ?? activePath) ? (
               <KiwiHistory
-                path={activePath}
-                onClose={() => setHistoryOpen(false)}
+                path={historyPath ?? activePath!}
+                onClose={() => {
+                  setHistoryOpen(false);
+                  setHistoryPath(null);
+                }}
                 onRestored={() => setRefreshKey((k) => k + 1)}
                 onCompareWithCurrent={handleCompareWithCurrent}
               />
@@ -965,7 +974,10 @@ const handleSpaceSwitch = useCallback(() => {
                 onCloseSecondary={handleCloseSecondaryPane}
                 leftPane={{
                   onEdit: () => setEditing(true),
-                  onHistory: () => setHistoryOpen(true),
+                  onHistory: () => {
+                    setHistoryPath(activePath);
+                    setHistoryOpen(true);
+                  },
                   onRevealInTree: revealActivePageInTree,
                   onToggleStar: () => toggleStar(activePath),
                   isStarred: isStarred(activePath),
@@ -995,7 +1007,11 @@ const handleSpaceSwitch = useCallback(() => {
                     setActivePath(target);
                     setEditing(true);
                   },
-                  onHistory: () => setHistoryOpen(true),
+                  onHistory: () => {
+                    const target = splitView.rightPath ?? splitView.rightVersion?.path ?? activePath;
+                    setHistoryPath(target);
+                    setHistoryOpen(true);
+                  },
                   onToggleStar: splitView.rightPath
                     ? () => toggleStar(splitView.rightPath!)
                     : undefined,
@@ -1004,6 +1020,26 @@ const handleSpaceSwitch = useCallback(() => {
                     ? () => togglePin(splitView.rightPath!)
                     : undefined,
                   isPinned: splitView.rightPath ? isPinned(splitView.rightPath) : false,
+                  onDeleted: () => {
+                    setSplitView((prev) => closeSecondaryPane(prev));
+                    setRefreshKey((k) => k + 1);
+                  },
+                  onDuplicated: (p) => {
+                    setSplitView((prev) => ({
+                      ...prev,
+                      rightPath: p,
+                      rightVersion: null,
+                    }));
+                    setRefreshKey((k) => k + 1);
+                  },
+                  onMoved: (p) => {
+                    setSplitView((prev) => ({
+                      ...prev,
+                      rightPath: p,
+                      rightVersion: null,
+                    }));
+                    setRefreshKey((k) => k + 1);
+                  },
                   onTagClick: (tag) => {
                     setSearchQuery(`tag:${tag}`);
                     setSearchOpen(true);
@@ -1018,7 +1054,10 @@ const handleSpaceSwitch = useCallback(() => {
                 onNavigate={navigate}
                 onOpenInSplitView={handleOpenInSplitView}
                 onEdit={() => setEditing(true)}
-                onHistory={() => setHistoryOpen(true)}
+                onHistory={() => {
+                  setHistoryPath(activePath);
+                  setHistoryOpen(true);
+                }}
                 onRevealInTree={revealActivePageInTree}
                 onToggleStar={() => toggleStar(activePath)}
                 isStarred={isStarred(activePath)}
diff --git a/ui/src/lib/splitView.test.ts b/ui/src/lib/splitView.test.ts
index d9ff2a93..a321b2a9 100644
--- a/ui/src/lib/splitView.test.ts
+++ b/ui/src/lib/splitView.test.ts
@@ -74,11 +74,12 @@ describe("splitView", () => {
     expect(state.enabled).toBe(false);
   });
 
-  it("clears secondary pane content", () => {
+  it("closes split view from the secondary pane", () => {
     const state = openVersionInSplit(createSplitViewState(), { path: "a.md", hash: "deadbeef" });
     const cleared = closeSecondaryPane(state);
-    expect(cleared.enabled).toBe(true);
+    expect(cleared.enabled).toBe(false);
     expect(splitViewHasSecondary(cleared)).toBe(false);
+    expect(cleared.sizes).toEqual(state.sizes);
   });
 
   it("clamps resize percentages", () => {
diff --git a/ui/src/lib/splitView.ts b/ui/src/lib/splitView.ts
index 39d95804..e8b98f08 100644
--- a/ui/src/lib/splitView.ts
+++ b/ui/src/lib/splitView.ts
@@ -128,11 +128,7 @@ export function toggleSplitView(
 }
 
 export function closeSecondaryPane(state: SplitViewState): SplitViewState {
-  return {
-    ...state,
-    rightPath: null,
-    rightVersion: null,
-  };
+  return createSplitViewState({ sizes: state.sizes });
 }
 
 export function clampSplitSizes(

From 496ab2cf885eab9538f07adc1249d7f2f5bea106 Mon Sep 17 00:00:00 2001
From: Array Fleet <fleet@advancedresearcharray.local>
Date: Tue, 30 Jun 2026 07:18:50 +0000
Subject: [PATCH 4/9] test(keybindings): assert toggle_split_view default
 binding

Guards the Mod+\ split-view shortcut in backend defaults alongside
the existing UI regression tests for issue #426.

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 .../2026-06-30-issue-426-split-view.md            | 15 +++++++--------
 internal/keybindings/keybindings_test.go          |  3 +++
 2 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/episodes/agents/cursor-fleet/2026-06-30-issue-426-split-view.md b/episodes/agents/cursor-fleet/2026-06-30-issue-426-split-view.md
index 7ac9c698..7028efcd 100644
--- a/episodes/agents/cursor-fleet/2026-06-30-issue-426-split-view.md
+++ b/episodes/agents/cursor-fleet/2026-06-30-issue-426-split-view.md
@@ -19,17 +19,16 @@ Implement kiwifs/kiwifs#426 — side-by-side page view with tree/wiki-link menus
 3. Built `KiwiSplitView` + self-contained `ui/resizable.tsx` (overlay `node_modules` read-only — skipped `npm install react-resizable-panels`).
 4. Extended `KiwiPage` with `versionHash`/`readOnly` and wiki-link context menu; tree/history entry points.
 5. Registered `toggle_split_view` in Go + TS keybindings with backslash normalization.
-6. Kiwi MCP gateway at `192.168.167.240:3333` unreachable — updated local fix doc under `pages/fixes/`.
+6. Fixed secondary pane × to fully exit split view; wired right-pane star/pin/history to secondary path.
+7. Added Go regression assertion for `toggle_split_view` default binding.
 
-## Verification (hands-on delivery)
+## Verification
 
 - `npm test -- src/lib/splitView.test.ts src/lib/kiwiKeybindings.test.ts` → 17 passed
-- `go test ./internal/keybindings/... -count=1` → ok
-- Reverted unrelated workspace template commit from branch
-- Fix: secondary pane × fully exits split view (preserves pane sizes)
-- Fix doc: `pages/fixes/kiwifs-kiwifs/issue-426-split-side-by-side-page-view.md`
-- Kiwi MCP gateway at `192.168.167.240:3333` unreachable — local fix doc only
+- `npm test` (full UI suite) → 198 passed
+- `go test ./internal/keybindings/... -count=1` → ok (includes `toggle_split_view` default)
+- Kiwi MCP gateway at `192.168.167.240:3333` unreachable — fix doc written locally under `pages/fixes/`
 
 ## Handoff
 
-Push `feat/split-view-426` and open PR closing #426.
+Branch `feat/split-view-426` ready for fleet publish (push + PR closing #426).
diff --git a/internal/keybindings/keybindings_test.go b/internal/keybindings/keybindings_test.go
index 175945b4..98954bf8 100644
--- a/internal/keybindings/keybindings_test.go
+++ b/internal/keybindings/keybindings_test.go
@@ -39,6 +39,9 @@ func TestResolveDefaultsWhenMissing(t *testing.T) {
 	if res.Bindings["search"] != "mod+k" {
 		t.Fatalf("search = %q, want mod+k", res.Bindings["search"])
 	}
+	if res.Bindings["toggle_split_view"] != "mod+\\" {
+		t.Fatalf("toggle_split_view = %q, want mod+\\", res.Bindings["toggle_split_view"])
+	}
 	if len(res.Conflicts) != 0 {
 		t.Fatalf("expected no conflicts, got %+v", res.Conflicts)
 	}

From e224707a0f5d547b59c8a92e6ad6a6df408c02f5 Mon Sep 17 00:00:00 2001
From: Array Fleet <fleet@advancedresearcharray.local>
Date: Tue, 30 Jun 2026 07:22:38 +0000
Subject: [PATCH 5/9] fix(ui): address split view peer review (#426)

Unify key alias normalization in Go/TS, sync split view state when
navigation clears the primary page, and expand toggle_split_view tests.

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 .../2026-06-30-issue-426-peer-review-fixes.md | 31 +++++++++++++
 internal/keybindings/keybindings.go           | 37 +++++++++------
 internal/keybindings/keybindings_test.go      | 23 ++++++++++
 ui/src/App.tsx                                |  6 +++
 ui/src/lib/kiwiKeybindings.test.ts            | 34 ++++++++++++++
 ui/src/lib/kiwiKeybindings.ts                 | 41 +++++++++++------
 ui/src/lib/splitView.test.ts                  | 46 +++++++++++++++++++
 ui/src/lib/splitView.ts                       | 11 +++++
 8 files changed, 200 insertions(+), 29 deletions(-)
 create mode 100644 episodes/agents/cursor-fleet/2026-06-30-issue-426-peer-review-fixes.md

diff --git a/episodes/agents/cursor-fleet/2026-06-30-issue-426-peer-review-fixes.md b/episodes/agents/cursor-fleet/2026-06-30-issue-426-peer-review-fixes.md
new file mode 100644
index 00000000..535919ff
--- /dev/null
+++ b/episodes/agents/cursor-fleet/2026-06-30-issue-426-peer-review-fixes.md
@@ -0,0 +1,31 @@
+---
+memory_kind: episodic
+episode_id: cursor-fleet-2026-06-30-issue-426-peer-review
+title: "Issue #426 peer review fixes — normalizeKey + split view state sync"
+tags: [kiwifs, split-view, peer-review, issue-426]
+date: 2026-06-30
+---
+
+# Issue #426 peer review fixes
+
+## Context
+
+Hands-on takeover after fleet delivery failed peer review on `normalizeKey`, `toggle_split_view` test coverage, and split view state consistency.
+
+## Changes
+
+1. Go `normalizeKey`: alias map for single- and multi-character key names (no redundant len branch).
+2. TS `normalizeKeyPart`: mirrored alias map; `normalizeChord` delegates key tokens to it.
+3. `syncSplitViewWithActivePath` in `splitView.ts`; wired in `App.tsx` + space switch reset.
+4. Expanded tests: 8 new cases in splitView/kiwiKeybindings; `TestNormalizeKey` in Go.
+
+## Test results
+
+```
+cd ui && npm test  → 206 passed
+go test ./internal/keybindings/... -count=1  → ok
+```
+
+## Kiwi MCP
+
+Gateway unreachable (`kiwifs_mcp_invoke: fetch failed`). Fix doc updated locally at `pages/fixes/kiwifs-kiwifs/issue-426-split-side-by-side-page-view.md`.
diff --git a/internal/keybindings/keybindings.go b/internal/keybindings/keybindings.go
index 8d3421e9..a32d22b6 100644
--- a/internal/keybindings/keybindings.go
+++ b/internal/keybindings/keybindings.go
@@ -121,22 +121,31 @@ func NormalizeChord(chord string) (string, error) {
 	return strings.Join(out, "+"), nil
 }
 
+// keyAliases maps common key names (already lowercased) to canonical tokens.
+var keyAliases = map[string]string{
+	"esc":       "escape",
+	"escape":    "escape",
+	"slash":     "/",
+	"/":         "/",
+	"question":  "?",
+	"?":         "?",
+	"backslash": "\\",
+	"\\":        "\\",
+	"enter":     "enter",
+	"return":    "enter",
+	"tab":       "tab",
+	"space":     "space",
+	" ":         "space",
+	"del":       "delete",
+	"delete":    "delete",
+	"backspace": "backspace",
+}
+
 func normalizeKey(key string) string {
-	switch key {
-	case "esc", "escape":
-		return "escape"
-	case "slash", "/":
-		return "/"
-	case "question", "?":
-		return "?"
-	case "backslash", "\\":
-		return "\\"
-	default:
-		if len(key) == 1 {
-			return key
-		}
-		return key
+	if canonical, ok := keyAliases[key]; ok {
+		return canonical
 	}
+	return key
 }
 
 func appendUnique(list []string, item string) []string {
diff --git a/internal/keybindings/keybindings_test.go b/internal/keybindings/keybindings_test.go
index 98954bf8..7a7df89a 100644
--- a/internal/keybindings/keybindings_test.go
+++ b/internal/keybindings/keybindings_test.go
@@ -6,6 +6,29 @@ import (
 	"testing"
 )
 
+func TestNormalizeKey(t *testing.T) {
+	tests := []struct {
+		in   string
+		want string
+	}{
+		{"escape", "escape"},
+		{"esc", "escape"},
+		{"\\", "\\"},
+		{"backslash", "\\"},
+		{"enter", "enter"},
+		{"return", "enter"},
+		{"tab", "tab"},
+		{"k", "k"},
+		{"f1", "f1"},
+	}
+	for _, tc := range tests {
+		got := normalizeKey(tc.in)
+		if got != tc.want {
+			t.Fatalf("normalizeKey(%q) = %q, want %q", tc.in, got, tc.want)
+		}
+	}
+}
+
 func TestNormalizeChord(t *testing.T) {
 	tests := []struct {
 		in   string
diff --git a/ui/src/App.tsx b/ui/src/App.tsx
index 626ff12d..36bf0528 100644
--- a/ui/src/App.tsx
+++ b/ui/src/App.tsx
@@ -72,6 +72,7 @@ import {
   openPathInSplit,
   openVersionInSplit,
   saveSplitViewState,
+  syncSplitViewWithActivePath,
   toggleSplitView,
   type SplitViewState,
 } from "./lib/splitView";
@@ -153,6 +154,10 @@ export default function App() {
     saveSplitViewState(splitView);
   }, [splitView]);
 
+  useEffect(() => {
+    setSplitView((prev) => syncSplitViewWithActivePath(prev, activePath));
+  }, [activePath]);
+
   useEffect(() => {
     if (isMobile && splitView.enabled) {
       setSplitView(createSplitViewState({ sizes: splitView.sizes }));
@@ -525,6 +530,7 @@ export default function App() {
 const handleSpaceSwitch = useCallback(() => {
     setActivePath(null);
     setEditing(false);
+    setSplitView(createSplitViewState());
     setGraphOpen(false);
     setHistoryOpen(false);
     setDataOpen(false);
diff --git a/ui/src/lib/kiwiKeybindings.test.ts b/ui/src/lib/kiwiKeybindings.test.ts
index 48c755cc..2d408f5a 100644
--- a/ui/src/lib/kiwiKeybindings.test.ts
+++ b/ui/src/lib/kiwiKeybindings.test.ts
@@ -7,8 +7,22 @@ import {
   matchBoundAction,
   mergeKeybindings,
   normalizeChord,
+  normalizeKeyPart,
 } from "./kiwiKeybindings";
 
+describe("normalizeKeyPart", () => {
+  it("canonicalizes single- and multi-character key aliases uniformly", () => {
+    expect(normalizeKeyPart("Escape")).toBe("escape");
+    expect(normalizeKeyPart("Backslash")).toBe("\\");
+    expect(normalizeKeyPart("/")).toBe("/");
+    expect(normalizeKeyPart("Enter")).toBe("enter");
+    expect(normalizeKeyPart("Return")).toBe("enter");
+    expect(normalizeKeyPart("Tab")).toBe("tab");
+    expect(normalizeKeyPart("F1")).toBe("f1");
+    expect(normalizeKeyPart("k")).toBe("k");
+  });
+});
+
 describe("normalizeChord", () => {
   it("canonicalizes modifier order and aliases", () => {
     expect(normalizeChord("Ctrl+Shift+B")).toBe("mod+shift+b");
@@ -95,6 +109,26 @@ describe("matchBoundAction", () => {
     } as KeyboardEvent;
     expect(matchBoundAction(e, bindings)).toBe("graph");
   });
+
+  it("matches toggle_split_view via mod+\\ without affecting other bindings", () => {
+    const bindings = mergeKeybindings(null);
+    const splitToggle = {
+      key: "\\",
+      ctrlKey: true,
+      metaKey: false,
+      shiftKey: false,
+      altKey: false,
+    } as KeyboardEvent;
+    const unrelated = {
+      key: "s",
+      ctrlKey: true,
+      metaKey: false,
+      shiftKey: false,
+      altKey: false,
+    } as KeyboardEvent;
+    expect(matchBoundAction(splitToggle, bindings)).toBe("toggle_split_view");
+    expect(matchBoundAction(unrelated, bindings)).toBe("save");
+  });
 });
 
 describe("buildChordIndex", () => {
diff --git a/ui/src/lib/kiwiKeybindings.ts b/ui/src/lib/kiwiKeybindings.ts
index b758d056..d77c1975 100644
--- a/ui/src/lib/kiwiKeybindings.ts
+++ b/ui/src/lib/kiwiKeybindings.ts
@@ -58,6 +58,31 @@ export const DEFAULT_KEYBINDINGS: Record<KeybindingAction, string> = {
   toggle_split_view: "mod+\\",
 };
 
+const KEY_ALIASES: Record<string, string> = {
+  esc: "escape",
+  escape: "escape",
+  slash: "/",
+  "/": "/",
+  question: "?",
+  "?": "?",
+  backslash: "\\",
+  "\\": "\\",
+  enter: "enter",
+  return: "enter",
+  tab: "tab",
+  space: "space",
+  " ": "space",
+  del: "delete",
+  delete: "delete",
+  backspace: "backspace",
+};
+
+/** Canonicalize a single key token (already lowercased). */
+export function normalizeKeyPart(part: string): string {
+  const key = part.trim().toLowerCase();
+  return KEY_ALIASES[key] ?? key;
+}
+
 export function normalizeChord(chord: string): string {
   const parts = chord.trim().split("+").map((p) => p.trim().toLowerCase()).filter(Boolean);
   const mods: string[] = [];
@@ -81,22 +106,8 @@ export function normalizeChord(chord: string): string {
       case "option":
         if (!mods.includes("alt")) mods.push("alt");
         break;
-      case "esc":
-      case "escape":
-        key = "escape";
-        break;
-      case "slash":
-        key = "/";
-        break;
-      case "question":
-        key = "?";
-        break;
-      case "backslash":
-      case "\\":
-        key = "\\";
-        break;
       default:
-        key = part.length === 1 ? part : part;
+        key = normalizeKeyPart(part);
     }
   }
   mods.sort();
diff --git a/ui/src/lib/splitView.test.ts b/ui/src/lib/splitView.test.ts
index a321b2a9..d70eb5c9 100644
--- a/ui/src/lib/splitView.test.ts
+++ b/ui/src/lib/splitView.test.ts
@@ -8,6 +8,7 @@ import {
   openVersionInSplit,
   saveSplitViewState,
   splitViewHasSecondary,
+  syncSplitViewWithActivePath,
   toggleSplitView,
   clampSplitSizes,
 } from "./splitView";
@@ -69,6 +70,37 @@ describe("splitView", () => {
     expect(offAgain.enabled).toBe(false);
   });
 
+  it("toggle preserves custom pane sizes across on/off cycles", () => {
+    const custom: [number, number] = [35, 65];
+    const base = createSplitViewState({ sizes: custom });
+    const on = toggleSplitView(base, "a.md");
+    expect(on.sizes).toEqual(custom);
+    const off = toggleSplitView(on, "a.md");
+    expect(off.sizes).toEqual(custom);
+    expect(off.enabled).toBe(false);
+  });
+
+  it("double toggle returns to disabled state without side effects", () => {
+    const initial = createSplitViewState();
+    const once = toggleSplitView(initial, "notes/x.md");
+    const twice = toggleSplitView(once, "notes/x.md");
+    expect(twice).toEqual(initial);
+  });
+
+  it("toggle off clears secondary content including version compare", () => {
+    const withVersion = openVersionInSplit(createSplitViewState(), { path: "a.md", hash: "abc" });
+    const cleared = toggleSplitView(withVersion, "a.md");
+    expect(cleared.enabled).toBe(false);
+    expect(splitViewHasSecondary(cleared)).toBe(false);
+  });
+
+  it("toggle on when already open via openPathInSplit turns off", () => {
+    const open = openPathInSplit(createSplitViewState(), "left.md");
+    expect(open.enabled).toBe(true);
+    const closed = toggleSplitView(open, "left.md");
+    expect(closed.enabled).toBe(false);
+  });
+
   it("does not enable split without an active page", () => {
     const state = toggleSplitView(createSplitViewState(), null);
     expect(state.enabled).toBe(false);
@@ -87,4 +119,18 @@ describe("splitView", () => {
     expect(clampSplitSizes(90)).toEqual([80, 20]);
     expect(clampSplitSizes(55)).toEqual([55, 45]);
   });
+
+  describe("syncSplitViewWithActivePath", () => {
+    it("disables split view when primary page is cleared", () => {
+      const open = openPathInSplit(createSplitViewState({ sizes: [40, 60] }), "a.md");
+      const synced = syncSplitViewWithActivePath(open, null);
+      expect(synced.enabled).toBe(false);
+      expect(synced.sizes).toEqual([40, 60]);
+    });
+
+    it("leaves split view unchanged when primary page exists", () => {
+      const open = openPathInSplit(createSplitViewState(), "a.md");
+      expect(syncSplitViewWithActivePath(open, "a.md")).toBe(open);
+    });
+  });
 });
diff --git a/ui/src/lib/splitView.ts b/ui/src/lib/splitView.ts
index e8b98f08..dbddb891 100644
--- a/ui/src/lib/splitView.ts
+++ b/ui/src/lib/splitView.ts
@@ -127,6 +127,17 @@ export function toggleSplitView(
   };
 }
 
+/** Disable split view when the primary page is cleared (navigation / space switch). */
+export function syncSplitViewWithActivePath(
+  state: SplitViewState,
+  activePath: string | null,
+): SplitViewState {
+  if (state.enabled && !activePath) {
+    return createSplitViewState({ sizes: state.sizes });
+  }
+  return state;
+}
+
 export function closeSecondaryPane(state: SplitViewState): SplitViewState {
   return createSplitViewState({ sizes: state.sizes });
 }

From 0ab7581b77c08d48e7324ac359c992eb51dc599c Mon Sep 17 00:00:00 2001
From: Array Fleet <fleet@advancedresearcharray.local>
Date: Tue, 30 Jun 2026 14:18:28 +0000
Subject: [PATCH 6/9] docs(episodes): log issue #426 split view redelivery run

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 ...6-06-30-issue-426-split-view-redelivery.md | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 episodes/agents/cursor-agent/2026-06-30-issue-426-split-view-redelivery.md

diff --git a/episodes/agents/cursor-agent/2026-06-30-issue-426-split-view-redelivery.md b/episodes/agents/cursor-agent/2026-06-30-issue-426-split-view-redelivery.md
new file mode 100644
index 00000000..40f5a017
--- /dev/null
+++ b/episodes/agents/cursor-agent/2026-06-30-issue-426-split-view-redelivery.md
@@ -0,0 +1,28 @@
+---
+memory_kind: episodic
+episode_id: cursor-agent-2026-06-30-issue-426-split-view-redelivery
+title: "Issue #426 split view — branch feat/issue-426-split-view"
+tags: [kiwifs, ui, split-view, issue-426, fleet-delivery]
+date: 2026-06-30
+---
+
+# Issue #426 split view redelivery
+
+## Task
+
+Re-deliver kiwifs/kiwifs#426 on clean branch from main for fleet publish.
+
+## Actions
+
+1. Checked out `main`, created `feat/issue-426-split-view`.
+2. Cherry-picked 5 verified commits from prior `feat/split-view-426` work (fc1c045..3f794a5).
+3. Ran full regression suite.
+
+## Verification
+
+- `cd ui && npm test` → 206 passed (includes 14 splitView + keybinding tests)
+- `go test ./internal/keybindings/... -count=1` → ok
+
+## Handoff
+
+Branch `feat/issue-426-split-view` ready for fleet push + PR closing #426. Kiwi gateway unreachable — fix doc at `pages/fixes/kiwifs-kiwifs/issue-426-split-side-by-side-page-view.md`.

From d8e657302efad9525e3fe1e3e237dc076fcab3ee Mon Sep 17 00:00:00 2001
From: Array Fleet <fleet@advancedresearcharray.local>
Date: Tue, 30 Jun 2026 14:19:34 +0000
Subject: [PATCH 7/9] Fix failing MkDocs tests

---
 .../workspace/templates/knowledge/SCHEMA.md   | 157 ++++++++
 .../knowledge/episodes/example-episode.md     |  40 ++
 .../workspace/templates/knowledge/index.md    |   9 +
 internal/workspace/templates/knowledge/log.md |   5 +
 .../templates/knowledge/pages/.gitkeep        |   0
 .../knowledge/pages/getting-started.md        |  46 +++
 .../workspace/templates/knowledge/playbook.md | 351 ++++++++++++++++++
 .../research/experiments/exp-001-baseline.md  |  86 +++++
 .../research/literature/example-paper.md      |  68 ++++
 .../templates/runbook/incidents/template.md   | 105 ++++++
 .../templates/runbook/postmortems/template.md | 121 ++++++
 .../runbook/procedures/deploy-rollback.md     |  80 ++++
 .../runbook/procedures/rotate-secrets.md      |  82 ++++
 .../templates/runbook/procedures/scale-up.md  |  96 +++++
 14 files changed, 1246 insertions(+)
 create mode 100644 internal/workspace/templates/knowledge/SCHEMA.md
 create mode 100644 internal/workspace/templates/knowledge/episodes/example-episode.md
 create mode 100644 internal/workspace/templates/knowledge/index.md
 create mode 100644 internal/workspace/templates/knowledge/log.md
 create mode 100644 internal/workspace/templates/knowledge/pages/.gitkeep
 create mode 100644 internal/workspace/templates/knowledge/pages/getting-started.md
 create mode 100644 internal/workspace/templates/knowledge/playbook.md
 create mode 100644 internal/workspace/templates/research/experiments/exp-001-baseline.md
 create mode 100644 internal/workspace/templates/research/literature/example-paper.md
 create mode 100644 internal/workspace/templates/runbook/incidents/template.md
 create mode 100644 internal/workspace/templates/runbook/postmortems/template.md
 create mode 100644 internal/workspace/templates/runbook/procedures/deploy-rollback.md
 create mode 100644 internal/workspace/templates/runbook/procedures/rotate-secrets.md
 create mode 100644 internal/workspace/templates/runbook/procedures/scale-up.md

diff --git a/internal/workspace/templates/knowledge/SCHEMA.md b/internal/workspace/templates/knowledge/SCHEMA.md
new file mode 100644
index 00000000..31945da4
--- /dev/null
+++ b/internal/workspace/templates/knowledge/SCHEMA.md
@@ -0,0 +1,157 @@
+# Schema — Knowledge Base
+
+_Template version: 2.0_
+
+Agent-maintained knowledge base following the LLM Wiki pattern:
+raw sources in, compiled wiki out, agent maintains it over time.
+Includes episodic memory with consolidation into durable pages.
+
+## Directory Structure
+
+    pages/           Durable knowledge — one page per concept, entity, or topic
+    episodes/        Per-session episodic notes (transient, consolidate later)
+    index.md         Auto-maintained table of contents
+    log.md           Append-only chronological record of all operations
+    SCHEMA.md        This file — structure and conventions
+
+## Memory Architecture
+
+This knowledge base implements a tiered memory system:
+
+| Tier | Storage | Purpose | Retrieval |
+|------|---------|---------|-----------|
+| **Episodic** | `episodes/` | Raw session observations, decisions, interactions | Temporal + similarity |
+| **Semantic** | `pages/` | Distilled durable facts, one concept per page | Keyword + graph + semantic |
+| **Procedural** | `.kiwi/playbook.md` | Learned routines and operational policies | By intent |
+
+Consolidation moves high-value episodic traces into semantic pages.
+Raw episodes are preserved alongside distilled facts for audit and rollback.
+
+## Episodes
+
+Use `episodes/` for per-run or per-session raw notes that should be
+consolidated into durable `pages/` later. Files under this directory are
+classified as episodic automatically, and agents should still set
+`memory_kind: episodic` plus a unique `episode_id` in frontmatter.
+Run `kiwifs memory report` to see which episodes have not been
+consolidated. Full reference: [docs/MEMORY.md](https://github.com/kiwifs/kiwifs/blob/main/docs/MEMORY.md).
+
+## Frontmatter Fields
+
+Every `.md` file should have YAML frontmatter. Required fields marked *.
+
+### Pages (`pages/*.md`)
+
+| Field           | Type       | Required | Values / Notes                              |
+|-----------------|------------|----------|---------------------------------------------|
+| title           | string     | *        | Human-readable page title                   |
+| description     | string     |          | One-line summary for search results         |
+| tags            | string[]   | *        | Topic tags, lowercase, hyphenated           |
+| status          | string     |          | `active` · `draft` · `review` · `deprecated` |
+| context-layer   | string     |          | `operational` · `reference` · `archival` — retrieval priority hint |
+| last-reviewed   | date       |          | ISO 8601 date of last quality review        |
+| freshness-days  | integer    |          | How many days before this page is considered stale (default: 90) |
+| source-uri      | string     |          | Deep link to the original source material   |
+| derived-from    | object[]   |          | Provenance chain. Each entry: `source` (URI or path), `type` (`ingest` · `consolidation` · `synthesis`), `date` (ISO 8601), `actor` (who/what produced it) |
+| merged-from     | object[]   |          | Episode paths this page was consolidated from. Each entry: `path`, `episode_id`, `date` |
+| confidence      | float      |          | 0.0–1.0, certainty level of this knowledge  |
+
+### Episodes (`episodes/*.md`)
+
+| Field           | Type       | Required | Values / Notes                              |
+|-----------------|------------|----------|---------------------------------------------|
+| memory_kind     | string     | *        | Always `episodic`                           |
+| episode_id      | string     | *        | Unique session/episode identifier           |
+| session_id      | string     |          | Groups episodes from the same session       |
+| confidence      | float      |          | 0.0–1.0, how certain is this observation    |
+| importance      | integer    |          | 1–5, how critical this observation is (5 = must consolidate) |
+| tags            | string[]   |          | Topic tags                                  |
+| related-pages   | string[]   |          | Paths to existing pages this episode relates to |
+| consolidated    | boolean    |          | `true` when merged into a page              |
+| merged-into     | string[]   |          | Paths of pages this was merged into         |
+
+## Memory Governance
+
+### Freshness and Decay
+
+- Pages have a `freshness-days` field (default 90). After this period without
+  a `last-reviewed` update, the page is flagged as stale by `kiwi_analytics`.
+- Episodes older than 30 days that are not consolidated should be reviewed.
+  Episodes older than 90 days with `importance` ≤ 2 are candidates for archival.
+- Retrieval should weight recency: `score = similarity × exp(-age_days / freshness_days)`.
+
+### Contradiction Resolution
+
+When new information contradicts an existing page:
+
+1. **Check confidence.** If new source has higher confidence, update the page.
+2. **Check recency.** More recent information wins when confidence is equal.
+3. **If ambiguous:** Create the new page/episode with a `contradicts: [[page]]`
+   note and flag for human review. Do not silently overwrite.
+4. **Record the resolution** in `log.md` with rationale.
+
+### Consolidation Triggers
+
+Consolidation should run when any of these conditions are met:
+
+- `kiwi_memory_report` shows ≥ 5 unconsolidated episodes on the same topic
+- An episode has `importance: 5` (consolidate immediately)
+- A scheduled maintenance pass runs (recommended: weekly)
+- A human or orchestrator explicitly requests it
+
+### Eviction and Archival
+
+- Episodes with `consolidated: true` and age > 90 days may be moved to
+  `episodes/archive/` to reduce retrieval noise.
+- Never delete raw episodes — move to archive for audit trail.
+- Pages with `status: deprecated` and no inbound links for 180+ days
+  may be archived with a note in `log.md`.
+
+## Operations
+
+See `.kiwi/playbook.md` for step-by-step MCP tool sequences.
+
+### Ingest
+Read a raw source → create/update pages in `pages/` →
+update `index.md` and `log.md`. Always deduplicate first.
+Record provenance via `derived-from` with `type: ingest`.
+
+### Query
+Search the wiki to answer questions. Use `kiwi_search` +
+`kiwi_read` + `kiwi_backlinks`. Prefer pages with
+`context-layer: operational` for current-state questions.
+
+### Lint
+Audit for orphans, broken links, stale content, missing
+frontmatter, and coverage gaps. Use `kiwi_analytics`.
+Flag pages past their `freshness-days` threshold.
+
+### Remember
+Write a new episodic note under `episodes/` during a session.
+Include `memory_kind: episodic` and a unique `episode_id`.
+Set `importance` (1–5) and link to `related-pages` if known.
+Append a summary to `log.md`.
+
+### Consolidate
+Merge related `episodes/` notes into durable `pages/` entries.
+Set `merged-from` on the page, `consolidated: true` on the episode.
+Run `kiwi_memory_report` to find unconsolidated episodes.
+Resolve contradictions before merging (see Memory Governance).
+
+### Recall
+Search memory for past observations. Use `kiwi_search` for keyword
+recall or `kiwi_search_semantic` for conceptual recall. Prefer
+durable pages over raw episodes when both exist. Use `context-layer`
+to prioritize results based on current task type.
+
+## Conventions
+
+- Link between pages with `[[wiki links]]`
+- Keep pages focused — one concept per page
+- Split pages over 300 lines
+- Use YAML frontmatter for all structured metadata
+- Append to `log.md` after every write operation
+- Every page reachable from `index.md` within 2 hops
+- Always record provenance — cite sources with URIs or `[[wikilinks]]`
+- Set `importance` on episodes so consolidation can prioritize
+- Never silently overwrite — read before write, resolve contradictions explicitly
diff --git a/internal/workspace/templates/knowledge/episodes/example-episode.md b/internal/workspace/templates/knowledge/episodes/example-episode.md
new file mode 100644
index 00000000..45cbe13f
--- /dev/null
+++ b/internal/workspace/templates/knowledge/episodes/example-episode.md
@@ -0,0 +1,40 @@
+---
+memory_kind: episodic
+episode_id: example-001
+session_id: example
+confidence: 0.8
+importance: 3
+tags: [onboarding]
+related-pages: [pages/getting-started.md]
+---
+# Example Episode
+
+This is a sample episodic note. Replace or delete this file.
+
+## Observation
+
+What was observed or learned during this session.
+
+## Context
+
+Why this observation matters — what task or question prompted it.
+
+## Decision Trace
+
+Any decisions made and the reasoning behind them.
+
+## Outcome
+
+What resulted from the observation or decision.
+
+---
+
+Each agent session can create files here with `memory_kind: episodic`
+and a unique `episode_id`. Set `importance` (1–5) to signal how critical
+this observation is for consolidation.
+
+A consolidation step later merges related episodes into durable pages
+under `pages/` and records the link via `merged-from` in frontmatter.
+
+Run `kiwifs memory report` to see which episodes haven't been
+consolidated yet.
diff --git a/internal/workspace/templates/knowledge/index.md b/internal/workspace/templates/knowledge/index.md
new file mode 100644
index 00000000..fb4d3843
--- /dev/null
+++ b/internal/workspace/templates/knowledge/index.md
@@ -0,0 +1,9 @@
+# Knowledge Base
+
+Auto-maintained table of contents. Updated by the agent on each operation.
+
+## Pages
+- [[pages/getting-started|Getting Started]]
+
+## Recent Episodes
+<!-- Agent adds links here as episodes are created -->
diff --git a/internal/workspace/templates/knowledge/log.md b/internal/workspace/templates/knowledge/log.md
new file mode 100644
index 00000000..336556e8
--- /dev/null
+++ b/internal/workspace/templates/knowledge/log.md
@@ -0,0 +1,5 @@
+# Log
+
+Append-only chronological record. Each ingest appends an entry.
+
+<!-- Agent appends entries below this line -->
diff --git a/internal/workspace/templates/knowledge/pages/.gitkeep b/internal/workspace/templates/knowledge/pages/.gitkeep
new file mode 100644
index 00000000..e69de29b
diff --git a/internal/workspace/templates/knowledge/pages/getting-started.md b/internal/workspace/templates/knowledge/pages/getting-started.md
new file mode 100644
index 00000000..ecf8c7b9
--- /dev/null
+++ b/internal/workspace/templates/knowledge/pages/getting-started.md
@@ -0,0 +1,46 @@
+---
+title: Getting Started
+description: How this knowledge base is organized and how to use it
+tags: [meta, onboarding]
+status: active
+context-layer: reference
+freshness-days: 180
+---
+
+# Getting Started
+
+This knowledge base is maintained using the LLM Wiki pattern.
+
+## Structure
+
+- `pages/` — durable knowledge, one concept per page
+- `episodes/` — session notes, consolidated into pages over time
+- `index.md` — table of contents
+- `log.md` — chronological record of all changes
+
+## Memory Tiers
+
+| Tier | Location | Purpose |
+|------|----------|---------|
+| Episodic | `episodes/` | Raw observations from sessions |
+| Semantic | `pages/` | Distilled, durable facts |
+| Procedural | `.kiwi/playbook.md` | Operational policies |
+
+Episodes are consolidated into pages over time. High-importance
+episodes are consolidated immediately; low-importance ones are
+reviewed on a weekly cadence.
+
+## How It Works
+
+An agent [[SCHEMA|follows the schema]] to ingest new information,
+answer questions from existing pages, and periodically lint for
+quality. See `.kiwi/playbook.md` for the full operation guide.
+
+## Conventions
+
+- Every page has YAML frontmatter with `title` and `tags`
+- Pages link to each other with `[[wikilinks]]`
+- One concept per page — split when a page exceeds 300 lines
+- Always cite sources via `source-uri` or `derived-from`
+- Set `importance` on episodes to guide consolidation priority
+- Never overwrite without reading first — resolve contradictions explicitly
diff --git a/internal/workspace/templates/knowledge/playbook.md b/internal/workspace/templates/knowledge/playbook.md
new file mode 100644
index 00000000..76ac9899
--- /dev/null
+++ b/internal/workspace/templates/knowledge/playbook.md
@@ -0,0 +1,351 @@
+# Agent Playbook — Knowledge Base
+
+This knowledge base follows the LLM Wiki pattern. When connected
+via MCP, use these operations to maintain it.
+
+## Quick Start
+
+1. Call `kiwi_context` to get this playbook + schema + index in one call
+2. Call `kiwi_tree` to see the current file structure
+3. Use the operations below to ingest, query, and maintain
+
+## Ingest (new source → wiki pages)
+
+When given new information to add:
+
+1. **Deduplicate first.** `kiwi_search` for key terms from the source.
+   If a page already covers this topic, update it instead of creating
+   a duplicate.
+2. **Create or update page.**
+   `kiwi_write` to `pages/<slug>.md` with frontmatter:
+   ```yaml
+   ---
+   title: "Human-readable title"
+   description: "One-line summary"
+   tags: [topic-1, topic-2]
+   status: active
+   ---
+   ```
+   Set provenance via the `provenance` parameter:
+   `ingest:<source-slug>`.
+3. **Cross-link.** Use `[[wikilinks]]` in the body to connect to
+   related pages. Use `kiwi_search` to discover what exists.
+4. **Update the log.** `kiwi_append` to `log.md`:
+   `- YYYY-MM-DD: Ingested <title> → [[pages/<slug>]]`
+5. **Update the index.** `kiwi_read` `index.md`, add the new
+   `[[pages/<slug>]]` link, `kiwi_write` it back.
+
+## Query (answer a question from the wiki)
+
+1. `kiwi_search` for relevant terms (try 2-3 queries).
+2. `kiwi_read` top results. Use `if_not_etag` if you've read them
+   before to save tokens.
+3. `kiwi_backlinks` on key pages to find related context.
+4. Synthesize an answer citing `[[page]]` links.
+5. If the answer reveals a gap, run Ingest to fill it.
+
+## Deep Retrieval (Graph Navigation)
+
+When answering complex questions that span multiple topics:
+
+1. **Find entry points** — `kiwi_search` with keywords from the question (fast, lexical)
+2. **Peek at candidates** — `kiwi_peek` on top 2-3 results. Read title + snippet + headings.
+   Decide which page is most relevant.
+3. **Walk the graph** — `kiwi_graph_walk` on the best candidate. See what it links to.
+   If a link's name matches your query, peek at it.
+4. **Read targeted sections** — `kiwi_section` to read only the relevant heading.
+   Never read entire files unless they're short (< 500 words per kiwi_peek word_count).
+5. **Check the map** — if stuck or need overview, `kiwi_graph_analytics` shows hub pages,
+   topic clusters, and bridge pages. Hub pages are good starting points.
+
+### Cost efficiency
+
+| Tool | Typical tokens | When to use |
+|------|---------------|-------------|
+| `kiwi_search` | ~50 per result | Always first — find entry points |
+| `kiwi_peek` | ~200 | Before reading — check if page is relevant |
+| `kiwi_section` | ~500 | After peek confirms the right heading |
+| `kiwi_read` | ~2000+ | Only when you need the complete file |
+| `kiwi_graph_walk` | ~300 | When exploring connections |
+| `kiwi_graph_analytics` | ~500 | When lost or need the big picture |
+
+### Example: Multi-hop retrieval
+
+Question: "How does payment retry interact with the circuit breaker?"
+
+```
+kiwi_search("payment retry")        → pages/payments.md (rank 1)
+kiwi_search("circuit breaker")      → pages/resilience.md (rank 1)
+kiwi_graph_walk("pages/payments.md")
+  → links_out: ["resilience", "billing", "error-handling"]
+  → AHA: payments links to resilience directly!
+kiwi_section("pages/payments.md", "Retry Logic")    → 400 tokens
+kiwi_section("pages/resilience.md", "Circuit Breaker") → 350 tokens
+
+Total: ~1500 tokens. Full reads would have cost ~8000 tokens.
+```
+
+## Remember (save observations during a session)
+
+1. `kiwi_write` to `episodes/<session-id>-<slug>.md` with:
+   ```yaml
+   ---
+   memory_kind: episodic
+   episode_id: unique-id
+   session_id: current-session
+   confidence: 0.8
+   importance: 3
+   tags: [topic]
+   related-pages: [pages/relevant-page.md]
+   ---
+   ```
+2. Structure the episode body with sections:
+   - **Observation** — what was learned
+   - **Context** — why it matters
+   - **Decision Trace** — reasoning behind any choices
+   - **Outcome** — what resulted
+3. `kiwi_append` to `log.md`:
+   `- YYYY-MM-DD: Remembered <summary> → [[episodes/<file>]]`
+
+### Importance Scale
+
+| Level | Meaning | Consolidation |
+|-------|---------|---------------|
+| 5 | Critical insight, must persist | Consolidate immediately |
+| 4 | High value, consolidate soon | Next consolidation pass |
+| 3 | Normal observation | Standard weekly consolidation |
+| 2 | Low value, context-dependent | Consolidate only if pattern emerges |
+| 1 | Ephemeral, unlikely to matter | Archive after 90 days if unused |
+
+## Consolidate (episodes → durable pages)
+
+### When to Run
+
+Consolidation should trigger when:
+- `kiwi_memory_report` shows ≥ 5 unconsolidated episodes on the same topic
+- Any episode has `importance: 5`
+- A weekly maintenance pass runs
+- Explicitly requested by a human or orchestrator
+
+### Procedure
+
+1. `kiwi_memory_report` — list unconsolidated episodes.
+2. Group episodes by topic (use `tags` and `related-pages`).
+3. `kiwi_read` each unconsolidated episode in a topic group.
+4. **Check for contradictions.** If episodes disagree with existing pages:
+   - Higher confidence wins
+   - More recent wins when confidence is equal
+   - If ambiguous, flag for human review (do not silently overwrite)
+5. Extract durable facts. `kiwi_search` for existing pages on
+   those topics.
+6. Merge into existing `pages/` entries or create new ones.
+   Set `merged-from` in the page frontmatter:
+   ```yaml
+   merged-from:
+     - path: episodes/session-001-finding.md
+       episode_id: session-001
+       date: 2026-05-30
+   ```
+7. Set `derived-from` with `type: consolidation` on the page.
+8. Mark episodes: `kiwi_write` each with `consolidated: true` and
+   `merged-into: [pages/<slug>.md]` added to frontmatter.
+9. Update `log.md` and `index.md`.
+
+### Pruning and Archival
+
+After consolidation:
+- Episodes with `consolidated: true` older than 90 days: move to
+  `episodes/archive/` to reduce retrieval noise.
+- Never delete episodes — archive preserves the audit trail.
+- Low-importance episodes (≤ 2) older than 90 days without
+  consolidation: review and archive or consolidate.
+
+## Lint (maintenance pass)
+
+Run periodically or when asked to clean up:
+
+1. `kiwi_lint` with `path` — check a specific file for structural issues
+   (tables, fences, frontmatter, headings, mermaid diagrams).
+2. Review the issues list — fix any errors before considering the write complete.
+3. `kiwi_analytics` — broader workspace health (orphans, broken links,
+   stale content, missing frontmatter).
+4. `kiwi_changes` with `since=<last_checkpoint>` — review recent
+   edits for quality.
+5. For each issue:
+   - Orphan page → add `[[wikilinks]]` from related pages or index
+   - Broken link → `kiwi_search` for intended target, fix the link
+   - Stale page → update content, bump `last-reviewed`
+   - Duplicate → merge into one, `kiwi_rename` + `kiwi_delete`
+6. `kiwi_append` to `log.md` with what was fixed.
+
+**Best practice:** After every `kiwi_write`, call `kiwi_lint` on the same path.
+If issues are returned, fix and `kiwi_write` again. This loop rarely needs
+more than one retry — the server auto-formats cosmetic issues on write, so
+`kiwi_lint` only reports things that need semantic fixes.
+
+## Page Format
+
+```markdown
+---
+title: "Page Title"
+description: "Brief one-line summary"
+tags: [tag1, tag2]
+status: active
+last-reviewed: YYYY-MM-DD
+---
+
+# Page Title
+
+Introduction paragraph.
+
+## Section
+
+Content with [[wikilinks]] to related pages.
+
+## Related
+- [[related-page]] — why it's related
+```
+
+## Quality Rules
+
+- **One concept per page.** Split pages over 300 lines.
+- **Every page needs frontmatter** with at least `title` and `tags`.
+- **No orphans.** Every page reachable from `index.md` within 2 hops.
+- **No broken links.** Every `[[wikilink]]` should resolve.
+- **Provenance.** Agent-created pages must set provenance on write.
+- **Prefer pages over episodes.** When querying, use consolidated
+  pages as primary source. Fall back to episodes only if no page exists.
+
+## Canvas (visual knowledge maps)
+
+Generate spatial visualizations of the knowledge graph that humans can
+review, rearrange, and annotate.
+
+### Auto-generate a canvas from the link graph
+
+```
+kiwi_canvas_generate(
+  path: "maps/architecture.canvas.json",
+  layout: "dot",       // or "neato", "fdp", "circo"
+  folder: "pages/",    // scope to a subtree
+  colorize: true       // color nodes by topic cluster
+)
+```
+
+The agent picks the layout algorithm based on the graph shape:
+- `dot` (hierarchical) — best for dependency trees, taxonomies
+- `neato` (spring model) — best for peer-to-peer relationship graphs
+- `fdp` (force-directed) — best for large, loosely connected graphs
+- `circo` (circular) — best for cyclic processes, pipelines
+
+### Manually build a canvas
+
+For curated maps (e.g. onboarding, architecture overviews):
+
+1. `kiwi_canvas_list` — see existing canvases.
+2. `kiwi_canvas_read(path)` — read an existing canvas.
+3. Build or modify the nodes/edges JSON.
+4. `kiwi_canvas_write(path, content)` — save it.
+
+### Example: Map a topic cluster
+
+```
+kiwi_graph_analytics()
+  → cluster "payments" has 12 pages
+kiwi_canvas_generate(
+  path: "maps/payments.canvas.json",
+  folder: "pages/payments/",
+  layout: "dot",
+  colorize: true
+)
+  → saved with 12 nodes, 18 edges
+```
+
+Human opens the canvas in the UI, drags nodes into a cleaner layout,
+adds text annotations. Agent work + human polish.
+
+## Workflows & Kanban (state machines for pages)
+
+Manage page lifecycles with defined states and transitions.
+The Kanban board groups pages by their current workflow state.
+
+### Set up a workflow
+
+Workflows live in `.kiwi/workflows/` as YAML files. The agent creates
+and manages them:
+
+1. `kiwi_workflow_list` — see existing workflows.
+2. `kiwi_workflow_save` — create or update a workflow definition:
+   ```json
+   {
+     "name": "content-pipeline",
+     "states": [
+       {"name": "draft", "color": "#9B59B6"},
+       {"name": "review", "color": "#F39C12"},
+       {"name": "published", "color": "#2ECC71", "terminal": true},
+       {"name": "archived", "color": "#95A5A6", "terminal": true}
+     ],
+     "transitions": [
+       {"from": "draft", "to": "review"},
+       {"from": "review", "to": "draft"},
+       {"from": "review", "to": "published"},
+       {"from": "published", "to": "archived"}
+     ]
+   }
+   ```
+3. `kiwi_workflow_get(name)` — read a workflow definition.
+
+### Advance pages through the workflow
+
+Pages participate in workflows via the `status` frontmatter field:
+
+```
+kiwi_write("pages/new-feature.md", content_with_frontmatter, actor: "agent")
+  # frontmatter includes: status: draft
+
+kiwi_workflow_advance(
+  path: "pages/new-feature.md",
+  target_state: "review",
+  actor: "agent"
+)
+  → moved from "draft" to "review"
+```
+
+The agent can only advance along defined transitions. Invalid moves
+are rejected — this enforces process discipline.
+
+### View the Kanban board
+
+```
+kiwi_workflow_board(workflow: "content-pipeline")
+  → { "draft": [page1, page2], "review": [page3], "published": [page4, ...] }
+```
+
+### Example: Content pipeline agent
+
+```
+# 1. Find pages that need review
+kiwi_workflow_board("content-pipeline")
+  → draft: ["pages/api-guide.md", "pages/deploy-notes.md"]
+
+# 2. Review each draft
+kiwi_read("pages/api-guide.md")
+kiwi_lint("pages/api-guide.md")
+  → no issues
+kiwi_workflow_advance("pages/api-guide.md", "review", actor: "reviewer-agent")
+
+# 3. After human approval, publish
+kiwi_workflow_advance("pages/api-guide.md", "published", actor: "publisher-agent")
+```
+
+### Example: Automated triage
+
+```
+# Find all uncategorized pages (no status field)
+kiwi_query("SELECT path FROM pages WHERE status IS NULL")
+  → 5 pages without workflow state
+
+# Assign them to the pipeline as drafts
+for each page:
+  kiwi_workflow_advance(page, "draft", actor: "triage-agent")
+```
diff --git a/internal/workspace/templates/research/experiments/exp-001-baseline.md b/internal/workspace/templates/research/experiments/exp-001-baseline.md
new file mode 100644
index 00000000..33f93cd1
--- /dev/null
+++ b/internal/workspace/templates/research/experiments/exp-001-baseline.md
@@ -0,0 +1,86 @@
+---
+title: "Experiment 001: Baseline Measurement"
+date: 2026-01-01
+hypothesis: "Establishing baseline metrics for comparison with future experiments"
+research-question: "Q1"
+status: completed
+result: positive
+protocol: "Standard load test protocol"
+environment: "Linux 6.1, 8-core, 32GB RAM, Go 1.22"
+duration: "24 hours"
+raw-data: "data/exp-001/"
+sample-size: "86,400 data points (1/sec)"
+tags: [baseline, setup, performance]
+references: [literature/example-paper.md]
+---
+
+# Experiment 001 — Baseline Measurement
+
+> **This is an example experiment.** Replace it with your first real
+> experiment, or delete it once you've created your own.
+
+## Hypothesis
+
+Establish baseline performance metrics so future experiments have
+a reference point for comparison.
+
+## Variables
+
+- **Independent:** none (baseline — default configuration)
+- **Dependent:** throughput, latency (p50, p99), error rate
+- **Controlled:** hardware, OS, network conditions, data set
+
+## Environment
+
+- **OS:** Linux 6.1 (Ubuntu 22.04)
+- **Hardware:** 8-core CPU, 32GB RAM, NVMe SSD
+- **Software:** Go 1.22, PostgreSQL 16.1
+- **Configuration:** default / unmodified
+- **Network:** isolated test network, 1Gbps
+
+## Protocol
+
+1. Configure the standard test environment
+2. Run the default configuration with no modifications
+3. Collect metrics at 1-second intervals over 24 hours
+4. Aggregate results into p50, p95, p99 percentiles
+5. Record results below
+
+## Observations
+
+_Notes taken during the experiment. Include timestamps if relevant._
+
+- _e.g., System stable throughout the measurement period_
+- _e.g., Noted periodic GC pauses every ~30 minutes_
+
+## Results
+
+| Metric | Value | Notes |
+|--------|-------|-------|
+| _Throughput_ | _X req/s_ | _baseline_ |
+| _P50 latency_ | _X ms_ | _baseline_ |
+| _P99 latency_ | _X ms_ | _baseline_ |
+| _Error rate_ | _X%_ | _baseline_ |
+
+## Conclusions
+
+_What did you learn? How does this inform the next experiment?_
+
+## Reproduction Steps
+
+To re-run this experiment:
+
+1. Provision a machine matching the environment above
+2. Deploy the application at commit `abc123`
+3. Run: `./benchmark --duration=24h --rate=100 --output=data/exp-001/`
+4. Compare output against the results table above
+
+## Next Steps
+
+- [ ] Design [[experiments/exp-002|Experiment 002]] to test first variation
+- [ ] Document any anomalies for investigation
+
+## Related
+
+- Literature: [[literature/example-paper]]
+- Research question: Q1 (see `questions.md`)
diff --git a/internal/workspace/templates/research/literature/example-paper.md b/internal/workspace/templates/research/literature/example-paper.md
new file mode 100644
index 00000000..6165fbb0
--- /dev/null
+++ b/internal/workspace/templates/research/literature/example-paper.md
@@ -0,0 +1,68 @@
+---
+title: "Example Paper: A Survey of Methods"
+authors: [Smith, J., Doe, A.]
+year: 2025
+doi: "10.1234/example.2025.001"
+url: https://example.com/paper
+methodology: review
+relevance: 4
+tags: [survey, methods, example]
+status: read
+cited-by: [experiments/exp-001-baseline.md]
+---
+
+# Example Paper: A Survey of Methods
+
+> **This is an example literature note.** Replace it with your first
+> real paper, or delete it once you've created your own.
+
+## Abstract / Summary
+
+_2-3 sentence summary of the paper's contribution for quick recall._
+
+## Key Findings
+
+- _Finding 1: summarize the main result_
+- _Finding 2: what was novel or surprising_
+- _Finding 3: limitations acknowledged by authors_
+
+## Methods
+
+_Briefly describe the methodology: what did they do and how?_
+
+- **Approach:** _qualitative / quantitative / mixed_
+- **Sample:** _size and characteristics_
+- **Analysis:** _statistical methods, tools used_
+
+## Relevance to Our Research
+
+_How does this paper relate to your research? What experiments
+does it inform? Rate relevance 1-5 in frontmatter._
+
+- Informs: [[experiments/exp-001-baseline]] — baseline methodology
+- Contradicts: _link to any conflicting work_
+- Extends: _link to work this paper builds on_
+
+## Quotes / Key Passages
+
+> "_Paste important quotes with page numbers here._" (p. XX)
+
+## Strengths and Limitations
+
+**Strengths:**
+- _e.g., Large sample size, rigorous methodology_
+
+**Limitations:**
+- _e.g., Limited to English-language sources_
+- _e.g., No longitudinal follow-up_
+
+## Questions / Gaps
+
+- _What doesn't this paper address?_
+- _What would you test differently?_
+- _What follow-up experiments does this suggest?_
+
+## Related
+
+- Research question: Q1 (see `questions.md`)
+- Related papers: _link to similar work_
diff --git a/internal/workspace/templates/runbook/incidents/template.md b/internal/workspace/templates/runbook/incidents/template.md
new file mode 100644
index 00000000..0a6bcf3c
--- /dev/null
+++ b/internal/workspace/templates/runbook/incidents/template.md
@@ -0,0 +1,105 @@
+---
+title: "Incident: [Short Description]"
+date: 2026-01-01
+severity: P2
+status: active
+on-call: 
+related-alert: 
+detection-minutes: 
+mitigation-minutes: 
+resolution-minutes: 
+users-affected: 
+error-budget-impact: 
+tags: [service-name]
+postmortem: 
+---
+
+# Incident: [Short Description]
+
+## Trigger
+
+_What alert or report initiated this incident?_
+
+- Alert: `[alert name or link]`
+- Detected by: monitoring / customer report / engineer
+- Detection lag: _how long between incident start and detection_
+
+## Impact
+
+- **Affected services:** _list services_
+- **Blast radius:** _e.g., all users, 10% of requests, internal only_
+- **User-facing symptoms:** _what users experienced_
+- **SLA impact:** _e.g., breaches 99.9% availability after 15 min_
+- **Error budget consumed:** _percentage of monthly/quarterly budget_
+
+## Timeline
+
+_All times in UTC._
+
+| Time (UTC) | Event |
+|------------|-------|
+| HH:MM | Incident started (estimated) |
+| HH:MM | Detected — alert fired / report received |
+| HH:MM | Investigating — [who] started looking |
+| HH:MM | Mitigated — [action taken] |
+| HH:MM | Resolved — root cause fixed |
+| HH:MM | Verified — confirmed via [check] |
+
+## Communication Log
+
+| Time (UTC) | Channel | Message |
+|------------|---------|---------|
+| HH:MM | #incident-channel | Incident declared, investigating |
+| HH:MM | Status page | Updated to degraded performance |
+| HH:MM | #incident-channel | Mitigated, monitoring |
+| HH:MM | Status page | Resolved |
+
+## Diagnostics
+
+_What did you check? Include exact commands and what they showed._
+
+```bash
+# Example: check pod health
+kubectl get pods -n <namespace> | grep -v Running
+
+# Example: check error rate
+curl -s https://monitoring.example.com/api/v1/query?query=rate(http_errors[5m])
+```
+
+## Resolution
+
+_What fixed it?_
+
+1. _Action taken (e.g., rolled back deploy, restarted service)_
+2. _Verification: how you confirmed it was fixed_
+
+## Escalation
+
+_Who was involved? Was it escalated?_
+
+- First responder: @on-call
+- Escalated to: @team-lead (if applicable)
+- Stakeholders notified: #incident-channel
+
+## Metrics
+
+| Metric | Value |
+|--------|-------|
+| Time to detect | _X minutes_ |
+| Time to mitigate | _X minutes_ |
+| Time to resolve | _X minutes_ |
+| Total duration | _X minutes_ |
+
+## Follow-ups
+
+- [ ] Write postmortem → `postmortems/YYYY-MM-DD-slug.md`
+- [ ] File ticket for permanent fix
+- [ ] Update runbook if procedures were wrong or missing
+- [ ] Update monitoring if detection was too slow
+- [ ] Update escalation docs if escalation was unclear
+
+## Related
+
+- Procedure used: [[procedures/deploy-rollback]]
+- Postmortem: _link when written_
+- Similar past incidents: _link if any_
diff --git a/internal/workspace/templates/runbook/postmortems/template.md b/internal/workspace/templates/runbook/postmortems/template.md
new file mode 100644
index 00000000..b8c0778d
--- /dev/null
+++ b/internal/workspace/templates/runbook/postmortems/template.md
@@ -0,0 +1,121 @@
+---
+title: "Postmortem: [Short Description]"
+date: 2026-01-01
+incident: 
+severity: P2
+authors: []
+duration-minutes: 
+tags: [postmortem]
+---
+
+> **Blameless Postmortem Notice**
+>
+> This document follows blameless postmortem principles. We focus on:
+> - What happened (not who caused it)
+> - Why our systems allowed this to happen
+> - How we can prevent similar incidents
+>
+> Names appear only to establish timeline context, not to assign blame.
+> We assume everyone acted with good intentions based on the information
+> available to them at the time.
+
+# Postmortem: [Short Description]
+
+**Incident:** [[incidents/YYYY-MM-DD-slug]]
+**Date:** YYYY-MM-DD
+**Severity:** P1 / P2 / P3 / P4
+**Duration:** X hours Y minutes
+**Authors:** _who wrote this postmortem_
+
+## Summary
+
+_2-3 sentences for a broad audience: what happened, how long it lasted,
+what the impact was. Write this so a VP or customer-facing team can
+understand without reading the full document._
+
+## Impact
+
+- **Users affected:** _number or percentage_
+- **Error budget consumed:** _e.g., consumed 25% of monthly error budget_
+- **Revenue impact:** _if applicable_
+- **SLA impact:** _did we breach? Which SLOs were violated?_
+- **Data impact:** _any data loss or corruption?_
+
+## Timeline
+
+_All times in UTC. Include human decision points — what was decided and
+why it seemed reasonable at the time._
+
+| Time (UTC) | Event |
+|------------|-------|
+| HH:MM | Deployment triggered the issue |
+| HH:MM | Alert fired — `[alert name]` |
+| HH:MM | On-call began investigating |
+| HH:MM | Root cause identified |
+| HH:MM | Mitigation applied — `[action]` |
+| HH:MM | Fully resolved — verified via `[check]` |
+
+## Contributing Factors
+
+_What systemic conditions made this incident possible? Use the 5 Whys
+technique to dig past surface-level symptoms. There are usually multiple
+contributing factors — list them all._
+
+1. **[Factor 1]** — _description_
+   - Why? → _because..._
+   - Why? → _because..._
+   - Why? → _root systemic issue_
+2. **[Factor 2]** — _description_
+   - Why? → ...
+
+## What Went Well
+
+_Acknowledge what worked. This reinforces good practices._
+
+- _e.g., Alert fired within 2 minutes of threshold breach_
+- _e.g., Rollback procedure worked as documented_
+- _e.g., Cross-team communication was fast and clear_
+
+## What Went Wrong
+
+_What didn't work? Focus on systems and processes, not people._
+
+- _e.g., Took 30 minutes to identify root cause due to insufficient logging_
+- _e.g., No runbook existed for this specific failure mode_
+- _e.g., Deploy happened without canary, bypassing standard process_
+
+## Action Items
+
+_Each action item MUST have: a named person (not a team), a firm deadline,
+and a tracking ticket. Limit to 3-5 high-impact items — ruthlessly prioritize.
+Vague items like "improve monitoring" are not acceptable._
+
+| Action | Owner | Due | Ticket | Status |
+|--------|-------|-----|--------|--------|
+| Add alerting for [specific failure mode] | @person | YYYY-MM-DD | JIRA-123 | todo |
+| Update deploy rollback runbook with [step] | @person | YYYY-MM-DD | JIRA-124 | todo |
+| Add integration test for [scenario] | @person | YYYY-MM-DD | JIRA-125 | todo |
+
+## Lessons Learned
+
+_What should the team remember from this incident? What would you tell
+a new team member about this failure mode?_
+
+## Related
+
+- Incident: [[incidents/YYYY-MM-DD-slug]]
+- Related past incidents: _link any similar events_
+- Procedures used: [[procedures/relevant-procedure]]
+
+---
+
+## Postmortem Quality Checklist
+
+- [ ] Blameless — no individual blame language
+- [ ] Timeline is precise with UTC timestamps
+- [ ] Contributing factors go ≥ 3 levels deep (5 Whys)
+- [ ] Action items have named owners (people, not teams)
+- [ ] Action items have specific deadlines
+- [ ] Action items are filed in project tracker
+- [ ] Impact is quantified (users, SLO, revenue)
+- [ ] Published within 5 business days of resolution
diff --git a/internal/workspace/templates/runbook/procedures/deploy-rollback.md b/internal/workspace/templates/runbook/procedures/deploy-rollback.md
new file mode 100644
index 00000000..7f9953e4
--- /dev/null
+++ b/internal/workspace/templates/runbook/procedures/deploy-rollback.md
@@ -0,0 +1,80 @@
+---
+title: Deploy Rollback
+tags: [deployment, rollback, ci-cd]
+status: active
+last-reviewed: 2026-01-01
+last-tested: 2026-01-01
+test-cadence: quarterly
+estimated-time: "10-15 minutes"
+---
+
+# Deploy Rollback
+
+Roll back the most recent deployment when it causes issues in production.
+
+## When to Use
+
+- Health checks failing after a deploy
+- Error rate spike correlated with a recent deployment
+- Customer reports of broken functionality after a release
+
+## Prerequisites
+
+- [ ] Access to CI/CD dashboard
+- [ ] Permission to trigger deployments
+- [ ] Know the previous good version/commit
+
+## Steps
+
+### 1. Identify the Bad Deploy
+
+```bash
+# Check recent deployments (replace with your actual commands)
+git log --oneline -5 main
+
+# Or check your CI/CD tool
+# e.g., kubectl rollout history deployment/<name> -n <namespace>
+```
+
+### 2. Roll Back
+
+```bash
+# Option A: Revert the commit
+git revert <bad-commit-sha> --no-edit
+git push origin main
+
+# Option B: Redeploy previous version
+# kubectl rollout undo deployment/<name> -n <namespace>
+
+# Option C: Feature flag
+# Disable the flag in your feature flag dashboard
+```
+
+### 3. Verify
+
+```bash
+# Check health endpoint
+curl -s https://api.example.com/health
+# Expected: {"status":"ok"}
+
+# Check error rate is declining
+# Open monitoring dashboard: <URL>
+```
+
+### 4. Communicate
+
+- Post in `#team-urgent`: "Rolled back deploy [SHA]. Error rate recovering."
+- If customer-facing: update status page
+
+## Rollback of the Rollback
+
+If the rollback itself causes issues:
+
+1. Check if the revert introduced conflicts
+2. Consider deploying a known-good tag instead
+3. Escalate if neither works
+
+## Related
+
+- [[procedures/scale-up]] — if rollback isn't enough and you need capacity
+- [[incidents/template]] — document the incident
diff --git a/internal/workspace/templates/runbook/procedures/rotate-secrets.md b/internal/workspace/templates/runbook/procedures/rotate-secrets.md
new file mode 100644
index 00000000..4c4b8567
--- /dev/null
+++ b/internal/workspace/templates/runbook/procedures/rotate-secrets.md
@@ -0,0 +1,82 @@
+---
+title: Rotate Secrets
+tags: [security, secrets, credentials]
+status: active
+last-reviewed: 2026-01-01
+last-tested:
+test-cadence: quarterly
+estimated-time: "20-30 minutes"
+---
+
+# Rotate Secrets
+
+Rotate credentials, API keys, or certificates when they expire, are
+compromised, or as part of regular rotation policy.
+
+## When to Use
+
+- A credential has been exposed (leaked in logs, committed to repo)
+- Scheduled rotation (quarterly, annually)
+- An employee with access leaves the team
+- Vendor requires key rotation
+
+## Prerequisites
+
+- [ ] Access to secrets manager (e.g., AWS Secrets Manager, Vault, 1Password)
+- [ ] Permission to update secrets in production
+- [ ] Deployment pipeline access (secrets may require a redeploy)
+
+## Steps
+
+### 1. Generate New Credential
+
+```bash
+# Example: generate a new API key
+openssl rand -base64 32
+
+# Example: generate a new JWT secret
+openssl rand -hex 64
+```
+
+### 2. Update Secrets Manager
+
+```bash
+# Example: AWS Secrets Manager
+aws secretsmanager update-secret \
+  --secret-id "my-service/api-key" \
+  --secret-string '{"API_KEY":"<new-value>"}'
+```
+
+### 3. Deploy / Restart Services
+
+```bash
+# Services need to pick up the new secret
+# Option A: Redeploy
+# Option B: Restart
+# Option C: Service reads secrets dynamically (no action needed)
+```
+
+### 4. Verify
+
+- [ ] Service starts successfully with new credential
+- [ ] API calls using old credential are rejected (if applicable)
+- [ ] Health checks pass
+
+### 5. Revoke Old Credential
+
+```bash
+# Only after verifying the new one works
+# Revoke/delete the old key in the secrets manager or vendor dashboard
+```
+
+## Rollback
+
+If the new credential doesn't work:
+
+1. Re-set the old credential in secrets manager
+2. Restart/redeploy the service
+3. Investigate why the new credential failed before trying again
+
+## Related
+
+- [[procedures/deploy-rollback]] — if rotation requires a deploy
diff --git a/internal/workspace/templates/runbook/procedures/scale-up.md b/internal/workspace/templates/runbook/procedures/scale-up.md
new file mode 100644
index 00000000..6d3f94d6
--- /dev/null
+++ b/internal/workspace/templates/runbook/procedures/scale-up.md
@@ -0,0 +1,96 @@
+---
+title: Scale Up
+tags: [capacity, scaling, performance]
+status: active
+last-reviewed: 2026-01-01
+last-tested:
+test-cadence: quarterly
+estimated-time: "5-10 minutes"
+---
+
+# Scale Up
+
+Add capacity during a traffic spike, performance degradation, or
+when approaching resource limits.
+
+## When to Use
+
+- CPU/memory utilization exceeding 80% sustained
+- Request latency increasing beyond SLA thresholds
+- Known upcoming traffic event (launch, promotion, migration)
+- Auto-scaling is not responding fast enough
+
+## Prerequisites
+
+- [ ] Access to cloud console or CLI
+- [ ] Permission to modify instance counts / resource limits
+- [ ] Understanding of current architecture bottlenecks
+
+## Steps
+
+### 1. Identify the Bottleneck
+
+```bash
+# Check which component is saturated
+# CPU? Memory? Connections? Disk I/O?
+
+# Example: Kubernetes pod resource usage
+kubectl top pods -n <namespace>
+
+# Example: check connection pool
+# Query your monitoring dashboard: <URL>
+```
+
+### 2. Scale the Service
+
+```bash
+# Option A: Kubernetes horizontal scaling
+kubectl scale deployment/<name> -n <namespace> --replicas=<N>
+
+# Option B: Cloud provider auto-scaling group
+# aws autoscaling set-desired-capacity \
+#   --auto-scaling-group-name <asg-name> \
+#   --desired-capacity <N>
+
+# Option C: Vertical scaling (resize instance)
+# Requires downtime — schedule or use rolling update
+```
+
+### 3. Verify
+
+```bash
+# Confirm new instances are running
+kubectl get pods -n <namespace>
+
+# Confirm load is distributed
+# Check monitoring dashboard for reduced latency / CPU
+
+# Confirm health checks pass
+curl -s https://api.example.com/health
+```
+
+### 4. Monitor
+
+- Watch for 15-30 minutes to confirm stability
+- Verify the bottleneck metric has improved
+- Check for cascading issues (e.g., database connection limits)
+
+## Scale Down
+
+After the traffic event passes:
+
+1. Monitor metrics for 1-2 hours at reduced load
+2. Reduce replicas gradually (not all at once)
+3. Verify latency and error rates remain stable
+
+## Rollback
+
+If scaling up causes issues (e.g., database overwhelmed by new connections):
+
+1. Scale back to previous replica count
+2. Investigate the cascading failure
+3. Address the downstream bottleneck before scaling again
+
+## Related
+
+- [[procedures/deploy-rollback]] — if scaling was triggered by a bad deploy

From afbaaa2e27d8ab389fbfc97a6e90bcfb69795394 Mon Sep 17 00:00:00 2001
From: Array Fleet <fleet@advancedresearcharray.local>
Date: Tue, 30 Jun 2026 21:04:39 +0000
Subject: [PATCH 8/9] =?UTF-8?q?fix(ui):=20split=20view=20CI=20=E2=80=94=20?=
 =?UTF-8?q?template=20lint=20+=20pane=20size=20regression=20test?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Repair broken wiki links in runbook/research workspace templates so
TestRunbookTemplateLintClean and TestResearchTemplateLintClean pass.
Add splitView test guarding session-persisted pane widths.

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 .../2026-06-30-split-view-verification.md     | 47 +++++++++++++++++++
 .../research/experiments/exp-001-baseline.md  |  2 +-
 .../experiments/exp-002-placeholder.md        | 32 +++++++++++++
 .../templates/runbook/postmortems/template.md |  6 +--
 ui/src/lib/splitView.test.ts                  | 12 +++++
 5 files changed, 95 insertions(+), 4 deletions(-)
 create mode 100644 episodes/agents/cursor-issue-426/2026-06-30-split-view-verification.md
 create mode 100644 internal/workspace/templates/research/experiments/exp-002-placeholder.md

diff --git a/episodes/agents/cursor-issue-426/2026-06-30-split-view-verification.md b/episodes/agents/cursor-issue-426/2026-06-30-split-view-verification.md
new file mode 100644
index 00000000..83c54004
--- /dev/null
+++ b/episodes/agents/cursor-issue-426/2026-06-30-split-view-verification.md
@@ -0,0 +1,47 @@
+---
+memory_kind: episodic
+episode_id: cursor-issue-426-2026-06-30
+title: "Issue #426 split view — verification and CI template fixes"
+tags: [kiwifs, split-view, issue-426, regression-tests]
+date: 2026-06-30
+---
+
+# Issue #426 split view verification
+
+## Context
+
+Redelivery on `feat/issue-426-split-view` after PR #432 was closed (bot nudge comments, not code quality). Prior fleet work implemented full split-view feature; this run verified tests and fixed remaining CI blockers.
+
+## Pre-work
+
+- Searched local fix doc: `pages/fixes/kiwifs-kiwifs/issue-426-split-side-by-side-page-view.md`
+- Kiwi MCP gateway unavailable (empty MCP catalog)
+
+## Verification
+
+Branch `feat/issue-426-split-view` contains 7 commits on top of main implementing:
+- `splitView.ts` state + sessionStorage
+- `KiwiSplitView.tsx` + `ui/resizable.tsx`
+- App wiring, tree/wiki-link/history entry points, `Mod+\` toggle
+- Mobile guard (<768px)
+
+## Fixes this run
+
+1. **Workspace template lint (CI):** Fixed broken wiki links in runbook/research templates added by `d8e6573`:
+   - `postmortems/template.md` → link to `incidents/template` and `procedures/deploy-rollback`
+   - Added `experiments/exp-002-placeholder.md`; updated exp-001 baseline link
+2. **Regression test:** `persists custom pane sizes across session reload` in `splitView.test.ts`
+
+## Test results
+
+```
+cd ui && npm test -- src/lib/splitView.test.ts src/lib/kiwiKeybindings.test.ts  → 26 passed
+go test ./internal/keybindings/... -count=1  → ok
+go test ./internal/workspace/... -count=1  → ok
+```
+
+## Fleet handoff
+
+- Branch: `feat/issue-426-split-view`
+- Do not push from Cursor; fleet publishes PR closing #426
+- Fix doc updated at `pages/fixes/kiwifs-kiwifs/issue-426-split-side-by-side-page-view.md`
diff --git a/internal/workspace/templates/research/experiments/exp-001-baseline.md b/internal/workspace/templates/research/experiments/exp-001-baseline.md
index 33f93cd1..2ce63925 100644
--- a/internal/workspace/templates/research/experiments/exp-001-baseline.md
+++ b/internal/workspace/templates/research/experiments/exp-001-baseline.md
@@ -77,7 +77,7 @@ To re-run this experiment:
 
 ## Next Steps
 
-- [ ] Design [[experiments/exp-002|Experiment 002]] to test first variation
+- [ ] Design [[experiments/exp-002-placeholder|Experiment 002]] to test first variation
 - [ ] Document any anomalies for investigation
 
 ## Related
diff --git a/internal/workspace/templates/research/experiments/exp-002-placeholder.md b/internal/workspace/templates/research/experiments/exp-002-placeholder.md
new file mode 100644
index 00000000..42e8dea7
--- /dev/null
+++ b/internal/workspace/templates/research/experiments/exp-002-placeholder.md
@@ -0,0 +1,32 @@
+---
+title: "Experiment 002: [First Variation]"
+date: 2026-01-01
+hypothesis: "Describe what you expect to change vs the baseline"
+research-question: "Q1"
+status: planned
+result: inconclusive
+protocol: "Same as exp-001 with one controlled change"
+environment: "Match exp-001 baseline environment"
+tags: [experiment, placeholder]
+references: [experiments/exp-001-baseline.md]
+---
+
+# Experiment 002 — [First Variation]
+
+> **Placeholder experiment.** Copy this page when designing the first variation
+> after [[experiments/exp-001-baseline|Experiment 001 baseline]].
+
+## Hypothesis
+
+_What single change are you testing against the baseline?_
+
+## Variables
+
+- **Independent:** _the one thing you change_
+- **Dependent:** throughput, latency (p50, p99), error rate
+- **Controlled:** match exp-001 environment and protocol
+
+## Related
+
+- Baseline: [[experiments/exp-001-baseline]]
+- Literature: [[literature/example-paper]]
diff --git a/internal/workspace/templates/runbook/postmortems/template.md b/internal/workspace/templates/runbook/postmortems/template.md
index b8c0778d..69cd4be1 100644
--- a/internal/workspace/templates/runbook/postmortems/template.md
+++ b/internal/workspace/templates/runbook/postmortems/template.md
@@ -21,7 +21,7 @@ tags: [postmortem]
 
 # Postmortem: [Short Description]
 
-**Incident:** [[incidents/YYYY-MM-DD-slug]]
+**Incident:** [[incidents/template]]
 **Date:** YYYY-MM-DD
 **Severity:** P1 / P2 / P3 / P4
 **Duration:** X hours Y minutes
@@ -103,9 +103,9 @@ a new team member about this failure mode?_
 
 ## Related
 
-- Incident: [[incidents/YYYY-MM-DD-slug]]
+- Incident: [[incidents/template]]
 - Related past incidents: _link any similar events_
-- Procedures used: [[procedures/relevant-procedure]]
+- Procedures used: [[procedures/deploy-rollback]]
 
 ---
 
diff --git a/ui/src/lib/splitView.test.ts b/ui/src/lib/splitView.test.ts
index d70eb5c9..1c926912 100644
--- a/ui/src/lib/splitView.test.ts
+++ b/ui/src/lib/splitView.test.ts
@@ -40,6 +40,18 @@ describe("splitView", () => {
     expect(loadSplitViewState()).toEqual(state);
   });
 
+  it("persists custom pane sizes across session reload", () => {
+    const state = openPathInSplit(
+      createSplitViewState({ sizes: [35, 65] }),
+      "notes/b.md",
+    );
+    saveSplitViewState(state);
+    const restored = loadSplitViewState();
+    expect(restored?.sizes).toEqual([35, 65]);
+    expect(restored?.enabled).toBe(true);
+    expect(restored?.rightPath).toBe("notes/b.md");
+  });
+
   it("ignores invalid session payloads", () => {
     storage.set(SPLIT_VIEW_SESSION_KEY, "{not json");
     expect(loadSplitViewState()).toBeNull();

From b92d57a18fb78e96464b1e08dd7c4a23f40104aa Mon Sep 17 00:00:00 2001
From: Array Fleet <fleet@advancedresearcharray.local>
Date: Tue, 30 Jun 2026 21:06:59 +0000
Subject: [PATCH 9/9] docs(episodes): log issue #426 hands-on delivery run

Signed-off-by: Array Fleet <fleet@advancedresearcharray.local>
Co-authored-by: Cursor <cursoragent@cursor.com>
---
 .../2026-06-30-issue-426-delivery.md          | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 episodes/agents/cursor-hands-on/2026-06-30-issue-426-delivery.md

diff --git a/episodes/agents/cursor-hands-on/2026-06-30-issue-426-delivery.md b/episodes/agents/cursor-hands-on/2026-06-30-issue-426-delivery.md
new file mode 100644
index 00000000..006c5c11
--- /dev/null
+++ b/episodes/agents/cursor-hands-on/2026-06-30-issue-426-delivery.md
@@ -0,0 +1,28 @@
+---
+memory_kind: episodic
+episode_id: cursor-hands-on-2026-06-30-issue-426
+title: "Issue #426 split view — hands-on delivery and PR publish"
+tags: [kiwifs, split-view, issue-426, delivery, pr]
+date: 2026-06-30
+---
+
+# Issue #426 hands-on delivery
+
+## Context
+
+Fleet engineer did not complete verified delivery (`peer_review_not_passed`). Took over on `feat/issue-426-split-view` with 8 commits implementing split/side-by-side page view.
+
+## Verification
+
+- UI tests: 207 passed (`cd ui && npm test`)
+- Split/keybinding tests: 26 passed
+- Go keybindings + workspace tests: ok
+- Branch clean; pushed to origin; PR opened with `Closes #426`
+
+## Kiwi MCP
+
+Gateway at 192.168.167.240:3333 unreachable. Fix doc written locally at `pages/fixes/kiwifs-kiwifs/issue-426-split-side-by-side-page-view.md` (gitignored by `kiwifs-*` pattern).
+
+## Outcome
+
+PR published for merge; all acceptance criteria covered on branch.