nexo-brain 7.28.0 → 7.29.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.28.0",
+  "version": "7.29.0",
   "description": "Local cognitive runtime for Claude Code \u2014 persistent memory, overnight learning, doctor diagnostics, personal scripts, recovery-aware jobs, startup preflight, and optional dashboard/power helper.",
   "author": {
     "name": "NEXO Brain",

package/README.md

@@ -18,7 +18,9 @@
 
 [Watch the overview video](https://nexo-brain.com/watch/) · [Watch on YouTube](https://www.youtube.com/watch?v=i2lkGhKyVqI) · [Open the infographic](https://nexo-brain.com/assets/nexo-brain-infographic-v5.png)
 
-Version `7.28.0` is the current packaged-runtime line. Minor release over v7.27.6 - the Brain memory architecture now links action authorship, reasons, operational state, entity profiles, failure prevention, semantic layers, and release-gated runtime memory benchmarks.
+Version `7.29.0` is the current packaged-runtime line. Minor release over v7.28.0 - the morning briefing now has structured content preferences, Desktop-facing briefing presentation state, and per-account email signature support.
+
+Previously in `7.28.0`: minor release over v7.27.6 - the Brain memory architecture now links action authorship, reasons, operational state, entity profiles, failure prevention, semantic layers, and release-gated runtime memory benchmarks.
 
 Previously in `7.27.6`: patch release over v7.27.5 - operational memory continuity now persists promises as commitments, routes pre-answer questions through evidence-backed memory, and exposes observation-queue convergence in health checks.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.28.0",
+  "version": "7.29.0",
   "mcpName": "io.github.wazionapps/nexo",
   "description": "NEXO Brain — Shared brain for AI agents. Persistent memory, semantic RAG, natural forgetting, metacognitive guard, trust scoring, 150+ MCP tools. Works with Claude Code, Codex, Claude Desktop & any MCP client. 100% local, free.",
   "homepage": "https://nexo-brain.com",

package/src/automation_controls.py

@@ -672,10 +672,17 @@ def get_script_runtime_contract(name: str) -> dict[str, Any]:
         blocked_reason = str(recipient_status.get("reason") or "")
         blocked_reason_code = str(recipient_status.get("reason_code") or "")
 
+    try:
+        from automation_preferences import supports_automation_preferences
+        preferences_supported = supports_automation_preferences(clean_name)
+    except Exception:
+        preferences_supported = False
+
     return {
         "name": clean_name,
         "toggleable_core": is_toggleable_core_script(clean_name),
         "supports_extra_instructions": supports_operator_extra_instructions(clean_name),
+        "supports_automation_preferences": preferences_supported,
         "schedule_configurable": bool(schedule_state.get("schedule_configurable")),
         "schedule_type": str(schedule_state.get("schedule_type") or ""),
         "schedule_source": str(schedule_state.get("schedule_source") or ""),

package/src/automation_preferences.py

@@ -0,0 +1,323 @@
+"""Structured operator preferences for product automations."""
+
+from __future__ import annotations
+
+import copy
+import json
+import unicodedata
+from pathlib import Path
+from typing import Any
+
+
+AUTOMATION_PREFERENCES_METADATA_KEY = "automation_preferences"
+SUPPORTED_AUTOMATIONS = {"morning-agent"}
+
+
+MORNING_AGENT_SCHEMA: dict[str, Any] = {
+    "schema_version": 1,
+    "automation": "morning-agent",
+    "title": "Morning briefing content",
+    "groups": [
+        {
+            "id": "content",
+            "label": "Content",
+            "items": [
+                {"id": "priorities", "type": "boolean", "label": "Priorities", "default": True},
+                {"id": "agenda", "type": "boolean", "label": "Agenda", "default": True},
+                {"id": "reminders", "type": "boolean", "label": "Reminders and tasks", "default": True},
+                {"id": "followups", "type": "boolean", "label": "Follow-ups", "default": True},
+                {"id": "decisions", "type": "boolean", "label": "Recent decisions", "default": True},
+                {"id": "email_activity", "type": "boolean", "label": "Recent sent email", "default": True},
+                {"id": "blockers", "type": "boolean", "label": "Blockers and risks", "default": True},
+                {"id": "internal_refs", "type": "boolean", "label": "Internal references", "default": False},
+                {
+                    "id": "news",
+                    "type": "boolean",
+                    "label": "News",
+                    "default": False,
+                    "disabled": True,
+                    "disabled_reason": "No verified news source is connected yet.",
+                },
+                {
+                    "id": "weather",
+                    "type": "boolean",
+                    "label": "Weather",
+                    "default": False,
+                    "disabled": True,
+                    "disabled_reason": "No verified weather source is connected yet.",
+                },
+            ],
+        },
+        {
+            "id": "style",
+            "label": "Style",
+            "items": [
+                {
+                    "id": "length",
+                    "type": "choice",
+                    "label": "Length",
+                    "default": "normal",
+                    "options": ["short", "normal", "detailed"],
+                },
+                {
+                    "id": "tone",
+                    "type": "choice",
+                    "label": "Tone",
+                    "default": "direct",
+                    "options": ["direct", "warm", "executive", "personal"],
+                },
+                {
+                    "id": "format",
+                    "type": "choice",
+                    "label": "Format",
+                    "default": "sections",
+                    "options": ["sections", "bullets", "narrative"],
+                },
+            ],
+        },
+        {
+            "id": "delivery",
+            "label": "Delivery",
+            "items": [
+                {
+                    "id": "quiet_days",
+                    "type": "choice",
+                    "label": "Quiet days",
+                    "default": "summary_if_anything_important",
+                    "options": ["always_send", "summary_if_anything_important", "skip_if_empty"],
+                },
+                {
+                    "id": "audience",
+                    "type": "choice",
+                    "label": "User type",
+                    "default": "operator",
+                    "options": ["operator", "founder", "student", "sales", "technical", "personal"],
+                },
+            ],
+        },
+    ],
+}
+
+
+def _schema_for(name: str) -> dict[str, Any] | None:
+    clean = normalize_automation_name(name)
+    if clean == "morning-agent":
+        return copy.deepcopy(MORNING_AGENT_SCHEMA)
+    return None
+
+
+def normalize_automation_name(name: str) -> str:
+    return str(name or "").strip().lower().replace("_", "-")
+
+
+def supports_automation_preferences(name: str) -> bool:
+    return normalize_automation_name(name) in SUPPORTED_AUTOMATIONS
+
+
+def get_automation_preference_schema(name: str) -> dict[str, Any]:
+    schema = _schema_for(name)
+    if not schema:
+        return {
+            "schema_version": 1,
+            "automation": normalize_automation_name(name),
+            "title": "Automation content",
+            "groups": [],
+        }
+    return schema
+
+
+def _iter_schema_items(schema: dict[str, Any]):
+    for group in list(schema.get("groups") or []):
+        for item in list(group.get("items") or []):
+            if isinstance(item, dict) and item.get("id"):
+                yield item
+
+
+def default_automation_preferences(name: str) -> dict[str, Any]:
+    schema = get_automation_preference_schema(name)
+    values: dict[str, Any] = {}
+    for item in _iter_schema_items(schema):
+        values[str(item["id"])] = copy.deepcopy(item.get("default"))
+    return {
+        "schema_version": int(schema.get("schema_version") or 1),
+        "automation": normalize_automation_name(name),
+        "values": values,
+    }
+
+
+def validate_automation_preferences(name: str, payload: dict[str, Any] | None) -> dict[str, Any]:
+    schema = get_automation_preference_schema(name)
+    defaults = default_automation_preferences(name)
+    source_values = {}
+    if isinstance(payload, dict):
+        if isinstance(payload.get("values"), dict):
+            source_values = payload.get("values") or {}
+        else:
+            source_values = payload
+    values = dict(defaults["values"])
+    warnings: list[str] = []
+    for item in _iter_schema_items(schema):
+        key = str(item["id"])
+        if key not in source_values:
+            continue
+        if item.get("disabled"):
+            values[key] = copy.deepcopy(item.get("default"))
+            warnings.append(f"{key}: disabled")
+            continue
+        kind = str(item.get("type") or "text")
+        raw_value = source_values.get(key)
+        if kind == "boolean":
+            values[key] = bool(raw_value)
+        elif kind == "choice":
+            options = [str(v) for v in list(item.get("options") or [])]
+            clean = str(raw_value or "").strip()
+            if clean in options:
+                values[key] = clean
+            else:
+                warnings.append(f"{key}: invalid choice")
+        elif kind == "number":
+            try:
+                values[key] = int(raw_value)
+            except Exception:
+                warnings.append(f"{key}: invalid number")
+        else:
+            values[key] = str(raw_value or "").strip()[:1000]
+    return {
+        "schema_version": int(schema.get("schema_version") or 1),
+        "automation": normalize_automation_name(name),
+        "values": values,
+        "warnings": warnings,
+    }
+
+
+def _script_row_for(name_or_path: str) -> tuple[dict, dict] | tuple[None, None]:
+    from db import init_db
+    from db._personal_scripts import get_personal_script
+    from script_registry import resolve_script, sync_personal_scripts
+
+    init_db()
+    sync_personal_scripts()
+    script = get_personal_script(name_or_path, include_core=True) or resolve_script(name_or_path)
+    if not script and normalize_automation_name(name_or_path) == "morning-agent":
+        script_path = Path(__file__).resolve().parent / "scripts" / "nexo-morning-agent.py"
+        script = {
+            "name": "morning-agent",
+            "path": str(script_path),
+            "description": "Generate and send the operator's daily morning briefing email.",
+            "runtime": "python",
+            "core": True,
+            "metadata": {},
+            "origin": "core",
+        }
+    if not script:
+        return None, None
+    existing = get_personal_script(script.get("path", ""), include_core=True) or script
+    return script, existing
+
+
+def get_automation_preferences(name_or_path: str) -> dict[str, Any]:
+    clean_name = normalize_automation_name(name_or_path)
+    script, existing = _script_row_for(name_or_path)
+    if script:
+        clean_name = normalize_automation_name(script.get("name") or clean_name)
+    metadata = (existing or {}).get("metadata") if isinstance((existing or {}).get("metadata"), dict) else {}
+    stored = metadata.get(AUTOMATION_PREFERENCES_METADATA_KEY) if isinstance(metadata, dict) else {}
+    validated = validate_automation_preferences(clean_name, stored if isinstance(stored, dict) else {})
+    return {
+        "ok": True,
+        "name": clean_name,
+        "schema": get_automation_preference_schema(clean_name),
+        "preferences": validated,
+        "supports_automation_preferences": supports_automation_preferences(clean_name),
+    }
+
+
+def set_automation_preferences(name_or_path: str, payload: dict[str, Any]) -> dict[str, Any]:
+    from db._personal_scripts import upsert_personal_script
+
+    script, existing = _script_row_for(name_or_path)
+    if not script:
+        return {"ok": False, "error": f"Automation not found: {name_or_path}"}
+    clean_name = normalize_automation_name(script.get("name") or name_or_path)
+    if not supports_automation_preferences(clean_name):
+        return {"ok": False, "error": "This automation does not support structured preferences."}
+    validated = validate_automation_preferences(clean_name, payload)
+    metadata = dict((existing or script).get("metadata") or {})
+    metadata[AUTOMATION_PREFERENCES_METADATA_KEY] = {
+        "schema_version": validated["schema_version"],
+        "values": validated["values"],
+    }
+    script_origin = "core" if (bool(script.get("core")) or str(script.get("origin") or "") == "core") else "user"
+    upsert_personal_script(
+        name=script.get("name", clean_name),
+        path=script.get("path", ""),
+        description=script.get("description", ""),
+        runtime=script.get("runtime", "unknown"),
+        metadata=metadata,
+        created_by="nexo-core" if script_origin == "core" else "manual",
+        source="core-toggle" if script_origin == "core" else "filesystem",
+        origin=script_origin,
+        enabled=bool((existing or script).get("enabled", True)),
+        has_inline_metadata=bool(script.get("metadata")),
+    )
+    return {
+        "ok": True,
+        "name": clean_name,
+        "preferences": validated,
+        "supports_automation_preferences": True,
+    }
+
+
+def search_automation_preference_schema(name: str, query: str) -> list[dict[str, Any]]:
+    clean_query = _fold_text(query)
+    if not clean_query:
+        return []
+    matches: list[dict[str, Any]] = []
+    for group in list(get_automation_preference_schema(name).get("groups") or []):
+        for item in list(group.get("items") or []):
+            text = " ".join([
+                str(item.get("id") or ""),
+                str(item.get("label") or ""),
+                str(item.get("disabled_reason") or ""),
+                str(group.get("label") or ""),
+            ])
+            if clean_query in _fold_text(text):
+                matches.append({"group": group.get("id"), **item})
+    return matches
+
+
+def _fold_text(value: str) -> str:
+    normalized = unicodedata.normalize("NFKD", str(value or ""))
+    asciiish = "".join(ch for ch in normalized if not unicodedata.combining(ch))
+    return asciiish.casefold()
+
+
+def format_automation_preferences_prompt_block(name_or_path: str) -> str:
+    result = get_automation_preferences(name_or_path)
+    if not result.get("supports_automation_preferences"):
+        return ""
+    prefs = result.get("preferences") or {}
+    values = prefs.get("values") if isinstance(prefs, dict) else {}
+    if not isinstance(values, dict):
+        values = {}
+    compact = json.dumps(values, ensure_ascii=False, sort_keys=True)
+    return (
+        "\n== STRUCTURED CONTENT PREFERENCES FOR THIS AUTOMATION ==\n"
+        f"{compact}\n"
+        "Use these preferences to decide what to include, omit, and emphasize. "
+        "Disabled/unavailable data sources must not be invented.\n"
+    )
+
+
+__all__ = [
+    "AUTOMATION_PREFERENCES_METADATA_KEY",
+    "default_automation_preferences",
+    "format_automation_preferences_prompt_block",
+    "get_automation_preference_schema",
+    "get_automation_preferences",
+    "normalize_automation_name",
+    "search_automation_preference_schema",
+    "set_automation_preferences",
+    "supports_automation_preferences",
+    "validate_automation_preferences",
+]

package/src/cli.py

@@ -1059,6 +1059,89 @@ def _automations_set_schedule(args):
     return 0
 
 
+def _automations_preference_schema(args):
+    from automation_preferences import get_automation_preference_schema, search_automation_preference_schema
+
+    query = str(getattr(args, "query", "") or "").strip()
+    schema = get_automation_preference_schema(args.name)
+    payload = {
+        "ok": True,
+        "name": args.name,
+        "schema": schema,
+        "matches": search_automation_preference_schema(args.name, query) if query else [],
+    }
+    if args.json:
+        print(json.dumps(payload, indent=2, ensure_ascii=False))
+        return 0
+    print(schema.get("title") or args.name)
+    for group in list(schema.get("groups") or []):
+        print(f"\n{group.get('label') or group.get('id')}")
+        for item in list(group.get("items") or []):
+            marker = " (unavailable)" if item.get("disabled") else ""
+            print(f"  - {item.get('label') or item.get('id')}{marker}")
+    return 0
+
+
+def _automations_preferences(args):
+    from script_registry import get_automation_preference_contract, set_automation_preference_contract
+
+    has_payload = any([
+        str(getattr(args, "payload", "") or "").strip(),
+        str(getattr(args, "payload_file", "") or "").strip(),
+        bool(getattr(args, "payload_stdin", False)),
+    ])
+    if has_payload:
+        payload, error_code = _load_json_payload_arg(args, command_name="automations preferences")
+        if error_code is not None:
+            print(json.dumps(payload, indent=2, ensure_ascii=False))
+            return error_code
+        result = set_automation_preference_contract(args.name, payload)
+    else:
+        result = get_automation_preference_contract(args.name)
+    if args.json:
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+        return 0 if result.get("ok", True) else 1
+    if not result.get("ok", True):
+        print(result.get("error", "Could not update automation preferences"), file=sys.stderr)
+        return 1
+    prefs = result.get("preferences") or {}
+    values = prefs.get("values") if isinstance(prefs, dict) else {}
+    print(f"Content preferences for {result.get('name') or args.name}:")
+    for key, value in sorted((values or {}).items()):
+        print(f"  {key}: {value}")
+    return 0
+
+
+def _morning_briefing(args):
+    from morning_briefing import latest_morning_briefing, mark_desktop_state
+
+    command = str(getattr(args, "morning_briefing_command", "") or "").strip()
+    if command == "latest":
+        result = latest_morning_briefing(include_non_sent=bool(getattr(args, "include_non_sent", False)))
+    elif command in {"mark-shown", "mark-opened", "mark-dismissed"}:
+        action = command.replace("mark-", "")
+        result = mark_desktop_state(action, briefing_id=getattr(args, "briefing_id", None))
+    else:
+        result = {"ok": False, "error": "Unknown morning briefing command."}
+
+    if getattr(args, "json", False):
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+        return 0 if result.get("ok", True) else 1
+    if not result.get("ok", True):
+        print(result.get("error", "Could not read morning briefing"), file=sys.stderr)
+        return 1
+    briefing = result.get("briefing")
+    if not briefing:
+        print("No morning briefing is available yet.")
+        return 0
+    print(briefing.get("subject") or "Morning briefing")
+    body = str(briefing.get("body_text") or "").strip()
+    if body:
+        print()
+        print(body)
+    return 0
+
+
 def _agents_list(args):
     from script_registry import list_agents
 
@@ -4069,6 +4152,34 @@ def main():
     automations_schedule_group.add_argument("--reset", action="store_true", help="Restore the shipped default cadence")
     automations_schedule_p.add_argument("--json", action="store_true", help="JSON output")
 
+    automations_schema_p = automations_sub.add_parser(
+        "preference-schema",
+        help="Read structured content options for an automation",
+    )
+    automations_schema_p.add_argument("name", help="Automation name or path")
+    automations_schema_p.add_argument("--query", default="", help="Local search inside the preference options")
+    automations_schema_p.add_argument("--json", action="store_true", help="JSON output")
+
+    automations_preferences_p = automations_sub.add_parser(
+        "preferences",
+        help="Read or update structured content preferences for an automation",
+    )
+    automations_preferences_p.add_argument("name", help="Automation name or path")
+    automations_preferences_p.add_argument("--payload", default="", help="JSON object to persist")
+    automations_preferences_p.add_argument("--payload-file", default="", help="Path to a JSON object to persist")
+    automations_preferences_p.add_argument("--payload-stdin", action="store_true", help="Read JSON object from stdin")
+    automations_preferences_p.add_argument("--json", action="store_true", help="JSON output")
+
+    morning_briefing_parser = sub.add_parser("morning-briefing", help="Read the latest operator morning briefing")
+    morning_briefing_sub = morning_briefing_parser.add_subparsers(dest="morning_briefing_command")
+    morning_latest_p = morning_briefing_sub.add_parser("latest", help="Show the latest sent morning briefing")
+    morning_latest_p.add_argument("--include-non-sent", action="store_true", help="Include failed/in-progress rows for diagnostics")
+    morning_latest_p.add_argument("--json", action="store_true", help="JSON output")
+    for mark_command in ("mark-shown", "mark-opened", "mark-dismissed"):
+        mark_p = morning_briefing_sub.add_parser(mark_command, help=f"{mark_command.replace('-', ' ')} for Desktop")
+        mark_p.add_argument("--id", dest="briefing_id", type=int, default=None, help="Specific briefing id")
+        mark_p.add_argument("--json", action="store_true", help="JSON output")
+
     core_schedules_parser = sub.add_parser("core-schedules", help="Manage structural core cron cadences")
     core_schedules_sub = core_schedules_parser.add_subparsers(dest="core_schedules_command")
 
@@ -4658,8 +4769,17 @@ def main():
             return _automations_set_instructions(args)
         elif args.automations_command == "schedule":
             return _automations_set_schedule(args)
+        elif args.automations_command == "preference-schema":
+            return _automations_preference_schema(args)
+        elif args.automations_command == "preferences":
+            return _automations_preferences(args)
         automations_parser.print_help()
         return 0
+    elif args.command == "morning-briefing":
+        if args.morning_briefing_command in {"latest", "mark-shown", "mark-opened", "mark-dismissed"}:
+            return _morning_briefing(args)
+        morning_briefing_parser.print_help()
+        return 0
     elif args.command == "core-schedules":
         if args.core_schedules_command == "list":
             return _core_schedules_list(args)

package/src/cli_email.py

@@ -222,6 +222,7 @@ def _account_to_public_dict(account: dict) -> dict:
     if not isinstance(metadata, dict):
         metadata = {}
     legacy_migrated = bool(metadata.get("migrated_from_legacy_email_config"))
+    signature = str(metadata.get("signature") or "").strip()
     return {
         "id": account.get("id"),
         "label": account.get("label"),
@@ -244,6 +245,8 @@ def _account_to_public_dict(account: dict) -> dict:
         "is_default": bool(account.get("is_default")),
         "has_credential": bool(account.get("credential_service")
                                and account.get("credential_key")),
+        "signature_configured": bool(signature),
+        "signature_preview": " ".join(signature.split())[:120],
     }
 
 
@@ -626,6 +629,82 @@ def cmd_email_set_enabled(args) -> int:
     return 0
 
 
+def cmd_email_signature(args) -> int:
+    json_mode = bool(getattr(args, "json", False))
+    account_id, label = _selector_from_args(args)
+    if account_id is None and not label:
+        msg = _selector_usage("signature")
+        if json_mode:
+            _emit_json({"ok": False, "message": msg})
+        else:
+            print(msg)
+        return 1
+
+    from db import init_db
+    from db._email_accounts import add_email_account, get_email_account, get_email_account_by_id
+
+    init_db()
+    acc = get_email_account_by_id(account_id) if account_id is not None else get_email_account(label)
+    if not acc:
+        selector = f"id={account_id}" if account_id is not None else label
+        msg = f"Account '{selector}' not found."
+        if json_mode:
+            _emit_json({"ok": False, "message": msg})
+        else:
+            print(f"✗ {msg}")
+        return 1
+
+    metadata = dict(acc.get("metadata") or {})
+    wants_set = any([
+        getattr(args, "text", None) is not None,
+        bool(getattr(args, "stdin", False)),
+        bool(getattr(args, "clear", False)),
+    ])
+    if wants_set:
+        if getattr(args, "clear", False):
+            metadata.pop("signature", None)
+        elif getattr(args, "stdin", False):
+            metadata["signature"] = sys.stdin.read().strip()
+        else:
+            metadata["signature"] = str(getattr(args, "text", "") or "").strip()
+        acc = add_email_account(
+            label=acc.get("label", ""),
+            email=acc.get("email", ""),
+            imap_host=acc.get("imap_host", ""),
+            imap_port=int(acc.get("imap_port") or 993),
+            smtp_host=acc.get("smtp_host", ""),
+            smtp_port=int(acc.get("smtp_port") or 465),
+            credential_service=acc.get("credential_service", ""),
+            credential_key=acc.get("credential_key", ""),
+            operator_email=acc.get("operator_email", ""),
+            trusted_domains=list(acc.get("trusted_domains") or []),
+            role=acc.get("role", "both"),
+            enabled=bool(acc.get("enabled", True)),
+            metadata=metadata,
+            account_type=acc.get("account_type", "agent"),
+            description=acc.get("description", ""),
+            can_read=bool(acc.get("can_read")),
+            can_send=bool(acc.get("can_send")),
+            is_default=bool(acc.get("is_default")),
+        )
+
+    signature = str((acc.get("metadata") or {}).get("signature") or "").strip()
+    payload = {
+        "ok": True,
+        "account": _account_to_public_dict(acc),
+        "signature": signature,
+        "cleared": wants_set and not bool(signature),
+    }
+    if json_mode:
+        _emit_json(payload)
+    else:
+        if wants_set:
+            print("Signature cleared." if not signature else "Signature saved.")
+        else:
+            print(signature or "(no signature configured)")
+    return 0
+
+
 def register_email_parser(subparsers) -> None:
     """Hook called by cli.py to add the `email` subcommand tree."""
     p = subparsers.add_parser("email", help="Manage NEXO email accounts")
@@ -704,6 +783,21 @@ def register_email_parser(subparsers) -> None:
     s.add_argument("--json", dest="json", action="store_true")
     s.set_defaults(func=cmd_email_set_enabled, enabled=False)
 
+    s = sub.add_parser("signature", help="Read or edit the signature for an account")
+    s.add_argument("label_pos", nargs="?", default=None,
+                   help="Account label (legacy positional)")
+    s.add_argument("--label", dest="label", default=None)
+    s.add_argument("--id", dest="account_id", type=int, default=None)
+    sig_group = s.add_mutually_exclusive_group()
+    sig_group.add_argument("--text", dest="text", default=None,
+                           help="Signature text to save")
+    sig_group.add_argument("--stdin", dest="stdin", action="store_true",
+                           help="Read signature text from stdin")
+    sig_group.add_argument("--clear", dest="clear", action="store_true",
+                           help="Clear the saved signature")
+    s.add_argument("--json", dest="json", action="store_true")
+    s.set_defaults(func=cmd_email_signature)
+
 
 __all__ = [
     "cmd_email_setup",
@@ -712,5 +806,6 @@ __all__ = [
     "cmd_email_test",
     "cmd_email_remove",
     "cmd_email_set_enabled",
+    "cmd_email_signature",
     "register_email_parser",
 ]