thumbgate 1.16.13 → 1.16.19

package/scripts/ai-org-governance.js

@@ -1,98 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-function normalizeText(value) {
-  if (value === undefined || value === null) return '';
-  return String(value).trim();
-}
-
-function normalizeBudget(value, fallback) {
-  const number = Number(value);
-  return Number.isFinite(number) && number >= 0 ? number : fallback;
-}
-
-function buildAiOrgGovernancePlan(input = {}) {
-  const mission = normalizeText(input.mission) || 'Continuously improve agent-governed workflows while staying within budget.';
-  const monthlyBudgetUsd = normalizeBudget(input.monthlyBudgetUsd, 25);
-  const roles = [
-    {
-      id: 'ceo',
-      title: 'Planner',
-      mission: 'Break goals into tickets, assign owners, and enforce ROI.',
-      monthlyBudgetUsd: normalizeBudget(input.ceoBudgetUsd, Math.min(10, monthlyBudgetUsd)),
-      canCreateAgents: false,
-    },
-    {
-      id: 'research_analyst',
-      title: 'Research Analyst',
-      mission: 'Collect market and technical signals into structured briefs.',
-      monthlyBudgetUsd: normalizeBudget(input.researchBudgetUsd, Math.min(5, monthlyBudgetUsd)),
-      canCreateAgents: false,
-    },
-    {
-      id: 'qa_operator',
-      title: 'QA Operator',
-      mission: 'Review evidence, tests, diffs, and spend anomalies before promotion.',
-      monthlyBudgetUsd: normalizeBudget(input.qaBudgetUsd, Math.min(5, monthlyBudgetUsd)),
-      canCreateAgents: false,
-    },
-  ];
-
-  return {
-    generatedAt: normalizeText(input.generatedAt) || new Date().toISOString(),
-    orgName: normalizeText(input.orgName) || 'ThumbGate Agent Company',
-    mission,
-    monthlyBudgetUsd,
-    roles,
-    ticketTemplates: [
-      {
-        id: 'market_signal_brief',
-        ownerRole: 'research_analyst',
-        outputSchema: ['source', 'claim', 'relevance', 'action', 'evidence'],
-      },
-      {
-        id: 'workflow_hardening',
-        ownerRole: 'ceo',
-        outputSchema: ['risk', 'gate', 'test', 'rollback', 'owner'],
-      },
-      {
-        id: 'evidence_review',
-        ownerRole: 'qa_operator',
-        outputSchema: ['claim', 'evidence', 'verdict', 'missing_proof'],
-      },
-    ],
-    approvalGates: [
-      'new_agent_role',
-      'budget_increase',
-      'credentialed_connector_write',
-      'production_release',
-      'public_claim_without_evidence',
-    ],
-    audit: {
-      daily: ['ticket outcomes', 'spend by role', 'blocked actions', 'open approvals'],
-      weekly: ['low ROI tickets', 'stale agents', 'budget cap changes', 'policy drift'],
-    },
-  };
-}
-
-function evaluateAiOrgAction(action = {}, plan = buildAiOrgGovernancePlan()) {
-  const type = normalizeText(action.type);
-  const issues = [];
-  if (type === 'create_agent') issues.push('new_agent_role');
-  if (type === 'raise_budget') issues.push('budget_increase');
-  if (type === 'connector_write') issues.push('credentialed_connector_write');
-  if (type === 'public_claim' && !(Array.isArray(action.evidence) && action.evidence.length > 0)) {
-    issues.push('public_claim_without_evidence');
-  }
-  const gateHits = issues.filter((issue) => plan.approvalGates.includes(issue));
-  return {
-    decision: gateHits.length > 0 ? 'warn' : 'allow',
-    gateHits,
-    requiredApproval: gateHits.length > 0,
-  };
-}
-
-module.exports = {
-  buildAiOrgGovernancePlan,
-  evaluateAiOrgAction,
-};

package/scripts/artifact-agent-plan.js

