seif-cli 0.5.0__tar.gz → 0.5.2__tar.gz

{seif_cli-0.5.0/src/seif_cli.egg-info → seif_cli-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: seif-cli
-Version: 0.5.0
+Version: 0.5.2
 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

{seif_cli-0.5.0 → seif_cli-0.5.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "seif-cli"
-version = "0.5.0"
+version = "0.5.2"
 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"}

{seif_cli-0.5.0 → seif_cli-0.5.2}/src/seif/analysis/stance_detector.py

@@ -55,8 +55,15 @@ class StanceAnalysis:
         return "\n".join(lines)
 
 
-# Patterns that indicate verifiable content
+# Patterns that indicate verifiable content.
+# Two groups: (1) original physics/EE/math patterns, (2) software-engineering
+# verifiable artifacts added by the s14 calibration debate (semver, SHAs,
+# file:line refs, test counts, ISO timestamps, PR refs, code identifiers, etc.).
+# The split exists because session summaries are dense in (2) and were scoring
+# F as "low data" before. Calibrated against 27 positive + 14 negative samples
+# at 100% recall / 0% false positives.
 VERIFIABLE_PATTERNS = [
+    # --- Group 1: physics / EE / math ---
     r'\d+\.?\d*\s*(%|Hz|Ω|ohm|mH|μF|uF|nF|pF|dB|°|deg|rad|ms|kHz|MHz|V|A|W|bpm|rpm)',
     r'[=≈≠<>]\s*\d',
     r'[ζφωπ√]',
@@ -69,9 +76,41 @@ VERIFIABLE_PATTERNS = [
     r'\b(?:theorem|proof|exhaustive|brute.?force)\b',
     r'(?:ISE|IAE|ITAE|RLC|PCB|BOM|DRC)',
     r'formal.?symbolic',
-    r'\b\w+[_]\w+\s*=',           # variable_name = (e.g. f_peak = f_n/2)
-    r'\b[A-Z]\([a-z]\)',                 # H(s), F(x), G(s)
-    r'property|unique|halving',          # mathematical property language
+    r'\b\w+[_]\w+\s*=',                     # variable_name = ...
+    r'\b[A-Z]\([a-z]\)',                    # H(s), F(x)
+    r'property|unique|halving',             # math property language
+
+    # --- Group 2: software-engineering verifiable artifacts ---
+    r'\bv?\d+\.\d+\.\d+(?:[-+][\w.]+)?\b',                                   # semver
+    r'\b(?:commit|tag|branch|sha|hash|merge|revert|cherry-?pick|HEAD)\s+[0-9a-f]{7,12}\b',  # short SHA in context
+    r'\b[0-9a-f]{40}\b',                                                      # long SHA
+    r'\b(?:sha\d{2,3}|md5|blake[23]b?):[0-9a-f]{16,128}\b',                  # prefixed digest
+    r'\b[\w./-]+\.(?:py|ts|tsx|js|jsx|go|rs|java|cpp|c|h|hpp|md|json|yaml|yml|toml|sh|rb|php|cs|kt|swift|sql|html|css|scss):\d+(?:-\d+)?\b',  # file:line
+    r'(?:#|\b)L\d+(?:-L?\d+)?\b',                                             # GitHub line anchors
+    r'\b\d+\s+(?:tests?|specs?|suites?|cases?|assertions?|examples?)\b\s*(?:passing|failing|skipped|pending|run|across|in)?',  # test count fwd
+    r'\b(?:tests?|specs?|suites?|cases?|assertions?|examples?)\s+(?:passing|failing|skipped|pending)?\s*(?:is|are|were|equals?|=)\s+\d+\b',  # test count inv
+    r'\b(?:added|removed|deleted|modified|fixed|merged|reverted|created|closed|reopened|broke|patched|migrated)\s+\d+\b',  # eng verb + count
+    r'\b\d{4}-\d{2}-\d{2}(?:[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:?\d{2})?)?\b',  # ISO 8601
+    r'(?<!\w)(?:#\d+|(?:PR|GH|MR|RFC|RFD|ISSUE|JIRA|[A-Z]{2,8})-\d+)\b',     # PR / issue refs
+    r'\b(?:returns?|status|code|HTTP|got|expected|received|responded\s+with)\s+(?:1\d{2}|2\d{2}|3\d{2}|4\d{2}|5\d{2})\b',  # HTTP verb-prefixed
+    r'\b(?:1\d{2}|2\d{2}|3\d{2}|4\d{2}|5\d{2})\s+(?:OK|Created|Accepted|No\s+Content|Moved|Found|Bad\s+Request|Unauthorized|Forbidden|Not\s+Found|Conflict|Gone|Too\s+Many|Internal\s+Server|Bad\s+Gateway|Service\s+Unavailable|Gateway\s+Timeout)\b',  # HTTP code + reason
+    r'(?:^|[\s(\[])(?:localhost|127\.0\.0\.1|0\.0\.0\.0|::1)?:(?:[1-9]\d{0,4})\b',  # port number
+    r'\b[\w.-]+@\^?\d+\.\d+(?:\.\d+)?(?:[-+][\w.]+)?\b',                     # package@version
+    r'\b[a-z][a-z0-9_]+\([^)]{0,80}\)',                                       # snake_case(...)
+    r'\b[A-Z][a-zA-Z0-9]+\([^)]{0,80}\)',                                     # PascalCase(...)
+    r'\b\w+\.\w+\([^)]{0,80}\)',                                              # foo.bar(...)
+    r'[+\-−]\d+\s*(?:[/,]\s*[+\-−]\d+|lines?|loc)?',                         # diff stats
+    r'\bexit(?:ed|s)?\s+(?:with\s+)?(?:code\s+)?-?\d+\b',                    # exit code
+    r'\breturn\s+code\s+-?\d+\b',                                             # return code
+    r'\b\d+(?:\.\d+)?\s*(?:[KMGTP]i?B|bytes?|kbps|Mbps|Gbps)\b',              # size with unit
+    r'\b\d+(?:\.\d+)?\s*(?:ns|us|μs|ms|min|sec|hr|hrs|hours?|minutes?|seconds?)\b',  # duration
+    r'\b\d+m\s*\d+s\b',                                                       # 4m 32s
+    r'\b\d+h\s*\d+m\b',                                                       # 1h 18m
+    r'\b(?:feature|bugfix|hotfix|release|chore|refactor|fix|feat)/[\w./-]+\b',  # branch convention
+    # File paths — require leading slash, ./, ../, OR dotted extension
+    # (rejects casual prose like "production/staging environments").
+    r'(?:^|(?<=[\s(\[]))(?:\.{1,2}/|/)[\w-]+(?:/[\w.-]+)+',
+    r'\b[\w-]+(?:/[\w.-]+)+\.[a-z]{1,6}\b',
 ]
 
 # Patterns that indicate metaphorical/interpretive drift
@@ -98,7 +137,14 @@ def analyze(text: str) -> StanceAnalysis:
     This does NOT judge the truth of claims. It measures the RATIO of
     verifiable to interpretive content, enabling informed reading.
     """
-    sentences = [s.strip() for s in re.split(r'(?<![0-9])[.!?]|\n', text) if len(s.strip()) > 10]
+    # Sentence boundary rules:
+    #   - Split on `.!?` only when NOT inside a decimal (no digit immediately
+    #     after the punctuation), OR when followed by whitespace + a capital
+    #     letter (the "0.612. This" case — punctuation preceded by a digit
+    #     but clearly closing a sentence).
+    #   - Newlines always split.
+    splitter = re.compile(r'[.!?](?!\d)(?=\s+[A-Z]|\s*$|\s+\Z)|(?<![0-9])[.!?]|\n')
+    sentences = [s.strip() for s in splitter.split(text) if len(s.strip()) > 10]
 
     if len(sentences) < 2:
         return StanceAnalysis(

{seif_cli-0.5.0 → seif_cli-0.5.2}/src/seif/cli/cli.py

@@ -3305,6 +3305,432 @@ def cmd_list():
             print(f"    ... and {len(unregistered) - 3} more")
 
 
+def cmd_audit_host(fix: bool = False, dry_run: bool = False):
+    """Audit ~/.seif/ host-level structure across the 5 architecture layers.
+
+    Layer A — Protocol (RESONANCE.json deployed)
+    Layer B — Init-generated (config.json, registry.json with current workspace)
+    Layer C — Derived (mapper.json, nucleus.seif, model_registry.json freshness)
+    Layer D — Per-host config (machine_id present)
+    Layer E — Heartbeat liveness
+
+    With --fix, calls the canonical regenerator for each missing/stale item.
+    """
+    import json as _json
+    import time as _time
+    from pathlib import Path as _P
+    from datetime import datetime, timezone
+
+    try:
+        from seif.data.paths import get_user_home, get_resonance_path
+        from seif.context.registry import (
+            load_registry, find_context_entry, rebuild_registry,
+        )
+        from seif.context.host_init import load_machine_id, ensure_machine_id
+        from seif.context.model_probe import (
+            probe_all, write_registry as write_model_registry,
+            get_registry_path as get_model_registry_path,
+        )
+    except ImportError as e:
+        print(f"Installation error: {e}")
+        return
+
+    home = get_user_home()
+    cwd = _P.cwd()
+    findings = []  # (layer, status, message, fixer)
+
+    # ── Layer A: Protocol artefacts ─────────────────────────────────────────
+    resonance_canonical = get_resonance_path()
+    resonance_deployed = home / "RESONANCE.json"
+    if not resonance_canonical.exists():
+        findings.append(("A", "FAIL", "RESONANCE.json missing in seif package — reinstall seif-cli", None))
+    elif not resonance_deployed.exists():
+        def _fix_resonance():
+            import shutil as _sh
+            _sh.copy2(resonance_canonical, resonance_deployed)
+            return f"deployed {resonance_canonical} → {resonance_deployed}"
+        findings.append(("A", "MISSING", "~/.seif/RESONANCE.json not deployed", _fix_resonance))
+    else:
+        findings.append(("A", "OK", f"RESONANCE.json deployed ({resonance_deployed.stat().st_size}B)", None))
+
+    # ── Layer B: Init-generated ─────────────────────────────────────────────
+    workspace_seif = cwd / ".seif"
+    in_workspace = workspace_seif.is_dir()
+
+    config_path = home / "config.json"
+    if not config_path.exists():
+        findings.append(("B", "MISSING", "~/.seif/config.json absent — run seif --init in a workspace", None))
+    else:
+        findings.append(("B", "OK", f"config.json present ({config_path.stat().st_size}B)", None))
+
+    registry_path = home / "registry.json"
+    if not registry_path.exists():
+        findings.append(("B", "MISSING", "~/.seif/registry.json absent",
+                        lambda: rebuild_registry([str(cwd.parent)]) and "rebuilt"))
+    else:
+        registry = load_registry()
+        if in_workspace:
+            entry = find_context_entry(registry, str(workspace_seif))
+            if not entry:
+                def _fix_registry():
+                    rebuild_registry([str(cwd.parent), str(cwd)])
+                    return "rebuilt with current workspace"
+                findings.append(("B", "STALE",
+                                f"current workspace {workspace_seif} not in registry "
+                                f"({len(registry.get('contexts', []))} entries)",
+                                _fix_registry))
+            else:
+                findings.append(("B", "OK",
+                                f"registry has {len(registry.get('contexts', []))} entries, current workspace registered",
+                                None))
+        else:
+            findings.append(("B", "OK",
+                            f"registry has {len(registry.get('contexts', []))} entries",
+                            None))
+
+    # ── Layer C: Derived (workspace-scoped) ─────────────────────────────────
+    if in_workspace:
+        for fname, label in [("mapper.json", "module index"),
+                             ("nucleus.seif", "workspace context")]:
+            f = workspace_seif / fname
+            if not f.exists():
+                findings.append(("C", "MISSING",
+                                f".seif/{fname} absent — run seif --sync to regenerate",
+                                None))
+            else:
+                age_h = (_time.time() - f.stat().st_mtime) / 3600
+                state = "OK" if age_h < 24 * 7 else "STALE"
+                findings.append(("C", state,
+                                f".seif/{fname} ({label}, age {age_h:.1f}h)",
+                                None))
+
+    # model_registry.json freshness (host-level)
+    mrp = get_model_registry_path()
+    if not mrp.exists():
+        def _fix_models():
+            r = probe_all()
+            write_model_registry(r)
+            return f"probed {len(r.models)} models"
+        findings.append(("C", "MISSING", "~/.seif/model_registry.json absent — run seif --probe-models", _fix_models))
+    else:
+        age_h = (_time.time() - mrp.stat().st_mtime) / 3600
+        if age_h > 24:
+            def _fix_models_stale():
+                r = probe_all()
+                write_model_registry(r)
+                return f"reprobed {len(r.models)} models"
+            findings.append(("C", "STALE",
+                            f"model_registry.json age {age_h:.1f}h > 24h",
+                            _fix_models_stale))
+        else:
+            findings.append(("C", "OK", f"model_registry.json fresh (age {age_h:.1f}h)", None))
+
+    # ── Layer D: Per-host ───────────────────────────────────────────────────
+    mid = load_machine_id()
+    if mid is None:
+        def _fix_machine_id():
+            payload, _ = ensure_machine_id()
+            return f"created with label={payload['label']}"
+        findings.append(("D", "MISSING", "~/.seif/machine_id absent — run seif --init-host", _fix_machine_id))
+    else:
+        findings.append(("D", "OK",
+                        f"machine_id {mid.get('label','?')}/{mid.get('role','?')} "
+                        f"fp={mid.get('fingerprint','?')[:8]}",
+                        None))
+
+    # ── Layer E: Heartbeat liveness ─────────────────────────────────────────
+    hb_file = home / "heartbeat"
+    if not hb_file.exists():
+        findings.append(("E", "MISSING",
+                        "~/.seif/heartbeat not present — start heartbeatd "
+                        "(seif-resonance-bridge/seif-heartbeatd.py --daemon)",
+                        None))
+    else:
+        try:
+            data = _json.loads(hb_file.read_text())
+            ts = data.get("timestamp", "")
+            from datetime import datetime as _dt
+            t = _dt.fromisoformat(ts.replace("Z", "+00:00"))
+            age_s = (_dt.now(timezone.utc) - t).total_seconds()
+            if age_s > 300:
+                findings.append(("E", "STALE",
+                                f"heartbeat {age_s:.0f}s old (>5min) — heartbeatd may be down",
+                                None))
+            else:
+                findings.append(("E", "OK",
+                                f"heartbeat {age_s:.0f}s old, machine={data.get('machine','?')}",
+                                None))
+        except Exception as e:
+            findings.append(("E", "WARN", f"heartbeat unparseable: {e}", None))
+
+    # ── Report ──────────────────────────────────────────────────────────────
+    print(f"SEIF audit — host={home.parent.name}, cwd={cwd}")
+    print()
+    icons = {"OK": "✓", "MISSING": "✗", "STALE": "~", "FAIL": "!", "WARN": "?"}
+    layer_labels = {
+        "A": "Protocol      ",
+        "B": "Init-generated",
+        "C": "Derived       ",
+        "D": "Per-host      ",
+        "E": "Heartbeat     ",
+    }
+    counts = {"OK": 0, "MISSING": 0, "STALE": 0, "FAIL": 0, "WARN": 0}
+    fixable = []
+    for layer, status, msg, fixer in findings:
+        icon = icons.get(status, "?")
+        print(f"  [{icon}] {layer_labels[layer]} [{status:<7}] {msg}")
+        counts[status] += 1
+        if fixer is not None:
+            fixable.append((layer, status, msg, fixer))
+
+    print()
+    print(f"Summary: {counts['OK']} OK, {counts['MISSING']} missing, "
+          f"{counts['STALE']} stale, {counts['FAIL']} failed, {counts['WARN']} warned.")
+
+    if fixable and fix and not dry_run:
+        print()
+        print(f"Auto-fixing {len(fixable)} item(s):")
+        for layer, status, msg, fixer in fixable:
+            try:
+                outcome = fixer()
+                print(f"  ✓ [{layer}] {outcome}")
+            except Exception as e:
+                print(f"  ✗ [{layer}] fixer raised: {e}")
+    elif fixable and not fix:
+        print()
+        print(f"{len(fixable)} item(s) can be auto-fixed. Re-run with --audit --fix to apply.")
+    elif fixable and dry_run:
+        print()
+        print(f"(dry-run) {len(fixable)} item(s) would be fixed.")
+
+
+def _parse_hub_spec(spec: str):
+    """Parse '--hub name=host[:port][,ssh=h][,key=p][,priority=1]' into HubSpec."""
+    from seif.context.host_init import HubSpec
+    if "=" not in spec:
+        raise ValueError(f"hub spec missing 'name=': {spec!r}")
+    name, _, rest = spec.partition("=")
+    name = name.strip()
+    if not name:
+        raise ValueError(f"hub spec has empty name: {spec!r}")
+    parts = [p.strip() for p in rest.split(",") if p.strip()]
+    if not parts:
+        raise ValueError(f"hub spec missing host: {spec!r}")
+    host_part = parts[0]
+    if ":" in host_part:
+        host, _, port_s = host_part.partition(":")
+        port = int(port_s)
+    else:
+        host, port = host_part, 7332
+    extras = {}
+    for p in parts[1:]:
+        if "=" not in p:
+            continue
+        k, _, v = p.partition("=")
+        extras[k.strip()] = v.strip()
+    return HubSpec(
+        name=name, host=host, port=port,
+        health_port=int(extras.get("health_port", port + 2)),
+        ssh_host=extras.get("ssh"),
+        ssh_key=extras.get("key"),
+        priority=int(extras.get("priority", 1)),
+        transport=extras.get("transport", "direct"),
+    )
+
+
+def cmd_init_host(label=None, role="dev", overwrite_machine_id=False,
+                  hub_specs=None, source_specs=None, dry_run=False):
+    """Initialize host-specific files (~/.seif/machine_id + optional bridge/sources)."""
+    try:
+        from seif.context.host_init import (
+            init_host, get_machine_id_path, get_bridge_config_path, get_sources_path,
+        )
+    except ImportError:
+        print("Installation error: seif.context.host_init not found.")
+        return
+
+    # Parse hub specs
+    hubs = []
+    for spec in (hub_specs or []):
+        try:
+            hubs.append(_parse_hub_spec(spec))
+        except (ValueError, TypeError) as e:
+            print(f"Invalid --hub spec {spec!r}: {e}")
+            return
+
+    # Validate source specs early
+    if source_specs:
+        from seif.context.host_init import parse_source_spec
+        for spec in source_specs:
+            try:
+                parse_source_spec(spec)
+            except ValueError as e:
+                print(f"Invalid --source spec {spec!r}: {e}")
+                return
+
+    print(f"Host directory: {get_machine_id_path().parent}")
+    if dry_run:
+        print("(dry-run — no files will be written)")
+    print()
+
+    result = init_host(
+        label=label, role=role,
+        overwrite_machine_id=overwrite_machine_id,
+        hubs=hubs or None,
+        source_specs=source_specs or None,
+        dry_run=dry_run,
+    )
+
+    mid = result.machine_id
+    print("[machine_id]")
+    print(f"  Status:      {'created' if result.machine_id_created else 'reused'}")
+    print(f"  Hostname:    {mid['hostname']}")
+    print(f"  Label:       {mid['label']}")
+    print(f"  Role:        {mid['role']}")
+    print(f"  Fingerprint: {mid['fingerprint']}")
+    if not dry_run:
+        print(f"  File:        {get_machine_id_path()}")
+    print()
+
+    if result.bridge_config is not None:
+        print("[bridge-config.json]")
+        for h in result.bridge_config["hubs"]:
+            ssh = f" via ssh={h.get('ssh_host')}" if h.get("ssh_host") else ""
+            print(f"  - {h['name']}: {h['host']}:{h['port']}{ssh}")
+        if not dry_run:
+            print(f"  File: {get_bridge_config_path()}")
+        print()
+
+    if result.sources:
+        print("[sources.json]")
+        for s in result.sources:
+            print(f"  - {s['repo']:<45} {s['type']:<8} {s['classification']}")
+        if result.sources_added:
+            print(f"  Added {result.sources_added} new source(s).")
+        if not dry_run:
+            print(f"  File: {get_sources_path()}")
+        print()
+
+    if dry_run:
+        print("Re-run without --dry-run to persist.")
+
+
+def cmd_probe_models(machine_label: str = "local",
+                     output_format: str = "summary",
+                     dry_run: bool = False):
+    """Probe model orchestra and regenerate ~/.seif/model_registry.json."""
+    try:
+        from seif.context.model_probe import (
+            probe_all, merge_cached_remote, write_registry,
+            format_orchestra, get_registry_path,
+        )
+    except ImportError:
+        print("Installation error: seif.context.model_probe not found.")
+        return
+    import json as _json
+
+    result = probe_all(machine_label=machine_label)
+    merge_cached_remote(result)
+
+    if output_format == "json":
+        print(_json.dumps(result.to_registry(), indent=2, ensure_ascii=False))
+    elif output_format == "orchestra":
+        print(format_orchestra(result))
+    else:  # summary
+        path = get_registry_path()
+        print(f"Probed in {result.duration_ms} ms.")
+        print(f"Registry: {path}{' (dry-run)' if dry_run else ''}")
+        print(f"  Models discovered: {len(result.models)}")
+        cli_n = sum(1 for m in result.models if m['id'].startswith('cli/'))
+        ide_n = sum(1 for m in result.models if m['id'].startswith('ide/'))
+        ollama_n = sum(1 for m in result.models if m['id'].startswith('ollama/'))
+        api_n = sum(1 for m in result.models
+                    if any(m['id'].startswith(p) for p in ('xai/', 'anthropic/', 'google/', 'openai/')))
+        cached_n = sum(1 for m in result.models if m['status'] == 'cached')
+        print(f"    CLI tools:    {cli_n}")
+        print(f"    IDE:          {ide_n}")
+        print(f"    Ollama local: {ollama_n}")
+        print(f"    API keys:     {api_n}")
+        print(f"    Cached remote:{cached_n}")
+        c = result.circuit
+        if c.get("connected"):
+            print(f"  Circuit: connected ({c.get('machine','?')}/{c.get('transport','?')})")
+        else:
+            print(f"  Circuit: offline")
+
+    if not dry_run:
+        write_registry(result)
+
+
+def cmd_rebuild_registry(scan_roots: list[str], dry_run: bool = False):
+    """Rebuild ~/.seif/registry.json from filesystem scan.
+
+    Drops stale entries (missing paths, ephemeral tempdirs) and discovers any
+    .seif/ workspaces under the given scan_roots that are not yet registered.
+    """
+    try:
+        from seif.context.registry import (
+            rebuild_registry,
+            load_registry,
+            get_registry_path,
+        )
+    except ImportError:
+        print("Installation error: seif.context.registry not found.")
+        return
+
+    # If no scan roots given, derive from existing registry: parents of known
+    # contexts make natural search roots.
+    if not scan_roots:
+        existing = load_registry().get("contexts", [])
+        derived = set()
+        for ctx in existing:
+            try:
+                from pathlib import Path as _P
+                p = _P(ctx["path"]).parent.parent
+                if p.exists() and "/var/folders/" not in str(p):
+                    derived.add(str(p))
+            except (KeyError, TypeError):
+                continue
+        if not derived:
+            print("No --scan-root given and no usable parents in existing registry.")
+            print("Provide one or more roots, e.g.:")
+            print("  seif --rebuild-registry --scan-root /Volumes/DockerData")
+            return
+        scan_roots = sorted(derived)
+
+    print(f"Registry: {get_registry_path()}")
+    print(f"Scan roots:")
+    for r in scan_roots:
+        print(f"  - {r}")
+    if dry_run:
+        print("(dry-run — no changes will be written)")
+    print()
+
+    result = rebuild_registry(scan_roots, dry_run=dry_run)
+
+    print(f"Kept    : {result['kept']:>4}  (existing entries with valid paths)")
+    print(f"Dropped : {result['dropped']:>4}  (stale or ephemeral)")
+    print(f"Added   : {result['added']:>4}  (newly discovered)")
+    print(f"Total   : {result['total']:>4}")
+
+    if result["added_entries"]:
+        print()
+        print("Added contexts:")
+        for e in result["added_entries"]:
+            print(f"  + {e['name']:<25} {e['path']}")
+    if result["dropped_entries"]:
+        print()
+        print(f"Dropped {len(result['dropped_entries'])} entries (first 5 shown):")
+        for e in result["dropped_entries"][:5]:
+            name = e.get("name", "?")
+            path = e.get("path", "?")
+            print(f"  - {name:<25} {path}")
+
+    if dry_run:
+        print()
+        print("Re-run without --dry-run to write changes.")
+
+
 def cmd_status(context_repo: str = None):
     """Show detailed status of the current .seif context."""
     from pathlib import Path
@@ -4114,6 +4540,58 @@ def main():
     parser.add_argument("--all", action="store_true", help="Pipeline completo (padrão)")
     parser.add_argument("--init", nargs="?", const=".", metavar="PATH",
                         help="Initialize S.E.I.F.: scan, detect projects, extract git, generate .seif")
+    parser.add_argument("--rebuild-registry", action="store_true",
+                        help="Rebuild ~/.seif/registry.json by scanning the filesystem. "
+                             "Drops stale entries (missing paths, tempdirs from old test runs). "
+                             "Use --scan-root to specify directories to scan; defaults to "
+                             "the parent of any context already in the registry.")
+    parser.add_argument("--scan-root", action="append", default=[], metavar="PATH",
+                        help="Directory to scan for .seif/ workspaces (repeatable). "
+                             "Used with --rebuild-registry.")
+    parser.add_argument("--dry-run", action="store_true",
+                        help="Preview the operation without writing changes "
+                             "(applies to --rebuild-registry, --probe-models).")
+    parser.add_argument("--probe-models", action="store_true",
+                        help="Probe local Ollama, installed CLI tools, API keys, and circuitd; "
+                             "regenerate ~/.seif/model_registry.json for this host. "
+                             "Per-host file (each machine sees different reachable models).")
+    parser.add_argument("--audit-host", action="store_true",
+                        help="Audit ~/.seif/ host-level structure across the 5 architecture "
+                             "layers (A: protocol, B: init-generated, C: derived, D: per-host, "
+                             "E: heartbeat). Complementary to --audit (which checks context "
+                             "modules). With --fix-host, regenerates missing/stale files.")
+    parser.add_argument("--fix-host", action="store_true",
+                        help="With --audit-host, automatically regenerate missing or stale files.")
+    parser.add_argument("--init-host", action="store_true",
+                        help="Initialize host-specific files (~/.seif/machine_id, "
+                             "optionally bridge-config.json and sources.json). Idempotent: "
+                             "only writes missing fields unless --overwrite-machine-id is set. "
+                             "These files are NEVER synced between machines.")
+    parser.add_argument("--label", metavar="LABEL",
+                        help="Machine label (e.g. 'mini-m4'). Default: derived from hostname. "
+                             "Used with --init-host.")
+    parser.add_argument("--host-role", default="dev", choices=("production", "dev", "edge", "ephemeral"),
+                        metavar="ROLE", dest="host_role",
+                        help="Host role within the SEIF circuit. Used with --init-host. "
+                             "(Note: --role is reserved for --quality-gate's text author role.)")
+    parser.add_argument("--overwrite-machine-id", action="store_true",
+                        help="Rotate the machine_id fingerprint (otherwise re-running --init-host "
+                             "preserves the existing fingerprint).")
+    parser.add_argument("--hub", action="append", default=[], metavar="SPEC",
+                        help="Bridge hub spec: 'name=host[:port][,ssh=ssh-host][,key=path]'. "
+                             "Repeatable. Triggers writing bridge-config.json. "
+                             "Example: --hub 'mini-primary=100.93.186.89:7332,ssh=mini'")
+    parser.add_argument("--source", action="append", default=[], metavar="SPEC",
+                        help="Source repo spec: 'repo[:type[:classification]]'. Type is one of "
+                             "context|research|project (default: context). Classification "
+                             "defaults to PUBLIC/INTERNAL/CONFIDENTIAL based on type. Repeatable.")
+    parser.add_argument("--machine-label", default="local", metavar="LABEL",
+                        help="Machine label for CLI-tool entries (e.g. 'air-m1', 'mini-m4'). "
+                             "Used with --probe-models.")
+    parser.add_argument("--format", default="summary", choices=("summary", "orchestra", "json"),
+                        metavar="FMT",
+                        help="Output format for --probe-models: summary (counts), "
+                             "orchestra (session-start block), json (full registry).")
     parser.add_argument("-y", "--yes", action="store_true",
                         help="Skip confirmation prompt (auto-approve)")
     parser.add_argument("--install-hooks", nargs="?", const=".", metavar="REPO",
@@ -4955,6 +5433,29 @@ def main():
                 auto_yes=args.yes)
         return
 
+    if getattr(args, "rebuild_registry", False):
+        cmd_rebuild_registry(scan_roots=args.scan_root, dry_run=args.dry_run)
+        return
+
+    if getattr(args, "probe_models", False):
+        cmd_probe_models(machine_label=args.machine_label,
+                         output_format=args.format,
+                         dry_run=args.dry_run)
+        return
+
+    if getattr(args, "init_host", False):
+        cmd_init_host(label=args.label,
+                      role=args.host_role,
+                      overwrite_machine_id=args.overwrite_machine_id,
+                      hub_specs=args.hub,
+                      source_specs=args.source,
+                      dry_run=args.dry_run)
+        return
+
+    if getattr(args, "audit_host", False):
+        cmd_audit_host(fix=args.fix_host, dry_run=args.dry_run)
+        return
+
     if args.sync is not None:
         cmd_sync(args.sync, args.author, args.via, context_repo=args.context_repo)
         return