Skip to content

akiiwa-games/AgentCompass / skills/agent-compass

agent-compass

Flagged

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.5 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.mdmarkdown28.9 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.mdmarkdown93.7 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.pyscript58.7 KB
scripts/dispatch_ground_truth.pyscript43.5 KB
scripts/dispatch_registry.pyscript113.7 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.4 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.pyscript322.3 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

scripts/launch_values.py

View on GitHub
"""Launch values: the declared patterns reference data must match, and how any launch value is made safe where it lands.

Reference data (shipped or published) is checked where it enters (account_fleet.launch_problems): a reference row whose
model, effort, mode or name does not match a pattern refuses the set, by name. The patterns accept every value in the
shipped data and every id this code generates itself (an automatic bundle id, its `#<sha8>` collision suffix).

Values from the user's machine (account names the user chose, model ids a provider lists, ids derived from them) are never
dropped by a pattern. They are made safe where they are used: passed as their own argument (argument), quoted for the
syntax they land in (toml_string, shell_word), or reduced to a safe file-name part (path_part). Where a value cannot be
expressed safely in one syntax, that one launch is refused there with a named error; nothing else about the account or
the model disappears.

No value is passed through cmd.exe: a Windows batch launcher (an npm `.cmd` shim, a desktop app's `.cmd`) is started as
the program its launch line runs (program), never as itself, since cmd.exe reads every argument of a batch file as
command text and no quoting of the argument list makes that safe.
"""
import json
import os
import re
import shutil
from pathlib import Path

# A model id: `claude-opus-5-5`, `claude-opus-5-5[1m]`, `gpt-6.2-sol`, `openai-codex/gpt-6-sol`, `model:high`,
# `name@version`.
MODEL = re.compile(r'[A-Za-z0-9][A-Za-z0-9._:/@+\[\]-]{0,159}')
# An account, provider, harness, family, effort or mode id in reference data: one word, no path separator.
NAME = re.compile(r'[A-Za-z0-9][A-Za-z0-9._-]{0,79}')
# A bundle id: an automatic one is `auto:<account>:<harness>:<model>@<effort>`, with `#<sha8>` after a name collision.
BUNDLE_ID = re.compile(r'[A-Za-z0-9][A-Za-z0-9._:/@+#\[\]-]{0,239}')
BUNDLE_FIELDS = {'model': MODEL, 'launch_model': MODEL, 'effort': NAME, 'modeId': NAME, 'provider': NAME,
                 'harness': NAME, 'family': NAME}
# A word a POSIX shell and PowerShell both read as itself.
_PLAIN_WORD = re.compile(r'[A-Za-z0-9._:/@+=-]+')
_UNSAFE_PATH = re.compile(r'[^A-Za-z0-9._-]+')


class LaunchValueError(ValueError):
    """A launch value that cannot be expressed safely in the syntax it would land in: this one launch is refused."""


def problem(label, value, pattern):
    """None when ``value`` is a string matching ``pattern``, else what is wrong, naming ``label``."""
    if isinstance(value, str) and pattern.fullmatch(value):
        return None
    return f'{label} {value!r} does not match {pattern.pattern}'


def bundle_problems(account, bundle_id, bundle):
    """What in one reference bundle row does not match the declared patterns: its id and every launch field present."""
    where = f'{account}.bundles.{bundle_id}'
    found = [p for p in (problem(f'{account}: bundle id', bundle_id, BUNDLE_ID),) if p]
    if not isinstance(bundle, dict):
        return found + [f'{where} is not an object']
    for field, pattern in BUNDLE_FIELDS.items():
        if bundle.get(field) not in (None, ''):
            found += [p for p in (problem(f'{where}.{field}', bundle[field], pattern),) if p]
    efforts = bundle.get('efforts')
    if efforts is not None:
        if not isinstance(efforts, list):
            found.append(f'{where}.efforts is not a list')
        else:
            found += [p for p in (problem(f'{where}.efforts[]', e, NAME) for e in efforts) if p]
    return found


