Extract tables as list of list of rows, where each row is a list of cells.

Find entries for a given commit.

Helper: create a minimal valid task directory.

Add clarifications and hints to the instruction.

Compute arithmetic mean of a sequence.

Parse a table row into cells.

Guess provider name from API base URL.

Format benchmark results for the leaderboard frontend. Returns a JSON-compatible dict matching the ``BenchResult`` interface used by the lead

Extract recipe lines for a specific target.

Check whether the ``gh`` CLI tool is installed.

Validate the package and print what *submit_pr* would do.

Check that the Docker daemon is running.

Extract bullet items from a named section.

Find a result entry by password string.

Generate a Markdown report.

Find a FunctionDef node by name.

Recursively find and load all summary.json files.

Create a mock httpx response.

Create a mock Sandbox context manager.

Deterministic seed from framework+model.

Check if user can start a new task. Returns (allowed, reason).

Get the ApiClient class.

Decrypt *input_path* to *output_path* using an age private key. The private key is passed via a temporary identity file to avoid leaking it i

Return the quotient of *a* / *b*. Raises: ValueError: If *b* is zero.

Encrypt *input_path* to *output_path* using an age public key. Raises: RuntimeError: If ``age`` is not installed or encryption fails.

Run *command* inside the container. Returns ``(stdout, stderr, exit_code)``.

Generate model x framework performance matrix for heatmap visualization. Parameters ---------- all_runs: Mapping from ``"framewor

Generate results for all framework-model combinations.

Verify that a token is valid and return the associated user. Args: token: The session token to verify. Returns: The authenti

Write an age-encrypted trace file. The plaintext JSON-lines are encrypted with the given *public_key* using the ``age`` encryption to

Validate that a skills mode is recognized.

Check that all adapters are importable. Returns (all_ok, failed_adapters).

Check that at least min_gb of disk space is available.

Check that Docker CLI is available.

Check that Python >= 3.11.

Find entries matching an endpoint substring.

Find an incident by type.

Find a result by rule_id.

Check if a function body contains a ListComp.

Load canonical model tier metadata.

Create a mock entry point that loads the given class.

Ensure the proposal belongs to the requesting expert.

Check whether the ``age`` CLI tool is installed and reachable.

Copy a local file or directory into the container at *container_path*.

Generate an age encryption keypair. Returns: A tuple of (public_key, private_key). Raises: RuntimeError: If ``age-keygen`` i

Get database connection.

Return all historical runs for *claw_id*, sorted by timestamp.

Load minimal task info from task.toml files.

Record one API round-trip.

Execute all tasks, with repeated runs and optional parallelism. Parameters ---------- on_task_complete: Optional callback ``(Task

Persist run results to JSON. When *tasks* is provided, also computes ``BenchmarkStatistics`` and writes a leaderboard-compatible ``leaderboar

Check that pyyaml is installed.

Compute 95% confidence interval: mean +/- 1.96 * (std / sqrt(n)).

Extract the absolute workspace path from the injected prompt.

Find entries matching a category.

Generate the next auto-increment ID for an entity type. Args: entity: Entity type name ('user', 'product', or 'order'). Returns:

Copy curated skills for the task's domain into the workspace. Returns a list of skill file names that were copied.

Compute population standard deviation.

Warn when a model tier is unknown or does not list the selected model.

Sum the costs of multiple task results. Each result dict must have: 'model', 'tokens_input', 'tokens_output'.

Copy a file or directory from the container to the local filesystem.

Generate a unique integer ID. Uses a simple incrementing counter. Not suitable for distributed systems.

Generate simulated task results for a framework-model pair.

Return all registered identities.

Update peak memory if *memory_mb* exceeds the current peak.

Write all entries to *path* in JSON-lines format.