Execute qualquer Skill no Manus
com um clique

Execute qualquer Skill no Manus com um clique

repo-map

Estrelas98

Forks20

Atualizado5 de julho de 2026 às 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

Instalação

Instalar com Codex ou Claude Copie este prompt, cole no Codex, Claude ou outro assistente e deixe que ele revise a página da skill e instale para você.

Executar no Manus

Fonte

LunCoSim

LunCoSim/lunco-sim

Abrir repositório GitHub Ver repositórios do creator

Download

Executar no Manus

Ocupações relacionadasSOC

Baseado na classificação ocupacional SOC

Desenvolvedores de softwareInformática e Matemática·SOC 15-1252

SKILL.md

readonly

Mais deste repositório

mesmo repositório

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).