@hera-al/server 1.6.1

package/bundled/open-prose/skills/prose/lib/cost-analyzer.prose

@@ -0,0 +1,174 @@
+# Cost Analyzer
+# Analyzes runs for token usage and cost patterns
+#
+# Usage:
+#   prose run @openprose/lib/cost-analyzer
+#
+# Inputs:
+#   run_path: Path to run to analyze, or "recent" for latest runs
+#   scope: single | compare | trend
+#
+# Outputs:
+#   - Token usage breakdown by agent/phase
+#   - Model tier efficiency analysis
+#   - Cost hotspots
+#   - Optimization recommendations
+
+input run_path: "Path to run, or 'recent' for latest runs in .prose/runs/"
+input scope: "Scope: single (one run) | compare (multiple runs) | trend (over time)"
+
+# ============================================================
+# Agents
+# ============================================================
+
+agent collector:
+  model: sonnet
+  prompt: """
+    You collect and structure cost/token data from .prose runs.
+
+    Extract from run artifacts:
+    - Model used per session (haiku/sonnet/opus)
+    - Approximate token counts (estimate from content length)
+    - Session count per agent
+    - Parallel vs sequential execution
+  """
+
+agent analyzer:
+  model: opus
+  prompt: """
+    You analyze cost patterns and identify optimization opportunities.
+
+    Consider:
+    - Model tier appropriateness (is opus needed, or would sonnet suffice?)
+    - Token efficiency (are contexts bloated?)
+    - Parallelization (could sequential steps run in parallel?)
+    - Caching opportunities (repeated computations?)
+  """
+
+agent tracker:
+  model: haiku
+  persist: user
+  prompt: """
+    You track cost metrics across runs for trend analysis.
+    Store compactly: run_id, program, total_cost_estimate, breakdown.
+  """
+
+# ============================================================
+# Phase 1: Collect Run Data
+# ============================================================
+
+let runs_to_analyze = session: collector
+  prompt: """
+    Find runs to analyze.
+
+    Input: {run_path}
+    Scope: {scope}
+
+    If run_path is a specific path, use that run.
+    If run_path is "recent", find the latest 5-10 runs in .prose/runs/
+
+    For scope=compare, find runs of the same program.
+    For scope=trend, find runs over time.
+
+    Return: list of run paths to analyze
+  """
+
+let run_data = runs_to_analyze | pmap:
+  session: collector
+    prompt: """
+      Extract cost data from run: {item}
+
+      Read state.md and bindings to determine:
+      1. Program name
+      2. Each session spawned:
+         - Agent name (or "anonymous")
+         - Model tier
+         - Estimated input tokens (context size)
+         - Estimated output tokens (binding size)
+      3. Parallel blocks (how many concurrent sessions)
+      4. Total session count
+
+      Estimate costs using rough rates:
+      - haiku: $0.25 / 1M input, $1.25 / 1M output
+      - sonnet: $3 / 1M input, $15 / 1M output
+      - opus: $15 / 1M input, $75 / 1M output
+
+      Return structured JSON.
+    """
+    context: item
+
+# ============================================================
+# Phase 2: Analyze
+# ============================================================
+
+let analysis = session: analyzer
+  prompt: """
+    Analyze cost patterns across these runs.
+
+    Data: {run_data}
+    Scope: {scope}
+
+    For single run:
+    - Break down cost by agent and phase
+    - Identify the most expensive operations
+    - Flag potential inefficiencies
+
+    For compare:
+    - Show cost differences between runs
+    - Identify which changes affected cost
+    - Note if cost increased/decreased
+
+    For trend:
+    - Show cost over time
+    - Identify if costs are stable, growing, or improving
+    - Flag anomalies
+
+    Always include:
+    - Model tier efficiency (are expensive models used appropriately?)
+    - Context efficiency (are contexts lean or bloated?)
+    - Specific optimization recommendations
+
+    Return structured JSON with:
+    {
+      "summary": { total_cost, session_count, by_model: {...} },
+      "hotspots": [ { agent, cost, percent, issue } ],
+      "recommendations": [ { priority, description, estimated_savings } ],
+      "details": { ... }
+    }
+  """
+  context: run_data
+
+# ============================================================
+# Phase 3: Track for Trends
+# ============================================================
+
+resume: tracker
+  prompt: """
+    Record this cost analysis for future trend tracking.
+
+    {analysis.summary}
+
+    Add to your historical record.
+  """
+  context: analysis
+
+# ============================================================
+# Output
+# ============================================================
+
+output report = session "Format report"
+  prompt: """
+    Format the cost analysis as a readable report.
+
+    Analysis: {analysis}
+
+    Include:
+    1. Executive summary (total cost, key finding)
+    2. Cost breakdown table
+    3. Hotspots (where money goes)
+    4. Recommendations (prioritized)
+    5. If scope=trend, include trend chart (ascii or description)
+
+    Format as markdown.
+  """
+  context: analysis