@@ -1,81 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-function normalizeText(value) {
-  if (value === undefined || value === null) return '';
-  return String(value).trim();
-}
-
-function normalizeTask(task, index = 0) {
-  const id = normalizeText(task?.id) || `task-${index + 1}`;
-  return {
-    id,
-    description: normalizeText(task?.description),
-    branchName: normalizeText(task?.branchName) || id.toLowerCase().replaceAll(/[^a-z0-9]+/g, '-'),
-    priority: Number.isFinite(Number(task?.priority)) ? Number(task.priority) : index + 1,
-  };
-}
-
-function buildArtifactAgentPlan(input = {}) {
-  const baselineName = normalizeText(input.baselineName) || 'baseline';
-  const gitUrl = normalizeText(input.gitUrl) || 'https://github.com/IgorGanapolsky/ThumbGate.git';
-  const tasks = Array.isArray(input.tasks) ? input.tasks.map(normalizeTask) : [];
-  const forks = tasks.map((task) => ({
-    taskId: task.id,
-    forkName: `${baselineName}-${task.id}`.toLowerCase().replaceAll(/[^a-z0-9-]+/g, '-'),
-    branchName: task.branchName,
-    artifactRemote: null,
-    tokenRef: `artifact_token_${task.id}`,
-    status: 'planned',
-  }));
-
-  return {
-    generatedAt: normalizeText(input.generatedAt) || new Date().toISOString(),
-    baseline: {
-      name: baselineName,
-      gitUrl,
-      importIfMissing: true,
-    },
-    taskSchema: {
-      required: ['id', 'description', 'branchName', 'priority'],
-      properties: {
-        id: 'stable task identifier',
-        description: 'agent-readable task description',
-        branchName: 'deterministic branch/fork suffix',
-        priority: 'lower number runs first',
-      },
-    },
-    tasks,
-    forks,
-    runnerContract: {
-      filesystem: 'in_memory_git',
-      tools: ['read(path)', 'write(path, contents)', 'run_tests(command)', 'commit(message)'],
-      constraints: [
-        'read before write',
-        'minimize changes',
-        'commit every successful task',
-        'never expose artifact tokens in logs',
-      ],
-    },
-    reviewGate: {
-      requiredBeforeMerge: [
-        'diff summary',
-        'changed files',
-        'test output',
-        'decision journal entry',
-        'human or reviewer-agent approval',
-      ],
-      blockedWithout: ['baseline comparison', 'rollback path', 'evidence artifacts'],
-    },
-    observability: {
-      events: ['task_created', 'fork_created', 'agent_started', 'tool_call', 'commit_pushed', 'reviewed', 'merged_or_rejected'],
-      metrics: ['task_latency_ms', 'tool_call_count', 'test_pass_rate', 'review_reject_rate'],
-      traceKey: 'artifact_task_id',
-    },
-  };
-}
-
-module.exports = {
-  buildArtifactAgentPlan,
-  normalizeTask,
-};

package/scripts/enterprise-agent-rollout.js

@@ -1,34 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-function buildEnterpriseAgentRollout(input = {}) {
-  const industry = input.industry || 'enterprise software';
-  return {
-    program: 'ThumbGate Enterprise Agent Acceleration',
-    industry,
-    operatingModel: {
-      forwardDeployedEngineer: true,
-      humanInTheLead: true,
-      domainExpertsRequired: true,
-      sovereignDeploymentOption: true,
-    },
-    phases: [
-      { id: 'discover', outcome: 'rank workflows by measurable business value and risk' },
-      { id: 'prototype', outcome: 'ship one governed agent with evidence and rollback' },
-      { id: 'scale', outcome: 'publish reusable agent catalog and approval policies' },
-      { id: 'operate', outcome: 'review traces, ROI, incidents, and policy drift weekly' },
-    ],
-    governance: [
-      'human oversight for high-stakes recommendations',
-      'sovereign data boundary when required',
-      'agent catalog with owner and allowed tools',
-      'decision journal for every business-critical action',
-      'measurable outcome before expansion',
-    ],
-    metrics: ['cycle_time_saved', 'blocked_risky_actions', 'approved_agent_runs', 'business_value_cents', 'incident_rate'],
-  };
-}
-
-module.exports = {
-  buildEnterpriseAgentRollout,
-};

package/scripts/experience-replay-governance.js

