Maestro Bundle logo

Maestro Bundle

Community
ReinaMacCredy
maestro-bundle

Route work into the right maestro tier and drive the SPEC/NOTES/VERIFY bundle lifecycle - open, resume, close, recall.

Overview

PublisherReinaMacCredy
Repositorymaestro
Skill namemaestro-bundle
Stars
232
Forks
23
Bundled files
Instructions only
LicenseMIT
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • Self-contained

    Everything the model needs lives in the instructions — no extra files to sync.

  • Open source

    Published by ReinaMacCredy on GitHub. Read the source before you install it.

Installation

Install the Maestro Bundle AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/ReinaMacCredy/maestro.git /tmp/maestro
mkdir -p .claude/skills
cp -r /tmp/maestro/src/plugins/skills/maestro-bundle .claude/skills/maestro-bundle
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Maestro Bundle in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Maestro Bundle on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Maestro Bundle is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

maestro-bundle

Use WORKFLOW.md for method rules and routing. This skill owns record creation, resume, and handoff procedures.

Tier rule

Apply Tiers after bounded reconnaissance. For tracked work use maestro work add|start|done. When Full is warranted, open the bundle in the store whose checkout will change, even when design runs in the Hub. List Hub decisions as hub:<id>; maestro bundle show renders them. Note the bundle on the Hub map and the map on its work item.

maestro bundle open <id> --work <workId>   # scaffold SPEC/NOTES/VERIFY, link work

The trio contract

Follow Bundle contract. Use maestro handoff <bundle-id> to render NOTES.md from work, decisions, handbacks, failures, and the latest checkpoint. Fill only placeholders the store cannot prove, including original authorization and retained gates. Use maestro bundle show <id> to read the contract and linked decisions. Never create root SPEC-*, NOTES-*, or VERIFY-* files.

Verbs

maestro bundle open <id> [--work <id>]  # scaffold + active row
maestro bundle close <id>               # snapshot trio into the store, archive
maestro bundle pause <id> [--reason]    # active stays open, out of the way
maestro bundle resume <id>              # paused back to active
maestro bundle list                     # states: active | paused | archived
maestro bundle show <id>                # trio + linked work + decisions
maestro bundle save <dir>               # ingest a foreign trio dir as archived
maestro search "<term>"                 # recall: hits labeled (bundle, ...)

Authorization boundaries

Follow Authorization boundaries. Put the original user instruction or retrievable reference on the work item so the successor can verify the grant, rather than relying on an agent's summary.

Routing

Use Routing; a skill transition is internal, not another user approval gate.

Resume protocol

Follow Resume. For Light, read the work and checkpoint without opening a bundle. For Full, locate and read the existing bundle, then reconcile it with the checkout before continuing.

Concurrency and git

Follow Concurrency and git. Record the work owner and task-owned paths in the handoff, not just the branch.

Compact or hand off

Hand off instead of compacting when:

  • the owner changes
  • a dependency becomes its own branch
  • the role changes
  • the context is full of false starts

Compact only when ownership, scope, and role stay stable and the history still helps the same writer continue. Compaction gives no warning turn in either harness, so the checkpoint must already exist: keep a checkpoint: work note (state / next / avoid, latest wins) on each held item, rewritten at every meaningful change of state or next action; the SessionStart brief prints it back after the compaction. Nothing summarized is trusted over it.

Use break-before-make when the writer on a moving scope changes: release the lease and refresh the handoff before the new session starts. The handoff packet must preserve the base, Current State, Next Action, Authority transferred and retained, Failed approaches, and Do not repeat.

Hand-off

Run maestro handoff <bundle-id> to seed untouched NOTES.md sections when a bundle exists. Then decide which of three cases this is; the destination differs:

  1. Continuation with a bundle. A future session, in any tool, continues this bundle in this workspace. The handoff IS the rendered NOTES.md covering every section the trio contract names, with a Driver: line naming the tool expected to resume. The bundle stays active; the next session's resume protocol must find it.
  2. Transfer. The work leaves this workspace, to a person, another repo, or an agent that will not resume the bundle. Write the standalone document below, then close the bundle per maestro-verify's close order, citing the handoff target.
  3. No bundle. For tracked work, save the continuation packet as a checkpoint: work note with original authorization and retained gates. If an untracked quickfix needs continuation, create a Light work item. For a transfer outside this workspace, provide a standalone document in the OS temporary directory, report its path, and transfer it to the recipient; a local path alone is not accessible from another machine.

The standalone document (cases 2 and 3) names the suggested skills for the next agent, references specs, decisions, commits, and diffs by path or id instead of duplicating them, and redacts secrets and personal data.

Design lane -> use the maestro-design skill. Implementation -> maestro-work. Verification and close -> maestro-verify.

Frequently asked questions

What does the Maestro Bundle AI skill do?

Route work into the right maestro tier and drive the SPEC/NOTES/VERIFY bundle lifecycle - open, resume, close, recall.

Why use Maestro Bundle on TypingMind?

Because you install it once and use it with any model. Maestro Bundle is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Maestro Bundle in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/ReinaMacCredy/maestro/tree/main/src/plugins/skills/maestro-bundle. TypingMind reads its SKILL.md and installs it as a skill you can enable per chat.

Which AI models can use Maestro Bundle?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Maestro Bundle?

As many as you like. As long as a model supports skills, you can use Maestro Bundle with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Maestro Bundle AI skill free?

Yes. It is published on GitHub by ReinaMacCredy under the MIT license. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