0xray 4.0.13 → 4.0.15

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

@@ -0,0 +1,59 @@
+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

@@ -0,0 +1,14 @@
+/**
+ * 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

@@ -0,0 +1,37 @@
+/**
+ * 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

@@ -0,0 +1,26 @@
+/**
+ * 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

@@ -0,0 +1,125 @@
+/**
+ * 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

@@ -0,0 +1,57 @@
+/**
+ * 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

@@ -0,0 +1,218 @@
+/**
+ * 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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,40 @@
+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;