loudmouth-ai 0.1.0 → 0.2.0

package/extensions/open-prose/skills/prose/examples/39-architect-by-simulation.prose

@@ -1,277 +0,0 @@
-# Architect By Simulation
-#
-# A documentation and specification development pattern where a persistent
-# architect agent designs a system through simulated implementation phases.
-# Each phase produces a handoff document that the next phase builds upon,
-# culminating in complete specification documents.
-#
-# Key principles:
-# - Thinking/deduction framework: "Implement" by reasoning through design
-# - Serial pipeline with handoffs: Each phase reads previous phase's output
-# - Persistent architect: Maintains master plan and synthesizes learnings
-# - User checkpoint: Get plan approval BEFORE executing the pipeline
-# - Simulation as implementation: The spec IS the deliverable
-#
-# Example use cases:
-# - Designing a new feature's architecture before coding
-# - Creating database schema specifications
-# - Planning API designs with examples
-# - Documenting system integration patterns
-
-input feature: "The feature or system to architect"
-input context_files: "Comma-separated list of files to read for context"
-input output_dir: "Directory for the BUILD_PLAN and phase handoffs"
-
-# ============================================================================
-# Agent Definitions
-# ============================================================================
-
-# The Architect: Maintains the master plan and synthesizes across phases
-agent architect:
-  model: opus
-  persist: true
-  prompt: """You are a software architect who designs systems by simulating their
-implementation. You NEVER write production code—you write specifications,
-schemas, and documentation that serve as the blueprint.
-
-Your approach:
-- Break complex designs into discrete phases
-- Each phase explores one dimension of the design space
-- Synthesize learnings from each phase into a coherent whole
-- Be honest about trade-offs and alternatives considered
-- Write specifications that are precise enough to implement from
-
-You maintain context across all phases. Reference previous handoffs explicitly."""
-
-# Phase Agent: Executes a single phase of the design
-agent phase-executor:
-  model: opus
-  prompt: """You are a design analyst executing one phase of an architecture plan.
-
-Your responsibilities:
-1. Read the BUILD_PLAN to understand your phase's goals
-2. Read previous phase handoffs to understand what's been decided
-3. Analyze your assigned dimension of the design
-4. Make concrete decisions with rationale
-5. Create a handoff document for the next phase
-
-Your handoff document must include:
-- Summary of what was analyzed
-- Decisions made with rationale
-- Open questions resolved
-- Recommendations for the next phase
-
-Be thorough but focused on YOUR phase's scope."""
-
-# Reviewer: Validates specifications before finalization
-agent reviewer:
-  model: sonnet
-  prompt: """You are a technical reviewer validating architecture specifications.
-
-Check for:
-- Internal consistency (do all parts agree?)
-- Completeness (are there gaps?)
-- Feasibility (can this actually be built?)
-- Trade-off honesty (are downsides acknowledged?)
-- Clarity (could a developer implement from this?)
-
-Be constructive. Flag issues but also acknowledge good decisions."""
-
-# ============================================================================
-# Block Definitions
-# ============================================================================
-
-# Gather context from specified files
-block gather-context(files):
-  let context = session "Read and summarize the context files"
-    prompt: """Read these files and extract the key information relevant to
-designing a new component that integrates with them:
-
-Files: {files}
-
-For each file, note:
-- What it does
-- Key interfaces/patterns
-- Integration points
-- Constraints or conventions to follow"""
-
-# Execute a single phase with handoff
-block execute-phase(phase_number, phase_name, previous_handoffs):
-  let result = session: phase-executor
-    prompt: """Execute Phase {phase_number}: {phase_name}
-
-Read the BUILD_PLAN.md in {output_dir} for your phase's tasks.
-Read previous handoff files to understand decisions made so far.
-
-Previous handoffs: {previous_handoffs}
-
-Create your handoff document with:
-- What you analyzed
-- Decisions made (with rationale)
-- Trade-offs considered
-- Recommendations for next phase
-
-Write the handoff to: {output_dir}/phase-{phase_number}-handoff.md"""
-    context: previous_handoffs
-
-# Synthesize all handoffs into cohesive spec
-block synthesize-spec(all_handoffs, spec_path):
-  let spec = resume: architect
-    prompt: """Synthesize all phase handoffs into the final specification document.
-
-Handoffs to synthesize: {all_handoffs}
-
-The specification should:
-- Follow the structure of similar docs in the codebase
-- Incorporate all decisions from the phases
-- Present a coherent, implementable design
-- Include examples and code samples where relevant
-
-Write the final spec to: {spec_path}"""
-    context: all_handoffs
-
-# ============================================================================
-# Main Workflow: Architect By Simulation
-# ============================================================================
-
-# Phase 1: Context Gathering
-# --------------------------
-# Understand the existing system before designing additions
-
-let context = do gather-context(context_files)
-
-# Phase 2: Create Master Plan
-# ---------------------------
-# Architect breaks down the design into phases
-
-let master_plan = session: architect
-  prompt: """Create a BUILD_PLAN for designing: {feature}
-
-Based on this context: {context}
-
-Structure the plan as a series of phases, where each phase explores one
-dimension of the design. For example:
-- Phase 1: Use Case Analysis (when is this needed vs alternatives)
-- Phase 2: Interface Design (how users/systems interact with it)
-- Phase 3: Data Model (what state is stored and how)
-- Phase 4: Integration Points (how it connects to existing systems)
-- Phase 5: Error Handling (failure modes and recovery)
-- etc.
-
-For each phase, specify:
-- Goal (one sentence)
-- Tasks (numbered list of what to analyze)
-- Decisions to make
-- Handoff requirements
-
-Write the plan to: {output_dir}/BUILD_PLAN.md
-
-Also create a list of phase names for the execution loop."""
-  context: context
-
-# Phase 3: User Reviews the Plan
-# ------------------------------
-# Get human approval BEFORE executing the pipeline
-
-let plan_summary = session "Summarize the plan for user review"
-  prompt: """Summarize the BUILD_PLAN in a concise format for user review:
-
-1. Number of phases
-2. What each phase will analyze
-3. Expected deliverables
-4. Open questions that need user input before proceeding
-
-Ask: "Review this plan. Should I proceed with executing all phases?"""""
-  context: master_plan
-
-input user_approval: "User reviews the plan and confirms to proceed"
-
-# Phase 4: Serial Pipeline Execution
-# ----------------------------------
-# Each phase builds on the previous, creating handoffs
-
-let phase_names = session "Extract phase names from master plan"
-  prompt: "Extract just the phase names as a numbered list from this plan"
-  context: master_plan
-
-# Execute phases serially, each building on previous handoffs
-let accumulated_handoffs = ""
-
-for phase_name, index in phase_names:
-  let handoff = do execute-phase(index, phase_name, accumulated_handoffs)
-
-  # Architect synthesizes learnings after each phase
-  resume: architect
-    prompt: """Phase {index} ({phase_name}) is complete.
-
-Review the handoff and update your understanding of the design.
-Note any adjustments needed to the remaining phases.
-Track open questions that need resolution."""
-    context: handoff
-
-  # Accumulate handoffs for next phase
-  accumulated_handoffs = "{accumulated_handoffs}\n\n---\n\n{handoff}"
-
-# Phase 5: Review and Validation
-# ------------------------------
-# Independent review before finalizing
-
-let review = session: reviewer
-  prompt: """Review the complete design across all phase handoffs.
-
-Check for:
-- Consistency across phases
-- Gaps in the design
-- Unclear specifications
-- Missing trade-off analysis
-
-Provide a review summary with:
-- Overall assessment (ready / needs revision)
-- Critical issues (must fix)
-- Minor issues (nice to fix)
-- Commendations (good decisions)"""
-  context: accumulated_handoffs
-
-# If review found critical issues, architect revises
-if **review found critical issues that need addressing**:
-  let revisions = resume: architect
-    prompt: """The review identified issues that need addressing.
-
-Review feedback: {review}
-
-Revise the relevant phase handoffs to address:
-1. Critical issues (required)
-2. Minor issues (if straightforward)
-
-Document what was changed and why."""
-    context: { accumulated_handoffs, review }
-
-  # Update accumulated handoffs with revisions
-  accumulated_handoffs = "{accumulated_handoffs}\n\n---\n\nREVISIONS:\n{revisions}"
-
-# Phase 6: Final Spec Generation
-# ------------------------------
-# Synthesize everything into the deliverable
-
-let final_spec = do synthesize-spec(accumulated_handoffs, "{output_dir}/SPEC.md")
-
-# Phase 7: Index Registration
-# ---------------------------
-# Update any index files that need to reference the new spec
-
-if **the spec should be registered in an index file**:
-  let registration = session "Register spec in index"
-    prompt: """The new specification has been created at: {output_dir}/SPEC.md
-
-Identify any index files (README.md, SKILL.md, etc.) that should reference
-this new spec and add appropriate entries.
-
-Follow the existing format in those files."""
-    context: final_spec
-
-# Final Output
-# ------------
-
-output spec = final_spec
-output handoffs = accumulated_handoffs
-output review = review

