thumbgate 0.9.9

package/plugins/claude-codex-bridge/scripts/codex-bridge.js

@@ -0,0 +1,288 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+function getPluginRoot() {
+  return process.env.CLAUDE_PLUGIN_ROOT || path.resolve(__dirname, '..');
+}
+
+function getDataRoot() {
+  return process.env.CLAUDE_PLUGIN_DATA || path.join(getPluginRoot(), '.codex-bridge-data');
+}
+
+function getRunsDir() {
+  return path.join(getDataRoot(), 'runs');
+}
+
+function getCodexBin() {
+  return process.env.THUMBGATE_CODEX_BIN || 'codex';
+}
+
+function ensureDir(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true });
+}
+
+function readJson(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+function writeJson(filePath, payload) {
+  fs.writeFileSync(filePath, `${JSON.stringify(payload, null, 2)}\n`);
+}
+
+function parseArgs(argv) {
+  const parsed = {
+    _: [],
+  };
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (!token.startsWith('--')) {
+      parsed._.push(token);
+      continue;
+    }
+    const key = token.slice(2);
+    const next = argv[index + 1];
+    if (!next || next.startsWith('--')) {
+      parsed[key] = true;
+      continue;
+    }
+    parsed[key] = next;
+    index += 1;
+  }
+  return parsed;
+}
+
+function runCommand(command, args, options = {}) {
+  return spawnSync(command, args, {
+    cwd: options.cwd || process.cwd(),
+    encoding: 'utf8',
+    env: { ...process.env, ...(options.env || {}) },
+  });
+}
+
+function resolveLatestMetadataPath() {
+  return path.join(getRunsDir(), 'latest.json');
+}
+
+function resolveLatestMessagePath() {
+  return path.join(getRunsDir(), 'latest.md');
+}
+
+function loadLatestRun() {
+  const latestPath = resolveLatestMetadataPath();
+  if (!fs.existsSync(latestPath)) {
+    return null;
+  }
+  return readJson(latestPath);
+}
+
+function getDefaultPrompt(mode) {
+  if (mode === 'adversarial-review') {
+    return 'Act as a skeptical adversarial reviewer. Hunt for hidden regressions, rollback risk, security mistakes, broken assumptions, and missing proof. Prefer precise findings over broad summaries.';
+  }
+  if (mode === 'second-pass') {
+    return 'Take a second pass on the current task from this repository. Be independent, concrete, and skeptical. If changes are warranted, explain the minimal patch or next action.';
+  }
+  return 'Review the current changes for correctness, regressions, missing tests, security issues, and release risk. Keep the output concise and actionable.';
+}
+
+function buildCodexArgs(mode, options, lastMessagePath) {
+  if (mode === 'second-pass') {
+    const args = ['exec', '--json', '--output-last-message', lastMessagePath];
+    if (options.model) {
+      args.push('--model', options.model);
+    }
+    args.push(options.prompt || getDefaultPrompt(mode));
+    return args;
+  }
+
+  const args = ['exec', 'review', '--json', '--output-last-message', lastMessagePath];
+  if (options.model) {
+    args.push('--model', options.model);
+  }
+  if (options.base) {
+    args.push('--base', options.base);
+  } else if (options.commit) {
+    args.push('--commit', options.commit);
+  } else {
+    args.push('--uncommitted');
+  }
+  if (options.title) {
+    args.push('--title', options.title);
+  }
+  args.push(options.prompt || getDefaultPrompt(mode));
+  return args;
+}
+
+function saveRun(mode, codexArgs, result, lastMessagePath) {
+  ensureDir(getRunsDir());
+
+  const timestamp = new Date().toISOString();
+  const runId = `${timestamp.replace(/[:.]/g, '-')}-${mode}`;
+  const eventsPath = path.join(getRunsDir(), `${runId}.jsonl`);
+  const metadataPath = path.join(getRunsDir(), `${runId}.json`);
+  const latestMetadataPath = resolveLatestMetadataPath();
+  const latestMessagePath = resolveLatestMessagePath();
+  const lastMessage = fs.existsSync(lastMessagePath) ? fs.readFileSync(lastMessagePath, 'utf8') : '';
+
+  fs.writeFileSync(eventsPath, result.stdout || '');
+  if (lastMessage) {
+    fs.writeFileSync(latestMessagePath, lastMessage);
+  } else if (!fs.existsSync(latestMessagePath)) {
+    fs.writeFileSync(latestMessagePath, '');
+  }
+
+  const metadata = {
+    ok: result.status === 0,
+    mode,
+    runId,
+    createdAt: timestamp,
+    cwd: process.cwd(),
+    codexBin: getCodexBin(),
+    command: [getCodexBin(), ...codexArgs],
+    exitCode: result.status,
+    signal: result.signal || null,
+    stderr: result.stderr || '',
+    eventsPath,
+    lastMessagePath: fs.existsSync(lastMessagePath) ? lastMessagePath : null,
+    latestMessagePath,
+  };
+
+  writeJson(metadataPath, metadata);
+  writeJson(latestMetadataPath, metadata);
+  return {
+    metadata,
+    lastMessage,
+  };
+}
+
+function commandSetup() {
+  const pluginRoot = getPluginRoot();
+  const dataRoot = getDataRoot();
+  const mcpConfigPath = path.join(pluginRoot, '.mcp.json');
+  const versionResult = runCommand(getCodexBin(), ['--version']);
+  const reviewHelpResult = runCommand(getCodexBin(), ['exec', 'review', '--help']);
+  const execHelpResult = runCommand(getCodexBin(), ['exec', '--help']);
+  const payload = {
+    ok: versionResult.status === 0 && reviewHelpResult.status === 0 && execHelpResult.status === 0,
+    codexBin: getCodexBin(),
+    codexInstalled: versionResult.status === 0,
+    codexVersion: (versionResult.stdout || '').trim(),
+    reviewCommand: reviewHelpResult.status === 0,
+    execCommand: execHelpResult.status === 0,
+    pluginRoot,
+    dataDir: dataRoot,
+    mcpConfigPath,
+    mcpConfigPresent: fs.existsSync(mcpConfigPath),
+  };
+  console.log(JSON.stringify(payload, null, 2));
+  if (!payload.ok) {
+    process.exitCode = 1;
+  }
+}
+
+function commandStatus() {
+  const latest = loadLatestRun();
+  if (!latest) {
+    console.log(JSON.stringify({
+      ok: false,
+      message: 'No Codex bridge run has been saved yet.',
+      dataDir: getDataRoot(),
+    }, null, 2));
+    process.exitCode = 1;
+    return;
+  }
+  console.log(JSON.stringify(latest, null, 2));
+}
+
+function commandResult() {
+  const latestPath = resolveLatestMessagePath();
+  if (!fs.existsSync(latestPath)) {
+    console.error('No saved Codex bridge result found.');
+    process.exitCode = 1;
+    return;
+  }
+  process.stdout.write(fs.readFileSync(latestPath, 'utf8'));
+}
+
+function commandRun(mode, options) {
+  ensureDir(getRunsDir());
+  const lastMessagePath = path.join(getRunsDir(), `${mode}-working.md`);
+  const codexArgs = buildCodexArgs(mode, options, lastMessagePath);
+  const result = runCommand(getCodexBin(), codexArgs);
+  const saved = saveRun(mode, codexArgs, result, lastMessagePath);
+
+  if (result.status !== 0) {
+    const message = [
+      `Codex ${mode} failed.`,
+      saved.metadata.stderr || 'No stderr captured.',
+      `Saved metadata: ${saved.metadata.eventsPath}`,
+    ].join('\n');
+    console.error(message);
+    process.exitCode = result.status || 1;
+    return;
+  }
+
+  if (saved.lastMessage.trim()) {
+    process.stdout.write(saved.lastMessage);
+    if (!saved.lastMessage.endsWith('\n')) {
+      process.stdout.write('\n');
+    }
+  }
+  process.stdout.write(`\nSaved metadata: ${resolveLatestMetadataPath()}\n`);
+}
+
+function main() {
+  const parsed = parseArgs(process.argv.slice(2));
+  const command = parsed._[0];
+  const prompt = parsed.prompt || parsed._.slice(1).join(' ').trim() || '';
+
+  switch (command) {
+    case 'setup':
+      commandSetup();
+      return;
+    case 'status':
+      commandStatus();
+      return;
+    case 'result':
+      commandResult();
+      return;
+    case 'review':
+    case 'adversarial-review':
+    case 'second-pass':
+      commandRun(command, {
+        base: parsed.base,
+        commit: parsed.commit,
+        uncommitted: parsed.uncommitted === true,
+        title: parsed.title,
+        model: parsed.model,
+        prompt,
+      });
+      return;
+    default:
+      console.error([
+        'Usage:',
+        '  node plugins/claude-codex-bridge/scripts/codex-bridge.js setup',
+        '  node plugins/claude-codex-bridge/scripts/codex-bridge.js review [--uncommitted|--base main|--commit <sha>] [--prompt "..."]',
+        '  node plugins/claude-codex-bridge/scripts/codex-bridge.js adversarial-review [--uncommitted|--base main|--commit <sha>] [--prompt "..."]',
+        '  node plugins/claude-codex-bridge/scripts/codex-bridge.js second-pass --prompt "..."',
+        '  node plugins/claude-codex-bridge/scripts/codex-bridge.js status',
+        '  node plugins/claude-codex-bridge/scripts/codex-bridge.js result',
+      ].join('\n'));
+      process.exitCode = 1;
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  buildCodexArgs,
+  getDataRoot,
+  getPluginRoot,
+  loadLatestRun,
+  parseArgs,
+};

package/plugins/claude-codex-bridge/skills/adversarial-review/SKILL.md

@@ -0,0 +1,24 @@
+---
+name: adversarial-review
+description: Run a skeptical Codex review from Claude Code that hunts for hidden regressions, unsafe assumptions, and release risk. Use before merges, deploys, migrations, or other risky changes.
+---
+
+# Adversarial Review
+
+Default to the current uncommitted workspace unless the user explicitly provides `base=<branch>` or `commit=<sha>`.
+
+Run one of:
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/scripts/codex-bridge.js" adversarial-review --uncommitted
+node "${CLAUDE_PLUGIN_ROOT}/scripts/codex-bridge.js" adversarial-review --base main
+node "${CLAUDE_PLUGIN_ROOT}/scripts/codex-bridge.js" adversarial-review --commit <sha>
+```
+
+If the user asks for a specific threat model such as security, rollback safety, billing, or data loss, pass that in `--prompt`.
+
+When reporting back:
+
+- lead with concrete risks
+- separate proven issues from speculation
+- mention the saved artifact path if the user wants the full Codex output

package/plugins/claude-codex-bridge/skills/result/SKILL.md

@@ -0,0 +1,22 @@
+---
+name: result
+description: Print the latest saved Codex bridge result from Claude Code without rerunning Codex. Use when the user asks for the last Codex output or wants to inspect the raw bridge result.
+---
+
+# Result
+
+Run:
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/scripts/codex-bridge.js" result
+```
+
+If a result exists:
+
+- show the raw saved output
+- do not rerun Codex unless the user explicitly asks for a fresh pass
+
+If no result exists:
+
+- state that no saved artifact exists yet
+- suggest running `/codex-bridge:review`, `/codex-bridge:adversarial-review`, or `/codex-bridge:second-pass`

package/plugins/claude-codex-bridge/skills/review/SKILL.md

@@ -0,0 +1,28 @@
+---
+name: review
+description: Run a Codex review from Claude Code against the current uncommitted work, a base branch diff, or a specific commit. Use when the user explicitly asks for a Codex review or second reviewer.
+---
+
+# Review
+
+When this skill is invoked, translate the request into one of these bridge calls:
+
+- default: current uncommitted work
+- `base=<branch>`: compare against a branch such as `main`
+- `commit=<sha>`: review one commit
+
+Prefer these forms:
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/scripts/codex-bridge.js" review --uncommitted
+node "${CLAUDE_PLUGIN_ROOT}/scripts/codex-bridge.js" review --base main
+node "${CLAUDE_PLUGIN_ROOT}/scripts/codex-bridge.js" review --commit <sha>
+```
+
+If the user gave a focus area, pass it as `--prompt "..."`.
+
+After the bridge returns:
+
+1. summarize the highest-signal findings
+2. mention the saved artifact path if the user may want to inspect the raw result
+3. do not pretend Codex found issues if the result says no issues

package/plugins/claude-codex-bridge/skills/second-pass/SKILL.md

@@ -0,0 +1,27 @@
+---
+name: second-pass
+description: Hand the current task or repo state to Codex for an independent second pass from inside Claude Code. Use when the user explicitly wants another agent to take a shot after Claude's first pass.
+---
+
+# Second Pass
+
+Use this skill only when the user explicitly asks for a Codex handoff or second pass.
+
+Build a concise task prompt from the user request and current repo context, then run:
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/scripts/codex-bridge.js" second-pass --prompt "<task prompt>"
+```
+
+Good task prompts are concrete:
+
+- what changed
+- what still looks risky
+- what Codex should do next
+- whether the user wants edits, a plan, or just a review
+
+After the bridge returns:
+
+1. summarize what Codex recommended or changed
+2. mention the saved artifact path if the user wants the raw result
+3. keep Claude's own judgment separate from Codex's output

package/plugins/claude-codex-bridge/skills/setup/SKILL.md

@@ -0,0 +1,21 @@
+---
+name: setup
+description: Validate that the Codex bridge plugin is ready inside Claude Code. Use when the user asks to install, configure, or sanity-check Codex review from Claude.
+---
+
+# Setup
+
+Use this skill only when the user explicitly wants to verify the bridge.
+
+Run:
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/scripts/codex-bridge.js" setup
+```
+
+Then explain:
+
+- whether `codex` is installed
+- whether `codex exec review` is available
+- where the persistent bridge artifact directory lives
+- whether ThumbGate's bundled `rlhf` MCP server config is present

package/plugins/claude-codex-bridge/skills/status/SKILL.md

@@ -0,0 +1,19 @@
+---
+name: status
+description: Show the latest Codex bridge artifact metadata from Claude Code. Use when the user asks whether the bridge already ran, what mode it used, or where the result was saved.
+---
+
+# Status
+
+Run:
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/scripts/codex-bridge.js" status
+```
+
+Summarize:
+
+- latest mode
+- timestamp
+- exit status
+- artifact paths

package/plugins/claude-skill/INSTALL.md

@@ -0,0 +1,55 @@
+# Claude Code: ThumbGate Feedback Skill Install
+
+Install the skill in under 60 seconds. No manual file editing required.
+
+## One-Command Install
+
+```bash
+cp plugins/claude-skill/SKILL.md .claude/skills/rlhf-feedback.md
+```
+
+Or from the published npm package:
+
+```bash
+npx thumbgate init
+cp node_modules/thumbgate/plugins/claude-skill/SKILL.md .claude/skills/rlhf-feedback.md
+```
+
+## What This Does
+
+Copies the skill definition to `.claude/skills/` so Claude Code loads it automatically on next launch.
+
+The skill activates on triggers: "thumbs up", "thumbs down", "that worked", "that failed".
+
+## Verify
+
+After copying, restart Claude Code and run:
+
+```bash
+# Claude Code will show available skills:
+# rlhf-feedback — Capture thumbs up/down feedback into structured memories
+```
+
+Then test it:
+
+```bash
+node .thumbgate/capture-feedback.js --feedback=up --context="skill install verified" --tags="install"
+```
+
+## What You Get
+
+- Automatic feedback capture on quality signals
+- Prevention rules generated from repeated mistakes
+- Session-start context loading: `npm run feedback:summary && npm run feedback:rules`
+
+## Requirements
+
+- Claude Code (any version)
+- Node.js 18+ in PATH
+- `.thumbgate/` directory (created by `npx thumbgate init`)
+
+## Uninstall
+
+```bash
+rm .claude/skills/rlhf-feedback.md
+```

package/plugins/claude-skill/SKILL.md

@@ -0,0 +1,46 @@
+---
+name: rlhf-feedback
+description: >
+  Capture thumbs up/down feedback into structured memories and prevention rules.
+  Use when user gives explicit quality signals about agent work (e.g. "that worked",
+  "that failed", "thumbs up/down"). Do NOT use for general questions, code generation,
+  file operations, or any task that is not explicit feedback on prior agent output.
+triggers:
+  - thumbs up
+  - thumbs down
+  - that worked
+  - that failed
+negative_triggers:
+  - generate code
+  - search files
+  - explain this
+  - run tests
+---
+
+# ThumbGate Feedback Skill
+
+When user provides feedback, execute:
+
+```bash
+# negative
+node .claude/scripts/feedback/capture-feedback.js \
+  --feedback=down \
+  --context="<what failed>" \
+  --what-went-wrong="<specific failure>" \
+  --what-to-change="<prevention action>" \
+  --tags="<domain>,regression"
+
+# positive
+node .claude/scripts/feedback/capture-feedback.js \
+  --feedback=up \
+  --context="<what succeeded>" \
+  --what-worked="<repeatable pattern>" \
+  --tags="<domain>,fix"
+```
+
+At session start, run:
+
+```bash
+npm run feedback:summary
+npm run feedback:rules
+```

package/plugins/codex-profile/.codex-plugin/plugin.json

@@ -0,0 +1,43 @@
+{
+  "name": "codex-profile",
+  "version": "0.9.9",
+  "description": "ThumbGate for Codex: pre-action gates, skill packs, hallucination detection, PII scanning, progressive disclosure (82% token savings), and MCP-backed reliability memory.",
+  "author": {
+    "name": "Igor Ganapolsky",
+    "url": "https://github.com/IgorGanapolsky"
+  },
+  "homepage": "https://thumbgate-production.up.railway.app",
+  "repository": "https://github.com/IgorGanapolsky/ThumbGate",
+  "license": "MIT",
+  "keywords": [
+    "codex",
+    "codex-plugin",
+    "thumbgate",
+    "pre-action-gates",
+    "feedback",
+    "mcp",
+    "agent-reliability"
+  ],
+  "mcpServers": "./.mcp.json",
+  "interface": {
+    "displayName": "ThumbGate for Codex",
+    "shortDescription": "Pre-action gates + skill packs + hallucination detection for Codex.",
+    "longDescription": "Adds ThumbGate's pre-action gates, domain skill packs (Stripe, Railway, DB), hallucination detection, PII scanning, progressive disclosure (82% token savings), and MCP reliability memory to Codex workflows.",
+    "developerName": "Igor Ganapolsky",
+    "category": "Developer Tools",
+    "capabilities": [
+      "Interactive",
+      "Write"
+    ],
+    "websiteURL": "https://thumbgate-production.up.railway.app",
+    "privacyPolicyURL": "https://thumbgate-production.up.railway.app/privacy",
+    "termsOfServiceURL": "https://github.com/IgorGanapolsky/ThumbGate/blob/main/LICENSE",
+    "defaultPrompt": [
+      "Load ThumbGate skill packs before a risky Codex task.",
+      "Capture a thumbs down with context after a mistake.",
+      "Check prevention gates before a deploy or publish.",
+      "Run the eval harness to measure before/after impact."
+    ],
+    "brandColor": "#0ea5e9"
+  }
+}

package/plugins/codex-profile/.mcp.json

@@ -0,0 +1,12 @@
+{
+  "mcpServers": {
+    "rlhf": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "thumbgate@0.9.9",
+        "serve"
+      ]
+    }
+  }
+}

