@krtclcdy/tersio 2.18.0 → 2.20.0

package/extensions/combo-toggle/index.ts

@@ -0,0 +1,217 @@
+// /combo session toggle — set all three (caveman, rtk, ponytail) at once.
+// Modes: off | medium | balanced | max
+
+import os from 'node:os';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import {
+  activeModesSummary,
+  asPromptArray,
+  COMBO_LEVELS,
+  getSharedComboState,
+  isComboPresetActive,
+  isOmpSubagentPrompt,
+  normalizeComboLevel,
+  paintableCtx,
+  reconcileSharedComboEntries,
+  sessionEntries,
+  setSharedComboLevel,
+  setSharedComboListener,
+  setSharedComboMode,
+  systemPromptIncludes,
+} from '../shared/session-state.ts';
+import { readComboDefault, readPonytailDefault } from '../shared/plugin-settings.ts';
+import type { ComboState, ExtensionApi, ExtensionCtx, SystemPromptEvent } from '../shared/types.ts';
+
+const require = createRequire(import.meta.url);
+
+const PONYTAIL_FALLBACK_INTENSITY: Record<string, string> = {
+  lite: 'Prefer the simplest correct solution.',
+  review: 'Review only for avoidable complexity; recommend the smallest correct replacement.',
+};
+
+function ponytailFallback(mode: string): string {
+  const intensity = PONYTAIL_FALLBACK_INTENSITY[mode] ?? 'Use the minimum correct solution. Delete or reuse before adding.';
+  return `🦥 PONYTAIL MODE ACTIVE — level: ${mode}\n${intensity} Understand the path first and fix root causes, not symptoms. Prefer the standard library and YAGNI. Avoid speculative abstractions and dependencies. Preserve correctness. Verify changed behavior.`;
+}
+
+function levelSummary(state: ComboState): string {
+  return `caveman=${state.caveman} rtk=${state.rtk} ponytail=${state.ponytail}`;
+}
+
+function loadPonytailInstructions(mode: string): string {
+  try {
+    const installed = path.join(
+      os.homedir(),
+      '.omp',
+      'plugins',
+      'node_modules',
+      '@dietrichgebert',
+      'ponytail',
+      'hooks',
+      'ponytail-instructions.js'
+    );
+    const { getPonytailInstructions } = require(installed) as { getPonytailInstructions?: (mode: string) => string };
+    if (typeof getPonytailInstructions === 'function') return getPonytailInstructions(mode);
+  } catch { }
+  return ponytailFallback(mode);
+}
+
+export default function comboToggleExtension(pi: ExtensionApi): void {
+  pi.setLabel?.('Combo session toggle (all 3 add-ons)');
+
+  let lastCtx: ExtensionCtx | undefined = undefined;
+
+  function syncStatus(ctx?: ExtensionCtx): void {
+    lastCtx = paintableCtx(lastCtx, ctx);
+    const c = lastCtx;
+    if (!c?.ui?.setStatus) return;
+    // Single unified bar replaces the three per-extension bars while a preset is
+    // active. In custom/off, the individual bars come back and combo stays clear.
+    if (!isComboPresetActive()) {
+      c.ui.setStatus('combo', undefined);
+      return;
+    }
+    // Read the live bridge, not cached extension state: sibling extensions
+    // reconcile it from persisted entries before this one runs.
+    const state = getSharedComboState();
+    const theme = c.ui.theme;
+    const c0 = state.caveman.toUpperCase();
+    const r = state.rtk.toUpperCase();
+    const p = state.ponytail.toUpperCase();
+    const lvl = state.level.toUpperCase();
+    const label = `combo ${lvl}: 🪨caveman=${c0} ⚡rtk=${r} 🦥ponytail=${p}`;
+    c.ui.setStatus('combo', theme?.fg ? `${theme.fg('accent', '🧩')} ${theme.fg('muted', label)}` : `🧩 ${label}`);
+    // Clobber any sibling bars another extension may have painted in a race
+    // during session_start — our bar is canonical for the duration of the preset.
+    c.ui.setStatus('caveman', undefined);
+    c.ui.setStatus('rtk', undefined);
+    c.ui.setStatus('ponytail', undefined);
+  }
+
+  // ponytail: same persistence as /combo — siblings (incl. upstream ponytail)
+  // restore from these entries, so the fallback must write them too or the
+  // preset evaporates on resume and ponytail never activates.
+  function persistPreset(level: string): void {
+    const modes = COMBO_LEVELS[level];
+    pi.appendEntry?.('caveman-mode', { mode: modes.caveman });
+    pi.appendEntry?.('rtk-mode', { enabled: modes.rtk === 'on' });
+    pi.appendEntry?.('ponytail-mode', { mode: modes.ponytail });
+    pi.appendEntry?.('combo-level', { level });
+  }
+
+  function useState(state: Readonly<ComboState>, ctx?: ExtensionCtx): Readonly<ComboState> {
+    syncStatus(ctx);
+    return state;
+  }
+
+  function reconcile(ctx?: ExtensionCtx): Readonly<ComboState> {
+    if (!ctx?.hasUI) return getSharedComboState();
+    return useState(reconcileSharedComboEntries(sessionEntries(ctx)), ctx);
+  }
+  function listen(ctx?: ExtensionCtx): void {
+    // Stable identity: the bridge set dedupes, so repeated track()/command
+    // calls register once instead of stacking duplicate listeners.
+    if (ctx?.hasUI) setSharedComboListener(useState);
+  }
+
+  function track(ctx?: ExtensionCtx): void {
+    listen(ctx);
+    if (ctx?.hasUI) reconcile(ctx);
+  }
+
+  pi.registerCommand?.('combo', {
+    description: 'Toggle all 3 OMP add-ons at once. Usage: /combo <off|medium|balanced|max|status>',
+    handler: async (args, ctx) => {
+      listen(ctx);
+      const arg = String(args || '').trim().toLowerCase();
+
+      if (!arg || arg === 'status') {
+        const state = reconcile(ctx);
+        ctx?.ui?.notify?.(
+          `Combo: ${state.level === 'custom' ? 'INACTIVE' : state.level.toUpperCase()} (${levelSummary(state)})`,
+          'info'
+        );
+        return;
+      }
+
+      if (arg === 'help') {
+        ctx?.ui?.notify?.(
+          '/combo off      — disables all 3 (caveman, rtk, ponytail)\n' +
+          '/combo medium   — light: caveman=lite, rtk=on, ponytail=lite\n' +
+          '/combo balanced — middle: caveman=full, rtk=on, ponytail=full\n' +
+          '/combo max      — aggressive: caveman=ultra, rtk=on, ponytail=ultra',
+          'info'
+        );
+        return;
+      }
+
+      const level = normalizeComboLevel(arg);
+      if (!level) {
+        ctx?.ui?.notify?.(
+          `Unknown combo level: ${arg}. Use: off | medium | balanced | max`,
+          'warning'
+        );
+        return;
+      }
+
+      persistPreset(level);
+      useState(setSharedComboLevel(level), ctx);
+
+      const active = activeModesSummary(getSharedComboState());
+      ctx?.ui?.notify?.(
+        level === 'off' ? `Combo off — all tersio modes inactive for this session. Active: ${active}.` : `Combo ${level} on — ${active} active for this session.`,
+        'info'
+      );
+    },
+  });
+
+  pi.on('session_start', async (_event, ctx) => {
+    track(ctx);
+    if (!ctx?.hasUI) syncStatus(ctx);
+    // Installer/user-configured default applies only when no persisted *mode*
+    // state exists — unrelated session entries must not block it, or the
+    // combo bar never paints on sessions that already carry other entries.
+    const entries = sessionEntries(ctx);
+    const hasModeState = entries.some((e) => e?.type === 'custom' && (
+      e.customType === 'combo-level' || e.customType === 'caveman-mode' ||
+      e.customType === 'rtk-mode' || e.customType === 'ponytail-mode'));
+    if (getSharedComboState().level === 'off' && !hasModeState) {
+      const fallback = readComboDefault();
+      if (fallback !== 'off') {
+        persistPreset(fallback);
+        useState(setSharedComboLevel(fallback), ctx);
+        ctx?.ui?.notify?.(`Combo default applied: ${fallback} — ${activeModesSummary(getSharedComboState())} active for this session.`, 'info');
+      }
+    }
+    // Standalone ponytail default: no sibling extension restores it (upstream
+    // owns the command), so apply it here when nothing persisted a
+    // ponytail-mode entry. Skipped when it matches the active preset — the
+    // preset entry already covers that, no redundant write.
+    if (!entries.some((e) => e?.type === 'custom' && e.customType === 'ponytail-mode')) {
+      const ponytailFallback = readPonytailDefault();
+      if (ponytailFallback !== 'off' && ponytailFallback !== getSharedComboState().ponytail) {
+        pi.appendEntry?.('ponytail-mode', { mode: ponytailFallback });
+        useState(setSharedComboMode('ponytail', ponytailFallback), ctx);
+      }
+    }
+  });
+
+  for (const event of ['session_branch', 'session_tree', 'agent_start']) {
+    pi.on(event, async (_event, ctx) => {
+      track(ctx);
+    });
+  }
+
+  pi.on<SystemPromptEvent>('before_agent_start', async (event, ctx) => {
+    if (ctx?.hasUI) reconcile(ctx);
+    if (!isOmpSubagentPrompt(event.systemPrompt)) return;
+
+    const mode = getSharedComboState().ponytail;
+    if (mode === 'off' || systemPromptIncludes(event.systemPrompt, 'PONYTAIL MODE ACTIVE')) return;
+    const base = asPromptArray(event.systemPrompt);
+    return { systemPrompt: [...base, loadPonytailInstructions(mode)] };
+  });
+
+  // Slash commands only; natural-language input caused accidental toggles and has no reload context.
+}

