principles-disciple 1.127.0 → 1.129.0

package/dist/service/central-sync-service.d.ts

@@ -0,0 +1,8 @@
+/**
+ * CentralSyncService - Periodically sync workspace data to central database.
+ *
+ * Ensures thinking_model_events and other workspace data are aggregated
+ * into the central database for cross-workspace queries and WebUI display.
+ */
+import type { OpenClawPluginService } from '../openclaw-sdk.js';
+export declare const CentralSyncService: OpenClawPluginService;

package/dist/service/central-sync-service.js

@@ -0,0 +1,71 @@
+/**
+ * CentralSyncService - Periodically sync workspace data to central database.
+ *
+ * Ensures thinking_model_events and other workspace data are aggregated
+ * into the central database for cross-workspace queries and WebUI display.
+ */
+import { CentralDatabase } from './central-database.js';
+import { WORKFLOW_TTL_MS } from '../config/defaults/runtime.js';
+let syncInterval = null;
+let logger = undefined;
+let centralDb = null;
+async function runSyncCycle() {
+    if (!centralDb) {
+        logger?.warn?.('[PD:CentralSync] CentralDatabase not initialized, skipping sync');
+        return;
+    }
+    try {
+        const results = centralDb.syncAll();
+        const totalSynced = Array.from(results.values()).reduce((sum, count) => sum + count, 0);
+        const workspacesSynced = Array.from(results.entries())
+            .filter(([, count]) => count > 0)
+            .map(([name, count]) => `${name}:${count}`)
+            .join(', ');
+        if (totalSynced > 0) {
+            logger?.info?.(`[PD:CentralSync] Synced ${totalSynced} records from workspaces: ${workspacesSynced}`);
+        }
+        else {
+            logger?.debug?.(`[PD:CentralSync] No new records to sync`);
+        }
+    }
+    catch (err) {
+        logger?.error?.(`[PD:CentralSync] Sync failed: ${String(err)}`);
+    }
+}
+export const CentralSyncService = {
+    id: 'principles-central-sync',
+    async start(ctx) {
+        const { logger: ctxLogger, config } = ctx;
+        logger = ctxLogger;
+        const { intervals } = config;
+        const intervalMs = intervals?.central_sync_ms ?? WORKFLOW_TTL_MS;
+        // Initialize CentralDatabase
+        centralDb = new CentralDatabase();
+        // Initial sync on start
+        logger?.info?.(`[PD:CentralSync] Starting with interval ${intervalMs}ms`);
+        await runSyncCycle();
+        // Schedule periodic sync
+        syncInterval = setInterval(runSyncCycle, intervalMs);
+        // Don't keep the process alive just for this timer
+        syncInterval.unref();
+        logger?.info?.(`[PD:CentralSync] Service started, syncing every ${intervalMs / 1000}s`);
+    },
+    async stop(ctx) {
+        if (syncInterval) {
+            clearInterval(syncInterval);
+            syncInterval = null;
+        }
+        // Final sync on stop
+        if (centralDb) {
+            try {
+                centralDb.syncAll();
+                ctx.logger?.info?.(`[PD:CentralSync] Final sync completed`);
+            }
+            catch (err) {
+                ctx.logger?.error?.(`[PD:CentralSync] Final sync failed: ${String(err)}`);
+            }
+        }
+        centralDb = null;
+        ctx.logger?.info?.(`[PD:CentralSync] Service stopped`);
+    },
+};

package/dist/service/correction-observer-service.d.ts

@@ -0,0 +1,19 @@
+import type { OpenClawPluginServiceContext, PluginLogger } from '../openclaw-sdk.js';
+import { WorkspaceContext } from '../core/workspace-context.js';
+import { CorrectionObserver } from '@principles/core/runtime-v2';
+export interface CorrectionObserverServiceShape {
+    id: string;
+    start: (ctx: OpenClawPluginServiceContext) => void;
+    stop?: (ctx: OpenClawPluginServiceContext) => void;
+}
+/**
+ * PRI-307: Resolve CorrectionObserver from .pd/config.yaml.
+ *
+ * States:
+ * - disabled: feature flag off → return null, no noisy logs
+ * - needs_setup: enabled but missing API key or profile → return null with structured reason
+ * - ready/not_ready: enabled and configured → return observer instance
+ */
+export declare function resolveCorrectionObserver(wctx: WorkspaceContext, logger?: Pick<PluginLogger, 'info' | 'warn' | 'error' | 'debug'>): CorrectionObserver | null;
+export declare function runCorrectionObserverCycle(wctx: WorkspaceContext, logger: PluginLogger): Promise<void>;
+export declare const CorrectionObserverService: CorrectionObserverServiceShape;

package/{src/service/correction-observer-service.ts → dist/service/correction-observer-service.js}

@@ -1,31 +1,17 @@
-import type { OpenClawPluginServiceContext, PluginLogger } from '../openclaw-sdk.js';
 import { WorkspaceContext } from '../core/workspace-context.js';
 import { TrajectoryRegistry } from '../core/trajectory.js';
 import { CorrectionCueLearner } from '../core/correction-cue-learner.js';
-import {
-    PiAiRuntimeAdapter,
-    CorrectionObserver,
-    AgentScheduler,
-} from '@principles/core/runtime-v2';
+import { PiAiRuntimeAdapter, CorrectionObserver, AgentScheduler, } from '@principles/core/runtime-v2';
 import { KeywordOptimizationService } from './keyword-optimization-service.js';
 import { SystemLogger } from '../core/system-logger.js';
 import { resolveObserverConfig } from '../core/pd-config-loader.js';
-
-export interface CorrectionObserverServiceShape {
-    id: string;
-    start: (ctx: OpenClawPluginServiceContext) => void;
-    stop?: (ctx: OpenClawPluginServiceContext) => void;
-}
-
-let correctionObserverTimeoutId: ReturnType<typeof setTimeout> | null = null;
+let correctionObserverTimeoutId = null;
 let correctionObserverStopped = false;
-const startedWorkspaces = new Set<string>();
-
+const startedWorkspaces = new Set();
 const CORRECTION_OBSERVER_INTERVAL_MS = 15 * 60 * 1000;
 const CORRECTION_OBSERVER_INITIAL_DELAY_MS = 10_000;
 const CORRECTION_OBSERVER_MAX_RECENT_SESSIONS = 20;
 const CORRECTION_OBSERVER_MAX_PAYLOAD_SESSIONS = 5;
-
 /**
  * PRI-307: Resolve CorrectionObserver from .pd/config.yaml.
  *
@@ -34,29 +20,22 @@ const CORRECTION_OBSERVER_MAX_PAYLOAD_SESSIONS = 5;
  * - needs_setup: enabled but missing API key or profile → return null with structured reason
  * - ready/not_ready: enabled and configured → return observer instance
  */
