@lucern/sdk 0.2.0-alpha.1

package/dist/lucern/packages/client-core/src/beliefs.d.ts

@@ -0,0 +1,30 @@
+import { type GatewayClientConfig, type PlatformGatewaySuccess } from "@/packages/sdk/src/coreClient";
+import type { ArchiveBeliefInput, BeliefArchiveResult, BeliefBisectResult, BeliefConfidenceHistoryResult, BeliefConfidenceUpdateResult, BeliefContractCreateInput, BeliefContractCreateResult, BeliefLineageResult, BeliefListResult, BeliefRefineInput, BeliefRecord, BisectBeliefConfidenceInput, CreateBeliefInput, ForkBeliefInput, ListBeliefsQuery, UpdateBeliefConfidenceInput } from "@/lucern/packages/domain-beliefs/src/beliefs";
+export type BeliefsClientCoreConfig = GatewayClientConfig;
+export type BeliefsGetResponse = PlatformGatewaySuccess<BeliefRecord>;
+export type BeliefsCreateResponse = PlatformGatewaySuccess<BeliefRecord>;
+export type BeliefsListResponse = PlatformGatewaySuccess<BeliefListResult>;
+export type BeliefsRefineResponse = PlatformGatewaySuccess<BeliefRecord>;
+export type BeliefsForkResponse = PlatformGatewaySuccess<BeliefRecord & {
+    parentBeliefId: string;
+    forkReason: string;
+}>;
+export type BeliefsUpdateConfidenceResponse = PlatformGatewaySuccess<BeliefConfidenceUpdateResult>;
+export type BeliefsArchiveResponse = PlatformGatewaySuccess<BeliefArchiveResult>;
+export type BeliefsLineageResponse = PlatformGatewaySuccess<BeliefLineageResult>;
+export type BeliefsConfidenceHistoryResponse = PlatformGatewaySuccess<BeliefConfidenceHistoryResult>;
+export type BeliefsCreateContractResponse = PlatformGatewaySuccess<BeliefContractCreateResult>;
+export type BeliefsBisectResponse = PlatformGatewaySuccess<BeliefBisectResult>;
+export declare function createBeliefsClientCore(config?: BeliefsClientCoreConfig): {
+    create(input: CreateBeliefInput, idempotencyKey?: string): Promise<BeliefsCreateResponse>;
+    get(id: string): Promise<BeliefsGetResponse>;
+    list(query: ListBeliefsQuery): Promise<BeliefsListResponse>;
+    refine(id: string, input: Omit<BeliefRefineInput, "id">, idempotencyKey?: string): Promise<BeliefsRefineResponse>;
+    fork(id: string, input: Omit<ForkBeliefInput, "id">, idempotencyKey?: string): Promise<BeliefsForkResponse>;
+    updateConfidence(id: string, input: Omit<UpdateBeliefConfidenceInput, "id">, idempotencyKey?: string): Promise<BeliefsUpdateConfidenceResponse>;
+    archive(id: string, input?: Omit<ArchiveBeliefInput, "id">, idempotencyKey?: string): Promise<BeliefsArchiveResponse>;
+    lineage(id: string): Promise<BeliefsLineageResponse>;
+    confidenceHistory(id: string): Promise<BeliefsConfidenceHistoryResponse>;
+    createContract(id: string, input: BeliefContractCreateInput, idempotencyKey?: string): Promise<BeliefsCreateContractResponse>;
+    bisect(id: string, input: Omit<BisectBeliefConfidenceInput, "id">, idempotencyKey?: string): Promise<BeliefsBisectResponse>;
+};

package/dist/lucern/packages/client-core/src/context.d.ts

@@ -0,0 +1,29 @@
+import type { ContextCompilationMode, ContextRankingProfile, PackWeightOverride } from "../../../contracts/src/context-pack.contract";
+export type CompileContextInput = {
+    query?: string;
+    budget?: number;
+    ranking?: ContextRankingProfile;
+    limit?: number;
+    maxDepth?: number;
+    includeEntities?: boolean;
+    mode?: ContextCompilationMode;
+    includeFailures?: boolean;
+    worktreeId?: string;
+    sessionId?: string;
+    packWeightOverrides?: PackWeightOverride[];
+    /** @deprecated Use budget. */
+    tokenBudget?: number;
+    /** @deprecated Use ranking. */
+    rankingProfile?: ContextRankingProfile;
+};
+export type ContextClientRequest = {
+    path: "/api/platform/v1/context/compile";
+    method: "POST";
+    body: Record<string, unknown>;
+};
+export declare function buildCompileContextRequest(topicId: string, input?: CompileContextInput): ContextClientRequest;
+export declare function createContextClientCore<TResult>(deps: {
+    execute(request: ContextClientRequest): Promise<TResult>;
+}): {
+    compile(topicId: string, input?: CompileContextInput): Promise<TResult>;
+};

