thumbgate 1.2.0 → 1.3.0

package/scripts/prove-packaged-runtime.js

@@ -0,0 +1,260 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const http = require('http');
+const net = require('net');
+const { execFileSync } = require('child_process');
+
+const ROOT = path.join(__dirname, '..');
+const DEFAULT_TIMEOUT_MS = 15000;
+const STATUSLINE_INPUT = JSON.stringify({ context_window: { used_percentage: 12 } });
+
+function parseArgs(argv = process.argv.slice(2)) {
+  const parsed = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (!token.startsWith('--')) continue;
+    const [rawKey, inlineValue] = token.slice(2).split('=');
+    const key = rawKey.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
+    const value = inlineValue !== undefined ? inlineValue : argv[index + 1];
+    parsed[key] = value;
+    if (inlineValue === undefined) index += 1;
+  }
+  return parsed;
+}
+
+function pkgVersion() {
+  return require(path.join(ROOT, 'package.json')).version;
+}
+
+function packCurrentRepo(packDir) {
+  fs.mkdirSync(packDir, { recursive: true });
+  const output = execFileSync('npm', ['pack', '--json', '--pack-destination', packDir], {
+    cwd: ROOT,
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+  const parsed = JSON.parse(output);
+  const fileName = parsed && parsed[0] && parsed[0].filename;
+  if (!fileName) {
+    throw new Error('npm pack did not return a tarball filename');
+  }
+  return path.join(packDir, fileName);
+}
+
+function installPackage(prefixDir, packageSpec) {
+  fs.mkdirSync(prefixDir, { recursive: true });
+  execFileSync('npm', ['install', '--prefix', prefixDir, '--no-fund', '--no-audit', packageSpec], {
+    cwd: ROOT,
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+  return path.join(prefixDir, 'node_modules', '.bin', 'thumbgate');
+}
+
+function request(url, timeoutMs = 2000) {
+  return new Promise((resolve, reject) => {
+    const req = http.get(url, (res) => {
+      let body = '';
+      res.setEncoding('utf8');
+      res.on('data', (chunk) => { body += chunk; });
+      res.on('end', () => resolve({ statusCode: res.statusCode, body }));
+    });
+    req.on('error', reject);
+    req.setTimeout(timeoutMs, () => {
+      req.destroy(new Error(`Timed out requesting ${url}`));
+    });
+  });
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function getAvailablePort() {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer();
+    server.listen(0, '127.0.0.1', () => {
+      const address = server.address();
+      const port = address && address.port;
+      server.close((error) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve(port);
+      });
+    });
+    server.on('error', reject);
+  });
+}
+
+async function waitForHealthy(origin, expectedVersion, timeoutMs = DEFAULT_TIMEOUT_MS) {
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    try {
+      const response = await request(`${origin}/health`);
+      if (response.statusCode === 200) {
+        const body = JSON.parse(response.body);
+        if (body.version === expectedVersion) {
+          return body;
+        }
+      }
+    } catch {
+      // Keep polling until the detached API server comes online.
+    }
+    await sleep(250);
+  }
+  throw new Error(`Timed out waiting for packaged runtime health at ${origin}`);
+}
+
+function renderStatusline(runtimeBin, projectDir, env) {
+  return execFileSync(runtimeBin, ['statusline-render'], {
+    cwd: projectDir,
+    env,
+    encoding: 'utf8',
+    input: STATUSLINE_INPUT,
+    stdio: ['pipe', 'pipe', 'pipe'],
+    timeout: 10000,
+  });
+}
+
+function runtimeStatePath(homeDir) {
+  return path.join(homeDir, '.thumbgate', 'runtime', 'statusline-api.json');
+}
+
+async function stopDetachedRuntime(homeDir) {
+  try {
+    const state = JSON.parse(fs.readFileSync(runtimeStatePath(homeDir), 'utf8'));
+    const pid = Number(state && state.pid);
+    if (!Number.isInteger(pid) || pid <= 0) return;
+    try {
+      process.kill(pid, 'SIGTERM');
+    } catch {
+      return;
+    }
+    for (let attempt = 0; attempt < 10; attempt += 1) {
+      await sleep(100);
+      try {
+        process.kill(pid, 0);
+      } catch {
+        return;
+      }
+    }
+    try {
+      process.kill(pid, 'SIGKILL');
+    } catch {
+      // Ignore cleanup races.
+    }
+  } catch {
+    // No runtime state means nothing to clean up.
+  }
+}
+
+async function runPackagedRuntimeSmoke(options = {}) {
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'thumbgate-packaged-runtime-'));
+  const homeDir = path.join(tempRoot, 'home');
+  const projectDir = path.join(tempRoot, 'project');
+  const packDir = path.join(tempRoot, 'pack');
+  const runtimeDir = path.join(tempRoot, 'runtime');
+  const expectedVersion = options.expectedVersion || pkgVersion();
+  const feedbackDir = path.join(projectDir, '.thumbgate');
+  fs.mkdirSync(homeDir, { recursive: true });
+  fs.mkdirSync(projectDir, { recursive: true });
+  fs.mkdirSync(feedbackDir, { recursive: true });
+  fs.writeFileSync(
+    path.join(feedbackDir, 'feedback-log.jsonl'),
+    [
+      JSON.stringify({ signal: 'positive', timestamp: '2026-04-08T20:00:00.000Z', context: 'packaged runtime smoke pass' }),
+      JSON.stringify({ signal: 'negative', timestamp: '2026-04-08T20:01:00.000Z', context: 'packaged runtime smoke fail path' }),
+    ].join('\n') + '\n'
+  );
+
+  try {
+    const packageSpec = options.packageSpec || packCurrentRepo(packDir);
+    const runtimeBin = installPackage(runtimeDir, packageSpec);
+    if (!fs.existsSync(runtimeBin)) {
+      throw new Error(`Installed runtime binary is missing: ${runtimeBin}`);
+    }
+
+    const port = await getAvailablePort();
+    const origin = `http://127.0.0.1:${port}`;
+    const env = {
+      ...process.env,
+      HOME: homeDir,
+      THUMBGATE_PROJECT_DIR: projectDir,
+      THUMBGATE_LOCAL_API_ORIGIN: origin,
+      THUMBGATE_API_KEY: 'tg_packaged_runtime_smoke',
+      NO_COLOR: '1',
+    };
+
+    const initialStatusline = renderStatusline(runtimeBin, projectDir, env);
+    if (!initialStatusline.includes(`ThumbGate v${expectedVersion}`)) {
+      throw new Error(`Statusline version mismatch before boot: ${initialStatusline.trim()}`);
+    }
+    if (!/(Dashboard|Dashboard…)/.test(initialStatusline) || !/(Lessons|Lessons…)/.test(initialStatusline)) {
+      throw new Error(`Statusline missing dashboard affordances before boot: ${initialStatusline.trim()}`);
+    }
+
+    const health = await waitForHealthy(origin, expectedVersion, Number(options.timeoutMs || DEFAULT_TIMEOUT_MS));
+    const dashboard = await request(`${origin}/dashboard`);
+    const lessons = await request(`${origin}/lessons`);
+    if (dashboard.statusCode !== 200) {
+      throw new Error(`Packaged dashboard returned ${dashboard.statusCode}`);
+    }
+    if (lessons.statusCode !== 200) {
+      throw new Error(`Packaged lessons returned ${lessons.statusCode}`);
+    }
+
+    const readyStatusline = renderStatusline(runtimeBin, projectDir, env);
+    if (!readyStatusline.includes(`${origin}/dashboard`)) {
+      throw new Error(`Ready statusline missing dashboard URL: ${readyStatusline.trim()}`);
+    }
+    if (!readyStatusline.includes(`${origin}/lessons`)) {
+      throw new Error(`Ready statusline missing lessons URL: ${readyStatusline.trim()}`);
+    }
+    if (!readyStatusline.includes(`${origin}/feedback/quick?signal=up`)) {
+      throw new Error(`Ready statusline missing thumbs-up URL: ${readyStatusline.trim()}`);
+    }
+    if (!readyStatusline.includes(`${origin}/feedback/quick?signal=down`)) {
+      throw new Error(`Ready statusline missing thumbs-down URL: ${readyStatusline.trim()}`);
+    }
+
+    return {
+      packageSpec,
+      expectedVersion,
+      origin,
+      health,
+    };
+  } finally {
+    await stopDetachedRuntime(homeDir);
+    fs.rmSync(tempRoot, { recursive: true, force: true });
+  }
+}
+
+async function main() {
+  const args = parseArgs();
+  const result = await runPackagedRuntimeSmoke({
+    packageSpec: args.packageSpec,
+    expectedVersion: args.expectedVersion,
+    timeoutMs: args.timeoutMs,
+  });
+  process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+}
+
+if (require.main === module) {
+  main().catch((error) => {
+    process.stderr.write(`${error.message || String(error)}\n`);
+    process.exit(1);
+  });
+}
+
+module.exports = {
+  getAvailablePort,
+  packCurrentRepo,
+  runPackagedRuntimeSmoke,
+  waitForHealthy,
+};

