@devflow-tools/database 0.16.20 → 0.16.22

package/dist/learning-candidates.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapLearningCandidateRow = mapLearningCandidateRow;
+exports.mapLearningEvidenceRow = mapLearningEvidenceRow;
+exports.mapLearningVersionRow = mapLearningVersionRow;
+exports.stableLearningJson = stableLearningJson;
+function mapLearningCandidateRow(row) {
+    return {
+        id: String(row.id),
+        projectRoot: String(row.project_root),
+        scope: row.scope === 'global' ? 'global' : 'project',
+        state: row.state,
+        kind: row.kind,
+        trigger: parseRecord(row.trigger_json),
+        instruction: String(row.instruction),
+        confidence: Number(row.confidence),
+        overlayVersion: Number(row.overlay_version),
+        supportingSessions: Number(row.supporting_sessions),
+        successfulOutcomes: Number(row.successful_outcomes),
+        contradictions: Number(row.contradictions),
+        manualOnly: Number(row.manual_only) === 1,
+        risk: row.risk === 'high' ? 'high' : row.risk === 'medium' ? 'medium' : 'low',
+        graderReceipt: optionalString(row.grader_receipt),
+        expiresAt: optionalNumber(row.expires_at),
+        createdAt: Number(row.created_at),
+        updatedAt: Number(row.updated_at),
+    };
+}
+function mapLearningEvidenceRow(row) {
+    return {
+        id: String(row.id),
+        candidateId: String(row.candidate_id),
+        projectRoot: String(row.project_root),
+        sessionId: String(row.session_id),
+        executionId: optionalString(row.execution_id),
+        memoryObservationId: optionalString(row.memory_observation_id),
+        outcomeId: optionalString(row.outcome_id),
+        sourceType: row.source_type,
+        polarity: row.polarity,
+        outcome: row.outcome,
+        evidenceHash: String(row.evidence_hash),
+        receipt: optionalString(row.receipt),
+        payload: parseRecord(row.payload_json),
+        createdAt: Number(row.created_at),
+        resolvedAt: optionalNumber(row.resolved_at),
+    };
+}
+function mapLearningVersionRow(row) {
+    return {
+        candidateId: String(row.candidate_id),
+        version: Number(row.version),
+        trigger: parseRecord(row.trigger_json),
+        instruction: String(row.instruction),
+        createdAt: Number(row.created_at),
+    };
+}
+function stableLearningJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(stableLearningJson).join(',')}]`;
+    if (!value || typeof value !== 'object')
+        return JSON.stringify(value) ?? 'null';
+    const record = value;
+    return `{${Object.keys(record).sort().map(key => `${JSON.stringify(key)}:${stableLearningJson(record[key])}`).join(',')}}`;
+}
+function parseRecord(value) {
+    try {
+        const parsed = typeof value === 'string' ? JSON.parse(value) : value;
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+function optionalString(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+function optionalNumber(value) {
+    return value === null || value === undefined ? undefined : Number(value);
+}

package/dist/work-queue.d.ts

@@ -1,4 +1,4 @@
-export type WorkKind = 'memory.explicit_commit' | 'memory.explicit_enrichment' | 'memory.turn_capture' | 'memory.turn_distill' | 'memory.vector_backfill' | 'session.bootstrap' | 'session.finalize' | 'telemetry.reconcile';
+export type WorkKind = 'memory.explicit_commit' | 'memory.explicit_enrichment' | 'memory.turn_capture' | 'memory.turn_distill' | 'memory.vector_backfill' | 'context.prefetch' | 'learning.analyze_session' | 'session.bootstrap' | 'session.finalize' | 'telemetry.reconcile';
 export type WorkState = 'pending' | 'leased' | 'completed' | 'failed' | 'dead_letter';
 export interface WorkError {
     category: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devflow-tools/database",
-  "version": "0.16.20",
+  "version": "0.16.22",
   "description": "DevFlow SQLite database package",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/database.ts

@@ -42,6 +42,19 @@ import {
   type RetrievalSessionRecord,
   type RetrievalSessionState,
 } from './retrieval-sessions';
+import {
+  mapLearningCandidateRow,
+  mapLearningEvidenceRow,
+  mapLearningVersionRow,
+  stableLearningJson,
+  type AddLearningCandidateEvidenceInput,
+  type LearningCandidateEvidenceRecord,
+  type LearningCandidateRecord,
+  type LearningCandidateState,
+  type LearningCandidateVersionRecord,
+  type TransitionLearningCandidateInput,
+  type UpsertLearningCandidateInput,
+} from './learning-candidates';
 
 export interface BenchmarkReportRecord {
   runId: string;
@@ -655,6 +668,74 @@ export class DevFlowDatabase {
       CREATE INDEX IF NOT EXISTS idx_session_closures_state
         ON devflow_session_closures(project_root, state, updated_at DESC);
 
+      CREATE TABLE IF NOT EXISTS devflow_learning_candidates (
+        id TEXT PRIMARY KEY,
+        project_root TEXT NOT NULL,
+        scope TEXT NOT NULL CHECK(scope IN ('project', 'global')),
+        state TEXT NOT NULL DEFAULT 'observed'
+          CHECK(state IN ('observed', 'candidate', 'shadow', 'evaluated', 'active', 'rejected', 'retired')),
+        kind TEXT NOT NULL CHECK(kind IN ('convention', 'workflow', 'tool_preference', 'correction')),
+        trigger_json TEXT NOT NULL,
+        instruction TEXT NOT NULL,
+        confidence REAL NOT NULL CHECK(confidence BETWEEN 0 AND 1),
+        overlay_version INTEGER NOT NULL DEFAULT 1 CHECK(overlay_version > 0),
+        supporting_sessions INTEGER NOT NULL DEFAULT 0 CHECK(supporting_sessions >= 0),
+        successful_outcomes INTEGER NOT NULL DEFAULT 0 CHECK(successful_outcomes >= 0),
+        contradictions INTEGER NOT NULL DEFAULT 0 CHECK(contradictions >= 0),
+        manual_only INTEGER NOT NULL DEFAULT 0 CHECK(manual_only IN (0, 1)),
+        risk TEXT NOT NULL DEFAULT 'low' CHECK(risk IN ('low', 'medium', 'high')),
+        grader_receipt TEXT,
+        expires_at INTEGER,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_learning_candidates_project
+        ON devflow_learning_candidates(project_root, state, kind, updated_at DESC);
+
+      CREATE TABLE IF NOT EXISTS devflow_learning_candidate_versions (
+        candidate_id TEXT NOT NULL,
+        version INTEGER NOT NULL CHECK(version > 0),
+        trigger_json TEXT NOT NULL,
+        instruction TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        PRIMARY KEY(candidate_id, version)
+      );
+
+      CREATE TABLE IF NOT EXISTS devflow_learning_candidate_evidence (
+        id TEXT PRIMARY KEY,
+        candidate_id TEXT NOT NULL,
+        project_root TEXT NOT NULL,
+        session_id TEXT NOT NULL,
+        execution_id TEXT,
+        memory_observation_id TEXT,
+        outcome_id TEXT,
+        source_type TEXT NOT NULL
+          CHECK(source_type IN ('memory', 'correction', 'workflow_outcome', 'tool_preference', 'convention', 'grader', 'manual')),
+        polarity TEXT NOT NULL CHECK(polarity IN ('supporting', 'contradicting')),
+        outcome TEXT NOT NULL DEFAULT 'unknown' CHECK(outcome IN ('positive', 'negative', 'unknown')),
+        evidence_hash TEXT NOT NULL,
+        receipt TEXT,
+        payload_json TEXT NOT NULL DEFAULT '{}',
+        created_at INTEGER NOT NULL,
+        resolved_at INTEGER,
+        UNIQUE(candidate_id, evidence_hash)
+      );
+      CREATE INDEX IF NOT EXISTS idx_learning_evidence_candidate
+        ON devflow_learning_candidate_evidence(candidate_id, polarity, resolved_at, created_at);
+
+      CREATE TABLE IF NOT EXISTS devflow_learning_activation_history (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        candidate_id TEXT NOT NULL,
+        from_state TEXT NOT NULL,
+        to_state TEXT NOT NULL,
+        reason TEXT NOT NULL,
+        grader_receipt TEXT,
+        manual_approval INTEGER NOT NULL DEFAULT 0 CHECK(manual_approval IN (0, 1)),
+        changed_at INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_learning_activation_candidate
+        ON devflow_learning_activation_history(candidate_id, changed_at DESC);
+
       CREATE TABLE IF NOT EXISTS devflow_host_actions (
         action_id TEXT PRIMARY KEY,
         run_id TEXT NOT NULL,
@@ -2231,6 +2312,352 @@ export class DevFlowDatabase {
     };
   }
 
+  // ---- Governed Learning ----
+
+  upsertLearningCandidate(input: UpsertLearningCandidateInput): LearningCandidateRecord {
+    if (!input.id.trim()) throw new Error('Learning candidate requires an ID');
+    if (!input.projectRoot.trim()) throw new Error('Learning candidate requires a project root');
+    if (!input.instruction.trim()) throw new Error('Learning candidate requires an instruction');
+    if (!Number.isFinite(input.confidence) || input.confidence < 0 || input.confidence > 1) {
+      throw new Error('Learning candidate confidence must be between 0 and 1');
+    }
+
+    return this.db.transaction(() => {
+      const now = Date.now();
+      const existing = this.getLearningCandidate(input.id);
+      const triggerJson = stableLearningJson(input.trigger);
+      const instruction = input.instruction.trim().slice(0, 2_000);
+      if (!existing) {
+        this.db.prepare(`
+          INSERT INTO devflow_learning_candidates (
+            id, project_root, scope, state, kind, trigger_json, instruction,
+            confidence, overlay_version, supporting_sessions, successful_outcomes,
+            contradictions, manual_only, risk, expires_at, created_at, updated_at
+          ) VALUES (?, ?, ?, 'observed', ?, ?, ?, ?, 1, 0, 0, 0, ?, ?, ?, ?, ?)
+        `).run(
+          input.id,
+          input.projectRoot,
+          input.scope,
+          input.kind,
+          triggerJson,
+          instruction,
+          input.confidence,
+          input.manualOnly ? 1 : 0,
+          input.risk ?? 'low',
+          input.expiresAt ?? null,
+          now,
+          now,
+        );
+        this.insertLearningCandidateVersion(input.id, 1, triggerJson, instruction, now);
+        return this.getLearningCandidate(input.id)!;
+      }
+      if (existing.projectRoot !== input.projectRoot || existing.scope !== input.scope || existing.kind !== input.kind) {
+        throw new Error(`Learning candidate identity mismatch for ${input.id}`);
+      }
+
+      const contentChanged = stableLearningJson(existing.trigger) !== triggerJson
+        || existing.instruction !== instruction;
+      const nextVersion = contentChanged ? existing.overlayVersion + 1 : existing.overlayVersion;
+      const nextState = contentChanged && (existing.state === 'active' || existing.state === 'evaluated')
+        ? 'shadow'
+        : existing.state;
+      this.db.prepare(`
+        UPDATE devflow_learning_candidates
+        SET trigger_json = ?, instruction = ?, confidence = ?, overlay_version = ?,
+            state = ?, manual_only = MAX(manual_only, ?),
+            risk = CASE
+              WHEN risk = 'high' OR ? = 'high' THEN 'high'
+              WHEN risk = 'medium' OR ? = 'medium' THEN 'medium'
+              ELSE 'low'
+            END,
+            expires_at = ?, updated_at = ?
+        WHERE id = ?
+      `).run(
+        triggerJson,
+        instruction,
+        Math.max(existing.confidence, input.confidence),
+        nextVersion,
+        nextState,
+        input.manualOnly ? 1 : 0,
+        input.risk ?? 'low',
+        input.risk ?? 'low',
+        input.expiresAt ?? existing.expiresAt ?? null,
+        now,
+        input.id,
+      );
+      if (contentChanged) {
+        this.insertLearningCandidateVersion(input.id, nextVersion, triggerJson, instruction, now);
+        if (nextState !== existing.state) {
+          this.insertLearningActivation(input.id, existing.state, nextState, 'candidate_content_changed', undefined, false, now);
+        }
+      }
+      return this.getLearningCandidate(input.id)!;
+    });
+  }
+
+  getLearningCandidate(id: string): LearningCandidateRecord | null {
+    const row = this.db.prepare('SELECT * FROM devflow_learning_candidates WHERE id = ?')
+      .get(id) as Record<string, unknown> | undefined;
+    return row ? mapLearningCandidateRow(row) : null;
+  }
+
+  listLearningCandidates(options: {
+    projectRoot?: string;
+    states?: LearningCandidateState[];
+    limit?: number;
+  } = {}): LearningCandidateRecord[] {
+    const predicates: string[] = [];
+    const params: unknown[] = [];
+    if (options.projectRoot) {
+      predicates.push('(project_root = ? OR scope = \'global\')');
+      params.push(options.projectRoot);
+    }
+    const states = [...new Set(options.states ?? [])];
+    if (states.length > 0) {
+      predicates.push(`state IN (${states.map(() => '?').join(',')})`);
+      params.push(...states);
+    }
+    const rows = this.db.prepare(`
+      SELECT * FROM devflow_learning_candidates
+      ${predicates.length > 0 ? `WHERE ${predicates.join(' AND ')}` : ''}
+      ORDER BY updated_at DESC, id ASC
+      LIMIT ?
+    `).all(...params, Math.max(1, Math.min(options.limit ?? 200, 2_000))) as Array<Record<string, unknown>>;
+    return rows.map(mapLearningCandidateRow);
+  }
+
+  addLearningCandidateEvidence(input: AddLearningCandidateEvidenceInput): LearningCandidateRecord {
+    if (!input.evidenceHash.trim()) throw new Error('Learning evidence requires a hash');
+    if (!input.sessionId.trim()) throw new Error('Learning evidence requires a session ID');
+    return this.db.transaction(() => {
+      const candidate = this.getLearningCandidate(input.candidateId);
+      if (!candidate) throw new Error(`Learning candidate ${input.candidateId} does not exist`);
+      if (candidate.projectRoot !== input.projectRoot && candidate.scope !== 'global') {
+        throw new Error(`Learning evidence project mismatch for ${input.candidateId}`);
+      }
+      const createdAt = input.createdAt ?? Date.now();
+      const inserted = this.db.prepare(`
+        INSERT OR IGNORE INTO devflow_learning_candidate_evidence (
+          id, candidate_id, project_root, session_id, execution_id,
+          memory_observation_id, outcome_id, source_type, polarity, outcome,
+          evidence_hash, receipt, payload_json, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(
+        input.id,
+        input.candidateId,
+        input.projectRoot,
+        input.sessionId,
+        input.executionId ?? null,
+        input.memoryObservationId ?? null,
+        input.outcomeId ?? null,
+        input.sourceType,
+        input.polarity,
+        input.outcome ?? 'unknown',
+        input.evidenceHash,
+        input.receipt ?? null,
+        stableLearningJson(input.payload ?? {}),
+        createdAt,
+      ).changes === 1;
+      if (!inserted) return candidate;
+
+      const previousState = candidate.state;
+      const aggregates = this.getLearningEvidenceAggregates(input.candidateId);
+      let state = previousState;
+      if (state === 'observed' && aggregates.supportingSessions > 0) state = 'candidate';
+      if (aggregates.contradictions > 0 && (state === 'active' || state === 'evaluated')) state = 'shadow';
+      this.db.prepare(`
+        UPDATE devflow_learning_candidates
+        SET state = ?, supporting_sessions = ?, successful_outcomes = ?,
+            contradictions = ?, updated_at = ?
+        WHERE id = ?
+      `).run(
+        state,
+        aggregates.supportingSessions,
+        aggregates.successfulOutcomes,
+        aggregates.contradictions,
+        createdAt,
+        input.candidateId,
+      );
+      if (state !== previousState) {
+        this.insertLearningActivation(
+          input.candidateId,
+          previousState,
+          state,
+          aggregates.contradictions > 0 ? 'unresolved_contradiction' : 'first_supporting_evidence',
+          undefined,
+          false,
+          createdAt,
+        );
+      }
+      return this.getLearningCandidate(input.candidateId)!;
+    });
+  }
+
+  listLearningCandidateEvidence(candidateId: string): LearningCandidateEvidenceRecord[] {
+    const rows = this.db.prepare(`
+      SELECT * FROM devflow_learning_candidate_evidence
+      WHERE candidate_id = ? ORDER BY created_at ASC, id ASC
+    `).all(candidateId) as Array<Record<string, unknown>>;
+    return rows.map(mapLearningEvidenceRow);
+  }
+
+  resolveLearningContradiction(candidateId: string, evidenceId: string, resolvedAt = Date.now()): LearningCandidateRecord {
+    return this.db.transaction(() => {
+      this.db.prepare(`
+        UPDATE devflow_learning_candidate_evidence
+        SET resolved_at = ?
+        WHERE id = ? AND candidate_id = ? AND polarity = 'contradicting' AND resolved_at IS NULL
+      `).run(resolvedAt, evidenceId, candidateId);
+      const aggregates = this.getLearningEvidenceAggregates(candidateId);
+      this.db.prepare(`
+        UPDATE devflow_learning_candidates
+        SET supporting_sessions = ?, successful_outcomes = ?, contradictions = ?, updated_at = ?
+        WHERE id = ?
+      `).run(
+        aggregates.supportingSessions,
+        aggregates.successfulOutcomes,
+        aggregates.contradictions,
+        resolvedAt,
+        candidateId,
+      );
+      const candidate = this.getLearningCandidate(candidateId);
+      if (!candidate) throw new Error(`Learning candidate ${candidateId} does not exist`);
+      return candidate;
+    });
+  }
+
+  transitionLearningCandidate(
+    candidateId: string,
+    input: TransitionLearningCandidateInput,
+  ): LearningCandidateRecord {
+    return this.db.transaction(() => {
+      const candidate = this.getLearningCandidate(candidateId);
+      if (!candidate) throw new Error(`Learning candidate ${candidateId} does not exist`);
+      if (candidate.state === input.target) return candidate;
+      this.assertLearningTransition(candidate, input);
+      const changedAt = input.changedAt ?? Date.now();
+      const graderReceipt = input.graderReceipt ?? candidate.graderReceipt;
+      this.db.prepare(`
+        UPDATE devflow_learning_candidates
+        SET state = ?, grader_receipt = COALESCE(?, grader_receipt), updated_at = ?
+        WHERE id = ?
+      `).run(input.target, graderReceipt ?? null, changedAt, candidateId);
+      this.insertLearningActivation(
+        candidateId,
+        candidate.state,
+        input.target,
+        input.reason,
+        graderReceipt,
+        input.manualApproval === true,
+        changedAt,
+      );
+      return this.getLearningCandidate(candidateId)!;
+    });
+  }
+
+  listLearningCandidateVersions(candidateId: string): LearningCandidateVersionRecord[] {
+    const rows = this.db.prepare(`
+      SELECT * FROM devflow_learning_candidate_versions
+      WHERE candidate_id = ? ORDER BY version ASC
+    `).all(candidateId) as Array<Record<string, unknown>>;
+    return rows.map(mapLearningVersionRow);
+  }
+
+  private assertLearningTransition(
+    candidate: LearningCandidateRecord,
+    input: TransitionLearningCandidateInput,
+  ): void {
+    const terminal = input.target === 'rejected' || input.target === 'retired';
+    const rollback = input.target === 'shadow'
+      && (candidate.state === 'active' || candidate.state === 'evaluated');
+    const legal: Record<LearningCandidateState, LearningCandidateState[]> = {
+      observed: ['candidate', 'rejected', 'retired'],
+      candidate: ['shadow', 'rejected', 'retired'],
+      shadow: ['evaluated', 'rejected', 'retired'],
+      evaluated: ['active', 'shadow', 'rejected', 'retired'],
+      active: ['shadow', 'retired'],
+      rejected: ['retired'],
+      retired: [],
+    };
+    if (!terminal && !rollback && !legal[candidate.state].includes(input.target)) {
+      throw new Error(`Illegal learning transition ${candidate.state} -> ${input.target}`);
+    }
+    if (input.target === 'shadow') {
+      if (candidate.supportingSessions < 3 || candidate.successfulOutcomes < 2) {
+        throw new Error('Learning candidate requires three sessions and two verified outcomes before shadow');
+      }
+    }
+    if (input.target === 'evaluated' && candidate.contradictions > 0) {
+      throw new Error('Learning candidate has unresolved contradictions');
+    }
+    if (input.target === 'active') {
+      const receipt = input.graderReceipt ?? candidate.graderReceipt;
+      if (!receipt) throw new Error('Learning candidate activation requires a grader receipt');
+      if (candidate.contradictions > 0) throw new Error('Learning candidate has unresolved contradictions');
+      const manualRequired = candidate.scope === 'global' || candidate.manualOnly || candidate.risk === 'high';
+      if (manualRequired && input.manualApproval !== true) {
+        throw new Error('Learning candidate requires manual approval');
+      }
+    }
+  }
+
+  private getLearningEvidenceAggregates(candidateId: string): {
+    supportingSessions: number;
+    successfulOutcomes: number;
+    contradictions: number;
+  } {
+    const row = this.db.prepare(`
+      SELECT
+        COUNT(DISTINCT CASE WHEN polarity = 'supporting' THEN session_id END) AS supporting_sessions,
+        COUNT(DISTINCT CASE WHEN polarity = 'supporting' AND outcome = 'positive' THEN session_id END) AS successful_outcomes,
+        SUM(CASE WHEN polarity = 'contradicting' AND resolved_at IS NULL THEN 1 ELSE 0 END) AS contradictions
+      FROM devflow_learning_candidate_evidence WHERE candidate_id = ?
+    `).get(candidateId) as Record<string, unknown> | undefined;
+    return {
+      supportingSessions: Number(row?.supporting_sessions ?? 0),
+      successfulOutcomes: Number(row?.successful_outcomes ?? 0),
+      contradictions: Number(row?.contradictions ?? 0),
+    };
+  }
+
+  private insertLearningCandidateVersion(
+    candidateId: string,
+    version: number,
+    triggerJson: string,
+    instruction: string,
+    createdAt: number,
+  ): void {
+    this.db.prepare(`
+      INSERT OR IGNORE INTO devflow_learning_candidate_versions
+        (candidate_id, version, trigger_json, instruction, created_at)
+      VALUES (?, ?, ?, ?, ?)
+    `).run(candidateId, version, triggerJson, instruction, createdAt);
+  }
+
+  private insertLearningActivation(
+    candidateId: string,
+    fromState: LearningCandidateState,
+    toState: LearningCandidateState,
+    reason: string,
+    graderReceipt: string | undefined,
+    manualApproval: boolean,
+    changedAt: number,
+  ): void {
+    this.db.prepare(`
+      INSERT INTO devflow_learning_activation_history
+        (candidate_id, from_state, to_state, reason, grader_receipt, manual_approval, changed_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `).run(
+      candidateId,
+      fromState,
+      toState,
+      reason.trim().slice(0, 500),
+      graderReceipt ?? null,
+      manualApproval ? 1 : 0,
+      changedAt,
+    );
+  }
+
   // ---- Durable Work Queue ----
 
   enqueueWork(input: EnqueueWorkInput): WorkItemRecord {

package/src/index.ts

@@ -59,6 +59,24 @@ export {
   mapSessionObligationRow,
   normalizeTurnId,
 } from './obligation-ledger';
+export {
+  mapLearningCandidateRow,
+  mapLearningEvidenceRow,
+  mapLearningVersionRow,
+  stableLearningJson,
+} from './learning-candidates';
+export type {
+  AddLearningCandidateEvidenceInput,
+  LearningCandidateEvidenceRecord,
+  LearningCandidateKind,
+  LearningCandidateRecord,
+  LearningCandidateState,
+  LearningCandidateVersionRecord,
+  LearningEvidencePolarity,
+  LearningOutcomeState,
+  TransitionLearningCandidateInput,
+  UpsertLearningCandidateInput,
+} from './learning-candidates';
 export type {
   SessionObligationKind,
   SessionObligationRecord,