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

package/dist/packages/sdk/src/contextClient.d.ts

@@ -0,0 +1,9 @@
+import { type CompileContextInput } from "@/lucern/packages/client-core/src/context";
+import type { PublicCompiledContext } from "@/lucern/packages/domain-context/src";
+import { type GatewayClientConfig } from "./coreClient";
+export type ContextClientConfig = GatewayClientConfig;
+export type CompileContextResponse = PublicCompiledContext;
+export declare function createContextClient(config?: ContextClientConfig): {
+    compile(topicId: string, input?: CompileContextInput): Promise<import("./coreClient").PlatformGatewaySuccess<PublicCompiledContext>>;
+};
+export type { CompileContextInput };

package/dist/packages/sdk/src/contracts/api-enums.contract.d.ts

@@ -0,0 +1,58 @@
+/**
+ * API Enum Contract Definitions
+ *
+ * Canonical enum values for all API-facing enumerations.
+ * These are co-equal with MCP contracts as external contracts.
+ * SDK types are DERIVED from these — not independently authored.
+ *
+ * CONTRACT SURFACE: Adding a new enum value is additive (non-breaking).
+ * Removing or renaming an existing value is a BREAKING CHANGE.
+ */
+/** Fork reasons — why a scored belief was branched */
+export declare const FORK_REASONS: readonly ["refinement", "contradiction_response", "scope_change", "confidence_collapse", "manual"];
+export type ForkReason = (typeof FORK_REASONS)[number];
+/** Confidence modulation triggers — what caused a confidence change */
+export declare const CONFIDENCE_TRIGGERS: readonly ["evidence_added", "contradiction_detected", "merge_outcome", "manual", "decay"];
+export type ConfidenceTrigger = (typeof CONFIDENCE_TRIGGERS)[number];
+/** Belief status — lifecycle state */
+export declare const BELIEF_STATUSES: readonly ["unscored", "scored", "archived"];
+export type BeliefStatus = (typeof BELIEF_STATUSES)[number];
+/** Reasoning methods — how an edge relationship was determined */
+export declare const REASONING_METHODS: readonly ["deductive", "inductive", "abductive", "analogical", "empirical"];
+export type ReasoningMethod = (typeof REASONING_METHODS)[number];
+/** Defeat types (Pollock taxonomy) — how a contradiction operates */
+export declare const DEFEAT_TYPES: readonly ["rebuts", "undercuts", "undermines"];
+export type DefeatType = (typeof DEFEAT_TYPES)[number];
+/** Contradiction severity levels */
+export declare const CONTRADICTION_SEVERITIES: readonly ["low", "medium", "high", "critical"];
+export type ContradictionSeverity = (typeof CONTRADICTION_SEVERITIES)[number];
+/** Contradiction resolution status */
+export declare const CONTRADICTION_STATUSES: readonly ["unresolved", "resolved", "accepted"];
+export type ContradictionStatus = (typeof CONTRADICTION_STATUSES)[number];
+/** Merge outcome types — how a worktree merge resolved */
+export declare const MERGE_OUTCOMES: readonly ["validated", "invalidated", "forked", "inconclusive"];
+export type MergeOutcome = (typeof MERGE_OUTCOMES)[number];
+/** Worktree phases — investigation lifecycle within a checked-out worktree */
+export declare const WORKTREE_PHASES: readonly ["hypothesis", "investigation", "evaluation", "resolution"];
+export type WorktreePhase = (typeof WORKTREE_PHASES)[number];
+/** Branch status — thematic branch lifecycle */
+export declare const BRANCH_STATUSES: readonly ["dormant", "active", "archived"];
+export type BranchStatus = (typeof BRANCH_STATUSES)[number];
+/** Pull request status — review lifecycle before merge */
+export declare const PULL_REQUEST_STATUSES: readonly ["pending_review", "changes_requested", "approved", "blocked"];
+export type PullRequestStatus = (typeof PULL_REQUEST_STATUSES)[number];
+/** Epistemic layers — the hierarchy of knowledge */
+export declare const EPISTEMIC_LAYERS: readonly ["L1", "L2", "L3", "L4"];
+export type EpistemicLayer = (typeof EPISTEMIC_LAYERS)[number];
+/**
+ * Judgment type — classification of the determination.
+ *
+ * Phase 1: These are new enum values for the Judgment (L4) vocabulary.
+ * The existing code uses "Decision" — these are the forward-looking terms
+ * that will eventually replace the Decision vocabulary (Phase 2-3).
+ */
+export declare const JUDGMENT_TYPES: readonly ["investment_thesis", "thesis_maturity", "contradiction_ruling", "scope_determination", "confidence_ruling"];
+export type JudgmentType = (typeof JUDGMENT_TYPES)[number];
+/** Core edge types used in the Integration Surfaces */
+export declare const INTEGRATION_EDGE_TYPES: readonly ["informs", "grounds", "answers", "contradicts", "weakened_by", "undermined_by", "depends_on", "cascades_to", "supersedes", "in_tension_with", "implies", "tests"];
+export type IntegrationEdgeType = (typeof INTEGRATION_EDGE_TYPES)[number];