package/extensions/lib/utils.ts

@@ -0,0 +1,162 @@
+// Shared helpers for the installer and the AI add-ons updater.
+// Node built-ins only — this module must stay dependency-free.
+
+import { createHash } from 'node:crypto';
+import { createWriteStream } from 'node:fs';
+import fs from 'node:fs/promises';
+import https from 'node:https';
+import path from 'node:path';
+
+export interface HttpOptions {
+  maxRedirects?: number;
+}
+
+// Promise.withResolvers is Node 22+; the package supports Node 18+.
+// ponytail: swap for the built-in when engines bumps to >=22.
+export function withResolvers<T>(): PromiseWithResolvers<T> {
+  let resolve!: (value: T | PromiseLike<T>) => void;
+  let reject!: (reason?: unknown) => void;
+  const promise = new Promise<T>((res, rej) => { resolve = res; reject = rej; });
+  return { promise, resolve, reject };
+}
+
+export const RTK_RELEASE_API = 'https://api.github.com/repos/rtk-ai/rtk/releases/latest';
+export const CAVEMAN_REMOTE_RULE = 'https://raw.githubusercontent.com/JuliusBrussee/caveman/main/src/rules/caveman-activate.md';
+
+export interface RtkPlatformSpec {
+  triple: string;
+  ext: string;
+  binary: string;
+}
+
+export interface RtkReleaseAsset {
+  name: string;
+  browser_download_url: string;
+}
+
+export interface RtkRelease {
+  tag_name?: string;
+  assets?: RtkReleaseAsset[];
+}
+
+const RTK_PLATFORM_SPECS: Record<string, RtkPlatformSpec> = {
+  'win32/x64': { triple: 'x86_64-pc-windows-msvc', ext: '.zip', binary: 'rtk.exe' },
+  'linux/x64': { triple: 'x86_64-unknown-linux-musl', ext: '.tar.gz', binary: 'rtk' },
+  'linux/arm64': { triple: 'aarch64-unknown-linux-gnu', ext: '.tar.gz', binary: 'rtk' },
+  'darwin/x64': { triple: 'x86_64-apple-darwin', ext: '.tar.gz', binary: 'rtk' },
+  'darwin/arm64': { triple: 'aarch64-apple-darwin', ext: '.tar.gz', binary: 'rtk' },
+};
+
+export function rtkPlatformSpec(platform: string = process.platform, arch: string = process.arch): RtkPlatformSpec | null {
+  return RTK_PLATFORM_SPECS[`${platform}/${arch}`] || null;
+}
+
+// Single source for the 3xx+location redirect rule shared by httpsGet/httpsDownload.
+function redirectNext(res: { statusCode?: number; headers: { location?: string } }, url: string): string | null {
+  if (res.statusCode !== undefined && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+    return new URL(res.headers.location, url).href;
+  }
+  return null;
+}
+
+export function httpsGet(url: string, opts: HttpOptions = {}): Promise<string> {
+  const { promise, resolve, reject } = withResolvers<string>();
+  const maxRedirects = opts.maxRedirects ?? 5;
+  const req = https.get(url, { headers: { 'User-Agent': 'tersio', Accept: 'application/json,*/*' } }, (res) => {
+    const next = redirectNext(res, url);
+    if (next) {
+      if (maxRedirects <= 0) { res.resume(); reject(new Error(`Too many redirects fetching ${url}`)); return; }
+      res.resume();
+      resolve(httpsGet(next, { maxRedirects: maxRedirects - 1 }));
+      return;
+    }
+    if (res.statusCode !== 200) { res.resume(); reject(new Error(`HTTP ${res.statusCode} for ${url}`)); return; }
+    let body = '';
+    // ponytail: streamed accumulation — fine for tens of KB; stream-pipe if assets ever exceed a few MB.
+    res.setEncoding('utf8');
+    res.on('data', (chunk) => { body += chunk; });
+    res.on('end', () => resolve(body));
+  });
+  req.on('error', reject);
+  req.setTimeout(30000, () => req.destroy(new Error(`Timeout fetching ${url}`)));
+  return promise;
+}
+
+export function httpsDownload(url: string, dest: string, opts: HttpOptions = {}): Promise<void> {
+  const { promise, resolve, reject } = withResolvers<void>();
+  const maxRedirects = opts.maxRedirects ?? 5;
+  const req = https.get(url, { headers: { 'User-Agent': 'tersio', Accept: '*/*' } }, (res) => {
+    const next = redirectNext(res, url);
+    if (next) {
+      if (maxRedirects <= 0) { res.resume(); reject(new Error(`Too many redirects downloading ${url}`)); return; }
+      res.resume();
+      resolve(httpsDownload(next, dest, { maxRedirects: maxRedirects - 1 }));
+      return;
+    }
+    if (res.statusCode !== 200) { res.resume(); reject(new Error(`HTTP ${res.statusCode} for ${url}`)); return; }
+    const file = createWriteStream(dest);
+    res.pipe(file);
+    file.on('finish', () => file.close(() => resolve()));
+    file.on('error', (err) => {
+      req.destroy();
+      res.resume();
+      reject(err);
+    });
+  });
+  req.on('error', reject);
+  req.setTimeout(120000, () => req.destroy(new Error(`Timeout downloading ${url}`)));
+  return promise;
+}
+
+export async function fetchJson<T>(url: string): Promise<T> {
+  return JSON.parse(await httpsGet(url)) as T;
+}
+
+export function sha256Hex(text: string): string {
+  return createHash('sha256').update(text, 'utf8').digest('hex');
+}
+
+export async function sha256File(filePath: string): Promise<string> {
+  const buf = await fs.readFile(filePath);
+  return createHash('sha256').update(buf).digest('hex');
+}
+
+export function parseChecksum(checksumsText: string, assetName: string): string | null {
+  const target = path.basename(assetName);
+  for (const line of checksumsText.split(/\r?\n/)) {
+    const m = line.match(/^([0-9a-fA-F]{64})\s+\*?(.+)$/);
+    if (m && path.basename(m[2]) === target) return m[1].toLowerCase();
+  }
+  return null;
+}
+
+export async function findFile(dir: string, name: string): Promise<string | null> {
+  try {
+    const ents = await fs.readdir(dir, { withFileTypes: true });
+    for (const e of ents) {
+      const full = path.join(dir, e.name);
+      if (e.isDirectory()) {
+        const found = await findFile(full, name);
+        if (found) return found;
+      } else if (e.isFile()) {
+        if (e.name === name) return full;
+        // Match rtk-* asset names (e.g. rtk-x86_64-unknown-linux-musl).
+        if (name === 'rtk' || name === 'rtk.exe') {
+          const base = e.name.toLowerCase();
+          if (!/\.(txt|md|json|sha256|sig|asc|pem|crt|license)$/i.test(base)) {
+            if (base === 'rtk' || base === 'rtk.exe' || /^rtk[-_.]/.test(base)) return full;
+          }
+        }
+      }
+    }
+  } catch { /* ignore */ }
+  return null;
+}
+
+export async function readTextIfExists(p: string): Promise<string | null> {
+  try { return await fs.readFile(p, 'utf8'); } catch { return null; }
+}
+
+export function normalizeRtkVersion(value: string | undefined): string {
+  return String(value || '').replace(/^rtk\s+/i, '').replace(/^v/i, '').trim();
+}

