sfora-cli 0.9.0 → 0.11.0

package/README.md

@@ -11,6 +11,7 @@ sfora new "Acme"                          # create a project
 sfora post plan.md --project acme        # push a markdown plan as a post
 sfora task spec.md --project acme         # …or a task on the board
 sfora cat /projects/acme/board/01-todo/0042-fix-login.md
+sfora url /projects/acme/docs/kickoff.md  # where it lives on the web
 ```
 
 Under the hood it maps a Unix view onto sfora's `/v1/fs` HTTP API (a sandboxed
@@ -21,7 +22,9 @@ shell interpreter backs the interactive mode).
 ├── projects/<slug>/posts/<YYYY-MM-DD-title>.md     # published posts  (GET·PUT·DELETE)
 │                  /drafts/<…>.md                   # your drafts      (GET·PUT·DELETE)
 │                  /board/<NN-col>/<NNNN-card>.md   # tasks by column  (GET·PUT·DELETE)
-│                  /docs/<…>.md                     # docs / notes     (GET·PUT·DELETE)
+│                  /library/documents/<…>.md        # docs / notes     (GET·PUT·DELETE)
+│                          /files/<…>                # uploaded files  (GET)
+│                          /repositories/<repo>/…    # source trees     (GET)
 ├── inbox/mentions.md                               # unread mentions  (GET)
 └── me/api-key                                      # your identity    (GET)
 ```
