thumbgate 1.35.0 → 1.37.2

package/scripts/codex-runbook-flywheel.js

@@ -0,0 +1,318 @@
+'use strict';
+
+/**
+ * Codex Runbook Flywheel — ThumbGate steal of OpenAI's "Automating repetitive
+ * work at OpenAI with Codex" workflow (developers.openai.com blog).
+ *
+ * The episode's loop, verbatim in spirit:
+ *   run the workflow -> document it (commands, results, dead ends,
+ *   decisions) -> the next run reuses what earlier runs learned.
+ *
+ * Four enforcement primitives, all deterministic:
+ *
+ *   1. Plan-before-act. Codex writes the plan into the notebook and WAITS
+ *      for approval before executing. -> newRunbook() starts at 'plan';
+ *      execute() refuses to run without an approved plan.
+ *
+ *   2. Consequential choices need human judgment. Automatic approval review
+ *      handles eligible actions WITHOUT changing permission boundaries.
+ *      -> autoReview() marks only bounded, reversible actions eligible;
+ *      consequential ones stay on the human queue.
+ *
+ *   3. Capture decisions that would otherwise vanish into chat history:
+ *      which option was chosen, why, what to do differently next time.
+ *      -> captureDecision() appends to a per-workflow decision log.
+ *
+ *   4. Cheap discovery for the next run: a companion index over past
+ *      runbooks (the *.index.md analog), searchable by workflow name.
+ *      -> buildIndex() / discoverContext().
+ */
+
+const RUN_STATES = Object.freeze(['plan', 'approved', 'running', 'done', 'blocked']);
+
+const CONSEQUENTIAL = Object.freeze([
+  'payment', 'external-email', 'production-deploy', 'delete', 'permission-change', 'publish',
+]);
+
+const ALLOWED_ACTIONS = Object.freeze([
+  'read-file', 'list-files', 'grep', 'search', 'read-notes',
+  'list-models', 'estimate-cost', 'check-quota',
+]);
+
+/**
+ * Create a runbook. Starts at the plan stage — execution is impossible until
+ * a human approves. Mirrors "wait for me to review and approve the plan."
+ */
+function newRunbook(workflow, goal) {
+  if (!workflow || !goal) {
+    throw new Error('runbook needs a workflow name and a goal');
+  }
+  return {
+    id: require('crypto').randomUUID(),
+    workflow,
+    goal,
+    state: 'plan',
+    plan: [],
+    decisions: [],
+    steps: [],
+    deadEnds: [],
+    createdAt: new Date().toISOString(),
+  };
+}
+
+/**
+ * Normalize a step to its stable identifier. String steps are used directly.
+ * Object steps must have an `id` property; otherwise approval is rejected.
+ * This prevents the approved-snapshot and executeStep from disagreeing due
+ * to object reference identity.
+ */
+function stepId(step) {
+  if (typeof step === 'string') return step.trim() || null;
+  if (step && typeof step === 'object' && typeof step.id === 'string' && step.id.trim()) {
+    return step.id.trim();
+  }
+  return null;
+}
+
+/**
+ * Record the plan and approve it. Approval is an explicit human act.
+ * Steps are normalized to immutable identifiers so that executeStep can
+ * match against the approved plan without relying on object reference identity.
+ */
+function approvePlan(runbook, plan, approver) {
+  if (runbook.state !== 'plan') {
+    return { ok: false, reason: `cannot approve from state "${runbook.state}"` };
+  }
+  if (!Array.isArray(plan) || plan.length === 0) {
+    return { ok: false, reason: 'an empty plan cannot be approved' };
+  }
+  if (!approver || typeof approver !== 'string' || !approver.trim()) {
+    return { ok: false, reason: 'approval requires a non-empty, trimmed string approver' };
+  }
+  // Normalize each step to a stable identifier. Object entries without a
+  // usable `id` are rejected rather than silently cloned by reference.
+  const normalized = [];
+  for (const s of plan) {
+    const id = stepId(s);
+    if (id === null) {
+      return { ok: false, reason: `step ${JSON.stringify(s)} has no stable id — reject or assign one` };
+    }
+    normalized.push(id);
+  }
+  runbook.approvedBy = approver.trim();
+  runbook.approvedPlan = Object.freeze(normalized);
+  runbook.state = 'approved';
+  runbook.approvedAt = new Date().toISOString();
+  return { ok: true, state: runbook.state };
+}
+
+/**
+ * Automatic approval review for individual actions. Uses an explicit
+ * allowlist of safe action types — fail closed for anything unlisted.
+ */
+function autoReview(action) {
+  if (!action || !action.type || typeof action.type !== 'string') {
+    return { eligible: false, reason: 'missing or invalid action type — human approval required' };
+  }
+  if (!ALLOWED_ACTIONS.includes(action.type)) {
+    return { eligible: false, reason: `"${action.type}" is unlisted — human approval required` };
+  }
+  if (CONSEQUENTIAL.includes(action.type)) {
+    return { eligible: false, reason: `"${action.type}" is consequential — human approval required` };
+  }
+  if (action.irreversible) {
+    return { eligible: false, reason: 'irreversible actions are never auto-approved' };
+  }
+  return { eligible: true, reason: 'bounded and reversible — auto-review passes' };
+}
+
+/**
+ * Execute one step. Refuses unless the plan was approved.
+ */
+function executeStep(runbook, step, outcome) {
+  if (runbook.state !== 'approved' && runbook.state !== 'running') {
+    return { ok: false, reason: `execution refused — runbook state is "${runbook.state}", not approved` };
+  }
+  if (!Array.isArray(runbook.approvedPlan)) {
+    return { ok: false, reason: 'execution refused — no approved plan snapshot on record' };
+  }
+  if (!runbook.approvedPlan.includes(stepId(step))) {
+    return { ok: false, reason: `execution refused — "${step}" is not in the approved plan` };
+  }
+  runbook.state = 'running';
+  runbook.steps.push({ step, outcome: outcome || 'ok', at: new Date().toISOString() });
+  return { ok: true, executed: runbook.steps.length };
+}
+
+/**
+ * Capture a decision that would otherwise disappear into chat history.
+ */
+function captureDecision(runbook, decision) {
+  if (!decision || !decision.choice || !decision.reason) {
+    return { ok: false, reason: 'a decision needs both a choice and a reason' };
+  }
+  runbook.decisions.push({
+    choice: decision.choice,
+    reason: decision.reason,
+    nextTime: decision.nextTime || null,
+    at: new Date().toISOString(),
+  });
+  return { ok: true, decisions: runbook.decisions.length };
+}
+
+/**
+ * Mark a dead end — the article documents these on purpose so the next run
+ * doesn't repeat them.
+ */
+function recordDeadEnd(runbook, deadEnd) {
+  runbook.deadEnds.push({ deadEnd, at: new Date().toISOString() });
+  return { deadEnds: runbook.deadEnds.length };
+}
+
+/**
+ * Close the runbook. Only a running/approved runbook can close, and only
+ * with at least one recorded step.
+ */
+function closeRunbook(runbook) {
+  if (runbook.state !== 'approved' && runbook.state !== 'running') {
+    return { ok: false, reason: `cannot close from state "${runbook.state}"` };
+  }
+  if (runbook.steps.length === 0) {
+    return { ok: false, reason: 'cannot close a runbook with no recorded steps' };
+  }
+  runbook.state = 'done';
+  runbook.completedAt = new Date().toISOString();
+  return { ok: true, state: 'done' };
+}
+
+/**
+ * Build the companion index over completed runbooks (the *.index.md analog).
+ * Full decision and dead-end records are stored alongside counts so later
+ * runs can reuse the captured guidance.
+ */
+function buildIndex(runbooks) {
+  return (runbooks || [])
+    .filter((r) => r.state === 'done')
+    .map((r) => ({
+      workflow: r.workflow,
+      goal: r.goal,
+      steps: r.steps.length,
+      decisions: r.decisions.length,
+      deadEnds: r.deadEnds.length,
+      decisionsLog: r.decisions.map((d) => ({ ...d })),
+      deadEndsLog: r.deadEnds.map((d) => ({ ...d })),
+      completedAt: r.completedAt,
+    }));
+}
+
+/**
+ * Discover prior context for a workflow — what earlier runs learned.
+ * Returns the full decision and dead-end records so callers can act on
+ * the captured guidance, not just counts.
+ */
+function discoverContext(index, workflow) {
+  const prior = (index || []).filter((e) => e.workflow === workflow);
+  return {
+    workflow,
+    priorRuns: prior.length,
+    totalDecisions: prior.reduce((n, e) => n + e.decisions, 0),
+    totalDeadEnds: prior.reduce((n, e) => n + e.deadEnds, 0),
+    decisions: prior.flatMap((e) => (e.decisionsLog || []).map((d) => ({ ...d }))),
+    deadEnds: prior.flatMap((e) => (e.deadEndsLog || []).map((d) => ({ ...d }))),
+    reusable: prior.length > 0,
+  };
+}
+
+function isCliEntrypoint() {
+  return require.main === module;
+}
+
+function parseCliArgs(argv) {
+  const args = argv.slice(2);
+  const mode = { dryRun: false, solve: false };
+  for (const arg of args) {
+    if (arg === '--dry-run') mode.dryRun = true;
+    else if (arg === '--solve') mode.solve = true;
+  }
+  return mode;
+}
+
+function main() {
+  const { dryRun, solve } = parseCliArgs(process.argv);
+  const rb = newRunbook('model-eval', 'Run the evaluation against the current model');
+
+  const premature = executeStep(rb, 'run eval'); // must refuse
+  approvePlan(rb, ['review previous run', 'write plan', 'run eval', 'document'], 'igor');
+  const review = { auto: autoReview({ type: 'read-file' }), blocked: autoReview({ type: 'production-deploy' }) };
+
+  if (dryRun) {
+    // Dry-run mode: do not record execution steps or complete the runbook.
+    // Surface the plan and auto-review decisions only.
+    process.stdout.write(JSON.stringify({
+      mode: 'dry-run',
+      honesty: 'deterministic model of the OpenAI Codex+Runme runbook flywheel',
+      source: 'https://developers.openai.com/blog/automating-repetitive-work-at-openai-with-codex',
+      prematureExecution: premature,
+      autoReview: review,
+      approvedPlan: rb.approvedPlan,
+      state: rb.state,
+    }, null, 2) + '\n');
+    return;
+  }
+
+  if (solve) {
+    // Solve mode: execute the approved plan end-to-end.
+    return runSolve(rb, review, premature);
+  }
+
+  // Default mode: execute the approved plan end-to-end.
+  runSolve(rb, review, premature);
+}
+
+function runSolve(rb, review, premature) {
+  executeStep(rb, 'review previous run', 'ok');
+  executeStep(rb, 'run eval', 'ok');
+  captureDecision(rb, {
+    choice: 'reuse existing eval cluster',
+    reason: 'quota exhausted on new provisioning',
+    nextTime: 'check quota before provisioning',
+  });
+  recordDeadEnd(rb, 'new cluster provisioning — quota exhausted');
+  closeRunbook(rb);
+
+  const index = buildIndex([rb]);
+  const context = discoverContext(index, 'model-eval');
+
+  process.stdout.write(JSON.stringify({
+    mode: 'solve',
+    honesty: 'deterministic model of the OpenAI Codex+Runme runbook flywheel',
+    source: 'https://developers.openai.com/blog/automating-repetitive-work-at-openai-with-codex',
+    prematureExecution: premature,
+    autoReview: review,
+    finalState: rb.state,
+    decisions: rb.decisions.length,
+    deadEnds: rb.deadEnds.length,
+    decisionsLog: rb.decisions,
+    deadEndsLog: rb.deadEnds,
+    index, context,
+  }, null, 2) + '\n');
+}
+
+if (isCliEntrypoint()) main();
+
+module.exports = {
+  RUN_STATES,
+  CONSEQUENTIAL,
+  ALLOWED_ACTIONS,
+  stepId,
+  newRunbook,
+  approvePlan,
+  autoReview,
+  executeStep,
+  captureDecision,
+  recordDeadEnd,
+  closeRunbook,
+  buildIndex,
+  discoverContext,
+  isCliEntrypoint,
+};

