@geravant/sinain 1.0.1

package/sinain-memory/playbook_curator.py

@@ -0,0 +1,225 @@
+#!/usr/bin/env python3
+"""Phase 3 Step 3: Playbook Curator — archive and update sinain-playbook.md.
+
+Archives current playbook, uses LLM to curate (add/prune/promote patterns),
+writes the updated playbook back. Respects the curate directive from feedback_analyzer.
+
+Usage:
+    python3 playbook_curator.py --memory-dir memory/ --session-summary "..." \
+        [--curate-directive normal] [--mining-findings "TEXT"]
+"""
+
+import argparse
+import json
+import shutil
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+from common import (
+    LLMError,
+    call_llm_with_fallback,
+    extract_json,
+    output_json,
+    read_effective_playbook,
+    read_playbook,
+    read_recent_logs,
+)
+
+SYSTEM_PROMPT = """\
+You are a playbook curator for a personal AI assistant (sinain).
+Your job: maintain a concise, high-quality playbook of patterns and observations.
+
+The playbook has these sections:
+1. Header comments (mining-index) — DO NOT modify these
+2. Patterns: "When [context], [approach] worked (score: X)" or failed patterns
+3. User preference observations
+4. Stale items with [since: YYYY-MM-DD] or [deferred: YYYY-MM-DD, reason: "..."] tags
+5. Footer comments (effectiveness) — DO NOT modify these (managed by plugin)
+
+Curate rules:
+- ADD new successful patterns from recent sessions
+- ADD failed patterns with reasons
+- ADD user preference observations (recurring topics, tools, rhythms)
+- PRUNE entries older than 7 days without reinforcement
+- PROMOTE patterns seen 3+ times from "observed" to "established"
+- Three Laws: (1) don't remove error-prevention patterns, (2) preserve high-scoring approaches, (3) then evolve
+- Keep under 50 lines — density over completeness
+- DEDUPLICATE: if multiple patterns describe the same concept (e.g., "idle standby" variants), merge them into ONE canonical pattern
+- Before adding: check if the pattern already exists in the Active Module Patterns section — do NOT duplicate module patterns into the base playbook
+
+Curate directive controls aggressiveness:
+- "aggressive_prune": effectiveness is low — remove weak/unverified patterns aggressively
+- "normal": balanced add/prune cycle
+- "stability": effectiveness is high — only add patterns with strong evidence (score > 0.5)
+- "insufficient_data": skip effectiveness adjustments, focus on gathering patterns
+
+Stale item rules:
+- New fixable patterns get [since: YYYY-MM-DD] tag
+- 48h without change → mandatory Phase 2 action (not your concern, just keep the tag)
+- After 3 actions without resolution → move to [deferred: YYYY-MM-DD, reason: "..."]
+- Max 5 deferred items; if adding 6th, prune oldest deferred
+
+Respond with ONLY a JSON object:
+{
+  "updatedPlaybook": "full text of updated playbook (body only, between header/footer comments)",
+  "changes": {
+    "added": ["pattern text", ...],
+    "pruned": ["pattern text", ...],
+    "promoted": ["pattern text", ...]
+  },
+  "staleItemActions": ["description of stale item handling", ...]
+}"""
+
+
+def archive_playbook(memory_dir: str) -> str | None:
+    """Archive current playbook to playbook-archive/. Returns archive path or None."""
+    src = Path(memory_dir) / "sinain-playbook.md"
+    if not src.exists():
+        return None
+
+    archive_dir = Path(memory_dir) / "playbook-archive"
+    archive_dir.mkdir(parents=True, exist_ok=True)
+
+    ts = datetime.now(timezone.utc).strftime("%Y-%m-%d-%H%M")
+    dest = archive_dir / f"sinain-playbook-{ts}.md"
+    shutil.copy2(src, dest)
+    return str(dest)
+
+
+def extract_header_footer(playbook: str) -> tuple[str, str, str]:
+    """Split playbook into (header_comments, body, footer_comments).
+
+    Header: lines starting with <!-- mining-index or other top comments
+    Footer: lines starting with <!-- effectiveness
+    Body: everything between
+    """
+    lines = playbook.splitlines()
+    header_lines = []
+    footer_lines = []
+    body_lines = []
+
+    for line in lines:
+        stripped = line.strip()
+        if stripped.startswith("<!-- mining-index:"):
+            header_lines.append(line)
+        elif stripped.startswith("<!-- effectiveness:"):
+            footer_lines.append(line)
+        else:
+            body_lines.append(line)
+
+    return "\n".join(header_lines), "\n".join(body_lines), "\n".join(footer_lines)
+
+
+def reassemble_playbook(header: str, body: str, footer: str) -> str:
+    """Reassemble playbook from header + body + footer, ensuring under 50 lines."""
+    parts = []
+    if header.strip():
+        parts.append(header.strip())
+    if body.strip():
+        parts.append(body.strip())
+    if footer.strip():
+        parts.append(footer.strip())
+
+    text = "\n\n".join(parts)
+
+    # Enforce 50-line limit on body (header/footer don't count)
+    body_lines = body.strip().splitlines()
+    if len(body_lines) > 50:
+        body = "\n".join(body_lines[:50])
+        text = "\n\n".join(filter(None, [header.strip(), body.strip(), footer.strip()]))
+
+    return text + "\n"
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Phase 3: Playbook curation")
+    parser.add_argument("--memory-dir", required=True, help="Path to memory/ directory")
+    parser.add_argument("--session-summary", required=True, help="Brief session summary")
+    parser.add_argument("--curate-directive", default="normal",
+                        choices=["aggressive_prune", "normal", "stability", "insufficient_data"],
+                        help="Curation aggressiveness directive")
+    parser.add_argument("--mining-findings", default="", help="Findings from memory_miner (if available)")
+    args = parser.parse_args()
+
+    playbook = read_playbook(args.memory_dir)
+    effective_playbook = read_effective_playbook(args.memory_dir)
+    logs = read_recent_logs(args.memory_dir, days=7)
+
+    # Archive before modification
+    archive_path = archive_playbook(args.memory_dir)
+    if archive_path:
+        print(f"[info] Archived playbook to {archive_path}", file=sys.stderr)
+
+    header, body, footer = extract_header_footer(playbook)
+
+    # Build LLM prompt
+    log_summary = []
+    for entry in logs[:10]:
+        changes = entry.get("playbookChanges", {})
+        output = entry.get("output", {})
+        log_summary.append({
+            "ts": entry.get("ts", "?"),
+            "changes": changes,
+            "suggestion": (output.get("suggestion", "") if output else "")[:100],
+            "skipped": entry.get("skipped", False),
+        })
+
+    today = datetime.now(timezone.utc).strftime("%Y-%m-%d")
+    user_prompt = (
+        f"## Current Date\n{today}\n\n"
+        f"## Curate Directive\n{args.curate_directive}\n\n"
+        f"## Session Summary\n{args.session_summary}\n\n"
+        f"## Current Playbook Body\n{body}\n\n"
+        f"## Recent Log Entries (last 10)\n{json.dumps(log_summary, indent=2)}\n\n"
+    )
+    if args.mining_findings:
+        user_prompt += f"## Mining Findings\n{args.mining_findings}\n\n"
+
+    if effective_playbook != playbook:
+        user_prompt += f"## Active Module Patterns (DO NOT duplicate these)\n{effective_playbook}\n\n"
+
+    user_prompt += (
+        "Curate the playbook. Return the FULL updated body text and a summary of changes.\n\n"
+        "IMPORTANT: Output ONLY the JSON object. No explanation, no reasoning, "
+        "no commentary — start your response with { and end with }."
+    )
+
+    try:
+        raw = call_llm_with_fallback(SYSTEM_PROMPT, user_prompt, script="playbook_curator", json_mode=True)
+        result = extract_json(raw)
+    except (ValueError, LLMError) as e:
+        print(f"[warn] {e}", file=sys.stderr)
+        output_json({
+            "changes": {"added": [], "pruned": [], "promoted": []},
+            "staleItemActions": [],
+            "playbookLines": len(body.splitlines()),
+            "error": "LLM response parse failed",
+        })
+        return
+
+    # Validate: updatedPlaybook should not be empty and should differ from input
+    updated_body = result.get("updatedPlaybook", "")
+    if not updated_body or not updated_body.strip():
+        print("[warn] LLM returned empty playbook body, keeping original", file=sys.stderr)
+        updated_body = body
+    elif updated_body.strip() == body.strip():
+        print("[info] Curator made no changes", file=sys.stderr)
+
+    # Write updated playbook
+    new_playbook = reassemble_playbook(header, updated_body, footer)
+
+    playbook_path = Path(args.memory_dir) / "sinain-playbook.md"
+    playbook_path.parent.mkdir(parents=True, exist_ok=True)
+    playbook_path.write_text(new_playbook, encoding="utf-8")
+
+    body_lines = updated_body.strip().splitlines()
+    output_json({
+        "changes": result.get("changes", {"added": [], "pruned": [], "promoted": []}),
+        "staleItemActions": result.get("staleItemActions", []),
+        "playbookLines": len(body_lines),
+    })
+
+
+if __name__ == "__main__":
+    main()