package/dist/lucern/packages/client-core/src/contradictions.d.ts

@@ -0,0 +1,11 @@
+import { type GatewayClientConfig, type PlatformGatewaySuccess } from "@/packages/sdk/src/coreClient";
+import type { ContradictionListResult, ContradictionRecord, FlagContradictionInput, ListContradictionsQuery } from "@/lucern/packages/domain-edges/src/contradictions";
+export type ContradictionsClientCoreConfig = GatewayClientConfig;
+export type ContradictionsFlagResponse = PlatformGatewaySuccess<ContradictionRecord>;
+export type ContradictionsListResponse = PlatformGatewaySuccess<ContradictionListResult>;
+export type ContradictionsGetResponse = PlatformGatewaySuccess<ContradictionRecord>;
+export declare function createContradictionsClient(config?: ContradictionsClientCoreConfig): {
+    flag(input: FlagContradictionInput, idempotencyKey?: string): Promise<ContradictionsFlagResponse>;
+    list(query: ListContradictionsQuery): Promise<ContradictionsListResponse>;
+    get(id: string): Promise<ContradictionsGetResponse>;
+};

package/dist/lucern/packages/client-core/src/edges.d.ts

@@ -0,0 +1,11 @@
+import { type GatewayClientConfig, type PlatformGatewaySuccess } from "@/packages/sdk/src/coreClient";
+import type { CreateEdgeInput, EdgeListResult, EdgeRecord, EdgeTraversalResult, ListEdgesQuery, TraverseEdgesInput } from "@/lucern/packages/domain-edges/src/edges";
+export type EdgesClientCoreConfig = GatewayClientConfig;
+export type EdgesCreateResponse = PlatformGatewaySuccess<EdgeRecord>;
+export type EdgesListResponse = PlatformGatewaySuccess<EdgeListResult>;
+export type EdgesTraverseResponse = PlatformGatewaySuccess<EdgeTraversalResult>;
+export declare function createEdgesClient(config?: EdgesClientCoreConfig): {
+    create(input: CreateEdgeInput, idempotencyKey?: string): Promise<EdgesCreateResponse>;
+    list(query: ListEdgesQuery): Promise<EdgesListResponse>;
+    traverse(input: TraverseEdgesInput, idempotencyKey?: string): Promise<EdgesTraverseResponse>;
+};

package/dist/lucern/packages/client-core/src/events.d.ts

@@ -0,0 +1,9 @@
+import { type GatewayClientConfig, type PlatformGatewaySuccess } from "@/packages/sdk/src/coreClient";
+import type { EventListQuery, EventListResult, ReplayEventsInput, ReplayEventsResult } from "@/lucern/packages/events/src/types";
+export type EventsClientCoreConfig = GatewayClientConfig;
+export type EventsListResponse = PlatformGatewaySuccess<EventListResult>;
+export type EventsReplayResponse = PlatformGatewaySuccess<ReplayEventsResult>;
+export declare function createEventsClientCore(config?: EventsClientCoreConfig): {
+    list(query?: EventListQuery): Promise<EventsListResponse>;
+    replay(input: ReplayEventsInput, idempotencyKey?: string): Promise<EventsReplayResponse>;
+};

package/dist/lucern/packages/client-core/src/evidence.d.ts