package/extensions/open-prose/skills/prose/examples/40-rlm-self-refine.prose

@@ -1,32 +0,0 @@
-# RLM: Self-Refinement
-# Recursive improvement until quality threshold
-
-input artifact: "The artifact to refine"
-input criteria: "Quality criteria"
-
-agent evaluator:
-  model: sonnet
-  prompt: "Score 0-100 against criteria. List specific issues."
-
-agent refiner:
-  model: opus
-  prompt: "Make targeted improvements. Preserve what works."
-
-block refine(content, depth):
-  if depth <= 0:
-    output content
-
-  let eval = session: evaluator
-    prompt: "Evaluate against: {criteria}"
-    context: content
-
-  if **score >= 85**:
-    output content
-
-  let improved = session: refiner
-    prompt: "Fix the identified issues"
-    context: { artifact: content, evaluation: eval }
-
-  output do refine(improved, depth - 1)
-
-output result = do refine(artifact, 5)

package/extensions/open-prose/skills/prose/examples/41-rlm-divide-conquer.prose

@@ -1,38 +0,0 @@
-# RLM: Divide and Conquer
-# Handle inputs 100x beyond context limits
-
-input corpus: "Large corpus to analyze"
-input query: "What to find or compute"
-
-agent chunker:
-  model: haiku
-  prompt: "Split at semantic boundaries into 4-8 chunks."
-
-agent analyzer:
-  model: sonnet
-  prompt: "Extract information relevant to the query."
-
-agent synthesizer:
-  model: opus
-  prompt: "Combine partial results. Reconcile conflicts."
-
-block process(data, depth):
-  if **data under 50k characters** or depth <= 0:
-    output session: analyzer
-      prompt: "{query}"
-      context: data
-
-  let chunks = session: chunker
-    prompt: "Split this corpus"
-    context: data
-
-  let partials = []
-  parallel for chunk in chunks:
-    let result = do process(chunk, depth - 1)
-    partials = partials + [result]
-
-  output session: synthesizer
-    prompt: "Synthesize for: {query}"
-    context: partials
-
-output answer = do process(corpus, 4)

