End of Day Brief

# go2-skill: multi-model-consensus
# Trigger: User creates copy, spec, taxonomy, or docs
# Runtime: Claude Code hook (PreToolCall)

import json, subprocess, sys

def dispatch_to_model(model_id, prompt, artifact):
    """Send artifact to a model via OpenRouter dispatch."""
    cmd = [
        "/Applications/OpenWork.app/Contents/MacOS/opencode", "run",
        "--model", f"openrouter/{model_id}",
        "-m", f"{prompt}\n\n---\nARTIFACT:\n{artifact}"
    ]
    result = subprocess.run(cmd, capture_output=True, text=True, timeout=120)
    return result.stdout.strip()

def run_consensus(artifact, rubric=None):
    models = [
        "openai/gpt-5.4-pro",
        "google/gemini-3.1-pro-preview",
        "anthropic/claude-sonnet-4-6"
    ]
    prompt = f"""Score this artifact 1-10 on each criterion.
Rubric: {rubric or 'clarity, completeness, accuracy, actionability'}
Return JSON: {{"scores": {{}}, "strengths": [], "weaknesses": [], "suggested_edit": ""}}"""

    results = {}
    for model in models:
        results[model] = dispatch_to_model(model, prompt, artifact)

    # Build agreement matrix
    agreement = analyze_agreement(results)
    return {
        "individual_reviews": results,
        "agreement_matrix": agreement,
        "recommended_merge": synthesize(results),
        "rubric_used": rubric
    }

# Usage: run_consensus(artifact_text, rubric="tone, CTA clarity, objection handling")

# go2-skill: voice-to-memory
# Trigger: New meta.json appears in ~/Documents/superwhisper/recordings/
# Runtime: fswatch + Python

import json, glob, os
from datetime import datetime

WATCH_DIR = os.path.expanduser("~/Documents/superwhisper/recordings")
MEMORY_LOG = os.path.expanduser("~/brain/voice-decisions.md")

def process_transcript(meta_path):
    with open(meta_path) as f:
        meta = json.load(f)

    transcript = meta.get("result", "")
    if not transcript or len(transcript) < 20:
        return None

    # Classify using local LLM or Claude API
    classification = classify_transcript(transcript)
    return {
        "timestamp": meta.get("datetime"),
        "text": transcript[:500],
        "category": classification["category"],  # decision/question/brainstorm/delegation
        "entities": classification["entities"],    # people, projects, tools mentioned
        "decisions": classification["decisions"],  # explicit decisions made
        "next_actions": classification["next_actions"],
        "unresolved": classification["unresolved_questions"]
    }

def classify_transcript(text):
    """Send to Claude for structured extraction."""
    prompt = f"""Classify this voice note:
Categories: decision, question, brainstorm, delegation, status-update
Extract: entities, decisions made, next actions, unresolved questions.
Return JSON.

TRANSCRIPT: {text}"""
    # dispatch to Claude API...
    return call_claude(prompt)

def append_to_decision_log(entry):
    with open(MEMORY_LOG, "a") as f:
        f.write(f"\n## {entry['timestamp']} — {entry['category']}\n")
        if entry['decisions']:
            f.write(f"**Decisions:** {', '.join(entry['decisions'])}\n")
        if entry['next_actions']:
            f.write(f"**Next:** {', '.join(entry['next_actions'])}\n")
        if entry['unresolved']:
            f.write(f"**Open:** {', '.join(entry['unresolved'])}\n")

# go2-skill: rubric-capture
# Trigger: User compares multiple options (copy, designs, approaches)
# Runtime: Claude Code hook (PostToolCall on Write/Edit)

import json, os
from datetime import datetime

RUBRIC_STORE = os.path.expanduser("~/brain/rubrics/")

def detect_comparison(context):
    """Detect when user is evaluating multiple options."""
    signals = [
        "which is better", "compare", "grade", "score",
        "rank", "pick the best", "evaluate", "rate"
    ]
    return any(s in context.lower() for s in signals)

def capture_rubric(task_type, criteria, weights=None):
    """Save rubric for future reuse."""
    rubric = {
        "id": f"rubric-{datetime.now().strftime('%Y%m%d-%H%M')}",
        "task_type": task_type,  # "landing_page_copy", "taxonomy", "email_outreach"
        "criteria": criteria,    # ["clarity", "CTA strength", "objection handling"]
        "weights": weights or {c: 1.0 for c in criteria},
        "created": datetime.now().isoformat(),
        "times_used": 0,
        "last_used": None
    }
    path = os.path.join(RUBRIC_STORE, f"{rubric['id']}.json")
    with open(path, "w") as f:
        json.dump(rubric, f, indent=2)
    return rubric

def suggest_rubric(task_description):
    """Find matching rubric from history."""
    rubrics = []
    for f in os.listdir(RUBRIC_STORE):
        if f.endswith(".json"):
            with open(os.path.join(RUBRIC_STORE, f)) as fh:
                rubrics.append(json.load(fh))

    # Use embedding similarity or keyword match
    matches = [r for r in rubrics if task_type_matches(r["task_type"], task_description)]
    return sorted(matches, key=lambda r: r["times_used"], reverse=True)[:3]

# Example: When Scott says "grade these 5 email variants"
# Go2 auto-suggests: "Use rubric 'email_outreach' from Mar 18?
# Criteria: personalization, pain-point match, CTA clarity, brevity"

# go2-skill: transcript-to-outreach
# Trigger: New demo transcript available
# Runtime: Scheduled task or fswatch

import json, subprocess

def process_demo_transcript(transcript_path):
    with open(transcript_path) as f:
        transcript = f.read()

    # Step 1: Extract lead signals
    extraction = call_claude(f"""From this demo transcript, extract:
    1. Company name and attendees
    2. Pain points mentioned
    3. Features they were most interested in
    4. Objections raised
    5. Next steps discussed
    6. Buying signals (budget, timeline, authority)

    TRANSCRIPT: {transcript}""")

    # Step 2: Pull CRM context
    crm_data = query_hubspot(extraction["company"])

    # Step 3: Draft personalized follow-up
    email = call_claude(f"""Draft a follow-up email for {extraction['company']}.
    Pain points: {extraction['pain_points']}
    Interest areas: {extraction['features']}
    CRM history: {crm_data}

    Tone: Direct, founder-to-founder. Reference specific things from the demo.
    Include: 1 clear CTA, link to beta signup, availability for next call.""")

    # Step 4: Queue for review
    save_draft(email, extraction, priority=score_lead(extraction))
    return email

# go2-skill: meeting-compression
# Trigger: Google Meet session ends (detected via activity_sessions gap)
# Runtime: Post-meeting hook

def compress_meeting(meet_transcript, pre_meeting_context):
    summary = call_claude(f"""Compress this meeting into:
    1. DECISIONS MADE (with owners)
    2. ACTION ITEMS (with deadlines)
    3. UNRESOLVED (needs follow-up)
    4. SLACK FOLLOW-UP (draft message for relevant channel)
    5. RESUME BRIEF (what Scott was doing before this meeting
       and the best way to get back into flow)

    Pre-meeting context: {pre_meeting_context}
    Meeting transcript: {meet_transcript}""")

    # Auto-post to Slack if configured
    if summary["slack_followup"]:
        post_to_slack(channel, summary["slack_followup"])

    # Create resume-working notification
    notify_scott(f"Meeting done. Resume: {summary['resume_brief']}")

    return summary