Skip to content

akiiwa-games/AgentCompass / skills/agent-compass

agent-compass

Flagged

Multi-agent task router and subscription quota scheduler. Choose owner, model and effort, outbound authorization, advisor use, and continuation for delegated work. Reads local usage and effective account policy, profiles the task with the configured System-One scorer, then allocates a compatible worker. Use for independent worker or advisor work; ordinary local execution needs no routing.

FileKindSize
SKILL.mdskill md5.6 KB
agents/openai.yamlconfig427 B
calibration/README.mdmarkdown55.2 KB
calibration/arena_capture.pyscript14.0 KB
calibration/community.pyscript25.2 KB
calibration/five_axis.pyscript196.4 KB
calibration/measurements.pyscript68.4 KB
calibration/refresh.pyscript48.6 KB
calibration/series.pyscript10.2 KB
calibration/sources.pyscript24.1 KB
calibration/tiers.pyscript14.6 KB
grok-bot/.gitignoreother47 B
grok-bot/dependency_patch.pyscript4.5 KB
grok-bot/install_cli.pyscript3.6 KB
grok-bot/test-recovery.mjsscript8.6 KB
grok-bot/test_install_cli.pyscript4.1 KB
grok-bot/upstream.jsonconfig3.4 KB
references/accounts.jsonconfig155.9 KB
references/classifier-cases.jsonconfig21.5 KB
references/dispatch-lifecycle.mdmarkdown37.7 KB
references/dispatch-rules.mdmarkdown11.3 KB
references/effort-matching.mdmarkdown5.1 KB
references/fast-modes.mdmarkdown3.5 KB
references/five-axis-scores.jsonconfig3.1 MB
references/gemini-decisions-api.mdmarkdown2.9 KB
references/grok-bot.mdmarkdown13.0 KB
references/herdr.mdmarkdown5.1 KB
references/jev-api.mdmarkdown1.6 KB
references/level-3-conversion.jsonconfig2.4 KB
references/model-capabilities.jsonconfig3.6 KB
references/model-capabilities.mdmarkdown14.6 KB
references/parent-address-gate.mdmarkdown10.1 KB
references/plan-templates.jsonconfig13.2 KB
references/provider-discovery.mdmarkdown11.5 KB
references/provider-usage.mdmarkdown4.1 KB
references/public-data.jsonconfig816 B
references/public-measurements.jsonconfig1.3 MB
references/roll-reference.mdmarkdown26.7 KB
references/router-internals.mdmarkdown94.5 KB
references/task-classifier.mdmarkdown6.1 KB
references/user-scores.jsonconfig6.8 KB
references/work-kinds.mdmarkdown4.7 KB
references/worker-communication.mdmarkdown2.1 KB
scripts/account_fleet.pyscript32.9 KB
scripts/account_state.pyscript22.2 KB
scripts/accounts_override.pyscript14.8 KB
scripts/allocator.pyscript19.8 KB
scripts/antigravity_plan.pyscript18.7 KB
scripts/antigravity_telemetry.pyscript5.1 KB
scripts/auto_bundles.pyscript31.3 KB
scripts/axis_scores.pyscript40.3 KB
scripts/caller_input.pyscript3.0 KB
scripts/candidate_eval.pyscript54.0 KB
scripts/candidate_ranking.pyscript9.5 KB
scripts/capability_catalog.pyscript8.0 KB
scripts/check_router_contract.pyscript2.8 KB
scripts/conftest.pyscript2.5 KB
scripts/cwd_policy.pyscript1.5 KB
scripts/data_age.pyscript1.5 KB
scripts/decision_ledger.pyscript18.9 KB
scripts/demo_plan.pyscript6.3 KB
scripts/dispatch_fallback.pyscript40.3 KB
scripts/dispatch_flow.pyscript63.1 KB
scripts/dispatch_ground_truth.pyscript43.5 KB
scripts/dispatch_registry.pyscript130.8 KB
scripts/entry.pyscript1.7 KB
scripts/env_vars.pyscript580 B
scripts/fast_modes.pyscript2.5 KB
scripts/fixtures/grok-api-responses.jsonconfig907 B
scripts/fixtures/reference-accounts.jsonconfig26.9 KB
scripts/grok_bot_paths.pyscript1005 B
scripts/host_herdr.pyscript16.8 KB
scripts/host_placement.pyscript9.4 KB
scripts/host_policy.pyscript10.1 KB
scripts/launch_failures.pyscript5.9 KB
scripts/launch_values.pyscript12.3 KB
scripts/ledger_snapshot.pyscript11.1 KB
scripts/live_models.pyscript21.1 KB
scripts/model_latch.pyscript7.6 KB
scripts/model_resolution.pyscript18.0 KB
scripts/override_store.pyscript2.2 KB
scripts/plan_state_residue.pyscript5.0 KB
scripts/provider_inventory.pyscript128.2 KB
scripts/provider_retry.pyscript34.6 KB
scripts/public_data.pyscript59.2 KB
scripts/quota_economy.pyscript38.0 KB
scripts/quota_exhaustion.pyscript5.9 KB
scripts/quota_overrides.pyscript25.6 KB
scripts/quota_pools.pyscript29.8 KB
scripts/reference_provenance.pyscript32.3 KB
scripts/released_names.pyscript3.8 KB
scripts/roll.pyscript106.3 KB
scripts/route_judge.pyscript83.5 KB
scripts/route_simulation.pyscript26.3 KB
scripts/router_test_support.pyscript6.7 KB
scripts/run_grok_bot.pyscript18.8 KB
scripts/scorer_client.pyscript55.2 KB
scripts/stage_help.pyscript5.8 KB
scripts/state_upgrade.pyscript24.0 KB
scripts/subscription_cli.pyscript3.6 KB
scripts/task_intake.pyscript33.6 KB
scripts/test_account_identity.pyscript7.1 KB
scripts/test_account_state.pyscript63.3 KB
scripts/test_accounts_override.pyscript30.1 KB
scripts/test_allocator.pyscript94.2 KB
scripts/test_antigravity_plan.pyscript13.2 KB
scripts/test_applicable_quota.pyscript9.1 KB
scripts/test_auto_bundles.pyscript10.8 KB
scripts/test_billing_routing_policy.pyscript9.9 KB
scripts/test_cadence_count.pyscript32.2 KB
scripts/test_calibration_units.pyscript27.0 KB
scripts/test_capability_catalog.pyscript5.0 KB
scripts/test_decision_ledger.pyscript8.5 KB
scripts/test_demo_plan.pyscript3.4 KB
scripts/test_derived_state.pyscript21.6 KB
scripts/test_dispatch.pyscript352.4 KB
scripts/test_dispatch_answers.pyscript14.8 KB
scripts/test_dispatch_fallback.pyscript53.2 KB
scripts/test_entry.pyscript1.6 KB
scripts/test_fast_modes.pyscript9.9 KB
scripts/test_five_axis.pyscript290.1 KB
scripts/test_five_axis_economy.pyscript105.0 KB
scripts/test_fleet_parity.pyscript15.6 KB
scripts/test_grok_bot.pyscript47.7 KB
scripts/test_ground_truth_recording.pyscript68.8 KB
scripts/test_herdr.pyscript14.1 KB
scripts/test_host_policy.pyscript24.6 KB
scripts/test_launch_values.pyscript8.0 KB
scripts/test_metered_usd.pyscript60.4 KB
scripts/test_model_resolution.pyscript9.2 KB
scripts/test_named_route_facts.pyscript28.6 KB
scripts/test_native_hosts.pyscript6.0 KB
scripts/test_new_user_fleet.pyscript3.3 KB
scripts/test_no_hardcode_classification.pyscript75.1 KB
scripts/test_no_legacy_scoring.pyscript6.5 KB
scripts/test_override_store.pyscript2.3 KB
scripts/test_plan_says_why.pyscript44.9 KB
scripts/test_provider_inventory.pyscript83.2 KB
scripts/test_provider_names.pyscript126.0 KB
scripts/test_provider_pools.pyscript14.2 KB
scripts/test_public_data.pyscript93.5 KB
scripts/test_quota_exhaustion.pyscript5.6 KB
scripts/test_rate_limit_windows.pyscript6.3 KB
scripts/test_record_says_why.pyscript26.5 KB
scripts/test_reference_provenance.pyscript16.7 KB
scripts/test_refresh_entry.pyscript110.7 KB
scripts/test_released_names.pyscript4.1 KB
scripts/test_reset_priority.pyscript4.8 KB
scripts/test_roll_answers.pyscript44.7 KB
scripts/test_roll_notifications.pyscript10.4 KB
scripts/test_route_judge.pyscript99.8 KB
scripts/test_route_simulation.pyscript7.0 KB
scripts/test_routing_parity.pyscript32.3 KB
scripts/test_routing_review.pyscript25.1 KB
scripts/test_setup_discovery_parity.pyscript9.5 KB
scripts/test_stage_help.pyscript2.0 KB
scripts/test_state_upgrade.pyscript13.8 KB
scripts/test_turn_refusal.pyscript16.7 KB
scripts/test_usage_cache.pyscript4.9 KB
scripts/test_usage_collector.pyscript21.4 KB
scripts/test_usage_core_claude_accounts.pyscript1.8 KB
scripts/test_usage_core_grok_cli_billing.pyscript15.6 KB
scripts/test_usage_core_magpie.pyscript5.4 KB
scripts/test_usage_core_magpie_pool.pyscript10.8 KB
scripts/test_usage_core_safety.pyscript24.4 KB
scripts/test_user_scores.pyscript102.3 KB
scripts/test_venice_usage.pyscript1.3 KB
scripts/test_window_scope.pyscript5.5 KB
scripts/turn_refusal.pyscript10.7 KB
scripts/usage_cache.pyscript4.7 KB
scripts/usage_collector.pyscript7.4 KB
scripts/usage_core.pyscript142.0 KB
scripts/usage_magpie.pyscript10.6 KB
scripts/usage_reading.pyscript17.1 KB
scripts/user_scores.pyscript72.8 KB
scripts/venice_usage.pyscript2.6 KB
scripts/window_scope.pyscript3.2 KB
scripts/worker_context.pyscript8.9 KB
scripts/worker_sessions.pyscript10.9 KB