@@ -0,0 +1,21 @@
+import { type GatewayClientConfig, type PlatformGatewaySuccess } from "@/packages/sdk/src/coreClient";
+import type { CreateEvidenceInput, EvidenceListResult, EvidenceRecord, EvidenceSearchPage, LinkEvidenceResult, ListEvidenceQuery, SearchEvidenceQuery } from "@/lucern/packages/domain-evidence/src/evidence";
+export type EvidenceClientCoreConfig = GatewayClientConfig;
+export type EvidenceGetResponse = PlatformGatewaySuccess<EvidenceRecord>;
+export type EvidenceCreateResponse = PlatformGatewaySuccess<EvidenceRecord>;
+export type EvidenceListResponse = PlatformGatewaySuccess<EvidenceListResult>;
+export type EvidenceSearchResponse = PlatformGatewaySuccess<EvidenceSearchPage>;
+export type EvidenceLinkResponse = PlatformGatewaySuccess<LinkEvidenceResult>;
+export declare function createEvidenceClient(config?: EvidenceClientCoreConfig): {
+    create(input: CreateEvidenceInput, idempotencyKey?: string): Promise<EvidenceCreateResponse>;
+    get(id: string): Promise<EvidenceGetResponse>;
+    list(query: ListEvidenceQuery): Promise<EvidenceListResponse>;
+    link(input: {
+        evidenceId: string;
+        targetId: string;
+        targetType?: "belief" | "question";
+        weight?: number;
+        rationale?: string;
+    }, idempotencyKey?: string): Promise<EvidenceLinkResponse>;
+    search(query: SearchEvidenceQuery, idempotencyKey?: string): Promise<EvidenceSearchResponse>;
+};

package/dist/lucern/packages/client-core/src/graph.d.ts

@@ -0,0 +1,17 @@
+import { type GatewayClientConfig, type PlatformGatewaySuccess } from "@/packages/sdk/src/coreClient";
+import type { GraphAnalyzeInput, GraphAnalyzeResult, GraphBiasInput, GraphBiasResult, GraphFalsifyInput, GraphFalsifyResult, GraphGapsInput, GraphGapsResult, GraphNeighborhoodInput, GraphNeighborhoodResult, GraphTraverseInput, GraphTraverseResult } from "@/lucern/packages/domain-graph/src/graph";
+export type GraphClientCoreConfig = GatewayClientConfig;
+export type GraphNeighborhoodResponse = PlatformGatewaySuccess<GraphNeighborhoodResult>;
+export type GraphTraverseResponse = PlatformGatewaySuccess<GraphTraverseResult>;
+export type GraphAnalyzeResponse = PlatformGatewaySuccess<GraphAnalyzeResult>;
+export type GraphBiasResponse = PlatformGatewaySuccess<GraphBiasResult>;
+export type GraphGapsResponse = PlatformGatewaySuccess<GraphGapsResult>;
+export type GraphFalsifyResponse = PlatformGatewaySuccess<GraphFalsifyResult>;
+export declare function createGraphClient(config?: GraphClientCoreConfig): {
+    neighborhood(input: GraphNeighborhoodInput): Promise<GraphNeighborhoodResponse>;
+    traverse(input: GraphTraverseInput): Promise<GraphTraverseResponse>;
+    analyze(input: GraphAnalyzeInput): Promise<GraphAnalyzeResponse>;
+    bias(input: GraphBiasInput): Promise<GraphBiasResponse>;
+    gaps(input: GraphGapsInput): Promise<GraphGapsResponse>;
+    falsify(input: GraphFalsifyInput): Promise<GraphFalsifyResponse>;
+};

package/dist/lucern/packages/client-core/src/identity.d.ts

@@ -0,0 +1,7 @@
+import { type GatewayClientConfig, type PlatformGatewaySuccess } from "@/packages/sdk/src/coreClient";
+import type { IdentitySummary } from "@/lucern/packages/domain-identity/src/whoami";
+export type IdentityClientCoreConfig = GatewayClientConfig;
+export type IdentityWhoamiResponse = PlatformGatewaySuccess<IdentitySummary>;
+export declare function createIdentityWhoamiClient(config?: IdentityClientCoreConfig): {
+    whoami(): Promise<IdentityWhoamiResponse>;
+};

package/dist/lucern/packages/client-core/src/ids.d.ts

@@ -0,0 +1,7 @@
+export type DecodedPrefixedId = {
+    prefix: string;
+    value: string;
+};
+export declare function encodePrefixedId(prefix: string, value: string): string;
+export declare function decodePrefixedId(id: string): DecodedPrefixedId;
+export declare function hasPrefixedIdPrefix(id: string, prefix: string): boolean;

package/dist/lucern/packages/client-core/src/ontologies.d.ts

