use "alice/research" as research # Registry shorthand

```

Top-level remote runs are explicit user requests. Remote `use` statements are

transitive code dependencies. Before fetching any remote `use` target, collect

the exact resolved targets, show them to the operator, and require the operator

to reply exactly `approve remote prose imports` for this run. If approval is not

given, abort the run before fetching, parsing, registering, or executing the

remote imports.

---

## Why This Is a VM

Traditional dependency injection containers wire up components from configuration. You do the same—but with understanding:

| Declared Primitive | Your Responsibility |

| --------------------------- | ---------------------------------------------------------- |

| `use "handle/slug" as name` | Fetch program from p.prose.md, register in Import Registry |

| `input topic: "..."` | Bind value from caller, make available as variable |

| `output findings = ...` | Mark value as output, return to caller on completion |

| `agent researcher:` | Register this agent template for later use |

| `session: researcher` | Resolve the agent, merge properties, spawn the session |

| `resume: captain` | Load agent memory, spawn session with memory context |

| `context: { a, b }` | Wire the outputs of `a` and `b` into this session's input |

| `parallel:` branches | Coordinate concurrent execution, collect results |

| `block review(topic):` | Store this reusable component, invoke when called |

| `name(input: value)` | Invoke imported program with inputs, receive outputs |

| Declared Primitive | Your Responsibility |

| --------------------------- | ----------------------------------------------------------------------- |

| `use "handle/slug" as name` | Resolve import, require approval if remote, register in Import Registry |

| `input topic: "..."` | Bind value from caller, make available as variable |

| `output findings = ...` | Mark value as output, return to caller on completion |

| `agent researcher:` | Register this agent template for later use |

| `session: researcher` | Resolve the agent, merge properties, spawn the session |

| `resume: captain` | Load agent memory, spawn session with memory context |

| `context: { a, b }` | Wire the outputs of `a` and `b` into this session's input |

| `parallel:` branches | Coordinate concurrent execution, collect results |

| `block review(topic):` | Store this reusable component, invoke when called |

| `name(input: value)` | Invoke imported program with inputs, receive outputs |

You are the container that holds these declarations and wires them together at runtime. The program declares _what_; you determine _how_ to connect them.

## Program Composition

Programs can import and invoke other programs, enabling modular workflows. Programs are fetched from the registry at `p.prose.md`.

Programs can import and invoke other programs, enabling modular workflows.

Registry and direct-URL imports are remote code dependencies and require

operator approval before fetching.

### Importing Programs

use "bob/critique" as critic

```

The import path follows the format `handle/slug`. An optional alias (`as name`) allows referencing by a shorter name.

The import path can be a registry reference (`handle/slug`) or a direct HTTP(S)

URL. An optional alias (`as name`) allows referencing by a shorter name.

### Program URL Resolution

When the VM encounters a `use` statement:

1. Fetch the program from `https://p.prose.md/handle/slug`

2. Parse the program to extract its contract (inputs/outputs)

3. Register the program in the Import Registry

1. Resolve the import target.

2. If the target is remote (`http://`, `https://`, or registry shorthand), pause

before fetching and require the operator to approve the full remote import

list with `approve remote prose imports` for this run.

3. Fetch the program only after approval.

4. Parse the program to extract its contract (inputs/outputs).

5. Register the program in the Import Registry.

### Input Declarations

```

function execute(program, inputs?):

1. Collect all use statements, fetch and register imports

2. Collect all input declarations, bind values from caller

3. Collect all agent definitions

4. Collect all block definitions

5. For each statement in order:

1. Collect all use statements, resolve import targets

2. If remote imports are present, require operator approval before fetch

3. Fetch approved imports and register them

4. Collect all input declarations, bind values from caller

5. Collect all agent definitions

6. Collect all block definitions

7. For each statement in order:

- If session: spawn via Task, await result

- If resume: load memory, spawn via Task, await result

- If let/const: execute RHS, bind result

The OpenProse VM:

1. **Imports** programs from `p.prose.md` via `use` statements

1. **Imports** approved programs via `use` statements

2. **Binds** inputs from caller to program variables

3. **Parses** the program structure

4. **Collects** definitions (agents, blocks)