@@ -154,11 +157,11 @@ sfora:/$ cd /projects/general/posts        # cwd persists across commands
 sfora:/projects/general/posts$ exit
 ```
 
-Writing a file `PUT`s it (creating a post or, within the 5-minute edit window,
-updating one you authored). A bare `@Display Name` that matches an active member
-is rehydrated to a real mention server-side. `rm` soft-deletes (author or org
-admin/owner). Drafts live under `…/drafts/`; a `scheduledFor:` in the frontmatter
-schedules auto-publish.
+Writing a post file publishes a new immutable record. Edit mutable work under
+`…/drafts/` and publish only when it is ready; overwriting an existing published
+filename is rejected. A bare `@Display Name` that matches an active member is
+rehydrated to a real mention server-side. `rm` soft-deletes (author or org
+admin/owner). A `scheduledFor:` in draft frontmatter schedules auto-publish.
 
 ## MCP server (Claude Desktop / Cursor)
 
@@ -209,6 +212,144 @@ backend) are the public exports, alongside the lower-level `SforaApiClient`.
 
 ## Supported operations
 
+## Blocks — write one paragraph, not the file
+
+A markdown body is addressable: every top-level block has an id that is a
+fingerprint over its bytes, so `sfora blocks` lists them and
+`sfora put --block <id>` replaces exactly one and leaves every other byte alone.
+
+```bash
+$ sfora blocks /projects/acme/docs/kickoff.md
+kfrontmat  yaml       id: k17e8c0...                         read-only
+k7f3a2cx   heading    # Kickoff                              read-only
+kq8w1zzp   paragraph  The hill chart is the one view that a…
+3 blocks · 1 writable
+https://www.sfora.ai/org/acme/notes/k17e8c0...
+
+$ echo "A rewritten paragraph." | sfora put /projects/acme/docs/kickoff.md --block kq8w1zzp
+✓ Wrote block kq8w1zzp of /v1/fs/projects/acme/library/documents/kickoff.md
+  changed · 3 of 4 block ids kept · 1 moved
+  https://www.sfora.ai/org/acme/notes/k17e8c0...
+  you are visible as editing this document
+```
+
+`read-only` blocks are real lines you can see in the file — the frontmatter
+fence, the title heading — that the write door does not store, so their ids
+address nothing. Aim at a writable one.
+
+**Every write prints what it did.** sfora's write door splices: a PUT of bytes
+that parse the same as the stored ones stores nothing, so `no change — the
+stored bytes already matched` is a real and frequent answer to a
+read-edit-write loop that reformatted more than it meant to. When bytes did
+move, the line says how many block ids survived it.
+
+**A stale id is not an error, it is a re-aim.** Block ids are derived from
+content, so "this id resolves to nothing" means somebody changed that block
+since you read it. The server sends the document's current blocks with the
+refusal, and the CLI prints them:
+
+```
+that block is gone — somebody changed it since you read it
+Block kq8w1zzp is not in this document any more.
+
+the document has these blocks now:
+  k7f3a2cx  line 1  ## Agenda
+  kt2p9lmx  line 3  A rewritten paragraph.
+  kb91xz4q  line 5  ```json
+
+re-aim with: sfora put /projects/acme/docs/kickoff.md --block <id>
+```
+
+The columns differ from `sfora blocks` on purpose. That listing describes what
+a READ serves — frontmatter, the title heading, and `writable` to say which of
+those the write door can reach. This one is what the write door FOUND, which is
+the document's stored body: every id here already resolves, so there is no
+read-only row to mark, and `line` is where in the file to look.
+
+`blocks`, `put` and `url` are also commands **inside the shell**, so the body
+can come from a pipeline:
+
+```text
+sfora:/$ blocks /projects/acme/docs/kickoff.md | grep paragraph
+sfora:/$ sed 's/hill chart/hill/' draft.md | put /projects/acme/docs/kickoff.md --block kq8w1zzp
+```
+
+Writing a document also makes you **visible in it** — the app's avatar stack
+shows you editing, with the block you aimed at. The CLI says so once per run.
+
+## Watch — a document as a channel
+
+`sfora watch` long-polls the workspace and prints every write as it lands. Point
+it at one document, or at a whole project.
+
+```bash
+$ sfora watch /projects/acme/docs/kickoff.md
+watching /projects/acme/docs/kickoff.md (not your own writes) — ^C to stop
+14:22:07 · Ada Lovelace · Kickoff · 4 of 5 block ids kept · https://www.sfora.ai/org/acme/notes/k17e8c0...
+14:24:19 · Dogfood Bot · Kickoff · edited · https://www.sfora.ai/org/acme/notes/k17e8c0...
+
+$ sfora watch acme --json | jq -r 'select(.docType == "note") | .title'
+```
+
+* `--json` writes **NDJSON** — one event per line (schema below).
+* Your own writes are excluded by default; `--self` includes them.
+* `--wait <secs>` sets the per-request long-poll budget (0–50, default 25).
+* Watching a document makes you **visible in it** as a viewer; ^C aborts the
+  open long-poll and retracts you on the way out, rather than leaving a ghost
+  in the avatar stack for 90 seconds. It lands immediately — it does not wait
+  out the `--wait` budget. A second ^C gives up on the retraction and exits
+  now.
+* A dropped connection reconnects with exponential backoff to 30s and resumes
+  from the cursor already reached — no replayed pings, no lost ones.
+
+### The NDJSON schema
+
+Each line is the server's `/v1/events` object, **verbatim** — the CLI reshapes
+nothing, so one parser reads the CLI's stream and the HTTP door's pages alike.
+
+| field | |
+|---|---|
+| `type` | `"doc.write"` or `"doc.delete"` |
+| `ts` | epoch ms — also the cursor value |
+| `docType` | `"note"` · `"post"` · `"card"` |
+| `docId` | the entity id |
+| `projectId` | the project it lives in |
+| `title`, `path` | the document's title and fs path |
+| `url` | the page it can be read on |
+| `author`, `authorId`, `authorType` | who wrote |
+| `changed` | always `true` — a write that changed nothing never pings |
+| `blockIds` | `{ rebound, orphaned, total }` for the version before this write |
+| `deleted` | `doc.delete` only; `blockIds` is then absent |
+| `restricted` | the ping is real, its pointer was withheld — see below |
+
+A **restricted** ping has no `title`, `path` or `url`: the document is somebody's
+unpublished draft. The event is still delivered, because a watch that went
+silent would look connected and be deaf.
+
+Warnings (reconnects) go to stderr, so `--json` stdout stays parseable.
+
+## Links — `sfora url` · `sfora open`
+
+Every workspace thing has a page. The server says where; the CLI prints it.
+
+```bash
+sfora url /projects/acme/library/documents/kickoff.md
+# https://www.sfora.ai/org/acme/notes/k17e8c0...
+
+sfora open /projects/acme/board/02-todo/0042-fix-login.md   # …and opens it
+sfora url /projects/acme/board --json                       # { "path": …, "url": … }
+```
+
+The CLI holds **no route table and no hostname**. It asks for the path you gave
+and reads the link off the answer — a markdown read carries it in the
+`X-Sfora-Url` header, a JSON one in a `url` field — so links stay right when the
+app's routes move, and a dev deployment hands out dev links.
+
+`ls`, `cat` and the write verbs print the same link as one dim line **on
+stderr**, so `sfora cat x.md > x.md` and `sfora ls | wc -l` stay byte-clean.
+Paths with no page of their own (uploaded files, repository trees, your inbox)
+print nothing, and `sfora url` on one says so.
+
 | op | behaviour |
 |----|-----------|
 | `ls`, `readdir` | directory listings via `/v1/fs/projects/…` (cached ~5s) |

