@opencxh/domain 1.171.0 → 1.172.2

package/dist/entities/activity/resolve.d.ts

@@ -1,18 +1,17 @@
-import { ActivityChannelKind, ActivityShape } from './catalog';
 import { ActivityBlock } from './blocks';
+import { ActivityChannelKind, ActivityShape } from './catalog';
 import { ActivityTypeDescriptor } from './descriptor';
 import { Activity } from './types';
 /**
- * Eén antwoord over een activity-type, ongeacht of het van ons is of van een app.
+ * One answer about an activity type, whether it is ours or an app's.
  *
- * De ingebouwde catalogus en een gedeclareerde descriptor beschrijven hetzelfde, maar in
- * een andere vorm: de eerste gebruikt functies (die geen HTTP-hop overleven), de tweede
- * vertaalsleutels. Deze laag vlakt dat verschil af, zodat de feed, de inboxlijst en de
- * playbook-builder niet elk hun eigen "is het van ons of niet?"-tak krijgen — precies de
- * tweedeling die dit hele traject wilde vermijden.
+ * The built-in catalog and a declared descriptor describe the same thing in a different shape: the
+ * first uses functions (which do not survive an HTTP hop), the second translation keys. This layer
+ * flattens that difference, so the feed, the inbox list and the playbook builder do not each grow
+ * their own "is it ours or not?" branch — exactly the split this whole effort wanted to avoid.
  *
- * Ingebouwd wint bij een botsing. Een app die `EMAIL_RECEIVED` claimt kan de mailweergave
- * dus niet kapen.
+ * Built-in wins on a collision. An app claiming `EMAIL_RECEIVED` therefore cannot hijack the mail
+ * view.
  */
 export interface ResolvedActivityType {
     type: string;
@@ -24,65 +23,65 @@ export interface ResolvedActivityType {
     carriesText: boolean;
     triggerable: boolean;
     component?: string;
-    /** True voor de 41 types die het platform zelf meebrengt. */
+    /** True for the 41 types the platform brings itself. */
     builtIn: boolean;
-    /** De sleutel voor de naam in keuzelijsten; aanwezig zodra een type triggerbaar is. */
+    /** The key for the name in pickers; present as soon as a type is triggerable. */
     displayNameKey?: string;
 }
-/** Vertaalfunctie voor sleutels uit een meegeleverde locale-bundel. */
+/** Translation function for keys from a supplied locale bundle. */
 export type Translate = (key: string, params?: Record<string, string>) => string;
 /**
- * Een opzoeker over de ingebouwde types plus wat apps declareerden.
+ * A lookup over the built-in types plus whatever apps declared.
  *
- * Bewust een expliciet object en geen module-globale registry: op de server leeft elke
- * request in zijn eigen module-instantie, dus een geregistreerde lijst zou daar nooit
- * geraakt worden — en dat zou onzichtbaar zijn.
+ * Deliberately an explicit object and not a module-global registry: on the server every request
+ * lives in its own module instance, so a registered list would never be hit there — and that would
+ * be invisible.
  */
 export declare class ActivityTypeRegistry {
     private readonly translate;
     private readonly declared;
     constructor(descriptors?: ActivityTypeDescriptor[], translate?: Translate);
     get(type: string): ResolvedActivityType | undefined;
-    /** Alles wat als trigger aangeboden mag worden, ingebouwd en gedeclareerd. */
+    /** Everything that may be offered as a trigger, built-in and declared. */
     triggerable(): ResolvedActivityType[];
     /**
-     * De tijdlijnregel. Ingebouwd komt uit de catalogus, gedeclareerd uit `text` + de
-     * meegeleverde vertaling. Zonder bruikbare tekst valt het terug op de ontstreepte
-     * typenaam — dezelfde regel die de feed altijd al toonde voor onbekende types.
+     * The timeline line. Built-in comes from the catalog, declared from `text` plus the supplied
+     * translation. Without usable text it falls back to the de-underscored type name — the same line
+     * the feed always showed for unknown types.
      */
     timelineText(activity: Activity, authorName: string): string;
-    /** De regel voor de inboxlijst. Leeg wanneer het type niets te tonen heeft. */
+    /** The line for the inbox list. Empty when the type has nothing to show. */
     snippet(activity: Activity): string;
-    /** De descriptor zoals hij binnenkwam; nodig om `text` als sleutel op te slaan. */
+    /** The descriptor as it arrived; needed to store `text` as a key. */
     descriptor(type: string): ActivityTypeDescriptor | undefined;
-    /** De declaratieve blokken van een type, als het er heeft. */
+    /** A type's declarative blocks, when it has any. */
     blocks(type: string): ActivityBlock[] | undefined;
     /**
-     * Dezelfde semantische vragen als de losse accessors in `catalog.ts`, maar dan óók voor
-     * types die een app declareerde.
+     * The same semantic questions as the standalone accessors in `catalog.ts`, but for types an app
+     * declared as well.
      *
-     * Dat verschil is de reden dat deze methodes bestaan. `isMessageType(type)` leest alleen
-     * `ACTIVITY_CATALOG`, dus een gedeclareerd type met `shape: "message"` gaf daar `false` —
-     * een helpdesk-app kon een berichtsoort meebrengen die vervolgens niet meetelde als
-     * gesprek, niet antwoordbaar was en niet in de analytics landde. Wie een registry bij de
-     * hand heeft, hoort deze te gebruiken; wie er geen heeft valt terug op de ingebouwde.
+     * That difference is why these methods exist. `isMessageType(type)` reads only
+     * `ACTIVITY_CATALOG`, so a declared type with `shape: "message"` returned `false` there — a
+     * helpdesk app could bring a message kind that then did not count as a conversation, was not
+     * replyable and never landed in the analytics. Anyone with a registry at hand should use these;
+     * anyone without falls back to the built-in ones.
      *
-     * De regel zelf staat maar op één plek: {@link isMessageShape} en de velden van
+     * The rule itself lives in one place: {@link isMessageShape} and the fields of
      * {@link ResolvedActivityType}.
      */
     isMessage(type: string): boolean;
-    /** Kan een mens hierop antwoorden? Notities niet — die gaan nergens heen. */
+    /** Can a person reply to this? Notes cannot — those go nowhere. */
     isReplyable(type: string): boolean;
-    /** Leesbare inhoud voor een model: berichten, notities én transcripten. */
+    /** Readable content for a model: messages, notes and transcripts. */
     carriesText(type: string): boolean;
-    /** Telt mee als in- of uitgaand bericht in de analytics-rollup. */
+    /** Counts as an inbound or outbound message in the analytics rollup. */
     countsAs(type: string): "inbound_message" | "outbound_message" | undefined;
-    /** `mail` | `chat` | `voice` | `video`, of `undefined` voor een levenscyclus-event. */
+    /** `mail` | `chat` | `voice` | `video`, or `undefined` for a lifecycle event. */
     channelKind(type: string): ActivityChannelKind | undefined;
-    /** Transcript-achtig artefact: meegeleverde inhoud die leesbare tekst draagt. */
+    /** Transcript-like artifact: supplied content carrying readable text. */
     isTranscript(type: string): boolean;
-    /** De vertaler die bij deze registry hoort, voor het oplossen van blokteksten. */
+    /** The translator belonging to this registry, for resolving block texts. */
     get translator(): Translate;
 }
-/** De lege registry: alleen de ingebouwde types. Voor code die (nog) geen catalogus laadt. */
+/** The empty registry: built-in types only. For code that does not (yet) load a catalog. */
 export declare const BUILT_IN_ONLY: ActivityTypeRegistry;

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

@@ -1,6 +1,6 @@
 import { ActingIdentity } from '../../platform/identity';
-import { AIMessageInput, AIMessageOutput } from '../ai-message/types';
 import { TranscriptSegment } from '../../platform/media';
+import { AIMessageInput, AIMessageOutput } from '../ai-message/types';
 export type CallStatus = "new" | "connecting" | "ringing" | "connected" | "held" | "ended" | "failed";
 export type CallDirection = "inbound" | "outbound";
 export type CallType = "audio" | "video" | "data" | "screen-share";
@@ -11,9 +11,9 @@ export interface Attachment {
     mimeType: string;
     size?: number;
     url?: string;
-    /** Content-ID voor inline (cid:) referenties in de body — bare, zonder `<>`. */
+    /** Content-ID for inline (cid:) references in the body — bare, without `<>`. */
     contentId?: string;
-    /** True wanneer de bijlage inline in de body hoort (cid:), niet als losse chip. */
+    /** True when the attachment belongs inline in the body (cid:), not as a separate chip. */
     isInline?: boolean;
 }
 export interface BaseActivity {
@@ -24,12 +24,12 @@ export interface BaseActivity {
     providerId: string;
     author: {
         type: "user" | "contact" | "system" | "app";
-        /** Provider/account-id (Microsoft user-id, SIP account-id, etc.). */
+        /** Provider/account id (Microsoft user id, SIP account id, etc.). */
         id?: string;
         name: string;
         /**
-         * Resolved-hint naar Contact-entity. Wordt door provider-sync gezet via
-         * endpoint-lookup. UI mag direct navigeren zonder extra lookup.
+         * Resolved hint to a Contact entity. Set by the provider sync through an endpoint lookup. The
+         * UI may navigate straight there without an extra lookup.
          */
         contactId?: string;
     };
@@ -37,12 +37,12 @@ export interface BaseActivity {
     externalIds?: string[];
     attachments?: Attachment[];
     /**
-     * Activity is optimistisch geschreven en wacht op bevestiging vanuit
-     * provider-sync. Sync zet 'm op `false` zodra de canonieke versie is
-     * opgehaald. UI kan een "verzenden..." indicator tonen wanneer true.
+     * The activity was written optimistically and awaits confirmation from the provider sync. Sync
+     * sets it to `false` once the canonical version is fetched. The UI can show a "sending…"
+     * indicator while true.
      */
     pending?: boolean;
-    /** Epoch ms — matcht DB-model en Interaction.createdAt. */
+    /** Epoch ms — matches the DB model and Interaction.createdAt. */
     createdAt?: number;
     updatedAt?: number;
 }
@@ -166,10 +166,10 @@ export type FileUploadedPayload = {
     fileId?: string;
 };
 /**
- * Elke status die `Interaction.status` kan aannemen, `snoozed` inbegrepen. Die ontbrak,
- * en daardoor had de tijdlijn een gat precies waar hij het meest verrast: parkeren en
- * wakker worden waren de enige twee statuswissels die geen spoor achterlieten, dus een
- * gesprek sprong uit en weer in de lijst zonder dat iets vertelde waarom.
+ * Every status `Interaction.status` can take, `snoozed` included. That one was missing, leaving
+ * the timeline with a gap exactly where it surprises most: snoozing and waking were the only two
+ * status changes leaving no trace, so a conversation jumped out of and back into the list without
+ * anything saying why.
  */
 export type InteractionStatus = "open" | "pending" | "closed" | "snoozed";
 export type InteractionStatusChangedPayload = {
@@ -206,7 +206,7 @@ export type AIActionProposedPayload = {
         params?: Record<string, unknown>;
     }[];
     status: "pending" | "approved" | "rejected";
-    /** Namens wie het voorstel is gedaan, zodat de kaart "namens Finance" kan tonen. */
+    /** Who the proposal was made on behalf of, so the card can show "on behalf of Finance". */
     actor?: ActingIdentity;
 };
 /** Playbook lifecycle marker in the interaction timeline (system-authored). */
@@ -215,7 +215,7 @@ export type PlaybookLifecyclePayload = {
     playbookId?: string;
     playbookName?: string;
     status?: string;
-    /** Namens wie de run handelde; voorkomt dat de UI de playbook opnieuw moet ophalen. */
+    /** Who the run acted for; saves the UI from fetching the playbook again. */
     actor?: ActingIdentity;
 };
 export type Activity = (BaseActivity & {
@@ -343,34 +343,34 @@ export type Activity = (BaseActivity & {
     payload: InteractionAssignedPayload;
 });
 /**
- * Een activity van **welk type dan ook**, inclusief een type dat een app declareerde.
+ * An activity of **any type at all**, including a type an app declared.
  *
- * `Activity` is een gesloten unie over de 41 ingebouwde types, en dat is met opzet: alleen zo
- * weet TypeScript na `activity.type === "EMAIL_RECEIVED"` dat `payload.from` bestaat. Maar
- * `ACTIVITY_TYPE_AUTHORING.md` nodigt apps uit hun eigen type mee te brengen, en zo'n rij
- * pást niet in die unie — vandaar de ~40 `as Activity`-casts die door de repo staan.
+ * `Activity` is a closed union over the 41 built-in types, deliberately: only that way does
+ * TypeScript know after `activity.type === "EMAIL_RECEIVED"` that `payload.from` exists. But
+ * `ACTIVITY_TYPE_AUTHORING.md` invites apps to bring their own type, and such a row does not fit
+ * that union — hence the ~40 `as Activity` casts across the repo.
  *
- * Een open tak ín `Activity` lost dat niet op: dan wordt `payload` overal een unie met
- * `Record<string, unknown>` en verdwijnt precies de versmalling waar de unie voor bestaat.
- * Daarom een eigen naam. Code die ook gedeclareerde types verwerkt — de feed, de
- * inboxregel, de analytics-rollup — typeert op `AnyActivity` en vraagt de catalogus wat het
- * ding is; code die in een payload leest blijft op `Activity` en versmalt.
+ * An open arm *inside* `Activity` does not fix it: `payload` would become a union with
+ * `Record<string, unknown>` everywhere, removing exactly the narrowing the union exists for. Hence
+ * a name of its own. Code that also handles declared types — the feed, the inbox line, the
+ * analytics rollup — types on `AnyActivity` and asks the catalog what the thing is; code reading
+ * into a payload stays on `Activity` and narrows.
  */
 export type AnyActivity = Activity | (BaseActivity & {
     type: string;
     payload: Record<string, unknown>;
 });
 /**
- * Type-guards voor de twee payload-vormen waar de UI rechtstreeks in leest.
+ * Type guards for the two payload shapes the UI reads into directly.
  *
- * Dit zijn bewust wél typenamen en geen catalogus-vraag. De catalogus beantwoordt *semantiek*
- * ("is dit een bericht", "welk kanaal") en dat hoort nooit als typelijstje in een component.
- * Deze twee doen iets anders: ze **versmallen het type**, zodat `activity.payload.from` en
- * `activity.payload.text` erna bestaan. Een `channelKindOf(...) === "mail"` kan dat niet — die
- * geeft een boolean terug en TypeScript weet daarna nog steeds niet welke payload er ligt.
+ * These are deliberately type names and not a catalog question. The catalog answers *semantics*
+ * ("is this a message", "which channel") and that never belongs as a type list inside a component.
+ * These two do something else: they **narrow the type**, so `activity.payload.from` and
+ * `activity.payload.text` exist afterwards. A `channelKindOf(...) === "mail"` cannot do that — it
+ * returns a boolean and TypeScript still does not know which payload is there.
  *
- * Ze staan hier, naast de union, zodat er één plek is die de namen kent in plaats van een
- * herhaling per component.
+ * They live here, next to the union, so one place knows the names instead of a repetition per
+ * component.
  */
 export declare function isEmailActivity(activity: Activity): activity is Extract<Activity, {
     type: "EMAIL_RECEIVED" | "EMAIL_SENT";

package/dist/entities/ai-account/types.d.ts

@@ -4,9 +4,9 @@ export interface AiAccount {
     vendor: string;
     apiKey: string;
     /**
-     * API-host voor dit account. Alleen in te vullen bij vendors zonder vaste
-     * host (self-hosted: Ollama, vLLM, een eigen gateway) — bij de rest komt de
-     * host uit `AI_VENDORS` en wordt dit veld genegeerd.
+     * API host for this account. Only fillable for vendors without a fixed host (self-hosted:
+     * Ollama, vLLM, a custom gateway) — for the rest the host comes from `AI_VENDORS` and this field
+     * is ignored.
      */
     baseUrl?: string;
     isDefaultLlm?: boolean;

package/dist/entities/ai-account/vendors.d.ts

@@ -1,61 +1,54 @@
 /**
- * De AI-vendors waar de ai-app een adapter voor heeft.
+ * The AI vendors the ai app has an adapter for.
  *
- * Eén bron voor zowel de UI (accountformulier, tabellabels) als de server
- * (default-model, API-host). Eerder stonden die lijsten los van elkaar en
- * liepen ze uiteen — de UI noemde vendors waarvoor geen adapter bestond.
+ * One source for both the UI (account form, table labels) and the server (default model, API
+ * host). Those lists used to be separate and drifted apart — the UI named vendors no adapter
+ * existed for.
  *
- * Deze catalogus beschrijft *wat* een vendor is. *Hoe* je ertegen praat (welke
- * adapterklasse, welk model-filter) staat server-side in `providers/registry`,
- * die zich tegen deze lijst verantwoordt: een vendor die hier `"chat"` claimt
- * en daar geen chat-adapter heeft, is een testfout.
+ * This catalog describes *what* a vendor is. *How* you talk to it (which adapter class, which
+ * model filter) lives server-side in `providers/registry`, which answers to this list: a vendor
+ * claiming `"chat"` here without a chat adapter there is a test failure.
  *
- * `id` is wat er in `AiAccount.vendor` belandt; die string is dus onderdeel van
- * het opslagformaat en mag niet zomaar hernoemd worden.
+ * `id` is what ends up in `AiAccount.vendor`, so that string is part of the storage format and
+ * must not be renamed casually.
  */
 export type AiVendorCapability = "chat" | "transcription" | "embedding";
 export interface AiVendor {
     id: string;
     label: string;
-    /** Wat deze vendor kan. Bepaalt waar hij in de UI als optie verschijnt. */
+    /** What this vendor can do. Decides where it appears as an option in the UI. */
     capabilities: readonly AiVendorCapability[];
-    /**
-     * Model waarmee een aanroep draait die zelf geen model meekrijgt. Afwezig
-     * voor vendors zonder chat-adapter.
-     */
+    /** Model a call runs on when it carries none itself. Absent for vendors without a chat adapter. */
     defaultModel?: string;
     /**
-     * Vaste API-host. Afwezig betekent dat de user er zelf een moet invullen
-     * op het account (`AiAccount.baseUrl`) — dat is het geval bij self-hosted
-     * runtimes en eigen gateways.
+     * Fixed API host. Absent means the user has to fill one in on the account (`AiAccount.baseUrl`) —
+     * the case for self-hosted runtimes and custom gateways.
      */
     baseUrl?: string;
     /**
-     * Welke bijlagesoorten deze vendor rechtstreeks aanneemt.
+     * Which attachment kinds this vendor accepts directly.
      *
-     * Bewust géén waarde in `capabilities`: `findAdapterGaps()` mapt elke
-     * capability die het niet kent op `"embedding"`, dus een vendor die daar
-     * `"attachments"` zou claimen wordt gemeld als missende embedding-adapter.
+     * Deliberately not a value in `capabilities`: `findAdapterGaps()` maps every capability it does
+     * not know to `"embedding"`, so a vendor claiming `"attachments"` there would be reported as a
+     * missing embedding adapter.
      *
-     * Afwezig of leeg = alleen tekst. Dat is het juiste default voor de
-     * Chat-Completions-vendors: ze delen één adapter maar niet één set
-     * mogelijkheden, en een gok levert een 400 midden in een gesprek op.
+     * Absent or empty = text only. The right default for the Chat Completions vendors: they share one
+     * adapter but not one set of capabilities, and a guess yields a 400 mid-conversation.
      */
     attachmentKinds?: readonly ("image" | "pdf")[];
 }
 export declare const AI_VENDORS: readonly AiVendor[];
 export declare function findAiVendor(vendorId: string): AiVendor | undefined;
-/** Leesbare naam voor een opgeslagen vendor-id; valt terug op de id zelf. */
+/** Readable name for a stored vendor id; falls back to the id itself. */
 export declare function aiVendorLabel(vendorId: string): string;
 /**
- * Default-model voor een vendor. De fallback is bewust een bestaand model en
- * geen lege string: callers gebruiken dit juist omdat ze zelf geen keuze
- * hebben.
+ * Default model for a vendor. The fallback is deliberately an existing model and not an empty
+ * string: callers use this precisely because they have no choice of their own.
  */
 export declare function aiVendorDefaultModel(vendorId: string, fallback?: string): string;
-/** Vendors die deze capability aanbieden — voor capability-gefilterde keuzelijsten. */
+/** Vendors offering this capability — for capability-filtered pickers. */
 export declare function aiVendorsWith(capability: AiVendorCapability): AiVendor[];
-/** True wanneer de user zelf een host moet invullen (vendor heeft er geen vaste). */
+/** True when the user has to fill in a host themselves (the vendor has no fixed one). */
 export declare function aiVendorNeedsBaseUrl(vendorId: string): boolean;
-/** Neemt deze vendor deze bijlagesoort aan? Tekst kan altijd — dat is prompt. */
+/** Does this vendor accept this attachment kind? Text always works — that is prompt. */
 export declare function aiVendorAcceptsAttachment(vendorId: string, kind: "image" | "pdf" | "text"): boolean;

package/dist/entities/ai-budget/types.d.ts

@@ -1,4 +1,4 @@
-import { OwnerScope } from '../contact/types';
+import { OwnerScope } from '../scope/types';
 /**
  * A ceiling on what may be spent on AI in one period.
  *
@@ -18,8 +18,12 @@ export interface AiBudget {
      * tenant, including the ones attributed to nobody (kb indexing, transcription,
      * playbooks running as the organisation). That unattributed spend is real and
      * it has to land somewhere.
+     *
+     * Named `ownerScope` like every other scoped entity. It was `scope` — the one
+     * deviation from the platform's convention, where `scope` is reserved for OAuth
+     * scopes, an unrelated concept that happens to share the word.
      */
-    scope: OwnerScope;
+    ownerScope: OwnerScope;
     /**
      * Warn here. Absent = never warn, only block. Both absent is allowed and means
      * the budget does nothing — the UI says so rather than pretending it is armed.
@@ -57,7 +61,7 @@ export type AiBudgetClearable = "softLimitNanos" | "hardLimitNanos";
  * what an ambiguous sentinel (`0`? that is a real limit) never could.
  */
 export interface AiBudgetInput {
-    scope?: OwnerScope;
+    ownerScope?: OwnerScope;
     softLimitNanos?: number;
     hardLimitNanos?: number;
     period?: AiBudgetPeriod;
@@ -118,12 +122,12 @@ export interface AiMyUsage {
  */
 export declare function aiBudgetState(budget: Pick<AiBudget, "softLimitNanos" | "hardLimitNanos" | "enabled">, spentNanos: number): AiBudgetState;
 /**
- * "Geen plafond" heeft twee vormen en die moeten hetzelfde betekenen.
+ * "No ceiling" has two shapes and they have to mean the same thing.
  *
- * Een gewist plafond wordt als `null` weggeschreven — `undefined` in een `$set`
- * laat het veld staan in plaats van het te legen. Bij het teruglezen is `null`
- * dus een echte waarde, en `x !== undefined` zou hem als het getal nul opvatten:
- * een plafond van nul blokkeert onmiddellijk, zonder dat iemand dat instelde.
+ * A cleared ceiling is written as `null` — `undefined` in a `$set` leaves the field standing
+ * instead of emptying it. On read-back `null` is therefore a real value, and `x !== undefined`
+ * would read it as the number zero: a ceiling of zero blocks immediately, without anyone setting
+ * it.
  */
 export declare function aiBudgetLimit(value: number | null | undefined): number | undefined;
 /**

package/dist/entities/ai-conversation/types.d.ts

@@ -1,23 +1,23 @@
 import { AssignmentStatus } from '../assignment/types';
 export type AIConversationVisibility = "shared" | "personal";
 /**
- * Dat deze draad die van een **agent-opdracht** is, en waar hij bij hoort te verschijnen.
+ * That this thread belongs to an **agent assignment**, and where it should appear.
  *
- * De draad van een opdracht leeft op `assignment:<id>` en niet op het onderwerp — dat is precies
- * waarom een opdracht meerdere beurten kan overleven terwijl de mensvragen over hetzelfde gesprek
- * hun eigen draad houden. Het nadeel was dat er geen enkele ingang naar toe was, behalve de
- * agentpagina: het werk was er wel, maar niet te zien op de plek waar het over ging.
+ * An assignment's thread lives on `assignment:<id>` and not on the subject — exactly why an
+ * assignment can survive several turns while the human questions about the same conversation keep
+ * their own thread. The downside was that there was no entrance to it except the agent page: the
+ * work was there, but not visible where it was about.
  *
- * Daarom levert `conversation/resolve` de draad van een opdracht ook uit bij de scope van zijn
- * **onderwerp**, met dit stempel erop. Niet opgeslagen — het is de stand van nu, gelezen bij het
- * ophalen, precies zoals de status van de opdracht zelf.
+ * So `conversation/resolve` also delivers an assignment's thread under the scope of its
+ * **subject**, with this stamp on it. Not stored — it is the state right now, read on fetch,
+ * exactly like the assignment's own status.
  */
 export interface AIConversationAgentThread {
     assignmentId: string;
-    /** Het `userId` van de agent die deze opdracht doet. */
+    /** The `userId` of the agent doing this assignment. */
     agentId: string;
     status: AssignmentStatus;
-    /** De scope waaronder deze draad wordt meegeleverd: het onderwerp van de opdracht. */
+    /** The scope this thread is delivered under: the assignment's subject. */
     subjectScopeKey: string;
 }
 /**
@@ -44,8 +44,8 @@ export interface AIConversation {
     createdAt: number;
     updatedAt: number;
     /**
-     * Gezet bij het ophalen, nooit opgeslagen: deze draad hangt aan een agent-opdracht over de
-     * gevraagde scope. Aanwezig = meelezen, niet meepraten (zie {@link AIConversationAgentThread}).
+     * Set on fetch, never stored: this thread hangs off an agent assignment about the requested
+     * scope. Present = read along, not join in (see {@link AIConversationAgentThread}).
      */
     agent?: AIConversationAgentThread;
 }

package/dist/entities/ai-profile/types.d.ts

@@ -1,4 +1,4 @@
-import { OwnerScope } from '../contact/types';
+import { OrgTeamScope } from '../scope/types';
 export interface PredefinedPrompt {
     name: string;
     prompt: string;
@@ -7,20 +7,22 @@ export interface AIProfile<T extends Record<string, any> = Record<string, any>>
     id: string;
     organizationId: string;
     /**
-     * Who may use this profile. Company-wide (`org`) or bound to a `team`; profiles
-     * are never personal. The server resolves one on create (`normalizeProfileScope`),
-     * so it is always present.
+     * Who may use this profile. Company-wide (`org`) or bound to a `team`; profiles are
+     * never personal. The server resolves one on create (`normalizeProfileScope`), so it is
+     * always present.
+     *
+     * "Never personal" was prose while the type allowed it. `OrgTeamScope` states it.
      */
-    ownerScope: OwnerScope;
+    ownerScope: OrgTeamScope;
     name: string;
     description?: string;
     accountId: string;
     model: string;
     providerConfig?: T;
     /**
-     * De basisinstructie van dit brein. Optioneel: een profiel dat alleen tools ontsluit heeft
-     * er geen nodig. Stond hier als verplicht terwijl het schema hem optioneel maakte, waardoor
-     * elke lezer `?? ""` moest schrijven zonder dat het type dat verklaarde.
+     * This brain's base instruction. Optional: a profile that only exposes tools needs none. It was
+     * documented as required while the schema made it optional, so every reader had to write `?? ""`
+     * without the type explaining why.
      */
     systemPrompt?: string;
     contextIds?: string[];
@@ -28,27 +30,20 @@ export interface AIProfile<T extends Record<string, any> = Record<string, any>>
     /** Namespaced tool names this profile may use (default: none enabled). */
     enabledTools?: string[];
     /**
-     * Per-tool confirmation policy, stored as a LIST (not a keyed map).
-     *
-     * De oorspronkelijke reden was dwingend: de SDK-client transformeerde élke object-key
-     * camel↔snake, en dat verminkte een genamespacede toolnaam (`communication__compose_email` →
-     * `communication_ComposeEmail`) zodat hij niet meer matchte met `enabledTools`. **Die transform
-     * is 17-08-2026 verwijderd**, dus een map zou nu werken.
-     *
-     * De lijst blijft staan: hij zit op bestaande profielrijen met een formulier eroverheen, en een
-     * migratie zou alleen een prettigere vorm opleveren. `enabledTools` ernaast is ook een lijst.
+     * Per-tool confirmation policy, stored as a LIST (not a keyed map). It sits on existing profile
+     * rows with a form on top, and a migration to a map would only yield a nicer shape;
+     * `enabledTools` next to it is a list too.
      *
-     * Under autonomy "suggest", write tools are held for approval; reads run freely.
-     * A tool absent from this list defaults to "write" (safe).
+     * Under autonomy "suggest", write tools are held for approval; reads run freely. A tool absent
+     * from this list defaults to "write" (safe).
      *
-     * **Waar dit wél en níet geldt.** Afgedwongen in `playbook/ai/gate.ts`, en daarmee op elke
-     * autonome run (workflow of procedure). De interactieve assistent doet er **niets** mee: daar
-     * bestaat geen bevestigingsstap, en er is ook geen `requiresConfirmation` om aan te haken —
-     * die stond hier als belofte terwijl er nergens een implementatie was. Een `write`-markering
-     * die je met een gesprek in de chat verwacht af te dwingen, doet dus niets.
+     * **Where this does and does not apply.** Enforced in `playbook/ai/gate.ts`, and thereby on
+     * every autonomous run (workflow or procedure). The interactive assistant does **nothing** with
+     * it: there is no confirmation step there. So a `write` marking you expect to enforce in a chat
+     * conversation does nothing.
      *
-     * Dat is een openstaand gat en geen ontwerpkeuze: een bevestigingsstap in de chat is UI plus
-     * een extra ronde, en hoort een besluit te zijn in plaats van een veld dat stil niets doet.
+     * That is an open gap and not a design choice: a confirmation step in the chat is UI plus an
+     * extra round, and should be a decision rather than a field that silently does nothing.
      */
     toolPolicy?: {
         name: string;

package/dist/entities/ai-settings/types.d.ts

@@ -1,27 +1,26 @@
 /**
- * Wat een organisatie voor de AI-app als geheel instelt — niet per profiel, niet per gebruiker.
+ * What an organisation configures for the AI app as a whole — not per profile, not per user.
  *
- * Eén veld tot nu toe, en dat is met opzet geen `Record<string, unknown>`: een instelling die
- * niemand kan opnoemen is een instelling die niemand kan vinden.
+ * One field so far, deliberately not a `Record<string, unknown>`: a setting nobody can name is a
+ * setting nobody can find.
  */
 export interface AiOrgSettings {
     /**
-     * Mag de AI-app meeluisteren met gesprekken (spraak naar tekst)?
+     * May the AI app listen in on conversations (speech to text)?
      *
-     * Dit is de knop die er niet was: de AI-app installeren zette transcriptie aan voor élk
-     * gesprek in de organisatie, wat een technische toevalligheid was die als beleid gold.
+     * The switch that did not exist: installing the AI app turned transcription on for *every*
+     * conversation in the organisation, a technical accident acting as policy.
      */
     listeningEnabled?: boolean;
 }
 /**
- * Mag er meegeluisterd worden?
+ * May anything listen in?
  *
- * **Afwezig = ja**, en dat is hier de juiste kant: de knop is nieuw, en een organisatie die
- * hem nooit heeft aangeraakt hoort niet plotseling zonder transcriptie te zitten. Uit is dus
- * een expliciete keuze en niet een lege rij.
+ * **Absent = yes**, the right side here: the switch is new, and an organisation that never touched
+ * it should not suddenly find itself without transcription. Off is therefore an explicit choice
+ * and not an empty row.
  *
- * Eén plek, zodat de client (die de upload overslaat) en de server (die hem weigert) niet
- * ieder hun eigen default kunnen hebben — dan zou de een luisteren terwijl de ander denkt van
- * niet.
+ * One place, so the client (which skips the upload) and the server (which refuses it) cannot each
+ * have their own default — then one would listen while the other thinks not.
  */
 export declare function listeningAllowed(settings: AiOrgSettings | null | undefined): boolean;

package/dist/entities/analytics/dashboard.d.ts

@@ -1,4 +1,4 @@
-import { OwnerScope } from '../contact/types';
+import { OwnerScope } from '../scope/types';
 import { DimensionId } from './dimensions';
 import { WidgetConfig } from './report';
 /**