0xray 4.0.11 → 4.0.13

package/dist/processors/implementations/regression-testing-processor.js

@@ -1,59 +0,0 @@
-import * as fs from "fs";
-import * as path from "path";
-import { PostProcessor } from "../processor-interfaces.js";
-import { frameworkLogger } from "../../core/framework-logger.js";
-export class RegressionTestingProcessor extends PostProcessor {
-    name = "regressionTesting";
-    priority = 15;
-    async run(context) {
-        const result = {
-            regressions: 0,
-            issues: [],
-            baseline: null,
-            current: null,
-        };
-        try {
-            const projectRoot = process.cwd();
-            const testCountPath = path.join(projectRoot, ".opencode", "xray", "test-count.json");
-            if (!fs.existsSync(testCountPath)) {
-                frameworkLogger.log("regression-testing-processor", "no-baseline", "info", { message: "No test-count.json baseline found" });
-                return result;
-            }
-            const baseline = JSON.parse(fs.readFileSync(testCountPath, "utf-8"));
-            result.baseline = `${baseline.totalTests ?? "unknown"} tests`;
-            const currentCount = this.getCurrentTestCount(projectRoot);
-            result.current = `${currentCount} tests`;
-            if (baseline.totalTests &&
-                currentCount > 0 &&
-                currentCount < baseline.totalTests * 0.9) {
-                result.regressions += 1;
-                result.issues.push({
-                    type: "new_failure",
-                    description: `Test count dropped from ${baseline.totalTests} to ${currentCount} (>10% regression)`,
-                });
-            }
-            if (result.regressions > 0) {
-                frameworkLogger.log("regression-testing-processor", "regressions-detected", "warning", { regressions: result.regressions, issues: result.issues });
-            }
-            else {
-                frameworkLogger.log("regression-testing-processor", "no-regressions", "info", { baseline: result.baseline, current: result.current });
-            }
-        }
-        catch (error) {
-            frameworkLogger.log("regression-testing-processor", "error", "error", { error: error instanceof Error ? error.message : String(error) });
-        }
-        return result;
-    }
-    getCurrentTestCount(projectRoot) {
-        try {
-            const testCountPath = path.join(projectRoot, ".opencode", "xray", "test-count.json");
-            if (!fs.existsSync(testCountPath))
-                return 0;
-            const data = JSON.parse(fs.readFileSync(testCountPath, "utf-8"));
-            return data.totalTests ?? 0;
-        }
-        catch {
-            return 0;
-        }
-    }
-}

package/dist/processors/implementations/session-capture-processor.d.ts

@@ -1,14 +0,0 @@
-/**
- * Session Capture Processor
- *
- * Extracted from InferenceImprovementProcessor - handles discovery of
- * session data sources (reflections, logs, reports) for inference workflows.
- *
- * @module processors/implementations
- */
-export declare class SessionCapture {
-    static findReflections(directory: string, reflectionsDir: string): string[];
-    static findLogs(directory: string, logsDir: string): string[];
-    static findReports(directory: string, reportsDir: string): string[];
-}
-export default SessionCapture;

package/dist/processors/implementations/session-capture-processor.js

@@ -1,37 +0,0 @@
-/**
- * Session Capture Processor
- *
- * Extracted from InferenceImprovementProcessor - handles discovery of
- * session data sources (reflections, logs, reports) for inference workflows.
- *
- * @module processors/implementations
- */
-import * as fs from "fs";
-import * as path from "path";
-export class SessionCapture {
-    static findReflections(directory, reflectionsDir) {
-        const reflectionsPath = path.join(directory, reflectionsDir);
-        if (!fs.existsSync(reflectionsPath))
-            return [];
-        return fs.readdirSync(reflectionsPath)
-            .filter(f => f.endsWith(".md"))
-            .map(f => path.join(reflectionsPath, f));
-    }
-    static findLogs(directory, logsDir) {
-        const logsPath = path.join(directory, logsDir);
-        if (!fs.existsSync(logsPath))
-            return [];
-        return fs.readdirSync(logsPath)
-            .filter(f => f.includes("routing") || f.includes("activity") || f.includes("session"))
-            .map(f => path.join(logsPath, f));
-    }
-    static findReports(directory, reportsDir) {
-        const reportsPath = path.join(directory, reportsDir);
-        if (!fs.existsSync(reportsPath))
-            return [];
-        return fs.readdirSync(reportsPath)
-            .filter(f => f.endsWith(".json") || f.endsWith(".md"))
-            .map(f => path.join(reportsPath, f));
-    }
-}
-export default SessionCapture;