@@ -0,0 +1,13 @@
+import { type GatewayClientConfig, type PlatformGatewaySuccess } from "@/packages/sdk/src/coreClient";
+import type { BindOntologyInput, OntologyBindingResult, OntologyListQuery, OntologyListResult, OntologyMatchInput, OntologyMatchResult, OntologyRecord } from "@/lucern/packages/domain-ontologies/src/ontologies";
+export type OntologiesClientCoreConfig = GatewayClientConfig;
+export type OntologiesGetResponse = PlatformGatewaySuccess<OntologyRecord>;
+export type OntologiesListResponse = PlatformGatewaySuccess<OntologyListResult>;
+export type OntologiesBindResponse = PlatformGatewaySuccess<OntologyBindingResult>;
+export type OntologiesMatchResponse = PlatformGatewaySuccess<OntologyMatchResult>;
+export declare function createOntologiesClientCore(config?: OntologiesClientCoreConfig): {
+    get(id: string): Promise<OntologiesGetResponse>;
+    list(query?: OntologyListQuery): Promise<OntologiesListResponse>;
+    bind(input: BindOntologyInput, idempotencyKey?: string): Promise<OntologiesBindResponse>;
+    match(input: OntologyMatchInput, idempotencyKey?: string): Promise<OntologiesMatchResponse>;
+};

package/dist/lucern/packages/client-core/src/questions.d.ts

@@ -0,0 +1,39 @@
+import { type GatewayClientConfig, type PlatformGatewaySuccess } from "@/packages/sdk/src/coreClient";
+import type { CreateQuestionInput, ListQuestionsQuery, QuestionArchiveResult, QuestionAnswerResult, QuestionListResult, QuestionRecord } from "@/lucern/packages/domain-questions/src/questions";
+export type QuestionsClientCoreConfig = GatewayClientConfig;
+export type QuestionsCreateResponse = PlatformGatewaySuccess<QuestionRecord>;
+export type QuestionsGetResponse = PlatformGatewaySuccess<QuestionRecord>;
+export type QuestionsListResponse = PlatformGatewaySuccess<QuestionListResult>;
+export type QuestionsRefineResponse = PlatformGatewaySuccess<QuestionRecord & {
+    previousText: string;
+    updatedText: string;
+}>;
+export type QuestionsUpdateStatusResponse = PlatformGatewaySuccess<QuestionRecord & {
+    previousStatus: string;
+    newStatus: string;
+}>;
+export type QuestionsArchiveResponse = PlatformGatewaySuccess<QuestionArchiveResult>;
+export type QuestionsAnswerResponse = PlatformGatewaySuccess<QuestionAnswerResult>;
+export declare function createQuestionsClient(config?: QuestionsClientCoreConfig): {
+    create(input: CreateQuestionInput, idempotencyKey?: string): Promise<QuestionsCreateResponse>;
+    get(id: string): Promise<QuestionsGetResponse>;
+    list(query: ListQuestionsQuery): Promise<QuestionsListResponse>;
+    answer(id: string, input: {
+        text: string;
+        confidence?: string;
+        evidenceIds?: string[];
+        rationale?: string;
+    }, idempotencyKey?: string): Promise<QuestionsAnswerResponse>;
+    refine(id: string, input: {
+        text: string;
+        rationale?: string;
+    }, idempotencyKey?: string): Promise<QuestionsRefineResponse>;
+    archive(id: string, input?: {
+        reason?: string;
+        rationale?: string;
+    }, idempotencyKey?: string): Promise<QuestionsArchiveResponse>;
+    updateStatus(id: string, input: {
+        status: string;
+        rationale?: string;
+    }, idempotencyKey?: string): Promise<QuestionsUpdateStatusResponse>;
+};

package/dist/lucern/packages/client-core/src/search.d.ts

@@ -0,0 +1,7 @@
+import { type GatewayClientConfig, type PlatformGatewaySuccess } from "@/packages/sdk/src/coreClient";
+import type { SearchInput, SearchResponse } from "@/lucern/packages/domain-search/src/search";
+export type SearchClientCoreConfig = GatewayClientConfig;
+export type SearchResourcesResponse = PlatformGatewaySuccess<SearchResponse>;
+export declare function createSearchClient(config?: SearchClientCoreConfig): {
+    query(input: SearchInput): Promise<SearchResourcesResponse>;
+};

package/dist/lucern/packages/client-core/src/tasks.d.ts

