extractSignals()

function extractSignals({ recentSessionTranscript, todayLog, memorySnippet, userSnippet, recentEvents })

// Refined error detection regex
var errorHit = /\[error\]|error:|exception:|iserror":true|"status":\s*"error"|错误\s*[：:]|异常\s*[：:]/.test(lower);
if (errorHit) signals.push('log_error');

// Error signature for reproducibility
var errLine = lines.find(l => /\b(typeerror|referenceerror|syntaxerror)\b\s*:|error\s*:/i.test(l));
if (errLine) {
  var clipped = errLine.replace(/\s+/g, ' ').slice(0, 260);
  signals.push('errsig:' + clipped);
}

var errorCounts = {};
var errPatterns = corpus.match(/(?:LLM error|"error"|"status":\s*"error")[^}]{0,200}/gi) || [];
for (var ep of errPatterns) {
  var key = ep.replace(/\s+/g, ' ').slice(0, 100);
  errorCounts[key] = (errorCounts[key] || 0) + 1;
}

var recurringErrors = Object.entries(errorCounts).filter(e => e[1] >= 3);
if (recurringErrors.length > 0) {
  signals.push('recurring_error');
  var topErr = recurringErrors.sort((a, b) => b[1] - a[1])[0];
  signals.push('recurring_errsig(' + topErr[1] + 'x):' + topErr[0].slice(0, 150));
}

const OPPORTUNITY_SIGNALS = [
  'user_feature_request',
  'user_improvement_suggestion',
  'perf_bottleneck',
  'capability_gap',
  'stable_success_plateau',
  'external_opportunity',
  'recurring_error',
  'unsupported_input_type',
  'evolution_stagnation_detected',
  'repair_loop_detected',
  'force_innovation_after_repair_loop',
];

// English
var featEn = corpus.match(/\b(add|implement|create|build|make)\b[^.?!\n]{3,120}\b(feature|function|module|capability)\b/i);
if (featEn) featureRequestSnippet = featEn[0].trim().slice(0, 200);

// Chinese (Simplified)
if (/加个|实现一下|做个|想要\s*一个/.test(corpus)) {
  var featZh = corpus.match(/.{0,100}(加个|实现一下|做个|想要\s*一个).{0,100}/);
  if (featZh) featureRequestSnippet = featZh[0].trim().slice(0, 200);
}

// Chinese (Traditional)
if (/加個|實現一下|做個|想要一個/.test(corpus)) {
  var featTw = corpus.match(/.{0,100}(加個|實現一下|做個|想要一個).{0,100}/);
}

// Japanese
if (/追加|実装|作って|機能を/.test(corpus)) {
  var featJa = corpus.match(/.{0,100}(追加|実装|作って|機能を).{0,100}/);
}

if (featureRequestSnippet) {
  signals.push('user_feature_request:' + featureRequestSnippet);
}

if (!errorHit) {
  var impEn = corpus.match(/.{0,80}\b(should be|could be better|improve|enhance|refactor)\b.{0,80}/i);
  if (impEn) improvementSnippet = impEn[0].trim().slice(0, 200);
  
  if (!improvementSnippet && /改进一下|优化一下|简化|重构/.test(corpus)) {
    var impZh = corpus.match(/.{0,100}(改进一下|优化一下|简化|重构).{0,100}/);
  }
  
  if (improvementSnippet) {
    signals.push('user_improvement_suggestion:' + improvementSnippet);
  }
}

var toolUsage = {};
var toolMatches = corpus.match(/\[TOOL:\s*([\w-]+)\]/g) || [];

// Extract exec commands to identify benign loops
var execCommands = corpus.match(/exec: (node\s+[\w\/\.-]+\.js\s+ensure)/g) || [];
var benignExecCount = execCommands.length;

for (var toolMatch of toolMatches) {
  var toolName = toolMatch.match(/\[TOOL:\s*([\w-]+)\]/)[1];
  toolUsage[toolName] = (toolUsage[toolName] || 0) + 1;
}

// Adjust exec count by subtracting benign commands
if (toolUsage['exec']) {
  toolUsage['exec'] = Math.max(0, toolUsage['exec'] - benignExecCount);
}

Object.keys(toolUsage).forEach(tool => {
  if (toolUsage[tool] >= 10) {
    signals.push('high_tool_usage:' + tool);
  }
  if (tool === 'exec' && toolUsage[tool] >= 5) {
    signals.push('repeated_tool_usage:exec');
  }
});

function analyzeRecentHistory(recentEvents) {
  var recent = recentEvents.slice(-10);
  var signalFreq = {};
  var tail = recent.slice(-8);
  
  for (var evt of tail) {
    var sigs = Array.isArray(evt.signals) ? evt.signals : [];
    for (var s of sigs) {
      // Normalize: strip details suffix
      var key = s.startsWith('errsig:') ? 'errsig'
        : s.startsWith('user_feature_request:') ? 'user_feature_request'
        : s;
      signalFreq[key] = (signalFreq[key] || 0) + 1;
    }
  }
  
  // Suppress signals that appeared in 3+ of the last 8 events
  var suppressedSignals = new Set();
  for (var [sig, count] of Object.entries(signalFreq)) {
    if (count >= 3) suppressedSignals.add(sig);
  }
  
  return { suppressedSignals, recentIntents, consecutiveRepairCount };
}

if (history.suppressedSignals.size > 0) {
  var beforeDedup = signals.length;
  signals = signals.filter(s => {
    var key = s.startsWith('errsig:') ? 'errsig'
      : s.startsWith('user_feature_request:') ? 'user_feature_request'
      : s;
    return !history.suppressedSignals.has(key);
  });
  
  if (beforeDedup > 0 && signals.length === 0) {
    // All signals were suppressed = system is stable but stuck in a loop
    signals.push('evolution_stagnation_detected');
    signals.push('stable_success_plateau');
  }
}

if (history.consecutiveRepairCount >= 3) {
  // Remove repair-only signals and inject innovation signals
  signals = signals.filter(s =>
    s !== 'log_error' && !s.startsWith('errsig:') && !s.startsWith('recurring_errsig')
  );
  if (signals.length === 0) {
    signals.push('repair_loop_detected');
    signals.push('stable_success_plateau');
  }
  signals.push('force_innovation_after_repair_loop');
}

if (history.emptyCycleCount >= 4) {
  signals = signals.filter(s =>
    s !== 'log_error' && !s.startsWith('errsig:')
  );
  if (!signals.includes('empty_cycle_loop_detected')) {
    signals.push('empty_cycle_loop_detected');
  }
  if (!signals.includes('stable_success_plateau')) {
    signals.push('stable_success_plateau');
  }
}

// When consecutive empty cycles pile up, signal graceful degradation
if (history.consecutiveEmptyCycles >= 5) {
  signals.push('force_steady_state');
  signals.push('evolution_saturation');
} else if (history.consecutiveEmptyCycles >= 3) {
  signals.push('evolution_saturation');
}

const signals = extractSignals({
  recentSessionTranscript: readRealSessionLog(),
  todayLog: readRecentLog(TODAY_LOG),
  memorySnippet: readMemorySnippet(),
  userSnippet: readUserSnippet(),
  recentEvents: readAllEvents().slice(-80),
});

console.log('Extracted signals:', signals);
// Output: ['log_error', 'errsig:TypeError: Cannot read property...', 'user_feature_request:add image support']