principles-disciple 1.5.4 → 1.7.0

package/dist/core/paths.js

@@ -1,67 +1,75 @@
 import * as path from 'path';
+const posixJoin = (...parts) => path.posix.join(...parts);
+function isWindowsPath(input) {
+    return /^[A-Za-z]:[\\/]/.test(input) || input.startsWith('\\\\');
+}
+function joinWorkspacePath(workspaceDir, relativePath) {
+    if (isWindowsPath(workspaceDir)) {
+        return path.win32.join(workspaceDir, relativePath);
+    }
+    if (workspaceDir.startsWith('/')) {
+        return path.posix.join(workspaceDir, relativePath);
+    }
+    return path.join(workspaceDir, relativePath);
+}
 /**
  * Principles Disciple Directory Constants
  * Establishing a logical separation between Identity, State, and Memory.
  */
 export const PD_DIRS = {
-    /** 🧬 Core configuration, identity, and kernel rules (hidden) */
     IDENTITY: '.principles',
-    /** 🧠 Deep Reflection mental models */
-    MODELS: path.join('.principles', 'models'),
-    /** ⚡ Volatile operational data, queues, and task status (hidden) */
+    MODELS: posixJoin('.principles', 'models'),
     STATE: '.state',
-    /** 💾 Historical records, logs, and long-term memory */
     MEMORY: 'memory',
-    /** 🎯 Strategic objectives and focus areas */
-    OKR: path.join('memory', 'okr'),
-    /** 📁 Internal logs directory */
-    LOGS: path.join('memory', 'logs'),
-    /** 🧠 Session persistence directory */
-    SESSIONS: path.join('.state', 'sessions'),
-    /** 🩹 Semantic pain samples for L3 retrieval */
-    PAIN_SAMPLES: path.join('memory', 'pain'),
+    OKR: posixJoin('memory', 'okr'),
+    LOGS: posixJoin('memory', 'logs'),
+    SESSIONS: posixJoin('.state', 'sessions'),
+    PAIN_SAMPLES: posixJoin('memory', 'pain'),
+    LOCKS: posixJoin('memory', '.locks'),
 };
 /**
  * Standard File Path Mappings
  */
 export const PD_FILES = {
-    // Identity Layer
-    PROFILE: path.join(PD_DIRS.IDENTITY, 'PROFILE.json'),
-    PRINCIPLES: path.join(PD_DIRS.IDENTITY, 'PRINCIPLES.md'),
-    THINKING_OS: path.join(PD_DIRS.IDENTITY, 'THINKING_OS.md'),
-    KERNEL: path.join(PD_DIRS.IDENTITY, '00-kernel.md'),
-    DECISION_POLICY: path.join(PD_DIRS.IDENTITY, 'DECISION_POLICY.json'),
+    PROFILE: posixJoin(PD_DIRS.IDENTITY, 'PROFILE.json'),
+    PRINCIPLES: posixJoin(PD_DIRS.IDENTITY, 'PRINCIPLES.md'),
+    THINKING_OS: posixJoin(PD_DIRS.IDENTITY, 'THINKING_OS.md'),
+    KERNEL: posixJoin(PD_DIRS.IDENTITY, '00-kernel.md'),
+    DECISION_POLICY: posixJoin(PD_DIRS.IDENTITY, 'DECISION_POLICY.json'),
     MODELS_DIR: PD_DIRS.MODELS,
-    // State Layer
     STATE_DIR: PD_DIRS.STATE,
-    EVOLUTION_QUEUE: path.join(PD_DIRS.STATE, 'evolution_queue.json'),
-    EVOLUTION_DIRECTIVE: path.join(PD_DIRS.STATE, 'evolution_directive.json'),
-    WORKBOARD: path.join(PD_DIRS.STATE, 'WORKBOARD.json'),
-    AGENT_SCORECARD: path.join(PD_DIRS.STATE, 'AGENT_SCORECARD.json'),
-    PAIN_FLAG: path.join(PD_DIRS.STATE, '.pain_flag'),
-    SYSTEM_CAPABILITIES: path.join(PD_DIRS.STATE, 'SYSTEM_CAPABILITIES.json'),
-    PAIN_SETTINGS: path.join(PD_DIRS.STATE, 'pain_settings.json'),
-    PAIN_CANDIDATES: path.join(PD_DIRS.STATE, 'pain_candidates.json'),
-    THINKING_OS_USAGE: path.join(PD_DIRS.STATE, 'thinking_os_usage.json'),
+    EVOLUTION_QUEUE: posixJoin(PD_DIRS.STATE, 'evolution_queue.json'),
+    EVOLUTION_DIRECTIVE: posixJoin(PD_DIRS.STATE, 'evolution_directive.json'),
+    WORKBOARD: posixJoin(PD_DIRS.STATE, 'WORKBOARD.json'),
+    AGENT_SCORECARD: posixJoin(PD_DIRS.STATE, 'AGENT_SCORECARD.json'),
+    PAIN_FLAG: posixJoin(PD_DIRS.STATE, '.pain_flag'),
+    SYSTEM_CAPABILITIES: posixJoin(PD_DIRS.STATE, 'SYSTEM_CAPABILITIES.json'),
+    PAIN_SETTINGS: posixJoin(PD_DIRS.STATE, 'pain_settings.json'),
+    PAIN_CANDIDATES: posixJoin(PD_DIRS.STATE, 'pain_candidates.json'),
+    THINKING_OS_USAGE: posixJoin(PD_DIRS.STATE, 'thinking_os_usage.json'),
+    TRAJECTORY_DB: posixJoin(PD_DIRS.STATE, 'trajectory.db'),
+    TRAJECTORY_BLOBS_DIR: posixJoin(PD_DIRS.STATE, 'blobs'),
+    EXPORTS_DIR: posixJoin(PD_DIRS.STATE, 'exports'),
     SESSION_DIR: PD_DIRS.SESSIONS,
-    DICTIONARY: path.join(PD_DIRS.STATE, 'pain_dictionary.json'),
-    // Workflow Layer (Project Root)
+    DICTIONARY: posixJoin(PD_DIRS.STATE, 'pain_dictionary.json'),
+    PRINCIPLE_BLACKLIST: posixJoin(PD_DIRS.STATE, 'principle_blacklist.json'),
     PLAN: 'PLAN.md',
     MEMORY_MD: 'MEMORY.md',
     HEARTBEAT: 'HEARTBEAT.md',
-    // Memory Layer
-    SYSTEM_LOG: path.join(PD_DIRS.LOGS, 'SYSTEM.log'),
-    REFLECTION_LOG: path.join(PD_DIRS.MEMORY, 'reflection-log.md'),
-    USER_CONTEXT: path.join(PD_DIRS.MEMORY, 'USER_CONTEXT.md'),
+    SYSTEM_LOG: posixJoin(PD_DIRS.LOGS, 'SYSTEM.log'),
+    REFLECTION_LOG: posixJoin(PD_DIRS.MEMORY, 'reflection-log.md'),
+    USER_CONTEXT: posixJoin(PD_DIRS.MEMORY, 'USER_CONTEXT.md'),
     OKR_DIR: PD_DIRS.OKR,
-    CURRENT_FOCUS: path.join(PD_DIRS.OKR, 'CURRENT_FOCUS.md'),
-    WEEK_STATE: path.join(PD_DIRS.OKR, 'WEEK_STATE.json'),
-    THINKING_OS_CANDIDATES: path.join(PD_DIRS.MEMORY, 'THINKING_OS_CANDIDATES.md'),
-    SEMANTIC_PAIN: path.join(PD_DIRS.PAIN_SAMPLES, 'confusion_samples.md'),
+    CURRENT_FOCUS: posixJoin(PD_DIRS.OKR, 'CURRENT_FOCUS.md'),
+    WEEK_STATE: posixJoin(PD_DIRS.OKR, 'WEEK_STATE.json'),
+    THINKING_OS_CANDIDATES: posixJoin(PD_DIRS.MEMORY, 'THINKING_OS_CANDIDATES.md'),
+    SEMANTIC_PAIN: posixJoin(PD_DIRS.PAIN_SAMPLES, 'confusion_samples.md'),
+    EVOLUTION_STREAM: posixJoin(PD_DIRS.MEMORY, 'evolution.jsonl'),
+    EVOLUTION_LOCK: posixJoin(PD_DIRS.LOCKS, 'evolution'),
 };
 /**
  * Resolves a PD file path within a given workspace.
  */
 export function resolvePdPath(workspaceDir, fileKey) {
-    return path.join(workspaceDir, PD_FILES[fileKey]);
+    return joinWorkspacePath(workspaceDir, PD_FILES[fileKey]);
 }

