@lucern/sdk 1.0.28 → 1.0.30

package/dist/contextTypes.d.ts

@@ -5,52 +5,21 @@ export type ContextTraversalMode = "anchored_ranked" | "bounded_exploration" | "
 export type ContextRequestedDepth = "low" | "medium" | "high" | "extra-high";
 export type ContextHeartbeatIntent = "pre_write" | "pre_closeout" | "research_loop" | "status_check";
 export type ContextPackSectionKey = "invariants" | "activeBeliefs" | "openQuestions" | "recentEvidence" | "contradictions";
-export type RankingWeightVector = {
-    query: number;
-    recency: number;
-    confidence?: number;
+export interface RankingWeightVector {
     beliefType?: number;
+    confidence?: number;
     priority?: number;
+    query: number;
+    recency: number;
     severity?: number;
-};
-export type PackWeightOverride = {
+}
+export interface PackWeightOverride {
     section: ContextPackSectionKey;
     weights: Partial<RankingWeightVector>;
-};
-export type CompileContextInput = {
-    /** Optional explicit topic. Omit to resolve by query. */
-    topicId?: string;
-    query?: string;
-    purpose?: CampaignContextPurpose;
-    purposePrompt?: string;
-    topicHint?: string;
-    tags?: string[];
-    touchedPaths?: string[];
-    sourceRef?: string;
-    sourceKind?: string;
-    campaign?: number;
-    lane?: string;
-    status?: string;
-    principalId?: string;
-    workspaceId?: string;
+}
+export interface CompileContextInput {
     budget?: number;
-    ranking?: ContextRankingProfile;
-    limit?: number;
-    maxDepth?: number;
-    includeEntities?: boolean;
-    mode?: ContextCompilationMode;
-    includeFailures?: boolean;
-    worktreeId?: string;
-    sessionId?: string;
-    heartbeat?: boolean;
-    heartbeatIntent?: ContextHeartbeatIntent;
-    heartbeatBudgetMs?: number;
-    heartbeatTraceId?: string;
-    invocationIntent?: string;
-    receiptIntent?: string;
-    packWeightOverrides?: PackWeightOverride[];
-    tokenBudget?: number;
-    rankingProfile?: ContextRankingProfile;
+    campaign?: number;
     /**
      * Dimension-seeded compiles synthesize every scoped worktree but bound raw
      * belief/question/evidence enrichment to a ranked carrier-topic sample.
@@ -58,89 +27,114 @@ export type CompileContextInput = {
      * enrichment in the returned pack.
      */
     contentTopicLimit?: number;
-    traversalMode?: ContextTraversalMode;
+    heartbeat?: boolean;
+    heartbeatBudgetMs?: number;
+    heartbeatIntent?: ContextHeartbeatIntent;
+    heartbeatTraceId?: string;
+    includeEntities?: boolean;
+    includeFailures?: boolean;
+    invocationIntent?: string;
+    lane?: string;
+    limit?: number;
+    maxDepth?: number;
+    mode?: ContextCompilationMode;
+    packWeightOverrides?: PackWeightOverride[];
+    principalId?: string;
+    purpose?: CampaignContextPurpose;
+    purposePrompt?: string;
+    query?: string;
+    ranking?: ContextRankingProfile;
+    rankingProfile?: ContextRankingProfile;
+    receiptIntent?: string;
     requestedDepth?: ContextRequestedDepth;
-};
+    sessionId?: string;
+    sourceKind?: string;
+    sourceRef?: string;
+    status?: string;
+    tags?: string[];
+    tokenBudget?: number;
+    topicHint?: string;
+    /** Optional explicit topic. Omit to resolve by query. */
+    topicId?: string;
+    touchedPaths?: string[];
+    traversalMode?: ContextTraversalMode;
+    workspaceId?: string;
+    worktreeId?: string;
+}
 export type CampaignContextPurpose = "campaign_status" | "avatar_tree_foundation" | "clean_prod_reset" | "graph_v2_readiness" | "custom";