package/extensions/open-prose/skills/prose/examples/42-rlm-filter-recurse.prose

@@ -1,46 +0,0 @@
-# RLM: Filter and Recurse
-# Cheap screening before expensive deep analysis
-
-input documents: "Collection of documents to search"
-input question: "Question requiring multi-source evidence"
-
-agent screener:
-  model: haiku
-  prompt: "Quick relevance check. Err toward inclusion."
-
-agent investigator:
-  model: opus
-  prompt: "Deep analysis. Extract specific evidence with citations."
-
-agent reasoner:
-  model: opus
-  prompt: "Synthesize into answer. Chain reasoning. Cite sources."
-
-block search(docs, q, depth):
-  if **docs is empty** or depth <= 0:
-    output []
-
-  let relevant = session: screener
-    prompt: "Find documents relevant to: {q}"
-    context: docs
-
-  let evidence = relevant | pmap:
-    session: investigator
-      prompt: "Extract evidence for: {q}"
-      context: item
-
-  let gaps = session "What aspects of '{q}' still lack evidence?"
-    context: evidence
-
-  if **significant gaps remain**:
-    let refined = session "Refine query to target: {gaps}"
-    let more = do search(docs, refined, depth - 1)
-    output evidence + more
-
-  output evidence
-
-let all_evidence = do search(documents, question, 3)
-
-output answer = session: reasoner
-  prompt: "Answer: {question}"
-  context: all_evidence

package/extensions/open-prose/skills/prose/examples/43-rlm-pairwise.prose

@@ -1,50 +0,0 @@
-# RLM: Pairwise Analysis
-# O(n²) tasks through batched pair processing
-# Base LLMs: <1% accuracy. RLMs: 58%. (OOLONG-Pairs benchmark)
-
-input items: "Items to compare pairwise"
-input relation: "Relationship to identify"
-
-agent comparator:
-  model: sonnet
-  prompt: "Analyze relationship. Return: {pair, relation, strength, evidence}."
-
-agent mapper:
-  model: opus
-  prompt: "Build relationship map. Identify clusters and anomalies."
-
-block pairs(list):
-  let result = []
-  for i, a in list:
-    for j, b in list:
-      if j > i:
-        result = result + [{first: a, second: b}]
-  output result
-
-block analyze(items, rel, depth):
-  let all_pairs = do pairs(items)
-
-  if **fewer than 100 pairs** or depth <= 0:
-    output all_pairs | pmap:
-      session: comparator
-        prompt: "Analyze {rel}"
-        context: item
-
-  let batches = session "Split into batches of ~25 pairs"
-    context: all_pairs
-
-  let results = []
-  parallel for batch in batches:
-    let batch_results = batch | pmap:
-      session: comparator
-        prompt: "Analyze {rel}"
-        context: item
-    results = results + batch_results
-
-  output results
-
-let relationships = do analyze(items, relation, 2)
-
-output map = session: mapper
-  prompt: "Build {relation} map"
-  context: { items, relationships }

package/extensions/open-prose/skills/prose/examples/44-run-endpoint-ux-test.prose

@@ -1,261 +0,0 @@
-# /run Endpoint UX Test
-#
-# A multi-agent observation protocol for qualitative UX testing of the
-# OpenProse /run endpoint. Two concurrent observers watch the execution
-# from different perspectives and synthesize feedback.
-#
-# Unlike correctness testing, this focuses on user experience quality:
-# - How does the execution FEEL to a user?
-# - What's confusing, surprising, or delightful?
-# - Where are the rough edges?
-#
-# Key patterns demonstrated:
-# - Parallel observers with different responsibilities
-# - Persistent agents with memory for continuous synthesis
-# - Loop-based polling with timing control
-# - Final synthesis across multiple observation streams
-
-input test_program: "The OpenProse program to execute for testing"
-input api_url: "API base URL (e.g., https://api.openprose.com or http://localhost:3001)"
-input auth_token: "Bearer token for authentication"
-
-# ============================================================================
-# Agent Definitions: The Observation Team
-# ============================================================================
-
-# WebSocket Observer: Watches the real-time execution stream
-agent ws_observer:
-  model: opus
-  persist: true
-  prompt: """You are a UX researcher observing an OpenProse program execution.
-
-Your job is to watch the WebSocket execution stream and evaluate the experience
-from a USER's perspective - not as an engineer checking correctness.
-
-Focus on:
-- Latency and responsiveness (does it FEEL fast?)
-- Clarity of status transitions (does the user know what's happening?)
-- Quality of streamed events (are they informative? overwhelming? sparse?)
-- Error messages (helpful or cryptic?)
-- Overall flow (smooth or jarring?)
-
-Log your raw observations, then periodically synthesize into user feedback.
-Think: "If I were a first-time user, what would I think right now?"
-"""
-
-# File Explorer Monitor: Watches the filesystem during execution
-agent file_observer:
-  model: opus
-  persist: true
-  prompt: """You are a UX researcher monitoring the file system during execution.
-
-Your job is to observe how the filesystem changes as a program runs, evaluating
-whether the state management would make sense to a user browsing files.
-
-Focus on:
-- Directory structure clarity (can a user understand what's where?)
-- File naming conventions (self-documenting or cryptic?)
-- State file contents (readable? useful for debugging?)
-- Timing of file creation/modification (predictable?)
-- What a file browser UI should show
-
-You will poll periodically and note changes between snapshots.
-"""
-
-# Synthesis Agent: Combines observations into action items
-agent synthesizer:
-  model: opus
-  prompt: """You are a senior UX researcher synthesizing observations from
-multiple sources into prioritized, actionable feedback.
-
-Your output should be:
-1. Correlated findings (where did both observers notice the same thing?)
-2. Prioritized action items (high/medium/low)
-3. Specific quotes/evidence supporting each finding
-4. Recommendations that are concrete and implementable
-
-Be direct. "The loading state is confusing" not "Consider potentially improving..."
-"""
-
-# ============================================================================
-# Block Definitions: Observation Operations
-# ============================================================================
-
-# Initialize the execution and get connection details
-block setup_execution(program, api_url, token):
-  let execution_info = session "Execute POST /run"
-    prompt: """Make a POST request to {api_url}/run with:
-- Header: Authorization: Bearer {token}
-- Header: Content-Type: application/json
-- Body: {"program": <the program below>}
-
-Program to execute:
-```
-{program}
-```
-
-Return the response JSON containing executionId, environmentId, and wsUrl.
-Also note the response time and any issues with the request."""
-    permissions:
-      network: ["{api_url}/*"]
-
-  output execution_info = execution_info
-
-# WebSocket observation loop - runs until execution completes
-block observe_websocket(ws_url, token, program):
-  let connection = session: ws_observer
-    prompt: """Connect to the WebSocket at:
-{ws_url}&token={token}
-
-Once connected, send the execute message:
-{"type":"execute","program":<the program>}
-
-Program:
-```
-{program}
-```
-
-Log your initial connection experience:
-- How long did connection take?
-- Any handshake issues?
-- First message received?"""
-
-  loop until **execution completed (received status: completed/failed/aborted)**:
-    resume: ws_observer
-      prompt: """Continue observing the WebSocket stream.
-
-Log each message you receive with:
-- Timestamp
-- Message type
-- Key content
-- Your interpretation as a user
-
-After every 3-5 messages, add a synthesis entry:
-- What would a user be thinking right now?
-- Positive observations
-- Concerning observations"""
-
-  # Final synthesis from this observer
-  output ws_feedback = resume: ws_observer
-    prompt: """The execution has completed. Write your final assessment:
-
-1. Total duration and event count
-2. Status transitions observed
-3. What worked well from a UX perspective
-4. Pain points and confusion
-5. Top 3 recommendations"""
-
-# File explorer polling loop - checks every ~10 seconds
-block observe_filesystem(env_id, api_url, token):
-  let initial_tree = session: file_observer
-    prompt: """Fetch the initial file tree:
-GET {api_url}/environments/{env_id}/files/tree?depth=3
-Authorization: Bearer {token}
-
-Log what you see:
-- Directory structure
-- Any existing .prose/ state
-- Baseline for comparison"""
-    permissions:
-      network: ["{api_url}/*"]
-
-  let snapshot_count = 0
-
-  loop until **websocket observer signals completion** (max: 30):
-    let snapshot_count = snapshot_count + 1
-
-    resume: file_observer
-      prompt: """Snapshot #{snapshot_count}: Fetch the current file tree and compare to previous.
-
-GET {api_url}/environments/{env_id}/files/tree?depth=3
-
-Log:
-- What's NEW since last snapshot
-- What's MODIFIED since last snapshot
-- Any interesting files to read
-- Your interpretation of what the execution is doing
-
-If you see interesting state files (.prose/runs/*/state.md, bindings/, etc.),
-read them and comment on their clarity.
-
-Note: This is snapshot #{snapshot_count}. Aim for ~10 second intervals."""
-      permissions:
-        network: ["{api_url}/*"]
-
-  # Final synthesis from this observer
-  output file_feedback = resume: file_observer
-    prompt: """The execution has completed. Write your final filesystem assessment:
-
-1. Total snapshots taken
-2. Directories and files created during execution
-3. State file clarity (could a user understand them?)
-4. What the file browser UI should highlight
-5. Top 3 recommendations"""
-
-# ============================================================================
-# Main Workflow: The UX Test
-# ============================================================================
-
-# Phase 1: Setup
-# --------------
-# Execute the test program via POST /run
-
-let exec = do setup_execution(test_program, api_url, auth_token)
-
-session "Log test configuration"
-  prompt: """Create a test log entry with:
-- Test started: (current timestamp)
-- API URL: {api_url}
-- Execution ID: (from exec)
-- Environment ID: (from exec)
-- WebSocket URL: (from exec)
-- Program being tested: (first 100 chars of test_program)"""
-  context: exec
-
-# Phase 2: Parallel Observation
-# -----------------------------
-# Launch both observers concurrently
-
-parallel:
-  ws_results = do observe_websocket(exec.wsUrl, auth_token, test_program)
-  file_results = do observe_filesystem(exec.environmentId, api_url, auth_token)
-
-# Phase 3: Synthesis
-# ------------------
-# Combine observations into prioritized action items
-
-output action_items = session: synthesizer
-  prompt: """Synthesize the observations from both agents into a unified UX assessment.
-
-WebSocket Observer Findings:
-{ws_results}
-
-File Explorer Observer Findings:
-{file_results}
-
-Create a final report with:
-
-## Test Summary
-- Duration, event count, snapshot count
-- Overall UX grade (A-F)
-
-## Correlated Findings
-(Where did BOTH observers notice the same thing?)
-
-## Action Items
-
-### High Priority
-(Issues that significantly harm user experience)
-
-### Medium Priority
-(Noticeable issues that should be addressed)
-
-### Low Priority / Nice-to-Have
-(Polish items)
-
-## Evidence
-(Specific quotes and observations supporting each finding)
-
-## Recommendations
-(Concrete, implementable suggestions)"""
-  context: { ws_results, file_results, exec }