calibration/arena_capture.py

View on GitHub
"""arena.ai leaderboards transcribed from the user's own browser (round 047, round 7). arena.ai sits behind bot protection,
so these boards are not fetched: the user captures the page text and this script imports it as a dated source.

    python -X utf8 arena_capture.py import CAPTURE.json [...] [--data DIR] [--by NAME]
    python -X utf8 arena_capture.py show [--data DIR]

A capture is the JSON the browser capture writes, the same shape on every refresh:
- the Agent board's categories, {"Overall": text, "Code": text, "Chat": text, "Work": text} (https://arena.ai/leaderboard/agent),
- one page, {"url": ..., "text": ...}: the Agent Alignment Index (https://arena.ai/leaderboard/agent/alignment), WebDev
  (https://arena.ai/leaderboard/code/webdev) or Text (https://arena.ai/leaderboard/chat/text),
optionally wrapped in a JSON string. `import` parses each page (a page that does not parse is an error, never a partial
board), keeps the date the page shows (`as_of`), its session or vote count and every row, and writes
`arena-agent-categories.json` / `arena-agent-alignment.json` / `arena-webdev.json` / `arena-text.json` into the
calibration data directory with a fetch-manifest row (`transcribed_by`, `captured_at`, sha256). measurements.py reads them:

- arena.agent_code (Agent / Code, Net Improvement) -> coding.execution
- arena.agent_alignment (Alignment Index) -> coding.faithfulness
- Agent / Overall: real-session Cost/Task P50 and Time/Task P50 -> usd_per_hour and throughput (`arena.agent_sessions`).
- Agent / Chat and Agent / Work: cross-check columns only (`show`), not scoring boards.
- WebDev and Text are read from the Hugging Face dataset (sources.py); their captures are a cross-check of it.
"""
import argparse
import hashlib
import json
import re
import sys
from datetime import datetime, timezone
from pathlib import Path

