@semiont/make-meaning 0.5.2 → 0.5.4

package/dist/knowledge-base.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Knowledge Base
+ *
+ * The durable store that records what intelligent actors decide.
+ * Groups the KB subsystems from ARCHITECTURE.md:
+ *
+ * - Event Log (immutable append-only) — via EventStore
+ * - Materialized Views (fast single-doc queries) — via ViewStorage
+ * - Content Store (working-tree files, URI-addressed) — via WorkingTreeStore
+ * - Graph (eventually consistent relationship projection) — via GraphDatabase
+ * - Graph Consumer (event-to-graph projection) — via GraphDBConsumer
+ * - Vectors (semantic search) — via VectorStore (optional, read-only)
+ *
+ * The Smelter (event-to-vector projection) runs as an external actor
+ * via @semiont/make-meaning/smelter-main. It subscribes to domain events
+ * via the EventBus gateway, embeds content, and writes to Qdrant directly.
+ */
+import type { EventStore } from '@semiont/event-sourcing';
+import { type ViewStorage } from '@semiont/event-sourcing';
+import { WorkingTreeStore } from '@semiont/content';
+import type { GraphDatabase } from '@semiont/graph';
+import type { VectorStore } from '@semiont/vectors';
+import type { SemiontProject } from '@semiont/core/node';
+import type { EventBus, Logger } from '@semiont/core';
+import { GraphDBConsumer } from './graph/consumer.js';
+export interface KnowledgeBase {
+    eventStore: EventStore;
+    views: ViewStorage;
+    content: WorkingTreeStore;
+    graph: GraphDatabase;
+    graphConsumer: GraphDBConsumer;
+    vectors?: VectorStore;
+    projectionsDir: string;
+}
+export interface CreateKnowledgeBaseOptions {
+    vectorStore?: VectorStore;
+    skipRebuild?: boolean;
+}
+export declare function createKnowledgeBase(eventStore: EventStore, project: SemiontProject, graphDb: GraphDatabase, eventBus: EventBus, logger: Logger, options?: CreateKnowledgeBaseOptions): Promise<KnowledgeBase>;
+//# sourceMappingURL=knowledge-base.d.ts.map

package/dist/knowledge-base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"knowledge-base.d.ts","sourceRoot":"","sources":["../src/knowledge-base.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,EAAyB,KAAK,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAClF,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAEtD,MAAM,WAAW,aAAa;IAC5B,UAAU,EAAK,UAAU,CAAC;IAC1B,KAAK,EAAU,WAAW,CAAC;IAC3B,OAAO,EAAQ,gBAAgB,CAAC;IAChC,KAAK,EAAU,aAAa,CAAC;IAC7B,aAAa,EAAE,eAAe,CAAC;IAC/B,OAAO,CAAC,EAAO,WAAW,CAAC;IAC3B,cAAc,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,0BAA0B;IACzC,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,wBAAsB,mBAAmB,CACvC,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE,cAAc,EACvB,OAAO,EAAE,aAAa,EACtB,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,0BAA0B,GACnC,OAAO,CAAC,aAAa,CAAC,CAkCxB"}

package/dist/knowledge-system.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Knowledge System
+ *
+ * Binds the KnowledgeBase to the actors that provide disciplined access to it.
+ * Nothing outside the KnowledgeSystem reads or writes the KnowledgeBase directly.
+ *
+ * - kb:                the durable store (event log, views, content, graph)
+ * - stower:            write actor — weaves new knowledge in
+ * - gatherer:          read actor — traces threads to build context
+ * - matcher:           search actor — finds related threads
+ * - browser:           filesystem actor — lists project directories
+ * - cloneTokenManager: token actor — manages resource clone tokens
+ *
+ * EventBus, JobQueue, and workers are peers to KnowledgeSystem, not members.
+ */
+import type { KnowledgeBase } from './knowledge-base.js';
+import type { Stower } from './stower.js';
+import type { Gatherer } from './gatherer.js';
+import type { Matcher } from './matcher.js';
+import type { Browser } from './browser.js';
+import type { CloneTokenManager } from './clone-token-manager.js';
+export interface KnowledgeSystem {
+    kb: KnowledgeBase;
+    stower: Stower;
+    gatherer: Gatherer;
+    matcher: Matcher;
+    browser: Browser;
+    cloneTokenManager: CloneTokenManager;
+    stop: () => Promise<void>;
+}
+export declare function stopKnowledgeSystem(ks: KnowledgeSystem): Promise<void>;
+//# sourceMappingURL=knowledge-system.d.ts.map

package/dist/knowledge-system.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"knowledge-system.d.ts","sourceRoot":"","sources":["../src/knowledge-system.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAU,qBAAqB,CAAC;AAC7D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAiB,aAAa,CAAC;AACrD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAe,eAAe,CAAC;AACvD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAgB,cAAc,CAAC;AACtD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAgB,cAAc,CAAC;AACtD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAElE,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAiB,aAAa,CAAC;IACjC,MAAM,EAAa,MAAM,CAAC;IAC1B,QAAQ,EAAW,QAAQ,CAAC;IAC5B,OAAO,EAAY,OAAO,CAAC;IAC3B,OAAO,EAAY,OAAO,CAAC;IAC3B,iBAAiB,EAAE,iBAAiB,CAAC;IACrC,IAAI,EAAe,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACxC;AAED,wBAAsB,mBAAmB,CAAC,EAAE,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAQ5E"}

package/dist/llm-context.d.ts

@@ -0,0 +1,26 @@
+/**
+ * LLM Context
+ *
+ * Builds comprehensive context for LLM processing of resources
+ * Orchestrates: ResourceContext, GraphContext, AnnotationContext, and generation functions
+ */
+import type { InferenceClient } from '@semiont/inference';
+import { type ResourceId } from '@semiont/core';
+import type { components } from '@semiont/core';
+import type { KnowledgeBase } from './knowledge-base';
+type ResourceLLMContextResponse = components['schemas']['ResourceLLMContextResponse'];
+export interface LLMContextOptions {
+    depth: number;
+    maxResources: number;
+    includeContent: boolean;
+    includeSummary: boolean;
+}
+export declare class LLMContext {
+    /**
+     * Get comprehensive LLM context for a resource
+     * Includes: main resource, related resources, annotations, graph, content, summary, references
+     */
+    static getResourceContext(resourceId: ResourceId, options: LLMContextOptions, kb: KnowledgeBase, inferenceClient: InferenceClient): Promise<ResourceLLMContextResponse>;
+}
+export {};
+//# sourceMappingURL=llm-context.d.ts.map

package/dist/llm-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"llm-context.d.ts","sourceRoot":"","sources":["../src/llm-context.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAE1D,OAAO,EAAgC,KAAK,UAAU,EAAE,MAAM,eAAe,CAAC;AAC9E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAGtD,KAAK,0BAA0B,GAAG,UAAU,CAAC,SAAS,CAAC,CAAC,4BAA4B,CAAC,CAAC;AAEtF,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,OAAO,CAAC;IACxB,cAAc,EAAE,OAAO,CAAC;CACzB;AAED,qBAAa,UAAU;IACrB;;;OAGG;WACU,kBAAkB,CAC7B,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE,iBAAiB,EAC1B,EAAE,EAAE,aAAa,EACjB,eAAe,EAAE,eAAe,GAC/B,OAAO,CAAC,0BAA0B,CAAC;CA4EvC"}

package/dist/local-content-transport.d.ts

@@ -0,0 +1,41 @@
+/**
+ * LocalContentTransport — `IContentTransport` for an in-process
+ * `KnowledgeSystem`.
+ *
+ * Reads go straight to `kb.views` (resource lookup) + `kb.content`
+ * (byte retrieval). No network, no auth — local mode runs as a single
+ * host-process identity.
+ *
+ * `putBinary` is intentionally not implemented in Phase 2: in-process
+ * resource creation is exercised through bus emits (mark/yield
+ * namespaces), not multipart upload. If a future caller needs raw
+ * binary upload from a local context, wire it through the same
+ * resource-creation pipeline the HTTP `/resources` handler uses.
+ */
+import type { AccessToken, ContentFormat, ResourceId } from '@semiont/core';
+import type { IContentTransport, PutBinaryRequest, PutBinaryOptions } from '@semiont/core';
+import type { KnowledgeSystem } from './knowledge-system.js';
+export declare class LocalContentTransport implements IContentTransport {
+    private readonly ks;
+    constructor(ks: KnowledgeSystem);
+    putBinary(_request: PutBinaryRequest, _options?: PutBinaryOptions): Promise<{
+        resourceId: ResourceId;
+    }>;
+    getBinary(resourceId: ResourceId, options?: {
+        accept?: ContentFormat | string;
+        auth?: AccessToken;
+    }): Promise<{
+        data: ArrayBuffer;
+        contentType: string;
+    }>;
+    getBinaryStream(resourceId: ResourceId, options?: {
+        accept?: ContentFormat | string;
+        auth?: AccessToken;
+    }): Promise<{
+        stream: ReadableStream<Uint8Array>;
+        contentType: string;
+    }>;
+    private loadBinary;
+    dispose(): void;
+}
+//# sourceMappingURL=local-content-transport.d.ts.map

package/dist/local-content-transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-content-transport.d.ts","sourceRoot":"","sources":["../src/local-content-transport.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,UAAU,EAAc,MAAM,eAAe,CAAC;AAGxF,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAE3F,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAW7D,qBAAa,qBAAsB,YAAW,iBAAiB;IACjD,OAAO,CAAC,QAAQ,CAAC,EAAE;gBAAF,EAAE,EAAE,eAAe;IAE1C,SAAS,CACb,QAAQ,EAAE,gBAAgB,EAC1B,QAAQ,CAAC,EAAE,gBAAgB,GAC1B,OAAO,CAAC;QAAE,UAAU,EAAE,UAAU,CAAA;KAAE,CAAC;IAUhC,SAAS,CACb,UAAU,EAAE,UAAU,EACtB,OAAO,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,aAAa,GAAG,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,WAAW,CAAA;KAAE,GAChE,OAAO,CAAC;QAAE,IAAI,EAAE,WAAW,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC;IAShD,eAAe,CACnB,UAAU,EAAE,UAAU,EACtB,OAAO,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,aAAa,GAAG,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,WAAW,CAAA;KAAE,GAChE,OAAO,CAAC;QAAE,MAAM,EAAE,cAAc,CAAC,UAAU,CAAC,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC;YAyBzD,UAAU;IAcxB,OAAO,IAAI,IAAI;CAGhB"}

package/dist/local-transport.d.ts

@@ -0,0 +1,80 @@
+/**
+ * LocalTransport — `ITransport` for an in-process `KnowledgeSystem`.
+ *
+ * Bus-ownership pattern (see `docs/protocol/TRANSPORT-CONTRACT.md`):
+ *   - The caller owns a make-meaning `EventBus` and passes it to both
+ *     `startMakeMeaning` and `LocalTransport` so the transport can publish
+ *     directly onto the bus the `KnowledgeSystem` actors are listening on.
+ *   - `SemiontClient` constructs its own `clientBus` and calls
+ *     `bridgeInto(clientBus)` during construction. `LocalTransport`
+ *     subscribes to every `BRIDGED_CHANNELS` entry on the make-meaning bus
+ *     and forwards each onto `clientBus`.
+ *   - The bus reference flows client → transport, never the other way.
+ *
+ * LocalTransport implements `ITransport` only. Auth, admin, and exchange
+ * (`IBackendOperations`) are HTTP-shaped concepts that don't apply
+ * in-process — local mode runs as a single host-process identity supplied
+ * at construction, with no token/credential lifecycle. A `SemiontClient`
+ * built over this transport has no `.auth` / `.admin` namespaces.
+ */
+import type { Observable } from 'rxjs';
+import { BehaviorSubject } from 'rxjs';
+import type { SemiontError } from '@semiont/core';
+import type { BaseUrl, EventBus, EventMap, ResourceId, UserDID } from '@semiont/core';
+import { type ConnectionState, type ITransport } from '@semiont/core';
+import type { KnowledgeSystem } from './knowledge-system.js';
+export interface LocalTransportConfig {
+    /**
+     * The in-process knowledge system. Lifetime is owned by the caller —
+     * `dispose()` on this transport does not stop the KnowledgeSystem.
+     */
+    knowledgeSystem: KnowledgeSystem;
+    /**
+     * The make-meaning `EventBus`. Must be the same instance passed to
+     * `startMakeMeaning` so that emits land on the bus KnowledgeSystem
+     * actors are subscribed to.
+     */
+    eventBus: EventBus;
+    /**
+     * Host-process identity. Stamped onto every emit as `_userId`, mirroring
+     * the gateway-injection convention used by `HttpTransport` (where the
+     * `/bus/emit` gateway reads the JWT subject and injects `_userId`).
+     * Handlers downstream trust nothing else.
+     */
+    userId: UserDID;
+    /**
+     * Cosmetic base URL for diagnostics and URL composition. Defaults to
+     * `local://in-process`. Local code never makes outgoing HTTP requests
+     * with it.
+     */
+    baseUrl?: BaseUrl;
+}
+export declare class LocalTransport implements ITransport {
+    readonly baseUrl: BaseUrl;
+    readonly state$: BehaviorSubject<ConnectionState>;
+    private readonly errorsSubject;
+    /**
+     * Stream of `SemiontError` instances surfaced from transport-mediated
+     * round-trips (typed-wire methods on this transport that fail). The
+     * in-process implementation does not currently surface errors through
+     * this stream — most failures here originate inside the make-meaning
+     * actors and surface through bus channels (correlation-ID failures via
+     * `busRequest`). The Subject exists to satisfy the `ITransport`
+     * contract; future expansion (e.g. transport-level guard failures)
+     * can publish into it.
+     */
+    readonly errors$: Observable<SemiontError>;
+    private readonly bus;
+    private readonly userId;
+    private readonly bridges;
+    private readonly bridgeSubs;
+    private disposed;
+    constructor(cfg: LocalTransportConfig);
+    emit<K extends keyof EventMap>(channel: K, payload: EventMap[K], resourceScope?: ResourceId): Promise<void>;
+    on<K extends keyof EventMap>(channel: K, handler: (payload: EventMap[K]) => void): () => void;
+    stream<K extends keyof EventMap>(channel: K): Observable<EventMap[K]>;
+    subscribeToResource(_resourceId: ResourceId): () => void;
+    bridgeInto(bus: EventBus): void;
+    dispose(): void;
+}
+//# sourceMappingURL=local-transport.d.ts.map

package/dist/local-transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-transport.d.ts","sourceRoot":"","sources":["../src/local-transport.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAgB,MAAM,MAAM,CAAC;AACrD,OAAO,EAAE,eAAe,EAAW,MAAM,MAAM,CAAC;AAChD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,KAAK,EACV,OAAO,EACP,QAAQ,EACR,QAAQ,EACR,UAAU,EACV,OAAO,EACR,MAAM,eAAe,CAAC;AAGvB,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,UAAU,EAChB,MAAM,eAAe,CAAC;AAEvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAE7D,MAAM,WAAW,oBAAoB;IACnC;;;OAGG;IACH,eAAe,EAAE,eAAe,CAAC;IACjC;;;;OAIG;IACH,QAAQ,EAAE,QAAQ,CAAC;IACnB;;;;;OAKG;IACH,MAAM,EAAE,OAAO,CAAC;IAChB;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,qBAAa,cAAe,YAAW,UAAU;IAC/C,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC,eAAe,CAAC,CAAC;IAClD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAsD;IACpF;;;;;;;;;OASG;IACH,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC,YAAY,CAAC,CAAqC;IAE/E,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAW;IAC/B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAU;IACjC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAkB;IAC1C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAsB;IACjD,OAAO,CAAC,QAAQ,CAAS;gBAEb,GAAG,EAAE,oBAAoB;IAU/B,IAAI,CAAC,CAAC,SAAS,MAAM,QAAQ,EACjC,OAAO,EAAE,CAAC,EACV,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAC,EACpB,aAAa,CAAC,EAAE,UAAU,GACzB,OAAO,CAAC,IAAI,CAAC;IAyBhB,EAAE,CAAC,CAAC,SAAS,MAAM,QAAQ,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,IAAI,GAAG,MAAM,IAAI;IAK7F,MAAM,CAAC,CAAC,SAAS,MAAM,QAAQ,EAAE,OAAO,EAAE,CAAC,GAAG,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;IAIrE,mBAAmB,CAAC,WAAW,EAAE,UAAU,GAAG,MAAM,IAAI;IAOxD,UAAU,CAAC,GAAG,EAAE,QAAQ,GAAG,IAAI;IA8B/B,OAAO,IAAI,IAAI;CAUhB"}

package/dist/matcher.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Matcher Actor
+ *
+ * Candidate search for the bind flow. Subscribes to match:search-requested,
+ * queries the KB graph for matching resources, scores them, and emits results.
+ *
+ * Handles:
+ * - match:search-requested — multi-source retrieval + composite scoring
+ *
+ * The write side (annotation.body.updated) stays in the route where userId
+ * is available from auth context.
+ */
+import type { Logger } from '@semiont/core';
+import { type EventBus } from '@semiont/core';
+import type { InferenceClient } from '@semiont/inference';
+import type { EmbeddingProvider } from '@semiont/vectors';
+import type { KnowledgeBase } from './knowledge-base';
+export declare class Matcher {
+    private kb;
+    private eventBus;
+    private inferenceClient;
+    private embeddingProvider?;
+    private subscriptions;
+    private readonly logger;
+    constructor(kb: KnowledgeBase, eventBus: EventBus, logger: Logger, inferenceClient: InferenceClient, embeddingProvider?: EmbeddingProvider | undefined);
+    initialize(): Promise<void>;
+    private handleSearch;
+    /**
+     * Context-driven search: multi-source retrieval + composite scoring
+     *
+     * Retrieval sources:
+     * 1. Name match — graph.searchResources(searchTerm)
+     * 2. Entity type match — graph.listResources({ entityTypes })
+     * 3. Graph neighborhood — connections from GatheredContext
+     *
+     * Ranking signals:
+     * - Entity type overlap (Jaccard similarity)
+     * - Bidirectionality (already connected both ways)
+     * - Citation weight (well-connected = important)
+     * - Name match quality (exact > prefix > contains)
+     * - Recency (newer resources scored higher)
+     */
+    private contextDrivenSearch;
+    /**
+     * LLM-based semantic relevance scoring (GraphRAG-style)
+     *
+     * Batches candidates into a single prompt asking the LLM to score
+     * each candidate's semantic relevance given the passage and graph context.
+     *
+     * @returns Map of resourceId → score (0-1)
+     */
+    private inferenceSemanticScore;
+    /**
+     * Search vectors for semantically similar resources.
+     * Returns empty array if vectors or embedding provider are not configured.
+     */
+    private searchVectors;
+    stop(): Promise<void>;
+}
+//# sourceMappingURL=matcher.d.ts.map

package/dist/matcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matcher.d.ts","sourceRoot":"","sources":["../src/matcher.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,OAAO,KAAK,EAA6B,MAAM,EAAsB,MAAM,eAAe,CAAC;AAC3F,OAAO,EAAE,KAAK,QAAQ,EAAwB,MAAM,eAAe,CAAC;AAGpE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAC1D,OAAO,KAAK,EAAE,iBAAiB,EAAsB,MAAM,kBAAkB,CAAC;AAC9E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEtD,qBAAa,OAAO;IAKhB,OAAO,CAAC,EAAE;IACV,OAAO,CAAC,QAAQ;IAEhB,OAAO,CAAC,eAAe;IACvB,OAAO,CAAC,iBAAiB,CAAC;IAR5B,OAAO,CAAC,aAAa,CAAsB;IAC3C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;gBAGtB,EAAE,EAAE,aAAa,EACjB,QAAQ,EAAE,QAAQ,EAC1B,MAAM,EAAE,MAAM,EACN,eAAe,EAAE,eAAe,EAChC,iBAAiB,CAAC,EAAE,iBAAiB,YAAA;IAKzC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;YAgBnB,YAAY;IAwC1B;;;;;;;;;;;;;;OAcG;YACW,mBAAmB;IAgMjC;;;;;;;OAOG;YACW,sBAAsB;IA6EpC;;;OAGG;YACW,aAAa;IAwBrB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAO5B"}

package/dist/resource-context.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Resource Context
+ *
+ * Assembles resource context from view storage and content store
+ * Does NOT touch the graph - graph queries go through GraphContext
+ */
+import type { ResourceId } from '@semiont/core';
+import type { KnowledgeBase } from './knowledge-base';
+import type { ResourceDescriptor } from '@semiont/core';
+export interface ListResourcesFilters {
+    search?: string;
+    archived?: boolean;
+}
+export declare class ResourceContext {
+    /**
+     * Get resource metadata from view storage
+     */
+    static getResourceMetadata(resourceId: ResourceId, kb: KnowledgeBase): Promise<ResourceDescriptor | null>;
+    /**
+     * List resources, optionally filtered.
+     *
+     * When `search` is set, delegates to `kb.graph.searchResources`, which runs
+     * the name match in the graph engine instead of scanning every view in JS.
+     * The graph result is then narrowed by `archived` if requested.
+     *
+     * When `search` is unset, falls back to scanning all materialized views.
+     * (TODO: also push the listing path through the graph for large KBs.)
+     */
+    static listResources(filters: ListResourcesFilters | undefined, kb: KnowledgeBase): Promise<ResourceDescriptor[]>;
+    private static sortByDateDesc;
+    /**
+     * Add content previews to resources (for search results)
+     * Retrieves and decodes the first 200 characters of each resource's primary representation
+     */
+    static addContentPreviews(resources: ResourceDescriptor[], kb: KnowledgeBase): Promise<Array<ResourceDescriptor & {
+        content: string;
+    }>>;
+    /**
+     * Get full content for a resource
+     * Retrieves and decodes the primary representation
+     */
+    static getResourceContent(resource: ResourceDescriptor, kb: KnowledgeBase): Promise<string | undefined>;
+}
+//# sourceMappingURL=resource-context.d.ts.map

package/dist/resource-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resource-context.d.ts","sourceRoot":"","sources":["../src/resource-context.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEtD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAExD,MAAM,WAAW,oBAAoB;IACnC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,qBAAa,eAAe;IAC1B;;OAEG;WACU,mBAAmB,CAAC,UAAU,EAAE,UAAU,EAAE,EAAE,EAAE,aAAa,GAAG,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC;IAS/G;;;;;;;;;OASG;WACU,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,SAAS,EAAE,EAAE,EAAE,aAAa,GAAG,OAAO,CAAC,kBAAkB,EAAE,CAAC;IAuBvH,OAAO,CAAC,MAAM,CAAC,cAAc;IAQ7B;;;OAGG;WACU,kBAAkB,CAC7B,SAAS,EAAE,kBAAkB,EAAE,EAC/B,EAAE,EAAE,aAAa,GAChB,OAAO,CAAC,KAAK,CAAC,kBAAkB,GAAG;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAkB3D;;;OAGG;WACU,kBAAkB,CAC7B,QAAQ,EAAE,kBAAkB,EAC5B,EAAE,EAAE,aAAa,GAChB,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;CAQ/B"}

package/dist/resource-operations.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Resource Operations
+ *
+ * Business logic for resource operations. All writes go through the EventBus
+ * — the Stower actor subscribes and handles persistence.
+ *
+ * For create: emits yield:create, awaits yield:created / yield:create-failed.
+ */
+import type { UserId, ResourceId } from '@semiont/core';
+import type { components } from '@semiont/core';
+import { EventBus } from '@semiont/core';
+type ContentFormat = components['schemas']['ContentFormat'];
+type Agent = components['schemas']['Agent'];
+export interface CreateResourceInput {
+    name: string;
+    storageUri: string;
+    contentChecksum: string;
+    byteSize: number;
+    format: ContentFormat;
+    language?: string;
+    entityTypes?: string[];
+    /** Provenance for AI-generated resources: source resource + annotation. */
+    generatedFrom?: {
+        resourceId?: string;
+        annotationId?: string;
+    };
+    generationPrompt?: string;
+    generator?: Agent | Agent[];
+    isDraft?: boolean;
+}
+export declare class ResourceOperations {
+    /**
+     * Create a new resource via EventBus → Stower
+     */
+    static createResource(input: CreateResourceInput, userId: UserId, eventBus: EventBus): Promise<ResourceId>;
+}
+export {};
+//# sourceMappingURL=resource-operations.d.ts.map

package/dist/resource-operations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resource-operations.d.ts","sourceRoot":"","sources":["../src/resource-operations.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAK,EACV,MAAM,EACN,UAAU,EACX,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,QAAQ,EAAgC,MAAM,eAAe,CAAC;AAEvE,KAAK,aAAa,GAAG,UAAU,CAAC,SAAS,CAAC,CAAC,eAAe,CAAC,CAAC;AAC5D,KAAK,KAAK,GAAG,UAAU,CAAC,SAAS,CAAC,CAAC,OAAO,CAAC,CAAC;AAE5C,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,aAAa,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,2EAA2E;IAC3E,aAAa,CAAC,EAAE;QAAE,UAAU,CAAC,EAAE,MAAM,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC/D,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,SAAS,CAAC,EAAE,KAAK,GAAG,KAAK,EAAE,CAAC;IAC5B,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,qBAAa,kBAAkB;IAC7B;;OAEG;WACU,cAAc,CACzB,KAAK,EAAE,mBAAmB,EAC1B,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,QAAQ,GACjB,OAAO,CAAC,UAAU,CAAC;CAwCvB"}

package/dist/service.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Make-Meaning Service
+ *
+ * Provides a clean interface:
+ *   const makeMeaning = await startMakeMeaning(project, config, eventBus, logger);
+ */
+import { type JobQueue } from '@semiont/jobs';
+import type { SemiontProject } from '@semiont/core/node';
+import { EventBus, type Logger } from '@semiont/core';
+import { type MakeMeaningConfig } from './config';
+import { type KnowledgeSystem } from './knowledge-system';
+export type { MakeMeaningConfig } from './config';
+export interface MakeMeaningService {
+    knowledgeSystem: KnowledgeSystem;
+    jobQueue: JobQueue;
+    stop: () => Promise<void>;
+}
+export declare function startMakeMeaning(project: SemiontProject, config: MakeMeaningConfig, eventBus: EventBus, logger: Logger, options?: {
+    skipRebuild?: boolean;
+}): Promise<MakeMeaningService>;
+//# sourceMappingURL=service.d.ts.map

package/dist/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAc,KAAK,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE1D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,EAAE,QAAQ,EAAE,KAAK,MAAM,EAAS,MAAM,eAAe,CAAC;AAE7D,OAAO,EAAyB,KAAK,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAazE,OAAO,EAAuB,KAAK,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAI/E,YAAY,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAElD,MAAM,WAAW,kBAAkB;IACjC,eAAe,EAAE,eAAe,CAAC;IACjC,QAAQ,EAAS,QAAQ,CAAC;IAC1B,IAAI,EAAa,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACtC;AAoID,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,cAAc,EACvB,MAAM,EAAE,iBAAiB,EACzB,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE;IAAE,WAAW,CAAC,EAAE,OAAO,CAAA;CAAE,GAClC,OAAO,CAAC,kBAAkB,CAAC,CA2B7B"}