@@ -1,69 +0,0 @@
-'use strict';
-
-function buildExperienceReplayPolicy(options = {}) {
-  const maxStalenessHours = Number.isFinite(options.maxStalenessHours) ? options.maxStalenessHours : 24;
-  const replayRatio = Number.isFinite(options.replayRatio) ? options.replayRatio : 0.25;
-  const minEntropy = Number.isFinite(options.minEntropy) ? options.minEntropy : 0.65;
-
-  return {
-    policyId: 'feedback_experience_replay',
-    purpose: 'Reuse high-signal feedback trajectories without letting stale lessons dominate training.',
-    buffer: {
-      strategy: 'fifo_with_quality_filters',
-      maxStalenessHours,
-      replayRatio,
-      sampleWithoutRemoval: true,
-    },
-    filters: [
-      'redacted',
-      'source_feedback_id_present',
-      'outcome_evidence_present',
-      'not_contradicted_by_newer_lesson',
-      'not_low_confidence_or_vague_feedback',
-    ],
-    monitors: {
-      maxStalenessHours,
-      minEntropy,
-      compareAgainstFreshOnly: true,
-      metrics: ['gate_precision', 'gate_recall', 'unsupported_claim_rate', 'policy_entropy', 'compute_saved_percent'],
-    },
-  };
-}
-
-function evaluateReplayCandidate(candidate = {}, policy = buildExperienceReplayPolicy()) {
-  const issues = [];
-  if (!candidate.sourceFeedbackId) issues.push('missing_source_feedback_id');
-  if (!candidate.redacted) issues.push('redaction_required');
-  if (!candidate.outcomeEvidence) issues.push('missing_outcome_evidence');
-  if (candidate.contradictedByNewerLesson) issues.push('contradicted_by_newer_lesson');
-  if (candidate.vagueFeedback) issues.push('vague_feedback_not_replayable');
-
-  const ageHours = Number(candidate.ageHours || 0);
-  if (ageHours > policy.buffer.maxStalenessHours) issues.push('stale_replay_sample');
-
-  return {
-    decision: issues.length ? 'reject' : 'accept',
-    issues,
-    replayWeight: issues.length ? 0 : Math.min(policy.buffer.replayRatio, Number(candidate.qualityScore || 1)),
-  };
-}
-
-function evaluateReplayRun(run = {}, policy = buildExperienceReplayPolicy()) {
-  const issues = [];
-  if (Number(run.replayRatio || 0) > 0.5) issues.push('replay_ratio_too_high');
-  if (Number(run.policyEntropy || 0) < policy.monitors.minEntropy) issues.push('policy_entropy_too_low');
-  if (!run.freshOnlyBaseline) issues.push('missing_fresh_only_baseline');
-  if (!run.computeSavedPercent && run.computeSavedPercent !== 0) issues.push('missing_compute_saved_metric');
-
-  return {
-    decision: issues.length ? 'warn' : 'allow',
-    issues,
-    computeEfficient: Number(run.computeSavedPercent || 0) > 0 && Number(run.policyEntropy || 0) >= policy.monitors.minEntropy,
-  };
-}
-
-module.exports = {
-  buildExperienceReplayPolicy,
-  evaluateReplayCandidate,
-  evaluateReplayRun,
-};

package/scripts/inference-economics.js

@@ -1,53 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-function estimateDifficulty(input = {}) {
-  let score = 0;
-  const text = String(input.task || input.prompt || '');
-  if (text.length > 1200) score += 20;
-  if (/ambiguous|research|architecture|security|production|migration|legal|financial/i.test(text)) score += 25;
-  if (Number(input.dollarImpact || 0) >= 1000) score += 25;
-  if (Array.isArray(input.files) && input.files.length > 5) score += 15;
-  if (input.requiresHumanApproval === true) score += 15;
-  return Math.max(0, Math.min(100, score));
-}
-
-function planInferenceBudget(input = {}) {
-  const difficulty = Number.isFinite(input.difficulty) ? input.difficulty : estimateDifficulty(input);
-  const maxCostCents = Number.isFinite(Number(input.maxCostCents)) ? Number(input.maxCostCents) : 50;
-  let depth = 'shallow';
-  let reasoningEffort = 'low';
-  let expertCount = 1;
-  let humanHandoff = false;
-
-  if (difficulty >= 70) {
-    depth = 'deep';
-    reasoningEffort = 'high';
-    expertCount = 4;
-    humanHandoff = true;
-  } else if (difficulty >= 35) {
-    depth = 'standard';
-    reasoningEffort = 'medium';
-    expertCount = 2;
-  }
-
-  if (maxCostCents < 20 && depth === 'deep') {
-    depth = 'standard';
-    reasoningEffort = 'medium';
-  }
-
-  return {
-    difficulty,
-    maxCostCents,
-    depth,
-    reasoningEffort,
-    activeExperts: expertCount,
-    humanHandoff,
-    telemetry: ['difficulty', 'depth', 'reasoningEffort', 'activeExperts', 'latencyMs', 'costCents', 'outcome'],
-  };
-}
-
-module.exports = {
-  estimateDifficulty,
-  planInferenceBudget,
-};