import sources

FILES = {'agent': 'arena-agent-categories.json', 'alignment': 'arena-agent-alignment.json',
         'webdev': 'arena-webdev.json', 'text': 'arena-text.json'}
URLS = {'agent': 'https://arena.ai/leaderboard/agent', 'alignment': 'https://arena.ai/leaderboard/agent/alignment',
        'webdev': 'https://arena.ai/leaderboard/code/webdev', 'text': 'https://arena.ai/leaderboard/chat/text'}
AGENT_COLUMNS = ('net_improvement', 'confirmed_success', 'praise_vs_complaint', 'steerability', 'bash_reliability',
                 'tool_hallucination')
MONTHS = {m: i for i, m in enumerate(('january', 'february', 'march', 'april', 'may', 'june', 'july', 'august', 'september',
                                      'october', 'november', 'december'), 1)}
# Lab names the run-together Alignment page glues to the model name (the Agent page prints them on their own line). The
# page text has no separator between a model name and its lab, so the labs are the only way to find the boundary;
# compared without case (the page writes `Nvidia` and `StepFun` where the Agent page has `NVIDIA` and `Stepfun`). A row's
# front label can differ from its closing lab (`Synlan` in front of `Spark-X2.6`, closed by `XHToken`), so every label
# that can stand in front is listed here too.
LABS = ('Anthropic', 'OpenAI', 'Google', 'Meta', 'SpaceXAI', 'xAI', 'Tencent', 'Moonshot', 'DeepSeek', 'Xiaomi', 'Alibaba',
        'Z.ai', 'StepFun', 'Reflection AI', 'Reflection', 'Thinking Machines', 'Thinky', 'MiniMax', 'Mistral', 'NVIDIA',
        'Amazon', 'Microsoft', 'ByteDance', 'Baidu', 'Cohere', 'IBM', 'Meituan', 'Ant Group', 'Kuaishou', 'Prime Intellect',
        'Nous Research', 'AI21', 'Upstage', 'XHToken', 'Synlan')