package/dist/{controlObjectOwnership.d.ts → packages/sdk/src/controlObjectOwnership.d.ts}

@@ -1,25 +1,14 @@
-/** All recognized control object kinds in the ownership model. */
-declare const CONTROL_OBJECT_KINDS: readonly ["tenant", "workspace", "principal", "tool", "pack", "ontology", "belief", "policy_rule"];
-/** A kind of control object (tenant, workspace, principal, tool, etc.). */
-type ControlObjectKind = (typeof CONTROL_OBJECT_KINDS)[number];
-/** Canonical ownership scopes: platform, tenant, workspace, or resource. */
-declare const CONTROL_OBJECT_OWNER_SCOPES: readonly ["platform", "tenant", "workspace", "resource"];
-/** The scope level that canonically owns a control object. */
-type ControlObjectOwnerScope = (typeof CONTROL_OBJECT_OWNER_SCOPES)[number];
-/** UI surfaces authorized to edit control objects. */
-declare const CONTROL_OBJECT_EDIT_SURFACES: readonly ["platform_admin", "tenant_admin", "workspace_admin", "graph_worktree"];
-/** A UI surface authorized to mutate a control object (platform admin, tenant admin, etc.). */
-type ControlObjectEditSurface = (typeof CONTROL_OBJECT_EDIT_SURFACES)[number];
-/** Rules governing how control object configuration flows through the scope hierarchy. */
-declare const CONTROL_OBJECT_INHERITANCE_RULES: readonly ["none", "platform_seed_to_tenant", "tenant_default_to_workspace", "workspace_narrowing_only", "pack_overlay_to_tenant", "topic_lineage_to_resource"];
-/** How a control object's configuration propagates through scope hierarchy. */
-type ControlObjectInheritanceRule = (typeof CONTROL_OBJECT_INHERITANCE_RULES)[number];
-/** Scope of impact when a control object is modified. */
-declare const CONTROL_OBJECT_BLAST_RADII: readonly ["platform", "tenant", "workspace", "resource"];
-/** The furthest scope impacted by a mutation to a control object. */
-type ControlObjectBlastRadius = (typeof CONTROL_OBJECT_BLAST_RADII)[number];
-/** A single row in the ownership matrix describing who owns, edits, and inherits a control object. */
-type ControlObjectOwnershipCase = {
+export declare const CONTROL_OBJECT_KINDS: readonly ["tenant", "workspace", "principal", "tool", "pack", "ontology", "belief", "policy_rule"];
+export type ControlObjectKind = (typeof CONTROL_OBJECT_KINDS)[number];
+export declare const CONTROL_OBJECT_OWNER_SCOPES: readonly ["platform", "tenant", "workspace", "resource"];
+export type ControlObjectOwnerScope = (typeof CONTROL_OBJECT_OWNER_SCOPES)[number];
+export declare const CONTROL_OBJECT_EDIT_SURFACES: readonly ["platform_admin", "tenant_admin", "workspace_admin", "graph_worktree"];
+export type ControlObjectEditSurface = (typeof CONTROL_OBJECT_EDIT_SURFACES)[number];
+export declare const CONTROL_OBJECT_INHERITANCE_RULES: readonly ["none", "platform_seed_to_tenant", "tenant_default_to_workspace", "workspace_narrowing_only", "pack_overlay_to_tenant", "topic_lineage_to_resource"];
+export type ControlObjectInheritanceRule = (typeof CONTROL_OBJECT_INHERITANCE_RULES)[number];
+export declare const CONTROL_OBJECT_BLAST_RADII: readonly ["platform", "tenant", "workspace", "resource"];
+export type ControlObjectBlastRadius = (typeof CONTROL_OBJECT_BLAST_RADII)[number];
+export type ControlObjectOwnershipCase = {
     caseKey: string;
     caseLabel: string;
     kind: ControlObjectKind;
@@ -28,10 +17,8 @@ type ControlObjectOwnershipCase = {
     inheritanceRule: ControlObjectInheritanceRule;
     blastRadius: ControlObjectBlastRadius;
 };
-/** Full ownership matrix keyed by control object kind. */
-type ControlObjectOwnershipMatrix = Record<ControlObjectKind, readonly ControlObjectOwnershipCase[]>;
-/** Versioned ownership contract bundling all enums, the matrix, and flattened rows. */
-type ControlObjectOwnershipContract = {
+export type ControlObjectOwnershipMatrix = Record<ControlObjectKind, readonly ControlObjectOwnershipCase[]>;
+export type ControlObjectOwnershipContract = {
     version: "1.0.0";
     kinds: readonly ControlObjectKind[];
     ownerScopes: readonly ControlObjectOwnerScope[];
@@ -41,8 +28,7 @@ type ControlObjectOwnershipContract = {
     matrix: ControlObjectOwnershipMatrix;
     rows: readonly ControlObjectOwnershipCase[];
 };
-/** Static ownership matrix mapping each control object kind to its ownership cases. */
-declare const CONTROL_OBJECT_OWNERSHIP_MATRIX: {
+export declare const CONTROL_OBJECT_OWNERSHIP_MATRIX: {
     readonly tenant: readonly [{
         readonly caseKey: "platform-record";
         readonly caseLabel: "Platform Record";
@@ -164,10 +150,9 @@ declare const CONTROL_OBJECT_OWNERSHIP_MATRIX: {
         readonly blastRadius: "workspace";
     }];
 };
-/** Flattened array of all ownership cases across all control object kinds. */
-declare const CONTROL_OBJECT_OWNERSHIP_ROWS: readonly ControlObjectOwnershipCase[];
+export declare const CONTROL_OBJECT_OWNERSHIP_ROWS: readonly ControlObjectOwnershipCase[];
 /** The canonical ownership contract exposed by the SDK. */
-declare const CONTROL_OBJECT_OWNERSHIP_CONTRACT: {
+export declare const CONTROL_OBJECT_OWNERSHIP_CONTRACT: {
     readonly version: "1.0.0";
     readonly kinds: readonly ["tenant", "workspace", "principal", "tool", "pack", "ontology", "belief", "policy_rule"];
     readonly ownerScopes: readonly ["platform", "tenant", "workspace", "resource"];
@@ -301,10 +286,8 @@ declare const CONTROL_OBJECT_OWNERSHIP_CONTRACT: {
 /**
  * List ownership cases for one control-object kind or the full matrix.
  */
-declare function listControlObjectOwnershipCases(kind?: ControlObjectKind): readonly ControlObjectOwnershipCase[];
+export declare function listControlObjectOwnershipCases(kind?: ControlObjectKind): readonly ControlObjectOwnershipCase[];
 /**
  * Get a specific ownership case by kind and case key.
  */
-declare function getControlObjectOwnershipCase(kind: ControlObjectKind, caseKey: string): ControlObjectOwnershipCase | undefined;
-
-export { CONTROL_OBJECT_BLAST_RADII, CONTROL_OBJECT_EDIT_SURFACES, CONTROL_OBJECT_INHERITANCE_RULES, CONTROL_OBJECT_KINDS, CONTROL_OBJECT_OWNERSHIP_CONTRACT, CONTROL_OBJECT_OWNERSHIP_MATRIX, CONTROL_OBJECT_OWNERSHIP_ROWS, CONTROL_OBJECT_OWNER_SCOPES, type ControlObjectBlastRadius, type ControlObjectEditSurface, type ControlObjectInheritanceRule, type ControlObjectKind, type ControlObjectOwnerScope, type ControlObjectOwnershipCase, type ControlObjectOwnershipContract, type ControlObjectOwnershipMatrix, getControlObjectOwnershipCase, listControlObjectOwnershipCases };
+export declare function getControlObjectOwnershipCase(kind: ControlObjectKind, caseKey: string): ControlObjectOwnershipCase | undefined;

package/dist/{coreClient.d.ts → packages/sdk/src/coreClient.d.ts}

@@ -1,23 +1,16 @@
-import { JsonValue, JsonObject } from './types.js';
-import './contracts/workflow-runtime.contract.js';
-import './contracts/lens-workflow.contract.js';
-import './contracts/lens-filter.contract.js';
-
-/** Tenant and workspace identifiers used to scope gateway requests. */
-type GatewayScope = {
+import type { JsonObject, JsonValue } from "./types";
+export type GatewayScope = {
     tenantId?: string;
     workspaceId?: string;
 };
-/** Successful response envelope from the platform gateway with correlation metadata. */
-type PlatformGatewaySuccess<T> = {
+export type PlatformGatewaySuccess<T> = {
     success: true;
     data: T;
     correlationId: string;
     policyTraceId: string | null;
     idempotentReplay: boolean;
 };
-/** Failed response envelope with structured error codes and optional invariant references. */
-type PlatformGatewayFailure = {
+export type PlatformGatewayFailure = {
     success: false;
     /**
      * Error string is the canonical envelope field.
@@ -40,15 +33,8 @@ type PlatformGatewayFailure = {
     correlationId: string;
     policyTraceId: string | null;
 };
-/** Discriminated union of success and failure gateway responses. */
-type PlatformGatewayEnvelope<T> = PlatformGatewaySuccess<T> | PlatformGatewayFailure;
-/**
- * Structured error thrown when a platform API request fails.
- *
- * Includes HTTP status, machine-readable error code, optional invariant
- * reference, and actionable suggestions for common failure modes.
- */
-declare class LucernApiError extends Error {
+export type PlatformGatewayEnvelope<T> = PlatformGatewaySuccess<T> | PlatformGatewayFailure;
+export declare class LucernApiError extends Error {
     readonly code: string;
     readonly status: number;
     readonly invariant?: string | null;
@@ -69,11 +55,9 @@ declare class LucernApiError extends Error {
         policyTraceId?: string | null;
     });
 }
-/** Supported HTTP methods for gateway requests. */
-type GatewayHttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+export type GatewayHttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
 type FetchLike = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
-/** Context passed to the `onRequest` hook before each gateway request attempt. */
-type GatewayRequestHookContext = {
+export type GatewayRequestHookContext = {
     requestId: string;
     attempt: number;
     maxRetries: number;
@@ -84,8 +68,7 @@ type GatewayRequestHookContext = {
     body?: string;
     timeoutMs: number;
 };
-/** Context passed to the `onResponse` hook after each gateway request attempt (including retries and failures). */
-type GatewayResponseHookContext = GatewayRequestHookContext & {
+export type GatewayResponseHookContext = GatewayRequestHookContext & {
     durationMs: number;
     status?: number;
     response?: Response;
@@ -96,13 +79,7 @@ type GatewayResponseHookContext = GatewayRequestHookContext & {
     retryAfterMs?: number | null;
     willRetry: boolean;
 };
-/**
- * Low-level transport configuration for the platform gateway client.
- *
- * Most developers should use {@link createLucernClient} instead, which wraps
- * this config with higher-level conveniences like `apiKey` and `environment`.
- */
-type GatewayClientConfig = {
+export type GatewayClientConfig = {
     baseUrl?: string;
     fetchImpl?: FetchLike;
     getAuthHeaders?: (() => Promise<Record<string, string>>) | (() => Record<string, string>);
@@ -122,15 +99,15 @@ type GatewayClientConfig = {
 /**
  * Serialize a gateway query object into a URL query string.
  */
-declare function toQueryString(scope: GatewayScope & Record<string, string | number | boolean | undefined>): string;
+export declare function toQueryString(scope: GatewayScope & Record<string, string | number | boolean | undefined>): string;
 /**
  * Generate a random idempotency key for retry-safe writes.
  */
-declare function randomIdempotencyKey(): string;
+export declare function randomIdempotencyKey(): string;
 /**
  * Create the transport client used by all SDK modules.
  */
-declare function createGatewayRequestClient(config?: GatewayClientConfig): {
+export declare function createGatewayRequestClient(config?: GatewayClientConfig): {
     request: <T>(args: {
         path: string;
         method?: GatewayHttpMethod;
@@ -140,5 +117,4 @@ declare function createGatewayRequestClient(config?: GatewayClientConfig): {
         timeoutMs?: number;
     }) => Promise<PlatformGatewaySuccess<T>>;
 };
-
-export { type GatewayClientConfig, type GatewayHttpMethod, type GatewayRequestHookContext, type GatewayResponseHookContext, type GatewayScope, LucernApiError, type PlatformGatewayEnvelope, type PlatformGatewayFailure, type PlatformGatewaySuccess, createGatewayRequestClient, randomIdempotencyKey, toQueryString };
+export {};

package/dist/packages/sdk/src/customTools.d.ts

@@ -0,0 +1,65 @@
+import { z } from "zod";
+import type { McpToolContract } from "@lucern/contracts/mcp-tools.contract";
+import type { JsonObject } from "./types";
+type AnyZodObject = z.ZodObject<z.ZodRawShape>;
+export type CustomToolInvocationSource = "sdk" | "mcp";
+export type CustomToolInvocationContext = {
+    source: CustomToolInvocationSource;
+};
+export type CustomToolMetadata = {
+    category?: string;
+    tags?: string[];
+    requiredScopes?: string[];
+};
+export type CustomToolRegistration<TInput extends AnyZodObject = AnyZodObject, TOutput extends z.ZodTypeAny = z.ZodTypeAny> = {
+    namespace?: string;
+    name: string;
+    description: string;
+    inputSchema: TInput;
+    outputSchema: TOutput;
+    handler: (input: z.infer<TInput>, context: CustomToolInvocationContext) => Promise<z.infer<TOutput>> | z.infer<TOutput>;
+    metadata?: CustomToolMetadata;
+    ownerModule?: string;
+    ontologyPrimitive?: McpToolContract["ontologyPrimitive"];
+    tier?: McpToolContract["tier"];
+};
+export type RegisteredCustomTool = {
+    fullName: string;
+    namespace: string;
+    shortName: string;
+    metadata: CustomToolMetadata;
+    contract: McpToolContract;
+    inputSchema: AnyZodObject;
+    outputSchema: z.ZodTypeAny;
+    invoke: (input: JsonObject, context: CustomToolInvocationContext) => Promise<unknown>;
+};
+export declare class CustomToolRegistryError extends Error {
+    constructor(message: string);
+}
+/**
+ * Register a custom SDK tool in the in-memory registry.
+ */
+export declare function registerCustomTool<TInput extends AnyZodObject, TOutput extends z.ZodTypeAny>(registration: CustomToolRegistration<TInput, TOutput>, options?: {
+    replace?: boolean;
+}): RegisteredCustomTool;
+/**
+ * Remove a custom SDK tool from the registry.
+ */
+export declare function unregisterCustomTool(fullName: string): boolean;
+/**
+ * Get a custom SDK tool by fully qualified name.
+ */
+export declare function getRegisteredCustomTool(fullName: string): RegisteredCustomTool | undefined;
+/**
+ * List all registered custom SDK tools.
+ */
+export declare function listRegisteredCustomTools(): RegisteredCustomTool[];
+/**
+ * Clear the registered custom tool registry.
+ */
+export declare function clearRegisteredCustomTools(): void;
+/**
+ * Invoke a registered custom SDK tool.
+ */
+export declare function invokeRegisteredCustomTool(fullName: string, params: JsonObject, context: CustomToolInvocationContext): Promise<unknown>;
+export {};

package/dist/packages/sdk/src/decisionsClient.d.ts

@@ -0,0 +1,97 @@
+import { type GatewayClientConfig, LucernApiError } from "./coreClient";
+import type { GetJudgmentResponse, JudgmentCalibrationResponse, JudgmentReadinessResponse, JudgmentTransitionAuditIntegrityResponse, ListJudgmentsResponse, PendingJudgmentOutcomeRecord, RecordJudgmentOutcomeResponse, RecordJudgmentResponse, TopicIdentifierInput } from "./types";
+export { LucernApiError };
+export type { PlatformGatewaySuccess } from "./coreClient";
+export type { GetJudgmentResponse, JudgmentCalibrationResponse, JudgmentReadinessResponse, JudgmentTransitionAuditIntegrityResponse, ListJudgmentsResponse, PendingJudgmentOutcomeReviewResponse, RecordJudgmentOutcomeResponse, RecordJudgmentResponse, } from "./types";
+export type DecisionsClientConfig = GatewayClientConfig;
+export type RecordJudgmentInput = {
+    title: string;
+    summary?: string;
+    rationale: string;
+    topicId?: string;
+    confidence?: number;
+    decisionConfidence?: number;
+    judgmentType?: string;
+    decisionType?: string;
+    beliefIds?: string[];
+    keyUncertainties?: string[];
+    alternativesConsidered?: string[];
+    decisionMakers?: string[];
+    companyId?: string;
+    amount?: number;
+    valuation?: number;
+    terms?: string;
+    themeIds?: string[];
+} & TopicIdentifierInput;
+export type ListJudgmentsInput = {
+    topicId?: string;
+    includeArchived?: boolean;
+    limit?: number;
+} & TopicIdentifierInput;
+export type RecordJudgmentOutcomeInput = {
+    outcome: "pending" | "successful" | "unsuccessful" | "mixed" | "unknown" | "too_early";
+    outcomeNotes?: string;
+    notes?: string;
+};
+export type GetJudgmentCalibrationInput = {
+    topicId?: string;
+} & TopicIdentifierInput;
+export type ListPendingJudgmentOutcomeReviewInput = {
+    topicId?: string;
+} & TopicIdentifierInput;
+export type GetJudgmentTransitionAuditIntegrityInput = {
+    topicId?: string;
+    judgmentId?: string;
+    includePassing?: boolean;
+} & TopicIdentifierInput;
+/**
+ * Create the judgments client for decision lifecycle operations.
+ */
+export declare function createDecisionsClient(config?: DecisionsClientConfig): {
+    /**
+     * List judgments for a topic scope.
+     */
+    listJudgments(query: ListJudgmentsInput): Promise<import("./coreClient").PlatformGatewaySuccess<ListJudgmentsResponse>>;
+    /**
+     * Get a single judgment by identifier.
+     */
+    getJudgment(judgmentId: string): Promise<import("./coreClient").PlatformGatewaySuccess<GetJudgmentResponse>>;
+    /**
+     * Get readiness signals for creating a judgment.
+     */
+    getJudgmentReadiness(query: {
+        topicId?: string;
+    } & TopicIdentifierInput): Promise<import("./coreClient").PlatformGatewaySuccess<JudgmentReadinessResponse>>;
+    /**
+     * Get calibration analytics for judgment outcomes.
+     */
+    getJudgmentCalibration(query: GetJudgmentCalibrationInput): Promise<import("./coreClient").PlatformGatewaySuccess<JudgmentCalibrationResponse>>;
+    /**
+     * List judgments still awaiting outcome review.
+     */
+    listPendingOutcomeReviews(query: ListPendingJudgmentOutcomeReviewInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<PendingJudgmentOutcomeRecord, "reviews">>>;
+    /**
+     * @deprecated Use listPendingOutcomeReviews.
+     */
+    listPendingJudgmentOutcomeReview(query: ListPendingJudgmentOutcomeReviewInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<PendingJudgmentOutcomeRecord, "reviews">>>;
+    /**
+     * Get audit integrity checks for judgment transitions.
+     */
+    getJudgmentTransitionAuditIntegrity(query: GetJudgmentTransitionAuditIntegrityInput): Promise<import("./coreClient").PlatformGatewaySuccess<JudgmentTransitionAuditIntegrityResponse>>;
+    /**
+     * Create a judgment.
+     */
+    createJudgment(input: RecordJudgmentInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<RecordJudgmentResponse>>;
+    /**
+     * @deprecated Use createJudgment.
+     */
+    recordJudgment(input: RecordJudgmentInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<RecordJudgmentResponse>>;
+    /**
+     * Update the outcome for an existing judgment.
+     */
+    updateJudgmentOutcome(judgmentId: string, input: RecordJudgmentOutcomeInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<RecordJudgmentOutcomeResponse>>;
+    /**
+     * @deprecated Use updateJudgmentOutcome.
+     */
+    recordJudgmentOutcome(judgmentId: string, input: RecordJudgmentOutcomeInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<RecordJudgmentOutcomeResponse>>;
+};

package/dist/packages/sdk/src/graphClient.d.ts

@@ -0,0 +1,191 @@
+import { type GatewayClientConfig, LucernApiError } from "./coreClient";
+import type { DeleteEdgeResponse, GraphAnalyticsMetric, GraphAnalyticsResponse, GraphNeighborhoodResponse, GraphPathResponse, JsonObject, ListResult, PlatformGraphEdge, PlatformGraphNode, TextAliasInput, TopicIdentifierInput } from "./types";
+export { LucernApiError };
+export type { GatewayScope, PlatformGatewaySuccess } from "./coreClient";
+export type { CreateEdgeResponse, CreateNodeResponse, DeleteEdgeResponse, GraphAnalyticsMetric, GraphAnalyticsResponse, GraphNeighborhoodResponse, GraphPathResponse, ListResult, QueryEdgesResponse, QueryNodesResponse, UpdateNodeResponse, } from "./types";
+export type GraphClientConfig = GatewayClientConfig;
+export type ListNodesInput = {
+    nodeId?: string;
+    globalId?: string;
+    topicId?: string;
+    nodeType?: string;
+    limit?: number;
+} & TopicIdentifierInput;
+export type ListNodesResponse = ListResult<PlatformGraphNode, "nodes">;
+export type QueryNodesInput = ListNodesInput;
+export type CreateNodeInput = {
+    text?: string;
+    /** @deprecated Use text. */
+    canonicalText?: string;
+    nodeType: string;
+    topicId?: string;
+    content?: string;
+    contentHash?: string;
+    globalId?: string;
+    sourceType?: string;
+    subtype?: string;
+    title?: string;
+    confidence?: number;
+    status?: string;
+    tags?: string[];
+    metadata?: JsonObject;
+    verificationStatus?: string;
+} & TextAliasInput & TopicIdentifierInput;
+export type UpdateNodeInput = {
+    nodeId: string;
+    text?: string;
+    canonicalText?: string;
+    content?: string;
+    contentHash?: string;
+    title?: string;
+    subtype?: string;
+    confidence?: number;
+    status?: string;
+    tags?: string[];
+    metadata?: JsonObject;
+    verificationStatus?: string;
+} & TextAliasInput;
+export type ListEdgesInput = {
+    edgeId?: string;
+    topicId?: string;
+    fromNodeId?: string;
+    toNodeId?: string;
+    edgeType?: string;
+    limit?: number;
+} & TopicIdentifierInput;
+export type ListEdgesResponse = ListResult<PlatformGraphEdge, "edges">;
+export type QueryEdgesInput = ListEdgesInput;
+export type CreateEdgeInput = {
+    fromNodeId: string;
+    toNodeId: string;
+    edgeType: string;
+    globalId?: string;
+    topicId?: string;
+    confidence?: number;
+    weight?: number;
+    context?: string;
+    derivationType?: string;
+} & TopicIdentifierInput;
+export type DeleteEdgeInput = {
+    edgeId?: string;
+    fromNodeId?: string;
+    toNodeId?: string;
+    edgeType?: string;
+};
+export type NeighborhoodInput = {
+    globalId?: string;
+    globalIds?: string;
+    maxDepth?: number;
+};
+export type PathInput = {
+    fromGlobalId: string;
+    toGlobalId: string;
+    maxDepth?: number;
+};
+export type AnalyticsInput = {
+    metric?: GraphAnalyticsMetric;
+    limit?: number;
+};
+export type TraverseInput = {
+    startNode: string;
+    direction?: string;
+    maxDepth?: number;
+    topicId?: string;
+} & TopicIdentifierInput;
+export type AnalyzeInput = {
+    topicId?: string;
+    metric?: GraphAnalyticsMetric;
+    limit?: number;
+} & TopicIdentifierInput;
+export type BiasInput = {
+    topicId?: string;
+    threshold?: number;
+    limit?: number;
+} & TopicIdentifierInput;
+export type GapsInput = {
+    topicId?: string;
+    minConfidence?: number;
+} & TopicIdentifierInput;
+export type SearchInput = {
+    q?: string;
+    query?: string;
+    topicId?: string;
+    types?: string[];
+    status?: string;
+    minConfidence?: number;
+    limit?: number;
+    cursor?: string;
+} & TopicIdentifierInput;
+/**
+ * Create the low-level graph client for nodes, edges, and graph analytics.
+ */
+export declare function createGraphClient(config?: GraphClientConfig): {
+    /**
+     * List graph nodes matching the provided filters.
+     */
+    listNodes(query: ListNodesInput): Promise<import("./coreClient").PlatformGatewaySuccess<ListResult<PlatformGraphNode, "nodes">>>;
+    /**
+     * @deprecated Use listNodes.
+     */
+    queryNodes(query: QueryNodesInput): Promise<import("./coreClient").PlatformGatewaySuccess<ListResult<PlatformGraphNode, "nodes">>>;
+    /**
+     * Create a graph node.
+     */
+    createNode(input: CreateNodeInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<PlatformGraphNode>>;
+    /**
+     * Update a graph node.
+     */
+    updateNode(input: UpdateNodeInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<PlatformGraphNode>>;
+    /**
+     * List graph edges matching the provided filters.
+     */
+    listEdges(query: ListEdgesInput): Promise<import("./coreClient").PlatformGatewaySuccess<ListResult<PlatformGraphEdge, "edges">>>;
+    /**
+     * @deprecated Use listEdges.
+     */
+    queryEdges(query: QueryEdgesInput): Promise<import("./coreClient").PlatformGatewaySuccess<ListResult<PlatformGraphEdge, "edges">>>;
+    /**
+     * Create a graph edge.
+     */
+    createEdge(input: CreateEdgeInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<PlatformGraphEdge>>;
+    /**
+     * Delete one or more edges matching the provided filter.
+     */
+    deleteEdge(query: DeleteEdgeInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<DeleteEdgeResponse>>;
+    /**
+     * Retrieve a graph neighborhood around a root node.
+     */
+    neighborhood(query: NeighborhoodInput): Promise<import("./coreClient").PlatformGatewaySuccess<GraphNeighborhoodResponse>>;
+    /**
+     * Traverse the graph from a starting node.
+     */
+    traverse(query: TraverseInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
+    /**
+     * Analyze graph structure for a topic.
+     */
+    analyze(query?: AnalyzeInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
+    /**
+     * Detect confirmation-bias patterns for a topic graph.
+     */
+    bias(query?: BiasInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
+    /**
+     * Find graph gaps for beliefs that still need testing.
+     */
+    gaps(query: GapsInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
+    /**
+     * Search across graph resources within a topic.
+     */
+    search(query: SearchInput): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
+    /**
+     * Retrieve a graph neighborhood around a root node.
+     */
+    getNeighborhood(query: NeighborhoodInput): Promise<import("./coreClient").PlatformGatewaySuccess<GraphNeighborhoodResponse>>;
+    /**
+     * Retrieve the shortest known path between two graph nodes.
+     */
+    getPath(query: PathInput): Promise<import("./coreClient").PlatformGatewaySuccess<GraphPathResponse>>;
+    /**
+     * Retrieve graph analytics for the requested metric.
+     */
+    getAnalytics(query?: AnalyticsInput): Promise<import("./coreClient").PlatformGatewaySuccess<GraphAnalyticsResponse>>;
+};