From 907b454298f0fd2d625967fd9c68ed4f4f99fda4 Mon Sep 17 00:00:00 2001
From: Teo | Nexcore <teonexcore@gmail.com>
Date: Wed, 23 Sep 2026 04:17:57 +0300
Subject: [PATCH 01/10] fix(canvas): keep sticky note editor wheel local

---
 .../src/features/notes/StickyNoteCard.tsx     |  5 +
 .../notes/stickyNoteWheelAttributes.ts        |  6 ++
 .../features/workspace/canvasWheelRouting.ts  | 57 +++++++++++
 .../workspace/useCanvasWheelNavigation.ts     | 33 ++-----
 tests/canvas-wheel-routing.test.mjs           | 96 +++++++++++++++++++
 5 files changed, 170 insertions(+), 27 deletions(-)
 create mode 100644 src/renderer/src/features/notes/stickyNoteWheelAttributes.ts
 create mode 100644 src/renderer/src/features/workspace/canvasWheelRouting.ts
 create mode 100644 tests/canvas-wheel-routing.test.mjs

diff --git a/src/renderer/src/features/notes/StickyNoteCard.tsx b/src/renderer/src/features/notes/StickyNoteCard.tsx
index c84f38e1..278b067a 100644
--- a/src/renderer/src/features/notes/StickyNoteCard.tsx
+++ b/src/renderer/src/features/notes/StickyNoteCard.tsx
@@ -8,6 +8,7 @@ import {
   MAX_STICKY_NOTE_SIZE,
   MIN_STICKY_NOTE_SIZE
 } from "./stickyNoteBounds";
