@lucern/sdk 0.2.0-alpha.12 → 0.2.0-alpha.2

package/dist/lucern/packages/domain-tasks/src/tasks.d.ts

@@ -0,0 +1,102 @@
+type TaskStatus = "todo" | "in_progress" | "blocked" | "done";
+type TaskPriority = "low" | "medium" | "high" | "urgent";
+type TaskType = "research" | "interview" | "analysis" | "data_collection" | "general";
+export type TaskRecord = {
+    id: string;
+    taskId: string;
+    topicId?: string;
+    title: string;
+    description?: string;
+    status: TaskStatus;
+    priority: TaskPriority;
+    taskType: TaskType;
+    linkedBeliefId?: string;
+    linkedQuestionId?: string;
+    linkedWorktreeId?: string;
+    outputSummary?: string;
+    createdAt?: number;
+    updatedAt?: number;
+    completedAt?: number;
+    metadata?: Record<string, unknown>;
+};
+export type TaskListResult = {
+    tasks: TaskRecord[];
+    count: number;
+};
+export type CreateTaskInput = {
+    topicId: string;
+    title: string;
+    description?: string;
+    taskType?: string;
+    priority?: string;
+    linkedBeliefId?: string;
+    linkedQuestionId?: string;
+    linkedWorktreeId?: string;
+    metadata?: Record<string, unknown>;
+};
+export type UpdateTaskInput = {
+    id: string;
+    title?: string;
+    description?: string;
+    priority?: string;
+    status?: string;
+    linkedBeliefId?: string;
+    linkedQuestionId?: string;
+    linkedWorktreeId?: string;
+    metadata?: Record<string, unknown>;
+};
+export type CompleteTaskInput = {
+    id: string;
+    outputSummary?: string;
+};
+export type ListTasksQuery = {
+    topicId?: string;
+    worktreeId?: string;
+    status?: string;
+    limit?: number;
+};
+type TaskCreatePortInput = {
+    topicId: string;
+    title: string;
+    description?: string;
+    taskType: TaskType;
+    priority: TaskPriority;
+    linkedBeliefId?: string;
+    linkedQuestionId?: string;
+    linkedWorktreeId?: string;
+    metadata?: Record<string, unknown>;
+};
+type TaskUpdatePortInput = {
+    taskRawId: string;
+    title?: string;
+    description?: string;
+    priority?: TaskPriority;
+    status?: TaskStatus;
+    linkedBeliefId?: string;
+    linkedQuestionId?: string;
+    linkedWorktreeId?: string;
+    metadata?: Record<string, unknown>;
+};
+type TaskCompletePortInput = {
+    taskRawId: string;
+    outputSummary?: string;
+};
+export type TasksPort = {
+    fetchTask: (rawId: string) => Promise<unknown | null>;
+    listTasksByTopic: (args: {
+        topicId: string;
+        status?: TaskStatus;
+        limit?: number;
+    }) => Promise<unknown[]>;
+    listTasksByWorktree: (args: {
+        worktreeId: string;
+    }) => Promise<unknown[]>;
+    createTask: (input: TaskCreatePortInput) => Promise<unknown>;
+    updateTask: (input: TaskUpdatePortInput) => Promise<unknown>;
+    completeTask: (input: TaskCompletePortInput) => Promise<unknown>;
+};
+export declare function createTask(deps: TasksPort, input: CreateTaskInput): Promise<TaskRecord>;
+export declare function updateTask(deps: TasksPort, input: UpdateTaskInput): Promise<TaskRecord>;
+export declare function completeTask(deps: TasksPort, input: CompleteTaskInput): Promise<TaskRecord>;
+export declare function listTasks(deps: TasksPort, query: ListTasksQuery): Promise<TaskListResult>;
+export {};

package/dist/lucern/packages/domain-topics/src/index.d.ts

@@ -0,0 +1 @@
+export * from "./topics";

package/dist/lucern/packages/domain-topics/src/topics.d.ts

@@ -0,0 +1,147 @@
+type TopicStatus = "active" | "archived" | "watching";
+type TopicVisibility = "private" | "team" | "firm" | "external" | "public";
+type TopicCoverageState = "full" | "partial" | "empty";
+export type TopicRecord = {
+    id: string;
+    topicId: string;
+    globalId?: string;
+    name: string;
+    description?: string;
+    type: string;
+    depth?: number;
+    status?: TopicStatus;
+    parentTopicId?: string | null;
+    tenantId?: string;
+    workspaceId?: string;
+    visibility?: TopicVisibility;
+    createdAt?: number;
+    updatedAt?: number;
+};
+export type TopicListResult = {
+    topics: TopicRecord[];
+    total: number;
+};
+export type TopicTreeNode = TopicRecord & {
+    path?: string[];
+};
+export type TopicTreeResult = {
+    tree: TopicTreeNode[];
+};
+export type TopicCoverageRecord = {
+    topicId: string;
+    name: string;
+    type: string;
+    depth: number;
+    beliefs: number;
+    questions: number;
+    evidence: number;
+    coverage: TopicCoverageState;
+};
+export type TopicCoverageSummary = {
+    totalTopics: number;
+    coveredTopics: number;
+    emptyTopics: number;
+    coveragePercent: number;
+    totalBeliefs: number;
+    totalQuestions: number;
+    totalEvidence: number;
+};
+export type TopicCoverageResult = {
+    topics: TopicCoverageRecord[];
+    summary: TopicCoverageSummary;
+    scopeTopicId?: string | null;
+};
+export type CreateTopicInput = {
+    name: string;
+    description?: string;
+    type?: string;
+    parentTopicId?: string;
+    ontologyId?: string;
+    tenantId?: string;
+    workspaceId?: string;
+    visibility?: TopicVisibility;
+    createdBy?: string;
+};
+export type UpdateTopicInput = {
+    id: string;
+    name?: string;
+    description?: string;
+    type?: string;
+    ontologyId?: string;
+    clearOntologyId?: boolean;
+    status?: TopicStatus;
+    visibility?: TopicVisibility;
+};
+export type GetTopicInput = {
+    id: string;
+};
+export type ListTopicsQuery = {
+    ontologyId?: string;
+    parentTopicId?: string;
+    status?: TopicStatus | string;
+    type?: string;
+};
+export type GetTopicTreeInput = {
+    id: string;
+    maxDepth?: number;
+};
+export type GetTopicCoverageInput = {
+    id: string;
+    includeDescendants?: boolean;
+    maxDepth?: number;
+};
+type CreateTopicPortInput = {
+    name: string;
+    description?: string;
+    type: string;
+    parentTopicRawId?: string;
+    ontologyId?: string;
+    tenantId?: string;
+    workspaceId?: string;
+    visibility?: TopicVisibility;
+    createdBy?: string;
+};
+type UpdateTopicPortInput = {
+    topicRawId: string;
+    name?: string;
+    description?: string;
+    type?: string;
+    ontologyId?: string;
+    clearOntologyId?: boolean;
+    status?: TopicStatus;
+    visibility?: TopicVisibility;
+};
+export type TopicsPort = {
+    fetchTopic: (rawId: string) => Promise<unknown | null>;
+    listTopics: (query: {
+        ontologyId?: string;
+        parentTopicRawId?: string;
+        status?: string;
+        type?: string;
+    }) => Promise<unknown[]>;
+    createTopic: (input: CreateTopicPortInput) => Promise<unknown>;
+    updateTopic?: (input: UpdateTopicPortInput) => Promise<unknown>;
+    fetchTopicTree: (args: {
+        rootRawId: string;
+        maxDepth?: number;
+    }) => Promise<unknown>;
+    listBeliefsByTopic: (args: {
+        topicId: string;
+        limit?: number;
+    }) => Promise<unknown[]>;
+    listQuestionsByTopic: (args: {
+        topicId: string;
+        limit?: number;
+    }) => Promise<unknown[]>;
+    listEvidenceByTopic: (args: {
+        topicId: string;
+        limit?: number;
+    }) => Promise<unknown[]>;
+};
+export declare function createTopic(deps: TopicsPort, input: CreateTopicInput): Promise<TopicRecord>;
+export declare function updateTopic(deps: TopicsPort, input: UpdateTopicInput): Promise<TopicRecord>;
+export declare function getTopic(deps: TopicsPort, input: GetTopicInput): Promise<TopicRecord>;
+export declare function listTopics(deps: TopicsPort, query?: ListTopicsQuery): Promise<TopicListResult>;
+export declare function getTopicTree(deps: TopicsPort, input: GetTopicTreeInput): Promise<TopicTreeResult>;
+export declare function getTopicCoverage(deps: TopicsPort, input: GetTopicCoverageInput): Promise<TopicCoverageResult>;
+export {};