package/dist/processors/implementations/session-summary-processor.d.ts

@@ -1,26 +0,0 @@
-/**
- * Session Summary Post-Processor
- *
- * Generates emoji-formatted session summaries after tool execution.
- * Uses features.json -> autonomous_reporting config for control.
- *
- * @since 2026-04-04
- */
-import { PostProcessor, ProcessorContext } from "../processor-interfaces.js";
-export declare class SessionSummaryProcessor extends PostProcessor {
-    readonly name = "sessionSummary";
-    readonly priority = 15;
-    private config;
-    private sessionStartTime;
-    private agentActivities;
-    private toolCalls;
-    private operations;
-    constructor();
-    private loadConfig;
-    run(context: ProcessorContext): Promise<unknown>;
-    private shouldGenerateSummary;
-    private generateEmojiSummary;
-    private generateRecommendation;
-    private stripEmojis;
-}
-export default SessionSummaryProcessor;

package/dist/processors/implementations/session-summary-processor.js

@@ -1,125 +0,0 @@
-/**
- * Session Summary Post-Processor
- *
- * Generates emoji-formatted session summaries after tool execution.
- * Uses features.json -> autonomous_reporting config for control.
- *
- * @since 2026-04-04
- */
-import { PostProcessor } from "../processor-interfaces.js";
-import { frameworkLogger } from "../../core/framework-logger.js";
-import { featuresConfigLoader } from "../../core/features-config.js";
-export class SessionSummaryProcessor extends PostProcessor {
-    name = "sessionSummary";
-    priority = 15;
-    config = {
-        enabled: true,
-        include_emojis: true,
-        include_recommendations: true,
-        include_agent_activities: true,
-    };
-    sessionStartTime = Date.now();
-    agentActivities = new Map();
-    toolCalls = new Map();
-    operations = [];
-    constructor() {
-        super();
-        this.loadConfig();
-    }
-    loadConfig() {
-        try {
-            const configData = featuresConfigLoader.loadConfig();
-            const autoReporting = configData.autonomous_reporting ?? configData.auto_reporting;
-            if (autoReporting) {
-                this.config.enabled = autoReporting.enabled !== false;
-                this.config.include_emojis =
-                    autoReporting.include_agent_activities !== false;
-                this.config.include_recommendations =
-                    autoReporting.include_recommendations !== false;
-                this.config.include_agent_activities =
-                    autoReporting.include_agent_activities !== false;
-            }
-        }
-        catch (error) {
-            // Silent fail - use defaults
-        }
-    }
-    async run(context) {
-        if (!this.config.enabled) {
-            return { summaryGenerated: false, reason: "disabled in features.json" };
-        }
-        // Track operation
-        const operation = context.operation || context.data || "unknown";
-        this.operations.push(operation);
-        // Track tool calls
-        const tool = context.operation || "unknown";
-        this.toolCalls.set(tool, (this.toolCalls.get(tool) || 0) + 1);
-        // Track agent if available
-        const agentName = context.agentName;
-        if (agentName) {
-            this.agentActivities.set(agentName, (this.agentActivities.get(agentName) || 0) + 1);
-        }
-        // Generate summary on triggers
-        const shouldSummarize = this.shouldGenerateSummary(context);
-        if (shouldSummarize) {
-            const summary = this.generateEmojiSummary(context);
-            frameworkLogger.log("sessionSummary", "session-summary-output", "info", { summary });
-            frameworkLogger.log("sessionSummary", "session-summary-generated", "info", { summary: this.stripEmojis(summary), operationCount: this.operations.length });
-            return { summaryGenerated: true, summary };
-        }
-        return { summaryGenerated: false };
-    }
-    shouldGenerateSummary(context) {
-        const isPublish = context.metadata?.isPublishing;
-        const operationCount = this.operations.length;
-        const isError = !context.success;
-        return isPublish || (operationCount > 0 && operationCount % 5 === 0) || isError;
-    }
-    generateEmojiSummary(context) {
-        const emojis = this.config.include_emojis;
-        const ops = this.operations.length;
-        const duration = Date.now() - this.sessionStartTime;
-        const prefix = emojis ? "🎯" : ">";
-        const separator = emojis ? "━━━━━━━━━━━━━━━━━━" : "===============";
-        const toolIcon = emojis ? "🛠️" : "Tools:";
-        const agentIcon = emojis ? "🤖" : "Agents:";
-        const recIcon = emojis ? "📝" : "Note:";
-        let summary = `\n${prefix} Session Summary (${ops} ops, ${(duration / 1000).toFixed(1)}s)\n${separator}\n`;
-        // Top tools
-        if (this.toolCalls.size > 0) {
-            const topTools = Array.from(this.toolCalls.entries())
-                .sort((a, b) => b[1] - a[1])
-                .slice(0, 5)
-                .map(([t, c]) => `${t}(${c})`)
-                .join(", ");
-            summary += `${toolIcon} ${topTools}\n`;
-        }
-        // Agents
-        if (this.config.include_agent_activities && this.agentActivities.size > 0) {
-            summary += `${agentIcon} ${Array.from(this.agentActivities.keys()).join(", ")}\n`;
-        }
-        // Last operation status
-        const lastOp = this.operations[this.operations.length - 1] || "unknown";
-        const status = context.success !== false ? "✅" : "❌";
-        summary += `${status} Last: ${lastOp}\n`;
-        // Recommendation
-        if (this.config.include_recommendations && ops >= 3) {
-            summary += `${recIcon} ${this.generateRecommendation()}\n`;
-        }
-        summary += `${separator}\n`;
-        return summary;
-    }
-    generateRecommendation() {
-        const editCount = this.toolCalls.get("edit") || 0;
-        const writeCount = this.toolCalls.get("write") || 0;
-        if (editCount > 5)
-            return "Heavy edits - consider running tests";
-        if (writeCount > 10)
-            return "Many writes - good time for a commit";
-        return "Session progressing well";
-    }
-    stripEmojis(text) {
-        return text.replace(/🎯|🛠️|🤖|✅|❌|📝|━━━━━━━━━━━━━━━━━━|===============/g, "").trim();
-    }
-}
-export default SessionSummaryProcessor;

