jmagly/prose-run

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