def argument(label, value):
    """``value`` as one argument after its option (`--model <value>`): text, not empty, not read as an option, no line
    break or NUL. Anything else is refused for this launch, by name."""
    if not isinstance(value, str) or not value or value.startswith('-') or any(c in value for c in '\0\r\n'):
        raise LaunchValueError(f'{label} {value!r} cannot be passed as a command-line argument; this launch is refused')
    return value


def path_part(value):
    """``value`` as one file-name part: unsafe characters become `_` (a run directory label, never an identity)."""
    return _UNSAFE_PATH.sub('_', str(value)).strip('._') or '_'


def toml_string(value):
    """``value`` as a TOML basic string (`-c key=<this>`): JSON string escapes are valid TOML basic-string escapes."""
    if not isinstance(value, str):
        raise LaunchValueError(f'a TOML string value must be text, not {type(value).__name__}')
    return json.dumps(value, ensure_ascii=True)


def shell_word(value):
    """``value`` as one word of a command a parent session runs in a POSIX shell or PowerShell: as it is when plain,
    else single-quoted; a value holding a single quote, or one read as an option, cannot be written the same way for
    both and is refused for this launch."""
    value = str(value)
    if value.startswith('-') or not value:
        raise LaunchValueError(f'{value!r} would be read as an option; this launch is refused')
    if _PLAIN_WORD.fullmatch(value):
        return value
    if "'" in value or any(c in value for c in '\0\r\n'):
        raise LaunchValueError(f'{value!r} cannot be quoted as one shell word; this launch is refused')
    return f"'{value}'"


BATCH_SUFFIXES = ('.cmd', '.bat')
_SET = re.compile(r'^@?set\s+(?!/)(?:"(?P<quoted>[^"=]+)=(?P<qvalue>[^"]*)"|(?P<name>[^\s="]+)=(?P<value>.*?))\s*$',
                  re.IGNORECASE)
_REFERENCE = re.compile(r'%~f0|%~dp0|%([^%\s]*)%', re.IGNORECASE)


class UnreadableLauncher(LaunchValueError):
    """A batch launcher whose launch line cannot be read as a program and its arguments: the launch is refused."""


def program(path, environ=None):
    """``(argv, env)`` that start the program at ``path`` with no command interpreter in between.

    For anything but a Windows batch launcher this is ``[path]`` and no variables. A batch launcher (`.cmd`, `.bat`: an
    npm shim, a desktop app's command-line launcher) is read, not run: its launch line is the last line that passes the
    arguments on (`%*`), after the last `&` or `|` outside quotes. Its words are expanded with what the file itself
    sets (`set "NAME=value"`, `%~dp0`, `%~f0`) and then the process environment; the first word, the program, must name
    an existing file that is not itself a batch file (a bare name is looked up on PATH), and a word with several
    possible values (an `if exist` choice) takes the first one that exists. ``env`` holds the variables the file sets
    for the program (those its launch line does not consume, with one value). Anything else (no such line, a word that
    cannot be expanded, more after `%*`, a program that cannot be found) is a stated refusal (UnreadableLauncher),
    never a start through cmd.exe."""
    path = Path(path)
    if path.suffix.lower() not in BATCH_SUFFIXES:
        return [str(path)], {}
    environ = os.environ if environ is None else environ

    def refuse(why):
        raise UnreadableLauncher(f'{path} is a batch launcher that cannot be started without cmd.exe ({why}); cmd.exe '
                                 'would read its arguments as commands, so this launch is refused: point the command '
                                 'at the executable it runs')
    try:
        text = path.read_text(encoding='utf-8', errors='replace')[:65536]
    except OSError as exc:
        refuse(f'it cannot be read: {exc.strerror or exc}')
    lines = [line.strip() for line in text.splitlines()]
    assigned = {}
    for line in lines:
        found = _SET.match(line)
        if found:
            name = found.group('quoted') or found.group('name')
            value = found.group('qvalue') if found.group('quoted') else found.group('value')
            assigned.setdefault(name.lower(), (name, []))[1].append(value)
    launch = [line for line in lines if '%*' in line and not line.lower().startswith(('rem ', '::', 'set '))]
    if not launch:
        refuse('no line passes its arguments on with %*')
    words = _words(_last_command(launch[-1]))
    if '%*' not in words:
        refuse('its launch line passes %* inside another word')
    at = words.index('%*')
    if words[at + 1:]:
        refuse(f'its launch line goes on after %*: {" ".join(words[at + 1:])}')
    words = words[:at]
    if words and words[0].lower() == 'call':
        words = words[1:]
    if not words:
        refuse('its launch line names no program')
    consumed, argv = set(), []
    for index, word in enumerate(words):
        values = _expand(word, path, assigned, environ, consumed, 0)
        if not values:
            refuse(f'{word} cannot be expanded without running cmd.exe')
        if index == 0:
            chosen = next((found for found in map(lambda v: _program_file(v, environ), values) if found), None)
            if chosen is None:
                refuse(f'its program {word} ({values[0]}) is not an existing executable')
        else:
            existing = [v for v in values if _looks_like_path(v) and Path(v).exists()]
            if not existing and len(values) > 1:
                refuse(f'{word} has more than one possible value and none exists')
            chosen = os.path.normpath(existing[0]) if existing else (
                os.path.normpath(values[0]) if _looks_like_path(values[0]) else values[0])
        argv.append(chosen)
    env = {}
    for key, (name, values) in assigned.items():
        if key in consumed or len(set(values)) != 1:
            continue
        expanded = _expand(values[0], path, assigned, environ, set(), 0)
        if len(expanded) == 1:
            env[name] = expanded[0]
    return argv, env


def _last_command(line):
    """What runs last on ``line``: the part after the last `&` or `|` outside double quotes, without a leading `@`."""
    quoted, start = False, 0
    for index, char in enumerate(line):
        if char == '"':
            quoted = not quoted
        elif char in '&|' and not quoted:
            start = index + 1
    return line[start:].strip().lstrip('@').strip().rstrip(')').strip()


def _words(text):
    """The words of ``text`` split at spaces outside double quotes, quotes removed."""
    words, current, quoted, started = [], [], False, False
    for char in text:
        if char == '"':
            quoted, started = not quoted, True
        elif char.isspace() and not quoted:
            if started:
                words.append(''.join(current))
            current, started = [], False
        else:
            current.append(char)
            started = True
    if started:
        words.append(''.join(current))
    return words


def _expand(text, path, assigned, environ, consumed, depth):
    """Every value ``text`` can take, its `%NAME%` references expanded from what the file sets, then the environment; []
    when a reference cannot be expanded (substring syntax, `%%F`, an unset name) or the nesting is too deep."""
    if depth > 8:
        return []
    results = ['']
    position = 0
    for found in _REFERENCE.finditer(text):
        literal = text[position:found.start()]
        token = found.group(0)
        if token.lower() == '%~dp0':
            options = [str(path.parent) + os.sep]
        elif token.lower() == '%~f0':
            options = [str(path)]
        else:
            name = found.group(1)
            if not name or ':' in name or name.startswith('~'):
                return []
            if name.lower() in assigned:
                consumed.add(name.lower())
                options = [v for raw in assigned[name.lower()][1]
                           for v in _expand(raw, path, assigned, environ, consumed, depth + 1)]
            else:
                value = next((v for k, v in environ.items() if k.lower() == name.lower()), None)
                options = [value] if value is not None else []
            if not options:
                return []
        results = [r + literal + o for r in results for o in options][:32]
        position = found.end()
    if '%' in text[position:]:
        return []
    return [r + text[position:] for r in results]


def _looks_like_path(value):
    return os.path.isabs(value) or '\\' in value or '/' in value


def _program_file(value, environ):
    """The existing executable file ``value`` names (a bare name looked up on PATH), else None; never a batch file."""
    if _looks_like_path(value):
        candidate = Path(os.path.normpath(value))
        found = str(candidate) if candidate.is_file() else None
    else:
        found = shutil.which(value, path=environ.get('PATH'))
    if not found or Path(found).suffix.lower() in BATCH_SUFFIXES:
        return None
    return found
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: 471kUpdated 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