diff --git a/servers/gateway/dashboard/index.js b/servers/gateway/dashboard/index.js
index 872d3062..ed54089c 100644
--- a/servers/gateway/dashboard/index.js
+++ b/servers/gateway/dashboard/index.js
@@ -7,7 +7,6 @@ import express from "express";
 import { renderLayout, renderLogin, render2faVerify, render2faRecovery, render2faSetup, renderResetRequest, renderResetForm } from "./shared/layout.js";
 import { playerBarHtml, playerBarJs } from "./shared/player.js";
 import { headerIconsHtml, headerIconsJs, tamagotchiHtml, tamagotchiJs } from "./shared/notifications.js";
-import perchHubRouter from "../routes/perch-hub.js";
 import {
   dashboardAuth,
   isPasswordSet,
@@ -80,6 +79,7 @@ import onboardingPanel, { handleIdentityBackupPost, handleCloudProviderPost, han
 import connectPanel from "./panels/connect.js";
 import fediversePanel from "./panels/fediverse.js";
 import meteringPanel from "./panels/metering.js";
+import perchHubPanel from "./panels/perch-hub.js";
 import { handleFixItAction } from "../fix-it/index.js";
 import bundlesRouterFactory from "../routes/bundles.js";
 import perchApiRouter from "../routes/perch.js";
@@ -114,6 +114,7 @@ export default function dashboardRouter(mcpAuthMiddleware) {
   registerPanel(connectPanel);
   registerPanel(fediversePanel);
   registerPanel(meteringPanel);
+  registerPanel(perchHubPanel);
 
   // Load third-party panels (async, non-blocking)
   loadExternalPanels().catch((err) => {
@@ -713,9 +714,11 @@ export default function dashboardRouter(mcpAuthMiddleware) {
   // Normal mount (session-cookie-authenticated path)
   router.use("/dashboard", bundlesRouter);
 
-  router.use("/dashboard", perchHubRouter(dashboardAuth));
-  // Short link. Outside the /dashboard mount, so it carries no auth — it is a
-  // redirect with no content, and the destination is fully gated.
+  // Perch Hub itself is a registered panel now (panels/perch-hub.js),
+  // dispatched by the generic "/dashboard/:panelId" route below — no
+  // separate mount here. This is just the short link. Outside the
+  // /dashboard mount, so it carries no auth — it is a redirect with no
+  // content, and the destination is fully gated.
   router.get("/perch", (req, res) => res.redirect(302, "/dashboard/perch"));
 
   // SSO launch — authenticated on THIS instance (after dashboardAuth). Mints a
diff --git a/servers/gateway/dashboard/panels/bot-board.js b/servers/gateway/dashboard/panels/bot-board.js
index 1674cef0..36709e36 100644
--- a/servers/gateway/dashboard/panels/bot-board.js
+++ b/servers/gateway/dashboard/panels/bot-board.js
@@ -116,12 +116,21 @@ export default {
         `title="Edit bot definition">${t("botboard.editBotLink", lang)}</a>`
       : "";
 
+    // Mirrors Perch's own "Board" link back to here (perch-hub/html.js's
+    // <nav class="machines">) — unconditional, like that one, so the board
+    // is reachable from Perch and vice versa regardless of which bot (if
+    // any) is selected.
+    const perchLink =
+      `<a href="/dashboard/perch" ` +
+      `style="font-size:.78rem;color:var(--crow-text-muted);text-decoration:none;margin-left:.3rem">` +
+      `${t("botboard.perchLink", lang)}</a>`;
+
     const switcher =
       `<form method="GET" action="/dashboard/bot-board" class="bb-switch">` +
       `<label for="bb-bot" style="font-size:.8rem;color:var(--crow-text-muted)">${t("botboard.labelBotSwitcher", lang)}</label>` +
       `<select id="bb-bot" name="bot" onchange="this.form.requestSubmit ? this.form.requestSubmit() : this.form.submit()">` +
       switcherOptions +
-      `</select>` + editBotLink +
+      `</select>` + editBotLink + perchLink +
       `<noscript><button type="submit">Go</button></noscript>` +
       switcherButtons +
       `</form>`;
diff --git a/servers/gateway/dashboard/panels/bot-board/client.js b/servers/gateway/dashboard/panels/bot-board/client.js
index dc01dc5e..a4326fe0 100644
--- a/servers/gateway/dashboard/panels/bot-board/client.js
+++ b/servers/gateway/dashboard/panels/bot-board/client.js
@@ -43,6 +43,11 @@ export function clientJs(botId, trackerType, projectId, trackerSlug, contextFiel
       .then(function(r){return r.json().catch(function(){return {};}).then(function(j){return {ok:r.ok,status:r.status,j:j};});});
   }
   function reload(){ location.reload(); }
+  // Nav-gap fix: every session action that used to open the in-page bird
+  // drawer now navigates to the standalone Perch Hub instead — a full-page
+  // chat surface, not a cramped side panel. sid is optional: action=sessions
+  // has no specific session, so it goes to the bare hub with no fragment.
+  function goToPerch(sid){ location.href = sid ? '/dashboard/perch#'+encodeURIComponent(sid) : '/dashboard/perch'; }
 
   var drawer=$('bb-drawer'), trackerDrawer=$('bb-tracker-drawer'), cur=null, dragId=null, dragType=null;
   // Track 1: plans are RECORDS now (board_plans), not a file — no mtime
@@ -446,7 +451,7 @@ export function clientJs(botId, trackerType, projectId, trackerSlug, contextFiel
     if(birdGlyph && ev.target.closest('.bb-card')){
       ev.preventDefault();
       ev.stopPropagation();
-      openBirdDrawer(birdGlyph.getAttribute('data-bird-sid'));
+      goToPerch(birdGlyph.getAttribute('data-bird-sid'));
       return;
     }
     var c=ev.target.closest && ev.target.closest('.bb-card');
@@ -876,13 +881,13 @@ export function clientJs(botId, trackerType, projectId, trackerSlug, contextFiel
     parseFilterHash();
     applyFilters();
 
-    // Track 3 Task 13: hash-driven drawer open — #bird=<sid> opens straight
-    // to that session, #card=<id> scrolls the card into view and opens its
-    // live bird's drawer if one is on it. Runs AFTER parseFilterHash so a
-    // drawer link co-existing with a search/status hash is never lost.
+    // Track 3 Task 13: hash-driven open — #bird=<sid> navigates straight to
+    // that session in Perch, #card=<id> scrolls the card into view and opens
+    // its live bird's drawer if one is on it. Runs AFTER parseFilterHash so
+    // a link co-existing with a search/status hash is never lost.
     if(window._bbForeignHash){
-      if(window._bbForeignHash.bird && typeof openBirdDrawer==='function'){
-        openBirdDrawer(window._bbForeignHash.bird);
+      if(window._bbForeignHash.bird){
+        goToPerch(window._bbForeignHash.bird);
       } else if(window._bbForeignHash.card && typeof bdFocusCard==='function'){
         bdFocusCard(window._bbForeignHash.card);
       }
@@ -1235,15 +1240,12 @@ export function clientJs(botId, trackerType, projectId, trackerSlug, contextFiel
     if(sendBtn) sendBtn.disabled=true;
     perchApi('POST','/bots/'+encodeURIComponent(roostDispatchBotId)+'/dispatch',{card_id:Number(cardId),note:note}).then(function(r){
       if(r.ok){
-        // Fix round 1: a successful dispatch used to close the dialog and
-        // call the (still-stub) openBirdDrawer — invisible, indistinguishable
-        // from a dropped click. The strip/card-face bird can't be patched
-        // into existence client-side (a bird-less card face carries no
-        // .bb-bird span to patch — see the bird-state handler below), so the
-        // honest fix is: show a perceivable success line, THEN reload. The
-        // reloaded SSR renders the bird on the strip + card truthfully.
+        // Nav-gap fix: a successful dispatch shows the perceivable success
+        // line, then navigates to the new session in Perch — POST
+        // /bots/:id/dispatch responds with the spawned session's id
+        // (perch-interactive-api.js's result object, which carries sessionId).
         msg($('bb-rd-msg'),'${tJs("botboard.roostDispatchSent", lang)}','ok');
-        setTimeout(reload,600);
+        goToPerch(r.j&&r.j.sessionId);
       } else if(r.status===409 && r.j && r.j.error==='card_occupied'){
         // A raced dispatch — surfaced as the dialog's OWN error line, not a
         // toast: the picker is still open and the operator needs to pick a
@@ -1291,17 +1293,16 @@ export function clientJs(botId, trackerType, projectId, trackerSlug, contextFiel
     var botId=actBtn.getAttribute('data-bot');
     var sid=actBtn.getAttribute('data-sid');
     if(action==='dispatch'){ openRoostDispatch(botId); return; }
-    // The DOM already carries the bird's display name (.bb-roost-name,
-    // rendered by roostBirdHtml) — read it here rather than a fresh API
-    // round trip just to fill in the drawer header.
-    var birdWrap=actBtn.closest&&actBtn.closest('.bb-roost-bird');
-    var nameEl=birdWrap&&birdWrap.querySelector('.bb-roost-name');
-    var botName=nameEl?nameEl.textContent:null;
-    if(action==='open' || action==='answer'){ openBirdDrawer(sid,botId,botName); return; }
-    if(action==='sessions'){ openBirdDrawer(sid||null,botId,botName); return; }
+    // Nav-gap fix: these used to open the in-page bird drawer — they now
+    // navigate to Perch, so the bird's display name (only ever needed for
+    // the drawer's own header) is no longer read here.
+    if(action==='open' || action==='answer'){ goToPerch(sid); return; }
+    // action='sessions' has no specific session to jump to — it goes to
+    // the bare hub, not a session fragment.
+    if(action==='sessions'){ goToPerch(); return; }
     if(action==='talk'){
       perchApi('POST','/bots/'+encodeURIComponent(botId)+'/interactive').then(function(r){
-        if(r.ok){ openBirdDrawer(r.j&&r.j.sessionId,botId,botName); }
+        if(r.ok){ goToPerch(r.j&&r.j.sessionId); }
         else { crowToast((r.j&&r.j.error)||'${tJs("botboard.roostActionFailed", lang)}', {type:'error'}); }
       }).catch(function(){ crowToast('${tJs("botboard.roostActionFailed", lang)}', {type:'error'}); });
       return;
diff --git a/servers/gateway/dashboard/panels/perch-hub.js b/servers/gateway/dashboard/panels/perch-hub.js
new file mode 100644
index 00000000..3d4698d9
--- /dev/null
+++ b/servers/gateway/dashboard/panels/perch-hub.js
@@ -0,0 +1,32 @@
+/**
+ * Perch Hub Panel — bot chat surface, registered so it gets a nav entry and
+ * a launcher icon like every other panel (it did not, before this file —
+ * it was a bare route mounted straight onto /dashboard from index.js).
+ *
+ * Renders its OWN standalone document (perchHubDocument), never the
+ * dashboard shell: dashboard/index.js's panel dispatcher only sends
+ * `result` when `!res.headersSent` ("Handler may have already sent
+ * response"), so a panel handler is free to write its own response, and
+ * Perch relies on that — the panel shell is what made the old drawer
+ * cramped on a phone. This handler must never call layout().
+ */
+
+import { perchHubDocument } from "../perch-hub/html.js";
+import { engineStatus } from "../../bot-engine-status.js";
+
+export default {
+  id: "perch",
+  name: "Perch Hub",
+  icon: "messages",
+  route: "/dashboard/perch",
+  navOrder: 15.5,
+  category: "ai",
+
+  async handler(req, res, { lang }) {
+    // engineStatus() is a LEAF module of synchronous fs stats
+    // (bot-engine-status.js:84) — safe and cheap from a route. /roost cannot
+    // report engine state, so without this the list looks normal and the
+    // first tap fails with a raw error.
+    res.type("html").send(perchHubDocument(lang, engineStatus()));
+  },
+};
diff --git a/servers/gateway/dashboard/shared/i18n.js b/servers/gateway/dashboard/shared/i18n.js
index 745dcf77..ae3ab804 100644
--- a/servers/gateway/dashboard/shared/i18n.js
+++ b/servers/gateway/dashboard/shared/i18n.js
@@ -1296,6 +1296,7 @@ export const translations = {
   "botboard.noBotsOption": { en: "-- no bots --", es: "-- sin bots --" },
   "botboard.labelBotSwitcher": { en: "Bot", es: "Bot" },
   "botboard.editBotLink": { en: "Edit bot", es: "Editar bot" },
+  "botboard.perchLink": { en: "Open Perch chat", es: "Abrir chat de Perch" },
   "botboard.botNotFound": { en: "not found or disabled.", es: "no encontrado o desactivado." },
   "botboard.colBot": { en: "Bot", es: "Bot" },
   "botboard.colInstance": { en: "Instance", es: "Instancia" },
@@ -1397,7 +1398,7 @@ export const translations = {
   "botboard.roostDispatchNoteLabel": { en: "Note (optional)", es: "Nota (opcional)" },
   "botboard.roostDispatchNoCards": { en: "No free cards to send this bot to.", es: "No hay tarjetas libres para enviar a este bot." },
   "botboard.roostDispatchConfirm": { en: "Send", es: "Enviar" },
-  "botboard.roostDispatchSent": { en: "Sent — reloading…", es: "Enviado — recargando…" },
+  "botboard.roostDispatchSent": { en: "Sent — opening…", es: "Enviado — abriendo…" },
   "botboard.roostDispatchOccupied": { en: "That card was just claimed by another session.", es: "Esa tarjeta acaba de ser tomada por otra sesi\u00f3n." },
   "botboard.roostConfirmRecall": { en: "Recall this session? This stops it.", es: "\u00bfRetirar esta sesi\u00f3n? Esto la detiene." },
   "botboard.roostActionFailed": { en: "Action failed.", es: "La acci\u00f3n fall\u00f3." },
diff --git a/servers/gateway/routes/perch-hub.js b/servers/gateway/routes/perch-hub.js
deleted file mode 100644
index 7d37e7b3..00000000
--- a/servers/gateway/routes/perch-hub.js
+++ /dev/null
@@ -1,29 +0,0 @@
-import { Router } from "express";
-import { perchHubDocument } from "../dashboard/perch-hub/html.js";
-import { SUPPORTED_LANGS } from "../dashboard/shared/i18n.js";
-import { parseCookies } from "../dashboard/auth.js";
-import { engineStatus } from "../bot-engine-status.js";
-
-/** Mounted at "/dashboard" by dashboard/index.js, so this serves
- *  /dashboard/perch and inherits that mount's auth + CSRF chain. */
-export default function perchHubRouter(dashboardAuth) {
-  const router = Router();
-  // Belt and braces, deliberately. dashboard/index.js:614 already applies
-  // dashboardAuth to the whole /dashboard mount BEFORE this router is added at
-  // ~713, so this is redundant TODAY. It is kept because perchApiRouter does
-  // the same (routes/perch-interactive-api.js:628-633: "installs dashboardAuth
-  // on its own prefix so it is closed wherever it is mounted") — the router
-  // stays safe if it is ever re-mounted somewhere else. dashboardAuth is
-  // idempotent, so running twice costs a session lookup and nothing else.
-  router.use("/perch", dashboardAuth);
-  router.get("/perch", (req, res) => {
-    const cookies = parseCookies(req);
-    const lang = SUPPORTED_LANGS.includes(cookies.crow_lang) ? cookies.crow_lang : "en";
-    // engineStatus() is a LEAF module of synchronous fs stats
-    // (bot-engine-status.js:84) — safe and cheap from a route. /roost cannot
-    // report engine state, so without this the list looks normal and the first
-    // tap fails with a raw error.
-    res.type("html").send(perchHubDocument(lang, engineStatus()));
-  });
-  return router;
-}
diff --git a/tests/bot-board-perch-link.test.js b/tests/bot-board-perch-link.test.js
new file mode 100644
index 00000000..4aea61bf
--- /dev/null
+++ b/tests/bot-board-perch-link.test.js
@@ -0,0 +1,74 @@
+/**
+ * Nav-gap fix, Task B — the bot board must link BACK to Perch. Perch already
+ * links to the board (perch-hub/html.js's <nav class="machines">); before
+ * this fix the reverse link did not exist, so an operator on the board had
+ * no way back to the chat surface.
+ *
+ * Harness mirrors tests/roost-strip-ui.test.js: a hand-rolled scratch
+ * tasks.db/crow.db, minus init-db.js, with just the tables the handler
+ * actually touches on this path — plus pi_bot_defs (empty), which is what
+ * bot-board.js's tableMissing() gates the whole panel on. An empty
+ * pi_bot_defs still reaches the switcher/perch-link markup (the "no bot
+ * selected" branch renders it too), so no bot fixture row is needed.
+ */
+import { test, before, after } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import Database from "better-sqlite3";
+
+const dir = mkdtempSync(join(tmpdir(), "bot-board-perch-link-"));
+process.env.CROW_TASKS_DB_PATH = join(dir, "tasks.db");
+process.env.CROW_DB_PATH = join(dir, "crow.db");
+
+{
+  const t = new Database(process.env.CROW_TASKS_DB_PATH);
+  t.exec(`CREATE TABLE tasks_items (id INTEGER PRIMARY KEY AUTOINCREMENT, title TEXT NOT NULL,
+    description TEXT, status TEXT NOT NULL DEFAULT 'pending', priority INTEGER DEFAULT 3,
+    due_date TEXT, phase TEXT, owner TEXT, tags TEXT, parent_id INTEGER, project_id INTEGER,
+    assigned_bot TEXT, plan_ref TEXT, board_id INTEGER, data_json TEXT NOT NULL DEFAULT '{}',
+    archived_at TEXT,
+    created_at TEXT DEFAULT (datetime('now')), updated_at TEXT DEFAULT (datetime('now')), completed_at TEXT)`);
+  t.close();
+
+  const c = new Database(process.env.CROW_DB_PATH);
+  c.exec(`CREATE TABLE pi_bot_defs (bot_id TEXT PRIMARY KEY, display_name TEXT, definition TEXT,
+      enabled INTEGER NOT NULL DEFAULT 1, project_id INTEGER)`);
+  c.exec(`CREATE TABLE bot_sessions (id INTEGER PRIMARY KEY AUTOINCREMENT, bot_id TEXT NOT NULL,
+      card_id INTEGER, status TEXT NOT NULL DEFAULT 'active', control TEXT NOT NULL DEFAULT 'run',
+      pi_session_dir TEXT, kind TEXT NOT NULL DEFAULT 'chat', updated_at TEXT DEFAULT (datetime('now')))`);
+  c.close();
+}
+
+let botBoardPanel, createDbClient;
+before(async () => {
+  ({ default: botBoardPanel } = await import("../servers/gateway/dashboard/panels/bot-board.js"));
+  ({ createDbClient } = await import("../servers/db.js"));
+});
+after(() => { rmSync(dir, { recursive: true, force: true }); });
+
+const layout = (o) => o.content;
+
+async function render(lang = "en") {
+  const db = createDbClient();
+  try {
+    return await botBoardPanel.handler({ method: "GET", query: {} }, {}, { db, layout, lang });
+  } finally { db.close(); }
+}
+
+test("the bot board links back to Perch", async () => {
+  const html = await render("en");
+  assert.match(html, /<a href="\/dashboard\/perch"[^>]*>[^<]*<\/a>/, "a plain anchor to /dashboard/perch must render");
+});
+
+test("the perch link text is i18n'd, not hardcoded, and differs between en and es", async () => {
+  const en = await render("en");
+  const es = await render("es");
+  const enMatch = en.match(/<a href="\/dashboard\/perch"[^>]*>([^<]*)<\/a>/);
+  const esMatch = es.match(/<a href="\/dashboard\/perch"[^>]*>([^<]*)<\/a>/);
+  assert.ok(enMatch, "en render must carry the link");
+  assert.ok(esMatch, "es render must carry the link");
+  assert.notEqual(enMatch[1], "", "link text must not be empty");
+  assert.notEqual(enMatch[1], esMatch[1], "es text must be a real translation, not a copy of en");
+});
diff --git a/tests/perch-hub-page.test.js b/tests/perch-hub-page.test.js
index 1f39fa29..44ba5dce 100644
--- a/tests/perch-hub-page.test.js
+++ b/tests/perch-hub-page.test.js
@@ -1,8 +1,11 @@
-// The hub is a full document, not a dashboard panel: the panel shell is a
-// large part of what made the drawer cramped on a phone. It still lives under
-// /dashboard so it inherits dashboardAuth, CSRF and the Funnel rejection —
-// dashboard/index.js applies those with router.use("/dashboard", ...), so a
-// bare top-level /perch would inherit none of them.
+// The hub IS a registered dashboard panel (panels/perch-hub.js) — that's what
+// gives it a nav entry and a launcher icon — but its handler renders its own
+// standalone document (perchHubDocument) instead of calling the `layout()`
+// the generic panel dispatcher hands it: the panel shell is a large part of
+// what made the drawer cramped on a phone. It still lives under /dashboard,
+// dispatched by dashboard/index.js's generic "/dashboard/:panelId" route, so
+// it inherits dashboardAuth, CSRF and the Funnel rejection the same way every
+// other panel does — a bare top-level /perch would inherit none of them.
 import { test } from "node:test";
 import assert from "node:assert/strict";
 import { readFileSync } from "node:fs";
@@ -37,24 +40,23 @@ test("the stylesheet keeps Perch's own palette and honours OS dark mode", async
   assert.ok(!css.includes("<style>"), "perchHubCss returns bare CSS; html.js wraps it");
 });
 
-test("perchHubRouter serves /dashboard/perch when auth passes (the /perch redirect below is this test's own stand-in route, not perchHubRouter's)", async () => {
-  const { default: perchHubRouter } = await import("../servers/gateway/routes/perch-hub.js");
+test("the perch panel handler serves the standalone Perch document, not the dashboard shell (the /perch redirect below is this test's own stand-in route, not the dispatcher's)", async () => {
+  const { default: perchHubPanel } = await import("../servers/gateway/dashboard/panels/perch-hub.js");
   const { default: express } = await import("express");
   const app = express();
-  // Auth is a pass-through stub here deliberately — this test exercises only
-  // perchHubRouter's own routing: it registers a relative "/perch" handler
-  // that SERVES the page (mounted under "/dashboard" below, so the effective
-  // path is /dashboard/perch). It does NOT redirect a bare top-level /perch —
-  // that redirect is a separate route dashboard/index.js registers directly
-  // on the app, outside this router. The app.get("/perch", ...) line right
-  // below is this test's OWN stand-in for that separate route, added only so
-  // this fetch block can exercise the same short-link flow a real request
-  // would follow. The real wiring — that dashboard/index.js actually mounts
-  // perchHubRouter AND actually registers that redirect — is pinned
-  // separately by the source-level guard below, "dashboard/index.js source
-  // mounts perchHubRouter and registers the /perch redirect" — see that
-  // test's own comment for why it reads source instead of firing requests.
-  app.use("/dashboard", perchHubRouter((req, res, next) => next()));
+  // No auth stub needed here — the panel manifest's handler takes no auth
+  // parameter at all; dashboardAuth is applied once, by the generic
+  // "/dashboard/:panelId" dispatcher in dashboard/index.js, to every
+  // registered panel alike. This test exercises only the handler itself: it
+  // is called directly with a context carrying NO `layout` function, so if
+  // the handler ever tried to call layout() (wrapping the page in the
+  // dashboard shell — the thing that made the old drawer cramped on a
+  // phone) this would throw instead of silently passing. The real wiring —
+  // that dashboard/index.js actually registers this panel AND actually
+  // registers the /perch redirect — is pinned separately by the
+  // source-level guard below; see that test's own comment for why it reads
+  // source instead of firing requests.
+  app.get("/dashboard/perch", (req, res) => perchHubPanel.handler(req, res, { lang: "en" }));
   app.get("/perch", (req, res) => res.redirect(302, "/dashboard/perch"));
   const srv = await new Promise((r) => { const s = app.listen(0, "127.0.0.1", () => r(s)); });
   try {
@@ -68,32 +70,63 @@ test("perchHubRouter serves /dashboard/perch when auth passes (the /perch redire
   } finally { srv.close(); }
 });
 
-test("dashboard/index.js source mounts perchHubRouter and registers the /perch redirect", () => {
+test("the perch panel manifest has the shape the registry needs: id/route match, category drives the Agents nav group, handler never calls layout()", async () => {
+  const { default: perchHubPanel } = await import("../servers/gateway/dashboard/panels/perch-hub.js");
+  assert.equal(perchHubPanel.id, "perch", "getPanel('perch') keys off this — must match the URL segment");
+  assert.equal(perchHubPanel.route, "/dashboard/perch");
+  // nav-registry.js's CATEGORY_TO_GROUP maps category "ai" -> the "agents"
+  // nav group, and auto-assigns any panel missing from stored
+  // nav_panel_assignments by this field — this is what puts Perch in the
+  // nav on an existing install with no migration.
+  assert.equal(perchHubPanel.category, "ai");
+  assert.equal(typeof perchHubPanel.handler, "function");
+  const src = readFileSync(join(REPO, "servers/gateway/dashboard/panels/perch-hub.js"), "utf8");
+  assert.match(src, /perchHubDocument\(/, "must render the standalone Perch document");
+  // Comments (this file's own header explains the layout()-avoidance rule in
+  // prose) are stripped first so a doc comment mentioning "layout(" can't
+  // make this pass without the code itself actually avoiding the call.
+  const codeOnly = src.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/[^\n]*/g, "");
+  assert.ok(!/\blayout\(/.test(codeOnly), "must never wrap perchHubDocument in the dashboard shell");
+});
+
+test("dashboard/index.js registers the perch panel exactly once and keeps the /perch short link", () => {
   // SOURCE-LEVEL guard, not a request-level one — and it has to be, not by
   // choice. dashboardAuth is a static import near the top of dashboard/index.js,
   // not the mcpAuthMiddleware parameter dashboardRouter() actually takes, so
   // there is no way to inject a pass-through auth and reach a handler at
-  // runtime to prove presence/absence of either wiring. Worse: dashboardAuth
+  // runtime to prove presence/absence of registration. Worse: dashboardAuth
   // is applied to the WHOLE "/dashboard" prefix (router.use("/dashboard",
-  // dashboardAuth), further down in the same file) and its isAllowedNetwork() check 403s an
-  // unauthenticated off-network request BEFORE any route matching happens —
-  // identically whether or not perchHubRouter is mounted underneath it. A
-  // request-level test therefore cannot distinguish "mounted" from "not
-  // mounted"; it was tried and proved not to (round 2 of this task's review
-  // deleted only the mount line, left the /perch redirect, and the prior
-  // version of this test stayed green). Reading the source and asserting on
-  // it is the only thing that actually pins these two lines.
+  // dashboardAuth), further down in the same file) and its isAllowedNetwork()
+  // check 403s an unauthenticated off-network request BEFORE any route
+  // matching happens — identically whether or not the panel is registered. A
+  // request-level test therefore cannot distinguish "registered" from "not
+  // registered"; a predecessor of this test proved that the hard way (round
+  // 2 of this feature's review deleted only the mount line, left the /perch
+  // redirect, and the prior version of this test stayed green). Reading the
+  // source and asserting on it is the only thing that actually pins this.
   const src = readFileSync(join(REPO, "servers/gateway/dashboard/index.js"), "utf8");
   assert.match(
     src,
-    /router\.use\(\s*"\/dashboard",\s*perchHubRouter\(dashboardAuth\)\s*\)/,
-    "perchHubRouter must be mounted onto the /dashboard prefix"
+    /import\s+perchHubPanel\s+from\s+"\.\/panels\/perch-hub\.js"/,
+    "the perch panel module must be imported"
+  );
+  assert.match(
+    src,
+    /registerPanel\(perchHubPanel\)/,
+    "the perch panel must be registered like every other built-in panel"
   );
   assert.match(
     src,
     /router\.get\(\s*"\/perch",[\s\S]{0,120}?\/dashboard\/perch/,
     "the top-level /perch short link must redirect to /dashboard/perch"
   );
+  // Exactly ONE handler must serve /dashboard/perch: the registered panel,
+  // dispatched by the generic "/dashboard/:panelId" route. The old bespoke
+  // router (routes/perch-hub.js, and its mount here) must be gone entirely —
+  // a leftover mount would double-register the route and this file's own
+  // import list would carry a router that duplicates what the panel already
+  // does.
+  assert.ok(!src.includes("perchHubRouter"), "the old bespoke router must not be mounted alongside the panel");
 });
 
 test("an absent bot engine is stated up front, not discovered on the first tap", async () => {
diff --git a/tests/roost-strip-ui.test.js b/tests/roost-strip-ui.test.js
index f9a7545f..025b656f 100644
--- a/tests/roost-strip-ui.test.js
+++ b/tests/roost-strip-ui.test.js
@@ -243,9 +243,9 @@ test("fix round 1: bird-state falls through to the SHARED guarded reload when it
   assert.ok(handlerSrc.includes("guardedReload()"), "the fallback is the SAME shared guard, not a bespoke reload");
 });
 
-// ---- Fix round 1: successful dispatch must be visible, not silent ----
+// ---- Nav-gap fix: successful dispatch must be visible, and go to Perch ----
 
-test("dispatch success shows a perceivable message and defers to reload(), never closes silently", async () => {
+test("dispatch success shows a perceivable message and navigates to the new session in Perch, never closes silently", async () => {
   const js = clientJs("scout", "kanban", 9, null, null, "en");
   const body = js.replace(/^<script>/, "").replace(/<\/script>$/, "");
   const anchor = "$('bb-rd-send').onclick=function(){";
@@ -260,16 +260,76 @@ test("dispatch success shows a perceivable message and defers to reload(), never
   const okBranch = handlerSrc.slice(okBraceStart, matchBrace(handlerSrc, okBraceStart) + 1);
 
   assert.ok(okBranch.includes(t("botboard.roostDispatchSent", "en")), "success branch shows the perceivable i18n success line");
-  assert.ok(okBranch.includes("setTimeout(reload,600)"), "success branch defers to reload() with a perceivable delay");
+  // Nav-gap fix: the drawer is no longer the destination — a successful
+  // dispatch now navigates straight to the new session in Perch, using the
+  // sessionId POST /bots/:id/dispatch responds with. There is no more
+  // reload to defer to.
+  assert.ok(okBranch.includes("goToPerch(r.j&&r.j.sessionId)"), "success branch navigates to the new session in Perch");
+  assert.ok(!okBranch.includes("setTimeout(reload,600)"), "must not still defer to a reload — navigation replaces it");
   assert.ok(!okBranch.includes("closeRoostDispatch()"), "must NOT close silently — the success line is the visible feedback");
-  assert.ok(!okBranch.includes("openBirdDrawer("), "the stub can't show anything real yet — reload is the honest fallback");
+  assert.ok(!okBranch.includes("openBirdDrawer("), "the drawer is not the destination any more");
 
-  // The 409/error branches must NOT reload — they're inline, in-dialog errors.
+  // The 409/error branches must stay in-dialog: no reload, no navigation.
   const restBranch = handlerSrc.slice(matchBrace(handlerSrc, okBraceStart) + 1);
   assert.ok(!restBranch.includes("setTimeout(reload"), "error/409 branches must stay in-dialog, never reload");
+  assert.ok(!restBranch.includes("goToPerch("), "error/409 branches must stay in-dialog, never navigate");
   assert.doesNotThrow(() => new Function(handlerSrc.slice(1, -1)), "handler body parses standalone");
 });
 
+// ---- Nav-gap fix: every remaining session-open path goes to Perch ----
+
+test("the card-face bird glyph navigates to Perch instead of opening the drawer", async () => {
+  const js = clientJs("scout", "kanban", 9, null, null, "en");
+  const body = js.replace(/^<script>/, "").replace(/<\/script>$/, "");
+  const anchor = "birdGlyph=ev.target.closest";
+  const start = body.indexOf(anchor);
+  assert.ok(start >= 0, "the card-face bird glyph handler must exist");
+  const scope = body.slice(start, body.indexOf("return;", start) + "return;".length);
+  assert.ok(scope.includes("goToPerch(birdGlyph.getAttribute('data-bird-sid'))"), "must navigate with the glyph's session id");
+  assert.ok(!scope.includes("openBirdDrawer("), "must not still open the drawer");
+});
+
+test("the #bird=<sid> deep link navigates to Perch instead of opening the drawer", async () => {
+  const js = clientJs("scout", "kanban", 9, null, null, "en");
+  const body = js.replace(/^<script>/, "").replace(/<\/script>$/, "");
+  const anchor = "if(window._bbForeignHash){";
+  // Two "if(window._bbForeignHash){" blocks are emitted: updateFilterHash's
+  // (round-trips search/status filters) comes first, the hash-driven-open
+  // block this test targets comes second — lastIndexOf, not indexOf.
+  const start = body.lastIndexOf(anchor);
+  assert.ok(start >= 0, "the foreign-hash open block must exist");
+  const braceStart = start + anchor.length - 1;
+  const scope = body.slice(braceStart, matchBrace(body, braceStart) + 1);
+  assert.ok(scope.includes("goToPerch(window._bbForeignHash.bird)"), "the bird hash key must navigate to that session");
+  assert.ok(!scope.includes("openBirdDrawer("), "must not still open the drawer");
+  // The card key is a DIFFERENT feature (scrolls the card into view) and is
+  // untouched by this fix — still routed through bdFocusCard.
+  assert.ok(scope.includes("bdFocusCard(window._bbForeignHash.card)"), "the card hash key must still be handled");
+});
+
+test("roost strip actions open/answer/sessions/talk navigate to Perch instead of opening the drawer", async () => {
+  const js = clientJs("scout", "kanban", 9, null, null, "en");
+  const body = js.replace(/^<script>/, "").replace(/<\/script>$/, "");
+  // Three "document.addEventListener('click',function(ev){" blocks are
+  // emitted (card-drag delegation, the spliced-in drawer's own listener,
+  // and this roost-strip delegation) — anchor on the roost-only marker
+  // "[data-roost-action]" and walk back to the nearest enclosing listener
+  // so the right one is sliced, not just the first match.
+  const needle = "document.addEventListener('click',function(ev){";
+  const roostMarker = body.indexOf("[data-roost-action]");
+  assert.ok(roostMarker >= 0, "the roost action delegation must exist");
+  const start = body.lastIndexOf(needle, roostMarker);
+  assert.ok(start >= 0, "must find the enclosing click listener");
+  const braceStart = body.indexOf("{", body.indexOf("function(ev)", start));
+  const handlerSrc = body.slice(braceStart, matchBrace(body, braceStart) + 1);
+
+  assert.ok(handlerSrc.includes("goToPerch(sid); return; }"), "action=open/answer must navigate with the session id");
+  assert.ok(handlerSrc.includes("goToPerch(); return; }"), "action=sessions has no specific session — bare hub, no fragment");
+  assert.ok(handlerSrc.includes("goToPerch(r.j&&r.j.sessionId); }"), "action=talk's spawn-success branch must navigate to the new session");
+  assert.ok(!handlerSrc.includes("openBirdDrawer("), "none of these actions may still open the drawer");
+  assert.doesNotThrow(() => new Function("ev", handlerSrc.slice(1, -1)), "handler body must parse standalone");
+});
+
 // ---- i18n ----
 
 test("roost i18n keys exist in both languages and are not identical placeholders", async () => {