@lucern/sdk 0.2.0-alpha.13 → 0.2.0-alpha.3

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>;

package/dist/{contextPackCompiler.d.ts → lucern/packages/domain-context/src/context-pack-compiler.d.ts}

@@ -1,7 +1,7 @@
-import { ContextRankingProfile, ContextCompilationMode, PackWeightOverride, ContextPackV1 } from './contracts/context-pack.contract.js';
-import { resolveEffectiveWeights } from './contextPackPolicy.js';
-
-type ContextPackTopicRow = {
+import { type ContextCompilationMode, type ContextPackV1, type PackWeightOverride } from "../../../contracts/src/context-pack.contract";
+import { resolveEffectiveWeights } from "../../../mcp-server/src/context-pack-policy";
+import { type ContextRankingProfile } from "../../../mcp-server/src/context-pack-schema";
+export type ContextPackTopicRow = {
     _id: string;
     name?: string;
     parentTopicId?: string;
@@ -64,7 +64,7 @@ type ContextPackFailureRow = {
     updatedAt?: number;
     createdAt?: number;
 };
-type CompileContextPackPlan = {
+export type CompileContextPackPlan = {
     topicId: string;
     queryText?: string;
     tokens: string[];
@@ -81,12 +81,12 @@ type CompileContextPackPlan = {
     effectiveWeights: ReturnType<typeof resolveEffectiveWeights>;
     scopedTopicIds: string[];
 };
-type CompileContextPackPlanInput = {
+export type CompileContextPackPlanInput = {
     args: Record<string, unknown> | undefined;
     topic: ContextPackTopicRow;
     allTopics: ContextPackTopicRow[];
 };
-type CompileContextPackSnapshot = {
+export type CompileContextPackSnapshot = {
     topic: ContextPackTopicRow;
     plan: CompileContextPackPlan;
     beliefs: ContextPackBeliefRow[];
@@ -96,7 +96,6 @@ type CompileContextPackSnapshot = {
     entities: ContextPackEntityRow[];
     failures?: ContextPackFailureRow[];
 };
-declare function planContextPackCompilation(input: CompileContextPackPlanInput): CompileContextPackPlan;
-declare function compileContextPackFromSnapshot(snapshot: CompileContextPackSnapshot): ContextPackV1;
-
-export { type CompileContextPackPlan, type CompileContextPackPlanInput, type CompileContextPackSnapshot, type ContextPackTopicRow, compileContextPackFromSnapshot, planContextPackCompilation };
+export declare function planContextPackCompilation(input: CompileContextPackPlanInput): CompileContextPackPlan;
+export declare function compileContextPackFromSnapshot(snapshot: CompileContextPackSnapshot): ContextPackV1;
+export {};

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

@@ -0,0 +1,4 @@
+export * from "./compile";
+export * from "./context-pack-compiler";
+export * from "./ports";
+export * from "./public-types";

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

@@ -0,0 +1,58 @@
+import type { ContextCompilationMode, ContextPackV1, ContextRankingProfile, PackWeightOverride } from "../../../contracts/src/context-pack.contract";
+export type CompileContextCommand = {
+    topicId?: string;
+    projectId?: string;
+    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;
+    actorPrincipalId?: string;
+    policyTraceId?: string | null;
+    allowedTopicIds?: string[];
+};
+export type CompileContextPortInput = {
+    topicId: string;
+    projectId: string;
+    query?: string;
+    budget?: number;
+    ranking?: ContextRankingProfile;
+    limit?: number;
+    maxDepth?: number;
+    includeEntities?: boolean;
+    mode?: ContextCompilationMode;
+    includeFailures?: boolean;
+    worktreeId?: string;
+    sessionId?: string;
+    packWeightOverrides?: PackWeightOverride[];
+    allowedTopicIds: string[];
+};
+export type ContextCompilerPort = {
+    compile(input: CompileContextPortInput): Promise<ContextPackV1>;
+};
+export type ContextPolicyPort = {
+    filterReadableTopicIds(input: {
+        topicIds: string[];
+        actorPrincipalId: string;
+        traceId?: string | null;
+    }): Promise<string[]>;
+    listReadableTopicIds(input: {
+        actorPrincipalId: string;
+        traceId?: string | null;
+    }): Promise<string[]>;
+};
+export type CompileContextPorts = {
+    compiler: ContextCompilerPort;
+    policy?: ContextPolicyPort;
+    requireAuth?: boolean;
+};

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

@@ -0,0 +1 @@
+export type { PublicCompiledContext, PublicContextBelief, PublicContextContradiction, PublicContextEntity, PublicContextEvidence, PublicContextInjectionPolicy, PublicContextQuestion, } from "../../../contracts/src/context-pack.contract";

package/dist/lucern/packages/domain-edges/src/contradictions.d.ts

@@ -0,0 +1,59 @@
+type PublicSeverity = "low" | "medium" | "high" | "critical";
+type DefeatType = "rebuts" | "undercuts" | "undermines";
+export type ContradictionRecord = {
+    id: string;
+    contradictionId: string;
+    topicId?: string;
+    beliefA: string;
+    beliefB: string;
+    description: string;
+    severity: PublicSeverity;
+    status: string;
+    defeatType: DefeatType;
+    createdAt?: number;
+    updatedAt?: number;
+    metadata?: Record<string, unknown>;
+};
+export type ContradictionListResult = {
+    contradictions: ContradictionRecord[];
+    nextCursor: null;
+};
+export type FlagContradictionInput = {
+    beliefA: string;
+    beliefB: string;
+    description: string;
+    topicId: string;
+    severity?: string;
+    defeatType?: string;
+};
+export type ListContradictionsQuery = {
+    topicId: string;
+    status?: string;
+    limit?: number;
+    cursor?: string;
+};
+type PortSeverity = "critical" | "significant" | "minor";
+type FlagContradictionPortInput = {
+    beliefARawId: string;
+    beliefBRawId: string;
+    description: string;
+    topicId: string;
+    severity: PortSeverity;
+    publicSeverity: PublicSeverity;
+    defeatType: DefeatType;
+};
+export type ContradictionsPort = {
+    fetchBelief: (rawId: string) => Promise<unknown | null>;
+    flagContradiction: (input: FlagContradictionPortInput) => Promise<unknown>;
+    listByTopic: (args: {
+        topicId: string;
+        limit?: number;
+    }) => Promise<unknown[]>;
+    getById: (id: string) => Promise<unknown | null>;
+};
+export declare function flagContradiction(deps: ContradictionsPort, input: FlagContradictionInput): Promise<ContradictionRecord>;
+export declare function listContradictions(deps: ContradictionsPort, query: ListContradictionsQuery): Promise<ContradictionListResult>;
+export declare function getContradiction(deps: ContradictionsPort, input: {
+    id: string;
+}): Promise<ContradictionRecord>;
+export {};

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

@@ -0,0 +1,91 @@
+type EdgeDirection = "up" | "down" | "both";
+export type EdgeRecord = {
+    id: string;
+    edgeId: string;
+    globalId?: string;
+    sourceId: string;
+    targetId: string;
+    edgeType: string;
+    topicId?: string;
+    confidence?: number;
+    weight?: number;
+    context?: string;
+    fromLayer?: string;
+    toLayer?: string;
+    isDuplicate?: boolean;
+    createdAt?: number;
+    updatedAt?: number;
+    metadata?: Record<string, unknown>;
+};
+export type EdgeListResult = {
+    edges: EdgeRecord[];
+    nextCursor: null;
+};
+export type EdgeTraversalNode = {
+    id: string;
+    nodeId: string;
+    globalId?: string;
+    nodeType?: string;
+    text?: string;
+    confidence?: number;
+    depth?: number;
+    topicId?: string;
+    metadata?: Record<string, unknown>;
+};
+export type EdgeTraversalResult = {
+    startNode: string;
+    direction: EdgeDirection;
+    maxDepth: number;
+    nodes: EdgeTraversalNode[];
+    edges: EdgeRecord[];
+    depth: number;
+};
+export type CreateEdgeInput = {
+    sourceId: string;
+    targetId: string;
+    edgeType: string;
+    topicId?: string;
+    confidence?: number;
+    weight?: number;
+    context?: string;
+};
+export type ListEdgesQuery = {
+    sourceId: string;
+    edgeType?: string;
+    limit?: number;
+    cursor?: string;
+};
+export type TraverseEdgesInput = {
+    startNode: string;
+    direction?: string;
+    maxDepth?: number;
+    topicId?: string;
+};
+type EdgeCreatePortInput = {
+    sourceRawId: string;
+    targetRawId: string;
+    edgeType: string;
+    topicId?: string;
+    confidence?: number;
+    weight?: number;
+    context?: string;
+};
+type EdgeTraversePortInput = {
+    startNode: string;
+    direction: EdgeDirection;
+    maxDepth: number;
+    topicId?: string;
+};
+export type EdgePort = {
+    createEdge: (input: EdgeCreatePortInput) => Promise<unknown>;
+    listEdgesBySource: (args: {
+        sourceRawId: string;
+        edgeType?: string;
+        limit?: number;
+    }) => Promise<unknown[]>;
+    traverseEdges: (input: EdgeTraversePortInput) => Promise<unknown>;
+};
+export declare function createEdge(deps: EdgePort, input: CreateEdgeInput): Promise<EdgeRecord>;
+export declare function listEdges(deps: EdgePort, query: ListEdgesQuery): Promise<EdgeListResult>;
+export declare function traverseEdges(deps: EdgePort, input: TraverseEdgesInput): Promise<EdgeTraversalResult>;
+export {};

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

@@ -0,0 +1,2 @@
+export * from "./edges";
+export * from "./contradictions";