@lucern/sdk 0.2.0-alpha.1

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/packages/sdk/src/controlObjectOwnership.d.ts

@@ -0,0 +1,293 @@
+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;
+    canonicalOwnerScope: ControlObjectOwnerScope;
+    editSurface: ControlObjectEditSurface;
+    inheritanceRule: ControlObjectInheritanceRule;
+    blastRadius: ControlObjectBlastRadius;
+};
+export type ControlObjectOwnershipMatrix = Record<ControlObjectKind, readonly ControlObjectOwnershipCase[]>;
+export type ControlObjectOwnershipContract = {
+    version: "1.0.0";
+    kinds: readonly ControlObjectKind[];
+    ownerScopes: readonly ControlObjectOwnerScope[];
+    editSurfaces: readonly ControlObjectEditSurface[];
+    inheritanceRules: readonly ControlObjectInheritanceRule[];
+    blastRadii: readonly ControlObjectBlastRadius[];
+    matrix: ControlObjectOwnershipMatrix;
+    rows: readonly ControlObjectOwnershipCase[];
+};
+export declare const CONTROL_OBJECT_OWNERSHIP_MATRIX: {
+    readonly tenant: readonly [{
+        readonly caseKey: "platform-record";
+        readonly caseLabel: "Platform Record";
+        readonly kind: "tenant";
+        readonly canonicalOwnerScope: "platform";
+        readonly editSurface: "platform_admin";
+        readonly inheritanceRule: "none";
+        readonly blastRadius: "tenant";
+    }];
+    readonly workspace: readonly [{
+        readonly caseKey: "tenant-workspace";
+        readonly caseLabel: "Tenant Workspace";
+        readonly kind: "workspace";
+        readonly canonicalOwnerScope: "tenant";
+        readonly editSurface: "tenant_admin";
+        readonly inheritanceRule: "tenant_default_to_workspace";
+        readonly blastRadius: "workspace";
+    }];
+    readonly principal: readonly [{
+        readonly caseKey: "tenant-principal";
+        readonly caseLabel: "Tenant Principal";
+        readonly kind: "principal";
+        readonly canonicalOwnerScope: "tenant";
+        readonly editSurface: "tenant_admin";
+        readonly inheritanceRule: "workspace_narrowing_only";
+        readonly blastRadius: "resource";
+    }];
+    readonly tool: readonly [{
+        readonly caseKey: "platform-core";
+        readonly caseLabel: "Platform Core";
+        readonly kind: "tool";
+        readonly canonicalOwnerScope: "platform";
+        readonly editSurface: "platform_admin";
+        readonly inheritanceRule: "platform_seed_to_tenant";
+        readonly blastRadius: "platform";
+    }, {
+        readonly caseKey: "tenant-custom";
+        readonly caseLabel: "Tenant Custom";
+        readonly kind: "tool";
+        readonly canonicalOwnerScope: "tenant";
+        readonly editSurface: "tenant_admin";
+        readonly inheritanceRule: "tenant_default_to_workspace";
+        readonly blastRadius: "tenant";
+    }];
+    readonly pack: readonly [{
+        readonly caseKey: "platform-definition";
+        readonly caseLabel: "Platform Definition";
+        readonly kind: "pack";
+        readonly canonicalOwnerScope: "platform";
+        readonly editSurface: "platform_admin";
+        readonly inheritanceRule: "platform_seed_to_tenant";
+        readonly blastRadius: "platform";
+    }, {
+        readonly caseKey: "tenant-installation";
+        readonly caseLabel: "Tenant Installation";
+        readonly kind: "pack";
+        readonly canonicalOwnerScope: "tenant";
+        readonly editSurface: "tenant_admin";
+        readonly inheritanceRule: "platform_seed_to_tenant";
+        readonly blastRadius: "tenant";
+    }];
+    readonly ontology: readonly [{
+        readonly caseKey: "platform-base";
+        readonly caseLabel: "Platform Base";
+        readonly kind: "ontology";
+        readonly canonicalOwnerScope: "platform";
+        readonly editSurface: "platform_admin";
+        readonly inheritanceRule: "platform_seed_to_tenant";
+        readonly blastRadius: "platform";
+    }, {
+        readonly caseKey: "pack-overlay";
+        readonly caseLabel: "Pack Overlay";
+        readonly kind: "ontology";
+        readonly canonicalOwnerScope: "platform";
+        readonly editSurface: "platform_admin";
+        readonly inheritanceRule: "pack_overlay_to_tenant";
+        readonly blastRadius: "platform";
+    }, {
+        readonly caseKey: "tenant-extension";
+        readonly caseLabel: "Tenant Extension";
+        readonly kind: "ontology";
+        readonly canonicalOwnerScope: "tenant";
+        readonly editSurface: "tenant_admin";
+        readonly inheritanceRule: "topic_lineage_to_resource";
+        readonly blastRadius: "tenant";
+    }];
+    readonly belief: readonly [{
+        readonly caseKey: "topic-resource";
+        readonly caseLabel: "Topic Resource";
+        readonly kind: "belief";
+        readonly canonicalOwnerScope: "resource";
+        readonly editSurface: "graph_worktree";
+        readonly inheritanceRule: "topic_lineage_to_resource";
+        readonly blastRadius: "resource";
+    }];
+    readonly policy_rule: readonly [{
+        readonly caseKey: "platform-baseline";
+        readonly caseLabel: "Platform Baseline";
+        readonly kind: "policy_rule";
+        readonly canonicalOwnerScope: "platform";
+        readonly editSurface: "platform_admin";
+        readonly inheritanceRule: "platform_seed_to_tenant";
+        readonly blastRadius: "platform";
+    }, {
+        readonly caseKey: "tenant-bundle";
+        readonly caseLabel: "Tenant Bundle";
+        readonly kind: "policy_rule";
+        readonly canonicalOwnerScope: "tenant";
+        readonly editSurface: "tenant_admin";
+        readonly inheritanceRule: "tenant_default_to_workspace";
+        readonly blastRadius: "tenant";
+    }, {
+        readonly caseKey: "workspace-override";
+        readonly caseLabel: "Workspace Override";
+        readonly kind: "policy_rule";
+        readonly canonicalOwnerScope: "workspace";
+        readonly editSurface: "workspace_admin";
+        readonly inheritanceRule: "none";
+        readonly blastRadius: "workspace";
+    }];
+};
+export declare const CONTROL_OBJECT_OWNERSHIP_ROWS: readonly ControlObjectOwnershipCase[];
+/** The canonical ownership contract exposed by the SDK. */
+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"];
+    readonly editSurfaces: readonly ["platform_admin", "tenant_admin", "workspace_admin", "graph_worktree"];
+    readonly inheritanceRules: readonly ["none", "platform_seed_to_tenant", "tenant_default_to_workspace", "workspace_narrowing_only", "pack_overlay_to_tenant", "topic_lineage_to_resource"];
+    readonly blastRadii: readonly ["platform", "tenant", "workspace", "resource"];
+    readonly matrix: {
+        readonly tenant: readonly [{
+            readonly caseKey: "platform-record";
+            readonly caseLabel: "Platform Record";
+            readonly kind: "tenant";
+            readonly canonicalOwnerScope: "platform";
+            readonly editSurface: "platform_admin";
+            readonly inheritanceRule: "none";
+            readonly blastRadius: "tenant";
+        }];
+        readonly workspace: readonly [{
+            readonly caseKey: "tenant-workspace";
+            readonly caseLabel: "Tenant Workspace";
+            readonly kind: "workspace";
+            readonly canonicalOwnerScope: "tenant";
+            readonly editSurface: "tenant_admin";
+            readonly inheritanceRule: "tenant_default_to_workspace";
+            readonly blastRadius: "workspace";
+        }];
+        readonly principal: readonly [{
+            readonly caseKey: "tenant-principal";
+            readonly caseLabel: "Tenant Principal";
+            readonly kind: "principal";
+            readonly canonicalOwnerScope: "tenant";
+            readonly editSurface: "tenant_admin";
+            readonly inheritanceRule: "workspace_narrowing_only";
+            readonly blastRadius: "resource";
+        }];
+        readonly tool: readonly [{
+            readonly caseKey: "platform-core";
+            readonly caseLabel: "Platform Core";
+            readonly kind: "tool";
+            readonly canonicalOwnerScope: "platform";
+            readonly editSurface: "platform_admin";
+            readonly inheritanceRule: "platform_seed_to_tenant";
+            readonly blastRadius: "platform";
+        }, {
+            readonly caseKey: "tenant-custom";
+            readonly caseLabel: "Tenant Custom";
+            readonly kind: "tool";
+            readonly canonicalOwnerScope: "tenant";
+            readonly editSurface: "tenant_admin";
+            readonly inheritanceRule: "tenant_default_to_workspace";
+            readonly blastRadius: "tenant";
+        }];
+        readonly pack: readonly [{
+            readonly caseKey: "platform-definition";
+            readonly caseLabel: "Platform Definition";
+            readonly kind: "pack";
+            readonly canonicalOwnerScope: "platform";
+            readonly editSurface: "platform_admin";
+            readonly inheritanceRule: "platform_seed_to_tenant";
+            readonly blastRadius: "platform";
+        }, {
+            readonly caseKey: "tenant-installation";
+            readonly caseLabel: "Tenant Installation";
+            readonly kind: "pack";
+            readonly canonicalOwnerScope: "tenant";
+            readonly editSurface: "tenant_admin";
+            readonly inheritanceRule: "platform_seed_to_tenant";
+            readonly blastRadius: "tenant";
+        }];
+        readonly ontology: readonly [{
+            readonly caseKey: "platform-base";
+            readonly caseLabel: "Platform Base";
+            readonly kind: "ontology";
+            readonly canonicalOwnerScope: "platform";
+            readonly editSurface: "platform_admin";
+            readonly inheritanceRule: "platform_seed_to_tenant";
+            readonly blastRadius: "platform";
+        }, {
+            readonly caseKey: "pack-overlay";
+            readonly caseLabel: "Pack Overlay";
+            readonly kind: "ontology";
+            readonly canonicalOwnerScope: "platform";
+            readonly editSurface: "platform_admin";
+            readonly inheritanceRule: "pack_overlay_to_tenant";
+            readonly blastRadius: "platform";
+        }, {
+            readonly caseKey: "tenant-extension";
+            readonly caseLabel: "Tenant Extension";
+            readonly kind: "ontology";
+            readonly canonicalOwnerScope: "tenant";
+            readonly editSurface: "tenant_admin";
+            readonly inheritanceRule: "topic_lineage_to_resource";
+            readonly blastRadius: "tenant";
+        }];
+        readonly belief: readonly [{
+            readonly caseKey: "topic-resource";
+            readonly caseLabel: "Topic Resource";
+            readonly kind: "belief";
+            readonly canonicalOwnerScope: "resource";
+            readonly editSurface: "graph_worktree";
+            readonly inheritanceRule: "topic_lineage_to_resource";
+            readonly blastRadius: "resource";
+        }];
+        readonly policy_rule: readonly [{
+            readonly caseKey: "platform-baseline";
+            readonly caseLabel: "Platform Baseline";
+            readonly kind: "policy_rule";
+            readonly canonicalOwnerScope: "platform";
+            readonly editSurface: "platform_admin";
+            readonly inheritanceRule: "platform_seed_to_tenant";
+            readonly blastRadius: "platform";
+        }, {
+            readonly caseKey: "tenant-bundle";
+            readonly caseLabel: "Tenant Bundle";
+            readonly kind: "policy_rule";
+            readonly canonicalOwnerScope: "tenant";
+            readonly editSurface: "tenant_admin";
+            readonly inheritanceRule: "tenant_default_to_workspace";
+            readonly blastRadius: "tenant";
+        }, {
+            readonly caseKey: "workspace-override";
+            readonly caseLabel: "Workspace Override";
+            readonly kind: "policy_rule";
+            readonly canonicalOwnerScope: "workspace";
+            readonly editSurface: "workspace_admin";
+            readonly inheritanceRule: "none";
+            readonly blastRadius: "workspace";
+        }];
+    };
+    readonly rows: readonly ControlObjectOwnershipCase[];
+};
+/**
+ * List ownership cases for one control-object kind or the full matrix.
+ */
+export declare function listControlObjectOwnershipCases(kind?: ControlObjectKind): readonly ControlObjectOwnershipCase[];
+/**
+ * Get a specific ownership case by kind and case key.
+ */
+export declare function getControlObjectOwnershipCase(kind: ControlObjectKind, caseKey: string): ControlObjectOwnershipCase | undefined;

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

@@ -0,0 +1,120 @@
+import type { JsonObject, JsonValue } from "./types";
+export type GatewayScope = {
+    tenantId?: string;
+    workspaceId?: string;
+};
+export type PlatformGatewaySuccess<T> = {
+    success: true;
+    data: T;
+    correlationId: string;
+    policyTraceId: string | null;
+    idempotentReplay: boolean;
+};
+export type PlatformGatewayFailure = {
+    success: false;
+    /**
+     * Error string is the canonical envelope field.
+     * Object form is legacy-only compatibility for older gateway responses.
+     */
+    error: string | {
+        code: string;
+        message: string;
+        details?: JsonValue;
+    };
+    code?: string;
+    invariant?: string | null;
+    suggestion?: string | null;
+    details?: JsonValue;
+    legacyError?: {
+        code: string;
+        message: string;
+        details?: JsonValue;
+    };
+    correlationId: string;
+    policyTraceId: string | null;
+};
+export type PlatformGatewayEnvelope<T> = PlatformGatewaySuccess<T> | PlatformGatewayFailure;
+export declare class LucernApiError extends Error {
+    readonly code: string;
+    readonly status: number;
+    readonly invariant?: string | null;
+    readonly suggestion?: string | null;
+    readonly details?: JsonValue;
+    readonly requestId?: string;
+    readonly correlationId?: string;
+    readonly policyTraceId?: string | null;
+    constructor(args: {
+        code: string;
+        message: string;
+        status: number;
+        invariant?: string | null;
+        suggestion?: string | null;
+        details?: JsonValue;
+        requestId?: string;
+        correlationId?: string;
+        policyTraceId?: string | null;
+    });
+}
+export type GatewayHttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+type FetchLike = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+export type GatewayRequestHookContext = {
+    requestId: string;
+    attempt: number;
+    maxRetries: number;
+    method: GatewayHttpMethod;
+    path: string;
+    url: string;
+    headers: Headers;
+    body?: string;
+    timeoutMs: number;
+};
+export type GatewayResponseHookContext = GatewayRequestHookContext & {
+    durationMs: number;
+    status?: number;
+    response?: Response;
+    error?: unknown;
+    correlationId?: string;
+    policyTraceId?: string | null;
+    idempotentReplay?: boolean;
+    retryAfterMs?: number | null;
+    willRetry: boolean;
+};
+export type GatewayClientConfig = {
+    baseUrl?: string;
+    fetchImpl?: FetchLike;
+    getAuthHeaders?: (() => Promise<Record<string, string>>) | (() => Record<string, string>);
+    /** Max retries for transient errors (5xx, network). Defaults to 2. */
+    maxRetries?: number;
+    /** Request timeout in ms. Defaults to 15000. */
+    timeoutMs?: number;
+    /** Optional timeout overrides by HTTP method. */
+    timeoutMsByMethod?: Partial<Record<GatewayHttpMethod, number>>;
+    /** Optional request ID factory used for correlation headers. */
+    requestIdFactory?: () => string;
+    /** Invoked before each request attempt, including retries. */
+    onRequest?: ((context: GatewayRequestHookContext) => void) | ((context: GatewayRequestHookContext) => Promise<void>);
+    /** Invoked after each request attempt, including retries and failures. */
+    onResponse?: ((context: GatewayResponseHookContext) => void) | ((context: GatewayResponseHookContext) => Promise<void>);
+};
+/**
+ * Serialize a gateway query object into a URL query string.
+ */
+export declare function toQueryString(scope: GatewayScope & Record<string, string | number | boolean | undefined>): string;
+/**
+ * Generate a random idempotency key for retry-safe writes.
+ */
+export declare function randomIdempotencyKey(): string;
+/**
+ * Create the transport client used by all SDK modules.
+ */
+export declare function createGatewayRequestClient(config?: GatewayClientConfig): {
+    request: <T>(args: {
+        path: string;
+        method?: GatewayHttpMethod;
+        body?: JsonObject;
+        idempotencyKey?: string;
+        requestId?: string;
+        timeoutMs?: number;
+    }) => Promise<PlatformGatewaySuccess<T>>;
+};
+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,110 @@
+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;
+    /** @deprecated Use topicId. */
+    projectId?: string;
+    confidence?: number;
+    decisionConfidence?: number;
+    judgmentType?: string;
+    decisionType?: string;
+    beliefIds?: string[];
+    keyUncertainties?: string[];
+    alternativesConsidered?: string[];
+    decisionMakers?: string[];
+    dealId?: string;
+    companyId?: string;
+    amount?: number;
+    valuation?: number;
+    terms?: string;
+    themeIds?: string[];
+} & TopicIdentifierInput;
+export type ListJudgmentsInput = {
+    topicId?: string;
+    /** @deprecated Use topicId. */
+    projectId?: 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;
+    /** @deprecated Use topicId. */
+    projectId?: string;
+} & TopicIdentifierInput;
+export type ListPendingJudgmentOutcomeReviewInput = {
+    topicId?: string;
+    /** @deprecated Use topicId. */
+    projectId?: string;
+} & TopicIdentifierInput;
+export type GetJudgmentTransitionAuditIntegrityInput = {
+    topicId?: string;
+    /** @deprecated Use topicId. */
+    projectId?: 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;
+        /** @deprecated Use topicId. */
+        projectId?: 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>>;
+};