package/sinain-memory/requirements.txt

@@ -0,0 +1,3 @@
+requests>=2.28
+numpy>=1.24.0
+sentence-transformers>=2.2.0

package/sinain-memory/signal_analyzer.py

@@ -0,0 +1,141 @@
+#!/usr/bin/env python3
+"""Phase 2: Signal Analyzer — detect actionable signals from session context.
+
+Reads playbook-logs (last 3 entries) + session summary, uses LLM to identify
+signals and recommend actions (spawn subagent, send tip, or skip).
+
+Usage:
+    python3 signal_analyzer.py --memory-dir memory/ --session-summary "..." [--idle]
+"""
+
+import argparse
+import sys
+
+from common import (
+    LLMError,
+    call_llm,
+    extract_json,
+    output_json,
+    read_effective_playbook,
+    read_recent_logs,
+)
+
+SYSTEM_PROMPT = """\
+You are a signal detection agent for a personal AI assistant system (sinain).
+Your job: scan the user's recent session activity and detect actionable signals.
+
+Signal types and recommended actions:
+| Signal | Action |
+|--------|--------|
+| Error or issue repeated in context | sessions_spawn: "Find root cause for: [error]" |
+| New tech/topic being explored | sessions_spawn: "Research [topic]: key findings, best practices, pitfalls" |
+| Clear next action to suggest | telegram_tip: concise suggestion |
+| User stuck (same search/error loop) | sessions_spawn: "Debug [issue]: investigate and propose fix" |
+| No meaningful signal | skip |
+
+Signal priority levels:
+- HIGH: Repeated errors, build failures, stuck loops — always act
+- MEDIUM: New topic exploration, workflow opportunity — act if confident
+- LOW: General browsing, social media — skip unless highly relevant
+
+Rules:
+- Max 1 recommended action per analysis
+- NEVER repeat an action that appears in recent log entries
+- Prefer depth (spawn research) over breadth (generic tips)
+- If idle (>30 min no activity), set idle=true and skip Phase 2 action
+- Confidence: 0.0-1.0 (only recommend actions with confidence > 0.5)
+
+Include a "priority" field ("high"/"medium"/"low") in each signal.
+
+Respond with ONLY a JSON object (no markdown, no explanation):
+{
+  "signals": [{"description": "signal text", "priority": "high|medium|low"}, ...],
+  "recommendedAction": {"action": "sessions_spawn|telegram_tip|skip", "task": "description if not skip", "confidence": 0.7} or null,
+  "idle": false
+}"""
+
+
+def build_user_prompt(
+    session_summary: str,
+    recent_logs: list[dict],
+    playbook: str,
+    idle: bool,
+    current_time: str | None = None,
+) -> str:
+    parts = []
+
+    if current_time:
+        parts.append(f"## Current Time\n{current_time}")
+
+    parts.append(f"## Session Summary\n{session_summary}")
+
+    if idle:
+        parts.append("\n## Status: IDLE (>30 min no activity)\nSkip Phase 2 action. Only report if any background signals exist.")
+
+    if recent_logs:
+        log_summary = []
+        for entry in recent_logs[:6]:
+            actions = entry.get("actionsConsidered", [])
+            chosen = [a for a in actions if a.get("chosen")]
+            skipped = entry.get("skipped", False)
+            log_summary.append(
+                f"- ts={entry.get('ts', '?')}, idle={entry.get('idle', '?')}, "
+                f"actions_chosen={len(chosen)}, skipped={skipped}"
+            )
+            for a in chosen:
+                log_summary.append(f"  -> {a.get('action', '?')}: {a.get('reason', '?')}")
+        parts.append(f"\n## Recent Log Entries (last 6)\n" + "\n".join(log_summary))
+
+    if playbook:
+        # Truncate playbook to first 50 lines for context
+        lines = playbook.splitlines()[:50]
+        parts.append(f"\n## Current Playbook (first 50 lines)\n" + "\n".join(lines))
+
+    return "\n".join(parts)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Phase 2: Signal detection")
+    parser.add_argument("--memory-dir", required=True, help="Path to memory/ directory")
+    parser.add_argument("--session-summary", required=True, help="Brief session summary from main agent")
+    parser.add_argument("--idle", action="store_true", help="User is idle (>30 min)")
+    parser.add_argument("--current-time", default=None, help="Current local time string (e.g. 'Monday, 2 March 2026, 14:30 (Europe/Berlin)')")
+    args = parser.parse_args()
+
+    playbook = read_effective_playbook(args.memory_dir)
+    recent_logs = read_recent_logs(args.memory_dir, days=3)
+
+    user_prompt = build_user_prompt(
+        session_summary=args.session_summary,
+        recent_logs=recent_logs,
+        playbook=playbook,
+        idle=args.idle,
+        current_time=args.current_time,
+    )
+
+    try:
+        raw = call_llm(SYSTEM_PROMPT, user_prompt, script="signal_analyzer", json_mode=True)
+        result = extract_json(raw)
+    except (ValueError, LLMError) as e:
+        print(f"[warn] {e}", file=sys.stderr)
+        result = {
+            "signals": [],
+            "recommendedAction": None,
+            "idle": args.idle,
+        }
+
+    # Suppress low-confidence actions
+    action = result.get("recommendedAction")
+    if action and isinstance(action, dict):
+        confidence = action.get("confidence", 0)
+        if confidence < 0.5:
+            result["recommendedAction"] = {"action": "skip", "task": None, "confidence": confidence}
+            print(f"[info] Suppressed low-confidence action ({confidence})", file=sys.stderr)
+
+    # Ensure idle flag matches CLI arg
+    result["idle"] = args.idle
+    output_json(result)
+
+
+if __name__ == "__main__":
+    main()