drafted 1.23.0 → 1.24.1

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

@@ -20,10 +20,10 @@ import { z } from 'zod';
 import { registerAppResource, RESOURCE_MIME_TYPE } from '@modelcontextprotocol/ext-apps/server';
 import WebSocket from 'ws';
 import { LAYERS } from '../src/shared/constants.mjs';
-import { liftFolderScope, normalizeFolder, rootEntries, subfolderEntries } from '../src/shared/folder-path.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';
 
@@ -3093,19 +3093,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();
@@ -3330,10 +3329,10 @@ server.resource('info', 'drafted://info', {
   };
 });
 
-tool('fs', 'Navigate Drafted like a local filesystem. A FOLDER is the single container and the org is the folder at depth 0: `fs(ls, path="/")` lists the orgs you can address, `/o/<org>` is that org, and every folder level — the org included — carries the SAME four roots:\n\n- `<folder>/wiki/<path>` — knowledge pages (markdown, OKF; free nesting; `index.md` at any level is synthesized and read-only)\n- `<folder>/skills/<slug>` — reusable procedures (flat: one dir per skill slug, `SKILL.md` + supporting files inside; slugs stay unique per ORG, so a skill resolves by slug from anywhere)\n- `<folder>/tasks/<lane?>/<file>` — work items. A task IS a frame: `read` renders its `drafted:status:`/`drafted:assignee:` as front matter and `write`/`edit` parse them back into columns, so they are never stored in the body. `drafted:assignee:` is a REFERENCE: write a member\'s email or userId (look them up with the `members` tool), or `agent:<name>` to assign an agent. A bare name is resolved against members by unique email local-part; an unknown or ambiguous one is REJECTED with the candidate list, never stored as free text. The keys are namespaced so an ordinary `status:` in your own front matter is left alone. Valid statuses: todo, in_progress, in_review, done, canceled -- the Linear set minus Backlog, which this product deliberately does not have (a Backlog column only ever accumulates). The names this system used to store -- open, scheduled, needs_review, needs_decision, failed, backlog -- are still ACCEPTED and normalised (an empty `drafted:status:` clears it). Status is a column, not a location — a task moved out of /tasks stays a task. `read` also projects `drafted:id:` (BEO-42), the org-scoped handle a human says out loud: READ-ONLY and server-allocated, so writing or inventing one is silently dropped rather than stored. Quote it back to the user; it resolves at /o/<org>/t/<id> and survives a rename or a move.\n- `<folder>/projects/<project>/<layer>/<lane>/<file>` — producible frames (then exactly layer → lane → file)\n\nFolders nest arbitrarily: `/o/<org>/engineering/backend/wiki/deploy`. The ROOT KEYWORD IS THE SEPARATOR — everything before `wiki`/`skills`/`tasks`/`projects` is the folder chain, everything after is the path inside that root, so `/o/<org>/wiki/engineering/foo` (the org wiki, nested page) and `/o/<org>/engineering/wiki/foo` (the engineering folder\'s wiki) are different pages. The four names are therefore RESERVED: a folder cannot be called one. `fs(ls, path="/o/<org>/<folder>")` shows a folder\'s four roots plus the folders inside it; `fs(mkdir, path="/o/<org>/<folder>")` creates one.\n\n(Bare `/wiki`, `/skills`, `/tasks`, `/projects` roots still resolve via the session\'s working org, at that org\'s root.)\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 — at THREE scopes, same as `rm`: a FILE path moves one frame; a LANE or LAYER path (`/<layer>/<lane>`, `/<layer>`) moves the whole set in one call, in-project or into another project, carrying frame ids, version history, connectors and assets; a PROJECT path (`/o/<org>/projects/<project>`) renames the project, with `to` as the new display name — the slug and every existing URL stay put), `rm` (delete), `search` (frames are searched by label AND content, with the matching line returned as a snippet; `fs(search, path="/o/<org>")` fans out across wiki + skills + projects in one call. SEARCH MUST NAME ITS ORG — put it in the path, or pass org=. If you belong to more than one org an unaddressed search is REFUSED rather than silently scoped, because "no matches" from one org is indistinguishable from "nowhere" and you would stop looking. Search several orgs with one call each; every result says which org it came from), `link` / `unlink` / `links` (relate one frame to another frame, to a project, or to an external url — `links` lists a frame\'s edges plus its backlinks, and on a project path lists the tasks linked to that project; a link is stored by ID, so `mv` never breaks it). `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, `.skillinstall/` is stripped on skill push. ANCHORED SKILLS are enforced by the server on every content write (frames, wiki pages, skills) in the scope they are anchored to — an org, a folder or a project: a write from a session that has not read them is refused with HTTP 428 `anchor_gate`, and the refusal carries the rule text and the `fs(read)` path of each skill; read them, then retry. Anchored FRAMES are not enforced — they are suggested reading only.', {
+tool('fs', 'Navigate Drafted like a local filesystem. A FOLDER is the single container and the org is the folder at depth 0: `fs(ls, path="/")` lists the orgs you can address, `/o/<org>` is that org, and every folder level — the org included — carries the SAME four roots:\n\n- `<folder>/wiki/<path>` — knowledge pages (markdown, OKF; free nesting; `index.md` at any level is synthesized and read-only)\n- `<folder>/skills/<slug>` — reusable procedures (flat: one dir per skill slug, `SKILL.md` + supporting files inside; slugs stay unique per ORG, so a skill resolves by slug from anywhere)\n- `<folder>/tasks/<lane?>/<file>` — work items. A task IS a frame: `read` renders its `drafted:status:`/`drafted:assignee:` as front matter and `write`/`edit` parse them back into columns, so they are never stored in the body. `drafted:assignee:` is a REFERENCE: write a member\'s email or userId (look them up with the `members` tool), or `agent:<name>` to assign an agent. A bare name is resolved against members by unique email local-part; an unknown or ambiguous one is REJECTED with the candidate list, never stored as free text. The keys are namespaced so an ordinary `status:` in your own front matter is left alone. Valid statuses: todo, in_progress, in_review, done, canceled -- the Linear set minus Backlog, which this product deliberately does not have (a Backlog column only ever accumulates). The names this system used to store -- open, scheduled, needs_review, needs_decision, failed, backlog -- are still ACCEPTED and normalised (an empty `drafted:status:` clears it). Status is a column, not a location — a task moved out of /tasks stays a task. `read` also projects `drafted:id:` (BEO-42), the org-scoped handle a human says out loud: READ-ONLY and server-allocated, so writing or inventing one is silently dropped rather than stored. Quote it back to the user; it resolves at /o/<org>/t/<id> and survives a rename or a move.\n- `<folder>/projects/<project>/<layer>/<lane>/<file>` — producible frames (then exactly layer → lane → file)\n\nFolders nest arbitrarily: `/o/<org>/engineering/backend/wiki/deploy`. The ROOT KEYWORD IS THE SEPARATOR — everything before `wiki`/`skills`/`tasks`/`projects` is the folder chain, everything after is the path inside that root, so `/o/<org>/wiki/engineering/foo` (the org wiki, nested page) and `/o/<org>/engineering/wiki/foo` (the engineering folder\'s wiki) are different pages. The four names are therefore RESERVED: a folder cannot be called one. `fs(ls, path="/o/<org>/<folder>")` shows a folder\'s four roots plus the folders inside it; `fs(mkdir, path="/o/<org>/<folder>")` creates one.\n\n(Bare `/wiki`, `/skills`, `/tasks`, `/projects` roots still resolve via the session\'s working org, at that org\'s root.)\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 — at THREE scopes, same as `rm`: a FILE path moves one frame; a LANE or LAYER path (`/<layer>/<lane>`, `/<layer>`) moves the whole set in one call, in-project or into another project, carrying frame ids, version history, connectors and assets; a PROJECT path (`/o/<org>/projects/<project>`) renames the project, with `to` as the new display name — the slug and every existing URL stay put), `rm` (delete), `search` (frames are searched by label AND content, with the matching line returned as a snippet; `fs(search, path="/o/<org>")` fans out across wiki + skills + projects in one call. SEARCH MUST NAME ITS ORG — put it in the path, or pass org=. If you belong to more than one org an unaddressed search is REFUSED rather than silently scoped, because "no matches" from one org is indistinguishable from "nowhere" and you would stop looking. Search several orgs with one call each; every result says which org it came from), `link` / `unlink` / `links` (ONE link graph across wiki pages, skills, frames, tasks, projects and urls: `link` relates any wiki page, skill or frame to any other node or to a url; `links` on a wiki page, skill or frame lists its edges plus its backlinks from every kind of node, and on a project path lists the tasks linked to that project. Links written IN content are edges too, parsed on every write — markdown links (relative wiki links, or `/o/<org>/...` addresses from any wiki page, skill or frame), HTML `<a href>` addresses, OKF `related:` frontmatter; a bare address in prose is not a link; `unlink` removes only declared ones, so edit the content to drop a written link. A link is stored by ID, so `mv` never breaks it; a link to a page not written yet is stored by path and connects when the page is written). `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, `.skillinstall/` is stripped on skill push. ANCHORED SKILLS are enforced by the server on every content write (frames, wiki pages, skills) in the scope they are anchored to — an org, a folder or a project: a write from a session that has not read them is refused with HTTP 428 `anchor_gate`, and the refusal carries the rule text and the `fs(read)` path of each skill; read them, then retry. Anchored FRAMES are not enforced — they are suggested reading only.', {
   action: z.enum(['ls', 'read', 'write', 'edit', 'mv', 'rm', 'mkdir', 'search', 'link', 'unlink', 'links']).describe('Filesystem verb.'),
   path: z.string().describe('Drafted path: /o/<org>[/<folder…>]/wiki/... | .../skills/... | .../tasks/... | .../projects/... — a folder chain may precede any root (bare /wiki, /skills, /tasks, /projects also work; for mv: source)'),
-  to: z.string().optional().describe('[mv] destination — a frame path for a frame, a container path (/<layer> or /<layer>/<lane>, optionally prefixed /o/<org>/projects/<other-project>/… to move across projects) for a lane or layer, or the NEW NAME when the source path is a project; [link/unlink] target path — a frame path, or a project path (/o/<org>/projects/<project>) to link a task to a project'),
+  to: z.string().optional().describe('[mv] destination — a frame path for a frame, a container path (/<layer> or /<layer>/<lane>, optionally prefixed /o/<org>/projects/<other-project>/… to move across projects) for a lane or layer, or the NEW NAME when the source path is a project; [link/unlink] target path — a wiki page (/o/<org>[/<folder>]/wiki/<page>), a skill (/o/<org>/skills/<slug>), a task, a frame path, or a project path (/o/<org>/projects/<project>) to link a task to a project'),
   url: z.string().optional().describe('[link/unlink] external target URL, instead of `to` (a link is internal-by-id OR external-by-url, never both)'),
   query: z.string().optional().describe('[search] term to match against names/content. The path must name an org (/o/<org>) unless you belong to exactly one.'),
   content: z.string().optional().describe('[write] inline HTML/markdown/text'),
@@ -3345,7 +3344,9 @@ tool('fs', 'Navigate Drafted like a local filesystem. A FOLDER is the single con
   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.'),
   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.'),
@@ -3383,10 +3384,22 @@ tool('fs', 'Navigate Drafted like a local filesystem. A FOLDER is the single con
   // is the folder chain, everything after is the path within that root. The
   // folder rides the REQUEST (X-Drafted-Folder); it is never stored, because a
   // "current folder" would be the retired org cursor rebuilt one level down.
-  const pScope = liftFolderScope(p, to);
+  // link/unlink: a wiki page or skill on EITHER end makes `to` an org-relative
+  // address the server resolves whole, so it keeps its folder chain (linkTo)
+  // and skips the rule that a move stays within one folder. A frame/task source
+  // linking to a frame/task/project still goes through the per-project
+  // resolver, which takes no folder — there the folder rule must stay, or a
+  // cross-folder target silently resolves in the source's folder.
+  const graphRoot = (x) => /^\/(wiki|skills)(\/|$)/.test(splitFolderScope(x).rest || '');
+  const linkTo = (action === 'link' || action === 'unlink') && to && (graphRoot(to) || graphRoot(p)) ? to : null;
+  const pScope = liftFolderScope(p, linkTo ? undefined : to);
   if (pScope.error) return err(new Error(`${action} ${pScope.error}`));
   const folder = pScope.folder;
-  to = pScope.to;
+  to = linkTo ? (splitFolderScope(linkTo).rest || linkTo) : pScope.to;
+  // A wiki page or skill target goes to the server as an org-relative address
+  // (/[<folder>/]wiki/<page>, /skills/<slug>), resolved there by the same
+  // resolver that parses links out of content.
+  const linkToAddress = linkTo && /^\/(wiki|skills)\//.test(splitFolderScope(linkTo).rest) ? linkTo : null;
   const orgHeader = {
     ...(org ? { 'X-Drafted-Org': org } : (orgFromPath ? { 'X-Drafted-Org': orgFromPath } : {})),
     ...(folder ? { 'X-Drafted-Folder': folder } : {}),
@@ -3634,22 +3647,41 @@ tool('fs', 'Navigate Drafted like a local filesystem. A FOLDER is the single con
     return ok({ created: true, name: created.name, slug: created.slug, id: created.id, folder: projectFolder || null, path: `${folderBase}/projects/${createdPath}`, projectUrl: `${getServerUrl()}/o/${created.orgId || org || ''}/projects/${createdPath}` });
   }
 
+  // links / link / unlink with a wiki page or skill as the node: one server
+  // route (/api/links) for both, addressed by org-relative path.
+  const graphAction = async (verb, node) => {
+    if (verb === 'links') {
+      return ok(await api('GET', `/api/links?node=${encodeURIComponent(node)}`, undefined, orgHeader));
+    }
+    if (!args.url && !linkTo) {
+      return err(new Error(`${verb} needs a target: to="<wiki page, skill, task, frame or project path>" or url="https://..."`));
+    }
+    const body = { from: node, ...(args.url ? { url: args.url } : { to: linkTo }) };
+    return ok(await api('POST', verb === 'link' ? '/api/links' : '/api/links/unlink', body, orgHeader));
+  };
+
   // ── 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)) {
+    if (['write', 'edit', 'mv', 'rm', 'link', 'unlink'].includes(action)) {
       await requireBoundOrgForProjectlessMutation(org || orgFromPath);
     }
     switch (action) {
+      case 'links':
+      case 'link':
+      case 'unlink': {
+        if (!wikiPath) return err(new Error(`${action} needs a wiki page: /wiki/<page>`));
+        return graphAction(action, `${folder ? '/' + folder : ''}/wiki/${wikiPath.replace(/\.md$/, '')}`);
+      }
       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 || []));
+        return ok(formatWikiIndex(pages?.pages || [], 50, `(no wiki pages under ${wikiPath})`));
       }
       case 'read': {
         const canonPath = wikiPath.replace(/\.md$/, '');
@@ -3722,7 +3754,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`));
@@ -3733,10 +3765,16 @@ tool('fs', 'Navigate Drafted like a local filesystem. A FOLDER is the single con
   if (p.startsWith('/skills')) {
     const { slug, filePath, isSkillMd } = splitSkillPath(p);
     const fileUrl = (id) => `/api/skills/${id}/files/${filePath.split('/').map(encodeURIComponent).join('/')}`;
-    if (['write', 'mv', 'rm'].includes(action)) {
+    if (['write', 'mv', 'rm', 'link', 'unlink'].includes(action)) {
       await requireBoundOrgForProjectlessMutation(org || orgFromPath);
     }
     switch (action) {
+      case 'links':
+      case 'link':
+      case 'unlink': {
+        if (!slug) return err(new Error(`${action} needs a skill: /skills/<slug>`));
+        return graphAction(action, `${folder ? '/' + folder : ''}/skills/${slug}`);
+      }
       case 'ls': {
         // A specific slug is a targeted ls: the skill's directory — SKILL.md
         // plus its supporting files, so a README is discoverable.
@@ -4088,10 +4126,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
@@ -4189,6 +4239,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'));
@@ -4333,6 +4389,8 @@ tool('fs', 'Navigate Drafted like a local filesystem. A FOLDER is the single con
           }
           if (args.url) {
             body.url = args.url;
+          } else if (linkToAddress) {
+            body.toAddress = linkToAddress;
           } else if (to) {
             // Same destination grammar as mv, through the SAME resolver: a
             // /projects/<...>/<layer>/... path is a frame in another project,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "drafted",
-  "version": "1.23.0",
+  "version": "1.24.1",
   "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": {