package/dist/processors/implementations/spawn-governance-processor.d.ts

@@ -1,57 +0,0 @@
-/**
- * Spawn Governance Processor
- *
- * Enforces codex terms #52-57:
- *  - #52 Agent Spawn Governance
- *  - #53 Subagent Spawning Prevention
- *  - #54 Concurrent Agent Limits
- *  - #55 Emergency Memory Cleanup
- *  - #56 Infinite Spawn Pattern Detection
- *  - #57 Spawn Rate Limiting
- *
- * @since 2026-03-28
- */
-export interface SpawnGovernanceConfig {
-    maxConcurrent: number;
-    rateLimitWindowMs: number;
-    maxSpawnsPerWindow: number;
-    memoryThreshold: number;
-    infiniteSpawnThreshold: number;
-    infiniteSpawnWindowMs: number;
-}
-export declare class SpawnGovernanceProcessor {
-    static readonly DEFAULT_MAX_CONCURRENT = 5;
-    static readonly DEFAULT_RATE_LIMIT_WINDOW_MS = 10000;
-    static readonly DEFAULT_MAX_SPAWNS_PER_WINDOW = 10;
-    static readonly DEFAULT_MEMORY_THRESHOLD = 0.8;
-    private readonly config;
-    private activeSpawns;
-    private spawnTimestamps;
-    private agentSpawnTimestamps;
-    private blockedCount;
-    private subagentDepth;
-    constructor(config?: Partial<SpawnGovernanceConfig>);
-    checkSpawnAllowed(agentName: string): {
-        allowed: boolean;
-        reason?: string;
-    };
-    recordSpawn(agentName: string): void;
-    recordSpawnComplete(agentName: string): void;
-    getMetrics(): {
-        activeSpawns: number;
-        recentSpawns: number;
-        blockedSpawns: number;
-        memoryUsage: number;
-    };
-    emergencyCleanup(): void;
-    setSubagentDepth(agentName: string, depth: number): void;
-    private purgeOldTimestamps;
-    private getMemoryUsageRatio;
-}
-export declare function resetGovernanceProcessor(): void;
-export declare function runSpawnGovernance(context: any): Promise<{
-    success: boolean;
-    allowed: boolean;
-    reason?: string;
-    metrics: ReturnType<SpawnGovernanceProcessor["getMetrics"]>;
-}>;

