principles-disciple 1.72.0 → 1.74.0

package/src/service/cooldown-strategy.ts

@@ -1,97 +0,0 @@
-/**
- * Cooldown Strategy -- Tiered escalation for persistent task failures
- * ===========================================================
- *
- * Manages cooldown escalation state persisted to nocturnal-runtime.json.
- * When the failure classifier (failure-classifier.ts) detects persistent
- * failure (3+ consecutive failures), this module applies escalating
- * cooldowns: 30min -> 4h -> 24h (cap).
- *
- * State is stored in NocturnalRuntimeState.taskFailureState, keyed by
- * taskKind string. Uses exported readState/writeState from
- * nocturnal-runtime.ts for atomic file access with locking.
- */
-
-import { readState as readStateAsync, readStateSync, writeState } from './nocturnal-runtime.js';
-import type { CooldownEscalationConfig } from './nocturnal-config.js';
-import { loadCooldownEscalationConfig } from './nocturnal-config.js';
-import type { ClassifiableTaskKind } from './failure-classifier.js';
-
-/**
- * Record a persistent failure and escalate the cooldown tier.
- * Called when the failure classifier detects persistent failure pattern.
- *
- * State transitions:
- *   No state -> Tier 1 (30min cooldown)
- *   Tier 1 -> Tier 2 (4h cooldown)
- *   Tier 2 -> Tier 3 (24h cooldown)
- *   Tier 3 -> Tier 3 (24h cooldown, capped)
- */
-export async function recordPersistentFailure(
-    stateDir: string,
-    taskKind: ClassifiableTaskKind,
-    config?: CooldownEscalationConfig,
-    classifierCount?: number,
-): Promise<void> {
-    const resolvedConfig = config ?? loadCooldownEscalationConfig(stateDir);
-
-    const state = await readStateAsync(stateDir);
-    if (!state.taskFailureState) state.taskFailureState = {};
-
-    const current = state.taskFailureState[taskKind] ?? {
-        consecutiveFailures: 0,
-        escalationTier: 0,
-    };
-
-    current.consecutiveFailures = classifierCount ?? (current.consecutiveFailures + 1);
-    current.escalationTier = Math.min(current.escalationTier + 1, 3);
-
-    const tierKey = current.escalationTier as 1 | 2 | 3;
-    const durationMs = resolvedConfig[`tier${tierKey}_ms` as keyof CooldownEscalationConfig] as number;
-    current.cooldownUntil = new Date(Date.now() + durationMs).toISOString();
-
-    state.taskFailureState[taskKind] = current;
-    await writeState(stateDir, state);
-}
-
-/**
- * Reset failure state for a task kind on successful completion.
- * Resets both consecutiveFailures and escalationTier to 0.
- */
-export async function resetFailureState(
-    stateDir: string,
-    taskKind: ClassifiableTaskKind,
-): Promise<void> {
-    const state = await readStateAsync(stateDir);
-    if (!state.taskFailureState?.[taskKind]) return; // No state to reset
-
-    state.taskFailureState[taskKind] = {
-        consecutiveFailures: 0,
-        escalationTier: 0,
-    };
-    await writeState(stateDir, state);
-}
-
-/**
- * Check if a task kind is currently in cooldown.
- * Returns remaining cooldown duration or 0 if not in cooldown.
- */
-export function isTaskKindInCooldown(
-    stateDir: string,
-    taskKind: ClassifiableTaskKind,
-): { inCooldown: boolean; remainingMs: number; cooldownUntil: string | null } {
-    const state = readStateSync(stateDir);
-
-    const failureState = state.taskFailureState?.[taskKind];
-    if (!failureState?.cooldownUntil) {
-        return { inCooldown: false, remainingMs: 0, cooldownUntil: null };
-    }
-
-    const cooldownEnd = new Date(failureState.cooldownUntil).getTime();
-    const remaining = cooldownEnd - Date.now();
-    if (remaining <= 0) {
-        return { inCooldown: false, remainingMs: 0, cooldownUntil: null };
-    }
-
-    return { inCooldown: true, remainingMs: remaining, cooldownUntil: failureState.cooldownUntil };
-}

