@wirecat/cli-core 0.419.0 → 0.421.0

package/dist/meetings/testing/event-store-contract.js

@@ -0,0 +1,161 @@
+import assert from "node:assert/strict";
+const HOUR = 3_600_000;
+/** "Now" in every case: entries before it have happened. */
+export const CONTRACT_NOW = 1_000 * HOUR;
+const single = (externalId, at, extra = {}) => ({
+    externalId,
+    kind: "single",
+    status: "confirmed",
+    title: "Example review",
+    startsAt: at,
+    endsAt: at + HOUR,
+    ...extra,
+});
+export const eventStoreContract = (make) => {
+    const test = (name, check) => ({
+        name,
+        async run() {
+            const fixture = await make();
+            const [calendar] = await fixture.store.saveCalendars(fixture.accountId, [{ externalId: "primary", title: "Work", timezone: "UTC", accessRole: "owner", primary: true }], 1);
+            await check({ ...fixture, calendar: calendar.id });
+        },
+    });
+    const second = async ({ store, accountId }, externalId = "personal") => (await store.saveCalendars(accountId, [{ externalId, title: externalId, timezone: "UTC", accessRole: "owner", primary: false }], 1))[0].id;
+    const later = CONTRACT_NOW + 24 * HOUR;
+    const earlier = CONTRACT_NOW - 24 * HOUR;
+    return [
+        test("a calendar the owner owns syncs; one shared with them is listed and does not", async ({ store, accountId, }) => {
+            await store.saveCalendars(accountId, [{ externalId: "team", title: "Team", timezone: null, accessRole: "reader", primary: false }], 2);
+            assert.deepEqual((await store.calendars(accountId)).map(({ externalId, synced }) => [externalId, synced]), [
+                ["primary", true],
+                ["team", false],
+            ]);
+        }),
+        test("rule 1: the same calendar and id is the same entry; a change keeps the old values", async ({ store, calendar, }) => {
+            const [first] = await store.saveEntries(calendar, [single("e1", later)], 2);
+            const [again] = await store.saveEntries(calendar, [single("e1", later + HOUR, { title: "Moved review" })], 3);
+            assert.equal(again?.id, first?.id);
+            assert.equal(again?.eventId, first?.eventId);
+            const details = await store.event(first?.eventId);
+            assert.equal(details?.event.title, "Moved review");
+            assert.equal(details?.event.startsAt, later + HOUR);
+            assert.equal(details?.event.origin, "calendar");
+            assert.deepEqual(details?.revisions.map(({ title, startsAt }) => [title, startsAt]), [["Example review", later]]);
+        }),
+        test("rule 2: a plain occurrence and the exception of its slot are one entry, the series in any order", async ({ store, calendar, }) => {
+            const slot = later;
+            const occurrence = (externalId, extra = {}) => single(externalId, slot, { kind: "occurrence", seriesExternalId: "s1", originalStartsAt: slot, ...extra });
+            const [plain] = await store.saveEntries(calendar, [occurrence("s1_slot")], 2);
+            await store.saveEntries(calendar, [{ ...single("s1", earlier), kind: "series", recurrence: ["RRULE:FREQ=WEEKLY"], recurrenceEndsAt: null }], 3);
+            const [exception] = await store.saveEntries(calendar, [occurrence("s1_moved", { exception: true, startsAt: slot + HOUR, endsAt: slot + 2 * HOUR })], 4);
+            assert.equal(exception?.id, plain?.id);
+            assert.notEqual(exception?.seriesEntryId, null);
+            const details = await store.event(exception?.eventId);
+            assert.equal(details?.event.startsAt, slot + HOUR);
+            assert.notEqual(details?.event.eventSeriesId, null);
+        }),
+        test("rule 3: another calendar's copy with the same iCalUID is the same event", async (fixture) => {
+            const { store, calendar } = fixture;
+            const other = await second(fixture);
+            const [work] = await store.saveEntries(calendar, [single("w1", later, { icalUid: "uid-1@example.com" })], 2);
+            const [home] = await store.saveEntries(other, [single("p1", later, { icalUid: "uid-1@example.com" })], 3);
+            assert.equal(home?.eventId, work?.eventId);
+            assert.equal((await store.event(work?.eventId))?.entries.length, 2);
+        }),
+        test("rule 5: otherwise a new event of origin calendar; a slot cancelled before it was stored is none", async ({ store, calendar, }) => {
+            const [one, two, gone] = await store.saveEntries(calendar, [single("a", later), single("b", later), single("c", later, { status: "cancelled" })], 2);
+            assert.notEqual(one?.eventId, two?.eventId);
+            assert.equal(gone?.eventId, null);
+            assert.equal((await store.events({ from: later, to: later + HOUR })).length, 2);
+        }),
+        test("two candidates: no link and one review entry, kept through a second sync and an owner's decision", async (fixture) => {
+            const { store, calendar } = fixture;
+            const other = await second(fixture);
+            const third = await second(fixture, "third");
+            const [a] = await store.saveEntries(calendar, [single("a", later, { icalUid: "first" })], 2);
+            const [b] = await store.saveEntries(other, [single("b", later, { icalUid: "second" })], 2);
+            await store.saveEntries(calendar, [single("a", later, { icalUid: "shared" })], 3);
+            await store.saveEntries(other, [single("b", later, { icalUid: "shared" })], 3);
+            const [c] = await store.saveEntries(third, [single("c", later, { icalUid: "shared" })], 4);
+            assert.equal(c?.eventId, null);
+            await store.saveEntries(third, [single("c", later, { icalUid: "shared" })], 5);
+            const open = await store.reviews({ status: "open" });
+            assert.equal(open.length, 1);
+            assert.deepEqual(open[0]?.candidates, [a?.eventId, b?.eventId].sort((x, y) => x - y));
+            await store.resolveReview(open[0]?.id, { choose: b?.eventId }, 6);
+            await store.saveEntries(third, [single("c", later, { icalUid: "shared" })], 7);
+            const [after] = await store.saveEntries(third, [single("c", later, { icalUid: "shared" })], 8);
+            assert.equal(after?.eventId, b?.eventId);
+            assert.deepEqual((await store.reviews()).map(({ status }) => status), ["linked"]);
+        }),
+        test("the owner's unlink holds: no rule links the entry again", async ({ store, calendar }) => {
+            const [entry] = await store.saveEntries(calendar, [single("a", later)], 2);
+            await store.unlinkEntry(entry?.id, 3);
+            const [again] = await store.saveEntries(calendar, [single("a", later, { title: "Renamed" })], 4);
+            assert.equal(again?.eventId, null);
+            await store.linkEntry(entry?.id, entry?.eventId, 5);
+            const [linked] = await store.saveEntries(calendar, [single("a", later)], 6);
+            assert.equal(linked?.eventId, entry?.eventId);
+        }),
+        test("a deleted single event: past stays as history, future is cancelled", async ({ store, calendar }) => {
+            const [past, future] = await store.saveEntries(calendar, [single("p", earlier), single("f", later)], 2);
+            await store.saveEntries(calendar, [single("p", earlier, { status: "cancelled" }), single("f", later, { status: "cancelled" })], CONTRACT_NOW);
+            const happened = (await store.event(past?.eventId))?.event;
+            assert.equal(happened?.sourceDeletedAt, CONTRACT_NOW);
+            assert.notEqual(happened?.status, "cancelled");
+            assert.equal(happened?.title, "Example review");
+            const cancelled = (await store.event(future?.eventId))?.event;
+            assert.equal(cancelled?.status, "cancelled");
+            assert.equal(cancelled?.sourceDeletedAt, null);
+        }),
+        test("a whole series deleted: its entries cancel, past occurrences stay, future ones cancel", async ({ store, calendar, }) => {
+            const series = {
+                ...single("s", earlier - HOUR),
+                kind: "series",
+                icalUid: "series@example.com",
+                recurrence: ["RRULE:FREQ=DAILY"],
+            };
+            const occurrence = (at) => single(`s_${at}`, at, { kind: "occurrence", seriesExternalId: "s", originalStartsAt: at });
+            const [, past, future] = await store.saveEntries(calendar, [series, occurrence(earlier), occurrence(later)], 2);
+            await store.saveEntries(calendar, [{ ...series, status: "cancelled" }], CONTRACT_NOW);
+            const before = await store.event(past?.eventId);
+            assert.equal(before?.event.sourceDeletedAt, CONTRACT_NOW);
+            assert.equal(before?.entries[0]?.status, "cancelled");
+            const after = await store.event(future?.eventId);
+            assert.equal(after?.event.status, "cancelled");
+        }),
+        test("a full list marks the entries it did not return, plain occurrences only inside the window", async ({ store, calendar, }) => {
+            const outside = later + 30 * 24 * HOUR;
+            const [kept, gone, far] = await store.saveEntries(calendar, [
+                single("kept", later),
+                single("gone", later),
+                single("far", outside, { kind: "occurrence", seriesExternalId: "x", originalStartsAt: outside }),
+            ], 2);
+            await store.saveEntries(calendar, [single("kept", later)], 10);
+            assert.equal(await store.markUnseen(calendar, 10, { from: earlier, to: later + 24 * HOUR }, 11), 1);
+            const entries = new Map((await store.event(gone?.eventId))?.entries.map((entry) => [entry.externalId, entry]));
+            assert.equal(entries.get("gone")?.deletedAt, 11);
+            assert.notEqual(await store.event(gone?.eventId), null);
+            assert.equal((await store.event(kept?.eventId))?.entries[0]?.deletedAt, null);
+            assert.equal((await store.event(far?.eventId))?.entries[0]?.deletedAt, null);
+        }),
+        test("participants are kept by address; a room is listed and is no contact", async ({ store, calendar }) => {
+            const [entry] = await store.saveEntries(calendar, [
+                single("a", later, {
+                    participants: [
+                        { email: "Alice@Example.com", name: "Alice Example", response: "accepted" },
+                        { email: "room-1@resource.example.com", name: "Room 1", resource: true },
+                    ],
+                }),
+            ], 2);
+            const participants = (await store.event(entry?.eventId))?.participants ?? [];
+            assert.deepEqual(participants.map(({ email, resource, identityId }) => [email, resource, identityId === null]), [
+                ["alice@example.com", false, false],
+                ["room-1@resource.example.com", true, true],
+            ]);
+        }),
+        test("an entry that ends before it starts is refused", async ({ store, calendar }) => {
+            await assert.rejects(store.saveEntries(calendar, [single("bad", later, { endsAt: later - 1 })], 2));
+        }),
+    ];
+};

