@evomap/evolver 1.28.1

package/src/gep/hubReview.js

@@ -0,0 +1,206 @@
+// Hub Asset Review: submit usage-verified reviews after solidify.
+//
+// When an evolution cycle reuses a Hub asset (source_type = 'reused' or 'reference'),
+// we submit a review to POST /a2a/assets/:assetId/reviews after solidify completes.
+// Rating is derived from outcome: success -> 4-5, failure -> 1-2.
+// Reviews are non-blocking; errors never affect the solidify result.
+// Duplicate prevention: a local file tracks reviewed assetIds to avoid re-reviewing.
+
+const fs = require('fs');
+const path = require('path');
+const { getNodeId, getHubNodeSecret } = require('./a2aProtocol');
+const { logAssetCall } = require('./assetCallLog');
+
+const REVIEW_HISTORY_FILE = path.join(
+  require('./paths').getEvolutionDir(),
+  'hub_review_history.json'
+);
+
+const REVIEW_HISTORY_MAX_ENTRIES = 500;
+
+function _loadReviewHistory() {
+  try {
+    if (!fs.existsSync(REVIEW_HISTORY_FILE)) return {};
+    const raw = fs.readFileSync(REVIEW_HISTORY_FILE, 'utf8');
+    if (!raw.trim()) return {};
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+
+function _saveReviewHistory(history) {
+  try {
+    const dir = path.dirname(REVIEW_HISTORY_FILE);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    const keys = Object.keys(history);
+    if (keys.length > REVIEW_HISTORY_MAX_ENTRIES) {
+      const sorted = keys
+        .map(k => ({ k, t: history[k].at || 0 }))
+        .sort((a, b) => a.t - b.t);
+      const toRemove = sorted.slice(0, keys.length - REVIEW_HISTORY_MAX_ENTRIES);
+      for (const entry of toRemove) delete history[entry.k];
+    }
+    const tmp = REVIEW_HISTORY_FILE + '.tmp';
+    fs.writeFileSync(tmp, JSON.stringify(history, null, 2) + '\n', 'utf8');
+    fs.renameSync(tmp, REVIEW_HISTORY_FILE);
+  } catch {}
+}
+
+function _alreadyReviewed(assetId) {
+  const history = _loadReviewHistory();
+  return !!history[assetId];
+}
+
+function _markReviewed(assetId, rating, success) {
+  const history = _loadReviewHistory();
+  history[assetId] = { at: Date.now(), rating, success };
+  _saveReviewHistory(history);
+}
+
+function _deriveRating(outcome, constraintCheck) {
+  if (outcome && outcome.status === 'success') {
+    const score = Number(outcome.score) || 0;
+    return score >= 0.85 ? 5 : 4;
+  }
+  const hasConstraintViolation =
+    constraintCheck &&
+    Array.isArray(constraintCheck.violations) &&
+    constraintCheck.violations.length > 0;
+  return hasConstraintViolation ? 1 : 2;
+}
+
+function _buildReviewContent({ outcome, gene, signals, blast, sourceType }) {
+  const parts = [];
+  const status = outcome && outcome.status ? outcome.status : 'unknown';
+  const score = outcome && Number.isFinite(Number(outcome.score))
+    ? Number(outcome.score).toFixed(2) : '?';
+
+  parts.push('Outcome: ' + status + ' (score: ' + score + ')');
+  parts.push('Reuse mode: ' + (sourceType || 'unknown'));
+
+  if (gene && gene.id) {
+    parts.push('Gene: ' + gene.id + ' (' + (gene.category || 'unknown') + ')');
+  }
+
+  if (Array.isArray(signals) && signals.length > 0) {
+    parts.push('Signals: ' + signals.slice(0, 6).join(', '));
+  }
+
+  if (blast) {
+    parts.push('Blast radius: ' + (blast.files || 0) + ' file(s), ' + (blast.lines || 0) + ' line(s)');
+  }
+
+  if (status === 'success') {
+    parts.push('The fetched asset was successfully applied and solidified.');
+  } else {
+    parts.push('The fetched asset did not lead to a successful evolution cycle.');
+  }
+
+  return parts.join('\n').slice(0, 2000);
+}
+
+function getHubUrl() {
+  return (process.env.A2A_HUB_URL || '').replace(/\/+$/, '');
+}
+
+async function submitHubReview({
+  reusedAssetId,
+  sourceType,
+  outcome,
+  gene,
+  signals,
+  blast,
+  constraintCheck,
+  runId,
+}) {
+  var hubUrl = getHubUrl();
+  if (!hubUrl) return { submitted: false, reason: 'no_hub_url' };
+
+  if (!reusedAssetId || typeof reusedAssetId !== 'string') {
+    return { submitted: false, reason: 'no_reused_asset_id' };
+  }
+
+  if (sourceType !== 'reused' && sourceType !== 'reference') {
+    return { submitted: false, reason: 'not_hub_sourced' };
+  }
+
+  if (_alreadyReviewed(reusedAssetId)) {
+    return { submitted: false, reason: 'already_reviewed' };
+  }
+
+  var rating = _deriveRating(outcome, constraintCheck);
+  var content = _buildReviewContent({ outcome, gene, signals, blast, sourceType });
+  var senderId = getNodeId();
+
+  var endpoint = hubUrl + '/a2a/assets/' + encodeURIComponent(reusedAssetId) + '/reviews';
+
+  var headers = { 'Content-Type': 'application/json', 'Accept': 'application/json' };
+  var secret = getHubNodeSecret();
+  if (secret) {
+    headers['Authorization'] = 'Bearer ' + secret;
+  }
+
+  var body = JSON.stringify({
+    sender_id: senderId,
+    rating: rating,
+    content: content,
+  });
+
+  try {
+    var controller = new AbortController();
+    var timer = setTimeout(function () { controller.abort('hub_review_timeout'); }, 10000);
+
+    var res = await fetch(endpoint, {
+      method: 'POST',
+      headers: headers,
+      body: body,
+      signal: controller.signal,
+    });
+    clearTimeout(timer);
+
+    if (res.ok) {
+      _markReviewed(reusedAssetId, rating, true);
+      console.log(
+        '[HubReview] Submitted review for ' + reusedAssetId + ': rating=' + rating + ', outcome=' + (outcome && outcome.status)
+      );
+      logAssetCall({
+        run_id: runId || null,
+        action: 'hub_review_submitted',
+        asset_id: reusedAssetId,
+        extra: { rating: rating, outcome_status: outcome && outcome.status },
+      });
+      return { submitted: true, rating: rating, asset_id: reusedAssetId };
+    }
+
+    var errData = await res.json().catch(function () { return {}; });
+    var errCode = errData.error || errData.code || ('http_' + res.status);
+
+    if (errCode === 'already_reviewed') {
+      _markReviewed(reusedAssetId, rating, false);
+    }
+
+    console.log('[HubReview] Hub rejected review for ' + reusedAssetId + ': ' + errCode);
+    logAssetCall({
+      run_id: runId || null,
+      action: 'hub_review_rejected',
+      asset_id: reusedAssetId,
+      extra: { rating: rating, error: errCode },
+    });
+    return { submitted: false, reason: errCode, rating: rating };
+  } catch (err) {
+    var reason = err.name === 'AbortError' ? 'timeout' : 'fetch_error';
+    console.log('[HubReview] Failed (non-fatal, ' + reason + '): ' + err.message);
+    logAssetCall({
+      run_id: runId || null,
+      action: 'hub_review_failed',
+      asset_id: reusedAssetId,
+      extra: { rating: rating, reason: reason, error: err.message },
+    });
+    return { submitted: false, reason: reason, error: err.message };
+  }
+}
+
+module.exports = {
+  submitHubReview,
+};

package/src/gep/hubSearch.js

@@ -0,0 +1,237 @@
+// Hub Search-First Evolution: query evomap-hub for reusable solutions before local solve.
+//
+// Flow: extractSignals() -> hubSearch(signals) -> if hit: reuse; if miss: normal evolve
+// Two modes: direct (skip local reasoning) | reference (inject into prompt as strong hint)
+//
+// Two-phase search-then-fetch to minimize credit cost:
+//   Phase 1: POST /a2a/fetch with signals + search_only=true (free, metadata only)
+//   Phase 2: POST /a2a/fetch with asset_ids=[selected] (pays for 1 asset only)
+
+const { getNodeId, buildFetch, getHubNodeSecret } = require('./a2aProtocol');
+const { logAssetCall } = require('./assetCallLog');
+
+const DEFAULT_MIN_REUSE_SCORE = 0.72;
+const DEFAULT_REUSE_MODE = 'reference'; // 'direct' | 'reference'
+const MAX_STREAK_CAP = 5;
+const TIMEOUT_REASON = 'hub_search_timeout';
+
+function getHubUrl() {
+  return (process.env.A2A_HUB_URL || '').replace(/\/+$/, '');
+}
+
+function getReuseMode() {
+  const m = String(process.env.EVOLVER_REUSE_MODE || DEFAULT_REUSE_MODE).toLowerCase();
+  return m === 'direct' ? 'direct' : 'reference';
+}
+
+function getMinReuseScore() {
+  const n = Number(process.env.EVOLVER_MIN_REUSE_SCORE);
+  return Number.isFinite(n) && n > 0 ? n : DEFAULT_MIN_REUSE_SCORE;
+}
+
+/**
+ * Score a hub asset for local reuse quality.
+ * rank = confidence * min(max(success_streak, 1), MAX_STREAK_CAP) * (reputation / 100)
+ * Streak is capped to prevent unbounded score inflation.
+ */
+function scoreHubResult(asset) {
+  const confidence = Number(asset.confidence) || 0;
+  const streak = Math.min(Math.max(Number(asset.success_streak) || 0, 1), MAX_STREAK_CAP);
+  const repRaw = Number(asset.reputation_score);
+  const reputation = Number.isFinite(repRaw) ? repRaw : 50;
+  return confidence * streak * (reputation / 100);
+}
+
+/**
+ * Pick the best matching asset above the threshold.
+ * Returns { match, score, mode } or null if nothing qualifies.
+ */
+function pickBestMatch(results, threshold) {
+  if (!Array.isArray(results) || results.length === 0) return null;
+
+  let best = null;
+  let bestScore = 0;
+
+  for (const asset of results) {
+    if (asset.status && asset.status !== 'promoted') continue;
+    const s = scoreHubResult(asset);
+    if (s > bestScore) {
+      bestScore = s;
+      best = asset;
+    }
+  }
+
+  if (!best || bestScore < threshold) return null;
+
+  return {
+    match: best,
+    score: Math.round(bestScore * 1000) / 1000,
+    mode: getReuseMode(),
+  };
+}
+
+/**
+ * Search the hub for reusable assets matching the given signals.
+ *
+ * Two-phase flow to minimize credit cost:
+ *   Phase 1: search_only=true -> get candidate metadata (free, no credit cost)
+ *   Phase 2: asset_ids=[best_match] -> fetch full payload for the selected asset only
+ *
+ * Falls back to single-call fetch (old behavior) if search_only is not supported.
+ * Returns { hit: true, match, score, mode } or { hit: false }.
+ */
+async function hubSearch(signals, opts) {
+  const hubUrl = getHubUrl();
+  if (!hubUrl) return { hit: false, reason: 'no_hub_url' };
+
+  const signalList = Array.isArray(signals)
+    ? signals.map(s => typeof s === 'string' ? s.trim() : '').filter(Boolean)
+    : [];
+  if (signalList.length === 0) return { hit: false, reason: 'no_signals' };
+
+  const threshold = (opts && Number.isFinite(opts.threshold)) ? opts.threshold : getMinReuseScore();
+  const timeout = (opts && Number.isFinite(opts.timeoutMs)) ? opts.timeoutMs : 8000;
+
+  try {
+    // Phase 1: search_only to get candidate metadata (free)
+    const searchMsg = buildFetch({ signals: signalList, searchOnly: true });
+    const endpoint = hubUrl + '/a2a/fetch';
+
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(TIMEOUT_REASON), timeout);
+
+    const headers = { 'Content-Type': 'application/json', 'Accept': 'application/json' };
+    const secret = getHubNodeSecret();
+    if (secret) {
+      headers['Authorization'] = 'Bearer ' + secret;
+    } else {
+      const token = process.env.A2A_HUB_TOKEN;
+      if (token) headers['Authorization'] = `Bearer ${token}`;
+    }
+
+    const res = await fetch(endpoint, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(searchMsg),
+      signal: controller.signal,
+    });
+    clearTimeout(timer);
+
+    if (!res.ok) {
+      logAssetCall({
+        run_id: (opts && opts.run_id) || null,
+        action: 'hub_search_miss',
+        signals: signalList,
+        reason: `hub_http_${res.status}`,
+        via: 'search_then_fetch',
+      });
+      return { hit: false, reason: `hub_http_${res.status}` };
+    }
+
+    const data = await res.json();
+    const results = (data && data.payload && Array.isArray(data.payload.results))
+      ? data.payload.results
+      : [];
+
+    if (results.length === 0) {
+      logAssetCall({
+        run_id: (opts && opts.run_id) || null,
+        action: 'hub_search_miss',
+        signals: signalList,
+        reason: 'no_results',
+        via: 'search_then_fetch',
+      });
+      return { hit: false, reason: 'no_results' };
+    }
+
+    const pick = pickBestMatch(results, threshold);
+    if (!pick) {
+      logAssetCall({
+        run_id: (opts && opts.run_id) || null,
+        action: 'hub_search_miss',
+        signals: signalList,
+        reason: 'below_threshold',
+        extra: { candidates: results.length, threshold },
+        via: 'search_then_fetch',
+      });
+      return { hit: false, reason: 'below_threshold', candidates: results.length };
+    }
+
+    // Phase 2: fetch full payload for the selected asset only (pays for 1 asset)
+    const selectedAssetId = pick.match.asset_id;
+    if (selectedAssetId) {
+      try {
+        const fetchMsg = buildFetch({ assetIds: [selectedAssetId] });
+        const controller2 = new AbortController();
+        const timer2 = setTimeout(() => controller2.abort(TIMEOUT_REASON), timeout);
+
+        const res2 = await fetch(endpoint, {
+          method: 'POST',
+          headers,
+          body: JSON.stringify(fetchMsg),
+          signal: controller2.signal,
+        });
+        clearTimeout(timer2);
+
+        if (res2.ok) {
+          const data2 = await res2.json();
+          const fullResults = (data2 && data2.payload && Array.isArray(data2.payload.results))
+            ? data2.payload.results
+            : [];
+          if (fullResults.length > 0) {
+            pick.match = { ...pick.match, ...fullResults[0] };
+          }
+        }
+      } catch (fetchErr) {
+        console.log(`[HubSearch] Phase 2 fetch failed (non-fatal): ${fetchErr.message}`);
+      }
+    }
+
+    console.log(`[HubSearch] Hit via search+fetch: ${pick.match.asset_id || 'unknown'} (score=${pick.score}, mode=${pick.mode})`);
+
+    logAssetCall({
+      run_id: (opts && opts.run_id) || null,
+      action: 'hub_search_hit',
+      asset_id: pick.match.asset_id || null,
+      asset_type: pick.match.asset_type || pick.match.type || null,
+      source_node_id: pick.match.source_node_id || null,
+      chain_id: pick.match.chain_id || null,
+      score: pick.score,
+      mode: pick.mode,
+      signals: signalList,
+      via: 'search_then_fetch',
+    });
+
+    return {
+      hit: true,
+      match: pick.match,
+      score: pick.score,
+      mode: pick.mode,
+      asset_id: pick.match.asset_id || null,
+      source_node_id: pick.match.source_node_id || null,
+      chain_id: pick.match.chain_id || null,
+    };
+  } catch (err) {
+    const isTimeout = err.name === 'AbortError' || (err.cause && err.cause === TIMEOUT_REASON);
+    const reason = isTimeout ? 'timeout' : 'fetch_error';
+    console.log(`[HubSearch] Failed (non-fatal, ${reason}): ${err.message}`);
+    logAssetCall({
+      run_id: (opts && opts.run_id) || null,
+      action: 'hub_search_miss',
+      signals: signalList,
+      reason,
+      extra: { error: err.message },
+      via: 'search_then_fetch',
+    });
+    return { hit: false, reason, error: err.message };
+  }
+}
+
+module.exports = {
+  hubSearch,
+  scoreHubResult,
+  pickBestMatch,
+  getReuseMode,
+  getMinReuseScore,
+  getHubUrl,
+};

