@aliceshimada/mica 1.1.0 → 1.2.0

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 1.2.0 - 2026-06-16
+
+- Add `mma_create_notebook` tool: create a new blank notebook in the Wolfram FrontEnd.
+- Add `mma_open_notebook` tool: open an existing notebook file (.nb) from disk.
+- Add `CreateNotebook` and `OpenNotebook` permissions (default false).
+- Fix agent-level tools when no live notebook exists for routing.
+
+## 1.1.1 - 2026-06-16
+
+- Fix `RestartKernelRequest`: kill kernel via `Quit[]` before restarting.
+- Fix `realpathSync` crash when `process.argv[1]` doesn't resolve.
+- Fix `$BridgeNotebookPermissions` memory leak: prune on notebook close.
+
 ## 1.1.0 - 2026-06-09
 
 - Add `mma_kill_kernel` tool: quit a notebook's Wolfram kernel (control agent kernel is protected).

package/dist/src/bun/httpServer.js

@@ -3,7 +3,7 @@ import http from "node:http";
 import { executeBackendMcpTool } from "../mcp/backendTools.js";
 import { renderDashboard } from "./dashboard.js";
 const JSON_BODY_LIMIT_BYTES = 1024 * 1024;
-const DEFAULT_VERSION = "1.1.0";
+const DEFAULT_VERSION = "1.2.0";
 export async function createBunHttpApp({ state, host = "127.0.0.1", port, authToken, version = DEFAULT_VERSION }) {
     const runtimeInfo = {
         host,
@@ -338,7 +338,7 @@ function readPermissions(value) {
     if (typeof value !== "object" || value === null || Array.isArray(value))
         throw new Error("BAD_REQUEST");
     const record = value;
-    const keys = ["ReadNotebook", "InsertCell", "ModifyCell", "DeleteCell", "RunCell", "SaveNotebook"];
+    const keys = ["ReadNotebook", "InsertCell", "ModifyCell", "DeleteCell", "RunCell", "SaveNotebook", "CreateNotebook", "OpenNotebook"];
     const permissions = {};
     for (const key of keys) {
         if (typeof record[key] !== "boolean")

package/dist/src/bun/index.js

@@ -8,7 +8,7 @@ import { loadRuntimeConfig } from "../runtime/config.js";
 import { writeSessionFile } from "../runtime/session.js";
 import { createBunHttpApp } from "./httpServer.js";
 const MCP_SERVER_NAME = "mica-bun";
-const MICA_PACKAGE_VERSION = "1.1.0";
+const MICA_PACKAGE_VERSION = "1.2.0";
 export async function startBunRuntime(deps = {}) {
     const config = deps.runtimeConfig ?? loadRuntimeConfig();
     const bridgeOnly = deps.bridgeOnly ?? config.bridgeOnly;

package/dist/src/cli/index.js

@@ -223,13 +223,18 @@ async function main() {
     process.exitCode = exitCode;
 }
 if (process.argv[1]) {
-    const scriptReal = realpathSync(fileURLToPath(import.meta.url));
-    const argReal = realpathSync(process.argv[1]);
-    if (scriptReal === argReal) {
-        main().catch((error) => {
-            const message = error instanceof Error ? error.stack ?? error.message : String(error);
-            process.stderr.write(`${message}\n`);
-            process.exitCode = 1;
-        });
+    try {
+        const scriptReal = realpathSync(fileURLToPath(import.meta.url));
+        const argReal = realpathSync(process.argv[1]);
+        if (scriptReal === argReal) {
+            main().catch((error) => {
+                const message = error instanceof Error ? error.stack ?? error.message : String(error);
+                process.stderr.write(`${message}\n`);
+                process.exitCode = 1;
+            });
+        }
+    }
+    catch {
+        // process.argv[1] may not resolve (e.g. node -e, shebang edge cases)
     }
 }

package/dist/src/mcp/backendTools.js

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { DEFAULT_TIMEOUTS_MS } from "../backend/protocol.js";
-import { abortEvaluationSchema, deleteCellSchema, getCellOutputSchema, insertCellSchema, killKernelSchema, listCellsSchema, modifyCellSchema, noArgsSchema, readArtifactSchema, readCellSchema, restartKernelSchema, runCellSchema, selectNotebookSchema, saveNotebookSchema, symbolLookupSchema, } from "./toolSchemas.js";
+import { abortEvaluationSchema, createNotebookSchema, deleteCellSchema, getCellOutputSchema, insertCellSchema, killKernelSchema, listCellsSchema, modifyCellSchema, noArgsSchema, openNotebookSchema, readArtifactSchema, readCellSchema, restartKernelSchema, runCellSchema, selectNotebookSchema, saveNotebookSchema, symbolLookupSchema, } from "./toolSchemas.js";
 import { INSERT_ANCHOR_GUIDANCE, notebookToolDescription } from "./descriptions.js";
 import { toolFailure, toolSuccess, withToolErrors } from "./toolResults.js";
 function assertLiveAgent(state) {
@@ -196,6 +196,16 @@ export const MICA_BACKEND_TOOL_DEFINITIONS = [
         description: notebookToolDescription("Select the active Mathematica notebook in the backend registry."),
         schema: selectNotebookSchema.shape,
     },
+    {
+        name: "mma_create_notebook",
+        description: notebookToolDescription("Create a new blank notebook in the Wolfram FrontEnd with the given window title."),
+        schema: createNotebookSchema.shape,
+    },
+    {
+        name: "mma_open_notebook",
+        description: notebookToolDescription("Open an existing notebook file (.nb) from disk in the Wolfram FrontEnd."),
+        schema: openNotebookSchema.shape,
+    },
     ...queuedNotebookTools.map((config) => ({
         name: config.name,
         description: notebookToolDescription(config.summary, config.extraGuidance),
@@ -231,6 +241,28 @@ export async function executeBackendMcpTool(state, tool, args = {}, extra) {
             return toolSuccess({ activeNotebookId: state.activeNotebookId, notebook: target.notebook });
         });
     }
+    // Agent-level tools: route to any live agent without requiring a notebook target
+    if (tool === "mma_create_notebook" || tool === "mma_open_notebook") {
+        return withToolErrors({ tool, args: recordArgs }, () => {
+            sweepStateLiveness(state);
+            const live = state.agents.list().find((a) => !a.offline && !a.retired);
+            if (!live)
+                throw new Error("NO_LIVE_AGENT");
+            const notebook = state.notebooks.listLive().find((n) => n.agentSessionId === live.agentSessionId);
+            const targetNotebookId = notebook?.notebookId ?? `__agent__${live.agentSessionId}`;
+            const requestId = randomUUID();
+            state.queue.enqueue({
+                requestId,
+                tool,
+                arguments: recordArgs,
+                targetNotebookId,
+                agentSessionId: live.agentSessionId,
+                timeoutMs: DEFAULT_TIMEOUTS_MS.mutation,
+                createdAt: Date.now(),
+            });
+            return toolSuccess({ status: "queued", requestId });
+        });
+    }
     const queuedConfig = queuedNotebookTools.find((config) => config.name === tool);
     if (!queuedConfig) {
         return toolFailure(new Error(`UNKNOWN_TOOL: ${tool}`), { tool, args: recordArgs });

package/dist/src/mcp/prompts.js

@@ -14,6 +14,8 @@ const TOOL_GUIDE = [
     ["mma_abort_evaluation", "Abort a running notebook evaluation."],
     ["mma_kill_kernel", "Quit the Wolfram kernel for a notebook (control agent kernel is protected)."],
     ["mma_restart_kernel", "Restart the Wolfram kernel for a notebook so it can evaluate cells again."],
+    ["mma_create_notebook", "Create a new blank notebook in the Wolfram FrontEnd."],
+    ["mma_open_notebook", "Open an existing notebook file (.nb) from disk in the Wolfram FrontEnd."],
     ["mma_get_cell_output", "Read output and messages produced by one cell; this may refresh completed run status."],
     ["mma_read_artifact", "Read large output or message artifacts by byte page; ids may become stale after notebook edits or reruns."],
     ["mma_save_notebook", "Save the selected notebook when SaveNotebook permission is granted."],
@@ -35,7 +37,7 @@ export const MICA_AGENT_INSTRUCTIONS = [
     "Tools:",
     ...TOOL_GUIDE.map(([name, description]) => `- ${name}: ${description}`),
 ].join("\n");
-export function createMicaMcpServer(name, version = "1.1.0") {
+export function createMicaMcpServer(name, version = "1.2.0") {
     return new McpServer({ name, version }, { instructions: MICA_AGENT_INSTRUCTIONS });
 }
 export function registerMicaPrompts(server) {

package/dist/src/mcp/toolSchemas.js

@@ -44,6 +44,12 @@ export const killKernelSchema = z.object({
 export const restartKernelSchema = z.object({
     ...notebookSelectorFields
 }).strict();
+export const createNotebookSchema = z.object({
+    title: z.string().min(1).describe("Window title for the new notebook")
+}).strict();
+export const openNotebookSchema = z.object({
+    path: z.string().min(1).describe("Absolute path to an existing .nb file")
+}).strict();
 export const getCellOutputSchema = z.object({
     ...notebookSelectorFields,
     cellId: z.string().min(1),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aliceshimada/mica",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Local MCP bridge for controlling live Wolfram Desktop / Mathematica notebooks.",
   "type": "module",
   "repository": {

package/paclet/Kernel/MMAAgentBridge.wl

@@ -1,3 +1,5 @@
+(* ::Package:: *)
+
 BeginPackage["MMAAgentBridge`"];
 
 StartMMAAgentPalette::usage = "StartMMAAgentPalette[] opens the MMA Agent Bridge palette.";
@@ -15,10 +17,10 @@ PollCancellations::usage = "PollCancellations[] polls palette-originated cancell
 
 Begin["`Private`"];
 
-$DefaultBridgeBaseURL = "http://127.0.0.1:19791";
-$BridgeBaseURL = $DefaultBridgeBaseURL;
-$BridgeAuthToken = None;
-$BridgeSessionFile = Automatic;
+$DefaultBridgeBaseURL = "http://127.0.0.1:19791";
+$BridgeBaseURL = $DefaultBridgeBaseURL;
+$BridgeAuthToken = None;
+$BridgeSessionFile = Automatic;
 $BridgeNotebooks = <||>;
 $ActiveNotebookId = None;
 $PaletteId = CreateUUID["palette-"];
@@ -33,24 +35,24 @@ $RunningNotebookId = None;
 $RunningNotebookObject = None;
 $RunningCellObject = None;
 $RunningCellOriginalEpilogRule = HoldComplete[CellEpilog -> Inherited];
-$RunningCellRestoreEpilogRule = HoldComplete[CellEpilog -> Inherited];
-$RunningStartedAt = None;
-$RunningStatus = None;
-$RunningStatusGraceSeconds = 2.0;
-$RunningTimeoutAt = None;
-$AbortRequestedAt = None;
-(* Reserved for future late-result surfacing; backend queue already rejects late timeout/cancel results. *)
-$LastLateResult = None;
-$LastRunStatusCellId = None;
+$RunningCellRestoreEpilogRule = HoldComplete[CellEpilog -> Inherited];
+$RunningStartedAt = None;
+$RunningStatus = None;
+$RunningStatusGraceSeconds = 2.0;
+$RunningTimeoutAt = None;
+$AbortRequestedAt = None;
+(* Reserved for future late-result surfacing; backend queue already rejects late timeout/cancel results. *)
+$LastLateResult = None;
+$LastRunStatusCellId = None;
 $LastRunStatusNotebookId = None;
 $LastRunStatus = None;
 $LastStatus = <||>;
-$LastError = None;
-$PollingInProgress = False;
-$MaxArtifactScanCells = 20;
-$DefaultMaxCellPayloadBytes = 262144;
-$MaxCellPayloadBytes = 1024 * 1024;
-$BridgeHTTPTimeoutSeconds = 30;
+$LastError = None;
+$PollingInProgress = False;
+$MaxArtifactScanCells = 20;
+$DefaultMaxCellPayloadBytes = 262144;
+$MaxCellPayloadBytes = 1024 * 1024;
+$BridgeHTTPTimeoutSeconds = 30;
 $BridgeHTTPRetryCount = 3;
 $BridgeHTTPRetryDelaySeconds = 0.25;
 $BridgeInbox = {};
@@ -68,43 +70,43 @@ $MMAAgentBridgeSourceFile = If[StringQ[$InputFileName] && StringLength[$InputFil
 $ControlAgentNotebook = None;
 $ControlAgentEvaluatorName = "MMAAgentControl";
 
-UnixTimeMilliseconds[] := Round[1000 UnixTime[]];
-
-NonEmptyStringQ[value_] := StringQ[value] && StringLength[value] > 0;
-
-EnvironmentValue[name_String] := Module[{value},
-  value = Quiet @ Check[Environment[name], ""];
-  If[NonEmptyStringQ[value], value, ""]
-];
-
-DefaultBridgeSessionFile[] := Module[{override, home},
-  override = EnvironmentValue["MICA_SESSION_FILE"];
-  If[NonEmptyStringQ[override], Return[override]];
-  home = EnvironmentValue["HOME"];
-  If[!NonEmptyStringQ[home], home = EnvironmentValue["USERPROFILE"]];
-  If[!NonEmptyStringQ[home], home = Directory[]];
-  FileNameJoin[{home, ".mica", "session.json"}]
-];
-
-If[$BridgeSessionFile === Automatic, $BridgeSessionFile = DefaultBridgeSessionFile[]];
-
-LoadBridgeSession[] := Module[{sessionFile = $BridgeSessionFile, payload},
-  If[!StringQ[sessionFile] || !FileExistsQ[sessionFile], Return[<||>]];
-  payload = Quiet @ Check[Import[sessionFile, "RawJSON"], $Failed];
-  If[AssociationQ[payload], payload, <||>]
-];
-
-ConfigureBridgeFromSession[] := Module[{session, baseUrl, token},
-  session = LoadBridgeSession[];
-  baseUrl = Lookup[session, "baseUrl", None];
-  If[NonEmptyStringQ[baseUrl],
-    $BridgeBaseURL = baseUrl,
-    $BridgeBaseURL = $DefaultBridgeBaseURL
-  ];
-  token = Lookup[session, "authToken", None];
-  $BridgeAuthToken = If[NonEmptyStringQ[token], token, None];
-  $BridgeBaseURL
-];
+UnixTimeMilliseconds[] := Round[1000 UnixTime[]];
+
+NonEmptyStringQ[value_] := StringQ[value] && StringLength[value] > 0;
+
+EnvironmentValue[name_String] := Module[{value},
+  value = Quiet @ Check[Environment[name], ""];
+  If[NonEmptyStringQ[value], value, ""]
+];
+
+DefaultBridgeSessionFile[] := Module[{override, home},
+  override = EnvironmentValue["MICA_SESSION_FILE"];
+  If[NonEmptyStringQ[override], Return[override]];
+  home = EnvironmentValue["HOME"];
+  If[!NonEmptyStringQ[home], home = EnvironmentValue["USERPROFILE"]];
+  If[!NonEmptyStringQ[home], home = Directory[]];
+  FileNameJoin[{home, ".mica", "session.json"}]
+];
+
+If[$BridgeSessionFile === Automatic, $BridgeSessionFile = DefaultBridgeSessionFile[]];
+
+LoadBridgeSession[] := Module[{sessionFile = $BridgeSessionFile, payload},
+  If[!StringQ[sessionFile] || !FileExistsQ[sessionFile], Return[<||>]];
+  payload = Quiet @ Check[Import[sessionFile, "RawJSON"], $Failed];
+  If[AssociationQ[payload], payload, <||>]
+];
+
+ConfigureBridgeFromSession[] := Module[{session, baseUrl, token},
+  session = LoadBridgeSession[];
+  baseUrl = Lookup[session, "baseUrl", None];
+  If[NonEmptyStringQ[baseUrl],
+    $BridgeBaseURL = baseUrl,
+    $BridgeBaseURL = $DefaultBridgeBaseURL
+  ];
+  token = Lookup[session, "authToken", None];
+  $BridgeAuthToken = If[NonEmptyStringQ[token], token, None];
+  $BridgeBaseURL
+];
 
 (* $BridgePermissions replaces the plan's $Permissions name because *)
 (* $Permissions is a protected Wolfram built-in symbol (Set::wrsym). *)
@@ -115,18 +117,40 @@ $DefaultBridgePermissions = <|
   "ModifyCell" -> False,
   "DeleteCell" -> False,
   "RunCell" -> False,
-  "SaveNotebook" -> False
-|>;
+  "SaveNotebook" -> False,
+  "CreateNotebook" -> False,
+  "OpenNotebook" -> False
+|>;
 
 If[!AssociationQ[Quiet @ Check[$BridgePermissions, None]],
   $BridgePermissions = $DefaultBridgePermissions
 ];
 
-PalettePermissionRow[label_String, key_String] := Row[{
-  Checkbox[Dynamic[$BridgePermissions[key], ($BridgePermissions[key] = #; Quiet @ Check[PostPermissions[], Null]) &]],
-  Spacer[8],
-  Style[label, 11]
-}];
+If[!AssociationQ[Quiet @ Check[$BridgeNotebookPermissions, None]],
+  $BridgeNotebookPermissions = <||>
+];
+
+NotebookPermissions[notebookId_String] := Lookup[$BridgeNotebookPermissions, notebookId, $DefaultBridgePermissions];
+
+SetNotebookPermissions[notebookId_String, perms_Association] := (
+  $BridgeNotebookPermissions[notebookId] = perms
+);
+
+PalettePermissionRow[label_String, key_String, notebookId_:None] := Module[{perms, setter},
+  perms = If[StringQ[notebookId] && StringLength[notebookId] > 0,
+    NotebookPermissions[notebookId],
+    $BridgePermissions
+  ];
+  setter = If[StringQ[notebookId] && StringLength[notebookId] > 0,
+    Function[val, SetNotebookPermissions[notebookId, Join[perms, <|key -> val|>]]],
+    Function[val, $BridgePermissions[key] = val; Quiet @ Check[PostPermissions[], Null]]
+  ];
+  Row[{
+    Checkbox[Dynamic[perms[key], (setter[#]) &]],
+    Spacer[8],
+    Style[label, 11]
+  }]
+];
 
 PaletteStatusSummary[] := Module[{server, paletteConnected, notebookAttached, pendingRequests, attachedNotebook, error},
   server = Lookup[$LastStatus, "server", "unknown"];
@@ -181,7 +205,7 @@ NotebookDisplayName[record_Association] := Module[{info, title, path, notebookId
   path = StringTrim[ToString[Lookup[info, "notebookPath", ""]]];
   If[title === "" && path === "",
     If[StringQ[notebookId] && StringLength[notebookId] > 0, notebookId, "Untitled notebook"],
-    If[path === "", title, title <> " — " <> FileNameTake[path]]
+    If[path === "", title, title <> " \[LongDash] " <> FileNameTake[path]]
   ]
 ];
 
@@ -291,7 +315,7 @@ RuntimeStatusCard[] := Module[{paletteConnected, transportMode, executorState, p
         Style["Running request: ", Bold],
         ToString[Lookup[runningRequest, "tool", "request"]],
         If[StringQ[Lookup[runningRequest, "requestId", ""]], " (" <> Lookup[runningRequest, "requestId", ""] <> ")", Nothing],
-        If[NumberQ[elapsedSeconds], " • " <> ToString[elapsedSeconds] <> "s", Nothing]
+        If[NumberQ[elapsedSeconds], " \[Bullet] " <> ToString[elapsedSeconds] <> "s", Nothing]
       },
       Nothing
     ]],
@@ -332,14 +356,16 @@ PermissionsPanel[] := Panel[
   Column[
     {
       Style["Permissions", Bold],
-      Grid[
+      Dynamic @ Grid[
         {
-          {PalettePermissionRow["Read notebook", "ReadNotebook"]},
-          {PalettePermissionRow["Insert cell", "InsertCell"]},
-          {PalettePermissionRow["Modify cell", "ModifyCell"]},
-          {PalettePermissionRow["Delete cell", "DeleteCell"]},
-          {PalettePermissionRow["Run cell", "RunCell"]},
-          {PalettePermissionRow["Save notebook", "SaveNotebook"]}
+          {PalettePermissionRow["Read notebook", "ReadNotebook", $ActiveNotebookId]},
+          {PalettePermissionRow["Insert cell", "InsertCell", $ActiveNotebookId]},
+          {PalettePermissionRow["Modify cell", "ModifyCell", $ActiveNotebookId]},
+          {PalettePermissionRow["Delete cell", "DeleteCell", $ActiveNotebookId]},
+          {PalettePermissionRow["Run cell", "RunCell", $ActiveNotebookId]},
+          {PalettePermissionRow["Save notebook", "SaveNotebook", $ActiveNotebookId]},
+          {PalettePermissionRow["Create notebook", "CreateNotebook", $ActiveNotebookId]},
+          {PalettePermissionRow["Open notebook", "OpenNotebook", $ActiveNotebookId]}
         },
         Alignment -> Left,
         Spacings -> {1, 0.35}
@@ -499,14 +525,14 @@ PaletteView[] := DynamicModule[{},
   ]
 ];
 
-(* Re-read the small session file before each request so Wolfram follows MCP restarts and dynamic ports. *)
-BridgeURL[path_String] := ConfigureBridgeFromSession[] <> path;
-
-BridgeHeaders[] := If[
-  StringQ[$BridgeAuthToken] && StringLength[$BridgeAuthToken] > 0,
-  {"Authorization" -> "Bearer " <> $BridgeAuthToken},
-  {}
-];
+(* Re-read the small session file before each request so Wolfram follows MCP restarts and dynamic ports. *)
+BridgeURL[path_String] := ConfigureBridgeFromSession[] <> path;
+
+BridgeHeaders[] := If[
+  StringQ[$BridgeAuthToken] && StringLength[$BridgeAuthToken] > 0,
+  {"Authorization" -> "Bearer " <> $BridgeAuthToken},
+  {}
+];
 
 URLComponentEncodeString[None] := "";
 URLComponentEncodeString[value_] := StringReplace[
@@ -564,8 +590,8 @@ JsonByteArrayToPayload[body_ByteArray] := Module[{text},
   Quiet @ Check[ImportString[text, "RawJSON"], $Failed]
 ];
 
-BridgeGet[path_String] := Module[{response},
-  response = BridgeRequestWithRetries[HTTPRequest[BridgeURL[path], <|"Method" -> "GET", "Headers" -> BridgeHeaders[]|>]];
+BridgeGet[path_String] := Module[{response},
+  response = BridgeRequestWithRetries[HTTPRequest[BridgeURL[path], <|"Method" -> "GET", "Headers" -> BridgeHeaders[]|>]];
   If[response === $Failed, Return[$Failed]];
   JsonByteArrayToPayload[response["BodyByteArray"]]
 ];
@@ -575,9 +601,9 @@ BridgePost[path_String, payload_Association] := Module[{response},
     HTTPRequest[
       BridgeURL[path],
       <|
-        "Method" -> "POST",
-        "Headers" -> BridgeHeaders[],
-        "ContentType" -> "application/json; charset=utf-8",
+        "Method" -> "POST",
+        "Headers" -> BridgeHeaders[],
+        "ContentType" -> "application/json; charset=utf-8",
         "Body" -> PayloadToJsonBytes[payload]
       |>
     ]
@@ -590,10 +616,16 @@ PostPermissions[] := Module[{payload = <|"permissions" -> $BridgePermissions|>},
   Quiet @ Check[BridgePost["/permissions", payload], $Failed]
 ];
 
-NeedsConfirmationQ[action_String] := Not @ TrueQ[$BridgePermissions[action]];
+NeedsConfirmationQ[action_String, notebookId_:None] := Module[{perms},
+  perms = If[StringQ[notebookId] && StringLength[notebookId] > 0,
+    NotebookPermissions[notebookId],
+    $BridgePermissions
+  ];
+  Not @ TrueQ[perms[action]]
+];
 
-ConfirmAction[action_String, message_String] := If[
-  NeedsConfirmationQ[action],
+ConfirmAction[action_String, message_String, notebookId_:None] := If[
+  NeedsConfirmationQ[action, notebookId],
   ChoiceDialog[message, {"Allow" -> True, "Deny" -> False}],
   True
 ];
@@ -606,8 +638,8 @@ FailedRequestCode[failure_Failure] := Module[{code = failure[[1]]},
 
 FailedRequestMessage[failure_Failure] := Lookup[failure[[2]], "Message", Lookup[failure[[2]], "message", "The Wolfram bridge rejected the request."]];
 
-RequireReadPermission[] := If[
-  Not @ ConfirmAction["ReadNotebook", "AI requests reading the notebook. Allow?"],
+RequireReadPermission[notebookId_:None] := If[
+  Not @ ConfirmAction["ReadNotebook", "AI requests reading the notebook. Allow?", notebookId],
   $Canceled,
   True
 ];
@@ -628,7 +660,7 @@ NotebookInfo[nb_NotebookObject, notebookId_String] := <|
   "wolframVersion" -> ToString @ $VersionNumber,
   "platform" -> $OperatingSystem,
   "paletteId" -> $PaletteId,
-  "permissions" -> $BridgePermissions
+  "permissions" -> NotebookPermissions[notebookId]
 |>;
 
 NotebookRecord[notebookId_String] := Lookup[$BridgeNotebooks, notebookId, <||>];
@@ -799,141 +831,141 @@ CellPayload[cell_CellObject, id_String, index_Integer] := <|
   "tags" -> CellTagsList[cell]
 |>;
 
-CellGeneratedBoundaryQ[style_String] := MemberQ[{"Input", "Code", "Text", "Section", "Subsection", "Subsubsection", "Title", "Chapter"}, style];
-
-CellArtifactStyleQ[style_String] := MemberQ[{"Output", "Print", "Message"}, style];
-
-CellPayloadMaxBytes[args_Association] := Module[{value = Lookup[args, "maxBytes", $DefaultMaxCellPayloadBytes]},
-  If[IntegerQ[value] && value > 0 && value <= $MaxCellPayloadBytes, value, $DefaultMaxCellPayloadBytes]
-];
-
-Utf8LeadByteLength[byte_Integer] := Which[
-  byte < 128, 1,
-  byte < 224, 2,
-  byte < 240, 3,
-  byte < 248, 4,
-  True, 1
-];
-
-Utf8PrefixByteLength[bytes_List, maxBytes_Integer] := Module[{safeLength = Min[maxBytes, Length[bytes]], start, lead, expected},
-  If[safeLength <= 0, Return[0]];
-  start = safeLength;
-  While[start > 1 && bytes[[start]] >= 128 && bytes[[start]] <= 191, start--];
-  lead = bytes[[start]];
-  expected = Utf8LeadByteLength[lead];
-  If[safeLength - start + 1 >= expected, safeLength, Max[0, start - 1]]
-];
-
-TruncateStringToUtf8Bytes[text_String, maxBytes_Integer] := Module[{originalBytes, originalByteLength, safeLength, returnedText},
-  originalBytes = ToCharacterCode[text, "UTF8"];
-  originalByteLength = Length[originalBytes];
-  If[maxBytes <= 0,
-    Return[<|"value" -> "", "truncated" -> (originalByteLength > 0), "originalByteLength" -> originalByteLength, "returnedByteLength" -> 0|>]
-  ];
-  If[originalByteLength <= maxBytes,
-    Return[<|"value" -> text, "truncated" -> False, "originalByteLength" -> originalByteLength, "returnedByteLength" -> originalByteLength|>]
-  ];
-  safeLength = Utf8PrefixByteLength[originalBytes, maxBytes];
-  returnedText = If[safeLength > 0, ByteArrayToString[ByteArray[Take[originalBytes, safeLength]], "UTF8"], ""];
-  <|"value" -> returnedText, "truncated" -> True, "originalByteLength" -> originalByteLength, "returnedByteLength" -> safeLength|>
-];
-
-TruncatePayloadFields[content_String, outputs_List, messages_List, maxBytes_Integer, includeContentQ_] := Module[{remainingByteLength = maxBytes, totalOriginalByteLength = 0, totalReturnedByteLength = 0, anyTruncated = False, truncatedContent = "", truncatedOutputs = {}, truncatedMessages = {}, processString, output, message},
-  processString[text_String] := Module[{item = TruncateStringToUtf8Bytes[text, remainingByteLength]},
-    totalOriginalByteLength += item["originalByteLength"];
-    totalReturnedByteLength += item["returnedByteLength"];
-    anyTruncated = anyTruncated || TrueQ[item["truncated"]];
-    remainingByteLength = Max[0, remainingByteLength - item["returnedByteLength"]];
-    item["value"]
-  ];
-  If[TrueQ[includeContentQ], truncatedContent = processString[content]];
-  Do[
-    AppendTo[truncatedOutputs, processString[If[StringQ[output], output, ToString[output, InputForm]]]],
-    {output, outputs}
-  ];
-  Do[
-    AppendTo[truncatedMessages, processString[If[StringQ[message], message, ToString[message, InputForm]]]],
-    {message, messages}
-  ];
-  Join[
-    If[TrueQ[includeContentQ], <|"content" -> truncatedContent|>, <||>],
-    <|
-      "outputs" -> truncatedOutputs,
-      "messages" -> truncatedMessages,
-      "truncated" -> anyTruncated,
-      "originalByteLength" -> totalOriginalByteLength,
-      "returnedByteLength" -> totalReturnedByteLength
-    |>
-  ]
-];
-
-ArtifactId[cellId_String, kind_String, index_Integer] := cellId <> ":" <> kind <> ":" <> ToString[index];
-
-ArtifactDescriptor[cellId_String, kind_String, index_Integer, text_String, maxBytes_Integer] := Module[{byteLength, preview},
-  byteLength = Length[ToCharacterCode[text, "UTF8"]];
-  preview = TruncateStringToUtf8Bytes[text, maxBytes];
-  <|
-    "artifactId" -> ArtifactId[cellId, kind, index],
-    "type" -> kind,
-    "index" -> index,
-    "byteLength" -> byteLength,
-    "preview" -> preview["value"],
-    "previewByteLength" -> preview["returnedByteLength"],
-    "truncated" -> True
-  |>
-];
-
-ArtifactPayloadFields[cellId_String, outputs_List, messages_List, maxBytes_Integer] := Module[{remainingByteLength = maxBytes, totalOriginalByteLength = 0, totalReturnedByteLength = 0, anyTruncated = False, processedOutputs = {}, processedMessages = {}, processString, output, message},
-  processString[text_, kind_String, index_Integer] := Module[{value = If[StringQ[text], text, ToString[text, InputForm]], byteLength, descriptor},
-    byteLength = Length[ToCharacterCode[value, "UTF8"]];
-    totalOriginalByteLength += byteLength;
-    If[byteLength <= remainingByteLength,
-      totalReturnedByteLength += byteLength;
-      remainingByteLength = Max[0, remainingByteLength - byteLength];
-      value,
-      anyTruncated = True;
-      descriptor = ArtifactDescriptor[cellId, kind, index, value, remainingByteLength];
-      totalReturnedByteLength += descriptor["previewByteLength"];
-      remainingByteLength = Max[0, remainingByteLength - descriptor["previewByteLength"]];
-      descriptor
-    ]
-  ];
-  Do[
-    AppendTo[processedOutputs, processString[outputs[[i]], "output", i - 1]],
-    {i, Length[outputs]}
-  ];
-  Do[
-    AppendTo[processedMessages, processString[messages[[i]], "message", i - 1]],
-    {i, Length[messages]}
-  ];
-  <|
-    "outputs" -> processedOutputs,
-    "messages" -> processedMessages,
-    "truncated" -> anyTruncated,
-    "originalByteLength" -> totalOriginalByteLength,
-    "returnedByteLength" -> totalReturnedByteLength
-  |>
-];
-
-Utf8SliceStringToBytes[text_String, offset_Integer, limit_Integer] := Module[{bytes, originalByteLength, start, available, safeLength, sliceBytes, value},
-  bytes = ToCharacterCode[text, "UTF8"];
-  originalByteLength = Length[bytes];
-  If[limit <= 0 || offset >= originalByteLength,
-    Return[<|"value" -> "", "originalByteLength" -> originalByteLength, "returnedByteLength" -> 0, "nextOffset" -> originalByteLength|>]
-  ];
-  start = Max[1, offset + 1];
-  While[start <= originalByteLength && bytes[[start]] >= 128 && bytes[[start]] <= 191, start++];
-  available = originalByteLength - start + 1;
-  If[available <= 0,
-    Return[<|"value" -> "", "originalByteLength" -> originalByteLength, "returnedByteLength" -> 0, "nextOffset" -> originalByteLength|>]
-  ];
-  safeLength = Utf8PrefixByteLength[Take[bytes, {start, originalByteLength}], Min[limit, available]];
-  sliceBytes = If[safeLength > 0, Take[bytes, {start, start + safeLength - 1}], {}];
-  value = If[safeLength > 0, ByteArrayToString[ByteArray[sliceBytes], "UTF8"], ""];
-  <|"value" -> value, "originalByteLength" -> originalByteLength, "returnedByteLength" -> safeLength, "nextOffset" -> (start - 1 + safeLength)|>
-];
-
-CellEvaluationTaggingPath[cellId_String] := {TaggingRules, "MMAAgentBridge", "evaluations", cellId, "complete"};
+CellGeneratedBoundaryQ[style_String] := MemberQ[{"Input", "Code", "Text", "Section", "Subsection", "Subsubsection", "Title", "Chapter"}, style];
+
+CellArtifactStyleQ[style_String] := MemberQ[{"Output", "Print", "Message"}, style];
+
+CellPayloadMaxBytes[args_Association] := Module[{value = Lookup[args, "maxBytes", $DefaultMaxCellPayloadBytes]},
+  If[IntegerQ[value] && value > 0 && value <= $MaxCellPayloadBytes, value, $DefaultMaxCellPayloadBytes]
+];
+
+Utf8LeadByteLength[byte_Integer] := Which[
+  byte < 128, 1,
+  byte < 224, 2,
+  byte < 240, 3,
+  byte < 248, 4,
+  True, 1
+];
+
+Utf8PrefixByteLength[bytes_List, maxBytes_Integer] := Module[{safeLength = Min[maxBytes, Length[bytes]], start, lead, expected},
+  If[safeLength <= 0, Return[0]];
+  start = safeLength;
+  While[start > 1 && bytes[[start]] >= 128 && bytes[[start]] <= 191, start--];
+  lead = bytes[[start]];
+  expected = Utf8LeadByteLength[lead];
+  If[safeLength - start + 1 >= expected, safeLength, Max[0, start - 1]]
+];
+
+TruncateStringToUtf8Bytes[text_String, maxBytes_Integer] := Module[{originalBytes, originalByteLength, safeLength, returnedText},
+  originalBytes = ToCharacterCode[text, "UTF8"];
+  originalByteLength = Length[originalBytes];
+  If[maxBytes <= 0,
+    Return[<|"value" -> "", "truncated" -> (originalByteLength > 0), "originalByteLength" -> originalByteLength, "returnedByteLength" -> 0|>]
+  ];
+  If[originalByteLength <= maxBytes,
+    Return[<|"value" -> text, "truncated" -> False, "originalByteLength" -> originalByteLength, "returnedByteLength" -> originalByteLength|>]
+  ];
+  safeLength = Utf8PrefixByteLength[originalBytes, maxBytes];
+  returnedText = If[safeLength > 0, ByteArrayToString[ByteArray[Take[originalBytes, safeLength]], "UTF8"], ""];
+  <|"value" -> returnedText, "truncated" -> True, "originalByteLength" -> originalByteLength, "returnedByteLength" -> safeLength|>
+];
+
+TruncatePayloadFields[content_String, outputs_List, messages_List, maxBytes_Integer, includeContentQ_] := Module[{remainingByteLength = maxBytes, totalOriginalByteLength = 0, totalReturnedByteLength = 0, anyTruncated = False, truncatedContent = "", truncatedOutputs = {}, truncatedMessages = {}, processString, output, message},
+  processString[text_String] := Module[{item = TruncateStringToUtf8Bytes[text, remainingByteLength]},
+    totalOriginalByteLength += item["originalByteLength"];
+    totalReturnedByteLength += item["returnedByteLength"];
+    anyTruncated = anyTruncated || TrueQ[item["truncated"]];
+    remainingByteLength = Max[0, remainingByteLength - item["returnedByteLength"]];
+    item["value"]
+  ];
+  If[TrueQ[includeContentQ], truncatedContent = processString[content]];
+  Do[
+    AppendTo[truncatedOutputs, processString[If[StringQ[output], output, ToString[output, InputForm]]]],
+    {output, outputs}
+  ];
+  Do[
+    AppendTo[truncatedMessages, processString[If[StringQ[message], message, ToString[message, InputForm]]]],
+    {message, messages}
+  ];
+  Join[
+    If[TrueQ[includeContentQ], <|"content" -> truncatedContent|>, <||>],
+    <|
+      "outputs" -> truncatedOutputs,
+      "messages" -> truncatedMessages,
+      "truncated" -> anyTruncated,
+      "originalByteLength" -> totalOriginalByteLength,
+      "returnedByteLength" -> totalReturnedByteLength
+    |>
+  ]
+];
+
+ArtifactId[cellId_String, kind_String, index_Integer] := cellId <> ":" <> kind <> ":" <> ToString[index];
+
+ArtifactDescriptor[cellId_String, kind_String, index_Integer, text_String, maxBytes_Integer] := Module[{byteLength, preview},
+  byteLength = Length[ToCharacterCode[text, "UTF8"]];
+  preview = TruncateStringToUtf8Bytes[text, maxBytes];
+  <|
+    "artifactId" -> ArtifactId[cellId, kind, index],
+    "type" -> kind,
+    "index" -> index,
+    "byteLength" -> byteLength,
+    "preview" -> preview["value"],
+    "previewByteLength" -> preview["returnedByteLength"],
+    "truncated" -> True
+  |>
+];
+
+ArtifactPayloadFields[cellId_String, outputs_List, messages_List, maxBytes_Integer] := Module[{remainingByteLength = maxBytes, totalOriginalByteLength = 0, totalReturnedByteLength = 0, anyTruncated = False, processedOutputs = {}, processedMessages = {}, processString, output, message},
+  processString[text_, kind_String, index_Integer] := Module[{value = If[StringQ[text], text, ToString[text, InputForm]], byteLength, descriptor},
+    byteLength = Length[ToCharacterCode[value, "UTF8"]];
+    totalOriginalByteLength += byteLength;
+    If[byteLength <= remainingByteLength,
+      totalReturnedByteLength += byteLength;
+      remainingByteLength = Max[0, remainingByteLength - byteLength];
+      value,
+      anyTruncated = True;
+      descriptor = ArtifactDescriptor[cellId, kind, index, value, remainingByteLength];
+      totalReturnedByteLength += descriptor["previewByteLength"];
+      remainingByteLength = Max[0, remainingByteLength - descriptor["previewByteLength"]];
+      descriptor
+    ]
+  ];
+  Do[
+    AppendTo[processedOutputs, processString[outputs[[i]], "output", i - 1]],
+    {i, Length[outputs]}
+  ];
+  Do[
+    AppendTo[processedMessages, processString[messages[[i]], "message", i - 1]],
+    {i, Length[messages]}
+  ];
+  <|
+    "outputs" -> processedOutputs,
+    "messages" -> processedMessages,
+    "truncated" -> anyTruncated,
+    "originalByteLength" -> totalOriginalByteLength,
+    "returnedByteLength" -> totalReturnedByteLength
+  |>
+];
+
+Utf8SliceStringToBytes[text_String, offset_Integer, limit_Integer] := Module[{bytes, originalByteLength, start, available, safeLength, sliceBytes, value},
+  bytes = ToCharacterCode[text, "UTF8"];
+  originalByteLength = Length[bytes];
+  If[limit <= 0 || offset >= originalByteLength,
+    Return[<|"value" -> "", "originalByteLength" -> originalByteLength, "returnedByteLength" -> 0, "nextOffset" -> originalByteLength|>]
+  ];
+  start = Max[1, offset + 1];
+  While[start <= originalByteLength && bytes[[start]] >= 128 && bytes[[start]] <= 191, start++];
+  available = originalByteLength - start + 1;
+  If[available <= 0,
+    Return[<|"value" -> "", "originalByteLength" -> originalByteLength, "returnedByteLength" -> 0, "nextOffset" -> originalByteLength|>]
+  ];
+  safeLength = Utf8PrefixByteLength[Take[bytes, {start, originalByteLength}], Min[limit, available]];
+  sliceBytes = If[safeLength > 0, Take[bytes, {start, start + safeLength - 1}], {}];
+  value = If[safeLength > 0, ByteArrayToString[ByteArray[sliceBytes], "UTF8"], ""];
+  <|"value" -> value, "originalByteLength" -> originalByteLength, "returnedByteLength" -> safeLength, "nextOffset" -> (start - 1 + safeLength)|>
+];
+
+CellEvaluationTaggingPath[cellId_String] := {TaggingRules, "MMAAgentBridge", "evaluations", cellId, "complete"};
 
 MarkCellEvaluationComplete[cellId_String] := Quiet @ Check[
   CurrentValue[EvaluationNotebook[], CellEvaluationTaggingPath[cellId]] = True,
@@ -1011,23 +1043,23 @@ RestoreRunningCellEpilog[] := Module[{},
 ClearRunningEvaluationState[] := Module[{cellId = $RunningCellId, notebook = $RunningNotebookObject},
   RestoreRunningCellEpilog[];
   If[Head[notebook] === NotebookObject && StringQ[cellId], ClearCellEvaluationComplete[notebook, cellId]];
-  $RunningCellId = None;
-  $RunningRequestId = None;
-  $RunningNotebookId = None;
-  $RunningNotebookObject = None;
-  $RunningStartedAt = None;
-  $RunningStatus = None;
-  $AbortRequestedAt = None;
-  $RunningTimeoutAt = None
-];
-
-FinishRunningCell[status_String] := Module[{cellId = $RunningCellId, notebookId = $RunningNotebookId},
-  ClearRunningEvaluationState[];
-  $LastRunStatusCellId = cellId;
-  $LastRunStatusNotebookId = notebookId;
-  $RunningStatus = status;
-  $LastRunStatus = status
-];
+  $RunningCellId = None;
+  $RunningRequestId = None;
+  $RunningNotebookId = None;
+  $RunningNotebookObject = None;
+  $RunningStartedAt = None;
+  $RunningStatus = None;
+  $AbortRequestedAt = None;
+  $RunningTimeoutAt = None
+];
+
+FinishRunningCell[status_String] := Module[{cellId = $RunningCellId, notebookId = $RunningNotebookId},
+  ClearRunningEvaluationState[];
+  $LastRunStatusCellId = cellId;
+  $LastRunStatusNotebookId = notebookId;
+  $RunningStatus = status;
+  $LastRunStatus = status
+];
 
 CellGeneratedArtifactQ[cell_CellObject] := TrueQ[Quiet @ Check[CurrentValue[cell, GeneratedCell], False]] && CellArtifactStyleQ[CellStyleName[cell]];
 
@@ -1087,14 +1119,14 @@ CellArtifactScan[cell_CellObject, cellId_String:"", notebook_:Automatic] := Modu
       "timeout",
     StringQ[cellId] && StringQ[$LastRunStatusCellId] && cellId === $LastRunStatusCellId && StringQ[$LastRunStatusNotebookId] && NotebookIdForObject[nb] === $LastRunStatusNotebookId && $LastRunStatus === "finished",
       "finished",
-    StringQ[cellId] && StringQ[$LastRunStatusCellId] && cellId === $LastRunStatusCellId && StringQ[$LastRunStatusNotebookId] && NotebookIdForObject[nb] === $LastRunStatusNotebookId && $LastRunStatus === "aborted",
-      "aborted",
-    sameRunningCellQ && NumberQ[$AbortRequestedAt] && !evaluationCompleteQ,
-      "abort_requested",
-    sameRunningCellQ && NumberQ[$AbortRequestedAt] && evaluationCompleteQ,
-      (FinishRunningCell["aborted"]; "aborted"),
-    sameRunningCellQ && NumberQ[$RunningStartedAt] && (AbsoluteTime[] - $RunningStartedAt < $RunningStatusGraceSeconds),
-      "running",
+    StringQ[cellId] && StringQ[$LastRunStatusCellId] && cellId === $LastRunStatusCellId && StringQ[$LastRunStatusNotebookId] && NotebookIdForObject[nb] === $LastRunStatusNotebookId && $LastRunStatus === "aborted",
+      "aborted",
+    sameRunningCellQ && NumberQ[$AbortRequestedAt] && !evaluationCompleteQ,
+      "abort_requested",
+    sameRunningCellQ && NumberQ[$AbortRequestedAt] && evaluationCompleteQ,
+      (FinishRunningCell["aborted"]; "aborted"),
+    sameRunningCellQ && NumberQ[$RunningStartedAt] && (AbsoluteTime[] - $RunningStartedAt < $RunningStatusGraceSeconds),
+      "running",
     sameRunningCellQ && (evaluationCompleteQ || hasFinalOutputQ),
       (FinishRunningCell["finished"]; "finished"),
     sameRunningCellQ,
@@ -1137,86 +1169,86 @@ RefreshCellMap[notebookId_String] := Module[{record, nb, cells, idByCell, previo
   payload
 ];
 
-ReadCellById[args_Association] := Module[{notebookId, record, cellId, cell, maxBytes, payload},
-  If[RequireReadPermission[] === $Canceled, Return[$Canceled]];
-  notebookId = TargetNotebookId[args];
-  If[!StringQ[notebookId] || StringLength[notebookId] == 0, Return[Failure["BAD_REQUEST", <|"message" -> "No notebook is selected."|>]]];
-  record = NotebookRecord[notebookId];
-  If[!AssociationQ[record] || record === <||>, Return[Failure["BAD_REQUEST", <|"message" -> "No notebook is selected."|>]]];
-  cellId = Lookup[args, "cellId", ""];
-  If[StringLength[cellId] == 0, Return[Failure["BAD_REQUEST", <|"message" -> "cellId is required."|>]]];
-  cell = Lookup[Lookup[record, "cellMap", <||>], cellId, Missing["NotFound"]];
-  If[MissingQ[cell], Return[Failure["BAD_REQUEST", <|"message" -> "Requested cell was not found."|>]]];
-  maxBytes = CellPayloadMaxBytes[args];
-  With[{artifacts = CellArtifactScan[cell, cellId, Lookup[record, "notebook", None]]},
-    payload = TruncatePayloadFields[CellContentString[cell], artifacts["outputs"], artifacts["messages"], maxBytes, True];
-    Join[
-      <|"cellId" -> cellId, "style" -> CellStyleName[cell]|>,
-      payload,
-      <|"status" -> artifacts["status"]|>
-    ]
-  ]
-];
-
-GetCellOutputById[args_Association] := Module[{notebookId, record, cellId, cell, artifacts, maxBytes, payload},
-  If[RequireReadPermission[] === $Canceled, Return[$Canceled]];
-  notebookId = TargetNotebookId[args];
-  If[!StringQ[notebookId] || StringLength[notebookId] == 0, Return[Failure["BAD_REQUEST", <|"message" -> "No notebook is selected."|>]]];
-  record = NotebookRecord[notebookId];
-  If[!AssociationQ[record] || record === <||>, Return[Failure["BAD_REQUEST", <|"message" -> "No notebook is selected."|>]]];
+ReadCellById[args_Association] := Module[{notebookId, record, cellId, cell, maxBytes, payload},
+  notebookId = TargetNotebookId[args];
+  If[RequireReadPermission[notebookId] === $Canceled, Return[$Canceled]];
+  If[!StringQ[notebookId] || StringLength[notebookId] == 0, Return[Failure["BAD_REQUEST", <|"message" -> "No notebook is selected."|>]]];
+  record = NotebookRecord[notebookId];
+  If[!AssociationQ[record] || record === <||>, Return[Failure["BAD_REQUEST", <|"message" -> "No notebook is selected."|>]]];
+  cellId = Lookup[args, "cellId", ""];
+  If[StringLength[cellId] == 0, Return[Failure["BAD_REQUEST", <|"message" -> "cellId is required."|>]]];
+  cell = Lookup[Lookup[record, "cellMap", <||>], cellId, Missing["NotFound"]];
+  If[MissingQ[cell], Return[Failure["BAD_REQUEST", <|"message" -> "Requested cell was not found."|>]]];
+  maxBytes = CellPayloadMaxBytes[args];
+  With[{artifacts = CellArtifactScan[cell, cellId, Lookup[record, "notebook", None]]},
+    payload = TruncatePayloadFields[CellContentString[cell], artifacts["outputs"], artifacts["messages"], maxBytes, True];
+    Join[
+      <|"cellId" -> cellId, "style" -> CellStyleName[cell]|>,
+      payload,
+      <|"status" -> artifacts["status"]|>
+    ]
+  ]
+];
+
+GetCellOutputById[args_Association] := Module[{notebookId, record, cellId, cell, artifacts, maxBytes, payload},
+  notebookId = TargetNotebookId[args];
+  If[RequireReadPermission[notebookId] === $Canceled, Return[$Canceled]];
+  If[!StringQ[notebookId] || StringLength[notebookId] == 0, Return[Failure["BAD_REQUEST", <|"message" -> "No notebook is selected."|>]]];
+  record = NotebookRecord[notebookId];
+  If[!AssociationQ[record] || record === <||>, Return[Failure["BAD_REQUEST", <|"message" -> "No notebook is selected."|>]]];
   cellId = Lookup[args, "cellId", ""];
   If[StringLength[cellId] == 0, Return[Failure["BAD_REQUEST", <|"message" -> "cellId is required."|>]]];
-  cell = Lookup[Lookup[record, "cellMap", <||>], cellId, Missing["NotFound"]];
-  If[MissingQ[cell], Return[Failure["BAD_REQUEST", <|"message" -> "Requested cell was not found."|>]]];
-  maxBytes = CellPayloadMaxBytes[args];
-  artifacts = CellArtifactScan[cell, cellId, Lookup[record, "notebook", None]];
-  payload = ArtifactPayloadFields[cellId, artifacts["outputs"], artifacts["messages"], maxBytes];
-  Join[
-    <|"cellId" -> cellId|>,
-    payload,
-    <|"status" -> artifacts["status"]|>
-  ]
-];
-
-ReadArtifactById[args_Association] := Module[{notebookId, record, artifactId, parts, cellId, kind, indexText, index, cell, artifacts, artifactList, text, offset, limit, page, nextOffset, done},
-  If[RequireReadPermission[] === $Canceled, Return[$Canceled]];
-  notebookId = TargetNotebookId[args];
-  If[!StringQ[notebookId] || StringLength[notebookId] == 0, Return[Failure["BAD_REQUEST", <|"message" -> "No notebook is selected."|>]]];
-  record = NotebookRecord[notebookId];
-  If[!AssociationQ[record] || record === <||>, Return[Failure["BAD_REQUEST", <|"message" -> "No notebook is selected."|>]]];
-  artifactId = Lookup[args, "artifactId", ""];
-  If[!StringQ[artifactId] || StringLength[artifactId] == 0, Return[Failure["BAD_REQUEST", <|"message" -> "artifactId is required."|>]]];
-  parts = StringSplit[artifactId, ":"];
-  If[Length[parts] =!= 3, Return[Failure["BAD_REQUEST", <|"message" -> "artifactId must have the form cellId:type:index."|>]]];
-  {cellId, kind, indexText} = parts;
-  If[!MemberQ[{"output", "message"}, kind], Return[Failure["BAD_REQUEST", <|"message" -> "artifact type must be output or message."|>]]];
-  If[!StringMatchQ[indexText, DigitCharacter..], Return[Failure["BAD_REQUEST", <|"message" -> "artifact index must be a non-negative integer."|>]]];
-  index = ToExpression[indexText];
-  offset = Lookup[args, "offset", 0];
-  limit = Lookup[args, "limit", 65536];
-  If[!IntegerQ[offset] || offset < 0, Return[Failure["BAD_REQUEST", <|"message" -> "offset must be a non-negative integer."|>]]];
-  If[!IntegerQ[limit] || limit <= 0 || limit > $MaxCellPayloadBytes, Return[Failure["BAD_REQUEST", <|"message" -> "limit must be a positive integer up to 1 MiB."|>]]];
-  cell = Lookup[Lookup[record, "cellMap", <||>], cellId, Missing["NotFound"]];
-  If[MissingQ[cell], Return[Failure["BAD_REQUEST", <|"message" -> "Requested cell was not found."|>]]];
-  artifacts = CellArtifactScan[cell, cellId, Lookup[record, "notebook", None]];
-  artifactList = If[kind === "output", artifacts["outputs"], artifacts["messages"]];
-  If[index >= Length[artifactList], Return[Failure["BAD_REQUEST", <|"message" -> "Requested artifact was not found."|>]]];
-  text = artifactList[[index + 1]];
-  page = Utf8SliceStringToBytes[text, offset, limit];
-  nextOffset = page["nextOffset"];
-  done = nextOffset >= page["originalByteLength"];
-  <|
-    "artifactId" -> artifactId,
-    "offset" -> offset,
-    "limit" -> limit,
-    "data" -> page["value"],
-    "nextOffset" -> nextOffset,
-    "done" -> done,
-    "byteLength" -> page["originalByteLength"]
-  |>
-];
-
-MakeCellExpression[content_String, style_String] := Module[{cellStyle = If[StringQ[style] && StringLength[style] > 0, style, "Input"]},
+  cell = Lookup[Lookup[record, "cellMap", <||>], cellId, Missing["NotFound"]];
+  If[MissingQ[cell], Return[Failure["BAD_REQUEST", <|"message" -> "Requested cell was not found."|>]]];
+  maxBytes = CellPayloadMaxBytes[args];
+  artifacts = CellArtifactScan[cell, cellId, Lookup[record, "notebook", None]];
+  payload = ArtifactPayloadFields[cellId, artifacts["outputs"], artifacts["messages"], maxBytes];
+  Join[
+    <|"cellId" -> cellId|>,
+    payload,
+    <|"status" -> artifacts["status"]|>
+  ]
+];
+
+ReadArtifactById[args_Association] := Module[{notebookId, record, artifactId, parts, cellId, kind, indexText, index, cell, artifacts, artifactList, text, offset, limit, page, nextOffset, done},
+  notebookId = TargetNotebookId[args];
+  If[RequireReadPermission[notebookId] === $Canceled, Return[$Canceled]];
+  If[!StringQ[notebookId] || StringLength[notebookId] == 0, Return[Failure["BAD_REQUEST", <|"message" -> "No notebook is selected."|>]]];
+  record = NotebookRecord[notebookId];
+  If[!AssociationQ[record] || record === <||>, Return[Failure["BAD_REQUEST", <|"message" -> "No notebook is selected."|>]]];
+  artifactId = Lookup[args, "artifactId", ""];
+  If[!StringQ[artifactId] || StringLength[artifactId] == 0, Return[Failure["BAD_REQUEST", <|"message" -> "artifactId is required."|>]]];
+  parts = StringSplit[artifactId, ":"];
+  If[Length[parts] =!= 3, Return[Failure["BAD_REQUEST", <|"message" -> "artifactId must have the form cellId:type:index."|>]]];
+  {cellId, kind, indexText} = parts;
+  If[!MemberQ[{"output", "message"}, kind], Return[Failure["BAD_REQUEST", <|"message" -> "artifact type must be output or message."|>]]];
+  If[!StringMatchQ[indexText, DigitCharacter..], Return[Failure["BAD_REQUEST", <|"message" -> "artifact index must be a non-negative integer."|>]]];
+  index = ToExpression[indexText];
+  offset = Lookup[args, "offset", 0];
+  limit = Lookup[args, "limit", 65536];
+  If[!IntegerQ[offset] || offset < 0, Return[Failure["BAD_REQUEST", <|"message" -> "offset must be a non-negative integer."|>]]];
+  If[!IntegerQ[limit] || limit <= 0 || limit > $MaxCellPayloadBytes, Return[Failure["BAD_REQUEST", <|"message" -> "limit must be a positive integer up to 1 MiB."|>]]];
+  cell = Lookup[Lookup[record, "cellMap", <||>], cellId, Missing["NotFound"]];
+  If[MissingQ[cell], Return[Failure["BAD_REQUEST", <|"message" -> "Requested cell was not found."|>]]];
+  artifacts = CellArtifactScan[cell, cellId, Lookup[record, "notebook", None]];
+  artifactList = If[kind === "output", artifacts["outputs"], artifacts["messages"]];
+  If[index >= Length[artifactList], Return[Failure["BAD_REQUEST", <|"message" -> "Requested artifact was not found."|>]]];
+  text = artifactList[[index + 1]];
+  page = Utf8SliceStringToBytes[text, offset, limit];
+  nextOffset = page["nextOffset"];
+  done = nextOffset >= page["originalByteLength"];
+  <|
+    "artifactId" -> artifactId,
+    "offset" -> offset,
+    "limit" -> limit,
+    "data" -> page["value"],
+    "nextOffset" -> nextOffset,
+    "done" -> done,
+    "byteLength" -> page["originalByteLength"]
+  |>
+];
+
+MakeCellExpression[content_String, style_String] := Module[{cellStyle = If[StringQ[style] && StringLength[style] > 0, style, "Input"]},
   If[cellStyle === "Input",
     Cell[BoxData[content], "Input", CellTags -> {"AI-Generated"}],
     Cell[content, cellStyle, CellTags -> {"AI-Generated"}]
@@ -1255,8 +1287,8 @@ InsertCellAtBeginning[notebook_NotebookObject, newCell_] := Module[{beforeCount,
 ];
 
 InsertCellRequest[args_Association] := Module[{notebookId, record, afterId, style, content, newCell, notebook, anchor, cells, inserted, refreshed},
-  If[Not @ ConfirmAction["InsertCell", "AI requests inserting 1 cell. Allow?"], Return[$Canceled]];
   notebookId = TargetNotebookId[args];
+  If[Not @ ConfirmAction["InsertCell", "AI requests inserting 1 cell. Allow?", notebookId], Return[$Canceled]];
   If[!StringQ[notebookId] || StringLength[notebookId] == 0, Return[Failure["BAD_REQUEST", <|"message" -> "No notebook is selected."|>]]];
   record = NotebookRecord[notebookId];
   If[!AssociationQ[record] || record === <||>, Return[Failure["BAD_REQUEST", <|"message" -> "No notebook is selected."|>]]];
@@ -1291,8 +1323,8 @@ InsertCellRequest[args_Association] := Module[{notebookId, record, afterId, styl
 ];
 
 ModifyCellRequest[args_Association] := Module[{notebookId, record, notebook, cellId, cellMap, cell, content, style, newCell, cells, cellIndex, updatedCells, updatedCell, writeResult},
-  If[Not @ ConfirmAction["ModifyCell", "AI requests modifying 1 cell. Allow?"], Return[$Canceled]];
   notebookId = TargetNotebookId[args];
+  If[Not @ ConfirmAction["ModifyCell", "AI requests modifying 1 cell. Allow?", notebookId], Return[$Canceled]];
   If[!StringQ[notebookId] || StringLength[notebookId] == 0, Return[Failure["BAD_REQUEST", <|"message" -> "No notebook is selected."|>]]];
   record = NotebookRecord[notebookId];
   If[!AssociationQ[record] || record === <||>, Return[Failure["BAD_REQUEST", <|"message" -> "No notebook is selected."|>]]];
@@ -1322,8 +1354,8 @@ ModifyCellRequest[args_Association] := Module[{notebookId, record, notebook, cel
 ];
 
 DeleteCellRequest[args_Association] := Module[{notebookId, record, notebook, cellId, cell, cellMap, artifacts, artifactIds, newCellMap},
-  If[Not @ ConfirmAction["DeleteCell", "AI requests deleting 1 cell. Allow?"], Return[$Canceled]];
   notebookId = TargetNotebookId[args];
+  If[Not @ ConfirmAction["DeleteCell", "AI requests deleting 1 cell. Allow?", notebookId], Return[$Canceled]];
   If[!StringQ[notebookId] || StringLength[notebookId] == 0, Return[Failure["BAD_REQUEST", <|"message" -> "No notebook is selected."|>]]];
   record = NotebookRecord[notebookId];
   If[!AssociationQ[record] || record === <||>, Return[Failure["BAD_REQUEST", <|"message" -> "No notebook is selected."|>]]];
@@ -1345,8 +1377,8 @@ DeleteCellRequest[args_Association] := Module[{notebookId, record, notebook, cel
 ];
 
 RunCellRequest[args_Association] := Module[{notebookId, record, notebook, cellId, cell, timeoutSec = Lookup[args, "timeoutSec", 120], installedEpilog, evaluateResult},
-  If[Not @ ConfirmAction["RunCell", "AI requests running 1 cell. Allow?"], Return[$Canceled]];
   notebookId = TargetNotebookId[args];
+  If[Not @ ConfirmAction["RunCell", "AI requests running 1 cell. Allow?", notebookId], Return[$Canceled]];
   If[!StringQ[notebookId] || StringLength[notebookId] == 0, Return[Failure["BAD_REQUEST", <|"message" -> "No notebook is selected."|>]]];
   record = NotebookRecord[notebookId];
   If[!AssociationQ[record] || record === <||>, Return[Failure["BAD_REQUEST", <|"message" -> "No notebook is selected."|>]]];
@@ -1358,14 +1390,14 @@ RunCellRequest[args_Association] := Module[{notebookId, record, notebook, cellId
   If[MissingQ[cell], Return[Failure["BAD_REQUEST", <|"message" -> "Requested cell was not found."|>]]];
   ClearCellEvaluationComplete[notebook, cellId];
   installedEpilog = InstallRunningCellEpilog[cell, cellId];
-  If[MatchQ[installedEpilog, _Failure], Return[installedEpilog]];
-  $LastRunStatusCellId = None;
-  $LastRunStatusNotebookId = None;
-  $LastRunStatus = None;
-  $RunningStatus = "running";
-  $AbortRequestedAt = None;
-  $LastLateResult = None;
-  $RunningRequestId = Lookup[args, "requestId", $CurrentRequestId];
+  If[MatchQ[installedEpilog, _Failure], Return[installedEpilog]];
+  $LastRunStatusCellId = None;
+  $LastRunStatusNotebookId = None;
+  $LastRunStatus = None;
+  $RunningStatus = "running";
+  $AbortRequestedAt = None;
+  $LastLateResult = None;
+  $RunningRequestId = Lookup[args, "requestId", $CurrentRequestId];
   $RunningCellId = cellId;
   $RunningNotebookId = notebookId;
   $RunningNotebookObject = notebook;
@@ -1384,8 +1416,8 @@ RunCellRequest[args_Association] := Module[{notebookId, record, notebook, cellId
 ];
 
 AbortEvaluationRequest[args_Association] := Module[{notebookId, record, notebook, runningCellId, runningRequestId, wasRunning},
-  If[Not @ ConfirmAction["RunCell", "AI requests aborting the running evaluation. Allow?"], Return[$Canceled]];
   notebookId = TargetNotebookId[args];
+  If[Not @ ConfirmAction["RunCell", "AI requests aborting the running evaluation. Allow?", notebookId], Return[$Canceled]];
   If[!StringQ[notebookId] || StringLength[notebookId] == 0, Return[Failure["BAD_REQUEST", <|"message" -> "No notebook is selected."|>]]];
   record = NotebookRecord[notebookId];
   If[!AssociationQ[record] || record === <||>, Return[Failure["BAD_REQUEST", <|"message" -> "No notebook is selected."|>]]];
@@ -1398,15 +1430,15 @@ AbortEvaluationRequest[args_Association] := Module[{notebookId, record, notebook
     FinishRunningCell["finished"];
     Return[<|"status" -> "finished", "cellId" -> runningCellId, "requestId" -> runningRequestId|>]
   ];
-  If[wasRunning,
-    $AbortRequestedAt = AbsoluteTime[];
-    $RunningStatus = "abort_requested"
-  ];
-  Quiet @ Check[FrontEndTokenExecute[notebook, "EvaluatorAbort"], Null];
-  If[wasRunning,
-    <|"status" -> "abort_requested", "cellId" -> runningCellId, "requestId" -> runningRequestId|>,
-    <|"status" -> "idle"|>
-  ]
+  If[wasRunning,
+    $AbortRequestedAt = AbsoluteTime[];
+    $RunningStatus = "abort_requested"
+  ];
+  Quiet @ Check[FrontEndTokenExecute[notebook, "EvaluatorAbort"], Null];
+  If[wasRunning,
+    <|"status" -> "abort_requested", "cellId" -> runningCellId, "requestId" -> runningRequestId|>,
+    <|"status" -> "idle"|>
+  ]
 ];
 
 KillKernelRequest[args_Association] := Module[{notebookId, record, notebook, evaluatorName},
@@ -1435,13 +1467,48 @@ RestartKernelRequest[args_Association] := Module[{notebookId, record, notebook,
   If[evaluatorName === $ControlAgentEvaluatorName,
     Return[Failure["PROTECTED_EVALUATOR", <|"message" -> "Cannot restart the MICA control agent evaluator."|>]]
   ];
+  Quiet @ Check[NotebookEvaluate[notebook, "Quit[]", InsertResults -> False], Null];
+  Pause[0.5];
   Quiet @ Check[NotebookEvaluate[notebook, "Null", InsertResults -> False], Null];
   <|"status" -> "restarted", "notebookId" -> notebookId|>
 ];
 
-SaveNotebookRequest[args_Association] := Module[{notebookId, record, notebook},
-  If[Not @ ConfirmAction["SaveNotebook", "AI requests saving the notebook. Allow?"], Return[$Canceled]];
+CreateNotebookRequest[args_Association] := Module[{title, nb, notebookId, payload, response},
+  title = Lookup[args, "title", "Untitled"];
+  If[!StringQ[title] || StringLength[StringTrim[title]] == 0, title = "Untitled"];
+  nb = Quiet @ Check[CreateDocument[{}, WindowTitle -> title, Visible -> True], $Failed];
+  If[Head[nb] =!= NotebookObject, Return[Failure["CREATE_FAILED", <|"message" -> "The FrontEnd failed to create the notebook."|>]]];
+  payload = NotebookHeartbeatPayload[nb];
+  response = Quiet @ Check[BridgePost["/notebooks/heartbeat", payload], $Failed];
+  notebookId = If[AssociationQ[response],
+    Lookup[Lookup[response, "notebook", <||>], "notebookId", Lookup[response, "notebookId", None]],
+    None
+  ];
+  <|"status" -> "created", "notebookId" -> notebookId, "title" -> title|>
+];
+
+OpenNotebookRequest[args_Association] := Module[{path, nb, notebookId, payload, response},
+  path = Lookup[args, "path", ""];
+  If[!StringQ[path] || StringLength[StringTrim[path]] == 0,
+    Return[Failure["BAD_REQUEST", <|"message" -> "path is required."|>]]
+  ];
+  If[!FileExistsQ[path],
+    Return[Failure["NOT_FOUND", <|"message" -> "File not found: " <> path|>]]
+  ];
+  nb = Quiet @ Check[NotebookOpen[path, Visible -> True], $Failed];
+  If[Head[nb] =!= NotebookObject, Return[Failure["OPEN_FAILED", <|"message" -> "The FrontEnd failed to open the notebook."|>]]];
+  payload = NotebookHeartbeatPayload[nb];
+  response = Quiet @ Check[BridgePost["/notebooks/heartbeat", payload], $Failed];
+  notebookId = If[AssociationQ[response],
+    Lookup[Lookup[response, "notebook", <||>], "notebookId", Lookup[response, "notebookId", None]],
+    None
+  ];
+  <|"status" -> "opened", "notebookId" -> notebookId, "path" -> path|>
+];
+
+SaveNotebookRequest[args_Association] := Module[{notebookId, record, notebook},
   notebookId = TargetNotebookId[args];
+  If[Not @ ConfirmAction["SaveNotebook", "AI requests saving the notebook. Allow?", notebookId], Return[$Canceled]];
   If[!StringQ[notebookId] || StringLength[notebookId] == 0, Return[Failure["BAD_REQUEST", <|"message" -> "No notebook is selected."|>]]];
   record = NotebookRecord[notebookId];
   If[!AssociationQ[record] || record === <||>, Return[Failure["BAD_REQUEST", <|"message" -> "No notebook is selected."|>]]];
@@ -1496,11 +1563,15 @@ AgentHeartbeat[] := BridgePost[
   |>
 ];
 
-NotebookHeartbeatPayload[nb_NotebookObject] := Module[{savedPath, windowTitle, displayName, frontendObjectKey},
+NotebookHeartbeatPayload[nb_NotebookObject, notebookId_:None] := Module[{savedPath, windowTitle, displayName, frontendObjectKey, perms},
   savedPath = Quiet @ Check[ToString[Replace[NotebookFileName[nb], $Failed -> ""]], ""];
   frontendObjectKey = FrontendObjectKey[nb];
   windowTitle = NotebookWindowTitle[nb];
   displayName = NotebookDisplayNameForHeartbeat[nb, savedPath, frontendObjectKey];
+  perms = If[StringQ[notebookId] && StringLength[notebookId] > 0,
+    NotebookPermissions[notebookId],
+    $DefaultBridgePermissions
+  ];
   <|
     "agentSessionId" -> $AgentSessionId,
     "frontendObjectKey" -> frontendObjectKey,
@@ -1510,7 +1581,7 @@ NotebookHeartbeatPayload[nb_NotebookObject] := Module[{savedPath, windowTitle, d
     "savedPath" -> savedPath,
     "wolframVersion" -> ToString[$VersionNumber],
     "platform" -> $OperatingSystem,
-    "permissions" -> $BridgePermissions,
+    "permissions" -> perms,
     "seenAt" -> UnixTimeMilliseconds[]
   |>
 ];
@@ -1544,7 +1615,8 @@ AgentHeartbeatNotebookClosure[notebookId_String] := Module[{record = Lookup[$Bri
   response = Quiet @ Check[BridgePost["/notebooks/" <> URLComponentEncodeString[notebookId] <> "/closed", <|"agentSessionId" -> $AgentSessionId|>], $Failed];
   If[AssociationQ[record] && AssociationQ[response] && TrueQ[Lookup[response, "ok", False]],
     If[!TrueQ[Lookup[record, "closed", False]],
-      $BridgeNotebooks[notebookId] = Join[record, <|"closed" -> True|>]
+      $BridgeNotebooks[notebookId] = Join[record, <|"closed" -> True|>];
+      KeyDropFrom[$BridgeNotebookPermissions, notebookId]
     ]
   ];
   response
@@ -1568,7 +1640,7 @@ HeartbeatNotebooks[] := Module[{notebooks = AgentVisibleNotebooks[], visibleNote
             None
           ];
           If[StringQ[localNotebookId] && StringLength[localNotebookId] > 0, AppendTo[visibleNotebookIds, localNotebookId]];
-          payload = NotebookHeartbeatPayload[nb];
+          payload = NotebookHeartbeatPayload[nb, localNotebookId];
           response = Quiet @ Check[BridgePost["/notebooks/heartbeat", payload], $Failed];
           If[AssociationQ[response],
             notebookId = Lookup[Lookup[response, "notebook", <||>], "notebookId", Lookup[response, "notebookId", None]];
@@ -1801,18 +1873,20 @@ ExecuteRequest[request_Association] := Module[{requestId, tool, args, result},
         !AssociationQ[args], Failure["BAD_REQUEST", <|"Message" -> "Request arguments must be an association."|>],
         True,
         Switch[tool,
-          "mma_list_cells", If[RequireReadPermission[] === $Canceled, $Canceled, Module[{notebookId = TargetNotebookId[args], refresh}, If[!StringQ[notebookId] || StringLength[notebookId] == 0, Failure["BAD_REQUEST", <|"Message" -> "No notebook is selected."|>], refresh = RefreshCellMap[notebookId]; If[MatchQ[refresh, _Failure], refresh, <|"cells" -> refresh|>]]]],
+          "mma_list_cells", If[RequireReadPermission[TargetNotebookId[args]] === $Canceled, $Canceled, Module[{notebookId = TargetNotebookId[args], refresh}, If[!StringQ[notebookId] || StringLength[notebookId] == 0, Failure["BAD_REQUEST", <|"Message" -> "No notebook is selected."|>], refresh = RefreshCellMap[notebookId]; If[MatchQ[refresh, _Failure], refresh, <|"cells" -> refresh|>]]]],
           "mma_read_cell", ReadCellById[args],
           "mma_insert_cell", InsertCellRequest[args],
           "mma_modify_cell", ModifyCellRequest[args],
           "mma_delete_cell", DeleteCellRequest[args],
-          "mma_run_cell", RunCellRequest[args],
+          "mma_run_cell", RunCellRequest[args],
           "mma_abort_evaluation", AbortEvaluationRequest[args],
           "mma_kill_kernel", KillKernelRequest[args],
-          "mma_restart_kernel", RestartKernelRequest[args],
-          "mma_get_cell_output", GetCellOutputById[args],
-          "mma_read_artifact", ReadArtifactById[args],
-          "mma_save_notebook", SaveNotebookRequest[args],
+          "mma_restart_kernel", RestartKernelRequest[args],
+          "mma_create_notebook", CreateNotebookRequest[args],
+          "mma_open_notebook", OpenNotebookRequest[args],
+          "mma_get_cell_output", GetCellOutputById[args],
+          "mma_read_artifact", ReadArtifactById[args],
+          "mma_save_notebook", SaveNotebookRequest[args],
           "mma_select_notebook", SelectNotebookRequest[args],
           "mma_symbol_lookup", SymbolLookup[Lookup[args, "query", ""]],
           _, Failure["BAD_REQUEST", <|"Message" -> StringTemplate["Unknown tool ``."][tool]|>]