Run any Skill in Manus with one click

repo-map

Stars98

Forks20

UpdatedJuly 5, 2026 at 07:28

Orientation for the LunCoSim workspace — how the repo is laid out, which binaries exist, and WHEN to run each. USE THIS SKILL whenever you need to get your bearings: "which app do I run for X?", "how do I launch the sim / workbench / server?", "where does <feature> live?", "what crate handles Y?", "is there a headless mode?", "how do I run it without a window?", or any moment you're about to grep the whole tree to find where something is. Also trigger when you catch yourself about to run a bare `cargo run` (ambiguous — needs a target), confusing `lunica` with the main simulator, reaching for `pkill`, or guessing an API port. It's project-specific: there is NO `apps/` dir (binaries live inside crates), `lunica` is the *Modelica* workbench (not the flagship sim), `sandbox` / `luncosim` / `sandbox-server` are three different entry points into overlapping stacks, and the canonical API port is 4101. Authoritative indexes: docs/apps/README.md (every binary) and docs/crates-index.md (every library crate, grouped by

Installation

Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.

Run Skill in Manus

Source

LunCoSim

LunCoSim/lunco-sim

View GitHub Repository View Creator Repositories

Download

Run Skill in Manus

Related occupationsSOC

Based on SOC occupation classification

Software DevelopersComputer and Mathematical Occupations·SOC 15-1252

SKILL.md

readonly

More from this repository

same repository

authoring-vessel-controllers

LunCoSim/lunco-sim

How to model a vehicle's behaviour in LunCoSim — making a spacecraft, lander, rover, or drone move, fly, drive, or land under its own control, and letting a person take over. USE THIS SKILL whenever the user asks, in plain words, things like: "how do I model this lander / rover?", "how do I make it fly (or drive, land, hover) itself?", "how do I add an autopilot / a control system / guidance / a GNC?", "how do I make it follow waypoints?", "how do I let the user take control?" or "why doesn't my controller / thruster respond?". Any request to model how a vehicle behaves under power, or to add/fix its self-driving or manual control, belongs here — the user will NOT know the internal terms. (For the agent mid-code, it also covers: a `.mo` control model, `lunco:simWires`, the `piloted` port, `external_throttle`, `possess`/`follow`, or a rumoca input that `set()` writes but that has no effect — and catch-yourself moments like putting control math in rhai, a bespoke mode flag, a self-wire, or reading the god-view

2026-07-1098

build-usd-scene

LunCoSim/lunco-sim

How to author and edit the 3D world in LunCoSim — load scenes, spawn objects, place/move/rotate them, and tune their properties, over the API. USE THIS SKILL whenever the user asks, in plain words, things like: "put a lander near that crater", "spawn a few rovers here", "load the Moon scene", "add some rocks / obstacles", "move / rotate / scale this", "set its colour / mass / material", "build a scene with X and Y", or "clear the scene and start over". Any request to assemble or edit what's IN the 3D world belongs here — the user won't say "USD" or "prim". (For the agent mid-code: `LoadScene` / `SpawnEntity` / `MoveEntity` / `SetObjectProperty`, an `entry_id` from the spawn catalog, a `.usda` file, coordinate placement, or "why did the gizmo grab the wrong thing?".) Project-specific and non-obvious: USD is the SOURCE OF TRUTH (projected to ECS — you edit the world by authoring it), the engine frame is fixed (Y-up, right-handed, −Z-forward, metres), `LoadScene` paths are relative to the assets root, spawnable

2026-07-0798

author-tutorial

LunCoSim/lunco-sim

How to author an interactive tutorial / guided lesson / onboarding flow in LunCoSim. USE THIS SKILL whenever the user asks, in plain words, things like: "make a tutorial that teaches X", "add a guided lesson for the rover / the Modelica workbench", "walk a new user through Y step by step", "add an onboarding flow / first-run experience", "spotlight this button and explain it", or "add an objectives checklist that advances as the user does things". Any request to teach a user how to do something in-app, guided, belongs here. (For the agent mid-code: a `mission(me)` / `objective(...)`, `coach_step`, `hint` / `spotlight`, `requires_event:"cmd:*"`, `register_tutorial`, `StartTutorial`, `TutorialProgress`, or a file under `assets/tutorials/`.) Project-specific and non-obvious: a tutorial IS a single `.rhai` scenario (no scene-vs-script split), objectives advance on REAL user actions (a `cmd:*` bus event or a `done` predicate — never a timer), the HUD auto-publishes from `mission(me)`, and adding one is two steps (

2026-07-0598

author-scenario

LunCoSim/lunco-sim

How to write a scenario in LunCoSim — a rhai program attached to an entity that senses the world and drives it every tick. USE THIS SKILL whenever the user asks, in plain words, things like: "make the rover patrol these waypoints", "drive it to X then Y", "have it react when it reaches / enters / sees something", "coordinate these two vehicles", "run this mission / sequence / timeline", "make it do X after N seconds", "spawn some rovers and have them survey the area", or "why isn't my script doing anything / holding its state?". Any request to orchestrate behaviour, missions, waypoints, reactions, or multi-entity coordination belongs here — the user will NOT say "scenario" or "rhai". (For the agent mid-code, it also covers: an `on_tick` / `on_event` / `on_start` hook, `RunScenario`, `nav_to` / `run_plan` / a sequencer step, `emit` / a `TelemetryEvent`, `this`-state that resets or reads empty, a `find`/`cmd`/`query` verb, or `lunco:script` on a prim.) These rules are project-specific: rhai `fn`s are pure (they

2026-07-0598

compose-multidomain-twin

LunCoSim/lunco-sim

How to assemble a complete multi-domain mission in LunCoSim — a vehicle (or fleet) whose geometry, physics, subsystem dynamics (GNC / power / thermal), and behaviour all cosimulate together, packaged as a Twin. USE THIS SKILL whenever the user asks, in plain words, things like: "build the lander+rover mission", "wire this Modelica model to that USD body", "make a spacecraft with a battery and thermal model that interact", "set up a full scenario with vehicles + behaviour", "package this as a Twin", or "connect the GNC output to the thruster". Any request to compose more than one domain (USD + Modelica + cosim + rhai) into one running system belongs here. (For the agent mid-code: `twin.toml`, `lunco:modelicaModel`, `lunco:simWires`, a sub-prim-per-domain layout, `SimConnection` / port wiring, a `lunco:scenario` orchestration prim, or `SetPorts`/`SetModelInput` fighting each other.) Project-specific and non-obvious: a vehicle is a USD FILE (not a Rust struct), each physical domain is its OWN sub-prim with its o

2026-07-0598

inspect-simulation

LunCoSim/lunco-sim

How to OBSERVE a running LunCoSim without asking the user to look — read live state, telemetry ports, cosim/Modelica variables, and viewport screenshots over the API. USE THIS SKILL whenever you need to answer "is it actually moving / working?", "what's the battery / altitude / speed / temperature?", "read the <X> port", "watch these signals over time", "what are the current variable values?", "did the cosim chain (Modelica → physics) work?", "what's in the scene right now?", or "show me what it looks like". Also trigger when you catch yourself about to `tail -f` the log and poll for a value, sleep-loop waiting for something to change, or ask the user "can you check?". The move is always: list entities → read the ports/variables → (watch if you need a series) → screenshot to confirm. It's the READ-side complement to test-via-api (which drives + verifies) and build-usd-scene (which authors). Project-specific: entity `api_id`s come from `list_entities`, ports are name-addressed and huge unless filtered, telemet

2026-07-0598

name

repo-map

description

Repo map — layout, binaries, and when to use them

A Rust/Bevy Cargo workspace: 60+ library crates + a handful of app binaries, plus assets, docs, specs, and skills. This skill is the fast orientation; the two authoritative, always-current indexes are:

docs/apps/README.md — every runnable binary, full CLI flags, launch lines.
docs/crates-index.md — every library crate, grouped by domain, with responsibilities.

When those disagree with anything here, they win.

Top-level layout

Dir	What's in it
`crates/`	All Rust code — libraries and the app binaries (there is no `apps/` dir).
`assets/`	Runtime data: `scenes/` (USD), `models/` (Modelica `.mo`), `scripting/` (rhai prelude/examples/tools), `tutorials/`, `vessels/`, `shaders/`, `props/`, `missions/`, `config/`.
`docs/`	`architecture/` (numbered design docs), `apps/`, `tutorials/`, `crates-index.md`, `scripting-guide.md`, `principles.md`.
`specs/`	Numbered feature specs (`NNN-name/spec.md`) — the intent behind subsystems.
`skills/`	Agent skills (this one, `author-scenario`, `authoring-vessel-controllers`, `run-modelica`, `test-via-api`, `lunco-ui`, `lunco-theme`).
`mcp/`	Node MCP server wrapping the HTTP API as tools for AI agents.
`scripts/`	`build.sh`, `check_.sh` (lints/wasm), `api/` (HTTP helpers), `deploy/`, `perf/`.

Binaries — which one do I run?

Pick by task, not by habit:

I want to…	Run	Why
Full lunar mission (celestial + ephemeris + solar-scale + full vehicle stack)	`luncosim`	The flagship windowed simulator.
Ground physics / rovers / USD scenes / edit tools	`sandbox`	Physics test bed — windowed, or headless with `--no-ui`.
Multiplayer host / CI automation (no GUI ever linked)	`sandbox-server`	Same sim as `sandbox` via `run_headless()`, GUI stack never compiled in.
Author / compile / simulate Modelica models, browse MSL	`lunica`	The Modelica workbench (⚠️ NOT the main sim).
Download / verify / process external assets	`lunco-assets`	`-- download\|list\|process`.

Launch (workspace default-members make a bare cargo run ambiguous — always pass a target):

cargo run -p luncosim
cargo run --release -p lunco-sandbox --bin sandbox
cargo run -p lunco-sandbox-server
cargo run --bin lunica

Utility / dev bins (all in lunco-modelica unless noted): modelica_run (headless Modelica CLI → CSV), msl_indexer (rebuild the MSL search index — re-run after an MSL change), lunica_worker (wasm compile worker, bundled not run), build_msl_assets (lunco-assets), net_smoke (lunco-networking, transport smoke test), joint_minimal (lunco-sandbox, single-joint physics repro). Details: docs/apps/README.md.

Talking to a running app (agents)

The windowed apps that embed the API bridge (sandbox, lunica, and anything with LunCoApiPlugin) honor:

--api [PORT] — enable the HTTP automation API. Default port 4101 (lunco_core::session::DEFAULT_API_PORT); the MCP config points here via LUNCO_API_PORT. Without --api, no network surface.
--no-ui — headless (skip winit/egui, run the shared sim loop).
--scene <path> — (sandbox) load a USD scene on boot; path is relative to the assets/ root (do not prefix with assets/).

Drive it: POST /api/commands with {"command":"<Name>","params":{...}}; discover the live command set with DiscoverSchema (it's introspected, never hard-coded). Full recipe in the run-modelica / test-via-api skills.

Crate domains at a glance

Crates are grouped into 8 domains in docs/crates-index.md. Use this to jump to the right one; read the index for the full responsibility.

Domain	Crates own	Key crates
Core foundation	primitives, docs/journal, time, storage, hashing, cache, settings, theme	`lunco-core`, `lunco-doc`, `lunco-twin-journal`, `lunco-time`, `lunco-storage`, `lunco-hash`
Simulation engine	celestial, environment, terrain, experiments, cosim	`lunco-celestial`, `lunco-cosim`, `lunco-experiments`, `lunco-terrain-*`
Vessel control & hardware	mobility, robotics, avatar, FSW/OBC/hardware, controller, autopilot	`lunco-mobility`, `lunco-fsw`, `lunco-autopilot`, `lunco-controller`
USD integration	OpenUSD↔Bevy: visuals, physics, sim schemas, materials	`lunco-usd`, `lunco-usd-bevy`, `lunco-usd-avian`, `lunco-materials`
Networking & API	replication, HTTP API, telemetry, attributes	`lunco-networking`, `lunco-api`, `lunco-telemetry`
Workbench & UI	IDE shell, widgets, viz, 2D canvas, edit tools, render, web boot	`lunco-workbench`, `lunco-ui`, `lunco-viz`, `lunco-canvas`, `lunco-sandbox-edit`
Scripting & modeling	Modelica, rhai bridge, tools, hooks, behavior trees, tutorials	`lunco-modelica`, `lunco-scripting`, `lunco-tools`, `lunco-hooks`, `lunco-behavior`, `lunco-tutorial`
Applications	the entry-point binaries above	`luncosim`, `lunco-sandbox`, `lunco-sandbox-server`, `lunco-modelica`

Where does X live? (routing)

Looking for…	Go to
A subsystem's design/intent	`docs/architecture/NN-.md` (numbered) or `specs/NNN-/spec.md`
Which crate owns a responsibility	`docs/crates-index.md`
How to run/launch anything	`docs/apps/README.md`
Writing rover/vehicle behavior (rhai)	skill `author-scenario` + `docs/scripting-guide.md`
A self-driving vessel / GNC / autopilot	skill `authoring-vessel-controllers`
Running Modelica / experiments over the API	skill `run-modelica`
Verifying a change end-to-end via the API	skill `test-via-api`
Runtime data (scenes, models, scripts)	`assets/` (see layout table)
Build/lint/deploy helpers	`scripts/`

Gotchas / naming traps

No apps/ directory — every binary lives in a crates/<crate>/src/{main.rs,bin/}.
lunica ≠ the main sim. It's the Modelica workbench (crate lunco-modelica). The flagship is luncosim; the physics bed is sandbox.
cargo run alone is ambiguous — default-members are luncosim, lunco-sandbox, lunco-modelica. Always -p <crate> and/or --bin <name>.
lunco-sandbox produces the sandbox binary (crate name ≠ binary name); sandbox-server is a separate crate (lunco-sandbox-server) that exists only to default to headless.
API port is 4101 everywhere — not 3000 (a stale MCP default) and not 3001.
Don't pkill a running app to restart — use the API Exit command (see test-via-api).
Composition roots: lunco-sandbox = SandboxCorePlugin (+ optional UI/headless plugin), shared by both sandbox and sandbox-server. There is no lunco-usd-composer crate — composition lives in lunco-usd-bevy (flatten_stage).