codetrellis 0.0.0-stage → 0.3.0

package/src/backend/mcp/tools/session-tools.js

@@ -0,0 +1,554 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var session_tools_exports = {};
+__export(session_tools_exports, {
+  register: () => register
+});
+module.exports = __toCommonJS(session_tools_exports);
+var import_zod = require("zod");
+var import_node_path = __toESM(require("node:path"));
+var import_helpers = require("../helpers");
+var import_types = require("../../../shared/types");
+var import_confined_fs = require("../../services/confined-fs");
+function notInRecents(projectPath) {
+  return {
+    isError: true,
+    content: [{ type: "text", text: `Project not in recents: ${projectPath}` }]
+  };
+}
+function register(server, deps) {
+  const notFound = (what, uid) => ({
+    content: [{ type: "text", text: `${what} ${uid} not found.` }],
+    isError: true
+  });
+  const missingPlan = (uid) => uid && !deps.planService.getPlan(uid) ? notFound("Plan", uid) : null;
+  const missingItem = (uid) => uid && !deps.planItemService.getItem(uid) ? notFound("Item", uid) : null;
+  server.registerTool(
+    "register_session",
+    {
+      description: "Register this agent connection with CodeTrellis. Identifies who you are, what model you use, and what capabilities you have. Capabilities are used for skill-matching when claiming Actions \u2014 declare your MCP servers, language proficiencies, and skills so CodeTrellis can route the right work to you.\n\nIf you are running inside a CodeTrellis terminal, the environment variable CODETRELLIS_HOST_TERMINAL will be set to your host terminal's session ID. Pass it as host_terminal_id so CodeTrellis can prevent you from accidentally writing to your own terminal via terminal_write (which would create a feedback loop).",
+      inputSchema: {
+        agent_type: import_zod.z.string().describe("Agent type, e.g. claude-code, cursor, aider"),
+        model: import_zod.z.string().optional().describe("Model name, e.g. claude-opus-4, gpt-4o"),
+        capabilities: import_zod.z.array(import_zod.z.object({
+          name: import_zod.z.string().describe('Capability name, e.g. "playwright", "typescript", "@refactor"'),
+          source: import_zod.z.enum(["mcp", "skill", "lang", "plugin"]).describe("Where this capability comes from")
+        })).optional().describe("Capabilities this agent has \u2014 MCP servers, skills, languages, plugins"),
+        host_terminal_id: import_zod.z.string().optional().describe(
+          "If you are running inside a CodeTrellis terminal, pass the value of the CODETRELLIS_HOST_TERMINAL environment variable here. This enables self-write protection \u2014 terminal_write will reject writes to your own host terminal to prevent feedback loops."
+        )
+      }
+    },
+    async ({ agent_type, model, capabilities, host_terminal_id }) => {
+      const sessionId = deps.sessionId;
+      deps.sessionService.registerSession(sessionId, agent_type, model, capabilities, host_terminal_id);
+      deps.broadcast("session-registered", { sessionId, agentType: agent_type, model, capabilities });
+      deps.broadcast("mcp-session-changed", { reason: "register", sessionId });
+      deps.saveNow(() => deps.exportDatabase());
+      const parts = [
+        `Session registered: ${sessionId} (${agent_type}${model ? ` / ${model}` : ""}${capabilities?.length ? ` with ${capabilities.length} capabilities` : ""})`
+      ];
+      if (host_terminal_id) {
+        parts.push(`Self-write protection enabled: writes to terminal ${host_terminal_id} will be blocked from this session.`);
+      }
+      return { content: [{ type: "text", text: parts.join("\n") }] };
+    }
+  );
+  server.registerTool(
+    "set_active_plan",
+    {
+      description: "Associate this agent session with a plan and navigate the UI to show it. Other connected agents see your active plan in the Connected Agents widget.",
+      inputSchema: { plan_uid: import_zod.z.string() }
+    },
+    async ({ plan_uid }) => {
+      const refused = missingPlan(plan_uid);
+      if (refused) return refused;
+      const sessionId = deps.sessionId;
+      if (sessionId) {
+        deps.sessionService.setActivePlan(sessionId, plan_uid);
+        deps.broadcast("mcp-session-changed", { reason: "set_active_plan", sessionId, planUid: plan_uid });
+      } else {
+        const sessions = deps.sessionService.getActiveSessions();
+        if (sessions.length > 0) {
+          deps.sessionService.setActivePlan(sessions[sessions.length - 1].sessionId, plan_uid);
+          deps.broadcast("mcp-session-changed", { reason: "set_active_plan", planUid: plan_uid });
+        }
+      }
+      const n = deps.broadcast("ui-navigate", { target: "plan", planUid: plan_uid });
+      return (0, import_helpers.resultWithMeta)({ ok: true, planUid: plan_uid, navigated: true }, n);
+    }
+  );
+  server.registerTool(
+    "navigate_to",
+    {
+      description: "Navigate the CodeTrellis UI to a specific view. Use this to show the user what you are working on \u2014 open the plan workspace, switch to graph view, enable split view, open the Brief on a task, or open a file you cite at the place you cite.",
+      inputSchema: {
+        target: import_zod.z.enum(["plan", "graph", "split", "timeline", "code", "brief", "artefact", "awareness", "stack", "review", "replay", "play-forward", "live", "changes"]).describe('"plan" = plan workspace, "graph" = dependency graph, "split" = plan + graph side-by-side, "timeline" = plan workspace with the activity/event feed open, "code" = the code reader on a file, "brief" = the Brief (the plan as tasks, materials and what good looks like), "artefact" = a recorded file in the viewer, at a locator, "awareness" / "stack" / "review" = that tab of the side panel (overlaps and what needs the person; how the work stacks up; what to merge first), "replay" = the project as it was, from a moment (`from`), played at 4\xD7 with speed 4, "play-forward" = every active plan played forward to where they meet, "live" = back to now from replay or play-forward, "changes" = the sidebar\'s Changes view (source control, no plan needed). Showing only: nothing here decides anything for the person.'),
+        plan_uid: import_zod.z.string().optional().describe("If navigating to plan/split/timeline, which plan to show. If omitted, keeps the current active plan."),
+        // `code` was missing entirely, so an agent could show someone the
+        // graph, a plan, a split and a timeline — and never the code,
+        // which is where the per-line verdict lives. An agent that says
+        // "look at what changed" could not make that happen.
+        file_path: import_zod.z.string().optional().describe('For target "code": absolute path of the file to open.'),
+        line: import_zod.z.number().int().optional().describe('For target "code": line to scroll to and mark.'),
+        // "Whose line is this?" is a question an agent can answer in words
+        // (line_history) and could not put on screen: the reader opened at
+        // the line, with who wrote it nowhere in sight.
+        line_history: import_zod.z.boolean().optional().describe("For target \"code\": turn on the reader's Line history, so the person sees who wrote each run of lines; with `line`, that line's card opens: its commit, git author, the agent and how CodeTrellis knows."),
+        // Phase 31 §5 — an agent that says "look at the figure I cited" can
+        // put it on screen, and one working a brief can show the task.
+        item_uid: import_zod.z.string().optional().describe('For target "brief": the task to show.'),
+        from: import_zod.z.union([import_zod.z.number(), import_zod.z.string()]).optional().describe('For target "replay": where to start, as epoch milliseconds or an ISO date. Defaults to two hours ago.'),
+        to: import_zod.z.union([import_zod.z.number(), import_zod.z.string()]).optional().describe('For target "replay": where to end, for a window in the past. Defaults to now.'),
+        speed: import_zod.z.union([import_zod.z.literal(1), import_zod.z.literal(4)]).optional().describe('For target "replay": 4 plays it at once at 4\xD7 (catching up); 1, the default, leaves the person to scrub.'),
+        signal_id: import_zod.z.string().optional().describe('With target "awareness": the overlap to scroll to and mark (an id from get_awareness or a notice).'),
+        breakpoint_ref: import_zod.z.string().optional().describe('With target "awareness": the paused or breached breakpoint to scroll to and mark in Needs you (a ref from a paused result).'),
+        attachment_uid: import_zod.z.string().optional().describe('For target "artefact": the recorded file to open (from get_brief or record_artefact).'),
+        locator: import_zod.z.object({
+          sheet: import_zod.z.string().optional(),
+          range: import_zod.z.string().optional(),
+          page: import_zod.z.union([import_zod.z.number().int(), import_zod.z.string()]).optional(),
+          lines: import_zod.z.union([import_zod.z.number().int(), import_zod.z.string()]).optional(),
+          text: import_zod.z.string().optional(),
+          t: import_zod.z.union([import_zod.z.number(), import_zod.z.string()]).optional()
+        }).strict().optional().describe('For target "artefact": where in the file \u2014 {sheet, range}, {page}, {lines}, {text} or {t}.')
+      }
+    },
+    async ({ target, plan_uid, file_path, line, line_history, item_uid, attachment_uid, locator, from, to, speed, signal_id, breakpoint_ref }) => {
+      const when = (v, name) => {
+        if (v === void 0) return void 0;
+        const ms = typeof v === "number" ? v : Date.parse(v);
+        return Number.isFinite(ms) ? ms : { error: `${name} is not a time: ${String(v)}` };
+      };
+      const fromMs = when(from, "from");
+      const toMs = when(to, "to");
+      for (const t of [fromMs, toMs]) {
+        if (t && typeof t === "object") return { content: [{ type: "text", text: t.error }], isError: true };
+      }
+      if ((signal_id || breakpoint_ref) && target !== "awareness") {
+        return { content: [{ type: "text", text: 'signal_id and breakpoint_ref go with target "awareness"' }], isError: true };
+      }
+      if (line_history && target !== "code") {
+        return { content: [{ type: "text", text: 'line_history goes with target "code"' }], isError: true };
+      }
+      if (target === "artefact" && !attachment_uid) {
+        return { content: [{ type: "text", text: 'target "artefact" needs attachment_uid' }], isError: true };
+      }
+      const refused = missingPlan(plan_uid) ?? missingItem(item_uid) ?? (attachment_uid && !deps.artefactService.getArtefact(attachment_uid) ? notFound("Recorded file", attachment_uid) : null);
+      if (refused) return refused;
+      deps.broadcast("ui-navigate", {
+        target,
+        planUid: plan_uid,
+        filePath: file_path,
+        line,
+        lineHistory: line_history === true ? true : void 0,
+        itemUid: item_uid,
+        attachmentUid: attachment_uid,
+        locator: locator ?? null,
+        from: fromMs,
+        to: toMs,
+        speed,
+        signalId: signal_id,
+        breakpointRef: breakpoint_ref
+      });
+      return { content: [{ type: "text", text: `Navigated to ${target}${plan_uid ? ` (plan ${plan_uid})` : ""}` }] };
+    }
+  );
+  server.registerTool(
+    "open_plan",
+    {
+      description: "Open a specific plan in the CodeTrellis UI. Switches to plan workspace mode and loads the plan. The user will see the plan immediately.",
+      inputSchema: {
+        plan_uid: import_zod.z.string().describe("UID of the plan to open"),
+        split_view: import_zod.z.boolean().optional().describe("Also enable split view (plan + graph side-by-side)")
+      }
+    },
+    async ({ plan_uid, split_view }) => {
+      const refused = missingPlan(plan_uid);
+      if (refused) return refused;
+      deps.broadcast("ui-navigate", { target: split_view ? "split" : "plan", planUid: plan_uid });
+      return { content: [{ type: "text", text: `Opened plan ${plan_uid}${split_view ? " in split view" : ""}` }] };
+    }
+  );
+  server.registerTool(
+    "toggle_panel",
+    {
+      description: 'Toggle a UI panel on or off in the CodeTrellis interface. "channel", "activity" and "history" live inside the plan workspace and will switch to it if a plan is active.',
+      inputSchema: {
+        panel: import_zod.z.enum(["sidebar", "inspector", "terminal", "plans", "split", "channel", "activity", "history"]).describe(
+          'Which panel to toggle. "terminal" = the terminal drawer, "plans" = the Plans / Timeline panel under the graph, "channel" = peer-to-peer coordination Channel panel, "activity" = plan activity/event feed, "history" = plan history (time-travel) rail.'
+        )
+      }
+    },
+    async ({ panel }) => {
+      deps.broadcast("ui-toggle", { panel });
+      return { content: [{ type: "text", text: `Toggled ${panel} panel` }] };
+    }
+  );
+  server.registerTool(
+    "refresh_ui",
+    {
+      description: "Force the CodeTrellis UI to refresh its plan list and active plan. Use this after making changes that the UI might not have picked up.",
+      inputSchema: {}
+    },
+    async () => {
+      deps.broadcast("ui-refresh", {});
+      return { content: [{ type: "text", text: "UI refresh triggered" }] };
+    }
+  );
+  server.registerTool(
+    "rescan_project",
+    {
+      description: 'Trigger a fresh AST re-parse of the currently open project. Use this after making changes to ensure the dependency graph and symbol index are up to date. Equivalent to hitting the "Rescan" button in the UI.',
+      inputSchema: {
+        project_path: import_zod.z.string().optional().describe(
+          "Absolute path of the project to scan. If omitted, rescans the currently open project."
+        )
+      }
+    },
+    async ({ project_path }) => {
+      const target = project_path ?? deps.getActiveProjectPath();
+      if (!target) {
+        return {
+          content: [{ type: "text", text: "Rescan failed: no project is open. Pass project_path, or open one with open_project." }],
+          isError: true
+        };
+      }
+      try {
+        const stats = await deps.scanProject(target);
+        return { content: [{ type: "text", text: `Rescan complete for ${target} \u2014 ${stats.fileCount} files, ${stats.symbolCount} symbols, ${stats.importCount} imports (${stats.resolvedImports} resolved)` }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Rescan failed: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+      }
+    }
+  );
+  server.registerTool(
+    "set_baseline",
+    {
+      description: `Pin the baseline the graph's "diff" and "baseline" modes compare against to a commit's own contents (full or short hash, or a ref such as a branch name), in the open project. Uncommitted work then shows as changes against it. Pass null to clear the baseline; the next scan sets one again.`,
+      inputSchema: {
+        commit_hash: import_zod.z.string().nullable().describe("Commit hash or ref to pin to. Null to clear.")
+      }
+    },
+    async ({ commit_hash }) => {
+      if (commit_hash === null) {
+        deps.clearBaseline();
+        deps.broadcast("ui-set-baseline", { commitHash: null, by: "agent" });
+        return { content: [{ type: "text", text: "Cleared the baseline. The next scan sets one again." }] };
+      }
+      const projectPath = deps.getActiveProjectPath();
+      if (!projectPath) {
+        return { content: [{ type: "text", text: "No project is open to pin a baseline in." }], isError: true };
+      }
+      try {
+        const baseline = await deps.pinBaseline(projectPath, commit_hash);
+        const n = deps.broadcast("ui-set-baseline", { commitHash: baseline.commitHash ?? null, by: "agent" });
+        return (0, import_helpers.resultWithMeta)({
+          ok: true,
+          commitHash: baseline.commitHash,
+          shortCommitHash: baseline.shortCommitHash,
+          files: baseline.files.size
+        }, n);
+      } catch (err) {
+        if (err instanceof deps.BaselineError) {
+          return { content: [{ type: "text", text: err.message }], isError: true };
+        }
+        throw err;
+      }
+    }
+  );
+  server.registerTool(
+    "list_recent_projects",
+    {
+      description: "List recently opened projects with their paths, display names, branches, and pinned status. Useful for discovering available projects to open.",
+      inputSchema: {}
+    },
+    async () => {
+      const projects = deps.listRecentProjects();
+      if (projects.length === 0) {
+        return { content: [{ type: "text", text: "No recent projects found." }] };
+      }
+      const lines = projects.map(
+        (p) => `- ${p.pinned ? "\u{1F4CC} " : ""}**${p.displayName}** \u2014 \`${p.path}\`${p.branch ? ` (${p.branch})` : ""}`
+      );
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
+  server.registerTool(
+    "pin_project",
+    {
+      description: "Pin a project in the recent projects list so it stays at the top and is never pruned.",
+      inputSchema: {
+        project_path: import_zod.z.string().describe("Absolute path of the project to pin")
+      }
+    },
+    async ({ project_path }) => {
+      if (!deps.getRecentProject(project_path)) return notInRecents(project_path);
+      deps.setRecentProjectPinned(project_path, true);
+      deps.saveNow(() => deps.exportDatabase());
+      return { content: [{ type: "text", text: `Pinned project: ${project_path}` }] };
+    }
+  );
+  server.registerTool(
+    "unpin_project",
+    {
+      description: "Unpin a project from the recent projects list. It will still appear in recents but can be pruned when the list is full.",
+      inputSchema: {
+        project_path: import_zod.z.string().describe("Absolute path of the project to unpin")
+      }
+    },
+    async ({ project_path }) => {
+      if (!deps.getRecentProject(project_path)) return notInRecents(project_path);
+      deps.setRecentProjectPinned(project_path, false);
+      deps.saveNow(() => deps.exportDatabase());
+      return { content: [{ type: "text", text: `Unpinned project: ${project_path}` }] };
+    }
+  );
+  server.registerTool(
+    "remove_recent_project",
+    {
+      description: "Remove a project from the recent projects list entirely.",
+      inputSchema: {
+        project_path: import_zod.z.string().describe("Absolute path of the project to remove")
+      }
+    },
+    async ({ project_path }) => {
+      if (!deps.getRecentProject(project_path)) return notInRecents(project_path);
+      deps.removeRecentProject(project_path);
+      deps.saveNow(() => deps.exportDatabase());
+      return { content: [{ type: "text", text: `Removed from recents: ${project_path}` }] };
+    }
+  );
+  server.registerTool(
+    "close_project",
+    {
+      description: "Close a project tab in the CodeTrellis UI. The human will see the tab disappear. Use list_recent_projects to find paths, or open_project to open a new one.",
+      inputSchema: {
+        project_path: import_zod.z.string().describe("Absolute path of the project to close")
+      }
+    },
+    async ({ project_path }) => {
+      deps.broadcast("ui-close-project", { path: project_path });
+      return { content: [{ type: "text", text: `Closed project tab: ${project_path}` }] };
+    }
+  );
+  server.registerTool(
+    "get_repo_identity",
+    {
+      description: "Read CodeTrellis' identity record for the project at the given path: the local user-facing alias (display name), the normalised git origin URL (the cross-machine identifier used to match the same repo across teammates and devices), the current branch, and recency / pinned flags. Returns null if the project isn't in the recent list.",
+      inputSchema: {
+        project_path: import_zod.z.string().describe("Absolute path of the project")
+      }
+    },
+    async ({ project_path }) => {
+      const project = deps.getRecentProject(project_path);
+      if (!project) {
+        return { content: [{ type: "text", text: JSON.stringify(null) }] };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(project, null, 2) }] };
+    }
+  );
+  server.registerTool(
+    "set_repo_alias",
+    {
+      description: "Set a per-device user-facing label for the project at `project_path`. The alias is local-only \u2014 it never travels in the manifest, so different teammates and even different machines of the same user can show different labels for the same repository. Pass an empty string to reset to the path's basename. The repo's canonical identity for cross-machine matching is its git origin URL, which is unaffected.",
+      inputSchema: {
+        project_path: import_zod.z.string().describe("Absolute path of the project"),
+        alias: import_zod.z.string().describe("New label to show in the UI. Empty string resets to the default.")
+      }
+    },
+    async ({ project_path, alias }) => {
+      const updated = deps.setProjectAlias(project_path, alias);
+      if (!updated) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Project not in recents: ${project_path}` }]
+        };
+      }
+      deps.broadcast("project-alias-changed", { path: project_path, alias: updated.displayName });
+      deps.saveNow(() => deps.exportDatabase());
+      return { content: [{ type: "text", text: JSON.stringify(updated, null, 2) }] };
+    }
+  );
+  server.registerTool(
+    "refresh_repo_origin",
+    {
+      description: "Re-read the git origin URL for the project at `project_path` and update CodeTrellis' cached value. Useful when the user has just run `git remote set-url origin <new>` and wants cross-repo pointer resolution to pick up the change without re-opening the project.",
+      inputSchema: {
+        project_path: import_zod.z.string().describe("Absolute path of the project")
+      }
+    },
+    async ({ project_path }) => {
+      const updated = deps.refreshProjectOriginUrl(project_path);
+      if (!updated) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Project not in recents: ${project_path}` }]
+        };
+      }
+      deps.broadcast("project-origin-changed", { path: project_path, originUrl: updated.originUrl });
+      deps.saveNow(() => deps.exportDatabase());
+      return { content: [{ type: "text", text: JSON.stringify(updated, null, 2) }] };
+    }
+  );
+  server.registerTool(
+    "navigate_item_back",
+    {
+      description: "Navigate backward in the item selection history (like Cmd+[). The history stack records every select_item call and every user click on a plan item. Switching plans (open_plan / set_active_plan) resets the stack. Back pops the last entry; the current item is pushed onto the forward stack. Deterministic: three back calls after select A \u2192 B \u2192 C \u2192 D will land on C, B, A in that order.",
+      inputSchema: {}
+    },
+    async () => {
+      deps.broadcast("ui-navigate-item-back", {});
+      return { content: [{ type: "text", text: "Navigated back in item history" }] };
+    }
+  );
+  server.registerTool(
+    "navigate_item_forward",
+    {
+      description: "Navigate forward in the item selection history (like Cmd+]). Pops the forward stack (populated by navigate_item_back) and pushes the current item onto the back stack. Any new select_item call clears the forward stack (same as browser navigation).",
+      inputSchema: {}
+    },
+    async () => {
+      deps.broadcast("ui-navigate-item-forward", {});
+      return { content: [{ type: "text", text: "Navigated forward in item history" }] };
+    }
+  );
+  server.registerTool(
+    "toggle_activity_drawer",
+    {
+      description: "Toggle the activity drawer in the plan workspace. Shows the activity/comment feed for the current plan.",
+      inputSchema: {}
+    },
+    async () => {
+      deps.broadcast("ui-toggle-activity-drawer", {});
+      return { content: [{ type: "text", text: "Toggled activity drawer" }] };
+    }
+  );
+  server.registerTool(
+    "open_history_drawer",
+    {
+      description: "Open the version history drawer for a specific item. Shows all prior versions with diffs.",
+      inputSchema: {
+        item_uid: import_zod.z.string().describe("UID of the item to show history for")
+      }
+    },
+    async ({ item_uid }) => {
+      const refused = missingItem(item_uid);
+      if (refused) return refused;
+      deps.broadcast("ui-open-history-drawer", { itemUid: item_uid });
+      return { content: [{ type: "text", text: `Opened history drawer for item ${item_uid}` }] };
+    }
+  );
+  server.registerTool(
+    "open_settings",
+    {
+      description: "Open the settings modal in the CodeTrellis UI, at a section when one is named. Showing only: settings that widen what the app can reach are changed by the person, in the window.",
+      inputSchema: {
+        section: import_zod.z.enum(import_types.SETTINGS_SECTIONS).optional().describe('The section to open at, e.g. "data" (the record), "git", "review-hosts", "mcp" (what agents may do).')
+      }
+    },
+    async ({ section }) => {
+      deps.broadcast("ui-open-settings", section ? { section } : {});
+      return { content: [{ type: "text", text: section ? `Opened settings at ${section}` : "Opened settings modal" }] };
+    }
+  );
+  server.registerTool(
+    "close_settings",
+    {
+      description: "Close the settings modal, as Escape does, so what is behind it can be seen again. Changes nothing in settings.",
+      inputSchema: {}
+    },
+    async () => {
+      deps.broadcast("ui-close-settings", {});
+      return { content: [{ type: "text", text: "Closed settings" }] };
+    }
+  );
+  server.registerTool(
+    "open_mcp_guide",
+    {
+      description: "Open the MCP connection guide modal. Shows how to connect agents to CodeTrellis.",
+      inputSchema: {}
+    },
+    async () => {
+      deps.broadcast("ui-open-mcp-guide", {});
+      return { content: [{ type: "text", text: "Opened MCP guide modal" }] };
+    }
+  );
+  server.registerTool(
+    "setup_agent_permissions",
+    {
+      description: "Write a .claude/settings.local.json file in the project directory that auto-approves all CodeTrellis MCP tools. Without this, Claude Code prompts for permission on every MCP tool call, which breaks the flow when the agent is driving the UI. Call this once per project during onboarding. The file is .local (gitignored) so it stays per-user.",
+      inputSchema: {
+        project_path: import_zod.z.string().describe("Absolute path to the project root directory.")
+      }
+    },
+    async ({ project_path: projectPath }) => {
+      const rel = import_node_path.default.join(".claude", "settings.local.json");
+      let settingsPath = import_node_path.default.join(projectPath, rel);
+      try {
+        let settings = {};
+        try {
+          settings = JSON.parse((0, import_confined_fs.readTextWithin)(projectPath, rel, "agent settings"));
+        } catch (err) {
+          if (err instanceof import_confined_fs.ConfinementError) throw err;
+        }
+        if (!settings || typeof settings !== "object" || Array.isArray(settings)) settings = {};
+        if (!settings.permissions) settings.permissions = {};
+        if (!Array.isArray(settings.permissions.allow)) settings.permissions.allow = [];
+        const wildcard = "mcp__codetrellis__*";
+        if (!settings.permissions.allow.includes(wildcard)) {
+          settings.permissions.allow = settings.permissions.allow.filter(
+            (entry) => !entry.startsWith("mcp__codetrellis__")
+          );
+          settings.permissions.allow.push(wildcard);
+        }
+        settingsPath = (0, import_confined_fs.writeFileWithin)(projectPath, rel, JSON.stringify(settings, null, 2) + "\n", "agent settings");
+        return {
+          content: [{
+            type: "text",
+            text: `Auto-approve permissions written to ${settingsPath}
+All CodeTrellis MCP tools are now auto-approved for this project.
+Note: The agent needs to restart the session for this to take effect.`
+          }]
+        };
+      } catch (err) {
+        return {
+          content: [{
+            type: "text",
+            text: `Failed to write permissions: ${err instanceof Error ? err.message : String(err)}`
+          }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  register
+});