package/dist/processors/implementations/spawn-governance-processor.js

@@ -1,218 +0,0 @@
-/**
- * Spawn Governance Processor
- *
- * Enforces codex terms #52-57:
- *  - #52 Agent Spawn Governance
- *  - #53 Subagent Spawning Prevention
- *  - #54 Concurrent Agent Limits
- *  - #55 Emergency Memory Cleanup
- *  - #56 Infinite Spawn Pattern Detection
- *  - #57 Spawn Rate Limiting
- *
- * @since 2026-03-28
- */
-import { frameworkLogger } from "../../core/framework-logger.js";
-// ---------------------------------------------------------------------------
-// Processor
-// ---------------------------------------------------------------------------
-export class SpawnGovernanceProcessor {
-    static DEFAULT_MAX_CONCURRENT = 5;
-    static DEFAULT_RATE_LIMIT_WINDOW_MS = 10000;
-    static DEFAULT_MAX_SPAWNS_PER_WINDOW = 10;
-    static DEFAULT_MEMORY_THRESHOLD = 0.8;
-    config;
-    activeSpawns = new Set();
-    spawnTimestamps = [];
-    agentSpawnTimestamps = new Map();
-    blockedCount = 0;
-    subagentDepth = new Map();
-    constructor(config) {
-        this.config = {
-            maxConcurrent: config?.maxConcurrent ?? SpawnGovernanceProcessor.DEFAULT_MAX_CONCURRENT,
-            rateLimitWindowMs: config?.rateLimitWindowMs ?? SpawnGovernanceProcessor.DEFAULT_RATE_LIMIT_WINDOW_MS,
-            maxSpawnsPerWindow: config?.maxSpawnsPerWindow ?? SpawnGovernanceProcessor.DEFAULT_MAX_SPAWNS_PER_WINDOW,
-            memoryThreshold: config?.memoryThreshold ?? SpawnGovernanceProcessor.DEFAULT_MEMORY_THRESHOLD,
-            infiniteSpawnThreshold: config?.infiniteSpawnThreshold ?? 3,
-            infiniteSpawnWindowMs: config?.infiniteSpawnWindowMs ?? 10000,
-        };
-    }
-    // -----------------------------------------------------------------------
-    // Core API
-    // -----------------------------------------------------------------------
-    checkSpawnAllowed(agentName) {
-        const now = Date.now();
-        // 1. Concurrent agent limit (#54)
-        if (this.activeSpawns.size >= this.config.maxConcurrent) {
-            this.blockedCount++;
-            frameworkLogger.log("spawn-governance", "concurrent-limit-exceeded", "warning", {
-                agentName,
-                activeSpawns: this.activeSpawns.size,
-                maxConcurrent: this.config.maxConcurrent,
-            });
-            return { allowed: false, reason: `Concurrent agent limit exceeded (${this.activeSpawns.size}/${this.config.maxConcurrent})` };
-        }
-        // 2. Recursive subagent spawning prevention (#53)
-        const depth = this.subagentDepth.get(agentName) ?? 0;
-        if (depth > 0) {
-            this.blockedCount++;
-            frameworkLogger.log("spawn-governance", "recursive-subagent-blocked", "warning", { agentName, depth });
-            return { allowed: false, reason: `Recursive subagent spawning blocked for "${agentName}" (depth ${depth})` };
-        }
-        // 3. Infinite spawn pattern detection (#56)
-        const agentTimes = this.agentSpawnTimestamps.get(agentName) ?? [];
-        const recentAgentSpawns = agentTimes.filter((t) => now - t < this.config.infiniteSpawnWindowMs);
-        if (recentAgentSpawns.length >= this.config.infiniteSpawnThreshold) {
-            this.blockedCount++;
-            frameworkLogger.log("spawn-governance", "infinite-spawn-pattern-detected", "warning", {
-                agentName,
-                recentCount: recentAgentSpawns.length,
-                threshold: this.config.infiniteSpawnThreshold,
-                windowMs: this.config.infiniteSpawnWindowMs,
-            });
-            return {
-                allowed: false,
-                reason: `Infinite spawn pattern detected for "${agentName}" (${recentAgentSpawns.length} spawns in ${this.config.infiniteSpawnWindowMs}ms)`,
-            };
-        }
-        // 4. Spawn rate limiting (#57)
-        this.purgeOldTimestamps(now);
-        if (this.spawnTimestamps.length >= this.config.maxSpawnsPerWindow) {
-            this.blockedCount++;
-            frameworkLogger.log("spawn-governance", "rate-limit-exceeded", "warning", {
-                agentName,
-                recentSpawns: this.spawnTimestamps.length,
-                maxSpawns: this.config.maxSpawnsPerWindow,
-                windowMs: this.config.rateLimitWindowMs,
-            });
-            return {
-                allowed: false,
-                reason: `Spawn rate limit exceeded (${this.spawnTimestamps.length}/${this.config.maxSpawnsPerWindow} in ${this.config.rateLimitWindowMs}ms)`,
-            };
-        }
-        // 5. Emergency memory check (#55)
-        const memRatio = this.getMemoryUsageRatio();
-        if (memRatio > this.config.memoryThreshold) {
-            frameworkLogger.log("spawn-governance", "memory-threshold-exceeded", "warning", {
-                agentName,
-                memoryUsage: memRatio,
-                threshold: this.config.memoryThreshold,
-            });
-            this.emergencyCleanup();
-            return { allowed: false, reason: `Emergency memory cleanup triggered (heap usage ${(memRatio * 100).toFixed(1)}% > ${(this.config.memoryThreshold * 100).toFixed(0)}%)` };
-        }
-        return { allowed: true };
-    }
-    recordSpawn(agentName) {
-        const now = Date.now();
-        this.activeSpawns.add(agentName);
-        this.spawnTimestamps.push(now);
-        const agentTimes = this.agentSpawnTimestamps.get(agentName) ?? [];
-        agentTimes.push(now);
-        this.agentSpawnTimestamps.set(agentName, agentTimes);
-        // Track subagent depth: increment parent depth for new subagent
-        const currentDepth = this.subagentDepth.get(agentName) ?? 0;
-        this.subagentDepth.set(agentName, currentDepth);
-        frameworkLogger.log("spawn-governance", "spawn-recorded", "info", { agentName, activeSpawns: this.activeSpawns.size });
-    }
-    recordSpawnComplete(agentName) {
-        this.activeSpawns.delete(agentName);
-        this.subagentDepth.delete(agentName);
-        frameworkLogger.log("spawn-governance", "spawn-completed", "info", { agentName, activeSpawns: this.activeSpawns.size });
-    }
-    // -----------------------------------------------------------------------
-    // Metrics
-    // -----------------------------------------------------------------------
-    getMetrics() {
-        this.purgeOldTimestamps(Date.now());
-        return {
-            activeSpawns: this.activeSpawns.size,
-            recentSpawns: this.spawnTimestamps.length,
-            blockedSpawns: this.blockedCount,
-            memoryUsage: this.getMemoryUsageRatio(),
-        };
-    }
-    // -----------------------------------------------------------------------
-    // Emergency cleanup
-    // -----------------------------------------------------------------------
-    emergencyCleanup() {
-        frameworkLogger.log("spawn-governance", "emergency-cleanup-started", "warning", { activeSpawns: this.activeSpawns.size, recentSpawns: this.spawnTimestamps.length });
-        this.activeSpawns.clear();
-        this.spawnTimestamps = [];
-        this.agentSpawnTimestamps.clear();
-        this.subagentDepth.clear();
-        if (global.gc) {
-            global.gc();
-        }
-        frameworkLogger.log("spawn-governance", "emergency-cleanup-completed", "info", {});
-    }
-    // -----------------------------------------------------------------------
-    // Subagent depth management (for recursive prevention)
-    // -----------------------------------------------------------------------
-    setSubagentDepth(agentName, depth) {
-        this.subagentDepth.set(agentName, depth);
-    }
-    // -----------------------------------------------------------------------
-    // Internal helpers
-    // -----------------------------------------------------------------------
-    purgeOldTimestamps(now) {
-        const cutoff = now - this.config.rateLimitWindowMs;
-        this.spawnTimestamps = this.spawnTimestamps.filter((t) => t > cutoff);
-        // Also purge agent-specific timestamps
-        this.agentSpawnTimestamps.forEach((times, agent) => {
-            const filtered = times.filter((t) => t > cutoff);
-            if (filtered.length === 0) {
-                this.agentSpawnTimestamps.delete(agent);
-            }
-            else {
-                this.agentSpawnTimestamps.set(agent, filtered);
-            }
-        });
-    }
-    getMemoryUsageRatio() {
-        try {
-            const mem = process.memoryUsage();
-            return mem.heapUsed / mem.heapTotal;
-        }
-        catch {
-            return 0;
-        }
-    }
-}
-// ---------------------------------------------------------------------------
-// Singleton instance for persistent governance state across processor calls
-// ---------------------------------------------------------------------------
-let governanceProcessor = null;
-function getGovernanceProcessor(config) {
-    if (!governanceProcessor) {
-        governanceProcessor = new SpawnGovernanceProcessor(config);
-    }
-    return governanceProcessor;
-}
-export function resetGovernanceProcessor() {
-    governanceProcessor = null;
-}
-// ---------------------------------------------------------------------------
-// Standalone runner for processor-manager integration
-// ---------------------------------------------------------------------------
-export async function runSpawnGovernance(context) {
-    const processor = getGovernanceProcessor(context.config);
-    const agentName = context.agentName;
-    if (!agentName) {
-        return {
-            success: false,
-            allowed: false,
-            reason: "Missing agentName in context",
-            metrics: processor.getMetrics(),
-        };
-    }
-    const check = processor.checkSpawnAllowed(agentName);
-    if (check.allowed) {
-        processor.recordSpawn(agentName);
-    }
-    return {
-        success: true,
-        allowed: check.allowed,
-        ...(check.reason ? { reason: check.reason } : {}),
-        metrics: processor.getMetrics(),
-    };
-}

