drafted 1.16.0 → 1.17.1

package/mcp/server.mjs

@@ -140,10 +140,7 @@ const LOCAL_ONLY_PARAMS = ['file_path'];
 // tool wrapper before the handler runs — so the stdio contract, the Zod runtime
 // validation, and every handler stay byte-for-byte unchanged.
 const REMOTE_JSON_STRING_PARAMS = {
-  frame: ['excalidraw_data', 'elements', 'requests', 'state'],
-  wiki: ['frontmatter', 'pages'],
-  project: ['layers'],
-  template: ['layers'],
+  fs: ['ops', 'state'],
   minion: ['target', 'checklist', 'output'],
   trigger: ['payload'],
 };
@@ -217,6 +214,35 @@ export function receiptOrg({ resourceOrgId, sessionOrg, orgList }) {
   return found || { id: rid, name: null };
 }
 
+// ── Org-scoped path grammar (Shape A: org is the top folder) ────
+// An org is the top of the filesystem: /o/<org>/<root>/... where <root> is
+// wiki | skills | projects. The org is part of the PATH — the agent ADDRESSES an
+// org, it never switches to one — and drives the per-request X-Drafted-Org, so
+// concurrent agents in different orgs cannot affect each other: there is no
+// shared org cursor to clobber. Bare roots (/wiki, /skills, /projects) stay
+// accepted and resolve via the session\'s working org (backward compat).
+// Pure + exported so the grammar is assertable (mcp/test-org-guards.mjs).
+export function splitOrgScope(raw) {
+  if (!/^\/o\//.test(raw || '')) return { path: raw, org: null };
+  const m = String(raw).match(/^\/o\/([^/]+)(?:\/(.*))?$/);
+  if (!m || !m[1]) {
+    return { error: `Invalid org-scoped path: ${raw} — expected /o/<org>/<root>/... where <root> is wiki, skills, or projects` };
+  }
+  return { path: m[2] ? `/${m[2]}` : '/', org: decodeURIComponent(m[1]) };
+}
+
+// Accept a FULL share URL (https://drafted.live/o/...?...) — humans paste links,
+// not paths. The pathname of a Drafted URL IS the fs path (Q2: one canonical link
+// for both consumers), so stripping the origin leaves an addressable path. Falls
+// back to the input unchanged when it isn't a URL. Pure + exported (asserted in
+// mcp/test-org-guards.mjs).
+export function stripUrlOrigin(p) {
+  const s = String(p || '');
+  if (!/^https?:\/\//i.test(s)) return s;
+  try { return new URL(s).pathname; } catch { return s; }
+}
+
+
 export function createMcpServer(transport) {
 // Remote transports (hosted HTTP MCP for claude.ai / ChatGPT) run on the
 // server, not the user's machine, so local-filesystem params like `file_path`
@@ -234,24 +260,24 @@ const server = new McpServer({
   version: PACKAGE_VERSION,
   description: `Multi-tenant design workspace. Structure: Organization → Projects → Layers → Lanes → Frames.
 
-An org contains projects. Each project has a zoomable canvas with frames (HTML files) organized as /{layer}/{lane}/{filename}. Layers are predefined categories (wireframes, designs, brand-assets, etc.), lanes are groups within a layer, and frames are the individual design files.
+Drafted is navigated like a local filesystem — one tool (fs), one path grammar, org first: fs(ls, path="/") lists the orgs you can address, then /o/<org>/wiki/<path> (org knowledge pages), /o/<org>/skills/<slug> (reusable procedures), /o/<org>/projects/<folder?>/<project>/<layer>/<lane>/<file> (frames on a zoomable canvas). The project is resolved from the path itself — no separate "open" step, and the org is part of the path — no org switching.
 
-WORKFLOW: project(action="list") → project(action="open") → ls / → read/write/edit. Projects span all orgs -- opening a project binds this agent session's context, and the org derives from the project. Every response includes a "project" field showing which project you're operating on -- always verify it matches your intent before writing. There is no org switching: address resources by UUID (org self-derives) and pass org=... on creates/searches that name no resource (wiki write, skill add, project create).
+WORKFLOW: fs(ls, path="/") → fs(ls, path="/o/<org>/projects") → fs(read/write/edit, path="/o/<org>/projects/<project>/<layer>/<lane>/<file>"). Address resources by UUID (org self-derives) and write wiki/skills under /o/<org>/... so the org is explicit. (Bare /wiki, /skills, /projects roots still resolve via the session\'s working org.)
 
-SKILLS: Drafted has a skill library -- reusable agent instructions stored as SKILL.md files. When a user says "use the X skill", call skill(action="search") to find it, then skill(action="load") to get its instructions. Skills can cover anything: UX guidelines, copywriting rules, brand voice, coding standards, review checklists, etc.
+SKILLS: /skills/<slug> holds reusable agent instructions (SKILL.md files). When a user says "use the X skill", fs(ls, path="/skills") then fs(read, path="/skills/<slug>"). Skills can cover anything: UX guidelines, copywriting rules, brand voice, coding standards, review checklists, etc.
 
-BREADCRUMBS: When a frame you write or read corresponds to a file in the user's codebase (a component spec, wireframe for a route, design doc for a module), leave a comment in that code file using the canonical token "drafted:<frameId>" wrapped in the file's comment syntax (e.g. "// drafted:abc-123..." for JS/TS, "# drafted:abc-123..." for Python/YAML, "<!-- drafted:abc-123... -->" for HTML/Markdown). Project-level references use "drafted-project:<projectId>" in the project README or CLAUDE.md. Future agents grepping for "drafted:" will discover the link and can pull the frame via read(<frameId>). One line per related frame. Skip for throwaway or exploratory frames.
+BREADCRUMBS: When a frame you write or read corresponds to a file in the user's codebase (a component spec, wireframe for a route, design doc for a module), leave a comment in that code file using the canonical token "drafted:<frameId>" wrapped in the file's comment syntax (e.g. "// drafted:abc-123..." for JS/TS, "# drafted:abc-123..." for Python/YAML, "<!-- drafted:abc-123... -->" for HTML/Markdown). Project-level references use "drafted-project:<projectId>" in the project README or CLAUDE.md. Future agents grepping for "drafted:" will discover the link and can pull the frame via fs(read, path="/f/<frameId>"). One line per related frame. Skip for throwaway or exploratory frames.
 
 CONTEXT RULES (follow these before every action):
-  - WIKI CHECK: Before acting on any request, search the org wiki for relevant conventions, existing designs, and prior decisions. Use wiki(action="search") with relevant keywords.
+  - WIKI CHECK: Before acting on any request, search the org wiki for relevant conventions, existing designs, and prior decisions. Use fs(search, query="<terms>") with the /wiki root.
   - LAYER CONTEXT: Before reading or mutating a frame, read all anchored frames in the same layer. Anchored frames are per-layer required reading (style guides, design systems, conventions). The server enforces this mechanically for writes/edits/deletes/moves — but proactively reading anchored frames before any frame operation prevents wasted work.
-IMPORTANT: Any URL containing /f/{uuid} is a Drafted frame link — ALWAYS use read(path=URL) to get frame content, focus(target=URL) to pan the canvas to it. Never curl or WebFetch Drafted URLs.
+IMPORTANT: Any URL containing /f/{uuid} is a Drafted frame link — ALWAYS use fs(read, path=URL) to get frame content, focus(target=URL) to pan the canvas to it. Never curl or WebFetch Drafted URLs.
 
 LINKING: link the user to the narrowest thing you touched, never the project as a stand-in. Wrote or edited ONE frame → give its \`frameUrl\` (from the write/read/ls response). Touched a whole lane → its \`laneUrl\`; a whole layer → its \`layerUrl\` (both on the matching \`ls\` entries). Only when the work spans the project is the project URL the right link. A project link where a frame link was available makes the user hunt the surface for what you just did.`,
 }, {
   // Initialize instructions: the agent-identity contract, so an agent learns its own
   // tab name + the right way to read it WITHOUT having to "think to" call a tool.
-  instructions: `SESSION IDENTITY — read this first: you run as a NAMED session tab visible to the user on their Drafted surface. Your session has a human-readable name (a Greek term, e.g. "Nous") — that name is how the user matches YOUR window to the tab they see, so identify yourself by it when it matters which agent you are. Read it from get_org (response field "session.name") or from the whoami tool; call whoami to refresh after a reconnect.
+  instructions: `SESSION IDENTITY — read this first: you run as a NAMED session tab visible to the user on their Drafted surface. Your session name is how the user matches YOUR window to the tab they see. NAME YOURSELF on first connect: call whoami first — if it reports nameRequired, all other tools are gated until you set a short 2-3 word name describing the work with session(action="name", name="...") (whoami suggests one from your working directory). The name persists across reconnects, so you only set it once. Read your name from the whoami tool; call whoami to refresh after a reconnect.
 
 DUAL REGISTRATION IS NORMAL: a separate "Drafted" remote connector (https://drafted.live/mcp, managed by claude.ai) may appear alongside this local stdio server in MCP listings. It is NOT a duplicate and NOT broken — it serves claude.ai web/mobile/Cowork, where a local stdio process cannot run. Never advise removing it; a "needs authentication" state on it is fixed by signing in from claude.ai and does not affect this stdio session.${isRemote ? `
 
@@ -275,76 +301,31 @@ const TOOL_ANNOTATIONS = {
   auth:                { title: 'Sign in',             readOnlyHint: false, destructiveHint: false, openWorldHint: true,  description: 'Sign in to Drafted. `action=get_link` returns a URL immediately and starts background approval polling; after the user opens the link, later Drafted tool calls also auto-consume the approved login. `action=login` opens a browser when needed and explicitly waits/polls for approval.' },
 
   // Identity — read-only introspection of THIS agent's session
-  whoami:              { title: 'Session identity',    readOnlyHint: true,  destructiveHint: false, openWorldHint: false, description: 'Return THIS agent session\'s identity: its server-assigned human-readable name (the correlation key between an agent window and its web-app session tab), sessionId, userId, orgId, active projectId, editor label, server URL, and surfaced/alive state. Read-only. Use this — not guesses from the host environment — to report which session you are.' },
-
-  // Health — call once per session, right after whoami and before any real work
-  health:              { title: 'Server health',       readOnlyHint: true,  destructiveHint: false, openWorldHint: true,  description: 'Server reachability + installed MCP version/update status. Call this once per session, right after whoami and before doing any real work, so a required update surfaces before you act on stale tool behavior.' },
-
-  // Projects
-  project:             { title: 'Projects',            readOnlyHint: false, destructiveHint: false, openWorldHint: false, widgetUri: 'ui://widget/drafted-canvas-overview.html', description: 'Manage projects: list (start here), open (bind this agent session to a project — org derives from it), create (org= names where it is born), update, move to another org.' },
-  get_org:             { title: 'Organization',        readOnlyHint: true,  destructiveHint: false, openWorldHint: false, description: 'List your orgs, the default org, and Google Drive availability (action="get", default), or fetch installed MCP update instructions (action="update_mcp"). There is no org switching — org derives from the resource you address; creates/searches take org=. When googleDrive.connected is true, strongly prefer Google Workspace frames for documents, sheets, and slides.' },
+  whoami:              { title: 'Session identity',    readOnlyHint: true,  destructiveHint: false, openWorldHint: false, description: 'Return THIS agent session\'s identity: its server-assigned human-readable name (the correlation key between an agent window and its web-app session tab), sessionId, userId, orgId, active projectId, editor label, server URL, and surfaced/alive state — PLUS server health and the installed MCP version/update status (cached ~5min). Call once per session, right after starting, so a required update surfaces before you act on stale tool behavior. Read-only. Use this — not guesses from the host environment — to report which session you are.' },
 
-  // Templates
-  template:            { title: 'Templates',            readOnlyHint: false, destructiveHint: true,  openWorldHint: false, description: 'Manage project templates: list, create, update, delete, fork.' },
-
-  // Layers
-  layer:               { title: 'Layers',              readOnlyHint: false, destructiveHint: true,  openWorldHint: false, description: 'Manage layers in a project: add, update, remove, reorder.' },
-
-  // Frames — filesystem
-  ls:                  { title: 'List frames',         readOnlyHint: true,  destructiveHint: false, openWorldHint: false, widgetUri: 'ui://widget/drafted-canvas-overview.html' },
-  frame:               { title: 'Frames',              readOnlyHint: false, destructiveHint: true,  openWorldHint: true, widgetUri: 'ui://widget/drafted-frame-preview.html', description: 'Read, write, edit, move, anchor, search, restore frame versions, create Google Workspace frames, or write values into Google Sheet frames in the ACTIVE PROJECT. Dispatch by `action`. Use `ls` to browse, `rm` to delete.' },
-  rm:                  { title: 'Delete frame',        readOnlyHint: false, destructiveHint: true,  openWorldHint: false },
-  // batch:               { title: 'Batch operations',   readOnlyHint: false, destructiveHint: true,  openWorldHint: false },
+  // Session naming — the name-before-work gate: every agent session must set a short
+  // name describing the work before any other tool call succeeds.
+  session:             { title: 'Session',              readOnlyHint: false, destructiveHint: false, openWorldHint: false, description: 'Name THIS agent session (and rename it later). The name is what the user sees on your surface tab — pick a short 2-3 word description of the work (e.g. "beoflow backend", "drafted fs work"). The name persists across reconnects and restarts; you only set it once unless the work changes. Dispatch by `action`: `name` (set/rename with the `name` param).' },
 
   // Canvas / view
   focus:               { title: 'Focus on target',     readOnlyHint: false, destructiveHint: false, openWorldHint: false, description: 'Pan the canvas viewport for connected clients to a frame, lane, or layer.' },
   screenshot:          { title: 'Screenshot',          readOnlyHint: true,  destructiveHint: false, openWorldHint: false, description: 'Render a PNG via headless browser. `scope=frame` for a single frame, `scope=canvas` for a region of the project surface.' },
 
-  // Assets
-  asset:               { title: 'Assets',              readOnlyHint: false, destructiveHint: false, openWorldHint: false, description: 'Manage project assets (CSS/JS/images/fonts referenced by frames). `action=upload` or `action=list`.' },
-
-  // Connectors / layout
-  connector:           { title: 'Connectors',          readOnlyHint: false, destructiveHint: true,  openWorldHint: false, description: 'Connect or disconnect frames with arrows on the surface. `action=connect` or `action=disconnect`.' },
-  layout:              { title: 'Auto-layout',         readOnlyHint: false, destructiveHint: false, openWorldHint: false },
-
-  // Skills
-  skill:               { title: 'Skills',              readOnlyHint: false, destructiveHint: true,  openWorldHint: false, description: 'Manage the Drafted skill library: search, load, add, update, remove, attach/detach from projects, favorite, and edit skill files.' },
-  wiki:                { title: 'Wiki',                readOnlyHint: false, destructiveHint: true,  openWorldHint: false, description: 'Per-org wiki. Markdown pages with paths as hierarchy. Dispatch by `action`.' },
-
   // Minions — checklist-driven intake surfaces bound to a project
-  minion:              { title: 'Minions',             readOnlyHint: false, destructiveHint: true,  openWorldHint: false, description: 'Manage Minions: checklist-driven intake surfaces that guide a consumer through a checklist (via a shareable /c/<slug> link) and then write a producible into the project. Dispatch by `action`: meta (discover layers/lanes/frames), list, get, create, update, enable, disable, delete. QA your own Minions with test_start/test_say/test_resolve — drive the checklist conversation yourself (works even when disabled) and verify it produces the right Doc/Sheet output. Requires the agent allowlist.' },
-  trigger:             { title: 'Inbound triggers',    readOnlyHint: false, destructiveHint: true,  openWorldHint: true,  description: 'Manage inbound webhook triggers for the ACTIVE PROJECT: an external system (AppSheet bot, GitHub, form tool) POSTs to the trigger URL and the server runs an agent conversation in the project from the stored prompt template + payload. Dispatch by `action`: create (returns URL + secret token ONCE — relay it to the user immediately, it is not retrievable later), list, update (enable/disable, edit template, daily limit, executor), rotate (new token), test (fire a synthetic delivery), deliveries (audit log), delete; for executor="queue" triggers, pending/claim/complete let a LOCAL agent poll and work queued deliveries. Requires the agent allowlist.' },
+  minion:              { title: 'Minions',             readOnlyHint: false, destructiveHint: true,  openWorldHint: false, description: 'Manage Minions: checklist-driven intake surfaces that guide a consumer through a checklist (via a shareable /c/<slug> link) and write a producible into the project. Dispatch by `action`: meta, list, get, create, update, enable, disable, delete. QA your own Minions with test_start/test_say/test_resolve — drive the checklist conversation yourself (works even when disabled). Requires the agent allowlist.' },
+  trigger:             { title: 'Inbound triggers',    readOnlyHint: false, destructiveHint: true,  openWorldHint: true,  description: 'Manage inbound webhook triggers for the ACTIVE PROJECT: an external system (AppSheet bot, GitHub, form tool) POSTs to the trigger URL and the server runs an agent conversation in the project from the stored prompt template + payload. Dispatch by `action`: create (returns URL + secret token ONCE — relay it to the user immediately, not retrievable later), list, update (enable/disable, edit template, daily limit, executor), rotate (new token), test (fire a synthetic delivery), deliveries (audit log), delete; for executor="queue" triggers, pending/claim/complete let a LOCAL agent poll and work queued deliveries. Requires the agent allowlist.' },
+  fs:                  { title: 'Filesystem',           readOnlyHint: false, destructiveHint: true,  openWorldHint: false, description: 'Navigate Drafted like a local filesystem: /wiki/<path> pages, /skills/<slug> procedures, /projects/<folder?>/<project>/<layer>/<lane>/<file> frames. Verbs: ls, read, write, edit, mv, rm, search.' },
 };
 
 function isMutatingToolCall(name, args = {}) {
   const action = args?.action;
   switch (name) {
-    case 'project':
-      return ['create', 'update', 'move'].includes(action);
-    case 'template':
-      return ['create', 'update', 'delete', 'fork'].includes(action);
-    case 'layer':
-      return ['add', 'update', 'remove', 'reorder'].includes(action);
-    case 'frame':
-      return ![
-        'read', 'search', 'versions', 'read_version',
-        'get_sheet', 'read_sheet_values',
-        'get_doc', 'read_doc_content',
-        'get_slide', 'read_slide_content',
-        'get_excel', 'read_excel_range',
-      ].includes(action);
-    case 'asset':
-      return ['upload', 'rm'].includes(action);
-    case 'skill':
-      return ['add', 'update', 'remove', 'attach', 'detach', 'favorite', 'unfavorite', 'update_file'].includes(action);
-    case 'wiki':
-      return ['log', 'write', 'edit', 'mv', 'rm', 'source-register', 'bulk-write'].includes(action);
     case 'minion':
       return ['create', 'update', 'enable', 'disable', 'delete', 'test_start', 'test_say', 'test_resolve'].includes(action);
-    case 'rm':
-    case 'connector':
-    case 'layout':
-      return true;
+    case 'trigger':
+      return ['create', 'update', 'rotate', 'delete'].includes(action);
+    case 'fs':
+      return !['ls', 'read', 'search'].includes(action);
     default:
       return false;
   }
@@ -1109,7 +1090,7 @@ async function api(method, path, body, extraHeaders = {}, _retried = false, _org
       if (sess._stdio) savePersistedProject(null, { serverUrl: getServerUrl() });
       throw new Error(
         `${msg} — the active project (${meta?.slug || pid}) is no longer in the current org. ` +
-        `Active project cleared. Call project(action="open") to set a new one, or proceed without one for org-scoped tools (wiki, skill).`
+        `Active project cleared. Address an /o/<org>/projects/<project>/... path or fs(ls, path="/o/<org>/projects") to bind one; org-scoped wiki/skills (fs /o/<org>/wiki, fs /o/<org>/skills) work without it.`
       );
     }
     // Attach the structured body so callers can key off machine-readable fields
@@ -1117,6 +1098,13 @@ async function api(method, path, body, extraHeaders = {}, _retried = false, _org
     const apiErr = new Error(msg);
     apiErr.status = res.status;
     if (data && typeof data === 'object') { apiErr.code = data.code; apiErr.body = data; }
+    // Name-before-work gate: enrich the server message with the LOCAL working-directory
+    // suggestion (the server doesn't know cwd) so the agent can accept it in one call
+    // even if it never ran whoami.
+    if (apiErr.code === 'session_unnamed') {
+      const suggest = getSuggestedSessionName();
+      if (suggest) apiErr.message += ` Suggested from your working directory: "${suggest}" — accept it with session(action="name", name="${suggest}") or pick your own 2-3 word name.`;
+    }
     throw apiErr;
   }
   return data;
@@ -1184,8 +1172,8 @@ function shapeSkillCatalog(result, { limit, offset = 0, compact = false } = {})
   result.truncated = start + page.length < total;
   result.skills = page.map(compact ? compactSkillEntry : summarizeSkillForSearch);
   result.note = compact
-    ? 'Compact catalog: {slug,name,tags} only. Load full content with skill(action="load", skill="<slug>"). Pass compact=false for descriptions/triggerPatterns; use offset to page.'
-    : 'Search/list returns skill summaries only (no SKILL.md body). Use skill(action="load", skill="<slug-or-id>") for full content. Pass compact=true for a leaner {slug,name,tags} catalog; use limit/offset to page.';
+    ? 'Compact catalog: {slug,name,tags} only. Load full content with fs(read, path="/skills/<slug>"). Pass compact=false for descriptions/triggerPatterns; use offset to page.'
+    : 'Search/list returns skill summaries only (no SKILL.md body). Use fs(read, path="/skills/<slug-or-id>") for full content. Pass compact=true for a leaner {slug,name,tags} catalog; use limit/offset to page.';
   return result;
 }
 
@@ -1319,6 +1307,20 @@ function setMcpActiveProject(projectId, meta = null) {
 // ponytail: process-lifetime cache, no TTL — a project rename goes stale until restart.
 // Add invalidation if renames ever become common.
 const projectRefCache = new Map();
+
+// Does an org-scoped path's org segment (/o/<org>/...) address the org of a
+// resolved project? Accepts the org id, slug, or name. Rejects paths whose org
+// segment contradicts the project's row org — the silent-strip gap in the old
+// URL-form alias, where /o/<orgX>/projects/<projInOrgY>/... wrote to orgY as if
+// orgX had been addressed.
+async function pathOrgMatches(orgSegment, meta) {
+  if (meta?.orgId && orgSegment === meta.orgId) return true;
+  if (meta?.orgSlug && orgSegment === meta.orgSlug) return true;
+  const orgs = await getOrgList();
+  const hit = orgs.find(o => o.id === orgSegment || (o.slug && o.slug === orgSegment) || (o.name || '').toLowerCase() === String(orgSegment).toLowerCase());
+  return !!hit && meta?.orgId === hit.id;
+}
+
 async function resolveProjectRef(ref) {
   if (!ref) return null;
   const hit = projectRefCache.get(ref);
@@ -1337,6 +1339,87 @@ async function resolveProjectRef(ref) {
   return meta;
 }
 
+/**
+ * Resolve a project argument to its meta, accepting the pseudo-filesystem path
+ * form (/projects/<name> or /projects/<folder>/<name>) OR a bare slug / name /
+ * UUID — all through the same resolver, so every tool that names a project
+ * behaves identically. Throws with a clear message when missing or unknown.
+ */
+async function resolveProjectArg(projectArg, { required = true } = {}) {
+  if (!projectArg) {
+    if (!required) return null;
+    throw new Error('project required — pass it as /projects/<name> (e.g. projectId="/projects/beoflow"), a slug, or a UUID');
+  }
+  let ref = String(projectArg);
+  // Org-scoped path (/o/<org>/projects/<name>) and bare root form
+  // (/projects/<name> or /projects/<folder>/<name>) → take the last segment as the ref.
+  const scoped = splitOrgScope(ref);
+  if (scoped.error) throw new Error(scoped.error);
+  ref = scoped.path || '';
+  if (ref.startsWith('/projects')) {
+    const parts = ref.replace(/^\/projects\/?/, '').split('/').filter(Boolean);
+    if (parts.length === 0) throw new Error(`Invalid project path: ${projectArg}`);
+    ref = parts[parts.length - 1];
+  }
+  const meta = await resolveProjectRef(ref);
+  if (!meta) throw new Error(`Project not found: ${projectArg} — list projects with fs(ls, path="/projects")`);
+  return meta;
+}
+
+/**
+ * Resolve a pseudo-filesystem path to a frame ID.
+ * Accepts:
+ *   /projects/<project>/<layer>/<lane>/<file>   (canonical)
+ *   /projects/<folder>/<project>/<layer>/<lane>/<file>
+ *   /projects/<project>/<layer>/<file>          (layer-root file)
+ *   /o/<org>/projects/<project>/<layer>/<lane>/<file>  (URL form)
+ *   /f/<uuid> | bare UUID
+ * Returns { frameId } or throws with a helpful message.
+ */
+async function resolveFsFramePath(path) {
+  const urlMatch = String(path).match(/\/f\/([a-f0-9-]{36})/);
+  const uuidMatch = String(path).match(/^[a-f0-9-]{36}$/);
+  if (urlMatch?.[1] || uuidMatch) return { frameId: urlMatch?.[1] || uuidMatch[0] };
+
+  const p = stripUrlOrigin(String(path));
+  // URL form: /o/<org>/projects/<project>/<layer>/<lane>/<file>
+  let fsPath = p;
+  const urlForm = p.match(/^\/o\/[^/]+\/projects\/(.+)$/);
+  if (urlForm) fsPath = '/projects/' + urlForm[1];
+  if (!fsPath.startsWith('/projects')) {
+    throw new Error('Target must be a frame URL, frame ID, or path /projects/<project>/<layer>/<lane>/<file>');
+  }
+
+  const parts = fsPath.replace(/^\/projects\/?/, '').split('/').filter(Boolean);
+  if (parts.length < 3) throw new Error('Path must include the project, layer, and file: /projects/<project>/<layer>/<lane>/<file>');
+  // <project>/<layer>/<lane>/<file> (no folder) or <folder>/<project>/<layer>/<lane>/<file>
+  const projectRef = parts.length === 4 ? parts[0] : parts.length >= 5 ? parts[1] : parts[0];
+  let layer, lane = null, filename;
+  if (parts.length >= 4) {
+    // canonical: .../<layer>/<lane>/<file>
+    layer = parts[parts.length - 3];
+    lane = parts[parts.length - 2];
+    filename = parts[parts.length - 1];
+  } else {
+    // 3 segments after project: <layer>/<file> (layer-root) or <layer>/<lane> (lane view).
+    // A filename has an extension; a lane name usually doesn't.
+    layer = parts[1];
+    if (/\.[a-z0-9]+$/i.test(parts[2])) {
+      filename = parts[2]; // layer-root file
+    } else {
+      throw new Error('Path must include a file: /projects/<project>/<layer>/<lane>/<file>');
+    }
+  }
+  const meta = await resolveProjectRef(projectRef);
+  if (!meta) throw new Error(`Project not found: ${projectRef}`);
+  const filePath = lane
+    ? `${encodeURIComponent(layer)}/${encodeURIComponent(lane)}/${encodeURIComponent(filename)}`
+    : `${encodeURIComponent(layer)}/${encodeURIComponent(filename)}`;
+  const frame = await withProjectOverride(meta, () => api('GET', `/api/fs/${filePath}`));
+  if (!frame?.id) throw new Error(`Frame not found: ${path}`);
+  return { frameId: frame.id };
+}
+
 // Run one tool call against a caller-named project WITHOUT rebinding the session.
 // The override lives in this call's AsyncLocalStorage frame only — request-local, so
 // it satisfies the DRAFT-36 addressing invariant (no shared, another-session-writable
@@ -1353,12 +1436,12 @@ function withProjectOverride(meta, fn) {
 
 // Tools that address frames/assets/layout inside ONE project. These accept the
 // per-call `projectId` override; everything else resolves org-side.
-const PROJECT_SCOPED_TOOLS = new Set(['frame', 'ls', 'rm', 'asset', 'connector', 'layout']);
+const PROJECT_SCOPED_TOOLS = new Set(['fs']);
 
 const PROJECT_OVERRIDE_PARAM = z.string().optional().describe(
   'Target project (UUID, slug, or name) for THIS call only — does NOT rebind the session. ' +
   'Use it when the session lost its binding (a reconnect), or to touch another project once ' +
-  'without re-opening it. Omit to use the project bound by project(action="open").',
+  'without re-opening it. Omit to derive the project from the path (/projects/<project>/...).',
 );
 
 // Returns { id, slug, name, orgId } for the project this MCP session most
@@ -1396,7 +1479,9 @@ async function connectAgentWs() {
     console.error('[MCP-WS] Connected');
     // Announce presence immediately so the agent surfaces (greyed/idle, no project) the
     // moment it connects — before opening any project. Project work later flips it active.
-    try { agentWs.send(JSON.stringify({ type: 'agent-hello', agentLabel: getAgentLabel() })); } catch {}
+    // suggestedName (basename of the working directory) lets the server offer it in the
+    // name-before-work gate message and as the tab placeholder.
+    try { agentWs.send(JSON.stringify({ type: 'agent-hello', agentLabel: getAgentLabel(), suggestedName: getSuggestedSessionName() })); } catch {}
     if (getState().projectId) {
       agentWs.send(JSON.stringify({ type: 'join', projectId: getState().projectId, agent: true, agentLabel: getAgentLabel() }));
     }
@@ -1411,6 +1496,7 @@ async function connectAgentWs() {
         agentSurface = {
           sessionId: m.sessionId, userId: m.userId, orgId: m.orgId, projectId: m.projectId,
           name: m.name, capital: m.capital, color: m.color, alive: m.alive, surfaced: true,
+          nameRequired: !!m.nameRequired, suggestedName: m.suggestedName || null,
           capturedAt: Date.now(),
         };
       }
@@ -1446,6 +1532,21 @@ function getAgentLabel() {
   return proj ? `${editor} - ${proj}` : editor;
 }
 
+// Suggested session name for the name-before-work gate: the user-set DRAFTED_AGENT_NAME
+// when present (it describes the work), else the basename of this process's working
+// directory — the durable session context Claude Code / Codex / pi all record per session
+// (their transcripts carry cwd; the MCP stdio process is spawned there). Terminal tabs
+// use the same convention, so the user recognizes it.
+function getSuggestedSessionName() {
+  const explicit = (process.env.DRAFTED_AGENT_NAME || '').trim();
+  if (explicit) return explicit;
+  try {
+    const base = basename(process.cwd());
+    if (base && base !== '/') return base;
+  } catch { /* fall through */ }
+  return null;
+}
+
 async function joinAgentWsRoom(projectId) {
   // Ensure WS is connected (may not be after restart/session re-clone)
   if (!agentWs || agentWs.readyState > WebSocket.OPEN) {
@@ -1461,12 +1562,12 @@ async function joinAgentWsRoom(projectId) {
 }
 
 // Tools that are pure introspection/sign-in, not "the agent started working" — excluded from
-// the first-substantive-action ping below so a bare whoami/health/auth never yanks the
+// the first-substantive-action ping below so a bare whoami/auth never yanks the
 // desktop app's window to the front.
-const NON_SUBSTANTIVE_TOOLS = new Set(['whoami', 'health', 'auth']);
+const NON_SUBSTANTIVE_TOOLS = new Set(['whoami', 'auth']);
 let hasAnnouncedSubstantiveWork = false;
 
-// Tell the server this agent has started real work (first call past whoami/health/auth this
+// Tell the server this agent has started real work (first call past whoami/auth this
 // process), so it can foreground the desktop app's window. Fire-and-forget — never blocks or
 // fails the tool call that triggered it.
 async function announceSubstantiveWork() {
@@ -1552,22 +1653,23 @@ async function requireBoundOrgForProjectlessMutation(explicitOrg) {
     return;
   }
   if (projectlessMutationNeedsOrg({ orgCount: orgs.length })) {
-    // Actionable, not a dead end: name the orgs and the ONE call that binds this session,
-    // so the agent recovers itself instead of stalling on the human. Project-less wiki and
-    // skill work is a first-class flow — no project required, ever. The only thing refused
-    // is GUESSING which org, which is what silently misfiled a page into the user's
-    // default org. (Listing the orgs is safe: they're the caller's own memberships.)
+    // Actionable, not a dead end: name the orgs and the address that resolves it.
+    // Project-less wiki and skill work is a first-class flow — no project required, ever.
+    // The only thing refused is GUESSING which org, which is what silently misfiled a
+    // page into the user's default org. (Listing the orgs is safe: they're the caller's
+    // own memberships.) Shape A recovery: the org is the top folder — address it in the
+    // path, no binding call exists anymore (fs(ls, path="/", org=...) does NOT bind).
     const names = orgs.map(o => o.name || o.id).filter(Boolean);
     throw new Error(
       `Which org? A project-less wiki/skill write needs one, and you belong to ${orgs.length}: ` +
       `${names.join(', ')}. Don't guess — an unaddressed write lands in whichever org this ` +
       `session inherited, which is how a page meant for one org ends up in another.\n` +
-      `Recover with ONE call: get_org(action="use", org="<name>"). That binds this session's ` +
-      `working org — every later project-less wiki/skill write then just works, with no project ` +
-      `and no org= to repeat. Prefer it over passing org= per call, which pays this toll on ` +
-      `every write.\n` +
-      `(Alternatives: org="<name>" on this single call; or project(action="open") if the work ` +
-      `belongs to a project — the org derives from it.)\n` +
+      `Address the org in the PATH — it's the top folder of the filesystem: ` +
+      `fs(ls, path="/") lists your orgs, then write to /o/<org>/wiki/... or ` +
+      `/o/<org>/skills/... — the org is part of the path, and every later write to that ` +
+      `path just works with no org= and no project.\n` +
+      `(Alternatives: org="<name>" on this single call; or a /o/<org>/projects/<project>/... ` +
+      `path — the org derives from the project.)\n` +
       `Pick from the conversation if the org is clear from context; ask the user only if it isn't.`
     );
   }
@@ -1582,9 +1684,15 @@ async function getOrgList() {
   if (sess.cachedOrgs && Date.now() - (sess.cachedOrgsTime || 0) < 30000) return sess.cachedOrgs;
   try {
     const d = await api('GET', '/api/orgs');
-    sess.cachedOrgs = (d.orgs || d || []).map(o => ({ id: o.orgId || o.id, name: o.orgName || o.name }));
+    sess.cachedOrgs = (d.orgs || d || []).map(o => ({ id: o.orgId || o.id, name: o.orgName || o.name, slug: o.slug || null, isActive: !!o.isActive }));
     sess.cachedOrgsTime = Date.now();
-  } catch { sess.cachedOrgs = sess.cachedOrgs || []; }
+  } catch (e) {
+    // The name-before-work gate must surface, not be swallowed by this defensive catch —
+    // otherwise an unnamed agent sees "no orgs to list" instead of the gate that tells
+    // it to name itself. Everything else degrades to [] ("can't determine membership").
+    if (e?.code === 'session_unnamed') throw e;
+    sess.cachedOrgs = sess.cachedOrgs || [];
+  }
   return sess.cachedOrgs;
 }
 
@@ -1666,7 +1774,7 @@ async function checkOrgSkills(orgId, operation) {
   const loaded = getSessionState().loadedSkillIds;
   const unloaded = skills.filter(s => !loaded.has(s.id));
   if (unloaded.length === 0) return null;
-  const lines = unloaded.map(s => `  skill(action="load", skill="${s.slug || s.id}")  -- ${s.name}`);
+  const lines = unloaded.map(s => `  fs(read, path="/skills/${s.slug || s.id}")  -- ${s.name}`);
   return `This org has ${skills.length} attached skill(s) that must be loaded before making changes. ` +
     `Unloaded skills:\n${lines.join('\n')}\n\n` +
     `Load all attached skills first, then retry your operation. Skills tell you HOW to do the work — they're not optional.`;
@@ -1800,7 +1908,11 @@ async function launchDesktopSignin() {
     const child = spawn(bin, ['--open-login'], {
       detached: true,
       stdio: 'ignore',
-      env: { ...process.env, DRAFTED_OPEN_LOGIN: '1' },
+      // DRAFTED_OPEN_LOGIN=1 makes a fresh primary instance open sign-in on boot. The app's
+      // base_url() reads DRAFTED_DESKTOP_URL (default https://drafted.live) — pass the server
+      // this MCP is bound to, or a local install's sign-in window would target production and
+      // the cookie→auth.json bridge would write the production file, never DRAFTED_AUTH_FILE.
+      env: { ...process.env, DRAFTED_OPEN_LOGIN: '1', DRAFTED_DESKTOP_URL: getServerUrl() },
     });
     child.unref();
     return true;
@@ -1966,6 +2078,8 @@ async function sessionSurfaceBlock() {
       color: agentSurface.color,
       surfaced: true,
       alive: !!agentSurface.alive,
+      nameRequired: !!agentSurface.nameRequired,
+      suggestedName: agentSurface.suggestedName || getSuggestedSessionName(),
       // `alive` was ambiguous: agents couldn't tell whether it meant "your writes are
       // no-ops" (act differently) or "the user's canvas tab is closed" (ignore). It's the
       // latter — say so, so nobody changes behavior over it.
@@ -1974,7 +2088,8 @@ async function sessionSurfaceBlock() {
         : 'No canvas surface is currently open for this session. Frame, wiki, and skill writes all persist normally — only focus/presence have nothing to draw on. Do not change what you write because of this.',
     };
   }
-  // No WS ack yet — best-effort identity from /auth/me so callers still get a userId/org.
+  // No WS ack yet — best-effort identity from /auth/me so callers still get a userId/org
+  // AND the name-before-work gate state (the WS ack races the first tool call).
   const cookieSid = sessionId || getBootstrapSessionId();
   let me = null;
   let unreachable = false;
@@ -1992,13 +2107,16 @@ async function sessionSurfaceBlock() {
       if (String(e?.message || '').startsWith('TLS interception')) unreachableWhy = e.message;
     }
   }
+  const nameRequired = !!me?.agentClone && !me?.surfaceName;
   return {
     sessionId: cookieSid,
     userId: me?.userId ?? null,
     orgId: me?.currentOrg?.id ?? null,
     projectId: getState().projectId ?? null,
-    name: null,
-    capital: null,
+    name: me?.surfaceName ?? null,
+    capital: me?.surfaceName ? (me.surfaceName[0] || '').toUpperCase() : null,
+    nameRequired,
+    suggestedName: getSuggestedSessionName(),
     color: null,
     surfaced: false,
     alive: false,
@@ -2009,18 +2127,30 @@ async function sessionSurfaceBlock() {
   };
 }
 
-// Identity: report THIS agent session's own surface identity. Read-only — no state changed.
-tool('whoami', 'Return THIS agent session\'s identity: its server-assigned human-readable name (the correlation key between an agent window and its web-app session tab), sessionId, userId, orgId, active projectId, editor label, server URL, and surfaced/alive state. Read-only.', {}, async () => {
+// Identity + server health: report THIS agent session's own surface identity, server
+// reachability, and installed-MCP staleness in ONE bootstrap call. The update data is
+// cached (5min), so repeat `whoami` calls are free; the server-side update gate still
+// blocks mutating calls on its own, independent of this tool. Read-only — no state changed.
+tool('whoami', 'Return THIS agent session\'s identity: its server-assigned human-readable name (the correlation key between an agent window and its web-app session tab), sessionId, userId, orgId, active projectId, editor label, server URL, and surfaced/alive state — PLUS server health and the installed MCP version/update status (cached ~5min). Call once per session, right after starting, so a required update surfaces before you act on stale tool behavior. Read-only.', {}, async () => {
   try {
+    // Ensure the child clone exists BEFORE reading identity — otherwise the /auth/me
+    // fallback (pre-WS-ack) queries the ROOT session and reports the wrong naming state.
+    await ensureSession();
     const block = await sessionSurfaceBlock();
+    const mcpUpdate = await getCachedMcpUpdateMetadata();
     // Tell the agent to actually surface its name to the user — returning `name` in the JSON isn't
     // enough; without an explicit instruction agents rarely say which session they are, so users
     // can't match them to their tab on the Drafted surface.
-    const instruction = block.name
-      ? `You are the session named "${block.name}". Tell the user you're "${block.name}" in your reply so they can match you to your tab on the Drafted surface.`
-      : undefined;
+    const instruction = block.nameRequired
+      ? `You have NO session name yet — the name-before-work gate blocks all other tools until you set one. Name this session by the work you're doing with the user: a short 2-3 word description (suggested: "${block.suggestedName || '...'}"). Set it now with session(action="name", name="<your name>"), then tell the user you're "<name>".`
+      : block.name
+        ? `You are the session named "${block.name}". Tell the user you're "${block.name}" in your reply so they can match you to your tab on the Drafted surface.`
+        : undefined;
     return ok({
       server: getServerUrl(),
+      ok: mcpUpdate.status !== 'unknown',
+      mcpVersion: PACKAGE_VERSION,
+      mcpUpdate,
       editor: (process.env.DRAFTED_AGENT_NAME || '').trim() || null,
       agentLabel: getAgentLabel(),
       ...block,
@@ -2029,342 +2159,29 @@ tool('whoami', 'Return THIS agent session\'s identity: its server-assigned human
   } catch (error) { return err(error); }
 });
 
-// Health: server reachability + installed-MCP staleness, meant to be the second call of a
-// session (right after whoami, before real work) so a required update surfaces early instead
-// of depending on an agent remembering to call get_org. Cached per-process — `whoami` stays
-// network-free between health checks, and repeat `health` calls in one session are free too.
-tool('health', {}, async () => {
+// Session naming: set/rename THIS agent session's name — the name-before-work gate stays
+// closed until this succeeds. The name persists server-side (sessions.surface_name), so
+// reconnects and server restarts keep it and the gate never re-fires for a named session.
+tool('session', 'Name THIS agent session (and rename it later). The name is what the user sees on your surface tab — pick a short 2-3 word description of the work (e.g. "beoflow backend", "drafted fs work"). The name persists across reconnects and restarts; you only set it once unless the work changes.', {
+  action: z.enum(['name']).describe('Operation — currently only `name` (set/rename this session).'),
+  name: z.string().optional().describe('[name] the session name — a short 2-3 word description of the work (e.g. "beoflow backend"). Max 5 words / 50 chars.'),
+}, async ({ action, name }) => {
+  if (action !== 'name') return err(new Error(`unknown session action: ${action}`));
+  if (!name || !String(name).trim()) return err(new Error('name required — a short 2-3 word description of the work, e.g. session(action="name", name="beoflow backend")'));
   try {
-    const mcpUpdate = await getCachedMcpUpdateMetadata();
-    return ok({
-      server: getServerUrl(),
-      ok: mcpUpdate.status !== 'unknown',
-      mcpVersion: PACKAGE_VERSION,
-      mcpUpdate,
-    });
+    const result = await api('POST', '/api/sessions/name', { name: String(name) });
+    if (agentSurface) {
+      agentSurface.name = result?.name || String(name).trim();
+      agentSurface.nameRequired = false;
+      agentSurface.capital = ((result?.name || String(name).trim())[0] || '').toUpperCase();
+    }
+    return ok({ sessionId: getState().sessionId, name: result?.name || String(name).trim(), named: true });
   } catch (error) { return err(error); }
 });
 
 // ── Project management tools (direct HTTP) ────────────────────────
 
-tool('project', 'START HERE for project management. Dispatch by `action`: list (lists all projects across all orgs — always call first), open (bind this agent session to a project; required before reading/writing frames — the org derives from the project), create (new project; org= names where it is born), update (change name/folder/description/layers), move (transfer to another org), export (the project as an OKF v0.1 bundle — <layer>/<lane>/<file>.md concepts, index.md/log.md synthesized), import (ingest an OKF bundle: concepts become markdown document frames, links between them become connectors; dryRun supported). There is no org switching: for project-less work (wiki/skills) pass org=... on the call. **Skill gate:** projects with attached skills will REJECT all mutations (write, edit, mv, rm, connector, layout, layer, asset upload) until you have loaded each attached skill via skill(action="load"). Skills tell you HOW to do the work — they\'re not optional. Open returns the attached skill list and auto-inlines content for projects with ≤3 skills.', {
-  action: z.enum(['list', 'open', 'create', 'update', 'move', 'export', 'import']).describe('Operation to perform.'),
-  projectId: z.string().optional().describe('[open|update|move|export|import] project ID. Get IDs from action=list. For export/import: defaults to the bound project.'),
-  name: z.string().optional().describe('[create|update] project name'),
-  description: z.string().nullable().optional().describe('[create|update] project description'),
-  templateSlug: z.string().optional().describe('[create] template slug (e.g. "web-design", "mobile-app", "landing-page")'),
-  org: z.string().optional().describe('[create] org slug or id the project is born in. Defaults to this session\'s org (the open project\'s org, else the default org).'),
-  folder: z.string().nullable().optional().describe('[update] folder name (null to remove from folder). Pass "Archive" to archive: the project drops out of search and the active list but is never deleted and can be restored by a human.'),
-  layers: z.array(z.object({}).passthrough()).optional().describe('[update] full layers array replacement. Use ls / to read current layers first.'),
-  targetOrgId: z.string().optional().describe('[move] destination organization ID. Get org IDs from action=list (each project has an orgId field) or get_org. Both source and target org must include the current user.'),
-  format: z.string().optional().describe('[export] "files" returns {files:[{path,content}]} paginated via limit/offset (compact=true for paths only) instead of writing a local dir (stdio) or returning a download URL (remote).'),
-  limit: z.number().optional().describe('[export] max files per page for format="files" (default 100, max 500)'),
-  offset: z.number().optional().describe('[export] pagination offset for format="files"'),
-  compact: z.boolean().optional().describe('[export] with format="files": return file paths only (no content)'),
-  files: z.array(z.object({
-    path: z.string().describe('Bundle-relative file path, e.g. "research/default/notes.md"'),
-    content: z.string().describe('File content (markdown, optional YAML frontmatter)'),
-  })).optional().describe('[import] OKF bundle files inline. index.md/log.md are skipped (synthesized). Caps: 500 files, 512KB/file, 5MB total.'),
-  dryRun: z.boolean().optional().describe('[import] preview the {creates, updates, skips, warnings} report without writing'),
-  ...(isRemote ? {} : { dir: z.string().optional().describe('[export|import] local directory. export: write the bundle files here (default ./okf-project-<slug>). import: recursively read .md files from here (alternative to files[]).') }),
-}, async (args) => {
-  try {
-    const { action } = args;
-    switch (action) {
-      case 'list': {
-        const data = await api('GET', '/api/projects');
-        data.agentProject = getState().projectId || null;
-        try {
-          const favData = await api('GET', '/api/skills/favorites');
-          const favs = favData.skills || [];
-          if (favs.length > 0) {
-            data.favoritedSkills = favs.map(s => ({
-              id: s.id,
-              name: s.name,
-              slug: s.slug,
-              description: s.description,
-              tags: s.tags,
-            }));
-          }
-        } catch { /* skills not available */ }
-
-        const structuredContent = {
-          projects: (data.projects || []).map(p => ({
-            id: p.id,
-            name: p.name,
-            slug: p.slug,
-            description: p.description,
-            orgId: p.orgId,
-          })),
-          activeProject: data.agentProject,
-        };
-        return ok(data, { structuredContent });
-      }
-      case 'open': {
-        const ref = args.projectId;
-        if (!ref) throw new Error('projectId required for action=open (UUID, slug, or name)');
-        // Accept a slug or name, not just a UUID — the slug is what an agent actually has
-        // in context after a reconnect.
-        const resolved = await resolveProjectRef(ref).catch(() => null);
-        const projectId = resolved?.id || ref;
-        const result = await api('POST', '/api/project/switch', { projectId });
-        joinAgentWsRoom(projectId);
-        const base = getServerUrl();
-        const projectMeta = resolved || { id: projectId, slug: null, name: null, orgId: null, orgSlug: null };
-        const projectSlug = projectMeta.slug || projectId;
-        const orgSlug = projectMeta.orgSlug || null;
-        setMcpActiveProject(projectId, projectMeta);
-        // Semantic /o/<org-slug>/<project-slug> when the org slug is known; otherwise
-        // the /project/<slug> resolver redirects to it.
-        const url = orgSlug ? `${base}/o/${encodeURIComponent(orgSlug)}/${encodeURIComponent(projectSlug)}` : `${base}/project/${projectSlug}`;
-        // Surfacing to the user is the focus mechanism's job now (agent-active ping ->
-        // desktop window / notification+glow for browser tabs) — this used to also force
-        // `exec('open <url>')` on the MCP host machine, an unsolicited GUI action that both
-        // duplicated the focus mechanism and did nothing useful for remote/hosted MCP mode
-        // (no GUI to open on Drafted's own server). `url` is still returned below for the
-        // agent/human to open manually.
-        let navigated = 0;
-        try {
-          const nav = await api('POST', '/api/project/navigate', { projectId });
-          navigated = nav.navigated || 0;
-        } catch { /* server may not support navigate yet */ }
-        // G4/G5 auto-inject (locked design): the project's attached skills + anchors
-        // are pushed into the open response within the per-project context budget,
-        // replacing the reject-style gate. Prefer the server-computed `priming`
-        // (authoritative + fresh on deploy); fall back to MCP-side assembly for
-        // older servers that don't return it.
-        let responseExtras;
-        const priming = result && result.priming ? result.priming : null;
-        if (priming) {
-          const primedSkills = priming.skills || [];
-          const primedAnchors = priming.anchors || [];
-          for (const s of primedSkills) getSessionState().loadedSkillIds.add(s.id);
-          responseExtras = { url, opened: true, navigated, skills: primedSkills, anchors: primedAnchors };
-          if (priming.budgetNotice) responseExtras.budgetNotice = priming.budgetNotice;
-        } else {
-          let projectSkillsList = [];
-          try {
-            const skillData = await api('GET', `/api/projects/${projectId}/skills`);
-            projectSkillsList = skillData.skills || [];
-          } catch { /* skills not available yet */ }
-          for (const s of projectSkillsList) {
-            try {
-              const full = await api('GET', `/api/skills/${s.id}`);
-              s.content = full.content;
-              s.files = full.files || [];
-            } catch { /* leaves this skill without inlined content */ }
-          }
-          let anchors = [];
-          try {
-            const anchored = await api('GET', `/api/designs/anchored?projectId=${projectId}`);
-            anchors = (Array.isArray(anchored) ? anchored : []).map(a => ({
-              id: a.id,
-              path: a.path || `/${a.layer || ''}/${a.lane || ''}/${a.label || ''}`,
-              layer: a.layer,
-              content: a.content || '',
-            }));
-          } catch { /* anchors unavailable */ }
-          const sel = selectWithinBudget([...projectSkillsList, ...anchors], PROJECT_CONTEXT_BUDGET_CHARS);
-          for (const it of sel.included) {
-            if (projectSkillsList.includes(it)) getSessionState().loadedSkillIds.add(it.id);
-          }
-          for (const it of sel.deferred) { it.content = undefined; if ('files' in it) it.files = undefined; }
-          responseExtras = { url, opened: true, navigated, skills: projectSkillsList, anchors };
-          if (sel.deferred.length > 0) {
-            responseExtras.budgetNotice =
-              `${sel.deferred.length} attached skill(s)/anchor(s) exceeded the per-project context budget ` +
-              `(${PROJECT_CONTEXT_BUDGET_CHARS} chars) and were not inlined — load explicitly if needed: ` +
-              sel.deferred.map(it => it.slug || it.path || it.id).join(', ');
-          }
-        }
-        // Don't echo the raw priming blob (surfaced via skills/anchors/budgetNotice).
-        if (result && typeof result === 'object') delete result.priming;
-        return ok({ ...result, ...responseExtras });
-      }
-      case 'create': {
-        const g3 = g3Block(getSessionState().gates);
-        if (g3) return err(new Error(g3));
-        const { name, description, templateSlug, org } = args;
-        if (!name) throw new Error('name required for action=create');
-        // Don't silently create the project in whatever org the session inherited.
-        await requireBoundOrgForProjectlessMutation(org);
-        const body = { name };
-        if (description) body.description = description;
-        if (templateSlug) body.templateSlug = templateSlug;
-        // `org` targets a specific org without switching the active org.
-        const createExtra = org ? { 'X-Drafted-Org': org } : {};
-        const created = await api('POST', '/api/projects', body, createExtra);
-        return ok({ ...withProjectBreadcrumb(created), ...(await orgEcho(created, org)) });
-      }
-      case 'update': {
-        const { projectId, name, folder, description, layers } = args;
-        if (!projectId) throw new Error('projectId required for action=update');
-        const body = {};
-        if (name !== undefined) body.name = name;
-        if (folder !== undefined) {
-          // "Archive" is the agent-facing name for the reserved __archived folder:
-          // archived projects drop out of search and the active list but are never
-          // deleted, so an agent can safely archive a project it created in error
-          // and a human can always restore it. Pass any other folder name to file,
-          // or null to remove from a folder.
-          body.folder = folder === 'Archive' ? '__archived' : folder;
-        }
-        if (description !== undefined) body.description = description;
-        if (layers) body.layers = layers;
-        if (Object.keys(body).length === 0) throw new Error('At least one field (name, folder, description, layers) is required for action=update');
-        return ok(await api('PATCH', `/api/project/${projectId}`, body));
-      }
-      case 'move': {
-        const { projectId, targetOrgId } = args;
-        if (!projectId || !targetOrgId) throw new Error('projectId and targetOrgId required for action=move');
-        return ok(await api('POST', `/api/project/${projectId}/move`, { targetOrgId }));
-      }
-
-      // ── export ──────────────────────────────────────────────────
-      // The project as an OKF v0.1 bundle. Mirrors wiki export: format="files"
-      // pages the bundle inline; otherwise stdio writes a local dir, remote
-      // returns the authenticated tar.gz download URL.
-      case 'export': {
-        const projectId = args.projectId || getState().projectId;
-        if (!projectId) throw new Error('projectId required for action=export (or open a project first)');
-        if (args.format === 'files') {
-          const qp = new URLSearchParams({ limit: String(Math.min(Math.max(1, args.limit || 100), 500)) });
-          if (args.offset) qp.set('offset', String(args.offset));
-          if (args.compact) qp.set('compact', 'true');
-          return ok(await api('GET', `/api/projects/${projectId}/export?${qp.toString()}`));
-        }
-        if (isRemote) {
-          return ok({
-            downloadUrl: `${getServerUrl()}/api/projects/${projectId}/export.tar.gz`,
-            note: 'Open the URL in a signed-in browser to download the OKF v0.1 project bundle, or call export with format="files" to page the bundle contents inline.',
-          });
-        }
-        // stdio: write every bundle file under a local directory.
-        const meta = getCurrentProjectContext();
-        const projSlug = String((meta && meta.id === projectId && (meta.slug || meta.name)) || projectId)
-          .toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '') || 'project';
-        const exportDir = resolve(args.dir || `./okf-project-${projSlug}`);
-        let expOffset = 0;
-        let written = 0;
-        for (;;) {
-          const batch = await api('GET', `/api/projects/${projectId}/export?limit=200&offset=${expOffset}`);
-          const batchFiles = batch.files || [];
-          for (const f of batchFiles) {
-            const dest = resolve(exportDir, f.path);
-            if (dest !== exportDir && !dest.startsWith(exportDir + '/') && !dest.startsWith(exportDir + '\\')) continue; // traversal guard
-            mkdirSync(dirname(dest), { recursive: true });
-            writeFileSync(dest, f.content, 'utf8');
-            written++;
-          }
-          expOffset += batchFiles.length;
-          if (!batch.truncated || batchFiles.length === 0) break;
-        }
-        return ok({ exported: written, dir: exportDir, note: 'OKF v0.1 project bundle written (<layer>/<lane>/<file>.md concepts; index.md and log.md are synthesized).' });
-      }
-
-      // ── import ──────────────────────────────────────────────────
-      // Ingest an OKF bundle into the project: inline files[] or (stdio) a
-      // local dir walked for .md files. Concepts become markdown document
-      // frames; markdown links between them become connectors.
-      case 'import': {
-        const projectId = args.projectId || getState().projectId;
-        if (!projectId) throw new Error('projectId required for action=import (or open a project first)');
-        let importFiles = args.files;
-        if (!importFiles && args.dir) {
-          const root = resolve(args.dir);
-          if (!existsSync(root)) throw new Error(`dir not found: ${args.dir}`);
-          importFiles = [];
-          const walk = (d) => {
-            for (const ent of readdirSync(d, { withFileTypes: true })) {
-              if (ent.name.startsWith('.')) continue;
-              const p = join(d, ent.name);
-              if (ent.isDirectory()) walk(p);
-              else if (/\.md$/i.test(ent.name)) {
-                if (importFiles.length >= 500) throw new Error('import capped at 500 files — split the bundle');
-                importFiles.push({ path: p.slice(root.length + 1).replace(/\\/g, '/'), content: readFileSync(p, 'utf8') });
-              }
-            }
-          };
-          walk(root);
-        }
-        if (!Array.isArray(importFiles) || importFiles.length === 0) {
-          throw new Error('import requires files[] (or dir on stdio) with at least one .md file');
-        }
-        return ok(await api('POST', `/api/projects/${projectId}/import`, { files: importFiles, dryRun: !!args.dryRun }));
-      }
-
-      default:
-        throw new Error(`Unknown project action: ${action}`);
-    }
-  } catch (error) { return err(error); }
-});
 
-tool('template', 'Manage project templates in an org. Dispatch by `action`: list/create/update/delete/fork. A template bundles layer definitions and an optional list of skill slugs that auto-attach to projects created from it. Scopes to the open project\'s org by default; pass org=... to target another org (per-request only — nothing is switched).', {
-  action: z.enum(['list', 'create', 'update', 'delete', 'fork']).describe('Operation to perform.'),
-  templateId: z.string().optional().describe('[update|delete|fork] template ID'),
-  name: z.string().optional().describe('[create|update|fork] template name (required for create; optional rename for fork)'),
-  description: z.string().optional().describe('[create|update] template description'),
-  layers: z.array(z.object({}).passthrough()).optional().describe('[create|update] array of layer definitions'),
-  skillSlugs: z.array(z.string()).optional().describe('[create|update] skill slugs to auto-attach to projects created from this template. Slugs are resolved against the org\'s skills (org-local first, built-in fallback) at project-create time; missing slugs are silently skipped. Pass an empty array on update to clear.'),
-  visibility: z.string().optional().describe('[create|update] "org" or "public"'),
-  compact: z.boolean().optional().describe('[list] default true — return {id,slug,name,description,layerCount,skillSlugs} only. Pass false for full layer definitions.'),
-  limit: z.number().optional().describe('[list] max templates to return (default 25, max 100).'),
-  offset: z.number().optional().describe('[list] pagination offset.'),
-  org: z.string().optional().describe('Org (id or name) to scope this call to — defaults to the open project\'s org. Per-request only.'),
-}, async (args) => {
-  try {
-    const { action } = args;
-    const orgHeader = args.org ? { 'X-Drafted-Org': args.org } : {};
-    switch (action) {
-      case 'list': {
-        const tpls = await api('GET', '/api/templates', undefined, orgHeader);
-        markSearched(getSessionState().gates, 'template');
-        return ok(shapeTemplateCatalog(tpls, { limit: args.limit, offset: args.offset, compact: args.compact !== false }));
-      }
-      case 'create': {
-        const { name, description, layers, skillSlugs, visibility } = args;
-        if (!name || !description || !layers) throw new Error('name, description, layers required for action=create');
-        // Don't silently create the template in whatever org the session inherited.
-        await requireBoundOrgForProjectlessMutation(args.org);
-        const body = { name, description, layers };
-        if (Array.isArray(skillSlugs)) body.skillSlugs = skillSlugs;
-        if (visibility) body.visibility = visibility;
-        const createdTpl = await api('POST', '/api/templates', body, orgHeader);
-        return ok({ ...createdTpl, ...(await orgEcho(createdTpl, args.org)) });
-      }
-      case 'update': {
-        const { templateId, name, description, layers, skillSlugs, visibility } = args;
-        if (!templateId) throw new Error('templateId required for action=update');
-        const body = {};
-        if (name) body.name = name;
-        if (description) body.description = description;
-        if (layers) body.layers = layers;
-        if (Array.isArray(skillSlugs)) body.skillSlugs = skillSlugs;
-        if (visibility) body.visibility = visibility;
-        if (Object.keys(body).length === 0) throw new Error('At least one field is required for action=update');
-        const updatedTpl = await api('PUT', `/api/templates/${templateId}`, body, orgHeader);
-        return ok({ ...updatedTpl, ...(await orgEcho(updatedTpl, args.org)) });
-      }
-      case 'delete': {
-        const { templateId } = args;
-        if (!templateId) throw new Error('templateId required for action=delete');
-        return ok(await api('DELETE', `/api/templates/${templateId}`, undefined, orgHeader));
-      }
-      case 'fork': {
-        const { templateId, name } = args;
-        if (!templateId) throw new Error('templateId required for action=fork');
-        // Forking creates a new template — same org rule as any create.
-        await requireBoundOrgForProjectlessMutation(args.org);
-        const body = {};
-        if (name) body.name = name;
-        const forkedTpl = await api('POST', `/api/templates/${templateId}/fork`, body, orgHeader);
-        return ok({ ...forkedTpl, ...(await orgEcho(forkedTpl, args.org)) });
-      }
-      default:
-        throw new Error(`Unknown template action: ${action}`);
-    }
-  } catch (error) { return err(error); }
-});
 
 tool('trigger', {
   action: z.enum(['create', 'list', 'update', 'rotate', 'test', 'deliveries', 'delete', 'pending', 'claim', 'complete']).describe('Operation to perform.'),
@@ -2379,28 +2196,35 @@ tool('trigger', {
   deliveryId: z.string().optional().describe('[complete] delivery ID returned by claim'),
   ok: z.boolean().optional().describe('[complete] whether the claimed work succeeded (default true)'),
   error: z.string().optional().describe('[complete] error note when ok=false'),
-  projectId: z.string().optional().describe('[create|list|pending] target project — defaults to the active (opened) project.'),
+  projectId: z.string().optional().describe('[create|list|pending] the project this trigger belongs to — REQUIRED, as a path (/projects/<name> or /projects/<folder>/<name>), slug, or UUID. Triggers are project-scoped: they run agent conversations in that project. No session fallback — name the project.'),
   limit: z.number().optional().describe('[deliveries] max rows (default 25, max 100)'),
 }, async (args) => {
   try {
     const { action } = args;
+    // Triggers are project-scoped. Resolve the project from the fs path (or
+    // slug/UUID), scope the API calls via withProjectOverride so api() appends
+    // THIS project (not whatever session is bound), and echo projectPath back.
+    const project = action === 'create' || action === 'list' || action === 'pending' ? await resolveProjectArg(args.projectId) : null;
+    const projectPath = project ? `/projects/${project.slug}` : null;
+    const scoped = (fn) => project ? withProjectOverride(project, fn) : fn();
     switch (action) {
       case 'create': {
         if (!args.name || !args.promptTemplate) throw new Error('name and promptTemplate required for action=create');
-        const body = { name: args.name, promptTemplate: args.promptTemplate };
-        if (args.projectId) body.projectId = args.projectId;
+        const body = { name: args.name, promptTemplate: args.promptTemplate, projectId: project.id };
         if (args.executor) body.executor = args.executor;
         if (args.signingSecret) body.signingSecret = args.signingSecret;
         if (args.dailyLimit !== undefined) body.dailyLimit = args.dailyLimit;
-        const created = await api('POST', '/api/triggers', body);
+        const created = await scoped(() => api('POST', '/api/triggers', body));
         return ok({
           ...created,
+          projectPath,
           note: 'Relay `url` (and the HMAC secret if set) to the user NOW — the token is shown once and cannot be retrieved later, only rotated.',
         });
       }
       case 'list': {
-        const qs = args.projectId ? `?projectId=${encodeURIComponent(args.projectId)}` : '';
-        return ok(await api('GET', `/api/triggers${qs}`));
+        const result = await scoped(() => api('GET', '/api/triggers'));
+        const triggers = (result.triggers || []).map(t => ({ ...t, projectPath }));
+        return ok({ ...result, triggers, projectPath });
       }
       case 'update': {
         if (!args.triggerId) throw new Error('triggerId required for action=update');
@@ -2434,8 +2258,7 @@ tool('trigger', {
         return ok(await api('DELETE', `/api/triggers/${args.triggerId}`));
       }
       case 'pending': {
-        const qs = args.projectId ? `?projectId=${encodeURIComponent(args.projectId)}` : '';
-        return ok(await api('GET', `/api/triggers/pending${qs}`));
+        return ok(await scoped(() => api('GET', '/api/triggers/pending').then(r => ({ ...r, projectPath }))));
       }
       case 'claim': {
         if (!args.triggerId) throw new Error('triggerId required for action=claim');
@@ -2457,67 +2280,55 @@ tool('trigger', {
 });
 
 tool('focus', {
-  target: z.string().describe('Frame URL (any URL containing /f/{uuid}), frame ID (UUID), or file path (/{layer}/{lane}/{filename}) to pan the canvas viewport to. When a user shares a Drafted frame link, pass it directly here.'),
+  target: z.string().describe('What to pan the canvas to: a frame path (/projects/<project>/<layer>/<lane>/<file>), a frame URL (any URL containing /f/{uuid} or /o/<org>/projects/...), or a frame ID (UUID). When a user shares a Drafted link, pass it directly here.'),
 }, async ({ target }) => {
   try {
-    // Resolve target to a frame ID
-    const frameUrlMatch = target.match(/\/f\/([a-f0-9-]{36})/);
-    const uuidMatch = target.match(/^[a-f0-9-]{36}$/);
-    let frameId = frameUrlMatch?.[1] || (uuidMatch ? target : null);
-
-    if (!frameId) {
-      // Path — resolve via read to get the frame ID
-      const parts = target.replace(/^\/+/, '').split('/');
-      if (parts.length !== 3) throw new Error('Target must be a frame URL, frame ID, or path /{layer}/{lane}/{filename}');
-      const frame = await api('GET', `/api/fs/${parts[0]}/${parts[1]}/${parts[2]}`);
-      if (!frame.id) throw new Error('Frame not found');
-      frameId = frame.id;
-    }
-
+    const { frameId } = await resolveFsFramePath(target);
     const result = await api('POST', `/api/focus/${frameId}`);
     return ok(result);
   } catch (error) { return err(error); }
 });
 
-tool('screenshot', 'Render a PNG via headless browser. `scope=frame` captures a single frame (default 1440×900, fullPage). `scope=canvas` captures a region of the project surface (default 1600×1200, typically the "plans" layer where frames live).', {
+tool('screenshot', 'Render a PNG via headless browser. `scope=frame` captures a single frame; `scope=canvas` captures a region of the project surface (default 1600×1200, typically the "plans" layer). Targets are pseudo-filesystem paths: `scope=frame` takes /projects/<project>/<layer>/<lane>/<file> (or a frame URL / UUID); `scope=canvas` takes /projects/<project> with an optional `layer`.', {
   scope: z.enum(['frame', 'canvas']).describe('What to capture.'),
-  target: z.string().optional().describe('[scope=frame] frame URL, UUID, or /{layer}/{lane}/{filename} path.'),
-  slug: z.string().optional().describe('[scope=canvas] project slug. Defaults to the currently active project.'),
-  layer: z.string().optional().describe('[scope=canvas] layer key to capture (default: plans).'),
+  path: z.string().optional().describe('[frame] /projects/<project>/<layer>/<lane>/<file>, a frame URL (/f/{uuid} or /o/<org>/projects/...), or a frame UUID. [canvas] /projects/<project> (project root) — captures that project\'s surface.'),
+  layer: z.string().optional().describe('[canvas] layer key to capture (default: plans).'),
   width: z.number().optional().describe('Viewport width in pixels (frame default 1440, canvas default 1600).'),
   height: z.number().optional().describe('Viewport height in pixels (frame default 900, canvas default 1200).'),
-  fullPage: z.boolean().optional().describe('[scope=frame] capture full page or just viewport (default true).'),
+  fullPage: z.boolean().optional().describe('[frame] capture full page or just viewport (default true).'),
   // outputPath is local-only — omitted on remote transports (web MCP) where the host has no caller filesystem.
   ...(isRemote ? {} : { outputPath: z.string().optional().describe('[stdio only] Absolute local path to write the rendered PNG to. When set, the PNG is saved to disk and the tool returns the path + byte count instead of returning the image inline — use this to get rendered pixels OUT of Drafted (attach to a message, upload, post-process). Parent directories are created if missing.') }),
+  // Legacy aliases (pre-fs-path): kept for installed-client compat.
+  target: z.string().optional().describe('[legacy frame] frame URL, UUID, or /{layer}/{lane}/{filename} path.'),
+  slug: z.string().optional().describe('[legacy canvas] project slug. Defaults to the currently active project.'),
 }, async (args) => {
   try {
     const { scope } = args;
     let buffer;
     if (scope === 'frame') {
-      const { target, width = 1440, height = 900, fullPage = true } = args;
-      if (!target) throw new Error('target required for scope=frame');
-      const frameUrlMatch = target.match(/\/f\/([a-f0-9-]{36})/);
-      const uuidMatch = target.match(/^[a-f0-9-]{36}$/);
-      let frameId = frameUrlMatch?.[1] || (uuidMatch ? target : null);
-      if (!frameId) {
-        const parts = target.replace(/^\/+/, '').split('/');
-        if (parts.length !== 3) throw new Error('Target must be a frame URL, frame ID, or path /{layer}/{lane}/{filename}');
-        const frame = await api('GET', `/api/fs/${parts[0]}/${parts[1]}/${parts[2]}`);
-        if (!frame.id) throw new Error('Frame not found');
-        frameId = frame.id;
-      }
+      const target = args.path || args.target;
+      const { width = 1440, height = 900, fullPage = true } = args;
+      if (!target) throw new Error('path required for scope=frame (e.g. /projects/<project>/<layer>/<lane>/<file>)');
+      const { frameId } = await resolveFsFramePath(target);
       const url = `${getServerUrl()}/api/screenshot/${frameId}?width=${width}&height=${height}&fullPage=${fullPage}`;
       await ensureSession();
       const res = await fetch(url, { headers: getAuthHeaders() });
       if (!res.ok) throw new Error(`Screenshot failed: ${res.status}`);
       buffer = Buffer.from(await res.arrayBuffer());
     } else if (scope === 'canvas') {
-      const { slug, layer = 'plans', width = 1600, height = 1200 } = args;
-      let targetSlug = slug;
+      const { path: canvasPath, layer = 'plans', width = 1600, height = 1200 } = args;
+      let targetSlug = args.slug;
+      if (!targetSlug && canvasPath) {
+        // /o/<org>/projects/<project> or /projects/<project> or /projects/<folder>/<project> → project slug
+        const scoped = splitOrgScope(canvasPath);
+        if (scoped.error) throw new Error(scoped.error);
+        const parts = scoped.path.replace(/^\/projects\/?/, '').split('/').filter(Boolean);
+        targetSlug = parts[parts.length - 1];
+      }
       if (!targetSlug) {
         const list = await api('GET', '/api/projects');
         const active = (list.projects || []).find(p => p.id === list.activeProject);
-        if (!active) throw new Error('No active project — pass slug explicitly.');
+        if (!active) throw new Error('No active project — pass path=/projects/<project> explicitly.');
         targetSlug = active.slug;
       }
       const url = `${getServerUrl()}/api/canvas-screenshot/${encodeURIComponent(targetSlug)}?layer=${encodeURIComponent(layer)}&width=${width}&height=${height}`;
@@ -2542,2188 +2353,65 @@ tool('screenshot', 'Render a PNG via headless browser. `scope=frame` captures a
   } catch (error) { return err(error); }
 });
 
-tool('layer', 'Manage layers in a project. Dispatch by `action`: add/update/remove/reorder. Layers are the horizontal bands of a Drafted canvas (e.g. wireframes, designs, brand-assets). All actions take projectId; add/update/remove also take the layer `key`.', {
-  action: z.enum(['add', 'update', 'remove', 'reorder']).describe('Operation to perform.'),
-  projectId: z.string().describe('Project ID (all actions require this)'),
-  key: z.string().optional().describe('[add|update|remove] unique layer key (e.g. "research", "prototypes")'),
-  label: z.string().optional().describe('[add|update] display label'),
-  type: z.string().optional().describe('[add|update] layer type (e.g. "html", "image", "text")'),
-  width: z.number().optional().describe('[add|update] default frame width in pixels'),
-  height: z.number().optional().describe('[add|update] default frame height in pixels'),
-  description: z.string().optional().describe('[add|update] layer description'),
-  prompt: z.string().optional().describe('[add|update] prompt hint for AI agents working in this layer'),
-  force: z.boolean().optional().describe('[remove] force removal even if the layer contains frames'),
-  keys: z.array(z.string()).optional().describe('[reorder] ordered array of ALL existing layer keys — no additions, removals, or duplicates'),
-}, async (args) => {
-  try {
-    const { action, projectId } = args;
-    if (!projectId) throw new Error('projectId is required');
-    switch (action) {
-      case 'add': {
-        const { key, label, type, width, height, description, prompt } = args;
-        if (!key || !label || !type || width == null || height == null) {
-          throw new Error('key, label, type, width, height are required for action=add');
-        }
-        const project = await api('GET', `/api/project/${projectId}`);
-        const layers = project.layers || [];
-        if (layers.some(l => l.key === key)) {
-          throw new Error(`Layer with key "${key}" already exists in this project`);
-        }
-        const newLayer = { key, label, type, width, height };
-        if (description !== undefined) newLayer.description = description;
-        if (prompt !== undefined) newLayer.prompt = prompt;
-        layers.push(newLayer);
-        return ok(await api('PATCH', `/api/project/${projectId}`, { layers }));
-      }
-      case 'update': {
-        const { key, label, type, width, height, description, prompt } = args;
-        if (!key) throw new Error('key is required for action=update');
-        const project = await api('GET', `/api/project/${projectId}`);
-        const layers = project.layers || project.project?.layers;
-        if (!Array.isArray(layers)) throw new Error('Project has no layers array');
-        const idx = layers.findIndex(l => l.key === key);
-        if (idx === -1) throw new Error(`Layer with key "${key}" not found`);
-        const updates = { label, type, width, height, description, prompt };
-        const filtered = Object.fromEntries(Object.entries(updates).filter(([, v]) => v !== undefined));
-        if (Object.keys(filtered).length === 0) throw new Error('At least one field (label, type, width, height, description, prompt) is required for action=update');
-        layers[idx] = { ...layers[idx], ...filtered };
-        return ok(await api('PATCH', `/api/project/${projectId}`, { layers }));
-      }
-      case 'remove': {
-        const { key, force = false } = args;
-        if (!key) throw new Error('key is required for action=remove');
-        const project = await api('GET', `/api/project/${projectId}`);
-        const layers = project.layers || [];
-        if (!layers.some(l => l.key === key)) {
-          throw new Error(`Layer with key "${key}" does not exist in this project`);
-        }
-        if (!force) {
-          const listing = await api('GET', `/api/fs?path=/${key}&projectId=${projectId}&recursive=true`);
-          const entries = listing.entries || [];
-          const frames = entries.filter(e => e.type === 'frame');
-          const realFrames = frames.filter(f => !f.path.endsWith('/_meta/_context.md') && !f.path.endsWith('/instructions/context.md') && !f.path.endsWith('/instructions/AGENTS.md') && !f.path.endsWith('/AGENTS.md'));
-          const frameCount = realFrames.length;
-          if (frameCount > 0) {
-            throw new Error(`Layer "${key}" contains ${frameCount} frame(s). Use force: true to confirm deletion.`);
-          }
-        }
-        const filtered = layers.filter(l => l.key !== key);
-        return ok(await api('PATCH', `/api/project/${projectId}`, { layers: filtered }));
-      }
-      case 'reorder': {
-        const { keys } = args;
-        if (!Array.isArray(keys)) throw new Error('keys (array) is required for action=reorder');
-        const project = await api('GET', `/api/project/${projectId}`);
-        const currentLayers = project.layers || [];
-        const currentKeys = currentLayers.map(l => l.key);
-        const uniqueKeys = new Set(keys);
-        if (uniqueKeys.size !== keys.length) {
-          const dupes = keys.filter((k, i) => keys.indexOf(k) !== i);
-          throw new Error(`Duplicate keys: ${[...new Set(dupes)].join(', ')}`);
-        }
-        const missing = currentKeys.filter(k => !uniqueKeys.has(k));
-        if (missing.length > 0) {
-          throw new Error(`Missing keys: ${missing.join(', ')}. You must include all existing layer keys.`);
-        }
-        const currentSet = new Set(currentKeys);
-        const extra = keys.filter(k => !currentSet.has(k));
-        if (extra.length > 0) {
-          throw new Error(`Unknown keys: ${extra.join(', ')}. Only existing layer keys are allowed.`);
-        }
-        const reorderedLayers = keys.map(k => currentLayers.find(l => l.key === k));
-        return ok(await api('PATCH', `/api/project/${projectId}`, { layers: reorderedLayers }));
-      }
-      default:
-        throw new Error(`Unknown layer action: ${action}`);
-    }
-  } catch (error) { return err(error); }
-});
 
 
-async function getGoogleDriveAvailability() {
-  try {
-    const status = await api('GET', '/api/google/status');
-    return {
-      connected: !!status?.connected,
-      syncEnabled: !!status?.syncEnabled,
-      driveRootFolderId: status?.driveRootFolderId || null,
-      driveRootFolderName: status?.driveRootFolderName || null,
-      workspaceFramesAvailable: !!status?.connected,
-      preference: status?.connected
-        ? 'Strongly prefer Google Workspace frames for docs, sheets, and slides in this org.'
-        : 'Google Drive is not connected; use normal Drafted frames.',
-    };
-  } catch {
-    return {
-      connected: false,
-      syncEnabled: false,
-      driveRootFolderId: null,
-      driveRootFolderName: null,
-      workspaceFramesAvailable: false,
-      preference: 'Google Drive status unavailable; use normal Drafted frames unless a Google Workspace frame succeeds.',
-    };
-  }
-}
 
-function normalizeMcpUpdatePolicy(policy) {
-  const severity = policy?.policy?.severity || 'unknown';
-  const updateAvailable = !!policy?.policy?.updateAvailable;
-  const required = !!policy?.policy?.required;
-  return {
-    status: required ? 'required' : updateAvailable ? 'stale' : severity === 'unknown' ? 'unknown' : 'current',
-    currentVersion: policy?.versions?.client || PACKAGE_VERSION,
-    latestVersion: policy?.versions?.latest || null,
-    recommendedVersion: policy?.versions?.recommended || null,
-    minimumRequiredVersion: policy?.versions?.minimumRequired || null,
-    severity,
-    updateAvailable,
-    stale: updateAvailable,
-    required,
-    reason: policy?.policy?.reason || null,
-    enabled: policy?.policy?.enabled !== false,
-    mode: policy?.package?.mcpMode || mcpMode(),
-    distribution: policy?.package?.distribution || (mcpMode() === 'stdio' ? 'npm-stdio' : 'hosted-http'),
-    update: {
-      command: policy?.update?.command || null,
-      helper: policy?.update?.helper || null,
-      packageManager: policy?.update?.packageManager || 'npm',
-    },
-    restart: {
-      required: !!policy?.restart?.required,
-      guidance: policy?.restart?.guidance || null,
-    },
-    checkedAt: policy?.serverTimestamp || null,
+
+
+
+
+// ── Skill library tool ───────────────────────────────────────────
+
+// Walk a local source tree for `skill action=push` with dir, pre-filtering heavy
+// dirs + any .skillignore as a convenience so we don't ship a node_modules tree
+// over the wire. The SERVER re-runs the authoritative hygiene pipeline. Mirrors the
+// CLI's collectSkillTree.
+function collectSkillTreeForPush(dir) {
+  const root = resolve(dir);
+  if (!existsSync(root) || !statSync(root).isDirectory()) throw new Error(`not a directory: ${dir}`);
+  const SKIP = new Set(['node_modules', '.git', '.venv', 'venv', '__pycache__', 'dist', 'build', '.next', 'target', 'coverage', '.cache', '.turbo', '.gradle', 'Pods', '.terraform', '.skillinstall']);
+  const NUL = String.fromCharCode(0);
+  let ignore = () => false;
+  const ign = join(root, '.skillignore');
+  if (existsSync(ign)) {
+    const pats = readFileSync(ign, 'utf8').split(/\r?\n/).map((l) => l.trim()).filter((l) => l && !l.startsWith('#'));
+    ignore = (rel) => pats.some((p) => { const d = p.replace(/\/$/, ''); return rel === d || rel.startsWith(d + '/') || rel.split('/').pop() === d; });
+  }
+  const out = [];
+  const walk = (abs, rel) => {
+    for (const name of readdirSync(abs)) {
+      const childAbs = join(abs, name);
+      const childRel = rel ? `${rel}/${name}` : name;
+      const st = statSync(childAbs);
+      if (st.isDirectory()) { if (SKIP.has(name) || ignore(childRel)) continue; walk(childAbs, childRel); }
+      else if (st.isFile()) {
+        if (ignore(childRel)) continue;
+        const content = readFileSync(childAbs, 'utf8');
+        if (content.includes(NUL)) continue; // skip binary; server rejects it anyway
+        out.push({ path: childRel, content });
+      }
+    }
   };
+  walk(root, '');
+  return out;
 }
 
-function buildInstalledMcpUpdateInstructions(updateMetadata = null) {
-  const mode = updateMetadata?.mode || mcpMode();
-  const restart = updateMetadata?.restart || {
-    required: mode === 'stdio',
-    guidance: 'Restart agents after updating the npm-installed Drafted MCP daemon.',
-  };
+// Ensure a pushed source tree's .gitignore excludes the rebuildable bundle dir, so
+// a skill's machine-specific build output (built into .skillinstall/ by its `setup:`
+// recipe) can never be committed. The server also strips .skillinstall/ from the
+// bundle (skill-ingest DENY_DIRS); this keeps the author's git clean. Idempotent.
+function ensureSkillInstallIgnored(dir) {
+  try {
+    const gi = join(dir, '.gitignore');
+    const existing = existsSync(gi) ? readFileSync(gi, 'utf8') : '';
+    if (existing.split(/\r?\n/).some((l) => l.trim().replace(/\/$/, '') === '.skillinstall')) return false;
+    const body = existing && !existing.endsWith('\n') ? existing + '\n' : existing;
+    writeFileSync(gi, body + '.skillinstall/\n');
+    return true;
+  } catch { return false; }
+}
 
-  if (mode !== 'stdio') {
-    return {
-      action: 'update_mcp',
-      started: false,
-      updateSupported: false,
-      mode,
-      currentVersion: updateMetadata?.currentVersion || PACKAGE_VERSION,
-      latestVersion: updateMetadata?.latestVersion || null,
-      updateAvailable: false,
-      required: false,
-      command: null,
-      dryRunCommand: null,
-      manualCommand: null,
-      restart: {
-        required: false,
-        guidance: restart.guidance || 'Hosted HTTP MCP updates with the Drafted server deploy.',
-      },
-      note: 'This session is using hosted HTTP MCP, so there is no npm-installed stdio daemon to update on this machine.',
-    };
-  }
 
-  const server = getServerUrl().replace(/\/$/, '');
-  const manualCommand = platform() === 'win32'
-    ? `$tmp = Join-Path $env:TEMP "drafted-install.ps1"; Invoke-WebRequest -UseBasicParsing "${server}/install.ps1" -OutFile $tmp; powershell -NoProfile -ExecutionPolicy Bypass -File $tmp`
-    : `tmp=$(mktemp); curl -fsSL ${server}/install.sh -o "$tmp" && bash "$tmp"`;
-
-  return {
-    action: 'update_mcp',
-    started: false,
-    updateSupported: true,
-    mode: 'stdio',
-    currentVersion: updateMetadata?.currentVersion || PACKAGE_VERSION,
-    latestVersion: updateMetadata?.latestVersion || null,
-    recommendedVersion: updateMetadata?.recommendedVersion || null,
-    minimumRequiredVersion: updateMetadata?.minimumRequiredVersion || null,
-    updateAvailable: !!updateMetadata?.updateAvailable,
-    required: !!updateMetadata?.required,
-    command: 'drafted update --yes',
-    dryRunCommand: 'drafted update --dry-run',
-    manualCommand,
-    restart: {
-      required: true,
-      guidance: restart.guidance || 'Restart agents after updating the npm-installed Drafted MCP daemon.',
-    },
-    note: 'This action is intentionally advisory: it does not replace the currently running MCP process. Run the command, then restart your agent/editor so it starts the updated drafted-mcp.',
-    mcpUpdate: updateMetadata || null,
-  };
-}
-
-async function getMcpUpdateMetadata() {
-  const mode = mcpMode();
-  try {
-    const query = new URLSearchParams({
-      cliVersion: PACKAGE_VERSION,
-      mcpMode: mode,
-    });
-    const policy = await api('GET', `/api/installations/latest?${query.toString()}`);
-    return normalizeMcpUpdatePolicy(policy);
-  } catch (error) {
-    return {
-      status: 'unknown',
-      currentVersion: PACKAGE_VERSION,
-      latestVersion: null,
-      recommendedVersion: null,
-      minimumRequiredVersion: null,
-      severity: 'unknown',
-      updateAvailable: false,
-      stale: false,
-      required: false,
-      reason: 'latest_check_failed',
-      enabled: false,
-      mode,
-      distribution: mode === 'stdio' ? 'npm-stdio' : 'hosted-http',
-      update: { command: null, helper: null, packageManager: 'npm' },
-      restart: { required: false, guidance: 'Drafted MCP update status is unavailable; this call still succeeded.' },
-      checkedAt: null,
-    };
-  }
-}
-
-// Process-lifetime cache: `health` is meant to be called every session, so avoid a network
-// round-trip on repeat calls. `get_org` shares the cache too (same underlying data).
-let mcpUpdateCache = null; // { data, fetchedAt }
-const MCP_UPDATE_CACHE_MS = 5 * 60_000;
-async function getCachedMcpUpdateMetadata() {
-  if (mcpUpdateCache && (Date.now() - mcpUpdateCache.fetchedAt) < MCP_UPDATE_CACHE_MS) return mcpUpdateCache.data;
-  const data = await getMcpUpdateMetadata();
-  mcpUpdateCache = { data, fetchedAt: Date.now() };
-  return data;
-}
-
-
-tool('get_org', {
-  action: z.enum(['get', 'update_mcp', 'use']).optional().describe('Default: "get" returns your orgs, this session\'s resolved working org, and Google Drive availability. "use" (with org=) sets THIS session\'s working org — a per-session, per-request DEFAULT for project-less creates/forks. It is NOT the retired sticky cursor: it never overrides a UUID-addressed resource, an explicit org=, or an open project, and it is private to this session (never a shared server row). "update_mcp" returns installed stdio MCP update instructions.'),
-  org: z.string().optional().describe('[use] org id or name to set as this session\'s working-org default.'),
-}, async (args = {}) => {
-  try {
-    const action = args.action || 'get';
-
-    if (action === 'update_mcp') {
-      const mcpUpdate = await getMcpUpdateMetadata();
-      return ok(buildInstalledMcpUpdateInstructions(mcpUpdate));
-    }
-
-    if (action === 'use') {
-      // P3 (DRAFT-36): the explicit per-session working-org. Symmetric with what a remote
-      // connection gets from its OAuth org — a stdio agent declares it here. Stored in
-      // THIS session's bucket only (never a shared server row), injected as X-Drafted-Org
-      // by api(), and only a DEFAULT: a UUID-addressed resource, an explicit org=, or an
-      // open project always win. In-memory (not persisted) so it can never clobber another
-      // process's boot state — the concurrency invariant holds by construction.
-      const want = (args.org || '').trim();
-      if (!want) throw new Error('org (id or name) required for action=use');
-      const orgs = await getOrgList();
-      const byId = orgs.find((o) => o.id === want);
-      const byName = orgs.filter((o) => (o.name || '').toLowerCase() === want.toLowerCase());
-      const hit = byId || (byName.length === 1 ? byName[0] : null);
-      if (!hit) {
-        const reason = byName.length > 1 ? `ambiguous org name "${want}"` : `not a member of org "${want}"`;
-        throw new Error(`${reason}. Your orgs: ${orgs.map((o) => o.name || o.id).join(', ') || '(none resolvable)'}`);
-      }
-      getSessionState().boundOrgId = hit.id;
-      return ok({
-        workingOrg: { id: hit.id, name: hit.name },
-        note: `Working org for this session is now "${hit.name}". Project-less creates/forks default here; a UUID-addressed resource, an explicit org=, or an open project still win. Not the retired switch — per-session and per-request, never a shared cursor.`,
-      });
-    }
-
-    // Source of truth = the org this MCP process scopes requests to (what mutations
-    // will actually hit). Each MCP process is independent — multiple agents can run
-    // in parallel scoped to different orgs. /auth/me reads sessions.org_id directly.
-    const me = await api('GET', '/auth/me');
-    const sessionOrgId = me?.orgId || null;
-
-    const data = await api('GET', '/api/orgs');
-    const orgs = (data.orgs || data || []).map(o => ({ id: o.orgId || o.id, name: o.orgName || o.name }));
-    const activeOrg = sessionOrgId ? (orgs.find(o => o.id === sessionOrgId) || null) : null;
-
-    // This session's WORKING org (P3): where project-less creates/forks land by default.
-    // It's the per-session boundOrgId — set by an open project, a get_org(action="use"),
-    // or (remote) the connection's org — not the shared session cursor. Announce it so an
-    // agent can self-verify without guessing (invariant: "announced, never opaque").
-    // Never REPORT a working org the caller isn't a member of. The old fallback
-    // fabricated `{ id, name: null }` for an unknown id, which is how a stale/foreign
-    // binding read as a real (if nameless) org instead of as the defect it is. If it
-    // isn't in the memberships we just fetched, it can't address anything — clear it
-    // so the session falls back to asking for an explicit org.
-    const sess = getSessionState();
-    const workingOrg = sess.boundOrgId ? (orgs.find(o => o.id === sess.boundOrgId) || null) : null;
-    if (sess.boundOrgId && !workingOrg) sess.boundOrgId = null;
-
-    const googleDrive = await getGoogleDriveAvailability();
-    const mcpUpdate = await getCachedMcpUpdateMetadata();
-
-    let members = [];
-    if (sessionOrgId) {
-      try {
-        const memberData = await api('GET', `/api/orgs/${sessionOrgId}/members`);
-        members = memberData.members || memberData || [];
-      } catch { /* no members */ }
-    }
-    return ok({
-      activeOrg,
-      workingOrg,
-      orgs,
-      members: members.map(m => ({ id: m.userId, name: m.username, email: m.email, role: m.role })),
-      googleDrive,
-      mcpVersion: PACKAGE_VERSION,
-      mcpUpdate,
-      session: await sessionSurfaceBlock(),
-      note: "Org is derived from the resource you address: opening a project binds this agent session's context (org = the project's org), and UUIDs (pageId/skillId/projectId) self-derive. `workingOrg` is where project-less creates/forks land by default — set it explicitly with get_org(action=\"use\", org=...) when you're multi-org and working project-less; a UUID/explicit org=/open project always wins. It is per-session and per-request, never a shared cursor or a switch. `session` is THIS agent's own surface identity — `session.name` is the human-readable tab name the user sees (use it to identify which agent you are); refresh it via whoami. Concurrent MCP sessions can operate on different orgs simultaneously. If googleDrive.connected is true, strongly prefer Google Workspace frames for docs, sheets, and slides.",
-    });
-  } catch (error) { return err(error); }
-});
-
-// ── Filesystem tools (direct HTTP to /api/fs) ─────────────────────
-
-tool('frame', 'Frame CRUD in the ACTIVE PROJECT. Dispatch by `action`: read (by path, frame URL, or UUID), write (new frame or overwrite), set_state / get_state (persist or read a deployed windowType:"app" frame\'s hydration state — push e.g. {specText} to drive a generic app frame with data after deploy; the canvas hydrates the app from it on load), Google Sheet actions (`get_sheet`, `read_sheet_values`, `write_sheet_values`, `append_sheet_rows`, `clear_sheet_range`, `update_sheet`), Google Doc actions (`get_doc`, `read_doc_content`, `write_doc_content`, `append_doc_content`, `clear_doc_content`, `update_doc`), Google Slide actions (`get_slide`, `read_slide_content`, `write_slide_content`, `append_slides`, `clear_slides`, `update_slide`), write_excalidraw (native editable Excalidraw diagram — full-scene replace), edit_excalidraw (element-level upsert/remove by id, for growing or surgically editing a large scene without resending it), edit (hashline ops), mv (rename/move), anchor (mark as required-read for the layer), search (match frame names). Use project(action="open") first. For listing use `ls`, for deletion use `rm`.\n\n**Google Workspace native content:** Create or attach Google Docs/Sheets/Slides with `frame(action="write", googleType=...)`. After creating, immediately populate the native file using the matching write action in the same tool — do NOT leave it empty and do NOT tell the user you cannot write to it. For Sheets: `write_sheet_values` or `append_sheet_rows` (pass `path` or `googleId` from the create response). For Docs: `write_doc_content`/`append_doc_content`. For Slides: `write_slide_content`/`append_slides`. Read with `read_sheet_values`/`read_doc_content`/`read_slide_content`. Do NOT use inline `frame.write(content)` or hashline `frame.edit` to populate Google Workspace frames.\n\n**Write — content, binary, or Google Workspace frame:** ' + (isRemote ? 'Provide exactly one of `content` (HTML/markdown/text), `base64` (base64-encoded binary with optional `content_type`), or `googleType` (`google-doc`, `google-sheet`, `google-slide`).' : 'Provide exactly one of `content` (HTML/markdown/text), `file_path` (absolute local file), `base64` (base64-encoded binary with optional `content_type`), or `googleType` (`google-doc`, `google-sheet`, `google-slide`).') + ' Call get_org first; when `googleDrive.connected` is true, strongly prefer Google Workspace frames for docs, sheets, and slides in that org. For inline content, filename extension matters: use `.html` for complete HTML documents and `.md` for Markdown. Never place a full HTML document in a `.md` or extensionless frame. For a new Google file, pass `googleType` and optional `title`; for an existing Google file, pass `googleType` plus `url` or `googleId`. ' + (isRemote ? 'For binary frames (images, PDFs, videos), pass `base64` with the binary bytes.' : 'For binary frames (images, PDFs, videos), use `file_path` when the file is local to the MCP host, or `base64` when the caller already has binary bytes.') + '\n\n**Write — dimensions:** By default, frames use the layer\'s default size (e.g. 1440×900 for designs, 1440×3000 for wireframes). Often too large for small content. Use `autoSize: true` to measure HTML content and size to fit, or pass explicit `width`/`height`.', {
-  projectId: PROJECT_OVERRIDE_PARAM,
-  action: z.enum(['read', 'write', 'set_state', 'get_state', 'write_sheet_values', 'read_sheet_values', 'append_sheet_rows', 'clear_sheet_range', 'get_sheet', 'update_sheet', 'get_doc', 'read_doc_content', 'write_doc_content', 'append_doc_content', 'clear_doc_content', 'update_doc', 'get_slide', 'read_slide_content', 'write_slide_content', 'append_slides', 'clear_slides', 'update_slide', 'create_office', 'read_office', 'edit_office', 'write_excalidraw', 'edit_excalidraw', 'edit', 'mv', 'anchor', 'search', 'versions', 'read_version', 'restore_version']).describe('Operation to perform. Use native Doc/Slide actions for Google Docs/Slides; do not use inline write/edit for native Workspace content.'),
-  path: z.string().optional().describe('[read] /{layer}/{lane}/{filename}, frame URL, or UUID. [write|edit|anchor] /{layer}/{lane}/{filename}.'),
-  lines: z.string().optional().describe('[read] line range (e.g. "1-50"). Omit to read all.'),
-  content: z.string().optional().describe('[write] HTML/markdown/text for Drafted inline frames. [write_doc_content|append_doc_content] native Google Doc body text. Do not use action=write content to populate Google Doc/Slide frames.'),
-  excalidraw_data: z.any().optional().describe('[write_excalidraw] Excalidraw scene JSON object or JSON string. Defaults to an empty scene. EVERY write_excalidraw REPLACES THE WHOLE SCENE — it does not merge; to grow a diagram, either resend all prior elements plus the new ones, or use action="edit_excalidraw" (element-level upsert/remove by id) which needs only the changed elements. WRITE LEAN SCENES: your MCP client caps tool-call arguments (a big scene is rejected before Drafted ever sees it — once a scene exceeds that cap, edit it with edit_excalidraw, not write_excalidraw), so emit only the fields that carry meaning — id, type, x, y, width, height, angle, text/label, strokeColor, backgroundColor, fillStyle, strokeWidth, and the binding ids for arrows. Omit every field the editor can default (version, versionNonce, seed, updated, groupIds, boundElements when empty, roundness, opacity at 100, frameId when null). The editor fills them on open; shipping them can triple the payload for no gain.'),
-  elements: z.array(z.any()).optional().describe('[edit_excalidraw] Excalidraw elements to upsert by id: an element whose id already exists is shallow-merged (a partial {id,x,y} moves it, keeping its other props); a new id is appended. Send only the changed elements — the rest of the scene is preserved. Same lean-fields guidance as excalidraw_data.'),
-  remove: z.array(z.string()).optional().describe('[edit_excalidraw] Element ids to delete from the scene.'),
-  raw: z.boolean().optional().describe('[read] return the frame content as stored bytes (no NNNhash| line-number prefixes) — use when you need to parse the content as JSON (e.g. an Excalidraw scene). Note: edit ops require the hashline anchors, so omit raw when you intend to edit.'),
-  state: z.any().optional().describe('[set_state] App-frame state object (JSON) to persist for a deployed windowType:"app" frame — e.g. {specText:"..."} for the AS/NZS electrical app. The canvas hydrates the app from this on load (the host posts a "hydrate" message with it when the frame mounts), so you can deploy a generic app frame once and drive it with data afterwards. Max 64KB. Frame must be an app frame.'),
-  file_path: z.string().optional().describe('[write] absolute path to a local file to upload. Mutually exclusive with content/base64/googleType.'),
-  base64: z.string().optional().describe('[write] base64-encoded binary content. Mutually exclusive with content/file_path/googleType. Use with content_type when known.'),
-  content_type: z.string().optional().describe('[write + base64] MIME type for base64 binary content, e.g. image/png, application/pdf. Defaults from the path extension or application/octet-stream.'),
-  googleType: z.enum(['google-doc', 'google-sheet', 'google-slide']).optional().describe('[write] Create or attach a native Google Workspace frame. Use with title to create new, or url/googleId to attach existing.'),
-  title: z.string().optional().describe('[write + googleType] Title for a new native file. Defaults to filename from path.'),
-  url: z.string().optional().describe('[write + googleType] Existing Google file URL to attach.'),
-  googleId: z.string().optional().describe('[write + googleType] Existing Google file ID to attach. [Sheet/Doc/Slide actions] Native Google file ID to use when not resolving from path/frame.'),
-  officeType: z.enum(['xlsx', 'docx']).optional().describe('[create_office] native Drafted-owned Office format to author: xlsx (spreadsheet) or docx (document). Real OOXML bytes — download is the file itself, no conversion.'),
-  rows: z.array(z.array(z.union([z.string(), z.number(), z.boolean(), z.null()]))).optional().describe('[create_office xlsx] initial rows for a single-sheet xlsx (2D array of cell values).'),
-  sheets: z.array(z.object({ name: z.string().optional(), rows: z.array(z.array(z.union([z.string(), z.number(), z.boolean(), z.null()]))).optional() })).optional().describe('[create_office xlsx] multiple sheets: [{ name, rows }].'),
-  paragraphs: z.array(z.object({ html: z.string().optional(), text: z.string().optional(), style: z.string().optional(), align: z.string().optional(), list: z.string().optional() })).optional().describe('[create_office docx] document paragraphs: [{ html?, text?, style?, align?, list? }]. html uses the inline subset <b>,<i>,<u>,<s>,<span style="color:#c00;font-size:12pt;font-family:Arial">. style = Heading1..Heading6 or Title. align = left|center|right|justify. list = bullet|number.'),
-  sheet: z.string().optional().describe('[read_office xlsx] limit the read to one sheet by name.'),
-  maxCells: z.number().optional().describe('[read_office xlsx] cap non-empty cells returned (default 5000).'),
-  ops: z.array(z.object({
-    type: z.string(),
-    sheet: z.string().optional(),
-    ref: z.string().optional(),
-    value: z.union([z.string(), z.number(), z.boolean(), z.null()]).optional(),
-    formula: z.string().optional(),
-    cells: z.array(z.object({ ref: z.string(), value: z.union([z.string(), z.number(), z.boolean(), z.null()]).optional(), formula: z.string().optional(), cellStyle: z.object({ bold: z.boolean().optional(), italic: z.boolean().optional(), underline: z.boolean().optional(), fontSize: z.number().optional(), fontName: z.string().optional(), color: z.string().optional(), bg: z.string().optional(), align: z.string().optional(), valign: z.string().optional(), numFmt: z.string().optional(), border: z.boolean().optional() }).optional() })).optional(),
-    range: z.string().optional(),
-    name: z.string().optional(),
-    from: z.string().optional(),
-    to: z.string().optional(),
-    rows: z.array(z.array(z.union([z.string(), z.number(), z.boolean(), z.null()]))).optional(),
-    id: z.string().optional(),
-    html: z.string().optional(),
-    text: z.string().optional(),
-    find: z.string().optional(),
-    replace: z.string().optional(),
-    all: z.boolean().optional(),
-    start: z.number().optional(),
-    end: z.number().optional(),
-    style: z.string().optional(),
-    align: z.string().optional(),
-    list: z.string().optional(),
-    header: z.boolean().optional(),
-    col: z.string().optional(),
-    width: z.number().optional(),
-    columns: z.array(z.object({ col: z.string(), width: z.number() })).optional(),
-    cellStyle: z.object({ bold: z.boolean().optional(), italic: z.boolean().optional(), underline: z.boolean().optional(), fontSize: z.number().optional(), fontName: z.string().optional(), color: z.string().optional(), bg: z.string().optional(), align: z.string().optional(), valign: z.string().optional(), numFmt: z.string().optional(), border: z.boolean().optional() }).optional(),
-    after: z.string().optional(),
-    before: z.string().optional(),
-    attrs: z.object({ b: z.boolean().optional(), i: z.boolean().optional(), u: z.boolean().optional(), strike: z.boolean().optional(), color: z.string().optional(), size: z.number().optional(), font: z.string().optional() }).optional(),
-  })).optional().describe('[edit_office] edit ops, resolved against stable addresses (no index drift). xlsx: {type:"setCell",sheet?,ref,value|formula,cellStyle?} | {type:"setCells",sheet?,cells:[{ref,value|formula,cellStyle?}]} | {type:"styleRange",sheet?,range,cellStyle} | {type:"setColumnWidth",sheet?,columns:[{col,width}]} | {type:"clearRange",sheet?,range} | {type:"addSheet",name,rows?} | {type:"renameSheet",from,to} | {type:"deleteSheet",name}. cellStyle:{bold,italic,underline,fontSize,fontName,color,bg,align,valign,numFmt,border}. docx (id = paraId from read_office): {type:"setParagraph",id,html|text,style?,align?,list?} | {type:"format",id,start,end,attrs:{b,i,u,strike,color,size,font}} (run-level char range) | {type:"replaceText",id,find,replace,all?} | {type:"setStyle",id,style?,align?,list?} | {type:"insertParagraph",after|before,html|text,style?,align?,list?} | {type:"insertTable",after|before,rows:[[...]],header?} | {type:"deleteParagraph",id}. align=left|center|right|justify; list=bullet|number.'),
-  format: z.enum(['plain_text', 'markdown']).optional().describe('[write_doc_content|append_doc_content] Source format hint. Currently plain_text and minimal markdown are accepted as text.'),
-  mode: z.enum(['replace', 'append', 'clear']).optional().describe('[Doc/Slide content actions] Optional mode hint for clients; prefer the explicit write/append/clear action names.'),
-  slides: z.array(z.object({
-    title: z.string().optional(),
-    bullets: z.array(z.string()).optional(),
-    speakerNotes: z.string().optional(),
-    layout: z.string().optional(),
-  })).optional().describe('[write_slide_content|append_slides] Structured slide spec: [{ title, bullets, speakerNotes?, layout? }].'),
-  requests: z.array(z.any()).optional().describe('[update_doc|update_slide] Raw Google Docs/Slides batchUpdate requests for advanced updates only; common Doc/Slide population should use write_doc_content/append_doc_content/write_slide_content/append_slides.'),
-  slideObjectIds: z.array(z.string()).optional().describe('[clear_slides] Optional slide object IDs to delete. Omit to clear all slides.'),
-  range: z.string().optional().describe('[Sheet value actions] A1 range, e.g. Sheet1!A1 or Data!A:Z.'),
-  values: z.array(z.array(z.union([z.string(), z.number(), z.boolean(), z.null()]))).optional().describe('[write_sheet_values|append_sheet_rows] 2D array of row values (each cell: string, number, boolean, or null).'),
-  valueInputOption: z.enum(['RAW', 'USER_ENTERED']).optional().describe('[write_sheet_values|append_sheet_rows] Google Sheets value input option. Defaults to USER_ENTERED.'),
-  majorDimension: z.enum(['ROWS', 'COLUMNS']).optional().describe('[Sheet value actions] Major dimension for values. Defaults to ROWS when writing/appending.'),
-  valueRenderOption: z.enum(['FORMATTED_VALUE', 'UNFORMATTED_VALUE', 'FORMULA']).optional().describe('[read_sheet_values] How values should be rendered. Defaults to Google Sheets API default.'),
-  dateTimeRenderOption: z.enum(['SERIAL_NUMBER', 'FORMATTED_STRING']).optional().describe('[read_sheet_values] How dates/times should be rendered.'),
-  insertDataOption: z.enum(['OVERWRITE', 'INSERT_ROWS']).optional().describe('[append_sheet_rows] How new rows are inserted. Defaults to INSERT_ROWS.'),
-  operation: z.enum(['add_sheet', 'rename_sheet']).optional().describe('[update_sheet] Sheet tab operation.'),
-  sheetTitle: z.string().optional().describe('[update_sheet add_sheet] Title for the new sheet tab.'),
-  sheetId: z.number().optional().describe('[update_sheet rename_sheet] Numeric sheet/tab id.'),
-  newTitle: z.string().optional().describe('[update_sheet rename_sheet] New title for the sheet tab.'),
-  autoSize: z.boolean().optional().describe('[write] measure HTML content and size frame to fit. Content only, not file_path.'),
-  width: z.number().optional().describe('[write] explicit width in pixels. Overrides layer default. Ignored if autoSize=true.'),
-  height: z.number().optional().describe('[write] explicit height in pixels. Overrides layer default. Ignored if autoSize=true.'),
-  color: z.string().optional().describe('[write] CSS color for frame border (e.g. #ff0000, red).'),
-  operations: z.array(z.object({
-    type: z.enum(['replace', 'delete', 'insertAfter', 'insertBefore']).describe('Edit type'),
-    lineHash: z.string().describe('The full line anchor copied verbatim from read output — line number + 3-char hash, e.g. "182vix" (the token left of the "|"). NOT the bare hash "vix": that is rejected, since the same hash can recur on multiple lines.'),
-    newContent: z.string().optional().describe('New content (for replace, insertAfter, insertBefore)'),
-  })).optional().describe('[edit] hashline edit operations'),
-  from: z.string().optional().describe('[mv] source path: /{layer}/{lane}/{filename} for a frame, /{layer}/{lane} for a lane, /{layer} for a whole layer (lane/layer require toProjectId)'),
-  to: z.string().optional().describe('[mv] destination path /{layer}/{lane}/{filename} — the layer segment is always required and explicit'),
-  toProjectId: z.string().optional().describe('[mv] move ACROSS projects: destination project UUID/slug/name. Same-org only. Frame ids and version history follow; frame-scoped shares, public links, and lane share tokens are NOT carried into the destination project. Omit for the classic in-project rename/move.'),
-  dryRun: z.boolean().optional().describe('[mv] preview the move without applying it; returns the resolved frame and current path so you can confirm before retrying with dryRun=false.'),
-  anchored: z.boolean().optional().describe('[anchor] true to anchor, false to unanchor. Anchored frames MUST be read before writing/editing in the same layer.'),
-  query: z.string().optional().describe('[search] term to match against frame names'),
-  limit: z.number().optional().describe('[search] max results (default 50, max 200)'),
-  versionId: z.string().optional().describe('[read_version|restore_version] version id'),
-  reason: z.string().optional().describe('[restore_version] reason recorded on the snapshot of current content'),
-}, async (args) => {
-  try {
-    const { action } = args;
-    // G1: don't edit frame content before the session has searched the wiki.
-    // When blocking, auto-inject the (bounded) wiki index so the search lands.
-    if (G1_MUTATING_FRAME_ACTIONS.has(action)) {
-      const gs = getSessionState().gates;
-      if (!gs.wikiSearched) {
-        let wikiIndex = '';
-        try { const tree = await api('GET', '/api/wiki/tree'); wikiIndex = formatWikiIndex(tree?.pages || []); } catch { /* index best-effort */ }
-        return err(new Error(g1Block(gs, wikiIndex)));
-      }
-    }
-    // Echo project context on every mutation so the agent sees where the
-    // write landed before it can develop a wrong assumption.
-    const projectCtx = getCurrentProjectContext();
-    const withProject = (result) => ({ ...result, project: projectCtx });
-    const workspaceBody = (kind) => {
-      const { path, googleId } = args;
-      const body = {};
-      const frameUrlMatch = path?.match(/\/f\/([a-f0-9-]{36})/);
-      const uuidMatch = path?.match(/^[a-f0-9-]{36}$/);
-      if (googleId) {
-        if (kind === 'sheet') body.spreadsheetId = googleId;
-        else if (kind === 'doc') body.documentId = googleId;
-        else body.presentationId = googleId;
-      } else if (frameUrlMatch?.[1] || uuidMatch) {
-        body.frameId = frameUrlMatch?.[1] || path;
-      } else if (path) {
-        body.path = path;
-        body.projectId = getState().projectId;
-      } else {
-        const label = kind === 'sheet' ? 'Google Sheet' : kind === 'doc' ? 'Google Doc' : 'Google Slide';
-        throw new Error(`Provide path to a ${label} frame, frame ID/URL, or googleId/native file ID`);
-      }
-      return body;
-    };
-    // Resolve a frame path / URL / UUID to a frame id for the native Office routes.
-    const resolveOfficeFrameId = async (path) => {
-      if (!path) throw new Error('Provide path to an office frame, frame URL, or frame ID');
-      const frameUrlMatch = path.match(/\/f\/([a-f0-9-]{36})/);
-      const uuidMatch = path.match(/^[a-f0-9-]{36}$/);
-      if (frameUrlMatch?.[1] || uuidMatch) return frameUrlMatch?.[1] || path;
-      const parts = path.replace(/^\/+/, '').split('/');
-      if (parts.length !== 3) throw new Error('Path must be /{layer}/{lane}/{filename}, a frame URL, or a frame ID');
-      const frame = await api('GET', `/api/fs/${parts[0]}/${parts[1]}/${parts[2]}`);
-      const id = frame?.id || frame?.frame?.id;
-      if (!id) throw new Error('Office frame not found for path');
-      return id;
-    };
-    switch (action) {
-      case 'read': {
-        const { path, lines, raw } = args;
-        if (!path) throw new Error('path required for action=read');
-        const qs = [];
-        if (lines) qs.push(`lines=${encodeURIComponent(lines)}`);
-        if (raw) qs.push('raw=1');
-        const query = qs.length ? `?${qs.join('&')}` : '';
-        const frameUrlMatch = path.match(/\/f\/([a-f0-9-]{36})/);
-        const uuidMatch = path.match(/^[a-f0-9-]{36}$/);
-        const frameId = frameUrlMatch?.[1] || (uuidMatch ? path : null);
-        let result;
-        if (frameId) {
-          result = await api('GET', `/api/fs/by-id/${frameId}${query}`);
-        } else {
-          const parts = path.replace(/^\/+/, '').split('/');
-          // 2 segments = a layer-root frame (empty lane, e.g. /designs/AGENTS.md);
-          // 3 = /{layer}/{lane}/{filename}. Both resolve server-side.
-          if (parts.length !== 2 && parts.length !== 3) throw new Error('Path must be /{layer}/{filename}, /{layer}/{lane}/{filename}, a frame URL, or a frame ID');
-          result = await api('GET', `/api/fs/${parts.map(encodeURIComponent).join('/')}${query}`);
-        }
-        // Surface content as the visible text. Some Claude clients prefer
-        // structuredContent over text when both are present and structured looks
-        // "complete" — so include content in BOTH places to ensure the agent
-        // can always see the frame's actual content, not just metadata.
-        const structured = frameStructuredContent(result, projectCtx);
-        structured.content = result.content ?? '';
-        structured.size = result.size;
-        structured.totalLines = result.totalLines;
-        const visibleText = JSON.stringify({
-          path: result.path,
-          contentType: result.contentType,
-          size: result.size,
-          totalLines: result.totalLines,
-          content: result.content ?? '',
-        }, null, 2);
-        return ok(visibleText, {
-          structuredContent: structured,
-          _meta: { frameHtml: result.content },
-        });
-      }
-      case 'set_state':
-      case 'get_state': {
-        // Read/write the persisted appState of a deployed windowType:'app' frame
-        // (designs.metadata.appState via /api/file/:id/state). The canvas hydrates
-        // the app from this on load — so a generic app frame can be driven with
-        // data after deploy (e.g. push {specText} to the AS/NZS electrical app).
-        const { path } = args;
-        if (!path) throw new Error(`path required for action=${action}`);
-        const urlMatch = path.match(/\/f\/([a-f0-9-]{36})/);
-        const uuidMatch = path.match(/^[a-f0-9-]{36}$/);
-        let frameId = urlMatch?.[1] || (uuidMatch ? path : null);
-        if (!frameId) {
-          const parts = path.replace(/^\/+/, '').split('/');
-          if (parts.length !== 3) throw new Error('Path must be /{layer}/{lane}/{filename}, a frame URL, or a frame ID');
-          const f = await api('GET', `/api/fs/${parts[0]}/${parts[1]}/${parts[2]}`);
-          frameId = f.id;
-          if (!frameId) throw new Error(`Could not resolve a frame id for ${path}`);
-        }
-        if (action === 'get_state') {
-          const r = await api('GET', `/api/file/${frameId}/state`);
-          return ok(JSON.stringify({ frameId, state: r.state ?? null }, null, 2));
-        }
-        if (args.state === undefined) throw new Error('state required for action=set_state — the app-frame state object to persist; the app hydrates from it on load');
-        await api('POST', `/api/file/${frameId}/state`, { state: args.state });
-        return ok(`App state persisted to frame ${frameId}. The app hydrates from it on next load — open or refresh the frame to see it render with the new state.`);
-      }
-      case 'get_sheet':
-      case 'read_sheet_values':
-      case 'write_sheet_values':
-      case 'append_sheet_rows':
-      case 'clear_sheet_range':
-      case 'update_sheet': {
-        const { path, googleId, range, values, valueInputOption, majorDimension, valueRenderOption, dateTimeRenderOption, insertDataOption, operation, sheetTitle, sheetId, newTitle } = args;
-        const body = workspaceBody('sheet');
-        if (range) body.range = range;
-        if (majorDimension) body.majorDimension = majorDimension;
-        if (action === 'write_sheet_values' || action === 'append_sheet_rows') {
-          if (!values || !Array.isArray(values)) throw new Error(`values required for action=${action}`);
-          body.values = values;
-          body.valueInputOption = valueInputOption || 'USER_ENTERED';
-          body.majorDimension = majorDimension || 'ROWS';
-        }
-        if (action === 'read_sheet_values') {
-          if (valueRenderOption) body.valueRenderOption = valueRenderOption;
-          if (dateTimeRenderOption) body.dateTimeRenderOption = dateTimeRenderOption;
-        }
-        if (action === 'append_sheet_rows') body.insertDataOption = insertDataOption || 'INSERT_ROWS';
-        if (action === 'update_sheet') {
-          body.operation = operation;
-          if (sheetTitle) body.sheetTitle = sheetTitle;
-          if (sheetId != null) body.sheetId = sheetId;
-          if (newTitle) body.newTitle = newTitle;
-        }
-        const endpoint = action === 'get_sheet'
-          ? '/api/google/workspace/sheet'
-          : action === 'read_sheet_values'
-          ? '/api/google/workspace/sheet-values/read'
-          : action === 'write_sheet_values'
-          ? '/api/google/workspace/sheet-values'
-          : action === 'append_sheet_rows'
-          ? '/api/google/workspace/sheet-values/append'
-          : action === 'clear_sheet_range'
-          ? '/api/google/workspace/sheet-values/clear'
-          : '/api/google/workspace/sheet-update';
-        const result = await api('POST', endpoint, body);
-        return ok(withProject(result));
-      }
-      case 'get_doc':
-      case 'read_doc_content':
-      case 'write_doc_content':
-      case 'append_doc_content':
-      case 'clear_doc_content':
-      case 'update_doc': {
-        const { content, format, mode, requests } = args;
-        const body = workspaceBody('doc');
-        if (format) body.format = format;
-        if (mode) body.mode = mode;
-        if (action === 'write_doc_content' || action === 'append_doc_content') {
-          if (typeof content !== 'string') throw new Error(`content string required for action=${action}`);
-          body.content = content;
-        }
-        if (action === 'update_doc') {
-          if (!Array.isArray(requests)) throw new Error('requests array required for action=update_doc');
-          body.requests = requests;
-        }
-        const endpoint = action === 'get_doc'
-          ? '/api/google/workspace/doc'
-          : action === 'read_doc_content'
-          ? '/api/google/workspace/doc-content/read'
-          : action === 'write_doc_content'
-          ? '/api/google/workspace/doc-content'
-          : action === 'append_doc_content'
-          ? '/api/google/workspace/doc-content/append'
-          : action === 'clear_doc_content'
-          ? '/api/google/workspace/doc-content/clear'
-          : '/api/google/workspace/doc-update';
-        const result = await api('POST', endpoint, body);
-        return ok(withProject(result));
-      }
-      case 'get_slide':
-      case 'read_slide_content':
-      case 'write_slide_content':
-      case 'append_slides':
-      case 'clear_slides':
-      case 'update_slide': {
-        const { slides, requests, slideObjectIds, mode } = args;
-        const body = workspaceBody('slide');
-        if (mode) body.mode = mode;
-        if (action === 'write_slide_content' || action === 'append_slides') {
-          if (!Array.isArray(slides)) throw new Error(`slides array required for action=${action}`);
-          body.slides = slides;
-        }
-        if (action === 'clear_slides' && Array.isArray(slideObjectIds)) body.slideObjectIds = slideObjectIds;
-        if (action === 'update_slide') {
-          if (!Array.isArray(requests)) throw new Error('requests array required for action=update_slide');
-          body.requests = requests;
-        }
-        const endpoint = action === 'get_slide'
-          ? '/api/google/workspace/slide'
-          : action === 'read_slide_content'
-          ? '/api/google/workspace/slide-content/read'
-          : action === 'write_slide_content'
-          ? '/api/google/workspace/slide-content'
-          : action === 'append_slides'
-          ? '/api/google/workspace/slides/append'
-          : action === 'clear_slides'
-          ? '/api/google/workspace/slides/clear'
-          : '/api/google/workspace/slide-update';
-        const result = await api('POST', endpoint, body);
-        return ok(withProject(result));
-      }
-      case 'create_office': {
-        // Author a native Drafted-owned Office file (real bytes; download is the
-        // file itself). Populate via edit_office; read structure via read_office.
-        const { path, title, officeType = 'xlsx', rows, sheets, paragraphs } = args;
-        let layer = 'copy';
-        let lane = 'default';
-        let label = title;
-        if (path) {
-          const p = path.replace(/^\/+/, '').split('/');
-          if (p.length === 3) { layer = p[0]; lane = p[1]; label = p[2]; }
-        }
-        if (!label) throw new Error('Provide title (filename) or a /{layer}/{lane}/{filename} path for the new office file');
-        return ok(await api('POST', '/api/office/create', { projectId: getState().projectId, layer, lane, label, format: officeType, rows, sheets, paragraphs }));
-      }
-      case 'read_office': {
-        const id = await resolveOfficeFrameId(args.path);
-        const q = [];
-        if (args.sheet) q.push('sheet=' + encodeURIComponent(args.sheet));
-        if (args.maxCells) q.push('maxCells=' + Number(args.maxCells));
-        return ok(await api('GET', `/api/office/${id}${q.length ? '?' + q.join('&') : ''}`));
-      }
-      case 'edit_office': {
-        if (!Array.isArray(args.ops) || !args.ops.length) throw new Error('ops (non-empty array) required for action=edit_office');
-        const id = await resolveOfficeFrameId(args.path);
-        return ok(await api('POST', `/api/office/${id}/edit`, { ops: args.ops }));
-      }
-      case 'write': {
-        const { path, content, file_path, base64, content_type, autoSize, width, height, color, googleType, title, url, googleId } = args;
-        if (!path) throw new Error('path required for action=write');
-        const writeSources = [content != null, !!file_path, base64 != null, !!googleType].filter(Boolean).length;
-        if (writeSources > 1) throw new Error('Provide only one of content, file_path, base64, or googleType');
-        if (writeSources === 0) throw new Error('Provide content, file_path, base64, or googleType');
-        const parts = path.replace(/^\/+/, '').split('/');
-        if (parts.length !== 3) throw new Error('Path must be /{layer}/{lane}/{filename}');
-        if (googleType) {
-          const projectId = getState().projectId;
-          if (!projectId) throw new Error('Open a project first with project(action="open") before creating Google Workspace frames');
-          const label = basename(parts[2], extname(parts[2])) || parts[2];
-          const body = {
-            projectId,
-            layer: parts[0],
-            lane: parts[1],
-            label,
-            type: googleType,
-            width,
-            height,
-          };
-          const result = url || googleId
-            ? await api('POST', '/api/google/workspace/frame', { ...body, url, googleId })
-            : await api('POST', '/api/google/workspace/create-frame', { ...body, title: title || label });
-          return ok(withProject(withFrameBreadcrumb({
-            ...result,
-            path,
-            label,
-            contentType: 'text/html',
-            sourceType: googleType,
-          }, { hint: true })), {
-            structuredContent: frameStructuredContent({ ...result, path, label, contentType: 'text/html' }, projectCtx),
-          });
-        }
-        let body;
-        if (file_path) {
-          const resolved = resolve(file_path);
-          if (!existsSync(resolved)) throw new Error(`File not found: ${resolved}`);
-          const ext = extname(resolved).toLowerCase();
-          const TEXT_EXTS = ['.html', '.htm', '.md', '.markdown', '.txt', '.css', '.js', '.mjs', '.json', '.xml', '.excalidraw'];
-          if (TEXT_EXTS.includes(ext)) {
-            body = { content: readFileSync(resolved, 'utf8') };
-            if (autoSize) body.autoSize = true;
-          } else {
-            const buffer = readFileSync(resolved);
-            const MIME = { '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.gif': 'image/gif', '.webp': 'image/webp', '.svg': 'image/svg+xml', '.pdf': 'application/pdf', '.mp4': 'video/mp4', '.webm': 'video/webm', '.mov': 'video/quicktime', '.m4v': 'video/x-m4v' };
-            body = { base64: buffer.toString('base64'), contentType: MIME[ext] || 'application/octet-stream' };
-          }
-        } else if (base64 != null) {
-          body = { base64, contentType: content_type || mimeFromExt(extname(parts[2])) };
-        } else {
-          body = { content };
-          if (autoSize) body.autoSize = true;
-        }
-        if (width) body.width = width;
-        if (height) body.height = height;
-        if (color) body.color = color;
-        const result = await api('PUT', `/api/fs/${parts[0]}/${parts[1]}/${parts[2]}`, body);
-        return ok(withProject(withFrameBreadcrumb(result, { hint: true })), {
-          structuredContent: frameStructuredContent(result, projectCtx),
-          _meta: body.content ? { frameHtml: body.content } : undefined,
-        });
-      }
-      case 'write_excalidraw': {
-        const { path, excalidraw_data, width, height, color } = args;
-        if (!path) throw new Error('path required for action=write_excalidraw');
-        const parts = path.replace(/^\/+/, '').split('/');
-        if (parts.length !== 3) throw new Error('Path must be /{layer}/{lane}/{filename}');
-        const filename = parts[2].toLowerCase().endsWith('.excalidraw') ? parts[2] : parts[2] + '.excalidraw';
-        const scene = excalidraw_data ?? emptyExcalidrawScene();
-        const body = { content: stringifyExcalidrawScene(scene) };
-        if (width) body.width = width;
-        if (height) body.height = height;
-        if (color) body.color = color;
-        const result = await api('PUT', `/api/fs/${parts[0]}/${parts[1]}/${filename}`, body);
-        return ok(withProject(withFrameBreadcrumb(result, { hint: true })), {
-          structuredContent: frameStructuredContent(result, projectCtx),
-          _meta: { frameHtml: body.content },
-        });
-      }
-      case 'edit_excalidraw': {
-        const { path, elements, remove } = args;
-        if (!path) throw new Error('path required for action=edit_excalidraw');
-        const parts = path.replace(/^\/+/, '').split('/');
-        if (parts.length !== 3) throw new Error('Path must be /{layer}/{lane}/{filename}');
-        const filename = parts[2].toLowerCase().endsWith('.excalidraw') ? parts[2] : parts[2] + '.excalidraw';
-        if (!Array.isArray(elements) && !Array.isArray(remove)) {
-          throw new Error('Provide elements[] to add/update and/or remove[] element ids');
-        }
-        const result = await api('POST', '/api/fs/edit-excalidraw', { path: `/${parts[0]}/${parts[1]}/${filename}`, elements, remove });
-        return ok(withProject(withFrameBreadcrumb(result, { hint: true })), {
-          structuredContent: frameStructuredContent(result, projectCtx),
-        });
-      }
-      case 'edit': {
-        const { path, operations } = args;
-        if (!path) throw new Error('path required for action=edit');
-        if (!Array.isArray(operations) || operations.length === 0) throw new Error('operations (array) required for action=edit');
-        const result = await api('POST', '/api/fs/edit', { path, operations });
-        return ok(withProject(result), {
-          structuredContent: frameStructuredContent(result, projectCtx),
-          _meta: result.content ? { frameHtml: result.content } : undefined,
-        });
-      }
-      case 'mv': {
-        const { from, to, toProjectId, dryRun = false } = args;
-        if (!from || !to) throw new Error('from and to required for action=mv');
-        if (dryRun) {
-          // Resolve current frame at `from`. Don't apply the rename, just
-          // confirm the source exists and report what `to` will become.
-          const current = await api('GET', `/api/fs?path=${encodeURIComponent(from)}`);
-          return ok(withProject({
-            dryRun: true,
-            from,
-            to,
-            toProjectId: toProjectId || undefined,
-            currentFrame: current?.frame || current,
-            note: 'No changes applied. Re-call with dryRun=false (or omit) to perform the move.',
-          }));
-        }
-        return ok(withProject(await api('POST', '/api/fs/mv', { from, to, ...(toProjectId ? { toProjectId } : {}) })));
-      }
-      case 'anchor': {
-        const { path, anchored } = args;
-        if (!path) throw new Error('path required for action=anchor');
-        if (typeof anchored !== 'boolean') throw new Error('anchored (boolean) required for action=anchor');
-        // Cap (G5): anchoring adds the frame's body to the project's required-reading
-        // set — reject if it would push the project past the per-project budget.
-        if (anchored === true) {
-          const used = await getProjectPrimingSize(getState().projectId);
-          const addSize = await getFrameContentSize(path);
-          if (wouldExceedBudget(used, addSize)) return err(new Error(budgetError(used, addSize, 'this anchored frame')));
-        }
-        return ok(withProject(await api('POST', '/api/fs/anchor', { path, anchored })));
-      }
-
-      case 'versions': {
-        const { path } = args;
-        if (!path) throw new Error('path required for action=versions');
-        const result = await api('GET', `/api/fs/versions?path=${encodeURIComponent(path)}`);
-        return ok(withProject(result));
-      }
-      case 'read_version': {
-        const { versionId } = args;
-        if (!versionId) throw new Error('versionId required for action=read_version');
-        const result = await api('GET', `/api/fs/versions/${versionId}`);
-        return ok(withProject(result));
-      }
-      case 'restore_version': {
-        const { versionId, reason } = args;
-        if (!versionId) throw new Error('versionId required for action=restore_version');
-        const result = await api('POST', '/api/fs/restore-version', { versionId, reason });
-        return ok(withProject(result));
-      }
-      case 'search': {
-        const { query, projectId, limit = 50 } = args;
-        if (!query) throw new Error('query required for action=search');
-        const params = new URLSearchParams({ q: query });
-        // projectId may be a slug/name (the shared override param) — the tool() seam has
-        // already resolved it into state, so take the resolved UUID from there.
-        if (projectId) params.set('projectId', getState().projectId || projectId);
-        await ensureSession();
-        const url = `${getServerUrl()}/api/search?${params.toString()}`;
-        const res = await fetch(url, { headers: getAuthHeaders() });
-        if (!res.ok) throw new Error(`Search failed: ${res.status}`);
-        const results = await res.json();
-        const cap = Math.min(Math.max(1, limit || 50), 200);
-        const slice = results.slice(0, cap);
-        return ok({
-          results: slice.map(r => ({
-            id: r.id,
-            path: `/${r.layer}/${r.lane}/${r.label}`,
-            project: r.projectName,
-            projectId: r.projectId,
-            frameUrl: semanticFrameUrl(r) || `${getServerUrl()}/f/${r.id}`,
-            contentType: r.contentType,
-            updatedAt: r.updatedAt,
-          })),
-          totalAvailable: results.length,
-          truncated: results.length > cap,
-        });
-      }
-      default:
-        throw new Error(`Unknown frame action: ${action}`);
-    }
-  } catch (error) { return err(error); }
-});
-
-tool('ls', 'List contents of the ACTIVE PROJECT. Use ls / after project(action="open") to see layers, workflow, and confirm you\'re in the right project.', {
-  projectId: PROJECT_OVERRIDE_PARAM,
-  path: z.string().optional().default('/').describe('Directory path: / (layers), /{layer} (lanes), /{layer}/{lane} (frames). Frame entries include frameUrl (canvas deep link) and id (frame UUID); layer entries include layerUrl and lane entries laneUrl — relay those to the user instead of the project URL when your work was scoped to one layer or lane.'),
-  recursive: z.boolean().optional().describe('List contents of subdirectories. When true, forces summary mode (metadata only, no full content) to keep results under the 25k token cap.'),
-  summary: z.boolean().optional().describe('Include size, updatedAt, title for frames'),
-  pattern: z.string().optional().describe('Glob pattern to filter filenames (e.g. "*.html")'),
-  head: z.number().optional().describe('Include the first N lines of EACH frame inline (max 50). Survey a whole lane in one call instead of one frame(action="read") per frame — read only the frames the heads show you actually need.'),
-  limit: z.number().optional().default(500).describe('Max entries to return (default 500, max 2000). Use pattern or path to scope further.'),
-}, async ({ path, recursive, summary, pattern, head, limit }) => {
-  try {
-    const params = new URLSearchParams();
-    params.set('path', path);
-    // At layer depth (/designs, /wireframes, etc.) auto-recurse so frames in sublanes
-    // are always visible — without this, agents only see root frames and miss any frame
-    // whose lane != "". Recursive walks force summary mode to keep payloads small.
-    const cleanPath = (path || '/').replace(/^\/+|\/+$/g, '');
-    const pathDepth = cleanPath ? cleanPath.split('/').length : 0;
-    if (recursive || pathDepth === 1) {
-      params.set('recursive', 'true');
-      params.set('summary', 'true');
-    } else if (summary) {
-      params.set('summary', 'true');
-    }
-    if (head) params.set('head', String(head));
-    if (pattern) params.set('pattern', pattern);
-    const result = await api('GET', `/api/fs/?${params.toString()}`);
-
-    // Cap entries client-side as a safety net
-    const cap = Math.min(Math.max(1, limit || 500), 2000);
-    if (Array.isArray(result?.entries) && result.entries.length > cap) {
-      result.totalAvailable = result.entries.length;
-      result.truncated = true;
-      result.entries = result.entries.slice(0, cap);
-    }
-
-    // ChatGPT Apps SDK: canvas-overview widget renders byLayer.
-    // /api/fs/ entries are { path, type: 'layer'|'lane'|'frame', id, title, size,
-    // updatedAt, color, frameUrl } — there are no layer/lane/name/label fields, so
-    // derive them from the path. Skip non-frame entries (lanes/layers are structural
-    // and would otherwise serialize as empty objects under "unsorted").
-    const entries = Array.isArray(result?.entries) ? result.entries : [];
-    const byLayer = {};
-    for (const e of entries) {
-      if (e.type && e.type !== 'frame') continue;
-      const segs = String(e.path || '').replace(/^\/+/, '').split('/').filter(Boolean);
-      if (!segs.length) continue;
-      const layer = segs[0];
-      const filename = segs[segs.length - 1];
-      const lane = segs.length >= 3 ? segs.slice(1, -1).join('/') : undefined;
-      (byLayer[layer] ??= []).push({
-        label: e.title || filename,
-        filename,
-        title: e.title,
-        layer,
-        lane,
-        id: e.id,
-        frameUrl: e.frameUrl || (e.id ? `${getServerUrl()}/f/${e.id}` : undefined),
-      });
-    }
-    const projectId = getState().projectId;
-    const structuredContent = {
-      project: result?.project || result?.projectName,
-      canvasUrl: result?.project?.slug
-        ? (result.project.orgSlug
-            ? `${getServerUrl()}/o/${encodeURIComponent(result.project.orgSlug)}/${encodeURIComponent(result.project.slug)}`
-            : `${getServerUrl()}/project/${encodeURIComponent(result.project.slug)}`)
-        : undefined,
-      byLayer,
-      truncated: result?.truncated || false,
-      totalAvailable: result?.totalAvailable,
-    };
-    return ok(result, { structuredContent });
-  } catch (error) { return err(error); }
-});
-
-tool('rm', 'Delete a frame or lane. Defaults to the ACTIVE PROJECT; pass projectId to delete in another project, or frameId to delete a frame by UUID from anywhere (no project binding needed — the frame\'s own org/project is authoritative). Response includes "project" so you see where the deletion landed.', {
-  projectId: PROJECT_OVERRIDE_PARAM,
-  path: z.string().optional().describe('Path to delete: /{layer}/{lane}/{filename} or /{layer}/{lane} (deletes entire lane). Mutually exclusive with frameId.'),
-  frameId: z.string().optional().describe('Frame UUID to delete, resolved independently of the active project — the one-call cleanup for a frame that landed in the wrong place. Mutually exclusive with path.'),
-}, async ({ path, frameId }) => {
-  try {
-    if (frameId && path) throw new Error('Pass either path or frameId, not both.');
-    if (!frameId && !path) throw new Error('rm needs a path or a frameId.');
-    // A frame UUID self-derives its org and project server-side, so this works from an
-    // unbound session and across projects — no open/re-open dance to remove a stray frame.
-    if (frameId) return ok(await api('DELETE', `/api/designs/${encodeURIComponent(frameId)}`));
-    const clean = path.replace(/^\/+|\/+$/g, '');
-    const result = await api('DELETE', `/api/fs/${clean}`);
-    return ok({ ...result, project: getCurrentProjectContext() });
-  } catch (error) { return err(error); }
-});
-
-// batch tool temporarily disabled — keep code intact for re-enablement later.
-/*
-tool('batch', 'Batch operations on the ACTIVE PROJECT. Response includes "project" field. Use project(action="open") first if needed.', {
-  operations: z.array(z.object({
-    tool: z.enum(['write', 'rm', 'mv', 'edit', 'upload_asset']).describe('Tool to execute'),
-    path: z.string().optional().describe('Path (for write, rm, edit)'),
-    content: z.string().optional().describe(`Content (for write).${isRemote ? '' : ' Mutually exclusive with file_path.'}`),
-    // file_path is local-only — omitted on remote transports (web MCP).
-    ...(isRemote ? {} : { file_path: z.string().optional().describe('Absolute path to a local file to upload (for write, upload_asset). Mutually exclusive with content.') }),
-    color: z.string().optional().describe('CSS color for frame border (for write)'),
-    from: z.string().optional().describe('Source path (for mv)'),
-    to: z.string().optional().describe('Destination path (for mv)'),
-    operations: z.array(z.object({
-      type: z.enum(['replace', 'delete', 'insertAfter', 'insertBefore']),
-      lineHash: z.string().describe('The full line anchor from read output — line number + 3-char hash, e.g. "182vix". NOT the bare hash.'),
-      newContent: z.string().optional(),
-    })).optional().describe('Edit operations (for edit). lineHash is the full anchor (lineNum + hash), e.g. "182vix".'),
-    asset_path: z.string().optional().describe('Relative asset path (for upload_asset, e.g., "css/styles.css")'),
-    content_type: z.string().optional().describe('MIME type (for upload_asset, auto-detected if omitted)'),
-    frame_id: z.string().optional().describe('Frame ID to associate asset with (for upload_asset)'),
-  })).describe('ALWAYS use batch instead of multiple individual tool calls. Applies the same change to many files, writes multiple frames, or combines writes+edits+deletes. One canvas refresh instead of many. Example: editing 5 wireframes to remove a section = one batch with 5 edit operations.'),
-}, async ({ operations }) => {
-  try {
-    // Collect all layers involved in the batch
-    const layers = new Set();
-    for (const op of operations) {
-      if (op.path) layers.add(parseLayer(op.path));
-      if (op.from) layers.add(parseLayer(op.from));
-      if (op.to) layers.add(parseLayer(op.to));
-    }
-    for (const layer of layers) {
-    }
-
-    // Resolve file_path → base64 for write operations before sending to server
-    // Separate asset uploads from frame operations
-    const assetOps = operations.filter(op => op.tool === 'upload_asset');
-    const frameOps = operations.filter(op => op.tool !== 'upload_asset');
-
-    const results = [];
-
-    // Handle asset uploads via the asset API
-    for (const op of assetOps) {
-      try {
-        if (!op.asset_path) throw new Error('asset_path is required for upload_asset');
-        if (op.asset_path.includes('..')) throw new Error('asset_path must not contain ".."');
-
-        let b64, ct;
-        if (op.file_path) {
-          const resolved = resolve(op.file_path);
-          if (!existsSync(resolved)) throw new Error(`File not found: ${resolved}`);
-          const buffer = readFileSync(resolved);
-          b64 = buffer.toString('base64');
-          ct = op.content_type || mimeFromExt(extname(resolved));
-        } else if (op.content != null) {
-          b64 = Buffer.from(op.content).toString('base64');
-          ct = op.content_type || mimeFromExt(extname(op.asset_path));
-        } else {
-          throw new Error('upload_asset requires file_path or content');
-        }
-
-        const body = { base64: b64, contentType: ct };
-        if (op.frame_id) body.frameId = op.frame_id;
-
-        const projectId = getState().projectId;
-        if (!projectId) throw new Error('No active project. Call project(action="open") first.');
-        const r = await api('PUT', `/api/projects/${projectId}/assets/${op.asset_path}`, body);
-        results.push({ ok: true, tool: 'upload_asset', asset_path: op.asset_path, ...r });
-      } catch (e) {
-        results.push({ ok: false, tool: 'upload_asset', asset_path: op.asset_path, error: e.message });
-      }
-    }
-
-    // Handle frame operations via the batch API
-    if (frameOps.length > 0) {
-      const TEXT_EXTS = ['.html', '.htm', '.md', '.markdown', '.txt', '.css', '.js', '.mjs', '.json', '.xml', '.excalidraw'];
-      const resolvedOps = frameOps.map(op => {
-        if (op.tool === 'write' && op.file_path) {
-          const resolved = resolve(op.file_path);
-          if (!existsSync(resolved)) throw new Error(`File not found: ${resolved}`);
-          const ext = extname(resolved).toLowerCase();
-          const { file_path: _, ...rest } = op;
-          if (TEXT_EXTS.includes(ext)) {
-            return { ...rest, content: readFileSync(resolved, 'utf8') };
-          }
-          const buffer = readFileSync(resolved);
-          const MIME = { '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.gif': 'image/gif', '.webp': 'image/webp', '.svg': 'image/svg+xml', '.pdf': 'application/pdf' };
-          return { ...rest, base64: buffer.toString('base64'), contentType: MIME[ext] || 'application/octet-stream' };
-        }
-        return op;
-      });
-
-      const batchResult = await api('POST', '/api/fs/batch', { operations: resolvedOps });
-      if (batchResult.results) {
-        for (const r of batchResult.results) {
-          results.push(withFrameBreadcrumb(r));
-        }
-      }
-    }
-
-    return ok({ ok: true, results });
-  } catch (error) { return err(error); }
-});
-*/
-
-// ── Asset tools ──────────────────────────────────────────────────
-
-tool('asset', 'Manage supporting files (CSS, JS, images, fonts) in the ACTIVE PROJECT. Assets are referenced by frames via relative paths — e.g., if your HTML has <link href="css/styles.css">, upload with asset_path="css/styles.css". Assets are NOT frames — they don\'t appear on the canvas. `action=upload` to add/replace, `action=list` to browse, `action=rm` to delete.', {
-  projectId: PROJECT_OVERRIDE_PARAM,
-  action: z.enum(['upload', 'list', 'rm']).describe('Operation to perform.'),
-  asset_path: z.string().optional().describe('[upload] relative asset path (e.g. "css/styles.css"). Must match the path used in HTML references.'),
-  file_path: z.string().optional().describe('[upload] absolute path to a local file. Mutually exclusive with content/base64.'),
-  content: z.string().optional().describe('[upload] text content (for CSS/JS). Mutually exclusive with file_path/base64.'),
-  base64: z.string().optional().describe('[upload] base64-encoded binary content. Mutually exclusive with file_path/content.'),
-  content_type: z.string().optional().describe('[upload] MIME type (auto-detected from extension if omitted).'),
-  frame_id: z.string().optional().describe('[upload|list] associate with / filter by a specific frame. Get frame IDs from frame(action="write") or ls.'),
-}, async (args) => {
-  try {
-    const { action } = args;
-    const projectId = getState().projectId;
-    if (!projectId) throw new Error('No active project. Call project(action="open") first.');
-    if (action === 'upload') {
-      const { asset_path, file_path, content, base64: rawBase64, content_type, frame_id } = args;
-      if (!asset_path) throw new Error('asset_path is required for action=upload');
-      if (asset_path.includes('..')) throw new Error('asset_path must not contain ".."');
-      let b64, ct;
-      if (file_path) {
-        const resolved = resolve(file_path);
-        if (!existsSync(resolved)) throw new Error(`File not found: ${resolved}`);
-        const buffer = readFileSync(resolved);
-        b64 = buffer.toString('base64');
-        ct = content_type || mimeFromExt(extname(resolved));
-      } else if (content != null) {
-        b64 = Buffer.from(content).toString('base64');
-        ct = content_type || mimeFromExt(extname(asset_path));
-      } else if (rawBase64) {
-        b64 = rawBase64;
-        ct = content_type || mimeFromExt(extname(asset_path));
-      } else {
-        throw new Error('Provide file_path, content, or base64');
-      }
-      const body = { base64: b64, contentType: ct };
-      if (frame_id) body.frameId = frame_id;
-      return ok(await api('PUT', `/api/projects/${projectId}/assets/${asset_path}`, body));
-    }
-    if (action === 'list') {
-      const { frame_id } = args;
-      const query = frame_id ? `?frameId=${frame_id}` : '';
-      return ok(await api('GET', `/api/projects/${projectId}/assets${query}`));
-    }
-    if (action === 'rm') {
-      const { asset_path } = args;
-      if (!asset_path) throw new Error('asset_path is required for action=rm');
-      if (asset_path.includes('..')) throw new Error('asset_path must not contain ".."');
-      return ok(await api('DELETE', `/api/projects/${projectId}/assets/${asset_path}`));
-    }
-    throw new Error(`Unknown asset action: ${action}`);
-  } catch (error) { return err(error); }
-});
-
-// ── Connector tools ───────────────────────────────────────────────
-
-tool('connector', 'Create or remove connectors (arrows) between frames on the surface. `action=connect` adds an arrow from source to target. `action=disconnect` removes one — pass either connectorId directly or source+target to find and delete.', {
-  projectId: PROJECT_OVERRIDE_PARAM,
-  action: z.enum(['connect', 'disconnect']).describe('Operation to perform.'),
-  source: z.string().optional().describe('[connect|disconnect] source frame path or ID'),
-  target: z.string().optional().describe('[connect|disconnect] target frame path or ID'),
-  label: z.string().optional().describe('[connect] connector label text'),
-  type: z.string().optional().describe('[connect] connector type (default: arrow-forward)'),
-  color: z.string().optional().describe('[connect] connector color (CSS color string)'),
-  connectorId: z.string().optional().describe('[disconnect] connector ID to delete directly'),
-}, async (args) => {
-  try {
-    const { action } = args;
-    if (action === 'connect') {
-      const { source, target, label, type = 'arrow-forward', color } = args;
-      if (!source || !target) throw new Error('source and target required for action=connect');
-      const body = { source, target };
-      if (label) body.label = label;
-      if (type) body.type = type;
-      if (color) body.color = color;
-      return ok(await api('POST', '/api/connectors', body));
-    }
-    if (action === 'disconnect') {
-      const { source, target, connectorId } = args;
-      if (connectorId) {
-        return ok(await api('DELETE', `/api/connectors/${connectorId}`));
-      }
-      if (source && target) {
-        const sourceFrame = await api('GET', `/api/fs/${source.replace(/^\/+/, '')}`);
-        const targetFrame = await api('GET', `/api/fs/${target.replace(/^\/+/, '')}`);
-        const sourceId = sourceFrame.id;
-        const targetId = targetFrame.id;
-        if (!sourceId || !targetId) throw new Error('Could not resolve source or target frame');
-        const connectors = await api('GET', '/api/connectors');
-        const match = (connectors.connectors || connectors || []).find(
-          c => c.sourceDesignId === sourceId && c.targetDesignId === targetId
-        );
-        if (!match) throw new Error(`No connector found from ${source} to ${target}`);
-        return ok(await api('DELETE', `/api/connectors/${match.id}`));
-      }
-      throw new Error('Provide either connectorId, or both source and target');
-    }
-    throw new Error(`Unknown connector action: ${action}`);
-  } catch (error) { return err(error); }
-});
-
-// ── Layout tools ──────────────────────────────────────────────────
-
-tool('layout', 'Auto-arrange frames using graph layout algorithm. Positions connected frames as a directed graph.', {
-  projectId: PROJECT_OVERRIDE_PARAM,
-  direction: z.enum(['TB', 'LR', 'BT', 'RL']).optional().default('TB').describe('Layout direction: TB (top-bottom), LR (left-right), BT (bottom-top), RL (right-left)'),
-}, async ({ direction }) => {
-  try {
-    const body = { direction };
-    const result = await api('POST', '/api/layout', body);
-    return ok(result);
-  } catch (error) { return err(error); }
-});
-
-// ── Skill library tool ───────────────────────────────────────────
-
-// Walk a local source tree for `skill action=push` with dir, pre-filtering heavy
-// dirs + any .skillignore as a convenience so we don't ship a node_modules tree
-// over the wire. The SERVER re-runs the authoritative hygiene pipeline. Mirrors the
-// CLI's collectSkillTree.
-function collectSkillTreeForPush(dir) {
-  const root = resolve(dir);
-  if (!existsSync(root) || !statSync(root).isDirectory()) throw new Error(`not a directory: ${dir}`);
-  const SKIP = new Set(['node_modules', '.git', '.venv', 'venv', '__pycache__', 'dist', 'build', '.next', 'target', 'coverage', '.cache', '.turbo', '.gradle', 'Pods', '.terraform', '.skillinstall']);
-  const NUL = String.fromCharCode(0);
-  let ignore = () => false;
-  const ign = join(root, '.skillignore');
-  if (existsSync(ign)) {
-    const pats = readFileSync(ign, 'utf8').split(/\r?\n/).map((l) => l.trim()).filter((l) => l && !l.startsWith('#'));
-    ignore = (rel) => pats.some((p) => { const d = p.replace(/\/$/, ''); return rel === d || rel.startsWith(d + '/') || rel.split('/').pop() === d; });
-  }
-  const out = [];
-  const walk = (abs, rel) => {
-    for (const name of readdirSync(abs)) {
-      const childAbs = join(abs, name);
-      const childRel = rel ? `${rel}/${name}` : name;
-      const st = statSync(childAbs);
-      if (st.isDirectory()) { if (SKIP.has(name) || ignore(childRel)) continue; walk(childAbs, childRel); }
-      else if (st.isFile()) {
-        if (ignore(childRel)) continue;
-        const content = readFileSync(childAbs, 'utf8');
-        if (content.includes(NUL)) continue; // skip binary; server rejects it anyway
-        out.push({ path: childRel, content });
-      }
-    }
-  };
-  walk(root, '');
-  return out;
-}
-
-// Ensure a pushed source tree's .gitignore excludes the rebuildable bundle dir, so
-// a skill's machine-specific build output (built into .skillinstall/ by its `setup:`
-// recipe) can never be committed. The server also strips .skillinstall/ from the
-// bundle (skill-ingest DENY_DIRS); this keeps the author's git clean. Idempotent.
-function ensureSkillInstallIgnored(dir) {
-  try {
-    const gi = join(dir, '.gitignore');
-    const existing = existsSync(gi) ? readFileSync(gi, 'utf8') : '';
-    if (existing.split(/\r?\n/).some((l) => l.trim().replace(/\/$/, '') === '.skillinstall')) return false;
-    const body = existing && !existing.endsWith('\n') ? existing + '\n' : existing;
-    writeFileSync(gi, body + '.skillinstall/\n');
-    return true;
-  } catch { return false; }
-}
-
-tool('skill', 'Manage the Drafted skill library. Skills are reusable prompts/guidelines agents can load and follow. When you build a reusable skill, author it HERE — add for prose, push to ingest a local source tree — so its method and setup: recipe live in Drafted and any machine or agent can reuse it; keep only machine-specific build output local in .skillinstall/ (always stripped on push). Dispatch by `action`: search/load/list for discovery; history for a skill\'s version git-log; add/update/remove for org skills; fork/push for source-only skills; attach/detach for project binding; favorite/unfavorite for personal pins; read_file/update_file for supporting files inside a skill directory; export/import to exchange the library as an OKF v0.1 bundle (skills/<slug>/SKILL.md layout).', {
-  action: z.enum([
-    'search', 'load', 'list', 'history',
-    'add', 'update', 'remove',
-    'fork', 'push',
-    'attach', 'detach',
-    'favorite', 'unfavorite',
-    'read_file', 'update_file',
-    'export', 'import',
-  ]).describe('Operation to perform. export: the skill library as an OKF v0.1 bundle (local dir on stdio, download URL on remote, or format="files" for paged inline files). import: ingest the SKILL.md-shaped concepts of an OKF bundle as org skills (files[] or local dir; dryRun supported).'),
-  query: z.string().optional().describe('[search] term to match against name/description/content'),
-  tags: z.array(z.string()).optional().describe('[search] filter by tags; [add|update] tag list'),
-  scope: z.enum(['all', 'org', 'global']).optional().describe('[search|list] library scope (default: all for search; when provided to list, lists the library instead of project/org attachments)'),
-  limit: z.number().optional().describe('[search|list] max results per page (default 25, max 100); [export] files per page for format="files" (default 100, max 500)'),
-  compact: z.boolean().optional().describe('[search|list] return only {slug,name,tags} per skill instead of full summaries — for browsing large catalogs within token budget; [export] with format="files": file paths only (no content)'),
-  skill: z.string().optional().describe('[load|history] skill ID (UUID) or slug'),
-  version: z.number().optional().describe('[history] fetch this version number\'s full snapshot (content included); omit for the reverse-chron version list'),
-  skillId: z.string().optional().describe('[update|remove|attach|detach|favorite|unfavorite|read_file|update_file] skill ID'),
-  projectId: z.string().optional().describe('[list] project to list skills for (defaults to active project; falls back to org-attached skills if no project)'),
-  name: z.string().optional().describe('[add|update] skill name'),
-  description: z.string().optional().describe('[add|update] one-line description'),
-  content: z.string().optional().describe('[add|update] root SKILL.md content; [update_file] file content'),
-  triggerPatterns: z.array(z.string()).optional().describe('[add|update] patterns that suggest this skill'),
-  path: z.string().optional().describe('[read_file|update_file] relative path inside skill directory (e.g. "examples/react.md")'),
-  offset: z.number().optional().describe('[search|list|export] skip N results for pagination; [read_file] start reading at this byte offset (default 0) — for large files (e.g. a >90KB app-frame bundle) read in chunks using the returned nextOffset until truncated=false'),
-  maxBytes: z.number().optional().describe('[read_file] return at most this many bytes from offset (default: whole remaining file). Response reports totalSize/offset/truncated/nextOffset.'),
-  org: z.string().optional().describe('[add] org (id or name) the skill is born in — defaults to the open project\'s org; [list|search|load] scope to this org; [fork|push|update|export|import] resolve/fork into this org. Per-request only — nothing is switched. NO PROJECT IS NEEDED: for project-less skill work either pass org= here, or bind the session once with get_org(action="use", org="<name>"). A multi-org caller that addresses neither is refused rather than guessed.'),
-  setup: z.array(z.string()).optional().describe('[add|update] setup command(s) (in order) run on materialize to build a source-only skill, e.g. ["npm ci","npm run build"]'),
-  files: z.array(z.object({ path: z.string(), content: z.string() })).optional().describe('[push] source files to push (path + UTF-8 content); server strips artifacts + enforces caps. [import] OKF bundle files inline — skills/<slug>/SKILL.md dirs and Skill/Playbook/SOP/Procedure-typed .md with name + description frontmatter become org skills. Caps: 500 files, 512KB/file, 5MB total.'),
-  dir: z.string().optional().describe('[push|export|import] local directory. push: source tree to push instead of files[]; walked locally (heavy dirs, .skillinstall/, and .skillignore pre-filtered), server re-enforces; the dir\'s .gitignore is auto-updated to exclude .skillinstall/ (the rebuildable bundle). export: write the OKF bundle files here (default ./okf-skills-<org>). import: read the bundle from here (alternative to files[]).'),
-  deleteMissing: z.boolean().optional().describe('[push] remove stored files not present in the pushed set'),
-  format: z.string().optional().describe('[export] "files" returns {files:[{path,content}]} paginated via limit/offset (compact=true for paths only) instead of writing a local dir (stdio) or returning a download URL (remote).'),
-  includeGlobal: z.boolean().optional().describe('[export] include global built-in skills in the bundle (default: org skills only)'),
-  dryRun: z.boolean().optional().describe('[import] report {created, updated, skips, warnings} without writing'),
-}, async (args) => {
-  try {
-    const { action } = args;
-    // Org-creating/editing skill actions on the project-less surface must have a
-    // bound org (or explicit org=) when the user is multi-org. (DRAFT-36 Phase 4.)
-    // UUID-first exception: update/remove addressed by a skillId derive their org
-    // from the skill row server-side, so the bound-org gate is unnecessary.
-    // `fork` (and the fork-on-403 branch inside `update`) run the same guard at
-    // fork time, inside their cases — a fork is a create, governed by the one rule.
-    if (['add', 'update', 'remove', 'push', 'import'].includes(action)) {
-      const byId = (action === 'update' || action === 'remove') && /^[a-f0-9-]{36}$/.test(args.skillId || '');
-      if (!byId) await requireBoundOrgForProjectlessMutation(args.org);
-    }
-    switch (action) {
-      case 'search': {
-        const { query, tags, scope = 'all', limit, offset, compact, org } = args;
-        const params = new URLSearchParams();
-        if (query) params.set('q', query);
-        if (tags?.length) params.set('tags', tags.join(','));
-        if (scope) params.set('scope', scope);
-        const qs = params.toString();
-        const endpoint = query ? '/api/skills/search' : '/api/skills';
-        const result = await api('GET', `${endpoint}${qs ? '?' + qs : ''}`, undefined, org ? { 'X-Drafted-Org': org } : {});
-        markSearched(getSessionState().gates, 'skill');
-        return ok(shapeSkillCatalog(result, { limit, offset, compact }));
-      }
-      case 'load': {
-        const { skill } = args;
-        if (!skill) throw new Error('skill (ID or slug) is required for action=load');
-        const isUuid = /^[a-f0-9-]{36}$/.test(skill);
-        const endpoint = isUuid ? `/api/skills/${skill}` : `/api/skills/slug/${skill}`;
-        const result = await api('GET', endpoint, undefined, args.org ? { 'X-Drafted-Org': args.org } : {});
-        if (result?.id) getSessionState().loadedSkillIds.add(result.id);
-        return ok(result);
-      }
-      case 'history': {
-        // Skill version git-log. Omit `version` for the list; pass it for a
-        // single version's full snapshot (content for view/diff).
-        const { skillId, skill: slugArg, version, org } = args;
-        const extra = org ? { 'X-Drafted-Org': org } : {};
-        let id = skillId;
-        if (!id && slugArg) { const s = await api('GET', `/api/skills/slug/${slugArg}`, undefined, extra); id = s.id; }
-        if (!id) throw new Error('skillId or skill (slug) required for action=history');
-        if (version != null) return ok(await api('GET', `/api/skills/${id}/versions/${version}`, undefined, extra));
-        return ok(await api('GET', `/api/skills/${id}/versions`, undefined, extra));
-      }
-      case 'list': {
-        if (args.scope || args.tags?.length || args.org) {
-          const params = new URLSearchParams();
-          params.set('scope', args.scope || (args.org ? 'org' : 'all'));
-          if (args.tags?.length) params.set('tags', args.tags.join(','));
-          const result = await api('GET', `/api/skills?${params.toString()}`, undefined, args.org ? { 'X-Drafted-Org': args.org } : {});
-          return ok(shapeSkillCatalog(result, { limit: args.limit, offset: args.offset, compact: args.compact }));
-        }
-
-        // Prefer the explicit projectId param; otherwise the active project;
-        // otherwise fall back to org-attached skills so list works in
-        // empty-org / wiki-only sessions where there's no project to bind to.
-        const explicit = args.projectId;
-        const active = getState().projectId;
-        const pid = explicit || active;
-        if (pid) {
-          try {
-            return ok(await api('GET', `/api/projects/${pid}/skills`));
-          } catch (e) {
-            // 404 / "not found" means the project isn't visible in the
-            // session's org (typical after binding to a project in another org). Fall through to
-            // org-attached skills rather than bubbling a useless error.
-            if (!/not found/i.test(e.message)) throw e;
-          }
-        }
-        const orgId = await getCurrentOrgId();
-        if (!orgId) throw new Error('No org context. Open a project (project(action="open")), pass projectId, or pass org=.');
-        return ok(await api('GET', `/api/orgs/${orgId}/skills`));
-      }
-      case 'add': {
-        const g2 = g2Block(getSessionState().gates);
-        if (g2) return err(new Error(g2));
-        const { name, description, content, tags, triggerPatterns, setup, org } = args;
-        if (!name || !description || !content) throw new Error('name, description, content required for action=add');
-        const body = { name, description, content };
-        if (tags) body.tags = tags;
-        if (triggerPatterns) body.triggerPatterns = triggerPatterns;
-        if (setup !== undefined) body.setup = setup;
-        // org names where the skill is born (UUID-first model: org is explicit at
-        // create) — without this the bound-org guard accepts org= but the write
-        // would land in the session org anyway.
-        const addedSkill = await api('POST', '/api/skills', body, org ? { 'X-Drafted-Org': org } : {});
-        return ok({ ...addedSkill, ...(await orgEcho(addedSkill, org)) });
-      }
-      case 'update': {
-        // Auto-fork-on-update (tool behavior): if the target is read-only (global/
-        // system or another org), the server returns 403 {code:"skill_read_only"};
-        // we fork into the caller's org and write the copy, returning forked:true.
-        // The raw PUT stays strict — this composition lives in the tool, mirroring
-        // the CLI verbatim so consumers treat CLI and MCP identically.
-        const { skillId, skill: slugArg, name, description, content, tags, triggerPatterns, setup, org } = args;
-        const extra = org ? { 'X-Drafted-Org': org } : {};
-        let id = skillId;
-        let slug = slugArg;
-        if (!id && slugArg) { const s = await api('GET', `/api/skills/slug/${slugArg}`, undefined, extra); id = s.id; slug = s.slug; }
-        if (!id) throw new Error('skillId or skill (slug) required for action=update');
-        const body = {};
-        if (name !== undefined) body.name = name;
-        if (description !== undefined) body.description = description;
-        if (content !== undefined) body.content = content;
-        if (tags !== undefined) body.tags = tags;
-        if (triggerPatterns !== undefined) body.triggerPatterns = triggerPatterns;
-        if (setup !== undefined) body.setup = setup;
-        if (Object.keys(body).length === 0) throw new Error('At least one field is required for action=update');
-        try {
-          const r = await api('PUT', `/api/skills/${id}`, body, extra);
-          return ok({ ...r, forked: false, ...(await orgEcho(r, org)) });
-        } catch (e) {
-          if (e.code !== 'skill_read_only') throw e;
-          // Read-only skill → the update becomes a FORK (a create). Its org must be a
-          // real root: explicit org=, the active project, or a single-org user's only
-          // org — else, multi-org with nothing bound, error rather than guess. The
-          // receipt names the resulting org so a surprising fork is visible (Reading A).
-          await requireBoundOrgForProjectlessMutation(org);
-          let forkId;
-          try {
-            forkId = (await api('POST', `/api/skills/${id}/fork`, {}, extra)).id;
-          } catch (fe) {
-            if (fe.status !== 409) throw fe;
-            const ownSlug = (fe.body && fe.body.slug) || (e.body && e.body.slug) || slug;
-            forkId = (await api('GET', `/api/skills/slug/${ownSlug}`, undefined, extra)).id;
-          }
-          const r2 = await api('PUT', `/api/skills/${forkId}`, body, extra);
-          return ok({ ...r2, forked: true, ...(await orgEcho(r2, org)) });
-        }
-      }
-      case 'remove': {
-        const { skillId } = args;
-        if (!skillId) throw new Error('skillId required for action=remove');
-        return ok(await api('DELETE', `/api/skills/${skillId}`));
-      }
-      case 'fork': {
-        // Block-then-fork: copy a readable (global/other-org) skill into the
-        // caller's org so it can be edited. Mirrors `drafted skill fork` verbatim.
-        const { skillId, skill: slugArg, org } = args;
-        const extra = org ? { 'X-Drafted-Org': org } : {};
-        let id = skillId;
-        if (!id && slugArg) { const s = await api('GET', `/api/skills/slug/${slugArg}`, undefined, extra); id = s.id; }
-        if (!id) throw new Error('skillId or skill (slug) required for action=fork');
-        // Forking creates a new skill — same org rule as any create (explicit org=,
-        // active project, or single-org; else refuse to guess). Receipt names the org.
-        await requireBoundOrgForProjectlessMutation(org);
-        try {
-          const forkedSkill = await api('POST', `/api/skills/${id}/fork`, {}, extra);
-          return ok({ ...forkedSkill, ...(await orgEcho(forkedSkill, org)) });
-        } catch (e) {
-          if (e.status === 409) return ok({ status: 'conflict', error: e.message }); // org already owns this slug
-          throw e;
-        }
-      }
-      case 'push': {
-        // Source-tree ingest. Pass files:[{path,content}] (the usual MCP shape) or a
-        // local dir (walked here, server re-enforces the §3 ingest guards). Mirrors
-        // `drafted skill push`.
-        const { skillId, skill: slugArg, files, dir, deleteMissing, org } = args;
-        const extra = org ? { 'X-Drafted-Org': org } : {};
-        let id = skillId;
-        if (!id && slugArg) { const s = await api('GET', `/api/skills/slug/${slugArg}`, undefined, extra); id = s.id; }
-        if (!id) throw new Error('skillId or skill (slug) required for action=push');
-        let fileList = files;
-        if (!fileList && dir) fileList = collectSkillTreeForPush(dir);
-        if (!Array.isArray(fileList) || fileList.length === 0) throw new Error('files[] (non-empty) or dir required for action=push');
-        const pushed = await api('POST', `/api/skills/${id}/files/bulk`, { files: fileList, deleteMissing: !!deleteMissing }, extra);
-        if (dir) { try { if (ensureSkillInstallIgnored(dir)) pushed.gitignored = '.skillinstall/'; } catch { /* best-effort */ } }
-        return ok({ ...pushed, ...(await orgEcho(pushed, org)) });
-      }
-      case 'attach': {
-        const { skillId } = args;
-        if (!skillId) throw new Error('skillId required for action=attach');
-        if (!getState().projectId) throw new Error('No active project. Call project(action="open") first.');
-        // Cap (G4): keep attached skills + anchors within the per-project budget so
-        // the auto-inject set always fits — reject the attach if it would overflow.
-        try {
-          const used = await getProjectPrimingSize(getState().projectId);
-          let addSize = 0;
-          try { const full = await api('GET', `/api/skills/${skillId}`); addSize = (full?.content || '').length; } catch { /* unknown size */ }
-          if (wouldExceedBudget(used, addSize)) return err(new Error(budgetError(used, addSize, 'this skill')));
-        } catch { /* size check is best-effort */ }
-        const result = await api('POST', `/api/projects/${getState().projectId}/skills`, { skillId });
-        return ok(result);
-      }
-      case 'detach': {
-        const { skillId } = args;
-        if (!skillId) throw new Error('skillId required for action=detach');
-        if (!getState().projectId) throw new Error('No active project. Call project(action="open") first.');
-        const result = await api('DELETE', `/api/projects/${getState().projectId}/skills/${skillId}`);
-        return ok(result);
-      }
-      case 'favorite': {
-        const { skillId } = args;
-        if (!skillId) throw new Error('skillId required for action=favorite');
-        return ok(await api('POST', `/api/skills/favorites/${skillId}`));
-      }
-      case 'unfavorite': {
-        const { skillId } = args;
-        if (!skillId) throw new Error('skillId required for action=unfavorite');
-        return ok(await api('DELETE', `/api/skills/favorites/${skillId}`));
-      }
-      case 'read_file': {
-        const { skillId, path, offset, maxBytes } = args;
-        if (!skillId || !path) throw new Error('skillId and path required for action=read_file');
-        const params = new URLSearchParams();
-        if (offset != null) params.set('offset', String(offset));
-        if (maxBytes != null) params.set('maxBytes', String(maxBytes));
-        const qs = params.toString();
-        return ok(await api('GET', `/api/skills/${skillId}/files/${path}${qs ? `?${qs}` : ''}`));
-      }
-      case 'update_file': {
-        const { skillId, path, content } = args;
-        if (!skillId || !path || content == null) throw new Error('skillId, path, content required for action=update_file');
-        return ok(await api('PUT', `/api/skills/${skillId}/files/${path}`, { content }));
-      }
-
-      // ── export ──────────────────────────────────────────────────
-      // The skill library as an OKF v0.1 bundle (skills/<slug>/SKILL.md +
-      // supporting files + synthesized log.md/index.md). Mirrors wiki export:
-      // format="files" pages the bundle inline; otherwise stdio writes a local
-      // dir, remote returns the authenticated tar.gz download URL.
-      case 'export': {
-        const extra = args.org ? { 'X-Drafted-Org': args.org } : {};
-        const inc = args.includeGlobal ? '&includeGlobal=1' : '';
-        if (args.format === 'files') {
-          const qp = new URLSearchParams({ limit: String(Math.min(Math.max(1, args.limit || 100), 500)) });
-          if (args.offset) qp.set('offset', String(args.offset));
-          if (args.compact) qp.set('compact', 'true');
-          return ok(await api('GET', `/api/skills/export?${qp.toString()}${inc}`, undefined, extra));
-        }
-        if (isRemote) {
-          return ok({
-            downloadUrl: `${getServerUrl()}/api/skills/export.tar.gz${args.includeGlobal ? '?includeGlobal=1' : ''}`,
-            note: 'Open the URL in a signed-in browser to download the OKF v0.1 skill bundle, or call export with format="files" to page the bundle contents inline.',
-          });
-        }
-        // stdio: write every bundle file under a local directory.
-        const skOrgCtx = await getCurrentOrgContext();
-        const skOrgSlug = String(skOrgCtx?.name || skOrgCtx?.id || 'org').toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '') || 'org';
-        const exportDir = resolve(args.dir || `./okf-skills-${skOrgSlug}`);
-        let expOffset = 0;
-        let written = 0;
-        for (;;) {
-          const batch = await api('GET', `/api/skills/export?limit=200&offset=${expOffset}${inc}`, undefined, extra);
-          const batchFiles = batch.files || [];
-          for (const f of batchFiles) {
-            const dest = resolve(exportDir, f.path);
-            if (dest !== exportDir && !dest.startsWith(exportDir + '/') && !dest.startsWith(exportDir + '\\')) continue; // traversal guard
-            mkdirSync(dirname(dest), { recursive: true });
-            writeFileSync(dest, f.content, 'utf8');
-            written++;
-          }
-          expOffset += batchFiles.length;
-          if (!batch.truncated || batchFiles.length === 0) break;
-        }
-        return ok({ exported: written, dir: exportDir, note: 'OKF v0.1 skill bundle written (skills/<slug>/SKILL.md layout; index.md and log.md are synthesized).' });
-      }
-
-      // ── import ──────────────────────────────────────────────────
-      // Ingest the SKILL.md-shaped concepts of an OKF bundle as org skills:
-      // inline files[] or (stdio) a local dir walked with the push filters.
-      // Use wiki(action="import") for a mixed knowledge bundle — it routes
-      // skill concepts here and everything else into the wiki.
-      case 'import': {
-        const extra = args.org ? { 'X-Drafted-Org': args.org } : {};
-        let importFiles = args.files;
-        if (!importFiles && args.dir) importFiles = collectSkillTreeForPush(args.dir);
-        if (!Array.isArray(importFiles) || importFiles.length === 0) {
-          throw new Error('import requires files[] (or dir on stdio) with at least one file');
-        }
-        return ok(await api('POST', '/api/skills/import', { files: importFiles, dryRun: !!args.dryRun }, extra));
-      }
-
-      default:
-        throw new Error(`Unknown skill action: ${action}`);
-    }
-  } catch (error) { return err(error); }
-});
-
-// ── Wiki tool (org-scoped, no project needed) ─────────────────────
-// All 11 actions dispatch from one tool. Read-only actions skip the
-// skill gate; mutations require org-level wiki-maintainer skills loaded.
-
-tool('wiki', 'Per-org wiki. Markdown pages with paths as hierarchy. You and other agents/humans share maintenance — every edit broadcasts live, and edits from others appear in `recent` and on `read`.\n\n**Addressing:** a `pageId` (UUID) self-derives its org — no org arg needed. Path-based and listing actions scope to the open project\'s org by default; pass `org=...` to target another org (there is no org switching). `search` spans ALL your orgs by default — don\'t assume "no hits" means the content doesn\'t exist.\n\nBefore mutating: check `recent` and `search` for relevant existing pages. Before mv/rm: check `links` (or pass `dryRun=true`). After completing a logical session of work, append a `log` entry. Reference sources with `cite` (appends a numbered entry to the page\'s `# Citations` section).\n\nThe wiki is an OKF v0.1 bundle (Open Knowledge Format): every page carries frontmatter with a `type` (default "Page"), a one-line `description` is recommended, links may use `/a/b.md` or extensionless `a/b` form, and `index.md` at any level is synthesized — read it for a directory listing, never write it. Exchange whole bundles with `export` (conformant tar.gz / local dir / paged files) and `import` (files[] or local dir, dryRun supported).\n\nThe tool handles bookkeeping you\'d otherwise forget: `mv` rewrites inbound references via the link index, `read` shows who edited last and when. Use `health` to find unlinked pages and broken links.\n\n**Skill gate:** the org may attach a `wiki-maintainer` skill that you MUST load before mutations. If you get a skill-gate error, run skill(action="load", skill="wiki-maintainer") then retry.', {
-  action: z.enum(['ls', 'recent', 'read', 'search', 'links', 'log', 'health', 'write', 'edit', 'mv', 'rm', 'cite', 'source-register', 'source-list', 'source-get', 'bulk-write', 'export', 'import']).describe('Operation to perform. export: the whole wiki as an OKF v0.1 bundle (local dir on stdio, download URL on remote, or format="files" for paged inline files). import: ingest an OKF bundle (files[] or local dir; dryRun supported).'),
-  path: z.string().optional().describe('[ls|read|links|cite] wiki path. For ls: default / (root). For read: required. For links/cite: required unless pageId given. Reading `index.md` (any level) returns the SYNTHESIZED OKF directory listing.'),
-  pageId: z.string().optional().describe('[read|edit|mv|rm|links] page UUID (from read/search). UUID-first: addresses the page directly, org auto-derives — no org needed and no path lookup. Preferred over path for an existing page.'),
-  org: z.string().optional().describe('Org slug or id to scope this call to (per-request only — nothing is switched). NO PROJECT IS NEEDED for wiki work: to write project-less, either pass org= here, or bind the session once with get_org(action="use", org="<name>") and then omit it. Multi-org callers MUST address the org one of those two ways — an unaddressed write is refused rather than guessed (it would land in whichever org the session inherited). [write] the org the page is created in. [search] restrict to this org (default: ALL your orgs). [ls|recent|read|links|log|health|edit|mv|rm|bulk-write] target this org\'s wiki instead of the open project\'s org. Ignored when a pageId is given (the page self-derives its org).'),
-  recursive: z.boolean().optional().describe('[ls] list recursively with depth indicators'),
-  limit: z.number().optional().describe('[recent|search|export] max results (recent default 10, search default 25, export files default 100)'),
-  offset: z.number().optional().describe('[export] pagination offset for format="files"'),
-  compact: z.boolean().optional().describe('[export] with format="files": return file paths only (no content)'),
-  format: z.string().optional().describe('[export] "files" returns {files:[{path,content}]} paginated via limit/offset (compact=true for paths only) instead of writing a local dir (stdio) or returning a download URL (remote).'),
-  files: z.array(z.object({
-    path: z.string().describe('Bundle-relative file path, e.g. "concepts/frames.md"'),
-    content: z.string().describe('File content (markdown, optional YAML frontmatter)'),
-  })).optional().describe('[import] OKF bundle files inline. index.md files are skipped (synthesized), bundle-root log.md merges into the wiki log page. Caps: 500 files, 512KB/file, 5MB total.'),
-  ...(isRemote ? {} : { dir: z.string().optional().describe('[export|import] local directory. export: write the bundle files here (default ./okf-export-<org>). import: recursively read .md files from here (alternative to files[]).') }),
-  query: z.string().optional().describe('[search] term to search in title, path, and content'),
-  lines: z.string().optional().describe('[read] line range (e.g. "1-50"). Omit to read all.'),
-  message: z.string().optional().describe('[log] message to append to the log page (OKF date-grouped format)'),
-  verb: z.string().optional().describe('[log] leading bold verb for the entry: Update (default), Creation, Deprecation, or Initialization.'),
-  title: z.string().optional().describe('[write] page title (required for write)'),
-  content: z.string().optional().describe('[write|edit] page content (write: full content; edit: hashline content not used — use operations)'),
-  type: z.string().optional().describe('[write] OKF concept type — free-form string, e.g. "Page", "Reference", "Playbook", "Decision", "Metric". Defaults to "Page" on create; must stay non-empty on update (OKF v0.1 requires a type on every page).'),
-  raw: z.boolean().optional().describe('[read] return content bytes-as-stored (skip the synthesized OKF frontmatter block). Do NOT build edit operations from a raw read — hashline anchors for edit must come from a normal (non-raw) read.'),
-  url: z.string().optional().describe('[cite] citation URL (required for cite)'),
-  label: z.string().optional().describe('[cite] link label for the citation (defaults to the URL)'),
-  frontmatter: z.any().optional().describe('[write] frontmatter object. Recommended OKF keys: a one-line "description" (index listings and consumers read it), "tags" (list), "resource" (canonical URI of the underlying asset). Unknown keys are preserved; never set "timestamp" (synthesized from the last update).'),
-  operations: z.array(z.object({
-    type: z.enum(['replace', 'delete', 'insertAfter', 'insertBefore']).describe('Edit type'),
-    lineHash: z.string().describe('The full line anchor copied verbatim from read output — line number + 3-char hash, e.g. "182vix" (the token left of the "|"). NOT the bare hash.'),
-    newContent: z.string().optional().describe('New content (for replace, insertAfter, insertBefore)'),
-  })).optional().describe('[edit] hashline edit operations — same shape as frame.edit'),
-  from: z.string().optional().describe('[mv] source path'),
-  to: z.string().optional().describe('[mv] destination path'),
-  dryRun: z.boolean().optional().describe('[mv|rm|import] preview impact without applying changes (import: returns the {creates, updates, skips, warnings} report without writing)'),
-  file_path: z.string().optional().describe('[source-register] absolute path to a local file. Server hashes it and registers the source. stdio MCP only.'),
-  contentHash: z.string().optional().describe('[source-register|source-list|cite] hex-encoded SHA-256 (64 chars). Use when the client already hashed the bytes (HTTP MCP). For cite: also registers the cited source.'),
-  filename: z.string().optional().describe('[source-register|cite] original filename for the source (informational)'),
-  contentType: z.string().optional().describe('[source-register] MIME type (informational)'),
-  size: z.number().optional().describe('[source-register] byte size (informational)'),
-  sourceId: z.string().optional().describe('[source-get] source ID returned from source-register'),
-  manifest_path: z.string().optional().describe('[bulk-write] absolute path to a JSON file containing {pages: [{path, title, content, type?, frontmatter?}, ...]}. The MCP wrapper reads the file locally and posts the array to the server in a single request — avoids round-tripping every page through tool args.'),
-  pages: z.array(z.any()).optional().describe('[bulk-write] alternative to manifest_path: pass the pages array inline.'),
-}, async (args) => {
-  try {
-    const { action } = args;
-
-    // UUID-first: a `pageId` (edit/mv/rm) or an explicit `org` (write) makes the
-    // target org unambiguous, so the bound-org gate is unnecessary — skip it.
-    // Otherwise (path-addressed, multi-org, nothing bound) the gate still
-    // refuses to guess the org so a write never silently lands in the wrong one.
-    const orgHeader = args.org ? { 'X-Drafted-Org': args.org } : {};
-    if (['write', 'edit', 'mv', 'rm', 'bulk-write', 'cite', 'import'].includes(action)) {
-      if (!args.pageId) await requireBoundOrgForProjectlessMutation(args.org);
-    }
-
-    // Resolve org context for this CALL. An explicit org= override wins (per
-    // request, nothing is switched); otherwise the session's binding (the open
-    // project's org). Resolving the override here keeps the echoed `org` field
-    // and every emitted browser URL truthful about where the call landed.
-    // Where the write will ACTUALLY land: the working org (explicit switch, else the
-    // bound project's org — the same address api() puts on the wire). getCurrentOrgContext
-    // reports the session's INHERITED org, so echoing it made a correctly-placed write
-    // look misfiled — and an agent trusting that echo would "fix" a page that was fine.
-    const working = workingOrgId();
-    // Cached for 30s, so this is a cache hit on all but the first wiki call in a
-    // session — cheap enough to always have on hand for the receipt below.
-    const orgList = await getOrgList();
-    let orgCtx = working
-      ? (orgList.find(o => o.id === working) || { id: working, name: null })
-      : await getCurrentOrgContext();
-    if (args.org) {
-      const d = await api('GET', '/api/orgs');
-      const list = (d.orgs || d || []).map(o => ({ id: o.orgId || o.id, name: o.orgName || o.name }));
-      const wanted = String(args.org).toLowerCase();
-      const byName = list.filter(o => (o.name || '').toLowerCase() === wanted);
-      const match = list.find(o => o.id === args.org) || (byName.length === 1 ? byName[0] : null);
-      if (match) orgCtx = match;
-    }
-    const orgId = orgCtx?.id || null;
-    // Mutation responses include `org` so the agent always sees where the
-    // write landed — eliminates silent cross-org confusion.
-    //
-    // A UUID-addressed resource (pageId=…) SELF-DERIVES its org server-side, so
-    // for those the write can land in an org this session isn't bound to. Echoing
-    // the session's working org there is the same defect the URL builder had: the
-    // receipt would name one org while `url` pointed at another. Prefer the org
-    // carried on the returned row, and fall back to the session context only when
-    // the response doesn't name one.
-    const withOrg = (result, resourceOrgId) => ({
-      ...result,
-      org: receiptOrg({ resourceOrgId: resourceOrgId || result?.orgId, sessionOrg: orgCtx, orgList }),
-    });
-    // Org-qualify every browser URL this tool emits (shadows the module fn for
-    // all call sites below) so links are portable across the viewer's orgs.
-    // A UUID-addressed page SELF-DERIVES its org server-side, so its URL must be
-    // built from the org on the returned row (`resourceOrg`), not from this session's
-    // working org — otherwise `wiki(action="read", pageId=…)` hands back a link into
-    // whatever org the session happens to be bound to, for a page that lives elsewhere.
-    // Path-addressed calls have no resource org and correctly fall back to `orgId`.
-    const wikiBrowserUrl = (p, resourceOrg) => wikiPageUrl(p, resourceOrg || orgId);
-
-    // ── Skill gate: all mutation actions ──────────────────────────
-    // Ensure the wiki-maintainer skill is attached to this org BEFORE the
-    // gate check, so the gate fires reliably on the very first wiki call —
-    // not just after the org has visited /wiki in a browser. Idempotent.
-    const MUTATING = new Set(['write', 'edit', 'mv', 'rm', 'log', 'cite', 'source-register', 'bulk-write', 'import']);
-    if (MUTATING.has(action)) {
-      try { await api('POST', '/api/wiki/_ensure-skill'); } catch { /* non-fatal */ }
-      const skillErr = await checkOrgSkills(orgId, action);
-      if (skillErr) return err(new Error(skillErr));
-    }
-
-    switch (action) {
-
-      // ── ls ──────────────────────────────────────────────────────
-      case 'ls': {
-        const { path: lsPath = '/', recursive: lsRecursive = false } = args;
-        const { pages, pathToPage } = await getTreeAsMap(orgHeader);
-        const parent = normalizeWikiPath(lsPath);
-
-        if (lsRecursive) {
-          // Full tree under path with depth
-          const prefix = parent ? parent + '/' : '';
-          const filtered = !parent ? pages : pages.filter(p => p.path === parent || p.path.startsWith(prefix));
-          const tree = filtered.map(p => ({
-            depth: !parent ? p.path.split('/').length - 1 : p.path.split('/').length - parent.split('/').length - (p.path === parent ? 1 : 0),
-            path: p.path,
-            title: p.title,
-            type: p.type,
-            id: p.id,
-            url: wikiBrowserUrl(p.path),
-          }));
-          return ok({ tree });
-        }
-
-        // Non-recursive: children of parent path
-        if (!parent) {
-          // Root: show top-level directories + root pages
-          const dirs = new Set();
-          const rootPages = [];
-          for (const p of pages) {
-            if (!p.path.includes('/')) { rootPages.push(p); }
-            else { dirs.add(p.path.split('/')[0]); }
-          }
-          return ok({
-            tree: [
-              ...Array.from(dirs).sort().map(d => ({ type: 'directory', name: d, url: wikiBrowserUrl(d) })),
-              ...rootPages.map(p => ({ type: 'page', path: p.path, title: p.title, id: p.id, url: wikiBrowserUrl(p.path) })),
-            ],
-          });
-        }
-
-        // Has parent: show immediate children
-        const children = [];
-        const seenDirs = new Set();
-        const prefix = parent + '/';
-        for (const p of pages) {
-          if (p.path === parent) {
-            children.push({ type: 'page', path: p.path, title: p.title, id: p.id, url: wikiBrowserUrl(p.path) });
-          } else if (p.path.startsWith(prefix)) {
-            const rest = p.path.slice(prefix.length);
-            if (rest.includes('/')) {
-              const sub = rest.split('/')[0];
-              if (!seenDirs.has(sub)) { seenDirs.add(sub); children.push({ type: 'directory', name: parent + '/' + sub, url: wikiBrowserUrl(parent + '/' + sub) }); }
-            } else {
-              children.push({ type: 'page', path: p.path, title: p.title, id: p.id, url: wikiBrowserUrl(p.path) });
-            }
-          }
-        }
-        return ok({ tree: children });
-      }
-
-      // ── recent ──────────────────────────────────────────────────
-      case 'recent': {
-        const { limit: recentLimit = 10 } = args;
-        const tree = await api('GET', '/api/wiki/tree', undefined, orgHeader);
-        const recent = (tree.pages || [])
-          .filter(p => p.updatedAt)
-          .sort((a, b) => new Date(b.updatedAt) - new Date(a.updatedAt))
-          .slice(0, Math.max(1, recentLimit))
-          .map(p => ({ path: p.path, title: p.title, updatedAt: p.updatedAt, url: wikiBrowserUrl(p.path) }));
-        return ok({ pages: recent });
-      }
-
-      // ── read ────────────────────────────────────────────────────
-      // Returns content in hashline format (`LINE+ID|content`) so the
-      // agent can produce hashline edit operations. Mirrors frame.read.
-      case 'read': {
-        const { path: readPath, pageId: readPageId, lines: readLines, raw: readRaw } = args;
-        if (readLines && !/^\d+-\d+$/.test(readLines)) throw new Error(`lines must be "N-M" (e.g. "10-50"), got: ${readLines}`);
-        let page;
-        if (readPageId) {
-          // UUID-first: address the page directly, org auto-derives server-side.
-          const params = new URLSearchParams({ format: 'hashline' });
-          if (readLines) params.set('lines', readLines);
-          if (readRaw) params.set('raw', 'true');
-          page = await api('GET', `/api/wiki/pages/${readPageId}?${params.toString()}`);
-        } else {
-          if (!readPath) throw new Error('path or pageId required for action=read');
-          const normalized = normalizeWikiPath(readPath);
-          const params = new URLSearchParams({ path: normalized, format: 'hashline' });
-          if (readLines) params.set('lines', readLines);
-          if (readRaw) params.set('raw', 'true');
-          page = await api('GET', `/api/wiki/page?${params.toString()}`, undefined, orgHeader);
-        }
-        // Get backlink count via search (approximate)
-        let backlinkCount = 0;
-        try {
-          const searchRes = await api('GET', `/api/wiki/search?q=${encodeURIComponent(page.path)}`, undefined, orgHeader);
-          backlinkCount = (searchRes.hits || []).length;
-        } catch { /* best-effort */ }
-        return ok({
-          id: page.id,
-          path: page.path,
-          title: page.title,
-          type: page.type,
-          frontmatter: page.frontmatter,
-          content: page.content,
-          totalLines: page.totalLines,
-          lastEditedBy: page.updatedBy,
-          lastEditedAt: page.updatedAt,
-          backlinkCount,
-          url: wikiBrowserUrl(page.path, page.orgId),
-        });
-      }
-
-      // ── search ──────────────────────────────────────────────────
-      case 'search': {
-        const { query: searchQuery, limit: searchLimit = 25, org: searchOrg } = args;
-        if (!searchQuery) throw new Error('query required for action=search');
-        // Default: search ALL the caller's orgs (discovery needs no bound org).
-        // An explicit `org` scopes to that one org.
-        const qp = new URLSearchParams({ q: searchQuery, limit: String(searchLimit) });
-        if (!searchOrg) qp.set('scope', 'all');
-        const result = await api('GET', `/api/wiki/search?${qp.toString()}`, undefined, orgHeader);
-        // Surface pageId (re-address by UUID, org-free) + the hit's own org, and
-        // build the URL from the hit's org so cross-org links are correct.
-        const hits = (result.hits || []).map(h => ({
-          id: h.id,
-          path: h.path,
-          title: h.title,
-          org: h.orgName || h.orgSlug || undefined,
-          orgId: h.orgId || undefined,
-          url: wikiPageUrl(h.path, h.orgId || orgId),
-        }));
-        markSearched(getSessionState().gates, 'wiki');
-        return ok({ hits });
-      }
-
-      // ── links ───────────────────────────────────────────────────
-      case 'links': {
-        const { path: linksPath, pageId: linksPageId } = args;
-        let id = linksPageId;
-        if (!id) {
-          if (!linksPath) throw new Error('path or pageId required for action=links');
-          const page = await api('GET', `/api/wiki/page?path=${encodeURIComponent(normalizeWikiPath(linksPath))}`, undefined, orgHeader);
-          id = page.id;
-        }
-        return ok(await api('GET', `/api/wiki/pages/${id}/links`));
-      }
-
-      // ── log ─────────────────────────────────────────────────────
-      // OKF log.md format: newest-first `## YYYY-MM-DD` date headings (UTC),
-      // each with `* **Verb**: message (agent, HH:MM UTC)` bullets. Legacy
-      // `## <ISO datetime> ...` headings on existing log pages are left as-is.
-      case 'log': {
-        const { message: logMessage, verb: logVerb } = args;
-        if (!logMessage) throw new Error('message required for action=log');
-        const agentName = process.env.DRAFTED_AGENT_NAME || 'mcp';
-        const now = new Date();
-        const entry = formatOkfLogEntry(logVerb, logMessage, agentName, now);
-        const logTitle = (orgCtx?.name ? orgCtx.name + ' ' : '') + 'Log';
-
-        // Try to read existing log page (raw: bytes-as-stored, no synthesis)
-        let logPage = null;
-        try {
-          logPage = await api('GET', '/api/wiki/page?path=log&raw=true', undefined, orgHeader);
-        } catch {
-          // Create new log page
-          const created = await api('POST', '/api/wiki/pages', {
-            path: 'log',
-            title: 'Log',
-            type: 'Log',
-            content: appendOkfLogEntry('', entry, now, logTitle),
-          }, orgHeader);
-          return ok(withOrg({ appended: true, created: true, pageId: created.id, path: 'log', url: wikiBrowserUrl('log') }));
-        }
-
-        // Append under today's date heading (created at the top if missing)
-        const updatedContent = appendOkfLogEntry(logPage.content || '', entry, now, logTitle);
-        await api('PATCH', `/api/wiki/pages/${logPage.id}`, { content: updatedContent }, orgHeader);
-        return ok(withOrg({ appended: true, path: 'log', url: wikiBrowserUrl('log') }));
-      }
-
-      // ── cite ────────────────────────────────────────────────────
-      // Append a numbered citation to a page's `# Citations` section
-      // (creating the section if missing), OKF style: `[n] [label](url)`.
-      // Optionally registers a wiki source when contentHash is given.
-      case 'cite': {
-        const { path: citePath, pageId: citePageId, url: citeUrl, label: citeLabel, contentHash: citeHash, filename: citeFilename } = args;
-        if (!citeUrl) throw new Error('url required for action=cite');
-        let page;
-        if (citePageId) {
-          page = await api('GET', `/api/wiki/pages/${citePageId}?raw=true`);
-        } else {
-          if (!citePath) throw new Error('path or pageId required for action=cite');
-          page = await api('GET', `/api/wiki/page?path=${encodeURIComponent(normalizeWikiPath(citePath))}&raw=true`, undefined, orgHeader);
-        }
-        const lines = (page.content || '').split('\n');
-        let maxN = 0;
-        for (const l of lines) {
-          const m = l.match(/^\[(\d+)\]\s/);
-          if (m) maxN = Math.max(maxN, parseInt(m[1], 10));
-        }
-        const n = maxN + 1;
-        const entry = `[${n}] [${citeLabel || citeUrl}](${citeUrl})`;
-        let content;
-        const hIdx = lines.findIndex((l) => /^#{1,3}\s+Citations\s*$/.test(l));
-        if (hIdx < 0) {
-          const base = (page.content || '').replace(/\s+$/, '');
-          content = (base ? base + '\n\n' : '') + '# Citations\n\n' + entry + '\n';
-        } else {
-          let end = hIdx + 1;
-          while (end < lines.length && !/^#{1,6}\s/.test(lines[end])) end++;
-          let insertAt = end;
-          while (insertAt > hIdx + 1 && lines[insertAt - 1].trim() === '') insertAt--;
-          lines.splice(insertAt, 0, entry);
-          content = lines.join('\n');
-        }
-        await api('PATCH', `/api/wiki/pages/${page.id}`, { content });
-        let source = null;
-        if (citeHash) {
-          try {
-            source = await api('POST', '/api/wiki/sources', { contentHash: citeHash, filename: citeFilename }, orgHeader);
-          } catch { /* source registration is best-effort */ }
-        }
-        return ok(withOrg({ cited: true, n, entry, path: page.path, id: page.id, sourceId: source?.id, url: wikiBrowserUrl(page.path, page.orgId) }));
-      }
-
-      // ── health ──────────────────────────────────────────────────
-      case 'health': {
-        return ok(await api('GET', '/api/wiki/health', undefined, orgHeader));
-      }
-
-      // ── export ──────────────────────────────────────────────────
-      // The whole wiki as an OKF v0.1 bundle. format="files" pages the bundle
-      // inline; otherwise stdio writes a local dir, remote returns the
-      // authenticated tar.gz download URL.
-      case 'export': {
-        if (args.format === 'files') {
-          const qp = new URLSearchParams({ limit: String(Math.min(Math.max(1, args.limit || 100), 500)) });
-          if (args.offset) qp.set('offset', String(args.offset));
-          if (args.compact) qp.set('compact', 'true');
-          return ok(withOrg(await api('GET', `/api/wiki/export?${qp.toString()}`, undefined, orgHeader)));
-        }
-        if (isRemote) {
-          return ok(withOrg({
-            downloadUrl: `${getServerUrl()}/api/wiki/export.tar.gz`,
-            note: 'Open the URL in a signed-in browser to download the OKF v0.1 bundle, or call export with format="files" to page the bundle contents inline.',
-          }));
-        }
-        // stdio: write every bundle file under a local directory.
-        const orgSlug = String(orgCtx?.name || orgId || 'org').toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '') || 'org';
-        const exportDir = resolve(args.dir || `./okf-export-${orgSlug}`);
-        let expOffset = 0;
-        let written = 0;
-        for (;;) {
-          const batch = await api('GET', `/api/wiki/export?limit=200&offset=${expOffset}`, undefined, orgHeader);
-          const batchFiles = batch.files || [];
-          for (const f of batchFiles) {
-            const dest = resolve(exportDir, f.path);
-            if (dest !== exportDir && !dest.startsWith(exportDir + '/') && !dest.startsWith(exportDir + '\\')) continue; // traversal guard
-            mkdirSync(dirname(dest), { recursive: true });
-            writeFileSync(dest, f.content, 'utf8');
-            written++;
-          }
-          expOffset += batchFiles.length;
-          if (!batch.truncated || batchFiles.length === 0) break;
-        }
-        return ok(withOrg({ exported: written, dir: exportDir, note: 'OKF v0.1 bundle written. Pages carry synthesized frontmatter; index.md files are synthesized directory listings.' }));
-      }
-
-      // ── import ──────────────────────────────────────────────────
-      // Ingest an OKF bundle: inline files[] or (stdio) a local dir walked
-      // for .md files. index.md skipped, bundle-root log.md merged into the
-      // wiki log page, frontmatter lifted with unknown keys preserved.
-      case 'import': {
-        let importFiles = args.files;
-        if (!importFiles && args.dir) {
-          const root = resolve(args.dir);
-          if (!existsSync(root)) throw new Error(`dir not found: ${args.dir}`);
-          importFiles = [];
-          const walk = (d) => {
-            for (const ent of readdirSync(d, { withFileTypes: true })) {
-              if (ent.name.startsWith('.')) continue;
-              const p = join(d, ent.name);
-              if (ent.isDirectory()) walk(p);
-              else if (/\.md$/i.test(ent.name)) {
-                if (importFiles.length >= 500) throw new Error('import capped at 500 files — split the bundle');
-                importFiles.push({ path: p.slice(root.length + 1).replace(/\\/g, '/'), content: readFileSync(p, 'utf8') });
-              }
-            }
-          };
-          walk(root);
-        }
-        if (!Array.isArray(importFiles) || importFiles.length === 0) {
-          throw new Error('import requires files[] (or dir on stdio) with at least one .md file');
-        }
-        const result = await api('POST', '/api/wiki/import', { files: importFiles, dryRun: !!args.dryRun }, orgHeader);
-        return ok(withOrg(result));
-      }
-
-      // ── write ───────────────────────────────────────────────────
-      case 'write': {
-        const { path: writePath, title: writeTitle, content: writeContent, type: writeType, frontmatter } = args;
-        if (!writePath) throw new Error('path required for action=write');
-        if (!writeTitle) throw new Error('title required for action=write');
-        const normalized = normalizeWikiPath(writePath);
-        const body = { path: normalized, title: writeTitle };
-        if (writeContent !== undefined) body.content = writeContent;
-        if (writeType) body.type = writeType;
-        if (frontmatter !== undefined) body.frontmatter = frontmatter;
-
-        // Writing the reserved log page directly is allowed (it IS an editable
-        // page) but the `log` action keeps the OKF date-grouped format for you.
-        const logNote = normalized === 'log'
-          ? 'Note: prefer wiki(action="log") for log entries — it maintains the OKF date-grouped format (## YYYY-MM-DD headings, newest first).'
-          : undefined;
-
-        // Check if page exists — if so, update; otherwise create. `orgHeader`
-        // (the `org` arg) targets a specific org without switching the active org.
-        try {
-          const existing = await api('GET', `/api/wiki/page?path=${encodeURIComponent(normalized)}`, undefined, orgHeader);
-          const result = await api('PATCH', `/api/wiki/pages/${existing.id}`, body, orgHeader);
-          return ok(withOrg({ path: result.path, title: result.title, id: result.id, updated: true, url: wikiBrowserUrl(result.path, result.orgId), note: logNote }));
-        } catch {
-          const result = await api('POST', '/api/wiki/pages', body, orgHeader);
-          return ok(withOrg({ path: result.path, title: result.title, id: result.id, created: true, url: wikiBrowserUrl(result.path, result.orgId), note: logNote }));
-        }
-      }
-
-      // ── edit ────────────────────────────────────────────────────
-      // Hashlines come from `read` (which now formats content as
-      // `LINE+ID|content`). The server applies the ops via the same
-      // hashline algorithm — no client-side re-hashing, no algorithm drift.
-      case 'edit': {
-        const { path: editPath, pageId: editPageId, operations: editOps } = args;
-        if (!Array.isArray(editOps) || editOps.length === 0) throw new Error('operations (array) required for action=edit');
-        let id = editPageId;
-        if (!id) {
-          if (!editPath) throw new Error('path or pageId required for action=edit');
-          const page = await api('GET', `/api/wiki/page?path=${encodeURIComponent(normalizeWikiPath(editPath))}`, undefined, orgHeader);
-          id = page.id;
-        }
-        const result = await api('POST', `/api/wiki/pages/${id}/edit`, { operations: editOps });
-        return ok(withOrg({ path: result.path, id: result.id, updated: true, applied: result.applied, url: wikiBrowserUrl(result.path, result.orgId) }));
-      }
-
-      // ── mv ──────────────────────────────────────────────────────
-      case 'mv': {
-        const { from: mvFrom, to: mvTo, pageId: mvPageId, dryRun: mvDryRun = false } = args;
-        if (!mvTo) throw new Error('to (destination path) required for action=mv');
-        const toPath = normalizeWikiPath(mvTo);
-        let id = mvPageId;
-        if (!id) {
-          if (!mvFrom) throw new Error('from (source path) or pageId required for action=mv');
-          const fromPath = normalizeWikiPath(mvFrom);
-          if (fromPath === toPath) throw new Error('source and destination are the same');
-          const page = await api('GET', `/api/wiki/page?path=${encodeURIComponent(fromPath)}`, undefined, orgHeader);
-          id = page.id;
-        }
-
-        if (mvDryRun) {
-          const { referrers } = await api('GET', `/api/wiki/pages/${id}/referrers`);
-          return ok(withOrg({ impacted: referrers.map(r => ({ path: r.path, title: r.title })) }));
-        }
-
-        // Server-side cascade: /move rewrites referrers in one transaction
-        const moved = await api('PATCH', `/api/wiki/pages/${id}/move`, { path: toPath });
-        return ok(withOrg({ path: moved.path, title: moved.title, id: moved.id, referrersUpdated: moved.referrersUpdated ?? 0, url: wikiBrowserUrl(moved.path, moved.orgId) }));
-      }
-
-      // ── rm ──────────────────────────────────────────────────────
-      case 'rm': {
-        const { path: rmPath, pageId: rmPageId, dryRun: rmDryRun = false } = args;
-        let id = rmPageId;
-        let normalized = null;
-        if (!id) {
-          if (!rmPath) throw new Error('path or pageId required for action=rm');
-          normalized = normalizeWikiPath(rmPath);
-          const page = await api('GET', `/api/wiki/page?path=${encodeURIComponent(normalized)}`, undefined, orgHeader);
-          id = page.id;
-        }
-        const { referrers } = await api('GET', `/api/wiki/pages/${id}/referrers`);
-        const broken = referrers.map(r => ({ path: r.path, title: r.title }));
-
-        if (rmDryRun) {
-          return ok(withOrg({ brokenAfterDelete: broken }));
-        }
-        await api('DELETE', `/api/wiki/pages/${id}`);
-        return ok(withOrg({ deleted: true, path: normalized, id, brokenReferences: broken }));
-      }
-
-      // ── bulk-write ──────────────────────────────────────────────
-      // Commit many pages in a single transaction. The MCP wrapper reads
-      // the manifest file locally and posts the pages array inline to
-      // /api/wiki/pages/bulk — avoids paying a tool-call round-trip per
-      // page and keeps the orchestrator's context clean.
-      case 'bulk-write': {
-        const { manifest_path, pages: inlinePages } = args;
-        let pages;
-        if (manifest_path) {
-          if (!existsSync(manifest_path)) throw new Error(`manifest not found: ${manifest_path}`);
-          const text = readFileSync(manifest_path, 'utf8');
-          let parsed;
-          try { parsed = JSON.parse(text); } catch (e) { throw new Error(`invalid JSON in ${manifest_path}: ${e.message}`); }
-          // Accept either {pages: [...]} or a bare array
-          pages = Array.isArray(parsed) ? parsed : parsed.pages;
-        } else if (Array.isArray(inlinePages)) {
-          pages = inlinePages;
-        } else {
-          throw new Error('bulk-write requires either manifest_path or pages array');
-        }
-        if (!Array.isArray(pages) || pages.length === 0) throw new Error('pages array is empty');
-        // Strip surplus fields the server ignores; keep payload tight.
-        const payload = pages.map((p) => ({
-          path: p.path,
-          title: p.title,
-          content: p.content,
-          type: p.type,
-          frontmatter: p.frontmatter,
-        }));
-        const result = await api('POST', '/api/wiki/pages/bulk', { pages: payload }, orgHeader);
-        return ok(withOrg({
-          created: result.created?.length ?? 0,
-          updated: result.updated?.length ?? 0,
-          createdPages: (result.created ?? []).map((r) => ({ path: r.path, url: wikiBrowserUrl(r.path) })),
-          updatedPages: (result.updated ?? []).map((r) => ({ path: r.path, url: wikiBrowserUrl(r.path) })),
-          errors: result.errors ?? [],
-        }));
-      }
-
-      // ── source-register ────────────────────────────────────────
-      // Register an external source (paper, article, transcript) by content
-      // hash. Idempotent: same hash + same org returns the existing source
-      // with `isNew: false` and the pages already derived from it. This is
-      // the dedup boundary — if isNew=false and derivedPages is non-empty,
-      // the agent should extend those pages, not create new ones.
-      case 'source-register': {
-        const { file_path: srcFile, contentHash, filename, contentType, size } = args;
-        if (!srcFile && !contentHash) throw new Error('file_path or contentHash required for action=source-register');
-        const body = {};
-        if (contentHash) body.contentHash = contentHash;
-        if (filename) body.filename = filename;
-        if (contentType) body.contentType = contentType;
-        if (size !== undefined) body.size = size;
-        if (srcFile && !contentHash) {
-          // Hash locally — server may not be able to read this client's filesystem.
-          if (!existsSync(srcFile)) throw new Error(`file not found: ${srcFile}`);
-          const buf = readFileSync(srcFile);
-          body.contentHash = createHash('sha256').update(buf).digest('hex');
-          body.size = body.size ?? buf.byteLength;
-          body.filename = body.filename ?? basename(srcFile);
-        }
-        const result = await api('POST', '/api/wiki/sources', body);
-        return ok(withOrg(result));
-      }
-
-      // ── source-list ────────────────────────────────────────────
-      case 'source-list': {
-        const { contentHash, limit: srcLimit = 50 } = args;
-        if (contentHash) {
-          try {
-            const result = await api('GET', `/api/wiki/sources?hash=${encodeURIComponent(contentHash)}`);
-            return ok({ sources: [result] });
-          } catch (e) {
-            if (/Not found/.test(e.message)) return ok({ sources: [] });
-            throw e;
-          }
-        }
-        const result = await api('GET', `/api/wiki/sources?limit=${srcLimit}`);
-        return ok(result);
-      }
-
-      // ── source-get ─────────────────────────────────────────────
-      case 'source-get': {
-        const { sourceId } = args;
-        if (!sourceId) throw new Error('sourceId required for action=source-get');
-        const result = await api('GET', `/api/wiki/sources/${encodeURIComponent(sourceId)}`);
-        return ok(result);
-      }
-
-      default:
-        throw new Error(`Unknown wiki action: ${action}`);
-    }
-  } catch (error) { return err(error); }
-});
-
-// ── Minions ───────────────────────────────────────────────────────
-
-function compactMinionEntry(c) {
-  if (!c || typeof c !== 'object') return c;
-  return { id: c.id, slug: c.slug, name: c.name, enabled: c.enabled, projectId: c.projectId };
-}
-
-// Shape a {minions:[...]} list with limit/offset pagination + optional compact
-// mode, mirroring shapeSkillCatalog so large lists stay within token budget.
-function shapeMinionList(result, { limit, offset = 0, compact = false } = {}) {
-  if (!Array.isArray(result?.minions)) return result;
-  const total = result.minions.length;
-  const start = Math.max(0, Math.floor(Number(offset) || 0));
-  const cap = Math.min(Math.max(1, Math.floor(Number(limit) || 25)), 100);
-  const page = result.minions.slice(start, start + cap);
-  result.totalAvailable = total;
-  result.offset = start;
-  result.returned = page.length;
-  result.truncated = start + page.length < total;
-  result.minions = compact ? page.map(compactMinionEntry) : page;
-  result.note = compact
-    ? 'Compact list: {id,slug,name,enabled,projectId} only. Use minion(action="get", id="<id>") for full config; limit/offset to page.'
-    : 'Minions are scoped to the active project (all org Minions when no project is open). Use limit/offset to page; compact=true for a leaner list.';
-  return result;
-}
-
-// Friendlier message when the agent allowlist gate (requireAgentAccess) rejects.
-function minionGateError(e) {
-  if (e?.status === 403 || e?.code === 'agent_disabled') {
-    return new Error('Minion management is not enabled for this org/account (agent allowlist). Ask an admin to add your org or email to DRAFTED_AGENT_ALLOWED_ORGS / DRAFTED_AGENT_ALLOWED_EMAILS.');
-  }
-  return e;
-}
 
 tool('minion', {
   action: z.enum(['meta', 'list', 'get', 'create', 'update', 'enable', 'disable', 'delete', 'test_start', 'test_say', 'test_resolve']).describe('Operation to perform. test_* drive a QA conversation against a Minion you own (even disabled) to verify it end-to-end.'),
@@ -4732,7 +2420,7 @@ tool('minion', {
   fresh: z.boolean().optional().describe('[test_start] start a brand-new run instead of resuming your latest'),
   actionId: z.string().optional().describe('[test_resolve] id of the pending action to resolve'),
   approve: z.boolean().optional().describe('[test_resolve] approve (default true) or reject the pending action'),
-  projectId: z.string().optional().describe('[create|meta] project to bind/scope to (defaults to the active project). The org derives from this project — open the target project first via project(action="open") if none is active.'),
+  projectId: z.string().optional().describe('[meta|list|create] the project this Minion belongs to — REQUIRED, as a path (/projects/<name> or /projects/<folder>/<name>), slug, or UUID. Minions are project-scoped: they write producibles into that project\'s surface. No session fallback — name the project.'),
   name: z.string().optional().describe('[create|update] Minion name'),
   description: z.string().optional().describe('[create|update] one-line description shown to the consumer'),
   enabled: z.boolean().optional().describe('[create|update] whether the Minion is live; a disabled Minion 404s on its /c/<slug> link. enable/disable set this directly.'),
@@ -4768,20 +2456,21 @@ tool('minion', {
 }, async (args) => {
   try {
     const { action } = args;
+    // Minions are project-scoped: meta/list/create need the project, addressed
+    // by fs path (or slug/UUID). Resolved once, scoped via withProjectOverride so
+    // api() appends THIS project (not whatever session is bound), echoed back as projectPath.
+    const projectNeeded = action === 'meta' || action === 'list' || action === 'create';
+    const project = projectNeeded ? await resolveProjectArg(args.projectId) : null;
+    const projectPath = project ? `/projects/${project.slug}` : null;
+    const scoped = (fn) => project ? withProjectOverride(project, fn) : fn();
     switch (action) {
       case 'meta': {
-        const active = getState().projectId;
-        const pid = active || args.projectId;
-        if (!pid) throw new Error('No active project. Call project(action="open") first, or pass projectId.');
-        // api() auto-appends the active project; add projectId explicitly only when none is active.
-        const path = active ? '/api/minions/meta' : `/api/minions/meta?projectId=${encodeURIComponent(pid)}`;
-        return ok(await api('GET', path));
+        return ok(await scoped(() => api('GET', '/api/minions/meta').then(r => ({ ...r, projectPath }))));
       }
       case 'list': {
-        // api() auto-appends the active project as ?projectId — so this lists the
-        // active project's Minions, or all org Minions when none is open.
-        const result = await api('GET', '/api/minions');
-        return ok(shapeMinionList(result, { limit: args.limit, offset: args.offset, compact: args.compact }));
+        const result = await scoped(() => api('GET', '/api/minions'));
+        const minions = (result.minions || []).map(m => ({ ...m, projectPath }));
+        return ok({ ...result, minions, projectPath });
       }
       case 'get': {
         if (!args.id) throw new Error('id is required for action=get');
@@ -4789,16 +2478,15 @@ tool('minion', {
       }
       case 'create': {
         // projectId lives in the BODY (the POST route reads body, ignores the query).
-        const projectId = args.projectId || getState().projectId;
-        if (!projectId) throw new Error('No active project. Call project(action="open") first, or pass projectId.');
         const { name, description, target, checklist, output, enabled } = args;
         if (!name || !target || !Array.isArray(checklist) || !output) {
           throw new Error('name, target, checklist[], and output are required for action=create');
         }
-        const body = { projectId, name, target, checklist, output };
+        const body = { projectId: project.id, name, target, checklist, output };
         if (description !== undefined) body.description = description;
         if (enabled !== undefined) body.enabled = enabled;
-        return ok(await api('POST', '/api/minions', body));
+        const created = await scoped(() => api('POST', '/api/minions', body));
+        return ok({ ...created, projectPath });
       }
       case 'update': {
         if (!args.id) throw new Error('id is required for action=update');
@@ -4835,7 +2523,7 @@ tool('minion', {
       default:
         throw new Error(`Unknown minion action: ${action}`);
     }
-  } catch (error) { return err(minionGateError(error)); }
+  } catch (error) { return err(error); }
 });
 
 // ── Resource: canvas info ─────────────────────────────────────────
@@ -4851,13 +2539,583 @@ server.resource('info', 'drafted://info', {
       text: JSON.stringify({
         version: PACKAGE_VERSION,
         layers: LAYERS,
-        pathFormat: '/{layer}/{lane}/{filename}',
-        tools: ['write', 'read', 'edit', 'ls', 'rm', 'mv'],
+        pathFormat: '/o/<org>/<root>/<path> — org first, no org switching',
+        roots: {
+          wiki: '/o/<org>/wiki/<path>',
+          skills: '/o/<org>/skills/<slug>',
+          projects: '/o/<org>/projects/<folder?>/<project>/<layer>/<lane>/<file>',
+        },
+        tools: ['fs (ls/read/write/edit/mv/rm/mkdir/search)', 'whoami', 'auth', 'session', 'trigger', 'focus', 'screenshot', 'minion'],
       }, null, 2),
     }],
   };
 });
 
+tool('fs', 'Navigate Drafted like a local filesystem. An org is the top folder: `fs(ls, path="/")` lists the orgs you can address, then `/o/<org>/<root>/...` addresses one of them — the org is part of the path, there is no org switching:\n\n- `/o/<org>/wiki/<path>` — org knowledge pages (markdown, OKF; free nesting; `index.md` at any level is synthesized and read-only)\n- `/o/<org>/skills/<slug>` — reusable procedures (flat: one dir per skill slug, `SKILL.md` + supporting files inside)\n- `/o/<org>/projects/<folder?>/<project>/<layer>/<lane>/<file>` — producible frames (folder optional; then exactly layer → lane → file)\n\n(Bare `/wiki`, `/skills`, `/projects` roots still resolve via the session\'s working org.)\n\nVerbs: `ls` (list a directory), `read` (file content — hashline-annotated for text so `edit` stays surgical), `write` (create/overwrite; extension + layer classify the type: .html design, .md document, .excalidraw diagram, .xlsx/.docx office, images/videos media, .pdf asset, .google-doc/.google-sheet/.google-slide create native Google Workspace files), `edit` (hashline ops for text, element ops for excalidraw, structured ops for office), `mv` (rename/move, cross-project), `rm` (delete), `search` (across wiki + skills + projects). `mkdir` creates a project only: use `/projects/<project>` or `/projects/<folder>/<project>`, never a layer path. To create a layer, write its first frame at `/projects/<project>/<new-layer>/<lane>/<file>`.\n\nThe project is resolved from the path itself — no separate "open" step. Guardrails are server-side and unchanged: the org in the path must be the project\'s own org (project paths under /o/<org>/ validate it), the G1 wiki-search gate fires before project mutations, attached-skill gates fire on mutations, anchored frames must be read before editing a layer, `.skillinstall/` is stripped on skill push.', {
+  action: z.enum(['ls', 'read', 'write', 'edit', 'mv', 'rm', 'mkdir', 'search']).describe('Filesystem verb.'),
+  path: z.string().describe('Drafted path: /o/<org>/wiki/... | /o/<org>/skills/... | /o/<org>/projects/... (bare /wiki, /skills, /projects also work; for mv: source)'),
+  to: z.string().optional().describe('[mv] destination path'),
+  query: z.string().optional().describe('[search] term to match against names/content'),
+  content: z.string().optional().describe('[write] inline HTML/markdown/text'),
+  file_path: z.string().optional().describe('[write] absolute path to a local file to upload (stdio only)'),
+  base64: z.string().optional().describe('[write] base64-encoded binary content'),
+  googleType: z.enum(['google-doc', 'google-sheet', 'google-slide']).optional().describe('[write] explicit Google Workspace type (also derived from .google-* filename extension)'),
+  title: z.string().optional().describe('[write + googleType] title for a new native file'),
+  ops: z.array(z.any()).optional().describe('[edit] hashline ops for text frames ({type,lineHash,newContent}), element ops for excalidraw ({id,x,y,...}), or office ops'),
+  state: z.any().optional().describe('[write] app-frame state (JSON) to persist for a deployed windowType:"app" frame; the canvas hydrates the app from it on load. Max 64KB.'),
+  recursive: z.boolean().optional().describe('[ls] recurse into subdirectories'),
+  lines: z.string().optional().describe('[read] line range (e.g. "1-50") — partial read; content is hashline-annotated so a later edit stays surgical'),
+  pattern: z.string().optional().describe('[ls] filter filenames (e.g. "*.html")'),
+  org: z.string().optional().describe('Org (id or name) for bare /wiki and /skills paths (org-scoped /o/<org>/... paths don\'t need it). Per-request only; project paths self-derive org from the project row.'),
+  projectId: PROJECT_OVERRIDE_PARAM,
+}, async (args) => {
+  const { action, path: rawPath, to: rawTo, query, content, file_path, base64, googleType, title, ops, state, recursive, pattern, lines, org } = args;
+  // Org-scoped path (Shape A): /o/<org>/<root>/... — strip the org segment here,
+  // carry it as the per-request org scope (orgHeader), validate per-root below.
+  // The PATH is the address; the org= param is legacy for bare roots only, and a
+  // contradiction between the two is an error, never a silent winner. A full share
+  // URL (https://…/o/…) is stripped to its pathname first — the pathname IS the fs path.
+  const scoped = splitOrgScope(stripUrlOrigin(rawPath));
+  if (scoped.error) return err(new Error(scoped.error));
+  let p = scoped.path;
+  const orgFromPath = scoped.org;
+  if (org && orgFromPath && String(org).toLowerCase() !== String(orgFromPath).toLowerCase()) {
+    return err(new Error(`org="${org}" contradicts the org addressed by the path (/o/${orgFromPath}/) — address the org in the path only`));
+  }
+  let to = rawTo;
+  if (to) {
+    const toScoped = splitOrgScope(stripUrlOrigin(to));
+    if (toScoped.error) return err(new Error(toScoped.error));
+    if (toScoped.org && orgFromPath && toScoped.org.toLowerCase() !== orgFromPath.toLowerCase()) {
+      return err(new Error('mv stays within one org — source and destination must address the same org'));
+    }
+    if (toScoped.org && !orgFromPath) {
+      return err(new Error('mv to an org-scoped destination needs an org-scoped source too (/o/<org>/... on both sides)'));
+    }
+    to = toScoped.path;
+  }
+  const orgHeader = org ? { 'X-Drafted-Org': org } : (orgFromPath ? { 'X-Drafted-Org': orgFromPath } : {});
+  const gs = getSessionState().gates;
+
+  // ── Root listing: / or empty → the orgs this session can address (Shape A) ──
+  if (!p || p === '/' || p === '') {
+    if (action !== 'ls') return err(new Error('read/write/edit/mv/rm require a path under /o/<org>/wiki, /o/<org>/skills, or /o/<org>/projects'));
+    if (orgFromPath) {
+      // ls /o/<org> → that org's three roots
+      return ok([
+        { name: 'wiki', type: 'directory', path: `/o/${orgFromPath}/wiki`, hint: 'org knowledge pages (markdown, OKF)' },
+        { name: 'skills', type: 'directory', path: `/o/${orgFromPath}/skills`, hint: 'reusable procedures (flat: one dir per skill slug)' },
+        { name: 'projects', type: 'directory', path: `/o/${orgFromPath}/projects`, hint: '<folder?>/<project>/<layer>/<lane>/<file>' },
+      ]);
+    }
+    // ls / → the orgs (id, slug, name) the agent belongs to; org is the top folder
+    const orgs = await getOrgList();
+    if (!orgs.length) return err(new Error('no orgs to list — are you signed in? fs(ls, path="/") shows the orgs you belong to'));
+    return ok(orgs.map(o => ({ name: o.name || o.id, type: 'directory', path: `/o/${o.slug || o.id}`, hint: 'org — fs(ls, path="/o/<org>") shows its wiki/skills/projects' })));
+  }
+
+  // ── mkdir: create a project (a directory in the /projects root) ──
+  if (action === 'mkdir') {
+    if (!p.startsWith('/projects')) {
+      return err(new Error('mkdir is only meaningful under /projects (wiki dirs are implicit; skills are flat) — e.g. fs(mkdir, path="/o/<org>/projects/my-project")'));
+    }
+    // A project create is project-less: it must not guess the org.
+    await requireBoundOrgForProjectlessMutation(org || orgFromPath);
+    const parts = p.replace(/^\/projects\/?/, '').split('/').filter(Boolean);
+    if (parts.length === 0 || parts.length > 2) {
+      return err(new Error(`mkdir path must be /projects/<name> or /projects/<folder>/<name> — got ${p}`));
+    }
+    const folder = parts.length === 2 ? parts[0] : null;
+    const projectRef = parts[parts.length - 1];
+    const existing = await resolveProjectRef(projectRef).catch(() => null);
+    if (existing) return err(new Error(`project already exists: ${projectRef}`));
+    const projectName = projectRef.replace(/[-_]/g, ' ').replace(/\b\w/g, c => c.toUpperCase());
+    const created = await api('POST', '/api/projects', { name: projectName }, orgHeader);
+    if (!created?.id) return err(new Error('project create returned no id'));
+    if (folder) {
+      try { await api('PATCH', `/api/project/${created.id}`, { folder }, orgHeader); } catch { /* folder best-effort */ }
+    }
+    projectRefCache.set(projectRef, { id: created.id, slug: created.slug, name: created.name, orgId: created.orgId, orgSlug: created.orgSlug });
+    return ok({ created: true, name: created.name, slug: created.slug, id: created.id, path: `${orgFromPath ? `/o/${orgFromPath}` : ''}/projects${folder ? '/' + folder : ''}/${created.slug}`, projectUrl: `${getServerUrl()}/o/${created.orgId || org || ''}/projects/${created.slug}` });
+  }
+
+  // ── Root: /wiki/... ────────────────────────────────────────────
+  if (p.startsWith('/wiki')) {
+    const wikiPath = p === '/wiki' || p === '/wiki/' ? '' : p.replace(/^\/wiki\/?/, '');
+    // Project-less mutations must not guess the org (Shape A: address it in the path —
+    // an org-scoped path or org= counts as explicit; a bare path needs a bound org).
+    if (['write', 'edit', 'mv', 'rm'].includes(action)) {
+      await requireBoundOrgForProjectlessMutation(org || orgFromPath);
+    }
+    switch (action) {
+      case 'ls': {
+        if (!wikiPath) {
+          const tree = await api('GET', '/api/wiki/tree', undefined, orgHeader);
+          return ok(formatWikiIndex(tree?.pages || []));
+        }
+        const pages = await api('GET', `/api/wiki/tree?prefix=${encodeURIComponent(wikiPath)}`, undefined, orgHeader);
+        return ok(formatWikiIndex(pages?.pages || []));
+      }
+      case 'read': {
+        const canonPath = wikiPath.replace(/\.md$/, '');
+        const page = await api('GET', `/api/wiki/page?path=${encodeURIComponent(canonPath)}&raw=true`, undefined, orgHeader);
+        if (!page?.content) return err(new Error(`wiki page not found: ${canonPath}`));
+        return ok(page.content);
+      }
+      case 'write': {
+        if (!content) return err(new Error('write to /wiki/... requires content'));
+        // OKF boundary rule: /a/b.md ≡ a/b — strip a trailing .md so both spellings work.
+        const canonPath = wikiPath.replace(/\.md$/, '');
+        const existing = await api('GET', `/api/wiki/page?path=${encodeURIComponent(canonPath)}`, undefined, orgHeader).catch(() => null);
+        const body = { path: canonPath, title: canonPath.split('/').pop(), content, type: existing?.type || 'Page' };
+        const result = existing
+          ? await api('PUT', `/api/wiki/page?path=${encodeURIComponent(canonPath)}`, { content }, orgHeader)
+          : await api('POST', '/api/wiki/pages', body, orgHeader);
+        return ok(result || { path: canonPath, written: true });
+      }
+      case 'edit': {
+        if (!ops?.length) return err(new Error('edit requires ops'));
+        const result = await api('POST', '/api/wiki/edit', { path: wikiPath, operations: ops }, orgHeader);
+        return ok(result);
+      }
+      case 'mv': {
+        if (!to || !to.startsWith('/wiki')) return err(new Error('mv within /wiki requires to=/wiki/...'));
+        const result = await api('POST', '/api/wiki/mv', { from: wikiPath, to: to.replace(/^\/wiki\/?/, '') }, orgHeader);
+        return ok(result);
+      }
+      case 'rm': {
+        // Soft delete: move the page under archive/ (agents never hard-delete;
+        // the web UI offers permanent delete in the archive). mv cascades
+        // inbound refs, so links keep working into the archive.
+        const canonPath = wikiPath.replace(/\.md$/, '');
+        const archivePath = canonPath.startsWith('archive/') ? canonPath : `archive/${canonPath}`;
+        const page = await api('GET', `/api/wiki/page?path=${encodeURIComponent(canonPath)}`, undefined, orgHeader).catch(() => null);
+        if (!page?.id) return err(new Error(`wiki page not found: ${canonPath}`));
+        const result = await api('PATCH', `/api/wiki/pages/${page.id}/move`, { path: archivePath }, orgHeader);
+        return ok({ archived: true, from: canonPath, to: archivePath, ...(result?.referrersUpdated ? { referrersUpdated: result.referrersUpdated } : {}) });
+      }
+      case 'search': {
+        markSearched(gs, 'wiki');
+        const pages = await api('GET', `/api/wiki/search?q=${encodeURIComponent(query || '')}`, undefined, orgHeader);
+        return ok(formatWikiIndex(pages?.pages || pages?.results || []));
+      }
+      default:
+        return err(new Error(`fs ${action} not supported for /wiki`));
+    }
+  }
+
+  // ── Root: /skills/... ──────────────────────────────────────────
+  if (p.startsWith('/skills')) {
+    const slug = p === '/skills' || p === '/skills/' ? '' : p.replace(/^\/skills\/?/, '').split('/')[0];
+    if (['write', 'mv', 'rm'].includes(action)) {
+      await requireBoundOrgForProjectlessMutation(org || orgFromPath);
+    }
+    switch (action) {
+      case 'ls': {
+        const list = await api('GET', '/api/skills', undefined, orgHeader);
+        const skills = Array.isArray(list) ? list : (list?.skills || []);
+        return ok(skills.map(s => ({ slug: s.slug, name: s.name, description: s.description })));
+      }
+      case 'read': {
+        if (!slug) return err(new Error('read /skills/<slug>'));
+        const s = await api('GET', `/api/skills/slug/${slug}`, undefined, orgHeader);
+        return ok(s?.content || '');
+      }
+      case 'write': {
+        if (!slug || !content) return err(new Error('write /skills/<slug> requires content'));
+        const existing = await api('GET', `/api/skills/slug/${slug}`, undefined, orgHeader).catch(() => null);
+        if (!existing) {
+          const g2 = g2Block(gs);
+          if (g2) return err(new Error(g2));
+        }
+        const name = existing?.name || slug.replace(/[-_]/g, ' ').replace(/\b\w/g, c => c.toUpperCase());
+        // Derive a description from the slug when the agent didn't pass one
+        // (the API requires a non-empty description on create).
+        const description = args.description || existing?.description || `Reusable procedure: ${name.toLowerCase()}`;
+        const result = existing
+          ? await api('PUT', `/api/skills/${existing.id}`, { content }, orgHeader)
+          : await api('POST', '/api/skills', { slug, name, content, description }, orgHeader);
+        // Writing an archived skill restores it (update flow un-archives).
+        if (result?.id && existing?.archived) {
+          try { await api('POST', `/api/skills/${result.id}/restore`, undefined, orgHeader); } catch { /* best-effort */ }
+        }
+        return ok(result || { slug, written: true });
+      }
+      case 'mv': {
+        if (!to || !to.startsWith('/skills')) return err(new Error('mv within /skills requires to=/skills/...'));
+        const toSlug = to.replace(/^\/skills\/?/, '').split('/')[0];
+        const result = await api('POST', '/api/skills/fork', { from: slug, to: toSlug, ...(org ? { org } : {}) }, orgHeader);
+        return ok(result);
+      }
+      case 'rm': {
+        const s = await api('GET', `/api/skills/slug/${slug}`, undefined, orgHeader);
+        if (!s?.id) return err(new Error(`skill not found: ${slug}`));
+        return ok(await api('DELETE', `/api/skills/${s.id}`, undefined, orgHeader));
+      }
+      case 'search': {
+        markSearched(gs, 'skill');
+        const results = await api('GET', `/api/skills/search?q=${encodeURIComponent(query || '')}`, undefined, orgHeader);
+        const skills = Array.isArray(results) ? results : (results?.skills || []);
+        return ok(skills.map(s => ({ slug: s.slug, name: s.name, description: s.description })));
+      }
+      default:
+        return err(new Error(`fs ${action} not supported for /skills`));
+    }
+  }
+
+  // ── Root: /projects/... ────────────────────────────────────────
+  if (p.startsWith('/projects')) {
+    const parts = p.replace(/^\/projects\/?/, '').split('/').filter(Boolean);
+    // Resolve the project from the path: <folder?>/<project>/<layer>/<lane>/<file>
+    let projectRef = null, layer, lane, filename;
+    if (parts.length === 0) {
+      // /projects or /o/<org>/projects — list projects (archived ones live in the
+      // Archive bin and are hidden from the agent's active list — mirroring the web UI).
+      // An org-scoped root lists ONLY that org's projects (Shape A).
+      const projects = await api('GET', '/api/projects');
+      const active = Array.isArray(projects?.projects)
+        ? { ...projects, projects: projects.projects.filter(x => x.folder !== '__archived') }
+        : projects;
+      if (orgFromPath && Array.isArray(active?.projects)) {
+        const kept = [];
+        for (const x of active.projects) {
+          if (await pathOrgMatches(orgFromPath, x)) kept.push(x);
+        }
+        active.projects = kept;
+      }
+      return ok(active);
+    }
+    if (parts.length >= 4) {
+      projectRef = parts.length === 4 ? parts[0] : parts[1]; // no-folder vs folder form
+      layer = parts[parts.length - 3];
+      lane = parts[parts.length - 2];
+      filename = parts[parts.length - 1];
+    } else if (parts.length === 3) {
+      // /projects/<project>/<layer>/<lane>  OR  /projects/<project>/<layer>/<file>
+      // A lane view (no extension) vs a layer-root file (has an extension) —
+      // mirror the server's dual routes.
+      projectRef = parts[0];
+      const last = parts[2];
+      if (/\.[a-z0-9]+$/i.test(last) && !['designs', 'research', 'plans', 'copy', 'wireframes', 'images', 'components', 'brand-assets'].includes(last)) {
+        layer = parts[1]; lane = null; filename = last; // layer-root file
+      } else {
+        layer = parts[1]; lane = last; filename = null; // lane view
+      }
+    } else if (parts.length === 2) {
+      projectRef = parts[0]; // /projects/<project>/<layer>
+      layer = parts[1]; lane = null; filename = null;
+    } else if (parts.length === 1) {
+      projectRef = parts[0]; // /projects/<project>
+    }
+
+    const run = async () => {
+      const hasFile = layer && filename;
+      // Layer-root file (lane null) hits the server's 2-segment route.
+      const filePath = hasFile ? (lane ? `${encodeURIComponent(layer)}/${encodeURIComponent(lane)}/${encodeURIComponent(filename)}` : `${encodeURIComponent(layer)}/${encodeURIComponent(filename)}`) : null;
+      const g1Mutating = ['write', 'edit', 'mv', 'rm'].includes(action);
+
+      if (g1Mutating && !gs.wikiSearched) {
+        let wikiIndex = '';
+        try { const tree = await api('GET', '/api/wiki/tree', undefined, orgHeader); wikiIndex = formatWikiIndex(tree?.pages || []); } catch { /* best-effort */ }
+        return err(new Error(g1Block(gs, wikiIndex)));
+      }
+
+      switch (action) {
+        case 'ls': {
+          // Listing path relative to the project. No-folder forms: [p] → '/',
+          // [p, layer] → '/layer', [p, layer, lane] → '/layer/lane' — a lane/layer
+          // URL IS this path (Q2), so ls of a shared lane URL lists the lane.
+          // (Folder-form ls — [folder, p, layer[, lane]] — is a pre-existing dead
+          // end: the parse takes parts[0] as the project ref and resolve fails.)
+          let lsPath, lsProjectId;
+          if (projectRef && parts.length >= 3) { lsProjectId = projectRef; lsPath = '/' + parts.slice(parts.length - 2).join('/'); }
+          else if (projectRef && parts.length === 2) { lsProjectId = projectRef; lsPath = '/' + parts[1]; }
+          else { lsProjectId = projectRef; lsPath = '/'; }
+          const lsParams = new URLSearchParams({ path: lsPath });
+          if (recursive) { lsParams.set('recursive', 'true'); lsParams.set('summary', 'true'); }
+          if (pattern) lsParams.set('pattern', pattern);
+          const result = await api('GET', `/api/fs/?${lsParams.toString()}`, undefined, orgHeader);
+          return ok(result);
+        }
+        case 'read': {
+          if (!filePath) return err(new Error('read requires a full file path: /projects/<project>/<layer>/<lane>/<file>'));
+          const query = lines ? `?lines=${encodeURIComponent(lines)}` : '';
+          const result = await api('GET', `/api/fs/${filePath}${query}`, undefined, orgHeader);
+          if (result?.type === 'binary') return ok({ type: 'binary', path: result.path, contentType: result.contentType });
+          // App frames (drafted:frame-type=app) carry a separate hydration state —
+          // return the state + a content preview rather than the full bundle, which
+          // is usually a large minified JS blob that would blow the tool-result cap.
+          if (result?.id && /drafted:frame-type[^>]*content="app"/.test(result.content || '')) {
+            let state = null;
+            try { const st = await api('GET', `/api/file/${result.id}/state`); state = st?.state ?? null; } catch { /* best-effort */ }
+            return ok({ appFrame: true, frameId: result.id, frameUrl: `${getServerUrl()}/f/${result.id}`, state, contentPreview: (result.content || '').slice(0, 500) });
+          }
+          // Surface the clickable link alongside content so the agent can hand
+          // the user a URL for what it just read (filesystem parity: cat gives
+          // you the path; this gives the path AND the shareable link). Prefer the
+          // semantic /o/<org>/<project>/<path> form when the project context is
+          // available; /f/<uuid> is the always-works fallback.
+          if (result?.id) {
+            const proj = result.project;
+            const semantic = proj?.orgSlug && proj?.slug ? `${getServerUrl()}/o/${proj.orgSlug}/projects/${proj.slug}${result.path}` : null;
+            return ok({ path: result.path, frameUrl: semantic || result.frameUrl || `${getServerUrl()}/f/${result.id}`, content: result.content || '' });
+          }
+          return ok(result?.content || '');
+        }
+        case 'write': {
+          if (!filePath) return err(new Error('write requires a full file path: /projects/<project>/<layer>/<lane>/<file>'));
+          // Google Workspace: explicit googleType OR .google-* filename extension.
+          const extType = /\.google-(doc|sheet|slide)$/.exec(filename || '');
+          const gw = googleType || (extType ? 'google-' + extType[1] : null);
+          // App-frame state write (persist state only, no content change).
+          if (state !== undefined && !content && !file_path && !base64 && !gw) {
+            const f = await api('GET', `/api/fs/${filePath}`, undefined, orgHeader);
+            if (!f?.id) return err(new Error('could not resolve frame for state write'));
+            await api('POST', `/api/file/${f.id}/state`, { state });
+            return ok({ path: p, stateWritten: true, frameId: f.id });
+          }
+          const body = {};
+          if (gw) {
+            // Google Workspace frames are created via the workspace endpoint (the
+            // label drops the .google-* extension), then populated with native actions.
+            const label = basename(filename, extname(filename)) || filename;
+            const result = await api('POST', '/api/google/workspace/create-frame', {
+              projectId: getState().projectId,
+              layer, lane, label, type: gw, title: title || label,
+            }, orgHeader);
+            return ok({ ...result, path: `/${layer}/${lane}/${filename}`, sourceType: gw });
+          }
+          else if (content) body.content = content;
+          else if (file_path) body.file_path = file_path;
+          else if (base64) body.base64 = base64;
+          else return err(new Error('write requires one of content / file_path / base64 / googleType / state'));
+          const result = await api('PUT', `/api/fs/${filePath}`, body, orgHeader);
+          if (state !== undefined && result?.id) {
+            try { await api('POST', `/api/file/${result.id}/state`, { state }); } catch { /* state best-effort */ }
+          }
+          return ok(result);
+        }
+        case 'edit': {
+          if (!filePath || !ops?.length) return err(new Error('edit requires a full file path + ops'));
+          const isExcalidraw = filename?.endsWith('.excalidraw');
+          const relPath = lane ? `/${layer}/${lane}/${filename}` : `/${layer}/${filename}`;
+          const result = isExcalidraw
+            ? await api('POST', '/api/fs/edit-excalidraw', { path: relPath, elements: ops, remove: args.remove }, orgHeader)
+            : await api('POST', '/api/fs/edit', { path: relPath, operations: ops }, orgHeader);
+          return ok(result);
+        }
+        case 'mv': {
+          const from = lane ? `/${layer}/${lane}/${filename}` : `/${layer}/${filename}`;
+          const toClean = (to || '').replace(/^\/+|\/+$/g, '');
+          const toHasProject = toClean.startsWith('projects/');
+          const toParts = toClean.replace(/^projects\/?/, '').split('/').filter(Boolean);
+          let toPath, toProjectId;
+          if (toHasProject && toParts.length >= 2) {
+            // Full destination path: first segment after /projects is the project ref
+            // (fs grammar: /projects/<project>/<layer>[/<lane>]/<file>). Drop it from
+            // the path; resolve toProjectId only when it differs from the source.
+            const toRef = toParts[0];
+            const sameProject = projectRef && String(toRef).toLowerCase() === String(projectRef).toLowerCase();
+            if (!sameProject) {
+              const toMeta = await resolveProjectRef(toRef).catch(() => null);
+              if (toMeta) toProjectId = toMeta.id;
+            }
+            toPath = '/' + toParts.slice(1).join('/');
+          } else {
+            // Bare relative path (no project prefix): /{layer}[/{lane}]/{file}
+            toPath = toParts.length ? '/' + toParts.join('/') : (to || '');
+          }
+          const result = await api('POST', '/api/fs/mv', { from, to: toPath, ...(toProjectId ? { toProjectId } : {}) }, orgHeader);
+          return ok(result);
+        }
+        case 'rm': {
+          // Project-level rm = archive (soft delete): move to the reserved
+          // __archived folder. Frame/lane rm still deletes those items, but a
+          // whole project is never hard-deleted by an agent — the web UI's
+          // Archive bin is where a human permanently deletes.
+          if (!filePath) {
+            const pid = getState().projectId;
+            if (!pid) return err(new Error('could not resolve project id for archive'));
+            const result = await api('PATCH', `/api/project/${pid}`, { folder: '__archived' }, orgHeader);
+            return ok({ archived: true, project: projectRef, projectId: pid, archiveHint: 'The project now lives in the Archive bin in the web UI sidebar — a human can restore or permanently delete it there.' });
+          }
+          const rmPath = lane ? `/${layer}/${lane}/${filename}` : `/${layer}/${filename}`;
+          const result = await api('DELETE', `/api/fs/${rmPath.replace(/^\//, '')}`, undefined, orgHeader);
+          return ok(result);
+        }
+        case 'search': {
+          const result = await api('GET', `/api/fs/search?q=${encodeURIComponent(query || '')}`, undefined, orgHeader);
+          return ok(result);
+        }
+        default:
+          return err(new Error(`fs ${action} not supported for /projects`));
+      }
+    };
+
+    // Resolve the project from the path and scope the API calls to it
+    // (same seam the old project(action="open") provided, now path-derived).
+    const meta = args.projectId ? await resolveProjectRef(args.projectId) : (projectRef ? await resolveProjectRef(projectRef) : null);
+    // Shape A: the org in the path must address the project's own org. Without
+    // this check, /o/<orgX>/projects/<projInOrgY>/... silently operated on orgY
+    // (the old URL-form alias stripped the org segment without validation).
+    if (orgFromPath && meta && !(await pathOrgMatches(orgFromPath, meta))) {
+      return err(new Error(`project "${projectRef}" is not in the addressed org — /o/${orgFromPath}/... addresses ${orgFromPath}, but the project lives in ${meta.orgSlug || meta.orgId}`));
+    }
+    if (!meta && projectRef && (action === 'write' || action === 'edit')) {
+      // mkdir -p semantics: writing into a non-existent project creates it.
+      // The project name comes from the path; org resolves like any project-less
+      // mutation (explicit org in the path / org= wins, else the bound org, else refused).
+      await requireBoundOrgForProjectlessMutation(org || orgFromPath);
+      const projectName = projectRef.replace(/[-_]/g, ' ').replace(/\b\w/g, c => c.toUpperCase());
+      const body = { name: projectName };
+      if (org) body.templateSlug = undefined;
+      let created;
+      try {
+        created = await api('POST', '/api/projects', body, orgHeader);
+      } catch (e) {
+        return err(new Error(`project "${projectRef}" not found and auto-create failed: ${e?.message || e}`));
+      }
+      if (!created?.id) return err(new Error(`project "${projectRef}" not found and auto-create returned no id`));
+      const createdMeta = { id: created.id, slug: created.slug, name: created.name || projectName, orgId: created.orgId, orgSlug: created.orgSlug };
+      projectRefCache.set(projectRef, createdMeta);
+      projectRefCache.set(created.id, createdMeta);
+      return withProjectOverride(createdMeta, run);
+    }
+    if (projectRef && !meta) return err(new Error(`project not found: ${projectRef} — pass a project slug/name/UUID from /projects, or write to a new path to create it`));
+    return meta ? withProjectOverride(meta, run) : run();
+  }
+
+  return err(new Error(`unknown fs path: ${rawPath} — expected /o/<org>/wiki/..., /o/<org>/skills/..., or /o/<org>/projects/... (bare /wiki, /skills, /projects still work)`));
+});
+function normalizeMcpUpdatePolicy(policy) {
+  const severity = policy?.policy?.severity || 'unknown';
+  const updateAvailable = !!policy?.policy?.updateAvailable;
+  const required = !!policy?.policy?.required;
+  return {
+    status: required ? 'required' : updateAvailable ? 'stale' : severity === 'unknown' ? 'unknown' : 'current',
+    currentVersion: policy?.versions?.client || PACKAGE_VERSION,
+    latestVersion: policy?.versions?.latest || null,
+    recommendedVersion: policy?.versions?.recommended || null,
+    minimumRequiredVersion: policy?.versions?.minimumRequired || null,
+    severity,
+    updateAvailable,
+    stale: updateAvailable,
+    required,
+    reason: policy?.policy?.reason || null,
+    enabled: policy?.policy?.enabled !== false,
+    mode: policy?.package?.mcpMode || mcpMode(),
+    distribution: policy?.package?.distribution || (mcpMode() === 'stdio' ? 'npm-stdio' : 'hosted-http'),
+    update: {
+      command: policy?.update?.command || null,
+      helper: policy?.update?.helper || null,
+      packageManager: policy?.update?.packageManager || 'npm',
+    },
+    restart: {
+      required: !!policy?.restart?.required,
+      guidance: policy?.restart?.guidance || null,
+    },
+    checkedAt: policy?.serverTimestamp || null,
+  };
+}
+
+function buildInstalledMcpUpdateInstructions(updateMetadata = null) {
+  const mode = updateMetadata?.mode || mcpMode();
+  const restart = updateMetadata?.restart || {
+    required: mode === 'stdio',
+    guidance: 'Restart agents after updating the npm-installed Drafted MCP daemon.',
+  };
+
+  if (mode !== 'stdio') {
+    return {
+      action: 'update_mcp',
+      started: false,
+      updateSupported: false,
+      mode,
+      currentVersion: updateMetadata?.currentVersion || PACKAGE_VERSION,
+      latestVersion: updateMetadata?.latestVersion || null,
+      updateAvailable: false,
+      required: false,
+      command: null,
+      dryRunCommand: null,
+      manualCommand: null,
+      restart: {
+        required: false,
+        guidance: restart.guidance || 'Hosted HTTP MCP updates with the Drafted server deploy.',
+      },
+      note: 'This session is using hosted HTTP MCP, so there is no npm-installed stdio daemon to update on this machine.',
+    };
+  }
+
+  const server = getServerUrl().replace(/\/$/, '');
+  const manualCommand = platform() === 'win32'
+    ? `$tmp = Join-Path $env:TEMP "drafted-install.ps1"; Invoke-WebRequest -UseBasicParsing "${server}/install.ps1" -OutFile $tmp; powershell -NoProfile -ExecutionPolicy Bypass -File $tmp`
+    : `tmp=$(mktemp); curl -fsSL ${server}/install.sh -o "$tmp" && bash "$tmp"`;
+
+  return {
+    action: 'update_mcp',
+    started: false,
+    updateSupported: true,
+    mode: 'stdio',
+    currentVersion: updateMetadata?.currentVersion || PACKAGE_VERSION,
+    latestVersion: updateMetadata?.latestVersion || null,
+    recommendedVersion: updateMetadata?.recommendedVersion || null,
+    minimumRequiredVersion: updateMetadata?.minimumRequiredVersion || null,
+    updateAvailable: !!updateMetadata?.updateAvailable,
+    required: !!updateMetadata?.required,
+    command: 'drafted update --yes',
+    dryRunCommand: 'drafted update --dry-run',
+    manualCommand,
+    restart: {
+      required: true,
+      guidance: restart.guidance || 'Restart agents after updating the npm-installed Drafted MCP daemon.',
+    },
+    note: 'This action is intentionally advisory: it does not replace the currently running MCP process. Run the command, then restart your agent/editor so it starts the updated drafted-mcp.',
+    mcpUpdate: updateMetadata || null,
+  };
+}
+
+async function getMcpUpdateMetadata() {
+  const mode = mcpMode();
+  try {
+    const query = new URLSearchParams({
+      cliVersion: PACKAGE_VERSION,
+      mcpMode: mode,
+    });
+    const policy = await api('GET', `/api/installations/latest?${query.toString()}`);
+    return normalizeMcpUpdatePolicy(policy);
+  } catch (error) {
+    return {
+      status: 'unknown',
+      currentVersion: PACKAGE_VERSION,
+      latestVersion: null,
+      recommendedVersion: null,
+      minimumRequiredVersion: null,
+      severity: 'unknown',
+      updateAvailable: false,
+      stale: false,
+      required: false,
+      reason: 'latest_check_failed',
+      enabled: false,
+      mode,
+      distribution: mode === 'stdio' ? 'npm-stdio' : 'hosted-http',
+      update: { command: null, helper: null, packageManager: 'npm' },
+      restart: { required: false, guidance: 'Drafted MCP update status is unavailable; this call still succeeded.' },
+      checkedAt: null,
+    };
+  }
+}
+
+// Process-lifetime cache: the update status rides on every `whoami` (meant to be called
+// once per session), so avoid a network round-trip on repeat calls. `get_org` shares the
+// cache too (same underlying data).
+let mcpUpdateCache = null; // { data, fetchedAt }
+const MCP_UPDATE_CACHE_MS = 5 * 60_000;
+async function getCachedMcpUpdateMetadata() {
+  if (mcpUpdateCache && (Date.now() - mcpUpdateCache.fetchedAt) < MCP_UPDATE_CACHE_MS) return mcpUpdateCache.data;
+  const data = await getMcpUpdateMetadata();
+  mcpUpdateCache = { data, fetchedAt: Date.now() };
+  return data;
+}
   return server;
 }