dxos

@dxos source repo

37 skills
0 followers
14 hours ago last updated

▌
Migrate Oxfmt · dxos
Guide for migrating a project from Prettier or Biome to Oxfmt. Use when asked to migrate, convert, or switch a JavaScript/TypeScript project's formatter from Prettier or Biome to Oxfmt.

0
installs
▌
Dxos Echo · dxos
Guide for ECHO (DXOS object graph / local-first DB). Use when adding or changing queries, filters, schema types, Ref/DXN handling, Database service layers, EchoClient/space DB access, or React ECHO hooks.

0
installs
▌
Land · dxos
Land an existing PR — finds it, fixes CI failures iteratively, keeps the branch up to date with main, subscribes to PR events for continuous autofixing, and adds to merge queue. Use when the user says "/land <PR number or URL>" or asks to land/ship an existing PR. Accepts optional extra instructions after the PR reference.

0
installs
▌
Moon · dxos bundle
This skill should be used when the user asks to "configure moon", "set up moonrepo", "create moon tasks", "run moon commands", "configure moon workspace", "add moon project", "moon ci setup", "moon docker", "moon query", "migrate to moon v2", or mentions moon.yml, .moon/workspace.yml, .moon/toolchains.yml, moon run, moon ci, or moonrepo in general.

0
installs
▌
Proto · dxos bundle
This skill should be used when the user asks to "install proto", "configure proto", "manage tool versions", "pin versions", "set up .prototools", "install node version", "install rust version", "install python version", "proto plugins", or mentions proto commands, .prototools file, or multi-language version management.

0
installs
▌
Effect · dxos bundle
Use when writing or changing Effect code, composing test layer stacks, working with Schema or SchemaAST, or reading pre-migration code.

0
installs
▌
Dxos Skills · dxos
Guide for creating and integrating Skills in DXOS. Use when adding skills to plugins, wiring operations as tools, structuring skill definitions, or testing with AssistantTestLayer.

0
installs
▌
Logging · dxos
DXOS logging with @dxos/log (log, levels, dbg), LOG_FILTER for test stdout, and querying Composer NDJSON logs via scripts/query-logs.mjs. Use when adding or reviewing logs, debugging from app.log or tests, or explaining log levels and vite-plugin-log output.

0
installs
▌
Tracing · dxos
Architecture and API reference for @dxos/tracing. Use when working with TracingBackend, TRACE_PROCESSOR, @trace.resource(), @trace.span(), @trace.info(), metrics counters, diagnostics, ContextRpcCodec, tracing-types.ts, trace-processor.ts, or api.ts.

0
installs
▌
Depot CI · dxos
Read CI logs, test results and failure diagnoses for the `Check` workflow, and retry its failed jobs, using the `depot` CLI against `DEPOT_TOKEN`. Use whenever a `Check / …` check run is red and you need the actual failure — the GitHub API returns empty output for these checks and `depot.dev` links redirect to SSO, so `mcp__github__get_check_run` and `get_job_logs` cannot see them. Also use to retry a flaky shard rather than asking a maintainer to press the button.

0
installs
▌
Debugging · dxos
Use when instrumenting code with runtime logs to test a hypothesis — @dxos/log debug lines captured to app.log (browser), test.log (node tests), or test-browser.log (browser tests/storybook), and querying them with query-logs.mjs. Reference for the log-exfiltration pipeline and instrumentation mechanics, not a debugging workflow.

0
installs
▌
Submit Pr · dxos
Create and submit a pull request from the current branch — sync with main, format/lint/test, commit all changes, push, monitor the Check workflow, and surface the Composer PR deploy URL. Use when the user asks to open, submit, or raise a PR, including stacking a PR on another open PR (`gh stack`). To land an existing PR, use the `land` skill instead.

0
installs
▌
Dxos Code Style · dxos
DXOS TypeScript authoring conventions. Use when writing or refactoring code — namespace-export packages, internal module imports, class member ordering, options-bag types, function overloads, the no-cast rule, the no-suppressing-unhandled-errors rule, the comment rule (say why, once), and test structure.

0
installs
▌
Dxos Operations · dxos
Guide for defining and implementing Operations in DXOS. Use when creating operation definitions, writing handlers, structuring operation modules, using OperationHandlerSet, or migrating from the old FunctionDefinition API.

0
installs
▌
Reactivity · dxos
House rules for reactive UI — the three state stores (React state, atoms, ECHO objects), the ECHO-to-atom bridge, and the anti-pattern catalog. Use when adding or placing component state, reading ECHO objects or refs in a component, rendering a list of refs, deriving a value from several reactive sources, when UI shows stale data or doesn't update until you navigate away and back, or when reviewing a diff that touches plugin containers or components.

0
installs
▌
Subduction Policy · dxos bundle
Reference for `SubductionPolicy` (the four hooks `authorizeConnect`, `authorizeFetch`, `authorizePut`, `filterAuthorizedFetch` passed via `Subduction.hydrate(..., policy)` or `new Repo({ subductionPolicy })`). Use when designing client-side access control over Subduction-replicated data, choosing which hook to deny in, or debugging why a doc did or did not replicate.

0
installs
▌
Composer QA · dxos
Run the executable QA of a `.mdl` spec — a `test QA-n`, a `suite`, or every suite carrying a tag — against a Composer dev server you start, driving each step as one operation call through the agent debug port, judging every step by the UI snapshot, and writing a per-run report. Use when asked to QA Composer, to run a plugin's `## QA` section, to verify a change end to end against the real app rather than a test runner, or when `/dxos:qa` is invoked. For ad-hoc probing of a live page use `composer-debug`; to record a walkthrough as video use `recording-demos`.

0
installs
▌
Composer UI · dxos
Use when building or styling plugin UI with Composer's design system — the `@dxos/react-ui*` packages. Covers theme tokens, primitives (Panel/Card/List/Input/Button/Icon), the standard container layout (Panel + ScrollArea), lists/pickers/stacks, schema-driven forms, toolbar/menu wiring, reactivity (useObject), attention/density, translations, storybook setup, and before/after screenshots. The UI adjunct to the composer-plugins skill; consult it whenever you write a container/component, reach for a Tailwind color class, build a toolbar, render a form or list, add a story, or open a PR that changes what the app renders.

0
installs
▌
Debugging UI · dxos
Use when debugging any UI bug — wrong rendering, layout or scroll jumps, flicker/flash, styling, interaction, focus/attention, or reactivity failures — in Composer plugins, react-ui components, storybook stories, or the running app. Applies from the first symptom report, before proposing any fix.

0
installs
▌
Cloud Sandbox · dxos
Working inside the Claude Code cloud sandbox (Claude Code on the web, remote sessions, scheduled runs). Use when CLAUDE_CODE_REMOTE is set; when `moon`, `gh`, or `oxfmt` are "command not found"; when Chromium or Playwright fails with ERR_CONNECTION_RESET or a TLS error against an HTTPS host that curl reaches fine; when /dxos:project answers `Unknown command` or a plugin's skills are missing from the session; or when a build or dev server unexpectedly triggers a full pnpm install.

0
installs
▌
Agentic Review · dxos bundle
Run the rule-driven agentic code review — discover `rule` blocks in the repo's `.mdl` files, prepare per-rule review groups (full project by default; diff-only with `--pr-only`), spawn one focused Sonnet subagent per group, then finalize the merged diagnostics into REVIEW.md + RESOLUTION.md. Use when asked to run the agentic review, list unresolved review issues, review a branch/PR against the repo's `.mdl` rules, or check a diff for known anti-patterns. For the built-in bug/quality passes use `/code-review` instead.

0
installs
▌
Composer Debug · dxos
Drive a live Composer page from the agent side via the loopback debug port — evaluate expressions against the running client, list plugins and operations, invoke an operation. Use when debugging a booting-but-misbehaving app (hang, bad query, plugin fault, wrong UI state) and you would otherwise ask the user to paste console output. The user opens the port; the agent never opens a browser. For a profile that will not boot, or for storage-level forensics, use `composer-forensics` instead.

0
installs
▌
Autonomous Mode · dxos
Working under AUTONOMOUS MODE — a pinned task the session must drive to a written definition of done without asking the user anything. Use when an `AUTONOMOUS MODE` block appears in the turn's context, when `/autonomous` is invoked, when you are about to ask a clarifying question about scope or PR size and cannot, when a blocker looks like a reason to stop, or before ending a run (the adversarial review and the stop command).

0
installs
▌
Recording Demos · dxos bundle
Record a demo of the running app that the agent drives itself — a `.mdl` QA test or an ad-hoc walkthrough — as a captioned `.webm` (or a screenshot), trimmed of dead air and ready to attach. Use when asked to demo a feature, show a flow working in the real app, produce a video or screenshots of the UI, or execute a flow whose steps have no operation behind them. For a pass/fail report rather than something to watch, use `composer-qa`; for a repeatable regression test, write a Playwright spec instead.

0
installs
▌
Test Perf Leaks · dxos
CPU-profile or leak-detect an existing vitest suite via env-gated instrumentation — DX_PROFILE_TESTS emits a V8 .cpuprofile, DX_DEBUG_LEAKS writes before/after heap snapshots plus a per-test heapUsed slope, with zero edits to the test file. Use when a suite is slow, memory grows across a run, or you need to find a hotspot/leak in node tests (echo/halo/mesh/sdk/composer/compute, incl. assistant + agentService).

0
installs
▌
Agent Eval Tests · dxos
Use when writing, editing, or reviewing evalite-scored agent evals in packages/core/compute/assistant-evals/src/evals. Use when creating new eval files, adding deterministic assertions or an LLM-judge scorer, or fixing a failing/mis-scoring eval.

0
installs
▌
Composer Plugins · dxos bundle
Use when working on files in packages/plugins/, adding new plugins, refactoring plugin components/containers, writing storybooks for plugins, or wiring capabilities like react-surface or operation-resolver. For the UI/design-system details of plugin components (layout, theming, forms, toolbars, lists, storybook), pair this with the composer-ui skill.

0
installs
▌
Trunk Quarantine · dxos
Use Trunk's CI Autopilot MCP server to investigate a failing CI run, find/diagnose a flaky test, and quarantine it. Use when a CI run is red and might be flaky, or when asked to quarantine/investigate a specific test.

0
installs
▌
User Submissions · dxos
Triage a user submission from the Composer feedback form — a Linear issue labelled "Composer Feedback Form" carrying an R2 debug-log path. Use when working a DX-#### issue created from a user report, when an issue body names a `composer-feedback-logs-*` NDJSON bundle, or when asked to find the root cause of a reported bug from its attached logs.

0
installs
▌
Browser E2e Tests · dxos
Authoring browser end-to-end tests for the Composer app with Playwright. Use when writing, editing, or reviewing *.spec.ts under packages/apps/composer-app/src/playwright, adding page-object helpers, or deciding how to target elements (always data-testid, never labels/roles).

0
installs
▌
Hosting Artifacts · dxos bundle
Publish a demo video, screenshot, contact sheet, or log bundle to the shared `agent-artifacts` R2 bucket and link it from a PR body, issue, or Linear ticket. Use when an artifact has to leave the machine so a reviewer on GitHub can see it — a `.webm` too large for git, a still you would otherwise commit-and-delete, a bundle to hand to a teammate — and use it INSTEAD of committing a binary to make it visible in a PR. Works in the cloud sandbox: it needs only `R2_ACCESS_KEY_ID` / `R2_SECRET_ACCESS_KEY`, no wrangler and no dependencies. For producing the recording in the first place, see `recording-demos`.

0
installs
▌
Composer Forensics · dxos bundle
Forensically inspect and repair Composer browser profiles — offline (Chrome OPFS / SQLite extract) or live via /recovery.html debug port. Use for data loss, corruption, slow space open, Automerge bloat, or when the app won't boot. Follow DOCTOR.md for live sessions: user opens debug port, agent explores, keeps a report, confirms before any data changes.

0
installs
▌
Context Propagation · dxos bundle
Rules for passing ctx: Context as the first parameter to internal methods so that @trace.span() produces connected trace hierarchies. Use when adding context propagation, reviewing ctx usage, fixing broken traces, or when code uses @trace.span(), Context, or this._ctx.

0
installs
▌
Composite Components · dxos
Use when authoring or refactoring composite React components in `@dxos/react-ui` and sibling UI packages — namespaced primitives like `Foo.Root` / `Foo.Trigger` / `Foo.Content` built around `forwardRef`, the `ark.*` factory's `asChild`, and a `tx()` theme function.

0
installs
▌
Regenerate Model Fixture · dxos
Regenerate cached LLM responses for tests that replay model fixtures. Use when tests fail with "No memoized conversation found for the given prompt", when fixing or adding model-fixture tests, or when the user asks to regenerate or update the LLM conversation cache.

0
installs
▌
Testing Assistant Conversations · dxos
Test assistant conversations, agents, and skills using AssistantTestLayer, Effect/vitest, ECHO types, and memoized LLM fixtures. Use when writing or fixing assistant-toolkit tests, skill.operation tests, AiSession flows, or when CI fails on missing memoized conversations.

0
installs
▌
Task Planning · dxos bundle
Use when work spans multiple steps, phases, or sessions, when resuming a task started earlier, when the user asks for a plan/roadmap/progress tracking, or when they use the `/dxos:project` command (any verb — list, tasks, new, end, track, hydrate, resume). Covers the project registry, maintaining a durable TASKS.md + DESIGN.md per work-stream, and checkpointing/reloading project state across sessions and PRs.

0
installs

37 published skills