package/dist/processors/implementations/state-validation-processor.d.ts

@@ -1,11 +0,0 @@
-import { PostProcessor } from "../processor-interfaces.js";
-import type { ProcessorContext } from "../processor-types.js";
-import type { ProcessorDependency } from "../processor-interfaces.js";
-export declare class StateValidationProcessor extends PostProcessor {
-    readonly name = "stateValidation";
-    readonly priority = 12;
-    static readonly dependencies: ProcessorDependency[];
-    private stateManager;
-    constructor(stateManager?: any);
-    protected run(_context: ProcessorContext): Promise<Record<string, boolean>>;
-}

package/dist/processors/implementations/state-validation-processor.js

@@ -1,15 +0,0 @@
-import { PostProcessor } from "../processor-interfaces.js";
-export class StateValidationProcessor extends PostProcessor {
-    name = "stateValidation";
-    priority = 12;
-    static dependencies = ["stateManager"];
-    stateManager;
-    constructor(stateManager) {
-        super();
-        this.stateManager = stateManager;
-    }
-    async run(_context) {
-        const currentState = this.stateManager.get("session:active");
-        return { stateValid: !!currentState };
-    }
-}

package/dist/processors/implementations/storytelling-trigger-processor.d.ts

@@ -1,40 +0,0 @@
-import { PostProcessor } from "../processor-interfaces.js";
-import { ProcessorContext } from "../processor-types.js";
-export declare class StorytellingTriggerProcessor extends PostProcessor {
-    readonly name = "storytelling-trigger";
-    readonly priority = 5;
-    private config;
-    private reflectionsDir;
-    private deepReflectionsDir;
-    constructor();
-    protected run(context: ProcessorContext): Promise<unknown>;
-    private runInferenceCycle;
-    private reflectOnCommits;
-    private reflectOnRelease;
-    private synthesizeReflection;
-    private detectPatterns;
-    private detectSemanticPatterns;
-    private extractDecisions;
-    private synthesizeInferences;
-    private getCommitsBetween;
-    private getRecentCommits;
-    private summarizeCommits;
-    private getLastTag;
-    private getFileCommitHash;
-    private getMostRecentReflectionFile;
-    private git;
-    static suggestStoryType(context: {
-        commitCount?: number;
-        fileCount?: number;
-        sessionDuration?: number;
-        isPublishing?: boolean;
-    }): "reflection" | "saga" | "journey" | "narrative";
-    static getStoryTypeMeta(storyType: string): {
-        location: string;
-        minWords: number;
-        idealWords: number;
-        framework: string;
-        template: string;
-    };
-}
-export default StorytellingTriggerProcessor;