package/scripts/knowledge-layer-plan.js

@@ -1,108 +0,0 @@
-'use strict';
-
-function buildKnowledgeLayerPlan(options = {}) {
-  const domain = options.domain || 'agent_reliability';
-  const graph = options.graph || 'neo4j';
-
-  return {
-    domain,
-    graph,
-    memoryTiers: [
-      {
-        id: 'short_term',
-        purpose: 'Current session context so the agent does not re-ask answered questions.',
-        ttl: 'session',
-      },
-      {
-        id: 'long_term',
-        purpose: 'Durable user, product, workflow, and feedback profile facts.',
-        ttl: 'durable',
-      },
-      {
-        id: 'reasoning_memory',
-        purpose: 'Reusable decision paths that avoid recomputing expensive traversals.',
-        ttl: 'versioned',
-      },
-    ],
-    nodeTypes: [
-      'User',
-      'Agent',
-      'Workflow',
-      'Feedback',
-      'Gate',
-      'Decision',
-      'Evidence',
-      'Recommendation',
-      'Outcome',
-    ],
-    relationshipTypes: [
-      'GAVE_FEEDBACK',
-      'TRIGGERED_GATE',
-      'USED_EVIDENCE',
-      'RECOMMENDED_ACTION',
-      'PRODUCED_OUTCOME',
-      'SIMILAR_TO',
-      'REUSES_REASONING',
-    ],
-    highRoiUseCases: [
-      'conversion recommendations with explainable evidence paths',
-      'compute savings from reasoning-memory cache hits',
-      'compliance audit trail for why an agent recommended or blocked an action',
-      'closed-loop profile updates from every feedback, purchase, or outcome event',
-    ],
-    gates: [
-      'do not recommend without an evidence path',
-      'do not reuse reasoning memory when source facts changed',
-      'write audit node for every recommendation and blocked action',
-      'record outcome feedback to update profile and graph edges',
-    ],
-  };
-}
-
-function buildRecommendationEvidencePath(input = {}) {
-  const userId = input.userId || 'unknown_user';
-  const recommendationId = input.recommendationId || 'rec_pending';
-  const evidence = Array.isArray(input.evidence) ? input.evidence : [];
-  const similarProfiles = Array.isArray(input.similarProfiles) ? input.similarProfiles : [];
-
-  return {
-    recommendationId,
-    path: [
-      { type: 'User', id: userId },
-      ...similarProfiles.map((id) => ({ type: 'SimilarProfile', id })),
-      ...evidence.map((item, index) => ({
-        type: item.type || 'Evidence',
-        id: item.id || `evidence_${index + 1}`,
-        quote: item.quote || null,
-      })),
-      { type: 'Recommendation', id: recommendationId },
-    ],
-    explainable: evidence.length > 0,
-  };
-}
-
-function evaluateKnowledgeLayerRun(run = {}) {
-  const issues = [];
-  if (!run.userId) issues.push('missing_user_id');
-  if (!run.recommendationId) issues.push('missing_recommendation_id');
-  if (!run.evidencePath?.explainable) issues.push('missing_explainable_evidence_path');
-  if (!run.auditNodeId) issues.push('missing_audit_node_id');
-  if (run.reusedReasoning && !run.reasoningVersion) issues.push('missing_reasoning_version');
-  if (run.profileUpdate && !run.outcomeEventId) issues.push('missing_outcome_event_id');
-
-  return {
-    decision: issues.length ? 'warn' : 'allow',
-    issues,
-    roiSignals: [
-      run.reusedReasoning ? 'lower_graph_query_and_token_cost' : null,
-      run.profileUpdate ? 'closed_loop_personalization' : null,
-      run.auditNodeId ? 'compliance_trace_available' : null,
-    ].filter(Boolean),
-  };
-}
-
-module.exports = {
-  buildKnowledgeLayerPlan,
-  buildRecommendationEvidencePath,
-  evaluateKnowledgeLayerRun,
-};

