diff --git a/docs/USER_GUIDE.md b/docs/USER_GUIDE.md
index a3ad1d28..13d73138 100644
--- a/docs/USER_GUIDE.md
+++ b/docs/USER_GUIDE.md
@@ -367,13 +367,13 @@ The Tracked tab lets you pin issues and PRs into a personal TODO list that you c
 
 ## Repo Pinning
 
-Each repo group header has a pin (lock) control, visible on hover on desktop and always visible on mobile. Pinning a repo keeps it at the top of the list on all tabs regardless of sort order or how recently it was updated. Pinned repos remain visible even when filters exclude all their items — they appear as compact, de-emphasized rows with the repo name and pin controls still accessible.
+Each repo group header has a pin (lock) control, visible on hover on desktop and always visible on mobile. Pinning a repo keeps it at the top of the list regardless of sort order or how recently it was updated. Pinned repos remain visible even when filters exclude all their items — they appear as compact, de-emphasized rows with the repo name and pin controls still accessible.
 
 - Click the pin icon to pin a repo to the top.
 - Click it again to unpin.
 - Use the up/down arrows (visible when pinned) to reorder pinned repos relative to each other.
 
-Pin state is shared across all tabs — pinning a repo on the Issues tab also pins it on Pull Requests and Actions.
+Pin state is per-tab — pinning a repo on the Issues tab does not pin it on Pull Requests or Actions. Each tab maintains its own independent pin list and ordering.
 
 ---
 
@@ -455,7 +455,7 @@ These are UI preferences that persist across sessions but are not included in th
 | Show PR runs (Actions) | Off | Whether to show workflow runs triggered by pull request events. |
 | Hide Dependency Dashboard | On | Whether to hide the Renovate Dependency Dashboard issue. |
 | Sort preferences | Updated (desc) | Sort field and direction per tab, remembered across sessions. |
-| Pinned repos | (none) | Repos pinned to the top of the list across all tabs. |
+| Pinned repos | (none) | Repos pinned to the top of the list, stored per tab independently. |
 | Tracked items | (none) | Issues and PRs pinned to the Tracked tab (max 200). |
 
 ---
