@opencxh/domain 1.154.0 → 1.158.0

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

@@ -51,6 +51,18 @@ interface ActivityTypeInfo<T extends ActivityType = ActivityType> {
     carriesText?: boolean;
     /** Door de engine zelf geschreven; mag geen nieuwe playbook-run openen. */
     playbookAuthored?: boolean;
+    /**
+     * Betekent dit type dat er daadwerkelijk contact tot stand kwam — dat er gesproken is?
+     *
+     * Nodig omdat "is hier echt iets uitgewisseld" niet uit berichten alleen te bepalen valt: een
+     * aangenomen telefoongesprek is een volwaardige casus met nul berichten, en een gemiste oproep
+     * is het tegenovergestelde. Een eigen vlag en niet afgeleid van `shape`, want beide zijn
+     * `event` — het verschil zit in de betekenis, niet in de vorm.
+     *
+     * Bewust hier en niet als lijstje in de app die de vraag stelt: dat is precies hoe "is dit een
+     * bericht?" zes keer los kwam te staan.
+     */
+    connected?: boolean;
     /**
      * Verschijnt in de trigger-keuzelijst van playbooks en webhooks.
      *
@@ -111,6 +123,17 @@ export declare function carriesText(type: string): boolean;
 export declare function messageCountsAs(type: string): "inbound_message" | "outbound_message" | undefined;
 /** Door de playbook-engine zelf geschreven; mag geen nieuwe run openen. */
 export declare function isPlaybookAuthoredType(type: string): boolean;
+/** Kwam er met dit type daadwerkelijk contact tot stand? Zie {@link ActivityTypeInfo.connected}. */
+export declare function isConnectedType(type: string): boolean;
+/**
+ * Is dit een transcript-achtig artefact — meegeleverde inhoud die leesbare tekst draagt?
+ *
+ * Het onderscheid met een bestand zit al in de catalogus (`FILE_UPLOADED` draagt geen tekst), dus
+ * dit is geen nieuwe lijst maar een combinatie van twee bestaande antwoorden. Zo telt het
+ * transcript van een externe provider mee zodra die app zijn type declareert, zonder dat hier een
+ * naam bij hoeft.
+ */
+export declare function isTranscriptType(type: string): boolean;
 /** De inboxlijst-regel, of `""` wanneer het type er geen heeft. */
 export declare function activitySnippet(activity: Activity): string;
 /**

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

@@ -8,16 +8,21 @@ export interface AIProfile<T extends Record<string, any> = Record<string, any>>
     organizationId: string;
     /**
      * Who may use this profile. Company-wide (`org`) or bound to a `team`; profiles
-     * are never personal. Optional only during the migration window - the server
-     * defaults new profiles to `org` and backfills existing ones.
+     * are never personal. The server resolves one on create (`normalizeProfileScope`),
+     * so it is always present.
      */
-    ownerScope?: OwnerScope;
+    ownerScope: OwnerScope;
     name: string;
     description?: string;
     accountId: string;
     model: string;
     providerConfig?: T;
-    systemPrompt: string;
+    /**
+     * 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.
+     */
+    systemPrompt?: string;
     contextIds?: string[];
     predefinedPrompts?: PredefinedPrompt[];
     /** Namespaced tool names this profile may use (default: none enabled). */
@@ -31,8 +36,16 @@ export interface AIProfile<T extends Record<string, any> = Record<string, any>>
      * which the transform leaves untouched.
      *
      * Under autonomy "suggest", write tools are held for approval; reads run freely.
-     * A tool absent from this list defaults to "write" (safe). Also usable by the
-     * interactive assistant's requiresConfirmation flow.
+     * 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.
+     *
+     * 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.
      */
     toolPolicy?: {
         name: string;

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

@@ -0,0 +1,27 @@
+/**
+ * Wat een organisatie voor de AI-app als geheel instelt — niet per profiel, niet per gebruiker.
+ *
+ * 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.
+ */
+export interface AiOrgSettings {
+    /**
+     * Mag de AI-app meeluisteren met gesprekken (spraak naar tekst)?
+     *
+     * 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.
+     */
+    listeningEnabled?: boolean;
+}
+/**
+ * Mag er meegeluisterd worden?
+ *
+ * **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.
+ *
+ * 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.
+ */
+export declare function listeningAllowed(settings: AiOrgSettings | null | undefined): boolean;

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

@@ -0,0 +1 @@
+export {};

package/dist/entities/assignment/index.d.ts

@@ -0,0 +1 @@
+export * from './types';

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

@@ -0,0 +1,142 @@
+import { ResourceRef } from '../../platform/resource';
+import { WaitingOn } from '../playbook/types';
+/**
+ * Een **opdracht**: werk dat aan een agent is toegewezen en zo lang leeft als het werk.
+ *
+ * **Waarom dit een entity is.** Het was er geen: `plans/unify-ai.md` besliste "een opdracht *is*
+ * een run met een procedure, een agent als actor en een lange levensduur". Dat is verdedigbaar
+ * gedacht, en de code liet zien wat het kostte:
+ *
+ * - `resume-playbook.ts` kortte elke procedure-run af op `{ status: "done" }`, dus een opdracht was
+ *   structureel **één modelbeurt**;
+ * - de draad (een `AIConversation` op `playbook-run:<id>`) deelde géén geheugen met de agent:
+ *   `runProcedure` gaf bewust geen `conversationId` mee, dus wat een mens in de draad zei bereikte
+ *   de agent nooit en omgekeerd;
+ * - `retry` betekende "doe de hele opdracht opnieuw vanaf de originele trigger" — zinnig voor een
+ *   workflow van seconden, onzin voor werk dat dagen liep;
+ * - en "wat voor ding is dit" moest uit de *uitvoeringsvorm* worden afgeleid
+ *   (`decider.kind === "procedure"`), dus de vorm deed dienst als producttype.
+ *
+ * Nu is een opdracht wat hij is, en een run wat die is: **één beurt**. De opdracht leeft, de runs
+ * zijn wat hij deed.
+ */
+/**
+ * Waar een opdracht in verkeert.
+ *
+ * Bewust dezelfde woorden als de eindstanden van een run, en bewust minder: een opdracht kan niet
+ * `failed` zijn. Een gefaalde beurt is een gefaalde run — de opdracht staat dan nog open, want er
+ * is niets afgehandeld. Dat verschil is precies waarom dit een eigen vocabulaire is.
+ */
+export type AssignmentStatus = "open" | "waiting" | "done" | "escalated";
+export declare const TERMINAL_ASSIGNMENT_STATUSES: readonly ["done", "escalated"];
+export declare function isAssignmentTerminal(status: AssignmentStatus | string): boolean;
+/**
+ * De scope-soort waaronder de draad van een opdracht leeft.
+ *
+ * Was `playbook-run:<id>`, want de draad hing aan een run. Hij hangt nu aan de opdracht, en dat is
+ * het hele punt: een draad die stopt zodra één beurt klaar is, is geen draad.
+ *
+ * Staat in domain omdat het een **contract tussen client en server** is: de client bouwt de
+ * sleutel om de draad te openen, de server autoriseert hem. Twee plekken die het voorvoegsel los
+ * uitschrijven lopen bij de eerste typefout stil uiteen — en het gevolg daarvan is "geen toegang
+ * tot deze scope", niet een foutmelding die het zegt.
+ */
+export declare const ASSIGNMENT_SCOPE_KIND = "assignment";
+export declare function assignmentScopeKey(assignmentId: string): string;
+export interface Assignment {
+    id: string;
+    organizationId: string;
+    /** De agent die dit doet: het `userId` van een gebruiker met `type: "agent"`. */
+    agentId: string;
+    /** De definitie waar deze opdracht uit voortkomt (een playbook met een procedure). */
+    jobId: string;
+    /**
+     * De versie waarmee hij begon — puur voor de audit.
+     *
+     * Elke **beurt** pint zijn eigen procedure (`run.decider`), dus een verbeterde prose komt bij de
+     * volgende beurt aan zonder een lopende beurt van opdracht te laten wisselen. Eeuwig pinnen zou
+     * betekenen dat een correctie nooit aankomt; niet pinnen dat een beurt halverwege verandert.
+     */
+    jobVersion: number;
+    /** Waar deze opdracht over gaat. Afwezig = werk zonder resource (een rollup, een klus). */
+    subjectKind?: string;
+    subjectId?: string;
+    status: AssignmentStatus;
+    /**
+     * Waarop de **opdracht** wacht tussen twee beurten.
+     *
+     * Bewust hier en niet op de run, want het zijn twee verschillende soorten pauze:
+     *
+     * - een **workflow** pauzeert *midden in een flow* en hervat op stap N+1 met dezelfde vars — de
+     *   cursor (`run.resumeAtStep`) is essentieel;
+     * - een **opdracht** heeft geen cursor. "Hervatten" is *nog een beurt nemen*, met de draad als
+     *   geheugen.
+     *
+     * Dat die twee in één veld geperst zaten is waarom elke procedure-run `resumeAtStep: 0` opsloeg.
+     */
+    waitingOn?: WaitingOn | null;
+    /** De soort van `waitingOn` als platte kolom — de store kan niet in een genest object zoeken. */
+    waitingOnKind?: WaitingOn["on"] | null;
+    /**
+     * Hoeveel beurten deze opdracht al heeft gehad.
+     *
+     * Was `run.rounds`, wat het aantal keer parkeren *binnen één run* telde. Op dit niveau is het de
+     * teller die telt: een agent die met een mens heen en weer blijft pingpongen moet een plafond
+     * hebben.
+     */
+    turns: number;
+    /** De draad: agent én mens schrijven hierin. Dit is de toestand van de opdracht. */
+    conversationId: string;
+    /** Lijst-index, geen autorisatie — zie `PlaybookRun.visibleTo`. */
+    visibleTo?: string[];
+    /** Waar deze opdracht over gaat, in mensentaal. Voor de lijst. */
+    title?: string;
+    createdBy: string;
+    lastActivityAt?: number;
+}
+/** Het onderwerp van een opdracht als één verwijzing, of `undefined`. */
+export declare function assignmentSubject(assignment: {
+    subjectKind?: string;
+    subjectId?: string;
+}): ResourceRef | undefined;
+/**
+ * Hoeveel beurten een opdracht mag nemen voordat een mens het overneemt.
+ *
+ * Niet oneindig, want elke beurt is een modelaanroep en een agent kan met de beste bedoelingen
+ * blijven vragen. Bij het plafond escaleert hij, en dat is te zien in de draad — een opdracht die
+ * stil ophoudt zou de vraag "waarom doet hij niets meer" onbeantwoordbaar maken.
+ */
+export declare const MAX_ASSIGNMENT_TURNS = 12;
+/**
+ * Wat een beurt als volgende zet koos. Dit is wat de control-tools vastleggen.
+ *
+ * Eén union, want de vier uitkomsten sluiten elkaar uit: je wacht op iets, je bent klaar, of je
+ * geeft het over aan een mens.
+ */
+export type AssignmentControl = {
+    kind: "wait";
+    on: WaitingOn;
+} | {
+    kind: "done";
+    note?: string;
+} | {
+    kind: "escalate";
+    reason: string;
+};
+/**
+ * Waar de opdracht na deze beurt in verkeert.
+ *
+ * Puur, zodat de regel op één plek staat en zonder Bridge te testen is — dezelfde vorm als
+ * `decideFinalState` voor een run.
+ *
+ * **Geen control-call betekent escaleren**, niet stil openblijven. Dat is de regel die
+ * `decideFinalState` al toepast op een run die wacht zonder geldige reden ("liever luid falen dan
+ * stil parkeren"): een agent die zijn beurt afmaakt zonder te zeggen wat hij wil, laat een mens
+ * met een opdracht zitten waarvan niemand weet of er nog iets gebeurt.
+ */
+export declare function decideAssignmentState(control: AssignmentControl | undefined, turnsSoFar: number, maxTurns?: number): {
+    status: AssignmentStatus;
+    waitingOn: WaitingOn | null;
+    turns: number;
+    reason?: string;
+};

package/dist/entities/assignment/types.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export * from './types';

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

@@ -0,0 +1,81 @@
+import { OwnerScope } from '../contact/types';
+import { ConditionStep, ForEachStep, LookupStep, ParallelStep, Step } from '../playbook/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.
+ *
+ * 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.
+ *
+ * Definities horen gescheiden te zijn naar hun **runtime**, niet naar hun editor. Een leesbaan
+ * heeft geen run, dus is het geen playbook.
+ *
+ * Wat hij deelt met een playbook is de **staptaal** en de executor — niet de tabel.
+ */
+/**
+ * Wat een leesbaan mag doen: opzoeken, kiezen, en dat desnoods parallel of per item.
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * 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.
+ */
+export type ReadStep = LookupStep | ConditionStep | ForEachStep<ReadStep> | ParallelStep<ReadStep>;
+/** De staptypes die een leesbaan mag bevatten — de runtime-tegenhanger van {@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}. */
+    ownerScope: OwnerScope;
+    name: string;
+    description?: string;
+    enabled: boolean;
+    /** Wat er opgezocht wordt. Alleen lezen — zie {@link ReadStep}. */
+    steps: ReadStep[];
+    createdBy: string;
+}
+/**
+ * Waarom deze stappenlijst geen leesbaan mag zijn, of `null` als hij het mag.
+ *
+ * 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.
+ *
+ * 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.
+ */
+export declare function readStepError(steps: readonly Step[]): string | null;
+/**
+ * De leesbanen die bij déze medewerker op dít moment horen.
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * 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.
+ */
+export declare function selectLenses<T extends Pick<LiveLens, "enabled" | "ownerScope">>(lenses: readonly T[], lens: {
+    userId: string;
+    teamId?: string;
+}): T[];

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

@@ -0,0 +1 @@
+export {};

package/dist/entities/playbook/actor.d.ts

@@ -9,6 +9,26 @@ import { OwnerScope } from '../contact/types';
  * functie is die vertaling, en de enige plek waar hij hoort.
  */
 export declare function playbookActor(scope: OwnerScope): ActingIdentity;
+/**
+ * Namens wie deze run handelt.
+ *
+ * **Twee verschillende vragen, en dat is de hele reden dat deze functie naast
+ * {@link playbookActor} bestaat:**
+ *
+ * - *wie handelt* — de agent, als er één is aangewezen;
+ * - *wie mag dit beheren* — `ownerScope`, en dat blijft van mensen.
+ *
+ * Die twee op één veld laten leunen leek aantrekkelijk, want een agent is een gebruiker en
+ * `ownerScope: { kind: "personal", userId }` levert precies de juiste actor op. Maar
+ * `ownerScope` bepaalt óók wie mag bewerken, en dan kon geen enkel mens de playbook van een
+ * agent nog aanpassen — de agent zelf logt immers nooit in.
+ *
+ * Zonder `agentId` verandert er niets: dan is de actor die van de scope, precies zoals eerst.
+ */
+export declare function runActor(playbook: {
+    agentId?: string | null;
+    ownerScope: OwnerScope;
+}): ActingIdentity;
 /**
  * Stabiele sleutel om actors te groeperen. Tien playbooks van hetzelfde team horen
  * één autorisatie-call te kosten, niet tien.

package/dist/entities/playbook/assignment.d.ts

@@ -0,0 +1,123 @@
+import { LocaleBundle } from '../analytics/dashboard';
+import { PlaybookTrigger } from './types';
+/**
+ * Toewijzen als wekker — het oppervlak waarop een **opdracht** bestaat.
+ *
+ * **Herzien:** een opdracht *is* wél een entiteit — zie {@link Assignment}. Hier stond "een
+ * opdracht is geen entiteit: het is een run met een procedure", en dat brak op drie punten: een
+ * procedure-run werd altijd afgekort tot één beurt, de draad ernaast deelde geen geheugen met de
+ * agent, en "wat voor ding is dit" moest uit de uitvoeringsvorm worden afgeleid.
+ *
+ * Wat deze module doet verandert daar niet door: de handeling die het werk begint bestaat al in
+ * elke app die werk kent — **je wijst iets aan iemand toe.** Wijs je het aan een gebruiker met
+ * `type: "agent"` toe, dan is dat het startsignaal, en dan zet de engine er een opdracht neer.
+ *
+ * Daarom is dit een federatie en geen lijst in de ai-app. Alleen comms weet dat een gesprek
+ * toegewezen kan worden en dat `INTERACTION_ASSIGNED` dat aankondigt; alleen een taken-app weet
+ * dat van een taak. De hub hoort dat niet te weten — precies de scheiding die de
+ * geheugen-catalogus (`memory-source`) en de analytics-catalogus al maken. Mal:
+ * `apps/context/server/src/memory/catalog.ts`.
+ *
+ * **Er komt geen nieuw wekmechanisme.** Een toewijzing is al een activity, dus de bestaande
+ * `activity`-poort levert hem af; deze module voegt alleen de vraag toe die de engine zelf niet
+ * kan beantwoorden: *"is dit aan míjn agent toegewezen?"*
+ */
+/**
+ * Eén soort werk dat aan een agent toegewezen kan worden, gedeclareerd door de app die het
+ * bezit.
+ */
+export interface AssignmentTargetKind {
+    /**
+     * `<app>.<ding>` — het voorvoegsel is de eigenaar, dezelfde conventie als `memory_kind` en
+     * de dossiersleutels. Twee apps kunnen zo nooit dezelfde soort claimen.
+     */
+    id: string;
+    label: string;
+    description?: string;
+    /**
+     * De activity-types waarmee deze app "dit is toegewezen" aankondigt.
+     *
+     * Gedeclareerd en niet geraden: de engine ziet alleen een type-string langskomen, en welk
+     * type een toewijzing ís weet alleen de bron. Een geraden voorvoegsel zou bij de eerste app
+     * die zijn eigen soort meebrengt stil het verkeerde type pakken.
+     */
+    activityTypes: string[];
+    /**
+     * Waar op de activity het userId van de toegewezene staat, als punt-pad
+     * (`"payload.userId"`).
+     *
+     * Een pad en geen vaste sleutel, omdat de payload van de bron is. Comms zet `payload.userId`;
+     * een andere app mag `payload.assignee.id` zetten zonder dat de hub verandert.
+     */
+    assigneePath: string;
+    /** Gezet door de hub na de fan-out, niet door de bron. */
+    origin?: "app";
+}
+/**
+ * Bare payload van `GET /provider/assignment/describe` — niet in `ResponseFactory` verpakt
+ * (mal: `MemorySourceDescription`).
+ */
+export interface AssignmentSourceDescription {
+    /** De declarerende app (== `manifest.name` == `req.source.app`). */
+    source: string;
+    targets: AssignmentTargetKind[];
+    /** Vlakke LIJST: keys met een punt worden gemangeld. */
+    locales?: LocaleBundle;
+}
+/** De samengestelde catalogus die de hub aan de builder levert. */
+export interface AssignmentCatalog {
+    targets: AssignmentTargetKind[];
+    /** Bronnen die meededen aan de fan-out (voor "wie levert dit?"). */
+    sources: string[];
+    locales: LocaleBundle;
+}
+/**
+ * De waarde op een punt-pad, of `undefined`.
+ *
+ * Eigen mini-lezer en niet `resolveRef` uit de engine: die woont in de ai-app en kent de
+ * `$`-conventie, terwijl hier een kaal pad uit een app-declaratie gelezen wordt. Stopt bij het
+ * eerste niet-object, zodat een pad dat langs `null` loopt `undefined` geeft en niet gooit.
+ */
+export declare function valueAtPath(source: unknown, path: string): unknown;
+/**
+ * De doelsoort die dit activity-type aankondigt, en de doelsoort met dit id.
+ *
+ * Twee lezers, één lijst: de engine komt binnen met een type ("wat is dit?"), de builder en de
+ * validatie met een id ("bestaat deze soort?").
+ */
+export declare function targetForActivityType(catalog: Pick<AssignmentCatalog, "targets">, activityType: string): AssignmentTargetKind | undefined;
+export declare function targetById(catalog: Pick<AssignmentCatalog, "targets">, id: string | undefined): AssignmentTargetKind | undefined;
+/** Is dit een trigger die op een toewijzing wacht? */
+export declare function isAssignmentTrigger(trigger: PlaybookTrigger | undefined): trigger is Extract<PlaybookTrigger, {
+    kind: "assignment";
+}>;
+/**
+ * Waarom deze toewijzing géén run van deze playbook start, of `null` als hij dat wél doet.
+ *
+ * Een reden en geen boolean, om dezelfde reden als `triggerMismatch`: een trigger die niet
+ * matcht laat geen run achter, dus er is geen trace om in te kijken. "Ik heb dit gesprek aan de
+ * agent gegeven en er gebeurt niets" moet te beantwoorden zijn.
+ *
+ * Puur, en dat is waar de vier poorten hier staan in plaats van in de job:
+ *
+ * 1. **Geen agent** ⇒ nooit. "Toegewezen aan wie?" heeft dan geen antwoord, en zonder deze
+ *    poort zou zo'n playbook op *elke* toewijzing van *iedereen* vuren.
+ * 2. **Onbekende doelsoort** ⇒ nooit, met naam en al. Dat is het geval "de app die dit
+ *    declareerde is uitgeschakeld of antwoordt niet", en dat mag geen stilte zijn.
+ * 3. **Aan iemand anders toegewezen** ⇒ niet deze playbook. Dit is de kernvergelijking.
+ * 4. **De agent wees het zichzelf toe** ⇒ niet opnieuw. Zonder deze poort is een procedure die
+ *    zelf toewijst (`update_interaction`) een lus die zichzelf blijft wekken: de
+ *    lifecycle-activity draagt geen `runId`, dus de bestaande loop-demping ziet hem niet.
+ */
+export declare function assignmentMismatch(input: {
+    trigger: PlaybookTrigger | undefined;
+    /** `Playbook.agentId` — het userId van de agent die deze playbook uitvoert. */
+    agentId?: string | null;
+    /** De doelsoort uit de catalogus die bij deze playbook hoort, indien gevonden. */
+    target?: AssignmentTargetKind;
+    activityType: string;
+    /** Aan wie dit toegewezen werd, gelezen via `target.assigneePath`. */
+    assigneeUserId?: string;
+    /** Wie de toewijzing deed, als het een gebruiker was. */
+    authorUserId?: string;
+}): string | null;

package/dist/entities/playbook/assignment.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/entities/playbook/index.d.ts

@@ -1,4 +1,5 @@
 export * from './labels';
 export * from './trigger-vars';
 export * from './actor';
+export * from './assignment';
 export * from './types';

package/dist/entities/playbook/status.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/entities/playbook/trigger-vars.d.ts

@@ -52,22 +52,53 @@ export declare const TRIGGER_VARS: readonly [{
 }, {
     readonly name: "companyId";
     readonly type: "string";
+}, {
+    readonly name: "assigneeUserId";
+    readonly type: "string";
 }];
-/** De variabelen die een classify-stap oplevert, per mode. */
+/**
+ * Wat een classify-stap per mode **oplevert** — het contract dat `runClassify` nakomt.
+ *
+ * Staat hier als type en niet alleen als lijst, omdat {@link CLASSIFY_VARS} eruit hoort te volgen.
+ * Die lijst was uiteengelopen met de werkelijkheid, precies zoals `TRIGGER_VARS` dat eerder was:
+ * `question` bood `confidence` aan (bestaat niet, de adapter geeft `answer` + `reasoning`) en
+ * `topics` miste `topicId` en `reasoning`. Een pad dat de picker aanbiedt en dat `undefined`
+ * oplevert is stil kapot — vandaar dat de adapter er in `ai/classify.test.ts` tegen wordt gehouden.
+ */
+export interface ClassifyTopicsResult {
+    topicId: string;
+    /** Naam van het onderwerp, of `null` bij `"none"`. */
+    topic: string | null;
+    confidence: number;
+    reasoning?: string;
+}
+export interface ClassifyQuestionResult {
+    answer: boolean;
+    reasoning?: string;
+}
+/** De zelf-gedefinieerde velden uit `ClassifyStep.fields`; de vorm is van de auteur. */
+export type ClassifyExtractResult = Record<string, unknown>;
+/** De variabelen die een classify-stap oplevert, per mode. Volgt de types hierboven. */
 export declare const CLASSIFY_VARS: {
     readonly topics: readonly [{
+        readonly name: "topicId";
+        readonly type: "string";
+    }, {
         readonly name: "topic";
         readonly type: "string";
     }, {
         readonly name: "confidence";
         readonly type: "number";
+    }, {
+        readonly name: "reasoning";
+        readonly type: "string";
     }];
     readonly question: readonly [{
         readonly name: "answer";
         readonly type: "boolean";
     }, {
-        readonly name: "confidence";
-        readonly type: "number";
+        readonly name: "reasoning";
+        readonly type: "string";
     }];
     readonly extract: readonly [];
 };