package/dist/core/profile.js

@@ -51,7 +51,7 @@ export const PROFILE_DEFAULTS = {
     thinking_checkpoint: {
         enabled: false, // Default OFF to avoid blocking new users
         window_ms: 5 * 60 * 1000, // 5 minute window
-        high_risk_tools: ['run_shell_command', 'delete_file', 'move_file', 'pd_spawn_agent'],
+        high_risk_tools: ['run_shell_command', 'delete_file', 'move_file', 'pd_run_worker'],
     },
     custom_guards: [],
 };

package/dist/core/session-tracker.d.ts

@@ -25,6 +25,7 @@ export interface SessionState {
     dailyPainSignals: number;
     dailyGfiPeak: number;
     lastThinkingTimestamp: number;
+    injectedProbationIds?: string[];
 }
 /**
  * Initialize persistence for session state.
@@ -58,6 +59,9 @@ export declare function recordThinkingCheckpoint(sessionId: string, workspaceDir
  */
 export declare function hasRecentThinking(sessionId: string, windowMs?: number): boolean;
 export declare function trackBlock(sessionId: string): SessionState;
+export declare function setInjectedProbationIds(sessionId: string, ids: string[], workspaceDir?: string): SessionState;
+export declare function getInjectedProbationIds(sessionId: string, workspaceDir?: string): string[];
+export declare function clearInjectedProbationIds(sessionId: string, workspaceDir?: string): SessionState;
 export declare function getSession(sessionId: string): SessionState | undefined;
 export declare function clearSession(sessionId: string): void;
 export declare function garbageCollectSessions(): void;

