@semiont/core 0.5.26 → 0.5.28

package/dist/index.d.ts

@@ -1353,12 +1353,14 @@ interface paths {
                 };
             };
             responses: {
-                /** @description Event accepted and published to subscribers */
+                /** @description Event accepted and published. The body reports how many subscribers the target subject had at dispatch; zero means the signal reached nobody. */
                 202: {
                     headers: {
                         [name: string]: unknown;
                     };
-                    content?: never;
+                    content: {
+                        "application/json": components["schemas"]["BusEmitAccepted"];
+                    };
                 };
                 /** @description Missing/invalid channel, payload, or scope; or payload failed schema validation for the channel */
                 400: {
@@ -1958,9 +1960,28 @@ interface components {
                 updatedAt: string;
             }[];
         };
-        /** @description Web Annotation / W3C PROV Agent. Discriminated by @type — Person, Organization, or Software. Each branch carries fields appropriate to its kind. Software peers are first-class participants, not a sub-class of Person. */
-        Agent: ({
-            /** @constant */
+        /** @description Web Annotation / W3C PROV Agent. Discriminated by @type — Person, Organization, or Software (named member schemas: AgentPerson, AgentOrganization, AgentSoftware). Software peers are first-class participants, not a sub-class of Person. */
+        Agent: components["schemas"]["AgentPerson"] | components["schemas"]["AgentOrganization"] | components["schemas"]["AgentSoftware"];
+        /** @description An organization — the Organization branch of Agent. */
+        AgentOrganization: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            "@type": "Organization";
+            /** Format: uri */
+            "@id"?: string;
+            name: string;
+            homepage?: string;
+        } & {
+            [key: string]: unknown;
+        };
+        /** @description A human participant — the Person branch of Agent. */
+        AgentPerson: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
             "@type": "Person";
             /**
              * Format: uri
@@ -1975,17 +1996,13 @@ interface components {
             homepage?: string;
         } & {
             [key: string]: unknown;
-        }) | ({
-            /** @constant */
-            "@type": "Organization";
-            /** Format: uri */
-            "@id"?: string;
-            name: string;
-            homepage?: string;
-        } & {
-            [key: string]: unknown;
-        }) | ({
-            /** @constant */
+        };
+        /** @description A software peer (an inference model acting as a first-class participant) — the Software branch of Agent. Carries structured provider + model. */
+        AgentSoftware: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
             "@type": "Software";
             /**
              * Format: uri
@@ -2004,7 +2021,7 @@ interface components {
             };
         } & {
             [key: string]: unknown;
-        });
+        };
         Annotation: {
             /**
              * @description W3C Web Annotation JSON-LD context
@@ -2039,7 +2056,7 @@ interface components {
             /** @description SHA-256 of resource content at annotation time */
             contentChecksum?: string;
         };