package/plugins/codex-profile/AGENTS.md

@@ -0,0 +1,20 @@
+# Codex ThumbGate Add-on
+
+## Trigger
+If user gives explicit positive/negative outcome feedback, capture it immediately.
+
+## Commands
+
+```bash
+node .claude/scripts/feedback/capture-feedback.js --feedback=up --context="..." --tags="..."
+node .claude/scripts/feedback/capture-feedback.js --feedback=down --context="..." --tags="..."
+```
+
+## Session Start
+
+```bash
+npm run feedback:summary
+npm run feedback:rules
+```
+
+Use generated rules as hard guardrails to avoid repeated mistakes.

package/plugins/codex-profile/INSTALL.md

@@ -0,0 +1,66 @@
+# ThumbGate for Codex
+
+ThumbGate now ships a repo-local Codex app plugin surface plus the version-pinned MCP profile. Use the plugin files when you want a distributable Codex artifact, or copy the TOML block for a manual install.
+
+## Shipped plugin files
+
+- Codex plugin manifest: `plugins/codex-profile/.codex-plugin/plugin.json`
+- Codex MCP config: `plugins/codex-profile/.mcp.json`
+- Codex marketplace entry: `.agents/plugins/marketplace.json`
+- Manual install profile: `adapters/codex/config.toml`
+
+## One-Command Install
+
+Add the MCP server block to your Codex config:
+
+```bash
+cat adapters/codex/config.toml >> ~/.codex/config.toml
+```
+
+Or create the config file if it does not exist:
+
+```bash
+mkdir -p ~/.codex
+cat adapters/codex/config.toml >> ~/.codex/config.toml
+```
+
+## What Gets Added
+
+The following block is appended to `~/.codex/config.toml`:
+
+```toml
+[mcp_servers.thumbgate]
+command = "npx"
+args = ["-y", "thumbgate@0.9.9", "serve"]
+```
+
+The repo-local Codex app plugin ships the same runtime path through `plugins/codex-profile/.mcp.json`, so the manual config and plugin metadata stay aligned.
+
+## Verify
+
+Start the MCP server manually to confirm it runs:
+
+```bash
+node adapters/mcp/server-stdio.js
+# Expected: MCP server listening on stdio
+# Press Ctrl+C to stop
+```
+
+Then restart Codex. The `rlhf` MCP server will appear in the tool list.
+
+## Available Tools (via MCP)
+
+- `capture_feedback` — POST `/v1/feedback/capture`
+- `feedback_summary` — GET `/v1/feedback/summary`
+- `prevention_rules` — POST `/v1/feedback/rules`
+- `plan_intent` — POST `/v1/intents/plan`
+
+## Requirements
+
+- Codex with MCP support
+- Node.js 18+ in PATH
+- Config file at `~/.codex/config.toml`
+
+## Uninstall
+
+Remove the `[mcp_servers.thumbgate]` section from `~/.codex/config.toml`.