+import { stickyNoteWheelAttributes } from "./stickyNoteWheelAttributes";
 
 interface StickyNoteCardProps {
   note: StickyNote;
@@ -213,12 +214,15 @@ export function StickyNoteCard({
     onBoundsChange(note.id, liveBounds.current);
   };
 
+  const wheelAttributes = stickyNoteWheelAttributes(note.id);
+
   return (
     <article
       className={`sticky-note-card ${groupSelected ? "sticky-note-card--selected" : ""}`}
       data-interactive="true"
       data-sticky-note-id={note.id}
       data-canvas-layer-id={`note:${note.id}`}
+      {...wheelAttributes.card}
       data-wheel-owner="local"
       style={{
         zIndex: stackIndex,
@@ -250,6 +254,7 @@ export function StickyNoteCard({
         </button>
       </header>
       <textarea
+        {...wheelAttributes.editor}
         ref={editor}
         className="sticky-note-card__editor"
         value={text}
diff --git a/src/renderer/src/features/notes/stickyNoteWheelAttributes.ts b/src/renderer/src/features/notes/stickyNoteWheelAttributes.ts
new file mode 100644
index 00000000..c0738b8c
--- /dev/null
+++ b/src/renderer/src/features/notes/stickyNoteWheelAttributes.ts
@@ -0,0 +1,6 @@
+export function stickyNoteWheelAttributes(noteId: string) {
+  return {
+    card: { "data-canvas-widget-id": `note:${noteId}` },
+    editor: { "data-canvas-wheel-priority": "local" }
+  } as const;
+}
diff --git a/src/renderer/src/features/workspace/canvasWheelRouting.ts b/src/renderer/src/features/workspace/canvasWheelRouting.ts
new file mode 100644
index 00000000..a238da98
--- /dev/null
+++ b/src/renderer/src/features/workspace/canvasWheelRouting.ts
@@ -0,0 +1,57 @@
+import type { CanvasWheelCaptureMode } from "../../../../shared/contracts.ts";
+import {
+  normalizeCanvasWheelDeltas,
+  shouldCanvasOwnWheel
+} from "../../../../shared/canvasNavigation.ts";
+import {
+  isFocusedCanvasWidgetTarget,
+  isPriorityLocalCanvasWheelTarget
+} from "./canvasWidgetFocus.ts";
+
+export interface CanvasWheelRoutingInput {
+  focusedWidgetId: string | null;
+  captureMode: CanvasWheelCaptureMode;
+  wheelOverrideActive: boolean;
+  navigationOverrideActive: boolean;
+  getBounds(): Pick<DOMRect, "width" | "height">;
+  applyCanvasWheel(input: {
+    clientX: number;
+    clientY: number;
+    deltaX: number;
+    deltaY: number;
+    ctrlKey: boolean;
+    metaKey: boolean;
+  }): void;
+}
+
+/** Route a native wheel event and report whether canvas navigation claimed it. */
+export function routeCanvasWheelEvent(event: WheelEvent, input: CanvasWheelRoutingInput): boolean {
+  const priorityLocalOwner = isPriorityLocalCanvasWheelTarget(event.target);
+  const browserFreezeOwned = !priorityLocalOwner
+    && event.target instanceof Element
+    && event.target.closest('[data-browser-canvas-wheel-owner="canvas"]') !== null;
+  const ownedByCanvas = browserFreezeOwned || shouldCanvasOwnWheel({
+    overFocusedWidget: priorityLocalOwner
+      || isFocusedCanvasWidgetTarget(event.target, input.focusedWidgetId),
+    captureMode: input.captureMode,
+    wheelOverrideActive: input.wheelOverrideActive,
+    navigationOverrideActive: input.navigationOverrideActive
+  });
+  if (!ownedByCanvas) return false;
+
+  event.preventDefault();
+  event.stopPropagation();
+  input.applyCanvasWheel({
+    clientX: event.clientX,
+    clientY: event.clientY,
+    ...normalizeCanvasWheelDeltas(
+      event.deltaX,
+      event.deltaY,
+      event.deltaMode,
+      input.getBounds()
+    ),
+    ctrlKey: event.ctrlKey,
+    metaKey: event.metaKey
+  });
+  return true;
+}
diff --git a/src/renderer/src/features/workspace/useCanvasWheelNavigation.ts b/src/renderer/src/features/workspace/useCanvasWheelNavigation.ts
index cf9c4e4a..bf64ebbd 100644
--- a/src/renderer/src/features/workspace/useCanvasWheelNavigation.ts
+++ b/src/renderer/src/features/workspace/useCanvasWheelNavigation.ts
@@ -10,14 +10,10 @@ import {
   canvasNavigationMouseButtonFromDomButton,
   canvasWheelIntent,
   isCanvasNavigationBindingActive,
-  normalizeCanvasWheelDeltas,
   shouldCanvasOwnWheel,
   type CanvasWheelDeltas
 } from "../../../../shared/canvasNavigation";
-import {
-  isFocusedCanvasWidgetTarget,
-  isPriorityLocalCanvasWheelTarget
-} from "./canvasWidgetFocus";
+import { routeCanvasWheelEvent } from "./canvasWheelRouting";
 import type { CanvasWidgetFocusState } from "./useCanvasWidgetFocus";
 
 export interface CanvasWheelInput extends CanvasWheelDeltas {
@@ -210,30 +206,13 @@ export function useCanvasWheelNavigation({
     const element = viewport.current;
     if (!element) return;
     const handleWheel = (event: WheelEvent): void => {
-      // A priority-local surface (Browser panels, HOME session list) keeps the
-      // wheel over its own scroll area, so the freeze marker on the card must
-      // not outrank it; explicit capture modes still claim the wheel below.
-      const priorityLocalOwner = isPriorityLocalCanvasWheelTarget(event.target);
-      const browserFreezeOwned = !priorityLocalOwner
-        && event.target instanceof Element
-        && event.target.closest('[data-browser-canvas-wheel-owner="canvas"]') !== null;
-      const ownedByCanvas = browserFreezeOwned || shouldCanvasOwnWheel({
-        overFocusedWidget: priorityLocalOwner
-          || isFocusedCanvasWidgetTarget(event.target, widgetFocusRef.current.id),
+      routeCanvasWheelEvent(event, {
+        focusedWidgetId: widgetFocusRef.current.id,
         captureMode: settingsRef.current.canvasWheelCaptureMode,
         wheelOverrideActive: wheelOverrideActiveRef.current,
-        navigationOverrideActive: canvasOverrideActiveRef.current
-      });
-      if (!ownedByCanvas) return;
-      event.preventDefault();
-      event.stopPropagation();
-      const bounds = element.getBoundingClientRect();
-      applyCanvasWheel({
-        clientX: event.clientX,
-        clientY: event.clientY,
-        ...normalizeCanvasWheelDeltas(event.deltaX, event.deltaY, event.deltaMode, bounds),
-        ctrlKey: event.ctrlKey,
-        metaKey: event.metaKey
+        navigationOverrideActive: canvasOverrideActiveRef.current,
+        getBounds: () => element.getBoundingClientRect(),
+        applyCanvasWheel
       });
     };
     element.addEventListener("wheel", handleWheel, { capture: true, passive: false });
diff --git a/tests/canvas-wheel-routing.test.mjs b/tests/canvas-wheel-routing.test.mjs
new file mode 100644
index 00000000..4dcfeb12
--- /dev/null
+++ b/tests/canvas-wheel-routing.test.mjs
@@ -0,0 +1,96 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { stickyNoteWheelAttributes } from "../src/renderer/src/features/notes/stickyNoteWheelAttributes.ts";
+import { routeCanvasWheelEvent } from "../src/renderer/src/features/workspace/canvasWheelRouting.ts";
+
+class TestElement {
+  constructor(attributes = {}, parent = null) {
+    this.attributes = attributes;
+    this.parent = parent;
+    this.dataset = Object.fromEntries(Object.entries(attributes)
+      .filter(([name]) => name.startsWith("data-"))
+      .map(([name, value]) => [name.slice(5).replace(/-([a-z])/g, (_, letter) => letter.toUpperCase()), value]));
+  }
+
+  closest(selector) {
+    const match = selector.match(/^\[([^=\]]+)(?:="([^"]+)")?\]$/);
+    if (!match) throw new Error(`Unsupported test selector: ${selector}`);
+    const [, name, expected] = match;
+    for (let element = this; element; element = element.parent) {
+      if (name in element.attributes && (expected === undefined || element.attributes[name] === expected)) {
+        return element;
+      }
+    }
+    return null;
+  }
+}
+
+function dispatchWheel(target, applyCanvasWheel) {
+  let defaultPrevented = false;
+  let propagationStopped = false;
+  const event = {
+    target,
+    clientX: 40,
+    clientY: 60,
+    deltaX: 0,
+    deltaY: 24,
+    deltaMode: 0,
+    ctrlKey: false,
+    metaKey: false,
+    preventDefault() { defaultPrevented = true; },
+    stopPropagation() { propagationStopped = true; }
+  };
+  const canvasClaimed = routeCanvasWheelEvent(event, {
+    focusedWidgetId: null,
+    captureMode: "off",
+    wheelOverrideActive: false,
+    navigationOverrideActive: false,
+    getBounds: () => ({ width: 800, height: 600 }),
+    applyCanvasWheel
+  });
+  return { canvasClaimed, defaultPrevented, propagationStopped };
+}
+
+test("sticky-note editor keeps its wheel while header and canvas background navigate", () => {
+  const priorElement = globalThis.Element;
+  globalThis.Element = TestElement;
+  try {
+    const attributes = stickyNoteWheelAttributes("note-1");
+    const card = new TestElement(attributes.card);
+    const editor = new TestElement(attributes.editor, card);
+    const header = new TestElement({}, card);
+    const background = new TestElement();
+    const canvasEvents = [];
+    const applyCanvasWheel = (input) => canvasEvents.push(input);
+
+    assert.equal(card.dataset.canvasWidgetId, "note:note-1");
+    assert.equal(card.dataset.canvasWidgetFocusable, undefined);
+    assert.deepEqual(dispatchWheel(editor, applyCanvasWheel), {
+      canvasClaimed: false,
+      defaultPrevented: false,
+      propagationStopped: false
+    });
+    assert.deepEqual(dispatchWheel(header, applyCanvasWheel), {
+      canvasClaimed: true,
+      defaultPrevented: true,
+      propagationStopped: true
+    });
+    assert.deepEqual(dispatchWheel(background, applyCanvasWheel), {
+      canvasClaimed: true,
+      defaultPrevented: true,
+      propagationStopped: true
+    });
+    assert.equal(canvasEvents.length, 2);
+    assert.deepEqual(canvasEvents[0], {
+      clientX: 40,
+      clientY: 60,
+      deltaX: 0,
+      deltaY: 24,
+      ctrlKey: false,
+      metaKey: false
+    });
+  } finally {
+    if (priorElement === undefined) delete globalThis.Element;
+    else globalThis.Element = priorElement;
+  }
+});

From e4f0c9fccacc7a00bf770f5a97e1d3ef6a42d424 Mon Sep 17 00:00:00 2001
From: SaneSanders <129727118+SaneSanders@users.noreply.github.com>
Date: Thu, 24 Sep 2026 04:47:59 +0300
Subject: [PATCH 02/10] fix(limits): read Kimi Code 2 usage quotas

---
 src/main/services/LimitsService.ts | 42 +++++++++++++++++++++++++++-
 tests/limits-normalizer.test.mjs   | 45 ++++++++++++++++++++++++++++++
 2 files changed, 86 insertions(+), 1 deletion(-)

diff --git a/src/main/services/LimitsService.ts b/src/main/services/LimitsService.ts
index aa929f43..875330cd 100644
--- a/src/main/services/LimitsService.ts
+++ b/src/main/services/LimitsService.ts
@@ -1009,7 +1009,13 @@ export function normalizeKimiLimits(raw: unknown): LimitWindow[] {
   const payload = isRecord(raw.data) ? raw.data : raw;
   if (payload.kind === "error") {
     const message = typeof payload.message === "string" ? payload.message.toLowerCase() : "";
-    throw new LimitsAdapterError(message.includes("auth") || message.includes("login") ? "not-authenticated" : "protocol-error");
+    throw new LimitsAdapterError(
+      message.includes("auth") || message.includes("login")
+        ? "not-authenticated"
+        : message.includes("timed out")
+          ? "timeout"
+          : "protocol-error"
+    );
   }
   const windows: LimitWindow[] = [];
   const managedSummary = payload.summary;
@@ -1086,6 +1092,40 @@ export function normalizeKimiLimits(raw: unknown): LimitWindow[] {
     }
   }
 
+  const managedUsages = isRecord(payload.quota) && isRecord(payload.quota.usages) ? payload.quota.usages : null;
+  if (managedUsages) {
+    const definitions: Array<{
+      key: "limit5h" | "limit7d" | "monthTotal";
+      id: string;
+      slot: "primary" | "secondary";
+      label: string;
+      windowMinutes: number | null;
+    }> = [
+      { key: "limit5h", id: "kimi:managed:300", slot: "primary", label: "5h", windowMinutes: 300 },
+      { key: "limit7d", id: "kimi:weekly", slot: "secondary", label: "7d", windowMinutes: 10_080 },
+      { key: "monthTotal", id: "kimi:monthly", slot: "secondary", label: "monthly", windowMinutes: null }
+    ];
+    for (const { key, id, slot, label, windowMinutes } of definitions) {
+      const candidate = managedUsages[key];
+      if (!isRecord(candidate)) continue;
+      const usedRatio = numericValue(candidate.usedRatio);
+      const resetsAt = epochMilliseconds(candidate.resetAt);
+      if (usedRatio === null && resetsAt === null) continue;
+      windows.push({
+        id,
+        bucketId: "kimi",
+        slot,
+        isDefaultBucket: true,
+        label,
+        usedPercent: usedRatio === null ? null : clampPercent(usedRatio * 100),
+        used: null,
+        limit: null,
+        windowMinutes,
+        resetsAt
+      });
+    }
+  }
+
   return windows.slice(0, MAX_WINDOWS);
 }
 
diff --git a/tests/limits-normalizer.test.mjs b/tests/limits-normalizer.test.mjs
index af5963f5..266b4773 100644
--- a/tests/limits-normalizer.test.mjs
+++ b/tests/limits-normalizer.test.mjs
@@ -97,6 +97,51 @@ test("normalizes Kimi weekly and rolling usage without exposing account metadata
   ]);
 });
 
+test("normalizes Kimi Code 2 quota windows", () => {
+  const windows = normalizeKimiLimits({
+    code: 0,
+    msg: "success",
+    data: {
+      kind: "ok",
+      quota: {
+        usages: {
+          limit5h: { usedRatio: 0.25, resetAt: "2026-09-24T05:45:52Z" },
+          limit7d: { usedRatio: 0.5, resetAt: "2026-09-29T00:00:00Z" },
+          monthTotal: { usedRatio: 0.1246, resetAt: "2026-10-18T00:00:00Z" },
+          monthCode: { usedRatio: 0.1, resetAt: "2026-10-18T00:00:00Z" }
+        },
+        extraUsage: null
+      }
+    }
+  });
+
+  assert.deepEqual(windows.map((window) => ({
+    id: window.id,
+    usedPercent: window.usedPercent,
+    windowMinutes: window.windowMinutes,
+    resetsAt: window.resetsAt
+  })), [
+    { id: "kimi:managed:300", usedPercent: 25, windowMinutes: 300, resetsAt: Date.parse("2026-09-24T05:45:52Z") },
+    { id: "kimi:weekly", usedPercent: 50, windowMinutes: 10_080, resetsAt: Date.parse("2026-09-29T00:00:00Z") },
+    { id: "kimi:monthly", usedPercent: 12.46, windowMinutes: null, resetsAt: Date.parse("2026-10-18T00:00:00Z") }
+  ]);
+});
+
+test("maps Kimi usage errors to reasons", () => {
+  const cases = [
+    { message: "Failed to fetch usage: request timed out.", reason: "timeout" },
+    { message: "Authorization failed. Please check your API key (try /login).", reason: "not-authenticated" },
+    { message: "Failed to fetch usage: HTTP 500", reason: "protocol-error" }
+  ];
+
+  for (const { message, reason } of cases) {
+    assert.throws(
+      () => normalizeKimiLimits({ code: 0, data: { kind: "error", message } }),
+      (error) => error instanceof Error && error.message === reason
+    );
+  }
+});
+
 test("normalizes every real OpenCode Go usage window", () => {
   const windows = normalizeOpenCodeGoLimits({
     usage: {

From e930173f31cd63ef919343c30f90c6f19d7fea21 Mon Sep 17 00:00:00 2001
From: SaneSanders <129727118+SaneSanders@users.noreply.github.com>
Date: Thu, 24 Sep 2026 18:17:24 +0300
Subject: [PATCH 03/10] fix(limits): distinguish expired Grok sessions from
 sign-out

---
 src/main/services/LimitsService.ts          |  28 +++--
 src/renderer/src/features/home/HomeZone.tsx |   2 +
 src/renderer/src/lib/i18n.ts                |   2 +
 src/shared/contracts.ts                     |   1 +
 tests/grok-limits-adapter.test.mjs          | 110 ++++++++++++++++++++
 5 files changed, 136 insertions(+), 7 deletions(-)
 create mode 100644 tests/grok-limits-adapter.test.mjs

diff --git a/src/main/services/LimitsService.ts b/src/main/services/LimitsService.ts
index aa929f43..5421b6cc 100644
--- a/src/main/services/LimitsService.ts
+++ b/src/main/services/LimitsService.ts
@@ -50,6 +50,13 @@ interface PendingRequest {
   timer: NodeJS.Timeout;
 }
 
+interface GrokCredential {
+  token: string;
+  authMode: number;
+  expiresAt: number;
+  sessionExpired: boolean;
+}
+
 export class LimitsService {
   private codex: CodexAppServerClient;
   private kimi: KimiWebUsageClient;
@@ -402,10 +409,11 @@ async function readOpenCodeGoUsage(clientVersion: string): Promise<unknown> {
 async function readGrokUsage(clientVersion: string): Promise<unknown> {
   const configRoot = process.env.GROK_HOME || join(homedir(), ".grok");
   const credentials = await readCredentialFile(join(configRoot, "auth.json"), "not-authenticated");
-  const accessToken = selectGrokAccessToken(credentials);
-  if (!accessToken) throw new LimitsAdapterError("not-authenticated");
+  const credential = selectGrokCredential(credentials);
+  if (!credential) throw new LimitsAdapterError("not-authenticated");
+  if (credential.sessionExpired) throw new LimitsAdapterError("session-expired");
 
-  return fetchUsageJson(GROK_BILLING_URL, accessToken, {
+  return fetchUsageJson(GROK_BILLING_URL, credential.token, {
     "x-xai-token-auth": "xai-grok-cli",
     "user-agent": `canvastty/${clientVersion}`
   });
@@ -445,17 +453,18 @@ async function readFirstCredentialFile(
   throw new LimitsAdapterError(missingReason);
 }
 
-function selectGrokAccessToken(credentials: Record<string, unknown>): string | null {
+function selectGrokCredential(credentials: Record<string, unknown>): GrokCredential | null {
   const candidates = Object.values(credentials)
     .filter(isRecord)
     .map((credential) => ({
       token: cleanSecret(credential.key),
       authMode: credential.auth_mode === "oidc" ? 1 : 0,
-      expiresAt: numericValue(credential.expires_at) ?? 0
+      expiresAt: numericValue(credential.expires_at) ?? 0,
+      sessionExpired: cleanSecret(credential.refresh_token) !== null && hasExpired(credential.expires_at)
     }))
-    .filter((candidate): candidate is { token: string; authMode: number; expiresAt: number } => candidate.token !== null)
+    .filter((candidate): candidate is GrokCredential => candidate.token !== null)
     .sort((left, right) => right.authMode - left.authMode || right.expiresAt - left.expiresAt);
-  return candidates[0]?.token ?? null;
+  return candidates[0] ?? null;
 }
 
 async function readCredentialFile(path: string, missingReason: LimitUnavailableReason): Promise<Record<string, unknown>> {
@@ -1199,6 +1208,11 @@ function epochMilliseconds(value: unknown): number | null {
   return Number.isSafeInteger(Math.trunc(milliseconds)) ? Math.trunc(milliseconds) : null;
 }
 
+function hasExpired(value: unknown): boolean {
+  const expiresAt = epochMilliseconds(value);
+  return expiresAt !== null && expiresAt <= Date.now();
+}
+
 function clampPercent(value: number): number {
   return Math.min(100, Math.max(0, value));
 }
diff --git a/src/renderer/src/features/home/HomeZone.tsx b/src/renderer/src/features/home/HomeZone.tsx
index 36d9a202..8167b50f 100644
--- a/src/renderer/src/features/home/HomeZone.tsx
+++ b/src/renderer/src/features/home/HomeZone.tsx
@@ -583,6 +583,8 @@ function limitReasonLabel(reason: HomeLimitReason | null, locale: LocaleId): str
     ? "limitCliNotFound"
     : reason === "not-authenticated"
       ? "limitNotAuthenticated"
+      : reason === "session-expired"
+        ? "limitSessionExpired"
       : reason === "subscription-required"
         ? "limitSubscriptionRequired"
       : reason === "unsupported-protocol"
diff --git a/src/renderer/src/lib/i18n.ts b/src/renderer/src/lib/i18n.ts
index 0495f7be..4544c1b9 100644
--- a/src/renderer/src/lib/i18n.ts
+++ b/src/renderer/src/lib/i18n.ts
@@ -24,6 +24,7 @@ const ru = {
   limitUnavailable: "Данные недоступны",
   limitCliNotFound: "CLI не найден",
   limitNotAuthenticated: "Требуется вход",
+  limitSessionExpired: "Сессия истекла, запустите CLI",
   limitSubscriptionRequired: "Требуется подписка",
   limitUnsupported: "Лимит не поддерживается",
   limitTimeout: "Провайдер не ответил",
@@ -628,6 +629,7 @@ const en: Record<keyof typeof ru, string> = {
   limitUnavailable: "Data unavailable",
   limitCliNotFound: "CLI not found",
   limitNotAuthenticated: "Sign-in required",
+  limitSessionExpired: "Session expired, launch the CLI",
   limitSubscriptionRequired: "Subscription required",
   limitUnsupported: "Limit not supported",
   limitTimeout: "Provider timed out",
diff --git a/src/shared/contracts.ts b/src/shared/contracts.ts
index 40279629..cbafab34 100644
--- a/src/shared/contracts.ts
+++ b/src/shared/contracts.ts
@@ -999,6 +999,7 @@ export type LimitSource =
 export type LimitUnavailableReason =
   | "cli-not-found"
   | "not-authenticated"
+  | "session-expired"
   | "subscription-required"
   | "unsupported-protocol"
   | "timeout"
diff --git a/tests/grok-limits-adapter.test.mjs b/tests/grok-limits-adapter.test.mjs
new file mode 100644
index 00000000..0a65a84d
--- /dev/null
+++ b/tests/grok-limits-adapter.test.mjs
@@ -0,0 +1,110 @@
+import assert from "node:assert/strict";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { LimitsService } from "../src/main/services/LimitsService.ts";
+
+async function readGrokLimits(credentials) {
+  const grokHome = await mkdtemp(join(tmpdir(), "canvastty-grok-limits-"));
+  const originalFetch = globalThis.fetch;
+  const previousGrokHome = process.env.GROK_HOME;
+  const requests = [];
+  const service = new LimitsService({
+    get(provider) {
+      if (provider === "grok") {
+        return { state: "available", provider, executable: "/resolved/grok", launcher: "native", environment: {}, checked: [] };
+      }
+      return { state: "unavailable", provider, reason: "cli-not-found", checked: [], diagnostic: "" };
+    }
+  }, "test");
+  try {
+    await writeFile(join(grokHome, "auth.json"), JSON.stringify(credentials), "utf8");
+    process.env.GROK_HOME = grokHome;
+    globalThis.fetch = async (url, init) => {
+      requests.push({ url: String(url), authorization: init.headers.authorization });
+      if (init.headers.authorization !== "Bearer live-token") return new Response("{}", { status: 401 });
+      return Response.json({
+        config: {
+          creditUsagePercent: 43,
+          currentPeriod: { type: "USAGE_PERIOD_TYPE_WEEKLY", start: "2026-09-21T06:16:11Z", end: "2026-09-28T06:16:11Z" }
+        }
+      });
+    };
+    const grok = (await service.get()).providers.find(({ provider }) => provider === "grok");
+    return { grok, requests };
+  } finally {
+    service.dispose();
+    globalThis.fetch = originalFetch;
+    if (previousGrokHome === undefined) delete process.env.GROK_HOME;
+    else process.env.GROK_HOME = previousGrokHome;
+    await rm(grokHome, { recursive: true, force: true });
+  }
+}
+
+test("expired Grok sessions ask to launch the CLI without a billing request", async () => {
+  const { grok, requests } = await readGrokLimits({
+    "https://auth.x.ai::client": {
+      key: "expired-token",
+      auth_mode: "oidc",
+      refresh_token: "refresh-token",
+      expires_at: "2026-09-21T08:58:02.037226Z"
+    }
+  });
+
+  assert.equal(grok.state, "unavailable");
+  assert.equal(grok.reason, "session-expired");
+  assert.deepEqual(requests, []);
+});
+
+test("expired Grok tokens without a refresh token still require sign-in", async () => {
+  const { grok, requests } = await readGrokLimits({
+    "https://accounts.x.ai/sign-in": { key: "expired-token", refresh_token: " ", expires_at: "2026-09-21T08:58:02Z" }
+  });
+
+  assert.equal(grok.state, "unavailable");
+  assert.equal(grok.reason, "not-authenticated");
+  assert.equal(requests.length, 1);
+});
+
+test("a stale Grok credential does not hide the selected live one", async () => {
+  const { grok, requests } = await readGrokLimits({
+    "https://accounts.x.ai/sign-in": { key: "expired-token", refresh_token: "refresh-token", expires_at: "2026-09-21T08:58:02Z" },
+    "https://auth.x.ai::client": {
+      key: "live-token",
+      auth_mode: "oidc",
+      refresh_token: "refresh-token",
+      expires_at: new Date(Date.now() + 3_600_000).toISOString()
+    }
+  });
+
+  assert.equal(grok.state, "available");
+  assert.equal(requests.length, 1);
+});
+
+test("Grok credentials without an expiry still read billing", async () => {
+  const { grok, requests } = await readGrokLimits({
+    "https://auth.x.ai::client": { key: "live-token", auth_mode: "oidc", refresh_token: "refresh-token" }
+  });
+
+  assert.equal(grok.state, "available");
+  assert.equal(requests.length, 1);
+});
+
+test("live Grok sessions still read billing", async () => {
+  const { grok, requests } = await readGrokLimits({
+    "https://auth.x.ai::client": {
+      key: "live-token",
+      auth_mode: "oidc",
+      refresh_token: "refresh-token",
+      expires_at: new Date(Date.now() + 3_600_000).toISOString()
+    }
+  });
+
+  assert.equal(grok.state, "available");
+  assert.equal(grok.windows[0].usedPercent, 43);
+  assert.deepEqual(requests, [{
+    url: "https://cli-chat-proxy.grok.com/v1/billing?format=credits",
+    authorization: "Bearer live-token"
+  }]);
+});

From cf04ad2ba512bc65d7b500bc1c78bb8db882be3a Mon Sep 17 00:00:00 2001
From: Teo | Nexcore <teonexcore@gmail.com>
Date: Thu, 24 Sep 2026 19:20:49 +0300
Subject: [PATCH 04/10] fix(canvas): place new terminals in free slots near
 Home

---
 src/renderer/src/App.tsx                      |  56 ++++--
 .../features/workspace/sessionPlacement.ts    | 169 ++++++++++++++++++
 tests/session-placement.test.mjs              | 168 +++++++++++++++++
 3 files changed, 375 insertions(+), 18 deletions(-)
 create mode 100644 src/renderer/src/features/workspace/sessionPlacement.ts
 create mode 100644 tests/session-placement.test.mjs

diff --git a/src/renderer/src/App.tsx b/src/renderer/src/App.tsx
index 37589a88..91a5db2b 100644
--- a/src/renderer/src/App.tsx
+++ b/src/renderer/src/App.tsx
@@ -62,6 +62,7 @@ import {
 } from "./lib/shortcuts";
 import { homeGridPixelSize, homeLayoutFitsGrid, placeHomeWidget } from "./features/home/homeLayout";
 import { boundsInsideRegion, translateBounds } from "./features/workspace/canvasRegions";
+import { DEFAULT_SESSION_SIZE, findNearHomeSessionPosition } from "./features/workspace/sessionPlacement";
 
 interface HomeEditDraft {
   homeGridSize: HomeGridSize;
@@ -185,6 +186,9 @@ function contrastRatio(left: number, right: number): number {
 export function App(): React.JSX.Element {
   const [settings, setSettings] = useState(FALLBACK_SETTINGS);
   const [sessions, setSessions] = useState<SessionSnapshot[]>([]);
+  const sessionsRef = useRef(sessions);
+  sessionsRef.current = sessions;
+  const pendingSessionPlacements = useRef<SessionBounds[]>([]);
   const [limits, setLimits] = useState<LimitsSnapshot | null>(null);
   const [limitsLoadState, setLimitsLoadState] = useState<LimitsLoadState>("loading");
   const [limitsRevision, setLimitsRevision] = useState(0);
@@ -364,17 +368,41 @@ export function App(): React.JSX.Element {
     requestedCenter?: Point,
     role: LaunchRole = "agent"
   ): Promise<SessionSnapshot> => {
+    const currentSettings = settingsRef.current;
     const position = requestedCenter
-      ? centeredWindowPosition(requestedCenter, { width: 700, height: 430 })
-      : nextSessionPosition(sessions.length, settings.homeGridSize);
-    const session = await window.canvasTTY.terminal.create({ provider, profile, cwd, position, role });
-    setSessions((current) => upsertSnapshot(current, session));
-    setActiveSessionId(session.id);
-    await saveSettings({ lastDirectory: cwd });
-    isHomeCamera.current = false;
-    setCamera(focusCamera(position, session.size));
-    return session;
-  }, [sessions.length, saveSettings, settings.homeGridSize]);
+      ? centeredWindowPosition(requestedCenter, DEFAULT_SESSION_SIZE)
+      : findNearHomeSessionPosition(
+          { position: { x: 0, y: 0 }, size: homeGridPixelSize(currentSettings.homeGridSize) },
+          [
+            ...sessionsRef.current,
+            ...currentSettings.pluginCanvas,
+            ...currentSettings.stickyNotes,
+            ...(currentSettings.browserCanvas ? [currentSettings.browserCanvas] : []),
+            ...pendingSessionPlacements.current
+          ],
+          DEFAULT_SESSION_SIZE
+        );
+    // Reserve the slot until the async create finishes, so fast parallel launches
+    // cannot both choose the same free position before React renders either card.
+    const reservation: SessionBounds | null = requestedCenter
+      ? null
+      : { position, size: DEFAULT_SESSION_SIZE };
+    if (reservation) pendingSessionPlacements.current.push(reservation);
+    try {
+      const session = await window.canvasTTY.terminal.create({ provider, profile, cwd, position, role });
+      sessionsRef.current = upsertSnapshot(sessionsRef.current, session);
+      setSessions((current) => upsertSnapshot(current, session));
+      setActiveSessionId(session.id);
+      await saveSettings({ lastDirectory: cwd });
+      isHomeCamera.current = false;
+      setCamera(focusCamera(position, session.size));
+      return session;
+    } finally {
+      if (reservation) {
+        pendingSessionPlacements.current = pendingSessionPlacements.current.filter((item) => item !== reservation);
+      }
+    }
+  }, [saveSettings]);
 
   const openTerminal = useCallback(async (position?: Point): Promise<void> => {
     try {
@@ -1164,14 +1192,6 @@ export function App(): React.JSX.Element {
   );
 }
 
-function nextSessionPosition(index: number, homeGridSize: HomeGridSize): Point {
-  const homeSize = homeGridPixelSize(homeGridSize);
-  return {
-    x: homeSize.width + 160 + (index % 2) * 760,
-    y: Math.floor(index / 2) * 500 + 20
-  };
-}
-
 function centeredWindowPosition(point: Point, size: { width: number; height: number }): Point {
   return {
     x: point.x - size.width / 2,
diff --git a/src/renderer/src/features/workspace/sessionPlacement.ts b/src/renderer/src/features/workspace/sessionPlacement.ts
new file mode 100644
index 00000000..5ad6250e
--- /dev/null
+++ b/src/renderer/src/features/workspace/sessionPlacement.ts
@@ -0,0 +1,169 @@
+import type { Point, SessionBounds, Size } from "../../../../shared/contracts";
+
+export interface SessionPlacementOptions {
+  /** Gap between placed cards. Defaults to 24px. */
+  gap?: number;
+  /** Margin separating placed cards from Home bounds. Defaults to 40px. */
+  margin?: number;
+  /** Maximum number of candidate positions to test before fallback. Defaults to 2000. */
+  maxCandidates?: number;
+}
+
+export const DEFAULT_SESSION_SIZE: Size = { width: 700, height: 430 };
+export const DEFAULT_SESSION_GAP = 24;
+export const DEFAULT_SESSION_MARGIN = 40;
+
+/**
+ * Checks whether two bounds intersect, treating touch/overlap within gap as intersection.
+ */
+export function boundsOverlapOrTouch(
+  a: SessionBounds,
+  b: SessionBounds,
+  minGap = 0
+): boolean {
+  return (
+    a.position.x < b.position.x + b.size.width + minGap &&
+    a.position.x + a.size.width + minGap > b.position.x &&
+    a.position.y < b.position.y + b.size.height + minGap &&
+    a.position.y + a.size.height + minGap > b.position.y
+  );
+}
+
+/**
+ * Calculates Euclidean distance between the center of candidate bounds and the center of Home.
+ */
+function distanceToHomeCenter(
+  bounds: SessionBounds,
+  homeCenter: Point
+): number {
+  const cx = bounds.position.x + bounds.size.width / 2;
+  const cy = bounds.position.y + bounds.size.height / 2;
+  return Math.hypot(cx - homeCenter.x, cy - homeCenter.y);
+}
+
+/**
+ * Generates an ordered sequence of discrete grid candidate positions near Home.
+ *
+ * Design:
+ * - Starts at the primary anchor to the right (East) of Home, aligned with Home's top.
+ *   X_base = home.x + home.width + margin
+ *   Y_base = home.y
+ * - Grid steps are (cardWidth + gap, cardHeight + gap).
+ * - Searches in every direction around Home after the preferred first position.
+ *   This keeps a large collection compact instead of growing endlessly down or right.
+ * - Candidates are sorted deterministically by distance from Home's visual center,
+ *   with row-major / col-major tie-breaking.
+ * - Any freed positions (gaps created by closing/moving a card) are visited early in the sequence and reused.
+ * - No candidate intersects Home or any occupied bounds.
+ */
+export function generateCandidatePositions(
+  homeBounds: SessionBounds,
+  size: Size,
+  options: SessionPlacementOptions = {}
+): Point[] {
+  const gap = options.gap ?? DEFAULT_SESSION_GAP;
+  const margin = options.margin ?? DEFAULT_SESSION_MARGIN;
+  const maxCandidates = options.maxCandidates ?? 2000;
+
+  const stepX = size.width + gap;
+  const stepY = size.height + gap;
+
+  // Primary anchor: East of Home
+  const baseX = homeBounds.position.x + homeBounds.size.width + margin;
+  const baseY = homeBounds.position.y;
+
+  const homeCenter: Point = {
+    x: homeBounds.position.x + homeBounds.size.width / 2,
+    y: homeBounds.position.y + homeBounds.size.height / 2
+  };
+
+  interface CandidateEntry {
+    point: Point;
+    dist: number;
+    col: number;
+    row: number;
+  }
+
+  const entries: CandidateEntry[] = [];
+
+  // The first slot stays immediately east of Home. After that, search the
+  // surrounding lattice; filtering below excludes cells overlapping Home.
+  const maxExtent = Math.max(6, Math.ceil(Math.sqrt(maxCandidates) / 2) + 4);
+  for (let col = -maxExtent; col <= maxExtent; col += 1) {
+    for (let row = -maxExtent; row <= maxExtent; row += 1) {
+      if (col === 0 && row === 0) continue;
+      const point: Point = {
+        x: baseX + col * stepX,
+        y: baseY + row * stepY
+      };
+      const bounds: SessionBounds = { position: point, size };
+      const dist = distanceToHomeCenter(bounds, homeCenter);
+      entries.push({ point, dist, col, row });
+    }
+  }
+
+  entries.sort((a, b) => {
+    if (Math.abs(a.dist - b.dist) > 0.001) {
+      return a.dist - b.dist;
+    }
+    if (a.row !== b.row) {
+      return a.row - b.row;
+    }
+    return a.col - b.col;
+  });
+
+  return [{ x: baseX, y: baseY }, ...entries.slice(0, maxCandidates - 1).map((e) => e.point)];
+}
+
+/**
+ * Finds a deterministic, non-overlapping free position for a new terminal session near Home.
+ *
+ * @param homeBounds Bounding box of Home.
+ * @param occupied Array of occupied card/session bounds currently on canvas.
+ * @param size Size of the card to place (defaults to 700x430).
+ * @param options Placement configuration (gap, margin).
+ * @returns The chosen Point (x, y) for the new session.
+ */
+export function findNearHomeSessionPosition(
+  homeBounds: SessionBounds,
+  occupied: readonly SessionBounds[],
+  size: Size = DEFAULT_SESSION_SIZE,
+  options: SessionPlacementOptions = {}
+): Point {
+  const gap = options.gap ?? DEFAULT_SESSION_GAP;
+  const candidates = generateCandidatePositions(homeBounds, size, options);
+
+  for (const candidate of candidates) {
+    const candidateBounds: SessionBounds = { position: candidate, size };
+
+    // Must not overlap Home
+    if (boundsOverlapOrTouch(candidateBounds, homeBounds, 0)) {
+      continue;
+    }
+
+    // Must not overlap any occupied bounds
+    let collision = false;
+    for (const card of occupied) {
+      if (boundsOverlapOrTouch(candidateBounds, card, gap)) {
+        collision = true;
+        break;
+      }
+    }
+
+    if (!collision) {
+      return candidate;
+    }
+  }
+
+  // Fallback if all discrete candidates collided (extremely dense/large canvas):
+  // Place safely to the right of all known occupied bounds and Home.
+  let maxRight = homeBounds.position.x + homeBounds.size.width;
+  for (const card of occupied) {
+    maxRight = Math.max(maxRight, card.position.x + card.size.width);
+  }
+
+  return {
+    x: maxRight + (options.margin ?? DEFAULT_SESSION_MARGIN),
+    y: homeBounds.position.y
+  };
+}
diff --git a/tests/session-placement.test.mjs b/tests/session-placement.test.mjs
new file mode 100644
index 00000000..949872bc
--- /dev/null
+++ b/tests/session-placement.test.mjs
@@ -0,0 +1,168 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  boundsOverlapOrTouch,
+  DEFAULT_SESSION_GAP,
+  DEFAULT_SESSION_MARGIN,
+  DEFAULT_SESSION_SIZE,
+  findNearHomeSessionPosition,
+  generateCandidatePositions
+} from "../src/renderer/src/features/workspace/sessionPlacement.ts";
+
+const HOME_BOUNDS = {
+  position: { x: 0, y: 0 },
+  size: { width: 1000, height: 700 }
+};
+
+const CARD_SIZE = { width: 700, height: 430 };
+
+test("finds initial position to the right of Home with margin", () => {
+  const pos = findNearHomeSessionPosition(HOME_BOUNDS, [], CARD_SIZE);
+  assert.equal(pos.x, HOME_BOUNDS.position.x + HOME_BOUNDS.size.width + DEFAULT_SESSION_MARGIN);
+  assert.equal(pos.y, HOME_BOUNDS.position.y);
+});
+
+test("is deterministic: same inputs always yield identical position", () => {
+  const occupied = [
+    { position: { x: 1040, y: 0 }, size: CARD_SIZE }
+  ];
+  const pos1 = findNearHomeSessionPosition(HOME_BOUNDS, occupied, CARD_SIZE);
+  const pos2 = findNearHomeSessionPosition(HOME_BOUNDS, occupied, CARD_SIZE);
+  assert.deepEqual(pos1, pos2);
+});
+
+test("does not intersect Home or occupied bounds", () => {
+  const occupied = [];
+  for (let i = 0; i < 10; i++) {
+    const nextPos = findNearHomeSessionPosition(HOME_BOUNDS, occupied, CARD_SIZE);
+    const candidateBounds = { position: nextPos, size: CARD_SIZE };
+
+    // Check no overlap with Home
+    assert.equal(
+      boundsOverlapOrTouch(candidateBounds, HOME_BOUNDS, 0),
+      false,
+      `Card ${i} overlaps with Home`
+    );
+
+    // Check no overlap with existing occupied cards
+    for (let j = 0; j < occupied.length; j++) {
+      assert.equal(
+        boundsOverlapOrTouch(candidateBounds, occupied[j], DEFAULT_SESSION_GAP),
+        false,
+        `Card ${i} overlaps with card ${j}`
+      );
+    }
+
+    occupied.push(candidateBounds);
+  }
+});
+
+test("reuses freed positions when cards are closed or moved", () => {
+  const cards = [];
+  for (let i = 0; i < 5; i++) {
+    const pos = findNearHomeSessionPosition(HOME_BOUNDS, cards, CARD_SIZE);
+    cards.push({ position: pos, size: CARD_SIZE });
+  }
+
+  // Remove the second card (index 1), leaving a hole
+  const freedCard = cards[1];
+  const occupiedWithHole = [cards[0], cards[2], cards[3], cards[4]];
+
+  // The next placement should fill the freed hole
+  const reusedPos = findNearHomeSessionPosition(HOME_BOUNDS, occupiedWithHole, CARD_SIZE);
+  assert.deepEqual(reusedPos, freedCard.position);
+});
+
+test("allocates 40+ cards in compact 2D growth rather than a strip endlessly downward", () => {
+  const occupied = [];
+  const cardCount = 45;
+
+  for (let i = 0; i < cardCount; i++) {
+    const pos = findNearHomeSessionPosition(HOME_BOUNDS, occupied, CARD_SIZE);
+    occupied.push({ position: pos, size: CARD_SIZE });
+  }
+
+  assert.equal(occupied.length, cardCount);
+
+  // Compute bounding box of all placed cards
+  let minX = Infinity;
+  let maxX = -Infinity;
+  let minY = Infinity;
+  let maxY = -Infinity;
+
+  const uniqueX = new Set();
+  const uniqueY = new Set();
+
+  for (const card of occupied) {
+    minX = Math.min(minX, card.position.x);
+    maxX = Math.max(maxX, card.position.x + card.size.width);
+    minY = Math.min(minY, card.position.y);
+    maxY = Math.max(maxY, card.position.y + card.size.height);
+    uniqueX.add(card.position.x);
+    uniqueY.add(card.position.y);
+  }
+
+  const clusterWidth = maxX - minX;
+  const clusterHeight = maxY - minY;
+  const aspectRatio = clusterWidth / clusterHeight;
+
+  // With a 1D downward strip (e.g. 2 columns), 45 cards would be ~23 rows tall:
+  // clusterWidth ~ 1400, clusterHeight ~ 10,000, aspectRatio ~ 0.14!
+  // For compact 2D growth:
+  // There should be multiple columns (at least 4) and multiple rows (at least 4).
+  assert.ok(
+    uniqueX.size >= 4,
+    `Expected at least 4 columns for compact 2D growth, got ${uniqueX.size}`
+  );
+  assert.ok(
+    uniqueY.size >= 4,
+    `Expected at least 4 rows for compact 2D growth, got ${uniqueY.size}`
+  );
+
+  // Aspect ratio should be well-proportioned (e.g. between 0.6 and 2.5), not an endless strip (<0.2)
+  assert.ok(
+    aspectRatio >= 0.5 && aspectRatio <= 3.0,
+    `Expected 2D aspect ratio between 0.5 and 3.0, got ${aspectRatio.toFixed(2)}`
+  );
+  assert.ok(maxY < 3000 && minY > -3000, `45 cards drifted too far vertically: ${minY}..${maxY}`);
+});
+
+test("respects different Home sizes without pushing the first card far away", () => {
+  for (const size of [{ width: 650, height: 520 }, { width: 1400, height: 900 }]) {
+    const home = { position: { x: -200, y: 100 }, size };
+    const position = findNearHomeSessionPosition(home, []);
+    assert.deepEqual(position, { x: home.position.x + size.width + DEFAULT_SESSION_MARGIN, y: home.position.y });
+    assert.equal(boundsOverlapOrTouch({ position, size: DEFAULT_SESSION_SIZE }, home), false);
+  }
+});
+
+test("handles custom size, gap, and margin options", () => {
+  const customSize = { width: 500, height: 300 };
+  const customGap = 15;
+  const customMargin = 50;
+
+  const pos = findNearHomeSessionPosition(HOME_BOUNDS, [], customSize, {
+    gap: customGap,
+    margin: customMargin
+  });
+
+  assert.equal(pos.x, HOME_BOUNDS.position.x + HOME_BOUNDS.size.width + customMargin);
+  assert.equal(pos.y, HOME_BOUNDS.position.y);
+});
+
+test("is bounded and robust with arbitrary occupied cards", () => {
+  // Random or arbitrary scattered existing cards
+  const existingCards = [
+    { position: { x: 1040, y: 0 }, size: { width: 800, height: 500 } },
+    { position: { x: 1900, y: 100 }, size: { width: 700, height: 400 } },
+    { position: { x: 1100, y: 600 }, size: { width: 600, height: 300 } }
+  ];
+
+  const pos = findNearHomeSessionPosition(HOME_BOUNDS, existingCards, CARD_SIZE);
+  const bounds = { position: pos, size: CARD_SIZE };
+
+  assert.equal(boundsOverlapOrTouch(bounds, HOME_BOUNDS, 0), false);
+  for (const card of existingCards) {
+    assert.equal(boundsOverlapOrTouch(bounds, card, DEFAULT_SESSION_GAP), false);
+  }
+});

From 9e4038f06835a18b275291f1159cb29eb4473277 Mon Sep 17 00:00:00 2001
From: SaneSanders <129727118+SaneSanders@users.noreply.github.com>
Date: Thu, 24 Sep 2026 22:31:46 +0300
Subject: [PATCH 05/10] fix(canvas): stop the layer-order render loop during
 region drag

---
 src/renderer/src/features/workspace/canvasStacking.ts | 4 ++--
 tests/canvas-stacking.test.mjs                        | 6 ++++++
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/src/renderer/src/features/workspace/canvasStacking.ts b/src/renderer/src/features/workspace/canvasStacking.ts
index bf9415c6..4a8ee179 100644
--- a/src/renderer/src/features/workspace/canvasStacking.ts
+++ b/src/renderer/src/features/workspace/canvasStacking.ts
@@ -1,7 +1,7 @@
 import type { CameraState, SessionBounds } from "../../../../shared/contracts";
 
 export function reconcileCanvasLayerOrder(
-  current: readonly string[],
+  current: string[],
   active: readonly string[]
 ): string[] {
   const activeSet = new Set(active);
@@ -9,7 +9,7 @@ export function reconcileCanvasLayerOrder(
   for (const id of active) {
     if (!next.includes(id)) next.push(id);
   }
-  return next;
+  return next.length === current.length && next.every((id, index) => id === current[index]) ? current : next;
 }
 
 export function bringCanvasLayerToFront(current: readonly string[], id: string): string[] {
diff --git a/tests/canvas-stacking.test.mjs b/tests/canvas-stacking.test.mjs
index 804ded57..2329bc0a 100644
--- a/tests/canvas-stacking.test.mjs
+++ b/tests/canvas-stacking.test.mjs
@@ -32,6 +32,12 @@ test("layer reconciliation keeps user order and appends only new live windows",
   );
 });
 
+test("an unchanged layer order reconciles to the same array", () => {
+  const order = ["browser", "terminal:a", "note:n"];
+  assert.equal(reconcileCanvasLayerOrder(order, ["note:n", "terminal:a", "browser"]), order);
+  assert.notEqual(reconcileCanvasLayerOrder(order, ["terminal:a", "browser"]), order);
+});
+
 test("the native Browser surface is hidden only under a higher overlapping layer", () => {
   const map = new Map([
     ["browser", bounds(0, 0)],

From c66a7055ce47b285c846baeb911d98da446041d2 Mon Sep 17 00:00:00 2001
From: tab11pm <tabrezshonizorov@gmail.com>
Date: Fri, 25 Sep 2026 21:38:27 +0700
Subject: [PATCH 06/10] feat(terminal): add fullscreen mode for terminal
 sessions

Implement CSS-only fullscreen overlay that expands a terminal session
to fill the entire viewport without persisting bounds to the backend.

Key design decisions:
- Fullscreen layer rendered outside the canvas camera transform to avoid
  coordinate-system conflicts with pan/zoom
- No IPC bounds changes: crash-safe, original layout preserved on restart
- Single-session constraint: entering fullscreen for another session
  auto-exits the current one
- Escape key exits fullscreen (bubble phase to avoid stealing from modals)
- Exit button in top-right corner and restore button in header

Includes i18n strings (en/ru) and feature documentation.
---
 docs/fullscreen-mode.md                       |  44 ++
 package-lock.json                             | 523 ------------------
 src/renderer/src/App.tsx                      |  18 +
 .../src/features/terminal/TerminalCard.tsx    |  40 +-
 .../features/workspace/WorkspaceCanvas.tsx    |  51 +-
 src/renderer/src/lib/i18n.ts                  |   4 +
 src/renderer/src/styles/app.css               |  26 +
 7 files changed, 180 insertions(+), 526 deletions(-)
 create mode 100644 docs/fullscreen-mode.md

diff --git a/docs/fullscreen-mode.md b/docs/fullscreen-mode.md
new file mode 100644
index 00000000..32b52d58
--- /dev/null
+++ b/docs/fullscreen-mode.md
@@ -0,0 +1,44 @@
+# Fullscreen Mode for Terminal Sessions
+
+CanvasTTY supports fullscreen mode for terminal sessions, allowing you to expand any session to fill the entire viewport for focused work.
+
+## How to Use
+
+### Enter Fullscreen
+
+- **Header button:** Click the maximize icon (⛶) in the terminal card header.
+- **Keyboard:** Not yet supported via shortcut (coming soon).
+
+### Exit Fullscreen
+
+- **Close button:** Click the X button in the top-right corner of the fullscreen session.
+- **Header button:** Click the restore icon (❐) in the terminal card header.
+- **Keyboard:** Press `Escape`.
+
+## Behavior
+
+- **Camera preserved:** When you exit fullscreen, the canvas camera (pan/zoom) stays where you left it. If you navigated during fullscreen, the camera won't snap back.
+- **Single session only:** Only one session can be fullscreen at a time. Opening fullscreen for another session automatically closes the previous one.
+- **No bounds persistence:** Fullscreen mode is CSS-only — it does not modify the session's saved position or size. If the app crashes during fullscreen, the session restores at its original layout on restart.
+- **Header hidden:** The terminal card header and resize handles are hidden in fullscreen, maximizing the terminal surface area.
+
+## Architecture
+
+Fullscreen is implemented as a **CSS overlay layer** separate from the canvas camera transform:
+
+1. `App.tsx` tracks `fullscreenSessionId` state and passes it down to `WorkspaceCanvas`.
+2. `WorkspaceCanvas` splits rendering into two groups:
+   - **Normal layer** (`workspace__windows`): all sessions *except* the fullscreen one.
+   - **Fullscreen layer** (`workspace__fullscreen-layer`): only the fullscreen session, rendered outside the camera transform with `position: absolute; inset: 0`.
+3. `TerminalCard` receives a `fullscreen` prop and applies the `terminal-card--fullscreen` CSS class, which overrides dimensions, removes borders/shadows, and hides the header.
+
+This design avoids coordinate-system conflicts between the canvas pan/zoom transform and the fullscreen overlay.
+
+## Internationalization
+
+Fullscreen UI strings are localized in `src/renderer/src/lib/i18n.ts`:
+
+| Key              | English              | Russian                       |
+|------------------|----------------------|-------------------------------|
+| `enterFullscreen`| Enter fullscreen     | Развернуть на весь экран     |
+| `exitFullscreen` | Exit fullscreen      | Свернуть из полноэкранного   |
\ No newline at end of file
diff --git a/package-lock.json b/package-lock.json
index 5dcf52db..c28ce21f 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -53,474 +53,6 @@
         "vite": "8.2.2"
       }
     },
-    "integrations/even-g2/node_modules/@esbuild/aix-ppc64": {
-      "version": "0.28.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.28.2.tgz",
-      "integrity": "sha512-XExcO+dvLKvVtNTibSTBej1NCAbaGhWn9Ww1ZPx80qsahhPFe/8jgWP0IchNe0F3HwkU7n8ejhH8bjonqht8mQ==",
-      "cpu": [
-        "ppc64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "aix"
-      ],
-      "peer": true,
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "integrations/even-g2/node_modules/@esbuild/android-arm": {
-      "version": "0.28.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.28.2.tgz",
-      "integrity": "sha512-kXXoiPVVGQcnIYGOeaovwOURpniDBpSq4A03qkQ+BMQqtGG6HYap3xne9C1O1yo4TR3qxlCX5IqqmX6fFo2Lqg==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "peer": true,
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "integrations/even-g2/node_modules/@esbuild/android-arm64": {
-      "version": "0.28.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.28.2.tgz",
-      "integrity": "sha512-5YfKeeI8qWfBZIX+u2xZC3Zlb3Os/gLS2sbEKM+I4ZOcsWmHS2WLysCcQZDAFRslDUU5Oiq44gf6PYN1vGwG5A==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "peer": true,
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "integrations/even-g2/node_modules/@esbuild/android-x64": {
-      "version": "0.28.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.28.2.tgz",
-      "integrity": "sha512-O387ite7SzUyCcy3JQX4P4bLtEA7bLLkx+esve5JHnyYfNTxcVpXZo9jhdB0lTKN44gztELTdU7nS8Nr16Fs1Q==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "peer": true,
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "integrations/even-g2/node_modules/@esbuild/darwin-arm64": {
-      "version": "0.28.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.28.2.tgz",
-      "integrity": "sha512-n4KqkOQrraxHJcgjM1RvwbigfQKIKJVpM7xp+KsxiyUSrRdIXnt73VhrPAx0fV44hgfmIVKjxMN9J1t5jySVkw==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "peer": true,
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "integrations/even-g2/node_modules/@esbuild/darwin-x64": {
-      "version": "0.28.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.28.2.tgz",
-      "integrity": "sha512-uq6suIWYP37qzGddBKPw5QEQPi6HiLGsO7UmkpfyaYNQ3D+rN6w6WfwH+nuqcGXWvawGwxOEroO4YGnFh95azw==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "peer": true,
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "integrations/even-g2/node_modules/@esbuild/freebsd-arm64": {
-      "version": "0.28.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.28.2.tgz",
-      "integrity": "sha512-n+I0BTSRIoy+d6RPKnEVwql5UwBJolytvY4mAOIEJorKlqgPII8ix6slVVrfZ5Tnj7glIZvloylbB/EJPMWEXw==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "freebsd"
-      ],
-      "peer": true,
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "integrations/even-g2/node_modules/@esbuild/freebsd-x64": {
-      "version": "0.28.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.28.2.tgz",
-      "integrity": "sha512-78XJTJkvPs0kz2w61301PJjXl4g7q3JqiYMZ/M/yVI73EHBrCRTgkhu9oqG7vPqq+a/yadEW8aD+agKlk5xrmg==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "freebsd"
-      ],
-      "peer": true,
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "integrations/even-g2/node_modules/@esbuild/linux-arm": {
-      "version": "0.28.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.28.2.tgz",
-      "integrity": "sha512-XlDnu2q5yoqems+xay6wSAcg9DDD7K9RLKZEBOMZm3ckNpJBvOX20tSfby8KfrrhINDyv9V2YVZKY/SpoGJI8w==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "peer": true,
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "integrations/even-g2/node_modules/@esbuild/linux-arm64": {
-      "version": "0.28.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.28.2.tgz",
-      "integrity": "sha512-pW4AC0P3it8c7do9MVM4p51FzHzdM/TZrerurgRcHJ2WTa1VQ1CIq18xncfpBJw4ojkiZZrKW2yIBWBP92j6Ug==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "peer": true,
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "integrations/even-g2/node_modules/@esbuild/linux-ia32": {
-      "version": "0.28.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.28.2.tgz",
-      "integrity": "sha512-CYbnj78HsIeA+DhgUKgFCfvNsTHFhMMrinUrMZpDXJXKN8T3XViTZ/+wtHeVxEWY8ewSzTFN+nRmSwO2tZaLUQ==",
-      "cpu": [
-        "ia32"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "peer": true,
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "integrations/even-g2/node_modules/@esbuild/linux-loong64": {
-      "version": "0.28.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.28.2.tgz",
-      "integrity": "sha512-buwkd8nsph4R+ajRvw0qM5Hja/TXQow3ptzWO2EbG/cqcIkHloRrdlBtQlshyYGTNFvfkfJ5tpPLVkY4DtsPfQ==",
-      "cpu": [
-        "loong64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "peer": true,
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "integrations/even-g2/node_modules/@esbuild/linux-mips64el": {
-      "version": "0.28.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.28.2.tgz",
-      "integrity": "sha512-ZVykbDyk7519VwiNb9Lcj9m8XM6v5V9uKPvrEMkkEedVewf+0itkhahp4HDpgERXhwLRpWFypsGbG/J8s0QjJA==",
-      "cpu": [
-        "mips64el"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "peer": true,
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "integrations/even-g2/node_modules/@esbuild/linux-ppc64": {
-      "version": "0.28.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.28.2.tgz",
-      "integrity": "sha512-CAXl+Dtd9UUuJd8pKKdwh6MLm3MUMiqMPmhZ3tTSXPqfyQ3vDl6R5hZdZ/kYojK4ofXtdfSv1tFq8XzWx3heNQ==",
-      "cpu": [
-        "ppc64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "peer": true,
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "integrations/even-g2/node_modules/@esbuild/linux-riscv64": {
-      "version": "0.28.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.28.2.tgz",
-      "integrity": "sha512-GeXCej4IQtU1B+QlDV8W/RRvbzI3O/Stss+/bCXv4lZls5WGRtu2a+3JkA3i4qIUlMXpcHebWpF8AkJhATowuA==",
-      "cpu": [
-        "riscv64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "peer": true,
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "integrations/even-g2/node_modules/@esbuild/linux-s390x": {
-      "version": "0.28.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.28.2.tgz",
-      "integrity": "sha512-3H1weTYZPxt/WOhByszQZybS9w5lKzUn1FDMsgEChbHWQwHYQQRfBxgCcZvPhjHfKyJjIievvMmEUawJrdY9Dg==",
-      "cpu": [
-        "s390x"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "peer": true,
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "integrations/even-g2/node_modules/@esbuild/linux-x64": {
-      "version": "0.28.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.28.2.tgz",
-      "integrity": "sha512-4xTZr1FUmSoQW4XIWmit3tzQrUTZM+N3P0XV8xROKYF50XfI7xeO90+1bZvNwxIufQ9hDQVRJH5YhgPVF8A/HQ==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "peer": true,
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "integrations/even-g2/node_modules/@esbuild/netbsd-arm64": {
-      "version": "0.28.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.28.2.tgz",
-      "integrity": "sha512-sSATRjPeDBg3pdgHoQfoYBob11Kk1FGa9lui5RIHZCoCkJa9QKlvl3/vKz2usCmYYjs7ymJR/2Nnsqe+Hjt5nw==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "netbsd"
-      ],
-      "peer": true,
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "integrations/even-g2/node_modules/@esbuild/netbsd-x64": {
-      "version": "0.28.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.28.2.tgz",
-      "integrity": "sha512-lqnzCV+mM0gIADaKihiCg6ifgfU2L3h5E33rNQBN1Y4MaVGnzryzmvvf7UHxprpQdE8hpqLolJ9Rl+SkIRDpyw==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "netbsd"
-      ],
-      "peer": true,
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "integrations/even-g2/node_modules/@esbuild/openbsd-arm64": {
-      "version": "0.28.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.28.2.tgz",
-      "integrity": "sha512-AL2qJILH7lNjrDmCQDvdxMfAUIv8KMNZOvrwAQ8i8//ntL9FflhOyMJ8OZSMBb8/AWXe3/5v5S20y3zCoZWKoQ==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "openbsd"
-      ],
-      "peer": true,
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "integrations/even-g2/node_modules/@esbuild/openbsd-x64": {
-      "version": "0.28.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.28.2.tgz",
-      "integrity": "sha512-QtiuPytchRyC4rwUKhexJdQKvDuZ6hWloi3igqPQNUJCS1/v9EiO3UTOXR6A3FoMo4fnAKbWJdqaIwhOzh8qEw==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "openbsd"
-      ],
-      "peer": true,
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "integrations/even-g2/node_modules/@esbuild/openharmony-arm64": {
-      "version": "0.28.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.28.2.tgz",
-      "integrity": "sha512-WkhYDmpTjLvGlScA1rwjRUmhl4k8oXR3cIbtqWmELgU/dFeHHlEllxDvdWcNJV9rbzCexB5vz8gtNewWLgCT7Q==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "openharmony"
-      ],
-      "peer": true,
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "integrations/even-g2/node_modules/@esbuild/sunos-x64": {
-      "version": "0.28.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.28.2.tgz",
-      "integrity": "sha512-GPMSkTOtMnv2U2F8gxe4Io6qmVs+YKyp832Etqqxr0hFngmXQ3rzwytelm3GIn7T4VviRUlf3sOgBOiTdvaf7g==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "sunos"
-      ],
-      "peer": true,
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "integrations/even-g2/node_modules/@esbuild/win32-arm64": {
-      "version": "0.28.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.28.2.tgz",
-      "integrity": "sha512-PIhhEkE9uPBleRBrQEJpUn7MBnibZzbGzYWPmY3x+YoVg/95zbjB4CxPPOQ8l5tYYM4mMaCthF8/1DIfBQQyWQ==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "peer": true,
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "integrations/even-g2/node_modules/@esbuild/win32-ia32": {
-      "version": "0.28.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.28.2.tgz",
-      "integrity": "sha512-YmJbfTlvU7Sdn9BB+4PRES4oB6pxgS37MAONj+hBr/cpXS1aBPKXxNnDbu+QCWPj0o9dgyxeq79g6c5P8KeuYA==",
-      "cpu": [
-        "ia32"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "peer": true,
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "integrations/even-g2/node_modules/@esbuild/win32-x64": {
-      "version": "0.28.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.28.2.tgz",
-      "integrity": "sha512-5ebpxr3nWMzrL/rnUI755Jkuee0bHL/Gq0WTF9lvcpv73wAp5eu8MfBUgWK9bhWvZjj7yX8etf/8tI8Ney695g==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "peer": true,
-      "engines": {
-        "node": ">=18"
-      }
-    },
     "integrations/even-g2/node_modules/@evenrealities/evenhub-cli": {
       "version": "0.1.14",
       "resolved": "https://registry.npmjs.org/@evenrealities/evenhub-cli/-/evenhub-cli-0.1.14.tgz",
@@ -567,50 +99,6 @@
         "node": ">=20"
       }
     },
-    "integrations/even-g2/node_modules/esbuild": {
-      "version": "0.28.2",
-      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.28.2.tgz",
-      "integrity": "sha512-HKVLS8dvII+xoKW9kmqxbRKrnWEXfJJr/FZhhJmiqIB0e053QNYFqOBouTMO/k5sID4MvCiUCvv8b9M4h32wIA==",
-      "dev": true,
-      "hasInstallScript": true,
-      "license": "MIT",
-      "optional": true,
-      "peer": true,
-      "bin": {
-        "esbuild": "bin/esbuild"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "optionalDependencies": {
-        "@esbuild/aix-ppc64": "0.28.2",
-        "@esbuild/android-arm": "0.28.2",
-        "@esbuild/android-arm64": "0.28.2",
-        "@esbuild/android-x64": "0.28.2",
-        "@esbuild/darwin-arm64": "0.28.2",
-        "@esbuild/darwin-x64": "0.28.2",
-        "@esbuild/freebsd-arm64": "0.28.2",
-        "@esbuild/freebsd-x64": "0.28.2",
-        "@esbuild/linux-arm": "0.28.2",
-        "@esbuild/linux-arm64": "0.28.2",
-        "@esbuild/linux-ia32": "0.28.2",
-        "@esbuild/linux-loong64": "0.28.2",
-        "@esbuild/linux-mips64el": "0.28.2",
-        "@esbuild/linux-ppc64": "0.28.2",
-        "@esbuild/linux-riscv64": "0.28.2",
-        "@esbuild/linux-s390x": "0.28.2",
-        "@esbuild/linux-x64": "0.28.2",
-        "@esbuild/netbsd-arm64": "0.28.2",
-        "@esbuild/netbsd-x64": "0.28.2",
-        "@esbuild/openbsd-arm64": "0.28.2",
-        "@esbuild/openbsd-x64": "0.28.2",
-        "@esbuild/openharmony-arm64": "0.28.2",
-        "@esbuild/sunos-x64": "0.28.2",
-        "@esbuild/win32-arm64": "0.28.2",
-        "@esbuild/win32-ia32": "0.28.2",
-        "@esbuild/win32-x64": "0.28.2"
-      }
-    },
     "integrations/even-g2/node_modules/postcss": {
       "version": "8.5.28",
       "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.28.tgz",
@@ -6353,7 +5841,6 @@
       "os": [
         "android"
       ],
-      "peer": true,
       "engines": {
         "node": ">= 12.0.0"
       },
@@ -6375,7 +5862,6 @@
       "os": [
         "darwin"
       ],
-      "peer": true,
       "engines": {
         "node": ">= 12.0.0"
       },
@@ -6397,7 +5883,6 @@
       "os": [
         "darwin"
       ],
-      "peer": true,
       "engines": {
         "node": ">= 12.0.0"
       },
@@ -6419,7 +5904,6 @@
       "os": [
         "freebsd"
       ],
-      "peer": true,
       "engines": {
         "node": ">= 12.0.0"
       },
@@ -6441,7 +5925,6 @@
       "os": [
         "linux"
       ],
-      "peer": true,
       "engines": {
         "node": ">= 12.0.0"
       },
@@ -6463,7 +5946,6 @@
       "os": [
         "linux"
       ],
-      "peer": true,
       "engines": {
         "node": ">= 12.0.0"
       },
@@ -6485,7 +5967,6 @@
       "os": [
         "linux"
       ],
-      "peer": true,
       "engines": {
         "node": ">= 12.0.0"
       },
@@ -6507,7 +5988,6 @@
       "os": [
         "linux"
       ],
-      "peer": true,
       "engines": {
         "node": ">= 12.0.0"
       },
@@ -6529,7 +6009,6 @@
       "os": [
         "linux"
       ],
-      "peer": true,
       "engines": {
         "node": ">= 12.0.0"
       },
@@ -6551,7 +6030,6 @@
       "os": [
         "win32"
       ],
-      "peer": true,
       "engines": {
         "node": ">= 12.0.0"
       },
@@ -6573,7 +6051,6 @@
       "os": [
         "win32"
       ],
-      "peer": true,
       "engines": {
         "node": ">= 12.0.0"
       },
diff --git a/src/renderer/src/App.tsx b/src/renderer/src/App.tsx
index 37589a88..71577a55 100644
--- a/src/renderer/src/App.tsx
+++ b/src/renderer/src/App.tsx
@@ -210,6 +210,7 @@ export function App(): React.JSX.Element {
   const [activeSessionId, setActiveSessionId] = useState<string | null>(null);
   const [browserSelected, setBrowserSelected] = useState(false);
   const [renamingSessionId, setRenamingSessionId] = useState<string | null>(null);
+  const [fullscreenSessionId, setFullscreenSessionId] = useState<string | null>(null);
   const [pendingTerminalUrl, setPendingTerminalUrl] = useState<string | null>(null);
   const [toast, setToast] = useState<string | null>(null);
   const [ready, setReady] = useState(false);
@@ -457,6 +458,21 @@ export function App(): React.JSX.Element {
     window.canvasTTY.terminal.setBounds(id, bounds);
   }, []);
 
+  const toggleSessionFullscreen = useCallback((id: string): void => {
+    if (fullscreenSessionId === id) {
+      // Exit fullscreen: only update state, no bounds persistence
+      // Note: Camera position is preserved intentionally (BUG 3 mitigation).
+      // If the user panned/zoomed during fullscreen, the camera stays where they left it.
+      setFullscreenSessionId(null);
+    } else {
+      // Enter fullscreen: exit current fullscreen first if switching sessions (BUG 2)
+      if (fullscreenSessionId !== null) {
+        setFullscreenSessionId(null);
+      }
+      setFullscreenSessionId(id);
+    }
+  }, [fullscreenSessionId]);
+
   const changePluginCanvasBounds = useCallback((id: string, bounds: SessionBounds): void => {
     const pluginCanvas = settingsRef.current.pluginCanvas.map((instance) => instance.id === id
       ? { ...instance, position: bounds.position, size: bounds.size }
@@ -1074,6 +1090,8 @@ export function App(): React.JSX.Element {
           activeSessionId={activeSessionId}
           browserSelected={browserSelected}
           renamingSessionId={renamingSessionId}
+          fullscreenSessionId={fullscreenSessionId}
+          onToggleFullscreen={toggleSessionFullscreen}
           onSelectSession={(id) => {
             setBrowserSelected(false);
             setActiveSessionId(id);
diff --git a/src/renderer/src/features/terminal/TerminalCard.tsx b/src/renderer/src/features/terminal/TerminalCard.tsx
index 0a3a0081..ecd62185 100644
--- a/src/renderer/src/features/terminal/TerminalCard.tsx
+++ b/src/renderer/src/features/terminal/TerminalCard.tsx
@@ -58,7 +58,9 @@ interface TerminalCardProps {
   /** Multi-select group member: gets the selected outline without focus/WebGL side effects. */
   groupSelected?: boolean;
   renaming: boolean;
+  fullscreen: boolean;
   snapTargets: readonly SessionBounds[];
+  onToggleFullscreen(): void;
   onActivate(session: SessionSnapshot): void;
   onSelect(id: string): void;
   onRename(id: string, title: string): Promise<void>;
@@ -111,7 +113,9 @@ export function TerminalCard({
   selected,
   groupSelected,
   renaming,
+  fullscreen,
   snapTargets,
+  onToggleFullscreen,
   onActivate,
   onSelect,
   onRename,
@@ -432,6 +436,20 @@ export function TerminalCard({
     if (summaryMode) closeSearch();
   }, [summaryMode]);
 
+  // Exit fullscreen mode on Escape key
+  useEffect(() => {
+    if (!fullscreen) return;
+    const handleEscape = (event: KeyboardEvent): void => {
+      if (event.key === "Escape") {
+        event.preventDefault();
+        event.stopPropagation();
+        onToggleFullscreen();
+      }
+    };
+    window.addEventListener("keydown", handleEscape, false);
+    return () => window.removeEventListener("keydown", handleEscape, false);
+  }, [fullscreen, onToggleFullscreen]);
+
   const bindRenameInput = useCallback((input: HTMLInputElement | null): void => {
     renameInput.current = input;
     if (!input) return;
@@ -621,7 +639,7 @@ export function TerminalCard({
   const searchCount = `${searchMatches.current}/${searchMatches.total}`;
   return (
     <article
-      className={`terminal-card terminal-card--${session.provider} ${summaryMode ? "terminal-card--summary" : ""} ${selected || groupSelected ? "terminal-card--selected" : ""} ${session.status === "needs_approval" || session.status === "failed" ? "terminal-card--attention" : ""}`}
+      className={`terminal-card terminal-card--${session.provider} ${summaryMode ? "terminal-card--summary" : ""} ${selected || groupSelected ? "terminal-card--selected" : ""} ${session.status === "needs_approval" || session.status === "failed" ? "terminal-card--attention" : ""} ${fullscreen ? "terminal-card--fullscreen" : ""}`}
       data-interactive="true"
       data-canvas-layer-id={`terminal:${session.id}`}
       data-canvas-widget-id={terminalCanvasWidgetId(session.id)}
@@ -677,6 +695,17 @@ export function TerminalCard({
         "--terminal-background": terminalBackground
       } as React.CSSProperties}
     >
+      {fullscreen && (
+        <button
+          className="terminal-card__exit-fullscreen"
+          type="button"
+          onClick={(event) => { event.stopPropagation(); onToggleFullscreen(); }}
+          title={t(locale, "exitFullscreen")}
+          aria-label={t(locale, "exitFullscreen")}
+        >
+          <UiIcon name="close" size="1.2em" />
+        </button>
+      )}
       <header
         className="terminal-card__header"
         onPointerDown={startDrag}
@@ -741,6 +770,15 @@ export function TerminalCard({
               <UiIcon name={restarting ? "working" : "reload"} size="1.23em" />
             </button>
           )}
+          <button
+            className="terminal-card__action terminal-card__action--fullscreen"
+            type="button"
+            onClick={(event) => { event.stopPropagation(); onToggleFullscreen(); }}
+            title={fullscreen ? t(locale, "exitFullscreen") : t(locale, "enterFullscreen")}
+            aria-label={fullscreen ? t(locale, "exitFullscreen") : t(locale, "enterFullscreen")}
+          >
+            <UiIcon name={fullscreen ? "restore" : "maximize"} size="1.23em" />
+          </button>
           <button className="terminal-card__action terminal-card__action--close" type="button" onClick={() => onDispose(session.id)} title={t(locale, "close")} aria-label={t(locale, "close")}><UiIcon name="close" size="1.23em" /></button>
         </div>
       </header>
diff --git a/src/renderer/src/features/workspace/WorkspaceCanvas.tsx b/src/renderer/src/features/workspace/WorkspaceCanvas.tsx
index 70237eb8..7df95aa6 100644
--- a/src/renderer/src/features/workspace/WorkspaceCanvas.tsx
+++ b/src/renderer/src/features/workspace/WorkspaceCanvas.tsx
@@ -160,6 +160,8 @@ interface WorkspaceCanvasProps {
   activeSessionId: string | null;
   browserSelected: boolean;
   renamingSessionId: string | null;
+  fullscreenSessionId: string | null;
+  onToggleFullscreen(id: string): void;
   onSelectSession(id: string): void;
   onSelectBrowser(): void;
   onClearCanvasSelection(): void;
@@ -196,7 +198,7 @@ export function WorkspaceCanvas(props: WorkspaceCanvasProps): React.JSX.Element
     settings, mediaData, sessions, limits, limitsLoadState, plugins, browser,
     browserViewVisible, homeEditing, camera, onCameraChange, onGoHome,
     onOpenSettings, onOpenAgent, onOpenTerminal, onOpenBrowser, onOpenTerminalUrl, onFocusSession,
-    activeSessionId, browserSelected, renamingSessionId, onSelectSession,
+    activeSessionId, browserSelected, renamingSessionId, fullscreenSessionId, onToggleFullscreen, onSelectSession,
     onSelectBrowser, onClearCanvasSelection, onRenameSession, onRenameEnd,
     onRequestMedia, onRemoveMedia, onHomeLayoutChange, onHomeGridSizeChange,
     onFinishHomeEdit, onResetHomeLayout, onPluginError, onPluginCanvasBoundsChange,
@@ -822,7 +824,7 @@ export function WorkspaceCanvas(props: WorkspaceCanvasProps): React.JSX.Element
           onPluginCanvasWheel={wheelNavigation.applyCanvasWheel}
         />
         <div className={`workspace__windows ${homeEditing ? "workspace__windows--hidden" : ""}`} aria-hidden={homeEditing}>
-          {renderedSessions.map((session) => (
+          {renderedSessions.filter((session) => fullscreenSessionId !== session.id).map((session) => (
             <TerminalCard
               key={session.id}
               session={withGroupNudge(terminalLayerId(session.id), session)}
@@ -839,6 +841,8 @@ export function WorkspaceCanvas(props: WorkspaceCanvasProps): React.JSX.Element
               selected={activeSessionId === session.id}
               groupSelected={marqueeSelection.has(terminalLayerId(session.id))}
               renaming={renamingSessionId === session.id}
+              fullscreen={fullscreenSessionId === session.id}
+              onToggleFullscreen={() => onToggleFullscreen(session.id)}
               snapTargets={[
                 homeBounds,
                 ...renderedCanvasRegions.map((candidate) => ({ position: candidate.position, size: candidate.size })),
@@ -974,6 +978,49 @@ export function WorkspaceCanvas(props: WorkspaceCanvasProps): React.JSX.Element
         </div>
       </div>
 
+      {/* Fullscreen layer: rendered outside workspace__scene to avoid camera transformation */}
+      <div className="workspace__fullscreen-layer">
+        {renderedSessions
+          .filter((session) => fullscreenSessionId === session.id)
+          .map((session) => (
+            <TerminalCard
+              key={session.id}
+              session={withGroupNudge(terminalLayerId(session.id), session)}
+              locale={settings.locale}
+              palette={settings.palette}
+              zoom={1}
+              stackIndex={9999}
+              snapEnabled={false}
+              focusActivation={settings.focusActivation}
+              invertTerminalWheel={settings.invertTerminalWheel}
+              captureCanvasWheelOverWidgets={false}
+              focused={widgetFocus.id === terminalCanvasWidgetId(session.id)}
+              focusChangeSource={widgetFocus.source}
+              selected={activeSessionId === session.id}
+              groupSelected={false}
+              renaming={renamingSessionId === session.id}
+              fullscreen={true}
+              onToggleFullscreen={() => onToggleFullscreen(session.id)}
+              snapTargets={[]}
+              onActivate={(selectedSession) => {
+                focusController.focus(terminalCanvasWidgetId(selectedSession.id), "explicit");
+                onFocusSession(selectedSession);
+              }}
+              onSelect={(id) => {
+                focusController.cancelHover();
+                focusController.focus(terminalCanvasWidgetId(id), "explicit");
+                onSelectSession(id);
+              }}
+              onRename={onRenameSession}
+              onRenameEnd={onRenameEnd}
+              onBoundsChange={() => {}}
+              onRestart={onRestartSession}
+              onDispose={onDisposeSession}
+              onOpenUrl={onOpenTerminalUrl}
+            />
+          ))}
+      </div>
+
       {pointerNavigation.marquee && (
         <div
           className="canvas-marquee"
diff --git a/src/renderer/src/lib/i18n.ts b/src/renderer/src/lib/i18n.ts
index 0495f7be..d244e1be 100644
--- a/src/renderer/src/lib/i18n.ts
+++ b/src/renderer/src/lib/i18n.ts
@@ -435,6 +435,8 @@ const ru = {
   close: "Закрыть",
   focus: "Фокус",
   expand: "Развернуть",
+  enterFullscreen: "Развернуть на весь экран",
+  exitFullscreen: "Свернуть из полноэкранного режима",
   sessionStarted: "Сессия создана",
   terminalStarted: "Терминал создан",
   launchFailed: "Не удалось запустить сессию",
@@ -1039,6 +1041,8 @@ const en: Record<keyof typeof ru, string> = {
   close: "Close",
   focus: "Focus",
   expand: "Expand",
+  enterFullscreen: "Enter fullscreen",
+  exitFullscreen: "Exit fullscreen",
   sessionStarted: "Session created",
   terminalStarted: "Terminal created",
   launchFailed: "Could not launch session",
diff --git a/src/renderer/src/styles/app.css b/src/renderer/src/styles/app.css
index 2407e41a..b79be05d 100644
--- a/src/renderer/src/styles/app.css
+++ b/src/renderer/src/styles/app.css
@@ -63,6 +63,8 @@ button { border: 0; }
 .workspace__regions { position: absolute; left: 0; top: 0; }
 .workspace__windows { position: absolute; left: 0; top: 0; }
 .workspace__windows--hidden { visibility: hidden; pointer-events: none; }
+.workspace__fullscreen-layer { position: absolute; inset: 0; z-index: 9999; pointer-events: none; }
+.workspace__fullscreen-layer .terminal-card--fullscreen { pointer-events: auto; }
 
 .radial-launcher {
   position: absolute;
@@ -396,6 +398,30 @@ button { border: 0; }
 .terminal-card__summary span { color: rgba(255,255,255,.58); font-size: 21px; font-weight: 750; line-height: 1; }
 .terminal-card--summary .terminal-card__surface { visibility: hidden; }
 .terminal-card--summary .terminal-card__summary { display: flex; }
+/* Fullscreen mode: full viewport overlay */
+.terminal-card--fullscreen {
+  position: absolute !important;
+  inset: 0 !important;
+  width: 100% !important;
+  height: 100% !important;
+  left: 0 !important;
+  top: 0 !important;
+  z-index: 9999 !important;
+  border-radius: 0 !important;
+  border: none !important;
+  max-width: none !important;
+  max-height: none !important;
+  transform: none !important;
+  box-shadow: none !important;
+}
+.terminal-card--fullscreen .terminal-card__header { display: none; }
+.terminal-card--fullscreen .terminal-card__surface { height: 100%; }
+.terminal-card--fullscreen .terminal-card__resize-handle { display: none; }
+
+/* Exit fullscreen button */
+.terminal-card__exit-fullscreen { position: fixed; top: calc(var(--titlebar-height) + 16px); right: 16px; z-index: 10000; width: 36px; height: 36px; display: grid; place-items: center; border-radius: 8px; color: rgba(255,255,255,.8); background: rgba(0,0,0,.6); cursor: pointer; font-size: 16px; opacity: 1; transition: opacity .2s ease, background .2s ease; border: none; }
+.terminal-card__exit-fullscreen:hover { color: white; background: rgba(0,0,0,.8); }
+.terminal-card:not(.terminal-card--fullscreen) .terminal-card__exit-fullscreen { display: none; }
 .terminal-card__resize-handle { position: absolute; z-index: 20; touch-action: none; }
 .terminal-card__resize-handle--n { top: 0; left: 10px; right: 10px; height: 8px; cursor: ns-resize; }
 .terminal-card__resize-handle--e { top: 10px; right: 0; bottom: 10px; width: 8px; cursor: ew-resize; }

From a55b5da1c82e25f270f547556cca39192778cbb8 Mon Sep 17 00:00:00 2001
From: BIackFIame <77388790+BIackFIame@users.noreply.github.com>
Date: Wed, 23 Sep 2026 19:41:52 +0300
Subject: [PATCH 07/10] fix: close open issues and fold in safe fixes from open
 PRs

Final part of the stack. It resolves what no other pull request resolves and
adopts the fixes from stalled pull requests that do not fall under a
maintainer exclusion.

- Issue #53: the HOME clock shows the localized date under the time.
- Issue #22: the plugin showcase and search work anonymously, following the
  issue's preferred baseline. GitHub sign-in is explained as optional before
  it starts. A rate-limit error names when to retry. The release workflow
  warns when no OAuth client ID is configured.
- From #51: hook stdin is read up to 512 KiB, so a long final answer keeps
  its turn id and bounded text.
- From #35: the default session denies web permissions, a crashed renderer
  reloads in place, lost child processes are logged, and the secret audit
  also scans the built bundle and Windows home paths.
- An Unreleased changelog section describes the whole stack in EN/RU/ZH.

Co-authored-by: SHEM <arxipov-pavel@mail.ru>
Co-authored-by: s079891 <mail@4544.ru>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

(cherry picked from commit 3b3674ae2f554c448c78e170fb2ffb55a23aa5d6)
---
 .github/workflows/release.yml                 |  3 ++
 CHANGELOG.md                                  |  4 +++
 CHANGELOG.ru.md                               |  4 +++
 CHANGELOG.zh-CN.md                            |  4 +++
 docs/plugins.md                               |  2 +-
 docs/plugins.ru.md                            |  2 +-
 docs/plugins.zh-CN.md                         |  2 +-
 src/agent-runtime/hook-helper.mjs             |  2 +-
 src/main/index.ts                             |  8 ++---
 src/main/services/PluginManager.ts            | 17 ++++++----
 src/renderer/src/features/home/HomeZone.tsx   |  4 ++-
 .../plugins/PluginSettingsSection.tsx         | 10 +++---
 src/renderer/src/lib/i18n.ts                  |  4 +--
 src/renderer/src/styles/app.css               | 23 ++++---------
 tests/agent-runtime-gateway.test.mjs          | 32 +++++++++++++++++++
 tests/app-hardening.test.mjs                  | 20 ++++++++++++
 tests/plugin-manager.test.mjs                 |  9 ++++++
 17 files changed, 109 insertions(+), 41 deletions(-)
 create mode 100644 tests/app-hardening.test.mjs

diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index a6529d72..82a4bf25 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -32,6 +32,9 @@ jobs:
             artifact: canvastty-macos
     runs-on: ${{ matrix.runner }}
     steps:
+      - name: Note plugin showcase sign-in availability
+        if: ${{ vars.CANVASTTY_GITHUB_CLIENT_ID == '' }}
+        run: echo "::warning::CANVASTTY_GITHUB_CLIENT_ID is not set. The plugin showcase still works anonymously; GitHub sign-in is unavailable in this build."
       - name: Check out repository
         uses: actions/checkout@v7
       - name: Set up Node.js
diff --git a/CHANGELOG.md b/CHANGELOG.md
index a9d987df..078880c1 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -23,6 +23,10 @@
 - Limited WebGL to the focused terminal card: one context at a time, disposed when focus leaves, with a fallback to the DOM renderer when the context is lost. Palette and transparency rendering are unchanged.
 - Added a self-update section in Settings → Updates with the honest states: idle, checking, update available with the version, downloading with the percent when known, ready to install, and unavailable for dev, offline, or error. Downloading and installing are explicit user actions, install-and-restart is offered only once the update is downloaded, and in development the row reports unavailable instead of throwing.
 - Hardened the repository secret audit to ignore key prefixes embedded inside identifiers, so names such as `disk-…` or `task-…` no longer produce false positives while real keys still match.
+- Added Cursor, MiniMax Code, Devin and Antigravity agents (PR #63).
+- Added provider API keys, API profiles and agent-to-agent delegation through the orchestration MCP (PR #64).
+- The plugin showcase works without a GitHub account; signing in is optional and only raises GitHub's limits (issue #22). The HOME clock shows the date (issue #53).
+- The default session denies web permissions, a crashed renderer reloads, long agent answers keep their turn, and the secret audit also checks the built bundle (from PRs #35 and #51).
 ## 1.5.2
 
 - Fixed terminal history jumping to the beginning when Codex clears and redraws its history after a card resize. Readers retain their relative scroll position, while terminals at the bottom continue following new output.
diff --git a/CHANGELOG.ru.md b/CHANGELOG.ru.md
index c87b04fb..2ed4b884 100644
--- a/CHANGELOG.ru.md
+++ b/CHANGELOG.ru.md
@@ -23,6 +23,10 @@
 - WebGL ограничен сфокусированной карточкой терминала: один контекст одновременно, освобождается при уходе фокуса, при потере контекста используется DOM-renderer. Отрисовка палитры и прозрачности не изменилась.
 - В «Настройках → Обновления» появилась строка самообновления с честными состояниями: простой, проверка, доступно обновление (с версией), загрузка (с процентом, когда он известен), готово к установке и недоступно (dev, offline или ошибка). Загрузка и установка — явные действия пользователя, установка с перезапуском предлагается только после загрузки обновления, а в режиме разработки строка сообщает о недоступности и не выбрасывает исключение.
 - Аудит секретов в репозитории больше не срабатывает на префиксы ключей внутри идентификаторов, поэтому имена вида `disk-…` и `task-…` не дают ложных срабатываний, а настоящие ключи по-прежнему находятся.
+- Добавлены агенты Cursor, MiniMax Code, Devin и Antigravity (PR #63).
+- Добавлены API-ключи провайдеров, API-профили и делегирование между агентами через MCP оркестрации (PR #64).
+- Витрина плагинов работает без аккаунта GitHub; вход необязателен и только повышает лимиты GitHub (issue #22). Часы на HOME показывают дату (issue #53).
+- Основная сессия отклоняет веб-разрешения, упавший интерфейс перезагружается, длинные ответы агентов сохраняют свой ход, а проверка секретов проверяет и собранный бандл (из PR #35 и #51).
 ## 1.5.2
 
 - Исправлен прыжок терминала в начало истории, когда Codex очищает и заново рисует её после изменения размера карточки. При чтении сохраняется относительная позиция прокрутки, а терминал в конце истории продолжает следить за новым выводом.
diff --git a/CHANGELOG.zh-CN.md b/CHANGELOG.zh-CN.md
index 08f0724e..b92a94a2 100644
--- a/CHANGELOG.zh-CN.md
+++ b/CHANGELOG.zh-CN.md
@@ -23,6 +23,10 @@
 - WebGL 仅用于聚焦的终端卡片：同一时间只有一个 context，焦点离开时释放；context 丢失时回退到 DOM renderer。调色板与透明度渲染保持不变。
 - Settings → Updates 新增一行自更新，状态如实呈现：idle、checking、update available（含版本号）、downloading（已知时显示百分比）、ready to install 以及 unavailable（dev、offline 或 error）。下载与安装都是显式操作，只有在更新下载完成后才提供 install-and-restart；开发模式下该行报告 unavailable 而不会抛错。
 - 仓库密钥审计不再把标识符内部的密钥前缀当作命中，因此 `disk-…`、`task-…` 这类名称不再产生误报，而真实密钥仍会被检出。
+- 新增 Cursor、MiniMax Code、Devin 和 Antigravity 智能体（PR #63）。
+- 新增提供商 API 密钥、API 配置文件，以及通过编排 MCP 在智能体之间委派任务（PR #64）。
+- 插件展示页无需 GitHub 账号即可使用；登录是可选的，只会提高 GitHub 限额（issue #22）。HOME 时钟显示日期（issue #53）。
+- 默认会话拒绝网页权限，渲染进程崩溃后会重新加载，较长的智能体回答会保留其轮次，密钥审计也会检查构建产物（来自 PR #35 和 #51）。
 ## 1.5.2
 
 - 修复调整卡片大小后，Codex 清空并重新绘制历史时终端跳到历史开头的问题。阅读时保留相对滚动位置，位于底部的终端继续跟随新输出。
diff --git a/docs/plugins.md b/docs/plugins.md
index bc38739a..6be85806 100644
--- a/docs/plugins.md
+++ b/docs/plugins.md
@@ -228,7 +228,7 @@ Context updates include the active CanvasTTY locale and palette. Plugins own the
 
 The current installer intentionally rejects private repositories, GitHub `/tree/branch/subdirectory` links, and repositories that require a build step. Publish a ready-to-run static package at the repository root.
 
-The optional showcase sign-in uses GitHub's OAuth device flow. Build maintainers can [register an OAuth App and enable Device Flow](https://docs.github.com/en/apps/oauth-apps/building-oauth-apps/creating-an-oauth-app), then store its public client ID in the `CANVASTTY_GITHUB_CLIENT_ID` GitHub Actions repository variable. Official builds bake in that value when configured; local builds can use `GITHUB_OAUTH_CLIENT_ID` or `CANVASTTY_GITHUB_CLIENT_ID`, and either variable can also override the bundled value at runtime. No client secret is shipped or required. Sign-in opens GitHub in CanvasTTY's built-in Browser by default and offers the system browser as an explicit fallback. Without a client ID the UI reports that OAuth is unavailable, while direct repository inspection and installation continue to work. Signing out removes the encrypted local session; revoke the OAuth grant separately under [GitHub application settings](https://github.com/settings/applications) when needed.
+Browsing and searching the showcase work without an account through GitHub's public search API. Signing in is optional and only raises GitHub's search limits; when the anonymous limit is reached, CanvasTTY shows when to try again. The optional showcase sign-in uses GitHub's OAuth device flow. Build maintainers can [register an OAuth App and enable Device Flow](https://docs.github.com/en/apps/oauth-apps/building-oauth-apps/creating-an-oauth-app), then store its public client ID in the `CANVASTTY_GITHUB_CLIENT_ID` GitHub Actions repository variable. Official builds bake in that value when configured; local builds can use `GITHUB_OAUTH_CLIENT_ID` or `CANVASTTY_GITHUB_CLIENT_ID`, and either variable can also override the bundled value at runtime. No client secret is shipped or required. Sign-in opens GitHub in CanvasTTY's built-in Browser by default and offers the system browser as an explicit fallback. Without a client ID the UI reports that OAuth is unavailable, while direct repository inspection and installation continue to work. Signing out removes the encrypted local session; revoke the OAuth grant separately under [GitHub application settings](https://github.com/settings/applications) when needed.
 
 ## Author checklist
 
diff --git a/docs/plugins.ru.md b/docs/plugins.ru.md
index 4fafa25b..cee62344 100644
--- a/docs/plugins.ru.md
+++ b/docs/plugins.ru.md
@@ -209,7 +209,7 @@ Context сообщает текущие locale и palette CanvasTTY. Локал
 
 Установщик намеренно не принимает приватные репозитории, ссылки GitHub вида `/tree/branch/subdirectory` и репозитории, которым нужен build. Публикуйте готовый пакет в корне.
 
-Опциональный вход в витрину использует GitHub OAuth Device Flow. Сопровождающий сборку может [зарегистрировать OAuth App и включить Device Flow](https://docs.github.com/en/apps/oauth-apps/building-oauth-apps/creating-an-oauth-app), затем сохранить его публичный client ID в repository variable GitHub Actions `CANVASTTY_GITHUB_CLIENT_ID`. Официальная сборка встраивает это значение, когда оно настроено; для локальной сборки подходят `GITHUB_OAUTH_CLIENT_ID` и `CANVASTTY_GITHUB_CLIENT_ID`, а при запуске любая из них может переопределить встроенный ID. Client secret в приложение не встраивается и не требуется. По умолчанию вход открывает GitHub во встроенном Browser CanvasTTY, а системный браузер остаётся явным fallback. Без client ID интерфейс прямо сообщает, что OAuth недоступен, но проверка и установка по прямой ссылке продолжают работать. Отключение удаляет локальную зашифрованную сессию; при необходимости отдельно отзовите доступ в [настройках приложений GitHub](https://github.com/settings/applications).
+Просмотр и поиск в витрине работают без входа, через публичный поиск GitHub. Вход необязателен и только повышает лимиты поиска GitHub; когда анонимный лимит исчерпан, CanvasTTY показывает, когда можно повторить. Опциональный вход в витрину использует GitHub OAuth Device Flow. Сопровождающий сборку может [зарегистрировать OAuth App и включить Device Flow](https://docs.github.com/en/apps/oauth-apps/building-oauth-apps/creating-an-oauth-app), затем сохранить его публичный client ID в repository variable GitHub Actions `CANVASTTY_GITHUB_CLIENT_ID`. Официальная сборка встраивает это значение, когда оно настроено; для локальной сборки подходят `GITHUB_OAUTH_CLIENT_ID` и `CANVASTTY_GITHUB_CLIENT_ID`, а при запуске любая из них может переопределить встроенный ID. Client secret в приложение не встраивается и не требуется. По умолчанию вход открывает GitHub во встроенном Browser CanvasTTY, а системный браузер остаётся явным fallback. Без client ID интерфейс прямо сообщает, что OAuth недоступен, но проверка и установка по прямой ссылке продолжают работать. Отключение удаляет локальную зашифрованную сессию; при необходимости отдельно отзовите доступ в [настройках приложений GitHub](https://github.com/settings/applications).
 
 ## Чек-лист автора
 
diff --git a/docs/plugins.zh-CN.md b/docs/plugins.zh-CN.md
index a09436f9..748b268f 100644
--- a/docs/plugins.zh-CN.md
+++ b/docs/plugins.zh-CN.md
@@ -207,7 +207,7 @@ if (library) {
 
 当前安装器会刻意拒绝私有仓库、GitHub `/tree/branch/subdirectory` 链接以及需要构建步骤的仓库。请把可直接运行的静态包发布到仓库根目录。
 
-可选的展示页登录使用 GitHub OAuth Device Flow。构建维护者可以[注册 OAuth App 并启用 Device Flow](https://docs.github.com/en/apps/oauth-apps/building-oauth-apps/creating-an-oauth-app)，再将公开的 client ID 保存到 GitHub Actions 仓库变量 `CANVASTTY_GITHUB_CLIENT_ID`。正式构建会在该变量已配置时嵌入其值；本地构建可使用 `GITHUB_OAUTH_CLIENT_ID` 或 `CANVASTTY_GITHUB_CLIENT_ID`，运行时也可以用任一变量覆盖内置值。应用不包含也不需要 client secret。默认情况下，登录会在 CanvasTTY 内置浏览器中打开 GitHub，同时明确提供系统浏览器作为备用选项。未配置 client ID 时，界面会明确显示 OAuth 不可用，但仍可通过仓库链接检查和安装插件。退出登录只删除本机的加密会话；需要时请另行在 [GitHub 应用设置](https://github.com/settings/applications)中撤销授权。
+无需账号即可通过 GitHub 公共搜索 API 浏览和搜索展示页。登录是可选的，只会提高 GitHub 搜索限额；达到匿名限额时，CanvasTTY 会显示何时可以重试。可选的展示页登录使用 GitHub OAuth Device Flow。构建维护者可以[注册 OAuth App 并启用 Device Flow](https://docs.github.com/en/apps/oauth-apps/building-oauth-apps/creating-an-oauth-app)，再将公开的 client ID 保存到 GitHub Actions 仓库变量 `CANVASTTY_GITHUB_CLIENT_ID`。正式构建会在该变量已配置时嵌入其值；本地构建可使用 `GITHUB_OAUTH_CLIENT_ID` 或 `CANVASTTY_GITHUB_CLIENT_ID`，运行时也可以用任一变量覆盖内置值。应用不包含也不需要 client secret。默认情况下，登录会在 CanvasTTY 内置浏览器中打开 GitHub，同时明确提供系统浏览器作为备用选项。未配置 client ID 时，界面会明确显示 OAuth 不可用，但仍可通过仓库链接检查和安装插件。退出登录只删除本机的加密会话；需要时请另行在 [GitHub 应用设置](https://github.com/settings/applications)中撤销授权。
 
 ## 作者检查清单
 
diff --git a/src/agent-runtime/hook-helper.mjs b/src/agent-runtime/hook-helper.mjs
index 93d654bd..a60a655e 100644
--- a/src/agent-runtime/hook-helper.mjs
+++ b/src/agent-runtime/hook-helper.mjs
@@ -62,7 +62,7 @@ await reportLifecycle({
 /** Cuts at the limit without leaving a dangling high surrogate. */
 function boundedText(value, limit) {
   const text = value.slice(0, limit);
-  return /[\uD800-\uDBFF]$/.test(text) ? text.slice(0, -1) : text;
+  return /[\uD800-\uDBFF]$/u.test(text) ? text.slice(0, -1) : text;
 }
 function firstString(...values) {
   return values.find((value) => typeof value === "string" && value.length > 0) ?? null;
diff --git a/src/main/index.ts b/src/main/index.ts
index 64427e89..ee3eb3a3 100644
--- a/src/main/index.ts
+++ b/src/main/index.ts
@@ -248,11 +248,9 @@ function shellWindowGone(window: BrowserWindow): boolean {
 }
 
 async function initializeServices(): Promise<void> {
-  // Deny-by-default browser permissions on the default session: neither the
-  // shell window nor plugin windows ever request camera, microphone, location,
-  // notifications or device access, so nothing is granted silently. The
-  // browser partition keeps its own, deliberately more permissive policy in
-  // BrowserService; exceptions belong there, not here.
+  // Deny-by-default web permissions on the default session: the app window and plugin windows
+  // never need camera, microphone, location, notifications or device access. The Browser card uses
+  // its own partition with its own policy in BrowserService.
   session.defaultSession.setPermissionRequestHandler((_webContents, _permission, callback) => callback(false));
   session.defaultSession.setPermissionCheckHandler(() => false);
   session.defaultSession.setDevicePermissionHandler(() => false);
diff --git a/src/main/services/PluginManager.ts b/src/main/services/PluginManager.ts
index 763f1d46..17e63527 100644
--- a/src/main/services/PluginManager.ts
+++ b/src/main/services/PluginManager.ts
@@ -1651,9 +1651,7 @@ async function githubGraphqlSearchPage(
     body: JSON.stringify({ query: gql, variables }),
     signal
   });
-  if (response.status === 403 || response.status === 429) {
-    throw new Error("GitHub search rate limit reached; try again in a minute.");
-  }
+  if (response.status === 403 || response.status === 429) throw new Error(githubRateLimitMessage(response));
   if (!response.ok) {
     throw new Error(`GitHub plugin search failed with HTTP ${response.status}.`);
   }
@@ -1702,9 +1700,7 @@ async function fetchGithubSearchPage(url: URL, signal: AbortSignal): Promise<Git
     if (signal.aborted) throw new Error("GitHub plugin search timed out.");
     throw new Error("GitHub plugin search could not establish a connection.", { cause: error });
   }
-  if (response.status === 403 || response.status === 429) {
-    throw new Error("GitHub search rate limit reached; try again in a minute.");
-  }
+  if (response.status === 403 || response.status === 429) throw new Error(githubRateLimitMessage(response));
   if (!response.ok || !response.body) {
     throw new Error(`GitHub plugin search failed with HTTP ${response.status}.`);
   }
@@ -1717,6 +1713,15 @@ async function fetchGithubSearchPage(url: URL, signal: AbortSignal): Promise<Git
   return items;
 }
 
+/** Names the time GitHub's search quota resets, and that signing in raises the limit. */
+export function githubRateLimitMessage(response: Pick<Response, "headers">): string {
+  const reset = Number(response.headers.get("x-ratelimit-reset"));
+  const when = Number.isFinite(reset) && reset > 0
+    ? `after ${new Date(reset * 1000).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" })}`
+    : "in a minute";
+  return `GitHub search rate limit reached; try again ${when}. Signing in to GitHub raises the limit.`;
+}
+
 function mapSearchResults(results: GithubSearchItem[]): GithubPluginSearchResult[] {
   const entries: GithubPluginSearchResult[] = [];
   for (const item of results) {
diff --git a/src/renderer/src/features/home/HomeZone.tsx b/src/renderer/src/features/home/HomeZone.tsx
index 8167b50f..6cb950b0 100644
--- a/src/renderer/src/features/home/HomeZone.tsx
+++ b/src/renderer/src/features/home/HomeZone.tsx
@@ -499,10 +499,12 @@ function isFocusableHomeWidget(widgetId: string, plugins: readonly InstalledPlug
 function ClockWidget({ locale, now }: { locale: LocaleId; now: Date }): React.JSX.Element {
   const formatLocale = locale === "ru" ? "ru-RU" : "en-GB";
   const time = now.toLocaleTimeString(formatLocale, { hour: "2-digit", minute: "2-digit" });
+  const date = now.toLocaleDateString(formatLocale, { weekday: "short", day: "numeric", month: "long", year: "numeric" });
 
   return (
     <section className="tile clock-tile">
-      <time className="clock-tile__time">{time}</time>
+      <time className="clock-tile__time" dateTime={now.toISOString()}>{time}</time>
+      <span className="clock-tile__date">{date}</span>
     </section>
   );
 }
diff --git a/src/renderer/src/features/plugins/PluginSettingsSection.tsx b/src/renderer/src/features/plugins/PluginSettingsSection.tsx
index 06497af4..e1c333d4 100644
--- a/src/renderer/src/features/plugins/PluginSettingsSection.tsx
+++ b/src/renderer/src/features/plugins/PluginSettingsSection.tsx
@@ -248,7 +248,7 @@ export function PluginSettingsSection({
   };
 
   const runSearch = async (): Promise<void> => {
-    if (searching || searchQuery.trim().length === 0 || !githubAuthorized) return;
+    if (searching || searchQuery.trim().length === 0) return;
     setSearching(true);
     setError(null);
     try {
@@ -283,7 +283,7 @@ export function PluginSettingsSection({
   };
 
   const runShowcase = async (): Promise<void> => {
-    if (loadingShowcase || !githubAuthorized) return;
+    if (loadingShowcase) return;
     setLoadingShowcase(true);
     setError(null);
     try {
@@ -811,6 +811,7 @@ export function PluginSettingsSection({
             </span>
           )}
         </h3>
+        {!githubAuthorized && !githubCode && <p className="plugin-github-optional">{t(locale, "githubAuthOptional")}</p>}
         {githubStatus?.authorized ? (
           <div>
             <div className="plugin-github-row">
@@ -866,7 +867,7 @@ export function PluginSettingsSection({
       </section>
 
       <div className="plugin-showcase-wrap">
-        <section className={`setting-group plugin-showcase-group${githubAuthorized ? "" : " plugin-showcase-group--off"}`}>
+        <section className="setting-group plugin-showcase-group">
           <h3>
             {t(locale, "pluginShowcase")}
             <button
@@ -920,9 +921,6 @@ export function PluginSettingsSection({
           </div>
         )}
         </section>
-        {!githubAuthorized && (
-          <p className="plugin-showcase-lock" role="status">{t(locale, "showcaseRequiresGithub")}</p>
-        )}
       </div>
     </div>
   );
diff --git a/src/renderer/src/lib/i18n.ts b/src/renderer/src/lib/i18n.ts
index a925a9cf..f785a028 100644
--- a/src/renderer/src/lib/i18n.ts
+++ b/src/renderer/src/lib/i18n.ts
@@ -165,7 +165,7 @@ const ru = {
   githubAuthCopied: "Код скопирован",
   githubAuthNotConfigured: "Подключение GitHub недоступно: в этой сборке не настроен OAuth Client ID.",
   githubAuthExpired: "Код авторизации GitHub истёк. Начните вход заново.",
-  showcaseRequiresGithub: "Требуется подключение к GitHub",
+  githubAuthOptional: "Витрина и поиск работают без входа. Вход в GitHub необязателен: он не запрашивает дополнительного доступа и только повышает лимиты поиска GitHub. Токен хранится зашифрованным на этом устройстве; выйти или отозвать доступ можно в любой момент.",
   showcaseOpenBrowser: "Открыть в браузере",
   showcaseOpenCanvas: "Открыть в CanvasTTY",
   paginationPage: "Страница",
@@ -772,7 +772,7 @@ const en: Record<keyof typeof ru, string> = {
   githubAuthCopied: "Code copied",
   githubAuthNotConfigured: "GitHub connection is unavailable: this build has no OAuth Client ID.",
   githubAuthExpired: "The GitHub authorization code expired. Start sign-in again.",
-  showcaseRequiresGithub: "GitHub connection required",
+  githubAuthOptional: "The showcase and search work without an account. Signing in to GitHub is optional: it requests no extra access and only raises GitHub's search limits. The token is stored encrypted on this device; you can sign out or revoke access at any time.",
   showcaseOpenBrowser: "Open in browser",
   showcaseOpenCanvas: "Open in CanvasTTY",
   paginationPage: "Page",
diff --git a/src/renderer/src/styles/app.css b/src/renderer/src/styles/app.css
index b79be05d..01ff49b0 100644
--- a/src/renderer/src/styles/app.css
+++ b/src/renderer/src/styles/app.css
@@ -172,8 +172,10 @@ button { border: 0; }
 .mini-media__remove { position: absolute; top: 12px; right: 12px; z-index: 3; width: 40px; height: 40px; display: grid; place-items: center; border-radius: 11px; color: white; background: rgba(35,36,47,.86); box-shadow: var(--shadow-sm); cursor: pointer; opacity: 0; transform: translateY(-4px); transition: opacity .15s ease, transform .15s ease, background .15s ease; }
 .mini-media:hover .mini-media__remove, .mini-media:focus-within .mini-media__remove { opacity: 1; transform: none; }
 .mini-media__remove:hover { background: var(--danger); }
-.clock-tile { display: grid; place-items: center; color: var(--home-clock-text); background: var(--home-clock); }
+.clock-tile { display: grid; place-items: center; align-content: center; gap: 14px; container: clock-tile / size; color: var(--home-clock-text); background: var(--home-clock); }
 .clock-tile__time { font: 900 118px/.9 var(--font-mono); letter-spacing: -.08em; white-space: nowrap; }
+.clock-tile__date { font: 700 17px/1.2 var(--font-sans); letter-spacing: .01em; opacity: .78; white-space: nowrap; }
+@container clock-tile (max-height: 170px) { .clock-tile__date { display: none; } }
 
 .agent-overview { padding: 13px; display: grid; align-content: start; gap: 9px; background: var(--surface); }
 .limits-list { grid-template-rows: repeat(var(--limit-rows, 3), minmax(0, 1fr)); }
@@ -854,6 +856,7 @@ button { border: 0; }
 .plugin-github-flow-actions button { min-height: 30px; padding: 5px 10px; border-radius: 8px; color: var(--text-dark); background: var(--primary); font-size: 11px; font-weight: 850; cursor: pointer; }
 .plugin-github-flow-actions button:last-child, .plugin-github-signin-secondary { background: rgba(255,255,255,.5); }
 .plugin-github-unavailable { margin: 8px 0 2px; color: var(--text-muted); font-size: 11px; font-weight: 750; line-height: 1.4; }
+.plugin-github-optional { margin: 8px 0 2px; color: var(--text-muted); font-size: 11px; font-weight: 650; line-height: 1.45; }
 .plugin-github-code { cursor: pointer; user-select: none; position: relative; padding-right: 4px; font-size: 14px; font-weight: 850; }
 .plugin-github-code:hover strong { text-decoration: underline; text-underline-offset: 3px; }
 .plugin-github-code strong { font-size: 22px; letter-spacing: .18em; font-family: var(--font-mono); color: #4c6a3b; }
@@ -869,20 +872,6 @@ button { border: 0; }
 .plugin-showcase-group { margin-top: 4px; }
 .plugin-showcase-wrap { position: relative; margin-top: 4px; }
 .plugin-showcase-wrap .plugin-showcase-group { margin-top: 0; }
-.plugin-showcase-group--off { filter: grayscale(1) opacity(.28); pointer-events: none; user-select: none; }
-.plugin-showcase-lock {
-  position: static;
-  display: block;
-  margin: 0 0 10px;
-  padding: 0;
-  color: var(--text-muted);
-  font-size: 12px;
-  font-weight: 700;
-  line-height: 1.45;
-  background: none;
-  box-shadow: none;
-  pointer-events: none;
-}
 .plugin-showcase-search { margin-top: 12px; }
 .plugin-pagination { margin-top: 10px; display: flex; align-items: center; gap: 10px; }
 .plugin-pagination button { min-width: 28px; min-height: 24px; padding: 0 8px; border-radius: 7px; color: var(--text-dark); background: var(--primary); font-size: 13px; font-weight: 850; cursor: pointer; }
@@ -998,7 +987,8 @@ button { border: 0; }
   .browser-settings__message,
   .home-widget-list__row > span small,
   .plugin-search-result small,
-  .plugin-github-unavailable
+  .plugin-github-unavailable,
+  .plugin-github-optional
 ) { color: var(--text-muted-on-dark); }
 .settings-panel :is(.shortcut-editor__capture-hint, .browser-settings__message, .plugin-settings__empty) { color: var(--text-muted-on-dark); }
 .settings-panel :is(.shortcut-editor__error, .agent-hooks__disabled, .agent-hooks__error, .browser-settings__empty--error, .plugin-settings__error) { color: var(--danger); }
@@ -1064,7 +1054,6 @@ button { border: 0; }
 .settings-panel :is(.plugin-github-code strong, .plugin-github-copied, .plugin-github-flow a) { color: var(--primary); }
 .settings-panel .plugin-github-copied { background: color-mix(in srgb, var(--primary) 14%, transparent); }
 .settings-panel .plugin-github-dot { background: var(--success); box-shadow: 0 0 0 .22em color-mix(in srgb, var(--success) 22%, transparent); }
-.settings-panel .plugin-showcase-lock { color: var(--text-muted); background: none; box-shadow: none; }
 .settings-panel .plugin-icon--fallback { color: var(--text-dark); background: var(--primary); }
 .settings-panel .canvas-launcher-settings-menu .canvas-menu__row--muted .canvas-menu__grow { color: var(--text-muted-on-dark); }
 .toast { position: fixed; z-index: 9999; left: 50%; bottom: 24px; max-width: min(540px, calc(100% - 40px)); padding: 12px 17px; border-radius: 11px; color: white; background: rgba(37,38,48,.94); box-shadow: var(--shadow-md); opacity: 0; transform: translate(-50%, 18px); pointer-events: none; transition: all .2s ease; }
diff --git a/tests/agent-runtime-gateway.test.mjs b/tests/agent-runtime-gateway.test.mjs
index cb06c6cc..f60e0861 100644
--- a/tests/agent-runtime-gateway.test.mjs
+++ b/tests/agent-runtime-gateway.test.mjs
@@ -56,6 +56,38 @@ test("RuntimeGateway accepts one authenticated hook event over a mode-0600 local
   assert.equal(JSON.stringify(signals).includes("must stay local"), false);
 });
 
+test("a final answer longer than one runtime message still reports its turn and a bounded answer", POSIX_RUNTIME_GATEWAY_TEST, async (t) => {
+  const root = await fixture(t);
+  const signals = [];
+  const gateway = new RuntimeGateway({ runtimeDirectory: root, onSignal: (id, signal) => signals.push({ id, signal }) });
+  await gateway.start();
+  t.after(() => gateway.close());
+  const grantExpiresAt = Date.now() + 60_000;
+  const capability = gateway.registerSession("terminal-long", "codex", grantExpiresAt);
+  await send(capability.address, message(capability, "working", "UserPromptSubmit", "turn-long"));
+  const helper = new URL("../src/agent-runtime/hook-helper.mjs", import.meta.url);
+  const child = spawn(process.execPath, [helper.pathname, "idle", "Stop"], {
+    env: {
+      ...process.env,
+      [CAPTURE_ANSWER_ENV]: "1",
+      [CAPTURE_ANSWER_EXPIRES_AT_ENV]: String(grantExpiresAt),
+      [AGENT_RUNTIME_ENV.address]: capability.address,
+      [AGENT_RUNTIME_ENV.terminalSessionId]: capability.terminalSessionId,
+      [AGENT_RUNTIME_ENV.provider]: capability.provider,
+      [AGENT_RUNTIME_ENV.capabilityToken]: capability.capabilityToken
+    },
+    stdio: ["pipe", "ignore", "pipe"]
+  });
+  // 40 KB of text with an astral character straddling the 4000-character cut.
+  const answer = "a".repeat(3999) + "\u{1F600}" + "b".repeat(40_000);
+  child.stdin.end(JSON.stringify({ turn_id: "turn-long", last_assistant_message: answer }));
+  const result = await childResult(child);
+  assert.equal(result.code, 0, result.stderr);
+  const stop = signals.find(({ signal }) => signal.event === "Stop");
+  assert.equal(stop?.signal.turnId, "turn-long");
+  assert.equal(stop.signal.lastAssistantMessage, "a".repeat(3999));
+});
+
 test("RuntimeGateway rejects a wrong capability and ignores a stale turn completion", POSIX_RUNTIME_GATEWAY_TEST, async (t) => {
   const root = await fixture(t);
   const signals = [];
diff --git a/tests/app-hardening.test.mjs b/tests/app-hardening.test.mjs
new file mode 100644
index 00000000..69779429
--- /dev/null
+++ b/tests/app-hardening.test.mjs
@@ -0,0 +1,20 @@
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import test from "node:test";
+
+const main = await readFile(new URL("../src/main/index.ts", import.meta.url), "utf8");
+
+test("the default session denies web permissions; the Browser keeps its own partition", () => {
+  assert.match(main, /session\.defaultSession\.setPermissionRequestHandler\(\(_webContents, _permission, callback\) => callback\(false\)\)/);
+  assert.match(main, /session\.defaultSession\.setPermissionCheckHandler\(\(\) => false\)/);
+  assert.match(main, /session\.defaultSession\.setDevicePermissionHandler\(\(\) => false\)/);
+});
+
+test("a crashed renderer reloads only the application surface and a clean exit does not", () => {
+  const handler = main.slice(main.indexOf('window.webContents.on("render-process-gone"'));
+  assert.match(handler, /if \(details\.reason === "clean-exit"\) return;/);
+  assert.match(handler, /void loadApplicationSurface\(window\)/);
+  const reload = main.slice(main.indexOf("async function loadApplicationSurface"), main.indexOf("async function loadApplication("));
+  assert.doesNotMatch(reload, /SMOKE/u, "smoke hooks run once at startup, not on recovery");
+  assert.match(main, /app\.on\("child-process-gone"/);
+});
diff --git a/tests/plugin-manager.test.mjs b/tests/plugin-manager.test.mjs
index f69a686a..cffdc39e 100644
--- a/tests/plugin-manager.test.mjs
+++ b/tests/plugin-manager.test.mjs
@@ -1781,3 +1781,12 @@ function writeOctal(header, offset, length, value) {
 function sha256(value) {
   return createHash("sha256").update(value).digest("hex");
 }
+
+test("the anonymous showcase search reports when GitHub's rate limit resets", async () => {
+  const { githubRateLimitMessage } = await import("../src/main/services/PluginManager.ts");
+  const reset = Math.floor(Date.UTC(2030, 0, 1, 12, 30) / 1000);
+  const message = githubRateLimitMessage(new Response("", { status: 403, headers: { "x-ratelimit-reset": String(reset) } }));
+  assert.match(message, /try again after \d{1,2}:\d{2}/u);
+  assert.match(message, /Signing in to GitHub raises the limit/u);
+  assert.match(githubRateLimitMessage(new Response("", { status: 429 })), /try again in a minute/u);
+});

From dacbba9887a1645f53f144369ada5ff2964f26c2 Mon Sep 17 00:00:00 2001
From: howdeploy <howdeploy@proton.me>
Date: Sat, 26 Sep 2026 13:03:49 +0300
Subject: [PATCH 08/10] chore(dev): label the selected PR review build

---
 .gitignore                               | 2 +-
 src/renderer/src/components/TitleBar.tsx | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.gitignore b/.gitignore
index 410ebb1c..e339edb9 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,5 @@
 # Dependencies and generated application output
-node_modules/
+node_modules
 bun.lock
 out/
 dist/
diff --git a/src/renderer/src/components/TitleBar.tsx b/src/renderer/src/components/TitleBar.tsx
index abfb11e2..95e86f88 100644
--- a/src/renderer/src/components/TitleBar.tsx
+++ b/src/renderer/src/components/TitleBar.tsx
@@ -4,7 +4,7 @@ import { ProviderIcon } from "./ProviderIcon";
 import { UiIcon } from "./UiIcon";
 import { t } from "../lib/i18n";
 
-const BUILD_CHANNEL = import.meta.env.DEV ? "DEV" : "RELEASE";
+const BUILD_CHANNEL = import.meta.env.DEV || import.meta.env.VITE_BUILD_CHANNEL === "DEV" ? "DEV" : "RELEASE";
 const BUILD_LABEL = `${BUILD_CHANNEL} v${appManifest.version}`;
 
 interface TitleBarProps {

From 1d37f07d91d8232bff7f9aee7b25b097f4df3b3c Mon Sep 17 00:00:00 2001
From: howdeploy <howdeploy@proton.me>
Date: Sat, 26 Sep 2026 13:38:53 +0300
Subject: [PATCH 09/10] fix: apply reviewed DEV feedback for fullscreen,
 shortcuts and region dragging

---
 docs/UI_CONTRACT.md                           |   2 +-
 docs/fullscreen-mode.md                       |   6 +-
 package-lock.json                             | 523 ++++++++++++++++++
 src/main/services/SettingsStore.ts            |   8 +-
 src/renderer/src/App.tsx                      |  21 +-
 .../src/components/ShortcutReference.tsx      |  32 ++
 .../src/features/settings/SettingsPanel.tsx   |  20 +
 .../src/features/terminal/TerminalCard.tsx    |  14 -
 .../features/workspace/WorkspaceCanvas.tsx    |   6 +
 src/renderer/src/lib/i18n.ts                  |  26 +
 src/renderer/src/styles/app.css               |  15 +-
 src/shared/contracts.ts                       |   6 +-
 tests/settings-normalizer.test.mjs            |  20 +-
 13 files changed, 664 insertions(+), 35 deletions(-)
 create mode 100644 src/renderer/src/components/ShortcutReference.tsx

diff --git a/docs/UI_CONTRACT.md b/docs/UI_CONTRACT.md
index e31d62ea..48266ccd 100644
--- a/docs/UI_CONTRACT.md
+++ b/docs/UI_CONTRACT.md
@@ -25,7 +25,7 @@ This contract preserves the approved MVP concept and prevents feature ownership
 - Click focus has three explicit modes: Off, Single click, and Double click. It is off by default. Selection and its visible outline still work when camera focus is off; a double-click mode never jumps the camera on the first click. Window stacking is independent: an ordinary primary click always raises the pressed terminal, plugin, Browser, or note card.
 - Selection is currently exclusive across terminals and the built-in Browser: pressing on empty canvas clears it. Input focus is tracked independently so future multi-selection does not have to redefine wheel ownership.
 - Hover focus is an off-by-default input-focus mode. After a configurable delay (slow `500ms`, normal `250ms`, fast `80ms`), an input-bearing widget under the pointer receives logical focus without changing selection; terminal and native Browser keyboard input follows that focus. Pointer leave only cancels a pending transfer; assigned focus remains until another focusable widget is clicked/hovered or the user clicks outside every widget. Focusable surfaces are terminals, the native Browser, plugin iframe/canvas surfaces, and actually scrollable HOME lists; decorative and action-only tiles do not take focus.
-- Go to HOME and Rename window are separate user-remappable Controls rows with their own short descriptions; there is no duplicate standalone shortcut list. Defaults are `Home` for focusing the Home zone and `F2` for renaming the selected terminal window. Either action also accepts Mouse3/Mouse4/Mouse5 with optional modifiers. Rename is an inline header edit and does not recreate the PTY. A compact passive canvas hint reflects the persisted bindings immediately, can be hidden, and can be placed in any corner from Appearance.
+- Go to HOME, Toggle terminal fullscreen, and Rename window are separate user-remappable Controls rows with their own short descriptions. Defaults are `Home`, `Super+F` (`Command+F` on macOS), and `F2`. These actions also accept Mouse3/Mouse4/Mouse5 with optional modifiers. Rename is an inline header edit and does not recreate the PTY. Escape remains terminal input rather than closing fullscreen. A compact canvas hint reflects the persisted bindings immediately, can be hidden, and can be placed in any corner from Appearance. Controls and an expandable section in the hint share a reference of fixed shortcuts, including their terminal/menu context.
 - Snapping is enabled by default and can be disabled without changing existing window bounds. Edge panning remains off by default and exposes slow/normal/fast speed. Wheel direction is configurable separately for terminal scrolling and canvas navigation; canvas inversion applies to both pan axes and historical wheel zoom. Fresh profiles pan on ordinary scroll, while migrated profiles retain ordinary wheel zoom, direction, and sensitivity.
 
 ## Visual system
diff --git a/docs/fullscreen-mode.md b/docs/fullscreen-mode.md
index 32b52d58..c91aef97 100644
--- a/docs/fullscreen-mode.md
+++ b/docs/fullscreen-mode.md
@@ -7,13 +7,13 @@ CanvasTTY supports fullscreen mode for terminal sessions, allowing you to expand
 ### Enter Fullscreen
 
 - **Header button:** Click the maximize icon (⛶) in the terminal card header.
-- **Keyboard:** Not yet supported via shortcut (coming soon).
+- **Keyboard:** Select a terminal and press `Super+F` (`Command+F` on macOS). Change the binding in Settings → Controls → Terminal fullscreen.
 
 ### Exit Fullscreen
 
 - **Close button:** Click the X button in the top-right corner of the fullscreen session.
 - **Header button:** Click the restore icon (❐) in the terminal card header.
-- **Keyboard:** Press `Escape`.
+- **Keyboard:** Press the same fullscreen shortcut again. `Escape` remains available to the terminal application and never exits fullscreen.
 
 ## Behavior
 
@@ -41,4 +41,4 @@ Fullscreen UI strings are localized in `src/renderer/src/lib/i18n.ts`:
 | Key              | English              | Russian                       |
 |------------------|----------------------|-------------------------------|
 | `enterFullscreen`| Enter fullscreen     | Развернуть на весь экран     |
-| `exitFullscreen` | Exit fullscreen      | Свернуть из полноэкранного   |
\ No newline at end of file
+| `exitFullscreen` | Exit fullscreen      | Свернуть из полноэкранного   |
diff --git a/package-lock.json b/package-lock.json
index c28ce21f..5dcf52db 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -53,6 +53,474 @@
         "vite": "8.2.2"
       }
     },
+    "integrations/even-g2/node_modules/@esbuild/aix-ppc64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.28.2.tgz",
+      "integrity": "sha512-XExcO+dvLKvVtNTibSTBej1NCAbaGhWn9Ww1ZPx80qsahhPFe/8jgWP0IchNe0F3HwkU7n8ejhH8bjonqht8mQ==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "peer": true,
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "integrations/even-g2/node_modules/@esbuild/android-arm": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.28.2.tgz",
+      "integrity": "sha512-kXXoiPVVGQcnIYGOeaovwOURpniDBpSq4A03qkQ+BMQqtGG6HYap3xne9C1O1yo4TR3qxlCX5IqqmX6fFo2Lqg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "peer": true,
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "integrations/even-g2/node_modules/@esbuild/android-arm64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.28.2.tgz",
+      "integrity": "sha512-5YfKeeI8qWfBZIX+u2xZC3Zlb3Os/gLS2sbEKM+I4ZOcsWmHS2WLysCcQZDAFRslDUU5Oiq44gf6PYN1vGwG5A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "peer": true,
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "integrations/even-g2/node_modules/@esbuild/android-x64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.28.2.tgz",
+      "integrity": "sha512-O387ite7SzUyCcy3JQX4P4bLtEA7bLLkx+esve5JHnyYfNTxcVpXZo9jhdB0lTKN44gztELTdU7nS8Nr16Fs1Q==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "peer": true,
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "integrations/even-g2/node_modules/@esbuild/darwin-arm64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.28.2.tgz",
+      "integrity": "sha512-n4KqkOQrraxHJcgjM1RvwbigfQKIKJVpM7xp+KsxiyUSrRdIXnt73VhrPAx0fV44hgfmIVKjxMN9J1t5jySVkw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "peer": true,
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "integrations/even-g2/node_modules/@esbuild/darwin-x64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.28.2.tgz",
+      "integrity": "sha512-uq6suIWYP37qzGddBKPw5QEQPi6HiLGsO7UmkpfyaYNQ3D+rN6w6WfwH+nuqcGXWvawGwxOEroO4YGnFh95azw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "peer": true,
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "integrations/even-g2/node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.28.2.tgz",
+      "integrity": "sha512-n+I0BTSRIoy+d6RPKnEVwql5UwBJolytvY4mAOIEJorKlqgPII8ix6slVVrfZ5Tnj7glIZvloylbB/EJPMWEXw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "peer": true,
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "integrations/even-g2/node_modules/@esbuild/freebsd-x64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.28.2.tgz",
+      "integrity": "sha512-78XJTJkvPs0kz2w61301PJjXl4g7q3JqiYMZ/M/yVI73EHBrCRTgkhu9oqG7vPqq+a/yadEW8aD+agKlk5xrmg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "peer": true,
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "integrations/even-g2/node_modules/@esbuild/linux-arm": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.28.2.tgz",
+      "integrity": "sha512-XlDnu2q5yoqems+xay6wSAcg9DDD7K9RLKZEBOMZm3ckNpJBvOX20tSfby8KfrrhINDyv9V2YVZKY/SpoGJI8w==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "peer": true,
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "integrations/even-g2/node_modules/@esbuild/linux-arm64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.28.2.tgz",
+      "integrity": "sha512-pW4AC0P3it8c7do9MVM4p51FzHzdM/TZrerurgRcHJ2WTa1VQ1CIq18xncfpBJw4ojkiZZrKW2yIBWBP92j6Ug==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "peer": true,
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "integrations/even-g2/node_modules/@esbuild/linux-ia32": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.28.2.tgz",
+      "integrity": "sha512-CYbnj78HsIeA+DhgUKgFCfvNsTHFhMMrinUrMZpDXJXKN8T3XViTZ/+wtHeVxEWY8ewSzTFN+nRmSwO2tZaLUQ==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "peer": true,
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "integrations/even-g2/node_modules/@esbuild/linux-loong64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.28.2.tgz",
+      "integrity": "sha512-buwkd8nsph4R+ajRvw0qM5Hja/TXQow3ptzWO2EbG/cqcIkHloRrdlBtQlshyYGTNFvfkfJ5tpPLVkY4DtsPfQ==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "peer": true,
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "integrations/even-g2/node_modules/@esbuild/linux-mips64el": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.28.2.tgz",
+      "integrity": "sha512-ZVykbDyk7519VwiNb9Lcj9m8XM6v5V9uKPvrEMkkEedVewf+0itkhahp4HDpgERXhwLRpWFypsGbG/J8s0QjJA==",
+      "cpu": [
+        "mips64el"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "peer": true,
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "integrations/even-g2/node_modules/@esbuild/linux-ppc64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.28.2.tgz",
+      "integrity": "sha512-CAXl+Dtd9UUuJd8pKKdwh6MLm3MUMiqMPmhZ3tTSXPqfyQ3vDl6R5hZdZ/kYojK4ofXtdfSv1tFq8XzWx3heNQ==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "peer": true,
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "integrations/even-g2/node_modules/@esbuild/linux-riscv64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.28.2.tgz",
+      "integrity": "sha512-GeXCej4IQtU1B+QlDV8W/RRvbzI3O/Stss+/bCXv4lZls5WGRtu2a+3JkA3i4qIUlMXpcHebWpF8AkJhATowuA==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "peer": true,
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "integrations/even-g2/node_modules/@esbuild/linux-s390x": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.28.2.tgz",
+      "integrity": "sha512-3H1weTYZPxt/WOhByszQZybS9w5lKzUn1FDMsgEChbHWQwHYQQRfBxgCcZvPhjHfKyJjIievvMmEUawJrdY9Dg==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "peer": true,
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "integrations/even-g2/node_modules/@esbuild/linux-x64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.28.2.tgz",
+      "integrity": "sha512-4xTZr1FUmSoQW4XIWmit3tzQrUTZM+N3P0XV8xROKYF50XfI7xeO90+1bZvNwxIufQ9hDQVRJH5YhgPVF8A/HQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "peer": true,
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "integrations/even-g2/node_modules/@esbuild/netbsd-arm64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.28.2.tgz",
+      "integrity": "sha512-sSATRjPeDBg3pdgHoQfoYBob11Kk1FGa9lui5RIHZCoCkJa9QKlvl3/vKz2usCmYYjs7ymJR/2Nnsqe+Hjt5nw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "peer": true,
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "integrations/even-g2/node_modules/@esbuild/netbsd-x64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.28.2.tgz",
+      "integrity": "sha512-lqnzCV+mM0gIADaKihiCg6ifgfU2L3h5E33rNQBN1Y4MaVGnzryzmvvf7UHxprpQdE8hpqLolJ9Rl+SkIRDpyw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "peer": true,
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "integrations/even-g2/node_modules/@esbuild/openbsd-arm64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.28.2.tgz",
+      "integrity": "sha512-AL2qJILH7lNjrDmCQDvdxMfAUIv8KMNZOvrwAQ8i8//ntL9FflhOyMJ8OZSMBb8/AWXe3/5v5S20y3zCoZWKoQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "peer": true,
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "integrations/even-g2/node_modules/@esbuild/openbsd-x64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.28.2.tgz",
+      "integrity": "sha512-QtiuPytchRyC4rwUKhexJdQKvDuZ6hWloi3igqPQNUJCS1/v9EiO3UTOXR6A3FoMo4fnAKbWJdqaIwhOzh8qEw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "peer": true,
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "integrations/even-g2/node_modules/@esbuild/openharmony-arm64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.28.2.tgz",
+      "integrity": "sha512-WkhYDmpTjLvGlScA1rwjRUmhl4k8oXR3cIbtqWmELgU/dFeHHlEllxDvdWcNJV9rbzCexB5vz8gtNewWLgCT7Q==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ],
+      "peer": true,
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "integrations/even-g2/node_modules/@esbuild/sunos-x64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.28.2.tgz",
+      "integrity": "sha512-GPMSkTOtMnv2U2F8gxe4Io6qmVs+YKyp832Etqqxr0hFngmXQ3rzwytelm3GIn7T4VviRUlf3sOgBOiTdvaf7g==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "peer": true,
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "integrations/even-g2/node_modules/@esbuild/win32-arm64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.28.2.tgz",
+      "integrity": "sha512-PIhhEkE9uPBleRBrQEJpUn7MBnibZzbGzYWPmY3x+YoVg/95zbjB4CxPPOQ8l5tYYM4mMaCthF8/1DIfBQQyWQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "peer": true,
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "integrations/even-g2/node_modules/@esbuild/win32-ia32": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.28.2.tgz",
+      "integrity": "sha512-YmJbfTlvU7Sdn9BB+4PRES4oB6pxgS37MAONj+hBr/cpXS1aBPKXxNnDbu+QCWPj0o9dgyxeq79g6c5P8KeuYA==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "peer": true,
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "integrations/even-g2/node_modules/@esbuild/win32-x64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.28.2.tgz",
+      "integrity": "sha512-5ebpxr3nWMzrL/rnUI755Jkuee0bHL/Gq0WTF9lvcpv73wAp5eu8MfBUgWK9bhWvZjj7yX8etf/8tI8Ney695g==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "peer": true,
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "integrations/even-g2/node_modules/@evenrealities/evenhub-cli": {
       "version": "0.1.14",
       "resolved": "https://registry.npmjs.org/@evenrealities/evenhub-cli/-/evenhub-cli-0.1.14.tgz",
@@ -99,6 +567,50 @@
         "node": ">=20"
       }
     },
+    "integrations/even-g2/node_modules/esbuild": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.28.2.tgz",
+      "integrity": "sha512-HKVLS8dvII+xoKW9kmqxbRKrnWEXfJJr/FZhhJmiqIB0e053QNYFqOBouTMO/k5sID4MvCiUCvv8b9M4h32wIA==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "peer": true,
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.28.2",
+        "@esbuild/android-arm": "0.28.2",
+        "@esbuild/android-arm64": "0.28.2",
+        "@esbuild/android-x64": "0.28.2",
+        "@esbuild/darwin-arm64": "0.28.2",
+        "@esbuild/darwin-x64": "0.28.2",
+        "@esbuild/freebsd-arm64": "0.28.2",
+        "@esbuild/freebsd-x64": "0.28.2",
+        "@esbuild/linux-arm": "0.28.2",
+        "@esbuild/linux-arm64": "0.28.2",
+        "@esbuild/linux-ia32": "0.28.2",
+        "@esbuild/linux-loong64": "0.28.2",
+        "@esbuild/linux-mips64el": "0.28.2",
+        "@esbuild/linux-ppc64": "0.28.2",
+        "@esbuild/linux-riscv64": "0.28.2",
+        "@esbuild/linux-s390x": "0.28.2",
+        "@esbuild/linux-x64": "0.28.2",
+        "@esbuild/netbsd-arm64": "0.28.2",
+        "@esbuild/netbsd-x64": "0.28.2",
+        "@esbuild/openbsd-arm64": "0.28.2",
+        "@esbuild/openbsd-x64": "0.28.2",
+        "@esbuild/openharmony-arm64": "0.28.2",
+        "@esbuild/sunos-x64": "0.28.2",
+        "@esbuild/win32-arm64": "0.28.2",
+        "@esbuild/win32-ia32": "0.28.2",
+        "@esbuild/win32-x64": "0.28.2"
+      }
+    },
     "integrations/even-g2/node_modules/postcss": {
       "version": "8.5.28",
       "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.28.tgz",
@@ -5841,6 +6353,7 @@
       "os": [
         "android"
       ],
+      "peer": true,
       "engines": {
         "node": ">= 12.0.0"
       },
@@ -5862,6 +6375,7 @@
       "os": [
         "darwin"
       ],
+      "peer": true,
       "engines": {
         "node": ">= 12.0.0"
       },
@@ -5883,6 +6397,7 @@
       "os": [
         "darwin"
       ],
+      "peer": true,
       "engines": {
         "node": ">= 12.0.0"
       },
@@ -5904,6 +6419,7 @@
       "os": [
         "freebsd"
       ],
+      "peer": true,
       "engines": {
         "node": ">= 12.0.0"
       },
@@ -5925,6 +6441,7 @@
       "os": [
         "linux"
       ],
+      "peer": true,
       "engines": {
         "node": ">= 12.0.0"
       },
@@ -5946,6 +6463,7 @@
       "os": [
         "linux"
       ],
+      "peer": true,
       "engines": {
         "node": ">= 12.0.0"
       },
@@ -5967,6 +6485,7 @@
       "os": [
         "linux"
       ],
+      "peer": true,
       "engines": {
         "node": ">= 12.0.0"
       },
@@ -5988,6 +6507,7 @@
       "os": [
         "linux"
       ],
+      "peer": true,
       "engines": {
         "node": ">= 12.0.0"
       },
@@ -6009,6 +6529,7 @@
       "os": [
         "linux"
       ],
+      "peer": true,
       "engines": {
         "node": ">= 12.0.0"
       },
@@ -6030,6 +6551,7 @@
       "os": [
         "win32"
       ],
+      "peer": true,
       "engines": {
         "node": ">= 12.0.0"
       },
@@ -6051,6 +6573,7 @@
       "os": [
         "win32"
       ],
+      "peer": true,
       "engines": {
         "node": ">= 12.0.0"
       },
diff --git a/src/main/services/SettingsStore.ts b/src/main/services/SettingsStore.ts
index 366f7e6d..a75a6e3a 100644
--- a/src/main/services/SettingsStore.ts
+++ b/src/main/services/SettingsStore.ts
@@ -41,6 +41,7 @@ import {
   DEFAULT_HOME_GRID_SIZE,
   DEFAULT_HOME_LAYOUT,
   DEFAULT_RADIAL_LAUNCHER_ITEMS,
+  DEFAULT_SHORTCUTS,
   DEFAULT_UI_SCALE,
   HOME_GRID_MAX_COLUMNS,
   HOME_GRID_MAX_ROWS,
@@ -96,7 +97,6 @@ const CANVAS_OVERLAY_PLACEMENTS = new Set<CanvasOverlayPlacement>([
 ]);
 const MINIMAP_INTERACTION_MODES = new Set<MinimapInteractionMode>(["click", "drag"]);
 const SHORTCUT_MODIFIERS = new Set(["Ctrl", "Alt", "Shift", "Meta"]);
-const DEFAULT_SHORTCUTS: ShortcutBindings = { home: "Home", renameWindow: "F2" };
 
 export class SettingsStore {
   private readonly filePath: string;
@@ -906,10 +906,12 @@ function normalizeShortcuts(candidate: unknown, fallback: ShortcutBindings): Sho
     : {};
   const shortcuts = {
     home: isValidShortcut(source.home) ? source.home : fallback.home,
-    renameWindow: isValidShortcut(source.renameWindow) ? source.renameWindow : fallback.renameWindow
+    renameWindow: isValidShortcut(source.renameWindow) ? source.renameWindow : fallback.renameWindow,
+    toggleFullscreen: isValidShortcut(source.toggleFullscreen) ? source.toggleFullscreen : fallback.toggleFullscreen
   };
 
-  if (shortcuts.home.toLowerCase() === shortcuts.renameWindow.toLowerCase()) {
+  const bindings = Object.values(shortcuts).map((binding) => binding.toLowerCase());
+  if (new Set(bindings).size !== bindings.length) {
     return { ...fallback };
   }
   return shortcuts;
diff --git a/src/renderer/src/App.tsx b/src/renderer/src/App.tsx
index 161ac8f3..754bc1ad 100644
--- a/src/renderer/src/App.tsx
+++ b/src/renderer/src/App.tsx
@@ -24,6 +24,7 @@ import type {
   ProviderId,
   SessionBounds,
   SessionSnapshot,
+  ShortcutAction,
   StickyNote,
   WindowState
 } from "../../shared/contracts";
@@ -995,7 +996,13 @@ export function App(): React.JSX.Element {
   }, [homeEditDraft, settings.locale, showToast]);
 
   useEffect(() => {
-    const performShortcut = (shortcut: "home" | "renameWindow"): void => {
+    const performShortcut = (shortcut: ShortcutAction): void => {
+      if (shortcut === "toggleFullscreen") {
+        if (settingsOpen || launchProvider !== null || pendingTerminalUrl !== null || homeEditDraft) return;
+        const id = fullscreenSessionId ?? activeSessionId;
+        if (id) toggleSessionFullscreen(id);
+        return;
+      }
       if (shortcut === "home") {
         goHome();
         return;
@@ -1008,6 +1015,12 @@ export function App(): React.JSX.Element {
     };
     const handleShortcut = (event: KeyboardEvent): void => {
       if (event.repeat || isShortcutCaptureTarget(event.target) || isRenameInputTarget(event.target)) return;
+      if (matchesShortcut(event, settings.shortcuts.toggleFullscreen)) {
+        event.preventDefault();
+        event.stopPropagation();
+        performShortcut("toggleFullscreen");
+        return;
+      }
       if (matchesShortcut(event, settings.shortcuts.home)) {
         event.preventDefault();
         event.stopPropagation();
@@ -1027,7 +1040,9 @@ export function App(): React.JSX.Element {
         ? "home"
         : matchesPointerShortcut(event, settings.shortcuts.renameWindow)
           ? "renameWindow"
-          : null;
+          : matchesPointerShortcut(event, settings.shortcuts.toggleFullscreen)
+            ? "toggleFullscreen"
+            : null;
       if (!action) return;
       event.preventDefault();
       event.stopPropagation();
@@ -1040,7 +1055,7 @@ export function App(): React.JSX.Element {
       window.removeEventListener("keydown", handleShortcut, true);
       window.removeEventListener("pointerdown", handlePointerShortcut, true);
     };
-  }, [activeSessionId, goHome, settings.locale, settings.shortcuts, showToast]);
+  }, [activeSessionId, fullscreenSessionId, goHome, homeEditDraft, launchProvider, pendingTerminalUrl, settings.locale, settings.shortcuts, settingsOpen, showToast, toggleSessionFullscreen]);
 
   const appearance = resolveAppearanceSettings(settings);
   const rootClasses = useMemo(
diff --git a/src/renderer/src/components/ShortcutReference.tsx b/src/renderer/src/components/ShortcutReference.tsx
new file mode 100644
index 00000000..6ff3b257
--- /dev/null
+++ b/src/renderer/src/components/ShortcutReference.tsx
@@ -0,0 +1,32 @@
+import type { LocaleId } from "../../../shared/contracts";
+import { t, type TranslationKey } from "../lib/i18n";
+
+export function ShortcutReference({ locale }: { locale: LocaleId }): React.JSX.Element {
+  const mac = window.canvasTTY.window.isMacOS;
+  const command = mac ? "Command" : "Ctrl";
+  const shortcuts: [string, TranslationKey][] = [
+    [`${command}+K`, "commandPalette"],
+    [`${command}+,`, "settings"],
+    [`${mac ? "Option" : "Alt"}+↑↓←→`, "focusWindowHint"],
+    ["Shift + drag", "marqueeSelectionHint"],
+    ["Ctrl+Shift+F", "terminalSearch"],
+    [mac ? "Command+C / Ctrl+C / Ctrl+Shift+C" : "Ctrl+C / Ctrl+Shift+C", "shortcutCopySelection"],
+    [mac ? "Command+V / Ctrl+Shift+V / Shift+Insert" : "Ctrl+Shift+V / Shift+Insert", "shortcutPaste"],
+    ["Shift+Enter", "shortcutLineBreak"],
+    ["PageUp / PageDown", "shortcutScrollPages"],
+    ["Ctrl+D", "shortcutRestartExited"],
+    ["Enter / Shift+Enter", "shortcutSearchMatches"],
+    ["↑↓ / Enter", "shortcutPaletteNavigation"],
+    ["↑↓←→ / Enter / Space", "shortcutRadialNavigation"],
+    ["↑↓←→", "shortcutMinimapNavigation"],
+    ["Enter / Escape", "shortcutRenameConfirm"],
+    ["Escape", "shortcutDismiss"]
+  ];
+  return (
+    <dl className="shortcut-reference">
+      {shortcuts.map(([keys, label]) => (
+        <div key={label}><dt><kbd>{keys}</kbd></dt><dd>{t(locale, label)}</dd></div>
+      ))}
+    </dl>
+  );
+}
diff --git a/src/renderer/src/features/settings/SettingsPanel.tsx b/src/renderer/src/features/settings/SettingsPanel.tsx
index d3fcb2dd..74549691 100644
--- a/src/renderer/src/features/settings/SettingsPanel.tsx
+++ b/src/renderer/src/features/settings/SettingsPanel.tsx
@@ -50,6 +50,7 @@ import {
   defaultCanvasWheelBinding
 } from "../../../../shared/canvasNavigation";
 import { ProviderIcon } from "../../components/ProviderIcon";
+import { ShortcutReference } from "../../components/ShortcutReference";
 import { UiIcon, type UiIconName } from "../../components/UiIcon";
 import {
   CanvasMenuDivider,
@@ -943,6 +944,22 @@ export function SettingsPanel({
                   <p className="shortcut-editor__error" role="alert">{shortcutError}</p>
                 )}
               </SettingGroup>
+              <SettingGroup label={t(locale, "toggleFullscreen")} description={t(locale, "toggleFullscreenDescription")}>
+                <ShortcutRow
+                  label={t(locale, "shortcutBinding")}
+                  value={settings.shortcuts.toggleFullscreen.replace("Meta", window.canvasTTY.window.isMacOS ? "Command" : "Super")}
+                  capturing={capturing === "toggleFullscreen"}
+                  onStart={() => {
+                    setShortcutError(null);
+                    setCapturing("toggleFullscreen");
+                  }}
+                  onKeyDown={(event) => captureShortcut("toggleFullscreen", event)}
+                  onPointerDown={(event) => capturePointerShortcut("toggleFullscreen", event)}
+                />
+                {shortcutError && capturing === "toggleFullscreen" && (
+                  <p className="shortcut-editor__error" role="alert">{shortcutError}</p>
+                )}
+              </SettingGroup>
               <SettingGroup label={t(locale, "renameWindow")} description={t(locale, "renameWindowDescription")}>
                 <ShortcutRow
                   label={t(locale, "shortcutBinding")}
@@ -959,6 +976,9 @@ export function SettingsPanel({
                   <p className="shortcut-editor__error" role="alert">{shortcutError}</p>
                 )}
               </SettingGroup>
+              <SettingGroup label={t(locale, "keyboardShortcuts")} layout="stacked">
+                <ShortcutReference locale={locale} />
+              </SettingGroup>
             </>
           )}
 
diff --git a/src/renderer/src/features/terminal/TerminalCard.tsx b/src/renderer/src/features/terminal/TerminalCard.tsx
index ecd62185..6df9f022 100644
--- a/src/renderer/src/features/terminal/TerminalCard.tsx
+++ b/src/renderer/src/features/terminal/TerminalCard.tsx
@@ -436,20 +436,6 @@ export function TerminalCard({
     if (summaryMode) closeSearch();
   }, [summaryMode]);
 
-  // Exit fullscreen mode on Escape key
-  useEffect(() => {
-    if (!fullscreen) return;
-    const handleEscape = (event: KeyboardEvent): void => {
-      if (event.key === "Escape") {
-        event.preventDefault();
-        event.stopPropagation();
-        onToggleFullscreen();
-      }
-    };
-    window.addEventListener("keydown", handleEscape, false);
-    return () => window.removeEventListener("keydown", handleEscape, false);
-  }, [fullscreen, onToggleFullscreen]);
-
   const bindRenameInput = useCallback((input: HTMLInputElement | null): void => {
     renameInput.current = input;
     if (!input) return;
diff --git a/src/renderer/src/features/workspace/WorkspaceCanvas.tsx b/src/renderer/src/features/workspace/WorkspaceCanvas.tsx
index 7df95aa6..f4678425 100644
--- a/src/renderer/src/features/workspace/WorkspaceCanvas.tsx
+++ b/src/renderer/src/features/workspace/WorkspaceCanvas.tsx
@@ -20,6 +20,7 @@ import type {
   StickyNote
 } from "../../../../shared/contracts";
 import { UiIcon } from "../../components/UiIcon";
+import { ShortcutReference } from "../../components/ShortcutReference";
 import { t } from "../../lib/i18n";
 import { displayCanvasNavigationBinding, isRenameInputTarget, isShortcutCaptureTarget, matchesPhysicalOrLayoutKey } from "../../lib/shortcuts";
 import { BrowserCard } from "../browser/BrowserCard";
@@ -1207,6 +1208,7 @@ export function WorkspaceCanvas(props: WorkspaceCanvasProps): React.JSX.Element
               <aside className="shortcut-hints" aria-label={t(settings.locale, "keyboardShortcuts")}>
                 <div><kbd>{settings.shortcuts.home}</kbd><span>{t(settings.locale, "homeShortcut")}</span></div>
                 <div><kbd>{settings.shortcuts.renameWindow}</kbd><span>{t(settings.locale, "renameWindow")}</span></div>
+                <div><kbd>{settings.shortcuts.toggleFullscreen.replace("Meta", window.canvasTTY.window.isMacOS ? "Command" : "Super")}</kbd><span>{t(settings.locale, "toggleFullscreen")}</span></div>
                 <div><kbd>{window.canvasTTY.window.isMacOS ? "Option+↑↓←→" : "Alt+↑↓←→"}</kbd><span>{t(settings.locale, "focusWindowHint")}</span></div>
                 <div><kbd>Shift + drag</kbd><span>{t(settings.locale, "marqueeSelectionHint")}</span></div>
                 {settings.canvasWheelCaptureMode === "key" && settings.canvasWheelOverride !== null && (
@@ -1217,6 +1219,10 @@ export function WorkspaceCanvas(props: WorkspaceCanvasProps): React.JSX.Element
                   <div><kbd>{displayCanvasNavigationBinding(settings.canvasNavigationOverride, window.canvasTTY.window.isMacOS)}</kbd>
                     <span>{t(settings.locale, "canvasNavigationOverrideHint")}</span></div>
                 )}
+                <details className="shortcut-hints__more" data-interactive="true" data-canvas-wheel-priority="local">
+                  <summary>{t(settings.locale, "keyboardShortcuts")}</summary>
+                  <ShortcutReference locale={settings.locale} />
+                </details>
               </aside>
             )}
           </div>
diff --git a/src/renderer/src/lib/i18n.ts b/src/renderer/src/lib/i18n.ts
index f785a028..27f575f2 100644
--- a/src/renderer/src/lib/i18n.ts
+++ b/src/renderer/src/lib/i18n.ts
@@ -344,10 +344,23 @@ const ru = {
   double: "Двойной клик",
   shortcutHints: "Подсказка горячих клавиш",
   keyboardShortcuts: "Горячие клавиши",
+  shortcutCopySelection: "Терминал: копировать выделенный текст",
+  shortcutPaste: "Терминал: вставить из буфера",
+  shortcutLineBreak: "Терминал: перенос строки (если CLI поддерживает)",
+  shortcutScrollPages: "Терминал: прокрутка обычного буфера; в TUI клавиши получает CLI",
+  shortcutRestartExited: "Терминал: перезапустить завершённую сессию",
+  shortcutSearchMatches: "В поиске терминала: следующее / предыдущее совпадение",
+  shortcutPaletteNavigation: "В командной палитре: выбрать / выполнить",
+  shortcutRadialNavigation: "В круговом меню: выбрать / выполнить",
+  shortcutMinimapNavigation: "В фокусе мини-карты: переместить камеру",
+  shortcutRenameConfirm: "При переименовании: сохранить / отменить",
+  shortcutDismiss: "Закрыть открытый поиск, меню или диалог; в терминале передаётся CLI",
   homeShortcut: "Переход к HOME",
   homeShortcutDescription: "Центрирует канвас на домашней зоне.",
   renameWindow: "Переименовать окно",
   renameWindowDescription: "Открывает переименование выбранного терминала.",
+  toggleFullscreen: "Полноэкранный терминал",
+  toggleFullscreenDescription: "Разворачивает выбранный терминал и возвращает его на канвас. По умолчанию Super+F (Command+F на macOS). Escape остаётся у терминала.",
   shortcutBinding: "Клавиша или кнопка мыши",
   minimapPlacement: "Расположение мини-карты",
   minimapInteractionMode: "Управление мини-картой",
@@ -944,10 +957,23 @@ const en: Record<keyof typeof ru, string> = {
   wheelNormal: "Normal",
   renameWindow: "Rename window",
   renameWindowDescription: "Starts renaming the selected terminal.",
+  toggleFullscreen: "Terminal fullscreen",
+  toggleFullscreenDescription: "Expands the selected terminal and returns it to the canvas. Defaults to Super+F (Command+F on macOS). Escape stays with the terminal.",
   homeShortcut: "Go to HOME",
   homeShortcutDescription: "Centers the canvas on the Home zone.",
   shortcutBinding: "Key or mouse button",
   keyboardShortcuts: "Keyboard shortcuts",
+  shortcutCopySelection: "Terminal: copy selected text",
+  shortcutPaste: "Terminal: paste from clipboard",
+  shortcutLineBreak: "Terminal: line break (if supported by the CLI)",
+  shortcutScrollPages: "Terminal: scroll normal buffer; TUI apps receive these keys directly",
+  shortcutRestartExited: "Terminal: restart an exited session",
+  shortcutSearchMatches: "In terminal search: next / previous match",
+  shortcutPaletteNavigation: "In command palette: select / activate",
+  shortcutRadialNavigation: "In radial menu: select / activate",
+  shortcutMinimapNavigation: "With minimap focused: move camera",
+  shortcutRenameConfirm: "While renaming: save / cancel",
+  shortcutDismiss: "Close open search, menu or dialog; passed to the CLI in the terminal",
   shortcutHints: "Shortcut hint",
   minimapPlacement: "Minimap position",
   minimapInteractionMode: "Minimap interaction",
diff --git a/src/renderer/src/styles/app.css b/src/renderer/src/styles/app.css
index 01ff49b0..a5abfa43 100644
--- a/src/renderer/src/styles/app.css
+++ b/src/renderer/src/styles/app.css
@@ -135,11 +135,13 @@ button { border: 0; }
 .tile { position: relative; overflow: hidden; border: 1px solid var(--border); border-radius: var(--radius-lg); box-shadow: var(--shadow-md); }
 
 .home-zone { position: absolute; left: 0; top: 0; display: grid; gap: 18px; border-radius: calc(var(--radius-lg) + 4px); }
+/* Empty HOME cells must not intercept regions visible underneath them. */
+.home-zone:not(.home-zone--editing) { pointer-events: none; }
 .home-zone--editing { outline: 2px dashed rgba(255,255,255,.86); outline-offset: 10px; background-color: rgba(255,255,255,.06); background-image: linear-gradient(to right, rgba(255,255,255,.2) 1px, transparent 1px), linear-gradient(to bottom, rgba(255,255,255,.2) 1px, transparent 1px); background-size: 100px 90px; }
 .home-zone__boundary-label { position: absolute; left: -11px; top: -49px; z-index: 60; min-height: 30px; padding: 7px 11px; display: flex; align-items: center; border-radius: 9px; color: white; background: rgba(40,41,52,.94); box-shadow: var(--shadow-sm); font: 800 11px/1 var(--font-mono); white-space: nowrap; }
 .home-zone__boundary-resize { position: absolute; right: -24px; bottom: -24px; z-index: 70; width: 42px; height: 42px; border: 4px solid rgba(255,255,255,.9); border-left: 0; border-top: 0; border-radius: 0 0 10px 0; background: rgba(40,41,52,.74); cursor: nwse-resize; touch-action: none; }
 .home-zone__boundary-resize:hover { background: rgba(40,41,52,.94); }
-.home-widget-slot { position: absolute; z-index: 1; min-width: 0; min-height: 0; }
+.home-widget-slot { position: absolute; z-index: 1; min-width: 0; min-height: 0; pointer-events: auto; }
 .home-widget-slot > .tile { width: 100%; height: 100%; }
 .home-zone--editing .home-widget-slot > .tile { pointer-events: none; }
 .home-zone--editing .home-widget-slot { border-radius: var(--radius-lg); outline: 2px dashed rgba(255,255,255,.72); outline-offset: 4px; }
@@ -276,9 +278,17 @@ button { border: 0; }
 .canvas-controls button { width: 36px; height: 36px; display: grid; place-items: center; border-radius: 8px; color: white; background: transparent; cursor: pointer; transition: background .15s ease; }
 .canvas-controls button:hover { background: rgba(255,255,255,.13); }
 .shortcut-hints { min-width: 224px; padding: 9px 11px; display: grid; gap: 7px; border-radius: 12px; color: white; background: rgba(40,41,52,.9); box-shadow: var(--shadow-sm); pointer-events: none; }
-.shortcut-hints div { display: grid; grid-template-columns: minmax(52px, auto) 1fr; align-items: center; gap: 10px; }
+.shortcut-hints > div { display: grid; grid-template-columns: minmax(52px, auto) 1fr; align-items: center; gap: 10px; }
 .shortcut-hints kbd { min-width: 52px; padding: 5px 7px; border: 1px solid rgba(255,255,255,.14); border-radius: 7px; color: white; background: rgba(255,255,255,.1); font: 800 11px var(--font-mono); text-align: center; }
 .shortcut-hints span { color: rgba(255,255,255,.66); font-size: 11px; font-weight: 750; }
+.shortcut-hints__more { pointer-events: auto; max-width: min(440px, 70vw); max-height: 45vh; overflow-y: auto; }
+.shortcut-hints__more summary { cursor: pointer; padding: 5px 0; font-size: 11px; font-weight: 750; }
+.shortcut-reference { margin: 0; display: grid; gap: 10px; font-size: 12px; }
+.shortcut-reference > div { display: grid; grid-template-columns: minmax(100px, 1fr) 2fr; align-items: center; gap: 12px; }
+.shortcut-reference dt, .shortcut-reference dd { margin: 0; }
+.shortcut-reference kbd { font: 700 11px var(--font-mono); overflow-wrap: anywhere; }
+.shortcut-hints .shortcut-reference { padding-top: 8px; font-size: 11px; }
+.shortcut-hints .shortcut-reference kbd { display: block; }
 .canvas-minimap { width: 190px; height: 122px; padding: 8px; overflow: hidden; border: 1px solid rgba(255,255,255,.12); border-radius: 12px; outline: 0; color: white; background: rgba(40,41,52,.92); box-shadow: var(--shadow-sm); cursor: crosshair; pointer-events: auto; touch-action: none; }
 .canvas-minimap[data-interaction-mode="drag"] { cursor: grab; }
 .canvas-minimap[data-interaction-mode="drag"]:active { cursor: grabbing; }
@@ -363,6 +373,7 @@ button { border: 0; }
 .sticky-note-card__close:hover, .sticky-note-card__close:focus-visible { color: white; background: var(--danger); }
 .sticky-note-card__editor { width: 100%; height: calc(100% - 3.15em); padding: 1em; resize: none; border: 0; outline: 0; color: var(--text-dark); background: transparent; font: 700 1em/1.5 "Trebuchet MS", "Segoe UI", sans-serif; user-select: text; }
 .sticky-note-card__editor::placeholder { color: color-mix(in srgb, var(--text-dark) 58%, transparent); }
+.sticky-note-card__editor { scrollbar-width: thin; scrollbar-color: color-mix(in srgb, color-mix(in srgb, var(--yellow) 65%, var(--text-dark)) 60%, transparent) transparent; }
 .home-editor-toolbar { position: absolute; left: 50%; top: 18px; z-index: 500; min-height: 48px; padding: 5px 6px 5px 15px; display: flex; align-items: center; gap: 8px; border-radius: 14px; color: white; background: rgba(40,41,52,.96); box-shadow: var(--shadow-md); transform: translateX(-50%); }
 .home-editor-toolbar strong { margin-right: 6px; font-size: 12px; }
 .home-editor-toolbar button { min-height: 36px; padding: 7px 12px; border-radius: 9px; color: white; background: rgba(255,255,255,.1); cursor: pointer; font-size: 11px; font-weight: 850; }
diff --git a/src/shared/contracts.ts b/src/shared/contracts.ts
index cbafab34..3e6cc7af 100644
--- a/src/shared/contracts.ts
+++ b/src/shared/contracts.ts
@@ -28,7 +28,7 @@ export type CanvasOverlayPlacement = "top-left" | "top-right" | "bottom-left" |
 export type MinimapInteractionMode = "click" | "drag";
 export type BrowserViewportSurface = "native" | "placeholder" | "hidden";
 export type FocusActivation = "off" | "single" | "double";
-export type ShortcutAction = "home" | "renameWindow";
+export type ShortcutAction = "home" | "renameWindow" | "toggleFullscreen";
 export type RadialLauncherActionId = "note" | "browser" | "settings";
 export type RadialLauncherItemId = ProviderId | RadialLauncherActionId;
 
@@ -143,11 +143,13 @@ export const DEFAULT_HOME_LAYOUT: HomeWidgetPlacement[] = [
 export interface ShortcutBindings {
   home: string;
   renameWindow: string;
+  toggleFullscreen: string;
 }
 
 export const DEFAULT_SHORTCUTS: ShortcutBindings = {
   home: "Home",
-  renameWindow: "F2"
+  renameWindow: "F2",
+  toggleFullscreen: "Meta+F"
 };
 
 export const INITIAL_TERMINAL_COLS = 80;
diff --git a/tests/settings-normalizer.test.mjs b/tests/settings-normalizer.test.mjs
index 8f0fe12c..987f7d56 100644
--- a/tests/settings-normalizer.test.mjs
+++ b/tests/settings-normalizer.test.mjs
@@ -52,7 +52,7 @@ const fallback = {
   minimapInteractionMode: "click",
   shortcutHintsPlacement: "bottom-right",
   canvasControlsPlacement: "bottom-left",
-  shortcuts: { home: "Home", renameWindow: "F2" },
+  shortcuts: { home: "Home", renameWindow: "F2", toggleFullscreen: "Meta+F" },
   mediaPath: null,
   mediaFit: "cover",
   lastDirectory: "/",
@@ -579,7 +579,7 @@ test("fresh installs default to scroll pan and key-gated widget wheel input", as
     assert.equal(store.get().browserRestoreTabs, true);
     assert.equal(store.get().persistCanvasRegions, true);
     assert.equal(store.get().persistStickyNotes, true);
-    assert.deepEqual(store.get().shortcuts, { home: "Home", renameWindow: "F2" });
+    assert.deepEqual(store.get().shortcuts, { home: "Home", renameWindow: "F2", toggleFullscreen: "Meta+F" });
     const persisted = JSON.parse(await readFile(join(dir, "settings.json"), "utf8"));
     assert.equal(Object.hasOwn(persisted, "zoomOverApplications"), false);
   } finally {
@@ -742,7 +742,7 @@ test("invalid explicit key mode fails closed without replacing action shortcuts"
   }, fallback, "darwin");
   assert.equal(normalized.canvasWheelCaptureMode, "off");
   assert.equal(normalized.canvasWheelOverride, null);
-  assert.deepEqual(normalized.shortcuts, { home: "Meta+Space", renameWindow: "F2" });
+  assert.deepEqual(normalized.shortcuts, { home: "Meta+Space", renameWindow: "F2", toggleFullscreen: "Meta+F" });
 });
 
 test("mode changes persist the compatible legacy boolean and preserve the hidden binding", async () => {
@@ -830,14 +830,20 @@ test("valid custom shortcuts survive normalization", () => {
   }, fallback);
   assert.equal(normalized.focusActivation, "double");
   assert.equal(normalized.showShortcutHints, false);
-  assert.deepEqual(normalized.shortcuts, { home: "Ctrl+H", renameWindow: "Ctrl+Shift+R" });
+  assert.deepEqual(normalized.shortcuts, { home: "Ctrl+H", renameWindow: "Ctrl+Shift+R", toggleFullscreen: "Meta+F" });
+});
+
+test("fullscreen shortcuts migrate, retain custom bindings and reject conflicts", () => {
+  assert.equal(normalizeSettings({ shortcuts: { home: "Home", renameWindow: "F2" } }, fallback).shortcuts.toggleFullscreen, "Meta+F");
+  assert.equal(normalizeSettings({ shortcuts: { toggleFullscreen: "Ctrl+Shift+F" } }, fallback).shortcuts.toggleFullscreen, "Ctrl+Shift+F");
+  assert.deepEqual(normalizeSettings({ shortcuts: { toggleFullscreen: "F2" } }, fallback).shortcuts, fallback.shortcuts);
 });
 
 test("mouse buttons survive action shortcut normalization", () => {
   const normalized = normalizeSettings({
     shortcuts: { home: "Mouse4", renameWindow: "Ctrl+Mouse5" }
   }, fallback);
-  assert.deepEqual(normalized.shortcuts, { home: "Mouse4", renameWindow: "Ctrl+Mouse5" });
+  assert.deepEqual(normalized.shortcuts, { home: "Mouse4", renameWindow: "Ctrl+Mouse5", toggleFullscreen: "Meta+F" });
 });
 
 test("normalizes canvas overlay positions independently", () => {
@@ -882,7 +888,7 @@ test("normalization preserves action shortcuts and allows modifier-only navigati
     shortcuts: { home: "Alt+H", renameWindow: "F2" },
     canvasNavigationOverride: "Alt"
   }, fallback, "darwin");
-  assert.deepEqual(conflict.shortcuts, { home: "Alt+H", renameWindow: "F2" });
+  assert.deepEqual(conflict.shortcuts, { home: "Alt+H", renameWindow: "F2", toggleFullscreen: "Meta+F" });
   assert.equal(conflict.canvasNavigationOverride, "Alt");
 
   const reserved = normalizeSettings({ canvasNavigationOverride: "Meta" }, fallback, "darwin");
@@ -892,7 +898,7 @@ test("normalization preserves action shortcuts and allows modifier-only navigati
   const migratedConflict = normalizeSettings({
     shortcuts: { home: "Alt+H", renameWindow: "F2" }
   }, fallback, "darwin");
-  assert.deepEqual(migratedConflict.shortcuts, { home: "Alt+H", renameWindow: "F2" });
+  assert.deepEqual(migratedConflict.shortcuts, { home: "Alt+H", renameWindow: "F2", toggleFullscreen: "Meta+F" });
   assert.equal(migratedConflict.canvasNavigationOverride, "Alt");
 });
 

From cce4f8f8ab75a9e87dd647ff9eff6bbb212e3208 Mon Sep 17 00:00:00 2001
From: howdeploy <howdeploy@proton.me>
Date: Sat, 26 Sep 2026 13:40:49 +0300
Subject: [PATCH 10/10] test: account for explicit DEV build labeling

---
 tests/titlebar-layout.test.mjs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/titlebar-layout.test.mjs b/tests/titlebar-layout.test.mjs
index 1845b7b9..32bf4c81 100644
--- a/tests/titlebar-layout.test.mjs
+++ b/tests/titlebar-layout.test.mjs
@@ -22,7 +22,7 @@ test("viewport-bound overlays and camera sizing share the titlebar boundary", as
   assert.match(startupPage, /--titlebar-height: \$\{titlebarHeight\}px;/);
   assert.match(startupPage, /grid-template-rows: var\(--titlebar-height\) 1fr;/);
   assert.match(titleBar, /import appManifest from "\.\.\/\.\.\/\.\.\/\.\.\/package\.json";/);
-  assert.match(titleBar, /import\.meta\.env\.DEV \? "DEV" : "RELEASE"/);
+  assert.match(titleBar, /import\.meta\.env\.DEV \|\| import\.meta\.env\.VITE_BUILD_CHANNEL === "DEV" \? "DEV" : "RELEASE"/);
   assert.match(titleBar, /`\$\{BUILD_CHANNEL\} v\$\{appManifest\.version\}`/);
   assert.match(styles, /\.titlebar__build--dev \{/);
   assert.match(styles, /\.titlebar__build--release \{/);