@xgent-ai/skills 0.1.0 → 0.3.0

package/skills/working-with-mbx/references/cache-results.md

@@ -0,0 +1,153 @@
+Cache results
+
+Cache results [​](#cache-results)
+
+Use the build summary to see what mbx restored, compiled, or left uncached. Counts describe compiler actions observed by mbx; they do not include work Cargo skipped because its outputs were already fresh.
+
+sh
+
+```
+mbx explain --last          # inspect the most recent recorded build
+MBX_SUMMARY=full mbx build  # print a detailed report for a new build
+```
+
+| Outcome | Cache lookup? | Result stored? |
+| --- | --- | --- |
+| [Hit](#hit) | Found a result | Already stored |
+| [Miss](#miss) | No matching result | After successful compilation |
+| [Not looked up](#could-not-look-up) | No usable input prediction yet | After successful compilation |
+| [Bypass](#bypass) | Skipped | No shared result |
+
+## Measure cache reuse [​](#measure-cache-reuse)
+
+Running the same command twice in the same target directory often measures Cargo's freshness check: no compiler work is needed. To observe mbx reuse, build equivalent source with the same toolchain, profile, and features into two fresh target directories:
+
+sh
+
+```
+mbx build --target-dir target/cache-demo-first
+mbx build --target-dir target/cache-demo-second
+```
+
+Use directory names that do not already contain build outputs. This keeps your normal target intact and avoids deleting the shared cache. The second build can restore work recorded by the first; unsupported actions still run. These explicit targets are not managed, so remove the two example directories when you finish. For repeatable timings, use the [benchmark harness](https://mr-boxington.jdx.dev/benchmarks).
+
+Compiler time avoided is summed across actions. It is not elapsed time saved; always compare wall-clock build time as well as the counters.
+
+## Hit [​](#hit)
+
+mbx derived an action key, found its result, and restored the outputs. A hit can come from the local store or a configured remote.
+
+## Miss [​](#miss)
+
+mbx derived a key and looked it up, but no result existed. The compilation ran and its successful result was stored.
+
+## Could not look up [​](#could-not-look-up)
+
+mbx did not yet have usable dep-info or a prediction from which to derive the key. This is common on a cold build. The action is still stored after compilation, so calling it a miss would overstate the number of failed lookups. The short summary counts these as `not looked up`; the full summary prints a `could not look up` line with the reason.
+
+## Bypass [​](#bypass)
+
+mbx recognized that it could not model the action exactly and ran the real compiler without caching it. The short summary's `bypassed` count leaves out routine compiler probes (`compiler-query`, `standard-input`, and their `cc-` counterparts). Reasons are grouped in the full summary (`MBX_SUMMARY=full`); set `MBX_BYPASS_LOG` to a file path for the per-action record.
+
+Run a Cargo command through `mbx explain` to collect those records temporarily, group identical causes, and print guidance for every bypass category:
+
+sh
+
+```
+mbx explain build --workspace
+```
+
+text
+
+```
+cache explanation: 8 compilations bypassed the cache
+
+compiler-query (2)
+Expected: Cargo asks rustc for toolchain information; there is no compilation to cache.
+  - rustc invocation is a compiler query, not a compilation (2 times)
+
+incremental (5)
+Cargo compiled this incrementally, which mbx cannot cache. `MBX_INCREMENTAL=0` makes it cacheable again; mbx already gives a crate you are editing its own incremental state without giving up the rest of the cache.
+  - incremental compilation cannot be combined with action caching (5 times)
+
+standard-input (1)
+Expected for Cargo probes: source supplied on standard input cannot be rediscovered later.
+  - rustc invocation reads source from standard input
+```
+
+Categories marked expected are routine compiler probes, with no output to cache; here the `incremental` group is the one the build could act on. The command preserves Cargo's exit status after printing the explanation.
+
+Actionable bypasses carry their remediation with the reason that produced them. For example, links rejected because of `split-debuginfo=packed` point to the active Cargo profile or `RUSTFLAGS`, while C compilations affected by `CPATH` name the environment variable to unset.
+
+`mbx explain` also reports cacheability problems that prevent a compilation from reaching mbx at all. If `CC`, `CXX`, `HOST_CC`, or `HOST_CXX` was already set when the build began, the report names the variable and value and explains that host C and C++ compiles are invisible to the cache. These are warnings, not bypass counts, because mbx never observed the compiler invocations.
+
+## Remote failure [​](#remote-failure)
+
+A remote cache request failed and the build continued without that result: an unreachable host, refused credentials, or an invalid response can all reduce reuse. Build-time transport failures fall back to local compilation. Invalid configuration can still stop startup, and explicit `mbx prefetch` and `mbx doctor` commands report connection failures as errors. The summary counts them because a remote that is failing every request reports the same hits, misses, and bytes as one that was empty. The short summary includes the count inline; the full summary explains it:
+
+text
+
+```
+mbx[cache]: the remote cache failed 4 of its requests; this build ran without what it could not reach, and the warnings above say why
+```
+
+The individual warnings, printed as the build runs, say what failed. The count also appears as `remote_failures` in the JSON statistics report, so CI can alert on a cache that has quietly stopped serving.
+
+## Watching a build instead [​](#watching-a-build-instead)
+
+Everything above describes results reported after a build. To see the same outcomes as they are decided, one row per compilation with the crate it belongs to, run [`mbx tui`](https://mr-boxington.jdx.dev/tui) in another terminal. It reads builds using the same local cache, including ones already running.
+
+## Reading the hit rate [​](#reading-the-hit-rate)
+
+A build can report a high hit rate among attempted lookups while spending most of its time on actions that were not looked up or were bypassed. Read all the summary counts together, and compare wall-clock time when evaluating the cache. Set `MBX_SUMMARY=full` when the one-line counts need a breakdown.
+
+A link mbx cannot describe always runs, so its downstream crates may have work to do on an otherwise warm build. Native executables, tests, and proc macros on Linux, macOS, and Windows, plus binaries, tests, and `cdylib`s for supported self-contained WebAssembly targets, may be restored as hits; see [limits](https://mr-boxington.jdx.dev/limits#native-linking-is-cached-only-where-the-linker-can-be-described).
+
+## Troubleshooting a low hit rate [​](#troubleshooting-a-low-hit-rate)
+
+Run the build through `mbx explain` first. It collects the per-action records, groups identical causes, and prints guidance for each category:
+
+sh
+
+```
+mbx explain build --workspace
+```
+
+The usual causes, roughly in the order they show up:
+
+- The store is cold. A first build has no dep-info to derive keys from, so "could not look up" can dominate. Compare equivalent builds with fresh targets as described [above](#measure-cache-reuse).
+- Incremental builds are enabled. With `MBX_INCREMENTAL=1`, workspace members compile incrementally, those compilations bypass the cache, and the changed artifacts make crates above them miss too. See [limits](https://mr-boxington.jdx.dev/limits#incremental-compilations-are-not-cached).
+- A link could not be described. Native executables, tests, and proc macros are cached on Linux, macOS, and Windows, and self-contained WebAssembly targets everywhere, but native links with custom or unmodeled inputs still run. A rebuilt dylib can also change the keys of its downstream crates. `mbx explain` reports why the link bypassed; see [limits](https://mr-boxington.jdx.dev/limits#native-linking-is-cached-only-where-the-linker-can-be-described).
+- The inputs differ. A different toolchain, feature set, profile, or `RUSTFLAGS` between two checkouts is a different key, and the summary reports it as an ordinary miss. Run `mbx explain --last` to replay the most recent recorded build and list, per missed crate, the key inputs that changed since its last recorded hit. Session history stores hashes, not source contents or environment values.
+- Build-script output that differs. mbx can share Rust compilations that read `OUT_DIR` when the generated output matches across checkouts. A build script that embeds the checkout path in its output prevents that reuse. Sharing also depends on whether mbx can detect the reference and copy the output; `MBX_SHARE_OUT_DIR=0` disables it. See [`OUT_DIR` sharing](https://mr-boxington.jdx.dev/limits#out-dir-sharing).
+- A build chose its own C compiler, or is cross-compiling. Setting `CC`, `HOST_CC`, `CXX`, or `HOST_CXX` leaves host compilations outside mbx. Cross-compilations are cached when the build explicitly names a supported compiler through `CC_<target>`, `CXX_<target>`, `TARGET_CC`, or `TARGET_CXX`. Bypass kinds beginning `cc-` report anything the C adapter declined to model. See [limits](https://mr-boxington.jdx.dev/limits#c-and-c-caching-covers-the-host-compiles-mbx-drives).
+- CI restored nothing. On GitHub Actions, check that the cache step restored an entry; a changed `cache-generation` or a fresh repository starts empty. With a remote cache configured, check the [remote failure](#remote-failure) count too: a remote that is failing every request reports the same zeros as one that is empty.
+
+## Compiler time [​](#compiler-time)
+
+The full summary reports real compiler time by outcome and an estimate of the compiler time avoided by cache hits:
+
+text
+
+```
+mbx[cache]: compiler time: 4m 12s estimated avoided; 38.20s spent (161 miss in 31.00s, 7 unconsulted in 7.20s)
+mbx[cache]: slowest uncached crates: syn 8.90s, regex-syntax 4.90s, serde_derive 3.90s
+```
+
+Times of a minute or more are reported in whole units, as above; shorter ones keep their fraction.
+
+The estimate comes from the duration recorded with the successful compilation that populated the action prediction; older predictions without a timing hint contribute zero. The five crates with the largest cumulative uncached compiler time are listed so you can identify expensive uncached work. Parallel compilations overlap, so this ranking does not directly identify the critical path.
+
+The JSON statistics report exposes the same data in `estimated_compiler_duration_avoided_ns`, `compiler`, and `slow_compilations`.
+
+[Edit this page on GitHub](https://github.com/jdx/mr-boxington/edit/main/docs/cache-results.md)
+
+Last updated:
+
+Pager
+
+[Previous pageTroubleshooting](https://mr-boxington.jdx.dev/troubleshooting)
+
+[Next pageSavings and statistics](https://mr-boxington.jdx.dev/stats)
+
+MIT License·Copyright © 2026· [jjdx.dev](https://jdx.dev)

package/skills/working-with-mbx/references/cache-server.md

@@ -0,0 +1,151 @@
+Cache server
+
+Cache server [​](#cache-server)
+
+[`jdx/mr-boxington-cache`](https://github.com/jdx/mr-boxington-cache) is the self-hostable remote cache server. It implements version 1 of the mbx action-cache protocol: immutable blobs, atomic action-result commits, namespace isolation, and streaming blob packs. It also serves [mise](https://mise.jdx.dev)'s task cache. Any server implementing the [protocol](https://mr-boxington.jdx.dev/protocol-compatibility) works with mbx; this page documents the reference implementation.
+
+## Run it [​](#run-it)
+
+Clone the server repository before starting its development stack. It runs the service, PostgreSQL, and MinIO:
+
+sh
+
+```
+git clone https://github.com/jdx/mr-boxington-cache.git
+cd mr-boxington-cache
+docker compose up --build
+```
+
+For a standalone instance with filesystem storage:
+
+sh
+
+```
+cargo install mbx-cache --locked
+mbx-cache \
+  --allow-anonymous \
+  --data-dir ./data \
+  --listen 127.0.0.1:8080
+```
+
+The standalone example binds to loopback and allows anonymous access for local evaluation. Production installations should terminate TLS at an ingress or proxy and configure tokens. The repository ships a Helm chart for horizontally scaled Kubernetes deployments and a Terraform-managed single-host example.
+
+Connect mbx to the local example with this global configuration:
+
+toml
+
+```
+[remote]
+url = "http://127.0.0.1:8080"
+namespace = "example/project"
+mode = "read-only"
+```
+
+Run `mbx doctor` to check connectivity. A local shell is read-only even when `mode` is `read-write`; use [trusted CI](https://mr-boxington.jdx.dev/remote-cache#read-and-write-policy) to populate the remote through mbx. For an authenticated deployment, use HTTPS and add a token or OIDC audience as described in [Remote cache](https://mr-boxington.jdx.dev/remote-cache).
+
+## Configuration [​](#configuration)
+
+Every option has a matching environment variable and CLI flag; run `mbx-cache --help` for the complete list.
+
+| Environment variable | Default | Purpose |
+| --- | --- | --- |
+| `MBX_CACHE_LISTEN` | `0.0.0.0:8080` | Listen address |
+| `MBX_CACHE_STORAGE` | `filesystem` | `filesystem` or `s3` |
+| `MBX_CACHE_DATA_DIR` | `/var/lib/mbx-cache` | Filesystem blob root |
+| `MBX_CACHE_DATABASE_URL` | `memory://` | PostgreSQL URL or development memory store |
+| `MBX_CACHE_S3_BUCKET` | none | Required for S3 storage |
+| `MBX_CACHE_S3_PREFIX` | `v1` | Object-key prefix |
+| `MBX_CACHE_S3_ENDPOINT` | AWS default | S3-compatible endpoint |
+| `MBX_CACHE_S3_REGION` | `us-east-1` | S3 region |
+| `MBX_CACHE_S3_PATH_STYLE` | `false` | Enable for MinIO and similar services |
+| `MBX_CACHE_TOKENS_JSON` | none | Static token grants |
+| `MBX_CACHE_OIDC_PROVIDERS_JSON` | none | Trusted OIDC providers and claim grants |
+| `MBX_CACHE_ALLOW_ANONYMOUS` | `false` | Allow access without configured grants |
+| `MBX_CACHE_MAX_BLOB_BYTES` | `5368709120` | Maximum upload size |
+
+AWS credentials use the standard SDK credential chain, including environment variables, workload identity, ECS, and EC2 roles.
+
+## Authorization [​](#authorization)
+
+Authorization is deny-by-default. Namespace patterns may be an exact name, `*`, or a prefix ending in `/*`.
+
+### Static tokens [​](#static-tokens)
+
+`MBX_CACHE_TOKENS_JSON` is an array of grants:
+
+json
+
+```
+[
+  {
+    "token": "replace-with-a-secret",
+    "read": ["acme/*", "public"],
+    "write": ["acme/project-a"]
+  }
+]
+```
+
+Rotate tokens by deploying the old and new grants together, moving clients to the new token, then removing the old grant. Inject the JSON through a secret, not through deployment configuration.
+
+### OIDC [​](#oidc)
+
+OIDC lets CI use short-lived identity tokens instead of stored secrets. Configure trusted issuers, acceptable audiences, and claim-based grants. This example grants access only to pushes on `acme/backend`'s `main` branch. Replace the numeric owner ID and add separate read-only rules for any other identities that need access:
+
+json
+
+```
+[
+  {
+    "issuer": "https://token.actions.githubusercontent.com",
+    "audiences": ["https://cache.example.com"],
+    "rules": [
+      {
+        "claims": {
+          "repository": "acme/backend",
+          "repository_owner_id": "12345",
+          "ref": "refs/heads/main",
+          "event_name": "push"
+        },
+        "read": ["acme/backend"],
+        "write": ["acme/backend"]
+      }
+    ]
+  }
+]
+```
+
+The server discovers the issuer's JWKS endpoint and verifies the signature, issuer, audience, expiry, not-before time, and subject before applying the first matching rule. Rules are alternatives; every claim within a rule must match exactly. Pin stable identity claims such as GitHub's numeric `repository_owner_id` alongside the repository name, since names can be reclaimed and the ID cannot. Add `ref` or `environment` claims when only a narrower workflow identity should write. Symmetric JWT algorithms are never accepted.
+
+On the client side, mbx acquires the GitHub Actions job token itself: set `MBX_REMOTE_OIDC_AUDIENCE`, or use [`jdx/mr-boxington-action`](https://github.com/jdx/mr-boxington-action) with `backend: server` as shown in [GitHub Action](https://mr-boxington.jdx.dev/github-action#cache-server).
+
+## Operations [​](#operations)
+
+For S3-backed storage, expire blobs with a bucket lifecycle rule. Run a separate metadata sweep to remove old records; this command exits after cleanup without starting the server:
+
+sh
+
+```
+mbx-cache --sweep-metadata-older-than-days 35
+```
+
+Keep the sweep age longer than the storage lifecycle so objects expire first. A dangling reference is never fatal: a client that cannot fetch a blob treats the action as a miss and recompiles.
+
+Multiple stateless replicas can run against the same PostgreSQL database and S3 bucket. Readiness and liveness probes use `/v1/status`, and `/metrics` exposes Prometheus counters for actions, blobs, and blob-pack transfers with fixed, low-cardinality labels. Namespaces, tokens, and digests never appear as labels. The server has no deletion endpoint. Retention and disaster recovery are administrative concerns: back up PostgreSQL, and use bucket versioning or replication as required.
+
+A server advertising action promises can coordinate identical cold compilations across replicas. Claims are short-lived database leases scoped by namespace and invocation digest; completion is accepted only after the named action result is durable. Abandoned claims expire, completed promises are immutable for their retention window, and no promise endpoint bypasses the namespace's write authorization.
+
+## Protocol [​](#protocol)
+
+The wire protocol (endpoints, media types, canonical hashing, and the evolution rules) is documented in [protocol compatibility](https://mr-boxington.jdx.dev/protocol-compatibility). The [repository README](https://github.com/jdx/mr-boxington-cache) covers implementation details beyond it, including blob-pack framing and validation behavior.
+
+[Edit this page on GitHub](https://github.com/jdx/mr-boxington/edit/main/docs/cache-server.md)
+
+Last updated:
+
+Pager
+
+[Previous pageRemote cache](https://mr-boxington.jdx.dev/remote-cache)
+
+[Next pageTroubleshooting](https://mr-boxington.jdx.dev/troubleshooting)
+
+MIT License·Copyright © 2026· [jjdx.dev](https://jdx.dev)

package/skills/working-with-mbx/references/cli/adopt.md

@@ -0,0 +1,29 @@
+mbx adopt
+
+`mbx adopt` [​](#mbx-adopt)
+
+- **Usage:** `mbx adopt [-r --recursive] [--dry-run] [PATH]…`
+
+Bring existing Cargo target directories under mbx management without deleting their contents.
+
+mbx moves each directory under the managed root and leaves a `target` link in its place. The adopted directory then follows the usual managed-target collection policy.
+
+## Arguments [​](#arguments)
+
+- **`[PATH]…`** — Cargo checkouts to adopt, or directories to search with --recursive. Defaults to the current directory.
+
+## Flags [​](#flags)
+
+- **`-r --recursive`** — Search below each path for Cargo checkouts with a target directory. Hidden directories, target directories, and symbolic links are skipped.
+- **`--dry-run`** — Report what would be adopted without moving anything.
+- **`-h --help`** — Print help
+
+[Edit this page on GitHub](https://github.com/jdx/mr-boxington/edit/main/crates/mbx/src/cli/adopt.rs)
+
+Last updated:
+
+Pager
+
+[Next pageDocumentation](https://mr-boxington.jdx.dev/guide)
+
+MIT License·Copyright © 2026· [jjdx.dev](https://jdx.dev)

package/skills/working-with-mbx/references/cli/cache/dir.md

@@ -0,0 +1,24 @@
+mbx cache dir
+
+`mbx cache dir` [​](#mbx-cache-dir)
+
+- **Usage:** `mbx cache dir [--json]`
+
+Print the store directory.
+
+## Flags [​](#flags)
+
+- **`--json`** — Print a stable machine-readable report.
+- **`-h --help`** — Print help
+
+[Edit this page on GitHub](https://github.com/jdx/mr-boxington/edit/main/crates/mbx/src/cli/cache.rs)
+
+Last updated:
+
+Pager
+
+[Previous pagecache](https://mr-boxington.jdx.dev/cli/cache/)
+
+[Next pagestats](https://mr-boxington.jdx.dev/cli/cache/stats)
+
+MIT License·Copyright © 2026· [jjdx.dev](https://jdx.dev)

package/skills/working-with-mbx/references/cli/cache/export.md

@@ -0,0 +1,31 @@
+mbx cache export
+
+`mbx cache export` [​](#mbx-cache-export)
+
+- **Usage:** `mbx cache export [--group <GROUP>] [--format <FORMAT>] <ARCHIVE>`
+
+Export the cache closure of this checkout's last build. The export includes Cargo scheduler state for recorded workspaces, with compiler outputs referenced from the content-addressed closure instead of duplicated.
+
+## Arguments [​](#arguments)
+
+- **`<ARCHIVE>`** — Tar archive or directory to write.
+
+## Flags [​](#flags)
+
+- **`--group <GROUP>`** — Export every build that set MBX\_CACHE\_EXPORT\_GROUP to this CI group.
+- **`--format <FORMAT>`** — Bundle layout: tar for a portable archive, or directory for a transport that archives a directory itself, such as the GitHub Actions cache.
+
+  **Default:** `tar`
+- **`-h --help`** — Print help
+
+[Edit this page on GitHub](https://github.com/jdx/mr-boxington/edit/main/crates/mbx/src/cli/cache.rs)
+
+Last updated:
+
+Pager
+
+[Previous pagetrace](https://mr-boxington.jdx.dev/cli/cache/trace)
+
+[Next pageimport](https://mr-boxington.jdx.dev/cli/cache/import)
+
+MIT License·Copyright © 2026· [jjdx.dev](https://jdx.dev)

package/skills/working-with-mbx/references/cli/cache/import.md

@@ -0,0 +1,27 @@
+mbx cache import
+
+`mbx cache import` [​](#mbx-cache-import)
+
+- **Usage:** `mbx cache import <ARCHIVE>`
+
+Import a cache export into the local store. A directory export is consumed: its objects are moved into the store and the directory is removed. If the export contains Cargo workspace state and the command runs from a matching checkout with an absent or empty target directory, restore that state as well. A non-empty target directory is never replaced.
+
+## Arguments [​](#arguments)
+
+- **`<ARCHIVE>`** — Tar archive or directory to import.
+
+## Flags [​](#flags)
+
+- **`-h --help`** — Print help
+
+[Edit this page on GitHub](https://github.com/jdx/mr-boxington/edit/main/crates/mbx/src/cli/cache.rs)
+
+Last updated:
+
+Pager
+
+[Previous pageexport](https://mr-boxington.jdx.dev/cli/cache/export)
+
+[Next pageremove](https://mr-boxington.jdx.dev/cli/cache/remove)
+
+MIT License·Copyright © 2026· [jjdx.dev](https://jdx.dev)

package/skills/working-with-mbx/references/cli/cache/largest.md

@@ -0,0 +1,26 @@
+mbx cache largest
+
+`mbx cache largest` [​](#mbx-cache-largest)
+
+- **Usage:** `mbx cache largest [--limit <LIMIT>]`
+
+List the largest objects and action-result records.
+
+## Flags [​](#flags)
+
+- **`--limit <LIMIT>`** — Maximum entries to print.
+
+  **Default:** `20`
+- **`-h --help`** — Print help
+
+[Edit this page on GitHub](https://github.com/jdx/mr-boxington/edit/main/crates/mbx/src/cli/cache.rs)
+
+Last updated:
+
+Pager
+
+[Previous pageprojects](https://mr-boxington.jdx.dev/cli/cache/projects)
+
+[Next pageverify](https://mr-boxington.jdx.dev/cli/cache/verify)
+
+MIT License·Copyright © 2026· [jjdx.dev](https://jdx.dev)

package/skills/working-with-mbx/references/cli/cache/projects.md

@@ -0,0 +1,23 @@
+mbx cache projects
+
+`mbx cache projects` [​](#mbx-cache-projects)
+
+- **Usage:** `mbx cache projects`
+
+Show cache use attributed to recorded workspaces.
+
+## Flags [​](#flags)
+
+- **`-h --help`** — Print help
+
+[Edit this page on GitHub](https://github.com/jdx/mr-boxington/edit/main/crates/mbx/src/cli/cache.rs)
+
+Last updated:
+
+Pager
+
+[Previous pagestats](https://mr-boxington.jdx.dev/cli/cache/stats)
+
+[Next pagelargest](https://mr-boxington.jdx.dev/cli/cache/largest)
+
+MIT License·Copyright © 2026· [jjdx.dev](https://jdx.dev)

package/skills/working-with-mbx/references/cli/cache/remove.md

@@ -0,0 +1,30 @@
+mbx cache remove
+
+`mbx cache remove` [​](#mbx-cache-remove)
+
+- **Usage:** `mbx cache remove [--interactive] [WORKSPACE]`
+
+Remove managed targets, learned incremental state, and cache claims for one workspace or selected workspaces.
+
+Provide exactly one of `<WORKSPACE>` or `--interactive`.
+
+## Arguments [​](#arguments)
+
+- **`[WORKSPACE]`** — Workspace root to forget.
+
+## Flags [​](#flags)
+
+- **`--interactive`** — Select recorded workspaces to remove.
+- **`-h --help`** — Print help
+
+[Edit this page on GitHub](https://github.com/jdx/mr-boxington/edit/main/crates/mbx/src/cli/cache.rs)
+
+Last updated:
+
+Pager
+
+[Previous pageimport](https://mr-boxington.jdx.dev/cli/cache/import)
+
+[Next pageStability](https://mr-boxington.jdx.dev/stability)
+
+MIT License·Copyright © 2026· [jjdx.dev](https://jdx.dev)

package/skills/working-with-mbx/references/cli/cache/stats.md

@@ -0,0 +1,24 @@
+mbx cache stats
+
+`mbx cache stats` [​](#mbx-cache-stats)
+
+- **Usage:** `mbx cache stats [--json]`
+
+Summarize what the store holds.
+
+## Flags [​](#flags)
+
+- **`--json`** — Print a stable machine-readable report.
+- **`-h --help`** — Print help
+
+[Edit this page on GitHub](https://github.com/jdx/mr-boxington/edit/main/crates/mbx/src/cli/cache.rs)
+
+Last updated:
+
+Pager
+
+[Previous pagedir](https://mr-boxington.jdx.dev/cli/cache/dir)
+
+[Next pageprojects](https://mr-boxington.jdx.dev/cli/cache/projects)
+
+MIT License·Copyright © 2026· [jjdx.dev](https://jdx.dev)

package/skills/working-with-mbx/references/cli/cache/trace.md

@@ -0,0 +1,27 @@
+mbx cache trace
+
+`mbx cache trace` [​](#mbx-cache-trace)
+
+- **Usage:** `mbx cache trace <SESSION>`
+
+Export wrapper timings from a session JSONL file as Perfetto-compatible trace JSON.
+
+## Arguments [​](#arguments)
+
+- **`<SESSION>`** — Session JSONL file under the store's sessions/v1 directory.
+
+## Flags [​](#flags)
+
+- **`-h --help`** — Print help
+
+[Edit this page on GitHub](https://github.com/jdx/mr-boxington/edit/main/crates/mbx/src/cli/cache.rs)
+
+Last updated:
+
+Pager
+
+[Previous pageverify](https://mr-boxington.jdx.dev/cli/cache/verify)
+
+[Next pageexport](https://mr-boxington.jdx.dev/cli/cache/export)
+
+MIT License·Copyright © 2026· [jjdx.dev](https://jdx.dev)

package/skills/working-with-mbx/references/cli/cache/verify.md

@@ -0,0 +1,23 @@
+mbx cache verify
+
+`mbx cache verify` [​](#mbx-cache-verify)
+
+- **Usage:** `mbx cache verify`
+
+Verify local objects and action results.
+
+## Flags [​](#flags)
+
+- **`-h --help`** — Print help
+
+[Edit this page on GitHub](https://github.com/jdx/mr-boxington/edit/main/crates/mbx/src/cli/cache.rs)
+
+Last updated:
+
+Pager
+
+[Previous pagelargest](https://mr-boxington.jdx.dev/cli/cache/largest)
+
+[Next pagetrace](https://mr-boxington.jdx.dev/cli/cache/trace)
+
+MIT License·Copyright © 2026· [jjdx.dev](https://jdx.dev)

package/skills/working-with-mbx/references/cli/cache.md

@@ -0,0 +1,35 @@
+mbx cache
+
+`mbx cache` [​](#mbx-cache)
+
+- **Usage:** `mbx cache <SUBCOMMAND>`
+
+Inspect the local store.
+
+## Flags [​](#flags)
+
+- **`-h --help`** — Print help
+
+## Subcommands [​](#subcommands)
+
+- [`mbx cache dir [--json]`](https://mr-boxington.jdx.dev/cli/cache/dir)
+- [`mbx cache export [--group <GROUP>] [--format <FORMAT>] <ARCHIVE>`](https://mr-boxington.jdx.dev/cli/cache/export)
+- [`mbx cache import <ARCHIVE>`](https://mr-boxington.jdx.dev/cli/cache/import)
+- [`mbx cache largest [--limit <LIMIT>]`](https://mr-boxington.jdx.dev/cli/cache/largest)
+- [`mbx cache projects`](https://mr-boxington.jdx.dev/cli/cache/projects)
+- [`mbx cache remove [--interactive] [WORKSPACE]`](https://mr-boxington.jdx.dev/cli/cache/remove)
+- [`mbx cache stats [--json]`](https://mr-boxington.jdx.dev/cli/cache/stats)
+- [`mbx cache trace <SESSION>`](https://mr-boxington.jdx.dev/cli/cache/trace)
+- [`mbx cache verify`](https://mr-boxington.jdx.dev/cli/cache/verify)
+
+[Edit this page on GitHub](https://github.com/jdx/mr-boxington/edit/main/crates/mbx/src/cli/cache.rs)
+
+Last updated:
+
+Pager
+
+[Previous pageexec](https://mr-boxington.jdx.dev/cli/exec)
+
+[Next pagedir](https://mr-boxington.jdx.dev/cli/cache/dir)
+
+MIT License·Copyright © 2026· [jjdx.dev](https://jdx.dev)

package/skills/working-with-mbx/references/cli/clean.md

@@ -0,0 +1,27 @@
+mbx clean
+
+`mbx clean` [​](#mbx-clean)
+
+- **Usage:** `mbx clean [WORKSPACE]`
+
+Remove this workspace's managed target, link, and learned incremental state.
+
+## Arguments [​](#arguments)
+
+- **`[WORKSPACE]`** — Workspace root whose managed target and learned incremental state are removed. Defaults to the current workspace.
+
+## Flags [​](#flags)
+
+- **`-h --help`** — Print help
+
+[Edit this page on GitHub](https://github.com/jdx/mr-boxington/edit/main/crates/mbx/src/cli/clean.rs)
+
+Last updated:
+
+Pager
+
+[Previous pageexplain](https://mr-boxington.jdx.dev/cli/explain)
+
+[Next pagegc](https://mr-boxington.jdx.dev/cli/gc)
+
+MIT License·Copyright © 2026· [jjdx.dev](https://jdx.dev)