package/extensions/rtk-session/index.ts

@@ -0,0 +1,164 @@
+import os from 'node:os';
+import path from 'node:path';
+import { activeModesSummary, asPromptArray, getSharedComboState, isComboPresetActive, isOmpSubagentPrompt, lastCustomValue, normalizeInputCommand, normalizeMode, paintStatusBar, paintableCtx, reconcileSharedComboEntries, sessionEntries, setSharedComboListener, setSharedComboMode } from '../shared/session-state.ts';
+import { readRtkDefault } from '../shared/plugin-settings.ts';
+import type { ExtensionApi, ExtensionCtx, InputEvent, SessionEntry, SystemPromptEvent } from '../shared/types.ts';
+
+const DEFAULT_ENABLED = false;
+
+function asBoolean(value: unknown): boolean | null {
+  if (typeof value === 'boolean') return value;
+  if (value === 'on' || value === 'true') return true;
+  if (value === 'off' || value === 'false') return false;
+  return null;
+}
+
+function resolveEnabled(entries: SessionEntry[] | null | undefined): boolean | null {
+  return lastCustomValue(entries, 'rtk-mode', (data) => asBoolean(data?.enabled));
+}
+
+const IS_WINDOWS = process.platform === 'win32';
+const HOME = os.homedir();
+const RTK_BINARY = path.join(HOME, '.bun', 'bin', IS_WINDOWS ? 'rtk.exe' : 'rtk');
+
+const RTK_PROMPT = `RTK mode active for this session.
+Use Rust Token Killer for shell output that would otherwise be noisy. Prefer explicit RTK commands in bash: \`rtk git status\`, \`rtk git diff\`, \`rtk read <file>\`, \`rtk grep <pattern> <path>\`, \`rtk find <glob> <path>\`, \`rtk test <cmd...>\`, \`rtk tsc\`, \`rtk lint\`, or \`rtk <tool> ...\` for supported dev commands.
+Do not use RTK when exact raw output is required, when a specialized OMP tool is required by system policy, or when the command changes state and RTK would hide important confirmation text. Specialized OMP tools still win: read/glob/grep/edit/lsp stay preferred over shell equivalents.`;
+
+interface ZodChain {
+  min: (n: number) => ZodChain;
+  describe: (text: string) => ZodChain;
+}
+
+export default function rtkSessionExtension(pi: ExtensionApi): void {
+  const { z } = pi.zod as { z: { object: (shape: Record<string, unknown>) => Record<string, unknown>; array: (el: unknown) => ZodChain; string: () => ZodChain } };
+  let enabled = DEFAULT_ENABLED;
+  let isActive = false;
+  let lastCtx: ExtensionCtx | undefined = undefined;
+
+  function syncStatus(ctx?: ExtensionCtx): void {
+    lastCtx = paintableCtx(lastCtx, ctx);
+    const c = lastCtx;
+    if (!c?.ui?.setStatus) return;
+    // Combo owns the bar when any preset is active; keep ours empty to avoid duplication.
+    if (isComboPresetActive() || !enabled) {
+      c.ui.setStatus('rtk', undefined);
+      return;
+    }
+    paintStatusBar(c.ui, 'rtk', '⚡', 'rtk: ON', isActive);
+  }
+
+  function setEnabled(next: unknown, ctx?: ExtensionCtx): void {
+    enabled = Boolean(next);
+    pi.appendEntry?.('rtk-mode', { enabled });
+    setSharedComboMode('rtk', enabled);
+    syncStatus(ctx);
+    const active = activeModesSummary(getSharedComboState());
+    ctx?.ui?.notify?.(enabled ? `RTK on — compact shell output for this session. Active: ${active}.` : `RTK off. Active: ${active}.`, 'info');
+  }
+
+  pi.setLabel?.('RTK session toggle');
+
+  // Live mirror: a /tersio or /combo switch publishes shared state — adopt
+  // it at once so the next turn and the rtk_run gate see it, no reload.
+  function syncFromShared(state: { rtk: string }): void {
+    enabled = state.rtk === 'on';
+    syncStatus();
+  }
+  setSharedComboListener(syncFromShared);
+  pi.registerCommand?.('rtk', {
+    description: 'Toggle RTK compact shell-output guidance for this session',
+    handler: async (args, ctx) => {
+      const arg = String(args || '').trim().toLowerCase();
+      if (!arg || arg === 'status') {
+        ctx?.ui?.notify?.(`RTK: ${enabled ? 'on' : 'off'}`, 'info');
+        return;
+      }
+      if (['on', 'enable', 'enabled', 'true'].includes(arg)) {
+        setEnabled(true, ctx);
+        return;
+      }
+      if (['off', 'disable', 'disabled', 'false'].includes(arg)) {
+        setEnabled(false, ctx);
+        return;
+      }
+      ctx?.ui?.notify?.('Usage: /rtk [on|off|status]', 'warning');
+    },
+  });
+
+  pi.registerTool?.({
+    name: 'rtk_run',
+    label: 'RTK Run',
+    description: 'Run the installed `rtk` binary for compact command output when RTK mode is enabled.',
+    parameters: z.object({
+      args: z.array(z.string()).min(1).describe("Arguments passed to rtk, e.g. ['git','status'] or ['read','src/index.ts']"),
+    }),
+    async execute(_toolCallId, params, signal, onUpdate, ctx) {
+      if (!enabled) {
+        return {
+          isError: true,
+          content: [{ type: 'text', text: 'RTK mode is off. Run /rtk on for this session, or use bash explicitly.' }],
+          details: { enabled },
+        };
+      }
+      onUpdate?.({ content: [{ type: 'text', text: `rtk ${params.args.join(' ')}` }], details: { phase: 'start' } });
+      const result = await pi.exec!(RTK_BINARY, params.args, { signal, cwd: ctx?.cwd || pi.cwd });
+      const text = [result.stdout, result.stderr].filter(Boolean).join('\n');
+      return {
+        isError: result.code !== 0,
+        content: [{ type: 'text', text: text || `rtk exited ${result.code}` }],
+        details: { code: result.code, killed: result.killed, enabled },
+      };
+    },
+  });
+
+  pi.on<InputEvent>('input', async (event) => {
+    if (event?.source === 'extension') return;
+    const t = normalizeInputCommand(event?.text);
+    if (t === 'rtk on' || t === 'use rtk') setEnabled(true);
+    if (t === 'rtk off' || t === 'stop rtk') setEnabled(false);
+  });
+  function restoreEnabled(ctx?: ExtensionCtx): void {
+    const entries = sessionEntries(ctx);
+    // Publish the persisted combo state (incl. combo-level) before painting:
+    // bar suppression reads the in-process bridge, which is empty in a fresh
+    // host until the combo extension reconciles — and its reconcile is
+    // UI-gated. Deriving it here makes suppression independent of load order.
+    reconcileSharedComboEntries(entries);
+    // Persisted session state wins; a fresh session falls back to the
+    // installer/user-configured default (off unless configured).
+    const persisted = resolveEnabled(entries);
+    enabled = typeof persisted === 'boolean' ? persisted : readRtkDefault();
+    syncStatus(ctx);
+  }
+
+  pi.on('session_start', async (_event, ctx) => {
+    restoreEnabled(ctx);
+    ctx?.ui?.notify?.(`RTK loaded: ${enabled ? 'on' : 'off'}`, 'info');
+  });
+
+  pi.on('session_branch', async (_event, ctx) => {
+    restoreEnabled(ctx);
+  });
+
+  pi.on('session_tree', async (_event, ctx) => {
+    restoreEnabled(ctx);
+  });
+
+  pi.on('agent_start', async (_event, ctx) => {
+    isActive = true;
+    syncStatus(ctx);
+  });
+
+  pi.on('agent_end', async (_event, ctx) => {
+    isActive = false;
+    syncStatus(ctx);
+  });
+
+  pi.on<SystemPromptEvent>('before_agent_start', async (event) => {
+    const active = isOmpSubagentPrompt(event.systemPrompt) ? getSharedComboState().rtk === 'on' : enabled;
+    if (!active) return;
+    const base = asPromptArray(event.systemPrompt);
+    return { systemPrompt: [...base, RTK_PROMPT] };
+  });
+}