-export type GetCampaignContextInput = {
+export interface GetCampaignContextInput {
     campaign: number;
+    lane?: string;
+    principalId?: string;
     purpose?: CampaignContextPurpose;
     purposePrompt?: string;
-    lane?: string;
+    scanLimit?: number;
+    sourceSpanLimit?: number;
     status?: string;
-    principalId?: string;
+    tokenBudget?: number;
     workspaceId?: string;
     worktreeLimit?: number;
-    sourceSpanLimit?: number;
-    scanLimit?: number;
-    tokenBudget?: number;
-};
-export type PublicContextBelief = {
+}
+export interface PublicContextBelief {
     beliefId: string;
-    text: string;
-    confidence: number | null;
     beliefType?: string | null;
+    confidence: number | null;
+    justification?: string;
+    score: number;
     status?: string;
+    text: string;
     updatedAt?: number | null;
-    score: number;
+}
+export interface PublicContextQuestion {
     justification?: string;
-};
-export type PublicContextQuestion = {
+    priority: string;
     questionId: string;
-    text: string;
+    score: number;
     status: string;
-    priority: string;
+    text: string;
     updatedAt?: number | null;
-    score: number;
-    justification?: string;
-};
-export type PublicContextEvidence = {
+}
+export interface PublicContextEvidence {
+    createdAt?: number | null;
     evidenceId: string;
-    text: string;
-    sourceUrl?: string | null;
+    justification?: string;
     kind: string;
-    createdAt?: number | null;
     score: number;
-    justification?: string;
-};
-export type PublicContextContradiction = {
+    sourceUrl?: string | null;
+    text: string;
+}
+export interface PublicContextContradiction {
     contradictionId: string;
-    severity: string;
-    status: string;
     description: string;
-    score: number;
     justification?: string;
-};
-export type PublicContextEntity = {
-    entityId: string;
-    entityType: string;
-    title: string;
-    text?: string;
+    score: number;
+    severity: string;
+    status: string;
+}
+export interface PublicContextEntity {
     connectedBeliefCount: number;
     connectedEvidenceCount: number;
-    score: number;
+    entityId: string;
+    entityType: string;
     metadata?: Record<string, unknown>;
-};
-export type PublicContextInjectionPolicy = {
-    tokenBudget: number;
+    score: number;
+    text?: string;
+    title: string;
+}
+export interface PublicContextInjectionPolicy {
     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;
     }>;
-};
-export type PublicContextNarrativeBlock = {
-    kind: string;
-    text: string;
-    recordsNamed?: number;
-    narrativeId?: string;
-    narrative_id?: string;
-    scope?: Record<string, unknown>;
+    sectionBudgets: Record<string, number>;
+    sectionUsage: Record<string, number>;
+    selected: Record<string, string[]>;
+    tokenBudget: number;
+}
+export interface PublicContextNarrativeBlock {
     childNarratives?: Array<{
         narrativeId: string;
         narrative_id?: string;
@@ -149,106 +143,112 @@ export type PublicContextNarrativeBlock = {
         summary: string;
         recordsNamed?: number;
     }>;
-};
-export type PublicContextNarrativeCoverage = {
-    recordsSynthesized?: number;
+    kind: string;
+    narrative_id?: string;
+    narrativeId?: string;
+    recordsNamed?: number;
+    scope?: Record<string, unknown>;
+    text: string;
+}
+export interface PublicContextNarrativeCoverage {
+    blocksEmitted?: number;
+    enrichmentMode?: string;
     recordsNamed?: number;
     recordsOmitted?: number;
-    topicsSynthesized?: number;
-    topicsEnriched?: number;
+    recordsSynthesized?: number;
     topicContentOmitted?: number;
-    enrichmentMode?: string;
-    blocksEmitted?: number;
+    topicsEnriched?: number;
+    topicsSynthesized?: number;
     [key: string]: unknown;
-};
-export type PublicContextSynthesisLint = {
+}
+export interface PublicContextSynthesisLint {
     code?: string;
-    severity?: string;
     message?: string;
     path?: string[];
+    severity?: string;
     [key: string]: unknown;
-};
-export type PublicContextRetrievalReceipt = {
+}
+export interface PublicContextRetrievalReceipt {
     candidateCounts?: Record<string, number>;
     coverageWarning?: string | null;
-    narrativeCoverage?: PublicContextNarrativeCoverage;
-    synthesisLints?: PublicContextSynthesisLint[];
     heartbeatReceipt?: PublicContextHeartbeatReceipt;
+    narrativeCoverage?: PublicContextNarrativeCoverage;
     suggestedNextActions?: string[];
+    synthesisLints?: PublicContextSynthesisLint[];
     [key: string]: unknown;
-};
-export type PublicContextHeartbeatReceipt = {
-    schemaVersion: "compile_context_heartbeat.v1";
-    intent: string;
-    sessionId?: string;
-    traceId?: string;
-    startedAt?: number;
+}
+export interface PublicContextHeartbeatReceipt {
+    budgetStatus: "within_budget" | "over_budget" | string;
+    cachedP50BudgetMs: number;
     completedAt?: number;
+    contextBeforeWrite: boolean;
+    coverageWarning?: boolean;
+    hardTimeoutMs?: number;
+    intent: string;
+    lintsBlockingPreWrite?: number;
     measuredDurationMs: number;
+    preWriteReady: boolean;
     requestedBudgetMs: number;
-    cachedP50BudgetMs: number;
+    schemaVersion: "compile_context_heartbeat.v1";
+    sessionId?: string;
+    startedAt?: number;
     synthesizedP50BudgetMs: number;
-    hardTimeoutMs?: number;
-    budgetStatus: "within_budget" | "over_budget" | string;
+    traceId?: string;
     traceMetric: "context_before_write" | string;
-    contextBeforeWrite: boolean;
-    preWriteReady: boolean;
-    lintsBlockingPreWrite?: number;
-    coverageWarning?: boolean;
     [key: string]: unknown;
-};
-export type PublicContextAssemblyReceipt = {
-    receiptVersion?: string;
-    receiptUuid?: string;
-    traceId?: string;
-    included?: Array<Record<string, unknown>>;
-    omitted?: Array<Record<string, unknown>>;
-    rankingInputs?: Record<string, unknown>;
+}
+export interface PublicContextAssemblyReceipt {
+    axiomTelemetry?: Record<string, unknown>;
+    included?: Record<string, unknown>[];
+    omitted?: Record<string, unknown>[];
     policyClipping?: Record<string, unknown>;
+    rankingInputs?: Record<string, unknown>;
+    receiptUuid?: string;
+    receiptVersion?: string;
     synthesisLints?: PublicContextSynthesisLint[];
-    axiomTelemetry?: Record<string, unknown>;
+    traceId?: string;
     [key: string]: unknown;
-};
-export type PublicContextSupportingObjects = {
-    invariants?: PublicContextBelief[];
+}
+export interface PublicContextSupportingObjects {
     activeBeliefs?: PublicContextBelief[];
+    contradictions?: PublicContextContradiction[];
+    entities?: unknown[];
+    invariants?: PublicContextBelief[];
+    lanes?: string[];
     openQuestions?: PublicContextQuestion[];
     recentEvidence?: PublicContextEvidence[];
-    contradictions?: PublicContextContradiction[];
     relatedEntities?: PublicContextEntity[];
     worktrees?: unknown[];
-    lanes?: string[];
-    entities?: unknown[];
-};
+}
 export type PublicCompiledContext = ContractPublicCompiledContext & {
     narrativeIndex?: Record<string, unknown>;
 };