package/dist/SforaFs.js

@@ -79,6 +79,15 @@ function classify(path) {
         if (dir === "links.md" && seg.length === 3) {
             return { kind: "linksFile", slug };
         }
+        if (dir === "plan.md" && seg.length === 3) {
+            return { kind: "planFile", slug };
+        }
+        if (dir === "map.md" && seg.length === 3) {
+            return { kind: "mapFile", slug };
+        }
+        if (dir === "asks.md" && seg.length === 3) {
+            return { kind: "asksFile", slug };
+        }
         if (dir === "posts" || dir === "drafts") {
             if (seg.length === 3)
                 return { kind: "postsDir", slug, dir };
@@ -92,6 +101,38 @@ function classify(path) {
             if (seg.length === 4)
                 return { kind: "docFile", slug, filename: seg[3] };
         }
+        if (dir === "artifacts") {
+            if (seg.length === 3)
+                return { kind: "filesDir", slug };
+            if (seg.length === 4)
+                return { kind: "artifactFile", slug, filename: seg[3] };
+        }
+        if (dir === "library") {
+            if (seg.length === 3)
+                return { kind: "libraryDir", slug };
+            if (seg[3] === "documents") {
+                if (seg.length === 4)
+                    return { kind: "docsDir", slug };
+                if (seg.length === 5)
+                    return { kind: "docFile", slug, filename: seg[4] };
+            }
+            if (seg[3] === "files") {
+                if (seg.length === 4)
+                    return { kind: "filesDir", slug };
+                if (seg.length === 5)
+                    return { kind: "artifactFile", slug, filename: seg[4] };
+            }
+            if (seg[3] === "repositories") {
+                if (seg.length === 4)
+                    return { kind: "repositoriesDir", slug };
+                return {
+                    kind: "repositoryPath",
+                    slug,
+                    repository: seg[4],
+                    path: seg.slice(5).join("/"),
+                };
+            }
+        }
         if (dir === "pulls") {
             if (seg.length === 3)
                 return { kind: "pullsDir", slug };
@@ -212,9 +253,45 @@ export class SforaFs {
         return this.#cached(key, async () => {
             const notes = await this.#client.listNotes(slug);
             this.#entrySnapshots.set(`/projects/${slug}/docs`, notes.map((n) => n.filename));
+            this.#entrySnapshots.set(`/projects/${slug}/library/documents`, notes.map((n) => n.filename));
             return notes;
         });
     }
+    #invalidateNotes(slug) {
+        this.#cache.delete(`docs:${slug}`);
+    }
+    #listArtifacts(slug) {
+        return this.#cached(`artifacts:${slug}`, async () => {
+            const artifacts = await this.#client.listArtifacts(slug);
+            const names = artifacts.map((artifact) => artifact.name);
+            this.#entrySnapshots.set(`/projects/${slug}/artifacts`, names);
+            this.#entrySnapshots.set(`/projects/${slug}/library/files`, names);
+            return artifacts;
+        });
+    }
+    #listRepositories(slug) {
+        return this.#cached(`repositories:${slug}`, async () => {
+            const repositories = await this.#client.listRepositories(slug);
+            this.#entrySnapshots.set(`/projects/${slug}/library/repositories`, repositories.map((repository) => repository.dirname));
+            return repositories;
+        });
+    }
+    #repositoryTree(slug, repository) {
+        return this.#cached(`repository-tree:${slug}/${repository}`, async () => {
+            const tree = await this.#client.getRepositoryTree(slug, repository);
+            this.#entrySnapshots.set(`/projects/${slug}/library/repositories/${repository}`, tree.entries.map((entry) => entry.path));
+            return tree;
+        });
+    }
+    async #repositoryEntry(slug, repository, path) {
+        if (!path) {
+            const repositories = await this.#listRepositories(slug);
+            return repositories.some((candidate) => candidate.dirname === repository)
+                ? { kind: "directory" }
+                : undefined;
+        }
+        return (await this.#repositoryTree(slug, repository)).entries.find((entry) => entry.path === path);
+    }
     // ─── pull requests cache (read-only) ─────────────────────────────
     #listPulls(slug) {
         const key = `pulls:${slug}`;
