agentic-comments 0.5.1 → 0.6.1

package/dist/{chunk-BSNBDKR2.js → chunk-VAVKBAHM.js}

@@ -115,6 +115,7 @@ function onlyOccurrence(type, quote) {
 
 // src/principal.ts
 import { PRINCIPAL_KINDS } from "agentic-identity";
+var ERASED_NAME = "erased";
 var MAX_NAME = 128;
 var issued = /* @__PURE__ */ new WeakSet();
 var Actor = class _Actor {
@@ -131,6 +132,7 @@ var Actor = class _Actor {
     const author = readAuthor(input);
     const given = author ? input.scopes : void 0;
     const scopes = given === void 0 ? [] : Array.isArray(given) ? Array.from(given) : void 0;
+    if (author?.name === ERASED_NAME) throw new CommentsError("INVALID_AUTHOR", `the name "${ERASED_NAME}" is kept for erased authors`);
     if (!author || !scopes || !scopes.every((s) => typeof s === "string" && s !== "")) {
       throw new CommentsError("INVALID_AUTHOR", `an author needs a kind (${PRINCIPAL_KINDS.join(", ")}), a name, and scopes that are a list of text`);
     }
@@ -187,7 +189,7 @@ var MAX_SUMMARY = 1e3;
 var SUGGESTIONS = "comments.suggestions";
 var APPLIED = "comments.suggestion-applied";
 var REJECTED = "comments.suggestion-rejected";
-var decidesOwn = (author, decider) => author.kind !== "human" && decider.kind !== "human" && author.name === decider.name;
+var decidesOwn = (author, decider) => author.name !== ERASED_NAME && author.kind !== "human" && decider.kind !== "human" && author.name === decider.name;
 var clientOf = (text) => /^(0|[1-9]\d{0,9})$/.test(text) && Number(text) <= 4294967295 ? Number(text) : void 0;
 var thenable = (value) => typeof value?.then === "function";
 var Suggestions = class {
@@ -308,6 +310,66 @@ var Suggestions = class {
     if (typeof id2 !== "string" || !ID.test(id2) || !this.map.has(id2)) throw new CommentsError("NO_SUGGESTION", `no suggestion with id ${shown(id2)}`);
     return { id: id2, fields: this.map.get(id2) };
   }
+  /**
+   * The suggestions a person wrote, and the decisions they made, in this document. `unread` counts stored
+   * suggestions and decision records with their name that this export cannot show: a suggestion that cannot
+   * be read, a decision that lost a merge, a refused decision, or a decision with no suggestion. When it is not
+   * 0 the export is not complete. A person may export their own data.
+   */
+  exportPerson(person, actor) {
+    const { match } = this.comments.checkPerson(person, actor);
+    const all = this.list();
+    const authored = all.filter((s) => match(s.author));
+    const decided = all.flatMap((s) => s.decidedBy && s.decidedAt && s.status !== "pending" && match(s.decidedBy) ? [{ id: s.id, status: s.status, at: s.decidedAt }] : []);
+    let found = 0;
+    for (const fields of this.map.values()) if (fields instanceof Y2.Map && this.named(fields.get("author"), match)) found++;
+    for (const map of [this.applied, this.rejected]) for (const raw of map.values()) if (this.named(raw?.by, match)) found++;
+    return { authored, decided, unread: Math.max(0, found - authored.length - decided.length) };
+  }
+  named(value, match) {
+    const author = readAuthor(value);
+    return author !== void 0 && match(author);
+  }
+  /**
+   * Give every suggestion a person wrote a tombstone author and drop its summary. An accepted one keeps its
+   * change, because that change is already part of the content. A pending or rejected one loses its change, and
+   * can no longer be accepted. A decision they made gets a tombstone decider. A decision that a read refuses (a
+   * principal that decided its own work) is deleted, so erase never turns it into a valid one. Returns how many
+   * suggestions and decisions it changed.
+   */
+  erasePerson(person, actor) {
+    const { match } = this.comments.checkPerson(person, actor);
+    const out = { suggestions: 0, decisions: 0 };
+    const authors = /* @__PURE__ */ new Map();
+    for (const [id2, fields] of this.map.entries()) {
+      const author = fields instanceof Y2.Map ? readAuthor(fields.get("author")) : void 0;
+      if (author) authors.set(id2, author);
+    }
+    const status = new Map(this.list().map((s) => [s.id, s.status]));
+    this.ydoc.transact(() => {
+      for (const map of [this.applied, this.rejected]) {
+        for (const [key2, raw] of [...map.entries()]) {
+          const by = readAuthor(raw?.by);
+          const author = authors.get(key2.slice(0, key2.lastIndexOf(":")));
+          if (!by || !(match(by) || author && match(author))) continue;
+          if (author && decidesOwn(author, by)) map.delete(key2);
+          else if (match(by)) {
+            map.set(key2, { ...raw, by: { kind: by.kind, name: ERASED_NAME } });
+            out.decisions++;
+          }
+        }
+      }
+      for (const [id2, author] of authors) {
+        if (!match(author)) continue;
+        const fields = this.map.get(id2);
+        fields.set("author", { kind: author.kind, name: ERASED_NAME });
+        fields.delete("summary");
+        if (status.get(id2) !== "accepted") fields.set("change", null);
+        out.suggestions++;
+      }
+    });
+    return out;
+  }
   /** Propose a change. Anyone can suggest. The host stamps the author. */
   add(input, actor) {
     const who = assertActor(actor);
@@ -335,6 +397,7 @@ var Suggestions = class {
   mayDecide(who, s, verb) {
     const ok = !decidesOwn(s.author, who) && (who.kind === "human" || who.scopes.includes(ACCEPT_SCOPE));
     if (!ok) throw new CommentsError("FORBIDDEN", `${who.kind}:${shown(who.name)} cannot ${verb} this suggestion: a signed-in person, or a principal with the ${ACCEPT_SCOPE} scope that did not write it, can`);
+    if (verb === "accept" && s.author.name === ERASED_NAME && s.status !== "accepted") throw new CommentsError("FORBIDDEN", "an erased suggestion has no change left and cannot be accepted");
   }
   /**
    * Apply the change as the accepting author and record the decision, in one step. Accepting an
@@ -461,6 +524,8 @@ var Suggestions = class {
 
 // src/threads.ts
 import * as Y3 from "yjs";
+var MODERATE_SCOPE = "comments:moderate";
+var ERASED_BODY = "[erased]";
 var THREADS = "comments.threads";
 var MAX_BODY = 1e4;
 var MAX_MENTIONS = 50;
@@ -605,7 +670,20 @@ var Comments = class {
       throw new Error("a message has no id, ISO time, valid author, or body");
     }
     if (!Array.isArray(m.mentions) || m.mentions.length > MAX_MENTIONS || !m.mentions.every(validHandle)) throw new Error("a message has bad mentions");
-    return { id: m.id, at: m.at, author, body: m.body, mentions: [...m.mentions] };
+    const editor = m.editedBy === void 0 ? void 0 : readAuthor(m.editedBy);
+    if (m.editedAt === void 0 !== (m.editedBy === void 0) || m.editedAt !== void 0 && !validDate(m.editedAt) || m.editedBy !== void 0 && !editor) {
+      throw new Error("a message has a bad edit stamp");
+    }
+    if (m.erased !== void 0 && (m.erased !== true || m.body !== ERASED_BODY || author.name !== ERASED_NAME || m.mentions.length > 0)) throw new Error("a message has a bad erased flag");
+    return {
+      id: m.id,
+      at: m.at,
+      author,
+      body: m.body,
+      mentions: [...m.mentions],
+      ...editor ? { editedAt: m.editedAt, editedBy: editor } : {},
+      ...m.erased ? { erased: true } : {}
+    };
   }
   /** A thread with a bad anchor or status is malformed. A bad message is skipped and named in `issues`. */
   read(id2, fields) {
@@ -622,11 +700,32 @@ var Comments = class {
       const raw = list.toArray();
       const counts = /* @__PURE__ */ new Map();
       for (const m of raw) counts.set(m?.id, (counts.get(m?.id) ?? 0) + 1);
+      const parsed = raw.map((entry) => {
+        try {
+          return { message: this.readMessage(entry) };
+        } catch (error) {
+          return { error };
+        }
+      });
+      const copies = (id3) => parsed.flatMap((p) => p.message?.id === id3 ? [p.message] : []);
       let past = 0;
-      raw.forEach((entry, index) => {
+      let superseded = 0;
+      parsed.forEach((entry, index) => {
         try {
-          const message = this.readMessage(entry);
-          if (counts.get(message.id) > 1) throw new Error("a message id repeats");
+          if (entry.error) throw entry.error;
+          const message = entry.message;
+          if (counts.get(message.id) > 1) {
+            const same = copies(message.id);
+            const names = new Set(same.filter((c) => !c.erased).map((c) => c.author.name));
+            const agree = same.every((c) => c.editedAt !== void 0 && c.at === message.at && c.author.kind === message.author.kind) && names.size <= 1;
+            if (same.length !== counts.get(message.id) || !agree) throw new Error("a message id repeats");
+            const rank = (c) => `${c.erased ? 1 : 0}${c.editedAt}${JSON.stringify(c)}`;
+            const best = same.reduce((a, b) => rank(b) > rank(a) ? b : a);
+            if (best !== message) {
+              superseded++;
+              return;
+            }
+          }
           if (messages.length >= READ_LIMIT) past++;
           else messages.push(message);
         } catch (error) {
@@ -636,7 +735,7 @@ var Comments = class {
       if (past > 0) issues.push(`${past} valid messages past the read limit are not shown`);
       if (messages.length === 0) throw new Error("the thread has no valid message");
       const anchor = this.parseAnchor(fields.get("anchor"));
-      const thread = { id: id2, anchor, anchorState: this.anchorState(anchor), status: state.status, statusBy: by, statusAt: state.at, messages, skipped: raw.length - messages.length };
+      const thread = { id: id2, anchor, anchorState: this.anchorState(anchor), status: state.status, statusBy: by, statusAt: state.at, messages, skipped: raw.length - messages.length - superseded };
       return { thread, issues };
     } catch (error) {
       throw new CommentsError("CORRUPT", `thread ${shown(id2)} is malformed: ${safeText(error instanceof Error ? error.message : error)}`);
@@ -715,6 +814,176 @@ var Comments = class {
   reopen(threadId, actor) {
     return this.setStatus(threadId, "open", actor);
   }
+  /** A principal may change what it wrote. A principal with the moderate scope may change what anyone wrote. A tombstone is nobody's. */
+  mayChange(who, message) {
+    return who.scopes.includes(MODERATE_SCOPE) || !message.erased && who.kind === message.author.kind && who.name === message.author.name;
+  }
+  forbid(who, what) {
+    throw new CommentsError("FORBIDDEN", `${who.kind}:${shown(who.name)} cannot ${what}: only its author, or a principal with the ${MODERATE_SCOPE} scope, can`);
+  }
+  /** Replace every stored copy of a message with `next`, or remove it when `next` is undefined. */
+  rewrite(fields, messageId, next) {
+    const list = fields.get("messages");
+    const at = list.toArray().flatMap((m, i) => m?.id === messageId ? [i] : []);
+    this.ydoc.transact(() => {
+      for (const i of [...at].reverse()) list.delete(i, 1);
+      if (next) list.insert(at[0], [copy(next)]);
+    });
+  }
+  find(threadId, messageId) {
+    const { id: id2, fields } = this.fields(threadId);
+    const { thread } = this.read(id2, fields);
+    const message = thread.messages.find((m) => m.id === messageId);
+    if (!message) throw new CommentsError("NO_MESSAGE", `thread ${shown(id2)} has no message with id ${shown(messageId)}`);
+    return { id: id2, fields, thread, message };
+  }
+  /** Change the body of a message. Its author and time stay, and it records who edited it and when. */
+  editMessage(threadId, messageId, input, actor) {
+    const who = assertActor(actor);
+    const given = exact(input, ["body", "mentions"], "an edit");
+    const text = body(given.body);
+    const { id: id2, fields, thread, message } = this.find(threadId, messageId);
+    if (message.erased) throw new CommentsError("FORBIDDEN", "an erased message cannot be edited");
+    if (!this.mayChange(who, message)) this.forbid(who, "edit this message");
+    if (thread.status === "resolved") throw new CommentsError("THREAD_RESOLVED", `thread ${shown(id2)} is resolved; reopen it to edit`);
+    const next = this.readEdited(message, text, given.mentions, who);
+    this.rewrite(fields, message.id, next);
+    return this.find(id2, message.id).message;
+  }
+  readEdited(message, text, explicit, who) {
+    const edited = { ...message, body: text, mentions: mentionsOf(text, explicit), editedAt: this.time(), editedBy: { kind: who.kind, name: who.name } };
+    try {
+      return this.readMessage(copy(edited));
+    } catch (error) {
+      return invalid(`the message cannot be stored: ${error.message}`);
+    }
+  }
+  /**
+   * Remove one message, also from a resolved thread. The last message of a thread stays: delete the thread instead. Replicas that delete
+   * two messages at once can leave a thread with none. A moderator can still delete that thread.
+   */
+  deleteMessage(threadId, messageId, actor) {
+    const who = assertActor(actor);
+    const { id: id2, fields, thread, message } = this.find(threadId, messageId);
+    if (!this.mayChange(who, message)) this.forbid(who, "delete this message");
+    if (thread.messages.length === 1) invalid(`thread ${shown(id2)} has only this message; delete the thread instead`);
+    this.rewrite(fields, message.id, void 0);
+    return { threadId: id2, messageId: message.id };
+  }
+  /**
+   * Remove a thread and all its messages. Its author may do it when every message is theirs. Once someone
+   * else replied, a message is erased, or a stored message cannot be read, it needs the moderate scope. A
+   * moderator can also remove a thread that cannot be read at all.
+   */
+  deleteThread(threadId, actor) {
+    const who = assertActor(actor);
+    const { id: id2, fields } = this.fields(threadId);
+    if (!who.scopes.includes(MODERATE_SCOPE)) {
+      const { thread } = this.read(id2, fields);
+      if (thread.skipped > 0 || !thread.messages.every((m) => this.mayChange(who, m))) this.forbid(who, "delete this thread");
+    }
+    this.map.delete(id2);
+    return { threadId: id2 };
+  }
+  /**
+   * Check who an export or erase is for, and that the actor may. A person may act on their own data: the same
+   * kind and name. A principal with the moderate scope may act on anyone's, and then every kind with that name is
+   * included. Returns the name and a test for an author. Used by `Suggestions`.
+   */
+  checkPerson(person, actor) {
+    const who = assertActor(actor);
+    if (typeof person !== "string" || person === "" || person !== person.trim() || person.length > 128) invalid("a person is a name of 1 to 128 characters");
+    if (person === ERASED_NAME) invalid("a tombstone is not a person");
+    const moderator = who.scopes.includes(MODERATE_SCOPE);
+    if (who.name !== person && !moderator) {
+      throw new CommentsError("FORBIDDEN", `${who.kind}:${shown(who.name)} cannot read or erase the data of another person without the ${MODERATE_SCOPE} scope`);
+    }
+    return { name: person, match: (a) => a.name === person && (moderator || a.kind === who.kind) };
+  }
+  /** The raw stored threads, for the code that must see data a read hides. `list` is missing when the message field is bad. */
+  stored() {
+    return [...this.map.entries()].flatMap(([id2, fields]) => fields instanceof Y3.Map ? [{ id: id2, fields, list: fields.get("messages") instanceof Y3.Array ? fields.get("messages") : void 0 }] : []);
+  }
+  /**
+   * What a person wrote in this document: their messages, the status change of theirs that stands, and the
+   * edits they made to other people's messages. `unread` counts stored entries with their name that this read
+   * cannot show: a bad message, a thread that cannot be read, a message past the read limit, or a copy that
+   * lost a merge. When it is not 0 the export is not complete. A person may export their own data.
+   */
+  exportPerson(person, actor) {
+    const { name, match } = this.checkPerson(person, actor);
+    const threads = [];
+    const edits = [];
+    let shownCount = 0;
+    for (const thread of this.list()) {
+      const messages = thread.messages.filter((m) => match(m.author));
+      shownCount += messages.length;
+      const status = match(thread.statusBy);
+      if (status) shownCount++;
+      for (const m of thread.messages) if (m.editedBy && match(m.editedBy) && !match(m.author)) edits.push({ threadId: thread.id, messageId: m.id, at: m.editedAt });
+      if (messages.length === 0 && !status) continue;
+      threads.push({
+        threadId: thread.id,
+        anchor: copy(thread.anchor),
+        messages: copy(messages),
+        ...status ? { statusChange: { status: thread.status, at: thread.statusAt, by: copy(thread.statusBy) } } : {}
+      });
+    }
+    let found = 0;
+    const named = (value) => {
+      const author = readAuthor(value);
+      return author !== void 0 && match(author);
+    };
+    for (const { fields, list } of this.stored()) {
+      for (const raw of list?.toArray() ?? []) if (named(raw?.author) || named(raw?.editedBy)) found++;
+      if (named(fields.get("state")?.by)) found++;
+    }
+    return { person: name, exportedAt: this.time(), threads, edits, unread: Math.max(0, found - shownCount - edits.length) };
+  }
+  /**
+   * Replace every message a person wrote with a tombstone: the body becomes "[erased]", the author name
+   * becomes "erased", and the mentions go. The author kind stays, so machine-made work stays marked. Thread
+   * shape, order, and times stay. A status change of theirs, and their name as the editor of another person's
+   * message, get the tombstone name. It works on the stored entries, so it reaches a bad message, a message past
+   * the read limit, a thread that cannot be read, and every copy that a merge hid. Names inside other people's
+   * messages are not touched. Returns how many messages, status changes, and edit stamps it erased.
+   */
+  erasePerson(person, actor) {
+    const { match } = this.checkPerson(person, actor);
+    const tomb = (a) => ({ kind: a.kind, name: ERASED_NAME });
+    const out = { messages: 0, statuses: 0, edits: 0 };
+    this.ydoc.transact(() => {
+      for (const { fields, list } of this.stored()) {
+        const entries = list?.toArray() ?? [];
+        for (let i = entries.length - 1; i >= 0; i--) {
+          const raw = entries[i];
+          if (typeof raw !== "object" || raw === null) continue;
+          const author = readAuthor(raw.author);
+          const editor = readAuthor(raw.editedBy);
+          let next;
+          if (author && match(author)) {
+            const id2 = typeof raw.id === "string" && ID.test(raw.id) ? raw.id : globalThis.crypto.randomUUID();
+            const at = validDate(raw.at) ? raw.at : this.time();
+            next = { id: id2, at, author: tomb(author), body: ERASED_BODY, mentions: [], editedAt: this.time(), editedBy: tomb(author), erased: true };
+            out.messages++;
+          } else if (editor && match(editor)) {
+            next = { ...raw, editedBy: tomb(editor) };
+            out.edits++;
+          }
+          if (!next) continue;
+          list.delete(i, 1);
+          list.insert(i, [next]);
+        }
+        const state = fields.get("state");
+        const by = readAuthor(state?.by);
+        if (state && by && match(by)) {
+          fields.set("state", { ...state, by: tomb(by) });
+          out.statuses++;
+        }
+      }
+    });
+    return out;
+  }
   get(threadId) {
     const { id: id2, fields } = this.fields(threadId);
     return this.read(id2, fields).thread;
@@ -755,6 +1024,7 @@ export {
   textAnchor,
   textRange,
   PRINCIPAL_KINDS,
+  ERASED_NAME,
   Actor,
   stamp,
   readAuthor,
@@ -764,5 +1034,7 @@ export {
   validDate,
   ACCEPT_SCOPE,
   Suggestions,
+  MODERATE_SCOPE,
+  ERASED_BODY,
   Comments
 };

package/dist/cli.js

@@ -3,17 +3,17 @@ import {
   FileStore,
   lockTimeoutFrom,
   operatorActor
-} from "./chunk-QJXI3P5D.js";
+} from "./chunk-6N53KQVU.js";
 import {
   VERSION
-} from "./chunk-REFQNIEP.js";
+} from "./chunk-H6JK62SP.js";
 import {
   CommentsService,
   TEXT_ROOT
-} from "./chunk-NQWRFKJ6.js";
+} from "./chunk-T77DPNIV.js";
 import {
   CommentsError
-} from "./chunk-BSNBDKR2.js";
+} from "./chunk-VAVKBAHM.js";
 
 // src/cli.ts
 import { readFileSync, realpathSync } from "fs";
@@ -24,6 +24,7 @@ var FLAGS = {
   "--file": "value",
   "--as": "value",
   "--body": "value",
+  "--message": "value",
   "--mention": "many",
   "--text-quote": "value",
   "--occurrence": "value",
@@ -50,19 +51,26 @@ var ALLOWED = {
   resolve: SHARED,
   reopen: SHARED,
   relocate: SHARED,
+  "edit-message": [...SHARED, "--message", "--body", "--mention"],
+  "delete-message": [...SHARED, "--message"],
+  "delete-thread": SHARED,
+  "export-person": SHARED,
+  "erase-person": SHARED,
   suggestions: [...SHARED, "--status", "--anchor-state"],
   suggest: [...SHARED, ...ANCHOR, "--replace", "--value", "--summary"],
   accept: SHARED,
   reject: SHARED,
   mcp: SHARED
 };
-var TAKES_ID = ["show", "reply", "resolve", "reopen", "relocate", "accept", "reject"];
-var COMMANDS = ["init", "list", "show", "comment", "reply", "resolve", "reopen", "relocate", "suggestions", "suggest", "accept", "reject", "mcp"];
+var TAKES_ID = ["show", "reply", "resolve", "reopen", "relocate", "accept", "reject", "edit-message", "delete-message", "delete-thread", "export-person", "erase-person"];
+var COMMANDS = ["init", "list", "show", "comment", "reply", "resolve", "reopen", "relocate", "edit-message", "delete-message", "delete-thread", "export-person", "erase-person", "suggestions", "suggest", "accept", "reject", "mcp"];
 function parseArgs(argv) {
   const [command, ...rest] = argv;
   if (command === void 0 || command === "--help" || command === "-h") return { command: "help", flags: {}, many: {} };
   if (command === "--version" || command === "-V") return { command: "version", flags: {}, many: {} };
   if (!COMMANDS.includes(command)) throw new UsageError(`unknown command "${command}"`);
+  if (command === "mcp" && rest.some((a) => a === "--help" || a === "-h")) return { command: "help", flags: {}, many: {} };
+  if (command === "mcp" && rest.some((a) => a === "--version" || a === "-V" || a === "-v")) return { command: "version", flags: {}, many: {} };
   const parsed = { command, flags: {}, many: {} };
   for (let i = 0; i < rest.length; i++) {
     const arg = rest[i];
@@ -112,6 +120,15 @@ function need(p) {
   if (p.id === void 0) throw new UsageError(`${p.command} needs an id`);
   return p.id;
 }
+function needName(p) {
+  if (p.id === void 0) throw new UsageError(`${p.command} needs the name of a person`);
+  return p.id;
+}
+function flag(p, name) {
+  const value = p.flags[name];
+  if (value === void 0) throw new UsageError(`${p.command} needs ${name}`);
+  return value;
+}
 var HELP = `agentic-comments ${VERSION}
 Comment threads and suggestions anchored to any content, from people and agents.
 
@@ -121,6 +138,7 @@ Setup:
   --file <path>     The store file. Or AGENTIC_COMMENTS_FILE. Default ./comments.ydoc.
   --as <kind:name>  Who acts. Or AGENTIC_COMMENTS_AS. Kinds: human, agent_of_human, agent_of_agent, agent, user_token.
   Scopes come only from AGENTIC_COMMENTS_SCOPES, a comma list such as comments:accept.
+  Another person's message, thread, or data needs comments:moderate.
 
 Commands:
   init [--text <t> | --text-file <p>]         Create the store.
@@ -129,6 +147,11 @@ Commands:
   comment <anchor> --body <t> [--mention h]   Start a thread.
   reply <id> --body <t> [--mention h]         Reply.
   resolve <id> | reopen <id> | relocate <id>
+  edit-message <id> --message <mid> --body <t> [--mention h]   Change a message you wrote.
+  delete-message <id> --message <mid>         Delete a message you wrote.
+  delete-thread <id>                          Delete a thread. Needs every message to be yours.
+  export-person <name>                        Export what a person wrote.
+  erase-person <name>                         Replace what a person wrote with a tombstone.
   suggestions [--status s] [--anchor-state s] List suggestions.
   suggest <anchor> (--replace <t> | --value <json>) [--summary <t>]
   accept <id> | reject <id>
@@ -155,7 +178,7 @@ async function runCli(argv, io) {
       return 0;
     }
     if (p.command === "mcp") {
-      const { startMcp } = await import("./mcp-XUV3RPOO.js");
+      const { startMcp } = await import("./mcp-WBAHKMF4.js");
       await startMcp(store, operatorActor(p.flags["--as"] ?? io.env.AGENTIC_COMMENTS_AS, io.env.AGENTIC_COMMENTS_SCOPES));
       return 0;
     }
@@ -163,7 +186,7 @@ async function runCli(argv, io) {
     const mentions = p.many["--mention"];
     const filter = { status: p.flags["--status"], anchorState: p.flags["--anchor-state"], mentioning: p.flags["--mentioning"] };
     const clean = Object.fromEntries(Object.entries(filter).filter(([, v]) => v !== void 0));
-    const result = p.command === "list" ? service.threads(clean) : p.command === "show" ? service.thread(need(p)) : p.command === "comment" ? service.comment({ anchor: anchorOf(p), body: p.flags["--body"], ...mentions ? { mentions } : {} }) : p.command === "reply" ? service.reply(need(p), { body: p.flags["--body"], ...mentions ? { mentions } : {} }) : p.command === "resolve" ? service.resolve(need(p)) : p.command === "reopen" ? service.reopen(need(p)) : p.command === "relocate" ? service.relocate(need(p)) : p.command === "suggestions" ? service.suggestions(Object.fromEntries(Object.entries(clean).filter(([k]) => k !== "mentioning"))) : p.command === "suggest" ? service.suggest({ anchor: anchorOf(p), change: changeOf(p), ...p.flags["--summary"] === void 0 ? {} : { summary: p.flags["--summary"] } }) : p.command === "accept" ? service.accept(need(p)) : service.reject(need(p));
+    const result = p.command === "list" ? service.threads(clean) : p.command === "show" ? service.thread(need(p)) : p.command === "comment" ? service.comment({ anchor: anchorOf(p), body: p.flags["--body"], ...mentions ? { mentions } : {} }) : p.command === "reply" ? service.reply(need(p), { body: p.flags["--body"], ...mentions ? { mentions } : {} }) : p.command === "edit-message" ? service.editMessage(need(p), flag(p, "--message"), { body: p.flags["--body"], ...mentions ? { mentions } : {} }) : p.command === "delete-message" ? service.deleteMessage(need(p), flag(p, "--message")) : p.command === "delete-thread" ? service.deleteThread(need(p)) : p.command === "export-person" ? service.exportPerson(needName(p)) : p.command === "erase-person" ? service.erasePerson(needName(p)) : p.command === "resolve" ? service.resolve(need(p)) : p.command === "reopen" ? service.reopen(need(p)) : p.command === "relocate" ? service.relocate(need(p)) : p.command === "suggestions" ? service.suggestions(Object.fromEntries(Object.entries(clean).filter(([k]) => k !== "mentioning"))) : p.command === "suggest" ? service.suggest({ anchor: anchorOf(p), change: changeOf(p), ...p.flags["--summary"] === void 0 ? {} : { summary: p.flags["--summary"] } }) : p.command === "accept" ? service.accept(need(p)) : service.reject(need(p));
     io.out(JSON.stringify(result));
     return 0;
   } catch (error) {

package/dist/client.d.ts

@@ -1,8 +1,8 @@
-import { L as ListFilter, A as AnchorSpec } from './service-hpWbnSmc.js';
-import { C as CommentsErrorCode } from './errors-CNgWMVQT.js';
+import { L as ListFilter, A as AnchorSpec } from './service-BvIE6t5n.js';
+import { C as CommentsErrorCode } from './errors-C-xvp24-.js';
 import { PrincipalKind } from 'agentic-identity';
 export { PrincipalKind } from 'agentic-identity';
-import { T as Thread, N as NewReply, M as Message, S as Suggestion } from './suggestions-CvJwo6r4.js';
+import { T as Thread, N as NewReply, M as Message, P as PersonExport, a as PersonSuggestions, S as Suggestion } from './suggestions-CnkEcTuY.js';
 import 'yjs';
 
 /** Codes the comment rules return, plus the ones the Worker and its auth return. */
@@ -35,6 +35,18 @@ interface Me {
 }
 type ThreadFilter = ListFilter;
 type SuggestionListFilter = Pick<ListFilter, "status" | "anchorState">;
+/** What `exportPerson` returns: the messages and status changes of one person, and their suggestions. */
+type PersonData = PersonExport & {
+    suggestions: PersonSuggestions;
+};
+/** What `erasePerson` changed in one document. */
+interface Erased {
+    messages: number;
+    statuses: number;
+    edits: number;
+    suggestions: number;
+    decisions: number;
+}
 interface CommentsClient {
     me(options?: CallOptions): Promise<Me>;
     createDocument(input: {
@@ -58,6 +70,19 @@ interface CommentsClient {
     resolve(docId: string, threadId: string, options?: CallOptions): Promise<Thread>;
     reopen(docId: string, threadId: string, options?: CallOptions): Promise<Thread>;
     relocate(docId: string, threadId: string, options?: CallOptions): Promise<Thread>;
+    editMessage(docId: string, threadId: string, messageId: string, input: {
+        body: string;
+        mentions?: string[];
+    }, options?: CallOptions): Promise<Message>;
+    deleteMessage(docId: string, threadId: string, messageId: string, options?: CallOptions): Promise<{
+        threadId: string;
+        messageId: string;
+    }>;
+    deleteThread(docId: string, threadId: string, options?: CallOptions): Promise<{
+        threadId: string;
+    }>;
+    exportPerson(docId: string, person: string, options?: CallOptions): Promise<PersonData>;
+    erasePerson(docId: string, person: string, options?: CallOptions): Promise<Erased>;
     listSuggestions(docId: string, filter?: SuggestionListFilter, options?: CallOptions): Promise<Suggestion[]>;
     suggest(docId: string, input: {
         anchor: AnchorSpec;
@@ -69,4 +94,4 @@ interface CommentsClient {
 }
 declare function createClient(options: ClientOptions): CommentsClient;
 
-export { AnchorSpec, type ApiErrorCode, type CallOptions, type ClientOptions, CommentsApiError, type CommentsClient, CommentsErrorCode, ListFilter, type Me, Message, NewReply, Suggestion, type SuggestionListFilter, Thread, type ThreadFilter, createClient };
+export { AnchorSpec, type ApiErrorCode, type CallOptions, type ClientOptions, CommentsApiError, type CommentsClient, CommentsErrorCode, type Erased, ListFilter, type Me, Message, NewReply, type PersonData, PersonExport, PersonSuggestions, Suggestion, type SuggestionListFilter, Thread, type ThreadFilter, createClient };

package/dist/client.js

@@ -4,6 +4,7 @@ var CODES = {
   INVALID_INPUT: true,
   INVALID_ANCHOR: true,
   NO_THREAD: true,
+  NO_MESSAGE: true,
   THREAD_RESOLVED: true,
   CORRUPT: true,
   NO_SUGGESTION: true,
@@ -40,15 +41,21 @@ var CommentsApiError = class extends Error {
 var KINDS = { human: true, agent_of_human: true, agent_of_agent: true, agent: true, user_token: true };
 var isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 var isString = (v) => typeof v === "string";
+var isAuthor = (v) => isObject(v) && typeof v.kind === "string" && Object.hasOwn(KINDS, v.kind) && isString(v.name);
+var personThread = (v) => isObject(v) && isString(v.threadId) && isObject(v.anchor) && Array.isArray(v.messages) && v.messages.every(SHAPES.message) && (v.statusChange === void 0 || isObject(v.statusChange) && (v.statusChange.status === "open" || v.statusChange.status === "resolved") && isString(v.statusChange.at) && isAuthor(v.statusChange.by));
 var SHAPES = {
-  me: (v) => isObject(v) && (typeof v.kind === "string" && Object.hasOwn(KINDS, v.kind)) && isString(v.name) && Array.isArray(v.scopes),
+  me: (v) => isObject(v) && (typeof v.kind === "string" && Object.hasOwn(KINDS, v.kind)) && isString(v.name) && Array.isArray(v.scopes) && v.scopes.every(isString),
   created: (v) => isObject(v) && isString(v.id),
   document: (v) => isObject(v) && isString(v.id) && isString(v.text),
-  thread: (v) => isObject(v) && isString(v.id) && isObject(v.anchor) && (v.status === "open" || v.status === "resolved") && Array.isArray(v.messages),
+  thread: (v) => isObject(v) && isString(v.id) && isObject(v.anchor) && isObject(v.anchorState) && isString(v.anchorState.state) && (v.status === "open" || v.status === "resolved") && isAuthor(v.statusBy) && isString(v.statusAt) && Array.isArray(v.messages) && v.messages.every(SHAPES.message) && typeof v.skipped === "number",
   threads: (v) => Array.isArray(v) && v.every(SHAPES.thread),
-  message: (v) => isObject(v) && isString(v.id) && isString(v.body) && isObject(v.author),
-  suggestion: (v) => isObject(v) && isString(v.id) && isObject(v.anchor) && isString(v.status) && isObject(v.author),
-  suggestions: (v) => Array.isArray(v) && v.every(SHAPES.suggestion)
+  message: (v) => isObject(v) && isString(v.id) && isString(v.at) && isString(v.body) && Array.isArray(v.mentions) && v.mentions.every(isString) && isAuthor(v.author) && (v.editedAt === void 0 || isString(v.editedAt)) && (v.editedBy === void 0 || isAuthor(v.editedBy)),
+  suggestion: (v) => isObject(v) && isString(v.id) && isObject(v.anchor) && isObject(v.anchorState) && isString(v.anchorState.state) && (v.status === "pending" || v.status === "accepted" || v.status === "rejected") && isAuthor(v.author) && isString(v.createdAt) && "change" in v && (v.summary === void 0 || isString(v.summary)) && (v.decidedBy === void 0 || isAuthor(v.decidedBy)) && (v.decidedAt === void 0 || isString(v.decidedAt)),
+  suggestions: (v) => Array.isArray(v) && v.every(SHAPES.suggestion),
+  deletedMessage: (v) => isObject(v) && isString(v.threadId) && isString(v.messageId),
+  deletedThread: (v) => isObject(v) && isString(v.threadId),
+  person: (v) => isObject(v) && isString(v.person) && isString(v.exportedAt) && Array.isArray(v.threads) && v.threads.every(personThread) && Array.isArray(v.edits) && v.edits.every((e) => isObject(e) && isString(e.threadId) && isString(e.messageId) && isString(e.at)) && typeof v.unread === "number" && isObject(v.suggestions) && Array.isArray(v.suggestions.authored) && v.suggestions.authored.every(SHAPES.suggestion) && Array.isArray(v.suggestions.decided) && v.suggestions.decided.every((d) => isObject(d) && isString(d.id) && (d.status === "accepted" || d.status === "rejected") && isString(d.at)) && typeof v.suggestions.unread === "number",
+  erased: (v) => isObject(v) && ["messages", "statuses", "edits", "suggestions", "decisions"].every((k) => typeof v[k] === "number")
 };
 function createClient(options) {
   if (typeof options.baseUrl !== "string" || options.baseUrl === "") throw new TypeError("createClient needs a baseUrl");
@@ -120,6 +127,11 @@ function createClient(options) {
     resolve: (id, threadId, o) => call("POST", `${thread(id, threadId)}/resolve`, void 0, o, "thread"),
     reopen: (id, threadId, o) => call("POST", `${thread(id, threadId)}/reopen`, void 0, o, "thread"),
     relocate: (id, threadId, o) => call("POST", `${thread(id, threadId)}/relocate`, void 0, o, "thread"),
+    editMessage: (id, threadId, messageId, input, o) => call("PATCH", `${thread(id, threadId)}/messages/${seg(messageId)}`, input, o, "message"),
+    deleteMessage: (id, threadId, messageId, o) => call("DELETE", `${thread(id, threadId)}/messages/${seg(messageId)}`, void 0, o, "deletedMessage"),
+    deleteThread: (id, threadId, o) => call("DELETE", thread(id, threadId), void 0, o, "deletedThread"),
+    exportPerson: (id, person, o) => call("GET", `${doc(id)}/people/${seg(person)}/export`, void 0, o, "person"),
+    erasePerson: (id, person, o) => call("DELETE", `${doc(id)}/people/${seg(person)}`, void 0, o, "erased"),
     listSuggestions: (id, filter, o) => call("GET", `${doc(id)}/suggestions${query(filter)}`, void 0, o, "suggestions"),
     suggest: (id, input, o) => call("POST", `${doc(id)}/suggestions`, input, o, "suggestion"),
     accept: (id, suggestionId, o) => call("POST", `${suggestion(id, suggestionId)}/accept`, void 0, o, "suggestion"),

package/dist/errors-C-xvp24-.d.ts

@@ -0,0 +1,7 @@
+type CommentsErrorCode = "INVALID_AUTHOR" | "INVALID_INPUT" | "INVALID_ANCHOR" | "NO_THREAD" | "NO_MESSAGE" | "THREAD_RESOLVED" | "CORRUPT" | "NO_SUGGESTION" | "FORBIDDEN" | "ALREADY_DECIDED" | "APPLY_FAILED" | "RELOCATE_FAILED" | "STORE_MISSING" | "STORE_EXISTS" | "STORE_CORRUPT" | "STORE_LOCKED" | "STORE_FULL" | "NO_DOCUMENT" | "DOCUMENT_EXISTS" | "CONFLICT" | "MISCONFIGURED" | "USAGE";
+declare class CommentsError extends Error {
+    readonly code: CommentsErrorCode;
+    constructor(code: CommentsErrorCode, message: string);
+}
+
+export { type CommentsErrorCode as C, CommentsError as a };

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-import { a as Author, C as Comments, b as Suggestions } from './suggestions-CvJwo6r4.js';
-export { c as ACCEPT_SCOPE, A as Actor, d as Anchor, e as AnchorKind, f as AnchorState, g as ApplyContext, h as CanvasAnchor, i as CellAnchor, j as CommentsOptions, M as Message, N as NewReply, k as NewSuggestion, l as NewThread, R as RelativePositionJson, m as RevertContext, n as SlideAnchor, o as StampInput, S as Suggestion, p as SuggestionFilter, q as SuggestionHost, r as TextAnchor, T as Thread, s as ThreadFilter, t as authorLabel, u as stamp, v as textAnchor, w as textOf } from './suggestions-CvJwo6r4.js';
-export { a as CommentsError, C as CommentsErrorCode } from './errors-CNgWMVQT.js';
+import { b as Author, C as Comments, c as Suggestions } from './suggestions-CnkEcTuY.js';
+export { d as ACCEPT_SCOPE, A as Actor, e as Anchor, f as AnchorKind, g as AnchorState, h as ApplyContext, i as CanvasAnchor, j as CellAnchor, k as CommentsOptions, E as ERASED_BODY, l as ERASED_NAME, m as EditMessage, n as MODERATE_SCOPE, M as Message, N as NewReply, o as NewSuggestion, p as NewThread, P as PersonExport, R as RelativePositionJson, q as RevertContext, r as SlideAnchor, s as StampInput, S as Suggestion, t as SuggestionFilter, u as SuggestionHost, v as TextAnchor, T as Thread, w as ThreadFilter, x as authorLabel, y as stamp, z as textAnchor, B as textOf } from './suggestions-CnkEcTuY.js';
+export { a as CommentsError, C as CommentsErrorCode } from './errors-C-xvp24-.js';
 export { PRINCIPAL_KINDS, PrincipalKind } from 'agentic-identity';
 import 'yjs';