@geravant/sinain 1.0.1

package/sinain-memory/feedback_analyzer.py

@@ -0,0 +1,221 @@
+#!/usr/bin/env python3
+"""Phase 3 Step 2/2b: Feedback Analyzer — score feedback + compute effectiveness.
+
+Fully mechanical: effectiveness, feedback scores, directive, and interpretation
+are all computed from log data without an LLM call.  The previous gpt-5-nano
+integration was removed after 60+ ticks of identical static output (avg 0.4,
+directive 'stability') regardless of context.
+
+Usage:
+    python3 feedback_analyzer.py --memory-dir memory/ --session-summary "..."
+"""
+
+import argparse
+import json
+import sys
+
+from common import (
+    output_json,
+    read_recent_logs,
+)
+
+
+def compute_effectiveness(logs: list[dict]) -> dict:
+    """Mechanically compute effectiveness from playbook-log entries.
+
+    - outputs: ticks where Step 5 produced output (not skipped)
+    - positive: ticks where output was followed by avg compositeScore > 0.2
+    - negative: ticks where output was followed by avg compositeScore < -0.1
+    - neutral: remainder
+    - rate: positive / outputs
+    """
+    output_ticks = [e for e in logs if not e.get("skipped", True)]
+    outputs = len(output_ticks)
+
+    if outputs == 0:
+        return {"outputs": 0, "positive": 0, "negative": 0, "neutral": 0, "rate": 0.0}
+
+    positive = 0
+    negative = 0
+    neutral = 0
+
+    # Sort by timestamp for sequential analysis
+    sorted_logs = sorted(logs, key=lambda e: e.get("ts", ""))
+
+    for i, entry in enumerate(sorted_logs):
+        if entry.get("skipped", True):
+            continue
+        # Look at next tick's feedback
+        if i + 1 < len(sorted_logs):
+            next_entry = sorted_logs[i + 1]
+            feedback = next_entry.get("feedbackScores", {})
+            avg = feedback.get("avg", 0)
+            if avg > 0.2:
+                positive += 1
+            elif avg < -0.1:
+                negative += 1
+            else:
+                neutral += 1
+        else:
+            neutral += 1  # No next tick yet
+
+    rate = positive / outputs if outputs > 0 else 0.0
+    return {
+        "outputs": outputs,
+        "positive": positive,
+        "negative": negative,
+        "neutral": neutral,
+        "rate": round(rate, 2),
+    }
+
+
+def extract_feedback_scores(logs: list[dict]) -> dict:
+    """Extract composite scores with time-decay weighting."""
+    all_scores = []
+    high_patterns = []
+    low_patterns = []
+
+    for i, entry in enumerate(logs):  # logs are newest-first
+        feedback = entry.get("feedbackScores", {})
+        avg = feedback.get("avg")
+        if avg is not None:
+            # Decay: recent entries weighted more (1.0 for newest, 0.3 for oldest)
+            weight = max(0.3, 1.0 - (i / max(len(logs), 1)) * 0.7)
+            all_scores.append((avg, weight))
+
+        for h in feedback.get("high", []):
+            if h not in high_patterns:  # deduplicate
+                high_patterns.append(h)
+        for lo in feedback.get("low", []):
+            if lo not in low_patterns:  # deduplicate
+                low_patterns.append(lo)
+
+    if all_scores:
+        weighted_sum = sum(s * w for s, w in all_scores)
+        weight_sum = sum(w for _, w in all_scores)
+        avg_score = round(weighted_sum / weight_sum, 2)
+    else:
+        avg_score = 0
+
+    return {
+        "avg": avg_score,
+        "high": high_patterns[:5],
+        "low": low_patterns[:5],
+    }
+
+
+def determine_directive(effectiveness: dict) -> str:
+    """Determine curate directive from effectiveness metrics."""
+    if effectiveness["outputs"] < 5:
+        return "insufficient_data"
+    rate = effectiveness["rate"]
+    if rate < 0.4:
+        return "aggressive_prune"
+    elif rate > 0.7:
+        return "stability"
+    return "normal"
+
+
+def compute_score_trend(logs: list[dict]) -> str:
+    """Detect score trend from recent logs: rising, falling, or flat."""
+    scores = []
+    for entry in sorted(logs, key=lambda e: e.get("ts", "")):
+        fb = entry.get("feedbackScores", {})
+        avg = fb.get("avg")
+        if avg is not None:
+            scores.append(avg)
+    if len(scores) < 3:
+        return "insufficient"
+    # Compare first third vs last third
+    third = max(1, len(scores) // 3)
+    early_avg = sum(scores[:third]) / third
+    late_avg = sum(scores[-third:]) / third
+    delta = late_avg - early_avg
+    if delta > 0.1:
+        return "rising"
+    elif delta < -0.1:
+        return "falling"
+    return "flat"
+
+
+def generate_interpretation(
+    feedback_scores: dict, effectiveness: dict, directive: str, logs: list[dict]
+) -> str:
+    """Heuristic interpretation from mechanical metrics — no LLM needed.
+
+    Replaces the gpt-5-nano call that was returning static output (avg 0.4,
+    directive 'stability') regardless of context across 60+ ticks.
+    """
+    parts = []
+
+    trend = compute_score_trend(logs)
+    avg = feedback_scores.get("avg", 0)
+    rate = effectiveness.get("rate", 0)
+    outputs = effectiveness.get("outputs", 0)
+
+    # Score summary
+    if trend == "rising":
+        parts.append(f"Scores trending up (avg {avg})")
+    elif trend == "falling":
+        parts.append(f"Scores trending down (avg {avg}) — review recent patterns")
+    elif trend == "flat":
+        parts.append(f"Scores flat at avg {avg}")
+    else:
+        parts.append(f"Too few data points for trend (avg {avg})")
+
+    # Effectiveness summary
+    pos = effectiveness.get("positive", 0)
+    neg = effectiveness.get("negative", 0)
+    if outputs > 0:
+        parts.append(f"Effectiveness {rate:.0%} ({pos} positive, {neg} negative of {outputs} outputs)")
+
+    # Pattern highlights
+    high = feedback_scores.get("high", [])
+    low = feedback_scores.get("low", [])
+    if high:
+        parts.append(f"Working well: {', '.join(high[:3])}")
+    if low:
+        parts.append(f"Underperforming: {', '.join(low[:3])}")
+
+    # Directive rationale
+    rationale = {
+        "aggressive_prune": "Low effectiveness — pruning weak patterns",
+        "normal": "Balanced cycle — standard add/prune",
+        "stability": "High effectiveness — preserving current patterns",
+        "insufficient_data": "Not enough data for effectiveness tuning",
+    }
+    parts.append(rationale.get(directive, f"Directive: {directive}"))
+
+    return ". ".join(parts)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Phase 3: Feedback analysis")
+    parser.add_argument("--memory-dir", required=True, help="Path to memory/ directory")
+    parser.add_argument("--session-summary", required=True, help="Brief session summary")
+    args = parser.parse_args()
+
+    logs = read_recent_logs(args.memory_dir, days=7)
+
+    # Fully mechanical computation — no LLM call
+    effectiveness = compute_effectiveness(logs)
+    feedback_scores = extract_feedback_scores(logs)
+    directive = determine_directive(effectiveness)
+    interpretation = generate_interpretation(feedback_scores, effectiveness, directive, logs)
+
+    # Compute skip rate for proactivity tracking
+    total_ticks = len(logs)
+    skip_ticks = sum(1 for e in logs if e.get("skipped", True))
+    skip_rate = round(skip_ticks / total_ticks, 2) if total_ticks > 0 else 1.0
+
+    output_json({
+        "feedbackScores": feedback_scores,
+        "effectiveness": effectiveness,
+        "curateDirective": directive,
+        "interpretation": interpretation,
+        "skipRate": skip_rate,
+    })
+
+
+if __name__ == "__main__":
+    main()

package/sinain-memory/git_backup.sh

@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+# Phase 1: Git backup — commit and push any uncommitted changes in the workspace.
+# Runs from the workspace root. Exits 0 on success or nothing to commit, 1 on push failure.
+
+set -euo pipefail
+
+changes=$(git status --porcelain 2>/dev/null || true)
+
+if [ -z "$changes" ]; then
+    echo "nothing to commit"
+    exit 0
+fi
+
+git add -A
+git commit -m "auto: heartbeat $(date -u +%Y-%m-%dT%H:%M:%SZ)"
+git push origin main
+
+# Output the commit hash
+git rev-parse --short HEAD

package/sinain-memory/insight_synthesizer.py

@@ -0,0 +1,181 @@
+#!/usr/bin/env python3
+"""Phase 3 Step 5: Insight Synthesizer — produce suggestion + insight for Telegram.
+
+Uses the "smart" model (configured in koog-config.json) for higher quality output.
+Reads post-curation playbook + recent logs to generate one Telegram message
+with a practical suggestion and a surprising insight.
+
+Usage:
+    python3 insight_synthesizer.py --memory-dir memory/ --session-summary "..." \
+        [--curator-changes "TEXT"] [--idle]
+"""
+
+import argparse
+import json
+import sys
+
+from common import (
+    LLMError,
+    call_llm,
+    extract_json,
+    output_json,
+    read_effective_playbook,
+    read_recent_logs,
+)
+
+SYSTEM_PROMPT = """\
+You are the insight synthesizer for sinain, a personal AI assistant.
+Your job: produce ONE high-quality Telegram message with two parts.
+
+**Suggestion** (1-2 sentences): A practical, actionable recommendation.
+- MUST reference a specific playbook pattern or concrete observation
+- NOT generic advice — grounded in actual data
+- Could be: workflow improvement, recurring problem to automate, successful pattern to replicate
+
+**Insight** (1-2 sentences): A surprising, non-obvious connection from accumulated data.
+- MUST connect 2+ distinct observations that aren't obviously related
+- Cross-domain patterns, unexpected correlations, things the user hasn't noticed
+- Cite specific observations from playbook or logs
+
+Quality gate — you MUST skip if:
+- You cannot produce BOTH a genuinely useful suggestion AND a genuinely surprising insight
+- The suggestion would repeat something from recent heartbeat outputs
+- The insight is obvious or doesn't connect distinct observations
+
+Proactivity rules:
+- On ACTIVE days, LOWER your skip threshold — the user wants daily engagement
+- If the last 3+ outputs were skipped, you MUST produce output (find something worth saying)
+- Prefer a moderate-quality insight over silence — the user explicitly asked for more proactive insights
+- When idle, focus on mined pattern synthesis and cross-day trend observations
+
+Total message MUST be under 500 characters.
+
+Respond with ONLY a JSON object. If producing output:
+{
+  "skip": false,
+  "suggestion": "the suggestion text",
+  "insight": "the insight text"
+}
+
+If skipping (be specific about WHY, citing what you read):
+{
+  "skip": true,
+  "skipReason": "specific reason citing files/patterns examined — 'no new data' is NOT valid"
+}
+
+When your suggestion or insight references a pattern from a section marked
+"[Transferred knowledge: ...]", naturally mention this origin (e.g. "Based on
+transferred OCR expertise, ..."). Keep the attribution brief and natural."""
+
+
+def build_user_prompt(
+    playbook: str,
+    recent_logs: list[dict],
+    session_summary: str,
+    curator_changes: 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 — focus on mined patterns and playbook evolution")
+
+    if playbook:
+        parts.append(f"\n## Current Playbook (post-curation)\n{playbook}")
+
+    if curator_changes:
+        parts.append(f"\n## Curator Changes This Tick\n{curator_changes}")
+
+    # Recent outputs to avoid repetition
+    if recent_logs:
+        recent_outputs = []
+        for entry in recent_logs[:5]:
+            output = entry.get("output", {})
+            if output and not entry.get("skipped", True):
+                recent_outputs.append({
+                    "ts": entry.get("ts", "?"),
+                    "suggestion": output.get("suggestion", "")[:100],
+                    "insight": output.get("insight", "")[:100],
+                })
+        if recent_outputs:
+            parts.append(f"\n## Recent Outputs (DO NOT REPEAT)\n{json.dumps(recent_outputs, indent=2)}")
+
+    # Count recent skips to enforce proactivity
+    if recent_logs:
+        recent_skips = sum(1 for e in recent_logs[:5] if e.get("skipped", True))
+        if recent_skips >= 3:
+            parts.append(f"\n## PROACTIVITY OVERRIDE: {recent_skips} of last 5 outputs were skipped. You MUST produce output this tick.")
+
+    return "\n".join(parts)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Phase 3: Insight synthesis")
+    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("--curator-changes", default="", help="JSON string of curator changes")
+    parser.add_argument("--idle", action="store_true", help="User is idle")
+    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(
+        playbook=playbook,
+        recent_logs=recent_logs,
+        session_summary=args.session_summary,
+        curator_changes=args.curator_changes,
+        idle=args.idle,
+        current_time=args.current_time,
+    )
+
+    try:
+        raw = call_llm(SYSTEM_PROMPT, user_prompt, script="insight_synthesizer", json_mode=True)
+        result = extract_json(raw)
+    except (ValueError, LLMError) as e:
+        print(f"[warn] {e}", file=sys.stderr)
+        result = {
+            "skip": True,
+            "skipReason": "LLM response was not parseable JSON",
+        }
+
+    # Enforce character limit on non-skip output
+    if not result.get("skip", False):
+        suggestion = result.get("suggestion", "")
+        insight = result.get("insight", "")
+        total_chars = len(suggestion) + len(insight)
+
+        if total_chars > 500:
+            # Truncate insight to fit
+            max_insight = 500 - len(suggestion) - 10  # buffer
+            if max_insight > 50:
+                truncated = insight[:max_insight]
+                # Cut at last sentence boundary
+                last_period = truncated.rfind(".")
+                last_excl = truncated.rfind("!")
+                last_q = truncated.rfind("?")
+                boundary = max(last_period, last_excl, last_q)
+                if boundary > max_insight // 2:
+                    insight = truncated[:boundary + 1]
+                else:
+                    insight = truncated.rstrip() + "..."
+                result["insight"] = insight
+                total_chars = len(suggestion) + len(insight)
+            else:
+                result["skip"] = True
+                result["skipReason"] = f"Output exceeded 500 chars ({total_chars}) and could not be trimmed"
+
+        result["totalChars"] = len(result.get("suggestion", "")) + len(result.get("insight", ""))
+
+    output_json(result)
+
+
+if __name__ == "__main__":
+    main()

package/sinain-memory/memory/2026-03-01.md

@@ -0,0 +1,11 @@
+# 2026-03-01 Session Notes
+
+## OCR Pipeline
+- Switched from Tesseract to OpenRouter vision API
+- Backpressure issue: camera produces frames faster than API can process
+- Solution: frame dropping with scene-gate (skip similar consecutive frames)
+
+## Wearable HUD
+- Testing 3-panel debug interface
+- Camera feed, OCR overlay, and pipeline stats side-by-side
+- Found that JPEG quality 70 is good balance of speed vs readability

package/sinain-memory/memory/playbook-archive/sinain-playbook-2026-03-01-1418.md

@@ -0,0 +1,15 @@
+<!-- mining-index: 2026-03-01 -->
+# Sinain Playbook
+
+## Established Patterns
+- When OCR pipeline stalls, check camera frame queue depth (score: 0.8)
+- When user explores new framework, spawn research agent proactively (score: 0.6)
+
+## Observed
+- User prefers concise Telegram messages over detailed ones
+- Late evening sessions tend to be exploratory/research-heavy
+
+## Stale
+- Flutter overlay rendering glitch on macOS 15 [since: 2026-02-18]
+
+<!-- effectiveness: outputs=8, positive=5, negative=1, neutral=2, rate=0.63, updated=2026-02-21 -->

package/sinain-memory/memory/playbook-logs/2026-03-01.jsonl

@@ -0,0 +1 @@
+{"ts": "2026-03-01T14:18:16.183587+00:00", "idle": false, "sessionHistorySummary": "User debugging OCR pipeline", "feedbackScores": {"avg": 0.35, "high": ["OCR fix suggestion"], "low": []}, "actionsConsidered": [{"action": "spawn research", "reason": "Flutter overlay perf", "chosen": false, "skipReason": "not urgent"}], "effectivenessRate": 0.63, "effectivenessAlert": false, "playbookChanges": {"added": [], "pruned": [], "promoted": []}, "output": {"suggestion": "Consider frame batching for OCR pipeline", "insight": "Evening sessions correlate with exploratory work"}, "skipped": false}

package/sinain-memory/memory/sinain-playbook.md

@@ -0,0 +1,21 @@
+<!-- mining-index: 2026-03-01 -->
+
+# Sinain Playbook
+
+## Established Patterns
+- When OCR pipeline stalls, check camera frame queue depth (score: 0.8)
+- When user explores new framework, spawn research agent proactively (score: 0.6)
+- When OCR backend switches (e.g., Tesseract → vision API), validate latency and cost tradeoffs before committing (score: 0.7)
+
+## Observed
+- User prefers concise Telegram messages over detailed ones
+- Late evening sessions tend to be exploratory/research-heavy
+- Scene-gating (drop frames on low scene change) is preferred approach for OCR backpressure
+- JPEG quality tuning is part of wearable pipeline optimization workflow
+- User converging on 3-panel HUD layout for wearable debug interface
+- Flutter overlay on macOS is an active exploration area (not settled)
+
+## Stale
+- Flutter overlay rendering glitch on macOS 15 [since: 2026-02-18]
+
+<!-- effectiveness: outputs=8, positive=5, negative=1, neutral=2, rate=0.63, updated=2026-02-21 -->

package/sinain-memory/memory-config.json

@@ -0,0 +1,39 @@
+{
+  "models": {
+    "fast": "google/gemini-3-flash-preview",
+    "smart": "anthropic/claude-sonnet-4.6"
+  },
+  "scripts": {
+    "signal_analyzer":    { "model": "fast",  "maxTokens": 1500 },
+    "feedback_analyzer":  { "model": "fast",  "maxTokens": 800 },
+    "memory_miner":       { "model": "smart", "maxTokens": 1500 },
+    "playbook_curator":   { "model": "fast",  "maxTokens": 3000, "timeout": 90 },
+    "insight_synthesizer": { "model": "smart", "maxTokens": 800 },
+    "module_manager":      { "model": "fast",  "maxTokens": 2000 },
+    "tick_evaluator":      { "model": "smart", "maxTokens": 200, "timeout": 30 },
+    "eval_reporter":       { "model": "smart", "maxTokens": 1000 },
+    "triple_extractor":    { "model": "fast",  "maxTokens": 1500, "timeout": 30 }
+  },
+  "defaults": { "model": "fast", "maxTokens": 1500 },
+  "triplestore": {
+    "dbPath": "memory/triplestore.db",
+    "maxTriplesPerTx": 100,
+    "conceptExtractionMode": "tiered",
+    "gcOlderThanDays": 30
+  },
+  "eval": {
+    "level": "sampled",
+    "sampleRate": 0.3,
+    "judges": {
+      "model": "smart",
+      "maxTokens": 200,
+      "timeout": 30
+    },
+    "dailyReport": true,
+    "regressionThresholds": {
+      "assertionPassRate": 0.85,
+      "effectivenessRate": 0.4,
+      "skipRate": 0.8
+    }
+  }
+}