package/bundled/open-prose/skills/prose/lib/error-forensics.prose

@@ -0,0 +1,250 @@
+# Error Forensics
+# Deep investigation of failed or problematic runs
+#
+# Usage:
+#   prose run @openprose/lib/error-forensics
+#
+# Inputs:
+#   run_path: Path to the failed/problematic run
+#   focus: Optional focus area (vm | program | context | external)
+#
+# Outputs:
+#   - Root cause analysis
+#   - Error classification
+#   - Fix recommendations
+#   - Prevention suggestions
+
+input run_path: "Path to the run to investigate"
+input focus: "Optional focus: vm | program | context | external (default: auto-detect)"
+
+# ============================================================
+# Agents
+# ============================================================
+
+agent investigator:
+  model: opus
+  prompt: """
+    You are a forensic investigator for failed .prose runs.
+
+    You methodically trace execution to find root causes:
+    - Read state.md for execution trace
+    - Check each binding for errors or unexpected content
+    - Look for patterns: where did things go wrong?
+    - Distinguish symptoms from causes
+  """
+
+agent classifier:
+  model: sonnet
+  prompt: """
+    You classify errors into actionable categories:
+
+    VM errors: The OpenProse VM itself misbehaved
+    - State management bugs
+    - Incorrect control flow
+    - Context passing failures
+
+    Program errors: The .prose program has issues
+    - Logic errors
+    - Missing error handling
+    - Bad agent prompts
+
+    Context errors: Context degradation or bloat
+    - Information lost between agents
+    - Context too large
+    - Wrong context passed
+
+    External errors: Outside factors
+    - Tool failures
+    - Network issues
+    - Resource limits
+  """
+
+agent fixer:
+  model: opus
+  prompt: """
+    You propose specific fixes for identified issues.
+    Be concrete: show the change, not just describe it.
+  """
+
+# ============================================================
+# Phase 1: Gather Evidence
+# ============================================================
+
+let evidence = session: investigator
+  prompt: """
+    Gather evidence from the failed run.
+
+    Run: {run_path}
+
+    Read and analyze:
+    1. state.md - What was the execution trace? Where did it stop?
+    2. bindings/ - Which bindings exist? Any with errors or empty?
+    3. program.prose - What was the program trying to do?
+    4. agents/ - Any agent memory files with clues?
+
+    Document:
+    - Last successful step
+    - First sign of trouble
+    - Error messages (if any)
+    - Unexpected states
+
+    Return structured evidence.
+  """
+
+# ============================================================
+# Phase 2: Trace Execution
+# ============================================================
+
+let trace = session: investigator
+  prompt: """
+    Trace execution step by step to find the failure point.
+
+    Evidence: {evidence}
+
+    Walk through the execution:
+    1. What was the program supposed to do at each step?
+    2. What actually happened (according to state.md)?
+    3. Where do expected and actual diverge?
+
+    For the divergence point:
+    - What was the input to that step?
+    - What was the output (or lack thereof)?
+    - What should have happened?
+
+    Return:
+    {
+      "failure_point": { step, statement, expected, actual },
+      "chain_of_events": [...],
+      "contributing_factors": [...]
+    }
+  """
+  context: evidence
+
+# ============================================================
+# Phase 3: Classify Error
+# ============================================================
+
+let classification = session: classifier
+  prompt: """
+    Classify this error.
+
+    Trace: {trace}
+    Evidence: {evidence}
+    Focus hint: {focus}
+
+    Determine:
+    - Primary category (vm | program | context | external)
+    - Subcategory (specific type within category)
+    - Severity (critical | major | minor)
+    - Reproducibility (always | sometimes | rare)
+
+    Return:
+    {
+      "category": "...",
+      "subcategory": "...",
+      "severity": "...",
+      "reproducibility": "...",
+      "confidence": "high" | "medium" | "low",
+      "reasoning": "..."
+    }
+  """
+  context: { trace, evidence }
+
+# ============================================================
+# Phase 4: Root Cause Analysis
+# ============================================================
+
+let root_cause = session: investigator
+  prompt: """
+    Determine the root cause (not just symptoms).
+
+    Trace: {trace}
+    Classification: {classification}
+
+    Ask "why" repeatedly until you reach the root:
+    - Why did this step fail?
+    - Why was that input malformed?
+    - Why did that agent produce that output?
+    - ...
+
+    The root cause is the earliest point where an intervention
+    would have prevented the failure.
+
+    Return:
+    {
+      "root_cause": "...",
+      "causal_chain": ["step 1", "led to step 2", "which caused failure"],
+      "root_cause_category": "vm" | "program" | "context" | "external"
+    }
+  """
+  context: { trace, classification }
+
+# ============================================================
+# Phase 5: Fix Recommendations
+# ============================================================
+
+let fixes = session: fixer
+  prompt: """
+    Propose fixes for this failure.
+
+    Root cause: {root_cause}
+    Classification: {classification}
+    Evidence: {evidence}
+
+    Provide:
+    1. Immediate fix (how to make this specific run work)
+    2. Permanent fix (how to prevent this class of error)
+    3. Detection (how to catch this earlier next time)
+
+    Be specific. If it's a code change, show the diff.
+    If it's a process change, describe the new process.
+
+    Return:
+    {
+      "immediate": { action, details },
+      "permanent": { action, details, files_to_change },
+      "detection": { action, details },
+      "prevention": "how to avoid this in future programs"
+    }
+  """
+  context: { root_cause, classification, evidence }
+
+# ============================================================
+# Output
+# ============================================================
+
+output report = session "Format report"
+  prompt: """
+    Format the forensic analysis as a report.
+
+    Evidence: {evidence}
+    Trace: {trace}
+    Classification: {classification}
+    Root cause: {root_cause}
+    Fixes: {fixes}
+
+    Structure:
+    1. Executive Summary
+       - What failed
+       - Why it failed (root cause)
+       - How to fix it
+
+    2. Timeline
+       - Execution trace with failure point highlighted
+
+    3. Root Cause Analysis
+       - Causal chain
+       - Classification
+
+    4. Recommendations
+       - Immediate fix
+       - Permanent fix
+       - Prevention
+
+    5. Technical Details
+       - Evidence gathered
+       - Files examined
+
+    Format as markdown.
+  """
+  context: { evidence, trace, classification, root_cause, fixes }

