@hera-al/server 1.6.1

package/bundled/open-prose/skills/prose/examples/48-habit-miner.prose

@@ -0,0 +1,445 @@
+# Habit Miner
+# Excavates your AI session history to find recurring workflows worth automating
+# Scans .claude, .opencode, .cursor, etc. — discovers patterns, writes .prose programs
+#
+# BACKEND: Run with sqlite+ or postgres for incremental processing across runs
+#   prose run 48-habit-miner.prose --backend sqlite+
+#
+# KEY VM FEATURES USED:
+# - persist: true on miner — remembers patterns across runs, watches them mature
+# - resume: — incremental processing, only analyzes new logs since last run
+# - recursive blocks — handles arbitrarily large log corpora
+# - reference-based context — agents read from storage, not everything in memory
+
+input mode: "Mode: 'full' (analyze everything), 'incremental' (new logs only), 'check' (see what's new)"
+input min_frequency: "Minimum times a pattern must appear to qualify (default: 3)"
+input focus: "Optional: filter to specific area (e.g., 'git', 'testing', 'refactoring')"
+
+# ============================================================
+# Agents
+# ============================================================
+
+agent scout:
+  model: sonnet
+  prompt: """
+    You discover AI assistant log files on the user's system.
+
+    Check common locations:
+    - ~/.claude/ (Claude Code)
+    - ~/.opencode/ (OpenCode)
+    - ~/.cursor/ (Cursor)
+    - ~/.continue/ (Continue)
+    - ~/.aider/ (Aider)
+    - ~/.copilot/ (GitHub Copilot)
+    - ~/.codeium/ (Codeium)
+    - ~/.tabnine/ (Tabnine)
+    - ~/.config/claude-code/
+    - ~/.config/github-copilot/
+    - ~/.local/share/*/
+
+    For each location found, report:
+    - Path
+    - Log format (jsonl, sqlite, json, etc.)
+    - Approximate size
+    - Number of sessions/files
+    - Date range (oldest to newest)
+    - NEW since last scan (if incremental)
+
+    Be thorough but respect permissions. Don't read content yet, just inventory.
+  """
+  permissions:
+    bash: allow
+    read: ["~/.claude/**", "~/.opencode/**", "~/.cursor/**", "~/.continue/**",
+           "~/.aider/**", "~/.copilot/**", "~/.codeium/**", "~/.tabnine/**",
+           "~/.config/**", "~/.local/share/**"]
+
+agent parser:
+  model: sonnet
+  prompt: """
+    You parse AI assistant log files into normalized conversation format.
+
+    Handle formats:
+    - JSONL: one JSON object per line (Claude Code, many others)
+    - SQLite: query conversation tables
+    - JSON: array of messages or nested structure
+    - Markdown: conversation exports
+
+    Extract for each session:
+    - Session ID / timestamp
+    - User messages (the requests)
+    - Assistant actions (tools used, files modified)
+    - Outcome (success/failure indicators)
+
+    Normalize to common schema regardless of source format.
+    Track file modification times for incremental processing.
+  """
+  permissions:
+    bash: allow
+    read: ["~/.claude/**", "~/.opencode/**", "~/.cursor/**", "~/.continue/**",
+           "~/.aider/**", "~/.copilot/**", "~/.codeium/**", "~/.tabnine/**"]
+
+agent miner:
+  model: opus
+  persist: true  # <-- KEY: Remembers patterns across runs
+  prompt: """
+    You find and track patterns in conversation histories over time.
+
+    Your memory contains patterns from previous runs. Each pattern has:
+    - name: descriptive identifier
+    - maturity: emerging (3-5 hits) → established (6-15) → proven (16+)
+    - examples: representative instances
+    - last_seen: when pattern last appeared
+    - trend: growing / stable / declining
+
+    On each run:
+    1. Load your memory of known patterns
+    2. Process new sessions
+    3. Update pattern frequencies and maturity
+    4. Identify NEW emerging patterns
+    5. Note patterns that are declining (not seen recently)
+
+    Patterns MATURE over time. Don't rush to automate emerging patterns.
+    Wait until they're established before recommending automation.
+  """
+
+agent qualifier:
+  model: opus
+  prompt: """
+    You determine which patterns are ready for automation.
+
+    Consider MATURITY (from miner's memory):
+    - emerging: Too early. Note it, but don't automate yet.
+    - established: Good candidate. Enough data to generalize.
+    - proven: Strong candidate. Battle-tested pattern.
+
+    Also consider:
+    - COMPLEXITY: Multi-step, not trivial
+    - CONSISTENCY: Similar enough across instances
+    - AUTOMATABLE: Not too context-dependent
+    - VALUE: Would save meaningful time/effort
+
+    Reject patterns that are:
+    - Still emerging (wait for more data)
+    - Too simple (just run a single command)
+    - Too variable (every instance is different)
+  """
+
+agent author:
+  model: opus
+  prompt: """
+    You write .prose programs from mature workflow patterns.
+
+    For each qualified pattern:
+    - Identify the inputs (what varies between instances)
+    - Identify the constants (what's always the same)
+    - Design appropriate agents for the workflow
+    - Structure phases logically
+    - Add error handling where needed
+    - Include user checkpoints at decision points
+
+    Write idiomatic OpenProse. Follow existing example patterns.
+    Reference the pattern's maturity level in a header comment.
+  """
+  permissions:
+    write: ["**/*.prose"]
+
+agent organizer:
+  model: sonnet
+  prompt: """
+    You organize generated .prose programs into a coherent collection.
+
+    Tasks:
+    - Group related programs by domain (git, testing, docs, etc.)
+    - Suggest directory structure
+    - Create an index/README
+    - Identify programs that could share blocks or agents
+    - Note potential compositions (program A often followed by B)
+  """
+  permissions:
+    write: ["**/*.md", "**/*.prose"]
+
+# ============================================================
+# Recursive block for processing large log corpora
+# ============================================================
+
+block process_logs(sources, depth):
+  # Base case: small enough to process directly
+  if **fewer than 50 sessions** or depth <= 0:
+    output sources | pmap:
+      session: parser
+        prompt: "Parse these logs into normalized format"
+        context: item
+
+  # Recursive case: chunk and fan out
+  let chunks = session "Split sources into ~25 session batches"
+    context: sources
+
+  let results = []
+  parallel for chunk in chunks:
+    let chunk_result = do process_logs(chunk, depth - 1)
+    results = results + chunk_result
+
+  output results
+
+# ============================================================
+# Phase 0: Discovery
+# ============================================================
+
+let inventory = session: scout
+  prompt: """
+    Scan the system for AI assistant log files.
+    Mode: {mode}
+
+    Check all common locations. For each found, report:
+    - Full path
+    - Format detected
+    - Size (human readable)
+    - Session/file count
+    - Date range
+    - If incremental: how many NEW since last scan
+
+    Return a structured inventory.
+  """
+
+# For "check" mode, just show what's available and exit
+if **mode is check**:
+  output result = {
+    status: "check-complete",
+    inventory: inventory,
+    hint: "Run with mode:'incremental' to process new logs, or mode:'full' for everything"
+  }
+
+input source_selection: """
+  ## AI Assistant Logs Found
+
+  {inventory}
+
+  ---
+
+  Mode: {mode}
+
+  Select which sources to analyze:
+  - List the paths you want included
+  - Or say "all" to analyze everything found
+  - Or say "none" to cancel
+"""
+
+if **user selected none or wants to cancel**:
+  output result = {
+    status: "cancelled",
+    inventory: inventory
+  }
+  throw "User cancelled - no sources selected"
+
+let selected_sources = session: scout
+  prompt: "Parse user's selection into a list of paths to analyze"
+  context: { inventory, source_selection, mode }
+
+# ============================================================
+# Phase 1: Parsing (with recursive chunking for scale)
+# ============================================================
+
+let parsed_sessions = do process_logs(selected_sources, 3)
+
+let session_count = session "Count total sessions parsed"
+  context: parsed_sessions
+
+# ============================================================
+# Phase 2: Mining (with persistent memory)
+# ============================================================
+
+# Resume the miner with its accumulated pattern knowledge
+let pattern_update = resume: miner
+  prompt: """
+    Process these new sessions against your pattern memory.
+
+    1. Load your known patterns (with maturity levels)
+    2. Match new sessions to existing patterns OR identify new ones
+    3. Update frequencies, maturity levels, last_seen dates
+    4. Report:
+       - Patterns that MATURED (crossed a threshold)
+       - NEW patterns emerging
+       - Patterns DECLINING (not seen in a while)
+       - Current state of all tracked patterns
+
+    Focus area (if specified): {focus}
+  """
+  context: { parsed_sessions, focus }
+
+# ============================================================
+# Phase 3: Qualification
+# ============================================================
+
+let qualified = session: qualifier
+  prompt: """
+    Review the miner's pattern update. Identify patterns ready for automation.
+
+    Minimum frequency threshold: {min_frequency}
+
+    PRIORITIZE:
+    1. Patterns that just reached "established" or "proven" maturity
+    2. Proven patterns not yet automated
+    3. High-value patterns even if just established
+
+    SKIP:
+    - Emerging patterns (let them mature)
+    - Already-automated patterns (unless significantly evolved)
+    - Declining patterns (might be obsolete)
+
+    Return ranked list with reasoning.
+  """
+  context: { pattern_update, min_frequency }
+
+if **no patterns ready for automation**:
+  output result = {
+    status: "no-new-automations",
+    sessions_analyzed: session_count,
+    pattern_update: pattern_update,
+    message: "Patterns are still maturing. Run again later."
+  }
+
+# ============================================================
+# Phase 4: User Checkpoint
+# ============================================================
+
+input pattern_selection: """
+  ## Patterns Ready for Automation
+
+  Analyzed {session_count} sessions.
+
+  Pattern Update:
+  {pattern_update}
+
+  Ready for automation:
+  {qualified}
+
+  ---
+
+  Which patterns should I write .prose programs for?
+  - List by name or number
+  - Or say "all" for everything qualified
+  - Or say "none" to let patterns mature further
+
+  You can also refine any pattern description before I write code.
+"""
+
+if **user wants to wait for more maturity**:
+  output result = {
+    status: "deferred",
+    sessions_analyzed: session_count,
+    pattern_update: pattern_update,
+    qualified: qualified
+  }
+
+let patterns_to_automate = session: qualifier
+  prompt: "Parse user selection into final list of patterns to automate"
+  context: { qualified, pattern_selection }
+
+# ============================================================
+# Phase 5: Program Generation
+# ============================================================
+
+let programs = patterns_to_automate | map:
+  session: author
+    prompt: """
+      Write a .prose program for this pattern.
+
+      Pattern maturity: {pattern.maturity}
+      Times observed: {pattern.frequency}
+      Representative examples: {pattern.examples}
+
+      The program should:
+      - Parameterize what varies between instances
+      - Hardcode what's always the same
+      - Use appropriate agents for distinct roles
+      - Include error handling
+      - Add user checkpoints at decision points
+
+      Include a header comment noting:
+      - Pattern maturity level
+      - Number of observations it's based on
+      - Date generated
+    """
+    context: item
+
+# ============================================================
+# Phase 6: Organization
+# ============================================================
+
+let organized = session: organizer
+  prompt: """
+    Organize the generated programs.
+
+    Tasks:
+    1. Group by domain (git, testing, docs, refactoring, etc.)
+    2. Suggest directory structure
+    3. Create an index README with:
+       - Program name and one-line description
+       - Pattern maturity (established/proven)
+       - When to use it
+       - Example invocation
+    4. Identify shared patterns that could be extracted
+    5. Note programs that often chain together
+  """
+  context: programs
+
+# ============================================================
+# Phase 7: Output Location
+# ============================================================
+
+input output_location: """
+  ## Generated Programs
+
+  {organized}
+
+  ---
+
+  Where should I write these programs?
+
+  Options:
+  - A directory path (e.g., ~/my-workflows/)
+  - "preview" to just show them without writing
+"""
+
+if **user wants preview only**:
+  output result = {
+    status: "preview",
+    sessions_analyzed: session_count,
+    pattern_update: pattern_update,
+    qualified: qualified,
+    programs: programs,
+    organization: organized
+  }
+
+let written = session: organizer
+  prompt: "Write all programs to the specified location with proper structure"
+  context: { programs, organized, output_location }
+  permissions:
+    write: ["**/*.prose", "**/*.md"]
+
+# ============================================================
+# Output
+# ============================================================
+
+output result = {
+  status: "complete",
+
+  # Discovery
+  sources_scanned: inventory,
+  sources_analyzed: selected_sources,
+
+  # Analysis
+  sessions_analyzed: session_count,
+  pattern_update: pattern_update,
+
+  # Qualification
+  patterns_qualified: qualified,
+  patterns_automated: patterns_to_automate,
+
+  # Generation
+  programs_written: written,
+  organization: organized,
+
+  # For next run
+  next_step: "Run again with mode:'incremental' to process new logs and mature patterns"
+}