package/scripts/memory-store-governance.js

@@ -1,60 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-function normalizeText(value) {
-  if (value === undefined || value === null) return '';
-  return String(value).trim();
-}
-
-function classifyMemoryFile(filePath) {
-  const normalized = normalizeText(filePath).toLowerCase();
-  if (/preference|style|tone|format/.test(normalized)) return 'preference';
-  if (/credential|token|secret|password|key/.test(normalized)) return 'blocked_secret';
-  if (/task|completed|todo|draft/.test(normalized)) return 'workflow_state';
-  if (/account|customer|user|contact/.test(normalized)) return 'sensitive_context';
-  return 'general';
-}
-
-function actionForClassification(classification) {
-  if (classification === 'blocked_secret') return 'block';
-  if (classification === 'sensitive_context') return 'redact_before_export';
-  return 'allow_reviewed_promotion';
-}
-
-function buildMemoryStoreGovernance(input = {}) {
-  const files = Array.isArray(input.files) ? input.files : [];
-  const records = files.map((file) => {
-    const path = typeof file === 'string' ? file : file.path;
-    const classification = classifyMemoryFile(path);
-    return {
-      path: normalizeText(path),
-      classification,
-      promotable: !['blocked_secret', 'sensitive_context'].includes(classification),
-      action: actionForClassification(classification),
-    };
-  }).filter((record) => record.path);
-
-  return {
-    generatedAt: normalizeText(input.generatedAt) || new Date().toISOString(),
-    storeKind: 'file_backed_agent_memory',
-    records,
-    policy: {
-      export: 'allowed_after_redaction',
-      import: 'requires_schema_validation',
-      promotion: 'requires_review_and_actionable_context',
-      deletion: 'append_decision_journal_entry',
-    },
-    summary: {
-      totalFiles: records.length,
-      blocked: records.filter((record) => record.action === 'block').length,
-      redactBeforeExport: records.filter((record) => record.action === 'redact_before_export').length,
-      promotable: records.filter((record) => record.promotable).length,
-    },
-  };
-}
-
-module.exports = {
-  actionForClassification,
-  buildMemoryStoreGovernance,
-  classifyMemoryFile,
-};

package/scripts/post-training-governance.js

@@ -1,34 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-function evaluatePostTrainingPlan(input = {}) {
-  const mode = String(input.mode || '').toLowerCase();
-  const issues = [];
-  if (!['sft', 'rl', 'grpo', 'gspo'].includes(mode)) issues.push('unsupported_post_training_mode');
-  if (!input.dataset) issues.push('missing_dataset');
-  if (!input.baseCheckpoint) issues.push('missing_base_checkpoint');
-  if (input.piiRedacted !== true) issues.push('pii_redaction_required');
-  if (input.holdoutEval !== true) issues.push('holdout_eval_required');
-  if (input.rewardSpecRequired !== false && ['rl', 'grpo', 'gspo'].includes(mode) && !input.rewardSpec) {
-    issues.push('missing_reward_spec');
-  }
-  if (input.maxSpendCents === undefined) issues.push('missing_spend_cap');
-
-  return {
-    mode,
-    decision: issues.length === 0 ? 'allow' : 'warn',
-    issues,
-    requiredArtifacts: [
-      'dataset manifest',
-      'PII redaction report',
-      'base checkpoint',
-      'holdout eval report',
-      'spend cap',
-      ['rl', 'grpo', 'gspo'].includes(mode) ? 'reward specification' : null,
-    ].filter(Boolean),
-  };
-}
-
-module.exports = {
-  evaluatePostTrainingPlan,
-};

package/scripts/production-agent-readiness.js

