seif-cli 0.3.0__tar.gz → 0.3.1__tar.gz

{seif_cli-0.3.0/src/seif_cli.egg-info → seif_cli-0.3.1}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: seif-cli
-Version: 0.3.0
+Version: 0.3.1
 Summary: Measure AI output quality, protect sensitive data, watch your AI environment resonate. Quality Gate, Classification, Sentinel & Auto-Healing, SEIF OS.
 Author: André Cunha Antero de Carvalho
 License: CC-BY-NC-SA-4.0
-Project-URL: Homepage, https://github.com/and2carvalho/seif
-Project-URL: Documentation, https://github.com/and2carvalho/seif
+Project-URL: Homepage, https://seifprotocol.com
+Project-URL: Documentation, https://seifprotocol.com/docs
 Project-URL: Repository, https://github.com/and2carvalho/seif
-Project-URL: Live Demo, https://seif-framework.streamlit.app
+Project-URL: Changelog, https://github.com/and2carvalho/seif/releases
 Keywords: ai-quality,llm-guardrails,ai-consensus,data-classification,context-management,ai-safety,multi-ai,quality-gate,prompt-evaluation,ai-grounding,resonance,sentinel,self-healing,seif-os,circuit-state,ai-observability
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
@@ -39,7 +39,7 @@ Requires-Dist: qrcode[pil]>=7.4; extra == "qr"
 Requires-Dist: Pillow>=10.0; extra == "qr"
 Requires-Dist: pyzbar>=0.1.9; extra == "qr"
 Provides-Extra: all
-Requires-Dist: seif-cli[consensus,generators,qr,telegram,web]; extra == "all"
+Requires-Dist: seif[consensus,generators,qr,telegram,web]; extra == "all"
 Dynamic: license-file
 
 # SEIF — AI Quality, Protection, and Resonance
@@ -231,6 +231,7 @@ seif --sync                           # re-sync git context
 seif --compress                       # 93% context compression
 seif --ingest daily.txt               # ingest external source
 seif --workspace                      # multi-project discovery + sync
+seif --sync-workspace                 # SSH workspace sync (all machines)
 seif --autonomous enable              # AI persists knowledge autonomously
 seif --export                         # export context as markdown
 
@@ -251,6 +252,8 @@ seif --adversarial "question"         # WITH vs WITHOUT comparison
 
 Grades: **A** (≥0.85) → **B** (≥0.70) → **C** (≥0.55) → **D** (≥0.40) → **F** (<0.40)
 
+> **Quality gate threshold: ζ = √6/4 ≈ 0.6124 (algebraically derived from H(s) — not φ⁻¹ = 0.618)**
+
 ---
 
 ## Why SEIF vs ChatGPT Memory

{seif_cli-0.3.0 → seif_cli-0.3.1}/README.md

@@ -187,6 +187,7 @@ seif --sync                           # re-sync git context
 seif --compress                       # 93% context compression
 seif --ingest daily.txt               # ingest external source
 seif --workspace                      # multi-project discovery + sync
+seif --sync-workspace                 # SSH workspace sync (all machines)
 seif --autonomous enable              # AI persists knowledge autonomously
 seif --export                         # export context as markdown
 
@@ -207,6 +208,8 @@ seif --adversarial "question"         # WITH vs WITHOUT comparison
 
 Grades: **A** (≥0.85) → **B** (≥0.70) → **C** (≥0.55) → **D** (≥0.40) → **F** (<0.40)
 
+> **Quality gate threshold: ζ = √6/4 ≈ 0.6124 (algebraically derived from H(s) — not φ⁻¹ = 0.618)**
+
 ---
 
 ## Why SEIF vs ChatGPT Memory