package/dist/lucern/packages/domain-worktrees/src/index.d.ts

@@ -0,0 +1 @@
+export * from "./worktrees";

package/dist/lucern/packages/domain-worktrees/src/worktrees.d.ts

@@ -0,0 +1,185 @@
+type WorktreeStatus = "planning" | "active" | "paused" | "completed" | "merged" | "failed" | "archived";
+export type WorktreeRecord = {
+    worktreeId: string;
+    id: string;
+    topicId?: string;
+    title: string;
+    status?: WorktreeStatus | string;
+    branchId?: string | null;
+    objective?: string;
+    hypothesis?: string;
+    gate?: string;
+    track?: string;
+    trackPosition?: number;
+    executionBand?: number;
+    executionOrder?: number;
+    dependsOn?: string[];
+    blocks?: string[];
+    targetBeliefIds?: string[];
+    targetQuestionIds?: string[];
+    questionCount?: number;
+    taskCount?: number;
+    frameworkSuggestions?: unknown[];
+    dependencySuggestions?: unknown[];
+    autoShapeApplied?: boolean;
+    proofArtifacts?: unknown[] | null;
+    staffingHint?: string | null;
+    lastReconciledAt?: number | null;
+    autoFixPolicy?: Record<string, unknown> | null;
+    lensId?: string | null;
+    createdAt?: number;
+    updatedAt?: number;
+};
+export type WorktreeListResult = {
+    worktrees: WorktreeRecord[];
+    total: number;
+};
+export type CreateWorktreeInput = {
+    title: string;
+    topicId: string;
+    objective?: string;
+    hypothesis?: string;
+    beliefIds?: string[];
+    autoShape?: boolean;
+    domainPackId?: string;
+    executionOrder?: number;
+    dependsOn?: string[];
+    blocks?: string[];
+    gate?: string;
+    proofArtifacts?: unknown[];
+    staffingHint?: string;
+    lastReconciledAt?: number;
+    autoFixPolicy?: Record<string, unknown>;
+    lensId?: string;
+};
+export type ListWorktreesQuery = {
+    topicId: string;
+    status?: string;
+    limit?: number;
+};
+export type ActivateWorktreeInput = {
+    id: string;
+};
+export type MergeWorktreeInput = {
+    id: string;
+    summary?: string;
+    outcomes: Array<{
+        beliefId: string;
+        confidence: number;
+        rationale: string;
+    }>;
+};
+export type MergeWorktreeResult = {
+    worktreeId: string;
+    status: "merged";
+    beliefsScored: number;
+    failedBeliefs: Array<{
+        beliefId: string;
+        reason: string;
+    }>;
+    summary?: string;
+    mergedAt: number;
+};
+export type UpdateWorktreeTargetsInput = {
+    id: string;
+    addBeliefIds?: string[];
+    addQuestionIds?: string[];
+    removeBeliefIds?: string[];
+    removeQuestionIds?: string[];
+};
+export type UpdateWorktreeInput = {
+    id: string;
+    objective?: string;
+    hypothesis?: string;
+    rationale?: string;
+    track?: string;
+    trackPosition?: number;
+    executionBand?: number;
+    executionOrder?: number;
+    dependsOn?: string[];
+    blocks?: string[];
+    gate?: string;
+    status?: string;
+    topicId?: string;
+    additionalTopicIds?: string[];
+    proofArtifacts?: unknown[];
+    staffingHint?: string;
+    lastReconciledAt?: number;
+    autoFixPolicy?: unknown;
+    lensId?: string;
+};
+type CreateWorktreePortInput = {
+    title: string;
+    topicRawId: string;
+    objective?: string;
+    hypothesis?: string;
+    beliefRawIds?: string[];
+    autoShape?: boolean;
+    domainPackId?: string;
+    executionOrder?: number;
+    dependsOn?: string[];
+    blocks?: string[];
+    gate?: string;
+    proofArtifacts?: unknown[];
+    staffingHint?: string;
+    lastReconciledAt?: number;
+    autoFixPolicy?: Record<string, unknown>;
+    lensId?: string;
+};
+type UpdateWorktreeTargetsPortInput = {
+    worktreeRawId: string;
+    addBeliefRawIds?: string[];
+    addQuestionRawIds?: string[];
+    removeBeliefRawIds?: string[];
+    removeQuestionRawIds?: string[];
+};
+type UpdateWorktreeMetadataPortInput = {
+    worktreeRawId: string;
+    objective?: string;
+    hypothesis?: string;
+    rationale?: string;
+    track?: string;
+    trackPosition?: number;
+    executionBand?: number;
+    executionOrder?: number;
+    dependsOn?: string[];
+    blocks?: string[];
+    gate?: string;
+    status?: string;
+    topicId?: string;
+    additionalTopicIds?: string[];
+    proofArtifacts?: unknown[];
+    staffingHint?: string;
+    lastReconciledAt?: number;
+    autoFixPolicy?: unknown;
+    lensId?: string;
+};
+export type WorktreesPort = {
+    fetchWorktree: (rawId: string) => Promise<unknown | null>;
+    listWorktreesByTopic: (args: {
+        topicId: string;
+        limit?: number;
+    }) => Promise<unknown[]>;
+    createWorktree: (input: CreateWorktreePortInput) => Promise<unknown>;
+    activateWorktree: (args: {
+        worktreeRawId: string;
+    }) => Promise<unknown>;
+    completeWorktree: (args: {
+        worktreeRawId: string;
+        summary: string;
+    }) => Promise<unknown>;
+    scoreBeliefOutcome: (args: {
+        beliefRawId: string;
+        confidence: number;
+        rationale: string;
+    }) => Promise<unknown>;
+    updateWorktreeMetadata: (input: UpdateWorktreeMetadataPortInput) => Promise<unknown>;
+    updateWorktreeTargets: (input: UpdateWorktreeTargetsPortInput) => Promise<unknown>;
+};
+export declare function createWorktree(deps: WorktreesPort, input: CreateWorktreeInput): Promise<WorktreeRecord>;
+export declare function listWorktrees(deps: WorktreesPort, query: ListWorktreesQuery): Promise<WorktreeListResult>;
+export declare function activateWorktree(deps: WorktreesPort, input: ActivateWorktreeInput): Promise<WorktreeRecord>;
+export declare function updateWorktree(deps: WorktreesPort, input: UpdateWorktreeInput): Promise<WorktreeRecord>;
+export declare function updateWorktreeTargets(deps: WorktreesPort, input: UpdateWorktreeTargetsInput): Promise<WorktreeRecord>;
+export declare function mergeWorktree(deps: WorktreesPort, input: MergeWorktreeInput): Promise<MergeWorktreeResult>;
+export {};

