loudmouth-ai 0.1.0 → 0.2.0

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

@@ -1,174 +0,0 @@
-# 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/extensions/open-prose/skills/prose/lib/error-forensics.prose

@@ -1,250 +0,0 @@
-# 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/extensions/open-prose/skills/prose/lib/inspector.prose

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