package/bundled/open-prose/skills/prose/lib/inspector.prose

@@ -0,0 +1,196 @@
+# Post-Run Inspector
+# Analyzes completed .prose runs for runtime fidelity and task effectiveness
+#
+# Usage:
+#   prose run @openprose/lib/inspector
+#
+# Inputs:
+#   run_path: Path to the run to inspect (e.g., .prose/runs/20260119-100000-abc123)
+#   depth: light | deep
+#   target: vm | task | all
+#
+# Compounding: Each inspection builds on prior inspections via persistent index agent.
+# The index agent uses `persist: user` so inspection history spans all projects.
+
+input run_path: "Path to the run to inspect (e.g., .prose/runs/20260119-100000-abc123)"
+input depth: "Inspection depth: light or deep"
+input target: "Evaluation target: vm, task, or all"
+
+# ============================================================
+# Agents
+# ============================================================
+
+agent index:
+  model: haiku
+  persist: user
+  prompt: """
+    You maintain the inspection registry across all projects.
+    Track: target_run_id, depth, target, timestamp, verdict.
+    Return JSON when queried. Store compactly.
+  """
+
+agent extractor:
+  model: sonnet
+  prompt: """
+    You extract structured data from .prose run artifacts.
+    Read state.md, bindings/, and logs carefully.
+    Return clean JSON.
+  """
+
+agent evaluator:
+  model: opus
+  prompt: """
+    You evaluate .prose runs with intelligent judgment.
+    Rate 1-10 with specific rationale. Be concrete.
+  """
+
+agent synthesizer:
+  model: sonnet
+  prompt: """
+    You produce clear reports in requested formats.
+  """
+
+# ============================================================
+# Phase 0: Check Prior Work
+# ============================================================
+
+let prior = resume: index
+  prompt: """
+    Any prior inspections for: {run_path}?
+    Return JSON: { "inspections": [...], "has_light": bool, "has_deep": bool }
+  """
+
+# ============================================================
+# Phase 1: Extraction
+# ============================================================
+
+let extraction = session: extractor
+  prompt: """
+    Extract from run at: {run_path}
+    Depth: {depth}
+    Prior work: {prior}
+
+    ALWAYS get:
+    - run_id (from path)
+    - completed (did state.md show completion?)
+    - error_count (failures in state.md)
+    - binding_names (list all bindings/)
+    - output_names (bindings with kind: output)
+
+    IF depth=deep AND no prior deep inspection:
+    - program_source (contents of program.prose)
+    - execution_summary (key statements from state.md)
+    - binding_previews (first 300 chars of each binding)
+
+    IF prior deep exists, skip deep extraction and note "using cached".
+
+    Return JSON.
+  """
+  context: prior
+
+# ============================================================
+# Phase 2: Evaluation
+# ============================================================
+
+let evaluation = session: evaluator
+  prompt: """
+    Evaluate this run.
+
+    Target: {target}
+    Depth: {depth}
+    Data: {extraction}
+    Prior findings: {prior}
+
+    FOR vm (if target=vm or all):
+    - completion (1-10): Clean finish?
+    - binding_integrity (1-10): Expected outputs exist with content?
+    - vm_verdict: pass/partial/fail
+    - vm_notes: 1-2 sentences
+
+    FOR task (if target=task or all):
+    - output_substance (1-10): Outputs look real, not empty/error?
+    - goal_alignment (1-10): Based on program name, does output fit?
+    - task_verdict: pass/partial/fail
+    - task_notes: 1-2 sentences
+
+    IF depth=deep, add:
+    - fidelity (1-10): Execution trace matches program structure?
+    - efficiency (1-10): Reasonable number of steps for the job?
+
+    Return JSON with all applicable fields.
+  """
+  context: extraction
+
+# ============================================================
+# Phase 3: Synthesis
+# ============================================================
+
+parallel:
+  verdict = session: synthesizer
+    prompt: """
+      Machine-readable verdict as JSON:
+      {
+        "run_id": "...",
+        "depth": "{depth}",
+        "target": "{target}",
+        "vm": { "verdict": "...", "scores": {...} },
+        "task": { "verdict": "...", "scores": {...} },
+        "flags": []
+      }
+
+      Data: {evaluation}
+    """
+    context: evaluation
+
+  diagram = session: synthesizer
+    prompt: """
+      Simple mermaid flowchart of the run.
+      Show: inputs -> key steps -> outputs.
+      Use execution_summary if available, else infer from bindings.
+      Output only the mermaid code.
+
+      Data: {extraction}
+    """
+    context: extraction
+
+  report = session: synthesizer
+    prompt: """
+      2-paragraph markdown summary:
+      1. What was inspected, key metrics
+      2. Findings and any recommendations
+
+      Data: {extraction}, {evaluation}
+    """
+    context: { extraction, evaluation }
+
+# ============================================================
+# Phase 4: Register
+# ============================================================
+
+resume: index
+  prompt: """
+    Register this inspection:
+    run_path: {run_path}
+    depth: {depth}
+    target: {target}
+    verdict: {verdict}
+
+    Update your memory with this entry.
+  """
+  context: verdict
+
+# ============================================================
+# Output
+# ============================================================
+
+output inspection = session: synthesizer
+  prompt: """
+    Combine into final output structure:
+
+    verdict_json: {verdict}
+    mermaid: {diagram}
+    summary: {report}
+
+    Return as JSON with these three fields.
+  """
+  context: { verdict, diagram, report }