@opencxh/domain 1.172.1 → 1.173.0

package/dist/entities/interaction/types.d.ts

@@ -2,26 +2,26 @@ import { InteractionParticipant } from '../../platform/communication';
 import { ActivityType, InteractionStatus } from '../activity/types';
 export interface ActivityPreview {
     activityId: string;
-    /** Ook een door een app gedeclareerd type; de union houdt alleen de autocomplete. */
+    /** Also an app-declared type; the union only keeps the autocomplete. */
     type: ActivityType | (string & {});
     /**
-     * De regel zoals de server hem kon maken. Voor ingebouwde types is dit de tekst zelf;
-     * voor een gedeclareerd type de al opgeloste versie in de org-taal.
+     * The line as the server could build it. For built-in types this is the text itself; for a
+     * declared type the already-resolved version in the org language.
      *
-     * Server-consumenten (zoek, assistent, analytics) hebben geen gebruikerstaal en lezen
-     * dit veld. De client geeft de voorkeur aan {@link snippetKey}.
+     * Server consumers (search, assistant, analytics) have no user language and read this field.
+     * The client prefers {@link snippetKey}.
      */
     snippet: string;
     authorName: string;
     direction: "inbound" | "outbound" | "internal" | "none";
     createdAt: number;
     /**
-     * Vertaalsleutel plus al uitgelezen parameters, voor types die er een declareerden.
+     * Translation key plus already-extracted parameters, for types that declared one.
      *
-     * De preview wordt éénmalig op de server berekend en opgeslagen, maar elke lezer heeft
-     * zijn eigen taal. Door de sleutel te bewaren in plaats van alleen de zin kan de
-     * inboxlijst hem in de taal van de kijker tekenen. (De ingebouwde snippets zijn nu nog
-     * hardcoded Nederlands — dezelfde constructie lost dat later op.)
+     * The preview is computed and stored once on the server, but every reader has their own
+     * language. Keeping the key instead of only the sentence lets the inbox list draw it in the
+     * viewer's language. (The built-in snippets are still hardcoded Dutch — the same construction
+     * fixes that later.)
      */
     snippetKey?: string;
     snippetParams?: Record<string, string>;
@@ -70,49 +70,47 @@ export interface Interaction {
     assignedTopicId?: string;
     channelId?: string;
     /**
-     * Afgeleide match-sleutel `<scheme>:<resource>` van het channel-adres.
-     * Stabiel over channel-relink heen (nieuwe channelId, zelfde adres), zodat de
-     * koppeling met het channel niet verloren gaat. Server-side afgeleid uit
-     * `channel.addressUri`.
+     * Derived match key `<scheme>:<resource>` of the channel address. Stable across a channel relink
+     * (new channelId, same address), so the link with the channel is not lost. Derived server-side
+     * from `channel.addressUri`.
      */
     channelUriKey?: string;
     title: string;
-    /** Eén definitie, gedeeld met `INTERACTION_STATUS_CHANGED`, zodat de tijdlijn elke
-     *  overgang kan vastleggen die dit veld kan maken. */
+    /** One definition, shared with `INTERACTION_STATUS_CHANGED`, so the timeline can record every
+     *  transition this field can make. */
     status: InteractionStatus;
     /**
-     * UX-shape van de interactie. "thread" = email-stijl met aparte replyable
-     * berichten (inline reply per activity). "conversation" = chat-stijl met
-     * doorlopende stream en één bottom-composer. Backend mag dit zetten; bij
-     * afwezigheid leidt de frontend het af uit `remoteParty.scheme`.
+     * UX shape of the interaction. "thread" = email style with separately replyable messages (inline
+     * reply per activity). "conversation" = chat style with a continuous stream and one bottom
+     * composer. The backend may set this; when absent the frontend derives it from
+     * `remoteParty.scheme`.
      */
     shape?: "thread" | "conversation";
     priority: "urgent" | "high" | "normal" | "low";
     /**
-     * "Headline" tegenpartij — voor 1-1 (mail/sms/direct chat) de enige
-     * counterparty; voor group-chats/meetings de groep- of meeting-Uri.
+     * "Headline" counterparty — for 1-1 (mail/sms/direct chat) the only counterparty; for group
+     * chats and meetings the group or meeting Uri.
      */
     remoteParty: InteractionParticipant;
     /**
-     * Alle deelnemers behalve het eigen channel. Optioneel voor backward-
-     * compatibility met bestaande interacties; voor 1-1 mag leeg of
-     * `[remoteParty]` zijn (UI valt terug op `remoteParty`). Voor group-chats
-     * en meetings hier de volledige lijst inclusief rollen (cc/bcc/organizer/…).
+     * Every participant except our own channel. Optional for backward compatibility with existing
+     * interactions; for 1-1 it may be empty or `[remoteParty]` (the UI falls back to
+     * `remoteParty`). For group chats and meetings the full list here, roles included
+     * (cc/bcc/organizer/…).
      */
     participants?: InteractionParticipant[];
     /**
-     * Canonieke identiteitssleutels van de tegenpartij — de andere helft van `channelUriKey`,
-     * dat onze eigen kant canonicaliseert. Geïndexeerd, zodat "elk gesprek met dit adres, dit
-     * nummer of dit domein" een indexvraag is en geen scan.
+     * Canonical identity keys of the counterparty — the other half of `channelUriKey`, which
+     * canonicalizes our own side. Indexed, so "every conversation with this address, this number or
+     * this domain" is an index question and not a scan.
      *
-     * Bevat `mailto:`/`tel:`-sleutels, een `domain:<registreerbaar>`-pseudosleutel voor
-     * niet-publieke e-maildomeinen, en `company:<id>`/`contact:<id>` wanneer een mens een
-     * koppeling expliciet heeft gelegd.
+     * Holds `mailto:`/`tel:` keys, a `domain:<registrable>` pseudo key for non-public email domains,
+     * and `company:<id>`/`contact:<id>` when a person made a link explicitly.
      *
-     * **Een sleutel wordt nooit onwaar.** "Dit adres kwam voor in dit gesprek" blijft altijd
-     * gelden, terwijl een afgeleide `companyId` onwaar wordt zodra iemand een bedrijf aanmaakt,
-     * samenvoegt of corrigeert — en dan backfill zou vragen. Los een identiteit bij het lezen op
-     * naar zijn sleutels en het antwoord omvat ook gesprekken van vóór die identiteit bestond.
+     * **A key never becomes false.** "This address appeared in this conversation" always keeps
+     * holding, whereas a derived `companyId` becomes false as soon as someone creates, merges or
+     * corrects a company — and would then demand a backfill. Resolve an identity to its keys at read
+     * time and the answer also covers conversations from before that identity existed.
      */
     partyKeys?: string[];
     source?: InteractionSource;
@@ -129,16 +127,15 @@ export interface Interaction {
     lastActivityAt?: number;
     lastActivityPreview?: ActivityPreview;
     /**
-     * Epoch-ms van de eerste uitgaande reactie op deze interactie. Eenmalig gezet door
-     * `applyActivityToInteraction` bij de eerste outbound-activity; drijft de first-response-time
-     * analytics-metric (firstResponseAt - createdAt). Afwezig = nog geen reactie.
+     * Epoch ms of the first outgoing reply to this interaction. Set once by
+     * `applyActivityToInteraction` on the first outbound activity; drives the first-response-time
+     * analytics metric (firstResponseAt - createdAt). Absent = no reply yet.
      */
     firstResponseAt?: number;
     /**
-     * Provider-side folder waar deze thread onder gearchiveerd staat (mail).
-     * Gezet door de sync (folder-membership van already-engaged threads) en door
-     * `folder.move`. Drijft de Folders-nav-filter en de two-way move. Afwezig =
-     * niet in een specifieke folder (of provider zonder folder-capability).
+     * Provider-side folder this thread is archived under (mail). Set by the sync (folder membership
+     * of already-engaged threads) and by `folder.move`. Drives the Folders nav filter and the two-way
+     * move. Absent = not in a specific folder (or a provider without folder capability).
      */
     folderRef?: {
         channelId: string;
@@ -146,10 +143,10 @@ export interface Interaction {
         name: string;
     };
     /**
-     * Epoch-ms tot wanneer de interactie gesnoozed is. Zolang `snoozedTill > now`
-     * wordt de interactie uit de lijst gefilterd (status is dan "snoozed"). Een
-     * cron-job wekt verlopen snoozes: zet status terug naar "open", bumpt
-     * `lastActivityAt` en wist `snoozedTill` (op null). `null`/afwezig = niet gesnoozed.
+     * Epoch ms until which the interaction is snoozed. While `snoozedTill > now` the interaction is
+     * filtered out of the list (its status is then "snoozed"). A cron job wakes expired snoozes: sets
+     * status back to "open", bumps `lastActivityAt` and clears `snoozedTill` (to null). `null`/absent
+     * = not snoozed.
      */
     snoozedTill?: number | null;
 }

package/dist/entities/live-lens/types.d.ts

@@ -1,79 +1,74 @@
-import { OwnerScope } from '../scope/types';
 import { ConditionStep, ForEachStep, LookupStep, ParallelStep, Step } from '../playbook/types';
+import { OwnerScope } from '../scope/types';
 /**
- * Een **leesbaan**: wat er meeleest tijdens een levend gesprek, en aan wie het iets toont.
- *
- * **Waarom dit een eigen entity is en geen playbook met een `stream`-trigger.** Dat was het:
- * `PlaybookTrigger` had een arm `{ kind: "stream" }` met opzet zonder velden, en zo'n rij deed
- * daarna niets van wat een playbook doet — geen run, geen job, geen lock, geen goedkeuringspoort,
- * geen `finalizeRun`. `live-assist` bouwde met de hand een `RunContext` en riep `executeFlow`
- * direct aan.
+ * A **read lane**: what listens along during a live conversation, and who it shows something to.
  *
- * De prijs stond in de velden: `autonomy`, `agentId`, `procedure`, `stats`, `lastRunAt` en
- * `debounceMs` waren voor zo'n rij allemaal betekenisloos, en `steps` mocht maar vier van de tien
- * staptypes bevatten. Iedere lezer van `Playbook` moest dus impliciet weten of hij naar een
- * automatisering of naar een leesbaan keek, met twee functies in domain als vangnet en een
- * tabel-scan-plus-cache als selectie.
+ * **Why this is its own entity and not a playbook with a `stream` trigger.** It used to be one:
+ * `PlaybookTrigger` had a deliberately field-less `{ kind: "stream" }` arm, and such a row then did
+ * none of what a playbook does — no run, no job, no lock, no approval gate, no `finalizeRun`.
  *
- * Definities horen gescheiden te zijn naar hun **runtime**, niet naar hun editor. Een leesbaan
- * heeft geen run, dus is het geen playbook.
+ * The price was in the fields: `autonomy`, `agentId`, `procedure`, `stats`, `lastRunAt` and
+ * `debounceMs` were all meaningless for such a row, and `steps` could hold only four of the ten
+ * step types. Every reader of `Playbook` had to implicitly know whether it was looking at an
+ * automation or at a read lane.
  *
- * Wat hij deelt met een playbook is de **staptaal** en de executor — niet de tabel.
+ * Definitions belong separated by their **runtime**, not by their editor. A read lane has no run,
+ * so it is not a playbook. What it shares with a playbook is the **step language** and the
+ * executor — not the table.
  */
 /**
- * Wat een leesbaan mag doen: opzoeken, kiezen, en dat desnoods parallel of per item.
+ * What a read lane may do: look up, choose, and do so in parallel or per item if needed.
  *
- * Dit is een **echt subtype** van {@link Step} en geen lijst met toegestane namen. Alles wat
- * schrijft (`action`), een model kost (`classify`, `generate`, `agent`) of kan pauzeren
- * (`wait-for-*`) valt erbuiten — en pauzeren kán hier ook niet, want er is geen rij om op te
- * hervatten.
+ * This is a **real subtype** of {@link Step} and not a list of allowed names. Anything that writes
+ * (`action`), costs a model call (`classify`, `generate`, `agent`) or can pause (`wait-for-*`) is
+ * outside it — and pausing cannot work here anyway, because there is no row to resume on.
  *
- * Dat het een type is en geen controle is de winst: een leesbaan die zou schrijven is nu een
- * typefout bij het bouwen, in plaats van een validatie die pas bij het opslaan (of erger: bij de
- * eerste ronde, tijdens een telefoongesprek) iets zegt.
+ * That it is a type and not a check is the win: a read lane that would write is now a type error
+ * while building, instead of a validation speaking up at save time (or worse: on the first round,
+ * during a phone call).
  *
- * Wie tijdens een gesprek iets wíl laten schrijven, doet dat met een playbook op een
- * `activity`-trigger. Die heeft een run, een eigenaar en een goedkeuringspoort.
+ * Anyone who *does* want something written during a call uses a playbook on an `activity` trigger.
+ * That one has a run, an owner and an approval gate.
  */
 export type ReadStep = LookupStep | ConditionStep | ForEachStep<ReadStep> | ParallelStep<ReadStep>;
-/** De staptypes die een leesbaan mag bevatten — de runtime-tegenhanger van {@link ReadStep}. */
+/** The step types a read lane may hold — the runtime counterpart of {@link ReadStep}. */
 export declare const READ_STEP_TYPES: readonly string[];
 export interface LiveLens {
     id: string;
     organizationId: string;
-    /** Voor wie deze baan loopt. De werkmodus selecteert de team-banen; zie {@link selectLenses}. */
+    /** Who this lane runs for. The work mode selects the team lanes; see {@link selectLenses}. */
     ownerScope: OwnerScope;
     name: string;
     description?: string;
     enabled: boolean;
-    /** Wat er opgezocht wordt. Alleen lezen — zie {@link ReadStep}. */
+    /** What gets looked up. Read-only — see {@link ReadStep}. */
     steps: ReadStep[];
     createdBy: string;
 }
 /**
- * Waarom deze stappenlijst geen leesbaan mag zijn, of `null` als hij het mag.
+ * Why this step list may not be a read lane, or `null` when it may.
  *
- * Nodig ondanks {@link ReadStep}, want een `POST` levert JSON en daar helpt een type niet: dit is
- * de poort bij het **opslaan**. Hij draaide voorheen bij élke ronde, elke acht seconden per lopend
- * gesprek, om een eigenschap te controleren die bij het opslaan al vaststond.
+ * Needed despite {@link ReadStep}, because a `POST` delivers JSON and a type does not help there:
+ * this is the gate at **save** time. It used to run on *every* round, every eight seconds per live
+ * call, to check a property that was already settled at save time.
  *
- * Een reden en geen boolean, omdat een geweigerde baan anders stil niets doet — precies de klasse
- * fout die "ik heb hem aangezet en er komt niets" onbeantwoordbaar maakt.
+ * A reason and not a boolean, because a refused lane otherwise silently does nothing — exactly the
+ * class of bug that makes "I switched it on and nothing comes" unanswerable.
  */
 export declare function readStepError(steps: readonly Step[]): string | null;
 /**
- * De leesbanen die bij déze medewerker op dít moment horen.
+ * The read lanes belonging to *this* agent at *this* moment.
  *
- * De werkmodus is wat een team-baan selecteert: zonder die keuze zouden bij iemand die in Sales
- * én Support zit beide baansets tegelijk meelezen — het probleem waarvoor de werkmodus bestaat.
- * Persoonlijke en org-brede banen staan er los van.
+ * The work mode is what selects a team lane: without that choice, someone in both Sales and
+ * Support would have both lane sets listening at once — the problem the work mode exists for.
+ * Personal and org-wide lanes are independent of it.
  *
- * Merk op dat de *acting identity* van een ronde altijd de medewerker zelf is, ook bij een team-
- * of org-brede baan: hij ziet tijdens zijn eigen gesprek nooit meer dan hij mag zien. De eigenaar
- * bepaalt hier alleen wélke banen er lopen.
+ * Note that the *acting identity* of a round is always the agent themselves, also for a team or
+ * org-wide lane: during their own call they never see more than they may see. The owner only
+ * decides *which* lanes run.
  *
- * Geen `skipped`-uitkomst meer: die bestond om een baan te melden die niet mocht meelezen, en dat
- * kan niet meer bestaan — `readStepError` weigert hem bij het opslaan.
+ * No `skipped` outcome any more: that existed to report a lane not allowed to listen, which can no
+ * longer exist — `readStepError` refuses it at save time.
  */
 export declare function selectLenses<T extends Pick<LiveLens, "enabled" | "ownerScope">>(lenses: readonly T[], lens: {
     userId: string;

package/dist/entities/mcp/types.d.ts

@@ -1,40 +1,39 @@
 /** How the AI server authenticates to an MCP server. */
 export type McpAuthMode = "header" | "oauth";
 /**
- * @deprecated Gebruik {@link McpCredentialScope}. Blijft één release staan omdat bestaande
- * rijen `oauth.scope` dragen; `mcpCredentialScope()` leest beide.
+ * @deprecated Use {@link McpCredentialScope}. Stays one release because existing rows carry
+ * `oauth.scope`; `mcpCredentialScope()` reads both.
  */
 export type McpOAuthAccountScope = "user" | "org";
 /**
- * **Hoe deze connector aan zijn credential komt:** één gedeeld organisatie-credential, of
- * iedereen brengt zijn eigen mee.
+ * **How this connector gets its credential:** one shared organisation credential, or everyone
+ * brings their own.
  *
- * Dit is de tweede van de drie scope-vragen, en de enige die op de connector hoort:
+ * The second of the three scope questions, and the only one belonging on the connector:
  *
- * | Vraag | Waar |
+ * | Question | Where |
  * |---|---|
- * | Van wie is deze *rij*? | `ownerUserId` / `ManagedAccount.userId` (afwezig = gedeeld) |
- * | Hoe komt hij aan een credential? | **`credentialScope`** — hier |
- * | Met wie is de *resource* gedeeld? | `ownerScope` op contacten, werkitems, geheugens |
+ * | Whose *row* is this? | `ownerUserId` / `ManagedAccount.userId` (absent = shared) |
+ * | How does it get a credential? | **`credentialScope`** — here |
+ * | Who is the *resource* shared with? | `ownerScope` on contacts, work items, memories |
  *
- * Het is een **configuratiekeuze van de organisatie**, geen eigenschap van de vendor: dezelfde
- * MCP-server kan met één service-account of met een token per gebruiker draaien. Hij hoort dus op
- * de connectorrij, want daar woont configuratie.
+ * It is a **configuration choice of the organisation**, not a property of the vendor: the same MCP
+ * server can run on one service account or on a token per user. So it belongs on the connector
+ * row, where configuration lives.
  *
- * De consequentie die hem belangrijk maakt: **een onbemande run (sync, cron, playbook) heeft geen
- * handelende gebruiker en kan dus nooit bij een `"per-user"`-credential.** Dat is vooraf te
- * controleren en uit te leggen, in plaats van te eindigen als een ronde die nul tools zag.
+ * The consequence that makes it matter: **an unattended run (sync, cron, playbook) has no acting
+ * user and can therefore never reach a `"per-user"` credential.** That is checkable and
+ * explainable up front, instead of ending as a round that saw zero tools.
  *
- * `personalConnect` is hier expliciet géén onderdeel van: dat is een *permissie* (mag een lid zijn
- * eigen token aan een beheerder-gedefinieerde server hangen), niet een scope. Alleen zinvol samen
- * met `"per-user"`.
+ * `personalConnect` is explicitly not part of this: that is a *permission* (may a member hang
+ * their own token on an admin-defined server), not a scope. Only meaningful with `"per-user"`.
  */
 export type McpCredentialScope = "shared" | "per-user";
 /**
- * De credential-scope van een server, met terugval op de oude velden.
+ * A server's credential scope, falling back to the old fields.
  *
- * Bestaande rijen dragen `oauth.scope`; nieuwe dragen `credentialScope`. Eén functie zodat
- * "wie brengt het token mee" nergens twee keer wordt uitgerekend.
+ * Existing rows carry `oauth.scope`; new ones carry `credentialScope`. One function, so "who
+ * brings the token" is never computed twice.
  */
 export declare function mcpCredentialScope(server: {
     credentialScope?: McpCredentialScope;
@@ -44,12 +43,11 @@ export declare function mcpCredentialScope(server: {
     };
 }): McpCredentialScope;
 /**
- * De naamconventie van een MCP-tool, op één plek.
+ * The naming convention of an MCP tool, in one place.
  *
- * Een tool heet `mcp__<connectorId>__<toolnaam>`. Het connector-id is per organisatie
- * willekeurig, dus een app kan de naam niet hardcoderen — maar zodra hij het id *heeft*
- * (bijvoorbeeld omdat de koppeling het expliciet bewaart) is dit een pure string en is er
- * geen enkele lookup nodig.
+ * A tool is called `mcp__<connectorId>__<toolname>`. The connector id is arbitrary per
+ * organisation, so an app cannot hardcode the name — but once it *has* the id (because the
+ * connection stores it explicitly, say) this is a pure string and no lookup is needed at all.
  */
 export declare function mcpToolPrefix(connectorId: string): string;
 /**
@@ -75,11 +73,11 @@ export interface McpServerConfig {
     organizationId: string;
     name: string;
     /**
-     * De catalogus-sleutel waar deze verbinding uit komt, als hint voor pickers.
+     * The catalog key this connection came from, as a hint for pickers.
      *
-     * Stond wél op de write-body maar niet op de read view, en dáárom moest het "welke verbinding is
-     * Asana"-antwoord server-side verzonnen worden: een client kón het niet zien. Nu wel, en dan is
-     * voorfilteren gewoon een `filter` in de UI.
+     * It was on the write body but not on the read view, which is why the "which connection is
+     * Asana" answer had to be invented server-side: a client could not see it. Now it can, and
+     * pre-filtering is just a `filter` in the UI.
      */
     catalogKey?: string;
     /** Only Streamable HTTP transport is supported for server-side connections. */
@@ -93,21 +91,21 @@ export interface McpServerConfig {
     /** OAuth settings, present when `authMode === "oauth"`. */
     oauth?: McpOAuthClientView;
     /**
-     * Hoe deze connector aan zijn credential komt. Afwezig op oude rijen — lees hem altijd via
-     * {@link mcpCredentialScope}, nooit rechtstreeks.
+     * How this connector gets its credential. Absent on old rows — always read it through
+     * {@link mcpCredentialScope}, never directly.
      */
     credentialScope?: McpCredentialScope;
     /**
-     * Van wie is deze RIJ: afwezig = door de organisatie gedefinieerd (beheerder), gezet = de
-     * eigen custom server van die gebruiker. Bepaalt wie hem mag wijzigen en waar hij zichtbaar
-     * is — los van {@link McpCredentialScope}, dat over het credential gaat.
+     * Whose ROW this is: absent = defined by the organisation (an admin), set = that user's own
+     * custom server. Decides who may change it and where it is visible — separate from
+     * {@link McpCredentialScope}, which is about the credential.
      */
     ownerUserId?: string;
     /**
-     * PERMISSIE, geen scope: mag een lid zijn eigen credential hangen aan deze door de
-     * organisatie gedefinieerde server (de "catalogus")? Alleen zinvol bij
-     * `credentialScope === "per-user"`. Bewust niet afgeleid — dat zou het recht stil
-     * verruimen voor servers waar de beheerder het juist niet toestond.
+     * A PERMISSION, not a scope: may a member hang their own credential on this
+     * organisation-defined server (the "catalog")? Only meaningful with
+     * `credentialScope === "per-user"`. Deliberately not derived — that would silently widen the
+     * right for servers where the admin did not allow it.
      */
     personalConnect?: boolean;
 }
@@ -140,33 +138,32 @@ export interface McpCatalogEntry {
         scope?: McpOAuthAccountScope;
         scopes?: string[];
     };
-    /** De voorgestelde default bij het toevoegen. Afwezig = afleiden uit `oauth.scope`. */
+    /** The suggested default when adding. Absent = derive from `oauth.scope`. */
     credentialScope?: McpCredentialScope;
 }
 /**
- * Wat een app over een **gekozen** connector mag weten.
+ * What an app may know about a **chosen** connector.
  *
- * Dit is een preflight, geen zoekopdracht: je komt hier met een id dat iemand bij het
- * configureren heeft vastgelegd, en de vraag is alleen "kan ik hem nog gebruiken". Een lookup
- * op primary key, dus deterministisch van constructie — anders dan de eerdere zoekopdracht op
- * catalogus-sleutel, die bij twee kandidaten een willekeurige winnaar koos.
+ * A preflight, not a search: you arrive with an id someone recorded while configuring, and the
+ * question is only "can I still use it". A lookup on primary key, so deterministic by
+ * construction — unlike the earlier search by catalog key, which picked an arbitrary winner
+ * whenever there were two candidates.
  */
 export interface McpConnectorDescribe {
     id: string;
     name: string;
-    /** Alleen als hij uit de catalogus komt. */
+    /** Only when it came from the catalog. */
     catalogKey?: string;
     enabled: boolean;
     credentialScope: McpCredentialScope;
     /**
-     * Er bestaat een gedeeld organisatie-credential.
+     * A shared organisation credential exists.
      *
-     * De enige vorm die een onbemande run kan gebruiken: die heeft geen handelende gebruiker en
-     * kan dus niet bij een persoonlijk token. `false` bij een `"per-user"`-connector, ook als
-     * tien mensen persoonlijk verbonden zijn.
+     * The only form an unattended run can use: it has no acting user and so cannot reach a personal
+     * token. `false` on a `"per-user"` connector, even when ten people are personally connected.
      */
     sharedCredential: boolean;
-    /** `mcp__<id>__`, hetzelfde als {@link mcpToolPrefix} — meegegeven zodat de beller niets rekent. */
+    /** `mcp__<id>__`, same as {@link mcpToolPrefix} — passed along so the caller computes nothing. */
     toolPrefix: string;
 }
 /** Body accepted by the create/update endpoints (write shape, distinct from the read view). */
@@ -174,13 +171,12 @@ export interface McpServerInput {
     name?: string;
     url?: string;
     /**
-     * De catalogus-sleutel waar dit uit komt ({@link McpCatalogEntry.key}).
+     * The catalog key this came from ({@link McpCatalogEntry.key}).
      *
-     * **Een hint, geen resolutie.** Hij filtert de connector-picker ("welke van jouw
-     * verbindingen is Asana") en voedt de "al toegevoegd"-status in de catalogus. Wie een
-     * connector nodig heeft bewaart het connector-**id** expliciet en gebruikt
-     * {@link mcpToolPrefix} — een zoekopdracht op key kan bij twee kandidaten geen winnaar
-     * kiezen en heeft dat eerder ook niet gedaan.
+     * **A hint, not a resolution.** It filters the connector picker ("which of your connections is
+     * Asana") and feeds the "already added" status in the catalog. Anything needing a connector
+     * stores the connector **id** explicitly and uses {@link mcpToolPrefix} — a search by key cannot
+     * pick a winner with two candidates, and never could.
      */
     catalogKey?: string;
     enabled?: boolean;

package/dist/entities/memory/alias.d.ts

@@ -1,19 +1,19 @@
 import { MemorySubjectKey } from './item';
 /**
- * Twee subjects die hetzelfde blijken te zijn (een merge van interacties, later een echte
- * identiteitslaag). Het geheugen verhuist niet: de alias wordt bij het lezen opgelost.
+ * Two subjects that turn out to be the same (a merge of interactions, later a real identity
+ * layer). The memory does not move: the alias is resolved at read time.
  *
- * **Eén niveau diep by construction**: een alias wiens `canonical` zelf een alias is wordt
- * geweigerd bij het schrijven. Resolutie is daarmee twee queries en nooit recursief — geen
- * cyclus-detectie, geen diepte-limiet, geen verrassing op het hete pad.
+ * **One level deep by construction**: an alias whose `canonical` is itself an alias is refused at
+ * write time. Resolution is therefore two queries and never recursive — no cycle detection, no
+ * depth limit, no surprise on the hot path.
  */
 export interface MemorySubjectAlias {
     id: string;
     organizationId: string;
-    /** Het subject dat is opgegaan in `canonical`. Unique per org. */
+    /** The subject that was absorbed into `canonical`. Unique per org. */
     subject: MemorySubjectKey;
     canonical: MemorySubjectKey;
-    /** De app die de samenvoeging meldde. */
+    /** The app that reported the merge. */
     source: string;
     createdAt?: number;
 }

package/dist/entities/memory/browse.d.ts

@@ -1,38 +1,38 @@
 import { MemoryItem, MemoryKindId, MemoryVisibility } from './item';
 /**
- * Het beheer-contract: **alles** wat er in het geheugen van deze organisatie staat, plat.
+ * The admin contract: **everything** in this organisation's memory, flat.
  *
- * Bewust géén tweede `MemoryQuery`. Dat contract is de retrieval-engine — ranking, embeddings,
- * tekenbudget, autorisatie per subject — en beantwoordt "wat is hier relevant". Deze vraagt
- * "wat staat er". Dezelfde route zou beide slechter doen: de engine moet mogen wegfilteren wat
- * niet scoort, en een beheerpagina mag juist niets stilhouden.
+ * Deliberately not a second `MemoryQuery`. That contract is the retrieval engine — ranking,
+ * embeddings, character budget, authorization per subject — and answers "what is relevant here".
+ * This one asks "what is there". One route would do both worse: the engine must be allowed to
+ * filter out what does not score, and an admin page must keep nothing quiet.
  */
 export interface MemoryBrowseQuery {
-    /** Exacte soort. Leeg = alle. */
+    /** Exact kind. Empty = all of them. */
     kind?: MemoryKindId;
-    /** Schrijvende app (`ai`, `comms`, `context`, …). */
+    /** Writing app (`ai`, `comms`, `context`, …). */
     source?: string;
-    /** Het deel vóór de `:` van het subject — `interaction`, `contact`, `company`. */
+    /** The part before the subject's `:` — `interaction`, `contact`, `company`. */
     subjectKind?: string;
-    /** Exact subject, bv. `contact:c_9`. Wint van {@link subjectKind}. */
+    /** Exact subject, e.g. `contact:c_9`. Beats {@link subjectKind}. */
     subject?: string;
     visibility?: MemoryVisibility;
-    /** Alleen items met `occurredAt >= since` (ms). */
+    /** Only items with `occurredAt >= since` (ms). */
     since?: number;
-    /** Scan-cap. Geklemd op {@link MAX_MEMORY_BROWSE}. */
+    /** Scan cap. Clamped to {@link MAX_MEMORY_BROWSE}. */
     limit?: number;
 }
 /**
- * Harde bovengrens op één beheer-scan.
+ * Hard upper bound on one admin scan.
  *
- * Er is geen full-text-operator in deze datastore, dus vrij zoeken gebeurt ná het ophalen. Zonder
- * cap zou een organisatie met tienduizenden items haar hele geheugen door één response persen.
- * Wordt de cap geraakt, dan zegt {@link MemoryBrowseResult.truncated} dat — stil afkappen op een
- * pagina die "alles" belooft is de ene fout die hier niet mag.
+ * There is no full-text operator in this datastore, so free search happens after fetching. Without
+ * a cap an organisation with tens of thousands of items would squeeze its whole memory through one
+ * response. When the cap is hit, {@link MemoryBrowseResult.truncated} says so — silently
+ * truncating on a page promising "everything" is the one mistake not allowed here.
  */
 export declare const MAX_MEMORY_BROWSE = 1000;
 export interface MemoryBrowseFacets {
-    /** Bronnen die in deze scan voorkomen, met hun aantal. Aflopend. */
+    /** Sources occurring in this scan, with their count. Descending. */
     sources: Array<{
         value: string;
         count: number;
@@ -48,13 +48,13 @@ export interface MemoryBrowseFacets {
 }
 export interface MemoryBrowseResult {
     items: MemoryItem[];
-    /** Hoeveel rijen het structurele filter opleverde (== `items.length`, of de cap). */
+    /** How many rows the structural filter yielded (== `items.length`, or the cap). */
     scanned: number;
-    /** Cap geraakt: er is méér dan dit. Verfijn het filter. */
+    /** Cap hit: there is more than this. Narrow the filter. */
     truncated?: boolean;
     /**
-     * Wat er in deze scan te kiezen valt. Afgeleid uit de scan en niet uit een `DISTINCT`, want
-     * die bestaat hier niet — bij `truncated` zijn dit dus de facetten van het zichtbare deel.
+     * What there is to choose in this scan. Derived from the scan and not from a `DISTINCT`, which
+     * does not exist here — so on `truncated` these are the facets of the visible part.
      */
     facets: MemoryBrowseFacets;
 }