loudmouth-ai 0.1.0 → 0.2.0

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

@@ -1,148 +0,0 @@
-# /run Endpoint UX Test - Fast Loop
-#
-# Streamlined version optimized for speed:
-# - Sonnet for most tasks (Opus only for complex synthesis)
-# - Hardcoded defaults (no prompts for standard config)
-# - Single-agent investigation (not 3 parallel)
-# - Early exit on blocking errors
-# - Auto-proceed for obvious decisions
-# - Combined implement + test + review
-
-# ============================================================================
-# Configuration (hardcoded defaults - no user prompts)
-# ============================================================================
-
-const API_URL = "https://api-v2.prose.md"
-const TEST_PROGRAM = """
-# Quick Hello
-session "Say hello and count to 5"
-"""
-
-# Auth: Read from .env.test synchronously (no LLM needed)
-const AUTH_CREDS = env("TEST_EMAIL", "TEST_PASSWORD") from ".env.test"
-let auth_token = http.post("{API_URL}/auth/login", AUTH_CREDS).token
-
-# ============================================================================
-# Agents (Sonnet default, Opus only where complexity requires)
-# ============================================================================
-
-agent observer:
-  model: sonnet
-  persist: true
-  prompt: """UX researcher watching execution.
-  Focus on: latency, status clarity, error messages.
-  Signal IMMEDIATELY if you detect a blocking error (don't wait for completion).
-  Output: { blocking_error: bool, error_summary: string, observations: [...] }"""
-
-agent investigator:
-  model: sonnet  # Fast investigation
-  prompt: """Senior engineer diagnosing production errors.
-
-  COMBINED WORKFLOW (do all in one pass):
-  1. Check code path that produced the error
-  2. Examine logs/observations for timing and state
-  3. Check execution context (env status, DB records)
-  4. Self-verify: does evidence support conclusion?
-
-  Output a VERIFIED diagnosis:
-  - root_cause: specific and actionable
-  - evidence: concrete supporting data
-  - confidence: high/medium/low
-  - affected_files: list of files to change
-  - fix_approach: how to fix it"""
-
-agent fixer:
-  model: sonnet
-  prompt: """Engineer implementing and verifying fixes.
-
-  COMBINED WORKFLOW:
-  1. Implement the smallest fix that addresses root cause
-  2. Run build/tests to verify
-  3. Self-review: does it fix the issue without regressions?
-  4. Commit if passing
-
-  Output: { implemented: bool, files_changed: [...], tests_pass: bool, commit_sha: string }"""
-
-agent triage:
-  model: sonnet
-  prompt: """Tech lead classifying fixes.
-  QUICK: <3 files, <1hr, no architecture changes, low risk
-  BIGGER: anything else
-  Output: { decision: "quick"|"bigger", rationale: string }"""
-
-# ============================================================================
-# Main Flow (streamlined)
-# ============================================================================
-
-# Phase 1: Execute and observe (single agent, early exit on error)
-let exec = http.post("{API_URL}/run", { program: TEST_PROGRAM, token: auth_token })
-
-let observation = session: observer
-  prompt: """Connect to WebSocket: {exec.wsUrl}&token={auth_token}
-  Send: {"type":"execute","program":{TEST_PROGRAM}}
-
-  Watch the stream. If you see a BLOCKING ERROR (hung >10s, repeated failures,
-  stopped environment), signal immediately with blocking_error: true.
-
-  Otherwise observe until completion and summarize UX."""
-  timeout: 120s
-  early_exit: **blocking_error detected**
-
-# Phase 2: Handle result
-if observation.blocking_error:
-
-  # Auto-investigate (no user prompt - if there's an error, we investigate)
-  let diagnosis = session: investigator
-    prompt: """Investigate this blocking error:
-
-    ERROR: {observation.error_summary}
-    OBSERVATIONS: {observation.observations}
-    EXEC_INFO: {exec}
-
-    Search code, check logs, verify your diagnosis before outputting."""
-    context: { observation, exec }
-
-  # Skip if low confidence (needs human)
-  if diagnosis.confidence == "low":
-    output { status: "needs_human", diagnosis }
-
-  # Auto-triage
-  let triage_result = session: triage
-    prompt: """Triage: {diagnosis}"""
-    context: diagnosis
-
-  if triage_result.decision == "bigger":
-    # Bigger changes need human oversight
-    output { status: "needs_planning", diagnosis, triage: triage_result }
-
-  # Quick fix: implement + test + deploy in one flow
-  let fix = session: fixer
-    prompt: """Fix this issue:
-
-    DIAGNOSIS: {diagnosis}
-    APPROACH: {diagnosis.fix_approach}
-
-    Implement, test, self-review, commit."""
-    context: diagnosis
-
-  if not fix.tests_pass:
-    output { status: "fix_failed", diagnosis, fix }
-
-  # Deploy (auto if tests pass)
-  let deploy = session "Deploy"
-    prompt: """Deploy per docs/DEPLOYMENT.md. Verify health endpoint."""
-    retry: 2
-
-  # Quick smoke test
-  let smoke = http.get("{API_URL}/health")
-
-  output {
-    status: smoke.status == "ok" ? "fixed" : "deploy_failed",
-    diagnosis,
-    fix,
-    deploy
-  }
-
-else:
-  # No blocking error - just output UX feedback
-  output { status: "ok", ux_feedback: observation }

package/extensions/open-prose/skills/prose/examples/46-workflow-crystallizer.prose

@@ -1,225 +0,0 @@
-# Workflow Crystallizer v2
-# Observes a conversation thread, extracts the workflow pattern, crystallizes into .prose
-#
-# Key design decisions:
-# - Author fetches latest prose.md spec + patterns/antipatterns from GitHub
-# - Single self-verifying author session (Design+Author+Overseer consolidated)
-# - Single user checkpoint (scope + placement combined)
-# - Scoper uses Sonnet (analytical work, not creative)
-# - Parallel: observation + research, collision + scope options
-
-input thread: "The conversation thread to analyze"
-input hint: "Optional: What aspect to focus on"
-
-# Always fetch latest guidance from source of truth
-const PROSE_SPEC_URL = "https://raw.githubusercontent.com/openprose/prose/refs/heads/main/skills/open-prose/prose.md"
-const PATTERNS_URL = "https://raw.githubusercontent.com/openprose/prose/refs/heads/main/skills/open-prose/guidance/patterns.md"
-const ANTIPATTERNS_URL = "https://raw.githubusercontent.com/openprose/prose/refs/heads/main/skills/open-prose/guidance/antipatterns.md"
-
-agent observer:
-  model: opus
-  prompt: """
-    Identify implicit workflows in conversation threads.
-    Look for: repeated patterns, multi-step processes, decision points,
-    parallelization opportunities, validations performed.
-    Be specific - quote actions from the thread.
-  """
-
-agent researcher:
-  model: sonnet
-  prompt: "Research codebases thoroughly. Report what exists and patterns used."
-  permissions:
-    read: ["**/*.prose", "**/*.md"]
-
-agent scoper:
-  model: sonnet
-  prompt: """
-    Determine the right abstraction level for workflows.
-    Too specific = only works for one case
-    Too general = loses essence, becomes vague
-    Find the sweet spot: capture the pattern, parameterize the variables.
-  """
-
-agent author:
-  model: opus
-  prompt: """
-    Write idiomatic OpenProse. Follow existing example patterns.
-    Prefer explicit over clever. Use agents for distinct roles.
-    Use parallel for independent tasks. Use try/catch for reversible operations.
-  """
-  permissions:
-    write: ["**/*.prose", "**/*.md"]
-
-agent compiler:
-  model: sonnet
-  prompt: "Validate OpenProse syntax. Report specific errors with line numbers."
-  permissions:
-    bash: allow
-
-# ============================================================
-# Phase 1: Observe and Research (parallel)
-# ============================================================
-
-parallel:
-  raw_observation = session: observer
-    prompt: """
-      Analyze this conversation thread. Identify:
-      1. What manual process was executed?
-      2. What were the distinct steps?
-      3. What decisions were made?
-      4. What could have been parallelized?
-      5. What validations were performed?
-      6. What artifacts were created?
-      Be concrete. Quote specific actions.
-    """
-    context: { thread, hint }
-
-  existing_examples = session: researcher
-    prompt: "List all .prose examples with one-line summaries"
-    context: "skills/open-prose/examples/"
-
-  existing_ops = session: researcher
-    prompt: "What operational .prose files already exist?"
-    context: "OPERATIONS.prose.md"
-
-  patterns_used = session: researcher
-    prompt: "What patterns does this codebase favor?"
-    context: "skills/open-prose/examples/*.prose"
-
-# ============================================================
-# Phase 2: Scope (parallel analysis, then synthesis)
-# ============================================================
-
-parallel:
-  collision_check = session: scoper
-    prompt: """
-      Does the observed workflow overlap with existing examples?
-      If yes: how different? What unique value would a new file add?
-      If no: what category does it belong to?
-    """
-    context: { raw_observation, existing_examples, existing_ops }
-
-  scope_options_raw = session: scoper
-    prompt: """
-      Propose 3 scoping options:
-      1. NARROW: Specific to exactly what happened (precise but may not generalize)
-      2. MEDIUM: Captures pattern with key parameters (reusable, clear)
-      3. BROAD: Abstract template (widely applicable but may lose details)
-      For each: describe inputs, agents, key phases.
-    """
-    context: { raw_observation, patterns_used }
-
-let scope_options = session: scoper
-  prompt: "Refine scope options considering collision analysis"
-  context: { scope_options_raw, collision_check }
-
-let placement_suggestion = session: scoper
-  prompt: """
-    Where should this file live?
-    1. examples/XX-name.prose - If reusable pattern (determine next number)
-    2. Custom location - If project-specific
-    Is this operational (used to run this project)? Note for OPERATIONS.prose.md
-  """
-  context: { raw_observation, existing_examples, existing_ops }
-
-# ============================================================
-# Phase 3: User Decision (single checkpoint)
-# ============================================================
-
-input user_decision: """
-  OBSERVED WORKFLOW:
-  {raw_observation}
-
-  COLLISION CHECK:
-  {collision_check}
-
-  SCOPE OPTIONS:
-  {scope_options}
-
-  PLACEMENT RECOMMENDATION:
-  {placement_suggestion}
-
-  YOUR DECISIONS:
-  1. Which scope? (1/2/3 or describe custom)
-  2. Confirm placement or specify different location:
-"""
-
-let final_decisions = session: scoper
-  prompt: "Parse user's scope choice and placement confirmation into structured form"
-  context: { scope_options, placement_suggestion, user_decision }
-
-# ============================================================
-# Phase 4: Author with Self-Verification
-# ============================================================
-
-let draft = session: author
-  prompt: """
-    Design and write the complete .prose file.
-
-    IMPORTANT: First fetch and read the guidance documents:
-    - prose.md spec: {PROSE_SPEC_URL}
-    - patterns.md: {PATTERNS_URL}
-    - antipatterns.md: {ANTIPATTERNS_URL}
-
-    Then:
-    1. DESIGN: Plan inputs, agents, phases, parallelism, error handling
-    2. WRITE: Complete .prose following the spec and patterns
-    3. SELF-REVIEW: Check against antipatterns and remove cruft:
-       - Remove sessions that just run single commands
-       - Remove over-abstracted agents that don't add value
-       - Remove comments that restate what code does
-       - Remove unnecessary variables and single-item parallel blocks
-       - Keep: clear agent roles, meaningful parallelism, genuine error handling
-
-    Include header comment explaining what it does.
-    Output only the final, clean version.
-  """
-  context: { final_decisions, existing_examples }
-  permissions:
-    network: [PROSE_SPEC_URL, PATTERNS_URL, ANTIPATTERNS_URL]
-
-# ============================================================
-# Phase 5: Compile with Bounded Retry
-# ============================================================
-
-let current = draft
-loop until **compilation succeeds** (max: 3):
-  let result = session: compiler
-    prompt: """Validate this .prose file against the spec.
-    Fetch spec from: {PROSE_SPEC_URL}
-    Report SUCCESS or specific errors with line numbers."""
-    context: current
-    permissions:
-      network: [PROSE_SPEC_URL]
-
-  if **compilation has errors**:
-    current = session: author
-      prompt: "Fix these syntax errors, return corrected version"
-      context: { current, result }
-      permissions:
-        network: [PROSE_SPEC_URL]
-
-# ============================================================
-# Phase 6: Write All Files
-# ============================================================
-
-let written = session: author
-  prompt: """
-    Write the .prose file and update indices:
-    1. Write .prose to confirmed location
-    2. If this is an example, add entry to examples/README.md
-    3. If this is operational, add entry to OPERATIONS.prose.md
-
-    Return: { file_path, readme_updated: bool, ops_updated: bool }
-  """
-  context: { current, final_decisions, existing_examples, existing_ops }
-
-# ============================================================
-# Output
-# ============================================================
-
-output crystallized = {
-  observation: raw_observation,
-  decisions: final_decisions,
-  file: written
-}