agentic-drive 0.8.0 → 0.9.1

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## 0.9.1
+
+No change to the SDK, CLI, MCP or HTTP shape. Two breaking changes for hosts that pin `agentic-design` or `agentic-identity`, see Breaking.
+
+### Breaking
+
+- **A host that pins `agentic-design` to `^0.4.0` must move its pin to `^0.5.0`.** The 0.9.0 README told hosts to add `agentic-design@^0.4.0` to their own dependencies. This release depends on `agentic-design` `^0.5.0`, so a host that keeps `^0.4.0` gets two copies. The two copies do not share React context. A host that wraps `DriveBrowser` in its own `ToastProvider` or `TooltipProvider` from `agentic-design/react` on 0.4 gets the error `useToast needs a ToastProvider above it`. `mount()` brings its own providers and is not affected.
+- A host that also pins `agentic-identity` to `^0.6.0` gets two copies of it, and the identity error classes and types from one copy do not match the other. Move the host's pin to `^0.9.0`.
+
+### Changed
+
+- `agentic-identity` is `^0.9.0`. It was `^0.6.0`. The lockfile follows. The 0.7.0 to 0.9.0 additions are not used by the drive package.
+- `agentic-design` is `^0.5.0`. It was `^0.4.0`. The design release changes values only: colors, borders, shadows, the large radius, control height, heading sizes, dialog and menu padding, and the disabled and danger button styles. The token names and the `agd-` prefix do not change. The web UI and the embedded UI take the new look. The look of a page that the host renders follows the host's own `agentic-design` pin. The screenshots in `docs/ui` show the 0.4 look until they are refreshed.
+- The README embed section names `agentic-design@^0.5.0`.
+
+## 0.9.0
+
+### Added
+
+- **An activity log for each item.** Drive now keeps an append-only entry for each create, rename, move, content update, share, unshare, delete (to the trash), and restore of an item. Each entry has the actor (`{ id, kind }`, where `kind` is `human` or `agent`), the time, and what changed (names and ids, never content). Every principal that is not a person counts as an agent. So a later change by an agent to an item that a person made carries the label. The entry of a create, rename, move, update, delete, or restore is written in the same transaction as the change. A share entry follows the grant, also for `claimRef` and for an accepted invite (but not an invite to a drive root). An unshare entry follows a revoke only when the subject held a role. Only the owner of the drive sees who got a role in a log. A share of the drive root is logged under the id `root`. The log uses the existing `Store` port, in the `drive_activity` collection. Items made before 0.9.0 have no entries until they change.
+- `listActivity(ctx, idOrPath, { limit })` in the SDK, `GET /api/v1/drive/items/:id/activity` in the HTTP API (and `listActivity` in the client), `activity <path|id> [--limit n]` in the CLI, and `drive_activity` in MCP. Anyone who may read an item may read its log. A purge deletes the log of the item.
+- The UI has an Activity page for an item (the Activity entry of the item menu). An entry made by an agent shows an "AI agent" label.
+- `buildExport` adds `activity` to the manifest: the entries made by the person and their agents, in any drive. In a drive that the person does not own, the entries have no names. `erasePerson` changes the actor id of those entries, and the id of a person named in a share entry, to `erased`. It keeps the kind.
+
+### Changed
+
+- **The web UI has a calm list view.** Files show in a table with sortable Name and Modified columns, a search that opens from a button, and a Share button next to the title of a folder. Select rows with the check boxes to see a bar at the bottom of the page that moves them all to the trash. A search with no match has its own empty state. The design classes in the list view are now `drive-*` classes of the app, not `agd-file-*` classes.
+
 ## 0.8.0
 
 Read the breaking changes before you upgrade.

package/README.md

@@ -7,7 +7,7 @@
 
 Store, sort, and share files and folders.
 