package/dist/core/session-tracker.js

@@ -115,6 +115,7 @@ function getOrCreateSession(sessionId, workspaceDir) {
             dailyPainSignals: 0,
             dailyGfiPeak: 0,
             lastThinkingTimestamp: 0,
+            injectedProbationIds: [],
         };
         sessions.set(sessionId, state);
     }
@@ -230,6 +231,20 @@ export function trackBlock(sessionId) {
     state.lastActivityAt = Date.now();
     return state;
 }
+export function setInjectedProbationIds(sessionId, ids, workspaceDir) {
+    const state = getOrCreateSession(sessionId, workspaceDir);
+    state.injectedProbationIds = [...ids];
+    state.lastActivityAt = Date.now();
+    schedulePersistence(state);
+    return state;
+}
+export function getInjectedProbationIds(sessionId, workspaceDir) {
+    const state = getOrCreateSession(sessionId, workspaceDir);
+    return [...(state.injectedProbationIds || [])];
+}
+export function clearInjectedProbationIds(sessionId, workspaceDir) {
+    return setInjectedProbationIds(sessionId, [], workspaceDir);
+}
 export function getSession(sessionId) {
     return sessions.get(sessionId);
 }

package/dist/core/thinking-models.d.ts

@@ -0,0 +1,38 @@
+export interface ThinkingModelDefinition {
+    id: string;
+    name: string;
+    description: string;
+    patterns: RegExp[];
+    baselineScenarios: string[];
+}
+export interface ThinkingModelMatch {
+    modelId: string;
+    matchedPattern: string;
+}
+export interface ThinkingScenarioContext {
+    recentToolCalls?: Array<{
+        toolName: string;
+        outcome: 'success' | 'failure' | 'blocked';
+        errorType?: string | null;
+    }>;
+    recentPainEvents?: Array<{
+        source: string;
+        score: number;
+    }>;
+    recentGateBlocks?: Array<{
+        toolName: string;
+        reason: string;
+    }>;
+    recentUserCorrections?: Array<{
+        correctionCue?: string | null;
+    }>;
+    recentPrincipleEvents?: Array<{
+        eventType: string;
+        principleId?: string | null;
+    }>;
+}
+export declare const THINKING_MODEL_MAP: Map<string, ThinkingModelDefinition>;
+export declare function listThinkingModels(): ThinkingModelDefinition[];
+export declare function getThinkingModel(modelId: string): ThinkingModelDefinition | undefined;
+export declare function detectThinkingModelMatches(text: string): ThinkingModelMatch[];
+export declare function deriveThinkingScenarios(modelId: string, context: ThinkingScenarioContext): string[];

package/dist/core/thinking-models.js

