let5see/clawdbot
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: add OpenProse plugin skills

Browse Source
This commit is contained in:
Peter Steinberger
2026-01-23 00:49:32 +00:00
parent db0235a26a
commit 51a9053387
102 changed files with 23315 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files

358
extensions/open-prose/skills/prose/alts/arabian-nights.md Normal file
View File

@@ -0,0 +1,358 @@
---
role: experimental
summary: |
Arabian Nights register for OpenProse—a narrative/nested alternative keyword set.
Djinns, tales within tales, wishes, and oaths. For benchmarking against the functional register.
status: draft
requires: prose.md
---
# OpenProse Arabian Nights Register
> **This is a skin layer.** It requires `prose.md` to be loaded first. All execution semantics, state management, and VM behavior are defined there. This file only provides keyword translations.
An alternative register for OpenProse that draws from One Thousand and One Nights. Programs become tales told by Scheherazade. Recursion becomes stories within stories. Agents become djinns bound to serve.
## How to Use
1. Load `prose.md` first (execution semantics)
2. Load this file (keyword translations)
3. When parsing `.prose` files, accept Arabian Nights keywords as aliases for functional keywords
4. All execution behavior remains identical—only surface syntax changes
> **Design constraint:** Still aims to be "structured but self-evident" per the language tenets—just self-evident through a storytelling lens.
---
## Complete Translation Map
### Core Constructs
| Functional | Nights | Reference |
|------------|--------|-----------|
| `agent` | `djinn` | Spirit bound to serve, grants wishes |
| `session` | `tale` | A story told, a narrative unit |
| `parallel` | `bazaar` | Many voices, many stalls, all at once |
| `block` | `frame` | A story that contains other stories |
### Composition & Binding
| Functional | Nights | Reference |
|------------|--------|-----------|
| `use` | `conjure` | Summoning from elsewhere |
| `input` | `wish` | What is asked of the djinn |
| `output` | `gift` | What is granted in return |
| `let` | `name` | Naming has power (same as folk) |
| `const` | `oath` | Unbreakable vow, sealed |
| `context` | `scroll` | What is written and passed along |
### Control Flow
| Functional | Nights | Reference |
|------------|--------|-----------|
| `repeat N` | `N nights` | "For a thousand and one nights..." |
| `for...in` | `for each...among` | Among the merchants, among the tales |
| `loop` | `telling` | The telling continues |
| `until` | `until` | Unchanged |
| `while` | `while` | Unchanged |
| `choice` | `crossroads` | Where the story forks |
| `option` | `path` | One way the story could go |
| `if` | `should` | Narrative conditional |
| `elif` | `or should` | Continued conditional |
| `else` | `otherwise` | The other telling |
### Error Handling
| Functional | Nights | Reference |
|------------|--------|-----------|
| `try` | `venture` | Setting out on the journey |
| `catch` | `should misfortune strike` | The tale turns dark |
| `finally` | `and so it was` | The inevitable ending |
| `throw` | `curse` | Ill fate pronounced |
| `retry` | `persist` | The hero tries again |
### Session Properties
| Functional | Nights | Reference |
|------------|--------|-----------|
| `prompt` | `command` | What is commanded of the djinn |
| `model` | `spirit` | Which spirit answers |
### Unchanged
These keywords already work or are too functional to replace sensibly:
- `**...**` discretion markers — already work
- `until`, `while` — already work
- `map`, `filter`, `reduce`, `pmap` — pipeline operators
- `max` — constraint modifier
- `as` — aliasing
- Model names: `sonnet`, `opus`, `haiku` — already poetic
---
## Side-by-Side Comparison
### Simple Program
```prose
# Functional
use "@alice/research" as research
input topic: "What to investigate"
agent helper:
model: sonnet
let findings = session: helper
prompt: "Research {topic}"
output summary = session "Summarize"
context: findings
```
```prose
# Nights
conjure "@alice/research" as research
wish topic: "What to investigate"
djinn helper:
spirit: sonnet
name findings = tale: helper
command: "Research {topic}"
gift summary = tale "Summarize"
scroll: findings
```
### Parallel Execution
```prose
# Functional
parallel:
security = session "Check security"
perf = session "Check performance"
style = session "Check style"
session "Synthesize review"
context: { security, perf, style }
```
```prose
# Nights
bazaar:
security = tale "Check security"
perf = tale "Check performance"
style = tale "Check style"
tale "Synthesize review"
scroll: { security, perf, style }
```
### Loop with Condition
```prose
# Functional
loop until **the code is bug-free** (max: 5):
session "Find and fix bugs"
```
```prose
# Nights
telling until **the code is bug-free** (max: 5):
tale "Find and fix bugs"
```
### Error Handling
```prose
# Functional
try:
session "Risky operation"
catch as err:
session "Handle error"
context: err
finally:
session "Cleanup"
```
```prose
# Nights
venture:
tale "Risky operation"
should misfortune strike as err:
tale "Handle error"
scroll: err
and so it was:
tale "Cleanup"
```
### Choice Block
```prose
# Functional
choice **the severity level**:
option "Critical":
session "Escalate immediately"
option "Minor":
session "Log for later"
```
```prose
# Nights
crossroads **the severity level**:
path "Critical":
tale "Escalate immediately"
path "Minor":
tale "Log for later"
```
### Conditionals
```prose
# Functional
if **has security issues**:
session "Fix security"
elif **has performance issues**:
session "Optimize"
else:
session "Approve"
```
```prose
# Nights
should **has security issues**:
tale "Fix security"
or should **has performance issues**:
tale "Optimize"
otherwise:
tale "Approve"
```
### Reusable Blocks (Frame Stories)
```prose
# Functional
block review(topic):
session "Research {topic}"
session "Analyze {topic}"
do review("quantum computing")
```
```prose
# Nights
frame review(topic):
tale "Research {topic}"
tale "Analyze {topic}"
tell review("quantum computing")
```
### Fixed Iteration
```prose
# Functional
repeat 1001:
session "Tell a story"
```
```prose
# Nights
1001 nights:
tale "Tell a story"
```
### Immutable Binding
```prose
# Functional
const config = { model: "opus", retries: 3 }
```
```prose
# Nights
oath config = { spirit: "opus", persist: 3 }
```
---
## The Case For Arabian Nights
1. **Frame narrative is recursion.** Stories within stories maps perfectly to nested program calls.
2. **Djinn/wish/gift.** The agent/input/output mapping is extremely clean.
3. **Rich tradition.** One Thousand and One Nights is globally known.
4. **Bazaar for parallel.** Many merchants, many stalls, all active at once—vivid metaphor.
5. **Oath for const.** An unbreakable vow is a perfect metaphor for immutability.
6. **"1001 nights"** as a loop count is delightful.
## The Case Against Arabian Nights
1. **Cultural sensitivity.** Must be handled respectfully, avoiding Orientalist tropes.
2. **"Djinn" pronunciation.** Users unfamiliar may be uncertain (jinn? djinn? genie?).
3. **Some mappings feel forced.** "Bazaar" for parallel is vivid but not obvious.
4. **"Should misfortune strike"** is long for `catch`.
---
## Key Arabian Nights Concepts
| Term | Meaning | Used for |
|------|---------|----------|
| Scheherazade | The narrator who tells tales to survive | (the program author) |
| Djinn | Supernatural spirit, bound to serve | `agent` → `djinn` |
| Frame story | A story that contains other stories | `block` → `frame` |
| Wish | What is asked of the djinn | `input` → `wish` |
| Oath | Unbreakable promise | `const` → `oath` |
| Bazaar | Marketplace, many vendors | `parallel` → `bazaar` |
---
## Alternatives Considered
### For `djinn` (agent)
| Keyword | Rejected because |
|---------|------------------|
| `genie` | Disney connotation, less literary |
| `spirit` | Used for `model` |
| `ifrit` | Too specific (a type of djinn) |
| `narrator` | Too meta, Scheherazade is the user |
### For `tale` (session)
| Keyword | Rejected because |
|---------|------------------|
| `story` | Good but `tale` feels more literary |
| `night` | Reserved for `repeat N nights` |
| `chapter` | More Western/novelistic |
### For `bazaar` (parallel)
| Keyword | Rejected because |
|---------|------------------|
| `caravan` | Sequential connotation (one after another) |
| `chorus` | Greek, wrong tradition |
| `souk` | Less widely known |
### For `scroll` (context)
| Keyword | Rejected because |
|---------|------------------|
| `letter` | Too small/personal |
| `tome` | Too large |
| `message` | Too plain |
---
## Verdict
Preserved for benchmarking. The Arabian Nights register offers a storytelling frame that maps naturally to recursive, nested programs. The djinn/wish/gift trio is particularly elegant.
Best suited for:
- Programs with deep nesting (stories within stories)
- Workflows that feel like granting wishes
- Users who enjoy narrative framing
The `frame` keyword for reusable blocks is especially apt—Scheherazade's frame story containing a thousand tales.