package/dist/lucern/packages/events/src/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./matching";
+export * from "./outbox";
+export * from "./types";
+export * from "./webhooks";

package/dist/lucern/packages/events/src/matching.d.ts

@@ -0,0 +1,3 @@
+export declare function eventPatternToRegExp(pattern: string): RegExp;
+export declare function matchesEventPattern(eventType: string, pattern: string): boolean;
+export declare function matchesAnyEventPattern(eventType: string, patterns: readonly string[]): boolean;

package/dist/lucern/packages/events/src/outbox.d.ts

@@ -0,0 +1,15 @@
+import { type CreateDomainEventInput, type DomainActorType, type DomainEvent, type EventCursor } from "./types";
+export declare function createEventId(): string;
+export declare function normalizeRetentionDays(value: number | undefined): number;
+export declare function buildDomainEvent(input: CreateDomainEventInput): DomainEvent;
+export declare function compareEventCursor(left: EventCursor, right: EventCursor): number;
+export declare function encodeEventCursor(cursor: EventCursor): string;
+export declare function decodeEventCursor(cursor: string | undefined): EventCursor | null;
+export declare function isAfterCursor(event: Pick<DomainEvent, "timestamp" | "eventId">, cursor: EventCursor | null): boolean;
+export declare function sortEventsByCursor<T extends Pick<DomainEvent, "timestamp" | "eventId">>(events: readonly T[]): T[];
+export declare function inferActorType(args: {
+    sessionType?: "agent" | "user";
+    authMode?: string;
+    principalType?: string;
+}): DomainActorType;
+export declare function emitDomainEvent(invokeMutation: (reference: any, args: CreateDomainEventInput) => Promise<unknown>, input: CreateDomainEventInput): Promise<unknown>;