-export function resolveCorrectionObserver(wctx: WorkspaceContext, logger?: Pick<PluginLogger, 'info' | 'warn' | 'error' | 'debug'>): CorrectionObserver | null {
+export function resolveCorrectionObserver(wctx, logger) {
     try {
-        const observerConfig = resolveObserverConfig(
-            wctx.workspaceDir,
-            'correction_observer',
-            'correctionObserver',
-            logger,
-        );
-
+        const observerConfig = resolveObserverConfig(wctx.workspaceDir, 'correction_observer', 'correctionObserver', logger);
         if (!observerConfig.enabled) {
             if (observerConfig.readiness === 'config_malformed') {
                 logger?.warn?.(`[PD:CorrectionObserver] Config malformed: ${observerConfig.reason}. ${observerConfig.nextAction}`);
-            } else {
+            }
+            else {
                 logger?.debug?.(`[PD:CorrectionObserver] ${observerConfig.reason}`);
             }
             return null;
         }
-
         if (observerConfig.readiness === 'needs_setup') {
             logger?.info?.(`[PD:CorrectionObserver] ${observerConfig.reason}. ${observerConfig.nextAction}`);
             return null;
         }
-
         // ready or not_ready — create the observer
         if (observerConfig.runtimeProfileType === 'pi-ai') {
             const adapter = new PiAiRuntimeAdapter({
@@ -69,17 +48,16 @@ export function resolveCorrectionObserver(wctx: WorkspaceContext, logger?: Pick<
             });
             return new CorrectionObserver({ runtimeAdapter: adapter }, { timeoutMs: observerConfig.timeoutMs ?? undefined });
         }
-
         // OpenClaw profile — not yet supported for observer runtime
         logger?.info?.(`[PD:CorrectionObserver] OpenClaw runtime profile not yet supported for correction observer. Skipping.`);
         return null;
-    } catch (err) {
+    }
+    catch (err) {
         logger?.warn?.(`[PD:CorrectionObserver] Failed to resolve CorrectionObserver: ${String(err)}`);
         return null;
     }
 }
-
-export async function runCorrectionObserverCycle(wctx: WorkspaceContext, logger: PluginLogger): Promise<void> {
+export async function runCorrectionObserverCycle(wctx, logger) {
     try {
         const observer = resolveCorrectionObserver(wctx, logger);
         if (!observer) {
@@ -87,19 +65,15 @@ export async function runCorrectionObserverCycle(wctx: WorkspaceContext, logger:
             logger?.debug?.(`[PD:CorrectionObserver] Observer not resolved. Skipping cycle.`);
             return;
         }
-
         logger?.info?.('[PD:CorrectionObserver] Observer resolved. Initiating periodic optimization...');
-
         const db = TrajectoryRegistry.get(wctx.workspaceDir);
         const recentSessions = db.listRecentSessions({ limit: CORRECTION_OBSERVER_MAX_RECENT_SESSIONS });
         const recentSessionIds = recentSessions.map(s => s.sessionId);
-
         if (recentSessionIds.length === 0) {
             logger?.info?.('[PD:CorrectionObserver] No recent sessions found. Skipping correction optimization.');
             return;
         }
-
-        const recentMessages: string[] = [];
+        const recentMessages = [];
         for (const sId of recentSessionIds.slice(0, CORRECTION_OBSERVER_MAX_PAYLOAD_SESSIONS)) {
             try {
                 const turns = db.listUserTurnsForSession(sId);
@@ -108,11 +82,11 @@ export async function runCorrectionObserverCycle(wctx: WorkspaceContext, logger:
                         recentMessages.push(t.rawExcerpt);
                     }
                 }
-            } catch (turnErr) {
+            }
+            catch (turnErr) {
                 logger?.warn?.(`[PD:CorrectionObserver] Failed to load user turns for session ${sId}: ${String(turnErr)}`);
             }
         }
-
         const learner = CorrectionCueLearner.get(wctx.stateDir);
         const keywords = learner.getStore().keywords;
         const keywordStoreSummary = {
@@ -125,10 +99,8 @@ export async function runCorrectionObserverCycle(wctx: WorkspaceContext, logger:
                 falsePositiveCount: k.falsePositiveCount ?? 0,
             })),
         };
-
         const optimizationService = KeywordOptimizationService.get(wctx.stateDir, wctx.workspaceDir, logger);
         const trajectoryHistory = await optimizationService.buildTrajectoryHistory(recentSessionIds);
-
         const payload = {
             parentSessionId: 'correction-observer-service',
             workspaceDir: wctx.workspaceDir,
@@ -136,96 +108,84 @@ export async function runCorrectionObserverCycle(wctx: WorkspaceContext, logger:
             recentMessages,
             trajectoryHistory,
         };
-
         const scheduler = new AgentScheduler();
         scheduler.register({
             agentId: 'correction-observer',
             mode: 'realtime',
             runner: observer,
         });
-
         logger?.info?.(`[PD:CorrectionObserver] Dispatching with ${trajectoryHistory.length} trajectory events, ${recentMessages.length} recent messages.`);
         const result = await scheduler.dispatch('correction-observer', payload);
         logger?.info?.(`[PD:CorrectionObserver] Completed: updated=${result.updated}, summary="${result.summary}"`);
-
         if (result.updated) {
             optimizationService.applyResult(result);
         }
-    } catch (err) {
+    }
+    catch (err) {
         const errMsg = `Correction observer cycle failed: ${String(err)}`;
         logger?.warn?.(`[PD:CorrectionObserver] ${errMsg}`);
         SystemLogger.log(wctx.workspaceDir, 'CORRECTION_OBSERVER_CYCLE_FAILED', errMsg);
     }
 }
-
-export const CorrectionObserverService: CorrectionObserverServiceShape = {
+export const CorrectionObserverService = {
     id: 'principles-correction-observer',
-
-    start(ctx: OpenClawPluginServiceContext): void {
+    start(ctx) {
         const workspaceDir = ctx?.workspaceDir;
         const logger = ctx?.logger || console;
-
         if (!workspaceDir) {
-            if (logger) logger.warn('[PD:CorrectionObserver] workspaceDir not found in service config. Correction observer disabled.');
+            if (logger)
+                logger.warn('[PD:CorrectionObserver] workspaceDir not found in service config. Correction observer disabled.');
             return;
         }
-
         if (startedWorkspaces.has(workspaceDir)) {
-            if (logger) logger.info(`[PD:CorrectionObserver] Already started for workspace: ${workspaceDir}. Skipping duplicate start.`);
+            if (logger)
+                logger.info(`[PD:CorrectionObserver] Already started for workspace: ${workspaceDir}. Skipping duplicate start.`);
             return;
         }
-
         // PRI-307: Check observer config before starting
-        const observerConfig = resolveObserverConfig(
-            workspaceDir,
-            'correction_observer',
-            'correctionObserver',
-            logger,
-        );
-
+        const observerConfig = resolveObserverConfig(workspaceDir, 'correction_observer', 'correctionObserver', logger);
         if (!observerConfig.enabled) {
             // Disabled → no start, no noisy cycling. Single structured log.
             logger?.info?.(`[PD:CorrectionObserver] ${observerConfig.reason}. ${observerConfig.nextAction}`);
             return;
         }
-
         if (observerConfig.readiness === 'needs_setup') {
             // Enabled but missing setup → structured needs_setup, no noisy cycling
             logger?.info?.(`[PD:CorrectionObserver] ${observerConfig.reason}. ${observerConfig.nextAction}`);
             return;
         }
-
         startedWorkspaces.add(workspaceDir);
         correctionObserverStopped = false;
-
         const wctx = WorkspaceContext.fromHookContext({ workspaceDir, ...ctx.config });
-        if (logger) logger.info(`[PD:CorrectionObserver] Starting with workspaceDir=${wctx.workspaceDir}, stateDir=${wctx.stateDir}`);
-
+        if (logger)
+            logger.info(`[PD:CorrectionObserver] Starting with workspaceDir=${wctx.workspaceDir}, stateDir=${wctx.stateDir}`);
         const interval = CORRECTION_OBSERVER_INTERVAL_MS;
-
-        async function runCycle(): Promise<void> {
-            if (correctionObserverStopped) return;
+        async function runCycle() {
+            if (correctionObserverStopped)
+                return;
             await runCorrectionObserverCycle(wctx, logger);
-            if (correctionObserverStopped) return;
+            if (correctionObserverStopped)
+                return;
             correctionObserverTimeoutId = setTimeout(runCycle, interval);
             correctionObserverTimeoutId.unref();
         }
-
         correctionObserverTimeoutId = setTimeout(() => {
             void runCycle().catch((err) => {
-                if (logger) logger.error(`[PD:CorrectionObserver] Startup cycle failed: ${String(err)}`);
-                if (correctionObserverStopped) return;
+                if (logger)
+                    logger.error(`[PD:CorrectionObserver] Startup cycle failed: ${String(err)}`);
+                if (correctionObserverStopped)
+                    return;
                 correctionObserverTimeoutId = setTimeout(runCycle, interval);
                 correctionObserverTimeoutId.unref();
             });
         }, CORRECTION_OBSERVER_INITIAL_DELAY_MS);
         correctionObserverTimeoutId.unref();
     },
-
-    stop(_ctx: OpenClawPluginServiceContext): void {
+    stop(_ctx) {
         correctionObserverStopped = true;
         startedWorkspaces.clear();
-        if (correctionObserverTimeoutId) clearTimeout(correctionObserverTimeoutId);
+        if (correctionObserverTimeoutId)
+            clearTimeout(correctionObserverTimeoutId);
         correctionObserverTimeoutId = null;
     },
 };

package/dist/service/evolution-dedup.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Evolution Queue Deduplication Utilities
+ *
+ * Dedup logic for preventing duplicate pain tasks and redundant reflections.
+ * Extracted from evolution-worker.ts.
+ */
+import type { EvolutionQueueItem } from './evolution-queue-migration.js';
+/**
+ * Dedup window for pain queue tasks (30 minutes).
+ */
+export declare const PAIN_QUEUE_DEDUP_WINDOW_MS: number;
+export declare function findRecentDuplicateTask(queue: EvolutionQueueItem[], source: string, preview: string, now: number, reason?: string): EvolutionQueueItem | undefined;
+/**
+ * Check if a similar pain task was enqueued recently.
+ */
+export declare function hasRecentDuplicateTask(queue: EvolutionQueueItem[], source: string, preview: string, now: number, reason?: string): boolean;
+/**
+ * Check if a phrase matches an active promoted rule.
+ */
+export declare function hasEquivalentPromotedRule(dictionary: {
+    getAllRules(): Record<string, {
+        type: string;
+        phrases?: string[];
+        pattern?: string;
+        status: string;
+    }>;
+}, phrase: string): boolean;

package/{src/service/evolution-dedup.ts → dist/service/evolution-dedup.js}

@@ -4,65 +4,45 @@
  * Dedup logic for preventing duplicate pain tasks and redundant reflections.
  * Extracted from evolution-worker.ts.
  */
-
-import type { EvolutionQueueItem } from './evolution-queue-migration.js';
-
 /**
  * Dedup window for pain queue tasks (30 minutes).
  */
 export const PAIN_QUEUE_DEDUP_WINDOW_MS = 30 * 60 * 1000;
-
 /**
  * Maximum length for dedup key components to prevent memory/performance issues
  * from extremely long source or preview strings during queue scanning.
  */
 const MAX_DEDUP_KEY_COMPONENT_LENGTH = 200;
-
-function normalizePainDedupKey(source: string, preview: string, reason?: string): string {
-    const truncate = (s: string) => s.slice(0, MAX_DEDUP_KEY_COMPONENT_LENGTH);
+function normalizePainDedupKey(source, preview, reason) {
+    const truncate = (s) => s.slice(0, MAX_DEDUP_KEY_COMPONENT_LENGTH);
     const normalizedReason = (reason || '').trim().toLowerCase().slice(0, 50);
     return `${truncate(source.trim().toLowerCase())}::${truncate(preview.trim().toLowerCase())}::${normalizedReason}`;
 }
-
-export function findRecentDuplicateTask(
-    queue: EvolutionQueueItem[],
-    source: string,
-    preview: string,
-    now: number,
-    reason?: string
-): EvolutionQueueItem | undefined {
+export function findRecentDuplicateTask(queue, source, preview, now, reason) {
     const key = normalizePainDedupKey(source, preview, reason);
     return queue.find((task) => {
-        if (task.status === 'completed') return false;
+        if (task.status === 'completed')
+            return false;
         const taskTime = new Date(task.enqueued_at || task.timestamp).getTime();
-        if (!Number.isFinite(taskTime) || (now - taskTime) > PAIN_QUEUE_DEDUP_WINDOW_MS) return false;
+        if (!Number.isFinite(taskTime) || (now - taskTime) > PAIN_QUEUE_DEDUP_WINDOW_MS)
+            return false;
         return normalizePainDedupKey(task.source, task.trigger_text_preview || '', task.reason) === key;
     });
 }
-
 /**
  * Check if a similar pain task was enqueued recently.
  */
-export function hasRecentDuplicateTask(
-    queue: EvolutionQueueItem[],
-    source: string,
-    preview: string,
-    now: number,
-    reason?: string
-): boolean {
+export function hasRecentDuplicateTask(queue, source, preview, now, reason) {
     return !!findRecentDuplicateTask(queue, source, preview, now, reason);
 }
-
 /**
  * Check if a phrase matches an active promoted rule.
  */
-export function hasEquivalentPromotedRule(
-    dictionary: { getAllRules(): Record<string, { type: string; phrases?: string[]; pattern?: string; status: string; }> },
-    phrase: string
-): boolean {
+export function hasEquivalentPromotedRule(dictionary, phrase) {
     const normalizedPhrase = phrase.trim().toLowerCase();
     return Object.values(dictionary.getAllRules()).some((rule) => {
-        if (rule.status !== 'active') return false;
+        if (rule.status !== 'active')
+            return false;
         if (rule.type === 'exact_match' && Array.isArray(rule.phrases)) {
             return rule.phrases.some((candidate) => candidate.trim().toLowerCase() === normalizedPhrase);
         }

package/{src/service/evolution-queue-migration.ts → dist/service/evolution-queue-migration.d.ts}

@@ -3,50 +3,37 @@
  *
  * Pure transformation functions and shared queue types.
  */
-
 import type { TaskKind, TaskPriority } from '../core/trajectory-types.js';
-
-// Re-export TaskKind and TaskPriority for convenience
 export type { TaskKind, TaskPriority } from '../core/trajectory-types.js';
-
 /**
  * Queue item status values.
  */
 export type QueueStatus = 'pending' | 'in_progress' | 'completed' | 'failed' | 'canceled';
-
 /**
  * Task resolution strings.
  */
-export type TaskResolution =
-    | 'marker_detected'
-    | 'auto_completed_timeout'
-    | 'failed_max_retries'
-    | 'runtime_unavailable'
-    | 'canceled'
-    | 'late_marker_principle_created'
-    | 'late_marker_no_principle'
-    | 'stub_fallback'
-    | 'skipped_thin_violation'
-    | 'noise_classified'
-    | 'retired';
-
+export type TaskResolution = 'marker_detected' | 'auto_completed_timeout' | 'failed_max_retries' | 'runtime_unavailable' | 'canceled' | 'late_marker_principle_created' | 'late_marker_no_principle' | 'stub_fallback' | 'skipped_thin_violation' | 'noise_classified' | 'retired';
 /**
  * Recent pain context for sleep_reflection tasks.
  * Attached to queue items to provide pain signal context.
  */
 export interface RecentPainContext {
-    mostRecent: { score: number; source: string; reason: string; timestamp: string; sessionId: string } | null;
+    mostRecent: {
+        score: number;
+        source: string;
+        reason: string;
+        timestamp: string;
+        sessionId: string;
+    } | null;
     recentPainCount: number;
     recentMaxPainScore: number;
 }
-
 /**
  * Default values for new V2 fields when migrating legacy items.
  */
-export const DEFAULT_TASK_KIND: TaskKind = 'pain_diagnosis';
-export const DEFAULT_PRIORITY: TaskPriority = 'medium';
-export const DEFAULT_MAX_RETRIES = 3;
-
+export declare const DEFAULT_TASK_KIND: TaskKind;
+export declare const DEFAULT_PRIORITY: TaskPriority;
+export declare const DEFAULT_MAX_RETRIES = 3;
 /**
  * Legacy (pre-V2) queue item schema.
  */
@@ -74,7 +61,6 @@ export interface LegacyEvolutionQueueItem {
     lastError?: string;
     resultRef?: string;
 }
-
 /**
  * V2 queue item schema.
  */
@@ -103,14 +89,12 @@ export interface EvolutionQueueItem {
     resultRef?: string;
     recentPainContext?: RecentPainContext;
 }
-
 export type RawQueueItem = Record<string, unknown>;
-
 /**
  * Migrate a legacy queue item to V2 schema.
  * Old items without taskKind are assumed to be pain_diagnosis for backward compatibility.
  */
-export function migrateToV2(item: LegacyEvolutionQueueItem): {
+export declare function migrateToV2(item: LegacyEvolutionQueueItem): {
     id: string;
     taskKind: TaskKind;
     priority: TaskPriority;
@@ -133,43 +117,12 @@ export function migrateToV2(item: LegacyEvolutionQueueItem): {
     maxRetries: number;
     lastError?: string;
     resultRef?: string;
-} {
-    return {
-        id: item.id,
-        taskKind: (item.taskKind as TaskKind) || DEFAULT_TASK_KIND,
-        priority: (item.priority as TaskPriority) || DEFAULT_PRIORITY,
-        source: item.source,
-        traceId: item.traceId,
-        task: item.task,
-        score: item.score,
-        reason: item.reason,
-        timestamp: item.timestamp,
-        enqueued_at: item.enqueued_at,
-        started_at: item.started_at,
-        completed_at: item.completed_at,
-        assigned_session_key: item.assigned_session_key,
-        trigger_text_preview: item.trigger_text_preview,
-        status: (item.status as QueueStatus) || 'pending',
-        resolution: item.resolution as TaskResolution | undefined,
-        session_id: item.session_id,
-        agent_id: item.agent_id,
-        retryCount: item.retryCount || 0,
-        maxRetries: item.maxRetries || DEFAULT_MAX_RETRIES,
-        lastError: item.lastError,
-        resultRef: item.resultRef,
-    };
-}
-
+};
 /**
  * Check if an item is a legacy (pre-V2) queue item.
  */
-export function isLegacyQueueItem(item: RawQueueItem): boolean {
-    return item && typeof item === 'object' && !('taskKind' in item);
-}
-
+export declare function isLegacyQueueItem(item: RawQueueItem): boolean;
 /**
  * Migrate entire queue to V2 schema if needed.
  */
-export function migrateQueueToV2(queue: RawQueueItem[]): ReturnType<typeof migrateToV2>[] {
-    return queue.map(item => isLegacyQueueItem(item) ? migrateToV2(item as unknown as LegacyEvolutionQueueItem) : item as unknown as ReturnType<typeof migrateToV2>);
-}
+export declare function migrateQueueToV2(queue: RawQueueItem[]): ReturnType<typeof migrateToV2>[];

package/dist/service/evolution-queue-migration.js

@@ -0,0 +1,53 @@
+/**
+ * Evolution Queue Migration — V1 to V2 Schema
+ *
+ * Pure transformation functions and shared queue types.
+ */
+/**
+ * Default values for new V2 fields when migrating legacy items.
+ */
+export const DEFAULT_TASK_KIND = 'pain_diagnosis';
+export const DEFAULT_PRIORITY = 'medium';
+export const DEFAULT_MAX_RETRIES = 3;
+/**
+ * Migrate a legacy queue item to V2 schema.
+ * Old items without taskKind are assumed to be pain_diagnosis for backward compatibility.
+ */
+export function migrateToV2(item) {
+    return {
+        id: item.id,
+        taskKind: item.taskKind || DEFAULT_TASK_KIND,
+        priority: item.priority || DEFAULT_PRIORITY,
+        source: item.source,
+        traceId: item.traceId,
+        task: item.task,
+        score: item.score,
+        reason: item.reason,
+        timestamp: item.timestamp,
+        enqueued_at: item.enqueued_at,
+        started_at: item.started_at,
+        completed_at: item.completed_at,
+        assigned_session_key: item.assigned_session_key,
+        trigger_text_preview: item.trigger_text_preview,
+        status: item.status || 'pending',
+        resolution: item.resolution,
+        session_id: item.session_id,
+        agent_id: item.agent_id,
+        retryCount: item.retryCount || 0,
+        maxRetries: item.maxRetries || DEFAULT_MAX_RETRIES,
+        lastError: item.lastError,
+        resultRef: item.resultRef,
+    };
+}
+/**
+ * Check if an item is a legacy (pre-V2) queue item.
+ */
+export function isLegacyQueueItem(item) {
+    return item && typeof item === 'object' && !('taskKind' in item);
+}
+/**
+ * Migrate entire queue to V2 schema if needed.
+ */
+export function migrateQueueToV2(queue) {
+    return queue.map(item => isLegacyQueueItem(item) ? migrateToV2(item) : item);
+}