@@ -1,40 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-function readinessStatus(score, missing) {
-  if (missing.length === 0) return 'production_ready';
-  if (score >= 60) return 'needs_hardening';
-  return 'prototype';
-}
-
-function evaluateProductionAgentReadiness(input = {}) {
-  const signals = {
-    subAgents: Array.isArray(input.subAgents) && input.subAgents.length >= 2,
-    structuredOutputs: input.structuredOutputs === true,
-    dynamicRag: input.dynamicRag === true,
-    observability: input.observability === true || input.tracing === true,
-    circuitBreakers: input.circuitBreakers === true,
-  };
-  const missing = Object.entries(signals)
-    .filter(([, present]) => !present)
-    .map(([name]) => name);
-  const score = Math.round((Object.values(signals).filter(Boolean).length / Object.keys(signals).length) * 100);
-  return {
-    status: readinessStatus(score, missing),
-    score,
-    signals,
-    missing,
-    requiredFixes: missing.map((name) => ({
-      subAgents: 'Split monolithic prompts into narrow sub-agent stages.',
-      structuredOutputs: 'Use runtime-validated schemas instead of prompt-only JSON formatting.',
-      dynamicRag: 'Replace hardcoded context with refreshed retrieval over indexed source material.',
-      observability: 'Emit traces for model calls, tool calls, tokens, latency, and stage failures.',
-      circuitBreakers: 'Set retry, timeout, loop, and spend limits before production use.',
-    }[name])),
-  };
-}
-
-module.exports = {
-  evaluateProductionAgentReadiness,
-  readinessStatus,
-};

package/scripts/scaling-law-claims.js

@@ -1,60 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-function normalizeText(value) {
-  if (value === undefined || value === null) return '';
-  return String(value).trim();
-}
-
-function classifyScalingClaim(claim) {
-  const text = normalizeText(claim).toLowerCase();
-  if (/\b(pretrain|pretraining|parameters|training tokens|flops|cross entropy|test loss)\b/.test(text)) {
-    return 'pretraining_scaling';
-  }
-  if (/\b(rl|reinforcement|feedback|dpo|kto|reward|policy|thumbs[-\s]?(up|down)|gate|prevention rule)\b/.test(text)) {
-    return 'feedback_policy_scaling';
-  }
-  return 'general_scaling';
-}
-
-function evaluateScalingClaim(input = {}) {
-  const claim = normalizeText(input.claim);
-  const claimType = classifyScalingClaim(claim);
-  const evidence = Array.isArray(input.evidence) ? input.evidence.filter(Boolean) : [];
-  const heldout = evidence.some((entry) => /held[-\s]?out|validation|eval|ablation|backtest/i.test(String(entry)));
-  const production = evidence.some((entry) => /production|real user|workflow run|decision journal|blocked action/i.test(String(entry)));
-  const rlCompute = evidence.some((entry) => /sampling compute|rollout|trajectory|policy update|reward model|rl compute/i.test(String(entry)));
-  const sampling = evidence.some((entry) => /pass@|best-of-n|majority vote|sample budget|sampling/i.test(String(entry)));
-  const issues = [];
-
-  if (!claim) issues.push('missing_claim');
-  if (claimType === 'feedback_policy_scaling' && !heldout) {
-    issues.push('missing_heldout_feedback_eval');
-  }
-  if (claimType === 'feedback_policy_scaling' && /rl|reinforcement|sampling/i.test(claim) && !rlCompute) {
-    issues.push('missing_rl_compute_evidence');
-  }
-  if (claimType === 'feedback_policy_scaling' && /sampling|best-of|vote|pass@/i.test(claim) && !sampling) {
-    issues.push('missing_sampling_budget_evidence');
-  }
-  if (claimType === 'pretraining_scaling' && evidence.length === 0) {
-    issues.push('missing_model_scaling_evidence');
-  }
-  if (/guarantee|always|never|100%|proves?/i.test(claim) && !production) {
-    issues.push('absolute_claim_without_production_evidence');
-  }
-
-  return {
-    claimType,
-    decision: issues.length === 0 ? 'allow' : 'warn',
-    issues,
-    requiredEvidence: claimType === 'feedback_policy_scaling'
-      ? ['held-out eval', 'ablation or backtest', 'RL/sampling compute budget when claimed', 'decision-journal production sample']
-      : ['source data', 'validation metric', 'scope limits'],
-  };
-}
-
-module.exports = {
-  classifyScalingClaim,
-  evaluateScalingClaim,
-};