Prose Run Skill

You execute OpenProse programs by loading the Prose VM specification into context and running the program according to its two-phase execution model.

Triggers

• "run prose program" / "execute prose program"
• "execute [file].md as prose"
• "prose run [path]"
• "run this as a prose program"

Input

• A path to an OpenProse program file (

  .md

  )
• Optional: input values for the program's

  requires:

  contract

Behavior

Step 0: Detect OpenProse Installation

Run

/prose-detect

to locate the OpenProse installation and resolve

PROSE_ROOT

. If not found, stop and report:

OpenProse not found. Run /prose-setup to install it, or set PROSE_ROOT to an existing installation.

Step 1: Locate Prose Specs

Using the

PROSE_ROOT

resolved by

/prose-detect

:

1. Prose VM spec:

   $PROSE_ROOT/prose.md

2. Forme Container spec:

   $PROSE_ROOT/forme.md

3. If files are missing at resolved path: report error (path is stale — re-run

   /prose-detect

   )

Step 2: Read the Program

Read the target program file. Parse frontmatter to determine:

• Single-component (

  kind: service

  or no

  services:

  list) → skip to Step 4
• Multi-component (

  kind: program

  with

  services:

  list) → proceed to Step 3

Step 3: Phase 1 — Forme Wiring (Multi-Component Only)

Load

forme.md

into context and execute wiring:

1. Read the program entry point
2. Read all service

   .md

   files listed in

   services:

3. For each service, extract

   requires:

   and

   ensures:

4. Match outputs to inputs by semantic understanding
5. Build a dependency graph
6. Determine execution order (topological sort)
7. Produce a manifest describing the wiring

Step 4: Phase 2 — Prose VM Execution

Load

prose.md

into context. This causes the LLM to simulate the Prose VM.

For each component in execution order:

1. Spawn a sub-agent session via the Task tool
2. Pass required inputs (from user input or previous component outputs)
3. The sub-agent executes the component's contract
4. Capture the

   ensures:

   outputs
5. Store outputs in

   .aiwg/working/prose-runs/{run-id}/

Step 5: Return Results

Collect the final program outputs (the root program's

ensures:

values) and present them to the user.

Step 6: Report Execution Summary

## Prose Execution Complete

**Program**: {name}
**Components executed**: {count}
**Execution order**: {component1} → {component2} → ...
**Duration**: {time}

### Outputs
| Name | Value Summary |
|------|---------------|
| {ensures name} | {brief output summary} |

### State
Run artifacts saved to: `.aiwg/working/prose-runs/{run-id}/`

Requirements

• Model: Opus-class model required for reliable Prose VM simulation ("Prose Complete" definition)
• Prose installation:

  prose.md

  and

  forme.md

  must be accessible
• Context budget: Multi-service programs consume significant context — monitor carefully

Safety

• Programs are executed in the current session's sandbox
• File writes are limited to

  .aiwg/working/prose-runs/

• Sub-agent sessions inherit the parent's tool permissions
• No network access beyond what the parent session allows

Limitations

• Requires Opus for reliable execution; Sonnet may produce partial or incorrect results
• Large multi-service programs may exceed context budget
• No persistent state across sessions (state lives in

  .aiwg/working/

  )

References

• @$AIWG_ROOT/agentic/code/addons/prose-integration/README.md — prose-integration addon overview
• @$AIWG_ROOT/agentic/code/addons/aiwg-utils/rules/subagent-scoping.md — Sub-agent spawning via Task tool for multi-component execution
• @$AIWG_ROOT/agentic/code/addons/aiwg-utils/rules/context-budget.md — Monitor context budget for large multi-service programs
• @$AIWG_ROOT/agentic/code/addons/aiwg-utils/rules/research-before-decision.md — Run prose-detect and prose-validate before execution
• @$AIWG_ROOT/docs/cli-reference.md — CLI reference for AIWG integration commands