@@ -0,0 +1,170 @@
+const THINKING_MODELS = [
+    {
+        id: 'T-01',
+        name: 'Survey Before Acting',
+        description: 'Understand the structure first before making changes.',
+        baselineScenarios: ['exploration', 'discovery'],
+        patterns: [
+            /let me (first )?(understand|map|outline|survey|review the (structure|architecture|dependencies))/i,
+            /before (changing|editing|touching) anything/i,
+            /让我先(梳理|理解|看看|盘点).*(结构|架构|依赖|全貌)/i,
+        ],
+    },
+    {
+        id: 'T-02',
+        name: 'Respect Constraints',
+        description: 'Explicitly reason about contracts, tests, schemas, and requirements.',
+        baselineScenarios: ['constraint-check', 'contract-verification'],
+        patterns: [
+            /(type|test|contract|schema|interface) (constraint|requirement|check|validation)/i,
+            /we (must|need to) (respect|follow|adhere to) the/i,
+            /(必须|需要).*(遵守|符合|满足).*(类型|测试|契约|接口|规范)/i,
+        ],
+    },
+    {
+        id: 'T-03',
+        name: 'Evidence Over Assumption',
+        description: 'Use logs, code, and outputs before inferring causes.',
+        baselineScenarios: ['evidence-gathering', 'verification'],
+        patterns: [
+            /based on (the |this )?(evidence|logs?|output|error|stack trace|test result)/i,
+            /let me (check|verify|confirm|read|look at) (the |)(actual|source|code|file|log)/i,
+            /根据(日志|证据|输出|报错|堆栈|测试结果)/i,
+        ],
+    },
+    {
+        id: 'T-04',
+        name: 'Reversible First',
+        description: 'Prefer changes that are safe to roll back when risk is high.',
+        baselineScenarios: ['risk-management', 'reversibility'],
+        patterns: [
+            /this (is|would be) (irreversible|destructive|permanent|not easily undone)/i,
+            /(reversible|can be undone|safely roll back)/i,
+            /(不可逆|破坏性|无法回滚|可以回滚|安全撤销)/i,
+        ],
+    },
+    {
+        id: 'T-05',
+        name: 'Safety Rails',
+        description: 'Call out guardrails, prohibitions, and failure-prevention constraints.',
+        baselineScenarios: ['guardrails', 'safety-rails'],
+        patterns: [
+            /we (must|should) (not|never|avoid|prevent|ensure we don't)/i,
+            /(critical|important) (not to|that we don't|to avoid)/i,
+            /(绝不能|必须避免|不可|禁止|确保不会)/i,
+        ],
+    },
+    {
+        id: 'T-06',
+        name: 'Simplicity First',
+        description: 'Prefer the smallest understandable solution over over-engineering.',
+        baselineScenarios: ['simplification', 'pragmatism'],
+        patterns: [
+            /(simpl(er|est|ify)|minimal|straightforward|lean) (approach|solution|fix|implementation)/i,
+            /(simple is better|keep it simple|no need to over)/i,
+            /(最简|更简单|精简|没必要过度设计)/i,
+        ],
+    },
+    {
+        id: 'T-07',
+        name: 'Minimal Change Surface',
+        description: 'Limit the blast radius and touch only what is necessary.',
+        baselineScenarios: ['minimal-diff', 'blast-radius-control'],
+        patterns: [
+            /(minimal|smallest|narrowest|least) (change|diff|modification|impact)/i,
+            /only (change|modify|touch|edit) (the |what)/i,
+            /(最小改动|最小变更|只改|只动必要部分)/i,
+        ],
+    },
+    {
+        id: 'T-08',
+        name: 'Pain As Signal',
+        description: 'Treat failures and friction as clues to step back and rethink.',
+        baselineScenarios: ['reflection', 'pain-response'],
+        patterns: [
+            /this (error|failure|issue) (tells us|indicates|signals|suggests|means)/i,
+            /let me (stop|pause|step back|reconsider|rethink)/i,
+            /这个(错误|失败|问题).*(说明|意味着|提示)/i,
+            /让我(停下|暂停|退一步|重新考虑|重新审视)/i,
+        ],
+    },
+    {
+        id: 'T-09',
+        name: 'Divide And Conquer',
+        description: 'Split the task into smaller phases before execution.',
+        baselineScenarios: ['decomposition', 'phased-execution'],
+        patterns: [
+            /(break|split|decompose|divide) (this |the task |it )?(into|down)/i,
+            /(step 1|first,? (we|i|let's)|phase 1)/i,
+            /(拆分|分解|分步|分阶段|第一步)/i,
+        ],
+    },
+];
+export const THINKING_MODEL_MAP = new Map(THINKING_MODELS.map((model) => [model.id, model]));
+export function listThinkingModels() {
+    return THINKING_MODELS.slice();
+}
+export function getThinkingModel(modelId) {
+    return THINKING_MODEL_MAP.get(modelId);
+}
+export function detectThinkingModelMatches(text) {
+    if (!text)
+        return [];
+    const matches = [];
+    for (const model of THINKING_MODELS) {
+        for (const pattern of model.patterns) {
+            if (pattern.test(text)) {
+                matches.push({
+                    modelId: model.id,
+                    matchedPattern: pattern.source,
+                });
+                break;
+            }
+        }
+    }
+    return matches;
+}
+export function deriveThinkingScenarios(modelId, context) {
+    const scenarios = new Set(getThinkingModel(modelId)?.baselineScenarios ?? []);
+    if ((context.recentToolCalls ?? []).some((call) => call.outcome === 'failure')) {
+        scenarios.add('after-tool-failure');
+    }
+    // after-recovery: success that follows a failure (not just any success)
+    const calls = context.recentToolCalls ?? [];
+    const hasFailure = calls.some((call) => call.outcome === 'failure');
+    const hasSuccess = calls.some((call) => call.outcome === 'success');
+    if (hasFailure && hasSuccess) {
+        scenarios.add('after-recovery');
+    }
+    if ((context.recentToolCalls ?? []).some((call) => call.outcome === 'blocked')) {
+        scenarios.add('blocked-execution');
+    }
+    if ((context.recentToolCalls ?? []).some((call) => Boolean(call.errorType))) {
+        scenarios.add('incident-response');
+    }
+    if ((context.recentPainEvents ?? []).length > 0) {
+        scenarios.add('user-friction');
+    }
+    if ((context.recentGateBlocks ?? []).length > 0) {
+        scenarios.add('gate-block');
+    }
+    if ((context.recentUserCorrections ?? []).length > 0) {
+        scenarios.add('user-correction');
+    }
+    if ((context.recentPrincipleEvents ?? []).length > 0) {
+        scenarios.add('principle-feedback');
+    }
+    if (modelId === 'T-03') {
+        scenarios.add('root-cause-analysis');
+    }
+    if (modelId === 'T-04' || modelId === 'T-05') {
+        scenarios.add('risk-review');
+    }
+    if (modelId === 'T-08') {
+        scenarios.add('reflection-loop');
+    }
+    if (modelId === 'T-09') {
+        scenarios.add('task-planning');
+    }
+    return Array.from(scenarios);
+}

package/dist/core/trajectory.d.ts

@@ -0,0 +1,184 @@
+export type CorrectionSampleReviewStatus = 'pending' | 'approved' | 'rejected';
+export type CorrectionExportMode = 'raw' | 'redacted';
+export interface TrajectoryDataStats {
+    dbPath: string;
+    dbSizeBytes: number;
+    assistantTurns: number;
+    userTurns: number;
+    toolCalls: number;
+    painEvents: number;
+    pendingSamples: number;
+    approvedSamples: number;
+    blobBytes: number;
+    lastIngestAt: string | null;
+}
+export interface TrajectoryAssistantTurnInput {
+    sessionId: string;
+    runId: string;
+    provider: string;
+    model: string;
+    rawText: string;
+    sanitizedText: string;
+    usageJson: unknown;
+    empathySignalJson: unknown;
+    createdAt?: string;
+}
+export interface TrajectoryUserTurnInput {
+    sessionId: string;
+    turnIndex: number;
+    rawText: string;
+    correctionDetected: boolean;
+    correctionCue?: string | null;
+    referencesAssistantTurnId?: number | null;
+    createdAt?: string;
+}
+export interface TrajectoryToolCallInput {
+    sessionId: string;
+    toolName: string;
+    outcome: 'success' | 'failure' | 'blocked';
+    durationMs?: number | null;
+    exitCode?: number | null;
+    errorType?: string | null;
+    errorMessage?: string | null;
+    gfiBefore?: number | null;
+    gfiAfter?: number | null;
+    paramsJson?: unknown;
+    createdAt?: string;
+}
+export interface TrajectoryPainEventInput {
+    sessionId: string;
+    source: string;
+    score: number;
+    reason?: string | null;
+    severity?: string | null;
+    origin?: string | null;
+    confidence?: number | null;
+    createdAt?: string;
+}
+export interface TrajectoryGateBlockInput {
+    sessionId?: string | null;
+    toolName: string;
+    filePath?: string | null;
+    reason: string;
+    planStatus?: string | null;
+    createdAt?: string;
+}
+export interface TrajectoryTrustChangeInput {
+    sessionId?: string | null;
+    previousScore: number;
+    newScore: number;
+    delta: number;
+    reason: string;
+    createdAt?: string;
+}
+export interface TrajectoryPrincipleEventInput {
+    principleId?: string | null;
+    eventType: string;
+    payload: unknown;
+    createdAt?: string;
+}
+export interface TrajectoryTaskOutcomeInput {
+    sessionId: string;
+    taskId?: string | null;
+    outcome: string;
+    summary?: string | null;
+    principleIdsJson?: unknown;
+    createdAt?: string;
+}
+export interface TrajectorySessionInput {
+    sessionId: string;
+    startedAt?: string;
+}
+export interface AssistantTurnRecord {
+    id: number;
+    sessionId: string;
+    runId: string;
+    provider: string;
+    model: string;
+    rawText: string;
+    sanitizedText: string;
+    blobRef: string | null;
+    createdAt: string;
+}
+export interface CorrectionSampleRecord {
+    sampleId: string;
+    sessionId: string;
+    badAssistantTurnId: number;
+    userCorrectionTurnId: number;
+    recoveryToolSpanJson: string;
+    diffExcerpt: string;
+    principleIdsJson: string;
+    qualityScore: number;
+    reviewStatus: CorrectionSampleReviewStatus;
+    exportMode: CorrectionExportMode;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface TrajectoryExportResult {
+    filePath: string;
+    count: number;
+    mode?: CorrectionExportMode;
+}
+export interface TrajectoryDatabaseOptions {
+    workspaceDir: string;
+    blobInlineThresholdBytes?: number;
+    busyTimeoutMs?: number;
+    orphanBlobGraceDays?: number;
+}
+export declare class TrajectoryDatabase {
+    private readonly workspaceDir;
+    private readonly stateDir;
+    private readonly dbPath;
+    private readonly blobDir;
+    private readonly exportDir;
+    private readonly blobInlineThresholdBytes;
+    private readonly orphanBlobGraceMs;
+    private readonly db;
+    constructor(opts: TrajectoryDatabaseOptions);
+    dispose(): void;
+    recordSession(input: TrajectorySessionInput): void;
+    recordAssistantTurn(input: TrajectoryAssistantTurnInput): number;
+    recordUserTurn(input: TrajectoryUserTurnInput): number;
+    recordToolCall(input: TrajectoryToolCallInput): number;
+    recordPainEvent(input: TrajectoryPainEventInput): void;
+    recordGateBlock(input: TrajectoryGateBlockInput): void;
+    recordTrustChange(input: TrajectoryTrustChangeInput): void;
+    recordPrincipleEvent(input: TrajectoryPrincipleEventInput): void;
+    recordTaskOutcome(input: TrajectoryTaskOutcomeInput): void;
+    listAssistantTurns(sessionId: string): AssistantTurnRecord[];
+    listCorrectionSamples(status?: CorrectionSampleReviewStatus): CorrectionSampleRecord[];
+    reviewCorrectionSample(sampleId: string, status: Exclude<CorrectionSampleReviewStatus, 'pending'>, note?: string): CorrectionSampleRecord;
+    exportCorrections(opts: {
+        mode: CorrectionExportMode;
+        approvedOnly: boolean;
+    }): TrajectoryExportResult;
+    exportAnalytics(): TrajectoryExportResult;
+    getDataStats(): TrajectoryDataStats;
+    cleanupBlobStorage(): {
+        removedFiles: number;
+        reclaimedBytes: number;
+    };
+    private initSchema;
+    private importLegacyArtifacts;
+    private migrateSchema;
+    private dailyMetrics;
+    private importLegacySessions;
+    private importLegacyEvents;
+    private importLegacyEvolution;
+    private markImported;
+    private isImported;
+    private maybeCreateCorrectionSample;
+    private recordExportAudit;
+    private storeRawText;
+    private restoreRawText;
+    private computeBlobBytes;
+    private pruneUnreferencedBlobs;
+    private withWrite;
+}
+export declare class TrajectoryRegistry {
+    private static instances;
+    static get(workspaceDir: string, opts?: Omit<TrajectoryDatabaseOptions, 'workspaceDir'>): TrajectoryDatabase;
+    static dispose(workspaceDir: string): void;
+    static clear(): void;
+    static use<T>(workspaceDir: string, fn: (db: TrajectoryDatabase) => T, opts?: Omit<TrajectoryDatabaseOptions, 'workspaceDir'>): T;
+}