cfa-kernel 0.1.0__py3-none-any.whl

cfa/cli/__init__.py

@@ -0,0 +1,296 @@
+"""
+CFA CLI — main entry point
+===========================
+argparse-based CLI with zero external dependencies.
+
+Commands are organized by family:
+- core/           evaluate, validate
+- governance/     rules, audit, catalog, signature, policy
+- reporting/      report, serve
+- project/        init, taxonomy
+- infrastructure/ backend_list
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="cfa",
+        description="CFA — Contextual Flux Architecture. Governed execution for AI and data systems.",
+    )
+    sub = parser.add_subparsers(dest="command")
+
+    p_eval = sub.add_parser("evaluate", help="Evaluate an intent through the governance pipeline")
+    p_eval.add_argument("intent", help="Natural language intent to evaluate")
+    p_eval.add_argument("--config", help="Path to cfa.yaml config file")
+    p_eval.add_argument("--catalog", "-c", help="Path to catalog JSON/YAML")
+    p_eval.add_argument("--policy-bundle", "-p", default="v1.0", help="Policy bundle version")
+    p_eval.add_argument("--backend", "-b", default="pyspark", help="Codegen backend name")
+    p_eval.add_argument("--format", "-f", choices=["table", "json", "summary"], default="table")
+    p_eval.add_argument("--output", "-o", help="Save result to file")
+    p_eval.add_argument("--warnings-blocking", action="store_true", help="Treat warnings as blocking")
+    p_eval.add_argument("--exit-code", action="store_true", help="Exit 1 if BLOCKED")
+    p_eval.add_argument("--normalizer", default="auto", choices=["auto", "rule_based", "mock", "openai", "deepseek", "llm"], help="Normalizer backend")
+    p_eval.add_argument("--strict", action="store_true", help="Block ambiguous intents")
+    p_eval.add_argument("--llm-model", help="LLM model name")
+    p_eval.add_argument("--llm-api-key", help="LLM API key")
+    p_eval.add_argument("--llm-base-url", help="LLM API base URL")
+    p_eval.add_argument("--llm-strict", action="store_true", help="Require LLM output to match catalog exactly")
+
+    p_val = sub.add_parser("validate", help="Validate an intent against a behavior spec")
+    p_val.add_argument("--spec", "-s", required=True, help="Path to behavior spec YAML")
+    p_val.add_argument("--intent", "-i", required=True, help="Intent to validate")
+    p_val.add_argument("--backend", "-b", default="pyspark")
+    p_val.add_argument("--exit-code", action="store_true", help="Exit 1 if BLOCKED")
+
+    p_rules = sub.add_parser("rules", help="Policy rule operations")
+    rules_sub = p_rules.add_subparsers(dest="rules_command")
+    p_list = rules_sub.add_parser("list", help="List all policy rules")
+    p_list.add_argument("--policy-bundle", "-p", default="v1.0")
+    p_list.add_argument("--format", "-f", choices=["table", "json"], default="table")
+    p_explain = rules_sub.add_parser("explain", help="Explain a fault code")
+    p_explain.add_argument("code", help="Fault code to explain")
+    p_explain.add_argument("--policy-bundle", "-p", default="v1.0")
+
+    p_audit = sub.add_parser("audit", help="Audit trail operations")
+    audit_sub = p_audit.add_subparsers(dest="audit_command")
+    p_show = audit_sub.add_parser("show", help="Show audit trail for an intent")
+    p_show.add_argument("--id", "-i", required=True, help="Intent ID")
+    p_show.add_argument("--file", help="Path to audit JSONL file")
+    p_show.add_argument("--data-dir", help="Path to audit data directory")
+    p_show.add_argument("--format", "-f", choices=["table", "json"], default="table")
+    p_show.add_argument("--output", "-o", help="Save to file")
+    p_verify = audit_sub.add_parser("verify", help="Verify audit chain integrity")
+    p_verify.add_argument("--id", "-i", help="Intent ID (omit for all)")
+    p_verify.add_argument("--file", help="Path to audit JSONL file")
+    p_verify.add_argument("--data-dir", help="Path to audit data directory")
+
+    p_tax = sub.add_parser("taxonomy", help="Behavior taxonomy operations")
+    tax_sub = p_tax.add_subparsers(dest="taxonomy_command")
+    p_gen = tax_sub.add_parser("generate", help="Generate taxonomy from behavior spec")
+    p_gen.add_argument("--spec", "-s", required=True, help="Path to behavior spec YAML")
+    p_gen.add_argument("--output", "-o", help="Save to file")
+    p_ti = tax_sub.add_parser("test-intents", help="Generate test intents from behavior spec")
+    p_ti.add_argument("--spec", "-s", required=True, help="Path to behavior spec YAML")
+    p_ti.add_argument("--count", "-n", type=int, default=5, help="Number of intents per category")
+    p_ti.add_argument("--output", "-o", help="Save to file")
+
+    p_be = sub.add_parser("backend", help="Backend operations")
+    be_sub = p_be.add_subparsers(dest="backend_command")
+    p_blist = be_sub.add_parser("list", help="List registered backends")
+    p_blist.add_argument("--format", "-f", choices=["table", "json"], default="table")
+
+    p_cat = sub.add_parser("catalog", help="Catalog operations")
+    cat_sub = p_cat.add_subparsers(dest="catalog_command")
+    p_cat_val = cat_sub.add_parser("validate", help="Validate a catalog JSON/YAML file")
+    p_cat_val.add_argument("path", help="Path to catalog JSON/YAML")
+    p_cat_val.add_argument("--require-datasets", action="store_true", help="Require at least one dataset")
+    p_cat_val.add_argument("--format", "-f", choices=["summary", "json"], default="summary")
+
+    p_sig = sub.add_parser("signature", help="StateSignature operations")
+    sig_sub = p_sig.add_subparsers(dest="signature_command")
+    p_sig_val = sig_sub.add_parser("validate", help="Validate a StateSignature JSON/YAML file")
+    p_sig_val.add_argument("path", help="Path to StateSignature JSON/YAML")
+    p_sig_val.add_argument("--require-datasets", action="store_true", help="Require at least one dataset")
+    p_sig_val.add_argument("--format", "-f", choices=["summary", "json"], default="summary")
+
+    p_pol = sub.add_parser("policy", help="Policy bundle operations")
+    pol_sub = p_pol.add_subparsers(dest="policy_command")
+    p_pol_val = pol_sub.add_parser("validate", help="Validate a policy bundle JSON/YAML file")
+    p_pol_val.add_argument("path", help="Path to policy bundle JSON/YAML")
+    p_pol_val.add_argument("--format", "-f", choices=["summary", "json"], default="summary")
+    p_pol_check = pol_sub.add_parser("check", help="Evaluate a StateSignature JSON/YAML against policy")
+    p_pol_check.add_argument("--config", help="Path to cfa.yaml config file")
+    p_pol_check.add_argument("--signature", "-s", required=True, help="Path to StateSignature JSON/YAML")
+    p_pol_check.add_argument("--catalog", help="Path to catalog JSON/YAML")
+    p_pol_check.add_argument("--policy-bundle", "-p", default="v1.0", help="Policy bundle version or path")
+    p_pol_check.add_argument("--format", "-f", choices=["summary", "json"], default="summary")
+    p_pol_check.add_argument("--exit-code", action="store_true", help="Exit 1 when action is not approve")
+    p_pol_check.add_argument("--require-datasets", action="store_true")
+    p_pol_check.add_argument("--strict", action="store_true", help="Validate signature datasets against catalog")
+    p_pol_check.add_argument("--audit-log", help="Append decision to audit JSONL file")
+
+    p_rep = sub.add_parser("report", help="Generate rich HTML reports")
+    rep_sub = p_rep.add_subparsers(dest="report_command")
+    p_rex = rep_sub.add_parser("execution", help="Execution report")
+    p_rex.add_argument("--intent", required=True, help="Intent text")
+    p_rex.add_argument("--intent-id", default="", help="Intent ID")
+    p_rex.add_argument("--state", default="approved", help="Decision state")
+    p_rex.add_argument("--signature-hash", default="", help="Signature hash")
+    p_rex.add_argument("--policy-bundle", default="v1.0", help="Policy bundle")
+    p_rex.add_argument("--replan-count", type=int, default=0)
+    p_rex.add_argument("--output", "-o", default="cfa_execution_report.html")
+    p_raud = rep_sub.add_parser("audit", help="Audit trail report")
+    p_raud.add_argument("--intent-id", required=True, help="Intent ID")
+    p_raud.add_argument("--policy-bundle", default="v1.0")
+    p_raud.add_argument("--output", "-o", default="cfa_audit_report.html")
+    p_rlife = rep_sub.add_parser("lifecycle", help="Lifecycle dashboard")
+    p_rlife.add_argument("--period", type=int, default=90, help="Period in days")
+    p_rlife.add_argument("--audit-file", help="Path to audit JSONL file for real data")
+    p_rlife.add_argument("--output", "-o", default="cfa_lifecycle_dashboard.html")
+    p_rcomp = rep_sub.add_parser("compliance", help="Compliance summary for auditors")
+    p_rcomp.add_argument("--policy-bundle", default="v1.0")
+    p_rcomp.add_argument("--audit-file", help="Path to audit JSONL file for real data")
+    p_rcomp.add_argument("--output", "-o", default="cfa_compliance_report.html")
+    p_rdash = rep_sub.add_parser("dashboard", help="Multi-pipeline dashboard")
+    p_rdash.add_argument("--period", type=int, default=90, help="Period in days")
+    p_rdash.add_argument("--audit-file", help="Path to audit JSONL file for real data")
+    p_rdash.add_argument("--output", "-o", default="cfa_dashboard.html")
+
+    p_srv = sub.add_parser("serve", help="Start live metrics/health server")
+    p_srv.add_argument("--port", "-p", type=int, default=8765)
+    p_srv.add_argument("--metrics-port", type=int, default=0, help="Enable /metrics on separate port")
+
+    p_init = sub.add_parser("init", help="Initialize CFA in current directory")
+    p_init.add_argument("--dir", "-d", default=".cfa", help="Target directory")
+
+    p_status = sub.add_parser("status", help="Show CFA project health and storage stats")
+    p_status.add_argument("--config", help="Path to cfa.yaml config file")
+    p_status.add_argument("--format", "-f", choices=["summary", "json"], default="summary")
+
+    # ── lifecycle ──────────────────────────────────────────────────────────
+    p_life = sub.add_parser("lifecycle", help="Lifecycle management operations")
+    life_sub = p_life.add_subparsers(dest="lifecycle_command")
+    p_life_eval = life_sub.add_parser("evaluate", help="Evaluate lifecycle indices for all skills")
+    p_life_eval.add_argument("--db", help="Path to SQLite database with execution records")
+    p_life_eval.add_argument("--policy-bundle", default="v1.0")
+    p_life_eval.add_argument("--window", type=int, default=30, help="Evaluation window in days")
+    p_life_eval.add_argument("--format", "-f", choices=["summary", "json"], default="summary")
+    p_life_list = life_sub.add_parser("list", help="List all tracked skills")
+    p_life_list.add_argument("--db", help="Path to SQLite database")
+    p_life_list.add_argument("--format", "-f", choices=["summary", "json"], default="summary")
+
+    # ── storage ────────────────────────────────────────────────────────────
+    p_stor = sub.add_parser("storage", help="Storage management operations")
+    stor_sub = p_stor.add_subparsers(dest="storage_command")
+    p_stor_stats = stor_sub.add_parser("stats", help="Show storage statistics")
+    p_stor_stats.add_argument("--db", help="Path to SQLite database")
+    p_stor_stats.add_argument("--dir", help="Path to JSONL storage directory")
+    p_stor_stats.add_argument("--format", "-f", choices=["summary", "json"], default="summary")
+    p_stor_cleanup = stor_sub.add_parser("cleanup", help="Remove records older than threshold")
+    p_stor_cleanup.add_argument("--db", help="Path to SQLite database")
+    p_stor_cleanup.add_argument("--dir", help="Path to JSONL storage directory")
+    p_stor_cleanup.add_argument("--before", help="ISO datetime cutoff (e.g. 2026-01-01T00:00:00)")
+    p_stor_cleanup.add_argument("--retention", type=int, dest="retention_days", help="Keep records from last N days")
+    p_stor_vacuum = stor_sub.add_parser("vacuum", help="Optimize/compact SQLite database")
+    p_stor_vacuum.add_argument("--db", required=True, help="Path to SQLite database")
+
+    return parser
+
+
+def main(args: list[str] | None = None) -> int:
+    parser = build_parser()
+    ns = parser.parse_args(args)
+
+    if ns.command is None:
+        parser.print_help()
+        return 0
+
+    from .core.evaluate import cmd_evaluate
+    from .core.validate import cmd_validate
+    from .governance.audit import cmd_audit_show, cmd_audit_verify
+    from .governance.catalog import cmd_catalog_validate
+    from .governance.policy import cmd_policy_check, cmd_policy_validate
+    from .governance.rules import cmd_rules_explain, cmd_rules_list
+    from .governance.signature import cmd_signature_validate
+    from .infrastructure.backend_list import cmd_backend_list
+    from .infrastructure.storage import cmd_storage_cleanup, cmd_storage_stats, cmd_storage_vacuum
+    from .project.init import cmd_init
+    from .project.lifecycle import cmd_lifecycle_evaluate, cmd_lifecycle_list
+    from .project.status import cmd_status
+    from .project.taxonomy import cmd_taxonomy_generate, cmd_taxonomy_test_intents
+    from .reporting.report import (
+        cmd_report_audit,
+        cmd_report_compliance,
+        cmd_report_dashboard,
+        cmd_report_execution,
+        cmd_report_lifecycle,
+    )
+    from .reporting.serve import cmd_serve
+
+    dispatch = {
+        "evaluate": cmd_evaluate,
+        "validate": cmd_validate,
+        "rules": lambda ns: (
+            cmd_rules_list(ns) if ns.rules_command == "list"
+            else cmd_rules_explain(ns) if ns.rules_command == "explain"
+            else _unknown(parser, "rules", ns.rules_command)
+        ),
+        "audit": lambda ns: (
+            cmd_audit_show(ns) if ns.audit_command == "show"
+            else cmd_audit_verify(ns) if ns.audit_command == "verify"
+            else _unknown(parser, "audit", ns.audit_command)
+        ),
+        "taxonomy": lambda ns: (
+            cmd_taxonomy_generate(ns) if ns.taxonomy_command == "generate"
+            else cmd_taxonomy_test_intents(ns) if ns.taxonomy_command == "test-intents"
+            else _unknown(parser, "taxonomy", ns.taxonomy_command)
+        ),
+        "backend": lambda ns: (
+            cmd_backend_list(ns) if ns.backend_command == "list"
+            else _unknown(parser, "backend", ns.backend_command)
+        ),
+        "catalog": lambda ns: (
+            cmd_catalog_validate(ns) if ns.catalog_command == "validate"
+            else _unknown(parser, "catalog", ns.catalog_command)
+        ),
+        "signature": lambda ns: (
+            cmd_signature_validate(ns) if ns.signature_command == "validate"
+            else _unknown(parser, "signature", ns.signature_command)
+        ),
+        "policy": lambda ns: (
+            cmd_policy_validate(ns) if ns.policy_command == "validate"
+            else cmd_policy_check(ns) if ns.policy_command == "check"
+            else _unknown(parser, "policy", ns.policy_command)
+        ),
+        "report": lambda ns: (
+            cmd_report_execution(ns) if ns.report_command == "execution"
+            else cmd_report_audit(ns) if ns.report_command == "audit"
+            else cmd_report_lifecycle(ns) if ns.report_command == "lifecycle"
+            else cmd_report_compliance(ns) if ns.report_command == "compliance"
+            else cmd_report_dashboard(ns) if ns.report_command == "dashboard"
+            else _unknown(parser, "report", ns.report_command)
+        ),
+        "serve": cmd_serve,
+        "init": cmd_init,
+        "status": cmd_status,
+        "lifecycle": lambda ns: (
+            cmd_lifecycle_evaluate(ns) if ns.lifecycle_command == "evaluate"
+            else cmd_lifecycle_list(ns) if ns.lifecycle_command == "list"
+            else _unknown(parser, "lifecycle", ns.lifecycle_command)
+        ),
+        "storage": lambda ns: (
+            cmd_storage_stats(ns) if ns.storage_command == "stats"
+            else cmd_storage_cleanup(ns) if ns.storage_command == "cleanup"
+            else cmd_storage_vacuum(ns) if ns.storage_command == "vacuum"
+            else _unknown(parser, "storage", ns.storage_command)
+        ),
+    }
+
+    handler = dispatch.get(ns.command)
+    if handler is None:
+        parser.print_help()
+        return 1
+
+    try:
+        return handler(ns)
+    except KeyboardInterrupt:
+        print("\nInterrupted.", file=sys.stderr)
+        return 130
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+
+
+def _unknown(parser: argparse.ArgumentParser, group: str, command: str | None) -> int:
+    print(f"Unknown {group} command: {command}", file=sys.stderr)
+    parser.print_help()
+    return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

cfa/cli/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for python -m cfa.cli"""
+import sys
+
+from cfa.cli import main
+
+sys.exit(main())

