wogiflow 2.4.1 → 2.4.3

package/scripts/flow-learning-orchestrator.js

@@ -1,10 +1,13 @@
-'use strict';
-
 /**
- * Learning Orchestrator Facade
+ * Learning Orchestrator — Centralized Write Mediator
+ *
+ * ALL writes to feedback-patterns.md and decisions.md MUST go through this module.
+ * Direct fs.writeFileSync to these files from learning modules is prohibited.
  *
- * Coordinates all learning pipeline modules with a unified API.
- * Existing direct imports continue working — this facade is additive.
+ * Features:
+ *   - Centralized write API with dedup checking
+ *   - Write locking via acquireLock to prevent race conditions
+ *   - Fuzzy dedup: rejects writes that duplicate existing entries
  *
  * Sub-modules (lazy-loaded to avoid startup cost):
  *   - flow-skill-learn.js          — Skill discovery and learning
@@ -20,6 +23,16 @@
  *   - flow-standards-learner.js    — Standards violation learning
  */
 
+const fs = require('node:fs');
+const { PATHS } = require('./flow-paths');
+const { acquireLock, readFile, writeFile, fileExists } = require('./flow-io');
+
+// ============================================================
+// Constants
+// ============================================================
+
+const DEDUP_SIMILARITY_THRESHOLD = 0.85; // 85% similarity = duplicate
+
 // ============================================================
 // Lazy Loaders
 // ============================================================
@@ -36,6 +49,287 @@ function getFailureLearning() { return require('./flow-failure-learning'); }
 function getAutoLearn() { return require('./flow-auto-learn'); }
 function getStandardsLearner() { return require('./flow-standards-learner'); }
 