-export type PublicCampaignContextPayload = {
-    mission?: Record<string, unknown>;
-    laneOrder?: Array<Record<string, unknown>>;
-    blockers?: Array<Record<string, unknown>>;
-    risks?: Array<Record<string, unknown>>;
-    openQuestions?: Array<Record<string, unknown>>;
+export interface PublicCampaignContextPayload {
+    blockers?: Record<string, unknown>[];
     evidencePosture?: Record<string, unknown>;
-    sourceSpans?: Array<Record<string, unknown>>;
+    laneOrder?: Record<string, unknown>[];
+    mission?: Record<string, unknown>;
+    openQuestions?: Record<string, unknown>[];
     purposeNarrative?: Record<string, unknown>;
+    risks?: Record<string, unknown>[];
+    sourceSpans?: Record<string, unknown>[];
     [key: string]: unknown;
-};
-export type PublicCampaignContext = {
-    contextNarrative: Array<string | PublicContextNarrativeBlock>;
+}
+export interface PublicCampaignContext {
+    campaign: number;
     campaignContext: PublicCampaignContextPayload;
-    purposeNarrative?: Record<string, unknown>;
+    contextNarrative: Array<string | PublicContextNarrativeBlock>;
+    diagnostics: Record<string, unknown>;
+    generatedAt: number;
     narrativeCoverage?: PublicContextNarrativeCoverage;
-    synthesisLints?: PublicContextSynthesisLint[];
+    purposeNarrative?: Record<string, unknown>;
     retrievalReceipt?: PublicContextRetrievalReceipt;
-    synthesisReceipt?: Record<string, unknown>;
-    supportingObjects?: PublicContextSupportingObjects & {
-        sourceSpans?: Array<Record<string, unknown>>;
-    };
     schemaVersion: "campaign_context.v1" | string;
-    campaign: number;
-    generatedAt: number;
     summary: Record<string, unknown>;
-    diagnostics: Record<string, unknown>;
-};
+    supportingObjects?: PublicContextSupportingObjects & {
+        sourceSpans?: Record<string, unknown>[];
+    };
+    synthesisLints?: PublicContextSynthesisLint[];
+    synthesisReceipt?: Record<string, unknown>;
+}
 //# sourceMappingURL=contextTypes.d.ts.map