cfa/cli/_helpers.py

@@ -0,0 +1,109 @@
+"""Shared helpers for CFA CLI commands."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+
+def load_catalog(path: str | None) -> dict[str, Any] | None:
+    if not path:
+        return None
+    import json
+    raw = Path(path).read_text(encoding="utf-8")
+    if path.endswith(".yaml") or path.endswith(".yml"):
+        try:
+            import yaml
+            return yaml.safe_load(raw)
+        except ImportError:
+            import sys
+            print("Error: PyYAML required for YAML catalogs. Install: pip install pyyaml", file=sys.stderr)
+            sys.exit(1)
+    return json.loads(raw)
+
+
+def load_policy(path_or_version: str) -> tuple[list | None, str]:
+    p = Path(path_or_version)
+    if p.suffix in (".yaml", ".yml", ".json"):
+        from cfa.policy.bundle import PolicyBundle
+        bundle = PolicyBundle.from_yaml(str(p)) if p.suffix != ".json" else PolicyBundle.from_json(str(p))
+        return bundle.rules, bundle.version
+    return None, path_or_version
+
+
+def load_structured_file(path: str, yaml_error: str) -> dict[str, Any]:
+    import json
+
+    raw = Path(path).read_text(encoding="utf-8")
+    if path.endswith((".yaml", ".yml")):
+        try:
+            import yaml
+            return yaml.safe_load(raw)
+        except ImportError:
+            import sys
+            print(yaml_error, file=sys.stderr)
+            sys.exit(1)
+    return json.loads(raw)
+
+
+def apply_config_defaults(args, config):
+    """Apply config defaults to args for fields not explicitly set by user.
+
+    Only fills in None values — never overrides explicit CLI flags.
+    """
+    if config is None:
+        return
+    if hasattr(args, "catalog") and args.catalog is None:
+        cat = config.defaults.catalog
+        if cat and Path(cat).exists():
+            args.catalog = cat
+    if hasattr(args, "policy_bundle") and args.policy_bundle in ("v1.0", None):
+        pol = config.defaults.policy_bundle
+        if pol and Path(pol).exists():
+            args.policy_bundle = pol
+    if hasattr(args, "backend") and args.backend in ("pyspark", None):
+        args.backend = config.defaults.backend
+
+
+def resolve_normalizer(args) -> object:
+    import os
+    import sys
+
+    if args.normalizer == "mock":
+        return None
+
+    has_openai = os.environ.get("OPENAI_API_KEY")
+    has_deepseek = os.environ.get("DEEPSEEK_API_KEY")
+
+    if args.normalizer in ("openai", "llm") or (args.normalizer == "auto" and has_openai and not has_deepseek):
+        from cfa.normalizer.llm import LLMNormalizerBackend, OpenAILMProvider
+        provider = OpenAILMProvider(
+            model=args.llm_model or "gpt-4o-mini",
+            api_key=args.llm_api_key or None,
+            base_url=args.llm_base_url or None,
+        )
+        return LLMNormalizerBackend(provider=provider, strict=args.llm_strict)
+
+    if args.normalizer == "deepseek" or (args.normalizer == "auto" and has_deepseek):
+        from cfa.normalizer.llm import LLMNormalizerBackend, OpenAILMProvider
+        provider = OpenAILMProvider(
+            model=args.llm_model or "deepseek-chat",
+            base_url=args.llm_base_url or "https://api.deepseek.com",
+            api_key=args.llm_api_key or has_deepseek or None,
+        )
+        return LLMNormalizerBackend(provider=provider, strict=args.llm_strict)
+
+    if args.normalizer == "auto":
+        print("Note: No LLM API key found. Using keyword-matching normalizer.", file=sys.stderr)
+        print("Set OPENAI_API_KEY or DEEPSEEK_API_KEY for semantic understanding.", file=sys.stderr)
+
+    return None
+
+
+def resolve_config(args) -> object | None:
+    """Discover and return CFA config if --config is provided or auto-detect."""
+    from cfa.config import CfaConfig
+    if hasattr(args, "config") and args.config:
+        if Path(args.config).exists():
+            return CfaConfig.from_yaml(args.config)
+    return CfaConfig.discover()

cfa/cli/core/evaluate.py

@@ -0,0 +1,72 @@
+"""cfa evaluate — run an intent through the governance pipeline."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+
+def cmd_evaluate(args) -> int:
+    from cfa.cli._helpers import apply_config_defaults, load_catalog, load_policy, resolve_config, resolve_normalizer
+    from cfa.cli.formatters import format_evaluate_table, format_json, format_summary
+    from cfa.core.kernel import KernelConfig, KernelOrchestrator
+
+    config = resolve_config(args)
+    apply_config_defaults(args, config)
+    catalog = load_catalog(args.catalog)
+    policy_rules, bundle_version = load_policy(args.policy_bundle)
+    normalizer_backend = resolve_normalizer(args)
+
+    config = KernelConfig(
+        policy_bundle_version=bundle_version,
+        backend=args.backend,
+        warnings_are_blocking=args.warnings_blocking,
+        normalizer=args.normalizer,
+        strict_normalization=args.strict,
+    )
+
+    kernel = KernelOrchestrator(
+        catalog=catalog, config=config, policy_rules=policy_rules,
+        normalizer_backend=normalizer_backend,
+    )
+    result = kernel.process(args.intent)
+
+    faults: list[dict[str, Any]] = []
+    if result.policy_result:
+        for f in result.policy_result.faults:
+            faults.append({
+                "code": f.code,
+                "severity": f.severity.value,
+                "family": f.family.value,
+                "message": f.message,
+                "remediation": list(f.remediation),
+            })
+
+    output: dict[str, Any] = {
+        "intent": args.intent,
+        "intent_id": result.intent_id,
+        "state": result.state.value,
+        "signature_hash": result.signature.signature_hash if result.signature else "",
+        "replan_count": len(result.replan_history),
+        "policy_bundle": config.policy_bundle_version,
+        "faults": faults,
+    }
+
+    fmt = args.format or "table"
+    if fmt == "json":
+        print(format_json(output))
+    elif fmt == "summary":
+        print(format_summary(output, faults))
+    else:
+        print(format_evaluate_table(output, faults))
+
+    if args.output:
+        out_path = Path(args.output)
+        if out_path.suffix == ".json":
+            out_path.write_text(format_json(output), encoding="utf-8")
+        else:
+            out_path.write_text(format_summary(output, faults), encoding="utf-8")
+
+    if args.exit_code and result.state.value == "blocked":
+        return 1
+    return 0

cfa/cli/core/validate.py

@@ -0,0 +1,29 @@
+"""cfa validate — validate an intent against a behavior spec."""
+
+from __future__ import annotations
+
+import sys
+
+
+def cmd_validate(args) -> int:
+    from cfa.behavior import BehaviorSpec, Systematizer
+    from cfa.cli.formatters import _icon
+    from cfa.core.kernel import KernelConfig, KernelOrchestrator
+
+    try:
+        spec = BehaviorSpec.from_yaml(args.spec)
+    except Exception as e:
+        print(f"Error loading spec: {e}", file=sys.stderr)
+        return 1
+
+    _, rules = Systematizer().systematize(spec)
+    config = KernelConfig(policy_bundle_version=spec.name, backend=args.backend)
+    kernel = KernelOrchestrator(config=config, policy_rules=rules)
+    result = kernel.process(args.intent)
+
+    if result.is_executable:
+        print(f"{_icon('approved')} PASSED  | {result.state.value} | {args.intent[:60]}")
+        return 0
+    else:
+        print(f"{_icon('blocked')} BLOCKED | {result.blocked_reason}")
+        return 1 if args.exit_code else 0