@@ -0,0 +1,13 @@
+import { type GatewayClientConfig, type PlatformGatewaySuccess } from "@/packages/sdk/src/coreClient";
+import type { CompleteTaskInput, CreateTaskInput, ListTasksQuery, TaskListResult, TaskRecord, UpdateTaskInput } from "@/lucern/packages/domain-tasks/src/tasks";
+export type TasksClientCoreConfig = GatewayClientConfig;
+export type TasksCreateResponse = PlatformGatewaySuccess<TaskRecord>;
+export type TasksUpdateResponse = PlatformGatewaySuccess<TaskRecord>;
+export type TasksCompleteResponse = PlatformGatewaySuccess<TaskRecord>;
+export type TasksListResponse = PlatformGatewaySuccess<TaskListResult>;
+export declare function createTasksClientCore(config?: TasksClientCoreConfig): {
+    create(input: CreateTaskInput, idempotencyKey?: string): Promise<TasksCreateResponse>;
+    update(input: UpdateTaskInput, idempotencyKey?: string): Promise<TasksUpdateResponse>;
+    complete(input: CompleteTaskInput, idempotencyKey?: string): Promise<TasksCompleteResponse>;
+    list(query: ListTasksQuery): Promise<TasksListResponse>;
+};

package/dist/lucern/packages/client-core/src/topics.d.ts

@@ -0,0 +1,17 @@
+import { type GatewayClientConfig, type PlatformGatewaySuccess } from "@/packages/sdk/src/coreClient";
+import type { CreateTopicInput, GetTopicCoverageInput, GetTopicTreeInput, ListTopicsQuery, TopicCoverageResult, TopicListResult, TopicRecord, TopicTreeResult, UpdateTopicInput } from "@/lucern/packages/domain-topics/src/topics";
+export type TopicsClientCoreConfig = GatewayClientConfig;
+export type TopicsCreateResponse = PlatformGatewaySuccess<TopicRecord>;
+export type TopicsGetResponse = PlatformGatewaySuccess<TopicRecord>;
+export type TopicsListResponse = PlatformGatewaySuccess<TopicListResult>;
+export type TopicsUpdateResponse = PlatformGatewaySuccess<TopicRecord>;
+export type TopicsTreeResponse = PlatformGatewaySuccess<TopicTreeResult>;
+export type TopicsCoverageResponse = PlatformGatewaySuccess<TopicCoverageResult>;
+export declare function createTopicsClientCore(config?: TopicsClientCoreConfig): {
+    create(input: CreateTopicInput, idempotencyKey?: string): Promise<TopicsCreateResponse>;
+    get(id: string): Promise<TopicsGetResponse>;
+    list(query?: ListTopicsQuery): Promise<TopicsListResponse>;
+    update(input: UpdateTopicInput, idempotencyKey?: string): Promise<TopicsUpdateResponse>;
+    tree(input: GetTopicTreeInput): Promise<TopicsTreeResponse>;
+    coverage(input: GetTopicCoverageInput): Promise<TopicsCoverageResponse>;
+};

package/dist/lucern/packages/client-core/src/webhooks.d.ts

@@ -0,0 +1,35 @@
+import { type GatewayClientConfig, type PlatformGatewaySuccess } from "@/packages/sdk/src/coreClient";
+import type { WebhookCreateInput, WebhookDeliveriesResult, WebhookHealthResult, WebhookRecord, WebhookTestResult, WebhookUpdateInput } from "@/lucern/packages/events/src/types";
+export type WebhooksClientCoreConfig = GatewayClientConfig;
+export type WebhookListQuery = {
+    topicId?: string;
+};
+export type WebhookDeliveriesQuery = {
+    limit?: number;
+};
+export type WebhookDeleteResult = {
+    webhookId: string;
+    deleted: boolean;
+};
+export type WebhooksCreateResponse = PlatformGatewaySuccess<WebhookRecord>;
+export type WebhooksListResponse = PlatformGatewaySuccess<{
+    webhooks: WebhookRecord[];
+}>;
+export type WebhooksGetResponse = PlatformGatewaySuccess<WebhookRecord>;
+export type WebhooksUpdateResponse = PlatformGatewaySuccess<WebhookRecord>;
+export type WebhooksDeleteResponse = PlatformGatewaySuccess<WebhookDeleteResult>;
+export type WebhooksTestResponse = PlatformGatewaySuccess<WebhookTestResult>;
+export type WebhooksDeliveriesResponse = PlatformGatewaySuccess<WebhookDeliveriesResult>;
+export type WebhooksHealthResponse = PlatformGatewaySuccess<WebhookHealthResult>;
+export declare function createWebhooksClientCore(config?: WebhooksClientCoreConfig): {
+    create(input: WebhookCreateInput, idempotencyKey?: string): Promise<WebhooksCreateResponse>;
+    list(query?: WebhookListQuery): Promise<WebhooksListResponse>;
+    get(id: string): Promise<WebhooksGetResponse>;
+    update(id: string, input: WebhookUpdateInput, idempotencyKey?: string): Promise<WebhooksUpdateResponse>;
+    delete(id: string, idempotencyKey?: string): Promise<WebhooksDeleteResponse>;
+    test(id: string, input?: {
+        topicId?: string;
+    }, idempotencyKey?: string): Promise<WebhooksTestResponse>;
+    deliveries(id: string, query?: WebhookDeliveriesQuery): Promise<WebhooksDeliveriesResponse>;
+    health(id: string): Promise<WebhooksHealthResponse>;
+};