@@ -336,12 +413,14 @@ export class SforaFs {
         const columns = meta.columns
             .slice()
             .sort((a, b) => a.position - b.position);
-        const out = [
-            `# ${project.name} roadmap`,
-            "",
-            `> https://www.sfora.ai/roadmap/${meta.publicSlug}`,
-            "",
-        ];
+        // The share link is the SERVER'S (`publicUrl` off `GET …/board`), not a
+        // hostname glued onto the slug here: which origin a deployment serves its
+        // pages from is the deployment's business, and a CLI pointed at a laptop or
+        // a preview would otherwise quote the production one. An older server that
+        // does not send it leaves the heading and the columns, minus the line.
+        const out = [`# ${project.name} roadmap`, ""];
+        if (meta.publicUrl)
+            out.push(`> ${meta.publicUrl}`, "");
         for (const col of columns) {
             out.push(`## ${col.name}`, "");
             const cards = await this.#listCards(slug, col.dirname);
@@ -381,6 +460,31 @@ export class SforaFs {
                 catch (e) {
                     throw fromApi(e, "open", normalize(path));
                 }
+            case "artifactFile":
+                try {
+                    return await this.#client.readArtifact(loc.slug, loc.filename);
+                }
+                catch (e) {
+                    throw fromApi(e, "open", normalize(path));
+                }
+            case "repositoryPath": {
+                if (!loc.path)
+                    throw eisdir("read", normalize(path));
+                const entry = await this.#repositoryEntry(loc.slug, loc.repository, loc.path);
+                if (!entry)
+                    throw enoent("open", normalize(path));
+                if (entry.kind === "directory")
+                    throw eisdir("read", normalize(path));
+                if (entry.kind === "submodule") {
+                    return `Submodule ${loc.path}\nRepository: ${loc.repository}\n`;
+                }
+                try {
+                    return await this.#client.readRepositoryFile(loc.slug, loc.repository, loc.path);
+                }
+                catch (e) {
+                    throw fromApi(e, "open", normalize(path));
+                }
+            }
             case "pullFile":
                 try {
                     return await this.#client.readPull(loc.slug, loc.number);
@@ -416,6 +520,27 @@ export class SforaFs {
                 catch (e) {
                     throw fromApi(e, "open", normalize(path));
                 }
+            case "planFile":
+                try {
+                    return await this.#client.readPlan(loc.slug);
+                }
+                catch (e) {
+                    throw fromApi(e, "open", normalize(path));
+                }
+            case "mapFile":
+                try {
+                    return await this.#client.readMap(loc.slug);
+                }
+                catch (e) {
+                    throw fromApi(e, "open", normalize(path));
+                }
+            case "asksFile":
+                try {
+                    return await this.#client.readAsks(loc.slug);
+                }
+                catch (e) {
+                    throw fromApi(e, "open", normalize(path));
+                }
             case "root":
             case "projectsDir":
             case "inboxDir":
@@ -423,6 +548,9 @@ export class SforaFs {
             case "projectDir":
             case "postsDir":
             case "docsDir":
+            case "libraryDir":
+            case "filesDir":
+            case "repositoriesDir":
             case "pullsDir":
             case "boardDir":
             case "boardColumnDir":
@@ -449,6 +577,10 @@ export class SforaFs {
         if (loc.kind === "inboxFile" || loc.kind === "meFile") {
             throw eacces("open", norm);
         }
+        // asks.md is a read-only projection — claims go through the asks API.
+        if (loc.kind === "asksFile") {
+            throw eacces("open", norm);
+        }
         if (loc.kind === "linksFile") {
             try {
                 await this.#client.setProjectLinks(loc.slug, toText(content));
@@ -458,6 +590,17 @@ export class SforaFs {
             }
             return;
         }
+        // plan.md: the PUT edits `## the goal` only; the server ignores (and
+        // names) every generated section, so a read-modify-write is always safe.
+        if (loc.kind === "planFile") {
+            try {
+                await this.#client.writePlan(loc.slug, toText(content));
+            }
+            catch (e) {
+                throw fromApi(e, "open", norm);
+            }
+            return;
+        }
         if (loc.kind === "root" ||
             loc.kind === "projectsDir" ||
             loc.kind === "inboxDir" ||
@@ -465,12 +608,21 @@ export class SforaFs {
             loc.kind === "projectDir" ||
             loc.kind === "postsDir" ||
             loc.kind === "docsDir" ||
+            loc.kind === "libraryDir" ||
+            loc.kind === "filesDir" ||
+            loc.kind === "repositoriesDir" ||
             loc.kind === "pullsDir" ||
             loc.kind === "boardDir" ||
             loc.kind === "boardColumnDir" ||
             loc.kind === "publicDir") {
             throw eisdir("open", norm);
         }
+        // map.md is derived from the board and refuses writes server-side (405);
+        // fail locally with the same message so an agent learns the write doors
+        // without a round trip.
+        if (loc.kind === "mapFile") {
+            throw eacces("open", norm);
+        }
         if (loc.kind === "postFile") {
             try {
                 await this.#client.writePost(loc.slug, loc.dir, loc.filename, toText(content));
@@ -481,6 +633,16 @@ export class SforaFs {
             this.#invalidate(loc.slug, loc.dir);
             return;
         }
+        if (loc.kind === "docFile") {
+            try {
+                await this.#client.writeNote(loc.slug, loc.filename, toText(content));
+            }
+            catch (e) {
+                throw fromApi(e, "open", norm);
+            }
+            this.#invalidateNotes(loc.slug);
+            return;
+        }
         if (loc.kind === "boardCardFile") {
             try {
                 const res = await this.#client.writeCard(loc.slug, loc.column, loc.filename, toText(content));
@@ -520,8 +682,14 @@ export class SforaFs {
                 case "projectDir":
                 case "postsDir":
                 case "docsDir":
+                case "libraryDir":
+                case "filesDir":
+                case "repositoriesDir":
                 case "pullsDir":
                 case "boardDir":
+                case "planFile":
+                case "mapFile":
+                case "asksFile":
                     return await this.#projectExists(loc.slug);
                 case "publicDir":
                 case "roadmapFile":
@@ -536,6 +704,10 @@ export class SforaFs {
                         undefined;
                 case "docFile":
                     return (await this.#matchNote(loc.slug, loc.filename)) !== undefined;
+                case "artifactFile":
+                    return (await this.#listArtifacts(loc.slug)).some((artifact) => artifact.name === loc.filename);
+                case "repositoryPath":
+                    return (await this.#repositoryEntry(loc.slug, loc.repository, loc.path)) !== undefined;
                 case "pullFile":
                     return (await this.#matchPull(loc.slug, loc.number)) !== undefined;
                 case "boardCardFile":
@@ -583,12 +755,18 @@ export class SforaFs {
                 case "meFile":
                     return this.#fileStat(new Date());
                 case "linksFile":
+                case "planFile":
+                case "mapFile":
+                case "asksFile":
                     if (!(await this.#projectExists(loc.slug)))
                         throw enoent("stat", norm);
                     return this.#fileStat(new Date());
                 case "projectDir":
                 case "postsDir":
                 case "docsDir":
+                case "libraryDir":
+                case "filesDir":
+                case "repositoriesDir":
                 case "pullsDir":
                 case "boardDir":
                     if (!(await this.#projectExists(loc.slug)))
@@ -625,6 +803,20 @@ export class SforaFs {
                         throw enoent("stat", norm);
                     return this.#fileStat(new Date(note.lastEditedAt || Date.now()));
                 }
+                case "artifactFile": {
+                    const artifact = (await this.#listArtifacts(loc.slug)).find((candidate) => candidate.name === loc.filename);
+                    if (!artifact)
+                        throw enoent("stat", norm);
+                    return this.#fileStat(new Date(artifact.uploadedAt || Date.now()), artifact.size);
+                }
+                case "repositoryPath": {
+                    const entry = await this.#repositoryEntry(loc.slug, loc.repository, loc.path);
+                    if (!entry)
+                        throw enoent("stat", norm);
+                    return entry.kind === "directory"
+                        ? this.#dirStat()
+                        : this.#fileStat(new Date(), "size" in entry ? entry.size ?? 0 : 0);
+                }
                 case "pullFile": {
                     const pull = await this.#matchPull(loc.slug, loc.number);
                     if (!pull)
@@ -683,10 +875,13 @@ export class SforaFs {
                         throw enoent("scandir", norm);
                     }
                     const entries = [
+                        dirent("asks.md", false),
                         dirent("board", true),
-                        dirent("docs", true),
                         dirent("drafts", true),
+                        dirent("library", true),
                         dirent("links.md", false),
+                        dirent("plan.md", false),
+                        dirent("map.md", false),
                         dirent("posts", true),
                         dirent("pulls", true),
                     ];
@@ -696,6 +891,14 @@ export class SforaFs {
                     }
                     return entries;
                 }
+                case "libraryDir":
+                    if (!(await this.#projectExists(loc.slug)))
+                        throw enoent("scandir", norm);
+                    return [
+                        dirent("documents", true),
+                        dirent("files", true),
+                        dirent("repositories", true),
+                    ];
                 case "postsDir": {
                     const entries = await this.#listEntries(loc.slug, loc.dir);
                     return entries.map((e) => dirent(e.filename, false));
@@ -707,6 +910,35 @@ export class SforaFs {
                     const notes = await this.#listNotes(loc.slug);
                     return notes.map((n) => dirent(n.filename, false));
                 }
+                case "filesDir": {
+                    if (!(await this.#projectExists(loc.slug)))
+                        throw enoent("scandir", norm);
+                    return (await this.#listArtifacts(loc.slug)).map((artifact) => dirent(artifact.name, false));
+                }
+                case "repositoriesDir": {
+                    if (!(await this.#projectExists(loc.slug)))
+                        throw enoent("scandir", norm);
+                    return (await this.#listRepositories(loc.slug)).map((repository) => dirent(repository.dirname, true));
+                }
+                case "repositoryPath": {
+                    const current = await this.#repositoryEntry(loc.slug, loc.repository, loc.path);
+                    if (!current)
+                        throw enoent("scandir", norm);
+                    if (current.kind !== "directory")
+                        throw enotdir("scandir", norm);
+                    const prefix = loc.path ? `${loc.path}/` : "";
+                    const children = new Map();
+                    for (const entry of (await this.#repositoryTree(loc.slug, loc.repository)).entries) {
+                        if (!entry.path.startsWith(prefix) || entry.path === loc.path)
+                            continue;
+                        const rest = entry.path.slice(prefix.length);
+                        const [name, ...tail] = rest.split("/");
+                        if (!name)
+                            continue;
+                        children.set(name, tail.length > 0 || entry.kind === "directory");
+                    }
+                    return [...children].map(([name, isDir]) => dirent(name, isDir));
+                }
                 case "pullsDir": {
                     if (!(await this.#projectExists(loc.slug))) {
                         throw enoent("scandir", norm);
@@ -743,9 +975,12 @@ export class SforaFs {
                 case "meFile":
                 case "postFile":
                 case "docFile":
+                case "artifactFile":
                 case "pullFile":
                 case "boardCardFile":
                 case "roadmapFile":
+                case "planFile":
+                case "asksFile":
                     throw enotdir("scandir", norm);
                 default:
                     throw enoent("scandir", norm);
@@ -772,6 +1007,9 @@ export class SforaFs {
             case "projectDir":
             case "postsDir":
             case "docsDir":
+            case "libraryDir":
+            case "filesDir":
+            case "repositoriesDir":
             case "pullsDir":
             case "boardDir":
             case "publicDir":
@@ -858,12 +1096,32 @@ export class SforaFs {
             }
             case "inboxFile":
             case "meFile":
-            case "docFile":
+            case "artifactFile":
+            case "repositoryPath":
             case "pullFile":
             case "roadmapFile":
-                // Read-only surfaces (notes aren't deletable through the fs yet; the
-                // roadmap is a projection; pulls are owned by GitHub).
+            case "planFile":
+            case "asksFile":
+                // Uploaded files and repositories are read-only projections; the
+                // roadmap and pulls are owned by their source systems; the plan and
+                // asks are generated views that can't be unlinked.
                 throw eacces("unlink", norm);
+            case "docFile": {
+                const note = await this.#matchNote(loc.slug, loc.filename);
+                if (!note) {
+                    if (options?.force)
+                        return;
+                    throw enoent("unlink", norm);
+                }
+                try {
+                    await this.#client.deleteNote(loc.slug, loc.filename);
+                }
+                catch (e) {
+                    throw fromApi(e, "unlink", norm);
+                }
+                this.#invalidateNotes(loc.slug);
+                return;
+            }
             case "root":
             case "projectsDir":
             case "inboxDir":
@@ -871,6 +1129,9 @@ export class SforaFs {
             case "projectDir":
             case "postsDir":
             case "docsDir":
+            case "libraryDir":
+            case "filesDir":
+            case "repositoriesDir":
             case "pullsDir":
             case "boardDir":
             case "publicDir":
@@ -982,9 +1243,16 @@ export class SforaFs {
         ]);
         for (const slug of this.#projectSlugs) {
             paths.add(`/projects/${slug}`);
+            paths.add(`/projects/${slug}/plan.md`);
+            paths.add(`/projects/${slug}/asks.md`);
             paths.add(`/projects/${slug}/posts`);
             paths.add(`/projects/${slug}/drafts`);
             paths.add(`/projects/${slug}/docs`);
+            paths.add(`/projects/${slug}/artifacts`);
+            paths.add(`/projects/${slug}/library`);
+            paths.add(`/projects/${slug}/library/documents`);
+            paths.add(`/projects/${slug}/library/files`);
+            paths.add(`/projects/${slug}/library/repositories`);
             paths.add(`/projects/${slug}/pulls`);
             paths.add(`/projects/${slug}/board`);
             // `public/` is only real for boards known to be shared.