package/scripts/prove-runtime.js

@@ -5,6 +5,7 @@ const os = require('os');
 const path = require('path');
 
 const { buildManagedScheduleCommand } = require('./schedule-manager');
+const { runPackagedRuntimeSmoke } = require('./prove-packaged-runtime');
 
 const ROOT = path.join(__dirname, '..');
 const RUNNER_PATH = require.resolve('./async-job-runner');
@@ -275,6 +276,18 @@ async function run() {
         }
       },
     },
+    {
+      id: 'RUNTIME-07',
+      desc: 'packaged thumbgate runtime boots local API and serves dashboard affordances',
+      fn: async () => {
+        const result = await runPackagedRuntimeSmoke({
+          expectedVersion: require(path.join(ROOT, 'package.json')).version,
+        });
+        if (!result.health || result.health.version !== require(path.join(ROOT, 'package.json')).version) {
+          throw new Error('Packaged runtime health version did not match package.json');
+        }
+      },
+    },
   ];
 
   console.log('Interruptible Runtime - Proof Gate\n');

package/scripts/rate-limiter.js

@@ -10,9 +10,9 @@ const {
 const USAGE_FILE = path.join(process.env.HOME || '/tmp', '.thumbgate', 'usage-limits.json');
 
 const FREE_TIER_LIMITS = {
-  capture_feedback: { daily: Infinity, label: 'feedback captures' },
+  capture_feedback: { daily: 3, label: 'feedback captures' },
   search_lessons: { daily: 5, label: 'lesson searches' },
-  search_thumbgate: { daily: 10, label: 'ThumbGate searches' },
+  search_thumbgate: { daily: 5, label: 'ThumbGate searches' },
   commerce_recall: { daily: 5, label: 'commerce recalls' },
   export_dpo: { daily: 0, label: 'DPO exports (Pro only)' },
   export_databricks: { daily: 0, label: 'Databricks exports (Pro only)' },
@@ -83,7 +83,7 @@ function checkLimit(action, authContext) {
   const current = usage.counts[action] || 0;
 
   if (current >= dailyLimit) {
-    return { allowed: false, message: UPGRADE_MESSAGE, used: current, limit: dailyLimit };
+    return { allowed: false, message: `Free tier limit reached. Upgrade to Pro for unlimited: https://thumbgate-production.up.railway.app/pro\n${UPGRADE_MESSAGE}`, used: current, limit: dailyLimit };
   }
 
   // Increment

package/scripts/statusline-local-stats.js

@@ -3,8 +3,10 @@
 
 const { analyzeFeedback } = require('./feedback-loop');
 const { normalizeStatsPayload } = require('./hook-thumbgate-cache-updater');
+const { syncClaudeHistoryFeedback } = require('./claude-feedback-sync');
 
 try {
+  syncClaudeHistoryFeedback();
   const stats = analyzeFeedback();
   const payload = {
     ...normalizeStatsPayload(stats),

package/scripts/statusline.sh

@@ -11,9 +11,18 @@ LOCAL_API_ORIGIN="${THUMBGATE_LOCAL_API_ORIGIN:-http://localhost:3456}"
 # ── Parse Claude Code session JSON from stdin ─────────────────────
 eval "$(cat | jq -r '
   def n(f): f // 0;
-  @sh "CTX_PCT=\(n(.context_window.used_percentage) | floor)"
+  @sh "CTX_PCT=\(n(.context_window.used_percentage) | floor)",
+  @sh "PROJECT_CWD=\(.cwd // .working_directory // "")"
 ' 2>/dev/null)"
 CTX_PCT="${CTX_PCT:-0}"
+PROJECT_CWD="${PROJECT_CWD:-}"
+
+if [ -n "$PROJECT_CWD" ] && [ -d "$PROJECT_CWD" ]; then
+  export THUMBGATE_PROJECT_DIR="$PROJECT_CWD"
+  if [ -z "${THUMBGATE_FEEDBACK_DIR:-}" ]; then
+    export THUMBGATE_FEEDBACK_DIR="${PROJECT_CWD}/.claude/memory/feedback"
+  fi
+fi
 
 # ── ThumbGate stats from cache ────────────────────────────────────────
 THUMBGATE_CACHE=""
@@ -117,6 +126,16 @@ if [ -n "$_TOWER_JSON" ]; then
   ' 2>/dev/null)"
 fi
 
+# ── Latest lesson ──────────────────────────────────────────────────
+LESSON_TEXT=""; LESSON_ID=""
+_LESSON_JSON=$(node "${SCRIPT_DIR}/statusline-lesson.js" 2>/dev/null)
+if [ -n "$_LESSON_JSON" ]; then
+  eval "$(echo "$_LESSON_JSON" | jq -r '
+    @sh "LESSON_TEXT=\(.text // "")",
+    @sh "LESSON_ID=\(.lessonId // "")"
+  ' 2>/dev/null)"
+fi
+
 # ── Colors ────────────────────────────────────────────────────────
 G='\033[32m'; R='\033[31m'; M='\033[35m'; C='\033[36m'; D='\033[90m'; BD='\033[1m'; RST='\033[0m'
 
@@ -140,19 +159,155 @@ DOWN_ICON="$(osc8_link "$DOWN_URL" "👎")"
 DASHBOARD_LINK="$(osc8_link "$DASHBOARD_URL" "$DASHBOARD_LABEL")"
 LESSONS_LINK="$(osc8_link "$LESSONS_URL" "$LESSONS_LABEL")"
 
+is_numeric() {
+  case "$1" in
+    ''|*[!0-9]*) return 1 ;;
+    *) return 0 ;;
+  esac
+}
+
+# Keep ThumbGate within a conservative left-side budget so Claude's own
+# right-side notices do not visually collide with our line.
+STATUSLINE_DEFAULT_MAX_CHARS="${THUMBGATE_STATUSLINE_DEFAULT_MAX_CHARS:-96}"
+STATUSLINE_RIGHT_RESERVE="${THUMBGATE_STATUSLINE_RIGHT_RESERVE:-28}"
+if ! is_numeric "$STATUSLINE_DEFAULT_MAX_CHARS"; then STATUSLINE_DEFAULT_MAX_CHARS=96; fi
+if ! is_numeric "$STATUSLINE_RIGHT_RESERVE"; then STATUSLINE_RIGHT_RESERVE=28; fi
+
+if is_numeric "${THUMBGATE_STATUSLINE_MAX_CHARS:-}"; then
+  STATUSLINE_MAX_CHARS="$THUMBGATE_STATUSLINE_MAX_CHARS"
+else
+  STATUSLINE_MAX_CHARS="$STATUSLINE_DEFAULT_MAX_CHARS"
+  if is_numeric "${COLUMNS:-}"; then
+    _AVAILABLE_CHARS=$(( COLUMNS - STATUSLINE_RIGHT_RESERVE ))
+    if [ "$_AVAILABLE_CHARS" -gt 0 ] && [ "$_AVAILABLE_CHARS" -lt "$STATUSLINE_MAX_CHARS" ]; then
+      STATUSLINE_MAX_CHARS="$_AVAILABLE_CHARS"
+    fi
+  fi
+fi
+if [ "$STATUSLINE_MAX_CHARS" -lt 48 ]; then STATUSLINE_MAX_CHARS=48; fi
+
+PLAIN_SEGMENTS=()
+RENDERED_SEGMENTS=()
+
+current_plain_length() {
+  local total=0
+  local i
+  for ((i = 0; i < ${#PLAIN_SEGMENTS[@]}; i++)); do
+    if [ "$i" -gt 0 ]; then
+      total=$((total + 3))
+    fi
+    total=$((total + ${#PLAIN_SEGMENTS[$i]}))
+  done
+  printf '%s' "$total"
+}
+
+push_segment() {
+  PLAIN_SEGMENTS+=("$1")
+  RENDERED_SEGMENTS+=("$2")
+}
+
+add_segment_if_fit() {
+  local plain="$1"
+  local rendered="$2"
+  local current extra
+  current=$(current_plain_length)
+  extra=${#plain}
+  if [ "${#PLAIN_SEGMENTS[@]}" -gt 0 ]; then
+    extra=$((extra + 3))
+  fi
+  if [ $((current + extra)) -le "$STATUSLINE_MAX_CHARS" ]; then
+    push_segment "$plain" "$rendered"
+    return 0
+  fi
+  return 1
+}
+
+truncate_plain_text() {
+  local text="$1"
+  local max_chars="$2"
+  if [ "$max_chars" -le 0 ]; then
+    printf ''
+  elif [ "${#text}" -le "$max_chars" ]; then
+    printf '%s' "$text"
+  elif [ "$max_chars" -le 3 ]; then
+    printf '%.*s' "$max_chars" "$text"
+  else
+    printf '%s...' "${text:0:$((max_chars - 3))}"
+  fi
+}
+
+add_truncated_segment_if_fit() {
+  local plain="$1"
+  local color="$2"
+  local min_chars="${3:-14}"
+  local current sep remaining truncated
+  current=$(current_plain_length)
+  sep=0
+  if [ "${#PLAIN_SEGMENTS[@]}" -gt 0 ]; then
+    sep=3
+  fi
+  remaining=$((STATUSLINE_MAX_CHARS - current - sep))
+  if [ "$remaining" -lt "$min_chars" ]; then
+    return 1
+  fi
+  truncated=$(truncate_plain_text "$plain" "$remaining")
+  push_segment "$truncated" "${color}${truncated}${RST}"
+  return 0
+}
+
+render_segments() {
+  local line=''
+  local i
+  for ((i = 0; i < ${#RENDERED_SEGMENTS[@]}; i++)); do
+    if [ "$i" -gt 0 ]; then
+      line="${line} · "
+    fi
+    line="${line}${RENDERED_SEGMENTS[$i]}"
+  done
+  printf '%b\n' "$line"
+}
+
 # ── Output (single line) ─────────────────────────────────────────
-LINE="ThumbGate v${TG_VERSION} · ${TG_TIER}"
 if [ "$UP" = "0" ] && [ "$DOWN" = "0" ]; then
-  LINE="${D}${LINE} · no feedback yet${RST} · ${C}${DASHBOARD_LINK}${RST} · ${M}${LESSONS_LINK}${RST}"
-  printf '%b\n' "$LINE"
+  push_segment "ThumbGate v${TG_VERSION}" "${D}ThumbGate v${TG_VERSION}${RST}"
+  push_segment "${TG_TIER}" "${D}${TG_TIER}${RST}"
+  push_segment "no feedback yet" "${D}no feedback yet${RST}"
+  add_segment_if_fit "${DASHBOARD_LABEL}" "${C}${DASHBOARD_LINK}${RST}"
+  add_segment_if_fit "${LESSONS_LABEL}" "${M}${LESSONS_LINK}${RST}"
+  render_segments
 else
-  LINE="${LINE} · ${G}${BD}${UP}${RST}${UP_ICON} ${R}${BD}${DOWN}${RST}${DOWN_ICON} ${ARROW}"
+  STATS_PLAIN="${UP}👍 ${DOWN}👎 ${ARROW}"
+  STATS_RENDERED="${G}${BD}${UP}${RST}${UP_ICON} ${R}${BD}${DOWN}${RST}${DOWN_ICON} ${ARROW}"
+  ALERTS_PLAIN=''
+  ALERTS_RENDERED=''
+
+  if [ "${SLO_V:-0}" -gt 0 ]; then
+    ALERTS_PLAIN="${ALERTS_PLAIN}${ALERTS_PLAIN:+ }${SLO_V} SLO"
+    ALERTS_RENDERED="${ALERTS_RENDERED}${ALERTS_RENDERED:+ }${R}${SLO_V} SLO${RST}"
+  fi
+  if [ "${AT_RISK:-0}" -gt 0 ]; then
+    ALERTS_PLAIN="${ALERTS_PLAIN}${ALERTS_PLAIN:+ }${AT_RISK}⚠"
+    ALERTS_RENDERED="${ALERTS_RENDERED}${ALERTS_RENDERED:+ }${R}${AT_RISK}⚠${RST}"
+  fi
+  if [ "${ANOMALIES:-0}" -gt 0 ]; then
+    ALERTS_PLAIN="${ALERTS_PLAIN}${ALERTS_PLAIN:+ }${ANOMALIES}☠"
+    ALERTS_RENDERED="${ALERTS_RENDERED}${ALERTS_RENDERED:+ }${R}${ANOMALIES}☠${RST}"
+  fi
 
-  # Control Tower alerts (if any)
-  [ "${SLO_V:-0}" -gt 0 ] && LINE="${LINE} ${R}${SLO_V} SLO${RST}"
-  [ "${AT_RISK:-0}" -gt 0 ] && LINE="${LINE} ${R}${AT_RISK}⚠${RST}"
-  [ "${ANOMALIES:-0}" -gt 0 ] && LINE="${LINE} ${R}${ANOMALIES}☠${RST}"
-  LINE="${LINE} · ${C}${DASHBOARD_LINK}${RST} · ${M}${LESSONS_LINK}${RST}"
+  push_segment "ThumbGate v${TG_VERSION}" "ThumbGate v${TG_VERSION}"
+  push_segment "${TG_TIER}" "${TG_TIER}"
+  push_segment "${STATS_PLAIN}" "${STATS_RENDERED}"
+  add_segment_if_fit "${DASHBOARD_LABEL}" "${C}${DASHBOARD_LINK}${RST}"
+  add_segment_if_fit "${LESSONS_LABEL}" "${M}${LESSONS_LINK}${RST}"
+  if [ "${LESSONS:-0}" -gt 0 ]; then
+    add_segment_if_fit "${LESSONS} lessons" "${M}${BD}${LESSONS}${RST} lessons"
+  fi
+  if [ -n "${ALERTS_PLAIN}" ]; then
+    add_segment_if_fit "${ALERTS_PLAIN}" "${ALERTS_RENDERED}"
+  fi
+  if [ -n "${LESSON_TEXT}" ]; then
+    add_truncated_segment_if_fit "${LESSON_TEXT}" "${D}" 14
+  fi
 
-  printf '%b\n' "$LINE"
+  render_segments
 fi

package/scripts/tool-registry.js

@@ -36,7 +36,7 @@ const TOOLS = [
         whatWorked: { type: 'string' },
         chatHistory: {
           type: 'array',
-          description: 'Optional recent conversation window used for history-aware lesson distillation.',
+          description: 'Optional caller-supplied recent conversation window used for history-aware lesson distillation. The current Claude auto-capture path sends up to 8 prior recorded entries for vague negative inline signals.',
           items: {
             type: 'object',
             properties: {
@@ -59,7 +59,7 @@ const TOOLS = [
               timestamp: { type: 'string' },
             },
           },
-          description: 'Last 5-10 conversation turns before the feedback signal. Raw messages, not summaries.',
+          description: 'Recent conversation turns before the feedback signal. Raw messages, not summaries.',
         },
         rubricScores: {
           type: 'array',