package/extensions/shared/carbon.ts

@@ -0,0 +1,123 @@
+// extensions/shared/carbon.ts — CO2/energy footprints, EcoLogits-style.
+//
+// Port of the EcoLogits v0.8.2 LLM impact model (genai-impact/ecologits,
+// MPL-2.0 — see ECO_NOTICE.md), following the same served-estimate approach
+// as honey-for-devs' hooks/eco.js: the faithful single-stream (batch-1)
+// ceiling divided by serving_concurrency for continuous-batching amortization.
+//
+// Model params come from EcoLogits' registry where it covers the model;
+// otherwise a documented class borrow (never a silent guess — every borrow
+// carries its source). Unknown ids fall to the gpt-4o default. Everything
+// rendered from here must carry ~est. and never merge with measured figures.
+
+export interface ModelCarbon {
+  activeB: number;
+  totalB: number;
+  provider: string;
+  source: 'registry' | 'borrowed' | 'default';
+}
+
+// EcoLogits 0.8.2 constants — kWh, kgCO2eq, seconds, GB.
+const Q_BITS = 4;
+const E_ALPHA = 8.91e-8;
+const E_BETA = 1.43e-6;
+const L_ALPHA = 8.02e-4;
+const L_BETA = 2.23e-2;
+const GPU_MEM = 80;
+const GPU_EMB_GWP = 143;
+const SRV_GPUS = 8;
+const SRV_POWER = 1;
+const SRV_EMB_GWP = 3000;
+const LIFETIME = 5 * 365 * 24 * 3600;
+const PUE = 1.2;
+
+// Per-provider grid intensity, gCO2eq/kWh (location-based research values).
+const GRIDS: Record<string, number> = {
+  anthropic: 500,
+  openai: 400,
+  google: 330,
+  default: 450,
+};
+
+// Serving amortization: single-stream ceiling ÷ concurrency ≈ served impact.
+export const SERVING_CONCURRENCY = 32;
+
+interface RegistryEntry {
+  match?: string;
+  exact?: string;
+  active: number;
+  total: number;
+  provider: string;
+  source: 'registry' | 'borrowed';
+}
+
+// Registry values verbatim from EcoLogits' model_repository; borrows cite
+// the public param disclosure they stand in for (MoE active/total).
+const TABLE: RegistryEntry[] = [
+  { match: 'opus', active: 625.0, total: 2000, provider: 'anthropic', source: 'registry' },
+  { match: 'sonnet', active: 137.5, total: 440, provider: 'anthropic', source: 'registry' },
+  { match: 'haiku', active: 18.0, total: 18.0, provider: 'anthropic', source: 'registry' },
+  { match: 'gpt-5', active: 93.75, total: 300, provider: 'openai', source: 'registry' },
+  { match: 'gpt', active: 137.5, total: 440, provider: 'openai', source: 'registry' },
+  { match: 'gemini', active: 137.5, total: 440, provider: 'google', source: 'registry' },
+  { match: 'deepseek', active: 37, total: 671, provider: 'default', source: 'borrowed' },
+  { match: 'qwen', active: 22, total: 235, provider: 'default', source: 'borrowed' },
+  { match: 'glm', active: 37, total: 671, provider: 'default', source: 'borrowed' },
+  { match: 'kimi', active: 32, total: 1000, provider: 'default', source: 'borrowed' },
+  { match: 'muse', active: 70, total: 70, provider: 'default', source: 'borrowed' },
+  { match: 'flash', active: 18.0, total: 18.0, provider: 'default', source: 'borrowed' },
+];
+
+const DEFAULT_ENTRY = { active: 137.5, total: 440, provider: 'openai' };
+
+export function carbonParamsFor(model: string): ModelCarbon {
+  const name = model.toLowerCase();
+  for (const row of TABLE) {
+    if (row.match && name.includes(row.match)) {
+      return { activeB: row.active, totalB: row.total, provider: row.provider, source: row.source };
+    }
+  }
+  return { activeB: DEFAULT_ENTRY.active, totalB: DEFAULT_ENTRY.total, provider: DEFAULT_ENTRY.provider, source: 'default' };
+}
+
+export interface Footprint {
+  energyWh: number;
+  gco2: number;
+  gco2Ceiling: number;
+  concurrency: number;
+  provider: string;
+  paramSource: 'registry' | 'borrowed' | 'default';
+}
+
+function impacts(activeB: number, totalB: number, outTokens: number, gridKg: number): { energyKwh: number; gco2: number } {
+  const gpuEnergy = outTokens * (E_ALPHA * activeB + E_BETA);
+  const latency = outTokens * (L_ALPHA * activeB + L_BETA);
+  const gpuCount = Math.ceil(((1.2 * totalB * Q_BITS) / 8 / GPU_MEM));
+  const serverEnergy = (latency / 3600) * SRV_POWER * (gpuCount / SRV_GPUS);
+  const energyKwh = PUE * (serverEnergy + gpuCount * gpuEnergy);
+  const embGwp = (latency / LIFETIME) * ((gpuCount / SRV_GPUS) * SRV_EMB_GWP + gpuCount * GPU_EMB_GWP);
+  return { energyKwh, gco2: (energyKwh * gridKg + embGwp) * 1000 };
+}
+
+export function footprintFor(model: string, outputTokens: number): Footprint {
+  const p = carbonParamsFor(model);
+  const gridKg = (GRIDS[p.provider] ?? GRIDS.default) / 1000;
+  const ceiling = impacts(p.activeB, p.totalB, Math.max(0, Math.floor(outputTokens)), gridKg);
+  const b = SERVING_CONCURRENCY > 0 ? SERVING_CONCURRENCY : 1;
+  return {
+    energyWh: (ceiling.energyKwh / b) * 1000,
+    gco2: ceiling.gco2 / b,
+    gco2Ceiling: ceiling.gco2,
+    concurrency: b,
+    provider: p.provider,
+    paramSource: p.source,
+  };
+}
+
+export function co2GramsFor(model: string, outputTokens: number): number {
+  return footprintFor(model, outputTokens).gco2;
+}
+
+export function energyWhFor(model: string, outputTokens: number): number {
+  return footprintFor(model, outputTokens).energyWh;
+}