package/dist/contracts/api-enums.contract.js

@@ -105,11 +105,7 @@ export const REASONING_METHODS = [
 // CONTRADICTION ENUMS
 // =============================================================================
 /** Defeat types (Pollock taxonomy) — how a contradiction operates */
-export const DEFEAT_TYPES = [
-    "rebuts",
-    "undercuts",
-    "undermines",
-];
+export const DEFEAT_TYPES = ["rebuts", "undercuts", "undermines"];
 /** Contradiction severity */
 export const CONTRADICTION_SEVERITIES = [
     "low",
@@ -151,12 +147,7 @@ export const WORKTREE_PHASES = [
  * - L3: Beliefs — structural claims that carry confidence
  * - L4: Judgments — irreversible commitments based on the epistemic state
  */
-export const EPISTEMIC_LAYERS = [
-    "L1",
-    "L2",
-    "L3",
-    "L4",
-];
+export const EPISTEMIC_LAYERS = ["L1", "L2", "L3", "L4"];
 // =============================================================================
 // JUDGMENT TYPES
 // =============================================================================

package/dist/contracts/auth-session.contract.d.ts

@@ -10,28 +10,22 @@ export declare const SESSION_PRINCIPAL_TYPES: readonly ["human", "service", "age
 export type SessionPrincipalType = (typeof SESSION_PRINCIPAL_TYPES)[number];
 export declare const SESSION_LIFECYCLE_STATUSES: readonly ["active", "expired", "revoked"];
 export type SessionLifecycleStatus = (typeof SESSION_LIFECYCLE_STATUSES)[number];
-export type SessionDelegationHop = {
-    principalId: string;
-    principalType: SessionPrincipalType;
+export interface SessionDelegationHop {
     authMode?: SessionAuthMode;
-    sessionId?: string;
     delegatedAt?: number;
-    reason?: string;
-};
-export type SessionAuditOutcome = "accepted" | "rejected" | "revoked" | "expired";
-export type SessionAuditEnvelope = {
-    sessionId: string;
-    authMode: SessionAuthMode;
     principalId: string;
     principalType: SessionPrincipalType;
-    tenantId: string;
-    workspaceId?: string;
+    reason?: string;
+    sessionId?: string;
+}
+export type SessionAuditOutcome = "accepted" | "rejected" | "revoked" | "expired";
+export interface SessionAuditEnvelope {
     apiKeyId?: string;
-    scopes: readonly string[];
-    roles?: readonly string[];
+    authMode: SessionAuthMode;
     delegationChain?: readonly SessionDelegationHop[];
-    sourceSessionId?: string;
     expiresAt?: number;
+    principalId: string;
+    principalType: SessionPrincipalType;
     request?: {
         endpoint?: string;
         method?: string;
@@ -41,7 +35,13 @@ export type SessionAuditEnvelope = {
         outcome: SessionAuditOutcome;
         reason?: string;
     };
-};
+    roles?: readonly string[];
+    scopes: readonly string[];
+    sessionId: string;
+    sourceSessionId?: string;
+    tenantId: string;
+    workspaceId?: string;
+}
 export declare function inferSessionPrincipalType(principalId: string): SessionPrincipalType;
 export declare function normalizeDelegationChain(args: {
     delegationChain?: readonly SessionDelegationHop[];

package/dist/contracts/auth-session.contract.js

@@ -22,8 +22,9 @@ export const SESSION_LIFECYCLE_STATUSES = [
     "expired",
     "revoked",
 ];
+const CLERK_USER_PRINCIPAL_PATTERN = /^user_[A-Za-z0-9]+$/;
 export function inferSessionPrincipalType(principalId) {
-    if (/^user_[A-Za-z0-9]+$/.test(principalId)) {
+    if (CLERK_USER_PRINCIPAL_PATTERN.test(principalId)) {
         return "human";
     }
     if (principalId.startsWith("agent:")) {
@@ -58,6 +59,6 @@ export function lastDelegator(delegationChain) {
     if (!delegationChain || delegationChain.length === 0) {
         return;
     }
-    return delegationChain[delegationChain.length - 1]?.principalId;
+    return delegationChain.at(-1)?.principalId;
 }
 //# sourceMappingURL=auth-session.contract.js.map