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/tiers.py

View on GitHub
"""Tier: a model's overall level at High, read off the arena.ai Overall board relative to the anchor.

`python -X utf8 tiers.py [--data DIR] [--json OUT] [model-id ...]`

The tier is not a score. It is the continuous standard score of the model's High (or effort-less single-configuration)
row on the arena.ai Overall leaderboard (`lmarena.text_overall`, `text_style_control` / `overall`, centered on the
accounts.json `calibration_panel.anchor` at High = 0.0), and it has one use: estimating a capability facet a model lacks (`five_axis.py`,
through a validated `facet~tier` linear fit). Nothing routes on it.

Sources, in order:

1. arena.ai Overall at High (`tier.arena_overall`). Only a model's High row (or its effort-less single-configuration
   listing when no effort variant is named) enters; `Max`, `xHigh`, `Medium`, `Low`, and non-effort quantized tags are
   never substituted for High. Values are standardized directly as `(rating - rating_anchor) / sd_board` with no
   hand-set anchor tiers and no PAV plateau across distinct Elo ratings.
2. Artificial Analysis Intelligence Index at High (`tier.aa_index`). A model that arena Overall does not list at High
   takes its High (or effort-less single-configuration) reading on `aa.index`, aligned onto the continuous
   `arena_overall` scale over the models listed at High on both boards (monotone pooled piecewise-linear interpolation,
   end-to-end slope beyond the ends, no floor).
3. Same-series sibling (`five_axis.py`, `calibration/series.py`). A model on neither overall board at High takes the
   tier of its nearest same-series sibling; with none it has no tier, and any unmeasured facet stays missing (mode B).
"""
import argparse
import json
import re
import statistics
import sys
from datetime import datetime, timezone

import numpy as np

import sources

EFFORT_TAG = re.compile(
    r'^(max|xhigh|high|medium|low|minimal|non-reasoning|none|default|[a-z0-9. ]+ fallback|'
    r'thinking|non-thinking|reasoning|instant|thinking\s+\d+k|\d+k|\d{2,4}|\d{6}|\d{8}|'
    r'\d{2,4}-\d{2}(?:-\d{2})?|(?:jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)[a-z]*\s+\d{4})$'
)
LISTING_BOARDS = ('arena', 'aa')   # accounts.json `listed_as` keys: the arena.ai / LMArena name and the Artificial Analysis name


def listed_as(models, model, board):
    """The name `board` lists `model` under (accounts.json `models[model].listed_as[board]`), or None when the row
    declares none (the automatic matcher then looks for the id's own spellings)."""
    return ((models.get(model) or {}).get('listed_as') or {}).get(board)


def panel(acc):
    """(anchor id, panel ids, anchor's arena.ai name) from accounts.json `calibration_panel` (a maintainer declaration:
    the anchor is 0 on every board, the panel models' shared board coverage defines the calibration panel)."""
    spec = acc.get('calibration_panel')
    if not isinstance(spec, dict) or not isinstance(spec.get('anchor'), str) or not isinstance(spec.get('models'), list):
        raise ValueError('accounts.json has no calibration_panel {anchor, models}: the calibration scale is undefined')
    anchor, members = spec['anchor'], list(spec['models'])
    if anchor not in members:
        raise ValueError(f'calibration_panel anchor {anchor!r} is not one of its models')
    models = acc.get('models') or {}
    for m in members:
        if not listed_as(models, m, 'arena') or not listed_as(models, m, 'aa'):
            raise ValueError(f'calibration_panel model {m!r} needs models[{m!r}].listed_as.arena and .aa')
    return anchor, members, listed_as(models, anchor, 'arena')


# Non-arena overall (aggregate) boards that may place a model on the tier scale: id -> (label, cited url).
OVERALL_BOARDS = {'aa.index': ('Artificial Analysis Intelligence Index', 'https://artificialanalysis.ai/leaderboards/models')}


def norm(name):
    return ''.join(ch for ch in str(name).lower() if ch.isalnum())


def pooled(xs, ys):
    """Points (x ascending, tied x averaged) with y made non-decreasing by pooling adjacent violators."""
    by_x = {}
    for x, y in zip(xs, ys):
        by_x.setdefault(float(x), []).append(float(y))
    pts = sorted((x, float(np.mean(v)), len(v)) for x, v in by_x.items())
    blocks = [[y * n, n, 1] for _, y, n in pts]       # [weighted sum, weight, points in the block]
    i = 0
    while i < len(blocks) - 1:
        if blocks[i][0] / blocks[i][1] > blocks[i + 1][0] / blocks[i + 1][1]:
            nxt = blocks.pop(i + 1)
            blocks[i] = [blocks[i][0] + nxt[0], blocks[i][1] + nxt[1], blocks[i][2] + nxt[2]]
            i = max(i - 1, 0)
        else:
            i += 1
    flat = [s / w for s, w, k in blocks for _ in range(k)]
    return [p[0] for p in pts], flat


def _valid_variant_tag(listed_name):
    tag = sources.variant(listed_name)
    return not [p for p in (q.strip().lower() for q in tag.split(',')) if p and not EFFORT_TAG.match(p)]


def _variant_rank_key(listed_name, value):
    tag = sources.variant(listed_name)
    date_m = re.search(r'(\d{8}|\d{6}|\d{4}-\d{2}-\d{2}|\d{4})', tag)
    date_key = date_m.group(1).replace('-', '') if date_m else ''
    thinking = 1 if re.search(r'\b(thinking|reasoning)\b', tag, re.I) and not re.search(r'\bnon-thinking\b', tag, re.I) else 0
    return (thinking, len(date_key), date_key, float(value))


def arena_high_rows(rows, readings):
    """{base model name: (value, lower, upper, listed name, publish date)} restricted to High or effort-less rows."""
    grouped = {}
    for row in rows:
        listed = row[3]
        if not listed or not _valid_variant_tag(listed):
            continue
        eff = sources.aa_effort(listed, readings) or ''
        if eff not in ('high', ''):
            continue
        grouped.setdefault(sources.base_name(listed), {}).setdefault(eff, []).append(row)
    out = {}
    for base, by_eff in grouped.items():
        chosen = by_eff.get('high') or by_eff.get('')
        if chosen:
            out[base] = max(chosen, key=lambda r: _variant_rank_key(r[3], r[0]))
    return out


def aa_high_index(records, readings):
    """{base model name: intelligenceIndex} restricted strictly to High or effort-less single-configuration rows."""
    grouped = {}
    for rec in records:
        name = rec.get('name')
        idx = rec.get('intelligenceIndex')
        if not name or not isinstance(idx, (int, float)) or isinstance(idx, bool) or idx <= 0:
            continue
        if not _valid_variant_tag(name):
            continue
        eff, rank = sources.aa_effort(name, readings) or '', sources.listing_rank(name, readings)
        if eff not in ('high', '') or rank is None:
            continue
        at = grouped.setdefault(sources.base_name(name), {})
        if eff not in at or rank <= at[eff][1]:
            at[eff] = (float(idx), rank)
    grouped = {base: {e: v for e, (v, _) in by.items()} for base, by in grouped.items()}
    out = {}
    for base, by_eff in grouped.items():
        if 'high' in by_eff:
            out[base] = by_eff['high']
        elif '' in by_eff:
            out[base] = by_eff['']
    return out


class Interpolation:
    """x -> tier by piecewise-linear interpolation through (x, tier) points; beyond the ends the map's end-to-end slope
    applies. `neighbours(x)` names the two points a reading lies between (or the end segment it lies beyond)."""

    def __init__(self, xs, ys, names=None, floor=None):
        order = sorted(range(len(xs)), key=lambda i: (xs[i], i))
        self.names = [names[i] for i in order] if names else None
        self.floor = floor
        raw_x = [float(xs[i]) for i in order]
        raw_y = [float(ys[i]) for i in order]
        # Tied x keep one point (their mean); inverted neighbours are pooled so the map never decreases.
        self.x, self.y = pooled(raw_x, raw_y)
        self.who = None
        if self.names:
            grouped = {}
            for n, x in zip(self.names, raw_x):
                grouped.setdefault(x, []).append(n)
            self.who = [grouped[x] for x in self.x]
        self.n = len(raw_x)
        self.raw = list(zip(raw_x, raw_y))

    def spread(self):
        """{'residual_sd', 'loo_rmse'}: the root mean square of the shared models' tiers around the map, in sample and
        leaving each model out of the map that predicts it (None under three distinct points left)."""
        res = [y - self(x) for x, y in self.raw]
        loo = []
        for i, (x, y) in enumerate(self.raw):
            rest = self.raw[:i] + self.raw[i + 1:]
            m = Interpolation([p[0] for p in rest], [p[1] for p in rest])
            if len(m.x) >= 2:
                loo.append(y - m(x))
        rms = (lambda v: round(float(np.sqrt(np.mean(np.square(v)))), 4) if v else None)
        return {'residual_sd': rms(res), 'loo_rmse': rms(loo)}

    def __call__(self, x):
        xs, ys = self.x, self.y
        if len(xs) < 2:
            raise ValueError('an interpolation needs at least two distinct points')
        if x <= xs[0]:
            val = ys[0] + self.slope * (x - xs[0])
        elif x >= xs[-1]:
            val = ys[-1] + self.slope * (x - xs[-1])
        else:
            val = float(np.interp(x, xs, ys))
        return max(self.floor, val) if self.floor is not None else val

    @property
    def slope(self):
        """End-to-end slope of the map (lowest to highest point), applied beyond the ends."""
        return (self.y[-1] - self.y[0]) / (self.x[-1] - self.x[0])

    def neighbours(self, x):
        """(lower point, upper point) as {'x', 'tier', 'models'}; a reading beyond an end gets the end segment."""
        xs = self.x
        j = int(np.searchsorted(xs, x, side='right'))
        j = min(max(j, 1), len(xs) - 1)
        out = []
        for k in (j - 1, j):
            point = {'x': xs[k], 'tier': round(self.y[k], 4)}
            if self.who:
                point['models'] = self.who[k]
            out.append(point)
        return out[0], out[1]


class Fitter:
    def __init__(self, target, anchor_name, aa_records, readings):
        self.anchor_name = anchor_name
        read = datetime.fromtimestamp((target / 'aa-models.html').stat().st_mtime, timezone.utc).date().isoformat() \
            if (target / 'aa-models.html').exists() else None
        self.aa_read = read
        self.overall = arena_high_rows(sources.arena_rows(target, 'text_style_control', 'overall'), readings)
        self.anchor_raw, self.sd = self.overall_scale(self.overall, anchor_name)
        self.aa = aa_high_index(aa_records, readings)
        self.maps = {'aa.index': self.board_map(self.aa)}

    @staticmethod
    def overall_scale(board, anchor_name):
        if anchor_name not in board:
            raise ValueError(f'anchor {anchor_name!r} has no High row on arena.ai Overall')
        vals = [float(r[0]) for r in board.values()]
        sd = statistics.stdev(vals) if len(vals) >= 2 else 1.0
        if sd <= 0:
            raise ValueError('arena.ai Overall High rows have zero standard deviation')
        return float(board[anchor_name][0]), float(sd)

    def arena_overall_tier(self, arena_name):
        row = self.overall.get(arena_name)
        return None if row is None else (float(row[0]) - self.anchor_raw) / self.sd

    def common(self, board):
        """[(board value, arena Overall tier, model name)] for the models listed at High on `board` and on arena Overall."""
        arena = {norm(sources.base_name(n)): n for n in self.overall}
        out = []
        for name, value in board.items():
            hit = arena.get(norm(sources.base_name(name)))
            if hit is not None:
                out.append((float(value), self.arena_overall_tier(hit), name))
        return out

    def board_map(self, board):
        pts = self.common(board)
        return Interpolation([p[0] for p in pts], [p[1] for p in pts], [p[2] for p in pts]) if len(pts) >= 3 else None

    def other_overall(self, listed):
        """{board id: reading} for the non-arena overall boards that list the model (`listed`: board id -> its name there)."""
        out = {}
        for board, mapping in self.maps.items():
            name = listed.get(board)
            if not name or mapping is None or name not in self.aa:
                continue
            x = self.aa[name]
            low, high = mapping.neighbours(x)
            out[board] = {'board': OVERALL_BOARDS[board][0], 'source': board, 'url': OVERALL_BOARDS[board][1],
                          'as_of': self.aa_read, 'listed_as': name, 'value': x, 'tier': round(float(mapping(x)), 4),
                          'neighbours': {'below': low, 'above': high}, 'n': mapping.n, 'status': 'estimated',
                          'fit': 'monotone piecewise-linear map of the board onto arena.ai Overall tiers through the models '
                                 'both list at High', **mapping.spread()}
        return out


def basis_arena(row, tier, anchor_raw, sd, anchor_name):
    value, lo, hi, listed, date = row
    return (f'arena.ai Overall {date} {listed} {value:.1f} [{lo:.1f},{hi:.1f}] at High standardized against '
            f'{anchor_name} ({anchor_raw:.1f}, sd {sd:.2f}): tier {tier:.4f}')


def main():
    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    ap.add_argument('models', nargs='*')
    ap.add_argument('--data')
    ap.add_argument('--json')
    args = ap.parse_args()
    acc = sources.accounts()
    models = acc['models']
    import measurements     # measurements imports this module: the records it reads (release pages included) are its to choose
    data = sources.data_dir(args.data)
    readings = sources.effort_readings(acc)
    fitter = Fitter(data, panel(acc)[2], measurements.aa_records_read(data, models, readings)[0], readings)
    for board, mapping in fitter.maps.items():
        print(f'{board}: {mapping.n if mapping else 0} models common with arena Overall at High')
    result = {}
    for key in args.models or [m for m, row in models.items() if isinstance(row, dict) and row.get('listed_as')]:
        explicit = listed_as(models, key, 'arena')
        arena = fitter.overall.get(explicit) if explicit else None
        entry = {'id': key}
        if arena:
            entry.update(method='arena_overall', tier=round(fitter.arena_overall_tier(explicit), 4))
        else:
            others = fitter.other_overall({'aa.index': listed_as(models, key, 'aa')})
            entry.update(method='other_overall' if others else 'none', boards=others,
                         tier=round(float(np.mean([o['tier'] for o in others.values()])), 4) if others else None)
        result[key] = entry
        print(f"{key:30s} {entry['method']:14s} tier {entry['tier']}")
    if args.json:
        Path_out = open(args.json, 'w', encoding='utf-8', newline='\n')
        with Path_out as fh:
            json.dump(result, fh, indent=1, default=str)


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