Forme Manifest Skill

You analyze a multi-service OpenProse program directory by reading all service contracts and generating the wiring manifest that the Forme Container would produce — without executing the program.

Triggers

• "show forme manifest" / "generate wiring manifest"
• "how does this prose program wire together"
• "forme manifest [path]"
• "show dependency graph for [program]"
• "what's the wiring for [program]"

Input

A path to a directory containing a multi-service OpenProse program (must have an index.md with kind: program and a services: list).

Behavior

Step 0: Detect OpenProse Installation

Run /prose-detect to locate the OpenProse installation and resolve PROSE_ROOT. The Forme Container spec at $PROSE_ROOT/forme.md drives the wiring semantics used in this analysis. 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: Read Entry Point

Read index.md (or the specified entry file) in the directory. Extract:

• Program name
• Services list
• Program-level requires: (external inputs)
• Program-level ensures: (final outputs)

Step 2: Read All Service Contracts

For each service in the services: list:

1. Read {service-name}.md from the same directory
2. Extract requires: (what this service needs)
3. Extract ensures: (what this service produces)
4. Extract strategies: (conditional behavior)

Step 3: Build Dependency Graph

Match outputs to inputs by semantic understanding:

For each service's requires: entry:

1. Check if it matches the program's requires: (external input)
2. Check if it matches another service's ensures: (internal wiring)
3. If no match found: flag as unwired dependency

For each service's ensures: entry:

1. Check if it's consumed by another service's requires:
2. Check if it maps to the program's ensures: (final output)
3. If not consumed: flag as unused output (warning)

Step 4: Determine Execution Order

Build a topological sort of the dependency graph:

• Services with only external inputs execute first
• Services depending on other services' outputs execute after their dependencies
• Services with no dependencies between them can execute in parallel

Step 5: Output Manifest

## Forme Wiring Manifest

**Program**: {name}
**Services**: {count}
**External Inputs**: {count}
**Final Outputs**: {count}

### Service Contracts

| Service | Requires | Ensures |
|---------|----------|---------|
| {name} | {requires list} | {ensures list} |

### Wiring Graph

{service_a}.{output} → {service_b}.requires.{input} {service_b}.{output} → {service_c}.requires.{input} {program}.requires.{input} → {service_a}.requires.{input} {service_c}.{output} → {program}.ensures.{output}

### Execution Order

1. {service_a} (depends on: external inputs only)
2. {service_b} (depends on: {service_a})
3. {service_c} (depends on: {service_b})

**Parallel groups**: [{service_a}] → [{service_b}] → [{service_c}]

### Issues

- {any unwired dependencies}
- {any unused outputs}
- {any circular dependencies}

### Mermaid Diagram

```mermaid
graph LR
    Input[Program Input] --> A[{service_a}]
    A --> B[{service_b}]
    B --> C[{service_c}]
    C --> Output[Program Output]

## Edge Cases

- **Single-component program**: Report that wiring is not needed — program is self-contained
- **Missing service file**: Report as error with path that was expected
- **Circular dependency**: Report as error — cannot determine execution order
- **Ambiguous wiring**: When multiple services could satisfy a requirement, list all candidates and flag for human decision

## Model

This skill runs on **Sonnet** — contract analysis requires moderate reasoning but not Opus-level complexity.

## References

- @$AIWG_ROOT/agentic/code/addons/prose-integration/README.md — prose-integration addon overview
- @$AIWG_ROOT/agentic/code/addons/aiwg-utils/rules/research-before-decision.md — Run prose-detect before operating
- @$AIWG_ROOT/agentic/code/addons/aiwg-utils/rules/vague-discretion.md — Report ambiguous wiring explicitly rather than resolving silently
- @$AIWG_ROOT/docs/cli-reference.md — CLI reference for AIWG addon integration commands