create-principles-disciple 1.82.0 → 1.83.0

package/plugin/dist/hooks/prompt.js

@@ -17,6 +17,7 @@ import { evaluatePainDiagnosticGate } from '../core/pain-diagnostic-gate.js';
 import { emitPainDetectedEvent, buildTrajectoryEvidence } from './pain.js';
 import { CorrectionCueLearner } from '../core/correction-cue-learner.js';
 import { detectCorrectionCue as coreDetectCorrectionCue, extractMessageContent, isMinimalTrigger, } from '@principles/core/prompt-builder';
+import { sanitizeForEvidence } from './message-sanitize.js';
 // ---------------------------------------------------------------------------
 // Static file cache — avoids re-reading rarely-changing files every message
 // ---------------------------------------------------------------------------
@@ -452,7 +453,7 @@ The empathy observer subagent handles pain detection independently.
                                     confidence: result.confidence,
                                     detection_mode: 'structured',
                                     deduped: false,
-                                    trigger_text_excerpt: latestUserMessage.substring(0, 120),
+                                    trigger_text_excerpt: sanitizeForEvidence(latestUserMessage, workspaceDir).substring(0, 120),
                                     raw_score: painScore,
                                     calibrated_score: painScore,
                                     eventId,
@@ -466,7 +467,7 @@ The empathy observer subagent handles pain detection independently.
                                         severity: result.severity,
                                         origin: 'system_infer',
                                         confidence: result.confidence,