package/dist/lucern/packages/events/src/types.d.ts

@@ -0,0 +1,151 @@
+export declare const DOMAIN_EVENT_VERSION: "1.0";
+export declare const EVENT_RETENTION_DEFAULT_DAYS = 30;
+export declare const WEBHOOK_MAX_ATTEMPTS = 5;
+export declare const WEBHOOK_RETRY_DELAYS_MS: readonly [1000, 5000, 30000, 300000];
+export declare const DOMAIN_EVENT_TYPES: readonly ["belief.created", "belief.forked", "belief.confidence_updated", "belief.archived", "belief.refined", "belief.contract_created", "belief.contract_evaluated", "belief.lineage_queried", "evidence.created", "evidence.linked", "evidence.search_executed", "question.created", "question.answered", "question.refined", "question.status_updated", "question.archived", "edge.created", "contradiction.flagged", "worktree.created", "worktree.activated", "worktree.merged", "worktree.targets_updated", "worktree.metadata_updated", "topic.created", "topic.updated", "topic.archived", "task.created", "task.completed", "task.updated", "ontology.bound", "context.compiled", "identity.key_created", "identity.key_rotated", "identity.key_revoked", "webhook.test"];
+export type DomainEventType = (typeof DOMAIN_EVENT_TYPES)[number];
+export type DomainResourceType = "belief" | "evidence" | "question" | "edge" | "contradiction" | "worktree" | "topic" | "task" | "ontology" | "context" | "identity" | "webhook";
+export type DomainActorType = "human" | "agent" | "service";
+export type DomainEventData = Record<string, unknown>;
+export type DomainEvent = {
+    eventId: string;
+    type: DomainEventType | string;
+    version: typeof DOMAIN_EVENT_VERSION;
+    timestamp: number;
+    tenantId?: string;
+    workspaceId?: string;
+    topicId: string;
+    resourceId: string;
+    resourceType: DomainResourceType | string;
+    actorId: string;
+    actorType: DomainActorType;
+    data: DomainEventData;
+    correlationId?: string;
+    expiresAt: number;
+};
+export type CreateDomainEventInput = {
+    eventId?: string;
+    timestamp?: number;
+    tenantId?: string;
+    workspaceId?: string;
+    topicId: string;
+    type: DomainEventType | string;
+    resourceId: string;
+    resourceType: DomainResourceType | string;
+    actorId: string;
+    actorType: DomainActorType;
+    data?: DomainEventData;
+    correlationId?: string;
+    retentionDays?: number;
+};
+export type EventCursor = {
+    timestamp: number;
+    eventId: string;
+};
+export type EventListQuery = {
+    topicId?: string;
+    after?: string;
+    types?: string[];
+    startTime?: number;
+    endTime?: number;
+    limit?: number;
+};
+export type EventListResult = {
+    events: DomainEvent[];
+    nextCursor: string | null;
+};
+export type WebhookSecretMode = "configured";
+export type WebhookRecord = {
+    id: string;
+    webhookId: string;
+    tenantId?: string;
+    workspaceId?: string;
+    topicId?: string;
+    url: string;
+    events: string[];
+    active: boolean;
+    secretConfigured: boolean;
+    createdAt: number;
+    updatedAt: number;
+    createdBy: string;
+    updatedBy: string;
+    lastDeliveryAt?: number;
+    lastSuccessfulDeliveryAt?: number;
+};
+export type WebhookCreateInput = {
+    url: string;
+    events: string[];
+    secret: string;
+    topicId?: string;
+    active?: boolean;
+};
+export type WebhookUpdateInput = {
+    url?: string;
+    events?: string[];
+    secret?: string;
+    topicId?: string | null;
+    active?: boolean;
+};
+export type WebhookDeliveryStatus = "pending" | "delivering" | "succeeded" | "failed" | "dead_letter";
+export type WebhookDeliveryRecord = {
+    id: string;
+    deliveryId: string;
+    webhookId: string;
+    eventId: string;
+    eventType: string;
+    topicId: string;
+    status: WebhookDeliveryStatus;
+    attemptCount: number;
+    maxAttempts: number;
+    nextAttemptAt?: number;
+    lastAttemptAt?: number;
+    lastStatusCode?: number;
+    lastError?: string;
+    deliveredAt?: number;
+    createdAt: number;
+    updatedAt: number;
+};
+export type WebhookDeliveryAttemptRecord = {
+    id: string;
+    attemptId: string;
+    deliveryId: string;
+    webhookId: string;
+    eventId: string;
+    eventType: string;
+    attemptNumber: number;
+    status: "succeeded" | "failed";
+    statusCode?: number;
+    error?: string;
+    responseBody?: string;
+    durationMs?: number;
+    createdAt: number;
+};
+export type WebhookDeliveriesResult = {
+    deliveries: Array<WebhookDeliveryRecord & {
+        attempts?: WebhookDeliveryAttemptRecord[];
+    }>;
+};
+export type WebhookHealthResult = {
+    webhookId: string;
+    totalAttempts: number;
+    successfulAttempts: number;
+    failedAttempts: number;
+    successRate: number;
+    pendingDeliveries: number;
+    deadLetterDeliveries: number;
+    lastDeliveryAt?: number;
+    lastSuccessfulDeliveryAt?: number;
+};
+export type WebhookTestResult = {
+    webhookId: string;
+    deliveryId: string;
+    status: WebhookDeliveryStatus;
+    attempts: number;
+};
+export type ReplayEventsInput = EventListQuery & {
+    webhookId?: string;
+};
+export type ReplayEventsResult = EventListResult & {
+    replayedDeliveries?: number;
+    replayedWebhookId?: string;
+};

