wogiflow 1.0.12 → 1.0.13

package/scripts/flow-import-profile

@@ -20,6 +20,7 @@ show_help() {
     echo "Import Workflow Profile"
     echo ""
     echo "Usage: flow import-profile <profile.zip> [options]"
+    echo "       flow import-profile --scan <project-folder> [options]"
     echo ""
     echo "Options:"
     echo "  --backup           Create backup of current config before importing"
@@ -29,10 +30,16 @@ show_help() {
     echo "  --skip-rules       Don't import rules (.claude/rules/)"
     echo "  --skip-templates   Don't import templates"
     echo ""
+    echo "Scan Mode (NEW):"
+    echo "  --scan <folder>       Scan another project folder for patterns"
+    echo "  --resolve-conflicts   Interactive conflict resolution (with --scan)"
+    echo "  --analysis-mode MODE  Analysis depth: balanced (default), deep"
+    echo ""
     echo "Examples:"
     echo "  flow import-profile team-frontend.zip"
     echo "  flow import-profile team-frontend.zip --backup"
-    echo "  flow import-profile team-frontend.zip --skip-learnings"
+    echo "  flow import-profile --scan /path/to/other/project"
+    echo "  flow import-profile --scan ../my-other-app --resolve-conflicts"
 }
 
 if [ -z "$1" ] || [ "$1" = "--help" ] || [ "$1" = "-h" ]; then
@@ -40,16 +47,21 @@ if [ -z "$1" ] || [ "$1" = "--help" ] || [ "$1" = "-h" ]; then
     exit 0
 fi
 
-PROFILE_FILE="$1"
-shift
-
-# Parse options
+# Parse options first to detect --scan mode
 BACKUP=false
 DRY_RUN=false
 FORCE=false
 SKIP_LEARNINGS=false
 SKIP_RULES=false
 SKIP_TEMPLATES=false
+SCAN_MODE=false
+SCAN_PATH=""
+RESOLVE_CONFLICTS=false
+ANALYSIS_MODE="balanced"
+PROFILE_FILE=""
+
+# Determine scripts directory
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 
 while [ $# -gt 0 ]; do
     case "$1" in
@@ -71,15 +83,254 @@ while [ $# -gt 0 ]; do
         --skip-templates)
             SKIP_TEMPLATES=true
             ;;
-        *)
+        --scan)
+            SCAN_MODE=true
+            shift
+            SCAN_PATH="$1"
+            ;;
+        --resolve-conflicts)
+            RESOLVE_CONFLICTS=true
+            ;;
+        --analysis-mode)
+            shift
+            ANALYSIS_MODE="$1"
+            ;;
+        -*)
             echo -e "${RED}Unknown option: $1${NC}"
             exit 1
             ;;
+        *)
+            # Positional argument - profile file
+            if [ -z "$PROFILE_FILE" ]; then
+                PROFILE_FILE="$1"
+            fi
+            ;;
     esac
     shift
 done
 