package/scripts/colab-compute-honesty.js

@@ -0,0 +1,281 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Colab signup FORMAT steal — not a Colab clone, not a GPU SKU.
+ *
+ * Live source 2026-09-17 (BrowserOS, iganapolsky@gmail.com):
+ *   https://colab.research.google.com/signup
+ *   Pay As You Go $9.99/100 CU and $49.99/500 CU (buttons disabled on this account)
+ *   Colab Pro $9.99/mo and Pro+ $49.99/mo still show Subscribe
+ *   "See current plan" is Google AI Plans — not proof of Pro+
+ *
+ * Transfers:
+ *   1. Free exists; paid buys Compute Units, not a dedicated GPU
+ *   2. Subscribe-button visible ≠ already subscribed
+ *   3. Background / 24h execution is a Pro+ receipt, not a default
+ *
+ * Does not buy Colab Pro/Pro+/PAYG. Does not install colab-cli.
+ * ThumbGate evals stay on GitHub Actions.
+ */
+
+const path = require('node:path');
+
+const SOURCE_URL = 'https://colab.research.google.com/signup';
+
+const PLANS = Object.freeze({
+  free: { monthlyUsd: 0, includedCu: 0, backgroundHours: 0 },
+  payg: { monthlyUsd: 0, includedCu: 0, backgroundHours: 0, packs: [[9.99, 100], [49.99, 500]] },
+  pro: { monthlyUsd: 9.99, includedCu: 100, backgroundHours: 0 },
+  proplus: { monthlyUsd: 49.99, includedCu: 600, backgroundHours: 24 },
+  enterprise: { monthlyUsd: null, includedCu: null, backgroundHours: null },
+  unknown: { monthlyUsd: null, includedCu: null, backgroundHours: 0 },
+});
+
+const CLONE_RE = /\b(colab-cli|google-colab-pro-runner|ngrok.*colab|colab.*ssh|zero-cost a100|free a100)\b/i;
+const PAID_FEATURE_RE = /\b(pro\+|proplus|a100|v100|background execution|24\s*hours?|high-?ram|premium gpu|compute units?)\b/i;
+const BUY_RE = /\b(buy|subscribe|purchase).{0,40}(colab pro|pro\+|compute units?)\b/i;
+
+const RAIL_MAP = Object.freeze([
+  { colab: 'Free always exists; paid is extra CU', thumbgate: 'Do not claim hosted GPU/A100 as the product' },
+  { colab: 'Subscribe button visible ≠ already subscribed', thumbgate: 'Require --plan-proof before Pro/Pro+ claims' },
+  { colab: 'CU packs ($9.99/100, $49.99/500) expire; CU ≠ dedicated GPU', thumbgate: 'Hours remaining need hardware class + CU rate; else fail closed' },
+  { colab: 'Background 24h is Pro+', thumbgate: 'GitHub Actions remains the eval runner; no Colab offload SKU' },
+]);
+
+function normalizeBoolean(value) {
+  if (value === true || value === 1) return true;
+  if (value === false || value === 0 || value == null) return false;
+  return /^(1|true|yes|on)$/i.test(String(value).trim());
+}
+
+function parseSnapshot(raw) {
+  if (!raw) return null;
+  if (typeof raw === 'object') return raw;
+  try {
+    return JSON.parse(String(raw));
+  } catch {
+    return { parseError: true };
+  }
+}
+
+function normalizeOptions(raw = {}) {
+  const plan = String(raw.plan || 'unknown').toLowerCase().replace('pro+', 'proplus');
+  return {
+    claim: String(raw.claim || ''),
+    plan: Object.prototype.hasOwnProperty.call(PLANS, plan) ? plan : 'unknown',
+    planProof: raw['plan-proof'] || raw.planProof || null,
+    snapshot: parseSnapshot(raw.snapshot || raw['signup-snapshot']),
+    cloneColab: normalizeBoolean(raw['clone-colab'] || raw.cloneColab),
+    buyPro: normalizeBoolean(raw['buy-pro'] || raw.buyPro),
+    mapOnly: normalizeBoolean(raw['map-only'] || raw.mapOnly),
+    claimReady: normalizeBoolean(raw['claim-ready'] || raw.claimReady),
+    json: normalizeBoolean(raw.json),
+    strict: normalizeBoolean(raw.strict),
+  };
+}
+
+function buildColabComputeHonestyReport(rawOptions = {}) {
+  const options = normalizeOptions(rawOptions);
+  const findings = [];
+  const claim = options.claim;
+  const snapshot = options.snapshot && !options.snapshot.parseError ? options.snapshot : null;
+
+  if (options.snapshot && options.snapshot.parseError) {
+    findings.push({
+      id: 'snapshot_parse_error',
+      severity: 'fail',
+      gateId: 'require-compute-unit-proof',
+      message: 'Signup snapshot JSON did not parse.',
+    });
+  }
+
+  if (options.cloneColab || CLONE_RE.test(claim)) {
+    findings.push({
+      id: 'colab_sku_clone',
+      severity: 'fail',
+      gateId: 'refuse-colab-sku-clone',
+      message: 'Refused Colab clone (colab-cli, ngrok/SSH, zero-cost A100, or a Colab-runner SKU).',
+    });
+  }
+
+  if (options.buyPro || BUY_RE.test(claim)) {
+    findings.push({
+      id: 'colab_spend_refused',
+      severity: 'fail',
+      gateId: 'refuse-colab-sku-clone',
+      message: 'Refused buying Colab Pro/Pro+/Compute Units from this doctor. No surprise spend.',
+    });
+  }
+
+  const wantsPaid = PAID_FEATURE_RE.test(claim);
+  const proof = options.planProof ? String(options.planProof).toLowerCase().replace('pro+', 'proplus') : null;
+  if (wantsPaid && !options.mapOnly) {
+    if (!proof || proof === 'unknown' || proof === 'free') {
+      findings.push({
+        id: 'paid_feature_without_plan_proof',
+        severity: 'fail',
+        gateId: 'require-compute-unit-proof',
+        message: 'Paid Colab features (Pro/Pro+/A100/CU/24h background) need --plan-proof from a live Current-plan receipt, not a Subscribe button.',
+      });
+    }
+  }
+
+  if (snapshot && snapshot.proSubscribeVisible && (proof === 'pro' || proof === 'proplus' || /pro\+|proplus/i.test(claim))) {
+    findings.push({
+      id: 'subscribe_button_is_not_receipt',
+      severity: 'fail',
+      gateId: 'require-compute-unit-proof',
+      message: 'Live signup still shows Subscribe on Pro/Pro+. That is not proof the account is subscribed.',
+    });
+  }
+
+  if (/24\s*hour|background execution/i.test(claim) && proof !== 'proplus') {
+    findings.push({
+      id: 'background_requires_proplus',
+      severity: 'fail',
+      gateId: 'require-compute-unit-proof',
+      message: '24h background execution is a Pro+ receipt on the signup page, not Free/Pro/PAYG.',
+    });
+  }
+
+  if (options.claimReady && findings.some((f) => f.severity === 'fail')) {
+    findings.push({
+      id: 'claim_without_compute_proof',
+      severity: 'fail',
+      gateId: 'require-compute-unit-proof',
+      message: 'Claimed Colab compute ready without plan proof.',
+    });
+  }
+
+  const seen = new Set();
+  const deduped = [];
+  for (const f of findings) {
+    if (seen.has(f.id)) continue;
+    seen.add(f.id);
+    deduped.push(f);
+  }
+
+  const failCount = deduped.filter((f) => f.severity === 'fail').length;
+  let status = 'ready';
+  if (failCount > 0) status = 'fail';
+
+  return {
+    name: 'thumbgate-colab-compute-honesty',
+    ok: status !== 'fail',
+    status,
+    source: SOURCE_URL,
+    disclaimer:
+      'FORMAT steal from Colab paid signup (CU packs, subscribe≠receipt, 24h background is Pro+). Not affiliated with Google Colab. Does not buy a plan or clone a notebook GPU SKU.',
+    observed: {
+      account: snapshot && snapshot.account,
+      paygDisabled: snapshot ? Boolean(snapshot.paygDisabled) : null,
+      proSubscribeVisible: snapshot ? Boolean(snapshot.proSubscribeVisible) : null,
+      proPlusSubscribeVisible: snapshot ? Boolean(snapshot.proPlusSubscribeVisible) : null,
+    },
+    plans: PLANS,
+    plan: options.plan,
+    planProof: proof,
+    map: options.mapOnly ? RAIL_MAP : undefined,
+    findings: deduped,
+    summary: { failCount, findingCount: deduped.length },
+    recommendedGates: [...new Set(deduped.map((f) => f.gateId).filter(Boolean))],
+    nextActions: [
+      'Keep ThumbGate evals on GitHub Actions. Do not offload PreToolUse to Colab.',
+      'Treat Subscribe on /signup as not-subscribed until a Current-plan receipt exists.',
+      'Do not buy Pro/Pro+/CU from an agent session.',
+      'Pair with gates require-compute-unit-proof and refuse-colab-sku-clone.',
+    ],
+    exampleCommand: 'npx thumbgate colab-compute-honesty --json --map-only',
+  };
+}
+
+function formatColabComputeHonestyReport(report) {
+  const lines = [
+    '',
+    'ThumbGate Colab Compute-Honesty Doctor',
+    '-'.repeat(48),
+    `Status : ${report.status}`,
+    `Plan   : ${report.plan}  proof=${report.planProof || '(none)'}`,
+    `Source : ${report.source}`,
+    `Findings: ${report.summary.findingCount} (fail=${report.summary.failCount})`,
+  ];
+  if (report.map) {
+    lines.push('', 'Rail map:');
+    for (const row of report.map) lines.push(`  - ${row.colab} → ${row.thumbgate}`);
+  }
+  if (report.findings.length) {
+    lines.push('', 'Findings:');
+    for (const f of report.findings) {
+      lines.push(`  - [${f.severity}] ${f.id}${f.gateId ? ` [${f.gateId}]` : ''}`);
+      lines.push(`    ${f.message}`);
+    }
+  }
+  lines.push('', 'Next actions:');
+  for (const a of report.nextActions) lines.push(`  - ${a}`);
+  lines.push('', `Example: ${report.exampleCommand}`);
+  lines.push(`Note: ${report.disclaimer}`, '');
+  return `${lines.join('\n')}\n`;
+}
+
+function parseCliArgs(argv) {
+  const options = {};
+  for (const arg of argv) {
+    if (arg === '--json') { options.json = true; continue; }
+    if (arg === '--strict') { options.strict = true; continue; }
+    if (arg === '--map-only') { options['map-only'] = true; continue; }
+    if (arg === '--claim-ready') { options['claim-ready'] = true; continue; }
+    if (arg === '--clone-colab') { options['clone-colab'] = true; continue; }
+    if (arg === '--buy-pro') { options['buy-pro'] = true; continue; }
+    if (arg === '--help' || arg === '-h') { options.help = true; continue; }
+    const m = /^--([^=]+)(?:=(.*))?$/.exec(arg);
+    if (!m) continue;
+    options[m[1]] = m[2] === undefined ? true : m[2];
+  }
+  return options;
+}
+
+function printHelp() {
+  process.stdout.write(`Usage: node scripts/colab-compute-honesty.js [flags]
+
+Flags:
+  --claim=TEXT             Claim to audit
+  --plan=free|payg|pro|proplus|unknown
+  --plan-proof=PLAN        Live Current-plan receipt (not a Subscribe button)
+  --snapshot=JSON          Live /signup snapshot
+  --map-only
+  --claim-ready
+  --clone-colab            Always fail
+  --buy-pro                Always fail (no surprise spend)
+  --json --strict
+
+Source: ${SOURCE_URL}
+`);
+}
+
+function runCli(argv = process.argv.slice(2)) {
+  const args = parseCliArgs(argv);
+  if (args.help) {
+    printHelp();
+    return 0;
+  }
+  const report = buildColabComputeHonestyReport(args);
+  if (args.json) process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+  else process.stdout.write(formatColabComputeHonestyReport(report));
+  if (args.strict && report.status !== 'ready') return 1;
+  if (report.status === 'fail') return 1;
+  return 0;
+}
+
+module.exports = {
+  SOURCE_URL,
+  PLANS,
+  RAIL_MAP,
+  buildColabComputeHonestyReport,
+  formatColabComputeHonestyReport,
+  runCli,
+};
+
+if (path.resolve(process.argv[1] || '') === path.resolve(__filename)) {
+  process.exitCode = runCli();
+}