package/bundled/open-prose/skills/prose/examples/49-prose-run-retrospective.prose

@@ -0,0 +1,210 @@
+# Prose Run Retrospective
+# Analyzes a completed run to extract learnings and produce an improved version.
+
+input run_id: "Path to the completed run directory"
+input prose_path: "Path to the .prose file that was executed"
+
+const PATTERNS_PATH = "prose/skills/open-prose/guidance/patterns.md"
+const ANTIPATTERNS_PATH = "prose/skills/open-prose/guidance/antipatterns.md"
+
+agent analyst:
+  model: sonnet
+  prompt: """You analyze OpenProse run artifacts to identify issues and classify outcomes.
+Checklist-style evaluation: read systematically, identify issues with evidence, classify outcomes.
+
+Classification criteria:
+- success: Program completed, outputs are correct
+- transient-error: External failure (API timeout, network) - not a program flaw
+- architectural-issue: Structural problem in .prose design
+- antipattern-instance: Program exhibits a known antipattern"""
+
+agent extractor:
+  model: opus
+  prompt: """You extract generalizable patterns from specific experiences.
+Deep reasoning: identify abstract success/failure factors, distinguish situational from generalizable,
+reason about trade-offs, synthesize observations into principles.
+Be conservative - avoid over-generalizing from single instances."""
+
+parallel:
+  run_artifacts = session: analyst
+    prompt: """Read and catalog all artifacts in {run_id}.
+Look for bindings/*.md, state.md, outputs/, error files.
+Summarize what exists and its content."""
+    context:
+      file: "{run_id}/state.md"
+
+  source_analysis = session: analyst
+    prompt: """Parse the .prose file structure at {prose_path}.
+Identify: inputs, agents and models, phase structure, error handling, decision points, outputs."""
+    context:
+      file: prose_path
+
+let classification = session: analyst
+  prompt: """Classify the run outcome.
+
+Run artifacts: {run_artifacts}
+Source structure: {source_analysis}
+
+Determine:
+- outcome_type: success | transient-error | architectural-issue | antipattern-instance
+- confidence: high | medium | low
+- evidence: Specific quotes supporting classification
+- summary: One-line description"""
+
+if **classification indicates transient error (API timeout, network failure) not caused by program**:
+  output result = {
+    status: "transient-error",
+    classification: classification,
+    recommendation: "Re-run the program; no structural changes needed"
+  }
+
+let improvements = session: analyst
+  prompt: """Identify improvement opportunities in the .prose file.
+
+Classification: {classification}
+Source structure: {source_analysis}
+
+For each improvement:
+- What: Specific change
+- Why: Problem it solves
+- Priority: high | medium | low
+
+Focus on structural improvements: model selection, parallelization, error handling, context management."""
+  context:
+    file: PATTERNS_PATH
+    file: ANTIPATTERNS_PATH
+
+let pattern_candidates = session: extractor
+  prompt: """Extract generalizable patterns from this run.
+
+Classification: {classification}
+Improvements: {improvements}
+
+For genuinely novel patterns/antipatterns (not already in guidance):
+- Name (kebab-case)
+- Category
+- Description
+- Example code
+- Rationale
+
+Be conservative. Only propose broadly applicable patterns supported by evidence."""
+  context:
+    file: PATTERNS_PATH
+    file: ANTIPATTERNS_PATH
+
+let improved_prose = session: extractor
+  prompt: """Write an improved version of the .prose file.
+
+Source structure: {source_analysis}
+Improvements: {improvements}
+
+Write the complete improved file:
+- Keep same purpose and inputs
+- Apply identified improvements
+- Follow patterns from guidance
+- Add brief header comment on what changed"""
+  context:
+    file: prose_path
+    file: PATTERNS_PATH
+
+if **pattern_candidates contains no novel patterns worth documenting**:
+  let new_patterns = { count: 0, entries: [] }
+  let new_antipatterns = { count: 0, entries: [] }
+else:
+  parallel:
+    new_patterns = session: analyst
+      prompt: """Draft new pattern entries for patterns.md.
+
+Candidates: {pattern_candidates}
+
+For genuinely novel patterns, follow exact format from patterns.md.
+Output: count, names, and full markdown entries."""
+      context:
+        file: PATTERNS_PATH
+
+    new_antipatterns = session: analyst
+      prompt: """Draft new antipattern entries for antipatterns.md.
+
+Candidates: {pattern_candidates}
+
+For genuinely novel antipatterns, follow exact format from antipatterns.md.
+Output: count, names, and full markdown entries."""
+      context:
+        file: ANTIPATTERNS_PATH
+
+input approval_response: """
+## Retrospective Complete
+
+**Classification**: {classification.outcome_type} ({classification.confidence})
+**Summary**: {classification.summary}
+
+**Improvements**: {improvements}
+
+**New Patterns**: {new_patterns.count} proposed
+**New Antipatterns**: {new_antipatterns.count} proposed
+
+Approve: `all` | `prose-only` | `docs-only` | `none`
+"""
+
+choice **user approval**:
+
+  option "all":
+    session "Write improved prose"
+      prompt: "Write to {run_id}/outputs/improved.prose:\n{improved_prose}"
+      permissions:
+        write: ["{run_id}/outputs/*"]
+
+    if **new_patterns.count > 0**:
+      session "Update patterns.md"
+        prompt: "Append to {PATTERNS_PATH}:\n{new_patterns.entries}"
+        permissions:
+          write: [PATTERNS_PATH]
+
+    if **new_antipatterns.count > 0**:
+      session "Update antipatterns.md"
+        prompt: "Append to {ANTIPATTERNS_PATH}:\n{new_antipatterns.entries}"
+        permissions:
+          write: [ANTIPATTERNS_PATH]
+
+    output result = {
+      status: classification.outcome_type,
+      improved_prose_path: "{run_id}/outputs/improved.prose",
+      patterns_added: new_patterns.names,
+      antipatterns_added: new_antipatterns.names
+    }
+
+  option "prose-only":
+    session "Write improved prose"
+      prompt: "Write to {run_id}/outputs/improved.prose:\n{improved_prose}"
+      permissions:
+        write: ["{run_id}/outputs/*"]
+
+    output result = {
+      status: classification.outcome_type,
+      improved_prose_path: "{run_id}/outputs/improved.prose"
+    }
+
+  option "docs-only":
+    if **new_patterns.count > 0**:
+      session "Update patterns.md"
+        prompt: "Append to {PATTERNS_PATH}:\n{new_patterns.entries}"
+        permissions:
+          write: [PATTERNS_PATH]
+
+    if **new_antipatterns.count > 0**:
+      session "Update antipatterns.md"
+        prompt: "Append to {ANTIPATTERNS_PATH}:\n{new_antipatterns.entries}"
+        permissions:
+          write: [ANTIPATTERNS_PATH]
+
+    output result = {
+      status: classification.outcome_type,
+      patterns_added: new_patterns.names,
+      antipatterns_added: new_antipatterns.names
+    }
+
+  option "none":
+    output result = {
+      status: "review-complete",
+      learnings: pattern_candidates
+    }