nexo-brain 2.2.0 → 2.3.1

package/src/plugins/schedule.py

@@ -0,0 +1,212 @@
+"""NEXO Schedule — Cron execution history, status, and management tools."""
+
+import json
+import os
+import platform
+import subprocess
+from pathlib import Path
+
+from db import cron_runs_recent, cron_runs_summary
+
+
+def handle_schedule_status(hours: int = 24, cron_id: str = '') -> str:
+    """Show cron execution status — what ran, what failed, durations.
+
+    Args:
+        hours: How far back to look (default 24h).
+        cron_id: Filter to a specific cron (optional). E.g. 'deep-sleep', 'immune'.
+    """
+    if cron_id:
+        runs = cron_runs_recent(hours, cron_id)
+        if not runs:
+            return f"No runs for '{cron_id}' in the last {hours}h."
+        lines = [f"CRON RUNS — {cron_id} (last {hours}h): {len(runs)} executions"]
+        for r in runs:
+            status = "✅" if r.get("exit_code") == 0 else "❌"
+            dur = f"{r['duration_secs']:.0f}s" if r.get("duration_secs") else "running"
+            summary = f" — {r['summary'][:100]}" if r.get("summary") else ""
+            error = f" ERROR: {r['error'][:100]}" if r.get("error") else ""
+            lines.append(f"  {status} {r['started_at']} ({dur}){summary}{error}")
+        return "\n".join(lines)
+
+    # Summary view — one line per cron
+    summary = cron_runs_summary(hours)
+    if not summary:
+        return f"No cron executions recorded in the last {hours}h."
+
+    lines = [f"CRON STATUS (last {hours}h):"]
+    for s in summary:
+        status = "✅" if s.get("last_exit_code") == 0 else "❌"
+        rate = f"{s['succeeded']}/{s['total_runs']}"
+        dur = f"{s['avg_duration']:.0f}s avg" if s.get("avg_duration") else ""
+        summary_txt = f" — {s['last_summary'][:80]}" if s.get("last_summary") else ""
+        lines.append(f"  {status} {s['cron_id']}: {rate} OK, {dur}{summary_txt}")
+
+    return "\n".join(lines)
+
+
+def handle_schedule_add(cron_id: str, script: str, schedule: str = '',
+                        interval_seconds: int = 0, description: str = '',
+                        script_type: str = 'python') -> str:
+    """Add a new personal cron job. Generates and installs the LaunchAgent (macOS) or systemd timer (Linux).
+
+    Args:
+        cron_id: Unique ID for this cron (e.g. 'my-backup', 'report-daily'). Must be lowercase with hyphens.
+        script: Path to the script to run (absolute or relative to NEXO_HOME/scripts/).
+        schedule: Time-based schedule as 'HH:MM' (daily) or 'HH:MM:weekday' (e.g. '08:00:1' for Monday 8AM). Mutually exclusive with interval_seconds.
+        interval_seconds: Run every N seconds (e.g. 300 for every 5 min). Mutually exclusive with schedule.
+        description: What this cron does (for logs and status).
+        script_type: 'python' (default) or 'shell'.
+    """
+    if not cron_id or not script:
+        return "ERROR: cron_id and script are required."
+    if not schedule and not interval_seconds:
+        return "ERROR: either schedule (e.g. '08:00') or interval_seconds (e.g. 300) is required."
+
+    nexo_home = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
+    script_path = Path(script)
+    if not script_path.is_absolute():
+        script_path = nexo_home / "scripts" / script
+    if not script_path.exists():
+        return f"ERROR: script not found: {script_path}"
+
+    wrapper_path = nexo_home / "scripts" / "nexo-cron-wrapper.sh"
+    if not wrapper_path.exists():
+        return f"ERROR: wrapper not found at {wrapper_path}. Run crons/sync.py first."
+
+    system = platform.system()
+
+    if system == "Darwin":
+        return _add_launchagent(cron_id, str(script_path), str(wrapper_path),
+                                schedule, interval_seconds, description, script_type, nexo_home)
+    elif system == "Linux":
+        return _add_systemd_timer(cron_id, str(script_path), str(wrapper_path),
+                                  schedule, interval_seconds, description, script_type, nexo_home)
+    else:
+        return f"ERROR: unsupported platform: {system}"
+
+
+def _add_launchagent(cron_id, script_path, wrapper_path, schedule, interval_seconds,
+                     description, script_type, nexo_home):
+    """Create and load a macOS LaunchAgent."""
+    import plistlib
+
+    label = f"com.nexo.{cron_id}"
+    plist_path = Path.home() / "Library" / "LaunchAgents" / f"{label}.plist"
+
+    if plist_path.exists():
+        return f"ERROR: cron '{cron_id}' already exists at {plist_path}. Use a different ID or remove it first."
+
+    python_bin = "/opt/homebrew/bin/python3"
+    for p in ["/opt/homebrew/bin/python3", "/usr/local/bin/python3", "/usr/bin/python3"]:
+        if Path(p).exists():
+            python_bin = p
+            break
+
+    if script_type == "shell":
+        program_args = ["/bin/bash", wrapper_path, cron_id, "/bin/bash", script_path]
+    else:
+        program_args = ["/bin/bash", wrapper_path, cron_id, python_bin, script_path]
+
+    plist = {
+        "Label": label,
+        "ProgramArguments": program_args,
+        "StandardOutPath": str(nexo_home / "logs" / f"{cron_id}-stdout.log"),
+        "StandardErrorPath": str(nexo_home / "logs" / f"{cron_id}-stderr.log"),
+        "EnvironmentVariables": {
+            "HOME": str(Path.home()),
+            "NEXO_HOME": str(nexo_home),
+            "PATH": "/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:" + str(Path.home() / ".local/bin"),
+        },
+    }
+
+    if interval_seconds:
+        plist["StartInterval"] = interval_seconds
+    elif schedule:
+        parts = schedule.split(":")
+        cal = {"Hour": int(parts[0]), "Minute": int(parts[1])}
+        if len(parts) > 2:
+            cal["Weekday"] = int(parts[2])
+        plist["StartCalendarInterval"] = cal
+
+    with open(plist_path, "wb") as f:
+        plistlib.dump(plist, f)
+
+    subprocess.run(["launchctl", "bootstrap", f"gui/{os.getuid()}", str(plist_path)], capture_output=True)
+
+    return f"Cron '{cron_id}' installed at {plist_path} and loaded.{' Schedule: ' + schedule if schedule else f' Interval: {interval_seconds}s'}"
+
+
+def _add_systemd_timer(cron_id, script_path, wrapper_path, schedule, interval_seconds,
+                       description, script_type, nexo_home):
+    """Create and enable a systemd user timer (Linux)."""
+    unit_dir = Path.home() / ".config" / "systemd" / "user"
+    unit_dir.mkdir(parents=True, exist_ok=True)
+
+    python_bin = "/usr/bin/python3"
+    for p in ["/usr/bin/python3", "/usr/local/bin/python3"]:
+        if Path(p).exists():
+            python_bin = p
+            break
+
+    if script_type == "shell":
+        exec_cmd = f"/bin/bash {wrapper_path} {cron_id} /bin/bash {script_path}"
+    else:
+        exec_cmd = f"/bin/bash {wrapper_path} {cron_id} {python_bin} {script_path}"
+
+    # Service unit
+    service_content = f"""[Unit]
+Description=NEXO: {description or cron_id}
+
+[Service]
+Type=oneshot
+ExecStart={exec_cmd}
+Environment=NEXO_HOME={nexo_home}
+Environment=HOME={Path.home()}
+"""
+    service_path = unit_dir / f"nexo-{cron_id}.service"
+    service_path.write_text(service_content)
+
+    # Timer unit
+    if interval_seconds:
+        timer_spec = f"OnUnitActiveSec={interval_seconds}s\nOnBootSec=60s"
+    elif schedule:
+        parts = schedule.split(":")
+        hour, minute = int(parts[0]), int(parts[1])
+        if len(parts) > 2:
+            days = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]
+            day = days[int(parts[2])]
+            timer_spec = f"OnCalendar={day} *-*-* {hour:02d}:{minute:02d}:00"
+        else:
+            timer_spec = f"OnCalendar=*-*-* {hour:02d}:{minute:02d}:00"
+    else:
+        return "ERROR: no schedule or interval"
+
+    timer_content = f"""[Unit]
+Description=NEXO timer: {description or cron_id}
+
+[Timer]
+{timer_spec}
+Persistent=true
+
+[Install]
+WantedBy=timers.target
+"""
+    timer_path = unit_dir / f"nexo-{cron_id}.timer"
+    timer_path.write_text(timer_content)
+
+    subprocess.run(["systemctl", "--user", "daemon-reload"], capture_output=True)
+    subprocess.run(["systemctl", "--user", "enable", "--now", f"nexo-{cron_id}.timer"], capture_output=True)
+
+    return f"Cron '{cron_id}' installed as systemd timer and enabled. Service: {service_path}, Timer: {timer_path}"
+
+
+TOOLS = [
+    (handle_schedule_status, "nexo_schedule_status",
+     "Show cron execution status: what ran overnight, what failed, durations. "
+     "Use at startup to give the user a quick health overview of autonomous processes."),
+
+    (handle_schedule_add, "nexo_schedule_add",
+     "Add a new personal cron job. Creates LaunchAgent (macOS) or systemd timer (Linux) "
+     "automatically, wrapped with execution tracking."),
+]

