@lucern/contracts 0.1.0-alpha.3 → 0.1.1-alpha.1

package/dist/index.d.ts

@@ -1,30 +1,2004 @@
 /**
- * Lucern Platform Contracts
- *
- * Machine-readable source of truth for all external API surfaces.
- * Enforcement hierarchy: MCP/API (co-equal) → SDK (derived) → Schema (internal).
- *
- * These contracts are consumed by:
- *   - MCP tool registration (learning-loop module)
- *   - API route validation (platform gateway)
- *   - SDK type generation (@lucern/sdk-* packages)
- *   - Contract lint gates (CI)
- */
-export * from "./api-enums.contract";
-export * from "./auth-session.contract";
-export * from "./auth-context.contract";
-export * from "./convex-admin.contract";
-export * from "./gateway.contract";
-export * from "./context-pack.contract";
-export * from "./events.contract";
-export * from "./events-types.contract";
-export * from "./ids.contract";
-export * as mcpToolsContract from "./mcp-tools.contract";
-export * from "./ontology-matching.contract";
-export * from "./prompt.contract";
-export * from "./sdk-methods.contract";
-export * as sdkToolsContract from "./sdk-tools.contract";
-export * from "./text-matching.contract";
-export * from "./topic-scope.contract";
-export * from "./workflow-runtime.contract";
-//# sourceMappingURL=index.d.ts.map
+ * 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 */
+declare const FORK_REASONS: readonly ["refinement", "contradiction_response", "scope_change", "confidence_collapse", "manual"];
+type ForkReason = (typeof FORK_REASONS)[number];
+/** Confidence modulation triggers — what caused a confidence change */
+declare const CONFIDENCE_TRIGGERS: readonly ["evidence_added", "contradiction_detected", "merge_outcome", "manual", "decay"];
+type ConfidenceTrigger = (typeof CONFIDENCE_TRIGGERS)[number];
+/** Belief status — lifecycle state */
+declare const BELIEF_STATUSES: readonly ["unscored", "scored", "archived"];
+type BeliefStatus = (typeof BELIEF_STATUSES)[number];
+/** Reasoning methods — how an edge relationship was determined */
+declare const REASONING_METHODS: readonly ["deductive", "inductive", "abductive", "analogical", "empirical"];
+type ReasoningMethod = (typeof REASONING_METHODS)[number];
+/** Defeat types (Pollock taxonomy) — how a contradiction operates */
+declare const DEFEAT_TYPES: readonly ["rebuts", "undercuts", "undermines"];
+type DefeatType = (typeof DEFEAT_TYPES)[number];
+/** Contradiction severity levels */
+declare const CONTRADICTION_SEVERITIES: readonly ["low", "medium", "high", "critical"];
+type ContradictionSeverity = (typeof CONTRADICTION_SEVERITIES)[number];
+/** Contradiction resolution status */
+declare const CONTRADICTION_STATUSES: readonly ["unresolved", "resolved", "accepted"];
+type ContradictionStatus = (typeof CONTRADICTION_STATUSES)[number];
+/** Merge outcome types — how a worktree merge resolved */
+declare const MERGE_OUTCOMES: readonly ["validated", "invalidated", "forked", "inconclusive"];
+type MergeOutcome = (typeof MERGE_OUTCOMES)[number];
+/** Worktree phases — investigation lifecycle within a checked-out worktree */
+declare const WORKTREE_PHASES: readonly ["hypothesis", "investigation", "evaluation", "resolution"];
+type WorktreePhase = (typeof WORKTREE_PHASES)[number];
+/** Branch status — thematic branch lifecycle */
+declare const BRANCH_STATUSES: readonly ["dormant", "active", "archived"];
+type BranchStatus = (typeof BRANCH_STATUSES)[number];
+/** Pull request status — review lifecycle before merge */
+declare const PULL_REQUEST_STATUSES: readonly ["pending_review", "changes_requested", "approved", "blocked"];
+type PullRequestStatus = (typeof PULL_REQUEST_STATUSES)[number];
+/** Epistemic layers — the hierarchy of knowledge */
+declare const EPISTEMIC_LAYERS: readonly ["L1", "L2", "L3", "L4"];
+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).
+ */
+declare const JUDGMENT_TYPES: readonly ["investment_thesis", "thesis_maturity", "contradiction_ruling", "scope_determination", "confidence_ruling"];
+type JudgmentType = (typeof JUDGMENT_TYPES)[number];
+/** Core edge types used in the Integration Surfaces */
+declare const INTEGRATION_EDGE_TYPES: readonly ["informs", "grounds", "answers", "contradicts", "supports", "depends_on", "derived_from", "contains", "supersedes", "tests"];
+type IntegrationEdgeType = (typeof INTEGRATION_EDGE_TYPES)[number];
+
+interface ConvexAdminClient {
+    query<T = unknown>(functionReference: unknown, args: Record<string, unknown>): Promise<T>;
+    mutation<T = unknown>(functionReference: unknown, args: Record<string, unknown>): Promise<T>;
+    action<T = unknown>(functionReference: unknown, args: Record<string, unknown>): Promise<T>;
+}
+
+/**
+ * @lucern/contracts — auth (canonical support contract)
+ *
+ * Consolidated flat support surface for Lucern authentication:
+ *   - Session primitives (auth modes, principal types, lifecycle)
+ *   - AuthContext shape + McpTransportKind + LucernSdkClient alias
+ *
+ * Consolidated from src/auth-session.contract.ts and src/auth-context.contract.ts
+ * in EK-16 T1 PR 3a. Compat shims remain at both old paths until Lucern 1.0.0 (D12).
+ */
+declare const SESSION_AUTH_MODES: readonly ["interactive_user", "service_principal", "tenant_api_key", "session_token"];
+type SessionAuthMode = (typeof SESSION_AUTH_MODES)[number];
+declare const SESSION_PRINCIPAL_TYPES: readonly ["human", "service", "agent"];
+type SessionPrincipalType = (typeof SESSION_PRINCIPAL_TYPES)[number];
+declare const SESSION_LIFECYCLE_STATUSES: readonly ["active", "expired", "revoked"];
+type SessionLifecycleStatus = (typeof SESSION_LIFECYCLE_STATUSES)[number];
+type SessionDelegationHop = {
+    principalId: string;
+    principalType: SessionPrincipalType;
+    authMode?: SessionAuthMode;
+    sessionId?: string;
+    delegatedAt?: number;
+    reason?: string;
+};
+type SessionAuditOutcome = "accepted" | "rejected" | "revoked" | "expired";
+type SessionAuditEnvelope = {
+    sessionId: string;
+    authMode: SessionAuthMode;
+    principalId: string;
+    principalType: SessionPrincipalType;
+    tenantId: string;
+    workspaceId?: string;
+    apiKeyId?: string;
+    scopes: readonly string[];
+    roles?: readonly string[];
+    delegationChain?: readonly SessionDelegationHop[];
+    sourceSessionId?: string;
+    expiresAt?: number;
+    request?: {
+        endpoint?: string;
+        method?: string;
+        correlationId?: string;
+    };
+    result?: {
+        outcome: SessionAuditOutcome;
+        reason?: string;
+    };
+};
+declare function inferSessionPrincipalType(principalId: string): SessionPrincipalType;
+declare function normalizeDelegationChain(args: {
+    delegationChain?: readonly SessionDelegationHop[];
+    delegatedBy?: string;
+    delegatedByType?: SessionPrincipalType;
+    delegatedAt?: number;
+    reason?: string;
+}): SessionDelegationHop[] | undefined;
+declare function lastDelegator(delegationChain?: readonly SessionDelegationHop[]): string | undefined;
+
+type McpTransportKind = "stdio" | "hosted";
+type LucernSdkClient = unknown;
+/**
+ * Session authentication context — injected by withAuth() middleware.
+ *
+ * Built from TenantConfig at dispatch time. Agent sessions get
+ * AGENT_IDENTITY + "agent:internal" role + unrestricted access.
+ * User sessions get Clerk userId + resolved role + tool ACLs.
+ */
+type AuthContext = {
+    sessionType: "agent" | "user";
+    userId: string;
+    tenantId: string;
+    role: string;
+    allowedTopics: string[] | null;
+    groupIds: string[];
+    permittedPackKeys: string[];
+    sessionId: string;
+    principalId?: string;
+    principalType?: SessionPrincipalType;
+    workspaceId?: string;
+    scopes?: string[];
+    authMode?: SessionAuthMode;
+    roles?: string[];
+    transportKind?: McpTransportKind;
+    lucernClient?: LucernSdkClient;
+    convex?: ConvexAdminClient;
+    setDefaultScopeContext?: (scopeId: string) => Promise<unknown>;
+    matchesWorkspaceReasoningScope?: (node: unknown, scope: unknown) => boolean;
+};
+
+/**
+ * Gateway contract types — shared between Stack's gateway middleware and
+ * Lucern's server-core / gateway route handlers.
+ *
+ * These types describe the authenticated request context that flows from
+ * the gateway into Lucern route handlers. The gateway (Stack-side) creates
+ * the context; Lucern consumes it read-only.
+ *
+ * @module @lucern/contracts/src/gateway
+ */
+
+type PlatformApiErrorCode = "AUTH_REQUIRED" | "AUTHENTICATION_REQUIRED" | "AUTH_TOKEN_MISSING" | "INVALID_REQUEST" | "IDEMPOTENCY_KEY_REQUIRED" | "FORBIDDEN" | "SCOPE_INSUFFICIENT" | "ENVIRONMENT_MISMATCH" | "KEY_EXPIRED" | "KEY_REVOKED" | "RATE_LIMIT_EXCEEDED" | "NOT_FOUND" | "CONFLICT" | "UPSTREAM_ERROR" | "INTERNAL_ERROR";
+type GatewayScope = {
+    tenantId?: string;
+    workspaceId?: string;
+};
+type GatewayEnvironment = "sandbox" | "production";
+type GatewayAuthMode = "interactive_user" | "service_principal" | "tenant_api_key" | "session_token";
+type KeyLifecycleStatus = "active" | "rotating" | "rotated" | "expired" | "revoked";
+type CutoverDomain = "graph" | "schema" | "identity" | "policy" | "audit" | "admin" | "agent" | "tool" | "prompt" | "intelligence";
+type CutoverFlagState = "legacy" | "cutover" | "disabled";
+/**
+ * Authenticated request context created by the gateway middleware.
+ * Lucern route handlers receive this as a read-only parameter.
+ *
+ * The `convex` field is typed as `unknown` in the contract because Lucern
+ * consumers should not use the gateway's Convex client directly — they
+ * have their own kernel client. The gateway (Stack-side) narrows this to
+ * `ConvexHttpClient` at the construction site.
+ */
+type GatewayAuthContext = {
+    userId: string;
+    convexToken?: string;
+    /** Opaque in contract — narrowed to ConvexHttpClient at the gateway. */
+    convex: any;
+    authMode: GatewayAuthMode;
+    principalId?: string;
+    principalType?: SessionPrincipalType;
+    tenantId?: string;
+    workspaceId?: string;
+    roles?: string[];
+    sessionId?: string;
+    sessionAuthMode?: SessionAuthMode;
+    sessionExpiresAt?: number;
+    delegationChain?: SessionDelegationHop[];
+    servicePrincipalId?: string;
+    servicePrincipalKeyId?: string;
+    servicePrincipalTenantId?: string;
+    servicePrincipalWorkspaceId?: string;
+    requestEnvironment: GatewayEnvironment;
+    keyEnvironment?: GatewayEnvironment;
+    keyStatus: KeyLifecycleStatus | "unknown";
+    grantedScopes: Set<string>;
+    cutoverDomain: CutoverDomain;
+    cutoverState: CutoverFlagState;
+};
+type GatewayErrorArgs = {
+    code: PlatformApiErrorCode;
+    message: string;
+    status: number;
+    correlationId: string;
+    policyTraceId?: string;
+    invariant?: string;
+    suggestion?: string;
+    details?: unknown;
+    headers?: HeadersInit;
+};
+type GatewaySuccessArgs = {
+    status?: number;
+    correlationId: string;
+    policyTraceId?: string;
+    idempotentReplay?: boolean;
+};
+declare function requireActorPrincipalId(authContext: GatewayAuthContext): string;
+
+/**
+ * Context-Pack Contract v1
+ *
+ * Canonical TypeScript types and constants for the context-pack output schema.
+ * This is the external contract consumed by:
+ *   - MCP tool `compile_context` (canonical compiler read)
+ *   - SDK/HTTP consumers that read compiled context packs programmatically
+ *   - Benchmark harnesses (context-pack-ab)
+ *
+ * BREAKING CHANGE RULES:
+ *   - Adding optional fields to ContextPackV1 is NON-breaking
+ *   - Removing fields or changing types is BREAKING (bump CONTEXT_PACK_SCHEMA_VERSION)
+ *   - Changing section budget ratios or ranking weights is NON-breaking (tuning)
+ *   - Changing the version string is BREAKING (consumers check it)
+ */
+/** Canonical version string. Consumers MUST check this field for compatibility. */
+declare const CONTEXT_PACK_SCHEMA_VERSION: "1.0.0";
+/**
+ * Available ranking profiles for context-pack assembly.
+ *
+ * - `baseline_v1`: Simple token-hit counting. Items with zero query hits are excluded.
+ * - `weighted_v1`: Multi-signal scoring combining query relevance, recency, confidence,
+ *    belief type, priority, and severity with section-specific weight vectors.
+ */
+type ContextRankingProfile = "baseline_v1" | "weighted_v1";
+declare const CONTEXT_RANKING_PROFILES: readonly ContextRankingProfile[];
+declare const DEFAULT_RANKING_PROFILE: ContextRankingProfile;
+/**
+ * Context compilation mode.
+ *
+ * - `standard`: Default — ranked beliefs, questions, evidence, contradictions.
+ * - `delta`: Diff-aware — adds failure context, verification obligations,
+ *    and worktree ledger analysis to the standard context pack.
+ */
+type ContextCompilationMode = "standard" | "delta";
+declare const DEFAULT_COMPILATION_MODE: ContextCompilationMode;
+/**
+ * The five canonical sections of a context pack.
+ * Order matters: invariants are injected first, contradictions last.
+ */
+type ContextPackSectionKey = "invariants" | "activeBeliefs" | "openQuestions" | "recentEvidence" | "contradictions";
+declare const CONTEXT_PACK_SECTION_KEYS: readonly ContextPackSectionKey[];
+/**
+ * Token budget allocation ratios per section.
+ * These sum to 1.0 and determine how the total tokenBudget is divided.
+ *
+ * Rationale:
+ * - invariants (0.28): Highest-priority constraints, injected first
+ * - activeBeliefs (0.30): Largest section, carries domain knowledge
+ * - openQuestions (0.17): Unresolved work items guide agent behavior
+ * - recentEvidence (0.17): Implementation context for grounding
+ * - contradictions (0.08): Tension signals, smallest section
+ */
+declare const SECTION_BUDGET_RATIOS: Readonly<Record<ContextPackSectionKey, number>>;
+/** Minimum allowed token budget. Below this, context packs lose utility. */
+declare const MIN_TOKEN_BUDGET = 400;
+/** Maximum allowed token budget. Above this, context packs bloat prompts. */
+declare const MAX_TOKEN_BUDGET = 8000;
+/** Default token budget when caller does not specify. */
+declare const DEFAULT_TOKEN_BUDGET = 1800;
+/** Default max items per section. */
+declare const DEFAULT_SECTION_LIMIT = 8;
+/** Hard ceiling on items per section. */
+declare const MAX_SECTION_LIMIT = 25;
+/** Minimum contradiction section budget floor (tokens). */
+declare const MIN_CONTRADICTION_BUDGET = 40;
+/**
+ * Weight vectors for the weighted_v1 ranking profile.
+ * Each section has a different signal mix:
+ *
+ * - query: How many query tokens appear in the candidate text
+ * - recency: Exponential decay from updatedAt (half-life = 30 days)
+ * - confidence: Belief confidence score [0,1]
+ * - beliefType: Bonus for invariant > tenet > principle > other
+ * - priority: Question priority (critical > high > medium > low)
+ * - severity: Contradiction severity (critical > high > medium > low)
+ */
+type RankingWeightVector = {
+    query: number;
+    recency: number;
+    confidence?: number;
+    beliefType?: number;
+    priority?: number;
+    severity?: number;
+};
+declare const RANKING_WEIGHTS: Readonly<Record<ContextPackSectionKey, RankingWeightVector>>;
+/** Recency decay half-life in days. After 30 days, recency score = 0.5. */
+declare const RECENCY_HALF_LIFE_DAYS = 30;
+/**
+ * Ranking weight vector for the relatedEntities section.
+ * Entities are ranked by query relevance and connectivity (bridge edge count).
+ * Separate from RANKING_WEIGHTS because entities are not part of the
+ * token-budgeted injection plan.
+ */
+declare const ENTITY_RANKING_WEIGHTS: {
+    readonly query: 0.4;
+    readonly connectivity: 0.6;
+};
+/** Default max entities to include in the context pack. */
+declare const DEFAULT_ENTITY_LIMIT = 10;
+/** Hard ceiling on entities per context pack. */
+declare const MAX_ENTITY_LIMIT = 50;
+/**
+ * Bonus multiplier for belief types in ranking.
+ * Invariants get 1.0, unknown types get 0.4.
+ */
+declare const BELIEF_TYPE_BONUS: Readonly<Record<string, number>>;
+declare const DEFAULT_BELIEF_TYPE_BONUS = 0.4;
+declare const PRIORITY_SCORES: Readonly<Record<string, number>>;
+declare const DEFAULT_PRIORITY_SCORE = 0.5;
+declare const SEVERITY_SCORES: Readonly<Record<string, number>>;
+declare const DEFAULT_SEVERITY_SCORE = 0.5;
+/** A ranked belief in the invariants or activeBeliefs section. */
+type ContextPackBelief = {
+    nodeId: string;
+    canonicalText: string;
+    confidence: number | null;
+    beliefType: string | null;
+    score: number;
+    /** Present in activeBeliefs, absent in invariants */
+    status?: string;
+    updatedAt?: number | null;
+    /** Human-readable explanation of why this item was ranked here (RS-2). */
+    justification?: string;
+};
+/** A ranked question in the openQuestions section. */
+type ContextPackQuestion = {
+    questionId: string;
+    text: string;
+    status: string;
+    priority: string;
+    updatedAt?: number | null;
+    score: number;
+    /** Human-readable explanation of why this item was ranked here (RS-2). */
+    justification?: string;
+};
+/** A ranked evidence item in the recentEvidence section. */
+type ContextPackEvidence = {
+    nodeId: string;
+    canonicalText: string;
+    sourceUrl: string | null;
+    kind: string;
+    createdAt: number | null;
+    score: number;
+    /** Human-readable explanation of why this item was ranked here (RS-2). */
+    justification?: string;
+};
+/** A ranked contradiction in the contradictions section. */
+type ContextPackContradiction = {
+    contradictionId: string;
+    severity: string;
+    status: string;
+    description: string;
+    score: number;
+    /** Human-readable explanation of why this item was ranked here (RS-2). */
+    justification?: string;
+};
+/**
+ * An entity from the ontological layer surfaced in the context pack.
+ * Entities are domain objects (companies, people, functions, etc.) connected
+ * to beliefs via bridge edges. They provide the "reality anchor" that makes
+ * the reasoning graph domain-aware.
+ */
+type ContextPackEntity = {
+    /** Convex document ID of the entity node. */
+    nodeId: string;
+    /** Entity type (e.g., "company", "person", "function"). */
+    entityType: string;
+    /** Human-readable title/name of the entity. */
+    title: string;
+    /** Number of beliefs connected to this entity via bridge edges. */
+    connectedBeliefCount: number;
+    /** Number of evidence items referencing this entity. */
+    connectedEvidenceCount: number;
+    /** Relevance score from ranking algorithm. */
+    score: number;
+    /** Entity metadata (structured per ontology schema). */
+    metadata?: Record<string, unknown>;
+};
+/**
+ * A lattice seed entry representing a belief that was auto-generated
+ * to cover an ontology entity type within a topic scope.
+ */
+type BeliefLatticeSeed = {
+    /** The belief node ID that was created or already existed. */
+    beliefNodeId: string;
+    /** The entity type this seed belief covers. */
+    entityType: string;
+    /** Whether this seed was newly created or already existed. */
+    created: boolean;
+    /** The canonical text of the seed belief. */
+    canonicalText: string;
+};
+/** Counts and scoped health signals for the context pack. */
+type ContextPackSummary = {
+    totalBeliefs: number;
+    invariants: number;
+    openQuestions: number;
+    evidenceItems: number;
+    contradictions: number;
+    /** Number of ontological entities in scope (optional, present when entity graph is active). */
+    relatedEntities?: number;
+    scopedTopics: number;
+    descendantDepth: number;
+    query: string | null;
+};
+/** A failed approach surfaced from the failure log for anti-repetition. */
+type ContextPackFailure = {
+    /** Lucern attempt/evidence node ID. */
+    attemptId: string;
+    /** What was tried. */
+    approach: string;
+    /** Why it failed. */
+    outcome: string;
+    /** When the attempt was recorded (ms since epoch). */
+    recordedAt: number;
+    /** Relevance score from ranking algorithm. */
+    score: number;
+};
+/** Failure context section appended to context packs in delta mode. */
+type ContextPackFailureContext = {
+    /** Ranked failed approaches relevant to the current query. */
+    failures: ContextPackFailure[];
+    /** IDs of items suppressed from other sections due to anti-repetition. */
+    suppressedIds: string[];
+};
+/** A verification obligation surfaced by delta compilation. */
+type VerificationObligation = {
+    /** What must be verified. */
+    description: string;
+    /** Source of the obligation (e.g., "belief:xyz confidence drop"). */
+    source: string;
+    /** Severity: how important it is to verify. */
+    severity: "critical" | "high" | "medium" | "low";
+};
+/** Delta report appended to context packs when mode = "delta". */
+type ContextPackDeltaReport = {
+    /** Items that changed since the reference point (new, updated, removed). */
+    changedItems: Array<{
+        id: string;
+        section: ContextPackSectionKey;
+        changeType: "added" | "updated" | "removed" | "confidence_changed";
+        summary: string;
+    }>;
+    /** Obligations the consuming session must verify. */
+    verificationObligations: VerificationObligation[];
+    /** Reference point for the delta (worktree ID, timestamp, or commit SHA). */
+    referencePoint: string;
+};
+/**
+ * Per-section weight overrides that domain packs can apply.
+ * Overrides merge with RANKING_WEIGHTS — only specified fields replace defaults.
+ */
+type PackWeightOverride = {
+    /** Which section to override weights for. */
+    section: ContextPackSectionKey;
+    /** Partial weight vector — only specified fields replace defaults. */
+    weights: Partial<RankingWeightVector>;
+};
+/** Token-budgeted section selections for prompt injection. */
+type ContextPackInjectionPolicy = {
+    /** Total token budget for the entire context pack. */
+    tokenBudget: number;
+    /** Estimated tokens consumed across all sections. */
+    estimatedTokens: number;
+    /** Per-section token budgets derived from SECTION_BUDGET_RATIOS. */
+    sectionBudgets: Record<ContextPackSectionKey, number>;
+    /** Actual token usage per section after greedy fill. */
+    sectionUsage: Record<ContextPackSectionKey, number>;
+    /** Node/question IDs selected for injection, per section. */
+    selected: Record<ContextPackSectionKey, string[]>;
+    /** Items that were scored but excluded from injection, with reason (RS-2). */
+    excludedItems?: Array<{
+        id: string;
+        section: ContextPackSectionKey;
+        reason: "budget_exceeded" | "anti_repetition" | "below_threshold";
+        score: number;
+    }>;
+};
+/** Telemetry for context pack assembly. */
+type ContextPackDiagnostics = {
+    /** Total candidates scored across all sections. */
+    itemsScored: number;
+    /** Ratio of estimatedTokens / tokenBudget. Range [0, 1+]. */
+    tokenBudgetUtilization: number;
+};
+/**
+ * Public context surface returned by the SDK-facing context client.
+ *
+ * This preserves the existing external shape while the canonical compiler
+ * contract evolves in parallel as ContextPackV1.
+ */
+type PublicContextBelief = {
+    beliefId: string;
+    text: string;
+    confidence: number | null;
+    beliefType?: string | null;
+    status?: string;
+    updatedAt?: number | null;
+    score: number;
+    justification?: string;
+};
+type PublicContextQuestion = {
+    questionId: string;
+    text: string;
+    status: string;
+    priority: string;
+    updatedAt?: number | null;
+    score: number;
+    justification?: string;
+};
+type PublicContextEvidence = {
+    evidenceId: string;
+    text: string;
+    sourceUrl?: string | null;
+    kind: string;
+    createdAt?: number | null;
+    score: number;
+    justification?: string;
+};
+type PublicContextContradiction = {
+    contradictionId: string;
+    severity: string;
+    status: string;
+    description: string;
+    score: number;
+    justification?: string;
+};
+type PublicContextEntity = {
+    entityId: string;
+    entityType: string;
+    title: string;
+    text?: string;
+    connectedBeliefCount: number;
+    connectedEvidenceCount: number;
+    score: number;
+    metadata?: Record<string, unknown>;
+};
+type PublicContextInjectionPolicy = {
+    tokenBudget: number;
+    estimatedTokens: number;
+    sectionBudgets: Record<string, number>;
+    sectionUsage: Record<string, number>;
+    selected: Record<string, string[]>;
+    excludedItems?: Array<{
+        id: string;
+        section: string;
+        reason: "budget_exceeded" | "anti_repetition" | "below_threshold";
+        score: number;
+    }>;
+};
+type PublicCompiledContext = {
+    schemaVersion: string;
+    topicId: string;
+    topicName: string;
+    scopedTopicIds: string[];
+    generatedAt: number;
+    ranking: ContextRankingProfile;
+    summary: Record<string, unknown>;
+    invariants: PublicContextBelief[];
+    activeBeliefs: PublicContextBelief[];
+    openQuestions: PublicContextQuestion[];
+    recentEvidence: PublicContextEvidence[];
+    contradictions: PublicContextContradiction[];
+    relatedEntities?: PublicContextEntity[];
+    contextNarrative: string[];
+    injectionPolicy: PublicContextInjectionPolicy;
+    diagnostics: Record<string, unknown>;
+    compilationMode?: string;
+    failureContext?: {
+        failures: Array<{
+            attemptId: string;
+            approach: string;
+            outcome: string;
+            recordedAt: number;
+            score: number;
+        }>;
+        suppressedIds: string[];
+    };
+    deltaReport?: {
+        changedItems: Array<{
+            id: string;
+            section: string;
+            changeType: string;
+            summary: string;
+        }>;
+        verificationObligations: Array<{
+            description: string;
+            source: string;
+            severity: "critical" | "high" | "medium" | "low";
+        }>;
+        referencePoint: string;
+    };
+    appliedWeightOverrides?: unknown[];
+};
+/**
+ * The canonical output schema for context compilation responses.
+ *
+ * This is the contract that consumers depend on. All fields are required
+ * in the output. Adding optional fields is non-breaking; removing or
+ * changing types is breaking (requires version bump).
+ */
+type ContextPackV1 = {
+    /** Schema version for compatibility checking. */
+    schemaVersion: typeof CONTEXT_PACK_SCHEMA_VERSION;
+    /** Deprecated compatibility alias for the requested scope ID. */
+    projectId?: string;
+    /** Resolved topic ID after scope resolution. */
+    topicId: string;
+    /** Human-readable topic name. */
+    topicName: string;
+    /** All topic IDs included in the neighborhood expansion. */
+    scopedTopicIds: string[];
+    /** Deterministic freshness watermark for this pack (ms since epoch). */
+    generatedAt: number;
+    /** Which ranking profile was used. */
+    rankingProfile: ContextRankingProfile;
+    /** Aggregate counts and health signals. */
+    summary: ContextPackSummary;
+    /** High-confidence invariant beliefs (beliefType = "invariant"). */
+    invariants: ContextPackBelief[];
+    /** Active beliefs ranked by query relevance. */
+    activeBeliefs: ContextPackBelief[];
+    /** Open questions ranked by relevance and priority. */
+    openQuestions: ContextPackQuestion[];
+    /** Recent evidence ranked by relevance and recency. */
+    recentEvidence: ContextPackEvidence[];
+    /** Active contradictions ranked by severity. */
+    contradictions: ContextPackContradiction[];
+    /**
+     * Ontological entities connected to beliefs in scope, ranked by connectivity.
+     * Optional — present when entity graph substrate is active for this topic.
+     * NON-BREAKING addition per contract rules.
+     */
+    relatedEntities?: ContextPackEntity[];
+    /** Concise instructions for agent context injection. */
+    contextNarrative: string[];
+    /** Token-budgeted injection selections. */
+    injectionPolicy: ContextPackInjectionPolicy;
+    /** Assembly telemetry. */
+    diagnostics: ContextPackDiagnostics;
+    /** Compilation mode used to generate this pack (RS-2). Default: "standard". */
+    compilationMode?: ContextCompilationMode;
+    /** Failure context for anti-repetition (RS-2). Present when failures are relevant. */
+    failureContext?: ContextPackFailureContext;
+    /** Delta report (RS-2). Present only when compilationMode = "delta". */
+    deltaReport?: ContextPackDeltaReport;
+    /** Pack weight overrides applied during ranking (RS-2). */
+    appliedWeightOverrides?: PackWeightOverride[];
+};
+/**
+ * The canonical input schema for `compile_context`.
+ * `topicId` is canonical. `projectId` remains an optional compatibility alias.
+ */
+type ContextPackRequestV1 = {
+    /** Topic scope ID (required). */
+    topicId: string;
+    /** Deprecated compatibility alias for older callers. */
+    projectId?: string;
+    /** Focus query for relevance ranking. */
+    query?: string;
+    /** Max items per section. Default: DEFAULT_SECTION_LIMIT. */
+    limit?: number;
+    /** Ranking profile. Default: DEFAULT_RANKING_PROFILE. */
+    rankingProfile?: ContextRankingProfile;
+    /** Total token budget. Default: DEFAULT_TOKEN_BUDGET. */
+    tokenBudget?: number;
+    /** Descendant topic depth for neighborhood expansion. */
+    maxDepth?: number;
+    /** Include ontological entities connected to beliefs in scope. Default: true. */
+    includeEntities?: boolean;
+    /** Compilation mode (RS-2). Default: "standard". */
+    mode?: ContextCompilationMode;
+    /** Include failure log context for anti-repetition (RS-2). Default: false. */
+    includeFailures?: boolean;
+    /** Active worktree ID for delta mode reference point (RS-2). */
+    worktreeId?: string;
+    /** Session ID for anti-repetition dedup (RS-2). */
+    sessionId?: string;
+    /** Pack weight overrides from domain pack binding (RS-2). */
+    packWeightOverrides?: PackWeightOverride[];
+};
+/**
+ * Question statuses that are considered "resolved" (not open).
+ * Used to filter which questions appear in the openQuestions section.
+ */
+declare const RESOLVED_QUESTION_STATUSES: readonly string[];
+/**
+ * Tokens-per-word multiplier for rough token estimation.
+ * Conservative estimate: ~1.35 tokens per whitespace-delimited word.
+ */
+declare const TOKENS_PER_WORD = 1.35;
+/** Minimum token estimate for any non-empty string. */
+declare const MIN_TOKEN_ESTIMATE = 8;
+
+/**
+ * @lucern/contracts — events (canonical support contract)
+ *
+ * Consolidated flat support surface for Lucern's domain event stream:
+ *   - Event type definitions, constants, and shared enums
+ *   - Event construction + cursor helpers
+ *
+ * Consolidated from the former split type-definition module
+ * and the prior src/events.contract.ts (helpers) in EK-16 T1 PR 3b.
+ * Compat shim remains at the old events-types path until Lucern 1.0.0 (D12).
+ */
+declare const DOMAIN_EVENT_VERSION: "1.0";
+declare const EVENT_RETENTION_DEFAULT_DAYS = 30;
+declare const WEBHOOK_MAX_ATTEMPTS = 5;
+declare const WEBHOOK_RETRY_DELAYS_MS: readonly [1000, 5000, 30000, 300000];
+declare const DOMAIN_EVENT_TYPES: readonly ["belief.created", "belief.forked", "belief.confidence_updated", "belief.archived", "belief.refined", "belief.contract_created", "belief.contract_evaluated", "belief.lineage_queried", "evidence.created", "evidence.linked", "evidence.search_executed", "question.created", "question.answered", "question.refined", "question.status_updated", "question.archived", "edge.created", "contradiction.flagged", "worktree.created", "worktree.activated", "worktree.merged", "worktree.targets_updated", "worktree.metadata_updated", "topic.created", "topic.updated", "topic.archived", "task.created", "task.completed", "task.updated", "ontology.bound", "context.compiled", "identity.key_created", "identity.key_rotated", "identity.key_revoked", "webhook.test"];
+type DomainEventType = (typeof DOMAIN_EVENT_TYPES)[number];
+type DomainResourceType = "belief" | "evidence" | "question" | "edge" | "contradiction" | "worktree" | "topic" | "task" | "ontology" | "context" | "identity" | "webhook";
+type DomainActorType = "human" | "agent" | "service";
+type DomainEventData = Record<string, unknown>;
+type DomainEvent = {
+    eventId: string;
+    type: DomainEventType | string;
+    version: typeof DOMAIN_EVENT_VERSION;
+    timestamp: number;
+    tenantId?: string;
+    workspaceId?: string;
+    topicId: string;
+    resourceId: string;
+    resourceType: DomainResourceType | string;
+    actorId: string;
+    actorType: DomainActorType;
+    data: DomainEventData;
+    correlationId?: string;
+    expiresAt: number;
+};
+type CreateDomainEventInput = {
+    eventId?: string;
+    timestamp?: number;
+    tenantId?: string;
+    workspaceId?: string;
+    topicId: string;
+    type: DomainEventType | string;
+    resourceId: string;
+    resourceType: DomainResourceType | string;
+    actorId: string;
+    actorType: DomainActorType;
+    data?: DomainEventData;
+    correlationId?: string;
+    retentionDays?: number;
+};
+type EventCursor = {
+    timestamp: number;
+    eventId: string;
+};
+type EventListQuery = {
+    topicId?: string;
+    after?: string;
+    types?: string[];
+    startTime?: number;
+    endTime?: number;
+    limit?: number;
+};
+type EventListResult = {
+    events: DomainEvent[];
+    nextCursor: string | null;
+};
+type WebhookSecretMode = "configured";
+type WebhookRecord = {
+    id: string;
+    webhookId: string;
+    tenantId?: string;
+    workspaceId?: string;
+    topicId?: string;
+    url: string;
+    events: string[];
+    active: boolean;
+    secretConfigured: boolean;
+    createdAt: number;
+    updatedAt: number;
+    createdBy: string;
+    updatedBy: string;
+    lastDeliveryAt?: number;
+    lastSuccessfulDeliveryAt?: number;
+};
+type WebhookCreateInput = {
+    url: string;
+    events: string[];
+    secret: string;
+    topicId?: string;
+    active?: boolean;
+};
+type WebhookUpdateInput = {
+    url?: string;
+    events?: string[];
+    secret?: string;
+    topicId?: string | null;
+    active?: boolean;
+};
+type WebhookDeliveryStatus = "pending" | "delivering" | "succeeded" | "failed" | "dead_letter";
+type WebhookDeliveryRecord = {
+    id: string;
+    deliveryId: string;
+    webhookId: string;
+    eventId: string;
+    eventType: string;
+    topicId: string;
+    status: WebhookDeliveryStatus;
+    attemptCount: number;
+    maxAttempts: number;
+    nextAttemptAt?: number;
+    lastAttemptAt?: number;
+    lastStatusCode?: number;
+    lastError?: string;
+    deliveredAt?: number;
+    createdAt: number;
+    updatedAt: number;
+};
+type WebhookDeliveryAttemptRecord = {
+    id: string;
+    attemptId: string;
+    deliveryId: string;
+    webhookId: string;
+    eventId: string;
+    eventType: string;
+    attemptNumber: number;
+    status: "succeeded" | "failed";
+    statusCode?: number;
+    error?: string;
+    responseBody?: string;
+    durationMs?: number;
+    createdAt: number;
+};
+type WebhookDeliveriesResult = {
+    deliveries: Array<WebhookDeliveryRecord & {
+        attempts?: WebhookDeliveryAttemptRecord[];
+    }>;
+};
+type WebhookHealthResult = {
+    webhookId: string;
+    totalAttempts: number;
+    successfulAttempts: number;
+    failedAttempts: number;
+    successRate: number;
+    pendingDeliveries: number;
+    deadLetterDeliveries: number;
+    lastDeliveryAt?: number;
+    lastSuccessfulDeliveryAt?: number;
+};
+type WebhookTestResult = {
+    webhookId: string;
+    deliveryId: string;
+    status: WebhookDeliveryStatus;
+    attempts: number;
+};
+type ReplayEventsInput = EventListQuery & {
+    webhookId?: string;
+};
+type ReplayEventsResult = EventListResult & {
+    replayedDeliveries?: number;
+    replayedWebhookId?: string;
+};
+declare function createEventId(): string;
+declare function normalizeRetentionDays(value: number | undefined): number;
+declare function buildDomainEvent(input: CreateDomainEventInput): DomainEvent;
+declare function compareEventCursor(left: EventCursor, right: EventCursor): number;
+declare function encodeEventCursor(cursor: EventCursor): string;
+declare function decodeEventCursor(cursor: string | undefined): EventCursor | null;
+declare function isAfterCursor(event: Pick<DomainEvent, "timestamp" | "eventId">, cursor: EventCursor | null): boolean;
+declare function sortEventsByCursor<T extends Pick<DomainEvent, "timestamp" | "eventId">>(events: readonly T[]): T[];
+declare function inferActorType(args: {
+    sessionType?: "agent" | "user";
+    authMode?: string;
+    principalType?: string;
+}): DomainActorType;
+declare function emitDomainEvent(invokeMutation: (reference: any, args: CreateDomainEventInput) => Promise<unknown>, input: CreateDomainEventInput): Promise<unknown>;
+
+type DecodedPrefixedId = {
+    prefix: string;
+    value: string;
+};
+declare function encodePrefixedId(prefix: string, value: string): string;
+declare function decodePrefixedId(id: string): DecodedPrefixedId;
+declare function hasPrefixedIdPrefix(id: string, prefix: string): boolean;
+
+/**
+ * MCP Tool Contract Definitions
+ *
+ * Machine-readable source of truth for all Lucern MCP tool names,
+ * descriptions, parameters, and response schemas.
+ *
+ * CONTRACT SURFACE: These definitions are the external API for AI agents.
+ * Renaming a tool or changing its description is a BREAKING CHANGE.
+ *
+ * Git-native naming rules (enforced by lint):
+ *   1. Workflow tools use git verbs directly (add_worktree, merge, push, open_pull_request)
+ *   2. Knowledge tools use epistemic verbs (create_belief, fork_belief, modulate_confidence)
+ *   3. First sentence of description includes the git analog verb
+ *   4. Description includes "Like `git X`" parenthetical
+ *   5. Parameter names use domain terms (canonicalText, nodeId, confidence)
+ */
+type McpToolContract = {
+    /** Stable tool name — breaking change to rename */
+    name: string;
+    /** Git-semantic description — breaking change to remove git references */
+    description: string;
+    /** Parameter schema (JSON Schema subset) */
+    parameters: Record<string, McpParameterDef>;
+    /** Required parameter names */
+    required: string[];
+    /** Response shape description */
+    response: McpResponseDef;
+    /** Which Lucern module owns the implementation */
+    ownerModule: string;
+    /** Ontology primitive this tool operates on */
+    ontologyPrimitive: "belief" | "evidence" | "source" | "question" | "judgment" | "worktree" | "branch" | "lens" | "edge" | "graph" | "task" | "policy" | "ontology" | "identity";
+    /** MCP surface tier — showcase (front page, every demo) or workhorse (complete CRUD, discovered when building) */
+    tier: "showcase" | "workhorse";
+    /** Hide this tool from public discovery surfaces. */
+    internal?: boolean;
+    /** Deprecation notice shown in contract-driven docs and discovery. */
+    deprecated?: string;
+};
+type McpParameterDef = {
+    type: "string" | "number" | "boolean" | "array" | "object";
+    description: string;
+    required?: boolean;
+    enum?: string[];
+};
+type McpResponseDef = {
+    description: string;
+    fields: Record<string, string>;
+};
+declare const CREATE_BELIEF: McpToolContract;
+declare const GET_BELIEF: McpToolContract;
+declare const REFINE_BELIEF: McpToolContract;
+declare const MODULATE_CONFIDENCE: McpToolContract;
+declare const FORK_BELIEF: McpToolContract;
+declare const ARCHIVE_BELIEF: McpToolContract;
+declare const CREATE_EPISTEMIC_CONTRACT: McpToolContract;
+declare const ADD_EVIDENCE: McpToolContract;
+declare const FLAG_CONTRADICTION: McpToolContract;
+declare const ADD_WORKTREE: McpToolContract;
+declare const MERGE: McpToolContract;
+declare const QUERY_LINEAGE: McpToolContract;
+declare const GET_CONFIDENCE_HISTORY: McpToolContract;
+declare const GET_AUDIT_TRAIL: McpToolContract;
+declare const TRAVERSE_GRAPH: McpToolContract;
+declare const GET_GRAPH_NEIGHBORHOOD: McpToolContract;
+declare const TRACE_ENTITY_IMPACT: McpToolContract;
+declare const SEARCH_BELIEFS: McpToolContract;
+declare const SEARCH_RESOURCES: McpToolContract;
+declare const FIND_CONTRADICTIONS: McpToolContract;
+declare const CREATE_EDGE: McpToolContract;
+declare const RECORD_JUDGMENT: McpToolContract;
+declare const CREATE_LENS: McpToolContract;
+declare const LIST_LENSES: McpToolContract;
+declare const APPLY_LENS_TO_TOPIC: McpToolContract;
+declare const REMOVE_LENS_FROM_TOPIC: McpToolContract;
+declare const PUSH: McpToolContract;
+declare const OPEN_PULL_REQUEST: McpToolContract;
+declare const BISECT_CONFIDENCE: McpToolContract;
+declare const DETECT_CONFIRMATION_BIAS: McpToolContract;
+declare const GET_GRAPH_STRUCTURE_ANALYSIS: McpToolContract;
+declare const GET_FALSIFICATION_QUESTIONS: McpToolContract;
+declare const SEARCH_SOURCES: McpToolContract;
+declare const EXECUTE_DEEP_RESEARCH: McpToolContract;
+declare const SEARCH_EVIDENCE: McpToolContract;
+declare const CREATE_EVIDENCE: McpToolContract;
+declare const GET_EVIDENCE: McpToolContract;
+declare const LIST_EVIDENCE: McpToolContract;
+declare const LINK_EVIDENCE: McpToolContract;
+declare const LINK_EVIDENCE_TO_BELIEF: McpToolContract;
+declare const CREATE_QUESTION: McpToolContract;
+declare const GET_QUESTION: McpToolContract;
+declare const REFINE_QUESTION: McpToolContract;
+declare const LIST_QUESTIONS: McpToolContract;
+declare const ANSWER_QUESTION: McpToolContract;
+declare const UPDATE_QUESTION_STATUS: McpToolContract;
+declare const ARCHIVE_QUESTION: McpToolContract;
+declare const LINK_EVIDENCE_TO_QUESTION: McpToolContract;
+declare const CREATE_ANSWER: McpToolContract;
+declare const GET_ANSWER: McpToolContract;
+declare const GET_HIGH_PRIORITY_QUESTIONS: McpToolContract;
+declare const FIND_MISSING_QUESTIONS: McpToolContract;
+declare const LIST_BELIEFS: McpToolContract;
+declare const LIST_WORKTREES: McpToolContract;
+declare const LIST_ALL_WORKTREES: McpToolContract;
+declare const ACTIVATE_WORKTREE: McpToolContract;
+declare const UPDATE_WORKTREE_TARGETS: McpToolContract;
+declare const UPDATE_WORKTREE_METADATA: McpToolContract;
+declare const IDENTITY_WHOAMI: McpToolContract;
+declare const COMPILE_CONTEXT: McpToolContract;
+declare const CHECK_PERMISSION: McpToolContract;
+declare const FILTER_BY_PERMISSION: McpToolContract;
+declare const INGEST_OBSERVATION: McpToolContract;
+declare const GET_OBSERVATION_CONTEXT: McpToolContract;
+declare const CREATE_TASK: McpToolContract;
+declare const COMPLETE_TASK: McpToolContract;
+declare const UPDATE_TASK$1: McpToolContract;
+declare const LIST_TASKS$1: McpToolContract;
+declare const CREATE_TOPIC: McpToolContract;
+declare const LIST_TOPICS: McpToolContract;
+declare const GET_TOPIC: McpToolContract;
+declare const UPDATE_TOPIC: McpToolContract;
+declare const GET_TOPIC_TREE: McpToolContract;
+declare const GET_CODE_CONTEXT: McpToolContract;
+declare const GET_CHANGE_HISTORY: McpToolContract;
+declare const RECORD_ATTEMPT: McpToolContract;
+declare const GET_FAILURE_LOG: McpToolContract;
+declare const GET_TOPIC_COVERAGE: McpToolContract;
+declare const GET_GRAPH_GAPS: McpToolContract;
+declare const MANAGE_WRITE_POLICY: McpToolContract;
+declare const LIST_ONTOLOGIES: McpToolContract;
+declare const GET_ONTOLOGY: McpToolContract;
+declare const APPLY_ONTOLOGY: McpToolContract;
+declare const MATCH_ENTITY_TYPE: McpToolContract;
+declare const CREATE_ONTOLOGY: McpToolContract;
+declare const UPDATE_ONTOLOGY: McpToolContract;
+declare const ARCHIVE_ONTOLOGY: McpToolContract;
+declare const CREATE_ONTOLOGY_VERSION: McpToolContract;
+declare const PUBLISH_ONTOLOGY_VERSION: McpToolContract;
+declare const DEPRECATE_ONTOLOGY_VERSION: McpToolContract;
+declare const RESOLVE_EFFECTIVE_ONTOLOGY: McpToolContract;
+/** All MCP tool contracts, indexed by name */
+declare const MCP_TOOL_CONTRACTS: Record<string, McpToolContract>;
+/** Tool names that MUST include git-semantic language in descriptions */
+declare const GIT_SEMANTIC_REQUIRED_TOOLS: string[];
+/**
+ * Lint validation: every tool description must contain "Like `git" or "Like a `git"
+ * or reference a git operation in the first sentence.
+ */
+declare function validateGitSemantics(tool: McpToolContract): {
+    valid: boolean;
+    reason?: string;
+};
+
+declare const mcpTools_contract_ACTIVATE_WORKTREE: typeof ACTIVATE_WORKTREE;
+declare const mcpTools_contract_ADD_EVIDENCE: typeof ADD_EVIDENCE;
+declare const mcpTools_contract_ADD_WORKTREE: typeof ADD_WORKTREE;
+declare const mcpTools_contract_ANSWER_QUESTION: typeof ANSWER_QUESTION;
+declare const mcpTools_contract_APPLY_LENS_TO_TOPIC: typeof APPLY_LENS_TO_TOPIC;
+declare const mcpTools_contract_APPLY_ONTOLOGY: typeof APPLY_ONTOLOGY;
+declare const mcpTools_contract_ARCHIVE_BELIEF: typeof ARCHIVE_BELIEF;
+declare const mcpTools_contract_ARCHIVE_ONTOLOGY: typeof ARCHIVE_ONTOLOGY;
+declare const mcpTools_contract_ARCHIVE_QUESTION: typeof ARCHIVE_QUESTION;
+declare const mcpTools_contract_BISECT_CONFIDENCE: typeof BISECT_CONFIDENCE;
+declare const mcpTools_contract_CHECK_PERMISSION: typeof CHECK_PERMISSION;
+declare const mcpTools_contract_COMPILE_CONTEXT: typeof COMPILE_CONTEXT;
+declare const mcpTools_contract_COMPLETE_TASK: typeof COMPLETE_TASK;
+declare const mcpTools_contract_CREATE_ANSWER: typeof CREATE_ANSWER;
+declare const mcpTools_contract_CREATE_BELIEF: typeof CREATE_BELIEF;
+declare const mcpTools_contract_CREATE_EDGE: typeof CREATE_EDGE;
+declare const mcpTools_contract_CREATE_EPISTEMIC_CONTRACT: typeof CREATE_EPISTEMIC_CONTRACT;
+declare const mcpTools_contract_CREATE_EVIDENCE: typeof CREATE_EVIDENCE;
+declare const mcpTools_contract_CREATE_LENS: typeof CREATE_LENS;
+declare const mcpTools_contract_CREATE_ONTOLOGY: typeof CREATE_ONTOLOGY;
+declare const mcpTools_contract_CREATE_ONTOLOGY_VERSION: typeof CREATE_ONTOLOGY_VERSION;
+declare const mcpTools_contract_CREATE_QUESTION: typeof CREATE_QUESTION;
+declare const mcpTools_contract_CREATE_TASK: typeof CREATE_TASK;
+declare const mcpTools_contract_CREATE_TOPIC: typeof CREATE_TOPIC;
+declare const mcpTools_contract_DEPRECATE_ONTOLOGY_VERSION: typeof DEPRECATE_ONTOLOGY_VERSION;
+declare const mcpTools_contract_DETECT_CONFIRMATION_BIAS: typeof DETECT_CONFIRMATION_BIAS;
+declare const mcpTools_contract_EXECUTE_DEEP_RESEARCH: typeof EXECUTE_DEEP_RESEARCH;
+declare const mcpTools_contract_FILTER_BY_PERMISSION: typeof FILTER_BY_PERMISSION;
+declare const mcpTools_contract_FIND_CONTRADICTIONS: typeof FIND_CONTRADICTIONS;
+declare const mcpTools_contract_FIND_MISSING_QUESTIONS: typeof FIND_MISSING_QUESTIONS;
+declare const mcpTools_contract_FLAG_CONTRADICTION: typeof FLAG_CONTRADICTION;
+declare const mcpTools_contract_FORK_BELIEF: typeof FORK_BELIEF;
+declare const mcpTools_contract_GET_ANSWER: typeof GET_ANSWER;
+declare const mcpTools_contract_GET_AUDIT_TRAIL: typeof GET_AUDIT_TRAIL;
+declare const mcpTools_contract_GET_BELIEF: typeof GET_BELIEF;
+declare const mcpTools_contract_GET_CHANGE_HISTORY: typeof GET_CHANGE_HISTORY;
+declare const mcpTools_contract_GET_CODE_CONTEXT: typeof GET_CODE_CONTEXT;
+declare const mcpTools_contract_GET_CONFIDENCE_HISTORY: typeof GET_CONFIDENCE_HISTORY;
+declare const mcpTools_contract_GET_EVIDENCE: typeof GET_EVIDENCE;
+declare const mcpTools_contract_GET_FAILURE_LOG: typeof GET_FAILURE_LOG;
+declare const mcpTools_contract_GET_FALSIFICATION_QUESTIONS: typeof GET_FALSIFICATION_QUESTIONS;
+declare const mcpTools_contract_GET_GRAPH_GAPS: typeof GET_GRAPH_GAPS;
+declare const mcpTools_contract_GET_GRAPH_NEIGHBORHOOD: typeof GET_GRAPH_NEIGHBORHOOD;
+declare const mcpTools_contract_GET_GRAPH_STRUCTURE_ANALYSIS: typeof GET_GRAPH_STRUCTURE_ANALYSIS;
+declare const mcpTools_contract_GET_HIGH_PRIORITY_QUESTIONS: typeof GET_HIGH_PRIORITY_QUESTIONS;
+declare const mcpTools_contract_GET_OBSERVATION_CONTEXT: typeof GET_OBSERVATION_CONTEXT;
+declare const mcpTools_contract_GET_ONTOLOGY: typeof GET_ONTOLOGY;
+declare const mcpTools_contract_GET_QUESTION: typeof GET_QUESTION;
+declare const mcpTools_contract_GET_TOPIC: typeof GET_TOPIC;
+declare const mcpTools_contract_GET_TOPIC_COVERAGE: typeof GET_TOPIC_COVERAGE;
+declare const mcpTools_contract_GET_TOPIC_TREE: typeof GET_TOPIC_TREE;
+declare const mcpTools_contract_GIT_SEMANTIC_REQUIRED_TOOLS: typeof GIT_SEMANTIC_REQUIRED_TOOLS;
+declare const mcpTools_contract_IDENTITY_WHOAMI: typeof IDENTITY_WHOAMI;
+declare const mcpTools_contract_INGEST_OBSERVATION: typeof INGEST_OBSERVATION;
+declare const mcpTools_contract_LINK_EVIDENCE: typeof LINK_EVIDENCE;
+declare const mcpTools_contract_LINK_EVIDENCE_TO_BELIEF: typeof LINK_EVIDENCE_TO_BELIEF;
+declare const mcpTools_contract_LINK_EVIDENCE_TO_QUESTION: typeof LINK_EVIDENCE_TO_QUESTION;
+declare const mcpTools_contract_LIST_ALL_WORKTREES: typeof LIST_ALL_WORKTREES;
+declare const mcpTools_contract_LIST_BELIEFS: typeof LIST_BELIEFS;
+declare const mcpTools_contract_LIST_EVIDENCE: typeof LIST_EVIDENCE;
+declare const mcpTools_contract_LIST_LENSES: typeof LIST_LENSES;
+declare const mcpTools_contract_LIST_ONTOLOGIES: typeof LIST_ONTOLOGIES;
+declare const mcpTools_contract_LIST_QUESTIONS: typeof LIST_QUESTIONS;
+declare const mcpTools_contract_LIST_TOPICS: typeof LIST_TOPICS;
+declare const mcpTools_contract_LIST_WORKTREES: typeof LIST_WORKTREES;
+declare const mcpTools_contract_MANAGE_WRITE_POLICY: typeof MANAGE_WRITE_POLICY;
+declare const mcpTools_contract_MATCH_ENTITY_TYPE: typeof MATCH_ENTITY_TYPE;
+declare const mcpTools_contract_MCP_TOOL_CONTRACTS: typeof MCP_TOOL_CONTRACTS;
+declare const mcpTools_contract_MERGE: typeof MERGE;
+declare const mcpTools_contract_MODULATE_CONFIDENCE: typeof MODULATE_CONFIDENCE;
+type mcpTools_contract_McpParameterDef = McpParameterDef;
+type mcpTools_contract_McpResponseDef = McpResponseDef;
+type mcpTools_contract_McpToolContract = McpToolContract;
+declare const mcpTools_contract_OPEN_PULL_REQUEST: typeof OPEN_PULL_REQUEST;
+declare const mcpTools_contract_PUBLISH_ONTOLOGY_VERSION: typeof PUBLISH_ONTOLOGY_VERSION;
+declare const mcpTools_contract_PUSH: typeof PUSH;
+declare const mcpTools_contract_QUERY_LINEAGE: typeof QUERY_LINEAGE;
+declare const mcpTools_contract_RECORD_ATTEMPT: typeof RECORD_ATTEMPT;
+declare const mcpTools_contract_RECORD_JUDGMENT: typeof RECORD_JUDGMENT;
+declare const mcpTools_contract_REFINE_BELIEF: typeof REFINE_BELIEF;
+declare const mcpTools_contract_REFINE_QUESTION: typeof REFINE_QUESTION;
+declare const mcpTools_contract_REMOVE_LENS_FROM_TOPIC: typeof REMOVE_LENS_FROM_TOPIC;
+declare const mcpTools_contract_RESOLVE_EFFECTIVE_ONTOLOGY: typeof RESOLVE_EFFECTIVE_ONTOLOGY;
+declare const mcpTools_contract_SEARCH_BELIEFS: typeof SEARCH_BELIEFS;
+declare const mcpTools_contract_SEARCH_EVIDENCE: typeof SEARCH_EVIDENCE;
+declare const mcpTools_contract_SEARCH_RESOURCES: typeof SEARCH_RESOURCES;
+declare const mcpTools_contract_SEARCH_SOURCES: typeof SEARCH_SOURCES;
+declare const mcpTools_contract_TRACE_ENTITY_IMPACT: typeof TRACE_ENTITY_IMPACT;
+declare const mcpTools_contract_TRAVERSE_GRAPH: typeof TRAVERSE_GRAPH;
+declare const mcpTools_contract_UPDATE_ONTOLOGY: typeof UPDATE_ONTOLOGY;
+declare const mcpTools_contract_UPDATE_QUESTION_STATUS: typeof UPDATE_QUESTION_STATUS;
+declare const mcpTools_contract_UPDATE_TOPIC: typeof UPDATE_TOPIC;
+declare const mcpTools_contract_UPDATE_WORKTREE_METADATA: typeof UPDATE_WORKTREE_METADATA;
+declare const mcpTools_contract_UPDATE_WORKTREE_TARGETS: typeof UPDATE_WORKTREE_TARGETS;
+declare const mcpTools_contract_validateGitSemantics: typeof validateGitSemantics;
+declare namespace mcpTools_contract {
+  export { mcpTools_contract_ACTIVATE_WORKTREE as ACTIVATE_WORKTREE, mcpTools_contract_ADD_EVIDENCE as ADD_EVIDENCE, mcpTools_contract_ADD_WORKTREE as ADD_WORKTREE, mcpTools_contract_ANSWER_QUESTION as ANSWER_QUESTION, mcpTools_contract_APPLY_LENS_TO_TOPIC as APPLY_LENS_TO_TOPIC, mcpTools_contract_APPLY_ONTOLOGY as APPLY_ONTOLOGY, mcpTools_contract_ARCHIVE_BELIEF as ARCHIVE_BELIEF, mcpTools_contract_ARCHIVE_ONTOLOGY as ARCHIVE_ONTOLOGY, mcpTools_contract_ARCHIVE_QUESTION as ARCHIVE_QUESTION, mcpTools_contract_BISECT_CONFIDENCE as BISECT_CONFIDENCE, mcpTools_contract_CHECK_PERMISSION as CHECK_PERMISSION, mcpTools_contract_COMPILE_CONTEXT as COMPILE_CONTEXT, mcpTools_contract_COMPLETE_TASK as COMPLETE_TASK, mcpTools_contract_CREATE_ANSWER as CREATE_ANSWER, mcpTools_contract_CREATE_BELIEF as CREATE_BELIEF, mcpTools_contract_CREATE_EDGE as CREATE_EDGE, mcpTools_contract_CREATE_EPISTEMIC_CONTRACT as CREATE_EPISTEMIC_CONTRACT, mcpTools_contract_CREATE_EVIDENCE as CREATE_EVIDENCE, mcpTools_contract_CREATE_LENS as CREATE_LENS, mcpTools_contract_CREATE_ONTOLOGY as CREATE_ONTOLOGY, mcpTools_contract_CREATE_ONTOLOGY_VERSION as CREATE_ONTOLOGY_VERSION, mcpTools_contract_CREATE_QUESTION as CREATE_QUESTION, mcpTools_contract_CREATE_TASK as CREATE_TASK, mcpTools_contract_CREATE_TOPIC as CREATE_TOPIC, mcpTools_contract_DEPRECATE_ONTOLOGY_VERSION as DEPRECATE_ONTOLOGY_VERSION, mcpTools_contract_DETECT_CONFIRMATION_BIAS as DETECT_CONFIRMATION_BIAS, mcpTools_contract_EXECUTE_DEEP_RESEARCH as EXECUTE_DEEP_RESEARCH, mcpTools_contract_FILTER_BY_PERMISSION as FILTER_BY_PERMISSION, mcpTools_contract_FIND_CONTRADICTIONS as FIND_CONTRADICTIONS, mcpTools_contract_FIND_MISSING_QUESTIONS as FIND_MISSING_QUESTIONS, mcpTools_contract_FLAG_CONTRADICTION as FLAG_CONTRADICTION, mcpTools_contract_FORK_BELIEF as FORK_BELIEF, mcpTools_contract_GET_ANSWER as GET_ANSWER, mcpTools_contract_GET_AUDIT_TRAIL as GET_AUDIT_TRAIL, mcpTools_contract_GET_BELIEF as GET_BELIEF, mcpTools_contract_GET_CHANGE_HISTORY as GET_CHANGE_HISTORY, mcpTools_contract_GET_CODE_CONTEXT as GET_CODE_CONTEXT, mcpTools_contract_GET_CONFIDENCE_HISTORY as GET_CONFIDENCE_HISTORY, mcpTools_contract_GET_EVIDENCE as GET_EVIDENCE, mcpTools_contract_GET_FAILURE_LOG as GET_FAILURE_LOG, mcpTools_contract_GET_FALSIFICATION_QUESTIONS as GET_FALSIFICATION_QUESTIONS, mcpTools_contract_GET_GRAPH_GAPS as GET_GRAPH_GAPS, mcpTools_contract_GET_GRAPH_NEIGHBORHOOD as GET_GRAPH_NEIGHBORHOOD, mcpTools_contract_GET_GRAPH_STRUCTURE_ANALYSIS as GET_GRAPH_STRUCTURE_ANALYSIS, mcpTools_contract_GET_HIGH_PRIORITY_QUESTIONS as GET_HIGH_PRIORITY_QUESTIONS, mcpTools_contract_GET_OBSERVATION_CONTEXT as GET_OBSERVATION_CONTEXT, mcpTools_contract_GET_ONTOLOGY as GET_ONTOLOGY, mcpTools_contract_GET_QUESTION as GET_QUESTION, mcpTools_contract_GET_TOPIC as GET_TOPIC, mcpTools_contract_GET_TOPIC_COVERAGE as GET_TOPIC_COVERAGE, mcpTools_contract_GET_TOPIC_TREE as GET_TOPIC_TREE, mcpTools_contract_GIT_SEMANTIC_REQUIRED_TOOLS as GIT_SEMANTIC_REQUIRED_TOOLS, mcpTools_contract_IDENTITY_WHOAMI as IDENTITY_WHOAMI, mcpTools_contract_INGEST_OBSERVATION as INGEST_OBSERVATION, mcpTools_contract_LINK_EVIDENCE as LINK_EVIDENCE, mcpTools_contract_LINK_EVIDENCE_TO_BELIEF as LINK_EVIDENCE_TO_BELIEF, mcpTools_contract_LINK_EVIDENCE_TO_QUESTION as LINK_EVIDENCE_TO_QUESTION, mcpTools_contract_LIST_ALL_WORKTREES as LIST_ALL_WORKTREES, mcpTools_contract_LIST_BELIEFS as LIST_BELIEFS, mcpTools_contract_LIST_EVIDENCE as LIST_EVIDENCE, mcpTools_contract_LIST_LENSES as LIST_LENSES, mcpTools_contract_LIST_ONTOLOGIES as LIST_ONTOLOGIES, mcpTools_contract_LIST_QUESTIONS as LIST_QUESTIONS, LIST_TASKS$1 as LIST_TASKS, mcpTools_contract_LIST_TOPICS as LIST_TOPICS, mcpTools_contract_LIST_WORKTREES as LIST_WORKTREES, mcpTools_contract_MANAGE_WRITE_POLICY as MANAGE_WRITE_POLICY, mcpTools_contract_MATCH_ENTITY_TYPE as MATCH_ENTITY_TYPE, mcpTools_contract_MCP_TOOL_CONTRACTS as MCP_TOOL_CONTRACTS, mcpTools_contract_MERGE as MERGE, mcpTools_contract_MODULATE_CONFIDENCE as MODULATE_CONFIDENCE, type mcpTools_contract_McpParameterDef as McpParameterDef, type mcpTools_contract_McpResponseDef as McpResponseDef, type mcpTools_contract_McpToolContract as McpToolContract, mcpTools_contract_OPEN_PULL_REQUEST as OPEN_PULL_REQUEST, mcpTools_contract_PUBLISH_ONTOLOGY_VERSION as PUBLISH_ONTOLOGY_VERSION, mcpTools_contract_PUSH as PUSH, mcpTools_contract_QUERY_LINEAGE as QUERY_LINEAGE, mcpTools_contract_RECORD_ATTEMPT as RECORD_ATTEMPT, mcpTools_contract_RECORD_JUDGMENT as RECORD_JUDGMENT, mcpTools_contract_REFINE_BELIEF as REFINE_BELIEF, mcpTools_contract_REFINE_QUESTION as REFINE_QUESTION, mcpTools_contract_REMOVE_LENS_FROM_TOPIC as REMOVE_LENS_FROM_TOPIC, mcpTools_contract_RESOLVE_EFFECTIVE_ONTOLOGY as RESOLVE_EFFECTIVE_ONTOLOGY, mcpTools_contract_SEARCH_BELIEFS as SEARCH_BELIEFS, mcpTools_contract_SEARCH_EVIDENCE as SEARCH_EVIDENCE, mcpTools_contract_SEARCH_RESOURCES as SEARCH_RESOURCES, mcpTools_contract_SEARCH_SOURCES as SEARCH_SOURCES, mcpTools_contract_TRACE_ENTITY_IMPACT as TRACE_ENTITY_IMPACT, mcpTools_contract_TRAVERSE_GRAPH as TRAVERSE_GRAPH, mcpTools_contract_UPDATE_ONTOLOGY as UPDATE_ONTOLOGY, mcpTools_contract_UPDATE_QUESTION_STATUS as UPDATE_QUESTION_STATUS, UPDATE_TASK$1 as UPDATE_TASK, mcpTools_contract_UPDATE_TOPIC as UPDATE_TOPIC, mcpTools_contract_UPDATE_WORKTREE_METADATA as UPDATE_WORKTREE_METADATA, mcpTools_contract_UPDATE_WORKTREE_TARGETS as UPDATE_WORKTREE_TARGETS, mcpTools_contract_validateGitSemantics as validateGitSemantics };
+}
+
+/**
+ * @lucern/contracts — OntologiesV1 namespace (resource contracts)
+ *
+ * Ontology Matching Engine — L0 entity type classification and similarity scoring.
+ * Provides bigram-based text similarity for matching free text against
+ * ontology entity types. Domain-agnostic: works identically for companies,
+ * molecules, code modules, or any tenant-defined entity vocabulary.
+ *
+ * Moved from src/ontology-matching.contract.ts in EK-16 T1 PR 2.
+ * Compat shim remains at the old path until the Lucern 1.0.0 cut.
+ */
+/** An entity type definition from a resolved ontology version. */
+type OntologyEntityType = {
+    value: string;
+    label: string;
+    description?: string;
+    subtypes?: Array<{
+        value: string;
+        label: string;
+        description?: string;
+    }>;
+};
+/** A scored match between input text and an entity type. */
+type EntityTypeMatch = {
+    entityType: string;
+    label: string;
+    score: number;
+    reason: string;
+};
+/** A candidate entity node that can be matched against a target node. */
+type EntityMatchCandidate = {
+    nodeId: string;
+    entityType: string;
+    title: string;
+    canonicalText: string;
+    connectedBeliefCount: number;
+    connectedEvidenceCount: number;
+};
+/** A scored entity match with suggested bridge edge type. */
+type EntityConnectionMatch = {
+    entityNodeId: string;
+    entityType: string;
+    title: string;
+    score: number;
+    suggestedEdgeType: string;
+    reason: string;
+};
+/**
+ * Score how well input text matches a single entity type definition.
+ * Combines bigram Jaccard similarity, word overlap, and description matching.
+ */
+declare function scoreEntityTypeMatch(inputText: string, entityType: OntologyEntityType): EntityTypeMatch;
+/**
+ * Rank all entity types in an ontology against input text.
+ * Returns matches sorted by score (descending), filtered to score > minScore.
+ */
+declare function rankEntityTypeMatches(inputText: string, entityTypes: OntologyEntityType[], options?: {
+    minScore?: number;
+    limit?: number;
+}): EntityTypeMatch[];
+/**
+ * Score how well a node's text matches an entity candidate.
+ * Used by discover_entity_connections to suggest missing bridge edges.
+ */
+declare function scoreEntityConnection(nodeText: string, candidate: EntityMatchCandidate, options?: {
+    connectivityWeight?: number;
+}): EntityConnectionMatch;
+/**
+ * Rank entity candidates against a node's text.
+ * Returns sorted matches above the minimum score threshold.
+ */
+declare function rankEntityConnections(nodeText: string, candidates: EntityMatchCandidate[], options?: {
+    minScore?: number;
+    limit?: number;
+    connectivityWeight?: number;
+}): EntityConnectionMatch[];
+
+/**
+ * Prompt contract for portable, provider-agnostic prompt artifacts.
+ */
+type LucernPromptModelHint = "fast" | "balanced" | "strong";
+type LucernPrompt = {
+    /** Stable prompt identifier, e.g. "lucern/classify-evidence" */
+    slug: string;
+    /** Semver-ish prompt version, e.g. "1.0.0" */
+    version: string;
+    /** Prompt template text (supports {{variable}} interpolation) */
+    template: string;
+    /** Variables expected by the template */
+    variables: string[];
+    /** Model family hint for runtime model routing */
+    modelHint: LucernPromptModelHint;
+    /** Metadata used for ownership and discovery */
+    metadata: {
+        author: string;
+        createdAt: string;
+        description: string;
+        tags: string[];
+    };
+};
+declare function isLucernPrompt(value: unknown): value is LucernPrompt;
+
+/**
+ * SDK Method Contract Definitions
+ *
+ * Canonical method signatures for the Lucern TypeScript SDK.
+ * DERIVED from API contracts — not independently authored.
+ *
+ * These types define the public API of `@lucern/sdk`, covering:
+ *   - client initialization (formerly @lucern/sdk-core)
+ *   - belief, evidence, edge, contradiction operations (formerly @lucern/sdk-graph)
+ *   - branch, worktree, merge, push, pull request lifecycle (formerly @lucern/sdk-workflows)
+ *
+ * Historical note: T7.3.2 (2026-04-18) deleted the three sdk-alpha shim
+ * packages; all surfaces now ship in the single `@lucern/sdk` package.
+ *
+ * CONTRACT SURFACE: Method signatures are semver-bound.
+ * Adding optional parameters is non-breaking.
+ * Changing required parameters or return types is BREAKING.
+ */
+
+type LucernClientConfig = {
+    apiKey: string;
+    environment: "sandbox" | "production";
+    /** Optional base URL override for self-hosted deployments */
+    baseUrl?: string;
+};
+type LucernClient = {
+    /** The authenticated client instance */
+    readonly config: LucernClientConfig;
+};
+/** Input to createBelief() */
+type CreateBeliefInput = {
+    canonicalText: string;
+    topicId: string;
+    /** @deprecated Use topicId. */
+    projectId?: string;
+    layer?: EpistemicLayer;
+    domain?: string;
+    nodeType?: string;
+};
+/** Result of createBelief() */
+type BeliefResult = {
+    nodeId: string;
+    globalId: string;
+    canonicalText: string;
+    status: BeliefStatus;
+    createdAt: number;
+};
+/** Input to refineBelief() */
+type RefineBeliefInput = {
+    canonicalText: string;
+    rationale?: string;
+};
+/** Input to modulateConfidence() */
+type ModulateConfidenceInput = {
+    confidence: number;
+    trigger: ConfidenceTrigger;
+    rationale: string;
+};
+/** Result of modulateConfidence() */
+type ConfidenceResult = {
+    nodeId: string;
+    newConfidence: number;
+    previousConfidence: number | null;
+    trigger: ConfidenceTrigger;
+};
+/** Input to forkBelief() */
+type ForkBeliefInput = {
+    newFormulation: string;
+    forkReason: ForkReason;
+};
+/** Result of forkBelief() */
+type ForkResult = {
+    nodeId: string;
+    parentNodeId: string;
+    forkReason: ForkReason;
+    canonicalText: string;
+};
+/** Input to addEvidence() */
+type AddEvidenceInput = {
+    canonicalText: string;
+    topicId: string;
+    /** @deprecated Use topicId. */
+    projectId?: string;
+    sourceUrl?: string;
+    supports?: {
+        nodeId: string;
+        weight: number;
+        reasoning?: string;
+    };
+};
+/** Result of addEvidence() */
+type EvidenceResult = {
+    nodeId: string;
+    globalId: string;
+    edgeId?: string;
+};
+/** Input to flagContradiction() */
+type FlagContradictionInput = {
+    beliefA: string;
+    beliefB: string;
+    description: string;
+    severity: ContradictionSeverity;
+    topicId: string;
+    /** @deprecated Use topicId. */
+    projectId?: string;
+    defeatType?: DefeatType;
+};
+/** Result of flagContradiction() */
+type ContradictionResult = {
+    contradictionId: string;
+    status: "unresolved";
+    beliefA: string;
+    beliefB: string;
+    defeatType?: DefeatType;
+};
+/** Input to createEdge() */
+type CreateEdgeInput = {
+    sourceId: string;
+    targetId: string;
+    edgeType: string;
+    weight?: number;
+    reasoning?: string;
+    reasoningMethod?: ReasoningMethod;
+};
+/** Result of createEdge() */
+type EdgeResult = {
+    globalId: string;
+    edgeType: string;
+    fromLayer: EpistemicLayer;
+    toLayer: EpistemicLayer;
+};
+/** Input to queryLineage() */
+type QueryLineageInput = {
+    depth?: number;
+};
+/** Result of queryLineage() */
+type LineageResult = {
+    chain: Array<{
+        nodeId: string;
+        canonicalText: string;
+        confidence: number | null;
+        forkedFrom: string | null;
+        scoredAt: number | null;
+    }>;
+    forkTree: Record<string, string[]>;
+    depth: number;
+};
+/** Input to searchBeliefs() */
+type SearchBeliefsInput = {
+    query: string;
+    status?: BeliefStatus;
+    minConfidence?: number;
+    topicId?: string;
+    /** @deprecated Use topicId. */
+    projectId?: string;
+    limit?: number;
+};
+/** Input to context.compile() */
+type CompileContextInput = {
+    query?: string;
+    budget?: number;
+    ranking?: ContextRankingProfile;
+    limit?: number;
+    maxDepth?: number;
+    includeEntities?: boolean;
+};
+/** Result of context.compile() */
+type CompiledContextResult = PublicCompiledContext;
+/** Input to addWorktree() — like git worktree add <branch> */
+type AddWorktreeInput = {
+    title: string;
+    topicId: string;
+    /** @deprecated Use topicId. */
+    projectId?: string;
+    branchId?: string;
+    objective?: string;
+    hypothesis?: string;
+    beliefIds?: string[];
+    autoShape?: boolean;
+    domainPackId?: string;
+    executionOrder?: number;
+    dependsOn?: string[];
+    blocks?: string[];
+    gate?: string;
+};
+/** Result of addWorktree() */
+type WorktreeResult = {
+    worktreeId: string;
+    title: string;
+    status: string;
+    hypothesis?: string;
+    questionCount?: number;
+    taskCount?: number;
+    autoShapeApplied?: boolean;
+};
+/** Input to merge() */
+type MergeInput = {
+    outcomes: Array<{
+        beliefId: string;
+        confidence: number;
+        rationale: string;
+    }>;
+    summary?: string;
+};
+/** Result of merge() */
+type MergeResult = {
+    worktreeId: string;
+    status: "merged";
+    outcome: MergeOutcome;
+    beliefsScored: number;
+};
+/** Input to recordJudgment() */
+type RecordJudgmentInput = {
+    title: string;
+    rationale: string;
+    topicId: string;
+    /** @deprecated Use topicId. */
+    projectId?: string;
+    beliefIds?: string[];
+    confidence?: number;
+    judgmentType?: JudgmentType;
+};
+/** Result of recordJudgment() */
+type JudgmentResult = {
+    judgmentId: string;
+    title: string;
+    status: "issued";
+};
+/** Input to createBranch() */
+type CreateBranchInput = {
+    name: string;
+    topicId: string;
+    /** @deprecated Use topicId. */
+    projectId?: string;
+    description?: string;
+};
+/** Result of createBranch() */
+type BranchResult = {
+    branchId: string;
+    name: string;
+    status: BranchStatus;
+    createdAt: number;
+};
+/** Input to push() */
+type PushInput = {
+    targetContext: string;
+    beliefIds?: string[];
+};
+/** Result of push() */
+type PushResult = {
+    pushedCount: number;
+    targetContext: string;
+    pushedAt: number;
+};
+/** Input to openPullRequest() */
+type OpenPullRequestInput = {
+    reviewers?: string[];
+    summary: string;
+};
+/** Result of openPullRequest() */
+type PullRequestResult = {
+    pullRequestId: string;
+    worktreeId: string;
+    status: PullRequestStatus;
+};
+/** Input to bisectConfidence() */
+type BisectConfidenceInput = {
+    expectedDirection: "overconfident" | "underconfident";
+    timeRange?: {
+        start: number;
+        end: number;
+    };
+};
+/** Result of bisectConfidence() */
+type BisectResult = {
+    inflectionEntry: {
+        confidence: number;
+        trigger: ConfidenceTrigger;
+        rationale: string;
+        timestamp: number;
+    };
+    triggerEvent: string;
+    confidenceBefore: number;
+    confidenceAfter: number;
+};
+/**
+ * @lucern/sdk (graph) method signatures.
+ *
+ * These define the public API. Implementation must match these signatures.
+ * Parameters are the source of truth — generated from API contracts.
+ */
+type LucernGraphMethods = {
+    createBelief(client: LucernClient, input: CreateBeliefInput): Promise<BeliefResult>;
+    refineBelief(client: LucernClient, nodeId: string, input: RefineBeliefInput): Promise<BeliefResult>;
+    modulateConfidence(client: LucernClient, nodeId: string, input: ModulateConfidenceInput): Promise<ConfidenceResult>;
+    forkBelief(client: LucernClient, nodeId: string, input: ForkBeliefInput): Promise<ForkResult>;
+    archiveBelief(client: LucernClient, nodeId: string, rationale?: string): Promise<{
+        nodeId: string;
+        status: "archived";
+    }>;
+    addEvidence(client: LucernClient, input: AddEvidenceInput): Promise<EvidenceResult>;
+    flagContradiction(client: LucernClient, input: FlagContradictionInput): Promise<ContradictionResult>;
+    createEdge(client: LucernClient, input: CreateEdgeInput): Promise<EdgeResult>;
+    queryLineage(client: LucernClient, nodeId: string, input?: QueryLineageInput): Promise<LineageResult>;
+    getConfidenceHistory(client: LucernClient, nodeId: string): Promise<{
+        entries: Array<{
+            confidence: number;
+            trigger: ConfidenceTrigger;
+            rationale: string;
+            timestamp: number;
+            userId: string;
+        }>;
+    }>;
+    getAuditTrail(client: LucernClient, nodeId: string, limit?: number): Promise<{
+        entries: Array<{
+            action: string;
+            actor: string;
+            timestamp: number;
+            rationale?: string;
+        }>;
+    }>;
+    searchBeliefs(client: LucernClient, input: SearchBeliefsInput): Promise<{
+        results: BeliefResult[];
+    }>;
+    findContradictions(client: LucernClient, input: {
+        topicId?: string;
+        projectId?: string;
+        nodeId?: string;
+        status?: string;
+    }): Promise<{
+        contradictions: ContradictionResult[];
+    }>;
+    traverseGraph(client: LucernClient, input: {
+        startNode: string;
+        direction?: "up" | "down" | "both";
+        maxDepth?: number;
+    }): Promise<{
+        nodes: unknown[];
+        edges: unknown[];
+        depth: number;
+    }>;
+    bisectConfidence(client: LucernClient, nodeId: string, input: BisectConfidenceInput): Promise<BisectResult>;
+    recordJudgment(client: LucernClient, input: RecordJudgmentInput): Promise<JudgmentResult>;
+};
+/**
+ * @lucern/sdk (workflows) method signatures.
+ *
+ * Lifecycle: createBranch (git branch) → addWorktree (git worktree add) →
+ *   openPullRequest (git pull request) → merge (git merge) → push (git push)
+ */
+type LucernWorkflowMethods = {
+    createBranch(client: LucernClient, input: CreateBranchInput): Promise<BranchResult>;
+    addWorktree(client: LucernClient, input: AddWorktreeInput): Promise<WorktreeResult>;
+    merge(client: LucernClient, worktreeId: string, input: MergeInput): Promise<MergeResult>;
+    openPullRequest(client: LucernClient, worktreeId: string, input: OpenPullRequestInput): Promise<PullRequestResult>;
+    push(client: LucernClient, worktreeId: string, input: PushInput): Promise<PushResult>;
+};
+
+/**
+ * SDK-Only Tool Contract Definitions
+ *
+ * Tools available in @lucern/sdk but NOT in the MCP gateway.
+ * The SDK unfolds deeper capabilities after the MCP gateway shows developers what's possible.
+ *
+ * Total SDK surface = MCP tools (44) + SDK-only tools (44) = 88 tools
+ *
+ * These tools are organized into capability tiers:
+ * - Advanced workflow & phase management (12 tools)
+ * - Deeper graph navigation (6 tools)
+ * - Conviction & analytics (7 tools)
+ * - Extended question & evidence analytics (1 tool; core lifecycle promoted to MCP)
+ * - Task lifecycle (5 tools)
+ * - Domain analytics (8 tools)
+ * - Bias detection suite (5 tools)
+ *
+ * CONTRACT SURFACE: These definitions are the external API for SDK consumers.
+ * Renaming a tool or changing its description is a BREAKING CHANGE.
+ *
+ * Git-native naming rules (same as MCP, enforced by lint):
+ *   1. Workflow tools use git verbs directly
+ *   2. Knowledge tools use epistemic verbs
+ *   3. First sentence of description includes the git analog verb
+ *   4. Description includes "Like `git X`" parenthetical
+ *   5. Parameter names use domain terms (canonicalText, nodeId, confidence)
+ */
+
+/** SDK-only tool contract — same shape as MCP but with sdk-only tier marker */
+interface SdkToolContract extends Omit<McpToolContract, "tier"> {
+    tier: "sdk-only";
+}
+declare const START_WORKTREE: SdkToolContract;
+declare const UPDATE_WORKTREE_PHASE: SdkToolContract;
+declare const ADVANCE_WORKTREE_PHASE: SdkToolContract;
+declare const ADD_NOTE_TO_WORKTREE: SdkToolContract;
+declare const LINK_DOCUMENT_TO_WORKTREE: SdkToolContract;
+declare const LINK_EVIDENCE_TO_WORKTREE: SdkToolContract;
+declare const LINK_QUESTION_TO_WORKTREE: SdkToolContract;
+declare const LINK_BELIEF_TO_WORKTREE: SdkToolContract;
+declare const CREATE_SYNTHESIZED_BELIEF: SdkToolContract;
+declare const COMPLETE_HYPOTHESIS_FORMATION: SdkToolContract;
+declare const COMPLETE_EVIDENCE_REVIEW: SdkToolContract;
+declare const REFINE_WORKTREE_BELIEF: SdkToolContract;
+declare const TRACE_PROVENANCE: SdkToolContract;
+declare const GET_BELIEF_RELATIONSHIPS: SdkToolContract;
+declare const GET_BELIEF_SUPPORT_CHAIN: SdkToolContract;
+declare const EXPLORE_CONNECTIONS: SdkToolContract;
+declare const GET_DEEP_LINEAGE: SdkToolContract;
+declare const GRAPH_AWARE_SEARCH: SdkToolContract;
+declare const GET_COLLECTION_CONVICTION: SdkToolContract;
+declare const GET_CONVICTION_TREND: SdkToolContract;
+declare const ANALYZE_BELIEF_CRITICALITY: SdkToolContract;
+declare const ANALYZE_BELIEF_CLUSTER_CANDIDATES: SdkToolContract;
+declare const CREATE_BELIEF_CONDITIONAL: SdkToolContract;
+declare const GET_NECESSARY_EVIDENCE: SdkToolContract;
+declare const ANALYZE_REASONING_DEPTH: SdkToolContract;
+declare const GET_EVIDENCE_BY_METHODOLOGY: SdkToolContract;
+declare const CREATE_EVIDENCE_TASK: SdkToolContract;
+declare const LIST_TASKS: SdkToolContract;
+declare const UPDATE_TASK: SdkToolContract;
+declare const GET_TASK_COUNTS: SdkToolContract;
+declare const ADD_RESEARCH_ACTION: SdkToolContract;
+declare const GET_PREDICTIONS: SdkToolContract;
+declare const GET_SURPRISE_DETECTION: SdkToolContract;
+declare const GET_CHALLENGED_BELIEFS: SdkToolContract;
+declare const GET_CAUSAL_CHAINS: SdkToolContract;
+declare const GET_NON_CONSENSUS_BELIEFS: SdkToolContract;
+declare const GET_BELIEFS_BY_EPISTEMIC_STATUS: SdkToolContract;
+declare const GET_PRIVILEGED_EVIDENCE: SdkToolContract;
+declare const GET_PRIVILEGED_SIGNALS: SdkToolContract;
+declare const DETECT_ANCHORING_BIAS: SdkToolContract;
+declare const DETECT_SOURCE_CONCENTRATION: SdkToolContract;
+declare const FIND_SOFT_CONTRADICTIONS: SdkToolContract;
+declare const FIND_SEMANTIC_BRIDGES: SdkToolContract;
+declare const FIND_SEMANTIC_ORPHANS: SdkToolContract;
+/** All SDK-only tool contracts, indexed by name */
+declare const SDK_ONLY_TOOL_CONTRACTS: Record<string, SdkToolContract>;
+/** Complete SDK surface: MCP gateway tools + SDK-only advanced tools */
+declare const ALL_SDK_TOOL_CONTRACTS: Record<string, McpToolContract | SdkToolContract>;
+/** All SDK-only tool names */
+declare const SDK_ONLY_TOOL_NAMES: string[];
+/** All tool names across the complete SDK surface */
+declare const ALL_SDK_TOOL_NAMES: string[];
+/**
+ * Lint validation: every SDK tool description must contain "Like `git" reference.
+ * Reuses the same git-semantic validation rule as MCP tools.
+ */
+declare function validateSdkGitSemantics(tool: SdkToolContract): {
+    valid: boolean;
+    reason?: string;
+};
+
+declare const sdkTools_contract_ADD_NOTE_TO_WORKTREE: typeof ADD_NOTE_TO_WORKTREE;
+declare const sdkTools_contract_ADD_RESEARCH_ACTION: typeof ADD_RESEARCH_ACTION;
+declare const sdkTools_contract_ADVANCE_WORKTREE_PHASE: typeof ADVANCE_WORKTREE_PHASE;
+declare const sdkTools_contract_ALL_SDK_TOOL_CONTRACTS: typeof ALL_SDK_TOOL_CONTRACTS;
+declare const sdkTools_contract_ALL_SDK_TOOL_NAMES: typeof ALL_SDK_TOOL_NAMES;
+declare const sdkTools_contract_ANALYZE_BELIEF_CLUSTER_CANDIDATES: typeof ANALYZE_BELIEF_CLUSTER_CANDIDATES;
+declare const sdkTools_contract_ANALYZE_BELIEF_CRITICALITY: typeof ANALYZE_BELIEF_CRITICALITY;
+declare const sdkTools_contract_ANALYZE_REASONING_DEPTH: typeof ANALYZE_REASONING_DEPTH;
+declare const sdkTools_contract_COMPLETE_EVIDENCE_REVIEW: typeof COMPLETE_EVIDENCE_REVIEW;
+declare const sdkTools_contract_COMPLETE_HYPOTHESIS_FORMATION: typeof COMPLETE_HYPOTHESIS_FORMATION;
+declare const sdkTools_contract_CREATE_BELIEF_CONDITIONAL: typeof CREATE_BELIEF_CONDITIONAL;
+declare const sdkTools_contract_CREATE_EVIDENCE_TASK: typeof CREATE_EVIDENCE_TASK;
+declare const sdkTools_contract_CREATE_SYNTHESIZED_BELIEF: typeof CREATE_SYNTHESIZED_BELIEF;
+declare const sdkTools_contract_DETECT_ANCHORING_BIAS: typeof DETECT_ANCHORING_BIAS;
+declare const sdkTools_contract_DETECT_SOURCE_CONCENTRATION: typeof DETECT_SOURCE_CONCENTRATION;
+declare const sdkTools_contract_EXPLORE_CONNECTIONS: typeof EXPLORE_CONNECTIONS;
+declare const sdkTools_contract_FIND_SEMANTIC_BRIDGES: typeof FIND_SEMANTIC_BRIDGES;
+declare const sdkTools_contract_FIND_SEMANTIC_ORPHANS: typeof FIND_SEMANTIC_ORPHANS;
+declare const sdkTools_contract_FIND_SOFT_CONTRADICTIONS: typeof FIND_SOFT_CONTRADICTIONS;
+declare const sdkTools_contract_GET_BELIEFS_BY_EPISTEMIC_STATUS: typeof GET_BELIEFS_BY_EPISTEMIC_STATUS;
+declare const sdkTools_contract_GET_BELIEF_RELATIONSHIPS: typeof GET_BELIEF_RELATIONSHIPS;
+declare const sdkTools_contract_GET_BELIEF_SUPPORT_CHAIN: typeof GET_BELIEF_SUPPORT_CHAIN;
+declare const sdkTools_contract_GET_CAUSAL_CHAINS: typeof GET_CAUSAL_CHAINS;
+declare const sdkTools_contract_GET_CHALLENGED_BELIEFS: typeof GET_CHALLENGED_BELIEFS;
+declare const sdkTools_contract_GET_COLLECTION_CONVICTION: typeof GET_COLLECTION_CONVICTION;
+declare const sdkTools_contract_GET_CONVICTION_TREND: typeof GET_CONVICTION_TREND;
+declare const sdkTools_contract_GET_DEEP_LINEAGE: typeof GET_DEEP_LINEAGE;
+declare const sdkTools_contract_GET_EVIDENCE_BY_METHODOLOGY: typeof GET_EVIDENCE_BY_METHODOLOGY;
+declare const sdkTools_contract_GET_NECESSARY_EVIDENCE: typeof GET_NECESSARY_EVIDENCE;
+declare const sdkTools_contract_GET_NON_CONSENSUS_BELIEFS: typeof GET_NON_CONSENSUS_BELIEFS;
+declare const sdkTools_contract_GET_PREDICTIONS: typeof GET_PREDICTIONS;
+declare const sdkTools_contract_GET_PRIVILEGED_EVIDENCE: typeof GET_PRIVILEGED_EVIDENCE;
+declare const sdkTools_contract_GET_PRIVILEGED_SIGNALS: typeof GET_PRIVILEGED_SIGNALS;
+declare const sdkTools_contract_GET_SURPRISE_DETECTION: typeof GET_SURPRISE_DETECTION;
+declare const sdkTools_contract_GET_TASK_COUNTS: typeof GET_TASK_COUNTS;
+declare const sdkTools_contract_GRAPH_AWARE_SEARCH: typeof GRAPH_AWARE_SEARCH;
+declare const sdkTools_contract_LINK_BELIEF_TO_WORKTREE: typeof LINK_BELIEF_TO_WORKTREE;
+declare const sdkTools_contract_LINK_DOCUMENT_TO_WORKTREE: typeof LINK_DOCUMENT_TO_WORKTREE;
+declare const sdkTools_contract_LINK_EVIDENCE_TO_WORKTREE: typeof LINK_EVIDENCE_TO_WORKTREE;
+declare const sdkTools_contract_LINK_QUESTION_TO_WORKTREE: typeof LINK_QUESTION_TO_WORKTREE;
+declare const sdkTools_contract_LIST_TASKS: typeof LIST_TASKS;
+declare const sdkTools_contract_REFINE_WORKTREE_BELIEF: typeof REFINE_WORKTREE_BELIEF;
+declare const sdkTools_contract_SDK_ONLY_TOOL_CONTRACTS: typeof SDK_ONLY_TOOL_CONTRACTS;
+declare const sdkTools_contract_SDK_ONLY_TOOL_NAMES: typeof SDK_ONLY_TOOL_NAMES;
+declare const sdkTools_contract_START_WORKTREE: typeof START_WORKTREE;
+type sdkTools_contract_SdkToolContract = SdkToolContract;
+declare const sdkTools_contract_TRACE_PROVENANCE: typeof TRACE_PROVENANCE;
+declare const sdkTools_contract_UPDATE_TASK: typeof UPDATE_TASK;
+declare const sdkTools_contract_UPDATE_WORKTREE_PHASE: typeof UPDATE_WORKTREE_PHASE;
+declare const sdkTools_contract_validateSdkGitSemantics: typeof validateSdkGitSemantics;
+declare namespace sdkTools_contract {
+  export { sdkTools_contract_ADD_NOTE_TO_WORKTREE as ADD_NOTE_TO_WORKTREE, sdkTools_contract_ADD_RESEARCH_ACTION as ADD_RESEARCH_ACTION, sdkTools_contract_ADVANCE_WORKTREE_PHASE as ADVANCE_WORKTREE_PHASE, sdkTools_contract_ALL_SDK_TOOL_CONTRACTS as ALL_SDK_TOOL_CONTRACTS, sdkTools_contract_ALL_SDK_TOOL_NAMES as ALL_SDK_TOOL_NAMES, sdkTools_contract_ANALYZE_BELIEF_CLUSTER_CANDIDATES as ANALYZE_BELIEF_CLUSTER_CANDIDATES, sdkTools_contract_ANALYZE_BELIEF_CRITICALITY as ANALYZE_BELIEF_CRITICALITY, sdkTools_contract_ANALYZE_REASONING_DEPTH as ANALYZE_REASONING_DEPTH, sdkTools_contract_COMPLETE_EVIDENCE_REVIEW as COMPLETE_EVIDENCE_REVIEW, sdkTools_contract_COMPLETE_HYPOTHESIS_FORMATION as COMPLETE_HYPOTHESIS_FORMATION, sdkTools_contract_CREATE_BELIEF_CONDITIONAL as CREATE_BELIEF_CONDITIONAL, sdkTools_contract_CREATE_EVIDENCE_TASK as CREATE_EVIDENCE_TASK, sdkTools_contract_CREATE_SYNTHESIZED_BELIEF as CREATE_SYNTHESIZED_BELIEF, sdkTools_contract_DETECT_ANCHORING_BIAS as DETECT_ANCHORING_BIAS, sdkTools_contract_DETECT_SOURCE_CONCENTRATION as DETECT_SOURCE_CONCENTRATION, sdkTools_contract_EXPLORE_CONNECTIONS as EXPLORE_CONNECTIONS, sdkTools_contract_FIND_SEMANTIC_BRIDGES as FIND_SEMANTIC_BRIDGES, sdkTools_contract_FIND_SEMANTIC_ORPHANS as FIND_SEMANTIC_ORPHANS, sdkTools_contract_FIND_SOFT_CONTRADICTIONS as FIND_SOFT_CONTRADICTIONS, sdkTools_contract_GET_BELIEFS_BY_EPISTEMIC_STATUS as GET_BELIEFS_BY_EPISTEMIC_STATUS, sdkTools_contract_GET_BELIEF_RELATIONSHIPS as GET_BELIEF_RELATIONSHIPS, sdkTools_contract_GET_BELIEF_SUPPORT_CHAIN as GET_BELIEF_SUPPORT_CHAIN, sdkTools_contract_GET_CAUSAL_CHAINS as GET_CAUSAL_CHAINS, sdkTools_contract_GET_CHALLENGED_BELIEFS as GET_CHALLENGED_BELIEFS, sdkTools_contract_GET_COLLECTION_CONVICTION as GET_COLLECTION_CONVICTION, sdkTools_contract_GET_CONVICTION_TREND as GET_CONVICTION_TREND, sdkTools_contract_GET_DEEP_LINEAGE as GET_DEEP_LINEAGE, sdkTools_contract_GET_EVIDENCE_BY_METHODOLOGY as GET_EVIDENCE_BY_METHODOLOGY, sdkTools_contract_GET_NECESSARY_EVIDENCE as GET_NECESSARY_EVIDENCE, sdkTools_contract_GET_NON_CONSENSUS_BELIEFS as GET_NON_CONSENSUS_BELIEFS, sdkTools_contract_GET_PREDICTIONS as GET_PREDICTIONS, sdkTools_contract_GET_PRIVILEGED_EVIDENCE as GET_PRIVILEGED_EVIDENCE, sdkTools_contract_GET_PRIVILEGED_SIGNALS as GET_PRIVILEGED_SIGNALS, sdkTools_contract_GET_SURPRISE_DETECTION as GET_SURPRISE_DETECTION, sdkTools_contract_GET_TASK_COUNTS as GET_TASK_COUNTS, sdkTools_contract_GRAPH_AWARE_SEARCH as GRAPH_AWARE_SEARCH, sdkTools_contract_LINK_BELIEF_TO_WORKTREE as LINK_BELIEF_TO_WORKTREE, sdkTools_contract_LINK_DOCUMENT_TO_WORKTREE as LINK_DOCUMENT_TO_WORKTREE, sdkTools_contract_LINK_EVIDENCE_TO_WORKTREE as LINK_EVIDENCE_TO_WORKTREE, sdkTools_contract_LINK_QUESTION_TO_WORKTREE as LINK_QUESTION_TO_WORKTREE, sdkTools_contract_LIST_TASKS as LIST_TASKS, sdkTools_contract_REFINE_WORKTREE_BELIEF as REFINE_WORKTREE_BELIEF, sdkTools_contract_SDK_ONLY_TOOL_CONTRACTS as SDK_ONLY_TOOL_CONTRACTS, sdkTools_contract_SDK_ONLY_TOOL_NAMES as SDK_ONLY_TOOL_NAMES, sdkTools_contract_START_WORKTREE as START_WORKTREE, type sdkTools_contract_SdkToolContract as SdkToolContract, sdkTools_contract_TRACE_PROVENANCE as TRACE_PROVENANCE, sdkTools_contract_UPDATE_TASK as UPDATE_TASK, sdkTools_contract_UPDATE_WORKTREE_PHASE as UPDATE_WORKTREE_PHASE, sdkTools_contract_validateSdkGitSemantics as validateSdkGitSemantics };
+}
+
+/**
+ * Shared lexical matching primitives used across MCP handlers and graph utilities.
+ *
+ * The goal is not to replace downstream LLM scoring. It provides a fast,
+ * deterministic substrate for candidate generation, reranking, and light
+ * classification across belief/question/evidence/entity surfaces.
+ */
+type LexicalStrategy = "tokenOverlap" | "bigramJaccard" | "wordOverlap";
+type PreparedLexicalQuery = {
+    raw: string;
+    tokens: string[];
+    words: string[];
+    bigrams: Set<string>;
+};
+type LexicalSignal = {
+    strategy?: LexicalStrategy;
+    text: string | null | undefined;
+    weight: number;
+};
+type LexicalRerankOptions = {
+    lexicalWeight?: number;
+    rankWeight?: number;
+};
+/** Tokenize a string into lowercase words, removing stop words. */
+declare function tokenizeSearchText(text: string): string[];
+/** Simple stemmer: strip common English suffixes for fuzzy matching. */
+declare function stemToken(word: string): string;
+/** Compute token overlap score between query tokens and text tokens. */
+declare function tokenOverlapScore(queryTokens: string[], textTokens: string[]): number;
+/**
+ * Extract character bigrams from text. Normalizes to lowercase, removes
+ * non-alphanumeric characters, and generates overlapping pairs.
+ */
+declare function bigramTokenize(text: string): Set<string>;
+/**
+ * Extract word-level tokens from text (for coarser matching).
+ * Normalizes to lowercase, splits on non-alphanumeric.
+ */
+declare function wordTokenize(text: string): string[];
+/** Jaccard similarity between two sets: |A ∩ B| / |A ∪ B|. */
+declare function jaccardSimilarity(setA: Set<string>, setB: Set<string>): number;
+/** Exact word overlap score: fraction of type words found in input text. */
+declare function wordOverlapScore(inputWords: string[], typeWords: string[]): number;
+/** Pre-compute reusable lexical structures for a query. */
+declare function prepareLexicalQuery(query: string): PreparedLexicalQuery;
+/** Score a single lexical signal against a prepared query. */
+declare function scoreLexicalSignal(query: PreparedLexicalQuery, signal: LexicalSignal): number;
+/** Weighted lexical score across multiple textual signals. */
+declare function scoreLexicalSignals(query: PreparedLexicalQuery, signals: LexicalSignal[]): number;
+/** Map a candidate's original rank position into a 0..1 prior. */
+declare function rankWindowScore(index: number, total: number): number;
+/** Rerank a candidate window by lexical overlap while preserving original-rank prior. */
+declare function rerankLexicalWindow<T>(query: string, items: T[], getText: (item: T) => string | null | undefined, options?: LexicalRerankOptions): T[];
+
+/**
+ * @lucern/contracts — TopicsV1 namespace (resource contracts)
+ *
+ * Moved from src/topic-scope.contract.ts in EK-16 T1 PR 2.
+ * Compat shim remains at the old path until the Lucern 1.0.0 cut.
+ */
+declare const ROOT_TOPIC_ID = "n17tm38rwet7wqgzrmwahyt1z582590y";
+type TopicDoc = {
+    _id: string;
+    name?: string;
+    parentTopicId?: string;
+    depth?: number;
+    type?: string;
+};
+/**
+ * BFS traversal collecting a topic and its neighborhood:
+ * ancestors up to root + descendants down to maxDescendantDepth.
+ */
+declare function collectTopicNeighborhood(topics: TopicDoc[], rootTopicId: string, maxDescendantDepth?: number): string[];
+
+/**
+ * Workflow Runtime Contract v1
+ *
+ * Canonical TypeScript contract for Lucern's graph-local workflow runtime.
+ * WF-1 defines the typed substrate for:
+ *   - workflow definitions and run receipts
+ *   - action mutation tiering and approval expectations
+ *   - hooks over worktree/question/evidence/inbox events
+ *   - output unions for domain-specific artifacts
+ *   - deterministic integrity checks and operational metadata
+ *
+ * BREAKING CHANGE RULES:
+ *   - Adding optional fields is NON-breaking
+ *   - Removing fields or renaming enum values is BREAKING
+ *   - Reclassifying a mutation tier is BREAKING
+ *   - Changing canonical workflow IDs is BREAKING
+ */
+declare const WORKFLOW_RUNTIME_SCHEMA_VERSION: "1.0.0";
+declare const WORKFLOW_MUTATION_TIERS: readonly ["read_only", "low_risk_write", "high_risk_write"];
+type WorkflowMutationTier = (typeof WORKFLOW_MUTATION_TIERS)[number];
+declare const WORKFLOW_APPROVAL_MODES: readonly ["none", "audit_only", "human_required", "auto_approve"];
+type WorkflowApprovalMode = (typeof WORKFLOW_APPROVAL_MODES)[number];
+declare const DEFAULT_TIER_APPROVAL_MODE: Readonly<Record<WorkflowMutationTier, WorkflowApprovalMode>>;
+declare const WORKFLOW_ACTION_KINDS: readonly ["context_pack", "integrity_check", "lucern_tool", "report_compile", "brief_publish", "notification", "custom"];
+type WorkflowActionKind = (typeof WORKFLOW_ACTION_KINDS)[number];
+declare const WORKFLOW_HOOK_EVENTS: readonly ["schedule.tick", "worktree.activated", "worktree.completed", "question.created", "question.answered", "evidence.appended", "inbox.item_created"];
+type WorkflowHookEvent = (typeof WORKFLOW_HOOK_EVENTS)[number];
+declare const WORKFLOW_OUTPUT_KINDS: readonly ["engineering_brief", "research_memo", "strategy_artifact", "inbox_summary", "pipeline_brief", "structured_payload"];
+type WorkflowOutputKind = (typeof WORKFLOW_OUTPUT_KINDS)[number];
+declare const WORKFLOW_RUN_STATUSES: readonly ["queued", "running", "awaiting_approval", "completed", "failed", "cancelled"];
+type WorkflowRunStatus = (typeof WORKFLOW_RUN_STATUSES)[number];
+declare const WORKFLOW_TRIGGER_KINDS: readonly ["manual", "schedule", "hook"];
+type WorkflowTriggerKind = (typeof WORKFLOW_TRIGGER_KINDS)[number];
+declare const WORKFLOW_PROOF_ARTIFACT_KINDS: readonly ["report", "brief", "artifact", "dashboard", "test_evidence"];
+type WorkflowProofArtifactKind = (typeof WORKFLOW_PROOF_ARTIFACT_KINDS)[number];
+declare const WORKFLOW_STAFFING_HINTS: readonly ["solo", "backend+tests", "fullstack", "mcp+tests"];
+type WorkflowStaffingHint = (typeof WORKFLOW_STAFFING_HINTS)[number];
+declare const WORKFLOW_AUTO_FIX_MODES: readonly ["disabled", "dry_run", "safe", "aggressive"];
+type WorkflowAutoFixMode = (typeof WORKFLOW_AUTO_FIX_MODES)[number];
+declare const WORKFLOW_INTEGRITY_CHECKS: readonly ["null_dependency_refs", "superseded_blockers", "band_order_inconsistency", "sparse_shaping", "failed_completed_gate"];
+type WorkflowIntegrityCheckId = (typeof WORKFLOW_INTEGRITY_CHECKS)[number];
+type WorkflowProofArtifact = {
+    kind: WorkflowProofArtifactKind;
+    label: string;
+    required?: boolean;
+    sourceRef?: string;
+};
+type WorkflowAutoFixPolicy = {
+    mode: WorkflowAutoFixMode;
+    maxActionsPerRun?: number;
+    permittedMutationTiers?: WorkflowMutationTier[];
+    requireAuditTrail?: boolean;
+    escalationGate?: string;
+};
+declare const DEFAULT_WORKFLOW_AUTO_FIX_POLICY: WorkflowAutoFixPolicy;
+type WorkflowApprovalPolicy = {
+    mode: WorkflowApprovalMode;
+    approvalGate?: string;
+    autoApprovePolicyKey?: string;
+    rationaleRequired?: boolean;
+};
+type WorkflowOutputBase = {
+    outputId: string;
+    kind: WorkflowOutputKind;
+    title: string;
+    summary: string;
+    generatedAt?: number;
+};
+type EngineeringBriefOutput = WorkflowOutputBase & {
+    kind: "engineering_brief";
+    sections: Array<{
+        heading: string;
+        body: string;
+    }>;
+    touchedPaths?: string[];
+};
+type ResearchMemoOutput = WorkflowOutputBase & {
+    kind: "research_memo";
+    claims: string[];
+    evidenceRefs?: string[];
+};
+type StrategyArtifactOutput = WorkflowOutputBase & {
+    kind: "strategy_artifact";
+    recommendations: string[];
+    decisionWindow?: string;
+};
+type InboxSummaryOutput = WorkflowOutputBase & {
+    kind: "inbox_summary";
+    channel: "developer_portal" | "chat" | "ops";
+    inboxTitle: string;
+    inboxBody: string;
+};
+type PipelineBriefOutput = WorkflowOutputBase & {
+    kind: "pipeline_brief";
+    hingeWorktreeId?: string;
+    groupedBlockers: Array<{
+        blocker: string;
+        blockedWorktreeIds: string[];
+    }>;
+};
+type StructuredPayloadOutput = WorkflowOutputBase & {
+    kind: "structured_payload";
+    payload: Record<string, unknown>;
+};
+type WorkflowOutputContract = EngineeringBriefOutput | ResearchMemoOutput | StrategyArtifactOutput | InboxSummaryOutput | PipelineBriefOutput | StructuredPayloadOutput;
+type WorkflowActionContract = {
+    actionId: string;
+    kind: WorkflowActionKind;
+    title: string;
+    description: string;
+    mutationTier: WorkflowMutationTier;
+    toolName?: string;
+    produces?: WorkflowOutputKind[];
+    idempotent?: boolean;
+    approval: WorkflowApprovalPolicy;
+};
+type WorkflowHookContract = {
+    hookId: string;
+    event: WorkflowHookEvent;
+    description: string;
+    condition?: string;
+    actionIds: string[];
+};
+type WorkflowTriggerContract = {
+    kind: "manual";
+    description?: string;
+} | {
+    kind: "schedule";
+    cadence: "hourly" | "daily" | "weekly";
+    timezone?: string;
+} | {
+    kind: "hook";
+    event: WorkflowHookEvent;
+};
+type WorkflowDefinitionV1 = {
+    workflowId: string;
+    version: typeof WORKFLOW_RUNTIME_SCHEMA_VERSION;
+    title: string;
+    description: string;
+    trigger: WorkflowTriggerContract;
+    staffingHint?: WorkflowStaffingHint;
+    proofArtifacts?: WorkflowProofArtifact[];
+    autoFixPolicy?: WorkflowAutoFixPolicy;
+    actions: readonly WorkflowActionContract[];
+    hooks?: readonly WorkflowHookContract[];
+    outputs: readonly WorkflowOutputKind[];
+    integrityChecks?: readonly WorkflowIntegrityCheckId[];
+};
+type WorkflowRunReceiptV1 = {
+    runId: string;
+    workflowId: string;
+    status: WorkflowRunStatus;
+    triggeredBy: WorkflowTriggerKind;
+    startedAt: number;
+    completedAt?: number;
+    outputKinds: WorkflowOutputKind[];
+    approvalsRequired?: number;
+};
+declare const NIGHTLY_RECONCILIATION_WORKFLOW_ID: "workflow.pipeline_reconciliation.v1";
+declare const MORNING_BRIEF_WORKFLOW_ID: "workflow.morning_brief.v1";
+declare const CANONICAL_WORKFLOW_DEFINITIONS: readonly WorkflowDefinitionV1[];
+
+export { type AddEvidenceInput, type AddWorktreeInput, type AuthContext, BELIEF_STATUSES, BELIEF_TYPE_BONUS, BRANCH_STATUSES, type BeliefLatticeSeed, type BeliefResult, type BeliefStatus, type BisectConfidenceInput, type BisectResult, type BranchResult, type BranchStatus, CANONICAL_WORKFLOW_DEFINITIONS, CONFIDENCE_TRIGGERS, CONTEXT_PACK_SCHEMA_VERSION, CONTEXT_PACK_SECTION_KEYS, CONTEXT_RANKING_PROFILES, CONTRADICTION_SEVERITIES, CONTRADICTION_STATUSES, type CompileContextInput, type CompiledContextResult, type ConfidenceResult, type ConfidenceTrigger, type ContextCompilationMode, type ContextPackBelief, type ContextPackContradiction, type ContextPackDeltaReport, type ContextPackDiagnostics, type ContextPackEntity, type ContextPackEvidence, type ContextPackFailure, type ContextPackFailureContext, type ContextPackInjectionPolicy, type ContextPackQuestion, type ContextPackRequestV1, type ContextPackSectionKey, type ContextPackSummary, type ContextPackV1, type ContextRankingProfile, type ContradictionResult, type ContradictionSeverity, type ContradictionStatus, type ConvexAdminClient, type CreateBeliefInput, type CreateBranchInput, type CreateDomainEventInput, type CreateEdgeInput, type CutoverDomain, type CutoverFlagState, DEFAULT_BELIEF_TYPE_BONUS, DEFAULT_COMPILATION_MODE, DEFAULT_ENTITY_LIMIT, DEFAULT_PRIORITY_SCORE, DEFAULT_RANKING_PROFILE, DEFAULT_SECTION_LIMIT, DEFAULT_SEVERITY_SCORE, DEFAULT_TIER_APPROVAL_MODE, DEFAULT_TOKEN_BUDGET, DEFAULT_WORKFLOW_AUTO_FIX_POLICY, DEFEAT_TYPES, DOMAIN_EVENT_TYPES, DOMAIN_EVENT_VERSION, type DecodedPrefixedId, type DefeatType, type DomainActorType, type DomainEvent, type DomainEventData, type DomainEventType, type DomainResourceType, ENTITY_RANKING_WEIGHTS, EPISTEMIC_LAYERS, EVENT_RETENTION_DEFAULT_DAYS, type EdgeResult, type EngineeringBriefOutput, type EntityConnectionMatch, type EntityMatchCandidate, type EntityTypeMatch, type EpistemicLayer, type EventCursor, type EventListQuery, type EventListResult, type EvidenceResult, FORK_REASONS, type FlagContradictionInput, type ForkBeliefInput, type ForkReason, type ForkResult, type GatewayAuthContext, type GatewayAuthMode, type GatewayEnvironment, type GatewayErrorArgs, type GatewayScope, type GatewaySuccessArgs, INTEGRATION_EDGE_TYPES, type InboxSummaryOutput, type IntegrationEdgeType, JUDGMENT_TYPES, type JudgmentResult, type JudgmentType, type KeyLifecycleStatus, type LexicalRerankOptions, type LexicalSignal, type LexicalStrategy, type LineageResult, type LucernClient, type LucernClientConfig, type LucernGraphMethods, type LucernPrompt, type LucernPromptModelHint, type LucernSdkClient, type LucernWorkflowMethods, MAX_ENTITY_LIMIT, MAX_SECTION_LIMIT, MAX_TOKEN_BUDGET, MERGE_OUTCOMES, MIN_CONTRADICTION_BUDGET, MIN_TOKEN_BUDGET, MIN_TOKEN_ESTIMATE, MORNING_BRIEF_WORKFLOW_ID, type McpTransportKind, type MergeInput, type MergeOutcome, type MergeResult, type ModulateConfidenceInput, NIGHTLY_RECONCILIATION_WORKFLOW_ID, type OntologyEntityType, type OpenPullRequestInput, PRIORITY_SCORES, PULL_REQUEST_STATUSES, type PackWeightOverride, type PipelineBriefOutput, type PlatformApiErrorCode, type PreparedLexicalQuery, type PublicCompiledContext, type PublicContextBelief, type PublicContextContradiction, type PublicContextEntity, type PublicContextEvidence, type PublicContextInjectionPolicy, type PublicContextQuestion, type PullRequestResult, type PullRequestStatus, type PushInput, type PushResult, type QueryLineageInput, RANKING_WEIGHTS, REASONING_METHODS, RECENCY_HALF_LIFE_DAYS, RESOLVED_QUESTION_STATUSES, ROOT_TOPIC_ID, type RankingWeightVector, type ReasoningMethod, type RecordJudgmentInput, type RefineBeliefInput, type ReplayEventsInput, type ReplayEventsResult, type ResearchMemoOutput, SECTION_BUDGET_RATIOS, SESSION_AUTH_MODES, SESSION_LIFECYCLE_STATUSES, SESSION_PRINCIPAL_TYPES, SEVERITY_SCORES, type SearchBeliefsInput, type SessionAuditEnvelope, type SessionAuditOutcome, type SessionAuthMode, type SessionDelegationHop, type SessionLifecycleStatus, type SessionPrincipalType, type StrategyArtifactOutput, type StructuredPayloadOutput, TOKENS_PER_WORD, type TopicDoc, type VerificationObligation, WEBHOOK_MAX_ATTEMPTS, WEBHOOK_RETRY_DELAYS_MS, WORKFLOW_ACTION_KINDS, WORKFLOW_APPROVAL_MODES, WORKFLOW_AUTO_FIX_MODES, WORKFLOW_HOOK_EVENTS, WORKFLOW_INTEGRITY_CHECKS, WORKFLOW_MUTATION_TIERS, WORKFLOW_OUTPUT_KINDS, WORKFLOW_PROOF_ARTIFACT_KINDS, WORKFLOW_RUNTIME_SCHEMA_VERSION, WORKFLOW_RUN_STATUSES, WORKFLOW_STAFFING_HINTS, WORKFLOW_TRIGGER_KINDS, WORKTREE_PHASES, type WebhookCreateInput, type WebhookDeliveriesResult, type WebhookDeliveryAttemptRecord, type WebhookDeliveryRecord, type WebhookDeliveryStatus, type WebhookHealthResult, type WebhookRecord, type WebhookSecretMode, type WebhookTestResult, type WebhookUpdateInput, type WorkflowActionContract, type WorkflowActionKind, type WorkflowApprovalMode, type WorkflowApprovalPolicy, type WorkflowAutoFixMode, type WorkflowAutoFixPolicy, type WorkflowDefinitionV1, type WorkflowHookContract, type WorkflowHookEvent, type WorkflowIntegrityCheckId, type WorkflowMutationTier, type WorkflowOutputBase, type WorkflowOutputContract, type WorkflowOutputKind, type WorkflowProofArtifact, type WorkflowProofArtifactKind, type WorkflowRunReceiptV1, type WorkflowRunStatus, type WorkflowStaffingHint, type WorkflowTriggerContract, type WorkflowTriggerKind, type WorktreePhase, type WorktreeResult, bigramTokenize, buildDomainEvent, collectTopicNeighborhood, compareEventCursor, createEventId, decodeEventCursor, decodePrefixedId, emitDomainEvent, encodeEventCursor, encodePrefixedId, hasPrefixedIdPrefix, inferActorType, inferSessionPrincipalType, isAfterCursor, isLucernPrompt, jaccardSimilarity, lastDelegator, mcpTools_contract as mcpToolsContract, normalizeDelegationChain, normalizeRetentionDays, prepareLexicalQuery, rankEntityConnections, rankEntityTypeMatches, rankWindowScore, requireActorPrincipalId, rerankLexicalWindow, scoreEntityConnection, scoreEntityTypeMatch, scoreLexicalSignal, scoreLexicalSignals, sdkTools_contract as sdkToolsContract, sortEventsByCursor, stemToken, tokenOverlapScore, tokenizeSearchText, wordOverlapScore, wordTokenize };