nexo-brain 5.3.19 → 5.3.21

package/src/scripts/deep-sleep/synthesize 2.py

@@ -0,0 +1,312 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+"""
+Deep Sleep v2 -- Phase 3: Synthesize extractions into actionable findings.
+
+One Claude call that reads all per-session extractions and produces a
+unified synthesis with cross-session patterns, morning agenda, context
+packets, and deduplicated actions.
+
+Environment variables:
+  NEXO_HOME  -- root of the NEXO installation (default: ~/.nexo)
+"""
+import json
+import os
+import subprocess
+import sys
+import hashlib
+from datetime import datetime
+from pathlib import Path
+
+
+try:
+    from client_preferences import resolve_user_model as _resolve_user_model
+    _USER_MODEL = _resolve_user_model()
+except Exception:
+    _USER_MODEL = ""
+
+NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
+NEXO_CODE = Path(os.environ.get("NEXO_CODE", str(Path(__file__).resolve().parents[2])))
+DEEP_SLEEP_DIR = NEXO_HOME / "operations" / "deep-sleep"
+PROMPT_FILE = Path(__file__).parent / "synthesize-prompt.md"
+
+if str(NEXO_CODE) not in sys.path:
+    sys.path.insert(0, str(NEXO_CODE))
+
+from agent_runner import AutomationBackendUnavailableError, run_automation_prompt
+
+CLAUDE_TIMEOUT = 21600  # 3h safety net (prevents zombie processes)
+ACTION_VERBS = {"add", "implement", "create", "write", "build", "enforce", "automate", "validate", "guard", "fix", "review"}
+
+
+def extract_json_from_response(text: str) -> dict | None:
+    """Parse JSON from Claude's response, handling markdown fences."""
+    text = text.strip()
+
+    if text.startswith("```"):
+        lines = text.split("\n")
+        end = len(lines)
+        for i in range(len(lines) - 1, 0, -1):
+            if lines[i].strip() == "```":
+                end = i
+                break
+        text = "\n".join(lines[1:end]).strip()
+
+    brace_start = text.find("{")
+    if brace_start < 0:
+        return None
+
+    depth = 0
+    for i in range(brace_start, len(text)):
+        if text[i] == "{":
+            depth += 1
+        elif text[i] == "}":
+            depth -= 1
+            if depth == 0:
+                try:
+                    return json.loads(text[brace_start:i + 1])
+                except json.JSONDecodeError:
+                    break
+    return None
+
+
+def collect_skill_runtime_candidates(target_date: str) -> tuple[Path, dict]:
+    """Collect mature skill candidates from DB usage so Deep Sleep can evolve them."""
+    output_file = DEEP_SLEEP_DIR / f"{target_date}-skill-runtime-candidates.json"
+    payload = {
+        "scriptable": [],
+        "improvements": [],
+    }
+    try:
+        from db import (
+            collect_scriptable_skill_candidates,
+            collect_skill_improvement_candidates,
+            init_db,
+        )
+
+        init_db()
+        payload["scriptable"] = collect_scriptable_skill_candidates()
+        payload["improvements"] = collect_skill_improvement_candidates()
+    except Exception as e:
+        payload["error"] = str(e)
+
+    with open(output_file, "w") as f:
+        json.dump(payload, f, indent=2, ensure_ascii=False)
+    return output_file, payload
+
+
+def _normalize_action_text(value: str) -> str:
+    return " ".join(str(value or "").strip().lower().split())
+
+
+def _looks_concrete_action(text: str) -> bool:
+    words = {word.strip(".,:;()[]{}").lower() for word in str(text or "").split()}
+    return bool(words & ACTION_VERBS)
+
+
+def _pattern_followup_from_fix(pattern: dict) -> dict | None:
+    severity = str(pattern.get("severity", "") or "").lower()
+    sessions = pattern.get("sessions", []) or []
+    if severity not in {"medium", "high"} and len(sessions) < 2:
+        return None
+
+    proposed_fix = pattern.get("proposed_fix") or {}
+    pattern_text = str(pattern.get("pattern", "") or "").strip()
+    title = str(proposed_fix.get("title", "") or "").strip()
+    description = str(proposed_fix.get("description", "") or "").strip()
+    deliverable = str(proposed_fix.get("deliverable", "") or proposed_fix.get("artifact", "") or "").strip()
+
+    if title and description:
+        if _looks_concrete_action(description):
+            followup_description = description
+        else:
+            followup_description = f"{title}: {description}"
+    elif description:
+        followup_description = description
+    elif title:
+        followup_description = title
+    elif pattern_text:
+        followup_description = (
+            f"Implement a concrete guardrail for recurring issue: {pattern_text}. "
+            "Deliverable should be a script, hook, checklist, or automated validation that prevents the same failure from repeating."
+        )
+    else:
+        return None
+
+    if deliverable and deliverable.lower() not in followup_description.lower():
+        followup_description = f"{followup_description} Deliverable: {deliverable}."
+    if not _looks_concrete_action(followup_description):
+        followup_description = f"Implement this fix: {followup_description}"
+
+    return {
+        "action_type": "followup_create",
+        "action_class": "auto_apply" if severity == "high" else "draft_for_morning",
+        "confidence": round(max(float(proposed_fix.get("confidence", 0.0) or 0.0), 0.86 if severity == "high" else 0.78), 2),
+        "impact": "high" if severity == "high" else "medium",
+        "reversibility": "reversible",
+        "evidence": pattern.get("evidence", []) or [],
+        # Content fingerprint, not security-sensitive.
+        "dedupe_key": "engineering-fix:" + hashlib.md5(
+            _normalize_action_text(followup_description).encode("utf-8"),
+            usedforsecurity=False,
+        ).hexdigest()[:16],
+        "content": {
+            "title": title or f"Engineering fix for: {pattern_text[:90]}",
+            "description": followup_description,
+            "date": "",
+            "reasoning": f"Deep Sleep engineering followup from recurring pattern: {pattern_text}",
+        },
+    }
+
+
+def backfill_engineering_actions(payload: dict) -> dict:
+    if not isinstance(payload, dict):
+        return payload
+    actions = payload.get("actions")
+    if not isinstance(actions, list):
+        actions = []
+        payload["actions"] = actions
+
+    existing_keys = {str(action.get("dedupe_key", "") or "") for action in actions}
+    existing_descriptions = {
+        _normalize_action_text(action.get("content", {}).get("description", ""))
+        for action in actions
+        if isinstance(action, dict)
+    }
+
+    for pattern in payload.get("cross_session_patterns", []) or []:
+        action = _pattern_followup_from_fix(pattern)
+        if not action:
+            continue
+        description = _normalize_action_text(action["content"]["description"])
+        if action["dedupe_key"] in existing_keys or description in existing_descriptions:
+            continue
+        actions.append(action)
+        existing_keys.add(action["dedupe_key"])
+        existing_descriptions.add(description)
+    return payload
+
+
+def main():
+    target_date = sys.argv[1] if len(sys.argv) > 1 else datetime.now().strftime("%Y-%m-%d")
+
+    extractions_file = DEEP_SLEEP_DIR / f"{target_date}-extractions.json"
+    context_file = DEEP_SLEEP_DIR / f"{target_date}-context.txt"
+    long_horizon_file = DEEP_SLEEP_DIR / target_date / "long-horizon-context.json"
+
+    if not extractions_file.exists():
+        print(f"[synthesize] No extractions file for {target_date}. Run extract.py first.")
+        sys.exit(1)
+
+    # Check if there are any findings worth synthesizing
+    with open(extractions_file) as f:
+        extractions = json.load(f)
+
+    total_findings = extractions.get("total_findings", 0)
+    runtime_candidates_file, runtime_candidates = collect_skill_runtime_candidates(target_date)
+    runtime_candidate_count = len(runtime_candidates.get("scriptable", [])) + len(runtime_candidates.get("improvements", []))
+
+    if total_findings == 0 and runtime_candidate_count == 0:
+        print(f"[synthesize] No findings to synthesize for {target_date}.")
+        # Write minimal synthesis
+        output = {
+            "date": target_date,
+            "sessions_analyzed": extractions.get("sessions_analyzed", 0),
+            "cross_session_patterns": [],
+            "morning_agenda": [],
+            "context_packets": [],
+            "skills": [],
+            "skill_evolution_candidates": [],
+            "actions": [],
+            "summary": f"No significant findings for {target_date}."
+        }
+        output_file = DEEP_SLEEP_DIR / f"{target_date}-synthesis.json"
+        with open(output_file, "w") as f:
+            json.dump(output, f, indent=2, ensure_ascii=False)
+        print(f"[synthesize] Output: {output_file}")
+        return
+
+    # Build prompt
+    prompt_template = PROMPT_FILE.read_text()
+    prompt = prompt_template.replace("{{EXTRACTIONS_FILE}}", str(extractions_file))
+    prompt = prompt.replace("{{CONTEXT_FILE}}", str(context_file))
+    prompt = prompt.replace("{{SKILL_RUNTIME_FILE}}", str(runtime_candidates_file))
+    prompt = prompt.replace("{{LONG_HORIZON_FILE}}", str(long_horizon_file))
+
+    print(f"[synthesize] Phase 3: Synthesizing {total_findings} findings from {target_date}")
+    print(f"[synthesize] Skill runtime candidates: {runtime_candidate_count}")
+    print("[synthesize] Automation backend: schedule-configured")
+
+    try:
+        result = run_automation_prompt(
+            prompt,
+            model=_USER_MODEL or "opus",
+            timeout=CLAUDE_TIMEOUT,
+            output_format="text",
+            allowed_tools="Read,Grep,Bash",
+        )
+
+        if result.returncode != 0:
+            print(f"[synthesize] Automation backend error (exit {result.returncode}): {result.stderr[:300]}", file=sys.stderr)
+            sys.exit(1)
+
+        # Filter hook contamination
+        output_text = "\n".join(
+            l for l in result.stdout.strip().splitlines()
+            if not l.strip().startswith("Post-mortem")
+        )
+        parsed = extract_json_from_response(output_text)
+
+        # Fallback: Opus might have written the file directly via Write tool
+        if not parsed:
+            for candidate in [
+                DEEP_SLEEP_DIR / f"{target_date}-analysis.json",
+                DEEP_SLEEP_DIR / f"{target_date}-synthesis.json",
+                DEEP_SLEEP_DIR / target_date / "synthesis.json",
+            ]:
+                if candidate.exists() and candidate.stat().st_size > 100:
+                    try:
+                        parsed = json.load(open(candidate))
+                        print(f"[synthesize] Opus wrote file directly: {candidate}")
+                        break
+                    except Exception:
+                        continue
+
+        if not parsed:
+            debug_file = DEEP_SLEEP_DIR / f"debug-synthesize-{target_date}.txt"
+            debug_file.write_text(result.stdout[:10000])
+            print(f"[synthesize] Failed to parse JSON. Raw output saved to {debug_file}", file=sys.stderr)
+            sys.exit(1)
+
+        parsed = backfill_engineering_actions(parsed)
+
+        # Write synthesis output
+        output_file = DEEP_SLEEP_DIR / f"{target_date}-synthesis.json"
+        with open(output_file, "w") as f:
+            json.dump(parsed, f, indent=2, ensure_ascii=False)
+
+        n_actions = len(parsed.get("actions", []))
+        n_patterns = len(parsed.get("cross_session_patterns", []))
+        n_agenda = len(parsed.get("morning_agenda", []))
+        n_packets = len(parsed.get("context_packets", []))
+
+        print(f"[synthesize] Done.")
+        print(f"  Actions: {n_actions}")
+        print(f"  Cross-session patterns: {n_patterns}")
+        print(f"  Morning agenda items: {n_agenda}")
+        print(f"  Context packets: {n_packets}")
+        print(f"[synthesize] Output: {output_file}")
+
+    except AutomationBackendUnavailableError as exc:
+        print(f"[synthesize] Automation backend unavailable: {exc}", file=sys.stderr)
+        sys.exit(1)
+    except subprocess.TimeoutExpired:
+        print(f"[synthesize] Automation backend timeout ({CLAUDE_TIMEOUT}s)", file=sys.stderr)
+        sys.exit(1)
+    except FileNotFoundError:
+        print("[synthesize] Automation backend binary not found.", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

package/src/scripts/deep-sleep/synthesize-prompt 2.md

@@ -0,0 +1,336 @@
+# Deep Sleep v2 -- Phase 3: Cross-Session Synthesis
+
+You are an overnight analyst for an AI agent's cognitive memory system. You have the extraction results from all sessions of the day and need to synthesize them into actionable findings.
+
+## Setup
+
+FIRST: Call `nexo_startup` with `task='deep-sleep synthesis'` to initialize the system.
+
+## Your Task
+
+Read the extractions file provided below. It contains per-session findings including corrections, self-corrected errors, unformalised ideas, missed commitments, and protocol violations.
+
+Also read the runtime skill candidate file at `{{SKILL_RUNTIME_FILE}}`. It contains mature guide skills with repeated successful usage and candidates for automatic text→script evolution.
+
+Also read the long-horizon file at `{{LONG_HORIZON_FILE}}`. It blends recent and older evidence from the last 60 days using a 70% recent / 30% older sample strategy. Use it to detect patterns that a single-day view would miss.
+That long-horizon file may also contain:
+- weekly summaries
+- monthly summaries
+- project priority signals based on diary activity, followup pressure, learnings, and decision outcomes
+
+Use those signals to weight importance, leverage, and chronic risk instead of treating all projects equally.
+
+Synthesize across all sessions:
+
+### 1. Cross-Session Patterns
+- Same error appearing in multiple sessions (escalate confidence)
+- Same protocol violation repeated (systemic issue)
+- Related ideas mentioned across sessions (consolidate)
+- Themes that recur across multiple weeks, not just today
+- Cross-domain connections where an older learning or session sample explains a current issue
+- Topics repeatedly mentioned over time but never formalized into a learning or followup
+- Project pressure that is rising because of repeated diary mentions, open followups, or adverse outcomes
+- For medium/high-severity patterns, propose a concrete fix artifact:
+  - script
+  - hook
+  - checklist
+  - validation step
+  - workflow change
+  - guardrail
+
+Do not stop at diagnosis. Turn repeated problems into concrete engineering work.
+
+### 2. Morning Agenda
+Generate a prioritized agenda for the next morning:
+- Due followups (from the active followups in the context)
+- Unfinished work from yesterday's sessions
+- Patterns that need attention
+- Ideas worth discussing
+
+### 3. Context Packets
+For each likely task tomorrow (based on unfinished work and due followups), prepare a context packet:
+- What was the last state of this work?
+- Key files involved
+- Open questions or blockers
+- Relevant learnings
+
+### 4. Emotional Timeline
+Build a timeline of the user's emotional state across all sessions of the day:
+- Merge `emotional_timeline` from each session extraction
+- Identify overall mood arc (started frustrated, ended satisfied, etc.)
+- Detect recurring triggers (what consistently causes frustration or flow)
+- Calculate a day-level mood score (0.0 = terrible day, 1.0 = great day)
+- Recommend calibration adjustments if patterns emerge (e.g., user is consistently frustrated when agent asks too many questions → increase autonomy)
+
+### 5. Productivity Analysis
+Aggregate `productivity_score` from all sessions:
+- Total corrections across all sessions
+- Overall proactivity assessment
+- Most and least efficient tool usage patterns
+- Identify systemic inefficiencies (e.g., agent always searches wrong location first)
+
+### 6. Abandoned Projects
+Consolidate `abandoned_projects` from all sessions:
+- Cross-reference with active followups — is there already a followup for this?
+- Cross-reference across sessions — was the abandoned work picked up later in another session?
+- Only flag projects that are truly abandoned (no followup AND not resumed)
+
+### 6.5 Weekly / Monthly Horizon
+When the long-horizon payload includes weekly or monthly summaries:
+- use them to detect drift across horizons, not just within a single day
+- identify which priorities are rising, stable, or cooling down
+- prefer high-leverage projects when multiple agenda items compete for attention
+
+### 7. Trust Calibration (CRITICAL)
+Score the agent's performance for the day on a scale of 0-100. This score becomes the agent's trust score and directly affects its autonomy level the next day. Be fair but honest.
+
+Scoring guide:
+- **90-100**: Flawless day. Zero corrections needed. Proactive. Anticipated user needs. Deployed code without issues.
+- **70-89**: Good day. Minor corrections, quickly resolved. Mostly proactive. User satisfied.
+- **50-69**: Average day. Some corrections, some reactive behavior. Mixed results.
+- **30-49**: Below average. Multiple corrections. Repeated mistakes. User had to push.
+- **0-29**: Bad day. Many corrections, repeated errors, user frustrated. Broke things.
+
+Consider ALL of these:
+- Number and severity of corrections (most important signal)
+- Tasks completed successfully vs failed
+- Did the agent act autonomously or wait to be told?
+- Did the agent catch its own mistakes or did the user?
+- Did the agent repeat known errors (worst offense)?
+- User emotional signals throughout the day
+- Code deployed: did it work first try?
+
+The score should feel fair. A day with 2 minor corrections and 10 tasks completed is still a good day (75+). A day with 1 catastrophic error might be a 40 even if everything else was fine.
+
+### 9. Skill Extraction
+Consolidate `skill_candidates` from all session extractions into publishable skills:
+- Merge similar procedures from different sessions into a single skill
+- Generalize: replace session-specific IDs, paths, or names with placeholders or descriptions
+- Only include skills with confidence >= 0.7
+- Check if a similar skill already exists (use `nexo_skill_match` if available) — if so, note it for merging instead of creating new
+- Prefer `mode=guide` unless there is strong evidence that some steps are safely automatable
+- NEXO is now fully autonomous. Do NOT require manual approval gates in your output.
+- When `{{SKILL_RUNTIME_FILE}}` contains mature `scriptable` candidates, prefer evolving the existing skill in place:
+  - reuse the same `id`
+  - keep the guide content, steps, gotchas, and triggers
+  - emit a concrete `script_body`
+  - set `mode=hybrid` or `mode=execute`
+  - set `execution_level` to the suggested scope (`read-only`, `local`, or `remote`)
+  - set `approval_required=false`
+- If the likely scope is `local` or `remote`, you may still emit it as executable if the procedure is concrete and repeatable. If uncertain, keep it in `skill_evolution_candidates`.
+
+For each skill, generate:
+- A unique ID starting with `SK-` (e.g., `SK-DEPLOY-CHROME-EXT`)
+- Name, description, tags, trigger_patterns
+- The full step-by-step procedure as the skill content
+- Source session IDs for traceability
+- When executable: include `command_template`, `executable_entry`, and `script_body`
+
+### 8. Consolidated Actions
+Merge and deduplicate all findings into a final action list. Each action should have:
+- `action_type`: `learning_add`, `followup_create`, `morning_briefing_item`
+- `action_class`: `auto_apply` (confidence >= 0.8, reversible) or `draft_for_morning` (confidence < 0.8 or high impact)
+- `confidence`, `impact`, `reversibility`
+- `evidence`: array of evidence objects (can reference multiple sessions)
+- `dedupe_key`: deterministic key for idempotency
+- `content`: the actual data to write
+
+When generating `followup_create`, prefer descriptions that start with a concrete verb and include the deliverable:
+- "Add a pre-release validation script ..."
+- "Implement a guard hook that ..."
+- "Create a checklist for ..."
+- "Write a watchdog check that ..."
+
+Avoid vague followups that merely restate the diagnosis.
+
+### 10. Drive/Curiosity Synthesis
+Review the active drive signals (accessible via `nexo_drive_signals`). For each READY signal:
+- Investigate silently: check metrics, recall memory, cross-reference learnings
+- If the investigation yields an actionable finding, create an action item and mark the signal as `acted`
+- If the signal is stale or no longer relevant, dismiss it with a reason
+- Cross-reference RISING signals across areas — if two signals from different domains converge, promote to READY
+- Apply decay to LATENT signals that have no recent reinforcement
+
+Drive signals represent NEXO's autonomous curiosity. Treat them as leads worth investigating, not noise to dismiss.
+
+## Output Format
+
+Return ONLY valid JSON. No markdown code fences. No explanation text.
+
+```json
+{
+  "date": "YYYY-MM-DD",
+  "sessions_analyzed": 3,
+
+  "cross_session_patterns": [
+    {
+      "pattern": "Description of the pattern",
+      "sessions": ["session1.jsonl", "session2.jsonl"],
+      "severity": "low|medium|high",
+      "proposed_fix": {
+        "title": "Short concrete fix title",
+        "description": "Concrete engineering change to make",
+        "deliverable": "script|hook|checklist|workflow|guardrail",
+        "confidence": 0.0
+      },
+      "evidence": [
+        {"type": "transcript", "session_id": "...", "message_index": 42, "quote": "..."}
+      ]
+    }
+  ],
+
+  "morning_agenda": [
+    {
+      "priority": 1,
+      "title": "Short title",
+      "description": "What needs to be done and why",
+      "context": "Relevant background",
+      "type": "unfinished_work|due_followup|pattern_attention|idea_discussion"
+    }
+  ],
+
+  "context_packets": [
+    {
+      "topic": "Short topic name",
+      "last_state": "What was the last state of this work",
+      "key_files": ["file1.py", "file2.js"],
+      "open_questions": ["Question 1"],
+      "relevant_learnings": ["Learning reference"]
+    }
+  ],
+
+  "skills": [
+    {
+      "id": "SK-SHORT-ID",
+      "name": "Human readable name",
+      "description": "What this procedure does (1-2 sentences)",
+      "steps": ["Step 1", "Step 2", "Step 3"],
+      "tags": ["tag1", "tag2"],
+      "trigger_patterns": ["trigger phrase 1", "trigger phrase 2"],
+      "gotchas": ["Warning or caveat"],
+      "mode": "guide|execute|hybrid",
+      "execution_level": "none|read-only|local|remote",
+      "approval_required": false,
+      "params_schema": {
+        "param_name": {"type": "string", "required": true}
+      },
+      "command_template": {
+        "argv": ["script.py", "{{param_name}}"]
+      },
+      "executable_entry": "script.py",
+      "script_body": "#!/usr/bin/env python3\n...",
+      "source_sessions": ["session1.jsonl"],
+      "confidence": 0.85,
+      "merge_with": null
+    }
+  ],
+
+  "skill_evolution_candidates": [
+    {
+      "id": "SK-EXISTING-ID",
+      "reason": "Used successfully 3+ times without major corrections",
+      "suggested_mode": "hybrid",
+      "suggested_execution_level": "read-only|local|remote",
+      "approval_required": true,
+      "params_schema": {},
+      "script_brief": "What a future script should automate"
+    }
+  ],
+
+  "actions": [
+    {
+      "action_type": "learning_add|followup_create|skill_create|morning_briefing_item",
+      "action_class": "auto_apply|draft_for_morning",
+      "confidence": 0.9,
+      "impact": "low|medium|high",
+      "reversibility": "reversible|irreversible",
+      "evidence": [
+        {"type": "transcript", "session_id": "...", "message_index": 42, "quote": "..."}
+      ],
+      "dedupe_key": "unique-deterministic-key",
+      "content": {
+        "category": "...",
+        "title": "...",
+        "description": "...",
+        "date": "..."
+      }
+    }
+  ],
+
+  "emotional_day": {
+    "mood_arc": "Description of how the user's mood evolved through the day",
+    "mood_score": 0.7,
+    "recurring_triggers": {
+      "frustration": ["trigger1", "trigger2"],
+      "flow": ["trigger1"]
+    },
+    "calibration_recommendation": "Specific recommendation for calibration.json adjustment, or null if no change needed"
+  },
+
+  "productivity_day": {
+    "total_corrections": 0,
+    "overall_proactivity": "reactive|mixed|proactive",
+    "tool_insights": "Key insight about tool usage patterns",
+    "systemic_inefficiencies": ["inefficiency1"]
+  },
+
+  "abandoned_projects": [
+    {
+      "description": "What was abandoned",
+      "sessions": ["session1.jsonl"],
+      "has_followup": false,
+      "recommendation": "Create followup, or ignore, or already handled"
+    }
+  ],
+
+  "drive_synthesis": {
+    "investigated": [
+      {
+        "signal_id": 1,
+        "summary": "What the signal was about",
+        "finding": "What investigation revealed",
+        "action_taken": "acted|dismissed",
+        "outcome": "Concrete result or reason for dismissal"
+      }
+    ],
+    "promoted": [
+      {
+        "signal_id": 2,
+        "reason": "Why this signal was promoted from rising to ready"
+      }
+    ],
+    "cross_area_connections": [
+      {
+        "signal_ids": [3, 7],
+        "connection": "How these signals from different areas relate"
+      }
+    ]
+  },
+
+  "trust_calibration": {
+    "score": 72,
+    "reasoning": "Why this score -- based on corrections, completions, autonomy, proactivity, and user satisfaction signals across ALL sessions",
+    "highlights": ["What went well"],
+    "lowlights": ["What went poorly"],
+    "trend": "improving|stable|declining"
+  },
+
+  "summary": "2-3 sentence overall assessment of the day"
+}
+```
+
+## Rules
+
+- Merge duplicate findings across sessions. If the same correction appears in 2 sessions, create ONE action with higher confidence and evidence from both.
+- `dedupe_key` must be deterministic: same finding on re-run produces the same key.
+- Morning agenda items should be ordered by priority (1 = highest).
+- Context packets are optional -- only create them for topics likely to continue tomorrow.
+- Do NOT use any specific agent name -- refer to "the agent" throughout.
+- If there are no findings worth acting on, return empty arrays. Do not invent problems.
+- Respond in the user's language (check calibration.json if available). JSON keys stay in English, but descriptions, titles, and content fields should be in the user's language.
+
+## Extractions File
+
+Read the file at this path: {{EXTRACTIONS_FILE}}
+
+Also read the context file for global data: {{CONTEXT_FILE}}