package/src/service/evolution-pain-context.ts

@@ -1,79 +0,0 @@
-/**
- * Evolution Pain Context Reader
- *
- * Reads and processes pain signal context for task enrichment.
- * Extracted from evolution-worker.ts.
- */
-
-import type { WorkspaceContext } from '../core/workspace-context.js';
-import { readPainFlagContract } from '../core/pain.js';
-import type { EvolutionQueueItem } from './evolution-queue-migration.js';
-import type { RecentPainContext } from './evolution-queue-migration.js';
-import { SLEEP_REFLECTION_DEDUP_WINDOW_MS } from './queue-io.js';
-
-/**
- * Read recent pain context from PAIN_FLAG file.
- * Extracts session_id to link to trajectory DB.
- * Returns structured pain metadata for attaching to sleep_reflection tasks.
- * Returns null if no pain flag exists.
- */
-export function readRecentPainContext(wctx: WorkspaceContext): RecentPainContext {
-    const contract = readPainFlagContract(wctx.workspaceDir);
-    if (contract.status !== 'valid') {
-        return { mostRecent: null, recentPainCount: 0, recentMaxPainScore: 0 };
-    }
-
-    try {
-        const score = parseInt(contract.data.score ?? '0', 10) || 0;
-        const source = contract.data.source ?? '';
-        const reason = contract.data.reason ?? '';
-        const timestamp = contract.data.time ?? '';
-        const sessionId = contract.data.session_id ?? '';
-
-        if (score > 0) {
-            return {
-                mostRecent: { score, source, reason, timestamp, sessionId },
-                recentPainCount: 1,
-                recentMaxPainScore: score,
-            };
-        }
-    } catch {
-        // Best effort — non-fatal
-    }
-
-    return { mostRecent: null, recentPainCount: 0, recentMaxPainScore: 0 };
-}
-
-/**
- * Build a dedup key from pain context.
- * Returns null when no pain context is available (bypasses dedup).
- */
-export function buildPainSourceKey(
-    painCtx: ReturnType<typeof readRecentPainContext>,
-): string | null {
-    if (!painCtx.mostRecent) return null;
-    return `${painCtx.mostRecent.source}::${painCtx.mostRecent.reason?.slice(0, 50) ?? ''}`;
-}
-
-/**
- * Check whether a similar sleep_reflection task completed recently.
- * Phase 3c: Prevents redundant reflections of the same underlying issue.
- */
-export function hasRecentSimilarReflection(
-    queue: EvolutionQueueItem[],
-    painSourceKey: string,
-    now: number,
-): EvolutionQueueItem | null {
-    return queue.find((t) => {
-        if (t.taskKind !== 'sleep_reflection') return false;
-        // Only match completed tasks (exclude failed to allow retries)
-        if (t.status !== 'completed') return false;
-        if (!t.completed_at) return false;
-        const age = now - new Date(t.completed_at).getTime();
-        if (age > SLEEP_REFLECTION_DEDUP_WINDOW_MS) return false;
-        const taskPainKey = buildPainSourceKey(t.recentPainContext ?? { mostRecent: null, recentPainCount: 0, recentMaxPainScore: 0 });
-        // If either side has no pain context, they don't match
-        if (!taskPainKey) return false;
-        return taskPainKey === painSourceKey;
-    }) ?? null;
-}

package/src/service/evolution-query-service.ts