-> Status: 0.8.0, early. The library, CLI, MCP server, and HTTP API work, with sharing in the SDK, the HTTP API, the CLI, and the MCP server.
+> Status: 0.9.1, early. The library, CLI, MCP server, and HTTP API work, with sharing in the SDK, the HTTP API, the CLI, and the MCP server.
 > A small web UI works. See [UI](#ui).
 
 ## Live demo
@@ -92,7 +92,7 @@ curl -H "authorization: Bearer <token>" "$URL/api/v1/drive/items?path=/"
 
 Routes: `GET /items`, `GET /stat`, `POST /folders`, `PUT /files`, `GET /files`, `GET /url`,
 `POST /move`, `POST /trash`, `GET /trash`, `POST /restore`, `POST /purge`, `GET /search`,
-`GET /export`, `DELETE /account?confirm=yes`, `GET /home`, `POST /documents`, `DELETE /documents?ref=`, `GET /trash/paths`, `GET /refs?ref=`, `POST /refs`.
+`GET /items/:id/activity`, `GET /export`, `DELETE /account?confirm=yes`, `GET /home`, `POST /documents`, `DELETE /documents?ref=`, `GET /trash/paths`, `GET /refs?ref=`, `POST /refs`.
 Sign in with a bearer token from agentic-identity. The token is a credential in the `credentials` collection of
 the same D1 database, and it names a principal in `principals`. The Worker resolves the whole delegation chain on
 every request. A missing, expired, or revoked credential, or a revoked or expired principal (or one above it), gets 401.
@@ -125,7 +125,7 @@ try {
 }
 ```
 
-- One method for each bearer route and each shared route: `list`, `stat`, `mkdir`, `upload`, `download`, `url`, `move`, `trash`, `listTrash`, `restore`, `purge`, `search`, `export`, `deleteAccount`, `home`, `registerDocument`, `forgetDocument`, `findByRef`, `listTrashWithPaths`, `claimRef`, `shares`, `share`, `unshare`, `invite`, `acceptInvite`, `createLink`, `revokeLink`, `openShared`, `listShared`, and `readShared`.
+- One method for each bearer route and each shared route: `list`, `stat`, `mkdir`, `upload`, `download`, `url`, `move`, `trash`, `listTrash`, `listActivity`, `restore`, `purge`, `search`, `export`, `deleteAccount`, `home`, `registerDocument`, `forgetDocument`, `findByRef`, `listTrashWithPaths`, `claimRef`, `shares`, `share`, `unshare`, `invite`, `acceptInvite`, `createLink`, `revokeLink`, `openShared`, `listShared`, and `readShared`.
 - Each method has typed input and output. The client checks the shape of every answer, and `download` checks the bytes against their hash (it needs WebCrypto). `readShared` does not: the Worker sends no hash there. An answer that fails a check throws `BAD_RESPONSE`. `url` gives a signed link that you fetch yourself. The last argument takes `{ signal }` to stop the call with an `AbortSignal`.
 - A failed call throws `DriveApiError`. It has the `code` of the API and the HTTP `status`. A call that gets no answer has the code `NETWORK_ERROR` and status 0. An abort stays the abort error of `fetch`. A code that the client does not know gives `BAD_RESPONSE`.
 - The client never sends a write again. `retries` (default 0) sends a read (GET) again after a network error or a 502, 503, or 504, with a short wait. A redirect is an error (`BAD_RESPONSE`, with the status of the redirect, or 0 in a browser): set `baseUrl` to the final URL.
@@ -203,7 +203,7 @@ drive.update({ baseUrl, getToken });  // use another server or callback
 drive.unmount();                      // remove the UI
 ```
 
-`getToken` returns 1 to 512 letters, digits, `-` or `_`, or `undefined` to send no `authorization` header. A bad `baseUrl` or a `getToken` that is not a function makes `mount` throw a `TypeError`. The server still checks every request against the token. The embed shows files and trash with upload, rename, move, share, and the "Created by agent" label. It has no sign-in form, because your app owns sign-in. It does not change the page address, and it has no theme switch. `agentic-design/styles.css` sets base styles for the whole page, and it follows the dark mode of the system unless your page sets `data-theme`. Add `agentic-design@^0.4.0` to your own dependencies, because your page imports its files. The Worker sends no CORS headers, so the server must be on the origin of your page. Set `baseUrl` to the same address as `DRIVE_PUBLIC_URL`, or the UI refuses its download links. `unmount` and `update` abort the requests that run and stop an upload that has more files to send. The UI keeps the list or grid choice in `localStorage` under `agentic-drive-view`, and it has its own heading for each view. Dialogs, menus, and messages render in `document.body`, outside your element. A click with Ctrl, Cmd, Shift, or the middle button on a folder link does not open the folder. The class names start with `drive-`. The design-system classes start with `agd-`. `DriveBrowser` is the same UI as a React component. It closes its requests when it unmounts. Wrap it in `TooltipProvider` and `ToastProvider` from `agentic-design/react`. `react` and `react-dom` (version 19 or later) are optional peer dependencies. Install them in your project when you use `agentic-drive/ui`. The web UI that the Worker serves uses the same views.
+`getToken` returns 1 to 512 letters, digits, `-` or `_`, or `undefined` to send no `authorization` header. A bad `baseUrl` or a `getToken` that is not a function makes `mount` throw a `TypeError`. The server still checks every request against the token. The embed shows files and trash with upload, rename, move, share, and the "Created by agent" label. It has no sign-in form, because your app owns sign-in. It does not change the page address, and it has no theme switch. `agentic-design/styles.css` sets base styles for the whole page, and it follows the dark mode of the system unless your page sets `data-theme`. Add `agentic-design@^0.5.0` to your own dependencies, because your page imports its files. The Worker sends no CORS headers, so the server must be on the origin of your page. Set `baseUrl` to the same address as `DRIVE_PUBLIC_URL`, or the UI refuses its download links. `unmount` and `update` abort the requests that run and stop an upload that has more files to send. The UI keeps the list or grid choice in `localStorage` under `agentic-drive-view`, and it has its own heading for each view. Dialogs, menus, and messages render in `document.body`, outside your element. A click with Ctrl, Cmd, Shift, or the middle button on a folder link does not open the folder. The class names start with `drive-`. The design-system classes start with `agd-`. `DriveBrowser` is the same UI as a React component. It closes its requests when it unmounts. Wrap it in `TooltipProvider` and `ToastProvider` from `agentic-design/react`. `react` and `react-dom` (version 19 or later) are optional peer dependencies. Install them in your project when you use `agentic-drive/ui`. The web UI that the Worker serves uses the same views.
 
 ### Serve the UI from the package
 
@@ -270,6 +270,7 @@ export default { fetch: app.fetch };
 - Paths that start with `/`. Anything else is an item id.
 - Move, rename, trash, restore, and purge. Trashing a folder hides its whole tree.
 - Names compare without regard to case or Unicode form. A clash fails, or renames, or replaces.
+- Each item has an activity log: create, rename, move, content update, share, unshare, delete, and restore, each with the actor (`{ id, kind: "human" | "agent" }`) and the time. Read it with `listActivity`, `GET /items/:id/activity`, `agentic-drive activity <path|id>`, or the MCP tool `drive_activity`. The UI shows it with an "AI agent" label on each change that an agent made. The export holds the activity of the person and their agents. Purge deletes the log of the item. Items from before the log have no entries until they change.
 - Each item records its size, type, owner, and who made and last changed it, with the actor kind.
 - Storage sits behind the `Store` and `Blobs` ports of `agentic-identity`. Tests use its memory adapters. The CLI uses a local file adapter that passes the same contract suites. The Worker uses its D1 and R2 adapters.
 - Roles: viewer, commenter, editor, owner. A role on a folder reaches everything under it, and follows an item that moves. Identity decides every request through `can()`, which also writes the audit entry. A caller who cannot read an item gets `NOT_FOUND`. A caller who can read it but not change it gets `FORBIDDEN`. Editors write and trash. An item takes the roles of its new folder, so moving an item into a folder where the caller is owner needs owner on the item. Only owners share, purge, and read the share list.
@@ -314,6 +315,21 @@ export default { fetch: app.fetch };
 - Every access check writes one audit row, and a transaction that runs again writes its rows again. The audit holds ids and kinds only: no emails and no content.
 - Data made before sharing has no `resources` docs, so its owner gets `NOT_FOUND`. Run `backfillResources(store, { maxPages: 1 })` on that store, paged the same way, once the old Worker has stopped writing. See CHANGELOG.md for the order of the upgrade steps.
 - A person who is not an owner cannot move an item into their own drive: the move fails with `CROSS_DRIVE`.
+
+## Run locally
+
+```sh
+bun install        # or: npm ci
+bun run dev        # or: npm run dev
+curl http://localhost:8787/health
+```
+
+The script builds the UI, then runs `wrangler dev --local` with `DRIVE_PUBLIC_URL=http://127.0.0.1:8787` and `DRIVE_REGION=unknown`. `/health` needs no token and no secret. Every `/api/v1/drive` call answers 503 until you set a secret: copy `.dev.vars.example` to `.dev.vars` and set `DRIVE_URL_SECRET` to a random value of 32 bytes or more (`openssl rand -hex 32`). `.dev.vars` stays out of git. If you change the port, also pass `--var DRIVE_PUBLIC_URL:http://127.0.0.1:<port>`, or the signed links point at port 8787. A fresh local database has no tokens: see `e2e/serve.mjs` to seed one.
+
+The scripts call `npm` and `node` (Node 22 or newer), so install both, even if you use bun. They need a POSIX shell.
+
+Run `npm run dev:smoke` to check this path. It starts the dev server on port 8799, waits for `GET /health` to answer 200, and stops the server. CI runs it as the "dev smoke" step. Set `DEV_SMOKE_PORT` to use another port.
+
 ## Develop
 
 ```sh

package/dist/{chunk-R2DUVOJT.js → chunk-622NAJ6K.js}

@@ -1,8 +1,9 @@
 // src/drive.ts
-import { EraseRefusedError, StoreConflictError, MAX_FOLDER_DEPTH, PRINCIPAL_KINDS, ROLES, SUBJECT_KINDS } from "agentic-identity";
+import { EraseRefusedError, isMachineMade, StoreConflictError, MAX_FOLDER_DEPTH, PRINCIPAL_KINDS, ROLES, SUBJECT_KINDS } from "agentic-identity";
 var ROOT_ID = "root";
 var NODES = "drive_nodes";
 var NAMES = "drive_names";
+var ACTIVITY = "drive_activity";
 var ACTOR_KINDS = PRINCIPAL_KINDS;
 var DECIDED = /* @__PURE__ */ Symbol("decided");
 var ERROR_STATUS = Object.freeze({
@@ -131,6 +132,17 @@ function parseSubject(input) {
   return { kind: s.kind, id: s.id };
 }
 var SHARE_ERROR = /^(invalid|give an|expiresAt|expiresInMs|resource exists|the last owner)/;
+var ACTIVITY_ACTIONS = ["create", "rename", "move", "update", "share", "unshare", "delete", "restore"];
+var publicActivity = ({ owner: _owner, actorId: _actorId, subjectId: _subjectId, subjectKind: _subjectKind, ...entry }) => ({
+  ...entry,
+  actor: { id: entry.actor.id, kind: entry.principalKind === "human" ? "human" : "agent" }
+});
+var keepVia = (entry) => {
+  const via = entry.detail?.via;
+  if (via === void 0) delete entry.detail;
+  else entry.detail = { via };
+};
+var shown = (doc) => typeof doc.id === "string" && typeof doc.itemId === "string" && typeof doc.at === "number" && Number.isFinite(doc.at) && ACTIVITY_ACTIONS.includes(doc.action) && typeof doc.actor === "object" && doc.actor !== null && typeof doc.actor.id === "string" && PRINCIPAL_KINDS.includes(doc.principalKind);
 function createDrive(deps) {
   const { store, blobs } = deps;
   let last = 0;
@@ -183,6 +195,29 @@ function createDrive(deps) {
   const who = (ctx) => ({ id: ctx.actor.id, kind: ctx.actor.kind });
   const stamp = (ctx, node) => ({ createdById: node.createdById ?? node.createdBy.id, updatedBy: who(ctx), updatedById: ctx.actor.id });
   const resourceDoc = async (node, parent) => ({ id: node.id, type: "drive", parentId: await resourceOf(parent) });
+  const activityDoc = (ctx, node, action, detail) => {
+    if (!PRINCIPAL_KINDS.includes(ctx.actor.kind)) throw new DriveError("FORBIDDEN", `an actor needs a kind: ${PRINCIPAL_KINDS.join(", ")}`);
+    return {
+      id: newId(),
+      itemId: node.id,
+      owner: node.owner,
+      action,
+      actor: { id: ctx.actor.id, kind: isMachineMade(ctx.actor.kind) ? "agent" : "human" },
+      actorId: ctx.actor.id,
+      principalKind: ctx.actor.kind,
+      at: now(),
+      ...detail ? { detail } : {},
+      ...typeof detail?.subjectId === "string" ? { subjectId: detail.subjectId, subjectKind: detail.subjectKind } : {}
+    };
+  };
+  const logDoc = (ctx, node, action, detail) => {
+    const doc = activityDoc(ctx, node, action, detail);
+    return [doc.id, doc];
+  };
+  const logIn = (w, ctx, node, action, detail) => {
+    const doc = activityDoc(ctx, node, action, detail);
+    w.put(ACTIVITY, doc.id, doc);
+  };
   async function rawNode(ops, id, owner, by, withMarked = false) {
     const node = id === ROOT_ID ? rootNode(owner, by) : await ops.get(NODES, id);
     return node && (withMarked || node.purging !== true) ? node : null;
@@ -328,6 +363,7 @@ function createDrive(deps) {
       if (onConflict === "replace" && slot.node?.kind === "file" && fields.kind === "file") {
         const node2 = { ...slot.node, ...fields, updatedAt: now(), ...stamp(ctx, slot.node) };
         w.put(NODES, node2.id, node2);
+        logIn(w, ctx, node2, "update", { size: node2.size, hash: node2.hash });
         return { node: node2, replacedBlob: slot.node.blobKey };
       }
       if (onConflict !== "rename") throw new DriveError("NAME_TAKEN", `"${name}" already exists`);
@@ -365,6 +401,7 @@ function createDrive(deps) {
       ...fields
     };
     w.put(NODES, node.id, node);
+    logIn(w, ctx, node, "create", { name: node.name, kind: node.kind });
     w.put(NAMES, await claimId(parent.owner, parent.id, key), { nodeId: node.id, owner: parent.owner, parentId: parent.id });
     if (sharing) w.put("resources", node.id, await resourceDoc(node, parent));
     return { node, replacedBlob: null };
@@ -402,6 +439,8 @@ function createDrive(deps) {
     }
     const moved = { ...node, parentId: dest.id, name, nameKey: key, updatedAt: now(), ...stamp(ctx, node) };
     w.put(NODES, moved.id, moved);
+    if (moved.name !== node.name) logIn(w, ctx, moved, "rename", { from: node.name, to: moved.name });
+    if (moved.parentId !== node.parentId) logIn(w, ctx, moved, "move", { from: node.parentId, to: moved.parentId });
     const [from, to] = [await claimId(node.owner, node.parentId, node.nameKey), await claimId(dest.owner, dest.id, key)];
     if (from !== to) {
       if ((await ops.get(NAMES, from))?.nodeId === node.id) w.remove(NAMES, from);
@@ -514,6 +553,7 @@ function createDrive(deps) {
       const all = await rawOwnerNodes(owner, true);
       if (all.length === 0) {
         await finishResource(principal, await rootResource(owner));
+        for (const entry of await allWhere(store, ACTIVITY, { itemId: ROOT_ID, owner })) await store.delete(ACTIVITY, entry.id);
         return removed;
       }
       removed += await removeNodes(all, void 0, principal);
@@ -592,6 +632,7 @@ function createDrive(deps) {
       const chunk = rows.slice(i, i + size);
       for (const node of chunk) if (node.blobKey) await blobs.delete(node.blobKey);
       for (const node of chunk) await finishResource(principal, node.id);
+      for (const node of chunk) for (const entry of await allWhere(store, ACTIVITY, { itemId: node.id, owner: node.owner })) await store.delete(ACTIVITY, entry.id);
       await transact(async (tx) => {
         const held = [];
         for (const node of chunk) {
@@ -619,6 +660,30 @@ function createDrive(deps) {
     async stat(ctx, loc) {
       return resolve(store, ctx, loc);
     },
+    /**
+     * The changes made to one item, newest first: who (a person or an agent), what, and when. Anyone who may read
+     * the item may read its log. A trashed item can be named by id, so its log can be read before a restore.
+     */
+    async listActivity(ctx, loc, opts = {}) {
+      const limit = opts.limit ?? 100;
+      if (!Number.isInteger(limit) || limit < 1) throw new RangeError("limit must be an integer of 1 or more");
+      const node = loc.includes("/") ? await resolve(store, ctx, loc) : await fetch(store, ctx, loc);
+      if (!node) throw new DriveError("NOT_FOUND", `no item ${loc}`);
+      const owner = node.owner === ctx.owner;
+      const out = [];
+      for (let cursor; out.length < limit; ) {
+        const page = await store.query(ACTIVITY, { where: { itemId: node.id, owner: node.owner }, orderBy: { field: "at", direction: "desc" }, limit: Math.min(limit - out.length, 100), cursor });
+        for (const e of page.items) {
+          if (!shown(e.data)) continue;
+          const entry = publicActivity(e.data);
+          if (!owner && (entry.action === "share" || entry.action === "unshare")) keepVia(entry);
+          out.push(entry);
+        }
+        if (!page.nextCursor) break;
+        cursor = page.nextCursor;
+      }
+      return out;
+    },
     /** Live children, sorted by name. */
     async list(ctx, loc = "/") {
       const folder = await resolve(store, ctx, loc);
@@ -735,6 +800,8 @@ function createDrive(deps) {
         const t = now();
         const trashed = { ...node, trashed: true, trashedAt: t, updatedAt: t, ...stamp(ctx2, node) };
         await tx.put(NODES, node.id, trashed);
+        const entry = activityDoc(ctx2, node, "delete");
+        await tx.put(ACTIVITY, entry.id, entry);
         if (held?.nodeId === node.id) await tx.delete(NAMES, claim);
         return trashed;
       });
@@ -788,6 +855,8 @@ function createDrive(deps) {
         }
         const restored = { ...node, parentId: parent.id, name, nameKey: key, trashed: false, trashedAt: null, updatedAt: now(), ...stamp(ctx2, node) };
         await tx.put(NODES, restored.id, restored);
+        const entry = activityDoc(ctx2, restored, "restore");
+        await tx.put(ACTIVITY, entry.id, entry);
         await tx.put(NAMES, await claimId(parent.owner, parent.id, key), { nodeId: restored.id, owner: parent.owner, parentId: parent.id });
         if (sharing && parent.id !== node.parentId) await tx.put("resources", restored.id, await resourceDoc(restored, parent));
         return restored;
@@ -938,6 +1007,7 @@ function createDrive(deps) {
         if (removed === 0 && !gone) console.error(`claimRef could not remove ${node.id} after a failed share. Purge it.`);
         throw error;
       }
+      await store.put(ACTIVITY, ...logDoc(ctx, node, "share", { subjectKind: subject.kind, subjectId: subject.id, role: claim.role }));
       return node;
     },
     /** An app deleted a document. Its references in this drive go to the trash. Returns how many. */
@@ -966,7 +1036,7 @@ function createDrive(deps) {
     async exportPerson(ctx) {
       await need(ctx, "read", rootNode(ctx.owner, ctx.actor));
       const subject = subjectOf(ctx);
-      if (!isInPerson(ctx)) return { subject, partial: true, authored: [], agents: [], shares: { held: [], invitesCreated: [] }, audit: [] };
+      if (!isInPerson(ctx)) return { subject, partial: true, authored: [], agents: [], shares: { held: [], invitesCreated: [] }, audit: [], activity: [] };
       const { actors, ownedAgents } = await actorsOf(store, subject.id);
       const authored = (await madeBy(store, actors)).filter((n) => n.owner !== subject.id && n.purging !== true).map((n) => ({
         id: n.id,
@@ -995,7 +1065,18 @@ function createDrive(deps) {
         }
       }
       audit.sort((x, y) => x.at - y.at);
-      return { subject, partial: false, authored, agents, shares: { held, invitesCreated }, audit };
+      const activity = [];
+      for (const actor of actors) {
+        for (const e of await allWhere(store, ACTIVITY, { actorId: actor })) {
+          if (!shown(e.data)) continue;
+          const doc = e.data;
+          const entry = publicActivity(doc);
+          if (doc.owner !== subject.id && !ownedAgents.includes(doc.owner)) keepVia(entry);
+          activity.push(entry);
+        }
+      }
+      activity.sort((x, y) => x.at - y.at || (x.id < y.id ? -1 : 1));
+      return { subject, partial: false, authored, agents, shares: { held, invitesCreated }, audit, activity };
     },
     /**
      * Erases a person for good. Only the person in person may. Their drive and its shares go. So do the shares
@@ -1043,16 +1124,38 @@ function createDrive(deps) {
           }
         });
       }
+      for (const actor of actors) {
+        const mine = await allWhere(store, ACTIVITY, { actorId: actor });
+        for (let i = 0; i < mine.length; i += CHUNK) {
+          await transact(async (tx) => {
+            for (const e of mine.slice(i, i + CHUNK)) await tx.put(ACTIVITY, e.id, { ...e.data, actorId: ERASED, actor: { ...e.data.actor, id: ERASED } });
+          });
+        }
+      }
+      for (const [actor, kind] of heldBy(subjectOf(ctx), ownedAgents)) {
+        for (const e of await allWhere(store, ACTIVITY, { subjectId: actor, subjectKind: kind })) {
+          await store.put(ACTIVITY, e.id, { ...e.data, subjectId: ERASED, detail: { ...e.data.detail, subjectId: ERASED } });
+        }
+      }
       return { removed, grants, invites, anonymized: todo.length };
     },
     /** Gives a person or an agent a role on an item and everything under it. Only an owner may. */
     async shareWith(ctx, loc, subject, role) {
-      const resource = await resourceOf(await resolve(store, ctx, loc));
-      await viaSharing(ctx, (s, p) => s.grant(p, resource, parseSubject(subject), role));
+      const node = await resolve(store, ctx, loc);
+      const resource = await resourceOf(node);
+      const target = parseSubject(subject);
+      const entry = logDoc(ctx, node, "share", { subjectKind: target.kind, subjectId: target.id, role });
+      await viaSharing(ctx, (s, p) => s.grant(p, resource, target, role));
+      await store.put(ACTIVITY, ...entry);
     },
     async unshare(ctx, loc, subject) {
-      const resource = await resourceOf(await resolve(store, ctx, loc));
-      await viaSharing(ctx, (s, p) => s.revokeGrant(p, resource, parseSubject(subject)));
+      const node = await resolve(store, ctx, loc);
+      const resource = await resourceOf(node);
+      const target = parseSubject(subject);
+      const entry = logDoc(ctx, node, "unshare", { subjectKind: target.kind, subjectId: target.id });
+      const held = (await allWhere(store, "grants", { resourceId: resource, subjectId: target.id, subjectKind: target.kind })).length > 0;
+      await viaSharing(ctx, (s, p) => s.revokeGrant(p, resource, target));
+      if (held) await store.put(ACTIVITY, ...entry);
     },
     /** Invite by `email` (a person) or `handle` (an agent). The invite lasts `expiresInMs`, if given. It sends no message. */
     async invite(ctx, loc, input) {
@@ -1061,7 +1164,16 @@ function createDrive(deps) {
     },
     /** `identity` is the verified email of a person, or the handle of an agent. */
     async acceptInvite(ctx, inviteId, identity) {
+      const invite = await store.get("invites", inviteId);
+      const node = typeof invite?.resourceId === "string" ? await store.get(NODES, invite.resourceId) : null;
+      const subjectKind = node && (ctx.actor.kind === "human" || ctx.actor.kind === "agent") ? subjectKindOf(ctx.actor.kind) : null;
+      const roleOf = async () => node && subjectKind ? (await allWhere(store, "grants", { resourceId: node.id, subjectId: ctx.actor.id, subjectKind }))[0]?.data.role ?? null : null;
+      const before = await roleOf();
       await viaSharing(ctx, (s, p) => s.acceptInvite(p, inviteId, identity));
+      const after = await roleOf();
+      if (node && subjectKind && after !== null && after !== before) {
+        await store.put(ACTIVITY, ...logDoc(ctx, node, "share", { subjectKind, subjectId: ctx.actor.id, role: after, via: "invite" }));
+      }
     },
     /** The token comes back once. Only its hash is stored. */
     async createLink(ctx, loc, input) {
@@ -1316,7 +1428,7 @@ async function buildExport(drive, ctx, now = Date.now) {
     };
   });
   const person = await drive.exportPerson(ctx);
-  const manifest = { format: "agentic-drive-export", version: 2, exportedAt: now(), owner: ctx.owner, subject: person.subject, partial: person.partial, items, authored: person.authored, agents: person.agents, shares: person.shares, audit: person.audit };
+  const manifest = { format: "agentic-drive-export", version: 2, exportedAt: now(), owner: ctx.owner, subject: person.subject, partial: person.partial, items, authored: person.authored, agents: person.agents, shares: person.shares, audit: person.audit, activity: person.activity };
   return writeZip([{ name: "manifest.json", data: new TextEncoder().encode(JSON.stringify(manifest, null, 2)) }, ...entries], now());
 }
 
@@ -1398,7 +1510,7 @@ function backfillResources(store, options = {}) {
 import { createHash } from "crypto";
 import { existsSync } from "fs";
 import { join } from "path";
-import { createSharing, isMachineMade, isScope, issueCredential, revokeCredential } from "agentic-identity";
+import { createSharing, isMachineMade as isMachineMade2, isScope, issueCredential, revokeCredential } from "agentic-identity";
 import { createFileBlobs, createFileStore } from "agentic-identity/file";
 function openLocal(dir, opts = {}) {
   if (!opts.beforeImport && existsSync(join(dir, "db", "store.jsonl")) && !existsSync(join(dir, "store.json"))) {
@@ -1462,8 +1574,8 @@ async function revokeKey(store, token) {
 }
 function publicNode(node, path) {
   const { nameKey: _nameKey, blobKey: _blobKey, purging: _purging, ...rest } = node;
-  const shown = { ...rest, machineMade: isMachineMade(node.createdBy.kind) };
-  return path === void 0 ? shown : { path, ...shown };
+  const shown2 = { ...rest, machineMade: isMachineMade2(node.createdBy.kind) };
+  return path === void 0 ? shown2 : { path, ...shown2 };
 }
 
 export {

package/dist/{chunk-6UQ6CDLJ.js → chunk-D6KW6NVM.js}

@@ -1,6 +1,6 @@
 // src/version.ts
 import { createRequire } from "module";
-var VERSION = true ? "0.8.0" : readPackageVersion();
+var VERSION = true ? "0.9.1" : readPackageVersion();
 
 export {
   VERSION

package/dist/{chunk-LELTSSZF.js → chunk-SEHT5Q5L.js}

@@ -48,6 +48,8 @@ var ROLES = ["viewer", "commenter", "editor", "owner"];
 var oneOf = (list) => (v) => typeof v === "string" && list.includes(v);
 var actor = (v) => record(v) && text(v.id) && oneOf(Object.keys(ACTOR_KINDS))(v.kind);
 var isItem = (v) => record(v) && text(v.id) && text(v.owner) && text(v.parentId) && text(v.name) && (v.kind === "folder" || v.kind === "file" || v.kind === "ref") && num(v.size) && orNull(text)(v.mime) && orNull(text)(v.hash) && orNull(text)(v.ref) && num(v.createdAt) && num(v.updatedAt) && actor(v.createdBy) && actor(v.updatedBy) && text(v.createdById) && text(v.updatedById) && typeof v.trashed === "boolean" && orNull(num)(v.trashedAt) && typeof v.machineMade === "boolean";
+var ACTIVITY_ACTIONS = ["create", "rename", "move", "update", "share", "unshare", "delete", "restore"];
+var isActivity = (v) => record(v) && text(v.id) && text(v.itemId) && oneOf(ACTIVITY_ACTIONS)(v.action) && record(v.actor) && text(v.actor.id) && oneOf(["human", "agent"])(v.actor.kind) && oneOf(Object.keys(ACTOR_KINDS))(v.principalKind) && num(v.at) && (v.detail === void 0 || record(v.detail));
 var isPathItem = (v) => isItem(v) && typeof v.path === "string";
 var listOf = (check) => (v) => Array.isArray(v) && v.every(check);
 var shape = (test) => (v) => record(v) && test(v);
@@ -186,6 +188,8 @@ function createClient(options) {
   return {
     /** The live items of a folder. */
     list: (path = "/", o = {}) => json("GET", `/items${query({ path })}`, o, listOf(isItem)),
+    /** The changes made to an item, newest first. `idOrPath` is an id or a path. */
+    listActivity: (idOrPath, opts = {}) => json("GET", `/items/${encodeURIComponent(idOrPath)}/activity${query({ limit: opts.limit })}`, opts, listOf(isActivity)),
     stat: (path, o = {}) => json("GET", `/stat${query({ path })}`, o, isItem),
     mkdir: (path, opts = {}, o = {}) => json("POST", "/folders", { json: { path, parents: opts.parents === true }, ...o }, isItem),
     /** Writes a file. A `ReadableStream` body streams in runtimes that allow it. */

package/dist/cli.js

@@ -4,7 +4,7 @@ import {
 } from "./chunk-AB2RTTHJ.js";
 import {
   VERSION
-} from "./chunk-6UQ6CDLJ.js";
+} from "./chunk-D6KW6NVM.js";
 import {
   AuthError,
   DriveError,
@@ -20,7 +20,7 @@ import {
   revokeKey,
   revokePrincipal,
   upload
-} from "./chunk-R2DUVOJT.js";
+} from "./chunk-622NAJ6K.js";
 
 // src/cli.ts
 import { createReadStream, realpathSync, writeFileSync } from "fs";
@@ -36,6 +36,7 @@ Usage: agentic-drive <command> [flags]
 Commands:
   ls [path]                    List a folder.
   stat <path|id>               Show one item.
+  activity <path|id> [--limit] List the changes to an item: who (person or AI agent), what, when.
   mkdir <path> [-p]            Make a folder.
   upload <local> <remote>      Upload a file. End remote with "/" to keep the name.
   download <remote> [out]      Save a file. Use "-" for stdout.
@@ -78,7 +79,7 @@ Flags:
 
 Exit codes: 0 done, 1 error, 2 bad usage, 3 no principal or an invalid key.
 `;
-var COMMANDS = ["ls", "stat", "mkdir", "upload", "download", "mv", "rm", "trash", "restore", "purge", "search", "export", "home", "register", "find-ref", "claim-ref", "forget", "shares", "share", "unshare", "invite", "accept-invite", "link-create", "link-revoke", "delete-all", "mcp", "principal", "key"];
+var COMMANDS = ["ls", "stat", "activity", "mkdir", "upload", "download", "mv", "rm", "trash", "restore", "purge", "search", "export", "home", "register", "find-ref", "claim-ref", "forget", "shares", "share", "unshare", "invite", "accept-invite", "link-create", "link-revoke", "delete-all", "mcp", "principal", "key"];
 var UsageError = class extends Error {
 };
 var options = {
@@ -166,6 +167,14 @@ async function runCli(argv, io) {
         need(1, "stat <path|id>");
         print(publicNode(await drive.stat(ctx, args[0])));
         break;
+      case "activity":
+        need(1, "activity <path|id> [--limit n]");
+        {
+          const limit = num(values.limit, "limit");
+          if (limit !== void 0 && (!Number.isInteger(limit) || limit < 1)) throw new UsageError("--limit needs a whole number of 1 or more");
+          print(await drive.listActivity(ctx, args[0], { limit }));
+        }
+        break;
       case "mkdir":
         need(1, "mkdir <path> [-p]");
         print(publicNode(await drive.mkdir(ctx, args[0], { parents: values.parents })));

package/dist/client.d.ts

@@ -1,4 +1,5 @@
-import { E as ErrorCode, N as Node, S as SearchQuery } from './drive-Dxy0gL0_.js';
+import { E as ErrorCode, N as Node, A as ActivityEntry, S as SearchQuery } from './drive-BRg1Uj_3.js';
+export { a as ActivityAction } from './drive-BRg1Uj_3.js';
 import 'agentic-identity';
 
 type Role = "viewer" | "commenter" | "editor" | "owner";
@@ -49,6 +50,10 @@ interface Downloaded {
 declare function createClient(options: ClientOptions): {
     /** The live items of a folder. */
     list: (path?: string, o?: CallOptions) => Promise<Item[]>;
+    /** The changes made to an item, newest first. `idOrPath` is an id or a path. */
+    listActivity: (idOrPath: string, opts?: {
+        limit?: number;
+    } & CallOptions) => Promise<ActivityEntry[]>;
     stat: (path: string, o?: CallOptions) => Promise<Item>;
     mkdir: (path: string, opts?: {
         parents?: boolean;
@@ -186,4 +191,4 @@ declare function createClient(options: ClientOptions): {
 };
 type DriveClient = ReturnType<typeof createClient>;
 
-export { type ApiErrorCode, type CallOptions, type ClientErrorCode, type ClientOptions, type Downloaded, DriveApiError, type DriveClient, ErrorCode, type Item, Node, type OnConflict, type PathItem, type Role, type Subject, type SubjectKind, type UploadBody, createClient };
+export { ActivityEntry, type ApiErrorCode, type CallOptions, type ClientErrorCode, type ClientOptions, type Downloaded, DriveApiError, type DriveClient, ErrorCode, type Item, Node, type OnConflict, type PathItem, type Role, type Subject, type SubjectKind, type UploadBody, createClient };

package/dist/client.js

@@ -1,7 +1,7 @@
 import {
   DriveApiError,
   createClient
-} from "./chunk-LELTSSZF.js";
+} from "./chunk-SEHT5Q5L.js";
 export {
   DriveApiError,
   createClient

package/dist/{drive-Dxy0gL0_.d.ts → drive-BRg1Uj_3.d.ts}

@@ -8,6 +8,22 @@ type Actor = {
     id: string;
     kind: ActorKind;
 };
+type ActivityAction = "create" | "rename" | "move" | "update" | "share" | "unshare" | "delete" | "restore";
+/** One change to an item. `actor.kind` is `agent` for every principal that is not a person, so a reader can label machine-made changes. */
+type ActivityEntry = {
+    id: string;
+    itemId: string;
+    action: ActivityAction;
+    actor: {
+        id: string;
+        kind: "human" | "agent";
+    };
+    /** The kind of principal behind the change, such as `agent_of_human`. */
+    principalKind: ActorKind;
+    at: number;
+    /** What changed, such as `{ from, to }` for a rename. Never file content. */
+    detail?: Record<string, string | number | null>;
+};
 /**
  * `owner` is the drive's owner, and the root of the caller's chain. `actor` is who acts for them.
  * `principal` is the resolved caller. Drive needs it to check roles when `sharing` is set.
@@ -98,6 +114,13 @@ declare function subjectKindOf(kind: unknown): SubjectKind;
 declare function parseSubject(input: unknown): Subject;
 declare function createDrive(deps: DriveDeps): {
     stat(ctx: Ctx, loc: string): Promise<Node>;
+    /**
+     * The changes made to one item, newest first: who (a person or an agent), what, and when. Anyone who may read
+     * the item may read its log. A trashed item can be named by id, so its log can be read before a restore.
+     */
+    listActivity(ctx: Ctx, loc: string, opts?: {
+        limit?: number;
+    }): Promise<ActivityEntry[]>;
     /** Live children, sorted by name. */
     list(ctx: Ctx, loc?: string): Promise<Node[]>;
     mkdir(ctx: Ctx, path: string, opts?: {
@@ -274,6 +297,7 @@ declare function createDrive(deps: DriveDeps): {
             principalKind: unknown;
             machineMade: unknown;
         }[];
+        activity: ActivityEntry[];
     }>;
     /**
      * Erases a person for good. Only the person in person may. Their drive and its shares go. So do the shares
@@ -356,4 +380,4 @@ declare function createDrive(deps: DriveDeps): {
     }>;
 };
 
-export { type Actor as A, type Ctx as C, type Drive as D, type ErrorCode as E, type Node as N, type OnConflict as O, ROOT_ID as R, type SearchQuery as S, ACTOR_KINDS as a, type Action as b, type ActorKind as c, type Can as d, type DriveDeps as e, DriveError as f, ERROR_STATUS as g, createDrive as h, parseSubject as i, parseName as p, subjectKindOf as s };
+export { type ActivityEntry as A, type Ctx as C, type Drive as D, type ErrorCode as E, type Node as N, type OnConflict as O, ROOT_ID as R, type SearchQuery as S, type ActivityAction as a, type Actor as b, ACTOR_KINDS as c, type Action as d, type ActorKind as e, type Can as f, type DriveDeps as g, DriveError as h, ERROR_STATUS as i, createDrive as j, parseSubject as k, parseName as p, subjectKindOf as s };