drafted 1.24.0 → 1.24.2

package/mcp/gates.mjs

@@ -111,8 +111,11 @@ export function shouldInjectLayerPrompt(layerPrompt, templateDefaultPrompt) {
 
 // ── Wiki index formatting (bounded map injected with the G1 block) ────────────
 
-export function formatWikiIndex(pages, max = 50) {
-  if (!Array.isArray(pages) || pages.length === 0) return '(wiki is empty — no pages yet)';
+// `empty` lets a caller say what an empty result MEANS: a zero-hit search or an
+// empty folder is not "the wiki is empty" (that read as a contradiction when other
+// searches of the same org had returned pages).
+export function formatWikiIndex(pages, max = 50, empty = '(wiki is empty — no pages yet)') {
+  if (!Array.isArray(pages) || pages.length === 0) return empty;
   const lines = pages.slice(0, max).map((p) => {
     const path = typeof p === 'string' ? p : p.path ?? p.slug ?? '';
     const title = typeof p === 'object' && p && p.title ? ` — ${p.title}` : '';
@@ -122,6 +125,22 @@ export function formatWikiIndex(pages, max = 50) {
   return lines.join('\n') + more;
 }
 
+// A frame read is capped per page, below MAX_TOOL_RESULT_CHARS, because the
+// content is JSON-escaped on its way out (quotes, newlines) and the blunt cap
+// above cuts mid-token with no way back: `lines` cannot split a minified frame
+// that is ONE line, so ~90 KB of it was simply lost. Paging by character gives
+// every byte an address.
+export const READ_PAGE_CHARS = 60_000;
+
+// "start-end" (0-based, end exclusive) or "start" -> the window to return.
+export function charWindow(spec, total) {
+  const m = /^\s*(\d+)\s*(?:-\s*(\d+))?\s*$/.exec(String(spec ?? ''));
+  if (spec != null && spec !== '' && !m) throw new Error(`chars must look like "0-60000" (got "${spec}")`);
+  const start = m ? Math.min(Number(m[1]), total) : 0;
+  const end = Math.min(m?.[2] ? Number(m[2]) : start + READ_PAGE_CHARS, start + READ_PAGE_CHARS, total);
+  return { start, end: Math.max(start, end) };
+}
+
 // ── Project index formatting ──────────────────────────────────────────────────
 // `ls /projects` is an ls, not a stat: one addressable line per project. The
 // previous shape returned the raw /api/projects rows — ~2.4KB each once the

package/mcp/server.mjs

@@ -23,7 +23,7 @@ import { LAYERS } from '../src/shared/constants.mjs';
 import { liftFolderScope, normalizeFolder, rootEntries, splitFolderScope, subfolderEntries } from '../src/shared/folder-path.mjs';
 import { emptyExcalidrawScene, stringifyExcalidrawScene } from '../src/shared/excalidraw.mjs';
 import { formatOkfLogEntry, appendOkfLogEntry } from '../src/shared/okf-log.mjs';
-import { createGateState, markSearched, g1Block, g2Block, g3Block, selectWithinBudget, wouldExceedBudget, budgetError, formatWikiIndex, formatProjectIndex, projectPath, PROJECT_CONTEXT_BUDGET_CHARS } from './gates.mjs';
+import { createGateState, markSearched, g1Block, g2Block, g3Block, selectWithinBudget, wouldExceedBudget, budgetError, formatWikiIndex, formatProjectIndex, charWindow, READ_PAGE_CHARS, projectPath, PROJECT_CONTEXT_BUDGET_CHARS } from './gates.mjs';
 import { loadPersistedProject, savePersistedProject } from './active-project-store.mjs';
 import { probeRepo, resolveAddress, addressNote } from './repo-address.mjs';
 
@@ -1616,21 +1616,47 @@ async function pathOrgMatches(orgSegment, meta) {
   return !!hit && meta?.orgId === hit.id;
 }
 
-async function resolveProjectRef(ref) {
+/**
+ * Fetch /api/projects with NO org scope.
+ *
+ * api() otherwise stamps the session's working org on every request, so a
+ * listing meant to answer "which projects exist in the org this PATH names"
+ * came back scoped to the org the session happened to be working in, and the
+ * org filter then removed all of it. An empty header is how the server is told
+ * "unaddressed" (req.get('x-drafted-org') is falsy) without a server change.
+ */
+const NO_ORG_SCOPE = { 'X-Drafted-Org': '' };
+
+async function resolveProjectRef(ref, orgHint = null) {
   if (!ref) return null;
-  const hit = projectRefCache.get(ref);
+  const cacheKey = orgHint ? `${orgHint}|${ref}` : ref;
+  const hit = projectRefCache.get(cacheKey) || (!orgHint && projectRefCache.get(ref));
   if (hit) return hit;
-  const data = await api('GET', '/api/projects');
-  const list = Array.isArray(data?.projects) ? data.projects : [];
+  // Scope the lookup to the org the path named. Without a hint the session's
+  // org applies — which is right for `fs ls /projects` but WRONG for a path
+  // that addressed another org, and that mismatch is what made a project
+  // created in org B unresolvable from a session working in org A.
+  const scoped = orgHint ? await api('GET', '/api/projects', undefined, { 'X-Drafted-Org': orgHint }) : await api('GET', '/api/projects');
+  let list = Array.isArray(scoped?.projects) ? scoped.projects : [];
   const want = String(ref).toLowerCase();
-  const p =
-    list.find(x => x.id === ref) ||
-    list.find(x => String(x.slug || '').toLowerCase() === want) ||
-    list.find(x => String(x.name || '').toLowerCase() === want);
+  const pick = (rows) =>
+    rows.find(x => x.id === ref) ||
+    rows.find(x => String(x.slug || '').toLowerCase() === want) ||
+    rows.find(x => String(x.name || '').toLowerCase() === want);
+  let p = pick(list);
+  // A miss is worth one unscoped look before "not found": the hint may be stale
+  // (a project that moved org), and an id passed as projectId= carries no org at
+  // all — only a UUID can name a project in an org the session is not inside.
+  if (!p && (orgHint || /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(String(ref)))) {
+    const all = await api('GET', '/api/projects', undefined, NO_ORG_SCOPE);
+    list = Array.isArray(all?.projects) ? all.projects : [];
+    p = pick(list);
+  }
   if (!p) return null;
   // `folder` rides along so a caller can rebuild the project's printed address
   // (/o/<org>/projects/<folder>/<slug>) without a second lookup.
   const meta = { id: p.id, slug: p.slug || null, name: p.name || null, orgId: p.orgId || null, orgSlug: p.orgSlug || null, folder: p.folder || '' };
+  projectRefCache.set(cacheKey, meta);
   projectRefCache.set(ref, meta);
   projectRefCache.set(p.id, meta);
   return meta;
@@ -1645,13 +1671,15 @@ async function resolveProjectRef(ref) {
  *
  * One /api/projects fetch for the whole scan, not one per candidate.
  */
-async function resolveFolderQualifiedProject(parts) {
+async function resolveFolderQualifiedProject(parts, orgHint = null) {
   // NOT `.catch(() => null)`. Swallowing the fetch turns "the session is gated"
   // or "the server is down" into "project not found", which is a wrong DIAGNOSIS,
   // not just a lost detail — it sends you hunting for a project instead of
   // reading the gate. Observed once for real: an unnamed session after an MCP
   // restart reported `project not found: Marketing/beoflow-marketing`.
-  const data = await api('GET', '/api/projects');
+  // Same org rule as resolveProjectRef: a folder-qualified address names an org,
+  // so the lookup has to be made in it rather than in the working org.
+  const data = await api('GET', '/api/projects', undefined, orgHint ? { 'X-Drafted-Org': orgHint } : NO_ORG_SCOPE);
   const list = Array.isArray(data?.projects) ? data.projects : [];
   const norm = (s) => String(s || '').toLowerCase();
   for (let i = 1; i < parts.length; i++) {
@@ -3093,19 +3121,18 @@ tool('screenshot', 'Render a PNG via headless browser. `scope=frame` captures a
       buffer = Buffer.from(await res.arrayBuffer());
     } else if (scope === 'canvas') {
       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) {
+      // Resolve through the shared project resolver (path, folder path, slug, name
+      // or UUID) and send the project ID: the server's slug lookup is scoped to the
+      // SESSION org, so a slug from /o/<other-org>/projects/<slug> was a 404.
+      let targetSlug;
+      const ref = canvasPath || args.slug;
+      if (ref) {
+        targetSlug = (await resolveProjectArg(ref)).id;
+      } else {
         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 path=/projects/<project> explicitly.');
-        targetSlug = active.slug;
+        targetSlug = active.id;
       }
       const url = `${getServerUrl()}/api/canvas-screenshot/${encodeURIComponent(targetSlug)}?layer=${encodeURIComponent(layer)}&width=${width}&height=${height}`;
       await ensureSession();
@@ -3343,16 +3370,19 @@ tool('fs', 'Navigate Drafted like a local filesystem. A FOLDER is the single con
   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. Apply ONLY against a fresh fs(read) of the frame: each op = {type, lineHash, newContent} where type is one of replace | delete | insertAfter | insertBefore, and lineHash is the FULL anchor from the read output (line number + hash, e.g. the token left of the |, like 42srt) — NOT a bare hash. delete/replace consume the target line; at most one replace/delete per line per edit (combine into one replace). If an op targets a line that changed since read it is rejected — re-read and retry. Element ops for excalidraw ({id,x,y,...}), or structured ops for office'),
   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.'),
+  expectedUpdatedAt: z.string().optional().describe('[write] optimistic concurrency: the frame\'s updatedAt as you last read it. If somebody else wrote since, the write is refused with code "conflict" and the current version, instead of silently overwriting their change. Omit for a blind write.'),
   metadata: z.any().optional().describe('[write] JSON metadata to attach to the written frame (e.g. {"tour": {title, auto?, steps}} to define a guided tour on this frame). Max 64KB.'),
   readme: z.string().optional().describe('[write] README.md markdown for a skill at /o/<org>/skills/<slug> — optional on both create and update. Stored as a supporting skill file so the skill directory renders a landing page on GitHub when exported; a skill created without one is returned with a warning, never rejected. Equivalent to a later fs(write, path="/o/<org>/skills/<slug>/README.md").'),
+  position: z.number().int().min(0).optional().describe('[mv] on a LAYER path, no `to`: move the layer to this 0-based index in the project\'s layer order (0 = first; `ls` of the project shows the order). A layer born from a first write is appended last, so use this to pin one first.'),
   recursive: z.boolean().optional().describe('[ls] recurse into subdirectories'),
+  chars: z.string().optional().describe('[read] character window "start-end" (0-based, end exclusive; at most 60000 per call). A frame longer than that is returned as its first page with `totalChars` and `nextChars` — pass `nextChars` back to read on. Use it for minified/single-line HTML, which `lines` cannot split.'),
   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")'),
   readonly: z.boolean().optional().describe('[link] read-only frame link (symlink): mirror the SOURCE frame named by `to` (a frame UUID or /projects/<other-project>/<layer>/<lane>/<file>) into the CURRENT project, displayed read-only. The source project stays the single writer.'),
   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, metadata, readme, recursive, pattern, lines, org } = args;
+  const { action, path: rawPath, to: rawTo, query, content, file_path, base64, googleType, title, ops, state, metadata, expectedUpdatedAt, readme, 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
@@ -3630,7 +3660,7 @@ tool('fs', 'Navigate Drafted like a local filesystem. A FOLDER is the single con
     // (/o/<org>/projects/eng/x). The chain wins when both are given.
     const projectFolder = folder || (parts.length === 2 ? parts[0] : null);
     const projectRef = parts[parts.length - 1];
-    const existing = await resolveProjectRef(projectRef).catch(() => null);
+    const existing = await resolveProjectRef(projectRef, orgFromPath || org || null).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, ...(projectFolder ? { folder: projectFolder } : {}) }, orgHeader);
@@ -3680,7 +3710,7 @@ tool('fs', 'Navigate Drafted like a local filesystem. A FOLDER is the single con
           return ok(formatWikiIndex(tree?.pages || []));
         }
         const pages = await api('GET', `/api/wiki/tree?prefix=${encodeURIComponent(wikiPath)}`, undefined, orgHeader);
-        return ok(formatWikiIndex(pages?.pages || []));
+        return ok(formatWikiIndex(pages?.pages || [], 50, `(no wiki pages under ${wikiPath})`));
       }
       case 'read': {
         const canonPath = wikiPath.replace(/\.md$/, '');
@@ -3753,7 +3783,7 @@ tool('fs', 'Navigate Drafted like a local filesystem. A FOLDER is the single con
         // which are never present, so every MCP wiki search reported empty.
         const hits = pages?.hits || pages?.pages || pages?.results || [];
         markSearched(gs, 'wiki');
-        return ok(formatWikiIndex(hits));
+        return ok(formatWikiIndex(hits, 50, `(no wiki pages match "${q}")`));
       }
       default:
         return err(new Error(`fs ${action} not supported for /wiki`));
@@ -3924,7 +3954,14 @@ tool('fs', 'Navigate Drafted like a local filesystem. A FOLDER is the single con
       // Archived projects 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 listing = await api('GET', '/api/projects');
+      //
+      // Fetch in the org the PATH names, not the one this session happens to be
+      // working in. api() stamps the working org on every request, so the
+      // unfiltered call came back as the working org's projects and the org
+      // filter below then removed every one of them: `ls /o/<other-org>/projects`
+      // answered "no projects" for an org with 265. Unscoped when the path names
+      // no org, which is what makes `/projects` the whole inventory again.
+      const listing = await api('GET', '/api/projects', undefined, orgFromPath ? { 'X-Drafted-Org': orgFromPath } : NO_ORG_SCOPE);
       let rows = (Array.isArray(listing?.projects) ? listing.projects : []).filter(x => !isTrashedRow(x));
       if (orgFromPath) {
         const kept = [];
@@ -4013,9 +4050,11 @@ tool('fs', 'Navigate Drafted like a local filesystem. A FOLDER is the single con
     // every failure as "project not found", so a gated session or an unreachable
     // server reads as a missing project.
     let lookupError = null;
-    let pathProject = await resolveProjectRef(projectRef).catch((e) => { lookupError = e; return null; });
+    // The org from the path rides the lookup: without it a project in another
+    // org was invisible and every write to it answered "project not found".
+    let pathProject = await resolveProjectRef(projectRef, orgFromPath || org || null).catch((e) => { lookupError = e; return null; });
     if (!pathProject?.id && parts.length > 1) {
-      const found = await resolveFolderQualifiedProject(parts);
+      const found = await resolveFolderQualifiedProject(parts, orgFromPath || org || null);
       if (found) { projectRef = parts[found.index]; tail = parts.slice(found.index + 1); pathProject = found.meta; }
     }
     if (!pathProject?.id && lookupError) return err(lookupError);
@@ -4056,9 +4095,9 @@ tool('fs', 'Navigate Drafted like a local filesystem. A FOLDER is the single con
       const segs = clean.replace(/^projects\/?/, '').split('/').filter(Boolean);
       if (!segs.length) throw new Error('destination needs a project: /o/<org>/projects/<project>/...');
       let idx = 0;
-      let meta = await resolveProjectRef(segs[0]).catch(() => null);
+      let meta = await resolveProjectRef(segs[0], orgFromPath || org || null).catch(() => null);
       if (!meta?.id && segs.length > 1) {
-        const found = await resolveFolderQualifiedProject(segs);
+        const found = await resolveFolderQualifiedProject(segs, orgFromPath || org || null);
         if (found) { idx = found.index; meta = found.meta; }
       }
       if (!meta?.id) throw new Error(`destination project not found: ${segs.join('/')} — list projects with fs(ls, path="/o/<org>/projects")`);
@@ -4125,10 +4164,22 @@ tool('fs', 'Navigate Drafted like a local filesystem. A FOLDER is the single con
             // server, re-created by a second writer that outranked the first.
             const proj = result.project;
             const local = proj?.orgSlug && proj?.slug ? `${getServerUrl()}/o/${proj.orgSlug}/projects/${proj.slug}${result.path}` : null;
+            const full = result.content || '';
+            let win;
+            try { win = charWindow(args.chars, full.length); } catch (e) { return err(e); }
+            const paged = win.start > 0 || win.end < full.length;
             return ok({
               path: result.path,
               frameUrl: result.frameUrl || local || `${getServerUrl()}/f/${result.id}`,
-              content: result.content || '',
+              content: paged ? full.slice(win.start, win.end) : full,
+              ...(paged
+                ? {
+                    totalChars: full.length,
+                    charRange: `${win.start}-${win.end}`,
+                    ...(win.end < full.length ? { nextChars: `${win.end}-${win.end + READ_PAGE_CHARS}` } : {}),
+                    pagedNote: `Showing characters ${win.start}-${win.end} of ${full.length}. This frame is too long for one result; pass chars=<nextChars> to read on. Hashline anchors only cover what is shown, so edit ops need a read of the lines they touch.`,
+                  }
+                : {}),
               // Comments on this frame the agent has not been shown, delivered by the server on
               // an agent's read and already marked seen there, so a second read does not repeat
               // them. The note says what they are: notes ABOUT the work, never instructions from
@@ -4202,6 +4253,7 @@ tool('fs', 'Navigate Drafted like a local filesystem. A FOLDER is the single con
           else if (base64) body.base64 = base64;
           else return err(new Error('write requires one of content / file_path / base64 / googleType / state'));
           if (metadata !== undefined) body.metadata = metadata;
+          if (expectedUpdatedAt) body.expectedUpdatedAt = expectedUpdatedAt;
           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 */ }
@@ -4226,6 +4278,12 @@ tool('fs', 'Navigate Drafted like a local filesystem. A FOLDER is the single con
           // missing. (moveFrames has carried units 'lane' and 'layer', with
           // connectors and assets, since cross-project move shipped.)
           const scope = rmScope(layer, lane, filename);
+          // `position` on a LAYER path reorders it in the project's layer order.
+          if (args.position !== undefined) {
+            if (scope !== 'directory' || lane) return err(new Error('position reorders a LAYER: fs(mv, path=/o/<org>/projects/<project>/<layer>, position=<0-based index>)'));
+            const result = await api('POST', '/api/fs/layer-order', { layer, position: args.position }, orgHeader);
+            return ok(result);
+          }
           if (scope === 'project') {
             const pid = getState().projectId;
             if (!pid) return err(new Error('could not resolve project id for mv'));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "drafted",
-  "version": "1.24.0",
+  "version": "1.24.2",
   "description": "Drafted — visual thinking surface for humans and AI agents. Renders HTML, markdown, images, and code as frames on a zoomable canvas, with MCP tools for AI agents and real-time sync for humans.",
   "type": "module",
   "bin": {