principles-disciple 1.11.0 → 1.13.0

package/src/service/subagent-workflow/workflow-store.ts

@@ -1,10 +1,10 @@
 import Database from 'better-sqlite3';
 import * as fs from 'fs';
 import * as path from 'path';
-import type { WorkflowRow, WorkflowEventRow, WorkflowState, WorkflowTransport } from './types.js';
+import type { WorkflowRow, WorkflowEventRow, WorkflowState } from './types.js';
 import type { DreamerOutput, PhilosopherOutput } from '../../core/nocturnal-trinity.js';
 
-const SCHEMA_VERSION = 1;
+const SCHEMA_VERSION = 2;
 
 const DEFAULT_BUSY_TIMEOUT_MS = 5000;
 
@@ -42,7 +42,7 @@ export class WorkflowStore {
             CREATE TABLE IF NOT EXISTS schema_version (
                 version INTEGER NOT NULL
             );
-            
+
             CREATE TABLE IF NOT EXISTS subagent_workflows (
                 workflow_id TEXT PRIMARY KEY,
                 workflow_type TEXT NOT NULL,
@@ -55,6 +55,7 @@ export class WorkflowStore {
                 created_at INTEGER NOT NULL,
                 updated_at INTEGER NOT NULL,
                 last_observed_at INTEGER,
+                duration_ms INTEGER,
                 metadata_json TEXT NOT NULL DEFAULT '{}'
             );
             
@@ -89,15 +90,29 @@ export class WorkflowStore {
         `);
         
         const row = this.db.prepare('SELECT version FROM schema_version LIMIT 1').get() as { version?: number } | undefined;
-        if (!row) {
+        const currentVersion = row?.version ?? 0;
+        if (currentVersion === 0) {
             this.db.prepare('INSERT INTO schema_version (version) VALUES (?)').run(SCHEMA_VERSION);
-        } else if (row.version !== SCHEMA_VERSION) {
+        } else if (currentVersion < SCHEMA_VERSION) {
+            // Run migrations for existing databases
+            this.runMigrations(currentVersion, SCHEMA_VERSION);
             this.db.prepare('UPDATE schema_version SET version = ?').run(SCHEMA_VERSION);
         }
     }
-    
+
+    private runMigrations(fromVersion: number, toVersion: number): void {
+        if (fromVersion < 2 && toVersion >= 2) {
+            // v1 → v2: Add duration_ms column for adaptive timeout tracking
+            try {
+                this.db.exec('ALTER TABLE subagent_workflows ADD COLUMN duration_ms INTEGER');
+                console.info(`[PD:WorkflowStore] Schema migration v${fromVersion} → v${toVersion}: added duration_ms column`);
+            } catch {
+                // Column may already exist if migration was partially applied
+            }
+        }
+    }
+
     createWorkflow(row: Omit<WorkflowRow, 'cleanup_state'>): void {
-        const now = Date.now();
         this.db.prepare(`
             INSERT INTO subagent_workflows (
                 workflow_id, workflow_type, transport, parent_session_id, child_session_key,
@@ -201,7 +216,23 @@ export class WorkflowStore {
             ORDER BY last_observed_at ASC
         `).all(cutoff) as WorkflowRow[];
     }
+
+    /** List all workflows, optionally filtered by state. */
+    listWorkflows(state?: string): WorkflowRow[] {
+        if (state) {
+            return this.db.prepare(`
+                SELECT * FROM subagent_workflows
+                WHERE state = ?
+                ORDER BY created_at DESC
+            `).all(state) as WorkflowRow[];
+        }
+        return this.db.prepare(`
+            SELECT * FROM subagent_workflows
+            ORDER BY created_at DESC
+        `).all() as WorkflowRow[];
+    }
     
+    /* eslint-disable @typescript-eslint/max-params -- Reason: Store interface requires full event context (workflowId, fromState, toState, reason, payload) */
     recordEvent(
         workflowId: string,
         eventType: string,
@@ -237,6 +268,7 @@ export class WorkflowStore {
      * idempotencyKey must be unique per (workflow_id, stage). If a row with the
      * same idempotency_key already exists, this is a no-op (idempotent).
      */
+    /* eslint-disable @typescript-eslint/max-params -- Reason: Store interface requires workflowId, stage, output, and idempotencyKey */
     recordStageOutput(
         workflowId: string,
         stage: 'dreamer' | 'philosopher',
@@ -262,24 +294,24 @@ export class WorkflowStore {
      * Get all stage outputs for a workflow (NOC-13 crash recovery).
      * Returns outputs ordered by created_at ascending.
      */
-    getStageOutputs(workflowId: string): Array<{
+    getStageOutputs(workflowId: string): {
         stage: string;
         output: DreamerOutput | PhilosopherOutput;
         idempotencyKey: string;
         createdAt: number;
-    }> {
+    }[] {
         const rows = this.db.prepare(`
             SELECT workflow_id, stage, output_json, idempotency_key, created_at
             FROM subagent_workflow_stage_outputs
             WHERE workflow_id = ?
             ORDER BY created_at ASC
-        `).all(workflowId) as Array<{
+        `).all(workflowId) as {
             workflow_id: string;
             stage: string;
             output_json: string;
             idempotency_key: string;
             created_at: number;
-        }>;
+        }[];
 
         return rows.map(row => ({
             workflowId: row.workflow_id,
@@ -325,4 +357,32 @@ export class WorkflowStore {
     deleteWorkflow(workflowId: string): void {
         this.db.prepare('DELETE FROM subagent_workflows WHERE workflow_id = ?').run(workflowId);
     }
+
+    /**
+     * Record the actual completion duration for a workflow.
+     * Used by adaptive timeout learning.
+     */
+    recordDuration(workflowId: string, durationMs: number): void {
+        this.db.prepare(`
+            UPDATE subagent_workflows SET duration_ms = ?, updated_at = ? WHERE workflow_id = ?
+        `).run(durationMs, Date.now(), workflowId);
+    }
+
+    /**
+     * Get completion durations for a specific workflow type, ordered by most recent first.
+     * Returns an array of duration_ms values for adaptive timeout calculation.
+     */
+    getCompletionDurations(workflowType: string, limit = 50): number[] {
+        const rows = this.db.prepare(`
+            SELECT duration_ms FROM subagent_workflows
+            WHERE workflow_type = ?
+            AND state = 'completed'
+            AND duration_ms IS NOT NULL
+            AND duration_ms > 0
+            ORDER BY created_at DESC
+            LIMIT ?
+        `).all(workflowType, limit) as { duration_ms: number }[];
+
+        return rows.map(r => r.duration_ms);
+    }
 }

package/src/service/trajectory-service.ts

@@ -6,7 +6,8 @@ export const TrajectoryService: OpenClawPluginService = {
   id: 'principles-disciple-trajectory',
   start(ctx: OpenClawPluginServiceContext): void {
     if (!ctx.workspaceDir) return;
-    WorkspaceContext.fromHookContext(ctx).trajectory;
+    // Trigger lazy initialization of trajectory registry
+    void WorkspaceContext.fromHookContext(ctx).trajectory;
   },
   stop(ctx: OpenClawPluginServiceContext): void {
     if (!ctx.workspaceDir) return;

package/src/tools/critique-prompt.ts

@@ -26,7 +26,7 @@ export function buildCritiquePromptV2(
         api?: OpenClawPluginApi;
     }
 ): string {
-    const { context, depth = 2, model_id, workspaceDir, api } = params;
+    const { context, depth = 2, workspaceDir, api } = params;
     
     // 1. 确定工作区目录 (优先级：显式传入 > api.config > official API > api.resolvePath)
     const effectiveWorkspaceDir = workspaceDir

package/src/tools/deep-reflect.ts

@@ -1,94 +1,15 @@
 import type { OpenClawPluginApi } from '../openclaw-sdk.js';
 import { Type } from '@sinclair/typebox';
 import * as fs from 'fs';
-import * as path from 'node:path';
 import { EventLogService } from '../core/event-log.js';
-import { buildCritiquePromptV2 } from './critique-prompt.js';
 import { resolvePdPath } from '../core/paths.js';
 import { resolveWorkspaceDirFromApi } from '../core/path-resolver.js';
-import { reflectionLogRetentionDays } from '../types.js';
 import {
     DeepReflectWorkflowManager,
     deepReflectWorkflowSpec,
     type DeepReflectTaskInput,
 } from '../service/subagent-workflow/index.js';
 
-function writeToReflectionLog(
-    workspaceDir: string,
-    context: string,
-    insights: string,
-    modelId?: string,
-    depth?: number
-): void {
-    const reflectionLogPath = resolvePdPath(workspaceDir, 'REFLECTION_LOG');
-    const memoryDir = path.dirname(reflectionLogPath);
-    if (!fs.existsSync(memoryDir)) {
-        fs.mkdirSync(memoryDir, { recursive: true });
-    }
-
-    const timestamp = new Date().toISOString();
-    const entry = `
----
-## Reflection at ${timestamp}
-**Model**: ${modelId || 'auto-select'}
-**Depth**: ${depth || 2}
-
-### Context
-${context.substring(0, 500)}${context.length > 500 ? '...' : ''}
-
-### Insights
-${insights}
-
-`;
-
-    const header = `# Reflection Log\n\n> Auto-generated by Deep Reflection Tool\n> Retention: ${reflectionLogRetentionDays} days\n`;
-
-    let existingContent = '';
-    if (fs.existsSync(reflectionLogPath)) {
-        existingContent = fs.readFileSync(reflectionLogPath, 'utf8');
-    }
-
-    const newContent = header + entry + existingContent.replace(header, '');
-
-    const tempPath = `${reflectionLogPath}.tmp`;
-    fs.writeFileSync(tempPath, newContent, 'utf8');
-    fs.renameSync(tempPath, reflectionLogPath);
-}
-
-function cleanupReflectionLog(workspaceDir: string): void {
-    const reflectionLogPath = resolvePdPath(workspaceDir, 'REFLECTION_LOG');
-
-    if (!fs.existsSync(reflectionLogPath)) return;
-
-    const content = fs.readFileSync(reflectionLogPath, 'utf8');
-    const cutoffDate = new Date();
-    cutoffDate.setDate(cutoffDate.getDate() - reflectionLogRetentionDays);
-
-    const entryPattern = /---\n## Reflection at (\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})/g;
-    const parts = content.split(entryPattern);
-
-    const header = parts[0];
-    const validEntries: string[] = [];
-
-    for (let i = 1; i < parts.length; i += 2) {
-        const timestamp = parts[i];
-        const entryContent = parts[i + 1] || '';
-
-        const entryDate = new Date(timestamp);
-        if (entryDate >= cutoffDate) {
-            validEntries.push(`---\n## Reflection at ${timestamp}${entryContent}`);
-        }
-    }
-
-    if (validEntries.length < (parts.length - 1) / 2) {
-        const newContent = header + validEntries.join('');
-
-        const tempPath = `${reflectionLogPath}.tmp`;
-        fs.writeFileSync(tempPath, newContent, 'utf8');
-        fs.renameSync(tempPath, reflectionLogPath);
-    }
-}
-
 interface DeepReflectionConfig {
     enabled: boolean;
     mode: 'auto' | 'forced' | 'disabled';
@@ -176,111 +97,164 @@ export function createDeepReflectTool(api: OpenClawPluginApi) {
         async execute(
             _toolCallId: string,
             rawParams: Record<string, unknown>
-        ): Promise<{ content: Array<{ type: string; text: string }> }> {
+        ): Promise<{ content: { type: string; text: string }[] }> {
             const context = readStringParam(rawParams, 'context') || '';
             const depth = readNumberParam(rawParams, 'depth') ?? 2;
             const model_id = readStringParam(rawParams, 'model_id');
 
             if (!context) {
-                return {
-                    content: [{
-                        type: 'text',
-                        text: '❌ 错误: 必须提供反思上下文 (context)。'
-                    }]
-                };
+                return { content: [{ type: 'text', text: '❌ 错误: 必须提供反思上下文 (context)。' }] };
             }
 
-            const effectiveWorkspaceDir =
-                (api.config?.workspaceDir as string)
-                || resolveWorkspaceDirFromApi(api)
-                || api.resolvePath?.('.');
-
+            // eslint-disable-next-line @typescript-eslint/no-use-before-define -- Reason: mutual recursion between helper functions - reordering would break logical grouping
+            const effectiveWorkspaceDir = resolveReflectionWorkspace(api);
             if (!effectiveWorkspaceDir) {
-                return {
-                    content: [{
-                        type: 'text',
-                        text: '❌ 反思执行失败: Workspace directory is required for deep reflection。请检查 API 配置或网络连接。'
-                    }]
-                };
+                return { content: [{ type: 'text', text: '❌ 反思执行失败: Workspace directory is required for deep reflection。请检查 API 配置或网络连接。' }] };
             }
 
             const config = loadConfig(effectiveWorkspaceDir, api);
             if (config.mode === 'disabled' || !config.enabled) {
-                return {
-                    content: [{
-                        type: 'text',
-                        text: '⏭️ Deep Reflection 已禁用。'
-                    }]
-                };
+                return { content: [{ type: 'text', text: '⏭️ Deep Reflection 已禁用。' }] };
             }
 
             if (model_id) {
                 safeLog(api, 'warn', `[DeepReflect] The 'model_id' parameter is deprecated. The agent will now auto-select models based on the context index.`);
             }
 
-            const stateDir = resolvePdPath(effectiveWorkspaceDir, 'STATE_DIR');
-            const eventLog = EventLogService.get(stateDir, api.logger);
-
             try {
-                // Use workspaceDir as parentSessionId proxy (OpenClaw does not expose sessionId to tools)
-                const parentSessionId = effectiveWorkspaceDir.replace(/[^a-zA-Z0-9_-]/g, '_').substring(0, 64);
-
-                const manager = new DeepReflectWorkflowManager({
-                    workspaceDir: effectiveWorkspaceDir,
-                    logger: api.logger,
-                    subagent: api.runtime.subagent as any,
-                });
-
-                const taskInput: DeepReflectTaskInput = { context, depth, model_id };
-
-                const handle = await manager.startWorkflow(deepReflectWorkflowSpec, {
-                    parentSessionId,
-                    workspaceDir: effectiveWorkspaceDir,
-                    taskInput,
-                });
-
-                // Wait for workflow completion via polling
-                const startTime = Date.now();
-                const timeoutMs = config.timeout_ms ?? 60000;
-                const pollInterval = 500;
-
-                while (Date.now() - startTime < timeoutMs) {
-                    await new Promise(resolve => setTimeout(resolve, pollInterval));
-                    const workflow = (manager as any).store.getWorkflow(handle.workflowId);
-                    if (!workflow) break;
-
-                    if (workflow.state === 'completed') {
-                        // Extract insights from reflection log (written by persistResult)
-                        const reflectionLogPath = resolvePdPath(effectiveWorkspaceDir, 'REFLECTION_LOG');
-                        let insights = '';
-                        if (fs.existsSync(reflectionLogPath)) {
-                            const content = fs.readFileSync(reflectionLogPath, 'utf8');
-                            // Extract most recent entry
-                            const match = content.match(/### Insights\n([\s\S]*?)(?=---|$)/);
-                            if (match) {
-                                insights = match[1].trim();
-                            }
-                        }
-
-                        if (eventLog) {
-                            eventLog.recordDeepReflection(handle.childSessionKey, {
-                                modelId: model_id || 'auto-select',
-                                modelSelectionMode: model_id ? 'manual' : 'auto',
-                                depth,
-                                contextPreview: context.substring(0, 200),
-                                resultPreview: insights.substring(0, 300),
-                                durationMs: Date.now() - startTime,
-                                passed: true,
-                                timeout: false
-                            });
-                        }
-
-                        manager.dispose();
-
-                        return {
-                            content: [{
-                                type: 'text',
-                                text: `
+                // eslint-disable-next-line @typescript-eslint/no-use-before-define -- Reason: mutual recursion between helper functions - reordering would break logical grouping
+                return await executeReflectionWorkflow(effectiveWorkspaceDir, config, context, depth, model_id, api);
+            } catch (err) {
+                // eslint-disable-next-line @typescript-eslint/no-use-before-define -- Reason: mutual recursion between helper functions - reordering would break logical grouping
+                return handleReflectionError(err, context, depth, model_id, effectiveWorkspaceDir, api);
+            }
+        }
+    };
+}
+
+/**
+ * Resolve workspace directory for deep reflection tool.
+ */
+function resolveReflectionWorkspace(api: OpenClawPluginApi): string | undefined {
+    return (api.config?.workspaceDir as string)
+        || resolveWorkspaceDirFromApi(api)
+        || api.resolvePath?.('.');
+}
+
+/**
+ * Execute the deep reflection workflow: start, poll, collect results.
+ */
+/* eslint-disable @typescript-eslint/max-params -- Reason: Function signature requires all parameters for type-safe reflection workflow */
+async function executeReflectionWorkflow(
+    effectiveWorkspaceDir: string,
+    config: DeepReflectionConfig,
+    context: string,
+    depth: number,
+    model_id: string | undefined,
+    api: OpenClawPluginApi,
+): Promise<{ content: { type: string; text: string }[] }> {
+    const stateDir = resolvePdPath(effectiveWorkspaceDir, 'STATE_DIR');
+    const eventLog = EventLogService.get(stateDir, api.logger);
+    const parentSessionId = effectiveWorkspaceDir.replace(/[^a-zA-Z0-9_-]/g, '_').substring(0, 64);
+
+    const manager = new DeepReflectWorkflowManager({
+        workspaceDir: effectiveWorkspaceDir,
+        logger: api.logger,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Reason: api.runtime.subagent has structurally compatible shape but differs from PluginRuntimeSubagent due to optional provider/model fields
+        subagent: api.runtime.subagent as any,
+        agentSession: api.runtime.agent?.session,
+    });
+
+    try {
+        const taskInput: DeepReflectTaskInput = { context, depth, model_id };
+        const handle = await manager.startWorkflow(deepReflectWorkflowSpec, {
+            parentSessionId,
+            workspaceDir: effectiveWorkspaceDir,
+            taskInput,
+        });
+
+        const startTime = Date.now();
+        const timeoutMs = config.timeout_ms ?? 60000;
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define -- Reason: mutual recursion between helper functions - reordering would break logical grouping
+        return await pollReflectionCompletion(manager, handle, timeoutMs, startTime, eventLog, effectiveWorkspaceDir, context, model_id, depth);
+    } finally {
+        manager.dispose();
+    }
+}
+
+/**
+ * Poll the reflection workflow until completion, timeout, or error.
+ */
+/* eslint-disable @typescript-eslint/max-params -- Reason: Function signature requires all parameters for type-safe polling */
+async function pollReflectionCompletion(
+    manager: DeepReflectWorkflowManager,
+    handle: { workflowId: string; childSessionKey: string },
+    timeoutMs: number,
+    startTime: number,
+    eventLog: ReturnType<typeof EventLogService.get>,
+    workspaceDir: string,
+    context: string,
+    model_id: string | undefined,
+    depth: number,
+): Promise<{ content: { type: string; text: string }[] }> {
+    const pollInterval = 500;
+
+    while (Date.now() - startTime < timeoutMs) {
+        await new Promise(resolve => setTimeout(resolve, pollInterval));
+        const workflowState = manager.getWorkflowState(handle.workflowId);
+        if (!workflowState) break;
+
+        if (workflowState === 'completed') {
+            // eslint-disable-next-line @typescript-eslint/no-use-before-define -- Reason: mutual recursion between helper functions - reordering would break logical grouping
+            return formatReflectionSuccess(handle, context, depth, model_id, startTime, eventLog, workspaceDir);
+        }
+
+        if (workflowState === 'terminal_error' || workflowState === 'expired') {
+            throw new Error(`Deep-reflect workflow failed: ${workflowState}`);
+        }
+    }
+
+    return { content: [{ type: 'text', text: '⚠️ 反思任务执行超时。你可以尝试减少上下文长度或增加深度。' }] };
+}
+
+/**
+ * Format the success response from a completed reflection.
+ */
+/* eslint-disable @typescript-eslint/max-params -- Reason: Function signature requires all parameters for type-safe formatting */
+function formatReflectionSuccess(
+    handle: { childSessionKey: string },
+    context: string,
+    depth: number,
+    model_id: string | undefined,
+    startTime: number,
+    eventLog: ReturnType<typeof EventLogService.get>,
+    workspaceDir: string,
+): { content: { type: string; text: string }[] } {
+    const reflectionLogPath = resolvePdPath(workspaceDir, 'REFLECTION_LOG');
+    let insights = '';
+    if (fs.existsSync(reflectionLogPath)) {
+        const content = fs.readFileSync(reflectionLogPath, 'utf8');
+        const match = /### Insights\n([\s\S]*?)(?=---|$)/.exec(content);
+        if (match) insights = match[1].trim();
+    }
+
+    if (eventLog) {
+        eventLog.recordDeepReflection(handle.childSessionKey, {
+            modelId: model_id || 'auto-select',
+            modelSelectionMode: model_id ? 'manual' : 'auto',
+            depth,
+            contextPreview: context.substring(0, 200),
+            resultPreview: insights.substring(0, 300),
+            durationMs: Date.now() - startTime,
+            passed: true,
+            timeout: false,
+        });
+    }
+
+    return {
+        content: [{
+            type: 'text',
+            text: `
 # 💎 Deep Reflection Insights
 ---
 **Selected Model(s)**: ${model_id || 'auto-select'}
@@ -291,53 +265,45 @@ ${insights || '反思完成，详见 REFLECTION_LOG。'}
 
 ---
 *Generated by Principles Disciple Meta-Cognitive Engine*
-`.trim()
-                            }]
-                        };
-                    }
-
-                    if (workflow.state === 'terminal_error' || workflow.state === 'expired') {
-                        manager.dispose();
-                        throw new Error(`Deep-reflect workflow failed: ${workflow.state}`);
-                    }
-                }
-
-                manager.dispose();
-                return {
-                    content: [{
-                        type: 'text',
-                        text: '⚠️ 反思任务执行超时。你可以尝试减少上下文长度或增加深度。'
-                    }]
-                };
-
-            } catch (err) {
-                const errorMsg = err instanceof Error ? err.message : String(err);
-                safeLog(api, 'error', `[DeepReflect] Reflection failed: ${errorMsg}`);
-
-                if (eventLog) {
-                    eventLog.recordDeepReflection('deep-reflect-error', {
-                        modelId: model_id || 'auto-select',
-                        modelSelectionMode: model_id ? 'manual' : 'auto',
-                        depth,
-                        contextPreview: context.substring(0, 200),
-                        durationMs: 0,
-                        passed: false,
-                        timeout: errorMsg.toLowerCase().includes('timeout'),
-                        error: errorMsg
-                    });
-                }
-
-                return {
-                    content: [{
-                        type: 'text',
-                        text: `❌ 反思执行失败: ${errorMsg}。请检查 API 配置或网络连接。`
-                    }]
-                };
-            }
-        }
+`.trim(),
+        }],
     };
 }
 
+/**
+ * Handle reflection errors and format error response.
+ */
+/* eslint-disable @typescript-eslint/max-params -- Reason: Function signature requires all parameters for type-safe error handling */
+function handleReflectionError(
+    err: unknown,
+    context: string,
+    depth: number,
+    model_id: string | undefined,
+    workspaceDir: string,
+    api: OpenClawPluginApi,
+): { content: { type: string; text: string }[] } {
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    safeLog(api, 'error', `[DeepReflect] Reflection failed: ${errorMsg}`);
+
+    const stateDir = resolvePdPath(workspaceDir, 'STATE_DIR');
+    const eventLog = EventLogService.get(stateDir, api.logger);
+
+    if (eventLog) {
+        eventLog.recordDeepReflection('deep-reflect-error', {
+            modelId: model_id || 'auto-select',
+            modelSelectionMode: model_id ? 'manual' : 'auto',
+            depth,
+            contextPreview: context.substring(0, 200),
+            durationMs: 0,
+            passed: false,
+            timeout: errorMsg.toLowerCase().includes('timeout'),
+            error: errorMsg,
+        });
+    }
+
+    return { content: [{ type: 'text', text: `❌ 反思执行失败: ${errorMsg}。请检查 API 配置或网络连接。` }] };
+}
+
 export const deepReflectTool = {
     name: 'deep_reflect',
     description: '执行深层次的元认知反思，分析当前任务的潜在风险、逻辑漏洞或架构改进点。',

package/src/tools/model-index.ts

@@ -33,7 +33,7 @@ const MAX_INDEX_SIZE = 50 * 1024; // 50KB
  */
 function loadCustomConfig(wctx: WorkspaceContext): { modelsDir?: string } | undefined {
     try {
-        const config = wctx.config;
+        const {config} = wctx;
         const modelsDir = config.get('deep_reflection.modelsDir');
         if (typeof modelsDir === 'string' && modelsDir.trim()) {
             return { modelsDir: modelsDir.trim() };
@@ -61,6 +61,7 @@ export function loadModelIndex(
         const wctx = WorkspaceContext.fromHookContext({ workspaceDir });
         const customConfig = loadCustomConfig(wctx);
         
+        // eslint-disable-next-line @typescript-eslint/init-declarations -- assigned in both if/else branches
         let modelsDir: string;
         if (customConfig?.modelsDir) {
             modelsDir = path.isAbsolute(customConfig.modelsDir) 

package/src/types/event-types.ts

@@ -245,11 +245,11 @@ export interface EmpathyEventStats {
     low: number;   // confidence < 0.5
   };
   /** Daily trend (last 7 days) */
-  dailyTrend: Array<{
+  dailyTrend: {
     date: string;
     count: number;
     score: number;
-  }>;
+  }[];
 }
 
 export interface GfiStats {