-        /** @description Phase 2: Body can be TextualBody (for entity tags, descriptions) or SpecificResource (for links) */
+        /** @description An annotation's body: a TextualBody carries text the annotation states (entity tags, descriptions, comments), a SpecificResource points at what it links to. Tell them apart by `type`, which is required on both and single-valued — a consumer never has to probe for which fields happen to be present. */
         AnnotationBody: components["schemas"]["TextualBody"] | components["schemas"]["SpecificResource"];
         /** @description Payload for mark:body-updated domain event */
         AnnotationBodyUpdatedPayload: {
@@ -2082,9 +2099,10 @@ interface components {
             refreshToken: string;
             isNewUser: boolean;
         };
-        /** @description Emitted when an annotation receives focus for beckoning */
+        /** @description Emitted when an annotation receives focus for beckoning. resourceId is a guard, not navigation: it names the resource this focus applies to, and a viewer currently showing a different resource ignores the event — a deliberate ignore rather than a silent no-op. Focus never moves the viewer; driving the Browser to a resource is browse:resource-open's job. */
         BeckonFocusEvent: {
             annotationId?: string;
+            /** @description Guard: the resource this focus applies to. A viewer showing a different resource ignores the event. Never causes navigation. */
             resourceId?: string;
         };
         /** @description Emitted when an annotation is hovered over for beckoning */
@@ -2210,10 +2228,9 @@ interface components {
             correlationId: string;
             response: components["schemas"]["GetAnnotationsResponse"];
         };
-        /** @description Emitted when an annotation is clicked in the browse panel */
+        /** @description An annotation was clicked — open it: the viewer selects its entry in the annotations panel and relays a focus signal to scroll to it. The annotation id is the whole address; it identifies exactly one annotation on exactly one resource, so no resource field is carried and none is needed to scope the event. Motivation is NOT on the wire either: the viewer derives it from the annotation the id names, so the wire states the fact once. A viewer that has not loaded that annotation finds nothing and does nothing. Emitted locally by every clickable annotation surface, and over the wire by a driver opening an annotation on another participant's screen. */
         BrowseClickEvent: {
             annotationId: string;
-            motivation: components["schemas"]["Motivation"];
         };
         /** @description Request to browse a directory listing */
         BrowseDirectoryRequest: {
@@ -2281,8 +2298,12 @@ interface components {
         BrowsePanelToggleEvent: {
             panel: string;
         };
-        /** @description Emitted when navigation to a reference resource is requested */
-        BrowseReferenceNavigateEvent: {
+        /** @description Domain intent to open a resource in the viewer (GUIDED-TOUR D1/D2): emitted locally by in-app link handlers and remotely by the launcher's tour verbs; the viewer translates it to host routing (nav:push). Deliberately not named 'navigate' — that word and the nav:* prefix belong to the host-local framework layer. */
+        BrowseResourceOpenEvent: {
+            resourceId: string;
+        };
+        /** @description REPORT that a resource has loaded in a viewer — emitted on arrival by ANY means: a followed cue, an in-app link, the back button, a typed URL (GUIDED-TOUR D6). Deliberately distinct from the imperative browse:resource-open: drive and report never share a channel, or the driver hears its own commands and one viewer's arrival steers another's page. */
+        BrowseResourceViewedEvent: {
             resourceId: string;
         };
         /** @description Request to browse annotations that reference a resource */
@@ -2333,7 +2354,7 @@ interface components {
         /** @description A resource's stored extraction outcome — the coordinate map with its provenance, or a named decline — or null when none has been derived. Null is the common case and not an error: a native text layer is read in the browser, and a media type with no extractor never produces one. */
         BrowseAnchoredTextResult: {
             correlationId: string;
-            response: components["schemas"]["ExtractionOutcome"] | null;
+            response: Omit<components["schemas"]["ExtractionOutcome"], "kind"> | null;
         };
         /** @description Request to browse a single resource */
         BrowseResourceRequest: {
@@ -2373,6 +2394,11 @@ interface components {
             correlationId: string;
             response: components["schemas"]["GetTagSchemasResponse"];
         };
+        /** @description Result of publishing one event. `subscribers` is the number of observers attached to the target subject at dispatch — the GLOBAL subject for an unscoped emit, the scoped one when `scope` is set. Zero means the signal reached nobody: /bus/subscribe enforces no channel allowlist and the emit handler publishes unconditionally, so a client can emit a channel no participant subscribes to and otherwise receive a clean 202 with no way to tell. Deliberately NOT named `delivered`: this is the count at dispatch, and a subscriber may still drop the frame downstream, so the field is named after what the server can actually observe. */
+        BusEmitAccepted: {
+            /** @description Observers on the target subject when the event was dispatched. */
+            subscribers: number;
+        };
         /** @description Emit an event on the Semiont bus. Channel names come from bus-protocol.ts; payload shape is validated against the channel's registered schema (CHANNEL_SCHEMAS). An optional scope routes resource-scoped broadcasts (e.g. mark:added, job:complete) to per-resource subscribers via eventBus.scope(scope); leave it unset for unscoped/global events. */
         BusEmitRequest: {
             /** @description Channel name from bus-protocol.ts EventMap */
@@ -2412,6 +2438,8 @@ interface components {
             agent: components["schemas"]["Agent"];
             /** @description Job types this agent is declared to serve (from the KB's workers.* config sections). Absent for Persons and for agents declared only under actor roles. */
             servesJobTypes?: components["schemas"]["JobType"][];
+            /** @description Discovered context/output ceilings for this agent's model; absent when discovery is currently unavailable. */
+            limits?: components["schemas"]["InferenceLimits"];
         };
         /** @description Error response for failed bus commands. Replaces native Error objects on the EventBus so payloads are serializable and OpenAPI-typed. */
         CommandError: {
@@ -2480,7 +2508,7 @@ interface components {
             /** @description Optional body. Omit for annotations whose motivation alone is meaningful (highlighting) or whose user-supplied content is empty. Shape matches Annotation.body. */
             body?: components["schemas"]["AnnotationBody"] | components["schemas"]["AnnotationBody"][];
         };
-        /** @description Response body for POST /resources (202 Accepted). Resource creation is asynchronous — the backend writes content to disk, emits yield:create on the bus, and returns the newly-minted resourceId immediately. Consumers watch SSE domain events (yield:created) to observe the fully-persisted state. */
+        /** @description Response body for POST /resources (202 Accepted). The route writes content to disk, emits yield:create, and AWAITS the confirmed-write reply — so the returned resourceId is the one Stower minted, and the resource's event is persisted before this response is sent. What remains asynchronous is downstream projection: graph, views and vectors settle after the 202. */
         CreateResourceResponse: {
             /** @description The id of the newly-created resource. Assigned by Stower when it persists yield:create. */
             resourceId: string;
@@ -2490,7 +2518,10 @@ interface components {
             message: string;
         };
         DirEntry: {
-            /** @enum {string} */
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
             type: "dir";
             /** @description Entry name (basename) */
             name: string;
@@ -2502,6 +2533,7 @@ interface components {
              */
             mtime: string;
         };
+        /** @description One entry in a directory listing: a file, which may carry the resource it was ingested as, or a subdirectory. Tell them apart by `type`, which is required on both and single-valued. */
         DirectoryEntry: components["schemas"]["FileEntry"] | components["schemas"]["DirEntry"];
         /**
          * DiscoveredKB
@@ -2539,7 +2571,7 @@ interface components {
             /** @description Every KB the launcher currently manages, local and forwarded */
             kbs: components["schemas"]["DiscoveredKB"][];
         };
-        /** @description Wire format emitted by GET /resources/:id/events/stream. Extends StoredEventResponse with optional enrichment fields populated from the materialized view at SSE-write time. Subscribers can read the enrichment fields directly to update local caches without an additional fetch. */
+        /** @description Wire format for persisted events delivered over the bus SSE stream (GET /bus/subscribe). Extends StoredEventResponse with optional enrichment fields the EventStore populates from the materialized view at publish time (persistence → view → enrich → notification). Subscribers read the enrichment fields directly to update local caches without an additional fetch. */
         EnrichedResourceEvent: components["schemas"]["StoredEventResponse"] & {
             /** @description Populated for events that mutate an annotation (mark:added, mark:body-updated, mark:removed). Carries the post-materialization annotation as it exists in the view, so subscribers can update local caches in-place without refetching. Absent for events that don't touch annotations. */
             annotation?: components["schemas"]["Annotation"];
@@ -2569,8 +2601,13 @@ interface components {
             data: string;
             id?: string;
         };
-        /** @description The full outcome of text extraction for one representation — the record the anchored-text store holds and the wire serves (PERSIST-ANCHORS decision D1). Either a success (the anchored text plus its provenance: how it was extracted, what class of PDF it came from, how confident OCR was, which pages could not be read) or a named decline. A decline is a first-class, cacheable outcome: 'we ran and there was nothing' costs a full recognition pass to discover. ocrConfidence is extraction quality for operators, deliberately not anchor confidence. */
-        ExtractionOutcome: (components["schemas"]["AnchoredText"] & {
+        /** @description A successful extraction: the anchored text plus its provenance (WIRE-UNION-DISCRIMINANTS P5c named this member; PERSIST-ANCHORS D1 made it the stored record). */
+        ExtractedText: components["schemas"]["AnchoredText"] & {
+            /**
+             * @description Discriminant — both ExtractionOutcome members carry `kind`, single-valued (D6: category here, detail in `method`).
+             * @enum {string}
+             */
+            kind: "extracted";
             /**
              * @description How the text was extracted.
              * @enum {string}
@@ -2591,15 +2628,33 @@ interface components {
             };
             /** @description 1-indexed pages this extraction could not read — present only for partially covered documents (class C). */
             unreadPages?: number[];
-        }) | {
+        } & {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            kind: "extracted";
+        };
+        /** @description A named decline: extraction ran and yielded nothing, by class. A first-class, cacheable outcome — 'we ran and there was nothing' costs a full recognition pass to discover. */
+        ExtractionDeclined: {
+            /**
+             * @description Discriminant — both ExtractionOutcome members carry `kind`, single-valued (D6: category here, detail in `declined`). (enum property replaced by openapi-typescript)
+             * @enum {string}
+             */
+            kind: "declined";
             /**
              * @description Why extraction yielded nothing, by class.
              * @enum {string}
              */
             declined: "no-text-layer" | "encrypted" | "corrupt" | "too-large";
         };
+        /** @description The full outcome of text extraction for one representation — the record the anchored-text store holds and the wire serves (PERSIST-ANCHORS decision D1). Discriminated on `kind` (WIRE-UNION-DISCRIMINANTS P5c/D6): 'extracted' — the anchored text with its provenance; 'declined' — a named decline. ocrConfidence is extraction quality for operators, deliberately not anchor confidence. */
+        ExtractionOutcome: components["schemas"]["ExtractedText"] | components["schemas"]["ExtractionDeclined"];
         FileEntry: {
-            /** @enum {string} */
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
             type: "file";
             /** @description Entry name (basename) */
             name: string;
@@ -2792,6 +2847,35 @@ interface components {
             /** @description LLM-generated summary of the focal anchor's relationships in the knowledge graph */
             inferredRelationshipSummary?: string;
         };
+        /** @description Params bag for `job:create` with `jobType: 'generation'` — exactly the shape yield.fromContext(context, options) takes: options + the gathered context. The job's ids are DERIVED from context.focus at the dispatcher (resource focus → focus.resource; annotation focus → focus.sourceResource, with the worker auto-binding to focus.annotation); a caller-supplied referenceId is rejected. Carried inside JobCreateCommand.params; this schema is the generation shape's contract, including its requiredness. */
+        GenerationJobParams: {
+            /** @description Title of the generated resource. */
+            title: string;
+            /** @description Storage URI for the generated resource's content. */
+            storageUri: string;
+            /** @description The gathered context that grounds the generation. Its `focus` names the anchor: the DISPATCHER derives the job's resourceId from it (resource focus → focus.resource; annotation focus → focus.sourceResource, with the worker auto-binding to focus.annotation) and REJECTS a caller-supplied id — the context is authoritative. Under `cite`, the ids its embedding carries are the only valid citation targets. */
+            context: components["schemas"]["GatheredContext"];
+            /** @description Refining instruction, composed with `task` (task = what, prompt = how). */
+            prompt?: string;
+            /** @description Entity-type tags to stamp on the synthesized resource. Used both as a prompt bias for the generation worker and as the `entityTypes` set on the resulting resource. */
+            entityTypes?: string[];
+            /** @description Annotation/resource body locale — language the generated resource is written in (typically the user's UI locale). BCP-47. */
+            language?: string;
+            /** @description Source-resource locale — language of the resource being referenced, used in the prompt so the LLM understands embedded source-context snippets when source ≠ target language. BCP-47. */
+            sourceLanguage?: string;
+            /** @description Sampling temperature forwarded to the model. */
+            temperature?: number;
+            /** @description Output token budget forwarded to the model. Length never determines structure. */
+            maxTokens?: number;
+            /** @description Requested media type of the generated resource's content. Default `text/markdown` at the worker, which validates it against its supported output set and FAILS the job for anything it can't write — not a silent fallback. */
+            outputMediaType?: components["schemas"]["SupportedMediaType"];
+            /** @description What the model is asked to produce — the prompt's framing verb. Canonical values ('resource', 'answer', 'summary') map to the worker's tested framings; any other string is used VERBATIM as the framing instruction (loud degrade: the worker warns, never silently falls back). Unset ⇒ 'resource' (article framing). */
+            task?: string;
+            /** @description How the output is internally segmented — shape for text-bearing media, subordinate to `outputMediaType` (never its peer). Canonical values: 'prose' (flowing paragraphs), 'sections' (titled sections + title), 'chat' (speaker-labeled turns); any other string becomes a freeform "organize as: …" directive (loud degrade). Unset ⇒ NO structure directive at all — the task framing and the model determine shape. */
+            structure?: string;
+            /** @description Ask the model to cite: emit [[<id>]] transport tokens after each claim, using the ids the context embedding provides. The worker validates each id against the embedded context (unknown ids are dropped loudly), strips the tokens from the stored content, and mints W3C linking annotations on the derived resource. */
+            cite?: boolean;
+        };
         GetAnnotationHistoryResponse: {
             events: components["schemas"]["StoredEventResponse"][];
             total: number;
@@ -2861,8 +2945,55 @@ interface components {
             database: "connected" | "disconnected" | "unknown";
             environment: string;
         };
+        /** @description A provider's actual ceilings for a model, discovered from the provider itself (Anthropic Models API; Ollama /api/show) — never hand-maintained constants. Semantics differ by provider shape: Anthropic reports maximum input tokens in contextTokens with a separate output ceiling in maxOutputTokens; Ollama reports the shared input+output window and mirrors it into both fields (there is no separate output ceiling), so maxOutputTokens === contextTokens signals a shared window. */
+        InferenceLimits: {
+            /** @description The context window in tokens. Anthropic: maximum input tokens (output has its own ceiling). Ollama: the shared input+output window. */
+            contextTokens: number;
+            /** @description Maximum output tokens per generation. Equal to contextTokens when the provider has a single shared window. */
+            maxOutputTokens: number;
+        };
+        /** @description An annotation's graph presence. The node IS the annotation, so the full W3C object is required — selectors and body included, which is what lets a client place context annotations without a second fetch. Citations ride here too: an inbound reference is its linking annotation, anchored by an `annotation-of` edge to the resource it lives on and a `cites` edge to the focal resource. */
+        GraphAnnotationNode: {
+            /** @description The AnnotationId — the same value as annotation.id */
+            id: string;
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            type: "annotation";
+            /** @description The annotation's motivation, as a display label */
+            label: string;
+            /** @description Entity types carried by the annotation */
+            entityTypes?: string[];
+            annotation: components["schemas"]["Annotation"];
+            metadata?: {
+                [key: string]: unknown;
+            };
+        };
+        /** @description A resource's presence in the gathered knowledge graph. */
+        GraphResourceNode: {
+            /** @description The resource's ResourceId */
+            id: string;
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            type: "resource";
+            /** @description The resource's display name — its raw id when the resource's view was missing at build time */
+            label: string;
+            /** @description Entity types on the resource */
+            entityTypes?: string[];
+            metadata?: {
+                [key: string]: unknown;
+            };
+        };
         /** @description Result of a completed assessment-annotation job. */
         JobAssessmentAnnotationResult: {
+            /**
+             * @description Discriminant — every JobResult member carries `kind`, single-valued, so a consumer holding only the result can tell what it is (WIRE-UNION-DISCRIMINANTS D1). (enum property replaced by openapi-typescript)
+             * @enum {string}
+             */
+            kind: "assessment-annotation";
             assessmentsFound: number;
             assessmentsCreated: number;
         };
@@ -2880,6 +3011,11 @@ interface components {
         };
         /** @description Result of a completed comment-annotation job. */
         JobCommentAnnotationResult: {
+            /**
+             * @description Discriminant — every JobResult member carries `kind`, single-valued, so a consumer holding only the result can tell what it is (WIRE-UNION-DISCRIMINANTS D1). (enum property replaced by openapi-typescript)
+             * @enum {string}
+             */
+            kind: "comment-annotation";
             commentsFound: number;
             commentsCreated: number;
         };
@@ -2907,7 +3043,6 @@ interface components {
             resultResourceId?: string;
             /** @description For generation: URI of annotation that triggered generation */
             annotationUri?: string;
-            message?: string;
             /** @description Full result object for extensibility */
             result?: {
                 [key: string]: unknown;
@@ -2919,7 +3054,8 @@ interface components {
             /** @description Authenticated user's DID, injected by the /bus/emit gateway. Clients do not set this. */
             _userId?: string;
             jobType: components["schemas"]["JobType"];
-            resourceId: string;
+            /** @description Resource the job operates on. REQUIRED for every jobType EXCEPT 'generation', where it must be ABSENT: the dispatcher derives it from params.context.focus (the context is authoritative) and REJECTS a supplied value via job:create-failed. Both directions are enforced at the dispatcher — this schema cannot express the per-jobType conditionality. */
+            resourceId?: string;
             params: {
                 [key: string]: unknown;
             };
@@ -2944,18 +3080,21 @@ interface components {
         };
         /** @description Result of a job that completed without doing its work because the resource could not be read. Distinct from a failure: nothing went wrong, there was simply no text to work with — an encrypted or damaged PDF, a scan whose text could not be recognized, or a document that yielded nothing. The reasons are the extraction vocabulary the Smelter reports on `smelt:settled`, MINUS `no-extractor`: a media type that can never yield text (a zip, an image) is a bad request rather than a decline, so a worker asked to detect over one throws and the job reports `job:fail`. Everything here is a resource-specific outcome — the same media type would have succeeded on a different document. */
         JobDeclinedResult: {
+            /**
+             * @description Discriminant — every JobResult member carries `kind`, single-valued, so a consumer holding only the result can tell what it is (WIRE-UNION-DISCRIMINANTS D1). (enum property replaced by openapi-typescript)
+             * @enum {string}
+             */
+            kind: "declined";
             /**
              * @description Discriminant. Always true — a job that did its work reports one of the other result shapes.
              * @enum {boolean}
              */
             declined: true;
             /**
-             * @description Why the resource could not be read.
+             * @description Why the resource could not be read. A CODE, not a sentence: the client owns the wording, so a browser renders it in the user's language and the CLI renders English terminal copy from the same value. The prose `message` this schema used to carry was composed backend-side and was therefore English everywhere (ASSIST-PROGRESS-CONSOLIDATION P5).
              * @enum {string}
              */
             reason: "no-text-layer" | "encrypted" | "corrupt" | "too-large" | "empty";
-            /** @description Human-readable explanation, suitable for showing to the user. */
-            message: string;
         };
         /** @description Payload for job:failed domain event */
         JobFailedPayload: {
@@ -2966,71 +3105,170 @@ interface components {
             error: string;
             details?: string;
         };
-        /** @description Result of a completed generation job. resourceId is assigned by Stower when yield:create is processed; the worker emits job:complete with only resourceName, and Stower populates resourceId on the persisted payload. */
+        /** @description Result of a completed generation job. The worker creates the resource first (the yield:create round-trip returns the id), then emits job:complete carrying it — so resourceId is always present on the wire. */
         JobGenerationResult: {
-            /** @description ID of the generated resource (populated by Stower, not by the worker) */
-            resourceId?: string;
+            /**
+             * @description Discriminant — every JobResult member carries `kind`, single-valued, so a consumer holding only the result can tell what it is (WIRE-UNION-DISCRIMINANTS D1). (enum property replaced by openapi-typescript)
+             * @enum {string}
+             */
+            kind: "generation";
+            /** @description ID of the generated resource, obtained by the worker from the create round-trip before job:complete is emitted */
+            resourceId: string;
             /** @description Name of the generated resource */
             resourceName: string;
+            /** @description True when the model stopped at the maxTokens ceiling — the artifact is cut off, not complete. Derived at the producer from the provider's stopReason ('max_tokens' → true); required because the worker always knows (GENERATE-FROM-RESOURCE D6/P3a). */
+            truncated: boolean;
         };
         /** @description Result of a completed highlight-annotation job. */
         JobHighlightAnnotationResult: {
+            /**
+             * @description Discriminant — every JobResult member carries `kind`, single-valued, so a consumer holding only the result can tell what it is (WIRE-UNION-DISCRIMINANTS D1). (enum property replaced by openapi-typescript)
+             * @enum {string}
+             */
+            kind: "highlight-annotation";
             highlightsFound: number;
             highlightsCreated: number;
         };
-        /** @description Progress report from a running job. Common fields are stage/percentage/message; job-type-specific fields may also be present. This is the single progress shape for every job type — annotation workers and generation alike. */
+        /** @description Progress report from a running job. The required field is `percentage`; `message` carries the coded phase and the rest are optional job-shape fields. This is the single progress shape for every job type — annotation workers and generation alike. `stage` and `currentEntityType` were REMOVED (ASSIST-PROGRESS-CONSOLIDATION P5): both were redundant denormalization of `message`. Terminality is signalled on `job:complete` / `job:fail`, not here. The per-flow progress vocabularies (`processedEntityTypes`/`totalEntityTypes` for references, `processedCategories`/`totalCategories`/`currentCategory` for tags) were replaced by one `current`/`processed`/`total` triple (CLEAN-PROGRESS D2): both flows iterate a user-chosen list, so they report the same shape and the client stops guessing which flow it is drawing. */
         JobProgress: {
-            /** @description Current processing stage (e.g. 'analyzing', 'creating', 'complete', 'error') */
-            stage: string;
             /** @description Completion percentage (0-100) */
             percentage: number;
-            /** @description Human-readable progress message */
-            message: string;
-            /** @description Annotation this job is attached to, when applicable. Echoed inside JobProgress (in addition to the outer command envelope) so consumers that only see the inner progress object (e.g. client.yield.fromAnnotation's Observable) can still route visual feedback to a specific annotation. */
+            /** @description What the job is doing right now, as a code plus typed params; the client renders the sentence. Optional: pure percentage heartbeats carry none, and consumers render nothing message-shaped when it is absent (this is also the whole tolerance story for pre-2026-08 persisted events that carried prose here). */
+            message?: components["schemas"]["JobProgressMessage"];
+            /** @description Annotation this job is attached to, when applicable. Echoed inside JobProgress (in addition to the outer command envelope) so consumers that only see the inner progress object (e.g. client.yield.fromContext's Observable) can still route visual feedback to a specific annotation. */
             annotationId?: string;
-            /** @description Total entity types to process (reference-annotation) */
-            totalEntityTypes?: number;
-            /** @description Entity types processed so far (reference-annotation) */
-            processedEntityTypes?: number;
+            /** @description What the run is working on right now. `kind` is a CODE the client renders a localized name for; `value` is KB data (an entity type, a tag category) shown verbatim — the same split as `requestParams`. Absent on flows that iterate nothing, such as generation. */
+            current?: {
+                /**
+                 * @description What sort of thing `value` is. Adding a variant means adding client copy for it in every locale.
+                 * @enum {string}
+                 */
+                kind: "entity-type" | "category";
+                /** @description The item itself, shown verbatim and never translated. */
+                value: string;
+            };
+            /** @description Items completed so far, zero-based — the item in `current` is the one after these. Paired with `total`. */
+            processed?: number;
+            /** @description Items this run will process in all. */
+            total?: number;
             /** @description Entities found so far (reference-annotation) */
             entitiesFound?: number;
             /** @description Annotations emitted so far (reference-annotation) */
             entitiesEmitted?: number;
-            /** @description Entity type currently being processed */
-            currentEntityType?: string;
-            /** @description Reference annotation: completed entity types with per-type counts, for UI progress display */
-            completedEntityTypes?: {
-                entityType: string;
+            /** @description Per-item results for the items already finished, for the UI's completed log. Generic across flows for the same reason `current` is. */
+            completedItems?: {
+                /** @description The item, shown verbatim. */
+                value: string;
+                /** @description Annotations found for it. */
                 foundCount: number;
             }[];
-            /** @description Categories processed (tag-annotation) */
-            processedCategories?: number;
-            /** @description Total categories (tag-annotation) */
-            totalCategories?: number;
-            /** @description Category currently being processed (tag-annotation) */
-            currentCategory?: string;
-            /** @description Echoed job parameters for display in the progress UI (e.g. entity types or categories the user asked to detect) */
+            /** @description Echoed job parameters for display in the progress UI. `label` is a CODE, not a sentence — the client owns the wording, same rule as the progress message. `value` is the user's own input (an entity-type list, their instructions) and is deliberately NOT translated: it is their words, not ours. */
             requestParams?: {
-                label: string;
+                /**
+                 * @description Which parameter this is. The client renders a localized name for it.
+                 * @enum {string}
+                 */
+                label: "entity-types" | "instructions" | "tone" | "density";
+                /** @description The user's own input, shown verbatim. */
                 value: string;
             }[];
         };
-        /** @description Payload for job:progress domain event */
-        JobProgressPayload: {
-            jobId: string;
-            jobType: components["schemas"]["JobType"];
-            percentage: number;
-            /** @description Human-readable current step */
-            currentStep?: string;
-            processedSteps?: number;
-            totalSteps?: number;
-            /** @description For detection: entities found so far */
-            foundCount?: number;
-            message?: string;
-            /** @description Full progress object for extensibility */
-            progress?: {
-                [key: string]: unknown;
-            };
+        /** @description What a running job is doing right now, as a code plus typed params — never a prose sentence. The producer reports what happened; each client renders it in the user's language (react-ui from its translations, the Go launcher from its English map). One named schema per code, discriminated on `code` (WIRE-UNION-DISCRIMINANTS P5b), so generated clients get typed variants and copy-map completeness is statically checkable. The vocabulary is the census of every onProgress call site in @semiont/jobs (.plans/ASSIST-PROGRESS-CONSOLIDATION.md P1); extending it means adding a named variant here and copy in every client, gated by the locale-completeness check. */
+        JobProgressMessage: components["schemas"]["JobProgressLoading"] | components["schemas"]["JobProgressAnalyzing"] | components["schemas"]["JobProgressAnalyzingTags"] | components["schemas"]["JobProgressGeneratingResource"] | components["schemas"]["JobProgressCreatingResource"] | components["schemas"]["JobProgressCompleteGenerated"] | components["schemas"]["JobProgressDetectingEntities"] | components["schemas"]["JobProgressCreatingAnnotations"] | components["schemas"]["JobProgressCreatingTagAnnotations"] | components["schemas"]["JobProgressCompleteCreated"];
+        /** @description Analyzing the content. */
+        JobProgressAnalyzing: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            code: "analyzing";
+        };
+        /** @description Analyzing the content against the tag schema. */
+        JobProgressAnalyzingTags: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            code: "analyzing-tags";
+        };
+        /** @description Terminal success summary. */
+        JobProgressCompleteCreated: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            code: "complete-created";
+            /** @description How many annotations were created */
+            count: number;
+            /**
+             * @description What kind of annotation was created; clients pluralize/translate
+             * @enum {string}
+             */
+            kind: "highlight" | "comment" | "assessment" | "reference" | "tag";
+        };
+        /** @description Generation's terminal success. Deliberately generic — the client already holds the title it typed, and the outcome (name + resource link) travels on job:complete, not on progress (GENERATE-FROM-RESOURCE D7/D8). `truncated` qualifies the completion (D6): the same bit `JobGenerationResult.truncated` carries, so the two surfaces cannot drift. */
+        JobProgressCompleteGenerated: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            code: "complete-generated";
+            /** @description True when the model stopped at the maxTokens ceiling — the artifact is cut off, not complete. */
+            truncated: boolean;
+        };
+        /** @description Writing detected annotations back to the resource. */
+        JobProgressCreatingAnnotations: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            code: "creating-annotations";
+            /** @description How many annotations are being created */
+            count: number;
+        };
+        /** @description Writing the generated resource. */
+        JobProgressCreatingResource: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            code: "creating-resource";
+        };
+        /** @description Writing detected tag annotations back to the resource. */
+        JobProgressCreatingTagAnnotations: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            code: "creating-tag-annotations";
+            /** @description How many annotations are being created */
+            count: number;
+        };
+        /** @description Entity detection, one entity type at a time. */
+        JobProgressDetectingEntities: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            code: "detecting-entities";
+            /** @description Entity type currently being detected */
+            entityType: string;
+        };
+        /** @description The model is generating the resource. */
+        JobProgressGeneratingResource: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            code: "generating-resource";
+        };
+        /** @description Loading the resource content. */
+        JobProgressLoading: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            code: "loading";
         };
         /** @description Event indicating a job has been queued */
         JobQueuedEvent: {
@@ -3042,6 +3280,11 @@ interface components {
         };
         /** @description Result of a completed reference-annotation job. */
         JobReferenceAnnotationResult: {
+            /**
+             * @description Discriminant — every JobResult member carries `kind`, single-valued, so a consumer holding only the result can tell what it is (WIRE-UNION-DISCRIMINANTS D1). (enum property replaced by openapi-typescript)
+             * @enum {string}
+             */
+            kind: "reference-annotation";
             /** @description Total entities found */
             totalFound: number;
             /** @description Total annotations emitted */
@@ -3061,7 +3304,7 @@ interface components {
             percentage: number;
             progress?: components["schemas"]["JobProgress"];
         };
-        /** @description Discriminated union of all job result types. */
+        /** @description Discriminated union of all job result types — every member carries a single-valued `kind` (WIRE-UNION-DISCRIMINANTS D1/D2). Consumers switch on `kind`; generated clients get typed variants. */
         JobResult: components["schemas"]["JobGenerationResult"] | components["schemas"]["JobReferenceAnnotationResult"] | components["schemas"]["JobHighlightAnnotationResult"] | components["schemas"]["JobAssessmentAnnotationResult"] | components["schemas"]["JobCommentAnnotationResult"] | components["schemas"]["JobTagAnnotationResult"] | components["schemas"]["JobDeclinedResult"];
         /** @description Command to start a job */
         JobStartCommand: {
@@ -3097,7 +3340,7 @@ interface components {
             completedAt?: string;
             error?: string;
             progress?: unknown;
-            result?: unknown;
+            result?: components["schemas"]["JobResult"];
         };
         /** @description Result of a job status request */
         JobStatusResult: {
@@ -3106,6 +3349,11 @@ interface components {
         };
         /** @description Result of a completed tag-annotation job. */
         JobTagAnnotationResult: {
+            /**
+             * @description Discriminant — every JobResult member carries `kind`, single-valued, so a consumer holding only the result can tell what it is (WIRE-UNION-DISCRIMINANTS D1). (enum property replaced by openapi-typescript)
+             * @enum {string}
+             */
+            kind: "tag-annotation";
             tagsFound: number;
             tagsCreated: number;
             /** @description Count of tags created per category */
@@ -3120,25 +3368,11 @@ interface components {
         JobType: "reference-annotation" | "generation" | "highlight-annotation" | "assessment-annotation" | "comment-annotation" | "tag-annotation";
         /** @description Knowledge graph gathered for an LLM context — a shared backbone in which resources AND annotations are typed nodes, connected by typed (optionally bidirectional) edges. Flattened views the matcher/generation read (connections, citedBy, siblings) are derived from these nodes/edges. */
         KnowledgeGraph: {
-            nodes: {
-                /** @description Node identifier — a ResourceId or AnnotationId */
-                id: string;
-                /**
-                 * @description Whether this node is a resource or an annotation
-                 * @enum {string}
-                 */
-                type: "resource" | "annotation";
-                label: string;
-                /** @description Entity types on the node (resources) or carried by the annotation */
-                entityTypes?: string[];
-                metadata?: {
-                    [key: string]: unknown;
-                };
-            }[];
+            nodes: (components["schemas"]["GraphResourceNode"] | components["schemas"]["GraphAnnotationNode"])[];
             edges: {
                 source: string;
                 target: string;
-                /** @description Edge kind (e.g. citation, annotation-of, sibling) */
+                /** @description Edge kind: `annotation-of` (an annotation → the resource it lives on), `cites` (a citing linking annotation → the focal resource), or a peer connection's own relationshipType (free-form; `link` when unnamed) */
                 type: string;
                 /** @description Whether the connection goes both ways */
                 bidirectional?: boolean;
@@ -3152,6 +3386,11 @@ interface components {
             total: number;
             offset: number;
             limit: number;
+            /**
+             * @description What kind of answer this is: 'lexical' — the resources matched the query text; 'semantic' — no lexical match existed, and these resources discuss the query per the vector index (SEMANTIC-FALLBACK). Required so every producer labels its answer; a UI can render semantic results as a different kind of page ('no title matches, but these documents discuss it').
+             * @enum {string}
+             */
+            matchKind: "lexical" | "semantic";
         };
         /** @description Bus command to archive a resource and optionally remove its file. */
         MarkArchiveCommand: {
@@ -3529,6 +3768,8 @@ interface components {
             text: string;
             /** @description Source resource ID */
             resourceId: string;
+            /** @description The source resource's display name, resolved from its view at gather time. Required: a match card must name its source, and corpus matches routinely come from outside the graph neighborhood, so there is no node to borrow a name from. A match whose source no longer resolves to a view is dropped by the producer rather than served nameless. */
+            resourceName: string;
             /** @description Source annotation ID, if the match is from an annotation */
             annotationId?: string;
             /** @description Cosine similarity score (0-1) */
@@ -3538,6 +3779,20 @@ interface components {
             /** @description True when this passage's text was recognized from pixels (OCR of a scanned page) rather than read from the document. Absent means read directly — the common case — so the flag is only present where it changes how the text should be trusted. It travels with the passage because a consumer receives the chunk with no document attached and cannot recompute how the text was obtained. */
             machineRead?: boolean;
         };
+        /** @description A participant opened a live connection to this KB — an SSE stream on /bus/subscribe. Presence is CONNECTION lifecycle, not login: a token can be minted and sit unused, so what this reports is that someone is WATCHING. One person with two tabs produces two of these, which is why connectionId is required — the DID alone cannot tell two connections apart, and a consumer that counts DIDs will undercount viewers. */
+        SessionJoinedEvent: {
+            /** @description DID of the authenticated principal on that connection. A person or a software agent — the bus does not distinguish. */
+            participant: string;
+            /** @description Identifies this connection for its lifetime. The matching session:left carries the same value. */
+            connectionId: string;
+        };
+        /** @description A participant's live connection to this KB ended — the SSE stream aborted. Carries the same connectionId as the session:joined that opened it, so a consumer tracking who is present can retire the right connection rather than assuming one per participant. */
+        SessionLeftEvent: {
+            /** @description DID of the authenticated principal on that connection. */
+            participant: string;
+            /** @description The connectionId announced by the matching session:joined. */
+            connectionId: string;
+        };
         /** @description Emitted when the hover delay setting changes */
         SettingsHoverDelayChangedEvent: {
             hoverDelayMs: number;
@@ -3552,7 +3807,10 @@ interface components {
             theme: "light" | "dark" | "system";
         };
         SpecificResource: {
-            /** @enum {string} */
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
             type: "SpecificResource";
             /** @description IRI of the target resource */
             source: string;
@@ -3645,7 +3903,10 @@ interface components {
             suffix?: string;
         };
         TextualBody: {
-            /** @enum {string} */
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
             type: "TextualBody";
             /** @description The text content (e.g., entity type name) */
             value: string;
@@ -4024,7 +4285,6 @@ type PersistedEventCatalog = {
     'frame:entity-type-added': components['schemas']['EntityTypeAddedPayload'];
     'frame:tag-schema-added': components['schemas']['TagSchemaAddedPayload'];
     'job:started': components['schemas']['JobStartedPayload'];
-    'job:progress': components['schemas']['JobProgressPayload'];
     'job:completed': components['schemas']['JobCompletedPayload'];
     'job:failed': components['schemas']['JobFailedPayload'];
 };
@@ -4054,7 +4314,7 @@ type PersistedEventType = PersistedEvent['type'];
  * also adding it here: forgetting fails to typecheck rather than silently
  * dropping the event from the events-stream.
  */
-declare const PERSISTED_EVENT_TYPES: readonly ["yield:created", "yield:cloned", "yield:updated", "yield:moved", "yield:representation-added", "yield:representation-removed", "mark:added", "mark:removed", "mark:body-updated", "mark:archived", "mark:unarchived", "mark:entity-tag-added", "mark:entity-tag-removed", "frame:entity-type-added", "frame:tag-schema-added", "job:started", "job:progress", "job:completed", "job:failed"];
+declare const PERSISTED_EVENT_TYPES: readonly ["yield:created", "yield:cloned", "yield:updated", "yield:moved", "yield:representation-added", "yield:representation-removed", "mark:added", "mark:removed", "mark:body-updated", "mark:archived", "mark:unarchived", "mark:entity-tag-added", "mark:entity-tag-removed", "frame:entity-type-added", "frame:tag-schema-added", "job:started", "job:completed", "job:failed"];
 /** Input type for appendEvent — PersistedEvent without id/timestamp (assigned at persistence time). */
 type EventInput = Omit<PersistedEvent, 'id' | 'timestamp'>;
 
@@ -4420,7 +4680,8 @@ type EventMap = {
     'browse:click': components['schemas']['BrowseClickEvent'] & {
         anchorRect?: AnchorRect;
     };
-    'browse:reference-navigate': components['schemas']['BrowseReferenceNavigateEvent'];
+    'browse:resource-open': components['schemas']['BrowseResourceOpenEvent'];
+    'browse:resource-viewed': components['schemas']['BrowseResourceViewedEvent'];
     'browse:entity-type-clicked': components['schemas']['BrowseEntityTypeClickedEvent'];
     'panel:toggle': components['schemas']['BrowsePanelToggleEvent'];
     'panel:open': components['schemas']['BrowsePanelOpenEvent'] & {
@@ -4439,7 +4700,6 @@ type EventMap = {
     'beckon:focus': components['schemas']['BeckonFocusEvent'];
     'beckon:sparkle': components['schemas']['BeckonSparkleEvent'];
     'job:started': StoredEvent<EventOfType<'job:started'>>;
-    'job:progress': StoredEvent<EventOfType<'job:progress'>>;
     'job:completed': StoredEvent<EventOfType<'job:completed'>>;
     'job:failed': StoredEvent<EventOfType<'job:failed'>>;
     'job:start': components['schemas']['JobStartCommand'];
@@ -4539,6 +4799,8 @@ type EventMap = {
         lastSeenId?: string;
         reason: string;
     };
+    'session:joined': components['schemas']['SessionJoinedEvent'];
+    'session:left': components['schemas']['SessionLeftEvent'];
 };
 
 /**
@@ -4724,8 +4986,9 @@ declare const CHANNEL_SCHEMAS: {
     readonly 'browse:directory-requested': "BrowseDirectoryRequest";
     readonly 'browse:directory-result': "BrowseDirectoryResult";
     readonly 'browse:directory-failed': null;
-    readonly 'browse:click': null;
-    readonly 'browse:reference-navigate': "BrowseReferenceNavigateEvent";
+    readonly 'browse:click': "BrowseClickEvent";
+    readonly 'browse:resource-open': "BrowseResourceOpenEvent";
+    readonly 'browse:resource-viewed': "BrowseResourceViewedEvent";
     readonly 'browse:entity-type-clicked': "BrowseEntityTypeClickedEvent";
     readonly 'panel:toggle': "BrowsePanelToggleEvent";
     readonly 'panel:open': null;
@@ -4740,7 +5003,6 @@ declare const CHANNEL_SCHEMAS: {
     readonly 'beckon:focus': "BeckonFocusEvent";
     readonly 'beckon:sparkle': "BeckonSparkleEvent";
     readonly 'job:started': null;
-    readonly 'job:progress': null;
     readonly 'job:completed': null;
     readonly 'job:failed': null;
     readonly 'job:start': "JobStartCommand";
@@ -4775,6 +5037,8 @@ declare const CHANNEL_SCHEMAS: {
     readonly 'stream-connected': null;
     readonly 'replay-window-exceeded': null;
     readonly 'bus:resume-gap': null;
+    readonly 'session:joined': "SessionJoinedEvent";
+    readonly 'session:left': "SessionLeftEvent";
 };
 /** Channels where `/bus/emit` validates the payload (non-null schema). */
 type EmittableChannel = {
@@ -4795,6 +5059,13 @@ type EmittableChannel = {
 
 type Selector = components['schemas']['TextPositionSelector'] | components['schemas']['TextQuoteSelector'] | components['schemas']['SvgSelector'] | components['schemas']['FragmentSelector'];
 type GatheredContext = components['schemas']['GatheredContext'];
+/**
+ * The `job:create` params shape for `jobType: 'generation'` — one type shared
+ * by the write side (sdk `yield.fromContext` → `runGeneration`) and the read
+ * side (the generation worker's `isGenerationJobParams` narrowing), so the two
+ * ends of the wire cannot drift a field apart silently.
+ */
+type GenerationJobParams = components['schemas']['GenerationJobParams'];
 type SelectionData = components['schemas']['SelectionData'];
 type JobType = components['schemas']['JobType'];
 /**
@@ -5885,8 +6156,15 @@ interface ITransport {
      * `resourceScope`, when set, marks the emit as a resource-scoped
      * broadcast — only delivered to subscribers attached to that
      * resource's scope.
+     *
+     * Resolves with the number of subscribers the emit reached
+     * (`/bus/emit` responds `{subscribers: n}`; GUIDED-TOUR P1), or `-1`
+     * when the count is unknown — an older backend, an unreadable body, or
+     * an in-process transport where the question does not apply. `-1` is
+     * the same sentinel the Go client uses: a parse failure must stay
+     * distinguishable from a genuine empty room.
      */
-    emit<K extends keyof EventMap>(channel: K, payload: EventMap[K], resourceScope?: ResourceId): Promise<void>;
+    emit<K extends keyof EventMap>(channel: K, payload: EventMap[K], resourceScope?: ResourceId): Promise<number>;
     on<K extends keyof EventMap>(channel: K, handler: (payload: EventMap[K]) => void): () => void;
     stream<K extends keyof EventMap>(channel: K): Observable<EventMap[K]>;
     /**
@@ -6348,7 +6626,7 @@ type BusOperationKey = keyof typeof BUS_OPERATIONS;
  * and SSE infrastructure. A reply channel must NOT go here — declare its
  * operation in `BUS_OPERATIONS` instead.
  */
-declare const BRIDGED_BROADCASTS: readonly ["job:report-progress", "job:complete", "job:fail", "frame:entity-type-added", "frame:tag-schema-added", "beckon:focus", "beckon:sparkle", "bus:resume-gap"];
+declare const BRIDGED_BROADCASTS: readonly ["job:report-progress", "job:complete", "job:fail", "frame:entity-type-added", "frame:tag-schema-added", "beckon:focus", "beckon:sparkle", "bus:resume-gap", "browse:resource-open", "browse:resource-viewed", "session:joined", "session:left", "browse:click"];
 type OpSpecs = (typeof BUS_OPERATIONS)[keyof typeof BUS_OPERATIONS];
 type ProgressChannel<O> = O extends {
     progress: infer P extends EventName;
@@ -6384,7 +6662,12 @@ declare class BusRequestError extends SemiontError {
  * can satisfy it without round-tripping through HTTP.
  */
 interface BusRequestPrimitive {
-    emit<K extends keyof EventMap>(channel: K, payload: EventMap[K]): Promise<void>;
+    /**
+     * Matches `ITransport.emit`'s return: the subscriber count (`-1` =
+     * unknown). `busRequest` itself ignores it — the reply channel is its
+     * ack — but the primitive must stay assignable from every ITransport.
+     */
+    emit<K extends keyof EventMap>(channel: K, payload: EventMap[K]): Promise<number>;
     stream<K extends keyof EventMap>(channel: K): Observable<EventMap[K]>;
     /**
      * Connection state of the stream that carries replies. Required, not
@@ -7222,6 +7505,35 @@ declare function isNullish(value: unknown): value is null | undefined;
  * Check if value is defined (not null or undefined)
  */
 declare function isDefined<T>(value: T | null | undefined): value is T;
+/**
+ * Boundary guard for `job:create` generation params (YIELD-FROM-CONTEXT P1).
+ *
+ * Checks the REQUIRED trio the schema declares (`title`, `storageUri`,
+ * `context`) plus basic shape — deliberately NOT a full schema validation
+ * (that depth belongs to the spec and its generated types); this is the
+ * runtime half of the contract for values whose type history was severed:
+ * wire JSON, storage, casts. For well-typed callers it is dead code, and
+ * that is the correct price for a trust-boundary check.
+ */
+declare function isGenerationJobParams(value: unknown): value is GenerationJobParams;
+/**
+ * Boundary guard for a `GatheredContext` whose type history was severed —
+ * today that is exactly one place: the wizard stashes the context in
+ * `sessionStorage` on the way to the compose page, which reads it back and
+ * `JSON.parse`s it.
+ *
+ * Checks what consumers actually dereference rather than the whole schema:
+ * `focus` (every view branches on `focus.kind`) and `graph.nodes` / `graph.edges`,
+ * which `deriveViews` maps over without a guard. Both are `required` in
+ * `GatheredContext.json` / `KnowledgeGraph.json`, so this is dead code for every
+ * well-typed caller — the price of a trust boundary, same as
+ * `isGenerationJobParams` above.
+ *
+ * The failure it prevents is not cosmetic: `deriveViews` runs during render, so a
+ * stale stash (a tab held open across a deploy) throws inside React rather than
+ * degrading, unmounting the flow to the nearest error boundary.
+ */
+declare function isGatheredContext(value: unknown): value is GatheredContext;
 
 /**
  * DID (Decentralized Identifier) and W3C Agent utilities
@@ -7727,8 +8039,8 @@ interface ServicesConfig {
     database?: DatabaseServiceConfig;
     graph?: GraphServiceConfig;
     mcp?: McpServiceConfig;
-    vectors?: VectorsServiceConfig;
-    embedding?: EmbeddingServiceConfig;
+    vectors: VectorsServiceConfig;
+    embedding: EmbeddingServiceConfig;
     [k: string]: unknown;
 }
 /**
@@ -8010,11 +8322,16 @@ declare function getAllPlatformTypes(): PlatformType[];
  * and `@semiont/jobs` (the generation prompt builder) can share one derivation. `buildKnowledgeGraph`
  * — which queries the graph DB — stays in make-meaning; this only transforms an already-built graph.
  *
- * Reports the graph as-is (Option A): missing-view citers are kept (the citation edge reflects a real
- * reference event); the only filter is excluding the focal annotation from siblings (an annotation
- * isn't its own sibling). Peer connections are edges out of `mainResourceId`; citations and
- * `annotation-of` edges point INTO it. The graph is a projection of the event log (the system of
- * record), read here because it is the queryable projection at gather time.
+ * Reports the graph as-is (Option A): missing-view citers are kept (the citing annotation reflects a
+ * real reference event; its resource label falls back to the raw id). A citation is its linking
+ * ANNOTATION: an annotation node with `annotation-of` → the citing resource and `cites` → the focal
+ * resource — so citedBy resolves through that pair, deduped per citing resource (several citations
+ * from one document are one citer). Siblings are annotations ON the focal resource
+ * (`annotation-of` → main), excluding the focal annotation — an annotation isn't its own sibling,
+ * and a CITING annotation lives on another resource, so it never was one. Peer connections are
+ * edges out of `mainResourceId`; derivation is structural (endpoints), never a match on the
+ * free-form relationshipType. The graph is a projection of the event log (the system of record),
+ * read here because it is the queryable projection at gather time.
  */
 
 type KnowledgeGraph = components['schemas']['KnowledgeGraph'];
@@ -8149,5 +8466,5 @@ declare function getShardPath(key: string, numBuckets?: number): [string, string
  */
 declare const DISCOVERY_URL_PATH = "/discovery/kbs.json";
 
-export { AUTHORABLE_MEDIA_TYPES, BRIDGED_CHANNELS, BUS_OPERATIONS, BusRequestError, CHANNEL_SCHEMAS, CONTEXT_FULL_WEIGHT, CONTEXT_PARTIAL_WEIGHT, ConfigurationError, ConflictError, DEFAULT_CHUNKING_CONFIG, DISCOVERY_URL_PATH, EMBEDDABLE_MEDIA_TYPES, EventBus, GENERATABLE_MEDIA_TYPES, JWTTokenSchema, LOCALES, MEDIA_TYPES, NotFoundError, PERSISTED_EVENT_TYPES, POSITION_WEIGHT_MAX, POSITION_WINDOW, RESOURCE_BROADCAST_TYPES, STARTUP_FETCH_RETRY, ScopedEventBus, ScriptError, SemiontError, UnauthorizedError, ValidationError, accessToken, agentToDid, anchorAnnotation, anchorRuns, annotationId, annotationUri, applyBodyOperations, assembleAnnotation, authCode, baseMediaType, baseUrl, buildContentCache, burstBuffer, busLog, busLogEnabled, busRequest, capabilitiesOf, chunkText, cloneToken, createCircleSvg, createFragmentSelector, createPolygonSvg, createRectangleSvg, createTomlConfigLoader, decodeRepresentation, decodeWithCharset, deriveViews, didToAgent, email, entityType, errField, estimateTokens, extensionForMediaType, extractBoundingBox, extractCharset, extractContext, findBestTextMatch, findBodyItem, findClaimSpan, formatLocaleDisplay, generateUuid, getAllLocaleCodes, getAllPlatformTypes, getAnnotationExactText, getAnnotationUriFromEvent, getBodySource, getBodyType, getChecksum, getCommentText, getCreator, getDerivedFrom, getExactText, getFragmentSelector, getLanguage, getLocaleEnglishName, getLocaleInfo, getLocaleNativeName, getNodeEncoding, getPageFromFragment, getPrimaryMediaType, getPrimaryRepresentation, getPrimarySelector, getResourceEntityTypes, getResourceId, getShardPath, getStorageUri, getSvgSelector, getTargetSelector, getTargetSource, getTextPositionSelector, getTextQuoteSelector, googleCredential, hasTargetSelector, isAnnotationId, isArchived, isArray, isAssessment, isBodyResolved, isBoolean, isComment, isDefined, isDraft, isEventRelatedToAnnotation, isFunction, isHighlight, isNull, isNullish, isNumber, isObject, isReference, isResolvedReference, isResourceId, isStoredEvent, isString, isStubReference, isSupportedMediaType, isTag, isTextRun, isTransientFetchError, isUndefined, isValidEmail, isValidPlatformType, jobId, jumpConsistentHash, kbDid, loadTomlConfig, locate, mcpToken, mediaTypeForExtension, normalizeCoordinates, normalizeText, parseEnvironment, parseFragmentSelector, parseSvgSelector, reconcileSelector, refreshToken, resourceAnnotationUri, resourceId, resourceUri, retryWithBackoff, scaleSvgToNative, searchQuery, serializePerKey, setBusLogTraceIdProvider, softwareToAgent, textExtractionOf, textUnder, userDID, userId, userToAgent, userToDid, uuidV4, validateData, validateEnvironment, validateSvgMarkup, verifyPosition };
-export type { AccessToken, AnchorConfidence, AnchorMethod, AnchorRect, AnchorSelectors, AnchorStrategy, AnchoredText, AnchoringModel, Annotation, AnnotationCategory, AnnotationId, AnnotationUri, AnthropicProviderConfig, AppConfig, AssembledAnnotation, AuthCode, BackendDownload, BackendServiceConfig, BaseUrl, BodyItem, BodyItemIdentity, BodyOperation, BoundingBox, Brand, BridgedChannel, BurstBufferOptions, BusOp, BusOperationKey, BusOperationSpec, BusRequestErrorCode, BusRequestPrimitive, ChunkingConfig, CloneToken, CollaboratorEntry, ConnectionState, ContentCache, ContentFormat, CreateAnnotationInternal, DatabaseServiceConfig, DiscoveredKB, DiscoveryDocument, Email, EmbeddingServiceConfig, EmittableChannel, EntityType, EntityTypeStats, Environment, EnvironmentConfig, EventBase, EventInput, EventMap, EventMetadata, EventName, EventOfType, EventQuery, EventSignature, ExtractionOutcome, FragmentSelector, FrontendServiceConfig, GatheredContext, GoogleAuthRequest, GoogleCredential, GraphConnection, GraphDatabaseType, GraphPath, GraphServiceConfig, GraphViews, HealthCheckResponse, IBackendOperations, IContentTransport, ITransport, InferenceProvidersConfig, JobId, JobType, ListUsersResponse, LlmSelectorInput, LocaleInfo, Logger, MCPToken, MatchQuality, McpServiceConfig, MediaTypeCapabilities, Motivation, OllamaProviderConfig, PdfCoordinate, PdfTextItem, PdfTextRun, PersistedEvent, PersistedEventType, PlatformType, Point, ProgressCallback, ProgressEvent, PutBinaryOptions, PutBinaryProgress, PutBinaryRequest, ReconciledSelector, RefreshToken, RenderMode, RenderedAnchor, ResourceAnnotationUri, ResourceAnnotations, ResourceBroadcastType, ResourceDescriptor, ResourceFilter, ResourceId, ResourceUri, RetryAttemptInfo, RetryPolicy, SearchQuery, SelectionData, Selector, SemiontConfig, ServicePlatformConfig, ServicesConfig, SiteConfig, StateUnit, StatusResponse, StoredEvent, StoredEventLike, SupportedMediaType, SvgSelector, TagCategory, TagSchema, TextExtraction, TextPosition, TextPositionSelector, TextQuoteSelector, ActorInferenceConfig as TomlActorInferenceConfig, TomlFileReader, InferenceConfig as TomlInferenceConfig, WorkerInferenceConfig as TomlWorkerInferenceConfig, TransportErrorCode, UpdateResourceInput, UpdateUserRequest, UpdateUserResponse, UserDID, UserId, UserResponse, ValidationFailure, ValidationResult, ValidationSuccess, VectorsServiceConfig, components, operations, paths };
+export { AUTHORABLE_MEDIA_TYPES, BRIDGED_CHANNELS, BUS_OPERATIONS, BusRequestError, CHANNEL_SCHEMAS, CONTEXT_FULL_WEIGHT, CONTEXT_PARTIAL_WEIGHT, ConfigurationError, ConflictError, DEFAULT_CHUNKING_CONFIG, DISCOVERY_URL_PATH, EMBEDDABLE_MEDIA_TYPES, EventBus, GENERATABLE_MEDIA_TYPES, JWTTokenSchema, LOCALES, MEDIA_TYPES, NotFoundError, PERSISTED_EVENT_TYPES, POSITION_WEIGHT_MAX, POSITION_WINDOW, RESOURCE_BROADCAST_TYPES, STARTUP_FETCH_RETRY, ScopedEventBus, ScriptError, SemiontError, UnauthorizedError, ValidationError, accessToken, agentToDid, anchorAnnotation, anchorRuns, annotationId, annotationUri, applyBodyOperations, assembleAnnotation, authCode, baseMediaType, baseUrl, buildContentCache, burstBuffer, busLog, busLogEnabled, busRequest, capabilitiesOf, chunkText, cloneToken, createCircleSvg, createFragmentSelector, createPolygonSvg, createRectangleSvg, createTomlConfigLoader, decodeRepresentation, decodeWithCharset, deriveViews, didToAgent, email, entityType, errField, estimateTokens, extensionForMediaType, extractBoundingBox, extractCharset, extractContext, findBestTextMatch, findBodyItem, findClaimSpan, formatLocaleDisplay, generateUuid, getAllLocaleCodes, getAllPlatformTypes, getAnnotationExactText, getAnnotationUriFromEvent, getBodySource, getBodyType, getChecksum, getCommentText, getCreator, getDerivedFrom, getExactText, getFragmentSelector, getLanguage, getLocaleEnglishName, getLocaleInfo, getLocaleNativeName, getNodeEncoding, getPageFromFragment, getPrimaryMediaType, getPrimaryRepresentation, getPrimarySelector, getResourceEntityTypes, getResourceId, getShardPath, getStorageUri, getSvgSelector, getTargetSelector, getTargetSource, getTextPositionSelector, getTextQuoteSelector, googleCredential, hasTargetSelector, isAnnotationId, isArchived, isArray, isAssessment, isBodyResolved, isBoolean, isComment, isDefined, isDraft, isEventRelatedToAnnotation, isFunction, isGatheredContext, isGenerationJobParams, isHighlight, isNull, isNullish, isNumber, isObject, isReference, isResolvedReference, isResourceId, isStoredEvent, isString, isStubReference, isSupportedMediaType, isTag, isTextRun, isTransientFetchError, isUndefined, isValidEmail, isValidPlatformType, jobId, jumpConsistentHash, kbDid, loadTomlConfig, locate, mcpToken, mediaTypeForExtension, normalizeCoordinates, normalizeText, parseEnvironment, parseFragmentSelector, parseSvgSelector, reconcileSelector, refreshToken, resourceAnnotationUri, resourceId, resourceUri, retryWithBackoff, scaleSvgToNative, searchQuery, serializePerKey, setBusLogTraceIdProvider, softwareToAgent, textExtractionOf, textUnder, userDID, userId, userToAgent, userToDid, uuidV4, validateData, validateEnvironment, validateSvgMarkup, verifyPosition };
+export type { AccessToken, AnchorConfidence, AnchorMethod, AnchorRect, AnchorSelectors, AnchorStrategy, AnchoredText, AnchoringModel, Annotation, AnnotationCategory, AnnotationId, AnnotationUri, AnthropicProviderConfig, AppConfig, AssembledAnnotation, AuthCode, BackendDownload, BackendServiceConfig, BaseUrl, BodyItem, BodyItemIdentity, BodyOperation, BoundingBox, Brand, BridgedChannel, BurstBufferOptions, BusOp, BusOperationKey, BusOperationSpec, BusRequestErrorCode, BusRequestPrimitive, ChunkingConfig, CloneToken, CollaboratorEntry, ConnectionState, ContentCache, ContentFormat, CreateAnnotationInternal, DatabaseServiceConfig, DiscoveredKB, DiscoveryDocument, Email, EmbeddingServiceConfig, EmittableChannel, EntityType, EntityTypeStats, Environment, EnvironmentConfig, EventBase, EventInput, EventMap, EventMetadata, EventName, EventOfType, EventQuery, EventSignature, ExtractionOutcome, FragmentSelector, FrontendServiceConfig, GatheredContext, GenerationJobParams, GoogleAuthRequest, GoogleCredential, GraphConnection, GraphDatabaseType, GraphPath, GraphServiceConfig, GraphViews, HealthCheckResponse, IBackendOperations, IContentTransport, ITransport, InferenceProvidersConfig, JobId, JobType, ListUsersResponse, LlmSelectorInput, LocaleInfo, Logger, MCPToken, MatchQuality, McpServiceConfig, MediaTypeCapabilities, Motivation, OllamaProviderConfig, PdfCoordinate, PdfTextItem, PdfTextRun, PersistedEvent, PersistedEventType, PlatformType, Point, ProgressCallback, ProgressEvent, PutBinaryOptions, PutBinaryProgress, PutBinaryRequest, ReconciledSelector, RefreshToken, RenderMode, RenderedAnchor, ResourceAnnotationUri, ResourceAnnotations, ResourceBroadcastType, ResourceDescriptor, ResourceFilter, ResourceId, ResourceUri, RetryAttemptInfo, RetryPolicy, SearchQuery, SelectionData, Selector, SemiontConfig, ServicePlatformConfig, ServicesConfig, SiteConfig, StateUnit, StatusResponse, StoredEvent, StoredEventLike, SupportedMediaType, SvgSelector, TagCategory, TagSchema, TextExtraction, TextPosition, TextPositionSelector, TextQuoteSelector, ActorInferenceConfig as TomlActorInferenceConfig, TomlFileReader, InferenceConfig as TomlInferenceConfig, WorkerInferenceConfig as TomlWorkerInferenceConfig, TransportErrorCode, UpdateResourceInput, UpdateUserRequest, UpdateUserResponse, UserDID, UserId, UserResponse, ValidationFailure, ValidationResult, ValidationSuccess, VectorsServiceConfig, components, operations, paths };