diff --git a/src/app/components/dashboard/ActionsTab.tsx b/src/app/components/dashboard/ActionsTab.tsx
index 062c306d..260c3ee4 100644
--- a/src/app/components/dashboard/ActionsTab.tsx
+++ b/src/app/components/dashboard/ActionsTab.tsx
@@ -189,23 +189,24 @@ export default function ActionsTab(props: ActionsTabProps) {
 
   const repoGroups = createMemo(() => {
     const groups = groupRuns(filteredRuns());
+    const lockedForTab = viewState.lockedRepos[tabKey()] ?? [];
     const withLocked = ensureLockedRepoGroups(
       groups,
-      viewState.lockedRepos,
+      lockedForTab,
       (name) => ({ repoFullName: name, workflows: [] }),
     );
-    return orderRepoGroups(withLocked, viewState.lockedRepos);
+    return orderRepoGroups(withLocked, lockedForTab);
   });
 
   createEffect(() => {
     const names = activeRepoNames();
     if (names.length === 0) return;
-    pruneLockedRepos(names);
+    pruneLockedRepos(tabKey(), names);
   });
 
   const highlightedReposActions = createReorderHighlight(
     () => repoGroups().map(g => g.repoFullName),
-    () => viewState.lockedRepos,
+    () => viewState.lockedRepos[tabKey()] ?? [],
     () => ignoredWorkflowRuns().length,
     () => JSON.stringify(props.customTabId
       ? (viewState.customTabFilters[props.customTabId] ?? {})
@@ -291,7 +292,7 @@ export default function ActionsTab(props: ActionsTabProps) {
               <Show
                 when={!isEmpty()}
                 fallback={
-                  <EmptyLockedRepoRow repoFullName={repoGroup.repoFullName} section="actions" />
+                  <EmptyLockedRepoRow repoFullName={repoGroup.repoFullName} section="actions" tabKey={tabKey()} />
                 }
               >
                 <div class="bg-base-100" data-repo-group={repoGroup.repoFullName}>
@@ -303,7 +304,7 @@ export default function ActionsTab(props: ActionsTabProps) {
                     trailing={
                       <>
                         <RepoGitHubLink repoFullName={repoGroup.repoFullName} section="actions" />
-                        <RepoLockControls repoFullName={repoGroup.repoFullName} />
+                        <RepoLockControls repoFullName={repoGroup.repoFullName} tabKey={tabKey()} />
                       </>
                     }
                     collapsedSummary={
diff --git a/src/app/components/dashboard/DashboardPage.tsx b/src/app/components/dashboard/DashboardPage.tsx
index 035a2309..fed30b6e 100644
--- a/src/app/components/dashboard/DashboardPage.tsx
+++ b/src/app/components/dashboard/DashboardPage.tsx
@@ -703,6 +703,7 @@ export default function DashboardPage() {
       const keys = new Set([
         ...Object.keys(viewState.customTabFilters),
         ...Object.keys(viewState.expandedRepos).filter((k) => !isBuiltinTab(k)),
+        ...Object.keys(viewState.lockedRepos).filter((k) => !isBuiltinTab(k)),
       ]);
       return [...keys].filter((id) => !activeIds.has(id));
     });
diff --git a/src/app/components/dashboard/IssuesTab.tsx b/src/app/components/dashboard/IssuesTab.tsx
index 3ae69934..07917b4e 100644
--- a/src/app/components/dashboard/IssuesTab.tsx
+++ b/src/app/components/dashboard/IssuesTab.tsx
@@ -187,12 +187,13 @@ export default function IssuesTab(props: IssuesTabProps) {
 
   const repoGroups = createMemo(() => {
     const groups = groupByRepo(filteredSorted());
+    const lockedForTab = viewState.lockedRepos[tabKey()] ?? [];
     const withLocked = ensureLockedRepoGroups(
       groups,
-      viewState.lockedRepos,
+      lockedForTab,
       (name) => ({ repoFullName: name, items: [] as typeof groups[0]["items"] }),
     );
-    return orderRepoGroups(withLocked, viewState.lockedRepos);
+    return orderRepoGroups(withLocked, lockedForTab);
   });
   const pageLayout = createMemo(() => computePageLayout(repoGroups(), config.itemsPerPage));
   const pageCount = createMemo(() => pageLayout().pageCount);
@@ -218,7 +219,7 @@ export default function IssuesTab(props: IssuesTabProps) {
   createEffect(() => {
     const names = activeRepoNames();
     if (names.length === 0) return;
-    pruneLockedRepos(names);
+    pruneLockedRepos(tabKey(), names);
   });
 
   const trackedIssueIds = createMemo(() =>
@@ -229,7 +230,7 @@ export default function IssuesTab(props: IssuesTabProps) {
 
   const highlightedReposIssues = createReorderHighlight(
     () => repoGroups().map(g => g.repoFullName),
-    () => viewState.lockedRepos,
+    () => viewState.lockedRepos[tabKey()] ?? [],
     () => ignoredIssues().length,
     () => JSON.stringify(props.customTabId
       ? (viewState.customTabFilters[props.customTabId] ?? {})
@@ -355,7 +356,7 @@ export default function IssuesTab(props: IssuesTabProps) {
                   <Show
                     when={!isEmpty()}
                     fallback={
-                      <EmptyLockedRepoRow repoFullName={repoGroup.repoFullName} section="issues" />
+                      <EmptyLockedRepoRow repoFullName={repoGroup.repoFullName} section="issues" tabKey={tabKey()} />
                     }
                   >
                     <div class="bg-base-100" data-repo-group={repoGroup.repoFullName}>
@@ -375,7 +376,7 @@ export default function IssuesTab(props: IssuesTabProps) {
                         trailing={
                           <>
                             <RepoGitHubLink repoFullName={repoGroup.repoFullName} section="issues" />
-                            <RepoLockControls repoFullName={repoGroup.repoFullName} />
+                            <RepoLockControls repoFullName={repoGroup.repoFullName} tabKey={tabKey()} />
                           </>
                         }
                         collapsedSummary={
diff --git a/src/app/components/dashboard/PullRequestsTab.tsx b/src/app/components/dashboard/PullRequestsTab.tsx
index defdf9c8..9bda6dc1 100644
--- a/src/app/components/dashboard/PullRequestsTab.tsx
+++ b/src/app/components/dashboard/PullRequestsTab.tsx
@@ -251,12 +251,13 @@ export default function PullRequestsTab(props: PullRequestsTabProps) {
 
   const repoGroups = createMemo(() => {
     const groups = groupByRepo(filteredSorted());
+    const lockedForTab = viewState.lockedRepos[tabKey()] ?? [];
     const withLocked = ensureLockedRepoGroups(
       groups,
-      viewState.lockedRepos,
+      lockedForTab,
       (name) => ({ repoFullName: name, items: [] as typeof groups[0]["items"] }),
     );
-    return orderRepoGroups(withLocked, viewState.lockedRepos);
+    return orderRepoGroups(withLocked, lockedForTab);
   });
   const pageLayout = createMemo(() => computePageLayout(repoGroups(), config.itemsPerPage));
   const pageCount = createMemo(() => pageLayout().pageCount);
@@ -282,7 +283,7 @@ export default function PullRequestsTab(props: PullRequestsTabProps) {
   createEffect(() => {
     const names = activeRepoNames();
     if (names.length === 0) return;
-    pruneLockedRepos(names);
+    pruneLockedRepos(tabKey(), names);
   });
 
   const { flashingIds: flashingPRIds, peekUpdates } = createFlashDetection({
@@ -302,7 +303,7 @@ export default function PullRequestsTab(props: PullRequestsTabProps) {
 
   const highlightedReposPRs = createReorderHighlight(
     () => repoGroups().map(g => g.repoFullName),
-    () => viewState.lockedRepos,
+    () => viewState.lockedRepos[tabKey()] ?? [],
     () => ignoredPullRequests().length,
     () => JSON.stringify(props.customTabId
       ? (viewState.customTabFilters[props.customTabId] ?? {})
@@ -429,7 +430,7 @@ export default function PullRequestsTab(props: PullRequestsTabProps) {
                   <Show
                     when={!isEmpty()}
                     fallback={
-                      <EmptyLockedRepoRow repoFullName={repoGroup.repoFullName} section="pulls" />
+                      <EmptyLockedRepoRow repoFullName={repoGroup.repoFullName} section="pulls" tabKey={tabKey()} />
                     }
                   >
                     <div class="bg-base-100" data-repo-group={repoGroup.repoFullName}>
@@ -449,7 +450,7 @@ export default function PullRequestsTab(props: PullRequestsTabProps) {
                         trailing={
                           <>
                             <RepoGitHubLink repoFullName={repoGroup.repoFullName} section="pulls" />
-                            <RepoLockControls repoFullName={repoGroup.repoFullName} />
+                            <RepoLockControls repoFullName={repoGroup.repoFullName} tabKey={tabKey()} />
                           </>
                         }
                         collapsedSummary={
diff --git a/src/app/components/shared/EmptyLockedRepoRow.tsx b/src/app/components/shared/EmptyLockedRepoRow.tsx
index 74b1974e..934c075b 100644
--- a/src/app/components/shared/EmptyLockedRepoRow.tsx
+++ b/src/app/components/shared/EmptyLockedRepoRow.tsx
@@ -4,6 +4,7 @@ import RepoLockControls from "./RepoLockControls";
 export default function EmptyLockedRepoRow(props: {
   repoFullName: string;
   section: "issues" | "pulls" | "actions";
+  tabKey: string;
 }) {
   return (
     <div
@@ -15,7 +16,7 @@ export default function EmptyLockedRepoRow(props: {
         <span class="text-sm text-base-content/60">{props.repoFullName}</span>
       </span>
       <RepoGitHubLink repoFullName={props.repoFullName} section={props.section} />
-      <RepoLockControls repoFullName={props.repoFullName} />
+      <RepoLockControls repoFullName={props.repoFullName} tabKey={props.tabKey} />
     </div>
   );
 }
diff --git a/src/app/components/shared/RepoLockControls.tsx b/src/app/components/shared/RepoLockControls.tsx
index be6cbf25..1e4dbf8f 100644
--- a/src/app/components/shared/RepoLockControls.tsx
+++ b/src/app/components/shared/RepoLockControls.tsx
@@ -5,11 +5,12 @@ import { withFlipAnimation } from "../../lib/scroll";
 
 interface RepoLockControlsProps {
   repoFullName: string;
+  tabKey: string;
 }
 
 export default function RepoLockControls(props: RepoLockControlsProps) {
   const lockInfo = createMemo(() => {
-    const list = viewState.lockedRepos;
+    const list = viewState.lockedRepos[props.tabKey] ?? [];
     const idx = list.indexOf(props.repoFullName);
     return {
       isLocked: idx !== -1,
@@ -26,7 +27,7 @@ export default function RepoLockControls(props: RepoLockControlsProps) {
           <Tooltip content="Pin to top">
             <button
               class="btn btn-ghost btn-xs opacity-0 group-hover/repo-header:opacity-100 focus:opacity-100 max-sm:opacity-60 sm:max-lg:opacity-60 transition-opacity"
-              onClick={() => withFlipAnimation(() => lockRepo(props.repoFullName))}
+              onClick={() => withFlipAnimation(() => lockRepo(props.tabKey, props.repoFullName))}
               aria-label={`Pin ${props.repoFullName} to top of list`}
             >
               {/* Heroicons 20px solid: lock-open */}
@@ -40,7 +41,7 @@ export default function RepoLockControls(props: RepoLockControlsProps) {
         <Tooltip content="Unpin">
           <button
             class="btn btn-ghost btn-xs"
-            onClick={() => withFlipAnimation(() => unlockRepo(props.repoFullName))}
+            onClick={() => withFlipAnimation(() => unlockRepo(props.tabKey, props.repoFullName))}
             aria-label={`Unpin ${props.repoFullName}`}
           >
             {/* Heroicons 20px solid: lock-closed */}
@@ -52,7 +53,7 @@ export default function RepoLockControls(props: RepoLockControlsProps) {
         <Tooltip content={lockInfo().isFirst ? "Already at top of pinned list" : "Move up"}>
           <button
             class="btn btn-ghost btn-xs"
-            onClick={() => withFlipAnimation(() => moveLockedRepo(props.repoFullName, "up"))}
+            onClick={() => withFlipAnimation(() => moveLockedRepo(props.tabKey, props.repoFullName, "up"))}
             disabled={lockInfo().isFirst}
             aria-label={`Move ${props.repoFullName} up`}
           >
@@ -65,7 +66,7 @@ export default function RepoLockControls(props: RepoLockControlsProps) {
         <Tooltip content={lockInfo().isLast ? "Already at bottom of pinned list" : "Move down"}>
           <button
             class="btn btn-ghost btn-xs"
-            onClick={() => withFlipAnimation(() => moveLockedRepo(props.repoFullName, "down"))}
+            onClick={() => withFlipAnimation(() => moveLockedRepo(props.tabKey, props.repoFullName, "down"))}
             disabled={lockInfo().isLast}
             aria-label={`Move ${props.repoFullName} down`}
           >
diff --git a/src/app/stores/view.ts b/src/app/stores/view.ts
index 36582dce..3d96b5f2 100644
--- a/src/app/stores/view.ts
+++ b/src/app/stores/view.ts
@@ -6,7 +6,7 @@ import { pushNotification } from "../lib/errors";
 export const VIEW_STORAGE_KEY = "github-tracker:view";
 const IGNORED_ITEMS_CAP = 500;
 const TRACKED_ITEMS_CAP = 200;
-const LOCKED_REPOS_CAP = 50;
+export const LOCKED_REPOS_CAP = 50;
 
 export const TrackedItemSchema = z.object({
   id: z.number(),
@@ -95,38 +95,27 @@ export const ViewStateSchema = z.object({
     pullRequests: {},
     actions: {},
   }),
-  lockedRepos: z.array(z.string().max(200)).max(LOCKED_REPOS_CAP).default([]),
+  lockedRepos: z.record(z.string(), z.array(z.string().max(200)).max(LOCKED_REPOS_CAP)).default({ issues: [], pullRequests: [], actions: [] }),
   trackedItems: z.array(TrackedItemSchema).max(TRACKED_ITEMS_CAP).default([]),
 });
 
 export type ViewState = z.infer<typeof ViewStateSchema>;
 export type IgnoredItem = ViewState["ignoredItems"][number];
 
-export function migrateLockedRepos(raw: unknown, lastActiveTab?: unknown): unknown {
-  if (Array.isArray(raw) || raw == null) return raw;
-  if (typeof raw !== "object") return raw;
-  const obj = raw as Record<string, unknown>;
-  if (!("issues" in obj || "pullRequests" in obj || "actions" in obj)) return raw;
-  const tabs = ["issues", "pullRequests", "actions"] as const;
-  const preferred = (typeof lastActiveTab === "string" && tabs.includes(lastActiveTab as typeof tabs[number]))
-    ? lastActiveTab as typeof tabs[number]
-    : "issues";
-  const remaining = tabs.filter(t => t !== preferred);
-  const all = [preferred, ...remaining];
-  const seen = new Set<string>();
-  const result: string[] = [];
-  for (const tab of all) {
-    const arr = obj[tab];
-    if (Array.isArray(arr)) {
-      for (const item of arr) {
-        if (typeof item === "string" && !seen.has(item)) {
-          seen.add(item);
-          result.push(item);
-        }
-      }
-    }
+const REPO_STATE_TAB_IDS = ["issues", "pullRequests", "actions"] as const;
+
+export function migrateLockedRepos(raw: unknown): unknown {
+  if (raw == null) return { issues: [], pullRequests: [], actions: [] };
+  if (Array.isArray(raw)) {
+    // Flat array → copy to all 3 built-in tabs
+    const arr = raw.filter((item): item is string => typeof item === "string").slice(0, LOCKED_REPOS_CAP);
+    return { issues: [...arr], pullRequests: [...arr], actions: [...arr] };
   }
-  return result.slice(0, LOCKED_REPOS_CAP);
+  if (typeof raw === "object") {
+    // Object → pass through as-is; loadViewState cap-guard sanitizes malformed entries
+    return raw;
+  }
+  return { issues: [], pullRequests: [], actions: [] };
 }
 
 function loadViewState(): ViewState {
@@ -138,11 +127,19 @@ function loadViewState(): ViewState {
       return ViewStateSchema.parse({});
     }
     const obj = parsed as Record<string, unknown>;
-    obj.lockedRepos = migrateLockedRepos(obj.lockedRepos, obj.lastActiveTab);
-    // Cap lockedRepos before Zod validates — an oversized array would fail
-    // .max(LOCKED_REPOS_CAP) and reject the ENTIRE ViewState, wiping all settings.
-    if (Array.isArray(obj.lockedRepos) && obj.lockedRepos.length > LOCKED_REPOS_CAP) {
-      obj.lockedRepos = obj.lockedRepos.slice(0, LOCKED_REPOS_CAP);
+    obj.lockedRepos = migrateLockedRepos(obj.lockedRepos);
+    // Cap lockedRepos entries before Zod validates — a corrupt or oversized entry would
+    // fail .max(LOCKED_REPOS_CAP) and reject the ENTIRE ViewState, wiping all settings.
+    if (typeof obj.lockedRepos === "object" && obj.lockedRepos !== null && !Array.isArray(obj.lockedRepos)) {
+      const record = obj.lockedRepos as Record<string, unknown>;
+      for (const [key, val] of Object.entries(record)) {
+        if (!Array.isArray(val)) {
+          delete record[key];
+        } else {
+          const filtered = val.filter((item): item is string => typeof item === "string");
+          record[key] = filtered.length > LOCKED_REPOS_CAP ? filtered.slice(0, LOCKED_REPOS_CAP) : filtered;
+        }
+      }
     }
     const result = ViewStateSchema.safeParse(parsed);
     if (result.success) return result.data;
@@ -161,13 +158,18 @@ export function resetViewState(): void {
     produce((draft) => {
       // Delete dynamic custom tab keys that Object.assign wouldn't clear
       for (const key of Object.keys(draft.expandedRepos)) {
-        if (!["issues", "pullRequests", "actions"].includes(key)) {
+        if (!(REPO_STATE_TAB_IDS as readonly string[]).includes(key)) {
           delete draft.expandedRepos[key];
         }
       }
       for (const key of Object.keys(draft.customTabFilters)) {
         delete draft.customTabFilters[key];
       }
+      for (const key of Object.keys(draft.lockedRepos)) {
+        if (!(REPO_STATE_TAB_IDS as readonly string[]).includes(key)) {
+          delete draft.lockedRepos[key];
+        }
+      }
       Object.assign(draft, {
         lastActiveTab: "issues",
         globalSort: { field: "updatedAt", direction: "desc" },
@@ -182,7 +184,7 @@ export function resetViewState(): void {
         hideDepDashboard: true,
         customTabFilters: {},
         expandedRepos: { issues: {}, pullRequests: {}, actions: {} },
-        lockedRepos: [],
+        lockedRepos: { issues: [], pullRequests: [], actions: [] },
         trackedItems: [],
       });
     })
@@ -365,51 +367,66 @@ export function removeCustomTabState(tabId: string): void {
     produce((draft) => {
       delete draft.customTabFilters[tabId];
       delete draft.expandedRepos[tabId];
+      delete draft.lockedRepos[tabId];
     })
   );
 }
 
-export function lockRepo(repoFullName: string): void {
-  setViewState(produce((draft) => {
-    if (!draft.lockedRepos.includes(repoFullName) && draft.lockedRepos.length < LOCKED_REPOS_CAP) {
-      draft.lockedRepos.push(repoFullName);
-    }
-  }));
+export function lockRepo(tabKey: string, repoFullName: string): void {
+  setViewState(
+    produce((draft) => {
+      if (!draft.lockedRepos[tabKey]) draft.lockedRepos[tabKey] = [];
+      const arr = draft.lockedRepos[tabKey];
+      if (!arr.includes(repoFullName) && arr.length < LOCKED_REPOS_CAP) {
+        arr.push(repoFullName);
+      }
+    })
+  );
 }
 
-export function unlockRepo(repoFullName: string): void {
-  setViewState(produce((draft) => {
-    draft.lockedRepos = draft.lockedRepos.filter(r => r !== repoFullName);
-  }));
+export function unlockRepo(tabKey: string, repoFullName: string): void {
+  setViewState(
+    produce((draft) => {
+      if (!draft.lockedRepos[tabKey]) return;
+      draft.lockedRepos[tabKey] = draft.lockedRepos[tabKey].filter((r) => r !== repoFullName);
+    })
+  );
 }
 
 export function moveLockedRepo(
+  tabKey: string,
   repoFullName: string,
   direction: "up" | "down"
 ): void {
-  setViewState(produce((draft) => {
-    const arr = draft.lockedRepos;
-    const idx = arr.indexOf(repoFullName);
-    if (idx === -1) return;
-    const targetIdx = direction === "up" ? idx - 1 : idx + 1;
-    if (targetIdx < 0 || targetIdx >= arr.length) return;
-    const tmp = arr[idx];
-    arr[idx] = arr[targetIdx];
-    arr[targetIdx] = tmp;
-  }));
+  setViewState(
+    produce((draft) => {
+      if (!draft.lockedRepos[tabKey]) return;
+      const arr = draft.lockedRepos[tabKey];
+      const idx = arr.indexOf(repoFullName);
+      if (idx === -1) return;
+      const targetIdx = direction === "up" ? idx - 1 : idx + 1;
+      if (targetIdx < 0 || targetIdx >= arr.length) return;
+      const tmp = arr[idx];
+      arr[idx] = arr[targetIdx];
+      arr[targetIdx] = tmp;
+    })
+  );
 }
 
 export function pruneLockedRepos(
+  tabKey: string,
   activeRepoNames: string[]
 ): void {
-  const current = untrack(() => viewState.lockedRepos);
+  const current = untrack(() => viewState.lockedRepos[tabKey] ?? []);
   if (current.length === 0) return;
   const activeSet = new Set(activeRepoNames);
-  const filtered = current.filter(name => activeSet.has(name));
+  const filtered = current.filter((name) => activeSet.has(name));
   if (filtered.length === current.length) return;
-  setViewState(produce((draft) => {
-    draft.lockedRepos = filtered;
-  }));
+  setViewState(
+    produce((draft) => {
+      draft.lockedRepos[tabKey] = filtered;
+    })
+  );
 }
 
 export function trackItem(item: TrackedItem): void {
@@ -444,16 +461,18 @@ export function moveTrackedItem(
   type: "issue" | "pullRequest",
   direction: "up" | "down"
 ): void {
-  setViewState(produce((draft) => {
-    const arr = draft.trackedItems;
-    const idx = arr.findIndex((i) => i.id === id && i.type === type);
-    if (idx === -1) return;
-    const targetIdx = direction === "up" ? idx - 1 : idx + 1;
-    if (targetIdx < 0 || targetIdx >= arr.length) return;
-    const tmp = arr[idx];
-    arr[idx] = arr[targetIdx];
-    arr[targetIdx] = tmp;
-  }));
+  setViewState(
+    produce((draft) => {
+      const arr = draft.trackedItems;
+      const idx = arr.findIndex((i) => i.id === id && i.type === type);
+      if (idx === -1) return;
+      const targetIdx = direction === "up" ? idx - 1 : idx + 1;
+      if (targetIdx < 0 || targetIdx >= arr.length) return;
+      const tmp = arr[idx];
+      arr[idx] = arr[targetIdx];
+      arr[targetIdx] = tmp;
+    })
+  );
 }
 
 export function pruneClosedTrackedItems(pruneKeys: Set<string>): void {
diff --git a/tests/components/dashboard/ActionsTab.test.tsx b/tests/components/dashboard/ActionsTab.test.tsx
index 7c535e16..6662177b 100644
--- a/tests/components/dashboard/ActionsTab.test.tsx
+++ b/tests/components/dashboard/ActionsTab.test.tsx
@@ -79,7 +79,7 @@ describe("ActionsTab — empty-repo state preservation", () => {
     setViewState(produce((s) => {
       s.expandedRepos.actions["owner/empty-repo"] = true;
       s.expandedRepos.actions["owner/stale-repo"] = true;
-      s.lockedRepos = ["owner/empty-repo", "owner/stale-repo"];
+      s.lockedRepos.actions = ["owner/empty-repo", "owner/stale-repo"];
     }));
 
     render(() => (
@@ -91,10 +91,10 @@ describe("ActionsTab — empty-repo state preservation", () => {
 
     // Empty repo preserved (in configRepoNames but no items)
     expect(viewState.expandedRepos.actions["owner/empty-repo"]).toBe(true);
-    expect(viewState.lockedRepos).toContain("owner/empty-repo");
+    expect(viewState.lockedRepos["actions"]).toContain("owner/empty-repo");
     // Stale repo pruned (not in configRepoNames)
     expect(viewState.expandedRepos.actions["owner/stale-repo"]).toBeUndefined();
-    expect(viewState.lockedRepos).not.toContain("owner/stale-repo");
+    expect(viewState.lockedRepos["actions"]).not.toContain("owner/stale-repo");
   });
 
   it("falls back to item-derived names when configRepoNames not provided", () => {
@@ -102,12 +102,12 @@ describe("ActionsTab — empty-repo state preservation", () => {
       <ActionsTab workflowRuns={[]} />
     ));
     // With empty items and no configRepoNames, guard returns early — no pruning
-    expect(viewState.lockedRepos).toEqual([]);
+    expect(viewState.lockedRepos["actions"]).toEqual([]);
   });
 
   it("renders compact stub row for a locked repo with no workflow runs", () => {
     setViewState(produce((s) => {
-      s.lockedRepos = ["owner/locked-empty"];
+      s.lockedRepos.actions = ["owner/locked-empty"];
     }));
 
     const { container } = render(() => (
@@ -126,7 +126,7 @@ describe("ActionsTab — empty-repo state preservation", () => {
 
   it("does not expand a locked repo with no workflow runs even when expandedRepos is set", () => {
     setViewState(produce((s) => {
-      s.lockedRepos = ["owner/locked-empty"];
+      s.lockedRepos.actions = ["owner/locked-empty"];
       s.expandedRepos.actions["owner/locked-empty"] = true;
     }));
 
@@ -144,7 +144,7 @@ describe("ActionsTab — empty-repo state preservation", () => {
 
   it("hides empty-state message when only locked stubs exist (no double render)", () => {
     setViewState(produce((s) => {
-      s.lockedRepos = ["owner/locked-empty"];
+      s.lockedRepos.actions = ["owner/locked-empty"];
     }));
 
     const { container } = render(() => (
@@ -163,7 +163,7 @@ describe("ActionsTab — empty-repo state preservation", () => {
 
   it("hides locked stubs during initial load (no skeleton + stub double render)", () => {
     setViewState(produce((s) => {
-      s.lockedRepos = ["owner/locked-empty"];
+      s.lockedRepos.actions = ["owner/locked-empty"];
     }));
 
     const { container } = render(() => (
diff --git a/tests/components/dashboard/IssuesTab.test.tsx b/tests/components/dashboard/IssuesTab.test.tsx
index f261a994..16d614a7 100644
--- a/tests/components/dashboard/IssuesTab.test.tsx
+++ b/tests/components/dashboard/IssuesTab.test.tsx
@@ -714,7 +714,7 @@ describe("IssuesTab — empty-repo state preservation", () => {
     setViewState(produce((s) => {
       s.expandedRepos.issues["owner/empty-repo"] = true;
       s.expandedRepos.issues["owner/stale-repo"] = true;
-      s.lockedRepos = ["owner/empty-repo", "owner/stale-repo"];
+      s.lockedRepos.issues = ["owner/empty-repo", "owner/stale-repo"];
     }));
 
     render(() => (
@@ -727,10 +727,10 @@ describe("IssuesTab — empty-repo state preservation", () => {
 
     // Empty repo preserved (in configRepoNames but no items)
     expect(viewState.expandedRepos.issues["owner/empty-repo"]).toBe(true);
-    expect(viewState.lockedRepos).toContain("owner/empty-repo");
+    expect(viewState.lockedRepos["issues"]).toContain("owner/empty-repo");
     // Stale repo pruned (not in configRepoNames)
     expect(viewState.expandedRepos.issues["owner/stale-repo"]).toBeUndefined();
-    expect(viewState.lockedRepos).not.toContain("owner/stale-repo");
+    expect(viewState.lockedRepos["issues"]).not.toContain("owner/stale-repo");
   });
 
   it("falls back to item-derived names when configRepoNames not provided", () => {
@@ -738,12 +738,12 @@ describe("IssuesTab — empty-repo state preservation", () => {
       <IssuesTab issues={[]} userLogin="me" />
     ));
     // With empty items and no configRepoNames, guard returns early — no pruning
-    expect(viewState.lockedRepos).toEqual([]);
+    expect(viewState.lockedRepos["issues"]).toEqual([]);
   });
 
   it("renders compact stub row for a locked repo with no issues", () => {
     setViewState(produce((s) => {
-      s.lockedRepos = ["owner/locked-empty"];
+      s.lockedRepos.issues = ["owner/locked-empty"];
     }));
 
     const { container } = render(() => (
@@ -763,7 +763,7 @@ describe("IssuesTab — empty-repo state preservation", () => {
 
   it("does not expand a locked repo with no issues even when expandedRepos is set", () => {
     setViewState(produce((s) => {
-      s.lockedRepos = ["owner/locked-empty"];
+      s.lockedRepos.issues = ["owner/locked-empty"];
       s.expandedRepos.issues["owner/locked-empty"] = true;
     }));
 
@@ -782,7 +782,7 @@ describe("IssuesTab — empty-repo state preservation", () => {
 
   it("hides empty-state message when only locked stubs exist (no double render)", () => {
     setViewState(produce((s) => {
-      s.lockedRepos = ["owner/locked-empty"];
+      s.lockedRepos.issues = ["owner/locked-empty"];
     }));
 
     render(() => (
@@ -797,6 +797,49 @@ describe("IssuesTab — empty-repo state preservation", () => {
   });
 });
 
+// ── customTabId lock mechanics ───────────────────────────────────────────────
+
+describe("IssuesTab — customTabId lock mechanics", () => {
+  it("renders stub row for a locked empty repo under a custom tab key", () => {
+    setViewState(produce((s) => {
+      s.lockedRepos["my-tab"] = ["owner/locked-empty"];
+    }));
+
+    const { container } = render(() => (
+      <IssuesTab
+        issues={[makeIssue({ id: 1, repoFullName: "owner/active-repo", surfacedBy: ["me"] })]}
+        userLogin="me"
+        customTabId="my-tab"
+        configRepoNames={["owner/active-repo", "owner/locked-empty"]}
+      />
+    ));
+
+    const stub = container.querySelector('[data-repo-group="owner/locked-empty"]');
+    expect(stub).not.toBeNull();
+    expect(stub?.textContent).toContain("owner/locked-empty");
+    expect(stub?.querySelector("[aria-expanded]")).toBeNull();
+    expect(container.querySelector('[data-repo-group="owner/active-repo"]')).not.toBeNull();
+  });
+
+  it("prunes locked repos outside configRepoNames under a custom tab key", () => {
+    setViewState(produce((s) => {
+      s.lockedRepos["my-tab"] = ["owner/kept", "owner/pruned"];
+    }));
+
+    render(() => (
+      <IssuesTab
+        issues={[makeIssue({ id: 1, repoFullName: "owner/kept", surfacedBy: ["me"] })]}
+        userLogin="me"
+        customTabId="my-tab"
+        configRepoNames={["owner/kept"]}
+      />
+    ));
+
+    expect(viewState.lockedRepos["my-tab"]).toContain("owner/kept");
+    expect(viewState.lockedRepos["my-tab"]).not.toContain("owner/pruned");
+  });
+});
+
 // ── customTabId filter preset ────────────────────────────────────────────────
 
 describe("IssuesTab — customTabId filter preset", () => {
diff --git a/tests/components/dashboard/PullRequestsTab.test.tsx b/tests/components/dashboard/PullRequestsTab.test.tsx
index ae74bc43..b51db27e 100644
--- a/tests/components/dashboard/PullRequestsTab.test.tsx
+++ b/tests/components/dashboard/PullRequestsTab.test.tsx
@@ -685,7 +685,7 @@ describe("PullRequestsTab — empty-repo state preservation", () => {
     setViewState(produce((s) => {
       s.expandedRepos.pullRequests["owner/empty-repo"] = true;
       s.expandedRepos.pullRequests["owner/stale-repo"] = true;
-      s.lockedRepos = ["owner/empty-repo", "owner/stale-repo"];
+      s.lockedRepos.pullRequests = ["owner/empty-repo", "owner/stale-repo"];
     }));
 
     render(() => (
@@ -698,10 +698,10 @@ describe("PullRequestsTab — empty-repo state preservation", () => {
 
     // Empty repo preserved (in configRepoNames but no items)
     expect(viewState.expandedRepos.pullRequests["owner/empty-repo"]).toBe(true);
-    expect(viewState.lockedRepos).toContain("owner/empty-repo");
+    expect(viewState.lockedRepos["pullRequests"]).toContain("owner/empty-repo");
     // Stale repo pruned (not in configRepoNames)
     expect(viewState.expandedRepos.pullRequests["owner/stale-repo"]).toBeUndefined();
-    expect(viewState.lockedRepos).not.toContain("owner/stale-repo");
+    expect(viewState.lockedRepos["pullRequests"]).not.toContain("owner/stale-repo");
   });
 
   it("falls back to item-derived names when configRepoNames not provided", () => {
@@ -709,12 +709,12 @@ describe("PullRequestsTab — empty-repo state preservation", () => {
       <PullRequestsTab pullRequests={[]} userLogin="me" />
     ));
     // With empty items and no configRepoNames, guard returns early — no pruning
-    expect(viewState.lockedRepos).toEqual([]);
+    expect(viewState.lockedRepos["pullRequests"]).toEqual([]);
   });
 
   it("renders compact stub row for a locked repo with no pull requests", () => {
     setViewState(produce((s) => {
-      s.lockedRepos = ["owner/locked-empty"];
+      s.lockedRepos.pullRequests = ["owner/locked-empty"];
     }));
 
     const { container } = render(() => (
@@ -734,7 +734,7 @@ describe("PullRequestsTab — empty-repo state preservation", () => {
 
   it("does not expand a locked repo with no pull requests even when expandedRepos is set", () => {
     setViewState(produce((s) => {
-      s.lockedRepos = ["owner/locked-empty"];
+      s.lockedRepos.pullRequests = ["owner/locked-empty"];
       s.expandedRepos.pullRequests["owner/locked-empty"] = true;
     }));
 
@@ -753,7 +753,7 @@ describe("PullRequestsTab — empty-repo state preservation", () => {
 
   it("hides empty-state message when only locked stubs exist (no double render)", () => {
     setViewState(produce((s) => {
-      s.lockedRepos = ["owner/locked-empty"];
+      s.lockedRepos.pullRequests = ["owner/locked-empty"];
     }));
 
     render(() => (
diff --git a/tests/components/shared/EmptyLockedRepoRow.test.tsx b/tests/components/shared/EmptyLockedRepoRow.test.tsx
index df01da0a..1b57a694 100644
--- a/tests/components/shared/EmptyLockedRepoRow.test.tsx
+++ b/tests/components/shared/EmptyLockedRepoRow.test.tsx
@@ -5,14 +5,14 @@ import EmptyLockedRepoRow from "../../../src/app/components/shared/EmptyLockedRe
 describe("EmptyLockedRepoRow", () => {
   it("renders the repo name", () => {
     const { getByText } = render(() => (
-      <EmptyLockedRepoRow repoFullName="owner/repo" section="issues" />
+      <EmptyLockedRepoRow repoFullName="owner/repo" section="issues" tabKey="issues" />
     ));
     expect(getByText("owner/repo")).toBeTruthy();
   });
 
   it("sets data-repo-group attribute", () => {
     const { container } = render(() => (
-      <EmptyLockedRepoRow repoFullName="owner/repo" section="issues" />
+      <EmptyLockedRepoRow repoFullName="owner/repo" section="issues" tabKey="issues" />
     ));
     const row = container.querySelector('[data-repo-group="owner/repo"]');
     expect(row).not.toBeNull();
@@ -20,7 +20,7 @@ describe("EmptyLockedRepoRow", () => {
 
   it("applies de-emphasis styling", () => {
     const { container } = render(() => (
-      <EmptyLockedRepoRow repoFullName="owner/repo" section="pulls" />
+      <EmptyLockedRepoRow repoFullName="owner/repo" section="pulls" tabKey="pullRequests" />
     ));
     const row = container.querySelector('[data-repo-group="owner/repo"]');
     expect(row?.className).toContain("opacity-40");
@@ -28,7 +28,7 @@ describe("EmptyLockedRepoRow", () => {
 
   it("has no aria-expanded attribute (non-interactive)", () => {
     const { container } = render(() => (
-      <EmptyLockedRepoRow repoFullName="owner/repo" section="actions" />
+      <EmptyLockedRepoRow repoFullName="owner/repo" section="actions" tabKey="actions" />
     ));
     expect(container.querySelector("[aria-expanded]")).toBeNull();
   });
diff --git a/tests/components/shared/RepoLockControls.test.tsx b/tests/components/shared/RepoLockControls.test.tsx
index 9661753a..e8ed8236 100644
--- a/tests/components/shared/RepoLockControls.test.tsx
+++ b/tests/components/shared/RepoLockControls.test.tsx
@@ -10,15 +10,15 @@ beforeEach(() => {
 describe("RepoLockControls", () => {
   it("renders unlock (pin) icon when repo is not locked", () => {
     render(() => (
-      <RepoLockControls repoFullName="owner/repo" />
+      <RepoLockControls repoFullName="owner/repo" tabKey="issues" />
     ));
     expect(screen.getByLabelText("Pin owner/repo to top of list")).toBeTruthy();
   });
 
   it("renders lock icon + chevrons when repo IS locked", () => {
-    lockRepo("owner/repo");
+    lockRepo("issues", "owner/repo");
     render(() => (
-      <RepoLockControls repoFullName="owner/repo" />
+      <RepoLockControls repoFullName="owner/repo" tabKey="issues" />
     ));
     expect(screen.getByLabelText("Unpin owner/repo")).toBeTruthy();
     expect(screen.getByLabelText("Move owner/repo up")).toBeTruthy();
@@ -27,67 +27,67 @@ describe("RepoLockControls", () => {
 
   it("click pin icon → locks the repo", () => {
     render(() => (
-      <RepoLockControls repoFullName="owner/repo" />
+      <RepoLockControls repoFullName="owner/repo" tabKey="issues" />
     ));
     fireEvent.click(screen.getByLabelText("Pin owner/repo to top of list"));
-    expect(viewState.lockedRepos).toContain("owner/repo");
+    expect(viewState.lockedRepos["issues"]).toContain("owner/repo");
   });
 
   it("click lock icon → unlocks the repo", () => {
-    lockRepo("owner/repo");
+    lockRepo("issues", "owner/repo");
     render(() => (
-      <RepoLockControls repoFullName="owner/repo" />
+      <RepoLockControls repoFullName="owner/repo" tabKey="issues" />
     ));
     fireEvent.click(screen.getByLabelText("Unpin owner/repo"));
-    expect(viewState.lockedRepos).not.toContain("owner/repo");
+    expect(viewState.lockedRepos["issues"]).not.toContain("owner/repo");
   });
 
   it("up button moves repo up in order", () => {
-    lockRepo("owner/a");
-    lockRepo("owner/b");
+    lockRepo("issues", "owner/a");
+    lockRepo("issues", "owner/b");
     render(() => (
-      <RepoLockControls repoFullName="owner/b" />
+      <RepoLockControls repoFullName="owner/b" tabKey="issues" />
     ));
     fireEvent.click(screen.getByLabelText("Move owner/b up"));
-    expect(viewState.lockedRepos[0]).toBe("owner/b");
-    expect(viewState.lockedRepos[1]).toBe("owner/a");
+    expect(viewState.lockedRepos["issues"][0]).toBe("owner/b");
+    expect(viewState.lockedRepos["issues"][1]).toBe("owner/a");
   });
 
   it("down button moves repo down in order", () => {
-    lockRepo("owner/a");
-    lockRepo("owner/b");
+    lockRepo("issues", "owner/a");
+    lockRepo("issues", "owner/b");
     render(() => (
-      <RepoLockControls repoFullName="owner/a" />
+      <RepoLockControls repoFullName="owner/a" tabKey="issues" />
     ));
     fireEvent.click(screen.getByLabelText("Move owner/a down"));
-    expect(viewState.lockedRepos[0]).toBe("owner/b");
-    expect(viewState.lockedRepos[1]).toBe("owner/a");
+    expect(viewState.lockedRepos["issues"][0]).toBe("owner/b");
+    expect(viewState.lockedRepos["issues"][1]).toBe("owner/a");
   });
 
   it("up button is disabled when repo is first in locked list", () => {
-    lockRepo("owner/repo");
+    lockRepo("issues", "owner/repo");
     render(() => (
-      <RepoLockControls repoFullName="owner/repo" />
+      <RepoLockControls repoFullName="owner/repo" tabKey="issues" />
     ));
     const upBtn = screen.getByLabelText("Move owner/repo up") as HTMLButtonElement;
     expect(upBtn.disabled).toBe(true);
   });
 
   it("down button is disabled when repo is last in locked list", () => {
-    lockRepo("owner/repo");
+    lockRepo("issues", "owner/repo");
     render(() => (
-      <RepoLockControls repoFullName="owner/repo" />
+      <RepoLockControls repoFullName="owner/repo" tabKey="issues" />
     ));
     const downBtn = screen.getByLabelText("Move owner/repo down") as HTMLButtonElement;
     expect(downBtn.disabled).toBe(true);
   });
 
   it("stopPropagation — parent click NOT triggered on locked button click", () => {
-    lockRepo("owner/repo");
+    lockRepo("issues", "owner/repo");
     const parentClick = vi.fn();
     render(() => (
       <div onClick={parentClick}>
-        <RepoLockControls repoFullName="owner/repo" />
+        <RepoLockControls repoFullName="owner/repo" tabKey="issues" />
       </div>
     ));
     fireEvent.click(screen.getByLabelText("Unpin owner/repo"));
@@ -98,7 +98,7 @@ describe("RepoLockControls", () => {
     const parentClick = vi.fn();
     render(() => (
       <div onClick={parentClick}>
-        <RepoLockControls repoFullName="owner/repo" />
+        <RepoLockControls repoFullName="owner/repo" tabKey="issues" />
       </div>
     ));
     fireEvent.click(screen.getByLabelText("Pin owner/repo to top of list"));
@@ -123,36 +123,36 @@ describe("RepoLockControls — scroll preservation", () => {
 
   it("preserves scroll position when locking a repo", () => {
     render(() => (
-      <RepoLockControls repoFullName="owner/repo" />
+      <RepoLockControls repoFullName="owner/repo" tabKey="issues" />
     ));
     fireEvent.click(screen.getByLabelText("Pin owner/repo to top of list"));
     expect(window.scrollTo).toHaveBeenCalledWith(0, 500);
   });
 
   it("preserves scroll position when unlocking a repo", () => {
-    lockRepo("owner/repo");
+    lockRepo("issues", "owner/repo");
     render(() => (
-      <RepoLockControls repoFullName="owner/repo" />
+      <RepoLockControls repoFullName="owner/repo" tabKey="issues" />
     ));
     fireEvent.click(screen.getByLabelText("Unpin owner/repo"));
     expect(window.scrollTo).toHaveBeenCalledWith(0, 500);
   });
 
   it("preserves scroll position when moving repo up", () => {
-    lockRepo("owner/a");
-    lockRepo("owner/b");
+    lockRepo("issues", "owner/a");
+    lockRepo("issues", "owner/b");
     render(() => (
-      <RepoLockControls repoFullName="owner/b" />
+      <RepoLockControls repoFullName="owner/b" tabKey="issues" />
     ));
     fireEvent.click(screen.getByLabelText("Move owner/b up"));
     expect(window.scrollTo).toHaveBeenCalledWith(0, 500);
   });
 
   it("preserves scroll position when moving repo down", () => {
-    lockRepo("owner/a");
-    lockRepo("owner/b");
+    lockRepo("issues", "owner/a");
+    lockRepo("issues", "owner/b");
     render(() => (
-      <RepoLockControls repoFullName="owner/a" />
+      <RepoLockControls repoFullName="owner/a" tabKey="issues" />
     ));
     fireEvent.click(screen.getByLabelText("Move owner/a down"));
     expect(window.scrollTo).toHaveBeenCalledWith(0, 500);
diff --git a/tests/stores/view-lock.test.ts b/tests/stores/view-lock.test.ts
index 3d0370ae..9ef1668b 100644
--- a/tests/stores/view-lock.test.ts
+++ b/tests/stores/view-lock.test.ts
@@ -10,197 +10,308 @@ import {
   ViewStateSchema,
 } from "../../src/app/stores/view";
 
-describe("view lock store", () => {
+describe("view lock store (per-tab)", () => {
   beforeEach(() => {
     resetViewState();
   });
 
   describe("lockRepo", () => {
-    it("locks a repo", () => {
-      lockRepo("org/repo-a");
-      expect(viewState.lockedRepos).toEqual(["org/repo-a"]);
+    it("locks a repo in the given tab", () => {
+      lockRepo("issues", "org/repo-a");
+      expect(viewState.lockedRepos["issues"]).toEqual(["org/repo-a"]);
     });
 
-    it("appends to end", () => {
-      lockRepo("org/repo-a");
-      lockRepo("org/repo-b");
-      expect(viewState.lockedRepos).toEqual(["org/repo-a", "org/repo-b"]);
+    it("appends to end within the same tab", () => {
+      lockRepo("issues", "org/repo-a");
+      lockRepo("issues", "org/repo-b");
+      expect(viewState.lockedRepos["issues"]).toEqual(["org/repo-a", "org/repo-b"]);
     });
 
-    it("deduplicates", () => {
-      lockRepo("org/repo-a");
-      lockRepo("org/repo-a");
-      expect(viewState.lockedRepos).toEqual(["org/repo-a"]);
+    it("deduplicates within the same tab", () => {
+      lockRepo("issues", "org/repo-a");
+      lockRepo("issues", "org/repo-a");
+      expect(viewState.lockedRepos["issues"]).toEqual(["org/repo-a"]);
     });
 
-    it("accumulates locks from multiple lockRepo calls", () => {
-      lockRepo("org/repo-a");
-      lockRepo("org/repo-b");
-      expect(viewState.lockedRepos).toEqual(["org/repo-a", "org/repo-b"]);
+    it("does not affect other tabs", () => {
+      lockRepo("issues", "org/repo-a");
+      expect(viewState.lockedRepos["pullRequests"]).toEqual([]);
+      expect(viewState.lockedRepos["actions"]).toEqual([]);
+    });
+
+    it("locks independently in each tab", () => {
+      lockRepo("issues", "org/repo-a");
+      lockRepo("pullRequests", "org/repo-b");
+      lockRepo("actions", "org/repo-c");
+      expect(viewState.lockedRepos["issues"]).toEqual(["org/repo-a"]);
+      expect(viewState.lockedRepos["pullRequests"]).toEqual(["org/repo-b"]);
+      expect(viewState.lockedRepos["actions"]).toEqual(["org/repo-c"]);
+    });
+
+    it("same repo can be locked in multiple tabs independently", () => {
+      lockRepo("issues", "org/shared");
+      lockRepo("pullRequests", "org/shared");
+      expect(viewState.lockedRepos["issues"]).toContain("org/shared");
+      expect(viewState.lockedRepos["pullRequests"]).toContain("org/shared");
+    });
+
+    it("creates the tab key if absent (custom tab)", () => {
+      lockRepo("custom-tab-1", "org/repo-a");
+      expect(viewState.lockedRepos["custom-tab-1"]).toEqual(["org/repo-a"]);
+    });
+
+    it("silently no-ops when at LOCKED_REPOS_CAP for that tab", () => {
+      for (let i = 0; i < 50; i++) {
+        lockRepo("issues", `org/repo-${i}`);
+      }
+      expect(viewState.lockedRepos["issues"].length).toBe(50);
+      lockRepo("issues", "org/repo-overflow");
+      expect(viewState.lockedRepos["issues"].length).toBe(50);
+      expect(viewState.lockedRepos["issues"]).not.toContain("org/repo-overflow");
+    });
+
+    it("cap is per-tab — reaching cap in one tab does not block another", () => {
+      for (let i = 0; i < 50; i++) {
+        lockRepo("issues", `org/repo-${i}`);
+      }
+      lockRepo("pullRequests", "org/repo-a");
+      expect(viewState.lockedRepos["pullRequests"]).toEqual(["org/repo-a"]);
     });
   });
 
   describe("unlockRepo", () => {
-    it("removes from locked array", () => {
-      lockRepo("org/repo-a");
-      lockRepo("org/repo-b");
-      unlockRepo("org/repo-a");
-      expect(viewState.lockedRepos).toEqual(["org/repo-b"]);
+    it("removes from locked array for the given tab", () => {
+      lockRepo("issues", "org/repo-a");
+      lockRepo("issues", "org/repo-b");
+      unlockRepo("issues", "org/repo-a");
+      expect(viewState.lockedRepos["issues"]).toEqual(["org/repo-b"]);
+    });
+
+    it("no-op if not locked in that tab", () => {
+      unlockRepo("issues", "org/repo-a");
+      expect(viewState.lockedRepos["issues"]).toEqual([]);
     });
 
-    it("no-op if not locked", () => {
-      unlockRepo("org/repo-a");
-      expect(viewState.lockedRepos).toEqual([]);
+    it("no-op if tab key is absent", () => {
+      expect(() => unlockRepo("nonexistent-tab", "org/repo-a")).not.toThrow();
+    });
+
+    it("does not affect other tabs", () => {
+      lockRepo("issues", "org/repo-a");
+      lockRepo("pullRequests", "org/repo-a");
+      unlockRepo("issues", "org/repo-a");
+      expect(viewState.lockedRepos["issues"]).toEqual([]);
+      expect(viewState.lockedRepos["pullRequests"]).toEqual(["org/repo-a"]);
     });
   });
 
   describe("moveLockedRepo", () => {
-    it("swaps with neighbor up", () => {
-      lockRepo("org/repo-a");
-      lockRepo("org/repo-b");
-      lockRepo("org/repo-c");
-      moveLockedRepo("org/repo-b", "up");
-      expect(viewState.lockedRepos).toEqual(["org/repo-b", "org/repo-a", "org/repo-c"]);
+    it("swaps with neighbor up within the given tab", () => {
+      lockRepo("issues", "org/repo-a");
+      lockRepo("issues", "org/repo-b");
+      lockRepo("issues", "org/repo-c");
+      moveLockedRepo("issues", "org/repo-b", "up");
+      expect(viewState.lockedRepos["issues"]).toEqual(["org/repo-b", "org/repo-a", "org/repo-c"]);
     });
 
-    it("swaps with neighbor down", () => {
-      lockRepo("org/repo-a");
-      lockRepo("org/repo-b");
-      lockRepo("org/repo-c");
-      moveLockedRepo("org/repo-b", "down");
-      expect(viewState.lockedRepos).toEqual(["org/repo-a", "org/repo-c", "org/repo-b"]);
+    it("swaps with neighbor down within the given tab", () => {
+      lockRepo("issues", "org/repo-a");
+      lockRepo("issues", "org/repo-b");
+      lockRepo("issues", "org/repo-c");
+      moveLockedRepo("issues", "org/repo-b", "down");
+      expect(viewState.lockedRepos["issues"]).toEqual(["org/repo-a", "org/repo-c", "org/repo-b"]);
     });
 
     it("no-op at top boundary", () => {
-      lockRepo("org/repo-a");
-      lockRepo("org/repo-b");
-      moveLockedRepo("org/repo-a", "up");
-      expect(viewState.lockedRepos).toEqual(["org/repo-a", "org/repo-b"]);
+      lockRepo("issues", "org/repo-a");
+      lockRepo("issues", "org/repo-b");
+      moveLockedRepo("issues", "org/repo-a", "up");
+      expect(viewState.lockedRepos["issues"]).toEqual(["org/repo-a", "org/repo-b"]);
     });
 
     it("no-op at bottom boundary", () => {
-      lockRepo("org/repo-a");
-      lockRepo("org/repo-b");
-      moveLockedRepo("org/repo-b", "down");
-      expect(viewState.lockedRepos).toEqual(["org/repo-a", "org/repo-b"]);
+      lockRepo("issues", "org/repo-a");
+      lockRepo("issues", "org/repo-b");
+      moveLockedRepo("issues", "org/repo-b", "down");
+      expect(viewState.lockedRepos["issues"]).toEqual(["org/repo-a", "org/repo-b"]);
+    });
+
+    it("no-op if repo not locked in that tab", () => {
+      lockRepo("issues", "org/repo-a");
+      moveLockedRepo("issues", "org/repo-z", "up");
+      expect(viewState.lockedRepos["issues"]).toEqual(["org/repo-a"]);
+    });
+
+    it("no-op if tab key is absent", () => {
+      expect(() => moveLockedRepo("nonexistent-tab", "org/repo-a", "up")).not.toThrow();
     });
 
-    it("no-op if not locked", () => {
-      lockRepo("org/repo-a");
-      moveLockedRepo("org/repo-z", "up");
-      expect(viewState.lockedRepos).toEqual(["org/repo-a"]);
+    it("does not affect other tabs", () => {
+      lockRepo("issues", "org/a");
+      lockRepo("issues", "org/b");
+      lockRepo("pullRequests", "org/a");
+      lockRepo("pullRequests", "org/b");
+      moveLockedRepo("issues", "org/b", "up");
+      expect(viewState.lockedRepos["issues"]).toEqual(["org/b", "org/a"]);
+      expect(viewState.lockedRepos["pullRequests"]).toEqual(["org/a", "org/b"]);
     });
   });
 
   describe("pruneLockedRepos", () => {
-    it("removes stale names", () => {
-      lockRepo("org/repo-a");
-      lockRepo("org/repo-b");
-      lockRepo("org/repo-c");
-      pruneLockedRepos(["org/repo-a", "org/repo-c"]);
-      expect(viewState.lockedRepos).toEqual(["org/repo-a", "org/repo-c"]);
+    it("removes stale names for the given tab", () => {
+      lockRepo("issues", "org/repo-a");
+      lockRepo("issues", "org/repo-b");
+      lockRepo("issues", "org/repo-c");
+      pruneLockedRepos("issues", ["org/repo-a", "org/repo-c"]);
+      expect(viewState.lockedRepos["issues"]).toEqual(["org/repo-a", "org/repo-c"]);
     });
 
-    it("preserves order of active repos", () => {
-      lockRepo("org/repo-c");
-      lockRepo("org/repo-a");
-      lockRepo("org/repo-b");
-      pruneLockedRepos(["org/repo-b", "org/repo-c"]);
-      expect(viewState.lockedRepos).toEqual(["org/repo-c", "org/repo-b"]);
+    it("preserves lock order of active repos", () => {
+      lockRepo("issues", "org/repo-c");
+      lockRepo("issues", "org/repo-a");
+      lockRepo("issues", "org/repo-b");
+      pruneLockedRepos("issues", ["org/repo-b", "org/repo-c"]);
+      expect(viewState.lockedRepos["issues"]).toEqual(["org/repo-c", "org/repo-b"]);
     });
 
-    it("no-op when empty", () => {
-      pruneLockedRepos(["org/repo-a"]);
-      expect(viewState.lockedRepos).toEqual([]);
+    it("no-op when tab is empty", () => {
+      pruneLockedRepos("issues", ["org/repo-a"]);
+      expect(viewState.lockedRepos["issues"]).toEqual([]);
     });
 
     it("no-op when all active", () => {
-      lockRepo("org/repo-a");
-      pruneLockedRepos(["org/repo-a", "org/repo-b"]);
-      expect(viewState.lockedRepos).toEqual(["org/repo-a"]);
+      lockRepo("issues", "org/repo-a");
+      pruneLockedRepos("issues", ["org/repo-a", "org/repo-b"]);
+      expect(viewState.lockedRepos["issues"]).toEqual(["org/repo-a"]);
+    });
+
+    it("no-op if tab key is absent", () => {
+      expect(() => pruneLockedRepos("nonexistent-tab", ["org/repo-a"])).not.toThrow();
+    });
+
+    it("does not affect other tabs", () => {
+      lockRepo("issues", "org/repo-a");
+      lockRepo("issues", "org/repo-b");
+      lockRepo("pullRequests", "org/repo-a");
+      pruneLockedRepos("issues", ["org/repo-a"]);
+      expect(viewState.lockedRepos["issues"]).toEqual(["org/repo-a"]);
+      expect(viewState.lockedRepos["pullRequests"]).toEqual(["org/repo-a"]);
+    });
+
+    it("prunes custom tab lock list correctly", () => {
+      lockRepo("custom-tab-1", "org/repo-a");
+      lockRepo("custom-tab-1", "org/repo-b");
+      lockRepo("custom-tab-1", "org/repo-c");
+      pruneLockedRepos("custom-tab-1", ["org/repo-a", "org/repo-c"]);
+      expect(viewState.lockedRepos["custom-tab-1"]).toEqual(["org/repo-a", "org/repo-c"]);
     });
   });
 
-  describe("schema migration", () => {
-    it("defaults lockedRepos when absent", () => {
+  describe("schema — lockedRepos defaults", () => {
+    it("defaults lockedRepos to per-tab record with empty arrays", () => {
       const result = ViewStateSchema.safeParse({});
       expect(result.success).toBe(true);
       if (result.success) {
-        expect(result.data.lockedRepos).toEqual([]);
+        expect(result.data.lockedRepos).toEqual({ issues: [], pullRequests: [], actions: [] });
       }
     });
 
-    it("preserves existing data without lockedRepos", () => {
+    it("accepts a per-tab record shape", () => {
       const result = ViewStateSchema.safeParse({
-        lastActiveTab: "issues",
-        expandedRepos: { issues: {}, pullRequests: {}, actions: {} },
+        lockedRepos: { issues: ["org/a"], pullRequests: [], actions: ["org/b"] },
       });
       expect(result.success).toBe(true);
       if (result.success) {
-        expect(result.data.lastActiveTab).toBe("issues");
-        expect(result.data.lockedRepos).toEqual([]);
+        expect(result.data.lockedRepos["issues"]).toEqual(["org/a"]);
+        expect(result.data.lockedRepos["actions"]).toEqual(["org/b"]);
+      }
+    });
+
+    it("preserves other state fields when lockedRepos is present", () => {
+      const result = ViewStateSchema.safeParse({
+        lastActiveTab: "pullRequests",
+        lockedRepos: { issues: ["org/a"], pullRequests: [], actions: [] },
+      });
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data.lastActiveTab).toBe("pullRequests");
+        expect(result.data.lockedRepos["issues"]).toEqual(["org/a"]);
       }
     });
   });
 
   describe("migrateLockedRepos", () => {
-    it("deduplicates with issues-first default", () => {
-      expect(migrateLockedRepos({ issues: ["a"], pullRequests: ["b"], actions: ["a"] }))
-        .toEqual(["a", "b"]);
+    it("converts flat array to per-tab record (same list in all 3 tabs)", () => {
+      const result = migrateLockedRepos(["org/a", "org/b"]);
+      expect(result).toEqual({
+        issues: ["org/a", "org/b"],
+        pullRequests: ["org/a", "org/b"],
+        actions: ["org/a", "org/b"],
+      });
+    });
+
+    it("passes through existing per-tab record unchanged", () => {
+      const record = { issues: ["org/a"], pullRequests: ["org/b"], actions: [] };
+      expect(migrateLockedRepos(record)).toEqual(record);
     });
 
-    it("uses lastActiveTab for precedence", () => {
-      expect(migrateLockedRepos({ issues: ["a"], pullRequests: ["b"], actions: ["a"] }, "pullRequests"))
-        .toEqual(["b", "a"]);
+    it("passes through partial object (missing built-in keys remain absent)", () => {
+      const partial = { issues: ["org/a"] };
+      const migrated = migrateLockedRepos(partial) as Record<string, string[]>;
+      expect(migrated["issues"]).toEqual(["org/a"]);
+      expect(migrated["pullRequests"]).toBeUndefined();
+      expect(migrated["actions"]).toBeUndefined();
     });
 
-    it("handles partial object", () => {
-      expect(migrateLockedRepos({ issues: ["a"], pullRequests: ["b"] }))
-        .toEqual(["a", "b"]);
+    it("returns default record for undefined/null", () => {
+      expect(migrateLockedRepos(undefined)).toEqual({ issues: [], pullRequests: [], actions: [] });
+      expect(migrateLockedRepos(null)).toEqual({ issues: [], pullRequests: [], actions: [] });
     });
 
-    it("returns array unchanged", () => {
-      expect(migrateLockedRepos(["a", "b"])).toEqual(["a", "b"]);
+    it("caps flat array at LOCKED_REPOS_CAP (50) before copying", () => {
+      const bigArr = Array.from({ length: 60 }, (_, i) => `org/repo-${i}`);
+      const result = migrateLockedRepos(bigArr) as Record<string, string[]>;
+      expect(Array.isArray(result["issues"])).toBe(true);
+      expect(result["issues"].length).toBe(50);
+      expect(result["pullRequests"].length).toBe(50);
+      expect(result["actions"].length).toBe(50);
     });
 
-    it("returns undefined unchanged", () => {
-      expect(migrateLockedRepos(undefined)).toBeUndefined();
+    it("creates independent array copies per tab (no shared references)", () => {
+      const result = migrateLockedRepos(["org/a"]) as Record<string, string[]>;
+      expect(result["issues"]).not.toBe(result["pullRequests"]);
+      expect(result["issues"]).not.toBe(result["actions"]);
+      expect(result["pullRequests"]).not.toBe(result["actions"]);
     });
 
-    it("uses actions tab for precedence when lastActiveTab is actions", () => {
-      expect(migrateLockedRepos(
-        { issues: ["a"], pullRequests: ["b"], actions: ["c", "a"] },
-        "actions"
-      )).toEqual(["c", "a", "b"]);
+    it("returns default record for non-array, non-object inputs", () => {
+      expect(migrateLockedRepos(42)).toEqual({ issues: [], pullRequests: [], actions: [] });
+      expect(migrateLockedRepos("bad")).toEqual({ issues: [], pullRequests: [], actions: [] });
     });
 
-    it("caps output at LOCKED_REPOS_CAP when merging exceeds limit", () => {
-      // 20 unique per tab × 3 tabs = 60 unique entries, exceeds cap of 50
-      const issues = Array.from({ length: 20 }, (_, i) => `org/issue-${i}`);
-      const prs = Array.from({ length: 20 }, (_, i) => `org/pr-${i}`);
-      const actions = Array.from({ length: 20 }, (_, i) => `org/action-${i}`);
-      const result = migrateLockedRepos({ issues, pullRequests: prs, actions });
-      expect(Array.isArray(result)).toBe(true);
-      expect((result as string[]).length).toBe(50);
-      // First 20 should be issues (default preferred), then first 20 PRs, then first 10 actions
-      expect((result as string[])[0]).toBe("org/issue-0");
-      expect((result as string[])[20]).toBe("org/pr-0");
-      expect((result as string[])[40]).toBe("org/action-0");
-      expect((result as string[])[49]).toBe("org/action-9");
+    it("filters out non-string elements from a flat mixed-type array", () => {
+      const result = migrateLockedRepos([42, "org/repo", null]) as Record<string, string[]>;
+      expect(result["issues"]).toEqual(["org/repo"]);
+      expect(result["pullRequests"]).toEqual(["org/repo"]);
+      expect(result["actions"]).toEqual(["org/repo"]);
     });
   });
 
-  describe("lockRepo cap enforcement", () => {
-    it("silently no-ops when at LOCKED_REPOS_CAP", () => {
-      // Fill to cap
-      for (let i = 0; i < 50; i++) {
-        lockRepo(`org/repo-${i}`);
-      }
-      expect(viewState.lockedRepos.length).toBe(50);
-      // Attempt to add one more
-      lockRepo("org/repo-overflow");
-      expect(viewState.lockedRepos.length).toBe(50);
-      expect(viewState.lockedRepos).not.toContain("org/repo-overflow");
+  describe("resetViewState — lockedRepos", () => {
+    it("clears all per-tab locked arrays", () => {
+      lockRepo("issues", "org/repo-a");
+      lockRepo("pullRequests", "org/repo-b");
+      lockRepo("actions", "org/repo-c");
+      resetViewState();
+      expect(viewState.lockedRepos["issues"]).toEqual([]);
+      expect(viewState.lockedRepos["pullRequests"]).toEqual([]);
+      expect(viewState.lockedRepos["actions"]).toEqual([]);
+    });
+
+    it("clears custom tab lock lists as well", () => {
+      lockRepo("custom-tab-1", "org/repo-a");
+      resetViewState();
+      expect(viewState.lockedRepos["custom-tab-1"]).toBeUndefined();
     });
   });
 });
diff --git a/tests/stores/view.test.ts b/tests/stores/view.test.ts
index b1cc22e2..4a856dce 100644
--- a/tests/stores/view.test.ts
+++ b/tests/stores/view.test.ts
@@ -1,4 +1,4 @@
-import { describe, it, expect, beforeEach, vi } from "vitest";
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
 import { createRoot } from "solid-js";
 import {
   viewState,
@@ -23,6 +23,7 @@ import {
   setCustomTabFilter,
   resetCustomTabFilters,
   removeCustomTabState,
+  lockRepo,
 } from "../../src/app/stores/view";
 import type { IgnoredItem, TrackedItem } from "../../src/app/stores/view";
 
@@ -692,6 +693,13 @@ describe("removeCustomTabState", () => {
     expect("tab-abc" in viewState.expandedRepos).toBe(false);
   });
 
+  it("cleans lockedRepos for the given tab ID", () => {
+    lockRepo("tab-abc", "owner/repo");
+    expect(viewState.lockedRepos["tab-abc"]).toContain("owner/repo");
+    removeCustomTabState("tab-abc");
+    expect("tab-abc" in viewState.lockedRepos).toBe(false);
+  });
+
   it("is a no-op for a nonexistent tab ID (no error thrown)", () => {
     expect(() => removeCustomTabState("tab-never-existed")).not.toThrow();
     expect("tab-never-existed" in viewState.customTabFilters).toBe(false);
@@ -728,6 +736,18 @@ describe("resetViewState — custom tab fields", () => {
     // Custom key is fully deleted
     expect("tab-custom" in viewState.expandedRepos).toBe(false);
   });
+
+  it("clears custom tab keys from lockedRepos and resets built-in keys to []", () => {
+    lockRepo("issues", "owner/repo");
+    lockRepo("tab-custom", "owner/repo");
+    resetViewState();
+    // Built-in keys reset to empty arrays
+    expect(viewState.lockedRepos["issues"]).toEqual([]);
+    expect(viewState.lockedRepos["pullRequests"]).toEqual([]);
+    expect(viewState.lockedRepos["actions"]).toEqual([]);
+    // Custom key is fully deleted
+    expect("tab-custom" in viewState.lockedRepos).toBe(false);
+  });
 });
 
 describe("expandedRepos — dynamic tab keys", () => {
@@ -745,3 +765,46 @@ describe("expandedRepos — dynamic tab keys", () => {
     expect(viewState.expandedRepos["tab-new"]["owner/repo"]).toBe(true);
   });
 });
+
+describe("loadViewState — cap-guard integration", () => {
+  afterEach(() => {
+    localStorageMock.clear();
+  });
+
+  it("deletes non-array lockedRepos tab values and preserves valid ones", async () => {
+    localStorageMock.setItem(VIEW_KEY, JSON.stringify({
+      lastActiveTab: "actions",
+      lockedRepos: { issues: ["org/repo"], pullRequests: "bad-value" },
+    }));
+
+    vi.resetModules();
+    const mod = await import("../../src/app/stores/view");
+
+    expect(mod.viewState.lastActiveTab).toBe("actions");
+    expect(mod.viewState.lockedRepos["issues"]).toEqual(["org/repo"]);
+    expect(mod.viewState.lockedRepos["pullRequests"]).toBeUndefined();
+  });
+
+  it("truncates oversized lockedRepos arrays to LOCKED_REPOS_CAP", async () => {
+    const bigArray = Array.from({ length: 60 }, (_, i) => `org/repo-${i}`);
+    localStorageMock.setItem(VIEW_KEY, JSON.stringify({
+      lockedRepos: { issues: bigArray },
+    }));
+
+    vi.resetModules();
+    const mod = await import("../../src/app/stores/view");
+
+    expect(mod.viewState.lockedRepos["issues"].length).toBe(mod.LOCKED_REPOS_CAP);
+  });
+
+  it("filters non-string elements from lockedRepos arrays", async () => {
+    localStorageMock.setItem(VIEW_KEY, JSON.stringify({
+      lockedRepos: { issues: [42, "org/repo", null, true, "org/other"] },
+    }));
+
+    vi.resetModules();
+    const mod = await import("../../src/app/stores/view");
+
+    expect(mod.viewState.lockedRepos["issues"]).toEqual(["org/repo", "org/other"]);
+  });
+});