+# Safe JSON reading function (prevents file path injection via process.argv)
+# Note: queries are hardcoded in this script, not external input
+# The query is passed via environment variable to avoid shell quoting issues
+safe_read_json() {
+    local file="$1"
+    local query="$2"
+    SAFE_JSON_QUERY="$query" node -e '
+        const fs = require("fs");
+        const file = process.argv[1];
+        try {
+            const content = fs.readFileSync(file, "utf-8");
+            // Check for prototype pollution attempts
+            if (/__proto__|constructor\s*["'"'"'`:]|prototype\s*["'"'"'`:]/i.test(content)) {
+                console.error("Suspicious content detected");
+                process.exit(1);
+            }
+            const p = JSON.parse(content);
+            // Query is passed via environment to avoid complex quoting issues
+            const queryFn = new Function("p", process.env.SAFE_JSON_QUERY);
+            queryFn(p);
+        } catch(e) {
+            console.error(e.message);
+            process.exit(1);
+        }
+    ' -- "$file" 2>/dev/null
+}
+
+# ==========================================
+# SCAN MODE - Import patterns from another project
+# ==========================================
+if [ "$SCAN_MODE" = true ]; then
+    if [ -z "$SCAN_PATH" ]; then
+        echo -e "${RED}Error: --scan requires a project folder path${NC}"
+        exit 1
+    fi
+
+    if [ ! -d "$SCAN_PATH" ]; then
+        echo -e "${RED}Error: Project folder not found: $SCAN_PATH${NC}"
+        exit 1
+    fi
+
+    echo -e "${CYAN}╔══════════════════════════════════════════════════════════╗${NC}"
+    echo -e "${CYAN}║  Scanning Project for Patterns                           ║${NC}"
+    echo -e "${CYAN}╚══════════════════════════════════════════════════════════╝${NC}"
+    echo ""
+    echo -e "${DIM}Source: $SCAN_PATH${NC}"
+    echo ""
+
+    # Create temp directory for extraction results
+    TEMP_DIR=$(mktemp -d)
+    PATTERNS_FILE="$TEMP_DIR/patterns.json"
+
+    # Run pattern extraction on the source project
+    echo -e "${YELLOW}Extracting patterns...${NC}"
+
+    EXTRACTOR_OPTS="--format json --with-conflicts --analysis-mode $ANALYSIS_MODE"
+
+    if ! node "$SCRIPT_DIR/flow-pattern-extractor.js" $EXTRACTOR_OPTS --output "$PATTERNS_FILE" --project "$SCAN_PATH" 2>/dev/null; then
+        echo -e "${RED}Error: Pattern extraction failed${NC}"
+        rm -rf "$TEMP_DIR"
+        exit 1
+    fi
+
+    # Parse extraction results (using safe JSON parsing instead of require())
+    PATTERN_COUNT=$(safe_read_json "$PATTERNS_FILE" "let c=0; for(const k in p.patterns){c+=p.patterns[k].length} console.log(c)" || echo "0")
+    CONFLICT_COUNT=$(safe_read_json "$PATTERNS_FILE" "console.log(p.conflicts ? p.conflicts.length : 0)" || echo "0")
+    FRAMEWORK=$(safe_read_json "$PATTERNS_FILE" "console.log(p.meta.framework || 'unknown')" || echo "unknown")
+
+    echo ""
+    echo -e "  ${GREEN}✓${NC} Detected: $FRAMEWORK"
+    echo -e "  ${GREEN}✓${NC} Extracted: $PATTERN_COUNT patterns"
+
+    # Handle conflicts
+    RESOLVED_FILE=""
+    if [ "$CONFLICT_COUNT" -gt 0 ]; then
+        echo -e "  ${YELLOW}!${NC} Found: $CONFLICT_COUNT conflicts"
+
+        if [ "$RESOLVE_CONFLICTS" = true ]; then
+            # Extract conflicts for resolver (using safe JSON parsing)
+            CONFLICTS_TEMP="$TEMP_DIR/conflicts.json"
+            safe_read_json "$PATTERNS_FILE" "console.log(JSON.stringify(p.conflicts, null, 2))" > "$CONFLICTS_TEMP"
+
+            echo ""
+            RESOLVED_FILE="$TEMP_DIR/resolved.json"
+
+            if ! node "$SCRIPT_DIR/flow-conflict-resolver.js" --input "$CONFLICTS_TEMP" --output "$RESOLVED_FILE"; then
+                echo -e "${YELLOW}Conflict resolution cancelled or skipped${NC}"
+                RESOLVED_FILE=""
+            fi
+        else
+            echo ""
+            echo -e "${DIM}Use --resolve-conflicts to interactively resolve conflicts${NC}"
+        fi
+    else
+        echo -e "  ${GREEN}✓${NC} No conflicts found"
+    fi
+
+    echo ""
+
+    # Dry run stops here
+    if [ "$DRY_RUN" = true ]; then
+        echo -e "${YELLOW}Dry run - patterns found:${NC}"
+        echo ""
+        safe_read_json "$PATTERNS_FILE" "
+            for (const category in p.patterns) {
+                console.log('  ' + category + ':');
+                for (const pattern of p.patterns[category] || []) {
+                    console.log('    - ' + pattern.name + ' (' + pattern.frequency + ' occurrences)');
+                }
+            }
+        " || true
+        rm -rf "$TEMP_DIR"
+        exit 0
+    fi
+
+    # Confirm import
+    if [ "$FORCE" != true ]; then
+        echo -e "${CYAN}Will import $PATTERN_COUNT patterns to:${NC}"
+        echo -e "  → .workflow/state/decisions.md"
+        echo -e "  → .claude/rules/ (auto-generated)"
+        echo ""
+        read -p "Import patterns? (y/N) " confirm
+        if [ "$confirm" != "y" ] && [ "$confirm" != "Y" ]; then
+            echo "Cancelled"
+            rm -rf "$TEMP_DIR"
+            exit 0
+        fi
+    fi
+
+    # Create backup if requested
+    if [ "$BACKUP" = true ]; then
+        BACKUP_DIR="wogi-backup-$(date +%Y%m%d-%H%M%S)"
+        mkdir -p "$BACKUP_DIR"
+        [ -f "$WORKFLOW_DIR/state/decisions.md" ] && cp "$WORKFLOW_DIR/state/decisions.md" "$BACKUP_DIR/"
+        [ -d ".claude/rules" ] && cp -r ".claude/rules" "$BACKUP_DIR/"
+        echo -e "${GREEN}✓${NC} Backup created: $BACKUP_DIR"
+        echo ""
+    fi
+
+    echo -e "${CYAN}Importing patterns...${NC}"
+    echo ""
+
+    # Generate decisions.md content from patterns (using safe JSON parsing)
+    mkdir -p "$WORKFLOW_DIR/state"
+
+    DECISIONS_CONTENT=$(safe_read_json "$PATTERNS_FILE" "
+        const lines = [];
+
+        lines.push('## Imported Patterns');
+        lines.push('Source: $SCAN_PATH');
+        lines.push('Imported: ' + new Date().toISOString().split('T')[0]);
+        lines.push('');
+
+        for (const category in p.patterns) {
+            lines.push('### ' + category.charAt(0).toUpperCase() + category.slice(1) + ' Patterns');
+            lines.push('');
+
+            for (const pattern of (p.patterns[category] || []).slice(0, 10)) {
+                lines.push('**' + pattern.subcategory + '**: ' + pattern.name);
+                if (pattern.examples && pattern.examples.length > 0) {
+                    lines.push('  Examples: \\\\\\\`' + pattern.examples.slice(0, 3).join('\\\\\\\`, \\\\\\\`') + '\\\\\\\`');
+                }
+                lines.push('');
+            }
+        }
+
+        console.log(lines.join('\\n'));
+    ")
+
+    if [ -f "$WORKFLOW_DIR/state/decisions.md" ]; then
+        echo "" >> "$WORKFLOW_DIR/state/decisions.md"
+        echo "---" >> "$WORKFLOW_DIR/state/decisions.md"
+        echo "" >> "$WORKFLOW_DIR/state/decisions.md"
+        echo "$DECISIONS_CONTENT" >> "$WORKFLOW_DIR/state/decisions.md"
+        echo -e "  ${GREEN}✓${NC} decisions.md ${DIM}(appended)${NC}"
+    else
+        echo "# Project Decisions" > "$WORKFLOW_DIR/state/decisions.md"
+        echo "" >> "$WORKFLOW_DIR/state/decisions.md"
+        echo "$DECISIONS_CONTENT" >> "$WORKFLOW_DIR/state/decisions.md"
+        echo -e "  ${GREEN}✓${NC} decisions.md ${DIM}(created)${NC}"
+    fi
+
+    # Generate rules from patterns
+    if [ -f "$SCRIPT_DIR/flow-rules-sync.js" ]; then
+        echo -e "  ${DIM}Syncing rules from patterns...${NC}"
+        node "$SCRIPT_DIR/flow-rules-sync.js" 2>/dev/null || true
+        echo -e "  ${GREEN}✓${NC} .claude/rules/"
+    fi
+
+    # Save extracted patterns for future reference
+    mkdir -p "$WORKFLOW_DIR/extracted"
+    cp "$PATTERNS_FILE" "$WORKFLOW_DIR/extracted/imported-patterns.json"
+
+    if [ -n "$RESOLVED_FILE" ] && [ -f "$RESOLVED_FILE" ]; then
+        cp "$RESOLVED_FILE" "$WORKFLOW_DIR/extracted/imported-resolutions.json"
+    fi
+
+    # Cleanup
+    rm -rf "$TEMP_DIR"
+
+    echo ""
+    echo -e "${GREEN}╔══════════════════════════════════════════════════════════╗${NC}"
+    echo -e "${GREEN}║  ✓ Patterns imported successfully!                       ║${NC}"
+    echo -e "${GREEN}╚══════════════════════════════════════════════════════════╝${NC}"
+    echo ""
+    echo -e "${DIM}Imported $PATTERN_COUNT patterns from $SCAN_PATH${NC}"
+    echo -e "${DIM}Restart Claude CLI to apply changes.${NC}"
+
+    exit 0
+fi
+
+# ==========================================
+# PROFILE MODE - Import from zip file
+# ==========================================
+
 # Check file exists
+if [ -z "$PROFILE_FILE" ]; then
+    echo -e "${RED}Error: No profile file specified${NC}"
+    echo -e "${DIM}Use --help for usage information${NC}"
+    exit 1
+fi
+
 if [ ! -f "$PROFILE_FILE" ]; then
     echo -e "${RED}Error: Profile file not found: $PROFILE_FILE${NC}"
     exit 1

package/scripts/flow-instruction-richness.js

@@ -28,6 +28,81 @@ try {
   // LSP module not available, will use fallback
 }
 
+// ============================================================
+// Model Context Preferences (from registry.json)
+// ============================================================
+
+/**
+ * Cache for model registry
+ */
+let registryCache = null;
+
+/**
+ * Load model registry from .workflow/models/registry.json
+ * @returns {Object|null} Registry data or null if not found
+ */
+function loadModelRegistry() {
+  if (registryCache) return registryCache;
+
+  const { PATHS } = require('./flow-utils');
+  const registryPath = path.join(path.dirname(PATHS.config), 'models', 'registry.json');
+
+  try {
+    if (fs.existsSync(registryPath)) {
+      const content = fs.readFileSync(registryPath, 'utf-8');
+      registryCache = JSON.parse(content);
+      return registryCache;
+    }
+  } catch (err) {
+    // Ignore errors, use defaults
+  }
+  return null;
+}
+
+/**
+ * Get model context preferences from registry
+ * @param {string} modelName - Model name (e.g., "claude-opus-4-5", "opus", "claude-sonnet-4")
+ * @returns {Object} Context preferences with defaults
+ */
+function getModelContextPreferences(modelName) {
+  const defaults = {
+    density: 'standard',
+    explicitExamples: true,
+    patternHints: true,
+    minContextForQuality: 0.5
+  };
+
+  if (!modelName) return defaults;
+
+  const registry = loadModelRegistry();
+  if (!registry?.models) return defaults;
+
+  // Normalize model name for lookup
+  const normalized = modelName.toLowerCase();
+
+  // Direct lookup first
+  if (registry.models[modelName]?.contextPreferences) {
+    return { ...defaults, ...registry.models[modelName].contextPreferences };
+  }
+
+  // Try partial matching (e.g., "opus" matches "claude-opus-4-5")
+  for (const [key, model] of Object.entries(registry.models)) {
+    if (normalized.includes(key) || key.includes(normalized)) {
+      if (model.contextPreferences) {
+        return { ...defaults, ...model.contextPreferences };
+      }
+    }
+    // Also try matching against modelId
+    if (model.modelId && (normalized.includes(model.modelId) || model.modelId.includes(normalized))) {
+      if (model.contextPreferences) {
+        return { ...defaults, ...model.contextPreferences };
+      }
+    }
+  }
+
+  return defaults;
+}
+
 // ============================================================
 // Instruction Richness Levels (Guidance, NOT Limits)
 // ============================================================
@@ -104,18 +179,52 @@ const COMPLEXITY_TO_RICHNESS = {
 /**
  * Gets the instruction richness configuration for a complexity level
  *
+ * Model-aware: Different models need different amounts of context:
+ * - Opus (concise): Can use minimal even for medium tasks
+ * - Sonnet (standard): Use default mapping
+ * - Haiku/Local (comprehensive): Needs rich even for small tasks
+ *
  * @param {string} complexityLevel - 'small', 'medium', 'large', or 'xl'
  * @param {Object} config - Optional config overrides from config.json
+ * @param {string} model - Optional model name for model-aware richness
  * @returns {Object} - Richness configuration
  */
-function getInstructionRichness(complexityLevel, config = {}) {
-  // Map complexity to richness level
+function getInstructionRichness(complexityLevel, config = {}, model = null) {
+  // Map complexity to base richness level
   let richnessLevel = COMPLEXITY_TO_RICHNESS[complexityLevel] || 'standard';
+  const levels = ['minimal', 'standard', 'rich', 'maximum'];
+
+  // Model-aware adjustment
+  if (model) {
+    const modelPrefs = getModelContextPreferences(model);
+
+    if (modelPrefs.density === 'concise') {
+      // Opus: Can use less context - downgrade one level (but not below minimal)
+      // small → minimal (already minimal)
+      // medium → minimal (was standard)
+      // large → standard (was rich)
+      // xl → rich (was maximum)
+      const currentIndex = levels.indexOf(richnessLevel);
+      if (currentIndex > 0) {
+        richnessLevel = levels[currentIndex - 1];
+      }
+    } else if (modelPrefs.density === 'comprehensive') {
+      // Local LLM / Haiku: Needs more context - upgrade one level (but not above maximum)
+      // small → standard (was minimal)
+      // medium → rich (was standard)
+      // large → maximum (was rich)
+      // xl → maximum (already maximum)
+      const currentIndex = levels.indexOf(richnessLevel);
+      if (currentIndex < levels.length - 1) {
+        richnessLevel = levels[currentIndex + 1];
+      }
+    }
+    // 'standard' density uses default mapping
+  }
 
   // Check for minimum richness override in config
   const minRichness = config.minRichness;
   if (minRichness) {
-    const levels = ['minimal', 'standard', 'rich', 'maximum'];
     const currentIndex = levels.indexOf(richnessLevel);
     const minIndex = levels.indexOf(minRichness);
     if (minIndex > currentIndex) {
@@ -125,8 +234,13 @@ function getInstructionRichness(complexityLevel, config = {}) {
 
   const richness = { ...INSTRUCTION_RICHNESS[richnessLevel] };
 
-  // Add level name for reference
+  // Add level name and model info for reference
   richness.level = richnessLevel;
+  if (model) {
+    const modelPrefs = getModelContextPreferences(model);
+    richness.modelDensity = modelPrefs.density;
+    richness.patternHintsOnly = modelPrefs.patternHints && !modelPrefs.explicitExamples;
+  }
 
   return richness;
 }
@@ -145,17 +259,26 @@ function loadProjectContext(projectRoot) {
   let context = '';
 
   // Try hybrid-context first (optimized for hybrid mode)
+  // Use try-catch even after existsSync (race conditions, permissions)
   if (fs.existsSync(contextPath)) {
-    context += fs.readFileSync(contextPath, 'utf-8');
+    try {
+      context += fs.readFileSync(contextPath, 'utf-8');
+    } catch (err) {
+      // File may have been deleted/modified between check and read
+    }
   }
 
   // Add project overview
   if (fs.existsSync(projectPath)) {
-    const projectMd = fs.readFileSync(projectPath, 'utf-8');
-    // Extract just the summary section
-    const summaryMatch = projectMd.match(/## Summary[\s\S]*?(?=##|$)/);
-    if (summaryMatch) {
-      context += '\n\n### Project Summary\n' + summaryMatch[0];
+    try {
+      const projectMd = fs.readFileSync(projectPath, 'utf-8');
+      // Extract just the summary section
+      const summaryMatch = projectMd.match(/## Summary[\s\S]*?(?=##|$)/);
+      if (summaryMatch) {
+        context += '\n\n### Project Summary\n' + summaryMatch[0];
+      }
+    } catch (err) {
+      // File may have been deleted/modified between check and read
     }
   }
 
@@ -173,7 +296,13 @@ function loadPatterns(projectRoot) {
     return null;
   }
 
-  const content = fs.readFileSync(decisionsPath, 'utf-8');
+  let content;
+  try {
+    content = fs.readFileSync(decisionsPath, 'utf-8');
+  } catch (err) {
+    // File may have been deleted/modified between check and read
+    return null;
+  }
 
   // Extract ALL ## sections from decisions.md
   // This includes: Naming Conventions, File Structure, Error Handling, etc.
@@ -310,7 +439,13 @@ async function loadRelevantTypesWithLSP(projectRoot, filePath, options = {}) {
     // If we have a target file, extract identifiers and get their types
     const absPath = path.isAbsolute(filePath) ? filePath : path.join(projectRoot, filePath);
     if (fs.existsSync(absPath)) {
-      const content = fs.readFileSync(absPath, 'utf-8');
+      let content;
+      try {
+        content = fs.readFileSync(absPath, 'utf-8');
+      } catch (err) {
+        // File may have been deleted/modified between check and read
+        return loadRelevantTypes(projectRoot, filePath, options);
+      }
       const identifiers = extractIdentifiersForLSP(content, keywords);
 
       // Get types for identified positions
@@ -759,6 +894,9 @@ module.exports = {
   COMPLEXITY_TO_RICHNESS,
   getInstructionRichness,
   getVerbosityGuidance,
+  // Model-aware context
+  getModelContextPreferences,
+  loadModelRegistry,
   // Context loaders
   loadProjectContext,
   loadPatterns,
@@ -781,26 +919,41 @@ if (require.main === module) {
 
   if (args.length === 0) {
     console.log(`
-Usage: node flow-instruction-richness.js <complexity-level>
+Usage: node flow-instruction-richness.js <complexity-level> [model]
 
 Complexity levels: small, medium, large, xl
+Model (optional): claude-opus-4-5, claude-sonnet-4, claude-haiku-3-5, etc.
+
+Model-Aware Context Density:
+  - opus (concise):        Uses less context, can infer from hints
+  - sonnet (standard):     Default context levels
+  - haiku/local (comprehensive): Uses more context, needs explicit examples
 
 Examples:
   node flow-instruction-richness.js small
-  node flow-instruction-richness.js large
+  node flow-instruction-richness.js medium claude-opus-4-5
+  node flow-instruction-richness.js medium claude-haiku-3-5
 `);
     process.exit(0);
   }
 
   const level = args[0];
-  const richness = getInstructionRichness(level);
+  const model = args[1] || null;
+  const richness = getInstructionRichness(level, {}, model);
 
   console.log('\n═══════════════════════════════════════════════════════════');
-  console.log('     INSTRUCTION RICHNESS CONFIG (Local LLM is FREE!)');
+  console.log('     INSTRUCTION RICHNESS CONFIG (Model-Aware)');
   console.log('═══════════════════════════════════════════════════════════\n');
 
   console.log(`Complexity Level: ${level.toUpperCase()}`);
   console.log(`Richness Level: ${richness.level.toUpperCase()}`);
+  if (model) {
+    console.log(`Model: ${model}`);
+    console.log(`Model Density: ${richness.modelDensity || 'standard'}`);
+    if (richness.patternHintsOnly) {
+      console.log(`Pattern Mode: Hints only (no explicit examples needed)`);
+    }
+  }
   console.log(`\n${richness.description}\n`);
 
   console.log('───────────────────────────────────────────────────────────');
@@ -821,7 +974,18 @@ Examples:
   console.log('───────────────────────────────────────────────────────────');
   console.log(getVerbosityGuidance(richness.templateVerbosity));
 
-  console.log('\n💡 Remember: Local LLM tokens are FREE! Include MORE context');
-  console.log('   when in doubt. Failed executions cost more than extra context.\n');
+  if (model) {
+    const prefs = getModelContextPreferences(model);
+    console.log('\n───────────────────────────────────────────────────────────');
+    console.log('              MODEL PREFERENCES');
+    console.log('───────────────────────────────────────────────────────────');
+    console.log(`  Density: ${prefs.density}`);
+    console.log(`  Explicit Examples: ${prefs.explicitExamples ? 'Yes' : 'No'}`);
+    console.log(`  Pattern Hints: ${prefs.patternHints ? 'Yes' : 'No'}`);
+    console.log(`  Min Context for Quality: ${(prefs.minContextForQuality * 100).toFixed(0)}%`);
+  }
+
+  console.log('\n💡 Model-aware context: Each model gets the right amount of');
+  console.log('   context for optimal quality without waste.\n');
   console.log('═══════════════════════════════════════════════════════════\n');
 }

package/scripts/flow-knowledge-router.js

@@ -3,6 +3,8 @@
 /**
  * Wogi Flow - Knowledge Router
  *
+ * See MEMORY-ARCHITECTURE.md for how this fits with other memory/knowledge modules.
+ *
  * Auto-detects where learnings/corrections should be stored:
  * - model-specific: Applies only to a specific LLM
  * - skill: Related to a specific skill (nestjs, react, etc.)

package/scripts/flow-knowledge-sync.js

@@ -3,6 +3,8 @@
 /**
  * Wogi Flow - Knowledge Sync
  *
+ * See MEMORY-ARCHITECTURE.md for how this fits with other memory/knowledge modules.
+ *
  * Detects drift in knowledge files (stack.md, architecture.md, testing.md)
  * by tracking hashes of project indicator files.
  *

package/scripts/{flow-transcript-chunking.js → flow-long-input-chunking.js}

@@ -35,9 +35,11 @@ function loadActiveDigest() { requireInit(); return digestCore.loadActiveDigest(
 function saveActiveDigest(d) { requireInit(); return digestCore.saveActiveDigest(d); }
 function countWords(t) { requireInit(); return digestCore.countWords(t); }
 function now() { requireInit(); return digestCore.now(); }
+function measureInputMetrics(t) { requireInit(); return digestCore.measureInputMetrics(t); }
 
-// Paths
-const STATE_DIR = path.join(process.cwd(), '.workflow', 'state', 'digests');
+// Paths - temp processing files, cleaned up after completion
+const TMP_DIR = path.join(process.cwd(), '.workflow', 'tmp', 'long-input');
+const STATE_DIR = TMP_DIR; // Alias for backward compatibility
 
 // ==========================================================================
 // E5-S3: Durable Digest Session Persistence

package/scripts/{flow-transcript-parsing.js → flow-long-input-parsing.js}

@@ -34,6 +34,41 @@ const SRT_TIMESTAMP = /(\d{2}):(\d{2}):(\d{2}),(\d{3})\s*-->\s*(\d{2}):(\d{2}):(
 const SPEAKER_COLON_PATTERN = /^([A-Z][a-zA-Z\s]+):\s*/;
 const SPEAKER_BRACKET_PATTERN = /^\[([^\]]+)\]\s*/;
 
+/**
+ * Simple word counter utility
+ */
+function countWords(text) {
+  return text.split(/\s+/).filter(w => w.length > 0).length;
+}
+
+/**
+ * Detect VTT format
+ */
+function isVTTFormat(text) {
+  // Check for WEBVTT header
+  if (text.trim().startsWith('WEBVTT')) {
+    return { detected: true, confidence: 0.95 };
+  }
+  // Check for VTT timestamps
+  const timestamps = text.match(VTT_TIMESTAMP_FULL) || text.match(VTT_TIMESTAMP_SHORT);
+  if (timestamps) {
+    return { detected: true, confidence: 0.85 };
+  }
+  return { detected: false, confidence: 0 };
+}
+
+/**
+ * Detect SRT format
+ */
+function isSRTFormat(text) {
+  const timestamps = text.match(SRT_TIMESTAMP);
+  const cueNumbers = text.match(/^\d+\s*$/m);
+  if (timestamps && cueNumbers) {
+    return { detected: true, confidence: 0.9 };
+  }
+  return { detected: false, confidence: 0 };
+}
+
 /**
  * Convert timestamp to milliseconds
  */