package/src/plugins/skills.py

@@ -0,0 +1,264 @@
+"""Skills plugin — reusable procedures extracted from complex tasks.
+
+Skills are procedural knowledge (step-by-step how-tos) vs learnings which are
+declarative (don't do X). Created automatically by Deep Sleep or manually.
+
+Pipeline: trace → draft → published, fully autonomous.
+Trust score with decay controls quality — no human approval gates.
+"""
+
+import json
+from db import (
+    create_skill, get_skill, list_skills, search_skills,
+    update_skill, delete_skill,
+    record_skill_usage, match_skills, merge_skills, get_skill_stats,
+)
+
+
+def handle_skill_create(
+    id: str,
+    name: str,
+    description: str = '',
+    level: str = 'draft',
+    tags: str = '[]',
+    trigger_patterns: str = '[]',
+    source_sessions: str = '[]',
+    linked_learnings: str = '[]',
+    file_path: str = '',
+) -> str:
+    """Create a new skill (reusable procedure).
+
+    Skills are procedural knowledge — step-by-step instructions for complex tasks.
+    Created by Deep Sleep (auto-extraction) or manually during sessions.
+
+    Pipeline levels: trace → draft → published → archived.
+    Promotion is automatic: 2+ successful uses in distinct contexts → published.
+
+    Args:
+        id: Unique ID starting with 'SK-' (e.g., SK-DEPLOY-CHROME-EXT).
+        name: Human-readable name (e.g., 'Deploy Chrome Extension').
+        description: What this skill does (1-2 sentences).
+        level: Starting level — trace, draft (default), published, archived.
+        tags: JSON array of tags for discovery (e.g., '["chrome", "extension", "deploy"]').
+        trigger_patterns: JSON array of phrases that should trigger this skill
+                         (e.g., '["deploy extension", "publish chrome"]').
+        source_sessions: JSON array of diary IDs where this skill was observed.
+        linked_learnings: JSON array of learning IDs related to this skill.
+        file_path: Path to the .md file with full procedure (if stored as file).
+    """
+    if not id.startswith('SK-'):
+        return "ERROR: Skill ID must start with 'SK-' (e.g., SK-DEPLOY-CHROME-EXT)"
+
+    existing = get_skill(id)
+    if existing:
+        return f"ERROR: Skill {id} already exists. Use nexo_skill_update to modify."
+
+    result = create_skill(
+        skill_id=id, name=name, description=description, level=level,
+        tags=tags, trigger_patterns=trigger_patterns,
+        source_sessions=source_sessions, linked_learnings=linked_learnings,
+        file_path=file_path,
+    )
+    if "error" in result:
+        return f"ERROR: {result['error']}"
+
+    return (
+        f"Skill {id} created ({level}, trust={result.get('trust_score', 50)}).\n"
+        f"  Name: {name}\n"
+        f"  Tags: {tags}\n"
+        f"  Triggers: {trigger_patterns}"
+    )
+
+
+def handle_skill_match(task: str, level: str = '') -> str:
+    """Find skills matching a task description. Call BEFORE starting multi-step tasks.
+
+    Searches by: FTS5 relevance, trigger pattern matching, tag keyword overlap.
+    Returns top-3 matches sorted by trust score.
+
+    Args:
+        task: Description of what you're about to do (e.g., 'deploy chrome extension to CWS').
+        level: Filter by level (optional). Default: draft + published.
+    """
+    matches = match_skills(task, level=level)
+    if not matches:
+        return f"No skills found for: '{task}'"
+
+    lines = [f"SKILLS MATCHED ({len(matches)}) for '{task}':"]
+    for m in matches:
+        match_method = m.pop('_match', 'unknown')
+        fp = f" → {m['file_path']}" if m.get('file_path') else ""
+        lines.append(
+            f"  [{m['id']}] {m['name']} ({m['level']}, trust={m['trust_score']}, "
+            f"used={m['use_count']}x) via {match_method}{fp}\n"
+            f"    {m['description'][:120]}"
+        )
+        try:
+            triggers = json.loads(m.get('trigger_patterns', '[]'))
+            if triggers:
+                lines.append(f"    Triggers: {', '.join(triggers[:5])}")
+        except (json.JSONDecodeError, TypeError):
+            pass
+    return "\n".join(lines)
+
+
+def handle_skill_get(id: str) -> str:
+    """Get a skill's full details including usage history.
+
+    Args:
+        id: Skill ID (e.g., SK-DEPLOY-CHROME-EXT).
+    """
+    skill = get_skill(id)
+    if not skill:
+        return f"ERROR: Skill {id} not found."
+
+    from db import get_db
+    conn = get_db()
+    recent_uses = conn.execute(
+        "SELECT * FROM skill_usage WHERE skill_id = ? ORDER BY created_at DESC LIMIT 5",
+        (id,),
+    ).fetchall()
+
+    lines = [
+        f"SKILL: {skill['id']}",
+        f"  Name: {skill['name']}",
+        f"  Description: {skill['description']}",
+        f"  Level: {skill['level']}",
+        f"  Trust: {skill['trust_score']}",
+        f"  File: {skill['file_path'] or '(none)'}",
+        f"  Tags: {skill['tags']}",
+        f"  Triggers: {skill['trigger_patterns']}",
+        f"  Source sessions: {skill['source_sessions']}",
+        f"  Linked learnings: {skill['linked_learnings']}",
+        f"  Stats: {skill['use_count']} uses, {skill['success_count']} success, {skill['fail_count']} fail",
+        f"  Created: {skill['created_at']}",
+        f"  Last used: {skill['last_used_at'] or 'never'}",
+    ]
+
+    if recent_uses:
+        lines.append("\n  RECENT USAGE:")
+        for u in recent_uses:
+            u = dict(u)
+            status = "✓" if u['success'] else "✗"
+            lines.append(f"    {status} {u['created_at']} — {u['context'][:60] or '(no context)'}")
+            if u.get('notes'):
+                lines.append(f"      Notes: {u['notes'][:80]}")
+
+    return "\n".join(lines)
+
+
+def handle_skill_result(id: str, success: bool = True, context: str = '', notes: str = '') -> str:
+    """Record the result of using a skill. Auto-promotes/degrades based on trust rules.
+
+    Call this AFTER following a skill's procedure to record whether it worked.
+    - Success: trust +5. After 2+ successes in distinct contexts: draft → published.
+    - Failure: trust -10. If trust < 20: → archived.
+
+    Args:
+        id: Skill ID.
+        success: Whether the skill's procedure worked correctly.
+        context: What task you were doing (used for distinct-context promotion).
+        notes: Additional notes (especially useful for failures — what went wrong).
+    """
+    result = record_skill_usage(skill_id=id, success=success, context=context, notes=notes)
+    if "error" in result:
+        return f"ERROR: {result['error']}"
+
+    promotion = result.pop('_promotion', None)
+    status = "SUCCESS" if success else "FAILURE"
+    msg = f"Skill {id} usage recorded: {status} (trust={result['trust_score']})"
+    if promotion:
+        msg += f"\n  ⚡ PROMOTION: {promotion}"
+    return msg
+
+
+def handle_skill_list(level: str = '', tag: str = '') -> str:
+    """List all skills, optionally filtered by level or tag.
+
+    Args:
+        level: Filter by level — trace, draft, published, archived.
+        tag: Filter by tag (e.g., 'chrome', 'deploy', 'shopify').
+    """
+    skills = list_skills(level=level, tag=tag)
+    if not skills:
+        filters = []
+        if level: filters.append(f"level={level}")
+        if tag: filters.append(f"tag={tag}")
+        return f"No skills found{' (' + ', '.join(filters) + ')' if filters else ''}."
+
+    lines = [f"SKILLS ({len(skills)}):"]
+    for s in skills:
+        fp = f" → {s['file_path']}" if s.get('file_path') else ""
+        used = f", last={s['last_used_at'][:10]}" if s.get('last_used_at') else ""
+        lines.append(
+            f"  [{s['id']}] {s['name']} ({s['level']}, trust={s['trust_score']}, "
+            f"used={s['use_count']}x{used}){fp}"
+        )
+    return "\n".join(lines)
+
+
+def handle_skill_merge(id1: str, id2: str, keep_id: str = '') -> str:
+    """Merge two similar skills into one. Combines tags, triggers, usage history.
+
+    The survivor keeps the higher trust score and all combined metadata.
+    The donor is deleted.
+
+    Args:
+        id1: First skill ID.
+        id2: Second skill ID.
+        keep_id: Which one to keep (default: higher trust score).
+    """
+    result = merge_skills(id1, id2, keep_id=keep_id)
+    if "error" in result:
+        return f"ERROR: {result['error']}"
+
+    merged_from = result.pop('_merged_from', '?')
+    return (
+        f"Skills merged. Kept {result['id']}, deleted {merged_from}.\n"
+        f"  Trust: {result['trust_score']}, Uses: {result['use_count']}, "
+        f"Tags: {result['tags']}"
+    )
+
+
+def handle_skill_stats() -> str:
+    """Show aggregate skill statistics: total count, by level, avg trust, usage rates."""
+    stats = get_skill_stats()
+    levels = stats.get('by_level', {})
+    lines = [
+        "SKILL STATS:",
+        f"  Total: {stats['total']}",
+        f"  By level: {', '.join(f'{k}={v}' for k, v in sorted(levels.items()))}",
+        f"  Avg trust: {stats['avg_trust']}",
+        f"  Total uses: {stats['total_uses']} (success rate: {stats['success_rate']}%)",
+        f"  Uses last 7d: {stats['uses_last_7d']}",
+    ]
+    return "\n".join(lines)
+
+
+# Plugin registration — TOOLS array consumed by plugin_loader.py
+TOOLS = [
+    (handle_skill_create, "nexo_skill_create",
+     "Create a new skill (reusable procedure). Skills are step-by-step instructions for complex tasks. "
+     "Auto-promoted from draft→published after 2+ successful uses. ID must start with 'SK-'."),
+
+    (handle_skill_match, "nexo_skill_match",
+     "Find skills matching a task description. Call BEFORE starting multi-step tasks "
+     "to check if a reusable procedure exists. Returns top-3 matches by trust score."),
+
+    (handle_skill_get, "nexo_skill_get",
+     "Get a skill's full details including procedure, tags, triggers, and usage history."),
+
+    (handle_skill_result, "nexo_skill_result",
+     "Record the result of using a skill (success/failure). Auto-promotes draft→published "
+     "after 2+ successes, auto-archives if trust drops below 20."),
+
+    (handle_skill_list, "nexo_skill_list",
+     "List all skills, optionally filtered by level (trace/draft/published/archived) or tag."),
+
+    (handle_skill_merge, "nexo_skill_merge",
+     "Merge two similar skills into one. Combines tags, triggers, and usage history. "
+     "Survivor keeps the higher trust score."),
+
+    (handle_skill_stats, "nexo_skill_stats",
+     "Show aggregate skill statistics: count by level, average trust, usage rates."),
+]