package/dist/meetings/testing/index.d.ts

@@ -1,4 +1,5 @@
 export { meetingStoreContract } from "./contract.js";
+export { CONTRACT_NOW, type EventStoreFixture, eventStoreContract } from "./event-store-contract.js";
 export { type MeetingManagementContractFixture, meetingManagementContract } from "./management-contract.js";
 export { memoryMeetingStore } from "./memory.js";
 export { type RecordingSyncCheckpointFixture, recordingSyncCheckpointStoreContract, } from "./recording-sync-contract.js";

package/dist/meetings/testing/index.js

@@ -1,4 +1,5 @@
 export { meetingStoreContract } from "./contract.js";
+export { CONTRACT_NOW, eventStoreContract } from "./event-store-contract.js";
 export { meetingManagementContract } from "./management-contract.js";
 export { memoryMeetingStore } from "./memory.js";
 export { recordingSyncCheckpointStoreContract, } from "./recording-sync-contract.js";

package/dist/parity/manifest.js

@@ -1,4 +1,3 @@
-import { MOVED_TO_MEMO } from "../cli/moved.js";
 export const longName = (flags) => flags.split(/[\s,|]+/).find((part) => part.startsWith("--")) ?? flags;
 const presence = (entry) => (typeof entry === "string" ? { in: entry } : entry);
 /** `true` the CLI must have it, `false` it must not, `undefined` it is planned and either passes. */