def page_date(text):
    m = re.search(r'(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)[a-z]*\.? (\d{1,2}), (\d{4})', text)
    if not m:
        raise ValueError('no page date')
    month = next(i for name, i in MONTHS.items() if name.startswith(m.group(1).lower()))
    return f'{int(m.group(3)):04d}-{month:02d}-{int(m.group(2)):02d}'


def count(text, word):
    text = re.sub(r'(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)[a-z]*\.? \d{1,2}, \d{4}', ' ', text)   # runs into the count
    m = re.search(r'(\d[\d,]*) ' + word, text)
    return int(m.group(1).replace(',', '')) if m else None


def number(cell):
    cell = cell.strip()
    if cell in ('', 'N/A', '-'):
        return None
    m = re.fullmatch(r'\$?([\d,.]+)\s*(K|M|min|h|s)?', cell)
    if not m:
        return None
    v = float(m.group(1).replace(',', ''))
    return v * {'K': 1e3, 'M': 1e6, 'h': 60.0, 's': 1 / 60}.get(m.group(2), 1.0)


def parse_agent(text):
    """One Agent category page: {as_of, sessions, rows: [{rank, name, lab, preliminary, <column>: (value, ci), sessions,
    cost_per_task_usd, time_per_task_min, output_tokens_per_task}]}."""
    head = text.split('Price $/M', 1)
    if len(head) != 2:
        raise ValueError('no Agent table header')
    body = head[1]
    row = re.compile(r'(?m)^(\d+)\n\d+\n\d+\n\t\n(?P<name>[^\n]+)\n(?P<lab>[^\n]+?)\n(?P<pre>·\nPreliminary\n)?\t\n'
                     r'(?P<cells>(?:(?:-?[\d.]+%\n±[\d.]+%|N/A)\n\t\n?){5}(?:-?[\d.]+%\n±[\d.]+%|N/A)\n)'
                     r'\t(?P<sessions>[\d,]+)\t(?P<cost>[^\t]*)\t(?P<time>[^\t]*)\t(?P<tokens>[^\t]*)\t(?P<price>[^\n]*)')
    rows = []
    for m in row.finditer(body):
        cells = re.findall(r'(-?[\d.]+)%\n±([\d.]+)%|N/A', m.group('cells'))
        if len(cells) != len(AGENT_COLUMNS):
            raise ValueError(f'row {m.group(1)}: {len(cells)} metric cells')
        r = {'rank': int(m.group(1)), 'name': m.group('name').strip(), 'lab': m.group('lab').split(' · ')[0].strip(),
             'preliminary': bool(m.group('pre')), 'sessions': int(m.group('sessions').replace(',', '')),
             'cost_per_task_usd': number(m.group('cost')), 'time_per_task_min': number(m.group('time')),
             'output_tokens_per_task': number(m.group('tokens'))}
        for col, (v, ci) in zip(AGENT_COLUMNS, cells):
            r[col] = [float(v), float(ci)] if v else None
        rows.append(r)
    listed = count(text, 'models')
    if not rows or [r['rank'] for r in rows] != list(range(1, len(rows) + 1)) or (listed and len(rows) != listed):
        raise ValueError(f'parsed {len(rows)} rows, page lists {listed}')
    return {'as_of': page_date(text), 'sessions': count(text, 'sessions'), 'rows': rows,
            'sign_rule': signed_net_improvement(rows)}


