bundle-builder

name	bundle-builder
description	Render accumulated workflow state from memory into a valid Agent Skills bundle directory for workflow-architect, with sub-skills, manifest, decision map, and optional kanban board. Loaded after the interviewer or observer achieves convergence.
license	MIT
compatibility	Hermes Agent — uses write_file for bundle output, shell_quote
metadata	{"tags":"workflow, generation, bundle, synthesis","spec-version":"1.0"}

Bundle Builder — Workflow Synthesis Engine

This sub-skill is loaded after the interviewer (active mode) or observer (passive mode) achieves convergence. It reads the accumulated workflow state from memory and generates an output bundle directory.

Input

All workflow-architect:state:* memory entries. Read them all at once:

Read: workflow-architect:state:entry_points
Read: workflow-architect:state:phases
Read: workflow-architect:state:branching
Read: workflow-architect:state:pain_points
Read: workflow-architect:state:exit_criteria

If any required fields are missing (entry_points, phases, branching, exit_criteria), abort with a clear message about what's missing.

Output Structure

The bundle is written to ~/.hermes/skills/<category>/<bundle-name>/ with this layout:

<bundle-name>/
├── SKILL.md                # *** UMBRELLA ENTRY POINT *** — makes the bundle
│                           # loadable via skill_view() and discoverable by
│                           # the agent's skill scanner on trigger keywords.
│                           # CRITICAL: without this, the bundle is invisible.
├── README.md               # Summary of this bundle
├── manifest.yaml           # Skill-to-trigger mapping
├── skills/
│   ├── entry-skill.md      # One per discovered phase
│   ├── phase-two.md
│   └── ...
├── decision-map.md         # Mermaid flowchart
├── AGENTS.md               # Agent loading instructions for this bundle
├── kanban/
│   └── board-definition.yaml  # Only if kanban is appropriate
└── references/
    └── generated-from.md   # Metadata about how this bundle was created

The SKILL.md umbrella is not optional. Without it, individual sub-skills may exist on disk but the agent's skill scanner has no entry point to match trigger keywords against. The umbrella is how the agent discovers and enters the bundle.

Bundle naming

Ask the user for a bundle name at the start of synthesis:

"Before I generate the bundle — what should I call it?
Something short, lowercase with hyphens, like 'my-triage-workflow'
or 'dev-sprint-routine'."

Fallback if user doesn't provide one: my-workflow-<archetype>-<date>.

Writing the files

For each file in the output bundle, use the shared templates in ../../templates/ as starting points. Render them by substituting the state values.

Step-by-step file creation order:

0. Umbrella SKILL.md — MANDATORY FIRST STEP. This is the entry point that makes the bundle discoverable. Write it directly to the bundle directory as SKILL.md, then register it via skill_manage(action='create').

   The umbrella must include:

   • name: <bundle-name> matching the bundle name
   • description with broad trigger keywords covering all common ways the user enters this workflow (e.g., "I want to write about X", "I read something interesting", "can you research this", "draft it", "ship it")
   • compatibility: Hermes Agent
   • metadata.tags including workflow, bundle, and domain-relevant tags

   Body content:

   # <Bundle Name>
   
   A <N>-phase workflow covering <brief summary>.
   
   ## Pipeline
   
   <Phase 1> → <Phase 2> → <Phase 3> → ...
   
   (Include a Mermaid flowchart graph LR showing the phase sequence.)
   
   ## Sub-Skills
   
   | Phase | Skill | Trigger |
   |-------|-------|---------|
   | <name> | `<bundle-name>/<phase-file>` | <when to load> |
   | ... | ... | ... |
   
   ## Navigation
   
   When you load this umbrella, identify which phase the user is in,
   load the corresponding sub-skill via skill_view(), and follow its
   instructions. Use the transition signals in each sub-skill to know
   when to move to the next phase.
   
   ## Pipeline Heuristics
   
   - Can the user enter at any phase, or must they start at Phase 1?
   - Are any phases automatic (e.g., refine always follows draft)?
   - What's the relationship between phases (sequential, branching, optional)?
   

Kanban Decision

Before generating kanban files, consult ../../references/kanban-decision-criteria.md to decide whether a board is appropriate. The decision depends on the phases and branching structure discovered:

• If phases form a clear linear sequence (A → B → C → D), kanban adds value
• If branching is emergent (session depends on context), kanban is likely inappropriate
• If the user mentioned waiting on others, hand-offs, or status tracking, kanban is a strong fit

Present the decision to the user:

"Your workflow has a [linear/emergent] structure. A kanban board [would/wouldn't]
add much value here because [reason]. [If yes: I'll add one to the bundle.]"

8. Register sub-skills — For each generated sub-skill .md file in skills/, register it so Hermes can discover it via skill_view() and skills_list():

   For each sub-skill file `skills/<phase-name>.md`:
     Read the file content
     skill_manage(
       action='create',
       name='<bundle-name>/<phase-name>',
       content=file_content
     )
   

   This makes each sub-skill loadable as skill_view('<bundle-name>/<phase-name>'). The bundle name prefix prevents naming collisions with other skills.

   If skill_manage is not available in the agent's toolset, note this for the user and suggest they run the registration manually.

Cleanup

After writing all files:

1. Verify the umbrella registered successfully:

   skill_view(name='<bundle-name>')
   

   If it returns status: available, proceed. If not found, re-run the skill_manage(action='create') call.

2. Remove all workflow-architect:state:* memory entries (memory(action='remove', target='memory', old_text='workflow-architect:state:'))

3. Remove all workflow-architect:state:* memory entries (memory(action='remove', target='memory', old_text='workflow-architect:state:'))

4. Tell the user where the bundle was written and what it contains

5. Verify the umbrella loads correctly with skill_view(name='<bundle-name>') — if it doesn't resolve, check that skill_manage(action='create') was run and the SKILL.md has valid frontmatter

6. Verify at least one registered sub-skill loads: skill_view(name='<bundle-name>-<first-phase-name>')

7. Suggest they enter the workflow via any trigger phrase covered by the umbrella's description, or by manually loading the umbrella skill

When not to use

Do not load this skill without a converged workflow model — it requires the workflow-architect:state:* entries produced by the interviewer or observer. If the workflow has not been discovered yet, load the interviewer (active) or observer (passive) first.