package/dist/smelter-actor-state-unit.d.ts

@@ -0,0 +1,31 @@
+/**
+ * SmelterActorStateUnit — domain-event fan-in for the Smelter worker.
+ *
+ * Subscribes to the six smelter-relevant channels on a shared bus and
+ * exposes them as a single typed `events$` stream. Transport-neutral —
+ * the caller passes a `WorkerBus` (HTTP `ActorStateUnit` today, an in-process
+ * bus shim if/when one exists). The state unit does not own the bus and does
+ * not dispose it.
+ *
+ * `start()` widens the bus's channel-subscription set to include the
+ * smelter channels. On HTTP this extends the SSE subscription URL;
+ * on an in-process bus this is a no-op (the underlying `EventBus`
+ * already delivers every emit).
+ */
+import { Observable } from 'rxjs';
+import type { StateUnit, WorkerBus } from '@semiont/sdk';
+export interface SmelterEvent {
+    type: string;
+    resourceId?: string;
+    payload: Record<string, unknown>;
+}
+export interface SmelterActorStateUnitOptions {
+    bus: WorkerBus;
+}
+export interface SmelterActorStateUnit extends StateUnit {
+    events$: Observable<SmelterEvent>;
+    emit(channel: string, payload: Record<string, unknown>): Promise<void>;
+    start(): void;
+}
+export declare function createSmelterActorStateUnit(options: SmelterActorStateUnitOptions): SmelterActorStateUnit;
+//# sourceMappingURL=smelter-actor-state-unit.d.ts.map

package/dist/smelter-actor-state-unit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smelter-actor-state-unit.d.ts","sourceRoot":"","sources":["../src/smelter-actor-state-unit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,UAAU,EAAS,MAAM,MAAM,CAAC;AAEzC,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEzD,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAClC;AAED,MAAM,WAAW,4BAA4B;IAC3C,GAAG,EAAE,SAAS,CAAC;CAChB;AAWD,MAAM,WAAW,qBAAsB,SAAQ,SAAS;IACtD,OAAO,EAAE,UAAU,CAAC,YAAY,CAAC,CAAC;IAClC,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACvE,KAAK,IAAI,IAAI,CAAC;CACf;AAED,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,4BAA4B,GAAG,qBAAqB,CA8BxG"}

package/dist/smelter-main.d.ts

@@ -1,2 +1,16 @@
-
-export {  }
+/**
+ * Smelter Main — standalone entry point
+ *
+ * Continuous stream processor that subscribes to domain events via the
+ * EventBus gateway, fetches content via HTTP, chunks text, embeds via
+ * the configured provider, and writes vectors to Qdrant.
+ *
+ * Reads configuration from ~/.semiontconfig (TOML) via the canonical
+ * `createTomlConfigLoader` from @semiont/core. Authenticates with the
+ * KS via shared secret.
+ *
+ * Environment variables:
+ *   SEMIONT_WORKER_SECRET — shared secret for JWT auth with the KS
+ */
+export {};
+//# sourceMappingURL=smelter-main.d.ts.map

package/dist/smelter-main.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smelter-main.d.ts","sourceRoot":"","sources":["../src/smelter-main.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG"}

package/dist/smelter-main.js

@@ -9805,10 +9805,14 @@ async function authenticate() {
     logger.warn("No SEMIONT_WORKER_SECRET set \u2014 using empty token");
     return "";
   }
-  const response = await fetch(`${baseUrl}/api/tokens/worker`, {
+  const response = await fetch(`${baseUrl}/api/tokens/agent`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ secret: workerSecret })
+    body: JSON.stringify({
+      secret: workerSecret,
+      provider: embeddingType,
+      model: embeddingModel
+    })
   });
   if (!response.ok) {
     throw new Error(`Authentication failed: ${response.status} ${response.statusText}`);