+// ============================================================
+// Dedup Utilities
+// ============================================================
+
+/**
+ * Normalize text for dedup comparison: lowercase, strip punctuation, collapse whitespace.
+ * @param {string} text
+ * @returns {string}
+ */
+function normalizeForDedup(text) {
+  if (!text || typeof text !== 'string') return '';
+  return text
+    .toLowerCase()
+    .replace(/[^a-z0-9\s]/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+/**
+ * Compute bigram similarity between two strings (Dice coefficient).
+ * Returns 0..1 where 1 = identical.
+ * @param {string} a
+ * @param {string} b
+ * @returns {number}
+ */
+function bigramSimilarity(a, b) {
+  const na = normalizeForDedup(a);
+  const nb = normalizeForDedup(b);
+
+  if (na === nb) return 1.0;
+  if (na.length < 2 || nb.length < 2) return 0;
+
+  const bigramsA = new Set();
+  for (let i = 0; i < na.length - 1; i++) bigramsA.add(na.slice(i, i + 2));
+  const bigramsB = new Set();
+  for (let i = 0; i < nb.length - 1; i++) bigramsB.add(nb.slice(i, i + 2));
+
+  let intersection = 0;
+  for (const bg of bigramsA) {
+    if (bigramsB.has(bg)) intersection++;
+  }
+
+  return (2 * intersection) / (bigramsA.size + bigramsB.size);
+}
+
+/**
+ * Check if an entry already exists in file content (fuzzy match).
+ * Checks both exact substring and bigram similarity against existing entries.
+ *
+ * @param {string} content - Current file content
+ * @param {string} entryText - The new entry text to check
+ * @returns {{ isDuplicate: boolean, matchedText?: string, similarity?: number }}
+ */
+function checkDuplicate(content, entryText) {
+  if (!content || !entryText) return { isDuplicate: false };
+
+  const normalizedEntry = normalizeForDedup(entryText);
+  if (!normalizedEntry || normalizedEntry.length < 5) return { isDuplicate: false };
+
+  // Exact substring check (case-insensitive)
+  if (content.toLowerCase().includes(normalizedEntry)) {
+    return { isDuplicate: true, matchedText: entryText, similarity: 1.0 };
+  }
+
+  // Extract existing entries from tables (pipe-delimited rows) and headings
+  const lines = content.split('\n');
+  for (const line of lines) {
+    const trimmed = line.trim();
+
+    // Skip header rows and separators
+    if (!trimmed || trimmed.startsWith('|---') || trimmed.startsWith('| Date')) continue;
+
+    // Table row: extract content cells
+    if (trimmed.startsWith('|')) {
+      const cells = trimmed.split('|').slice(1, -1).map(c => c.trim());
+      // Check cells 1 and 2 (pattern/correction columns)
+      for (let i = 1; i < Math.min(cells.length, 3); i++) {
+        const sim = bigramSimilarity(cells[i], entryText);
+        if (sim >= DEDUP_SIMILARITY_THRESHOLD) {
+          return { isDuplicate: true, matchedText: cells[i], similarity: sim };
+        }
+      }
+    }
+
+    // Heading: ### Pattern Name
+    if (trimmed.startsWith('###')) {
+      const heading = trimmed.replace(/^###\s*/, '').replace(/\s*\([\d-]+\)$/, '');
+      const sim = bigramSimilarity(heading, entryText);
+      if (sim >= DEDUP_SIMILARITY_THRESHOLD) {
+        return { isDuplicate: true, matchedText: heading, similarity: sim };
+      }
+    }
+  }
+
+  return { isDuplicate: false };
+}
+
+// ============================================================
+// Centralized Write API
+// ============================================================
+
+/**
+ * Write to feedback-patterns.md through the orchestrator.
+ * Acquires a lock, checks for duplicates, then applies the write.
+ *
+ * @param {Object} params
+ * @param {string} params.content - Full new content to write (replaces file)
+ * @param {string} [params.entryText] - Key text of the new entry (for dedup)
+ * @param {string} params.caller - Calling module name (for logging)
+ * @param {boolean} [params.skipDedup=false] - Skip dedup check (for bulk rewrites)
+ * @returns {Promise<{ success: boolean, reason?: string }>}
+ */
+async function writeToFeedbackPatterns({ content, entryText, caller, skipDedup = false }) {
+  const filePath = PATHS.feedbackPatterns;
+
+  const release = await acquireLock(filePath, { retries: 5, retryDelay: 100 });
+  try {
+    // Dedup check
+    if (!skipDedup && entryText) {
+      const currentContent = fileExists(filePath) ? readFile(filePath, '') : '';
+      const dupCheck = checkDuplicate(currentContent, entryText);
+      if (dupCheck.isDuplicate) {
+        if (process.env.DEBUG) {
+          console.log(`[orchestrator] Dedup rejected write from ${caller}: "${entryText}" matches "${dupCheck.matchedText}" (${(dupCheck.similarity * 100).toFixed(0)}%)`);
+        }
+        return { success: false, reason: 'duplicate', matchedText: dupCheck.matchedText, similarity: dupCheck.similarity };
+      }
+    }
+
+    writeFile(filePath, content);
+    if (process.env.DEBUG) {
+      console.log(`[orchestrator] ${caller} wrote to feedback-patterns.md`);
+    }
+    return { success: true };
+  } catch (err) {
+    return { success: false, reason: err.message };
+  } finally {
+    release();
+  }
+}
+
+/**
+ * Write to decisions.md through the orchestrator.
+ * Acquires a lock, checks for duplicates, then applies the write.
+ *
+ * @param {Object} params
+ * @param {string} params.content - Full new content to write (replaces file)
+ * @param {string} [params.entryText] - Key text of the new entry (for dedup)
+ * @param {string} params.caller - Calling module name (for logging)
+ * @param {boolean} [params.skipDedup=false] - Skip dedup check (for bulk rewrites)
+ * @param {boolean} [params.syncRules=false] - Trigger rules sync after write
+ * @returns {Promise<{ success: boolean, reason?: string }>}
+ */
+async function writeToDecisions({ content, entryText, caller, skipDedup = false, syncRules = false }) {
+  const filePath = PATHS.decisions;
+
+  const release = await acquireLock(filePath, { retries: 5, retryDelay: 100 });
+  try {
+    // Dedup check
+    if (!skipDedup && entryText) {
+      const currentContent = fileExists(filePath) ? readFile(filePath, '') : '';
+      const dupCheck = checkDuplicate(currentContent, entryText);
+      if (dupCheck.isDuplicate) {
+        if (process.env.DEBUG) {
+          console.log(`[orchestrator] Dedup rejected write from ${caller}: "${entryText}" matches "${dupCheck.matchedText}" (${(dupCheck.similarity * 100).toFixed(0)}%)`);
+        }
+        return { success: false, reason: 'duplicate', matchedText: dupCheck.matchedText, similarity: dupCheck.similarity };
+      }
+    }
+
+    writeFile(filePath, content);
+    if (process.env.DEBUG) {
+      console.log(`[orchestrator] ${caller} wrote to decisions.md`);
+    }
+
+    // Optionally sync rules after write
+    if (syncRules) {
+      try {
+        require('./flow-rules-sync');
+      } catch (_err) {
+        // Non-fatal — rules sync is optional
+      }
+    }
+
+    return { success: true };
+  } catch (err) {
+    return { success: false, reason: err.message };
+  } finally {
+    release();
+  }
+}
+
+/**
+ * Read-modify-write helper for feedback-patterns.md.
+ * Acquires lock, reads current content, calls modifier, writes result.
+ *
+ * @param {Function} modifier - (currentContent: string) => { content: string, entryText?: string }
+ * @param {Object} opts - { caller: string, skipDedup?: boolean }
+ * @returns {Promise<{ success: boolean, reason?: string }>}
+ */
+async function modifyFeedbackPatterns(modifier, { caller, skipDedup = false } = {}) {
+  const filePath = PATHS.feedbackPatterns;
+
+  const release = await acquireLock(filePath, { retries: 5, retryDelay: 100 });
+  try {
+    const currentContent = fileExists(filePath) ? readFile(filePath, '') : '';
+    const result = modifier(currentContent);
+
+    if (!result || !result.content) {
+      return { success: false, reason: 'modifier returned no content' };
+    }
+
+    // Dedup check
+    if (!skipDedup && result.entryText) {
+      const dupCheck = checkDuplicate(currentContent, result.entryText);
+      if (dupCheck.isDuplicate) {
+        if (process.env.DEBUG) {
+          console.log(`[orchestrator] Dedup rejected modify from ${caller}: "${result.entryText}" matches "${dupCheck.matchedText}"`);
+        }
+        return { success: false, reason: 'duplicate', matchedText: dupCheck.matchedText };
+      }
+    }
+
+    writeFile(filePath, result.content);
+    return { success: true };
+  } catch (err) {
+    return { success: false, reason: err.message };
+  } finally {
+    release();
+  }
+}
+
+/**
+ * Read-modify-write helper for decisions.md.
+ * Acquires lock, reads current content, calls modifier, writes result.
+ *
+ * @param {Function} modifier - (currentContent: string) => { content: string, entryText?: string }
+ * @param {Object} opts - { caller: string, skipDedup?: boolean, syncRules?: boolean }
+ * @returns {Promise<{ success: boolean, reason?: string }>}
+ */
+async function modifyDecisions(modifier, { caller, skipDedup = false, syncRules = false } = {}) {
+  const filePath = PATHS.decisions;
+
+  const release = await acquireLock(filePath, { retries: 5, retryDelay: 100 });
+  try {
+    const currentContent = fileExists(filePath) ? readFile(filePath, '') : '';
+    const result = modifier(currentContent);
+
+    if (!result || !result.content) {
+      return { success: false, reason: 'modifier returned no content' };
+    }
+
+    // Dedup check
+    if (!skipDedup && result.entryText) {
+      const dupCheck = checkDuplicate(currentContent, result.entryText);
+      if (dupCheck.isDuplicate) {
+        if (process.env.DEBUG) {
+          console.log(`[orchestrator] Dedup rejected modify from ${caller}: "${result.entryText}" matches "${dupCheck.matchedText}"`);
+        }
+        return { success: false, reason: 'duplicate', matchedText: dupCheck.matchedText };
+      }
+    }
+
+    writeFile(filePath, result.content);
+
+    if (syncRules) {
+      try {
+        require('./flow-rules-sync');
+      } catch (_err) {
+        // Non-fatal
+      }
+    }
+
+    return { success: true };
+  } catch (err) {
+    return { success: false, reason: err.message };
+  } finally {
+    release();
+  }
+}
+
 // ============================================================
 // Unified API
 // ============================================================
@@ -114,10 +408,10 @@ async function learn(type, context = {}) {
 function getStats() {
   const stats = {};
 
-  try { stats.tiered = getTieredLearning().getLearningStats(); } catch (err) { stats.tiered = null; }
-  try { stats.failure = getFailureLearning().getLearningStats(); } catch (err) { stats.failure = null; }
-  try { stats.loop = getLoopRetryLearning().getLearningStats(); } catch (err) { stats.loop = null; }
-  try { stats.auto = getAutoLearn().showStatus(); } catch (err) { stats.auto = null; }
+  try { stats.tiered = getTieredLearning().getLearningStats(); } catch (_err) { stats.tiered = null; }
+  try { stats.failure = getFailureLearning().getLearningStats(); } catch (_err) { stats.failure = null; }
+  try { stats.loop = getLoopRetryLearning().getLearningStats(); } catch (_err) { stats.loop = null; }
+  try { stats.auto = getAutoLearn().showStatus(); } catch (_err) { stats.auto = null; }
 
   return stats;
 }
@@ -134,19 +428,19 @@ function loadRelevantPatterns(context = {}) {
 
   try {
     patterns.decisions = getPatternEnforcer().loadDecisionPatterns();
-  } catch (err) {
+  } catch (_err) {
     patterns.decisions = [];
   }
 
   try {
     patterns.skills = getPatternEnforcer().loadSkillPatterns(context.skills || []);
-  } catch (err) {
+  } catch (_err) {
     patterns.skills = [];
   }
 
   try {
     patterns.tiered = getTieredLearning().getPatternsByTier(context.tier || 'all');
-  } catch (err) {
+  } catch (_err) {
     patterns.tiered = [];
   }
 
@@ -158,7 +452,18 @@ function loadRelevantPatterns(context = {}) {
 // ============================================================
 
 module.exports = {
-  // Unified API
+  // Centralized write API (MUST be used for all learning file writes)
+  writeToFeedbackPatterns,
+  writeToDecisions,
+  modifyFeedbackPatterns,
+  modifyDecisions,
+
+  // Dedup utilities (exposed for testing)
+  checkDuplicate,
+  bigramSimilarity,
+  normalizeForDedup,
+
+  // Unified learning API
   learn,
   getStats,
   loadRelevantPatterns,

package/scripts/flow-links.js

@@ -25,14 +25,12 @@ const path = require('node:path');
 const https = require('node:https');
 const http = require('node:http');
 const dns = require('dns');
-const { getProjectRoot, colors: c, readJson } = require('./flow-utils');
+const { getProjectRoot, colors: c, readJson, PATHS } = require('./flow-utils');
 const { success: printSuccess } = require('./flow-output');
 
-const PROJECT_ROOT = getProjectRoot();
-const WORKFLOW_DIR = path.join(PROJECT_ROOT, '.workflow');
-const LINKS_PATH = path.join(WORKFLOW_DIR, 'links.yaml');
-const LINKS_JSON_PATH = path.join(WORKFLOW_DIR, 'links.json');
-const CACHE_DIR = path.join(WORKFLOW_DIR, 'cache', 'links');
+const LINKS_PATH = path.join(PATHS.workflow, 'links.yaml');
+const LINKS_JSON_PATH = path.join(PATHS.workflow, 'links.json');
+const CACHE_DIR = path.join(PATHS.workflow, 'cache', 'links');
 
 /**
  * Link types
@@ -357,7 +355,7 @@ async function fetchLink(name, links = null) {
       const filePath = url.startsWith('file://') ? url.slice(7) : url;
       const absPath = path.isAbsolute(filePath)
         ? filePath
-        : path.join(PROJECT_ROOT, filePath);
+        : path.join(PATHS.root, filePath);
 
       if (fs.existsSync(absPath)) {
         content = fs.readFileSync(absPath, 'utf-8');

package/scripts/flow-long-input-association.js

@@ -0,0 +1,275 @@
+/**
+ * Long Input Processing - Statement Association
+ *
+ * Extracted from flow-long-input.js
+ * Handles statement splitting, meaningfulness checks, association with topics,
+ * and statement map persistence.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { safeJsonParse } = require('./flow-utils');
+
+const { FILLER_PATTERNS, REQUIREMENT_PATTERNS } = require('./flow-long-input-constants');
+
+// These are injected via init()
+let _loadActiveDigest = null;
+let _updatePhase = null;
+
+/**
+ * Initialize with core functions from the main module.
+ * @param {Object} deps
+ */
+function init(deps) {
+  _loadActiveDigest = deps.loadActiveDigest;
+  _updatePhase = deps.updatePhase;
+}
+
+/**
+ * Check if statement is meaningful (contains requirements/substance)
+ */
+function isMeaningfulStatement(text) {
+  const trimmed = text.trim();
+
+  // Too short
+  if (trimmed.length < 5) return { meaningful: false, reason: 'too_short' };
+
+  // Check filler patterns
+  for (const pattern of FILLER_PATTERNS) {
+    if (pattern.test(trimmed)) {
+      return { meaningful: false, reason: 'filler' };
+    }
+  }
+
+  // Check for requirement signals
+  for (const pattern of REQUIREMENT_PATTERNS) {
+    if (pattern.test(trimmed)) {
+      return { meaningful: true, reason: 'requirement_signal' };
+    }
+  }
+
+  // Check word count - very short statements without requirement signals are likely filler
+  const wordCount = trimmed.split(/\s+/).length;
+
+  if (wordCount < 4) {
+    return { meaningful: false, reason: 'too_brief' };
+  }
+
+  // Default to meaningful if substantial enough
+  return { meaningful: true, reason: 'substantial' };
+}
+
+/**
+ * Split transcript into statements
+ */
+function splitIntoStatements(text) {
+  const statements = [];
+  let position = 0;
+
+  // Split by sentence boundaries and speaker changes
+  const segments = text.split(/(?<=[.!?])\s+|(?=^[A-Z][a-z]+:|\[\d{2}:\d{2})/gm);
+
+  for (const segment of segments) {
+    const trimmed = segment.trim();
+    if (!trimmed) continue;
+
+    // Extract speaker if present
+    const speakerMatch = trimmed.match(/^([A-Z][a-z]+):\s*/);
+    const speaker = speakerMatch ? speakerMatch[1] : null;
+    const content = speakerMatch ? trimmed.slice(speakerMatch[0].length) : trimmed;
+
+    // Extract timestamp if present
+    const timestampMatch = trimmed.match(/^\[?(\d{2}:\d{2}(?::\d{2})?)\]?\s*/);
+    const timestamp = timestampMatch ? timestampMatch[1] : null;
+
+    if (content.trim()) {
+      statements.push({
+        text: content.trim(),
+        speaker,
+        timestamp,
+        position
+      });
+    }
+
+    position += segment.length;
+  }
+
+  return statements;
+}
+
+/**
+ * Calculate association confidence between statement and topic
+ */
+function calculateAssociationConfidence(statement, topic) {
+  let confidence = 0.5; // Base confidence
+  const reasons = [];
+
+  const statementLower = statement.text.toLowerCase();
+  const topicTitle = topic.title.toLowerCase();
+
+  // Entity match - highest confidence
+  if (topic.entities) {
+    for (const entity of topic.entities) {
+      if (statementLower.includes(entity.toLowerCase())) {
+        confidence = Math.max(confidence, 0.9);
+        reasons.push(`entity_match:${entity}`);
+      }
+    }
+  }
+
+  // Title word match
+  const titleWords = topicTitle.split(/\s+/).filter(w => w.length > 3);
+  for (const word of titleWords) {
+    if (statementLower.includes(word)) {
+      confidence = Math.max(confidence, 0.8);
+      reasons.push(`title_match:${word}`);
+    }
+  }
+
+  // Keyword match
+  if (topic.keywords) {
+    for (const keyword of topic.keywords) {
+      if (statementLower.includes(keyword.toLowerCase())) {
+        confidence = Math.max(confidence, 0.75);
+        reasons.push(`keyword_match:${keyword}`);
+      }
+    }
+  }
+
+  return { confidence, reasons };
+}
+
+/**
+ * Associate statements with topics
+ */
+function associateStatements(statements, topics) {
+  const mappedStatements = [];
+  let currentTopicId = null;
+  let statementId = 1;
+
+  for (const stmt of statements) {
+    const meaningfulCheck = isMeaningfulStatement(stmt.text);
+
+    const mappedStatement = {
+      id: `s-${String(statementId).padStart(3, '0')}`,
+      text: stmt.text,
+      position: stmt.position,
+      timestamp: stmt.timestamp,
+      speaker: stmt.speaker,
+      meaningful: meaningfulCheck.meaningful
+    };
+
+    if (!meaningfulCheck.meaningful) {
+      mappedStatement.topic_id = null;
+      mappedStatement.skip_reason = meaningfulCheck.reason;
+    } else {
+      // Find best matching topic
+      let bestMatch = { topicId: null, confidence: 0, reasons: [] };
+
+      for (const topic of topics) {
+        const { confidence, reasons } = calculateAssociationConfidence(stmt, topic);
+        if (confidence > bestMatch.confidence) {
+          bestMatch = { topicId: topic.id, confidence, reasons };
+        }
+      }
+
+      // Use context continuity if no strong match
+      if (bestMatch.confidence < 0.6 && currentTopicId) {
+        bestMatch = {
+          topicId: currentTopicId,
+          confidence: 0.6,
+          reasons: ['context_continuity']
+        };
+      }
+
+      mappedStatement.topic_id = bestMatch.topicId;
+      mappedStatement.confidence = bestMatch.confidence;
+      mappedStatement.association_reason = bestMatch.reasons.join(',') || 'context_continuity';
+      mappedStatement.clarification_needed = bestMatch.confidence < 0.7;
+
+      if (mappedStatement.clarification_needed) {
+        mappedStatement.clarification_question =
+          `You mentioned "${stmt.text.slice(0, 50)}..." - which feature does this relate to?`;
+      }
+
+      // Update current topic for context continuity
+      if (bestMatch.confidence >= 0.7) {
+        currentTopicId = bestMatch.topicId;
+      }
+    }
+
+    mappedStatements.push(mappedStatement);
+    statementId++;
+  }
+
+  return mappedStatements;
+}
+
+/**
+ * Save statement map to digest
+ */
+function saveStatementMap(statementMap) {
+  const activeDigest = _loadActiveDigest();
+  if (!activeDigest.session.digest_path) {
+    throw new Error('No active digest session');
+  }
+
+  const mapPath = path.join(activeDigest.session.digest_path, 'statement-map.json');
+
+  // Calculate metadata
+  const meaningful = statementMap.statements.filter(s => s.meaningful);
+  const mapped = meaningful.filter(s => s.topic_id !== null);
+  const orphans = meaningful.filter(s => s.topic_id === null);
+
+  const data = {
+    statements: statementMap.statements,
+    contradictions: statementMap.contradictions || [],
+    metadata: {
+      total_statements: statementMap.statements.length,
+      meaningful_statements: meaningful.length,
+      mapped_statements: mapped.length,
+      orphan_statements: orphans.length,
+      contradictions_detected: (statementMap.contradictions || []).length,
+      contradictions_resolved: 0,
+      coverage_percentage: meaningful.length > 0
+        ? Math.round((mapped.length / meaningful.length) * 100 * 10) / 10
+        : 0
+    }
+  };
+
+  fs.writeFileSync(mapPath, JSON.stringify(data, null, 2));
+
+  // Update phase
+  _updatePhase('statement_mapping', 'completed', {
+    statements_mapped: mapped.length,
+    orphans_found: orphans.length,
+    contradictions_found: (statementMap.contradictions || []).length
+  });
+
+  return data;
+}
+
+/**
+ * Load statement map from digest
+ */
+function loadStatementMap() {
+  const activeDigest = _loadActiveDigest();
+  if (!activeDigest.session.digest_path) {
+    return null;
+  }
+
+  const mapPath = path.join(activeDigest.session.digest_path, 'statement-map.json');
+  const data = safeJsonParse(mapPath, null);
+  if (!data) return null;
+  return data;
+}
+
+module.exports = {
+  init,
+  isMeaningfulStatement,
+  splitIntoStatements,
+  calculateAssociationConfidence,
+  associateStatements,
+  saveStatementMap,
+  loadStatementMap
+};

package/scripts/flow-long-input-chunking.js

@@ -12,6 +12,7 @@
 const fs = require('node:fs');
 const path = require('node:path');
 const { readJson } = require('./flow-io');
+const { PATHS } = require('./flow-utils');
 
 // Core functions are injected via init() to avoid circular dependencies
 let digestCore = null;

package/scripts/flow-long-input-cli.js

@@ -1,6 +1,4 @@
 #!/usr/bin/env node
-'use strict';
-
 /**
  * Long Input Processing - CLI handler
  *

package/scripts/flow-long-input-complexity.js

@@ -1,5 +1,3 @@
-'use strict';
-
 /**
  * Long Input Processing - Complexity Detection (E3-S1)
  *