def signed_net_improvement(rows):
    """The page text drops the minus sign. The table is sorted by Net Improvement, so the true values fall down the
    ranks: the magnitudes fall to the row before the first rise and every row from that rise on is negative. The last
    row before the rise may be either sign (both are within its interval of zero); it stays positive and is flagged.
    Other columns keep their magnitude (`sign_lost`)."""
    vals = [r['net_improvement'][0] for r in rows]
    turn = next((i for i in range(1, len(vals)) if vals[i] > vals[i - 1] + 1e-9), len(vals))
    tail = vals[turn:]
    if any(b < a - 1e-9 for a, b in zip(tail, tail[1:])):
        raise ValueError('Net Improvement magnitudes do not fall then rise down the ranks; the sign cannot be rebuilt')
    for i, r in enumerate(rows):
        r['net_improvement'][0] = -vals[i] if i >= turn else vals[i]
        r['sign_lost'] = [c for c in AGENT_COLUMNS[1:] if r.get(c)]
    if 0 < turn < len(rows):
        rows[turn - 1]['sign_ambiguous'] = True
    return (f'Net Improvement signs rebuilt from the rank order: rows {turn + 1}..{len(rows)} negative'
            + (f', row {turn} ambiguous (kept positive)' if 0 < turn < len(rows) else '') if turn < len(rows)
            else 'every Net Improvement positive')


def split_name_lab(head):
    """(name, lab) of a run-together `[lab]name lab` cell, else (None, None). The lab ends the cell. Some rows also carry
    the lab's text in front of the name (the logo's text: `AnthropicClaude Opus 5.5Anthropic`, `Thinking MachinesInkling
    2 SmallThinky`); that prefix is a lab written straight against the name, with no space or punctuation between them,
    so `Mistral Large 4Mistral` and `NVIDIA-Nemotron-3.5 (NVFP4)Nvidia` keep their names."""
    labs = sorted(LABS, key=len, reverse=True)
    low = head.lower()
    for lab in labs:
        if low.endswith(lab.lower()) and len(head) > len(lab):
            name = head[:-len(lab)].strip()
            for front in labs:
                if len(name) > len(front) and name.lower().startswith(front.lower()) and name[len(front)].isalnum():
                    name = name[len(front):].strip()
                    break
            return name, head[-len(lab):]
    return None, None


def parse_alignment(text):
    """The Alignment Index page (its text runs together): {as_of, sessions, rows: [{rank, name, lab, alignment_index:
    (value, ci), unauthorized_action, false_attribution, deceptive_completion: (pct, low, high)}]}."""
    start = text.find('Deceptive completion')
    if start < 0:
        raise ValueError('no Alignment table header')
    body = text[start + len('Deceptive completion'):]
    rate = r'(\d+\.\d\d)%([\d.]+)–([\d.]+)%'
    cell = re.compile(r'(?P<head>.+?)(?P<idx>\d{2}\.\d)±(?P<ci>\d+\.\d)' + rate * 3)
    rows, pos, errors = [], 0, []
    listed = count(text, 'models')
    while len(rows) < (listed or 10 ** 6):
        m = cell.match(body, pos)
        if not m:
            break
        pos = m.end()
        n = len(rows) + 1
        head = m.group('head')
        if not head.startswith(str(n)):
            raise ValueError(f'row {n}: unexpected rank in {head[:30]!r}')
        name, lab = split_name_lab(re.sub(r'^\d+', '', head[len(str(n)):]))
        if name is None:
            errors.append(f'row {n}: lab not recognised in {head!r}')
        g = [float(x) for x in m.groups()[3:]]
        rows.append({'rank': n, 'name': name, 'lab': lab, 'alignment_index': [float(m.group('idx')), float(m.group('ci'))],
                     'unauthorized_action': g[0:3], 'false_attribution': g[3:6], 'deceptive_completion': g[6:9]})
    if not rows or (listed and len(rows) != listed) or errors:
        raise ValueError(f'parsed {len(rows)} rows, page lists {listed}; ' + '; '.join(errors))
    return {'as_of': page_date(text), 'sessions': count(text, 'sessions'), 'rows': rows}


def load(path):
    raw = json.loads(Path(path).read_text(encoding='utf-8'))
    return json.loads(raw) if isinstance(raw, str) else raw


def kind_of(doc):
    if isinstance(doc, dict) and {'Overall', 'Code', 'Work'} <= set(doc):
        return 'agent'
    text = (doc or {}).get('text') or ''
    url = (doc or {}).get('url') or ''
    if 'Alignment Index' in text[:400] or url.endswith('/agent/alignment'):
        return 'alignment'
    if 'WebDev' in text[:200] or url.endswith('/code/webdev'):
        return 'webdev'
    if 'Text Arena' in text[:200] or url.endswith('/chat/text'):
        return 'text'
    raise ValueError('not a known arena.ai capture')


def normalise(doc, by, captured_at):
    kind = kind_of(doc)
    base = {'source': 'arena.ai, transcribed from the user\'s browser', 'url': doc.get('url') or URLS[kind] if kind != 'agent'
            else URLS['agent'], 'transcribed_by': by, 'captured_at': captured_at}
    if kind == 'agent':
        return kind, {**base, 'categories': {cat: parse_agent(doc[cat]) for cat in doc if isinstance(doc[cat], str) and doc[cat]}}
    if kind == 'alignment':
        return kind, {**base, **parse_alignment(doc['text'])}
    return kind, {**base, 'as_of': page_date(doc['text']), 'text': doc['text']}


def import_captures(paths, target, by):
    files = sources.manifest(target) if (target / sources.MANIFEST).exists() else {}
    for path in paths:
        stamp = datetime.fromtimestamp(Path(path).stat().st_mtime, timezone.utc).isoformat(timespec='seconds')
        kind, doc = normalise(load(path), by, stamp)
        body = (json.dumps(doc, indent=1, ensure_ascii=False) + '\n').encode('utf-8')
        (target / FILES[kind]).write_bytes(body)
        files[FILES[kind]] = {'url': doc['url'], 'fetched_at': stamp, 'status': 'ok', 'bytes': len(body),
                              'sha256': hashlib.sha256(body).hexdigest(), 'transcribed_by': by, 'kind': 'transcribed',
                              'as_of': doc.get('as_of') or min(c['as_of'] for c in doc['categories'].values())}
        (target / sources.MANIFEST).write_text(json.dumps({'files': files}, indent=1), encoding='utf-8')
        print(f'{FILES[kind]:32s} {kind:9s} as of {files[FILES[kind]]["as_of"]}  from {path}')


def read(target, kind):
    """The imported capture of `kind`, or None when it was never imported (a missing source, never an older copy)."""
    row = sources.manifest(target).get(FILES[kind]) or {}
    path = target / FILES[kind]
    if row.get('status') != 'ok' or not path.exists():
        return None
    return json.loads(path.read_text(encoding='utf-8'))


def usd_per_hour(rows):
    """{listed name: community usd per active hour} from the median cost and time per task of real sessions."""
    return {r['name']: round(r['cost_per_task_usd'] / (r['time_per_task_min'] / 60.0), 2) for r in rows
            if r.get('cost_per_task_usd') and r.get('time_per_task_min')}


def main(argv=None):
    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    sub = ap.add_subparsers(dest='cmd', required=True)
    imp = sub.add_parser('import')
    imp.add_argument('paths', nargs='+')
    imp.add_argument('--data')
    imp.add_argument('--by', default='user (browser capture)')
    show = sub.add_parser('show')
    show.add_argument('--data')
    args = ap.parse_args(argv)
    target = sources.data_dir(args.data)
    if args.cmd == 'import':
        import_captures(args.paths, target, args.by)
        return 0
    for kind in FILES:
        doc = read(target, kind)
        if doc is None:
            print(f'{kind}: not imported')
            continue
        if kind == 'agent':
            for cat, page in doc['categories'].items():
                print(f'agent/{cat}: as of {page["as_of"]}, {page["sessions"]} sessions, {len(page["rows"])} models')
        else:
            print(f'{kind}: as of {doc["as_of"]}' + (f', {doc.get("sessions")} sessions, {len(doc["rows"])} models'
                                                     if 'rows' in doc else ''))
    return 0


if __name__ == '__main__':
    sys.exit(main())
reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness.Stars: 322kUpdated Claude CodeCodexVerifiedInstall
dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependenciesStars: 322kUpdated Claude CodeCodexVerifiedInstall
executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is availableStars: 322kUpdated Claude CodeCodexVerifiedInstall