package/dist/lucern/packages/client-core/src/worktrees.d.ts

@@ -0,0 +1,17 @@
+import { type GatewayClientConfig, type PlatformGatewaySuccess } from "@/packages/sdk/src/coreClient";
+import type { ActivateWorktreeInput, CreateWorktreeInput, ListWorktreesQuery, MergeWorktreeInput, MergeWorktreeResult, UpdateWorktreeInput, UpdateWorktreeTargetsInput, WorktreeListResult, WorktreeRecord } from "@/lucern/packages/domain-worktrees/src/worktrees";
+export type WorktreesClientCoreConfig = GatewayClientConfig;
+export type WorktreesCreateResponse = PlatformGatewaySuccess<WorktreeRecord>;
+export type WorktreesListResponse = PlatformGatewaySuccess<WorktreeListResult>;
+export type WorktreesActivateResponse = PlatformGatewaySuccess<WorktreeRecord>;
+export type WorktreesUpdateResponse = PlatformGatewaySuccess<WorktreeRecord>;
+export type WorktreesTargetsResponse = PlatformGatewaySuccess<WorktreeRecord>;
+export type WorktreesMergeResponse = PlatformGatewaySuccess<MergeWorktreeResult>;
+export declare function createWorktreesClientCore(config?: WorktreesClientCoreConfig): {
+    create(input: CreateWorktreeInput, idempotencyKey?: string): Promise<WorktreesCreateResponse>;
+    list(query: ListWorktreesQuery): Promise<WorktreesListResponse>;
+    activate(input: ActivateWorktreeInput, idempotencyKey?: string): Promise<WorktreesActivateResponse>;
+    update(input: UpdateWorktreeInput, idempotencyKey?: string): Promise<WorktreesUpdateResponse>;
+    merge(input: MergeWorktreeInput, idempotencyKey?: string): Promise<WorktreesMergeResponse>;
+    updateTargets(input: UpdateWorktreeTargetsInput, idempotencyKey?: string): Promise<WorktreesTargetsResponse>;
+};

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

@@ -0,0 +1,283 @@
+type BeliefRecordStatus = "active" | "superseded" | "archived";
+type BeliefScoringState = "unscored" | "scored";
+type BeliefForkReason = "refinement" | "contradiction_response" | "scope_change" | "confidence_collapse" | "manual";
+type BeliefConfidenceTrigger = "evidence_added" | "evidence_removed" | "contradiction_detected" | "contradiction_resolved" | "manual" | "decay" | "agent_assessment" | "worktree_outcome" | "worktree_completed";
+type ContractConditionType = "assertion" | "temporal" | "evidential" | "threshold" | "composite";
+type ContractDirection = "confirms" | "falsifies";
+type ContractCompositeOperator = "all" | "any" | "majority";
+type ContractEvaluationSchedule = "on_demand" | "on_evidence" | "periodic" | "event_driven";
+type BisectExpectedDirection = "overconfident" | "underconfident";
+export type BeliefRecord = {
+    id: string;
+    nodeId: string;
+    beliefId: string;
+    globalId?: string;
+    topicId?: string;
+    text: string;
+    canonicalText: string;
+    formulation: string;
+    status: BeliefRecordStatus;
+    scoringState: BeliefScoringState;
+    confidence?: number;
+    beliefStatus?: string;
+    title?: string;
+    sourceType?: string;
+    beliefType?: string;
+    createdAt?: number;
+    updatedAt?: number;
+    metadata?: Record<string, unknown>;
+};
+export type BeliefListResult = {
+    beliefs: BeliefRecord[];
+    nextCursor: null;
+};
+export type BeliefLineageEntry = {
+    beliefId: string;
+    nodeId: string;
+    formulation: string;
+    forkReason?: string;
+    createdAt?: number;
+};
+export type BeliefLineageResult = {
+    beliefId: string;
+    lineage: BeliefLineageEntry[];
+};
+export type BeliefConfidenceHistoryEntry = {
+    id?: string;
+    confidence: number;
+    trigger: BeliefConfidenceTrigger | string;
+    rationale?: string;
+    timestamp?: number;
+    userId?: string;
+    opinion?: {
+        b?: number;
+        d?: number;
+        u?: number;
+        a?: number;
+    };
+};
+export type BeliefConfidenceHistoryResult = {
+    beliefId: string;
+    entries: BeliefConfidenceHistoryEntry[];
+    nextCursor: null;
+};
+export type BeliefPropagationTarget = {
+    beliefId: string;
+    edgeType: "supports" | "depends_on";
+    direction: "incoming" | "outgoing";
+    confidence?: number;
+    formulation?: string;
+};
+export type BeliefConfidenceUpdateResult = {
+    beliefId: string;
+    nodeId: string;
+    previousConfidence: number;
+    newConfidence: number;
+    trigger: BeliefConfidenceTrigger;
+    rationale?: string;
+    requestId: string;
+    propagationSummary: {
+        mode: "scheduled";
+        bounded: true;
+        totalCandidateTargets: number;
+        inlineTargets: BeliefPropagationTarget[];
+        remainingTargetCount: number;
+    };
+    opinion?: {
+        b?: number;
+        d?: number;
+        u?: number;
+        a?: number;
+    };
+    historyEntry?: BeliefConfidenceHistoryEntry;
+};
+export type BeliefArchiveResult = BeliefRecord & {
+    previousStatus?: string;
+    newStatus: "archived";
+};
+export type BeliefRefineInput = {
+    id: string;
+    text: string;
+    rationale?: string;
+};
+export type BeliefContractCreateInput = {
+    title: string;
+    description?: string;
+    conditionType: ContractConditionType;
+    direction: ContractDirection;
+    condition: {
+        expression: string;
+        evaluator: string;
+        evaluatorConfig?: Record<string, unknown>;
+    };
+    deadline?: number;
+    compositeOf?: string[];
+    compositeOperator?: ContractCompositeOperator;
+    modulation: {
+        onConfirmed: {
+            delta: number;
+            ceiling?: number;
+        };
+        onDisconfirmed: {
+            delta: number;
+            floor?: number;
+        };
+        onExpired?: {
+            delta: number;
+        };
+        onPartial?: {
+            threshold: number;
+            delta: number;
+        };
+    };
+    evaluationSchedule: ContractEvaluationSchedule;
+    periodicIntervalMs?: number;
+};
+export type BeliefContractCreateResult = {
+    id: string;
+    contractId: string;
+    beliefId: string;
+    status: string;
+    title: string;
+    storageId?: string;
+};
+export type BeliefBisectResult = {
+    beliefId: string;
+    expectedDirection: BisectExpectedDirection;
+    inflectionEntry: BeliefConfidenceHistoryEntry | null;
+    triggerEvent: string | null;
+    confidenceBefore: number | null;
+    confidenceAfter: number | null;
+    totalEntries: number;
+    inflectionIndex: number | null;
+};
+export type CreateBeliefInput = {
+    topicId: string;
+    text: string;
+    rationale?: string;
+    worktreeId?: string;
+    pillar?: string;
+    sourceBeliefIds?: string[];
+    sourceType?: string;
+    beliefType?: string;
+    reversibility?: string;
+    predictionMeta?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+};
+export type ListBeliefsQuery = {
+    topicId?: string;
+    status?: string;
+    worktreeId?: string;
+    minConfidence?: number;
+    limit?: number;
+    cursor?: string;
+    includeEdgeAssociated?: boolean;
+};
+export type ForkBeliefInput = {
+    id: string;
+    text: string;
+    forkReason?: BeliefForkReason | string;
+    rationale?: string;
+};
+export type UpdateBeliefConfidenceInput = {
+    id: string;
+    confidence: number;
+    trigger?: string;
+    rationale: string;
+    certainty?: number;
+    maxInlinePropagationTargets?: number;
+};
+export type ArchiveBeliefInput = {
+    id: string;
+    reason?: string;
+};
+export type CreateBeliefContractRequest = {
+    id: string;
+    input: BeliefContractCreateInput;
+};
+export type BisectBeliefConfidenceInput = {
+    id: string;
+    expectedDirection: BisectExpectedDirection;
+    timeRange?: {
+        start: number;
+        end: number;
+    };
+};
+type BeliefCreatePortInput = {
+    topicId: string;
+    text: string;
+    rationale?: string;
+    worktreeId?: string;
+    pillar?: string;
+    sourceBeliefRawIds?: string[];
+    sourceType?: string;
+    beliefType?: string;
+    reversibility?: string;
+    predictionMeta?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+};
+type BeliefForkPortInput = {
+    beliefRawId: string;
+    text: string;
+    forkReason: BeliefForkReason;
+    rationale?: string;
+};
+type BeliefRefinePortInput = {
+    beliefRawId: string;
+    text: string;
+    rationale?: string;
+};
+type BeliefConfidencePortInput = {
+    beliefRawId: string;
+    confidence: number;
+    trigger: BeliefConfidenceTrigger;
+    rationale?: string;
+    certainty?: number;
+};
+type BeliefArchivePortInput = {
+    beliefRawId: string;
+    reason?: string;
+};
+type BeliefContractPortInput = {
+    beliefRawId: string;
+    input: BeliefContractCreateInput;
+};
+export type BeliefPort = {
+    fetchBelief: (rawId: string) => Promise<unknown | null>;
+    listBeliefsByTopic: (args: {
+        topicId: string;
+        status?: BeliefRecordStatus;
+        limit?: number;
+        includeEdgeAssociated?: boolean;
+    }) => Promise<unknown[]>;
+    createBelief: (input: BeliefCreatePortInput) => Promise<unknown>;
+    refineBelief: (input: BeliefRefinePortInput) => Promise<unknown>;
+    forkBelief: (input: BeliefForkPortInput) => Promise<unknown>;
+    modulateConfidence: (input: BeliefConfidencePortInput) => Promise<unknown>;
+    archiveBelief: (input: BeliefArchivePortInput) => Promise<unknown>;
+    getLineage: (rawId: string) => Promise<unknown[]>;
+    getConfidenceHistory: (rawId: string) => Promise<unknown[]>;
+    createContract: (input: BeliefContractPortInput) => Promise<unknown>;
+    getRelationships: (rawId: string) => Promise<unknown>;
+};
+export declare function createBelief(port: BeliefPort, input: CreateBeliefInput): Promise<BeliefRecord>;
+export declare function getBelief(port: BeliefPort, args: {
+    id: string;
+}): Promise<BeliefRecord>;
+export declare function listBeliefs(port: BeliefPort, query: ListBeliefsQuery): Promise<BeliefListResult>;
+export declare function refineBelief(port: BeliefPort, input: BeliefRefineInput): Promise<BeliefRecord>;
+export declare function forkBelief(port: BeliefPort, input: ForkBeliefInput): Promise<BeliefRecord & {
+    parentBeliefId: string;
+    forkReason: BeliefForkReason;
+}>;
+export declare function updateBeliefConfidence(port: BeliefPort, input: UpdateBeliefConfidenceInput): Promise<BeliefConfidenceUpdateResult>;
+export declare function archiveBelief(port: BeliefPort, input: ArchiveBeliefInput): Promise<BeliefArchiveResult>;
+export declare function getBeliefLineage(port: BeliefPort, args: {
+    id: string;
+}): Promise<BeliefLineageResult>;
+export declare function getBeliefConfidenceHistory(port: BeliefPort, args: {
+    id: string;
+}): Promise<BeliefConfidenceHistoryResult>;
+export declare function createBeliefContract(port: BeliefPort, request: CreateBeliefContractRequest): Promise<BeliefContractCreateResult>;
+export declare function bisectBeliefConfidence(port: BeliefPort, input: BisectBeliefConfidenceInput): Promise<BeliefBisectResult>;
+export {};

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

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

package/dist/lucern/packages/domain-context/src/compile.d.ts

@@ -0,0 +1,11 @@
+import type { ContextPackV1 } from "../../../contracts/src/context-pack.contract";
+import { type CompileContextCommand, type CompileContextPorts } from "./ports";
+import type { PublicCompiledContext } from "./public-types";
+export declare class ContextCompileError extends Error {
+    readonly code: string;
+    readonly status: number;
+    constructor(code: string, message: string, status: number);
+}
+export declare function isContextCompileError(error: unknown): error is ContextCompileError;
+export declare function toPublicCompiledContext(pack: ContextPackV1): PublicCompiledContext;
+export declare function compileContext(ports: CompileContextPorts, input: CompileContextCommand): Promise<PublicCompiledContext>;