· 1 observation
Technical updates · 1
Package or technical metadata updated
View technical comparison →Charles Chen-Zhou Benjamin v1.4.12
Agent workflows for MOOS-IvP
From the developer
Not specified in the available declarations: limitations, pricing & account requirements.
Use MOOS-IvP skills to build or repair this MOOS app
Developer declarations; not independently tested. Listing last checked Nov 22, 2026. Package observed Nov 21, 2026.
From the marketplace listing
Build and validate MOOS-IvP apps, IvP behaviors, missions, test harnesses, and TIFF background maps. Consult framework documentation, analyze .alog mission logs, and more.
Language: English · Automatically detected from descriptions.
· 1 observation
Package or technical metadata updated
View technical comparison →· 2 observations
Package or technical metadata updated
View technical comparison →· 2 observations
Package or technical metadata updated
View technical comparison →Package or technical metadata updated
View technical comparison →Finding similar plugins… Results will appear here automatically.
Browse plugins →--- name: ivp-behavior-builder description: "Build or modify user-owned IvP helm behaviors outside the core MOOS-IvP source tree: BHV_* C++ classes, IvPBehavior lifecycle methods, shared behavior libraries, IVP_BEHAVIOR_DIRS wiring, and behavior-specific configuration parameters." --- # IvP Behavior Builder ## Overview Use this skill for custom IvP helm behavior development against the local MOOS-IvP checkout. Treat MOOS-IvP as the dependency and example source unless the user explicitly asks to patch core MOOS-IvP. ## MOOS-IvP Checkout Resolution When this skill needs a local MOOS-IvP checkout, resolve it in this order: 1. Path explicitly provided by the user. 2. `MOOS_IVP_ROOT` from the shell environment. 3. Active task workspace if it contains `ivp/src`. 4. Parent or sibling directories near the active task workspace. 5. Common home locations such as `~/moos-ivp`, `~/src/moos-ivp`, `~/repos/moos-ivp`, and `~/projects/moos-ivp`. 6. A bounded shallow home search for a directory named `moos-ivp`, excluding noisy folders. Validate a candidate by confirming `ivp/src` exists and `scripts/GenBehavior` is executable. If no valid checkout is found and the task requires behavior source generation, build wiring, examples, headers, or libraries, stop and ask the user for the checkout path before editing code, generating build files, or using placeholder paths. ## Core Rules - Default new behaviors to third-party dynamic shared libraries in the user project. - Do not add new behavior source to core `ivp/src/lib_behaviors*` unless the user explicitly asks to modify core MOOS-IvP. - Use `$MOOS_IVP_ROOT/scripts/GenBehavior` when there is no close existing behavior to copy. - Run `GenBehavior` only in a clean behavior source location; it appends to `BHV_<Name>.h/.cpp` if those files already exist. - Name behavior files and classes `BHV_<Name>.h/.cpp` and `BHV_<Name>`. - Export `createBehavior` for dynamic loading. - Build dynamic behaviors as shared libraries named so the output is `libBHV_<Name>.dylib` on macOS or `libBHV_<Name>.so` on Linux. - Ensure `pHelmIvP` can find the library. Default to the user's shell convention: add the project `lib` directory to `IVP_BEHAVIOR_DIRS`, usually in `.bashrc` or the user's equivalent shell startup file when they ask for persistent setup. Use mission-local `ivp_behavior_dir = <project>/lib` only when the user explicitly wants a self-contained mission, non-interactive execution cannot assume shell setup, or an existing mission already uses that convention. - Use `.bhv` blocks for mission configuration; do not bake mission-specific parameters into the constructor. - Call `IvPBehavior::setParam(param, val)` first when the behavior should accept standard behavior parameters. - Apply `m_priority_wt` to returned IvP functions. - Use `postWMessage()` or `postEMessage()` for behavior warnings/errors instead of silent failure. - Preserve the generator-style metadata comment box at the top of source files and update `NAME`, `ORGN`, `FILE`, and `DATE` to match the user project. - Use short comments before non-obvious behavior logic; do not add comments that merely restate simple code. - Reuse existing MOOS-IvP behavior, IvP build, geometry, contact, and utility libraries before writing custom parsers, objective-function machinery, or geometry math. - During live validation, keep `pAntler` in the foreground unless the task explicitly requires persistent or concurrent execution. Use the shortest timeout that proves the claim, capped at 30 seconds unless a stated task-specific reason requires longer. After it stops, verify scoped processes and selected ports are clear. - Do not commit or present build directories/binaries as source changes unless the user's project already tracks generated artifacts. ## Workflow 1. Choose the behavior shape. - Default to the simplest shape that matches the requested effect. - Posting-only behavior: use when the behavior should publish state/flags but not i
Preview of the first 4,000 characters. Read full instructions →
Referenced files: 6 — file references are metadata, not package contents.
--- name: moos-alog-analysis description: "Analyze existing MOOS .alog files for post-run, log-backed questions such as mission reconstruction, variable history, helm-state context, or timestamped incident evidence." --- # MOOS ALog Analysis ## Overview Use this skill for two jobs: - reconstruct what happened in a mission - investigate suspicious event(s) in a mission ## Shell Assumption Run `aloggrep`, `aloghelm`, and `alogscan` directly in the current agent shell. Do not wrap `alog*` commands in an extra shell bootstrap step. ## Source of Truth Analyze only the original `.alog` files. Never read or rely on derived artifacts such as: - `*_alvtmp/` - `*.klog` - any other files generated by `alogview` or similar viewers These files are not source evidence for mission analysis. If they exist, ignore them and continue using the `.alog` files only. ## Workflow 1. Find the relevant `.alog` files. 2. If you already know the variable, signal, or specific variable set you care about, go straight to targeted `aloggrep` queries. 3. If you need mission phases, behavior transitions, or helm context, use `aloghelm`. 4. If you need variable discovery, use `scripts/alogvars.sh <alog_path>` first. Add one or more prefixes when you already know the variable family. 5. Read raw log lines only when you need the exact posting format, need to resolve source ambiguity, or need to cite original evidence lines. 6. If the question is geometric or numeric, extract the relevant variables and analyze them directly. ## Tool Policy Autonomous tools: - `aloggrep` - `aloghelm` - `alogscan` - `scripts/alogvars.sh` Use them with this bias: - `aloggrep` is the default tool when you already know the variable names or have already narrowed the problem to a specific variable set. - `aloghelm` is the default mission-context tool. - `scripts/alogvars.sh` is the default discovery tool when the variable names are still unknown. - Raw `alogscan --sort=vars --nocolors` is acceptable for a full variable inventory when you actually need counts, sources, or full scan metadata, but prefer `scripts/alogvars.sh` for compact unknown-variable discovery. Read `references/alog-tool-guide.md` when you need concise examples for `aloggrep`, `aloghelm`, or `alogvars.sh`. ## Mission Overview For mission reconstruction: - if the key variables are already known, use `aloggrep` immediately - if the question names a specific variable set, stay targeted and use one or more `aloggrep` queries for that set before doing broader discovery - use `aloghelm` first for modes and behaviors when mission phases matter - use `scripts/alogvars.sh` only when the variable set is still unclear - inspect raw log lines only when the exact payload format or source matters ## Incident Forensics For one event or anomaly: - identify the relevant variables to the event - if the user already gave a variable set, start with that set and use `aloggrep` directly - if the variable names are still unknown, use `scripts/alogvars.sh` to discover them compactly - use `aloggrep` once the variables are known - use `aloghelm` if the incident may be explained by a mode or behavior change - use shell or Python for custom logic - use raw log lines only when you need exact evidence or payload structure - for source attribution, prefer `aloggrep <alog> <var> --format=time:var:src` when the installed build emits all requested fields. Some builds advertise that format but emit only the source field; in that case use a narrow raw `.alog` check for timestamped source evidence instead of broad log reads. If the question is about loops, turns, divergence, rendezvous, stops, or similar geometry, do not expect an `alog*` command to answer it directly. For these cases, still extract evidence only from the `.alog` file. ## Evidence Standard - Cite exact command(s) used. - Cite timestamped output lines for each conclusion. ## Reference Use `references/alog-tool-guide.md` only if more detail is needed.
Referenced files: 4 — file references are metadata, not package contents.
--- name: moos-app-builder description: "Build or modify user-owned MOOS apps outside the core MOOS-IvP source tree: C++ app generation, project build wiring, MOOS mail/config/iterate logic, app help/interface text, and app-specific ProcessConfig examples." --- # MOOS App Builder ## Overview Use this skill for user application development against the local MOOS-IvP checkout. Treat MOOS-IvP itself as the dependency and example source unless the user explicitly asks to patch core MOOS-IvP. ## MOOS-IvP Checkout Resolution When this skill needs a local MOOS-IvP checkout, resolve it in this order: 1. Path explicitly provided by the user. 2. `MOOS_IVP_ROOT` from the shell environment. 3. Active task workspace if it contains `ivp/src`. 4. Parent or sibling directories near the active task workspace. 5. Common home locations such as `~/moos-ivp`, `~/src/moos-ivp`, `~/repos/moos-ivp`, and `~/projects/moos-ivp`. 6. A bounded shallow home search for a directory named `moos-ivp`, excluding noisy folders. Validate a candidate by confirming `ivp/src` exists and `scripts/GenMOOSApp_AppCasting` is executable. If no valid checkout is found and the task requires app source generation, build wiring, examples, headers, or libraries, stop and ask the user for the checkout path before editing code, generating build files, or using placeholder paths. ## Core Rules - Use `GenMOOSApp_AppCasting` for new apps. - If the project has `src/CMakeLists.txt`, update it with `ADD_SUBDIRECTORY(<app-dir>)`. - If the project has no build skeleton, create the smallest project-level CMake needed for the new app and point it at the resolved `MOOS_IVP_ROOT`. - Keep MOOS communication boundaries clear: `OnNewMail()` ingests mail, validates messages, and updates state through `handleMail*` helpers; `Iterate()` owns most business logic, recurring work, and state-derived publications. - Keep config parsing in `OnStartUp()`, using `handleConfig*` helpers for nontrivial values and AppCasting warnings for bad or unhandled config. - Keep subscriptions centralized in `registerVariables()` and call `AppCastingMOOSApp::RegisterVariables()` in AppCasting apps. - Update `_Info.cpp` as part of the app implementation: synopsis, example config, subscriptions, publications, and options must describe the real app. - Preserve the generator-style metadata comment box at the top of source files and update `NAME`, `ORGN`, `FILE`, and `DATE` to match the user project. - Use short comments before non-obvious logic blocks; do not add comments that merely restate simple code. - Reuse existing MOOS-IvP libraries and helpers before writing new parsing, geometry, contact, logic, or AppCasting support code. - Use local style: MOOS variables are usually uppercase with underscores; mission config params are usually lowercase snake case; C++ members use `m_`; helpers commonly use `handleMail*`, `handleConfig*`, `post*`, `update*`. - Build and run `--help`, `--example`, and `--interface` as binary smoke checks before finishing when feasible. These prove the app starts and its self-documentation is wired; they do not prove mission runtime config. - During live validation, keep `pAntler` in the foreground unless the task explicitly requires persistent or concurrent execution. Use the shortest timeout that proves the claim, capped at 30 seconds unless a stated task-specific reason requires longer. After it stops, verify scoped processes and selected ports are clear. - Do not commit or present build directories/binaries as source changes unless the user's project already tracks generated artifacts. ## Workflow 1. Identify the app role and prefix. - `p`: process/control/monitoring app - `u`: utility or simulation-support app - `uFld`: shoreside field app - `i`: interface/driver app - If the user did not specify a prefix, use `p` for process/control/monitoring apps and `u` for utilities or simulation helpers. 2. Generate the starting point. - New app: run `$MOOS_IV
Preview of the first 4,000 characters. Read full instructions →
Referenced files: 6 — file references are metadata, not package contents.
--- name: moos-ivp-docs description: "Consult MIT MOOS-IvP PDFs and local ivp/src for documentation-backed answers about apps, behaviors, parameters, concepts, upstream semantics, or doc-vs-source differences." --- # MOOS-IVP Docs ## Overview Use this skill to ground MOOS-IvP answers in the live MIT manual PDFs and, when needed, the local `moos-ivp` source tree. Read `references/doc-selection.md` when you need the filename-family rules, alias map, repo discovery order, or source-inspection rules. ## When To Use Use this skill when the task is about: - MOOS-IvP app or utility behavior - IvP behavior semantics or parameters - MOOS-IvP terminology, architecture, or conceptual questions - `.moos` or `.bhv` settings whose upstream meaning should be confirmed in the docs - comparing upstream documentation against a local `moos-ivp` checkout ## When Not To Use Do not use this skill as the primary tool for: - `.alog` mission reconstruction or incident forensics - launching or tearing down missions - purely local code-editing tasks when no documentation question is involved If the task is mainly about `.alog` evidence, use `moos-alog-analysis` first. ## Authority Model Apply this authority order: 1. If the user explicitly asks for documentation, or if you are unsure about upstream MOOS-IvP behavior, use the MIT PDFs first. Do not answer from memory in this case. 2. If the user asks what the current checkout actually does, inspect local `ivp/src` first and use MIT PDFs only as upstream context. 3. If MIT docs and local source differ, say so explicitly and cite both. 4. Do not widen to broader web sources in v1. Treat the MIT PDFs as the upstream source of truth for documented semantics when asked or when uncertain. Treat local `ivp/src` as the source of truth for checkout-specific implementation behavior. ## MIT PDF Lookup Workflow 1. Open the live MIT index at `https://oceanai.mit.edu/ivpman/pdfs/` first. 2. Classify the question as one of: - app or utility - behavior - conceptual or architecture - tutorial or operator help 3. Build a shortlist of 1 to 3 candidate PDFs from the live filenames only. - For an exact app or utility name, prefer the matching `app_*` filename first if it exists, for example `uQueryDB` -> `app_uquerydb.pdf`. 4. Open the best candidate first. If opening the PDF from the index fails, construct the direct PDF URL from the filename shown in the index and open that URL directly. If both attempts fail, treat that document as unavailable and either try another candidate or fall back to local source inspection. 5. Use in-PDF search to verify the app name, behavior name, parameter, or topic appears in the document before relying on it. 6. Open a second or third candidate only if the first document is incomplete, too general, or ambiguous. 7. Answer with the selected PDF URL and line citations. If the PDF tool does not provide stable line numbers, use `pdftotext -layout <pdf> - | nl -ba` or an equivalent extraction artifact and label those as extracted-text line spans rather than canonical PDF anchors. Representative pattern: - `uQueryDB` question: inspect the live index, shortlist `app_uquerydb.pdf`, verify `uQueryDB` appears inside the PDF, and only then fall back to local `ivp/src/uQueryDB` if the PDF is unavailable or incomplete. Critical rule: - Do not hard-default a conceptual question to a specific `chap_*` PDF before inspecting the live index and verifying the topic inside the PDF. ## Local Repo Fallback Workflow Use local source inspection when: - the docs are unavailable - no clear PDF match exists - the PDF text is too weak to settle the question - the user asks what the current checkout actually does - the local checkout version is newer or more specific than the available MIT PDFs When local MOOS-IvP source is needed, resolve the checkout in this order: 1. Path explicitly provided by the user. 2. `MOOS_IVP_ROOT` from the shell environment. 3. Active task worksp
Preview of the first 4,000 characters. Read full instructions →
Referenced files: 3 — file references are metadata, not package contents.
--- name: moos-ivp-eval-mission-builder description: "Build or repair one self-evaluating MOOS-IvP mission by adding an evaluation layer to an ordinary mission: headless startup, pMissionEval grading, results.txt, uMayFinish/xlaunch completion, zlaunch automation, scoped teardown, and single-scenario validation." --- # MOOS-IvP Eval Mission Builder ## Overview Use this skill for one self-evaluating mission folder: a normal MOOS-IvP mission with an added single-run grading contract. The mission should still be readable and runnable by a person, but it must also run headlessly, decide pass/fail inside the mission, write `results.txt`, and finish through the shared `xlaunch.sh` / `uMayFinish` path. For ordinary mission layout, use `moos-ivp-mission-builder` first. For multi-case matrices, patch sweeps, parallel runs, or expected-vs-actual aggregation, use `moos-ivp-harness-builder`. For post-run `.alog` evidence, use `moos-alog-analysis`. ## Core Rules - Start from an ordinary mission that already launches cleanly. Prefer the `moos-ivp-mission-builder` baselines or an existing nearby mission family. - Add only the evaluation plumbing needed for one scenario: optional `pAutoPoke`, optional `uTimerScript`, `pMissionEval`, `results.txt`, and a thin `zlaunch.sh`. - Keep `launch.sh` human-facing. It may accept `--xlaunched`, `--nogui`, and port overrides, but it should not contain case loops or result aggregation. - Keep `zlaunch.sh` thin: parse automation arguments, truncate `results.txt`, call shared `xlaunch.sh`, validate that `results.txt` contains `grade=`, then apply project-local scoped cleanup. - Let `xlaunch.sh --max_time=<secs>` own `uMayFinish` and the timed wait/stop contract. Do not duplicate that lifecycle in mission-local wrappers. - Do not synthesize `grade=` or write the final result row from `zlaunch.sh`, `launch.sh`, or target-file parsing. `pMissionEval` must own the verdict and write `results.txt`; wrappers may only truncate, launch, wait, validate presence of `grade=`, and clean up. - For cleanup backstops, copy `assets/moos_scoped_teardown.sh` into the target project as `<project-root>/scripts/moos_scoped_teardown.sh` if it does not already exist. Reuse an existing project-root helper unless it is clearly stale or incompatible. - Prefer `pAutoPoke` to seed deploy and evaluation variables in moving missions. Unit-style evals may use `uTimerScript` or the app under test for readiness when there is no vehicle/deploy lifecycle. Do not put pass/fail logic in `pAutoPoke`. - Use `pMissionEval` as the primary verdict owner. Prefer mission-level booleans or simple scalar checks over harness-side parsing of raw MOOS traffic. - Prefer event-driven `pMissionEval` leads: evaluate when the mission-owned completion event occurs. Use `uMayFinish` through `xlaunch.sh --max_time` as the outer infrastructure ceiling. Use a time-driven evaluation-window lead only when non-completion is an expected mission outcome that should produce mission-owned `grade=fail`. - Multiple `lead_condition` lines in the same aspect are allowed, but they are ANDed: all must be true before pass/fail conditions are evaluated. A `lead_condition` after pass/fail conditions starts the next ordered aspect. A single `lead_condition` may use textual `or` when each operand is parenthesized, for example `(EVENT_A = true) or (EVENT_B = true)`. Do not use `||`; it is not a supported `LogicCondition` operator. - Treat `BHV_ERROR_SEEN=false` as a normal safety/integrity pass condition. Treat `BHV_WARNING` as advisory development evidence by default: inspect and investigate it with appcasts or `.alog` tools, but do not add a sticky `BHV_WARNING_SEEN` mailflag, result column, or pass condition unless the scenario is explicitly warning-intolerant and the warning signal is known to be stable rather than transient/retracted. - Keep `results.txt` scalar and parseable. The only hard schema requirement is
Preview of the first 4,000 characters. Read full instructions →
Referenced files: 20 — file references are metadata, not package contents.
--- name: moos-ivp-harness-builder description: "Build or repair multi-case MOOS-IvP test harnesses around self-evaluating stem missions: case matrices, per-case mission copies, result aggregation, serial and rolling parallel execution, port isolation, scoped teardown, and nspatch variants. Use moos-ivp-eval-mission-builder for stem missions." --- # MOOS-IvP Harness Builder ## Overview Use this skill for a harness that runs one or more self-evaluating stem missions across multiple named cases. The stem mission should own the mission grade. The harness should own case selection, patching, temp copies, port isolation, rolling parallel execution, cleanup, and direct publication of per-case result rows. For the stem mission itself, use `moos-ivp-eval-mission-builder`. For ordinary mission construction before evaluation plumbing, use `moos-ivp-mission-builder`. For post-run `.alog` evidence, use `moos-alog-analysis`. ## Core Rules - Start from a stem mission that runs headlessly and writes `results.txt` with a `grade=` column. - Prefer placing harness directories at the repository root, alongside `missions/`, for example `harnesses/<harness_name>/` paired with `missions/<stem_mission>/`. In larger repositories, use optional family grouping for both sides, such as `harnesses/<family>_harnesses/HNN-<harness_name>/` paired with `missions/<family>_missions/<stem_mission>/`. Have the harness refer to stem missions with explicit relative paths. Other layouts are acceptable when project conventions or packaging require them. - The stem mission must be a real eval mission: `pMissionEval` writes the `grade=` row. Do not accept a stem where `zlaunch.sh` or shell code synthesizes `grade=` from target files, patch markers, or harness knowledge. - Keep case intent documented in the harness README under `Cases` or `Current Matrix`. - Use exact case tokens in documentation and in `zlaunch.sh`. - `case=` is the harness-owned variation identity. Harnesses must not set, derive, require, or interpret `mmod`; any `mmod=` field produced by the mission is opaque mission-owned provenance. - Keep case setup explicit. A shell `case` block mapping case name to patch files, fixture files, stem launch arguments, and intent is easier to audit than filename inference. - When multiple cases reuse one stem but need different setup or evaluation criteria, express the differences in the case matrix and case-owned patch files, fixture files, or stem launch arguments. - Keep `launch.sh` and stem wrappers human-facing. Put loops, temp copies, aggregation, and archives in harness code. - Prefer mission-owned grades. The harness should normally prepend `case=<case_name>` to the mission result row and preserve the mission's `grade=pass|fail` as the case verdict. - For expected-negative cases, make the stem `pMissionEval` pass when the expected negative evidence is observed. Do not encode those cases as `expected=fail actual=fail` unless the harness is explicitly testing failure machinery such as `pMissionEval`, `uMayFinish`, or CLI return semantics. - Harness code should synthesize its own `grade=fail` rows only for runner failures, such as `reason=launch_error`, `reason=missing_result`, `reason=prepare_error`, `reason=missing_result_file`, or `reason=teardown_error`. - Do not add a harness-owned `reason=` for ordinary `pMissionEval` failures. Preserve the mission evidence columns that explain the failure. A mission may report its own compact `reason=`, but the harness should not reinterpret it. - Avoid new `case_result=success|mismatch|error` result formats for ordinary harnesses. Treat them as legacy compatibility or as a special pattern for tests whose subject is the failure machinery itself. - Keep evaluation levels strict: app-level harnesses should grade the app under test; moving/integration harnesses may grade arrival, encounter outcome, collision state, or other mission outcomes. - Expose `--c
Preview of the first 4,000 characters. Read full instructions →
Referenced files: 13 — file references are metadata, not package contents.
---
name: moos-ivp-installer
description: "Install or validate upstream MOOS-IvP: locate or clone moos-ivp/moos-ivp, follow the platform setup README, create env.sh, and verify the checkout for MOOS-IvP development."
---
# MOOS-IvP Installer
## Overview
Use this skill to get a working local checkout of upstream MOOS-IvP. Keep the
install simple: clone or locate the checkout, follow the upstream setup README,
then add the small environment setup the other MOOS-IvP skills expect.
After this skill succeeds, the machine should be ready for MOOS-IvP extension
repo, app, behavior, or mission work.
## Defaults
- Source repo: `https://github.com/moos-ivp/moos-ivp.git`
- SSH form when requested: `git@github.com:moos-ivp/moos-ivp.git`
- Default install path: `~/moos-ivp`
- Environment file: `<moos-ivp-root>/env.sh`
- Dependencies and build commands: follow the relevant upstream setup README
- Persistent shell profile edits: ask first
## Confirm Before Changes
Before cloning, installing packages, building, creating `env.sh`, or editing a
shell profile:
1. Do non-destructive discovery first: look for an existing checkout, resolve
the likely install path, and choose the platform setup README.
2. Ask for any missing user choices: install location and whether to add
persistent shell integration.
3. Summarize the resolved path, clone URL if cloning, branch or tag if
requested, selected README, and shell-profile choice in one concise
sentence.
4. Proceed when the user has already given explicit approval, or after they
confirm the summary. Still ask before package-manager, `sudo`, or shell
profile edits unless that specific approval was already given.
## Workflow
1. Check whether the user already has a valid checkout.
- Try an explicit user path first.
- Then try `MOOS_IVP_ROOT`.
- Then try common paths such as `~/moos-ivp`, `~/src/moos-ivp`,
`~/repos/moos-ivp`, and `~/projects/moos-ivp`.
- Treat a checkout as valid when it has `ivp/src`, `build-moos.sh`,
`build-ivp.sh`, `scripts/GenMOOSApp_AppCasting`, and
`scripts/GenBehavior`.
2. If no checkout exists, confirm the target path before cloning.
3. Clone with the confirmed source URL:
```bash
git clone https://github.com/moos-ivp/moos-ivp.git <target-root>
```
If the user requests a branch or tag, include it in the clone or checkout
plan before building.
4. Choose the relevant setup README from the checkout:
- macOS: `README-OS-X.txt`
- GNU/Linux: `README-GNULINUX.txt`
- Windows: `README-WINDOWS.txt`
5. Read the selected README and follow its dependency and build instructions.
Ask before running package-manager or sudo commands.
6. Create the checkout-local shell environment file.
- Write `<moos-ivp-root>/env.sh`.
- Resolve the absolute checkout path before writing the file.
- Write expanded absolute paths inside `env.sh`, not `~` or `$HOME`.
- Make repeated sourcing idempotent so `PATH` does not accumulate duplicate
entries.
- Keep the file source-compatible with common Bash and zsh startup files.
- Only set `MOOS_IVP_ROOT` and `PATH` for the core checkout. Do not set
`IVP_BEHAVIOR_DIRS` here; extension repos own their behavior library
paths.
- Use this shape:
```bash
#!/usr/bin/env bash
# Source this file to use this MOOS-IvP checkout.
export MOOS_IVP_ROOT="<absolute-moos-ivp-root>"
case ":$PATH:" in *":<absolute-moos-ivp-root>/bin:"*) ;; *) PATH="$PATH:<absolute-moos-ivp-root>/bin" ;; esac
case ":$PATH:" in *":<absolute-moos-ivp-root>/scripts:"*) ;; *) PATH="$PATH:<absolute-moos-ivp-root>/scripts" ;; esac
export PATH
```
7. If the user opted into persistent shell integration, update the selected
shell profile.
- Do not require the user to already know shell profile details. If the user
named a shell, suggest its usual profile, such as `~/.zshrc` for zsh or
`~/.bashrc` for Bash, and ask for confirmation. If the user did not name a
Preview of the first 4,000 characters. Read full instructions →
Referenced files: 3 — file references are metadata, not package contents.
--- name: moos-ivp-mission-builder description: "Build or repair the ordinary mission layer for one standalone MOOS-IvP mission: launchers, meta files, helm layout, communities, ports, nsplug targets, viewer setup, and README updates. For self-evaluating missions, use moos-ivp-eval-mission-builder as the primary skill." --- # MOOS-IvP Mission Builder ## Overview Use this skill for one ordinary mission folder: launchers, meta files, helm behavior layout, mission README, and target generation. The mission may be headless-capable, but it should remain human-readable and runnable on its own. Optimize for the quality of that single mission, not for batch execution. For custom app config surfaces, use `moos-app-builder`. For custom behavior config surfaces, use `ivp-behavior-builder`. For upstream app or behavior parameters not already clear from the chosen baseline or local repo convention, use `moos-ivp-docs`. Use `moos-alog-analysis` for existing logs or when a required claim cannot be established through bounded live evidence. ## Core Rules - Prefer copying `assets/baseline-single-vehicle/` or `assets/baseline-two-vehicle/` and adapting it over writing launchers from scratch. - Treat bundled launch scripts as near-copy templates. Change names, defaults, mission-specific parameters, app runs, and forwarded arguments as needed, but preserve the launcher structure unless the existing project has a stronger local convention. - Before adding custom mission plumbing or functionality, determine whether existing apps, behaviors, or parameters already achieve the requested effect by checking local examples and docs/source; add new functionality only when none fits. - Keep `launch.sh`, `launch_vehicle.sh`, `launch_shoreside.sh`, and `clean.sh` convention-bound. Preserve their `Part N` structure and help summaries. - Keep `launch.sh` as the human-facing mission-level launcher. - Keep sublaunchers thin: each sublauncher generates one community and launches it unless `--just_make` is set. - Let top-level `launch.sh` own interactive `uMAC`; pass `--auto` into sublaunchers so they do not open nested `uMAC` sessions. - Use `--just_make` as the first validation path. It proves target generation, not runtime app validity. - During live validation, preserve the canonical launcher structure and keep the top-level `launch.sh`/`uMAC` session in the foreground. Use the shortest timeout that proves the claim, capped at 30 seconds unless a stated task-specific reason requires longer. After it stops, verify scoped processes and selected ports are clear. - Include caller-controlled port overrides when adding or repairing launchers: `--shore_mport`, `--shore_pshare`, `--veh_mport`, and `--veh_pshare` for a one-vehicle mission. These make the mission easy to run beside other local MOOS work and easy to validate on non-default ports. - Keep `ServerHost = localhost`; map each sublauncher's `--ip` value to `pHostInfo.default_hostip_force`, and map vehicle `--shore` separately to the shoreside broker route. - Use `nsplug --strict --force -x` for both direct and `--auto` sublauncher generation so unresolved macros fail consistently and `.moosx` / `.bhvx` sidecars remain supported. - Launchable mission examples should include `ProcessConfig = ANTLER` with the `Run = ...` roster. A standalone `ProcessConfig = <AppName>` block is appropriate only for intentional snippets or app help text. - Treat plug files as discretionary style. Follow the local repo convention: keep small missions readable with direct `ProcessConfig` blocks unless a plug file clearly removes shared duplication or the project already uses plug files. - Keep `.moos` and `.bhv` files in the local boxed-header style: ```text //------------------------------------------------- // FILE: <filename> // NAME: <author> //------------------------------------------------- ``` - Use `//------------------------------------------------
Preview of the first 4,000 characters. Read full instructions →
Referenced files: 27 — file references are metadata, not package contents.
--- name: moos-ivp-repo-builder description: "Create a user-owned MOOS-IvP extension repository from moos-ivp-extend: clone/customize the template, confirm the local MOOS-IvP dependency, configure PATH and IVP_BEHAVIOR_DIRS, initialize independent Git, and validate the baseline build before app, behavior, or mission work." --- # MOOS-IvP Repo Builder ## Overview Use this skill to bootstrap a new external MOOS-IvP project modeled on the course `moos-ivp-extend` tree. The goal is a working user-owned repository that builds, has its `bin`, `scripts`, and behavior `lib` paths available from the shell, and is ready for custom apps, behaviors, and missions. This skill owns the repo shell and environment setup. For code inside the new repo, delegate follow-on work to: - `moos-app-builder` for custom MOOS apps - `ivp-behavior-builder` for custom IvP behaviors - `moos-ivp-mission-builder` for runnable missions ## Defaults - Template source: `https://github.com/moos-ivp/moos-ivp-extend.git` - Git handling: fresh repo. Remove the template `.git/`, then run `git init`. - Environment file: `<repo>/env.sh` - Persistent shell integration: ask before editing a shell profile - Environment additions: - add `<repo>/bin` and `<repo>/scripts` to `PATH` - add `<repo>/lib` to `IVP_BEHAVIOR_DIRS` - Keep the example app, behavior, and missions unless the user asks for a clean shell. Use a different template repo or skip the repo-local environment file only when the user explicitly asks. ## Confirmation Gate Before cloning or editing files, collect and confirm: 1. New repo name and target parent directory or full target path. 2. Repository author name and optional organization string for customized project text. This is not the same as Git commit identity. 3. Whether examples should stay or be removed. 4. Whether to add persistent shell integration by sourcing `<repo>/env.sh` from the user's preferred shell profile. If yes, confirm the profile path. If the user already gave these values and said to proceed, treat that as the confirmation. Otherwise, stop and ask a concise confirmation question before cloning. ## Guiding Vague Users When the user starts with a vague request such as "I want a new MOOS-IvP repo", guide them with one or two small questions at a time instead of dumping the whole checklist at once. Good first move: 1. Try to resolve `MOOS_IVP_ROOT` in the background. 2. Say whether it was found. 3. Ask for the repo name. Then ask for the target location, project display author, examples/defaults, and shell integration preference as needed. If the user says "wherever is fine", suggest a concrete default path and confirm it. Prefer a sibling of the validated `moos-ivp` checkout, for example `~/my-new-repo` when `MOOS_IVP_ROOT` is `~/moos-ivp`. Do not default to nesting the new repo inside an unrelated active workspace. Explain that the project display author is for README/CMake text, not a Git committer email. When proposing persistent shell integration, show the concise block that would be added to the selected profile: ```bash # >>> moos-ivp repo: <repo-name> >>> [ -f "<absolute-repo-path>/env.sh" ] && . "<absolute-repo-path>/env.sh" # <<< moos-ivp repo: <repo-name> <<< ``` Before side effects, summarize the resolved values in one sentence and ask for explicit confirmation. ## MOOS-IvP Root Resolution Resolve `MOOS_IVP_ROOT` before cloning. Try, in order: 1. Path explicitly provided by the user. 2. `MOOS_IVP_ROOT` from the shell environment. 3. A sibling or parent `moos-ivp` near the target path or current workspace. 4. Common home locations: - `~/moos-ivp` - `~/src/moos-ivp` - `~/repos/moos-ivp` - `~/projects/moos-ivp` 5. A bounded shallow home search for a directory named `moos-ivp`, suppressing expected permission noise. Validate a candidate by confirming: - `ivp/src` exists - `build-moos.sh` exists - `build-ivp.sh` exists - `scripts/GenMOOSApp_AppCasting` exists and is executable - `scr
Preview of the first 4,000 characters. Read full instructions →
Referenced files: 2 — file references are metadata, not package contents.
--- name: moos-map-builder description: "Create and verify MOOS-IvP TIFF background maps with the moos-map application. Use when a user wants to select a map region visually in the local GUI; build directly from two geographic corners through the CLI; choose imagery, zoom, mission origin, or output location; recreate a map from existing bounds; or inspect and verify generated .tif, .info, and .moos files." --- # MOOS Map Builder ## Principles Use the public `moos-map` application as the single implementation. Do not reimplement its map-building or verification logic inside this skill. Address the user directly. Ask plainly for any needed choice, confirmation, or missing information without referring to this skill or its workflow. ## Route First If the user already requested the GUI or CLI, use that route without asking again. Otherwise ask one concise question and wait for the answer: > Would you like to select the region visually in the GUI, or build it directly through the CLI? - Choose the GUI for manual map browsing and visual corner selection. - Choose the CLI for known coordinates, repeatable builds, or agent-driven automation. Make this routing decision before searching the workspace, inspecting existing map code, or looking for prior map files. ## Check the Application Before either route, run: ```bash command -v moos-map moos-map --version ``` Use only the executable returned by `command -v moos-map`; do not substitute another mapping application or activate a repository `.venv`. If it is unavailable, ask before installing it with: ```bash pipx install moos-map ``` If the installed command lacks an option used below, inspect `moos-map <command> -h` before suggesting `pipx upgrade moos-map`. Ask before upgrading. ## GUI Route Launch: ```bash moos-map ui ``` Keep the server process alive while the user works and report its URL. Once the user finishes the build, ask for the TIFF path they chose and verify it with `moos-map verify /absolute/path/to/MAP_NAME.tif --json`. Do not claim that a map was created merely because the UI launched. If the default port is occupied, choose a free one with `--port` and report the exact resulting URL. ## CLI Route ### Resolve only essential inputs - **Corners:** require two diagonally opposite WGS84 points as `latitude longitude` pairs. Either corner order is accepted. - **Name:** obtain or derive a short filesystem-safe map name. - **Origin:** add `--origin LAT_ORIGIN LON_ORIGIN` only when the user explicitly requests those origin coordinates. Otherwise let `moos-map` use the map center. - **Optional choices:** retain Esri World Imagery, zoom 17, `~/moos-maps`, the `.moos` snippet, cached tiles, and output replacement as defaults unless the user requests otherwise. If the user supplies only a city or place name, do not invent a rectangle or scale. Offer the visual GUI route, or ask for the two corners or desired area. When an existing `.info` file defines the requested map, reuse its north, south, east, and west bounds unless the user asks to change them. Reuse its datum only when the user explicitly asks to preserve that origin. ### Plan, confirm, and build Run `plan` with the same corners, origin, source, zoom, and resource-limit options intended for the build: ```bash moos-map plan --corners LAT1 LON1 LAT2 LON2 ``` Tell the user the estimated TIFF size and dimensions, then ask for confirmation before building. After confirmation, run: ```bash moos-map build \ --corners LAT1 LON1 LAT2 LON2 \ --name MAP_NAME \ --json ``` Use `moos-map sources` only when the user wants to compare providers. Add custom `--origin`, `--source`, `--zoom`, or `--output-dir` only when requested. Consult `moos-map build -h` for other options rather than inventing arguments. Preserve these defaults unless the user says otherwise: - include the `.moos` snippet; - replace an existing same-named bundle safely; - reuse cached source tiles. The build JSON includes
Preview of the first 4,000 characters. Read full instructions →
Referenced files: 2 — file references are metadata, not package contents.
Publisher declarations from the archived package. These are separate from our research and the live service's terms.
Package observed Nov 21, 2026.
plugins_6aadb63c78b88191a10493870d2f5f6d
Download plugin data (JSON)Plugin details: freshly prepared. Prepared . Refreshed when plugin data changes or after 6 hours. Your account and Follow status are live.