package/src/plugins/update.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 """Update plugin — pull latest code, backup DBs, run migrations, verify."""
 import json
 import os

package/src/scripts/deep-sleep/apply_findings.py

@@ -1,4 +1,5 @@
 #!/usr/bin/env python3
+from __future__ import annotations
 """
 Deep Sleep v2 -- Phase 4: Apply synthesized findings.
 
@@ -135,21 +136,52 @@ def update_calibration_mood(synthesis: dict) -> dict:
         # Keep last 30 days
         cal["mood_history"] = cal["mood_history"][-30:]
 
-        # Apply calibration recommendation if any
+        # Apply calibration recommendation automatically
         rec = emotional_day.get("calibration_recommendation")
         if rec and rec != "null":
-            if "calibration_notes" not in cal:
-                cal["calibration_notes"] = []
-            cal["calibration_notes"].append({
+            applied_changes = []
+
+            # Parse and apply known calibration adjustments
+            rec_lower = rec.lower()
+            personality = cal.get("personality", {})
+
+            # Autonomy adjustments
+            if "autonomy" in rec_lower or "autonomía" in rec_lower:
+                if any(w in rec_lower for w in ["full", "más autonomía", "subir", "increase"]):
+                    personality["autonomy"] = "full"
+                    applied_changes.append("autonomy → full")
+                elif any(w in rec_lower for w in ["conservative", "reducir", "bajar"]):
+                    personality["autonomy"] = "conservative"
+                    applied_changes.append("autonomy → conservative")
+
+            # Communication adjustments
+            if any(w in rec_lower for w in ["concis", "breve", "shorter", "telegráf"]):
+                personality["communication"] = "concise"
+                applied_changes.append("communication → concise")
+            elif any(w in rec_lower for w in ["detail", "explicar más", "más contexto"]):
+                personality["communication"] = "detailed"
+                applied_changes.append("communication → detailed")
+
+            # Proactivity adjustments
+            if any(w in rec_lower for w in ["más proactiv", "proactive", "anticipar"]):
+                personality["proactivity"] = "proactive"
+                applied_changes.append("proactivity → proactive")
+
+            cal["personality"] = personality
+
+            # Log the recommendation and what was applied
+            if "calibration_log" not in cal:
+                cal["calibration_log"] = []
+            cal["calibration_log"].append({
                 "date": synthesis.get("date", ""),
                 "recommendation": rec,
-                "applied": False,
+                "applied": applied_changes if applied_changes else ["noted, no auto-applicable changes"],
             })
-            # Keep last 10
-            cal["calibration_notes"] = cal["calibration_notes"][-10:]
+            cal["calibration_log"] = cal["calibration_log"][-20:]
 
         calibration_file.write_text(json.dumps(cal, indent=2, ensure_ascii=False))
-        return {"success": True, "mood_score": emotional_day.get("mood_score")}
+        changes_str = ", ".join(applied_changes) if rec and applied_changes else "none"
+        return {"success": True, "mood_score": emotional_day.get("mood_score"), "calibration_applied": changes_str}
     except Exception as e:
         return {"success": False, "error": str(e)}
 
@@ -203,6 +235,52 @@ def calibrate_trust_score(synthesis: dict, target_date: str) -> dict:
         return {"success": False, "error": str(e)}
 
 
+def create_skill(skill_data: dict) -> dict:
+    """Create a skill in nexo.db from Deep Sleep extraction."""
+    if not NEXO_DB.exists():
+        return {"success": False, "error": "nexo.db not found"}
+    try:
+        import hashlib
+        skill_id = skill_data.get("id", "")
+        if not skill_id:
+            skill_id = "SK-DS-" + hashlib.md5(
+                skill_data.get("name", "").encode()
+            ).hexdigest()[:8].upper()
+
+        name = skill_data.get("name", "")
+        description = skill_data.get("description", "")
+        tags = json.dumps(skill_data.get("tags", []))
+        trigger_patterns = json.dumps(skill_data.get("trigger_patterns", []))
+        source_sessions = json.dumps(skill_data.get("source_sessions", []))
+        steps = skill_data.get("steps", [])
+        gotchas = skill_data.get("gotchas", [])
+
+        # Build file content for the skill .md file
+        steps_md = "\n".join(f"{i+1}. {s}" for i, s in enumerate(steps))
+        gotchas_md = "\n".join(f"- {g}" for g in gotchas) if gotchas else "None"
+
+        conn = sqlite3.connect(str(NEXO_DB))
+        # Check if skill already exists
+        existing = conn.execute("SELECT id FROM skills WHERE id = ?", (skill_id,)).fetchone()
+        if existing:
+            conn.close()
+            return {"success": False, "error": f"Skill {skill_id} already exists", "id": skill_id}
+
+        now = datetime.now().isoformat(timespec='seconds')
+        conn.execute(
+            """INSERT INTO skills
+               (id, name, description, level, trust_score, tags, trigger_patterns,
+                source_sessions, linked_learnings, created_at, updated_at)
+               VALUES (?, ?, ?, 'draft', 50, ?, ?, ?, '[]', ?, ?)""",
+            (skill_id, name, description, tags, trigger_patterns, source_sessions, now, now),
+        )
+        conn.commit()
+        conn.close()
+        return {"success": True, "id": skill_id, "name": name}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
 def create_abandoned_followups(synthesis: dict) -> list[dict]:
     """Create followups for truly abandoned projects."""
     results = []
@@ -494,6 +572,11 @@ def apply_action(action: dict, run_id: str) -> dict:
         log_entry["status"] = "applied" if result.get("success") else "error"
         log_entry["details"] = result
 
+    elif action_type == "skill_create":
+        result = create_skill(content)
+        log_entry["status"] = "applied" if result.get("success") else "error"
+        log_entry["details"] = result
+
     elif action_type == "morning_briefing_item":
         # These are included in the briefing file, not applied separately
         log_entry["status"] = "included_in_briefing"
@@ -585,6 +668,26 @@ def main():
     else:
         print(f"  Trust skip: {trust_result.get('error', '?')}")
 
+    # Create skills from synthesis
+    skills_data = synthesis.get("skills", [])
+    if skills_data:
+        print(f"[apply] Creating {len(skills_data)} skill(s)...")
+        for skill_data in skills_data:
+            if skill_data.get("confidence", 0) < 0.7:
+                continue
+            if skill_data.get("merge_with"):
+                print(f"  Skip {skill_data.get('id', '?')}: merge candidate (needs runtime merge)")
+                continue
+            result = create_skill(skill_data)
+            if result.get("success"):
+                stats["applied"] += 1
+                print(f"  Skill created: {result['id']} — {result.get('name', '')[:50]}")
+            elif "already exists" in result.get("error", ""):
+                stats["skipped_dedupe"] += 1
+            else:
+                stats["errors"] += 1
+                print(f"  Skill error: {result.get('error', 'unknown')}", file=sys.stderr)
+
     # Create followups for abandoned projects
     abandoned_results = create_abandoned_followups(synthesis)
     for r in abandoned_results: