← Plugin catalog
Developer Tools

MOOS-IvP Skills

Charles Chen-Zhou Benjamin v1.4.12

Agent workflows for MOOS-IvP

Create a free account to save this plugin.

From the developer

Declared capabilities

  • Read
  • Write
  • Execute

Not specified in the available declarations: limitations, pricing & account requirements.

Onboarding example

Use MOOS-IvP skills to build or repair this MOOS app
Sources & dates

Developer declarations; not independently tested. Listing last checked Nov 22, 2026. Package observed Nov 21, 2026.

View package source →

Description

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.

What changed

Similar plugins

Finding similar plugins… Results will appear here automatically.

Browse plugins →

Keywords

Files & skills

File archives

Plugin package100 files · 16.4 MBBrowse files →
Skill instructions
ivp-behavior-builder7.82 KB

View saved version →

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

moos-alog-analysis3.9 KB

View saved version →

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

moos-app-builder7.57 KB

View saved version →

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

moos-ivp-docs6.29 KB

View saved version →

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

moos-ivp-eval-mission-builder8.48 KB

View saved version →

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

moos-ivp-harness-builder10.9 KB

View saved version →

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

moos-ivp-installer5.38 KB

View saved version →

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

moos-ivp-mission-builder7.14 KB

View saved version →

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

moos-ivp-repo-builder13.3 KB

View saved version →

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

moos-map-builder5.45 KB

View saved version →

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

Package details

Publisher declarations from the archived package. These are separate from our research and the live service's terms.

Package license
GPL-3.0-only
Package author
Charles Benjamin
Keywords
See keywords

Declared capabilities

  • Read
  • Write
  • Execute

Package observed Nov 21, 2026.

Technical details
First seen
Sep 30, 2026 · 22:02 UTC
Last seen
Nov 22, 2026 · 18:00 UTC
Collection status
Collected

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.