@@ -93,9 +92,6 @@ export const manifestProblems = (manifest) => {
         }
         optionEntries(path, row.options ?? {});
     }
-    for (const path of Object.keys(manifest.commands))
-        if (Object.keys(MOVED_TO_MEMO).some((moved) => path === moved || path.startsWith(`${moved} `)))
-            problems.push(`${path}: moved to memo (src/cli/moved.ts), so a source tool has no row for it`);
     for (const [name, option] of Object.entries(manifest.options)) {
         if (!option.meaning)
             problems.push(`options ${name}: no meaning`);

package/dist/search/account-list.js

@@ -1,5 +1,5 @@
 import { CliError } from "@wirecat/cli-base";
-import { FOLDER_PROVIDER, INTERNAL_NOTES, isKind, kindIn, kindOf, providerNamed, providers as registered, UNKNOWN_PROVIDER, } from "../domain/providers.js";
+import { INTERNAL_NOTES, isDocumentAccountProvider, isFolderProvider, isKind, kindIn, kindOf, providerNamed, providers as registered, UNKNOWN_PROVIDER, } from "../domain/providers.js";
 import { isBotProvider } from "./query.js";
 /** Store-wide: every profile, tg, MAX and memo reads the same groups. */
 export const ACCOUNT_GROUPS = "accountGroups";
@@ -29,13 +29,29 @@ const describe = (accounts) => accounts.map(({ provider, account, name }) => `${
 const kindHere = (provider, running) => provider === running.provider ? kindOf(provider) : kindIn(provider);
 const heldOf = (stored, running) => [
     ...stored
-        .filter(({ provider }) => kindIn(provider) !== "notes")
+        .filter(({ provider }) => kindIn(provider) !== "notes" && !isDocumentAccountProvider(provider))
         .map(({ provider, account, name }) => ({ provider, account, name, kind: kindHere(provider, running) })),
     { provider: "notes", account: INTERNAL_NOTES, name: null, kind: "notes" },
     ...stored
-        .filter(({ provider }) => provider === FOLDER_PROVIDER)
-        .map(({ id, name }) => ({ provider: "notes", account: String(id), name, kind: "notes" })),
+        .filter(({ provider }) => isFolderProvider(provider))
+        .map(({ id, name, provider }) => ({
+        provider: "notes",
+        account: String(id),
+        name,
+        kind: "notes",
+        folder: provider,
+    })),
+    ...stored
+        .filter(({ provider }) => isDocumentAccountProvider(provider))
+        .map(({ id, provider, account, name }) => ({
+        provider: "notes",
+        account: String(id),
+        name,
+        kind: "notes",
+        stored: { provider, account },
+    })),
 ];
+const storedAs = (held, key) => held.filter(({ stored }) => stored?.provider === key.provider && (key.account === "" || stored.account === key.account));
 const registry = () => registered()
     .map(({ name, aliases }) => (aliases.length ? `${name} (${aliases.join(", ")})` : name))
     .join(", ");
@@ -44,7 +60,7 @@ const providerOf = (prefix, held, { running, profiles }) => {
     if (wanted === running.command?.toLowerCase())
         return running.provider;
     const providers = [...new Set(held.map(({ provider }) => provider))];
-    if (providers.includes(wanted))
+    if (providers.includes(wanted) || isDocumentAccountProvider(wanted))
         return wanted;
     const named = providerNamed(wanted);
     if (named)
@@ -57,6 +73,11 @@ const providerOf = (prefix, held, { running, profiles }) => {
 const profilesOf = (provider, profiles) => Object.values(profiles).flatMap((named) => Object.entries(named).filter(([, key]) => key.provider === provider));
 const accountOf = (prefix, ref, held, context) => {
     const provider = providerOf(prefix, held, context);
+    if (isDocumentAccountProvider(provider) && !context.profiles[prefix.toLowerCase()]?.[ref]) {
+        const stored = storedAs(held, { provider, account: ref })[0];
+        if (stored)
+            return stored;
+    }
     const ofProvider = held.filter((one) => one.provider === provider);
     const byId = ofProvider.find(({ account }) => account === ref || account === ref.toLowerCase());
     if (byId)
@@ -67,12 +88,18 @@ const accountOf = (prefix, ref, held, context) => {
         kind: kindHere(key.provider, context.running),
     };
     const recorded = context.profiles[prefix.toLowerCase()]?.[ref];
-    if (recorded?.provider === FOLDER_PROVIDER) {
+    if (recorded && isFolderProvider(recorded.provider)) {
         const folder = held.find((one) => one.provider === "notes" && one.name === recorded.account);
         if (folder)
             return folder;
         return fail(`no stored folder for ${prefix}:${ref}; sync that profile first`);
     }
+    if (recorded && isDocumentAccountProvider(recorded.provider)) {
+        const account = storedAs(held, recorded)[0];
+        if (account)
+            return account;
+        return fail(`no stored documents for ${prefix}:${ref}; sync that profile first`);
+    }
     if (recorded)
         return keyed(recorded);
     const byProfile = [
@@ -101,9 +128,14 @@ const accountsOfWord = (word, held, context) => {
     if (isKind(wanted))
         return held.filter(({ kind }) => kind === wanted);
     const recorded = context.profiles[wanted];
-    if (recorded && Object.values(recorded).every((key) => key.provider === FOLDER_PROVIDER))
+    if (recorded &&
+        Object.values(recorded).every((key) => isFolderProvider(key.provider) || isDocumentAccountProvider(key.provider)))
         return Object.keys(recorded).map((profile) => accountOf(word, profile, held, context));
     const provider = providerOf(word, held, context);
+    if (isDocumentAccountProvider(provider))
+        return storedAs(held, { provider, account: "" });
+    if (isFolderProvider(provider))
+        return held.filter(({ folder }) => folder === provider);
     return held.filter((one) => one.provider === provider);
 };
 const keyOf = ({ provider, account }) => `${provider}\u0000${account}`;

package/dist/sends/index.d.ts

@@ -3,7 +3,7 @@ export { type FloodDeadline, FloodMemory, type FloodState, FROZEN_HOLD_MS, flood
 export { type Asker, type GuardRequest, guardFor, type SendGuard, type SendGuardOptions, sendGuard, sharedJournal, } from "./guard.js";
 export { currentOperation, guardedWrite, type Operated } from "./guarded.js";
 export { type AccountAction, type ChatAction, type SendEntry, SendJournal, type SendKind, type SendOutcome, sendsPathFor, } from "./journal.js";
-export { assertStatsPermissionsCurrent, CEILING_KEY, DEFAULT_PERMISSIONS, keyForCommand, keyForWrite, LEVELS, type Level, layerPermissions, levelFor, PERMISSIONS, type Permission, type PermissionKey, permissionFor, permissionOverrides, readKeysForCommand, skipFlagFor, WRITE_KEYS, } from "./permissions.js";
+export { CEILING_KEY, DEFAULT_PERMISSIONS, keyForCommand, keyForWrite, LEVELS, type Level, layerPermissions, levelFor, type PermissionKey, permissionOverrides, readKeysForCommand, skipFlagFor, WRITE_KEYS, } from "./permissions.js";
 export { type Recipient, RecipientList, recipientsPathFor } from "./recipients.js";
 export { newOperationId, newSendId } from "./send-id.js";
 export { MAX_BUFFERED_UPLOAD_BYTES, readUpload, refusedPlace, uploadBlob, uploadBytes, uploadSize, } from "./upload.js";

package/dist/sends/index.js

@@ -2,7 +2,7 @@ export { FloodMemory, FROZEN_HOLD_MS, floodPathFor, LIMITED_HOLD_MS, } from "./f
 export { guardFor, sendGuard, sharedJournal, } from "./guard.js";
 export { currentOperation, guardedWrite } from "./guarded.js";
 export { SendJournal, sendsPathFor, } from "./journal.js";
-export { assertStatsPermissionsCurrent, CEILING_KEY, DEFAULT_PERMISSIONS, keyForCommand, keyForWrite, LEVELS, layerPermissions, levelFor, PERMISSIONS, permissionFor, permissionOverrides, readKeysForCommand, skipFlagFor, WRITE_KEYS, } from "./permissions.js";
+export { CEILING_KEY, DEFAULT_PERMISSIONS, keyForCommand, keyForWrite, LEVELS, layerPermissions, levelFor, permissionOverrides, readKeysForCommand, skipFlagFor, WRITE_KEYS, } from "./permissions.js";
 export { RecipientList, recipientsPathFor } from "./recipients.js";
 export { newOperationId, newSendId } from "./send-id.js";
 export { MAX_BUFFERED_UPLOAD_BYTES, readUpload, refusedPlace, uploadBlob, uploadBytes, uploadSize, } from "./upload.js";

package/dist/sends/permissions.d.ts

@@ -1,13 +1,4 @@
 import type { AccountAction, ChatAction, SendKind } from "./journal.js";
-/**
- * What a profile may be allowed to do (max-cli `CLI-37`, `NEED-251`). One name per thing the owner would
- * recognise, so `sessions` — which logs the owner out of their phone — never rides along with
- * adding a contact. There is no `*`: "everything" is not setting `allow` at all, and a wildcard
- * would switch on `delete` without anyone naming it.
- */
-export declare const PERMISSIONS: readonly ["send", "forward", "reaction", "edit", "pin", "read", "delete", "groups", "contacts", "profile", "folders", "sessions"];
-export type Permission = (typeof PERMISSIONS)[number];
-export declare const permissionFor: (kind: SendKind, action?: string) => Permission;
 /** What a profile may do with one command path — the standard's "Permissions". */
 export declare const LEVELS: readonly ["deny", "readonly", "ask", "allow"];
 export type Level = (typeof LEVELS)[number];
@@ -32,8 +23,6 @@ export declare const isBotApi: (path: readonly string[]) => boolean;
 export declare const botApiAllowed: (levels: Readonly<Record<PermissionKey, Level>>) => boolean;
 /** The resources at the top of the command tree, which `readOnly` and `allow` turn read-only as a whole. */
 export declare const RESOURCES: readonly ["messages", "drafts", "reactions", "polls", "topics", "chats", "contacts", "account", "bot", "conversations", "tags", "mentions", "search", "searches", "tasks", "replies", "attachments", "stats", "store", "metadata", "mcp", "server", "models", "schedule", "doctor", "images"];
-/** The command path an old `allow` word stood for, as one key — what an MCP tool's `permission` is checked against. */
-export declare const keyOfWord: (word: Permission) => PermissionKey;
 /**
  * Layers come nearest first. A key a nearer layer sets hides that key and every key under it in the
  * farther layers, so a profile's `messages: readonly` is not undone by `messages.delete: allow` in
@@ -67,8 +56,6 @@ export declare const writeOfKey: (key: PermissionKey) => {
 };
 /** Every key a write is checked against that a command path may not spell out. */
 export declare const WRITE_KEYS: readonly PermissionKey[];
-/** Statistics and searches moved; a deny under an old path would stop applying unseen, so the command refuses. */
-export declare const assertStatsPermissionsCurrent: (path: readonly string[], permissions: Readonly<Record<string, Level>>) => void;
 export declare const readKeysForCommand: (path: readonly string[]) => PermissionKey[];
 /**
  * The key a command path is checked against: `null` for housekeeping, which no level stops, and

package/dist/sends/permissions.js

@@ -1,66 +1,4 @@
 import { CliError } from "@wirecat/cli-base";
-import { canonicalPermissionKey, canonicalPermissions } from "./permission-aliases.js";
-/**
- * What a profile may be allowed to do (max-cli `CLI-37`, `NEED-251`). One name per thing the owner would
- * recognise, so `sessions` — which logs the owner out of their phone — never rides along with
- * adding a contact. There is no `*`: "everything" is not setting `allow` at all, and a wildcard
- * would switch on `delete` without anyone naming it.
- */
-export const PERMISSIONS = [
-    "send",
-    "forward",
-    "reaction",
-    "edit",
-    "pin",
-    "read",
-    "delete",
-    "groups",
-    "contacts",
-    "profile",
-    "folders",
-    "sessions",
-];
-const ACCOUNT = {
-    "contact-add": "contacts",
-    "contact-remove": "contacts",
-    "contact-import": "contacts",
-    "contact-rename": "contacts",
-    "contact-block": "contacts",
-    "contact-unblock": "contacts",
-    profile: "profile",
-    "folder-create": "folders",
-    "folder-update": "folders",
-    "folder-delete": "folders",
-    "folder-order": "folders",
-    "folder-join": "folders",
-    "sessions-end": "sessions",
-    "chat-mute": "profile",
-    "chat-unmute": "profile",
-    "chat-archive": "profile",
-    "chat-unarchive": "profile",
-    "chat-pin": "profile",
-    "chat-unpin": "profile",
-    "chat-mark-unread": "profile",
-    "message-star": "profile",
-    "message-unstar": "profile",
-    privacy: "profile",
-};
-export const permissionFor = (kind, action) => {
-    switch (kind) {
-        case "message":
-            return "send";
-        case "chat":
-            return "groups";
-        case "account": {
-            const permission = ACCOUNT[action];
-            if (!permission)
-                throw new Error(`an account change without a known action: ${action}`);
-            return permission;
-        }
-        default:
-            return kind;
-    }
-};
 /** What a profile may do with one command path — the standard's "Permissions". */
 export const LEVELS = ["deny", "readonly", "ask", "allow"];
 /** The deletions nobody gets back: the word that skips their question is `--allow-dangerous`, never `--yes`. */
@@ -148,47 +86,6 @@ export const RESOURCES = [
     "doctor",
     "images",
 ];
-const OLD_WORDS = {
-    send: ["messages.send", "polls.create", "chats.start"],
-    forward: ["messages.forward"],
-    reaction: ["reactions", "polls.vote", "messages.press", "chats.app"],
-    edit: ["messages.edit", "polls.close"],
-    pin: ["messages.pin", "messages.unpin"],
-    read: ["chats.mark-read"],
-    delete: ["messages.delete", "chats.delete", "chats.clear"],
-    groups: [
-        "chats.create",
-        "chats.update",
-        "chats.join",
-        "chats.leave",
-        "chats.members",
-        "chats.admins",
-        "chats.links",
-        "chats.requests",
-        "chats.moderate",
-        "topics.enable",
-        "topics.create",
-        "topics.edit",
-        "topics.delete",
-    ],
-    contacts: ["contacts"],
-    profile: ["account.update", "account.privacy.set", "chats.mute", "messages.star", "messages.unstar"],
-    folders: ["chats.folders"],
-    sessions: ["account.sessions.end"],
-};
-/** The command path an old `allow` word stood for, as one key — what an MCP tool's `permission` is checked against. */
-export const keyOfWord = (word) => OLD_WORDS[word][0];
-/**
- * A bot's old words meant its own writes: `profile` was its command menu, and `read` was taking
- * updates, which every level but `deny` allows now.
- */
-const botKeysOf = (word) => {
-    if (word === "profile")
-        return ["bot.commands"];
-    if (word === "read")
-        return [];
-    return OLD_WORDS[word].map((key) => `bot.${key}`);
-};
 /**
  * Layers come nearest first. A key a nearer layer sets hides that key and every key under it in the
  * farther layers, so a profile's `messages: readonly` is not undone by `messages.delete: allow` in
@@ -199,7 +96,7 @@ export const layerPermissions = (layers) => {
     const sources = {};
     for (const [from, layer] of layers) {
         const nearer = Object.keys(levels);
-        for (const [key, level] of Object.entries(canonicalPermissions(layer ?? {}))) {
+        for (const [key, level] of Object.entries(layer ?? {})) {
             if (nearer.some((named) => key === named || key.startsWith(`${named}.`)))
                 continue;
             levels[key] = level;
@@ -224,11 +121,6 @@ const nearest = (levels, key) => {
     }
     return undefined;
 };
-/**
- * `chats unmute` was checked as `chats.mute` before it had its own key; a config that names only the old key
- * keeps meaning it, so a `chats.mute: readonly` written then still stops an unmute.
- */
-const FORMER_KEYS = { "chats.unmute": "chats.mute" };
 /**
  * The most specific key the owner set wins. A built-in default (`DEFAULT_PERMISSIONS`) only ever
  * tightens: against a broader key of the owner's, the stricter of the two holds — so
@@ -236,16 +128,11 @@ const FORMER_KEYS = { "chats.unmute": "chats.mute" };
  * A path nothing names is allowed.
  */
 export const levelFor = (permissions, key, defaults = DEFAULT_PERMISSIONS) => {
-    permissions = canonicalPermissions(permissions);
-    key = canonicalPermissionKey(key);
     const found = profileLevel(permissions, key, defaults);
     const ceiling = permissions[CEILING_KEY];
     return ceiling && ORDER[ceiling] < ORDER[found.level] ? { level: ceiling, key: CEILING_KEY } : found;
 };
 const profileLevel = (permissions, key, defaults) => {
-    const former = FORMER_KEYS[key];
-    if (former !== undefined && permissions[key] === undefined)
-        return profileLevel(permissions, former, defaults);
     const own = nearest(permissions, key);
     const builtIn = nearest(defaults, key);
     if (!builtIn || (own && own.depth >= builtIn.depth))
@@ -254,7 +141,15 @@ const profileLevel = (permissions, key, defaults) => {
         return { level: builtIn.level, key: builtIn.key };
     return { level: own.level, key: own.key };
 };
-const CHAT_KEYS = { settings: "chats.update" };
+const CHAT_KEYS = {
+    settings: "chats.update",
+    "requests.accept": "chats.requests.confirm",
+    "requests.decline": "chats.requests.reject",
+    "link.create": "chats.links.create",
+    "link.reset": "chats.links.reset",
+    "link.revoke": "chats.links.remove",
+    "link.update": "chats.links.update",
+};
 const ACCOUNT_KEYS = {
     "contact-add": "contacts.add",
     "contact-remove": "contacts.remove",
@@ -292,7 +187,7 @@ const KIND_KEYS = {
 /** The command path a guarded write belongs to, when the caller did not name it. */
 export const keyForWrite = (kind, action) => {
     if (kind === "chat")
-        return canonicalPermissionKey(CHAT_KEYS[action ?? ""] ?? `chats.${action ?? "update"}`);
+        return CHAT_KEYS[action] ?? `chats.${action ?? "update"}`;
     if (kind === "account") {
         const key = ACCOUNT_KEYS[action];
         if (!key)
@@ -303,7 +198,6 @@ export const keyForWrite = (kind, action) => {
 };
 /** `keyForWrite` read backwards, as far as a command's key says it: an unpin is a `pin`, a chat change names its action. */
 export const writeOfKey = (key) => {
-    key = canonicalPermissionKey(key);
     const account = Object.entries(ACCOUNT_KEYS).find(([, named]) => named === key)?.[0];
     if (account)
         return { kind: "account", action: account };
@@ -399,8 +293,7 @@ export const WRITE_KEYS = [
         ...Object.values(KIND_KEYS),
         ...Object.values(ACCOUNT_KEYS),
         ...Object.values(CHAT_KEYS),
-        ...PERMISSIONS.flatMap((word) => [...OLD_WORDS[word], ...botKeysOf(word)]),
-    ].map(canonicalPermissionKey)),
+    ]),
 ];
 /** Commands that look after the tool and its files and never show a message: no level stops them. */
 const HOUSEKEEPING = new Set([
@@ -430,21 +323,6 @@ const BOT_HOUSEKEEPING = new Set(["auth", "list", "sends", "recipients", "mcp"])
 const STORE_MAINTENANCE = new Set(["info", "check", "copies"]);
 /** Commands outside `messages` that print what people wrote, so `deny messages` reaches them too. */
 const SHOW_MESSAGES = new Set(["inbox", "review", "watch", "serve", "store", "conversations"]);
-/** Before every search moved under `search` (2026-10-09). */
-const OLD_SEARCH_KEY = /^(bot\.)?(messages|conversations|topics)\.search(?:\.|$)/;
-/** Statistics and searches moved; a deny under an old path would stop applying unseen, so the command refuses. */
-export const assertStatsPermissionsCurrent = (path, permissions) => {
-    if (path[0] === "bot") {
-        assertStatsPermissionsCurrent(path.slice(1), permissions);
-        return;
-    }
-    if (path[0] === "search" && Object.keys(permissions).some((key) => OLD_SEARCH_KEY.test(key)))
-        throw new CliError("configuration_error", "search permission paths have moved — rename messages.search, conversations.search and topics.search to search.messages, search.conversations and search.topics", { retryable: false });
-    if (path[0] !== "stats")
-        return;
-    if (Object.keys(permissions).some((key) => /^(bot\.)?(messages|chats|tasks)\.stats(?:\.|$)/.test(key)))
-        throw new CliError("configuration_error", "statistics permission paths have moved — rename messages.stats, chats.stats and tasks.stats to stats.messages.show, stats.chats.show and stats.tasks.show", { retryable: false });
-};
 export const readKeysForCommand = (path) => {
     if (path[0] === "bot")
         return readKeysForCommand(path.slice(1)).map((key) => `bot.${key}`);
@@ -488,7 +366,6 @@ export const readKeysForCommand = (path) => {
 export const keyForCommand = (path) => {
     if (path.length === 0)
         return null;
-    path = canonicalPermissionKey(path.join(".")).split(".");
     const [top, next] = path;
     if (top === "bot") {
         if (next === undefined || BOT_HOUSEKEEPING.has(next))
@@ -500,7 +377,7 @@ export const keyForCommand = (path) => {
         return path.join(".");
     if (top === undefined || HOUSEKEEPING.has(top) || (top === "search" && next === "runs"))
         return null;
-    // Picture models moved from `models image` (0.270.0); a model is housekeeping wherever it is listed.
+    // A model is housekeeping wherever it is listed.
     if (top === "images" && next === "models")
         return null;
     if (top === "attachments" && (next === "check" || next === "jobs"))
@@ -513,7 +390,7 @@ export const keyForCommand = (path) => {
     if (top === "conversations" && next === "links")
         return path[2] === "rebuild" ? "conversations.links.rebuild" : "conversations.links";
     // Vectors are written to the local store only, and the text never leaves the machine (phase 5 E10).
-    if ((top === "conversations" && next === "embeddings") ||
+    if ((top === "conversations" && (next === "embeddings" || next === "embed")) ||
         (top === "images" && next === "embed") ||
         (top === "conversations" && next === "rebuild"))
         return "conversations.embeddings";
@@ -526,8 +403,6 @@ export const keyForCommand = (path) => {
         return next === "rebuild" || next === "confirm" || next === "reject" ? `mentions.${next}` : "messages";
     if (top === "store" && (next === "gaps" || next === "jobs"))
         return path.join(".");
-    if (top === "messages" && next === "sync")
-        return "messages";
     if (SHOW_MESSAGES.has(top) || (top === "contacts" && (next === "context" || next === "prepare" || next === "events")))
         return "messages";
     if (RESOURCES.includes(top))
@@ -544,12 +419,10 @@ export const permissionOverrides = (entries = []) => {
             throw new CliError("validation_error", "--permission takes a command path and level, e.g. messages.send=allow (deny, readonly, ask, allow)");
         levels[key] = level;
     }
-    return canonicalPermissions(levels);
+    return levels;
 };
 /** No startup flag grants access: an override may narrow the profile's level, never lift it or a key under it. */
 export const assertOverridesTighten = (overrides, profile) => {
-    overrides = canonicalPermissions(overrides);
-    profile = canonicalPermissions(profile);
     for (const [key, level] of Object.entries(overrides)) {
         const under = Object.keys(profile).filter((named) => named.startsWith(`${key}.`));
         const lifted = [key, ...under].find((named) => ORDER[level] > ORDER[levelFor(profile, named).level]);

package/dist/services/agenda.js

@@ -5,6 +5,7 @@ import { agenda } from "../entities/agenda.js";
 import { AGENDA_COLUMNS, inboxKey, queryFilter, } from "../store/store.js";
 import { CHAT_KINDS } from "./chats.js";
 import { taskAccount } from "./task-rules.js";
+import { taskTagFilters } from "./task-tag-filters.js";
 const DAY = 86_400_000;
 const CLAIMS = ["none", "mine", "others", "any"];
 const TASK_FIELDS = new Set(["tag", "category", "claimed"]);
@@ -46,8 +47,9 @@ export const agendaService = (deps, now = Date.now) => ({
             throw error;
         });
         const open = await find();
+        const tags = await taskTagFilters(store, parts.tasks);
         const listed = parts.tasks
-            ? await find(queryFilter(parts.tasks, taskColumns(holder, at), { command: "tasks agenda" }))
+            ? await find(queryFilter(parts.tasks, taskColumns(holder, at, tags), { command: "tasks agenda" }))
             : open;
         const tasks = listed
             .map((task) => ({ task, reasons: reasonsOf(task, at, dueWithin) }))
@@ -148,11 +150,9 @@ const split = (query) => {
     };
     return { tasks: of("tasks"), chats: of("chats") };
 };
-const TAGGED = "EXISTS (SELECT 1 FROM taggings g JOIN tags n ON n.id = g.tag_id " +
-    "WHERE g.taggable_type = 'task' AND g.taggable_id = t.id AND n.name = ?)";
 /** A claim that lapsed holds nothing, as `tasks claim` reads it. */
-const taskColumns = (holder, at) => ({
-    tag: { where: (node) => ({ sql: TAGGED, params: [node.value.trim().toLowerCase()] }) },
+const taskColumns = (holder, at, tags) => ({
+    tag: { where: (node) => tags.get(node.value) ?? { sql: "0", params: [] } },
     category: { type: "kw", sql: "t.category" },
     claimed: {
         where: (node) => {