-                                        text: latestUserMessage,
+                                        text: sanitizeForEvidence(latestUserMessage, workspaceDir),
                                     });
                                 }
                                 catch (error) {

package/plugin/dist/hooks/trajectory-evidence.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Trajectory Evidence Builder — PRI-326
+ *
+ * Extracted from pain.ts to avoid circular imports between
+ * pain.ts and after-tool-call-helpers.ts.
+ *
+ * Pure data extraction — reads from trajectory DB, sanitizes, returns evidence entries.
+ */
+import type { PainEvidenceEntry } from '@principles/core/runtime-v2';
+import type { WorkspaceContext } from '../core/workspace-context.js';
+export declare function buildTrajectoryEvidence(wctx: WorkspaceContext, sessionId: string): PainEvidenceEntry[];

package/plugin/dist/hooks/trajectory-evidence.js

@@ -0,0 +1,65 @@
+/**
+ * Trajectory Evidence Builder — PRI-326
+ *
+ * Extracted from pain.ts to avoid circular imports between
+ * pain.ts and after-tool-call-helpers.ts.
+ *
+ * Pure data extraction — reads from trajectory DB, sanitizes, returns evidence entries.
+ */
+import { sanitizeAssistantText } from './message-sanitize.js';
+import { MAX_EVIDENCE_ENTRIES, MAX_EVIDENCE_NOTE_CHARS } from '@principles/core/runtime-v2';
+export function buildTrajectoryEvidence(wctx, sessionId) {
+    const evidence = [];
+    if (!wctx.trajectory || sessionId === 'unknown') {
+        evidence.push({
+            sourceRef: 'owner_message:unavailable',
+            note: `trajectory_unavailable: ${!wctx.trajectory ? 'no_trajectory_db' : 'unknown_session'}`,
+        });
+        return evidence.slice(0, MAX_EVIDENCE_ENTRIES);
+    }
+    try {
+        const userTurns = wctx.trajectory.listUserTurnsForSession(sessionId) ?? [];
+        const lastCorrectionTurn = [...userTurns].reverse().find(t => t.correctionDetected);
+        if (lastCorrectionTurn) {
+            const sanitizedOwnerMessage = sanitizeAssistantText((lastCorrectionTurn.rawExcerpt ?? '').slice(0, MAX_EVIDENCE_NOTE_CHARS));
+            evidence.push({
+                sourceRef: `owner_message:${lastCorrectionTurn.createdAt}`,
+                note: sanitizedOwnerMessage,
+            });
+        }
+    }
+    catch (e) {
+        evidence.push({
+            sourceRef: 'owner_message:unavailable',
+            note: `trajectory_user_turns_unavailable: ${String(e).slice(0, 100)}`,
+        });
+    }
+    try {
+        const assistantTurns = wctx.trajectory.listAssistantTurns(sessionId) ?? [];
+        const recentAssistant = assistantTurns.slice(-3);
+        for (const turn of recentAssistant) {
+            if (evidence.length >= MAX_EVIDENCE_ENTRIES)
+                break;
+            const sanitizedNote = sanitizeAssistantText((turn.sanitizedText ?? '').slice(0, MAX_EVIDENCE_NOTE_CHARS));
+            evidence.push({
+                sourceRef: `agent_turn:${turn.createdAt}`,
+                note: sanitizedNote,
+            });
+        }
+    }
+    catch (e) {
+        if (evidence.length < MAX_EVIDENCE_ENTRIES) {
+            evidence.push({
+                sourceRef: 'agent_turn:unavailable',
+                note: `trajectory_assistant_turns_unavailable: ${String(e).slice(0, 100)}`,
+            });
+        }
+    }
+    if (evidence.length === 0) {
+        evidence.push({
+            sourceRef: 'trajectory:empty',
+            note: 'trajectory_available_but_empty: no user correction or assistant turns found',
+        });
+    }
+    return evidence.slice(0, MAX_EVIDENCE_ENTRIES);
+}

package/plugin/dist/hooks/triage-adapter.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Triage Adapter — PEAT-B1
+ *
+ * Plugin-side adapter that maps OpenClaw hook context to evidence triage input.
+ * Calls the pure triage policy from principles-core.
+ *
+ * This file lives in openclaw-plugin because it:
+ * - Maps hook-specific context (source strings, session state) to SourceKind
+ * - Wraps evaluatePainDiagnosticGate as a compatibility sub-policy
+ * - Knows about OpenClaw hook conventions (sessionId, toolName, etc.)
+ *
+ * It does NOT expose evaluatePainDiagnosticGate to core.
+ * Core only sees SourceKind and TriageResult.
+ *
+ * ERR checklist:
+ * - ERR-001: Source kind derived from runtime values with guards, not `as` casts.
+ * - ERR-002: Every triage result carries reason + nextAction.
+ * - ERR-024/025/048: Production-path tests cover this adapter.
+ */
+import { type TriageResult, type SourceKind } from '@principles/core/runtime-v2';
+/**
+ * Map after_tool_call hook context to SourceKind.
+ *
+ * Classifies based on:
+ * - toolName: 'pain' or 'skill:pain' → agent_on_owner_request
+ * - failureSource: 'dispatch_error' vs 'tool_failure'
+ * - isRisky + score: only used for rulehost_block upgrade, not for kind resolution
+ */
+export declare function resolveSourceKindFromToolFailure(toolName: string | undefined, failureSource: 'tool_failure' | 'dispatch_error', provenance?: 'openclaw_context_bound' | 'owner_reported_no_host_trace' | 'automatic_hook'): SourceKind;
+/**
+ * Map empathy/semantic detection context to SourceKind.
+ *
+ * Classifies based on detection source prefix:
+ * - 'llm_paralysis' → llm_paralysis
+ * - 'llm_*' (detection rule) → semantic
+ * - 'user_empathy' or empathy keyword match → empathy_inferred
+ * - GFI threshold crossed → gfi_threshold
+ */
+export declare function resolveSourceKindFromLlmDetection(detectionSource: string, isGfiTriggered: boolean): SourceKind;
+/**
+ * Map gate-block context to SourceKind.
+ */
+export declare function resolveSourceKindFromGateBlock(): SourceKind;
+/**
+ * Map /pd-pain command to SourceKind.
+ */
+export declare function resolveSourceKindFromCommand(): SourceKind;
+/**
+ * Map provider/rate-limit failure to SourceKind.
+ */
+export declare function resolveSourceKindFromProvider(isRateLimit: boolean): SourceKind;
+/**
+ * Map subagent error to SourceKind.
+ */
+export declare function resolveSourceKindFromSubagent(): SourceKind;
+/**
+ * Evaluate evidence triage for a given source kind and context.
+ *
+ * This is the main entry point for hooks. It calls the pure triage policy
+ * from principles-core and returns the result.
+ *
+ * The caller (hook) is responsible for:
+ * - Checking the painEvidenceAdmission feature flag
+ * - Acting on the triage result (proceed to diagnosis, store evidence, etc.)
+ * - Falling back to existing behavior when the flag is off
+ */
+export declare function evaluateEvidenceTriage(sourceKind: SourceKind, score: number, options?: {
+    isUnsafeHighConfidence?: boolean;
+    provenance?: 'openclaw_context_bound' | 'owner_reported_no_host_trace' | 'automatic_hook';
+}): TriageResult;
+/**
+ * Determine if a gate-blocked action is a high-confidence unsafe action.
+ *
+ * This is a heuristic that the plugin adapter owns. Core does not know about
+ * these heuristics — it only receives the boolean flag.
+ *
+ * Criteria for high-confidence unsafe:
+ * - Score >= 70 (high severity)
+ * - Tool is in the risky write set
+ * - Action would be irreversible (file deletion, force push, etc.)
+ */
+export declare function isHighConfidenceUnsafeAction(score: number, isRisky: boolean): boolean;

package/plugin/dist/hooks/triage-adapter.js

@@ -0,0 +1,121 @@
+/**
+ * Triage Adapter — PEAT-B1
+ *
+ * Plugin-side adapter that maps OpenClaw hook context to evidence triage input.
+ * Calls the pure triage policy from principles-core.
+ *
+ * This file lives in openclaw-plugin because it:
+ * - Maps hook-specific context (source strings, session state) to SourceKind
+ * - Wraps evaluatePainDiagnosticGate as a compatibility sub-policy
+ * - Knows about OpenClaw hook conventions (sessionId, toolName, etc.)
+ *
+ * It does NOT expose evaluatePainDiagnosticGate to core.
+ * Core only sees SourceKind and TriageResult.
+ *
+ * ERR checklist:
+ * - ERR-001: Source kind derived from runtime values with guards, not `as` casts.
+ * - ERR-002: Every triage result carries reason + nextAction.
+ * - ERR-024/025/048: Production-path tests cover this adapter.
+ */
+import { evaluateTriage, } from '@principles/core/runtime-v2';
+// ── Source Kind Resolution ───────────────────────────────────────────────────
+/**
+ * Map after_tool_call hook context to SourceKind.
+ *
+ * Classifies based on:
+ * - toolName: 'pain' or 'skill:pain' → agent_on_owner_request
+ * - failureSource: 'dispatch_error' vs 'tool_failure'
+ * - isRisky + score: only used for rulehost_block upgrade, not for kind resolution
+ */
+export function resolveSourceKindFromToolFailure(toolName, failureSource, provenance) {
+    // Manual pain via agent tool call
+    if (toolName === 'pain' || toolName === 'skill:pain') {
+        return provenance === 'openclaw_context_bound' ? 'agent_on_owner_request' : 'owner_reported';
+    }
+    // Dispatch errors (tool not found, unknown tool)
+    if (failureSource === 'dispatch_error') {
+        return 'dispatch_error';
+    }
+    // Regular tool failure
+    return 'tool_failure';
+}
+/**
+ * Map empathy/semantic detection context to SourceKind.
+ *
+ * Classifies based on detection source prefix:
+ * - 'llm_paralysis' → llm_paralysis
+ * - 'llm_*' (detection rule) → semantic
+ * - 'user_empathy' or empathy keyword match → empathy_inferred
+ * - GFI threshold crossed → gfi_threshold
+ */
+export function resolveSourceKindFromLlmDetection(detectionSource, isGfiTriggered) {
+    if (isGfiTriggered)
+        return 'gfi_threshold';
+    if (detectionSource === 'llm_paralysis')
+        return 'llm_paralysis';
+    if (detectionSource.startsWith('llm_'))
+        return 'semantic';
+    if (detectionSource === 'user_empathy')
+        return 'empathy_inferred';
+    return 'unknown';
+}
+/**
+ * Map gate-block context to SourceKind.
+ */
+export function resolveSourceKindFromGateBlock() {
+    return 'rulehost_block';
+}
+/**
+ * Map /pd-pain command to SourceKind.
+ */
+export function resolveSourceKindFromCommand() {
+    return 'owner_reported';
+}
+/**
+ * Map provider/rate-limit failure to SourceKind.
+ */
+export function resolveSourceKindFromProvider(isRateLimit) {
+    return isRateLimit ? 'rate_limit' : 'provider_failure';
+}
+/**
+ * Map subagent error to SourceKind.
+ */
+export function resolveSourceKindFromSubagent() {
+    return 'subagent_error';
+}
+// ── Triage Evaluation ───────────────────────────────────────────────────────
+/**
+ * Evaluate evidence triage for a given source kind and context.
+ *
+ * This is the main entry point for hooks. It calls the pure triage policy
+ * from principles-core and returns the result.
+ *
+ * The caller (hook) is responsible for:
+ * - Checking the painEvidenceAdmission feature flag
+ * - Acting on the triage result (proceed to diagnosis, store evidence, etc.)
+ * - Falling back to existing behavior when the flag is off
+ */
+export function evaluateEvidenceTriage(sourceKind, score, options) {
+    const input = {
+        sourceKind,
+        score,
+        isUnsafeHighConfidence: options?.isUnsafeHighConfidence,
+        provenance: options?.provenance,
+    };
+    return evaluateTriage(input);
+}
+// ── High-Confidence Unsafe Action Detection ──────────────────────────────────
+/**
+ * Determine if a gate-blocked action is a high-confidence unsafe action.
+ *
+ * This is a heuristic that the plugin adapter owns. Core does not know about
+ * these heuristics — it only receives the boolean flag.
+ *
+ * Criteria for high-confidence unsafe:
+ * - Score >= 70 (high severity)
+ * - Tool is in the risky write set
+ * - Action would be irreversible (file deletion, force push, etc.)
+ */
+export function isHighConfidenceUnsafeAction(score, isRisky) {
+    return isRisky && score >= 70;
+}

package/console/dist/server/models/EventLogReadModel.d.ts

@@ -1,33 +0,0 @@
-import type { EventLogEntry, GateBlockEvent } from '../types/index.js';
-export declare class EventLogReadModel {
-    private readonly logsDir;
-    constructor(stateDir: string);
-    private readFilesWithConcurrency;
-    getEventsPaginated(options: {
-        types?: string[];
-        startDate?: string;
-        endDate?: string;
-        searchQuery?: string;
-        page?: number;
-        pageSize?: number;
-    }): Promise<{
-        events: EventLogEntry[];
-        total: number;
-        totalPages: number;
-    }>;
-    countEventsGroupedByType(dateRange?: {
-        startDate?: string;
-        endDate?: string;
-    }): Promise<Record<string, number>>;
-    getRelatedEvents(eventId: string, maxDistance?: number): Promise<EventLogEntry[]>;
-    getGateBlocks(limit?: number): Promise<GateBlockEvent[]>;
-    countGateBlocksToday(): Promise<number>;
-    countEventsByTypeToday(eventType: string): Promise<number>;
-    getEventsByTypes(types: string[], limit?: number): Promise<EventLogEntry[]>;
-    countEventsByTypeAndDate(eventType: string, date: string): Promise<number>;
-    countEventsByCategoryAndDate(category: string, date: string): Promise<number>;
-    private getEventFiles;
-    private readEventsOfFile;
-    private readLines;
-    dispose(): void;
-}

package/console/dist/server/models/EventLogReadModel.js

@@ -1,218 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-function extractFileDate(filePath) {
-    const match = /events_(\d{4}-\d{2}-\d{2})\.jsonl/.exec(filePath);
-    return match ? match[1] : null;
-}
-export class EventLogReadModel {
-    logsDir;
-    constructor(stateDir) {
-        this.logsDir = path.join(stateDir, 'logs');
-    }
-    async readFilesWithConcurrency(files, processor, concurrency = 5) {
-        void this;
-        const results = [];
-        for (let i = 0; i < files.length; i += concurrency) {
-            const batch = files.slice(i, i + concurrency);
-            const batchResults = await Promise.all(batch.map(processor));
-            for (const batchResult of batchResults) {
-                results.push(...batchResult);
-            }
-        }
-        return results;
-    }
-    async getEventsPaginated(options) {
-        const { types, startDate, endDate, searchQuery, page = 1, pageSize = 50, } = options;
-        const allFiles = this.getEventFiles().reverse(); // newest first
-        const filteredFiles = allFiles.filter(file => {
-            if (!startDate && !endDate)
-                return true;
-            const fileDate = extractFileDate(file);
-            if (!fileDate)
-                return true;
-            if (startDate && fileDate < startDate)
-                return false;
-            if (endDate && fileDate > endDate)
-                return false;
-            return true;
-        });
-        const allEntries = await this.readFilesWithConcurrency(filteredFiles, (file) => this.readEventsOfFile(file));
-        const allMatchingEvents = [];
-        for (const entry of allEntries.reverse()) {
-            if (types && types.length > 0 && !types.includes(entry.type))
-                continue;
-            if (searchQuery) {
-                const entryStr = JSON.stringify(entry).toLowerCase();
-                if (!entryStr.includes(searchQuery.toLowerCase()))
-                    continue;
-            }
-            allMatchingEvents.push(entry);
-        }
-        const total = allMatchingEvents.length;
-        const totalPages = Math.ceil(total / pageSize);
-        const startIndex = (page - 1) * pageSize;
-        const events = allMatchingEvents.slice(startIndex, startIndex + pageSize);
-        return { events, total, totalPages };
-    }
-    async countEventsGroupedByType(dateRange) {
-        const allFiles = this.getEventFiles().reverse();
-        const filteredFiles = allFiles.filter(file => {
-            if (!dateRange?.startDate && !dateRange?.endDate)
-                return true;
-            const fileDate = extractFileDate(file);
-            if (!fileDate)
-                return true;
-            if (dateRange.startDate && fileDate < dateRange.startDate)
-                return false;
-            if (dateRange.endDate && fileDate > dateRange.endDate)
-                return false;
-            return true;
-        });
-        const allEntries = await this.readFilesWithConcurrency(filteredFiles, (file) => this.readEventsOfFile(file));
-        const counts = {};
-        for (const entry of allEntries) {
-            counts[entry.type] = (counts[entry.type] || 0) + 1;
-        }
-        return counts;
-    }
-    async getRelatedEvents(eventId, maxDistance = 10) {
-        const allFiles = this.getEventFiles().reverse();
-        const allEntries = await this.readFilesWithConcurrency(allFiles, (file) => this.readEventsOfFile(file));
-        const relatedEvents = [];
-        let foundTarget = false;
-        let distance = 0;
-        for (const entry of allEntries) {
-            if (entry.id === eventId) {
-                foundTarget = true;
-                relatedEvents.push(entry);
-            }
-            else if (foundTarget && distance < maxDistance) {
-                relatedEvents.push(entry);
-                distance++;
-            }
-        }
-        return relatedEvents;
-    }
-    async getGateBlocks(limit = 100) {
-        const files = this.getEventFiles();
-        const allEntries = await this.readFilesWithConcurrency(files, (file) => this.readEventsOfFile(file));
-        const blocks = [];
-        for (const entry of allEntries.reverse()) {
-            if (entry.type === 'gate_block' && blocks.length < limit) {
-                blocks.push(entry);
-            }
-            if (blocks.length >= limit)
-                break;
-        }
-        return blocks;
-    }
-    async countGateBlocksToday() {
-        const [today] = new Date().toISOString().split('T');
-        const file = path.join(this.logsDir, `events_${today}.jsonl`);
-        if (!fs.existsSync(file))
-            return 0;
-        let count = 0;
-        for await (const line of this.readLines(file)) {
-            try {
-                const entry = JSON.parse(line);
-                if (entry.type === 'gate_block')
-                    count++;
-            }
-            catch { /* skip malformed */ }
-        }
-        return count;
-    }
-    async countEventsByTypeToday(eventType) {
-        const [today] = new Date().toISOString().split('T');
-        const file = path.join(this.logsDir, `events_${today}.jsonl`);
-        if (!fs.existsSync(file))
-            return 0;
-        let count = 0;
-        for await (const line of this.readLines(file)) {
-            try {
-                const entry = JSON.parse(line);
-                if (entry.type === eventType)
-                    count++;
-            }
-            catch { /* skip malformed */ }
-        }
-        return count;
-    }
-    async getEventsByTypes(types, limit = 50) {
-        const files = this.getEventFiles();
-        const allEntries = await this.readFilesWithConcurrency(files, (file) => this.readEventsOfFile(file));
-        const results = [];
-        for (const entry of allEntries.reverse()) {
-            if (types.includes(entry.type) && results.length < limit) {
-                results.push(entry);
-            }
-            if (results.length >= limit)
-                break;
-        }
-        return results;
-    }
-    async countEventsByTypeAndDate(eventType, date) {
-        const file = path.join(this.logsDir, `events_${date}.jsonl`);
-        if (!fs.existsSync(file))
-            return 0;
-        let count = 0;
-        for await (const line of this.readLines(file)) {
-            try {
-                const entry = JSON.parse(line);
-                if (entry.type === eventType)
-                    count++;
-            }
-            catch { /* skip malformed */ }
-        }
-        return count;
-    }
-    async countEventsByCategoryAndDate(category, date) {
-        const file = path.join(this.logsDir, `events_${date}.jsonl`);
-        if (!fs.existsSync(file))
-            return 0;
-        let count = 0;
-        for await (const line of this.readLines(file)) {
-            try {
-                const entry = JSON.parse(line);
-                if (entry.category === category)
-                    count++;
-            }
-            catch { /* skip malformed */ }
-        }
-        return count;
-    }
-    getEventFiles() {
-        if (!fs.existsSync(this.logsDir))
-            return [];
-        return fs.readdirSync(this.logsDir)
-            .filter(f => f.startsWith('events_') && f.endsWith('.jsonl'))
-            .sort()
-            .map(f => path.join(this.logsDir, f));
-    }
-    async readEventsOfFile(filePath) {
-        const entries = [];
-        for await (const line of this.readLines(filePath)) {
-            try {
-                entries.push(JSON.parse(line));
-            }
-            catch { /* skip malformed */ }
-        }
-        return entries;
-    }
-    async *readLines(filePath) {
-        const fileStream = fs.createReadStream(filePath, { encoding: 'utf8' });
-        const readline = await import('readline');
-        const rl = readline.createInterface({
-            input: fileStream,
-            crlfDelay: Infinity,
-        });
-        for await (const line of rl) {
-            if (line.trim())
-                yield line;
-        }
-        void this.logsDir;
-    }
-    dispose() {
-        void this.logsDir;
-    }
-}

package/console/dist/server/models/EvolutionConsoleModel.d.ts

@@ -1,79 +0,0 @@
-export type PrincipleStatus = 'candidate' | 'active' | 'archived' | 'deprecated' | 'probation';
-export interface EvolutionStats {
-    total: number;
-    pending: number;
-    inProgress: number;
-    completed: number;
-    failed: number;
-    stageDistribution: {
-        stage: string;
-        count: number;
-    }[];
-}
-export interface EvolutionTaskItem {
-    taskId: string;
-    taskKind: string;
-    status: string;
-    createdAt: string;
-    leaseOwner: string | null;
-    leaseExpiresAt: string | null;
-}
-export interface EvolutionTasksOutput {
-    items: EvolutionTaskItem[];
-    pagination: {
-        page: number;
-        pageSize: number;
-        total: number;
-        totalPages: number;
-    };
-}
-export interface PrincipleLifecycleSummary {
-    candidate: number;
-    probation: number;
-    active: number;
-    deprecated: number;
-    archived: number;
-    total: number;
-}
-export interface PrincipleTransition {
-    principleId: string;
-    status: PrincipleStatus;
-    text: string;
-    triggerPattern: string;
-    action: string;
-    evaluability: string;
-    createdAt: string;
-    updatedAt: string;
-}
-export interface EvolutionPrinciplesOutput {
-    summary: PrincipleLifecycleSummary;
-    recent: PrincipleTransition[];
-}
-export interface QueueHealthOutput {
-    pendingCount: number;
-    retryWaitCount: number;
-    countsByTaskKind: Record<string, number>;
-    countsByChannel: Record<string, number>;
-    invalidMetadataCount: number;
-    blockedCount: number;
-    dependencyFailedCount: number;
-    readyTaskCount: number;
-    noReadyTasksReason: string | null;
-}
-export declare class EvolutionConsoleModel {
-    private readonly workspaceDir;
-    private stateManager;
-    private initPromise;
-    constructor(workspaceDir: string);
-    private ensureInitialized;
-    getStats(): Promise<EvolutionStats>;
-    getTasks(filters?: {
-        status?: string;
-        taskKind?: string;
-        page?: number;
-        pageSize?: number;
-    }): Promise<EvolutionTasksOutput>;
-    getPrinciples(): Promise<EvolutionPrinciplesOutput>;
-    getQueueHealth(): Promise<QueueHealthOutput>;
-    dispose(): void;
-}