@@ -1,407 +0,0 @@
-/**
- * EvolutionQueryService - 进化流程查询服务
- *
- * 提供 WebUI 所需的查询 API：
- * - getTasks() - 获取任务列表
- * - getEvents() - 获取事件流
- * - getTrace() - 获取完整追踪
- * - getStats() - 获取统计数据
- */
-
-import type { TrajectoryDatabase, EvolutionTaskRecord } from '../core/trajectory.js';
-import { STAGE_LABELS, STAGE_COLORS } from '../core/evolution-logger.js';
-
-export interface TaskListFilters {
-  status?: string;
-  dateFrom?: string;
-  dateTo?: string;
-  page?: number;
-  pageSize?: number;
-}
-
-export interface EventFilters {
-  traceId?: string;
-  stage?: string;
-  limit?: number;
-  offset?: number;
-}
-
-export interface TasksResponse {
-  items: {
-    taskId: string;
-    traceId: string;
-    source: string;
-    reason: string | null;
-    score: number;
-    status: string;
-    enqueuedAt: string | null;
-    startedAt: string | null;
-    completedAt: string | null;
-    duration: number | null;
-    resolution: string | null;
-    eventCount: number;
-    createdAt: string;
-  }[];
-  pagination: {
-    page: number;
-    pageSize: number;
-    total: number;
-    totalPages: number;
-  };
-}
-
-export interface EventsResponse {
-  items: {
-    id: number;
-    traceId: string;
-    taskId: string | null;
-    stage: string;
-    stageLabel: string;
-    stageColor: string;
-    level: string;
-    message: string;
-    summary: string | null;
-    metadata: Record<string, unknown>;
-    createdAt: string;
-  }[];
-  pagination: {
-    limit: number;
-    offset: number;
-    hasMore: boolean;
-  };
-}
-
-export interface TraceDetailResponse {
-  traceId: string;
-  task: {
-    taskId: string;
-    traceId: string;
-    source: string;
-    reason: string | null;
-    score: number;
-    status: string;
-    enqueuedAt: string | null;
-    startedAt: string | null;
-    completedAt: string | null;
-    duration: number | null;
-    resolution: string | null;
-    createdAt: string;
-    updatedAt: string;
-  };
-  events: {
-    id: number;
-    traceId: string;
-    taskId: string | null;
-    stage: string;
-    stageLabel: string;
-    stageColor: string;
-    level: string;
-    message: string;
-    summary: string | null;
-    metadata: Record<string, unknown>;
-    createdAt: string;
-  }[];
-  timeline: {
-    stage: string;
-    stageLabel: string;
-    stageColor: string;
-    timestamp: string;
-    message: string;
-    summary: string | null;
-  }[];
-}
-
-export interface EvolutionStatsResponse {
-  total: number;
-  pending: number;
-  inProgress: number;
-  completed: number;
-  failed: number;
-  recentActivity: {
-    day: string;
-    created: number;
-    completed: number;
-  }[];
-  stageDistribution: {
-    stage: string;
-    stageLabel: string;
-    count: number;
-  }[];
-}
-
-/**
- * 计算任务持续时间（毫秒）
- */
-function calculateDuration(task: EvolutionTaskRecord): number | null {
-  if (!task.startedAt) return null;
-  const start = new Date(task.startedAt).getTime();
-  const end = task.completedAt ? new Date(task.completedAt).getTime() : Date.now();
-  return end - start;
-}
-
-/**
- * EvolutionQueryService 类
- * 封装进化流程的查询逻辑
- */
-export class EvolutionQueryService {
-  private readonly trajectory: TrajectoryDatabase;
-
-  constructor(trajectory: TrajectoryDatabase) {
-    this.trajectory = trajectory;
-  }
-
-  /**
-   * 释放资源
-   * 注意：不关闭 trajectory，因为它是单例由 TrajectoryRegistry 管理
-   */
-   
-   
-  dispose(): void {
-    // EvolutionQueryService 不拥有 trajectory，所以不关闭它
-    // trajectory 是由 TrajectoryRegistry 管理的单例
-  }
-
-  /**
-   * 获取任务列表（带分页、筛选）
-   */
-  getTasks(filters: TaskListFilters = {}): TasksResponse {
-    const page = filters.page ?? 1;
-    const pageSize = filters.pageSize ?? 20;
-    const offset = (page - 1) * pageSize;
-
-    // 获取任务列表
-    const tasks = this.trajectory.listEvolutionTasks({
-      status: filters.status,
-      dateFrom: filters.dateFrom,
-      dateTo: filters.dateTo,
-      limit: pageSize + 1, // 多取一条判断 hasMore
-      offset,
-    });
-
-    // 获取总数（简化实现，使用全量计数）
-    const allTasks = this.trajectory.listEvolutionTasks({
-      status: filters.status,
-      dateFrom: filters.dateFrom,
-      dateTo: filters.dateTo,
-      limit: 10000,
-      offset: 0,
-    });
-    const total = allTasks.length;
-    const totalPages = Math.ceil(total / pageSize);
-
-    // 组装响应
-    const items = tasks.slice(0, pageSize).map((task) => {
-      // 获取事件数量
-      const events = this.trajectory.listEvolutionEvents(task.traceId, { limit: 1000 });
-
-      return {
-        taskId: task.taskId,
-        traceId: task.traceId,
-        source: task.source,
-        reason: task.reason,
-        score: task.score,
-        status: task.status,
-        enqueuedAt: task.enqueuedAt,
-        startedAt: task.startedAt,
-        completedAt: task.completedAt,
-        duration: calculateDuration(task),
-        resolution: task.resolution,
-        eventCount: events.length,
-        createdAt: task.createdAt,
-      };
-    });
-
-    return {
-      items,
-      pagination: {
-        page,
-        pageSize,
-        total,
-        totalPages,
-      },
-    };
-  }
-
-  /**
-   * 获取事件流
-   */
-  getEvents(filters: EventFilters = {}): EventsResponse {
-    const limit = filters.limit ?? 100;
-    const offset = filters.offset ?? 0;
-
-    // 获取更多事件以支持 stage 过滤
-    const fetchLimit = filters.stage ? 500 : limit + 1;
-    const events = this.trajectory.listEvolutionEvents(filters.traceId, {
-      limit: fetchLimit,
-      offset: 0, // 从头获取，后续再过滤和分页
-    });
-
-    // 应用 stage 过滤
-    let filteredEvents = events;
-    if (filters.stage) {
-      filteredEvents = events.filter(event => event.stage === filters.stage);
-    }
-
-    // 应用分页
-    const hasMore = filteredEvents.length > offset + limit;
-    const items = filteredEvents.slice(offset, offset + limit).map((event) => ({
-      id: event.id,
-      traceId: event.traceId,
-      taskId: event.taskId,
-      stage: event.stage,
-      stageLabel: STAGE_LABELS[event.stage as keyof typeof STAGE_LABELS] || event.stage,
-      stageColor: STAGE_COLORS[event.stage as keyof typeof STAGE_COLORS] || '#6b7280',
-      level: event.level,
-      message: event.message,
-      summary: event.summary,
-      metadata: event.metadata,
-      createdAt: event.createdAt,
-    }));
-
-    return {
-      items,
-      pagination: {
-        limit,
-        offset,
-        hasMore,
-      },
-    };
-  }
-
-  /**
-   * 获取完整追踪（单个 trace 的所有事件）
-   */
-  getTrace(traceId: string): TraceDetailResponse | null {
-    // 获取任务信息
-    const task = this.trajectory.getEvolutionTaskByTraceId(traceId);
-    if (!task) return null;
-
-    // 获取所有事件
-    const events = this.trajectory.listEvolutionEvents(traceId, { limit: 1000 });
-
-    // 构建时间线
-    const timeline = events.map((event) => ({
-      stage: event.stage,
-      stageLabel: STAGE_LABELS[event.stage as keyof typeof STAGE_LABELS] || event.stage,
-      stageColor: STAGE_COLORS[event.stage as keyof typeof STAGE_COLORS] || '#6b7280',
-      timestamp: event.createdAt,
-      message: event.message,
-      summary: event.summary,
-    }));
-
-    return {
-      traceId,
-      task: {
-        taskId: task.taskId,
-        traceId: task.traceId,
-        source: task.source,
-        reason: task.reason,
-        score: task.score,
-        status: task.status,
-        enqueuedAt: task.enqueuedAt,
-        startedAt: task.startedAt,
-        completedAt: task.completedAt,
-        duration: calculateDuration(task),
-        resolution: task.resolution,
-        createdAt: task.createdAt,
-        updatedAt: task.updatedAt,
-      },
-      events: events.map((event) => ({
-        id: event.id,
-        traceId: event.traceId,
-        taskId: event.taskId,
-        stage: event.stage,
-        stageLabel: STAGE_LABELS[event.stage as keyof typeof STAGE_LABELS] || event.stage,
-        stageColor: STAGE_COLORS[event.stage as keyof typeof STAGE_COLORS] || '#6b7280',
-        level: event.level,
-        message: event.message,
-        summary: event.summary,
-        metadata: event.metadata,
-        createdAt: event.createdAt,
-      })),
-      timeline,
-    };
-  }
-
-  /**
-   * 获取统计数据
-   */
-  getStats(days = 30): EvolutionStatsResponse {
-    // 获取基础统计
-    const stats = this.trajectory.getEvolutionStats();
-
-    // 获取近期活动
-    const now = new Date();
-    const daysAgo = new Date(now.getTime() - days * 24 * 60 * 60 * 1000);
-    const recentTasks = this.trajectory.listEvolutionTasks({
-      dateFrom: daysAgo.toISOString(),
-      limit: 10000,
-    });
-
-    // 按天分组
-    const activityByDay = new Map<string, { created: number; completed: number }>();
-    for (let i = 0; i < days; i++) {
-      const day = new Date(now.getTime() - i * 24 * 60 * 60 * 1000);
-      const [dayStr] = day.toISOString().split('T');
-      activityByDay.set(dayStr, { created: 0, completed: 0 });
-    }
-
-    for (const task of recentTasks) {
-      const [createdDay] = task.createdAt.split('T');
-      if (activityByDay.has(createdDay)) {
-         
-        activityByDay.get(createdDay)!.created++;
-      }
-      if (task.completedAt) {
-        const [completedDay] = task.completedAt.split('T');
-        if (activityByDay.has(completedDay)) {
-           
-          activityByDay.get(completedDay)!.completed++;
-        }
-      }
-    }
-
-    const recentActivity = Array.from(activityByDay.entries())
-      .map(([day, data]) => ({ day, ...data }))
-      .sort((a, b) => a.day.localeCompare(b.day));
-
-    // 获取阶段分布
-    const allEvents = this.trajectory.listEvolutionEvents(undefined, { limit: 10000 });
-    const stageCount = new Map<string, number>();
-    for (const event of allEvents) {
-      stageCount.set(event.stage, (stageCount.get(event.stage) || 0) + 1);
-    }
-
-    const stageDistribution = Array.from(stageCount.entries())
-      .map(([stage, count]) => ({
-        stage,
-        stageLabel: STAGE_LABELS[stage as keyof typeof STAGE_LABELS] || stage,
-        count,
-      }))
-      .sort((a, b) => b.count - a.count);
-
-    return {
-      ...stats,
-      recentActivity,
-      stageDistribution,
-    };
-  }
-}
-
-// 单例缓存
-const serviceCache = new Map<string, EvolutionQueryService>();
-
-/**
- * 获取 EvolutionQueryService 实例（单例）
- */
-export function getEvolutionQueryService(trajectory: TrajectoryDatabase): EvolutionQueryService {
-  // 使用 trajectory 的 dbPath 作为缓存键
-  const cacheKey = (trajectory as unknown as { dbPath?: string }).dbPath || 'default';
-  const cached = serviceCache.get(cacheKey);
-  if (cached) {
-    return cached;
-  }
-  const service = new EvolutionQueryService(trajectory);
-  serviceCache.set(cacheKey, service);
-  return service;
-}