thumbgate 1.29.1 → 1.30.0

package/scripts/growth-campaigns.js

@@ -1,6 +1,183 @@
 #!/usr/bin/env node
 'use strict';
 
+const MARKETING_AGENT_CAMPAIGN_ID = 'marketing_agent_governance_20260727';
+const CAMPAIGN_ALIASES = Object.freeze({
+  mg27: MARKETING_AGENT_CAMPAIGN_ID,
+});
+const CAMPAIGN_BUYER_ORIGIN = 'https://thumbgate-production.up.railway.app';
+
+function campaignChannel(
+  channel,
+  permalink,
+  medium,
+  content = null,
+  campaignId = MARKETING_AGENT_CAMPAIGN_ID
+) {
+  const buyerUrl = new URL('/go/pro', CAMPAIGN_BUYER_ORIGIN);
+  buyerUrl.searchParams.set('utm_source', channel);
+  buyerUrl.searchParams.set('utm_medium', medium);
+  buyerUrl.searchParams.set('utm_campaign', campaignId);
+  if (content) buyerUrl.searchParams.set('utm_content', content);
+  return Object.freeze({
+    channel,
+    status: 'LIVE',
+    permalink,
+    trackedBuyerUrl: buyerUrl.toString(),
+  });
+}
+
+const MARKETING_AGENT_CAMPAIGN = Object.freeze({
+  campaignId: MARKETING_AGENT_CAMPAIGN_ID,
+  aliases: ['mg27'],
+  episode: {
+    title: 'Marketing Agents Are Too Good Now',
+    url: 'https://www.youtube.com/watch?v=U2hogriGmEw',
+  },
+  channels: [
+    campaignChannel(
+      'linkedin',
+      'https://www.linkedin.com/feed/update/urn:li:share:7487654549785128960/',
+      'organic_social',
+      'episode_response'
+    ),
+    campaignChannel(
+      'hashnode',
+      'https://ai-agent-blog-12345.hashnode.dev/your-marketing-agent-can-publish-and-pause-ads-who-gates-the-write',
+      'organic_article',
+      'episode_deep_dive'
+    ),
+    campaignChannel(
+      'bluesky',
+      'https://bsky.app/profile/iganapolsky.bsky.social/post/3mro3mkmrzc2y',
+      'social',
+      null,
+      'mg27'
+    ),
+    campaignChannel(
+      'threads',
+      'https://www.threads.com/@igorganapolsky/post/DbUMBzXDlj8',
+      'social',
+      null,
+      'mg27'
+    ),
+    campaignChannel(
+      'instagram',
+      'https://www.instagram.com/igorganapolsky/p/DbUNjFsDQz3/',
+      'organic_social',
+      'episode_card'
+    ),
+    campaignChannel(
+      'reddit',
+      'https://www.reddit.com/r/SideProject/comments/1v8i0it/i_built_a_preaction_firewall_for_ai_agents_that/',
+      'organic_social',
+      'sideproject_build'
+    ),
+    campaignChannel(
+      'youtube',
+      'https://www.youtube.com/post/UgkxERIbGUvSgCkGQ_dx2W0nbTl5_abcF17O',
+      'community_post',
+      'episode_response'
+    ),
+  ],
+});
+
+function normalizeCampaignId(value) {
+  const normalized = String(value || '').trim();
+  if (!normalized) return null;
+  return CAMPAIGN_ALIASES[normalized] || normalized;
+}
+
+function campaignAttributionKeys(campaign = MARKETING_AGENT_CAMPAIGN) {
+  return [...new Set([
+    campaign.campaignId,
+    ...(campaign.aliases || []),
+  ].map((value) => String(value || '').trim()).filter(Boolean))];
+}
+
+function validateCampaignChannel(entry, campaign, seenChannels, seenSources) {
+  const issues = [];
+  const channel = String(entry.channel || '').trim().toLowerCase();
+  if (!channel || seenChannels.has(channel)) {
+    issues.push(`duplicate_or_missing_channel:${channel || 'unknown'}`);
+  }
+  seenChannels.add(channel);
+
+  if (entry.status !== 'LIVE') {
+    issues.push(`channel_not_live:${channel || 'unknown'}`);
+  }
+
+  let permalink;
+  let trackedBuyerUrl;
+  try {
+    permalink = new URL(entry.permalink);
+    trackedBuyerUrl = new URL(entry.trackedBuyerUrl);
+  } catch {
+    issues.push(`invalid_url:${channel || 'unknown'}`);
+    return issues;
+  }
+
+  if (permalink.protocol !== 'https:') {
+    issues.push(`permalink_not_https:${channel}`);
+  }
+  if (
+    trackedBuyerUrl.protocol !== 'https:'
+    || trackedBuyerUrl.origin !== CAMPAIGN_BUYER_ORIGIN
+    || trackedBuyerUrl.pathname !== '/go/pro'
+  ) {
+    issues.push(`buyer_path_not_canonical:${channel}`);
+  }
+
+  const source = trackedBuyerUrl.searchParams.get('utm_source');
+  if (source !== channel || seenSources.has(source)) {
+    issues.push(`source_mismatch_or_duplicate:${channel}`);
+  }
+  seenSources.add(source);
+
+  if (
+    normalizeCampaignId(trackedBuyerUrl.searchParams.get('utm_campaign'))
+    !== campaign.campaignId
+  ) {
+    issues.push(`campaign_mismatch:${channel}`);
+  }
+  if (!trackedBuyerUrl.searchParams.get('utm_medium')) {
+    issues.push(`missing_medium:${channel}`);
+  }
+  return issues;
+}
+
+function validateMarketingAgentCampaign(campaign = MARKETING_AGENT_CAMPAIGN) {
+  const issues = [];
+  const channels = Array.isArray(campaign.channels) ? campaign.channels : [];
+  const seenChannels = new Set();
+  const seenSources = new Set();
+
+  if (normalizeCampaignId(campaign.campaignId) !== MARKETING_AGENT_CAMPAIGN_ID) {
+    issues.push('campaign_id_must_be_canonical');
+  }
+  if (campaign.episode?.url !== 'https://www.youtube.com/watch?v=U2hogriGmEw') {
+    issues.push('episode_url_mismatch');
+  }
+  if (channels.length !== 7) {
+    issues.push('expected_seven_channels');
+  }
+  for (const entry of channels) {
+    issues.push(...validateCampaignChannel(
+      entry,
+      campaign,
+      seenChannels,
+      seenSources
+    ));
+  }
+
+  return {
+    ok: issues.length === 0,
+    issues,
+    channelCount: channels.length,
+    campaignId: campaign.campaignId,
+  };
+}
+
 function buildCreatorGrowthCampaign(input = {}) {
   const appUrl = input.appUrl || 'https://thumbgate-production.up.railway.app';
   const webinarTitle = input.webinarTitle || 'Stop AI Agents From Repeating Expensive Mistakes';
@@ -45,5 +222,11 @@ function buildCreatorGrowthCampaign(input = {}) {
 }
 
 module.exports = {
+  CAMPAIGN_ALIASES,
+  MARKETING_AGENT_CAMPAIGN,
+  MARKETING_AGENT_CAMPAIGN_ID,
   buildCreatorGrowthCampaign,
+  campaignAttributionKeys,
+  normalizeCampaignId,
+  validateMarketingAgentCampaign,
 };

package/scripts/human-escalation.js

@@ -0,0 +1,265 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Human Escalation Queue
+ *
+ * Agents may request or inspect escalation, but approval decisions require an
+ * explicit human actor identity distinct from the requesting agent. Events are
+ * append-only so every transition remains auditable.
+ */
+
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const path = require('node:path');
+const { getFeedbackPaths } = require('./feedback-paths');
+
+const ESCALATIONS_FILE = 'human-escalations.jsonl';
+const MAX_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+const DEFAULT_TTL_MS = 24 * 60 * 60 * 1000;
+const SEVERITIES = new Set(['low', 'medium', 'high', 'critical']);
+const DECISIONS = new Set(['approved', 'rejected', 'cancelled']);
+
+function getEscalationsPath(options = {}) {
+  return path.join(getFeedbackPaths(options).FEEDBACK_DIR, ESCALATIONS_FILE);
+}
+
+function requestEscalation(input = {}, options = {}) {
+  const now = options.now || new Date();
+  const taskId = requiredString(input.taskId, 'taskId');
+  const reason = requiredString(input.reason, 'reason');
+  const requester = requiredIdentity(input.requester, 'requester');
+  const evidence = stringArray(input.evidence);
+  if (evidence.length === 0) throw escalationError('evidence must contain at least one item');
+  const severity = input.severity || 'medium';
+  if (!SEVERITIES.has(severity)) throw escalationError(`severity must be one of ${Array.from(SEVERITIES).join(', ')}`);
+  const ttlMs = Math.min(MAX_TTL_MS, Math.max(1, finiteNumber(input.ttlMs, DEFAULT_TTL_MS)));
+  const idempotencyKey = requiredString(input.idempotencyKey || taskId, 'idempotencyKey');
+  const existing = listEscalations(options).find((entry) => entry.idempotencyKey === idempotencyKey);
+
+  const request = {
+    escalationId: input.escalationId || `esc_${crypto.randomUUID()}`,
+    idempotencyKey,
+    taskId,
+    reason,
+    severity,
+    requester,
+    evidence,
+    requestedAt: now.toISOString(),
+    expiresAt: new Date(now.getTime() + ttlMs).toISOString(),
+    status: 'pending',
+    eventType: 'requested',
+  };
+  request.eventHash = eventHash(request);
+
+  if (existing) {
+    if (eventComparableHash(existing) !== eventComparableHash(request)) {
+      const error = escalationError(`conflicting request for idempotency key '${idempotencyKey}'`);
+      error.code = 'THUMBGATE_IDEMPOTENCY_CONFLICT';
+      throw error;
+    }
+    return { recorded: false, duplicate: true, escalation: existing };
+  }
+
+  appendEvent(request, options);
+  return { recorded: true, duplicate: false, escalation: request };
+}
+
+function decideEscalation(input = {}, options = {}) {
+  const escalationId = requiredString(input.escalationId, 'escalationId');
+  const decision = requiredString(input.decision, 'decision');
+  if (!DECISIONS.has(decision)) throw escalationError(`decision must be one of ${Array.from(DECISIONS).join(', ')}`);
+  if (Object.hasOwn(input, 'actor')) {
+    throw escalationError('decision actor is derived from the authenticated reviewer and must not be supplied by the caller');
+  }
+  const actor = requiredIdentity(options.authenticatedActor, 'authenticatedActor');
+  if (actor.kind !== 'human') throw escalationError('authenticatedActor.kind must be human');
+  const reason = requiredString(input.reason, 'reason');
+  const current = getEscalation(escalationId, options);
+  if (!current) throw escalationError(`unknown escalation '${escalationId}'`);
+  if (current.status !== 'pending') throw escalationError(`escalation '${escalationId}' is already ${current.status}`);
+  if (sameIdentity(current.requester, actor)) throw escalationError('requester cannot decide their own escalation');
+
+  const now = options.now || new Date();
+  const event = {
+    escalationId,
+    taskId: current.taskId,
+    status: decision,
+    eventType: 'decided',
+    decision,
+    actor,
+    reason,
+    decidedAt: now.toISOString(),
+  };
+  event.eventHash = eventHash(event);
+  appendEvent(event, options);
+  return { recorded: true, escalation: { ...current, ...event } };
+}
+
+function listEscalations(options = {}) {
+  const events = readEvents(options);
+  const byId = new Map();
+  for (const event of events) {
+    const current = byId.get(event.escalationId) || {};
+    byId.set(event.escalationId, { ...current, ...event });
+  }
+
+  const nowMs = (options.now || new Date()).getTime();
+  const rows = Array.from(byId.values()).map((entry) => {
+    if (entry.status === 'pending' && Date.parse(entry.expiresAt) <= nowMs) {
+      return { ...entry, status: 'expired' };
+    }
+    return entry;
+  });
+  const status = options.status;
+  return rows
+    .filter((entry) => !status || entry.status === status)
+    .sort((a, b) => Date.parse(b.requestedAt || b.decidedAt) - Date.parse(a.requestedAt || a.decidedAt));
+}
+
+function getEscalation(escalationId, options = {}) {
+  return listEscalations(options).find((entry) => entry.escalationId === escalationId) || null;
+}
+
+function calculateEscalationMetrics(escalations = [], now = new Date()) {
+  const rows = escalations.filter(Boolean);
+  const decided = rows.filter((entry) => ['approved', 'rejected'].includes(entry.status));
+  const decisionLatencies = decided
+    .map((entry) => Date.parse(entry.decidedAt) - Date.parse(entry.requestedAt))
+    .filter((value) => Number.isFinite(value) && value >= 0);
+  const overdue = rows.filter((entry) => entry.status === 'pending' && Date.parse(entry.expiresAt) <= now.getTime());
+  return {
+    generatedAt: now.toISOString(),
+    sampleSize: rows.length,
+    evidenceStatus: rows.length ? 'measured' : 'insufficient_evidence',
+    pending: rows.filter((entry) => entry.status === 'pending').length,
+    approved: rows.filter((entry) => entry.status === 'approved').length,
+    rejected: rows.filter((entry) => entry.status === 'rejected').length,
+    expired: rows.filter((entry) => entry.status === 'expired').length,
+    overdue: overdue.length,
+    medianDecisionLatencyMs: percentile(decisionLatencies, 0.5),
+    p95DecisionLatencyMs: percentile(decisionLatencies, 0.95),
+  };
+}
+
+function readEvents(options = {}) {
+  const inputPath = options.inputPath ? path.resolve(options.inputPath) : getEscalationsPath(options);
+  let raw = '';
+  try {
+    raw = fs.readFileSync(inputPath, 'utf8');
+  } catch {
+    return [];
+  }
+  return raw.split('\n').map((line) => line.trim()).filter(Boolean).flatMap((line) => {
+    try {
+      return [JSON.parse(line)];
+    } catch {
+      return [];
+    }
+  });
+}
+
+function appendEvent(event, options) {
+  const outputPath = getEscalationsPath(options);
+  fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+  fs.appendFileSync(outputPath, `${JSON.stringify(event)}\n`, 'utf8');
+}
+
+function requiredIdentity(value, field) {
+  if (!value || typeof value !== 'object') throw escalationError(`${field} identity is required`);
+  const identity = {
+    id: requiredString(value.id, `${field}.id`),
+    kind: requiredString(value.kind, `${field}.kind`),
+  };
+  const displayName = optionalString(value.displayName);
+  if (displayName) identity.displayName = displayName;
+  return identity;
+}
+
+function requiredString(value, field) {
+  const clean = String(value ?? '').trim();
+  if (!clean) throw escalationError(`${field} is required`);
+  return clean;
+}
+
+function optionalString(value) {
+  const clean = String(value ?? '').trim();
+  return clean || undefined;
+}
+
+function stringArray(value) {
+  return Array.isArray(value) ? value.map((entry) => String(entry).trim()).filter(Boolean) : [];
+}
+
+function finiteNumber(value, fallback) {
+  const number = Number(value);
+  return Number.isFinite(number) ? number : fallback;
+}
+
+function sameIdentity(a, b) {
+  return a?.kind === b?.kind && a?.id === b?.id;
+}
+
+function eventHash(event) {
+  return crypto.createHash('sha256').update(stableStringify(event)).digest('hex');
+}
+
+function eventComparableHash(event) {
+  const comparable = {
+    idempotencyKey: event.idempotencyKey,
+    taskId: event.taskId,
+    reason: event.reason,
+    severity: event.severity,
+    requester: event.requester,
+    evidence: event.evidence,
+  };
+  return crypto.createHash('sha256').update(stableStringify(comparable)).digest('hex');
+}
+
+function stableStringify(value) {
+  if (!value || typeof value !== 'object') return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(',')}]`;
+  const keys = Object.keys(value).sort((left, right) => left.localeCompare(right));
+  const properties = keys.map((key) => [
+    JSON.stringify(key),
+    stableStringify(value[key]),
+  ].join(':'));
+  return ['{', properties.join(','), '}'].join('');
+}
+
+function percentile(values, quantile) {
+  if (!values.length) return null;
+  const sorted = [...values].sort((a, b) => a - b);
+  const index = Math.max(0, Math.ceil(sorted.length * quantile) - 1);
+  return sorted[index];
+}
+
+function escalationError(message) {
+  const error = new Error(`Invalid human escalation: ${message}`);
+  error.code = 'THUMBGATE_ESCALATION_INVALID';
+  return error;
+}
+
+function isCliInvocation() {
+  return Boolean(process.argv[1]) && path.resolve(process.argv[1]) === __filename;
+}
+
+if (isCliInvocation()) {
+  const command = process.argv[2] || 'metrics';
+  const escalations = listEscalations();
+  if (command === 'list') console.log(JSON.stringify(escalations, null, 2));
+  else if (command === 'metrics') console.log(JSON.stringify(calculateEscalationMetrics(escalations), null, 2));
+  else {
+    console.error('Usage: human-escalation.js [list|metrics]');
+    process.exitCode = 1;
+  }
+}
+
+module.exports = {
+  calculateEscalationMetrics,
+  decideEscalation,
+  getEscalation,
+  getEscalationsPath,
+  listEscalations,
+  requestEscalation,
+};

package/scripts/hybrid-feedback-context.js

@@ -151,13 +151,14 @@ function isHookPromptEnvelope(context) {
         parsed.transcriptPath
       )
     );
-  } catch (_) {
+  } catch {
+    // Not JSON — by definition not a hook envelope.
     return false;
   }
 }
 
 function patternContext(entry) {
-  const context = entry && entry.context ? String(entry.context) : '';
+  const context = entry?.context ? String(entry.context) : '';
   if (!context) return '';
   const hasExplicitFeedback = Boolean(
     entry.whatWentWrong ||
@@ -189,48 +190,6 @@ function isAutomatedFeedback(entry) {
 }
 
 
-function isHookPromptEnvelope(context) {
-  if (!context || typeof context !== 'string') return false;
-  try {
-    const parsed = JSON.parse(context);
-    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return false;
-    return Boolean(
-      parsed.prompt &&
-      (
-        parsed.hookEventName ||
-        parsed.hook_event_name ||
-        parsed.workspaceRoot ||
-        parsed.workspace_root ||
-        parsed.session_id ||
-        parsed.sessionId ||
-        parsed.transcript_path ||
-        parsed.transcriptPath
-      )
-    );
-  } catch (_) {
-    return false;
-  }
-}
-
-function patternContext(entry) {
-  const context = entry && entry.context ? String(entry.context) : '';
-  if (!context) return '';
-  const hasExplicitFeedback = Boolean(
-    entry.whatWentWrong ||
-    entry.what_went_wrong ||
-    entry.whatToChange ||
-    entry.what_to_change ||
-    entry.failureType ||
-    (Array.isArray(entry.tags) && entry.tags.length > 0) ||
-    entry.structuredRule
-  );
-  if (isHookPromptEnvelope(context) && !hasExplicitFeedback) return '';
-  if (isHookPromptEnvelope(context) && hasExplicitFeedback) {
-    return '';
-  }
-  return context;
-}
-
 /**
  * Extract ms from a timestamp value. Returns 0 on failure.
  */
@@ -494,14 +453,94 @@ function buildAdditionalContext(state, constraints, maxChars) {
  * @param {string[]} words - keyword list from a pattern
  * @returns {boolean}
  */
+// Callers hand us the pending action in several shapes: a plain command string, an object,
+// or a JSON envelope like {"toolName":…,"command":…,"filePath":…,"affectedFiles":[…]}.
+// Matching over the raw JSON meant the envelope's own KEY NAMES were part of the haystack,
+// so the tokens "files", "command", "tool", "name" and "path" were present on every single
+// evaluation. With a two-hit block threshold, any guard whose keywords included two such
+// common words blocked every action regardless of what that action was. Match on the VALUES
+// only — the guard should key on the action, never on how we happened to serialize it.
+// normalize() runs text through sanitizeFeedbackText(), which exists to reject hook
+// TRANSPORT PAYLOADS and path-dominated blobs from human FEEDBACK. That is the wrong filter
+// for the pending action we are matching against: a real action is frequently just a command
+// plus a list of file paths, which sanitizeFeedbackText() discards wholesale as a "path blob",
+// leaving an empty haystack and silently matching nothing. Apply only the redactions here.
+function normalizeActionText(text) {
+  if (!text || typeof text !== 'string') return '';
+  return text
+    .replace(/\/Users\/[^\s/]+/g, '/Users/redacted')
+    .replace(/:\d{4,5}\b/g, ':PORT')
+    .toLowerCase()
+    .trim();
+}
+
+function buildMatchHaystack(input) {
+  if (input == null) return '';
+  let value = input;
+  if (typeof value === 'string') {
+    const trimmed = value.trim();
+    if (!(trimmed.startsWith('{') || trimmed.startsWith('['))) return value;
+    try {
+      value = JSON.parse(trimmed);
+    } catch {
+      return value;
+    }
+  }
+  if (typeof value !== 'object') return String(value);
+
+  const parts = [];
+  const seen = new Set();
+  const walk = (node, depth) => {
+    if (node == null || depth > 6) return;
+    if (typeof node === 'object') {
+      if (seen.has(node)) return;
+      seen.add(node);
+      for (const child of Array.isArray(node) ? node : Object.values(node)) walk(child, depth + 1);
+      return;
+    }
+    if (typeof node === 'boolean') return; // "true"/"false" are structure, not content
+    parts.push(String(node));
+  };
+  walk(value, 0);
+  return parts.join(' ');
+}
+
+// A guard word is "specific" when it is a compound identifier — keywords() preserves `-` and
+// `_`, so a token like "generated-cache" or "tool_registry" survives intact and is almost
+// always lifted from a real command, path or symbol rather than from prose. One such token
+// is strong evidence on its own.
+//
+// Deliberately NOT keyed on length: ordinary English words ("deployment", "permission",
+// "everything") are long but common, and letting one of them carry a block on its own would
+// over-block. Those still require a second corroborating hit.
+function isSpecificKeyword(word) {
+  return /[-_]/.test(word);
+}
+
+// Whole-word matching: a bare includes() let "app" hit "apps/", "application" and "happen".
+// Boundaries are non-alphanumerics, so path and punctuation separators still delimit tokens
+// (`src/jobs/queue.js` matches the word "jobs").
+function containsWholeWord(haystack, word) {
+  const escaped = String(word).replace(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
+  try {
+    return new RegExp(`(?:^|[^a-z0-9])${escaped}(?:[^a-z0-9]|$)`, 'i').test(haystack);
+  } catch {
+    return haystack.includes(word);
+  }
+}
+
 function hasTwoKeywordHits(normalizedInput, words) {
   if (!normalizedInput || !words || words.length === 0) return false;
   let hits = 0;
+  const seen = new Set();
   for (const word of words) {
-    if (normalizedInput.includes(word)) {
-      hits++;
-      if (hits >= 2) return true;
-    }
+    if (!word || seen.has(word)) continue;
+    seen.add(word);
+    if (!containsWholeWord(normalizedInput, word)) continue;
+    // A specific compound/long token carries a match on its own; generic words need two.
+    if (isSpecificKeyword(word)) return true;
+    hits++;
+    if (hits >= 2) return true;
   }
   return false;
 }
@@ -614,7 +653,7 @@ function evaluateCompiledGuards(artifact, toolName, toolInput) {
     return { mode: 'allow', reason: '', source: 'compiled' };
   }
 
-  const normInput = normalize(toolInput || '');
+  const normInput = normalizeActionText(buildMatchHaystack(toolInput));
   const normTool = (toolName || '').toLowerCase();
 
   for (const guard of artifact.guards) {
@@ -656,7 +695,7 @@ function evaluateCompiledGuards(artifact, toolName, toolInput) {
  * @returns {{ mode: string, reason: string, source: string }}
  */
 function evaluatePretoolFromState(state, toolName, toolInput) {
-  const normInput = normalize(toolInput || '');
+  const normInput = normalizeActionText(buildMatchHaystack(toolInput));
   const normTool = (toolName || '').toLowerCase();
 
   for (const pattern of state.recurringNegativePatterns || []) {
@@ -824,6 +863,10 @@ module.exports = {
   keywords,
   hashText,
   hasTwoKeywordHits,
+  buildMatchHaystack,
+  normalizeActionText,
+  isSpecificKeyword,
+  containsWholeWord,
   readJsonl,
   getHybridPaths,
   PATHS,

package/scripts/jsonl-watcher.js

@@ -71,6 +71,7 @@ function ingestEntry(entry) {
     whatWorked: entry.whatWorked || undefined,
     tags: [...(entry.tags || []), WATCHER_SOURCE_TAG, `bridged-from:${entry.source}`],
     skill: entry.skill || undefined,
+    reviewOrigin: entry.reviewOrigin || 'imported',
   });
 
   return result;