package/dist/lucern/packages/events/src/webhooks.d.ts

@@ -0,0 +1,9 @@
+import { type WebhookDeliveryStatus, type WebhookRecord } from "./types";
+export declare function assertValidWebhookUrl(url: string): string;
+export declare function normalizeWebhookPatterns(patterns: readonly string[]): string[];
+export declare function assertValidWebhookSecret(secret: string): string;
+export declare function computeWebhookSignature(payload: string, secret: string): Promise<string>;
+export declare function nextDeliveryAttemptAt(currentAttemptCount: number, now?: number): number | undefined;
+export declare function resolveDeliveryFailureStatus(attemptCount: number): WebhookDeliveryStatus;
+export declare function sanitizeWebhookRecord(value: Record<string, unknown>): WebhookRecord;
+export declare function truncateWebhookResponseBody(responseBody: string | undefined, maxLength?: number): string | undefined;

package/dist/lucern/packages/sdk-typescript/src/facade/beliefs.d.ts

@@ -0,0 +1,15 @@
+import { type BeliefsClientCoreConfig } from "@/lucern/packages/client-core/src/beliefs";
+export type BeliefsFacadeConfig = BeliefsClientCoreConfig;
+export declare function createBeliefsFacade(config?: BeliefsFacadeConfig): {
+    create(input: Parameters<(input: import("..").CreateBeliefInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsCreateResponse>>[0], idempotencyKey?: Parameters<(input: import("..").CreateBeliefInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsCreateResponse>>[1]): Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsCreateResponse>;
+    get(id: string): Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsGetResponse>;
+    list(query: Parameters<(query: import("..").ListBeliefsQuery) => Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsListResponse>>[0]): Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsListResponse>;
+    refine(id: string, input: Parameters<(id: string, input: Omit<import("..").BeliefRefineInput, "id">, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsRefineResponse>>[1], idempotencyKey?: Parameters<(id: string, input: Omit<import("..").BeliefRefineInput, "id">, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsRefineResponse>>[2]): Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsRefineResponse>;
+    fork(id: string, input: Parameters<(id: string, input: Omit<import("..").ForkBeliefInput, "id">, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsForkResponse>>[1], idempotencyKey?: Parameters<(id: string, input: Omit<import("..").ForkBeliefInput, "id">, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsForkResponse>>[2]): Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsForkResponse>;
+    updateConfidence(id: string, input: Parameters<(id: string, input: Omit<import("..").UpdateBeliefConfidenceInput, "id">, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsUpdateConfidenceResponse>>[1], idempotencyKey?: Parameters<(id: string, input: Omit<import("..").UpdateBeliefConfidenceInput, "id">, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsUpdateConfidenceResponse>>[2]): Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsUpdateConfidenceResponse>;
+    archive(id: string, input?: Parameters<(id: string, input?: Omit<import("..").ArchiveBeliefInput, "id">, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsArchiveResponse>>[1], idempotencyKey?: Parameters<(id: string, input?: Omit<import("..").ArchiveBeliefInput, "id">, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsArchiveResponse>>[2]): Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsArchiveResponse>;
+    lineage(id: string): Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsLineageResponse>;
+    confidenceHistory(id: string): Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsConfidenceHistoryResponse>;
+    createContract(id: string, input: Parameters<(id: string, input: import("..").BeliefContractCreateInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsCreateContractResponse>>[1], idempotencyKey?: Parameters<(id: string, input: import("..").BeliefContractCreateInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsCreateContractResponse>>[2]): Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsCreateContractResponse>;
+    bisect(id: string, input: Parameters<(id: string, input: Omit<import("..").BisectBeliefConfidenceInput, "id">, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsBisectResponse>>[1], idempotencyKey?: Parameters<(id: string, input: Omit<import("..").BisectBeliefConfidenceInput, "id">, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsBisectResponse>>[2]): Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsBisectResponse>;
+};

package/dist/lucern/packages/sdk-typescript/src/facade/context.d.ts

@@ -0,0 +1,12 @@
+import { type CompileContextInput, type ContextClientRequest } from "../../../client-core/src/context";
+import type { PublicCompiledContext } from "../../../domain-context/src";
+export type ContextFacadeTransport = {
+    request<T>(request: ContextClientRequest): Promise<T>;
+};
+export type ContextFacadeConfig = {
+    transport: ContextFacadeTransport;
+};
+export declare function createContextFacade(config: ContextFacadeConfig): {
+    compile(topicId: string, input?: CompileContextInput): Promise<PublicCompiledContext>;
+};
+export type { CompileContextInput, PublicCompiledContext };

package/dist/lucern/packages/sdk-typescript/src/facade/contradictions.d.ts

@@ -0,0 +1,7 @@
+import { type ContradictionsClientCoreConfig } from "@/lucern/packages/client-core/src/contradictions";
+export type ContradictionsFacadeConfig = ContradictionsClientCoreConfig;
+export declare function createContradictionsFacade(config?: ContradictionsFacadeConfig): {
+    flag(input: Parameters<(input: import("..").FlagContradictionInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/contradictions").ContradictionsFlagResponse>>[0], idempotencyKey?: Parameters<(input: import("..").FlagContradictionInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/contradictions").ContradictionsFlagResponse>>[1]): Promise<import("@/lucern/packages/client-core/src/contradictions").ContradictionsFlagResponse>;
+    list(query: Parameters<(query: import("..").ListContradictionsQuery) => Promise<import("@/lucern/packages/client-core/src/contradictions").ContradictionsListResponse>>[0]): Promise<import("@/lucern/packages/client-core/src/contradictions").ContradictionsListResponse>;
+    get(id: string): Promise<import("@/lucern/packages/client-core/src/contradictions").ContradictionsGetResponse>;
+};