drafted 1.22.10 → 1.23.0

package/cli/drafted.mjs

@@ -1962,7 +1962,7 @@ skillCmd
     let id = opts.id;
     let slug = opts.slug;
     if (!id && opts.slug) {
-      const lookup = await authFetch(`${server}/api/skills/slug/${encodeURIComponent(opts.slug)}`, { headers: orgHeaders });
+      const lookup = await authFetch(`${server}/api/skills/slug/${encodeURIComponent(opts.slug)}?lookup=1`, { headers: orgHeaders });
       if (!lookup.ok) { emitSkillResult(opts.format, { status: 'unresolvable', error: `slug ${opts.slug}: HTTP ${lookup.status}` }); process.exit(1); }
       const lj = await lookup.json().catch(() => ({}));
       id = lj.id; slug = lj.slug;
@@ -1988,7 +1988,7 @@ skillCmd
       } else if (forkRes.status === 409) {
         // Org already owns a copy of this slug — update that one (still "forked").
         const ownSlug = data.slug || slug;
-        const own = await authFetch(`${server}/api/skills/slug/${encodeURIComponent(ownSlug)}`, { headers: orgHeaders });
+        const own = await authFetch(`${server}/api/skills/slug/${encodeURIComponent(ownSlug)}?lookup=1`, { headers: orgHeaders });
         if (!own.ok) { emitSkillResult(opts.format, { status: 'error', error: `resolve existing fork ${ownSlug}: HTTP ${own.status}` }); process.exit(1); }
         forkId = (await own.json().catch(() => ({}))).id;
       } else {
@@ -2016,7 +2016,7 @@ async function checkOneSkill(ref, org) {
   const loadUrl = UUID_RE.test(idOrSlug)
     ? `${server}/api/skills/${idOrSlug}`
     : `${server}/api/skills/slug/${encodeURIComponent(idOrSlug)}`;
-  const res = await authFetch(loadUrl, { headers: orgHeaders });
+  const res = await authFetch(`${loadUrl}?lookup=1`, { headers: orgHeaders });
   if (res.status === 404 || res.status === 403) return { ref, slug: '', hash: '', status: 'unresolvable', error: await unresolvableReason(res, org) };
   if (!res.ok) return { ref, slug: '', hash: '', status: 'error', error: `HTTP ${res.status}` };
   const skill = await res.json();
@@ -2092,7 +2092,7 @@ skillCmd
 async function resolveSkillId(opts, server, orgHeaders) {
   if (opts.id) return opts.id;
   if (!opts.slug) return null;
-  const lookup = await authFetch(`${server}/api/skills/slug/${encodeURIComponent(opts.slug)}`, { headers: orgHeaders });
+  const lookup = await authFetch(`${server}/api/skills/slug/${encodeURIComponent(opts.slug)}?lookup=1`, { headers: orgHeaders });
   if (!lookup.ok) return null;
   return (await lookup.json().catch(() => ({}))).id || null;
 }

package/mcp/server.mjs

@@ -440,7 +440,7 @@ BREADCRUMBS: When a frame you write or read corresponds to a file in the user's
 
 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 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.
+  - 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 does not enforce reading anchored frames (it does enforce anchored SKILLS: a write is refused with 428 anchor_gate until you have read them), so read them proactively to avoid wasted work.
 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.`,
@@ -2099,34 +2099,6 @@ async function orgEcho(result, explicitOrg) {
   } catch { return {}; }
 }
 
-async function getOrgSkills(orgId) {
-  if (!orgId) return [];
-  // No cache: gate freshness > the ~5ms HTTP roundtrip. Otherwise an attach
-  // performed mid-session won't take effect until the cached [] expires.
-  try {
-    const result = await api('GET', `/api/orgs/${orgId}/skills`);
-    return Array.isArray(result?.skills) ? result.skills : [];
-  } catch { return []; }
-}
-
-// Sum the per-project priming content (attached skill bodies + project anchor
-// bodies) so deposits can be capped against the per-project context budget (G4/G5).
-async function getProjectPrimingSize(projectId) {
-  if (!projectId) return 0;
-  let total = 0;
-  try {
-    const { skills = [] } = (await api('GET', `/api/projects/${projectId}/skills`)) || {};
-    for (const s of skills) {
-      try { const full = await api('GET', `/api/skills/${s.id}`); total += (full?.content || '').length; } catch { /* skip */ }
-    }
-  } catch { /* skills unavailable */ }
-  try {
-    const anchored = await api('GET', `/api/designs/anchored?projectId=${projectId}`);
-    for (const a of (Array.isArray(anchored) ? anchored : [])) total += (a?.content || '').length;
-  } catch { /* anchors unavailable */ }
-  return total;
-}
-
 // Best-effort size (chars) of a frame's content by path / URL / id — for the
 // anchor deposit cap. Returns 0 if it can't be read (cap then allows).
 async function getFrameContentSize(path) {
@@ -2145,19 +2117,6 @@ async function getFrameContentSize(path) {
   } catch { return 0; }
 }
 
-async function checkOrgSkills(orgId, operation) {
-  if (!orgId) return null;
-  const skills = await getOrgSkills(orgId);
-  if (skills.length === 0) return null;
-  const loaded = getSessionState().loadedSkillIds;
-  const unloaded = skills.filter(s => !loaded.has(s.id));
-  if (unloaded.length === 0) return null;
-  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.`;
-}
-
 // ── Wiki helpers ─────────────────────────────────────────────────
 
 function normalizeWikiPath(input) {
@@ -3371,7 +3330,7 @@ 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, attached-skill gates fire on mutations, anchored frames must be read before editing a layer, `.skillinstall/` is stripped on skill push.', {
+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.', {
   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'),
@@ -3662,7 +3621,7 @@ tool('fs', 'Navigate Drafted like a local filesystem. A FOLDER is the single con
     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);
+    const created = await api('POST', '/api/projects', { name: projectName, ...(projectFolder ? { folder: projectFolder } : {}) }, orgHeader);
     if (!created?.id) return err(new Error('project create returned no id'));
     if (projectFolder) {
       try { await api('PATCH', `/api/project/${created.id}`, { folder: projectFolder }, orgHeader); } catch { /* folder best-effort */ }
@@ -3782,7 +3741,7 @@ tool('fs', 'Navigate Drafted like a local filesystem. A FOLDER is the single con
         // A specific slug is a targeted ls: the skill's directory — SKILL.md
         // plus its supporting files, so a README is discoverable.
         if (slug) {
-          const s = await api('GET', `/api/skills/slug/${slug}`, undefined, orgHeader).catch(() => null);
+          const s = await api('GET', `/api/skills/slug/${slug}?lookup=1`, undefined, orgHeader).catch(() => null);
           if (!s) return ok([]);
           const listed = await api('GET', `/api/skills/${s.id}/files`, undefined, orgHeader).catch(() => null);
           const files = (listed?.files || []).map((f) => f.path || f).filter((f) => f !== 'SKILL.md');
@@ -3795,7 +3754,7 @@ tool('fs', 'Navigate Drafted like a local filesystem. A FOLDER is the single con
       case 'read': {
         if (!slug) return err(new Error('read /skills/<slug>'));
         if (!isSkillMd) {
-          const owner = await api('GET', `/api/skills/slug/${slug}`, undefined, orgHeader).catch(() => null);
+          const owner = await api('GET', `/api/skills/slug/${slug}?lookup=1`, undefined, orgHeader).catch(() => null);
           if (!owner?.id) return err(new Error(`no Drafted-authored skill "${slug}" — supporting files exist only for skills stored in Drafted; a repo-indexed skill lives in git (read its SKILL.md with fs(read, path="/skills/${slug}"))`));
           const f = await api('GET', fileUrl(owner.id), undefined, orgHeader).catch(() => null);
           if (f?.content == null) return err(new Error(`file not found in skill ${slug}: ${filePath} (fs(ls, path="/skills/${slug}") lists what is there)`));
@@ -3818,7 +3777,7 @@ tool('fs', 'Navigate Drafted like a local filesystem. A FOLDER is the single con
           try { text = textFromLocalFile(file_path); } catch (e) { return err(e); }
         }
         if (!text) return err(new Error('write /skills/<slug> requires content or file_path'));
-        const existing = await api('GET', `/api/skills/slug/${slug}`, undefined, orgHeader).catch(() => null);
+        const existing = await api('GET', `/api/skills/slug/${slug}?lookup=1`, undefined, orgHeader).catch(() => null);
         if (!isSkillMd) {
           // Supporting file inside an existing skill. It can't create the skill —
           // the skill row is what owns the file — so say what call does.
@@ -3858,7 +3817,7 @@ tool('fs', 'Navigate Drafted like a local filesystem. A FOLDER is the single con
         return ok(result);
       }
       case 'rm': {
-        const s = await api('GET', `/api/skills/slug/${slug}`, undefined, orgHeader);
+        const s = await api('GET', `/api/skills/slug/${slug}?lookup=1`, undefined, orgHeader);
         if (!s?.id) return err(new Error(`skill not found: ${slug}`));
         if (!isSkillMd) return ok(await api('DELETE', fileUrl(s.id), undefined, orgHeader));
         return ok(await api('DELETE', `/api/skills/${s.id}`, undefined, orgHeader));

package/package.json

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

package/plugin/commands/create-project.md

@@ -14,7 +14,7 @@ Search before creating (also satisfies the gates):
 Then:
 - Create the project — a project is a folder: `fs(mkdir, path="/o/<org>/projects/<name>")`. It starts with **no layers**; you define them by writing into them.
 - `fs(write, path="/o/<org>/projects/<name>/<layer>/<lane>/brief.md", content=...)` a real brief at the earliest layer (goal, audience, constraints — 6-12 lines, not a placeholder). The layer + lane auto-create.
-- Attach the relevant skills you found via the skill gates.
+- Attach the relevant skills you found; anchor any that agents must read before they write.
 - `fs(ls, path="/o/<org>/projects/<name>")` to confirm the structure, and hand the user the `projectUrl` from the response.
 
 For a **template**: build the layer structure + anchored guidance, then note how to fork it next time. Don't speculatively fill downstream frames — wait for direction.

package/plugin/commands/improve-project-harness.md

@@ -7,10 +7,10 @@ When the user had to correct the work in this project, codify the correction so
 
 1. Identify the recurring correction(s) or standing rule from this session.
 2. Choose the right Drafted-side gate per correction (each counts toward the project's context budget):
-   - **Project anchor** — a brief, constraint, or style guide that must be in context project-wide: `fs(write, path="/o/<org>/projects/<project>/<layer>/<lane>/<file>", content=...)` it, then anchor it so it surfaces on open. [G5]
-   - **Attached skill** — a procedure that must be loaded before work: `/drafted:create-skill` (or `fs(search, path="/o/<org>/skills", ...)` for an existing one), then attach it to the project. [G4]
-   - **Layer rule** — a standing instruction for one stage: set that layer's rules so work in it is gated. [G6]
+   - **Project anchor** — a brief, constraint, or style guide that must be in context project-wide: `fs(write, path="/o/<org>/projects/<project>/<layer>/<lane>/<file>", content=...)` it, then anchor it so it is listed as suggested reading (not enforced). [G5]
+   - **Attached skill** — a procedure that must be loaded before work: `/drafted:create-skill` (or `fs(search, path="/o/<org>/skills", ...)` for an existing one), then ask the user to anchor it to the project (Skills view > Anchoring, effect Enforce; an agent cannot do this itself, and attaching a skill alone does not gate). Writes in that scope are then refused until the skill is read. [G4]
+   - **Layer rule** — a standing instruction for one stage: set that layer's rules (an AGENTS.md in the layer) so they are surfaced when work happens there. [G6]
 3. Propose which mechanism for each correction, confirm with the user, then apply.
-4. Confirm what is now enforced — the next session in this project will be gated on it automatically.
+4. Confirm what is now enforced — only an anchored skill gates writes; a project anchor and a layer rule do not.
 
 Keep within the project's context budget — if a deposit would exceed it, tighten existing gates instead of piling on.

package/plugin/commands/onboard-drafted.md

@@ -7,7 +7,7 @@ Onboard the user to Drafted — a producibles harness that compounds across thre
 
 This is the over-arching prime command: orient, then seed all three stores so every later session starts smart.
 
-1. **Orient** — in 3-4 lines explain the loop: you *prime* from the harness (the system makes you search the wiki, and auto-loads the project's attached skills, anchors, and layer rules before you work), you *build*, then you *compound* (deposit what you learned). The more it's used, the less searching and the more stable the work. Drafted is navigated like a filesystem — one `fs` tool, three roots: `/wiki`, `/skills`, `/projects`.
+1. **Orient** — in 3-4 lines explain the loop: you *prime* from the harness (the system makes you search the wiki, and refuses a write until you have read the skills anchored to where you are working), you *build*, then you *compound* (deposit what you learned). The more it's used, the less searching and the more stable the work. Drafted is navigated like a filesystem — one `fs` tool, three roots: `/wiki`, `/skills`, `/projects`.
 2. **Name the org** — the org is an address, not a cursor: address wiki/skills with `org=...` on the call, and projects self-derive their org from the path. Never rely on an "active" org: a project-less create by a multi-org user is refused rather than guessed.
 3. **Find the work (ask first).** Make your first question permission, offering three scopes, narrowest first: (a) "tell me what you're working on this week" (nothing is read), (b) one folder they point you to, (c) recent files plus their inbox, Drive and calendar. Option (c) needs `gws` signed in; check it as the `drafted` skill's *Source material from Google* section describes, and if it isn't, offer `! drafted google-setup`. Say plainly what stays on their machine (everything you read) and what reaches Drafted (only what they pick). Read headers before bodies. Then write one frame, **Your work, mapped**: the 3-7 strongest candidates for a Drafted project, each with why it fits (many artifacts, several people, a recurring process, a decision to make), its source links, and the project it would become. Let the user pick.
 4. **Seed knowledge** — run the `/drafted:ingest` flow: help the user point at existing business materials (folders, docs, past research, the sources behind the candidate they picked) or interrogate them for tacit knowledge, and land durable pages in the wiki.

package/plugin/skills/drafted/SKILL.md

@@ -31,7 +31,7 @@ Verbs: `ls` (list) · `read` (cat, hashline-annotated) · `write` (create/overwr
 
 ## The loop — prime → build → compound
 
-- **Prime (session start).** Pull accumulated value in. The system *enforces* this: you must search the wiki before working (G1), and a project's attached skills and anchored frames are required reading when you open it. Don't fight the gates — they make you start smart.
+- **Prime (session start).** Pull accumulated value in. The system *enforces* this: you must search the wiki before working (G1), and the skills anchored to an org, folder or project must be read before you change content there (a refused write returns HTTP 428 `anchor_gate` with the rule text; read the skill, then retry). Don't fight the gates — they make you start smart.
 - **Build (the work).** Produce artifacts as frames on the surface.
 - **Compound (session end / when you notice something).** Deposit learning back: capture knowledge, distill or fix a skill, harden the project. This is *your* responsibility — the system can't force it, so do it.
 
@@ -42,8 +42,8 @@ These reset every session. A gate that blocks you tells you exactly what to call
 - **G1 — wiki search before work.** Before reading or editing anything, `fs(search, path="/o/<org>/wiki", query="<terms>")` for relevant org knowledge.
 - **G2 — prior-art before a new skill.** Writing a new `/o/<org>/skills/<slug>` requires `fs(search, path="/o/<org>/skills", query="<topic>")` first.
 - **G3 — prior-art before a new project.** Creating a project requires wiki + skill searches first.
-- **G4 — attached skills** are auto-injected when you open a project. Follow them — they're how the org does this work.
-- **G5 — the project's anchored frames** are required reading (briefs, constraints, style guides).
+- **G4 — anchored skills** gate every content write (frames, wiki pages, skills) in the scope they are anchored to: an org, a folder or a project. The refusal (HTTP 428 `anchor_gate`) carries the rule text and the `fs(read)` path of each skill; read them, then retry. Editing a skill re-arms the gate. They are how the org does this work.
+- **G5 — the project's anchored frames** are suggested reading (briefs, constraints, style guides). The server does not enforce them.
 - **G6 — a layer's rules** are surfaced when you work in that layer. Honor them.
 
 ## The commands (when to reach for each)

package/src/shared/anchor-scope.mjs

@@ -0,0 +1,98 @@
+/**
+ * Anchored skills: which scope does an fs-style path address?
+ *
+ * Pure, no I/O. The root keyword is the separator (see folder-path.mjs), so the
+ * folder chain and the gate surface both fall out of one split:
+ *
+ *   /o/acme/eng/backend/projects/api/designs/default/x.html
+ *     -> surface 'projects', folder 'eng/backend', project 'api'
+ *   /wiki/eng/foo        -> surface 'wiki',   folder ''    (the ORG wiki)
+ *   /eng/wiki/foo        -> surface 'wiki',   folder 'eng' (the folder's wiki)
+ *
+ * Gate surfaces follow where the write lands: wiki -> wiki_pages, skills ->
+ * skills, projects AND tasks -> designs rows ('projects'; a task is a frame).
+ * A path that names no root (`/`, `/eng`) is a folder, not content: surface null.
+ *
+ * Id-addressed routes (layout, conflicts, designs/:id) cannot be classified
+ * from a path; they resolve id -> project -> projects.folder and then call
+ * buildScopeChain themselves.
+ */
+import { ROOTS, folderPathError, normalizeFolder, splitFolderScope } from './folder-path.mjs';
+
+const SURFACE_OF_ROOT = { wiki: 'wiki', skills: 'skills', tasks: 'projects', projects: 'projects' };
+
+/**
+ * @returns {{ org: string|null, folder: string, root: string|null, surface: 'projects'|'wiki'|'skills'|null,
+ *             project: string|null, rest: string[], error?: string }}
+ * `project` is the NAME in the path (null for tasks and bare `/projects`): the
+ * caller resolves it to an id. `rest` is what follows the project (projects) or
+ * the root (wiki/skills/tasks).
+ */
+export function classifyPath(path) {
+  let segs = String(path || '').split('/').map((s) => s.trim()).filter(Boolean);
+  let org = null;
+  if (segs[0] === 'o' && segs.length >= 2) {
+    org = segs[1];
+    segs = segs.slice(2);
+  }
+  const { folder, rest } = splitFolderScope('/' + segs.join('/'));
+  const out = { org, folder: normalizeFolder(folder), root: null, surface: null, project: null, rest: [] };
+  if (out.folder) {
+    const bad = folderPathError(out.folder);
+    if (bad) return { ...out, error: bad };
+  }
+  if (!rest) return out;
+  const [root, ...tail] = rest.split('/').filter(Boolean);
+  out.root = root;
+  out.surface = SURFACE_OF_ROOT[root];
+  if (root === 'projects') {
+    out.project = tail[0] || null;
+    out.rest = tail.slice(1);
+  } else {
+    out.rest = tail;
+  }
+  return out;
+}
+
+/**
+ * Both ends of a move. A `to` that names no root is relative to the source
+ * (liftFolderScope does the same), so it gates the same scope. Identical
+ * targets collapse to one; a cross-project move yields two.
+ */
+export function classifyMove(from, to) {
+  const src = classifyPath(from);
+  const dstRaw = to == null ? null : classifyPath(to);
+  const dst = dstRaw && dstRaw.root ? dstRaw : null;
+  const targets = [src];
+  if (dst && !sameTarget(src, dst)) targets.push(dst);
+  return { from: src, to: dst, targets };
+}
+
+function sameTarget(a, b) {
+  return a.surface === b.surface && a.folder === b.folder && a.project === b.project;
+}
+
+/**
+ * The scope chain a write at (folder, projectId) sits inside, outermost first:
+ * org, each folder prefix, then the project. 'eng/backend' -> org, eng, eng/backend.
+ *
+ * @returns {Array<{scope:'org'|'folder'|'project', folder?:string, projectId?:string}>}
+ */
+export function buildScopeChain({ folder = '', projectId = null } = {}) {
+  const chain = [{ scope: 'org', folder: '' }];
+  const segs = normalizeFolder(folder).split('/').filter(Boolean);
+  for (let i = 0; i < segs.length; i++) {
+    chain.push({ scope: 'folder', folder: segs.slice(0, i + 1).join('/') });
+  }
+  if (projectId) chain.push({ scope: 'project', projectId });
+  return chain;
+}
+
+/** Human/receipt form, stored in skill_gate_events.scope_chain. */
+export function formatScopeChain(chain) {
+  return (chain || [])
+    .map((n) => (n.scope === 'org' ? 'org' : n.scope === 'folder' ? n.folder : `project:${n.projectId}`))
+    .join(' > ');
+}
+
+export { ROOTS };