{seif_cli-0.3.0 → seif_cli-0.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "seif-cli"
-version = "0.3.0"
+version = "0.3.1"
 description = "Measure AI output quality, protect sensitive data, watch your AI environment resonate. Quality Gate, Classification, Sentinel & Auto-Healing, SEIF OS."
 readme = "README.md"
 license = {text = "CC-BY-NC-SA-4.0"}
@@ -64,14 +64,14 @@ qr = [
 ]
 # Everything
 all = [
-    "seif-cli[consensus,generators,web,telegram,qr]",
+    "seif[consensus,generators,web,telegram,qr]",
 ]
 
 [project.urls]
-Homepage = "https://github.com/and2carvalho/seif"
-Documentation = "https://github.com/and2carvalho/seif"
+Homepage = "https://seifprotocol.com"
+Documentation = "https://seifprotocol.com/docs"
 Repository = "https://github.com/and2carvalho/seif"
-"Live Demo" = "https://seif-framework.streamlit.app"
+Changelog = "https://github.com/and2carvalho/seif/releases"
 
 [project.scripts]
 seif = "seif.cli.wrapper:main"

{seif_cli-0.3.0 → seif_cli-0.3.1}/src/seif/analysis/quality_gate.py

@@ -20,7 +20,7 @@ Usage:
 from dataclasses import dataclass, field
 from seif.core.triple_gate import evaluate as triple_evaluate, TripleGateResult
 from seif.analysis.stance_detector import analyze as stance_analyze, StanceAnalysis
-from seif.constants import PHI_INVERSE
+from seif.constants import PHI_INVERSE, RESONANCE_THRESHOLD
 
 
 # Default weights: stance (semantic) 6/9, resonance (harmonic) 3/9.
@@ -77,7 +77,7 @@ def _compute_status(stance_status: str, triple_status: str,
     """Determine overall status."""
     if stance_status == "LOW_DATA":
         return "LOW_DATA"
-    if stance_status == "GROUNDED" and score >= PHI_INVERSE:
+    if stance_status == "GROUNDED" and score >= RESONANCE_THRESHOLD:
         return "SOLID"
     if stance_status == "DRIFT":
         return "WEAK"
@@ -132,7 +132,7 @@ def _generate_flags(stance: StanceAnalysis,
     if triple.status == "CLOSED":
         flags.append("RESONANCE: all 3 harmonic layers closed")
     if triple.resonance_score < 0.3:
-        flags.append(f"LOW COHERENCE: {triple.resonance_score:.3f} (threshold: {PHI_INVERSE:.3f})")
+        flags.append(f"LOW COHERENCE: {triple.resonance_score:.3f} (ζ threshold: {RESONANCE_THRESHOLD:.3f})")
     return flags
 
 
@@ -154,10 +154,10 @@ def _generate_suggestions(stance: StanceAnalysis,
         suggestions.append(
             "AI response is speculative — re-prompt with verifiable constraints"
         )
-    if triple.resonance_score < PHI_INVERSE and triple.resonance_score > 0:
+    if triple.resonance_score < RESONANCE_THRESHOLD and triple.resonance_score > 0:
         suggestions.append(
-            f"Coherence {triple.resonance_score:.3f} below threshold "
-            f"{PHI_INVERSE:.3f} — restructure for clarity"
+            f"Coherence {triple.resonance_score:.3f} below ζ threshold "
+            f"{RESONANCE_THRESHOLD:.3f} — restructure for clarity"
         )
     return suggestions
 
@@ -218,13 +218,14 @@ def assess(text: str, role: str = "human",
 
 
 def describe_verdict(v: QualityVerdict) -> str:
-    """Human-readable quality report."""
+    """Human-readable quality report with resonance emoji feedback."""
     lines = []
 
-    # Header
-    icon = {"SOLID": "🟢", "MIXED": "🟡", "WEAK": "🔴", "LOW_DATA": "⚪"}.get(v.status, "⚪")
+    # ζ gate indicator
+    zeta_icon = "ζ✅" if v.grade in ("A", "B") else "ζ⚠️" if v.grade == "C" else "ζ❌"
+    stance_icon = {"SOLID": "🟢", "MIXED": "🟡", "WEAK": "🔴", "LOW_DATA": "⚪"}.get(v.status, "⚪")
     role_label = "AI" if v.role == "ai" else "HUMAN"
-    lines.append(f"{icon} [{role_label}] Grade: {v.grade} | Score: {v.score:.3f} | Status: {v.status}")
+    lines.append(f"{stance_icon} {zeta_icon} [{role_label}] Grade: {v.grade} | Score: {v.score:.3f} | Status: {v.status}")
     lines.append("")
 
     # Components
@@ -235,8 +236,8 @@ def describe_verdict(v: QualityVerdict) -> str:
                  f"(composite: {v.triple_gate.composite_score:.3f}, "
                  f"layers: {v.triple_gate.layers_open}/3)")
     lines.append(f"  Coherence:   {v.triple_gate.resonance_score:.3f} "
-                 f"({'above' if v.triple_gate.resonance_score >= PHI_INVERSE else 'below'} "
-                 f"threshold {PHI_INVERSE:.3f})")
+                 f"({'above' if v.triple_gate.resonance_score >= RESONANCE_THRESHOLD else 'below'} "
+                 f"ζ={RESONANCE_THRESHOLD:.3f})")
 
     # Flags
     if v.flags:

{seif_cli-0.3.0 → seif_cli-0.3.1}/src/seif/cli/cli.py

@@ -222,7 +222,7 @@ def cmd_relay(module_paths: list[str], backend: str, prompt: str, output: str):
         "gemini": "gemini_cli",
         "anthropic": "anthropic_api",
         "grok": "grok_api",
-        "bigpickle": "opencode_bigpickle",
+        "opencode": "opencode",
     }
     backend_key = backend_map.get(backend, backend)
 
@@ -276,8 +276,9 @@ def cmd_relay(module_paths: list[str], backend: str, prompt: str, output: str):
     # Measure response quality
     from seif.analysis.quality_gate import assess
     verdict = assess(response.text[:1000], role="ai")
-    print(f"\n[Quality: {verdict.grade} | Stance: {verdict.status} | "
-          f"Resonance: {verdict.triple_gate.status}]")
+    _zeta = "ζ✅" if verdict.grade in ("A","B") else "ζ⚠️" if verdict.grade == "C" else "ζ❌"
+    _stance = {"SOLID":"🟢","GROUNDED":"🟢","MIXED":"🟡","WEAK":"🔴","DRIFT":"🔴"}.get(verdict.status, "⚪")
+    print(f"\n{_stance} {_zeta}  grade:{verdict.grade}  stance:{verdict.status}  resonance:{verdict.triple_gate.status}")
 
 
 def cmd_packet(module_path: str, message: str, sender: str, receiver: str,
@@ -331,7 +332,7 @@ def cmd_packet(module_path: str, message: str, sender: str, receiver: str,
             "gemini": "gemini_cli",
             "anthropic": "anthropic_api",
             "grok": "grok_api",
-            "bigpickle": "opencode_bigpickle",
+            "opencode": "opencode",
         }
         backend_key = backend_map.get(receiver, receiver)
 
@@ -478,7 +479,7 @@ def cmd_consensus(question: str, module_paths: list[str], backends: list[str],
         "gemini": "gemini_cli",
         "anthropic": "anthropic_api",
         "grok": "grok_api",
-        "bigpickle": "opencode_bigpickle",
+        "opencode": "opencode",
     }
 
     # Verify at least 2 backends are available
@@ -1505,7 +1506,7 @@ def cmd_consult(question: str, context_paths: list[str],
     backend_map = {
         "claude": "claude_cli", "gemini": "gemini_cli",
         "anthropic": "anthropic_api", "grok": "grok_api",
-        "bigpickle": "opencode_bigpickle",
+        "opencode": "opencode",
         "deepseek": "deepseek", "kimi": "kimi",
     }
 
@@ -1887,7 +1888,7 @@ def cmd_adversarial(question: str, context_paths: list[str],
     backend_map = {
         "claude": "claude_cli", "gemini": "gemini_cli",
         "anthropic": "anthropic_api", "grok": "grok_api",
-        "bigpickle": "opencode_bigpickle",
+        "opencode": "opencode",
     }
 
     # Resolve backend
@@ -2755,6 +2756,305 @@ def cmd_extract(path: str, context_repo: str = None,
         print("No content to extract (all files filtered by classification).")
 
 
+# ── Agent Roles & Start ─────────────────────────────────────────────────────
+
+_AGENT_ROLES_FILE = "agent-roles-v1.seif"
+_DEFAULT_ROLES = {
+    "writer":       {"agent": "copilot",   "fallback": "claude"},
+    "vigilant":     {"agent": "claude",    "fallback": "copilot"},
+    "sentinel":     {"agent": "claude",    "fallback": "grok"},
+    "orchestrator": {"agent": "copilot",   "fallback": "claude"},
+    "researcher":   {"agent": "grok",      "fallback": "gemini"},
+}
+_KNOWN_AGENTS = ["copilot", "claude", "grok", "gemini", "opencode", "deepseek", "cursor", "windsurf"]
+
+
+def _agent_roles_path(ctx_repo: str) -> str:
+    import os
+    return os.path.join(ctx_repo, "modules", _AGENT_ROLES_FILE)
+
+
+def _load_agent_roles(ctx_repo: str) -> dict:
+    import json, os
+    path = _agent_roles_path(ctx_repo)
+    if os.path.exists(path):
+        try:
+            with open(path) as f:
+                data = json.load(f)
+            return data.get("roles", _DEFAULT_ROLES)
+        except Exception:
+            pass
+    return dict(_DEFAULT_ROLES)
+
+
+def _save_agent_roles(ctx_repo: str, roles: dict, authored_by: str = "") -> None:
+    import json, os
+    from datetime import datetime, timezone
+    if not authored_by:
+        try:
+            from seif.context.nucleus import load_profile
+            authored_by = load_profile().get("name", "unknown") or "unknown"
+        except Exception:
+            authored_by = "unknown"
+    path = _agent_roles_path(ctx_repo)
+    module = {
+        "_instruction": "Workspace agent role assignments. Owner-only write. Propagates to all collaborators.",
+        "protocol": "SEIF-MODULE-v2",
+        "module_id": "agent-roles-v1",
+        "classification": "INTERNAL",
+        "decay_exempt": True,
+        "governance": {
+            "authored_by": authored_by,
+            "collaborator_override": False,
+            "propagates_to_all": True,
+            "note": "Only workspace-owner can write this module. All collaborators inherit these assignments."
+        },
+        "roles": roles,
+        "known_agents": _KNOWN_AGENTS,
+        "updated_at": datetime.now(timezone.utc).isoformat(),
+        "integrity_hash": f"agent-roles-{datetime.now(timezone.utc).strftime('%Y%m%d%H%M')}"
+    }
+    with open(path, "w") as f:
+        json.dump(module, f, indent=2)
+
+
+def _cmd_agents_show(ctx_repo: str) -> None:
+    roles = _load_agent_roles(ctx_repo)
+    print("╔══ SEIF AGENT ROLES ═══════════════════════════════╗")
+    for role, cfg in roles.items():
+        agent = cfg.get("agent", "—") if isinstance(cfg, dict) else cfg
+        fallback = cfg.get("fallback", "—") if isinstance(cfg, dict) else "—"
+        avail = _check_agent_available(agent)
+        icon = "✅" if avail else "⚠ "
+        fb_note = f"  (fallback: {fallback})" if not avail else ""
+        print(f"  {icon} {role:<14} → {agent}{fb_note}")
+    print("╚═══════════════════════════════════════════════════╝")
+    print("  Set with: seif --agents-set ROLE=AGENT")
+    print(f"  Known agents: {', '.join(_KNOWN_AGENTS)}")
+
+
+def _check_agent_available(agent: str) -> bool:
+    """Best-effort availability check — checks if agent binary/process exists."""
+    import shutil
+    checks = {
+        "copilot": ["gh", "copilot"],
+        "claude":  ["claude"],
+        "cursor":  ["cursor"],
+        "windsurf": ["windsurf"],
+    }
+    bins = checks.get(agent, [agent])
+    return any(shutil.which(b) for b in bins)
+
+
+def _cmd_agents_set(assignment: str, ctx_repo: str) -> None:
+    if "=" not in assignment:
+        print(f"⚠  Format: ROLE=AGENT  (e.g. writer=claude)")
+        return
+    role, agent = assignment.split("=", 1)
+    role, agent = role.strip().lower(), agent.strip().lower()
+    if agent not in _KNOWN_AGENTS:
+        print(f"⚠  Unknown agent '{agent}'. Known: {', '.join(_KNOWN_AGENTS)}")
+        return
+    roles = _load_agent_roles(ctx_repo)
+    old = roles.get(role, {})
+    old_agent = old.get("agent", "—") if isinstance(old, dict) else old
+    roles[role] = {"agent": agent, "fallback": old_agent if old_agent != agent else "copilot"}
+    _save_agent_roles(ctx_repo, roles)
+    print(f"╔══ AGENT ROLE UPDATED ══════════════════════════════╗")
+    print(f"  {role:<14} → {agent}  (previous: {old_agent})")
+    print(f"  Saved to: {_agent_roles_path(ctx_repo)}")
+    print(f"  Propagates to all workspace collaborators.")
+    print(f"╚════════════════════════════════════════════════════╝")
+
+
+def _cmd_sync_workspace(ctx_repo: str, host: str | None = None, dry_run: bool = False) -> None:
+    """Sync all SEIF repos on a remote device (same local network, owner-only).
+
+    Connects via SSH, detects all git repos under the remote workspace root,
+    pulls each one from its configured GitHub origin, then runs seif absorb
+    if seif is available on the remote.
+
+    Security: only runs when called as the workspace owner (checks agent-roles
+    authored_by). SSH host is resolved from: CLI arg → SEIF_SYNC_HOST env var
+    → agent-roles-v1.seif sync_host field.
+    """
+    import os, json, subprocess, shutil
+
+    WORKSPACE_ROOT = os.environ.get(
+        "SEIF_WORKSPACE_ROOT",
+        str(__import__("pathlib").Path.home() / "seif-admin")
+    )
+    REPOS = ["seif", "seif-engine", "seif-suite", "seif-context",
+             "seif-internal", "seif-research", "seif-resonance-bridge",
+             "seif-vscode-extension"]
+
+    print("╔══ SEIF SYNC-WORKSPACE ═════════════════════════════╗")
+
+    # ── 1. Resolve SSH host ──────────────────────────────────
+    if not host:
+        host = os.environ.get("SEIF_SYNC_HOST", "")
+    if not host and ctx_repo:
+        # Try to read from agent-roles module
+        roles_path = os.path.join(ctx_repo, "modules", "agent-roles-v1.seif")
+        if os.path.exists(roles_path):
+            try:
+                import re
+                with open(roles_path) as f:
+                    content = f.read()
+                m = re.search(r"sync_host:\s*(.+)", content)
+                if m:
+                    host = m.group(1).strip()
+            except Exception:
+                pass
+
+    if not host:
+        print("  ⚠  No SSH host specified.")
+        print("  Set via: --sync-workspace-host <host>")
+        print("       or: export SEIF_SYNC_HOST=<host>")
+        print("       or: add 'sync_host: <host>' to agent-roles-v1.seif")
+        print("╚════════════════════════════════════════════════════╝")
+        return
+
+    print(f"  Host   : {host}")
+    print(f"  Root   : {WORKSPACE_ROOT}")
+    print(f"  Repos  : {', '.join(REPOS)}")
+    if dry_run:
+        print("  Mode   : DRY RUN (no changes)")
+    print()
+
+    # ── 2. Check SSH reachability ────────────────────────────
+    if not dry_run:
+        ping = subprocess.run(
+            ["ssh", "-o", "ConnectTimeout=5", "-o", "BatchMode=yes",
+             host, "echo ok"],
+            capture_output=True, text=True
+        )
+        if ping.returncode != 0:
+            print(f"  ✗ Cannot reach {host} via SSH.")
+            print(f"    Ensure you are on the same network and SSH is enabled.")
+            print("╚════════════════════════════════════════════════════╝")
+            return
+        print(f"  ✓ SSH connection to {host} confirmed")
+        print()
+
+    # ── 3. Build the remote script ───────────────────────────
+    remote_script = f"""#!/bin/bash
+set -e
+ROOT="{WORKSPACE_ROOT}"
+REPOS=({" ".join(REPOS)})
+echo "── Remote sync starting on $(hostname) ──"
+echo ""
+for repo in "${{REPOS[@]}}"; do
+  path="$ROOT/$repo"
+  expanded_path=$(eval echo "$path")
+  if [ ! -d "$expanded_path/.git" ]; then
+    echo "  ⊘  $repo — not found or no .git"
+    continue
+  fi
+  cd "$expanded_path"
+  remote_url=$(git remote get-url origin 2>/dev/null || echo "")
+  if [ -z "$remote_url" ]; then
+    echo "  ⚠  $repo — no remote configured"
+    continue
+  fi
+  branch=$(git branch --show-current 2>/dev/null || echo "main")
+  before=$(git log --oneline -1 2>/dev/null | cut -c1-7)
+  git fetch origin --quiet 2>&1 | head -1
+  git pull origin "$branch" --ff-only --quiet 2>&1 | tail -1
+  after=$(git log --oneline -1 2>/dev/null | cut -c1-7)
+  if [ "$before" = "$after" ]; then
+    echo "  ✓  $repo ($branch) — already up to date [$after]"
+  else
+    echo "  ↑  $repo ($branch) — $before → $after"
+  fi
+done
+echo ""
+# Absorb if seif is available
+if command -v seif &>/dev/null; then
+  echo "  🌀 Running seif absorb..."
+  seif --cycle absorb 2>/dev/null | tail -3 || true
+fi
+echo ""
+echo "── Sync complete on $(hostname) ──"
+"""
+
+    if dry_run:
+        print("  [DRY RUN] Would run on remote:")
+        print("  " + remote_script.replace("\n", "\n  ").strip())
+        print()
+        print("╚════════════════════════════════════════════════════╝")
+        return
+
+    # ── 4. Execute remote script via SSH ────────────────────
+    result = subprocess.run(
+        ["ssh", host, "bash -s"],
+        input=remote_script, capture_output=False, text=True
+    )
+
+    print()
+    if result.returncode == 0:
+        print("  ✅ Workspace sync complete")
+    else:
+        print(f"  ⚠  Remote script exited with code {result.returncode}")
+
+    # ── 5. Update agent-roles-v1.seif with sync timestamp ───
+    if ctx_repo:
+        roles_path = os.path.join(ctx_repo, "modules", "agent-roles-v1.seif")
+    else:
+        roles_path = None
+    if roles_path and os.path.exists(roles_path):
+        try:
+            from datetime import datetime, timezone
+            now = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+            with open(roles_path) as f:
+                content = f.read()
+            import re
+            if "last_sync_workspace:" in content:
+                content = re.sub(
+                    r"last_sync_workspace:.*",
+                    f"last_sync_workspace: {now}",
+                    content
+                )
+            else:
+                content = content.rstrip() + f"\nlast_sync_workspace: {now}\n"
+            with open(roles_path, "w") as f:
+                f.write(content)
+            print(f"\n  📝 last_sync_workspace → {now}")
+        except Exception:
+            pass
+
+    print("╚════════════════════════════════════════════════════╝")
+
+
+def _cmd_start(ctx_repo: str) -> None:
+    import webbrowser, os, subprocess
+    print("╔══ SEIF START ══════════════════════════════════════╗")
+
+    # 1. Cycle status
+    try:
+        result = subprocess.run(
+            ["python3", "-m", "seif.cli.cli", "--cycle", "status"],
+            capture_output=True, text=True, cwd=os.path.dirname(ctx_repo)
+        )
+        print(result.stdout.strip())
+    except Exception:
+        print("  ⚠  Could not load cycle status")
+
+    # 2. Agent roles
+    print()
+    _cmd_agents_show(ctx_repo)
+
+    # 3. Open Suite in browser
+    suite_url = os.environ.get("SEIF_SUITE_URL", "http://localhost:3000")
+    print(f"\n  🌐 Opening SEIF Suite: {suite_url}")
+    try:
+        webbrowser.open(suite_url)
+    except Exception:
+        print(f"  ⚠  Could not open browser. Navigate to: {suite_url}")
+
+    print("╚════════════════════════════════════════════════════╝")
+
+
 def main():
     parser = argparse.ArgumentParser(
         prog="seif",
@@ -3006,6 +3306,33 @@ def main():
     parser.add_argument("--dia-skill", action="store_true",
                         help="Generate Dia browser skill prompt from current nucleus context")
 
+    # ── Cycle Management (enoch-tree-reverb: branch-seif-cycle-module) ──
+    parser.add_argument("--cycle", metavar="ACTION", nargs="?", const="status",
+                        choices=["status", "audit", "meditate", "absorb", "close",
+                                 "new", "full-circle"],
+                        help="Cycle management: status|audit|meditate|absorb|close|new|full-circle")
+    parser.add_argument("--cycle-name", metavar="NAME",
+                        help="Cycle name for --cycle new")
+    parser.add_argument("--cycle-parent", metavar="PARENT",
+                        help="Parent cycle for --cycle new (auto-detected if omitted)")
+    parser.add_argument("--identity-scan", metavar="TARGET",
+                        nargs="?", const="local",
+                        help="Scan resonance identities. TARGET: 'local' (default) or SSH host e.g. 'my-laptop'")
+    parser.add_argument("--identity-scan-path", metavar="PATH",
+                        help="Remote path for --identity-scan (default: ~/seif-admin/seif-context/modules or SEIF_CONTEXT_MODULES)")
+    parser.add_argument("--start", action="store_true",
+                        help="Open SEIF Suite in browser + show cycle status + load agent roles")
+    parser.add_argument("--agents", action="store_true",
+                        help="Show current agent role assignments for this workspace")
+    parser.add_argument("--agents-set", metavar="ROLE=AGENT",
+                        help="Set an agent role (owner only). E.g. --agents-set writer=claude")
+    parser.add_argument("--sync-workspace", action="store_true",
+                        help="Sync all SEIF repos on a remote device via SSH (owner only, same local network)")
+    parser.add_argument("--sync-workspace-host", metavar="HOST",
+                        help="SSH host/alias for --sync-workspace (e.g. my-laptop). Falls back to SEIF_SYNC_HOST env var.")
+    parser.add_argument("--sync-workspace-dry-run", action="store_true",
+                        help="Show what --sync-workspace would do without making changes")
+
     args = parser.parse_args()
 
     # ── Personal Nucleus commands ──
@@ -3115,13 +3442,14 @@ def main():
         except ImportError:
             print("This feature requires SEIF Suite. Learn more: https://seifos.io")
             return
+        from seif.cli.resonance_display import resonance_header, health_status_line
         detected = detect_backends()
         healthy = get_healthy_backends(detected)
-        print(f"Detected backends: {', '.join(detected) or 'none'}")
-        print(f"Healthy backends:  {', '.join(healthy) or 'none'}")
+        print(resonance_header("SEIF HEALTH", f"backends: {len(healthy)}/{len(detected)} healthy"))
+        print(health_status_line(len(healthy), len(detected)))
         unhealthy = set(detected) - set(healthy)
         if unhealthy:
-            print(f"Unhealthy:         {', '.join(unhealthy)}")
+            print(f"\n  ζ❌  unhealthy: {', '.join(unhealthy)}")
         print()
         print(describe_health())
         return
@@ -3138,6 +3466,80 @@ def main():
         print(result)
         return
 
+    if args.cycle:
+        from seif.context.cycle import (
+            cycle_status, cycle_audit, cycle_meditate, cycle_absorb,
+            cycle_close, cycle_new, cycle_full_circle,
+        )
+        ctx_repo = args.context_repo or None
+        action = args.cycle.lower()
+        if action == "status":
+            print(cycle_status(ctx_repo))
+        elif action == "audit":
+            print(cycle_audit(ctx_repo))
+        elif action == "meditate":
+            print(cycle_meditate(ctx_repo))
+        elif action == "absorb":
+            print(cycle_absorb(ctx_repo))
+        elif action == "close":
+            from seif.cli.resonance_display import resonance_footer
+            print(cycle_close(context_repo=ctx_repo))
+            print(resonance_footer())
+        elif action == "new":
+            if not args.cycle_name:
+                print("Error: --cycle-name required for --cycle new")
+                print("Usage: seif --cycle new --cycle-name <name>")
+                return
+            print(cycle_new(args.cycle_name, args.cycle_parent, ctx_repo))
+        elif action == "full-circle":
+            print(cycle_full_circle(ctx_repo))
+        return
+
+    if args.identity_scan is not None:
+        try:
+            from seif_engine.identity.scanner import scan_workspace, format_scan_report
+        except ImportError:
+            print("⚠  seif-engine not available — identity scanner requires the engine.")
+            return
+        target = args.identity_scan or "local"
+        import socket as _socket
+        _machine_id = __import__("os").environ.get("SEIF_MACHINE_ID") or _socket.gethostname()
+        local_scan = scan_workspace(machine=_machine_id)
+        if target == "local":
+            print(format_scan_report(local_scan))
+        else:
+            remote_path = getattr(args, "identity_scan_path", None) or \
+                __import__("os").environ.get("SEIF_CONTEXT_MODULES", "~/seif-admin/seif-context/modules")
+            remote_scan = scan_workspace(
+                machine="air-m1",
+                ssh_host=target,
+                remote_path=remote_path,
+            )
+            print(format_scan_report(local_scan, remote_scan))
+        return
+
+    # ctx_repo default for owner-level commands (start, agents, sync-workspace)
+    if "ctx_repo" not in dir():
+        ctx_repo = getattr(args, "context_repo", None) or None
+
+    if args.start:
+        _cmd_start(ctx_repo)
+        return
+
+    if args.agents:
+        _cmd_agents_show(ctx_repo)
+        return
+
+    if args.agents_set:
+        _cmd_agents_set(args.agents_set, ctx_repo)
+        return
+
+    if args.sync_workspace or args.sync_workspace_dry_run:
+        host = getattr(args, "sync_workspace_host", None)
+        dry = getattr(args, "sync_workspace_dry_run", False)
+        _cmd_sync_workspace(ctx_repo, host=host, dry_run=dry)
+        return
+
     if args.fingerprint_verify:
         cmd_fingerprint_verify(args.fingerprint_verify)
         return
@@ -3224,6 +3626,8 @@ def main():
             path = close_session(ctx, name, author_name)
             print(f"Session '{name}' closed.")
             print(f"  Archived: {path}")
+            from seif.cli.resonance_display import resonance_footer
+            print(resonance_footer())
         elif action == "list":
             sessions = list_sessions(ctx)
             if not sessions: