@hera-al/server 1.6.1

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

@@ -0,0 +1,148 @@
+# /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/bundled/open-prose/skills/prose/examples/46-workflow-crystallizer.prose

@@ -0,0 +1,225 @@
+# 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
+}