package/src/gep/issueReporter.js

@@ -0,0 +1,262 @@
+// Automatic GitHub issue reporter for recurring evolver failures.
+// When the evolver hits persistent errors (failure streaks, recurring errors),
+// this module files a GitHub issue with sanitized logs and environment info.
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { getEvolutionDir } = require('./paths');
+const { captureEnvFingerprint } = require('./envFingerprint');
+const { redactString } = require('./sanitize');
+const { getNodeId } = require('./a2aProtocol');
+
+const STATE_FILE_NAME = 'issue_reporter_state.json';
+const DEFAULT_REPO = 'autogame-17/capability-evolver';
+const DEFAULT_COOLDOWN_MS = 24 * 60 * 60 * 1000;
+const DEFAULT_MIN_STREAK = 5;
+const MAX_LOG_CHARS = 2000;
+const MAX_EVENTS = 5;
+
+function getConfig() {
+  var enabled = String(process.env.EVOLVER_AUTO_ISSUE || 'true').toLowerCase();
+  if (enabled === 'false' || enabled === '0') return null;
+  return {
+    repo: process.env.EVOLVER_ISSUE_REPO || DEFAULT_REPO,
+    cooldownMs: Number(process.env.EVOLVER_ISSUE_COOLDOWN_MS) || DEFAULT_COOLDOWN_MS,
+    minStreak: Number(process.env.EVOLVER_ISSUE_MIN_STREAK) || DEFAULT_MIN_STREAK,
+  };
+}
+
+function getGithubToken() {
+  return process.env.GITHUB_TOKEN || process.env.GH_TOKEN || process.env.GITHUB_PAT || '';
+}
+
+function getStatePath() {
+  return path.join(getEvolutionDir(), STATE_FILE_NAME);
+}
+
+function readState() {
+  try {
+    var p = getStatePath();
+    if (fs.existsSync(p)) {
+      return JSON.parse(fs.readFileSync(p, 'utf8'));
+    }
+  } catch (_) {}
+  return { lastReportedAt: null, recentIssueKeys: [] };
+}
+
+function writeState(state) {
+  try {
+    var dir = getEvolutionDir();
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(getStatePath(), JSON.stringify(state, null, 2) + '\n');
+  } catch (_) {}
+}
+
+function truncateNodeId(nodeId) {
+  if (!nodeId || typeof nodeId !== 'string') return 'unknown';
+  if (nodeId.length <= 10) return nodeId;
+  return nodeId.slice(0, 10) + '...';
+}
+
+function computeErrorKey(signals) {
+  var relevant = signals
+    .filter(function (s) {
+      return s.startsWith('recurring_errsig') ||
+        s.startsWith('ban_gene:') ||
+        s === 'recurring_error' ||
+        s === 'failure_loop_detected' ||
+        s === 'high_failure_ratio';
+    })
+    .sort()
+    .join('|');
+  return crypto.createHash('sha256').update(relevant || 'unknown').digest('hex').slice(0, 16);
+}
+
+function extractErrorSignature(signals) {
+  var errSig = signals.find(function (s) { return s.startsWith('recurring_errsig'); });
+  if (errSig) {
+    return errSig.replace(/^recurring_errsig\(\d+x\):/, '').trim().slice(0, 200);
+  }
+  var banned = signals.find(function (s) { return s.startsWith('ban_gene:'); });
+  if (banned) return 'Repeated failures with gene: ' + banned.replace('ban_gene:', '');
+  return 'Persistent evolution failure';
+}
+
+function extractStreakCount(signals) {
+  for (var i = 0; i < signals.length; i++) {
+    if (signals[i].startsWith('consecutive_failure_streak_')) {
+      var n = parseInt(signals[i].replace('consecutive_failure_streak_', ''), 10);
+      if (Number.isFinite(n)) return n;
+    }
+  }
+  return 0;
+}
+
+function formatRecentEvents(events) {
+  if (!Array.isArray(events) || events.length === 0) return '_No recent events available._';
+  var failed = events.filter(function (e) { return e && e.outcome && e.outcome.status === 'failed'; });
+  var rows = failed.slice(-MAX_EVENTS).map(function (e, idx) {
+    var intent = e.intent || '-';
+    var gene = (Array.isArray(e.genes_used) && e.genes_used[0]) || '-';
+    var outcome = (e.outcome && e.outcome.status) || '-';
+    var reason = (e.outcome && e.outcome.reason) || '';
+    if (reason.length > 80) reason = reason.slice(0, 80) + '...';
+    reason = redactString(reason);
+    return '| ' + (idx + 1) + ' | ' + intent + ' | ' + gene + ' | ' + outcome + ' | ' + reason + ' |';
+  });
+  if (rows.length === 0) return '_No failed events in recent history._';
+  return '| # | Intent | Gene | Outcome | Reason |\n|---|--------|------|---------|--------|\n' + rows.join('\n');
+}
+
+function buildIssueBody(opts) {
+  var fp = opts.envFingerprint || captureEnvFingerprint();
+  var signals = opts.signals || [];
+  var recentEvents = opts.recentEvents || [];
+  var sessionLog = opts.sessionLog || '';
+  var streakCount = extractStreakCount(signals);
+  var errorSig = extractErrorSignature(signals);
+  var nodeId = truncateNodeId(getNodeId());
+
+  var failureSignals = signals.filter(function (s) {
+    return s.startsWith('recurring_') ||
+      s.startsWith('consecutive_failure') ||
+      s.startsWith('failure_loop') ||
+      s.startsWith('high_failure') ||
+      s.startsWith('ban_gene:') ||
+      s === 'force_innovation_after_repair_loop';
+  }).join(', ');
+
+  var sanitizedLog = redactString(
+    typeof sessionLog === 'string' ? sessionLog.slice(-MAX_LOG_CHARS) : ''
+  );
+
+  var eventsTable = formatRecentEvents(recentEvents);
+
+  var reportId = crypto.createHash('sha256')
+    .update(nodeId + '|' + Date.now() + '|' + errorSig)
+    .digest('hex').slice(0, 12);
+
+  var body = [
+    '## Environment',
+    '- **Evolver Version:** ' + (fp.evolver_version || 'unknown'),
+    '- **Node.js:** ' + (fp.node_version || process.version),
+    '- **Platform:** ' + (fp.platform || process.platform) + ' ' + (fp.arch || process.arch),
+    '- **Container:** ' + (fp.container ? 'yes' : 'no'),
+    '',
+    '## Failure Summary',
+    '- **Consecutive failures:** ' + (streakCount || 'N/A'),
+    '- **Failure signals:** ' + (failureSignals || 'none'),
+    '',
+    '## Error Signature',
+    '```',
+    redactString(errorSig),
+    '```',
+    '',
+    '## Recent Evolution Events (sanitized)',
+    eventsTable,
+    '',
+    '## Session Log Excerpt (sanitized)',
+    '```',
+    sanitizedLog || '_No session log available._',
+    '```',
+    '',
+    '---',
+    '_This issue was automatically created by evolver v' + (fp.evolver_version || 'unknown') + '._',
+    '_Device: ' + nodeId + ' | Report ID: ' + reportId + '_',
+  ];
+
+  return body.join('\n');
+}
+
+function shouldReport(signals, config) {
+  if (!config) return false;
+
+  var hasFailureLoop = signals.includes('failure_loop_detected');
+  var hasRecurringAndHigh = signals.includes('recurring_error') && signals.includes('high_failure_ratio');
+
+  if (!hasFailureLoop && !hasRecurringAndHigh) return false;
+
+  var streakCount = extractStreakCount(signals);
+  if (streakCount > 0 && streakCount < config.minStreak) return false;
+
+  var state = readState();
+  var errorKey = computeErrorKey(signals);
+
+  if (state.lastReportedAt) {
+    var elapsed = Date.now() - new Date(state.lastReportedAt).getTime();
+    if (elapsed < config.cooldownMs) {
+      var recentKeys = Array.isArray(state.recentIssueKeys) ? state.recentIssueKeys : [];
+      if (recentKeys.includes(errorKey)) {
+        return false;
+      }
+    }
+  }
+
+  return true;
+}
+
+async function createGithubIssue(repo, title, body, token) {
+  var url = 'https://api.github.com/repos/' + repo + '/issues';
+  var response = await fetch(url, {
+    method: 'POST',
+    headers: {
+      'Authorization': 'Bearer ' + token,
+      'Accept': 'application/vnd.github+json',
+      'Content-Type': 'application/json',
+      'X-GitHub-Api-Version': '2022-11-28',
+    },
+    body: JSON.stringify({ title: title, body: body }),
+    signal: AbortSignal.timeout(15000),
+  });
+
+  if (!response.ok) {
+    var errText = '';
+    try { errText = await response.text(); } catch (_) {}
+    throw new Error('GitHub API ' + response.status + ': ' + errText.slice(0, 200));
+  }
+
+  var data = await response.json();
+  return { number: data.number, url: data.html_url };
+}
+
+async function maybeReportIssue(opts) {
+  var config = getConfig();
+  if (!config) return;
+
+  var signals = opts.signals || [];
+
+  if (!shouldReport(signals, config)) return;
+
+  var token = getGithubToken();
+  if (!token) {
+    console.log('[IssueReporter] No GitHub token available. Skipping auto-report.');
+    return;
+  }
+
+  var errorSig = extractErrorSignature(signals);
+  var titleSig = errorSig.slice(0, 80);
+  var title = '[Auto] Recurring failure: ' + titleSig;
+  var body = buildIssueBody(opts);
+
+  try {
+    var result = await createGithubIssue(config.repo, title, body, token);
+    console.log('[IssueReporter] Created GitHub issue #' + result.number + ': ' + result.url);
+
+    var state = readState();
+    var errorKey = computeErrorKey(signals);
+    var recentKeys = Array.isArray(state.recentIssueKeys) ? state.recentIssueKeys : [];
+    recentKeys.push(errorKey);
+    if (recentKeys.length > 20) recentKeys = recentKeys.slice(-20);
+    writeState({
+      lastReportedAt: new Date().toISOString(),
+      recentIssueKeys: recentKeys,
+      lastIssueUrl: result.url,
+      lastIssueNumber: result.number,
+    });
+  } catch (e) {
+    console.log('[IssueReporter] Failed to create issue (non-fatal): ' + (e && e.message ? e.message : String(e)));
+  }
+}
+
+module.exports = { maybeReportIssue, buildIssueBody, shouldReport };