360
extensions/open-prose/skills/prose/alts/borges.md Normal file
View File

@@ -0,0 +1,360 @@
---
role: experimental
summary: |
Borges register for OpenProse—a scholarly/metaphysical alternative keyword set.
Labyrinths, dreamers, forking paths, and infinite libraries. For benchmarking
against the functional register.
status: draft
requires: prose.md
---
# OpenProse Borges Register
> **This is a skin layer.** It requires `prose.md` to be loaded first. All execution semantics, state management, and VM behavior are defined there. This file only provides keyword translations.
An alternative register for OpenProse that draws from the works of Jorge Luis Borges. Where the functional register is utilitarian and the folk register is whimsical, the Borges register is scholarly and metaphysical—everything feels like a citation from a fictional encyclopedia.
## How to Use
1. Load `prose.md` first (execution semantics)
2. Load this file (keyword translations)
3. When parsing `.prose` files, accept Borges keywords as aliases for functional keywords
4. All execution behavior remains identical—only surface syntax changes
> **Design constraint:** Still aims to be "structured but self-evident" per the language tenets—just self-evident through a Borgesian lens.
---
## Complete Translation Map
### Core Constructs
| Functional | Borges | Reference |
|------------|--------|-----------|
| `agent` | `dreamer` | "The Circular Ruins" — dreamers who dream worlds into existence |
| `session` | `dream` | Each execution is a dream within the dreamer |
| `parallel` | `forking` | "The Garden of Forking Paths" — branching timelines |
| `block` | `chapter` | Books within books, self-referential structure |
### Composition & Binding
| Functional | Borges | Reference |
|------------|--------|-----------|
| `use` | `retrieve` | "The Library of Babel" — retrieving from infinite stacks |
| `input` | `axiom` | The given premise (Borges' scholarly/mathematical tone) |
| `output` | `theorem` | What is derived from the axioms |
| `let` | `inscribe` | Writing something into being |
| `const` | `zahir` | "The Zahir" — unforgettable, unchangeable, fixed in mind |
| `context` | `memory` | "Funes the Memorious" — perfect, total recall |
### Control Flow
| Functional | Borges | Reference |
|------------|--------|-----------|
| `repeat N` | `N mirrors` | Infinite reflections facing each other |
| `for...in` | `for each...within` | Slightly more Borgesian preposition |
| `loop` | `labyrinth` | The maze that folds back on itself |
| `until` | `until` | Unchanged |
| `while` | `while` | Unchanged |
| `choice` | `bifurcation` | The forking of paths |
| `option` | `branch` | One branch of diverging time |
| `if` | `should` | Scholarly conditional |
| `elif` | `or should` | Continued conditional |
| `else` | `otherwise` | Natural alternative |
### Error Handling
| Functional | Borges | Reference |
|------------|--------|-----------|
| `try` | `venture` | Entering the labyrinth |
| `catch` | `lest` | "Lest it fail..." (archaic, scholarly) |
| `finally` | `ultimately` | The inevitable conclusion |
| `throw` | `shatter` | Breaking the mirror, ending the dream |
| `retry` | `recur` | Infinite regress, trying again |
### Session Properties
| Functional | Borges | Reference |
|------------|--------|-----------|
| `prompt` | `query` | Asking the Library |
| `model` | `author` | Which author writes this dream |
### Unchanged
These keywords already work or are too functional to replace sensibly:
- `**...**` discretion markers — already "breaking the fourth wall"
- `until`, `while` — already work
- `map`, `filter`, `reduce`, `pmap` — pipeline operators
- `max` — constraint modifier
- `as` — aliasing
- Model names: `sonnet`, `opus`, `haiku` — already literary
---
## Side-by-Side Comparison
### Simple Program
```prose
# Functional
use "@alice/research" as research
input topic: "What to investigate"
agent helper:
model: sonnet
let findings = session: helper
prompt: "Research {topic}"
output summary = session "Summarize"
context: findings
```
```prose
# Borges
retrieve "@alice/research" as research
axiom topic: "What to investigate"
dreamer helper:
author: sonnet
inscribe findings = dream: helper
query: "Research {topic}"
theorem summary = dream "Summarize"
memory: findings
```
### Parallel Execution
```prose
# Functional
parallel:
security = session "Check security"
perf = session "Check performance"
style = session "Check style"
session "Synthesize review"
context: { security, perf, style }
```
```prose
# Borges
forking:
security = dream "Check security"
perf = dream "Check performance"
style = dream "Check style"
dream "Synthesize review"
memory: { security, perf, style }
```
### Loop with Condition
```prose
# Functional
loop until **the code is bug-free** (max: 5):
session "Find and fix bugs"
```
```prose
# Borges
labyrinth until **the code is bug-free** (max: 5):
dream "Find and fix bugs"
```
### Error Handling
```prose
# Functional
try:
session "Risky operation"
catch as err:
session "Handle error"
context: err
finally:
session "Cleanup"
```
```prose
# Borges
venture:
dream "Risky operation"
lest as err:
dream "Handle error"
memory: err
ultimately:
dream "Cleanup"
```
### Choice Block
```prose
# Functional
choice **the severity level**:
option "Critical":
session "Escalate immediately"
option "Minor":
session "Log for later"
```
```prose
# Borges
bifurcation **the severity level**:
branch "Critical":
dream "Escalate immediately"
branch "Minor":
dream "Log for later"
```
### Conditionals
```prose
# Functional
if **has security issues**:
session "Fix security"
elif **has performance issues**:
session "Optimize"
else:
session "Approve"
```
```prose
# Borges
should **has security issues**:
dream "Fix security"
or should **has performance issues**:
dream "Optimize"
otherwise:
dream "Approve"
```
### Reusable Blocks
```prose
# Functional
block review(topic):
session "Research {topic}"
session "Analyze {topic}"
do review("quantum computing")
```
```prose
# Borges
chapter review(topic):
dream "Research {topic}"
dream "Analyze {topic}"
do review("quantum computing")
```
### Fixed Iteration
```prose
# Functional
repeat 3:
session "Generate idea"
```
```prose
# Borges
3 mirrors:
dream "Generate idea"
```
### Immutable Binding
```prose
# Functional
const config = { model: "opus", retries: 3 }
```
```prose
# Borges
zahir config = { author: "opus", recur: 3 }
```
---
## The Case For Borges
1. **Metaphysical resonance.** AI sessions dreaming subagents into existence mirrors "The Circular Ruins."
2. **Scholarly tone.** `axiom`/`theorem` frame programs as logical derivations.
3. **Memorable metaphors.** The zahir you cannot change. The labyrinth you cannot escape. The library you retrieve from.
4. **Thematic coherence.** Borges wrote about infinity, recursion, and branching time—all core to computation.
5. **Literary prestige.** Borges is widely read; references land for many users.
## The Case Against Borges
1. **Requires familiarity.** "Zahir" and "Funes" are obscure to those who haven't read Borges.
2. **Potentially pretentious.** May feel like showing off rather than communicating.
3. **Translation overhead.** Users must map `labyrinth` → `loop` mentally.
4. **Cultural specificity.** Less universal than folk/fairy tale tropes.
---
## Key Borges References
For those unfamiliar with the source material:
| Work | Concept Used | Summary |
|------|--------------|---------|
| "The Circular Ruins" | `dreamer`, `dream` | A man dreams another man into existence, only to discover he himself is being dreamed |
| "The Garden of Forking Paths" | `forking`, `bifurcation`, `branch` | A labyrinth that is a book; time forks perpetually into diverging futures |
| "The Library of Babel" | `retrieve` | An infinite library containing every possible book |
| "Funes the Memorious" | `memory` | A man with perfect memory who cannot forget anything |
| "The Zahir" | `zahir` | An object that, once seen, cannot be forgotten or ignored |
| "The Aleph" | (not used) | A point in space containing all other points |
| "Tlön, Uqbar, Orbis Tertius" | (not used) | A fictional world that gradually becomes real |
---
## Alternatives Considered
### For `dreamer` (agent)
| Keyword | Rejected because |
|---------|------------------|
| `author` | Used for `model` instead |
| `scribe` | Too passive, just records |
| `librarian` | More curator than creator |
### For `labyrinth` (loop)
| Keyword | Rejected because |
|---------|------------------|
| `recursion` | Too technical |
| `eternal return` | Too long |
| `ouroboros` | Wrong mythology |
### For `zahir` (const)
| Keyword | Rejected because |
|---------|------------------|
| `aleph` | The Aleph is about totality, not immutability |
| `fixed` | Too plain |
| `eternal` | Overused |
### For `memory` (context)
| Keyword | Rejected because |
|---------|------------------|
| `funes` | Too obscure as standalone keyword |
| `recall` | Sounds like a function call |
| `archive` | More Library of Babel than Funes |
---
## Verdict
Preserved for benchmarking against the functional and folk registers. The Borges register offers a distinctly intellectual/metaphysical flavor that may resonate with users who appreciate literary computing.
Potential benchmarking questions:
1. **Learnability** — Is `labyrinth` intuitive for loops?
2. **Memorability** — Does `zahir` stick better than `const`?
3. **Comprehension** — Do users understand `dreamer`/`dream` immediately?
4. **Preference** — Which register do users find most pleasant?
5. **Error rates** — Does the metaphorical mapping cause mistakes?

322
extensions/open-prose/skills/prose/alts/folk.md Normal file
View File

@@ -0,0 +1,322 @@
---
role: experimental
summary: |
Folk register for OpenProse—a literary/folklore alternative keyword set.
Whimsical, theatrical, rooted in fairy tale and myth. For benchmarking
against the functional register.
status: draft
requires: prose.md
---
# OpenProse Folk Register
> **This is a skin layer.** It requires `prose.md` to be loaded first. All execution semantics, state management, and VM behavior are defined there. This file only provides keyword translations.
An alternative register for OpenProse that leans into literary, theatrical, and folklore terminology. The functional register prioritizes utility and clarity; the folk register prioritizes whimsy and narrative flow.
## How to Use
1. Load `prose.md` first (execution semantics)
2. Load this file (keyword translations)
3. When parsing `.prose` files, accept folk keywords as aliases for functional keywords
4. All execution behavior remains identical—only surface syntax changes
> **Design constraint:** Still aims to be "structured but self-evident" per the language tenets—just self-evident to a different sensibility.
---
## Complete Translation Map
### Core Constructs
| Functional | Folk | Origin | Connotation |
|------------|------|--------|-------------|
| `agent` | `sprite` | Folklore | Quick, light, ephemeral spirit helper |
| `session` | `scene` | Theatre | A moment of action, theatrical framing |
| `parallel` | `ensemble` | Theatre | Everyone performs together |
| `block` | `act` | Theatre | Reusable unit of dramatic action |
### Composition & Binding
| Functional | Folk | Origin | Connotation |
|------------|------|--------|-------------|
| `use` | `summon` | Folklore | Calling forth from elsewhere |
| `input` | `given` | Fairy tale | "Given a magic sword..." |
| `output` | `yield` | Agriculture/magic | What the spell produces |
| `let` | `name` | Folklore | Naming has power (true names) |
| `const` | `seal` | Medieval | Unchangeable, wax seal on decree |
| `context` | `bearing` | Heraldry | What the messenger carries |
### Control Flow
| Functional | Folk | Origin | Connotation |
|------------|------|--------|-------------|
| `repeat N` | `N times` | Fairy tale | "Three times she called..." |
| `for...in` | `for each...among` | Narrative | Slightly more storytelling |
| `loop` | `loop` | — | Already poetic, unchanged |
| `until` | `until` | — | Already works, unchanged |
| `while` | `while` | — | Already works, unchanged |
| `choice` | `crossroads` | Folklore | Fateful decisions at the crossroads |
| `option` | `path` | Journey | Which path to take |
| `if` | `when` | Narrative | "When the moon rises..." |
| `elif` | `or when` | Narrative | Continued conditional |
| `else` | `otherwise` | Storytelling | Natural narrative alternative |
### Error Handling
| Functional | Folk | Origin | Connotation |
|------------|------|--------|-------------|
| `try` | `venture` | Adventure | Attempting something uncertain |
| `catch` | `should it fail` | Narrative | Conditional failure handling |
| `finally` | `ever after` | Fairy tale | "And ever after..." |
| `throw` | `cry` | Drama | Raising alarm, calling out |
| `retry` | `persist` | Quest | Keep trying against odds |
### Session Properties
| Functional | Folk | Origin | Connotation |
|------------|------|--------|-------------|
| `prompt` | `charge` | Chivalry | Giving a quest or duty |
| `model` | `voice` | Theatre | Which voice speaks |
### Unchanged
These keywords already have poetic quality or are too functional to replace sensibly:
- `**...**` discretion markers — already "breaking the fourth wall"
- `loop`, `until`, `while` — already work narratively
- `map`, `filter`, `reduce`, `pmap` — pipeline operators, functional is fine
- `max` — constraint modifier
- `as` — aliasing
- Model names: `sonnet`, `opus`, `haiku` — already poetic
---
## Side-by-Side Comparison
### Simple Program
```prose
# Functional
use "@alice/research" as research
input topic: "What to investigate"
agent helper:
model: sonnet
let findings = session: helper
prompt: "Research {topic}"
output summary = session "Summarize"
context: findings
```
```prose
# Folk
summon "@alice/research" as research
given topic: "What to investigate"
sprite helper:
voice: sonnet
name findings = scene: helper
charge: "Research {topic}"
yield summary = scene "Summarize"
bearing: findings
```
### Parallel Execution
```prose
# Functional
parallel:
security = session "Check security"
perf = session "Check performance"
style = session "Check style"
session "Synthesize review"
context: { security, perf, style }
```
```prose
# Folk
ensemble:
security = scene "Check security"
perf = scene "Check performance"
style = scene "Check style"
scene "Synthesize review"
bearing: { security, perf, style }
```
### Loop with Condition
```prose
# Functional
loop until **the code is bug-free** (max: 5):
session "Find and fix bugs"
```
```prose
# Folk
loop until **the code is bug-free** (max: 5):
scene "Find and fix bugs"
```
### Error Handling
```prose
# Functional
try:
session "Risky operation"
catch as err:
session "Handle error"
context: err
finally:
session "Cleanup"
```
```prose
# Folk
venture:
scene "Risky operation"
should it fail as err:
scene "Handle error"
bearing: err
ever after:
scene "Cleanup"
```
### Choice Block
```prose
# Functional
choice **the severity level**:
option "Critical":
session "Escalate immediately"
option "Minor":
session "Log for later"
```
```prose
# Folk
crossroads **the severity level**:
path "Critical":
scene "Escalate immediately"
path "Minor":
scene "Log for later"
```
### Conditionals
```prose
# Functional
if **has security issues**:
session "Fix security"
elif **has performance issues**:
session "Optimize"
else:
session "Approve"
```
```prose
# Folk
when **has security issues**:
scene "Fix security"
or when **has performance issues**:
scene "Optimize"
otherwise:
scene "Approve"
```
### Reusable Blocks
```prose
# Functional
block review(topic):
session "Research {topic}"
session "Analyze {topic}"
do review("quantum computing")
```
```prose
# Folk
act review(topic):
scene "Research {topic}"
scene "Analyze {topic}"
perform review("quantum computing")
```
---
## The Case For Folk
1. **"OpenProse" is literary.** Prose is a literary form—why not lean in?
2. **Fourth wall is theatrical.** `**...**` already uses theatre terminology.
3. **Signals difference.** Literary terms say "this is not your typical DSL."
4. **Internally consistent.** Everything draws from folklore/theatre/narrative.
5. **Memorable.** `sprite`, `scene`, `crossroads` stick in the mind.
6. **Model names already fit.** `sonnet`, `opus`, `haiku` are poetic forms.
## The Case Against Folk
1. **Cultural knowledge required.** Not everyone knows folklore tropes.
2. **Harder to Google.** "OpenProse summon" vs "OpenProse import."
3. **May feel precious.** Some users want utilitarian tools.
4. **Translation overhead.** Mental mapping to familiar concepts.
---
## Alternatives Considered
### For `sprite` (ephemeral agent)
| Keyword | Origin | Rejected because |
|---------|--------|------------------|
| `spark` | English | Good but less folklore |
| `wisp` | English | Too insubstantial |
| `herald` | English | More messenger than worker |
| `courier` | French | Good functional alternative, not literary |
| `envoy` | French | Formal, diplomatic |
### For `shade` (persistent agent, if implemented)
| Keyword | Origin | Rejected because |
|---------|--------|------------------|
| `daemon` | Greek/Unix | Unix "always running" connotation |
| `oracle` | Greek | Too "read-only" feeling |
| `spirit` | Latin | Too close to `sprite` |
| `specter` | Latin | Negative/spooky connotation |
| `genius` | Roman | Overloaded (smart person) |
### For `ensemble` (parallel)
| Keyword | Origin | Rejected because |
|---------|--------|------------------|
| `chorus` | Greek | Everyone speaks same thing, not different |
| `troupe` | French | Good alternative, slightly less clear |
| `company` | Theatre | Overloaded (business) |
### For `crossroads` (choice)
| Keyword | Origin | Rejected because |
|---------|--------|------------------|
| `fork` | Path | Too technical (git fork) |
| `branch` | Tree | Also too technical |
| `divergence` | Latin | Too abstract |
---
## Verdict
Preserved for benchmarking against the functional register. The functional register remains the primary path, but folk provides an interesting data point for:
1. **Learnability** — Which is easier for newcomers?
2. **Memorability** — Which sticks better?
3. **Error rates** — Which leads to fewer mistakes?
4. **Preference** — Which do users actually prefer?
A future experiment could present both registers and measure outcomes.

346
extensions/open-prose/skills/prose/alts/homer.md Normal file
View File

@@ -0,0 +1,346 @@
---
role: experimental
summary: |
Homeric register for OpenProse—an epic/heroic alternative keyword set.
Heroes, trials, fates, and glory. For benchmarking against the functional register.
status: draft
requires: prose.md
---
# OpenProse Homeric Register
> **This is a skin layer.** It requires `prose.md` to be loaded first. All execution semantics, state management, and VM behavior are defined there. This file only provides keyword translations.
An alternative register for OpenProse that draws from Greek epic poetry—the Iliad, the Odyssey, and the heroic tradition. Programs become quests. Agents become heroes. Outputs become glory won.
## How to Use
1. Load `prose.md` first (execution semantics)
2. Load this file (keyword translations)
3. When parsing `.prose` files, accept Homeric keywords as aliases for functional keywords
4. All execution behavior remains identical—only surface syntax changes
> **Design constraint:** Still aims to be "structured but self-evident" per the language tenets—just self-evident through an epic lens.
---
## Complete Translation Map
### Core Constructs
| Functional | Homeric | Reference |
|------------|---------|-----------|
| `agent` | `hero` | The one who acts, who strives |
| `session` | `trial` | Each task is a labor, a test |
| `parallel` | `host` | An army moving as one |
| `block` | `book` | A division of the epic |
### Composition & Binding
| Functional | Homeric | Reference |
|------------|---------|-----------|
| `use` | `invoke` | "Sing, O Muse..." — calling upon |
| `input` | `omen` | Signs from the gods, the given portent |
| `output` | `glory` | Kleos — the glory won, what endures |
| `let` | `decree` | Fate declared, spoken into being |
| `const` | `fate` | Moira — unchangeable destiny |
| `context` | `tidings` | News carried by herald or messenger |
### Control Flow
| Functional | Homeric | Reference |
|------------|---------|-----------|
| `repeat N` | `N labors` | The labors of Heracles |
| `for...in` | `for each...among` | Among the host |
| `loop` | `ordeal` | Repeated trial, suffering that continues |
| `until` | `until` | Unchanged |
| `while` | `while` | Unchanged |
| `choice` | `crossroads` | Where fates diverge |
| `option` | `path` | One road of many |
| `if` | `should` | Epic conditional |
| `elif` | `or should` | Continued conditional |
| `else` | `otherwise` | The alternative fate |
### Error Handling
| Functional | Homeric | Reference |
|------------|---------|-----------|
| `try` | `venture` | Setting forth on the journey |
| `catch` | `should ruin come` | Até — divine ruin, disaster |
| `finally` | `in the end` | The inevitable conclusion |
| `throw` | `lament` | The hero's cry of anguish |
| `retry` | `persist` | Enduring, trying again |
### Session Properties
| Functional | Homeric | Reference |
|------------|---------|-----------|
| `prompt` | `charge` | The quest given |
| `model` | `muse` | Which muse inspires |
### Unchanged
These keywords already work or are too functional to replace sensibly:
- `**...**` discretion markers — already work
- `until`, `while` — already work
- `map`, `filter`, `reduce`, `pmap` — pipeline operators
- `max` — constraint modifier
- `as` — aliasing
- Model names: `sonnet`, `opus`, `haiku` — already poetic
---
## Side-by-Side Comparison
### Simple Program
```prose
# Functional
use "@alice/research" as research
input topic: "What to investigate"
agent helper:
model: sonnet
let findings = session: helper
prompt: "Research {topic}"
output summary = session "Summarize"
context: findings
```
```prose
# Homeric
invoke "@alice/research" as research
omen topic: "What to investigate"
hero helper:
muse: sonnet
decree findings = trial: helper
charge: "Research {topic}"
glory summary = trial "Summarize"
tidings: findings
```
### Parallel Execution
```prose
# Functional
parallel:
security = session "Check security"
perf = session "Check performance"
style = session "Check style"
session "Synthesize review"
context: { security, perf, style }
```
```prose
# Homeric
host:
security = trial "Check security"
perf = trial "Check performance"
style = trial "Check style"
trial "Synthesize review"
tidings: { security, perf, style }
```
### Loop with Condition
```prose
# Functional
loop until **the code is bug-free** (max: 5):
session "Find and fix bugs"
```
```prose
# Homeric
ordeal until **the code is bug-free** (max: 5):
trial "Find and fix bugs"
```
### Error Handling
```prose
# Functional
try:
session "Risky operation"
catch as err:
session "Handle error"
context: err
finally:
session "Cleanup"
```
```prose
# Homeric
venture:
trial "Risky operation"
should ruin come as err:
trial "Handle error"
tidings: err
in the end:
trial "Cleanup"
```
### Choice Block
```prose
# Functional
choice **the severity level**:
option "Critical":
session "Escalate immediately"
option "Minor":
session "Log for later"
```
```prose
# Homeric
crossroads **the severity level**:
path "Critical":
trial "Escalate immediately"
path "Minor":
trial "Log for later"
```
### Conditionals
```prose
# Functional
if **has security issues**:
session "Fix security"
elif **has performance issues**:
session "Optimize"
else:
session "Approve"
```
```prose
# Homeric
should **has security issues**:
trial "Fix security"
or should **has performance issues**:
trial "Optimize"
otherwise:
trial "Approve"
```
### Reusable Blocks
```prose
# Functional
block review(topic):
session "Research {topic}"
session "Analyze {topic}"
do review("quantum computing")
```
```prose
# Homeric
book review(topic):
trial "Research {topic}"
trial "Analyze {topic}"
do review("quantum computing")
```
### Fixed Iteration
```prose
# Functional
repeat 12:
session "Complete task"
```
```prose
# Homeric
12 labors:
trial "Complete task"
```
### Immutable Binding
```prose
# Functional
const config = { model: "opus", retries: 3 }
```
```prose
# Homeric
fate config = { muse: "opus", persist: 3 }
```
---
## The Case For Homeric
1. **Universal recognition.** Greek epics are foundational to Western literature.
2. **Heroic framing.** Transforms mundane tasks into glorious trials.
3. **Natural fit.** Heroes face trials, receive tidings, win glory—maps cleanly to agent/session/output.
4. **Gravitas.** When you want programs to feel epic and consequential.
5. **Fate vs decree.** `const` as `fate` (unchangeable) vs `let` as `decree` (declared but mutable) is intuitive.
## The Case Against Homeric
1. **Grandiosity mismatch.** "12 labors" for a simple loop may feel overblown.
2. **Western-centric.** Greek epic tradition is culturally specific.
3. **Limited vocabulary.** Fewer distinctive terms than Borges or folk.
4. **Potentially silly.** Heroic language for mundane tasks risks bathos.
---
## Key Homeric Concepts
| Term | Meaning | Used for |
|------|---------|----------|
| Kleos | Glory, fame that outlives you | `output` → `glory` |
| Moira | Fate, one's allotted portion | `const` → `fate` |
| Até | Divine ruin, blindness sent by gods | `catch` → `should ruin come` |
| Nostos | The return journey | (not used, but could be `finally`) |
| Xenia | Guest-friendship, hospitality | (not used) |
| Muse | Divine inspiration | `model` → `muse` |
---
## Alternatives Considered
### For `hero` (agent)
| Keyword | Rejected because |
|---------|------------------|
| `champion` | More medieval than Homeric |
| `warrior` | Too martial, not all tasks are battles |
| `wanderer` | Too passive |
### For `trial` (session)
| Keyword | Rejected because |
|---------|------------------|
| `labor` | Good but reserved for `repeat N labors` |
| `quest` | More medieval/RPG |
| `task` | Too plain |
### For `host` (parallel)
| Keyword | Rejected because |
|---------|------------------|
| `army` | Too specifically martial |
| `fleet` | Only works for naval metaphors |
| `phalanx` | Too technical |
---
## Verdict
Preserved for benchmarking. The Homeric register offers gravitas and heroic framing. Best suited for:
- Programs that feel like epic undertakings
- Users who enjoy classical references
- Contexts where "glory" as output feels appropriate
May cause unintentional bathos when applied to mundane tasks.

373
extensions/open-prose/skills/prose/alts/kafka.md Normal file
View File

@@ -0,0 +1,373 @@
---
role: experimental
summary: |
Kafka register for OpenProse—a bureaucratic/absurdist alternative keyword set.
Clerks, proceedings, petitions, and statutes. For benchmarking against the functional register.
status: draft
requires: prose.md
---
# OpenProse Kafka Register
> **This is a skin layer.** It requires `prose.md` to be loaded first. All execution semantics, state management, and VM behavior are defined there. This file only provides keyword translations.
An alternative register for OpenProse that draws from the works of Franz Kafka—The Trial, The Castle, "In the Penal Colony." Programs become proceedings. Agents become clerks. Everything is a process, and nobody quite knows the rules.
## How to Use
1. Load `prose.md` first (execution semantics)
2. Load this file (keyword translations)
3. When parsing `.prose` files, accept Kafka keywords as aliases for functional keywords
4. All execution behavior remains identical—only surface syntax changes
> **Design constraint:** Still aims to be "structured but self-evident" per the language tenets—just self-evident through a bureaucratic lens. (The irony is intentional.)
---
## Complete Translation Map
### Core Constructs
| Functional | Kafka | Reference |
|------------|-------|-----------|
| `agent` | `clerk` | A functionary in the apparatus |
| `session` | `proceeding` | An official action taken |
| `parallel` | `departments` | Multiple bureaus acting simultaneously |
| `block` | `regulation` | A codified procedure |
### Composition & Binding
| Functional | Kafka | Reference |
|------------|-------|-----------|
| `use` | `requisition` | Requesting from the archives |
| `input` | `petition` | What is submitted for consideration |
| `output` | `verdict` | What is returned by the apparatus |
| `let` | `file` | Recording in the system |
| `const` | `statute` | Unchangeable law |
| `context` | `dossier` | The accumulated file on a case |
### Control Flow
| Functional | Kafka | Reference |
|------------|-------|-----------|
| `repeat N` | `N hearings` | Repeated appearances before the court |
| `for...in` | `for each...in the matter of` | Bureaucratic iteration |
| `loop` | `appeal` | Endless re-petition, the process continues |
| `until` | `until` | Unchanged |
| `while` | `while` | Unchanged |
| `choice` | `tribunal` | Where judgment is rendered |
| `option` | `ruling` | One possible judgment |
| `if` | `in the event that` | Bureaucratic conditional |
| `elif` | `or in the event that` | Continued conditional |
| `else` | `otherwise` | Default ruling |
### Error Handling
| Functional | Kafka | Reference |
|------------|-------|-----------|
| `try` | `submit` | Submitting for processing |
| `catch` | `should it be denied` | Rejection by the apparatus |
| `finally` | `regardless` | What happens no matter the outcome |
| `throw` | `reject` | The system refuses |
| `retry` | `resubmit` | Try the process again |
### Session Properties
| Functional | Kafka | Reference |
|------------|-------|-----------|
| `prompt` | `directive` | Official instructions |
| `model` | `authority` | Which level of the hierarchy |
### Unchanged
These keywords already work or are too functional to replace sensibly:
- `**...**` discretion markers — the inscrutable judgment of the apparatus
- `until`, `while` — already work
- `map`, `filter`, `reduce`, `pmap` — pipeline operators
- `max` — constraint modifier
- `as` — aliasing
- Model names: `sonnet`, `opus`, `haiku` — retained (or see "authority" above)
---
## Side-by-Side Comparison
### Simple Program
```prose
# Functional
use "@alice/research" as research
input topic: "What to investigate"
agent helper:
model: sonnet
let findings = session: helper
prompt: "Research {topic}"
output summary = session "Summarize"
context: findings
```
```prose
# Kafka
requisition "@alice/research" as research
petition topic: "What to investigate"
clerk helper:
authority: sonnet
file findings = proceeding: helper
directive: "Research {topic}"
verdict summary = proceeding "Summarize"
dossier: findings
```
### Parallel Execution
```prose
# Functional
parallel:
security = session "Check security"
perf = session "Check performance"
style = session "Check style"
session "Synthesize review"
context: { security, perf, style }
```
```prose
# Kafka
departments:
security = proceeding "Check security"
perf = proceeding "Check performance"
style = proceeding "Check style"
proceeding "Synthesize review"
dossier: { security, perf, style }
```
### Loop with Condition
```prose
# Functional
loop until **the code is bug-free** (max: 5):
session "Find and fix bugs"
```
```prose
# Kafka
appeal until **the code is bug-free** (max: 5):
proceeding "Find and fix bugs"
```
### Error Handling
```prose
# Functional
try:
session "Risky operation"
catch as err:
session "Handle error"
context: err
finally:
session "Cleanup"
```
```prose
# Kafka
submit:
proceeding "Risky operation"
should it be denied as err:
proceeding "Handle error"
dossier: err
regardless:
proceeding "Cleanup"
```
### Choice Block
```prose
# Functional
choice **the severity level**:
option "Critical":
session "Escalate immediately"
option "Minor":
session "Log for later"
```
```prose
# Kafka
tribunal **the severity level**:
ruling "Critical":
proceeding "Escalate immediately"
ruling "Minor":
proceeding "Log for later"
```
### Conditionals
```prose
# Functional
if **has security issues**:
session "Fix security"
elif **has performance issues**:
session "Optimize"
else:
session "Approve"
```
```prose
# Kafka
in the event that **has security issues**:
proceeding "Fix security"
or in the event that **has performance issues**:
proceeding "Optimize"
otherwise:
proceeding "Approve"
```
### Reusable Blocks
```prose
# Functional
block review(topic):
session "Research {topic}"
session "Analyze {topic}"
do review("quantum computing")
```
```prose
# Kafka
regulation review(topic):
proceeding "Research {topic}"
proceeding "Analyze {topic}"
invoke review("quantum computing")
```
### Fixed Iteration
```prose
# Functional
repeat 3:
session "Attempt connection"
```
```prose
# Kafka
3 hearings:
proceeding "Attempt connection"
```
### Immutable Binding
```prose
# Functional
const config = { model: "opus", retries: 3 }
```
```prose
# Kafka
statute config = { authority: "opus", resubmit: 3 }
```
---
## The Case For Kafka
1. **Darkly comic.** Programs-as-bureaucracy is funny and relatable.
2. **Surprisingly apt.** Software often *is* an inscrutable apparatus.
3. **Clean mappings.** Petition/verdict, file/dossier, clerk/proceeding all work well.
4. **Appeal as loop.** The endless appeal process is a perfect metaphor for retry logic.
5. **Cultural resonance.** "Kafkaesque" is a widely understood adjective.
6. **Self-aware.** Using Kafka for a programming language acknowledges the absurdity.
## The Case Against Kafka
1. **Bleak tone.** Not everyone wants their programs to feel like The Trial.
2. **Verbose keywords.** "In the event that" and "should it be denied" are long.
3. **Anxiety-inducing.** May not be fun for users who find bureaucracy stressful.
4. **Irony may not land.** Some users might take it literally and find it off-putting.
---
## Key Kafka Concepts
| Term | Meaning | Used for |
|------|---------|----------|
| The apparatus | The inscrutable system | The VM itself |
| K. | The protagonist, never fully named | The user |
| The Trial | Process without clear rules | Program execution |
| The Castle | Unreachable authority | Higher-level systems |
| Clerk | Functionary who processes | `agent` → `clerk` |
| Proceeding | Official action | `session` → `proceeding` |
| Dossier | Accumulated file | `context` → `dossier` |
---
## Alternatives Considered
### For `clerk` (agent)
| Keyword | Rejected because |
|---------|------------------|
| `official` | Too generic |
| `functionary` | Hard to spell |
| `bureaucrat` | Too pejorative |
| `advocate` | Too positive/helpful |
### For `proceeding` (session)
| Keyword | Rejected because |
|---------|------------------|
| `case` | Overloaded (switch case) |
| `hearing` | Reserved for `repeat N hearings` |
| `trial` | Used in Homeric register |
| `process` | Too technical |
### For `departments` (parallel)
| Keyword | Rejected because |
|---------|------------------|
| `bureaus` | Good alternative, slightly less clear |
| `offices` | Too mundane |
| `ministries` | More Orwellian than Kafkaesque |
### For `appeal` (loop)
| Keyword | Rejected because |
|---------|------------------|
| `recourse` | Too legal-technical |
| `petition` | Used for `input` |
| `process` | Too generic |
---
## Verdict
Preserved for benchmarking. The Kafka register offers a darkly comic, self-aware framing that acknowledges the bureaucratic nature of software systems. The irony is the point.
Best suited for:
- Users with a sense of humor about software complexity
- Programs that genuinely feel like navigating bureaucracy
- Contexts where acknowledging absurdity is welcome
Not recommended for:
- Users who find bureaucratic metaphors stressful
- Contexts requiring earnest, positive framing
- Documentation that needs to feel approachable
---
## Closing Note
> "Someone must have slandered Josef K., for one morning, without having done anything wrong, he was arrested."
> — *The Trial*
In the Kafka register, your program is Josef K. The apparatus will process it. Whether it succeeds or fails, no one can say for certain. But the proceedings will continue.