core-runtime 0.1.1__py3-none-any.whl

cli/resources/admin/forensics.py

@@ -0,0 +1,97 @@
+# src/cli/resources/admin/forensics.py
+"""
+Admin Forensics Command - A2 Chain of Legality Evidence.
+Links Agent reasoning to Body execution for constitutional auditing.
+"""
+
+from __future__ import annotations
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from cli.logic.governance.forensics_service import GovernanceForensicsService
+from cli.utils import core_command
+from shared.cli.command_meta import CommandBehavior, CommandLayer, command_meta
+
+from .hub import app
+
+
+console = Console()
+
+
+@app.command("forensics")
+@command_meta(
+    canonical_name="admin.forensics",
+    behavior=CommandBehavior.READ,
+    layer=CommandLayer.MIND,
+    summary="Investigate the Chain of Legality for a specific session.",
+)
+@core_command(dangerous=False, requires_context=False)
+# ID: d8a39a36-cf22-4ceb-b301-08a28fb5a124
+async def admin_forensics_cmd(
+    session_id: str = typer.Argument(
+        ..., help="The UUID of the session to investigate."
+    ),
+) -> None:
+    """
+    Reconstructs the history of an autonomous operation.
+    Shows exactly what the AI thought vs what the System physically did.
+    """
+    service = GovernanceForensicsService()
+    console.print(
+        f"\n[bold cyan]🔎 Forensics: Reconstructing Session {session_id[:8]}...[/bold cyan]\n"
+    )
+    trail = await service.get_audit_trail(session_id)
+    if trail["intent"]:
+        intent = trail["intent"]
+        thought_process = f"[bold]Agent:[/bold] {intent['agent_name']}\n[bold]Goal :[/bold] {intent['goal']}\n[bold]Patterns Used:[/bold] {intent['pattern_stats']}"
+        console.print(
+            Panel(
+                thought_process,
+                title="[blue]Phase A: Intent & Reasoning[/blue]",
+                expand=False,
+            )
+        )
+    else:
+        console.print("[yellow]⚠️  No decision trace found for this session.[/yellow]")
+    if trail["actions"]:
+        console.print("\n[blue]Phase B: Executed Actions & Governance Verdicts[/blue]")
+        action_table = Table(show_header=True, header_style="bold magenta")
+        action_table.add_column("Time", style="dim")
+        action_table.add_column("Action", style="cyan")
+        action_table.add_column("Result")
+        action_table.add_column("Metadata", style="dim")
+        for action in trail["actions"]:
+            status = (
+                "[green]PASS[/green]"
+                if action["ok"]
+                else f"[red]FAIL: {action['error_message']}[/red]"
+            )
+            action_table.add_row(
+                str(action["created_at"])[:19],
+                action["action_type"],
+                status,
+                str(action["action_metadata"]),
+            )
+        console.print(action_table)
+    else:
+        console.print(
+            "[yellow]⚠️  No physical actions recorded for this session.[/yellow]"
+        )
+    if trail["legality_verified"]:
+        console.print(
+            "\n[bold green]⚖️  VERDICT: CHAIN OF LEGALITY VERIFIED[/bold green]"
+        )
+        console.print(
+            "[dim]Every action in this session is backed by a recorded reasoning trace.[/dim]\n"
+        )
+    else:
+        console.print(
+            "\n[bold red]⚖️  VERDICT: ILLEGITIMATE SESSION DETECTED[/bold red]"
+        )
+        console.print(
+            "[red]Critical Error: This session contains actions that lack recorded intent.[/red]\n"
+        )
+        raise typer.Exit(code=1)

cli/resources/admin/health.py

@@ -0,0 +1,66 @@
+# src/cli/resources/admin/health.py
+import typer
+from rich.console import Console
+from rich.table import Table
+from sqlalchemy import text
+
+from cli.utils import core_command
+from shared.cli.command_meta import CommandBehavior, CommandLayer, command_meta
+from shared.infrastructure.database.session_manager import get_session
+
+from .hub import app
+
+
+console = Console()
+
+
+@app.command("health")
+@command_meta(
+    canonical_name="admin.health",
+    behavior=CommandBehavior.READ,
+    layer=CommandLayer.BODY,
+    summary="View the continuous system health log trend from background observers.",
+)
+@core_command(dangerous=False, requires_context=False)
+# ID: f03440ee-7fa3-4496-921d-77255394464d
+async def admin_health_cmd(
+    limit: int = typer.Option(
+        10, "--limit", "-n", help="Number of recent health snapshots to show."
+    ),
+) -> None:
+    """
+    Reads the system_health_log populated by the continuous ObserverWorker.
+    Replaces the legacy 'check audit' active scan with a passive, instant ledger read.
+    """
+    console.print("\n[bold cyan]🏥 Continuous System Health Trend[/bold cyan]\n")
+    query = text(
+        "\n        SELECT observed_at, open_findings, stale_entries, silent_workers, orphaned_symbols\n        FROM core.system_health_log\n        ORDER BY observed_at DESC\n        LIMIT :limit\n    "
+    )
+    async with get_session() as session:
+        result = await session.execute(query, {"limit": limit})
+        rows = result.fetchall()
+    if not rows:
+        console.print("[yellow]No health logs found. Is the daemon running?[/yellow]")
+        return
+    table = Table(show_header=True, header_style="bold magenta")
+    table.add_column("Observed At", style="dim")
+    table.add_column("Open Findings", justify="right")
+    table.add_column("Stale Entries", justify="right")
+    table.add_column("Silent Workers", justify="right")
+    table.add_column("Orphaned Symbols", justify="right")
+    for row in rows:
+        f_color = "red" if row.open_findings > 0 else "green"
+        s_color = "yellow" if row.stale_entries > 0 else "green"
+        w_color = "red" if row.silent_workers > 0 else "green"
+        o_color = "yellow" if row.orphaned_symbols > 0 else "green"
+        table.add_row(
+            row.observed_at.strftime("%Y-%m-%d %H:%M:%S"),
+            f"[{f_color}]{row.open_findings}[/{f_color}]",
+            f"[{s_color}]{row.stale_entries}[/{s_color}]",
+            f"[{w_color}]{row.silent_workers}[/{w_color}]",
+            f"[{o_color}]{row.orphaned_symbols}[/{o_color}]",
+        )
+    console.print(table)
+    console.print(
+        "\n[dim]Run `core-admin workers blackboard` to investigate specific findings.[/dim]\n"
+    )

cli/resources/admin/hub.py

@@ -0,0 +1,9 @@
+# src/cli/resources/admin/hub.py
+import typer
+
+
+app = typer.Typer(
+    name="admin",
+    help="System forensics: decision traces, refusals, and pattern analytics.",
+    no_args_is_help=True,
+)

cli/resources/admin/meta.py

@@ -0,0 +1,47 @@
+# src/cli/resources/admin/meta.py
+import typer
+from rich.console import Console
+
+from body.analyzers.constitutional_path_analyzer import ConstitutionalPathAnalyzer
+from cli.utils import core_command
+from shared.action_types import ActionImpact, ActionResult
+from shared.atomic_action import atomic_action
+
+from .hub import app
+
+
+console = Console()
+
+
+@app.command("meta")
+@atomic_action(
+    action_id="admin.meta",
+    intent="List all indexed constitutional files.",
+    impact=ActionImpact.READ_ONLY,
+    policies=["governance.audit_context"],
+)
+@core_command(dangerous=False, requires_context=False)
+# ID: 05ee1736-8480-40f6-94d9-f0e813eb5e0c
+async def admin_meta_cmd(
+    ctx: typer.Context,
+    format: str = typer.Option("list", "--format", help="Output format (list|json)"),
+    **kwargs,
+) -> ActionResult:
+    """
+    Explore the System Mind: Prints all authoritative constitutional files.
+    """
+    analyzer = ConstitutionalPathAnalyzer()
+    result = await analyzer.execute()
+    paths = result.data["paths"]
+    if format == "json":
+        import json
+
+        console.print(json.dumps(paths, indent=2))
+    else:
+        console.print(
+            f"\n[bold cyan]🏛️  Authoritative Mind Artifacts ({len(paths)}):[/bold cyan]"
+        )
+        for p in paths:
+            console.print(f"  [dim]•[/dim] {p}")
+        console.print()
+    return ActionResult(action_id="admin.meta", ok=True, data=result.data)

cli/resources/admin/patterns.py

@@ -0,0 +1,28 @@
+# src/cli/resources/admin/patterns.py
+
+import typer
+
+from cli.utils import core_command
+
+from .hub import app
+
+
+@app.command("patterns")
+@core_command(dangerous=False, requires_context=True)
+# ID: 2763bdbf-a6d8-44f5-bf47-5972d4dee390
+async def admin_patterns_cmd(
+    ctx: typer.Context,
+    last: int = typer.Option(
+        10, "--last", "-l", help="Number of recent traces to analyze."
+    ),
+):
+    """
+    Analyze architectural pattern usage and classification accuracy.
+
+    Helps identify if certain code patterns (like 'action_pattern')
+    are frequently misidentified or failing validation.
+    """
+    from cli.commands.inspect.patterns import patterns_cmd as logic_func
+
+    # We forward to the existing logic which analyzes JSON traces in reports/
+    await logic_func(ctx, last=last)

cli/resources/admin/refusals.py

@@ -0,0 +1,31 @@
+# src/cli/resources/admin/refusals.py
+
+import typer
+
+from cli.utils import core_command
+from shared.infrastructure.intent.operational_config import load_operational_config
+
+from .hub import app
+
+
+_CFG = load_operational_config().misc
+
+
+@app.command("refusals")
+@core_command(dangerous=False, requires_context=False)
+# ID: 89bbb5fe-04e4-48b9-9841-3afa714906a2
+async def admin_refusals_cmd(
+    limit: int = typer.Option(_CFG.refusal_inspect_default_limit, "--limit", "-n"),
+    refusal_type: str = typer.Option(
+        None, "--type", "-t", help="Filter by type (e.g. boundary, extraction)"
+    ),
+):
+    """
+    Audit constitutional refusal outcomes.
+
+    Refusals are first-class outcomes where CORE chose to stop because
+    an operation was unsafe or lacked sufficient context.
+    """
+    from cli.logic.refusal_inspect_logic import show_recent_refusals
+
+    await show_recent_refusals(limit=limit, refusal_type=refusal_type, details=True)

cli/resources/admin/self_check.py

@@ -0,0 +1,175 @@
+# src/cli/resources/admin/self_check.py
+
+"""``core-admin admin self-check`` — manual preflight against the same
+``cli_gate`` engine the autonomous audit uses.
+
+The command audits the live Typer command registry against the eight
+``cli.*`` rules wired to ``engine: cli_gate`` in
+``.intent/enforcement/mappings/cli/interface_design.yaml`` (plus
+``cli.command.no_duplicates`` in ``infrastructure/cli_commands.yaml``).
+Findings are produced by the canonical ``CliCheck`` implementations and
+match what ``core-admin code audit`` produces for the same rules.
+
+``--write`` invokes ``MetadataScribeService`` to autonomously assign
+``@command_meta`` decorators to commands that lack explicit metadata.
+That branch is independent of the audit and uses ``walk_typer_app``
+directly for command discovery.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import typer
+from rich.console import Console
+
+from body.atomic.executor import ActionExecutor
+from cli.utils import core_command
+from shared.cli.command_meta import CommandBehavior, CommandLayer, command_meta
+from shared.models import AuditFinding
+
+from .hub import app
+
+
+console = Console()
+
+
+_CLI_GATE_RULE_IDS: tuple[str, ...] = (
+    "cli.resource_first",
+    "cli.no_layer_exposure",
+    "cli.standard_verbs",
+    "cli.dangerous_explicit",
+    "cli.async_execution",
+    "cli.discovery_strict",
+    "cli.help_required",
+    "cli.command.no_duplicates",
+)
+
+
+@app.command("self-check")
+@command_meta(
+    canonical_name="admin.self-check",
+    behavior=CommandBehavior.VALIDATE,
+    layer=CommandLayer.BODY,
+    summary="Validate CLI command registration and constitutional alignment",
+)
+@core_command(dangerous=True, requires_context=True)
+# ID: 6fa9d0bd-63d7-4d93-a326-d0ee95793423
+async def self_check_cmd(
+    ctx: typer.Context,
+    verbose: bool = typer.Option(
+        False, "--verbose", "-v", help="Show full command listing."
+    ),
+    write: bool = typer.Option(
+        False, "--write", help="Autonomously repair missing metadata using AI."
+    ),
+) -> None:
+    """
+    Validate CLI registry against structural and constitutional rules.
+    Use --write to automatically assign missing @command_meta decorators.
+    """
+    from cli.admin_cli import app as main_app
+    from mind.governance.enforcement_loader import EnforcementMappingLoader
+    from mind.logic.engines.registry import EngineRegistry
+    from shared.cli.app_introspection import walk_typer_app
+    from shared.infrastructure.intent.intent_repository import get_intent_repository
+    from will.maintenance.metadata_scribe_service import MetadataScribeService
+
+    core_context = ctx.obj
+
+    commands = walk_typer_app(main_app, include_missing_handlers=True)
+    unassigned = [c for c in commands if not c.get("has_explicit_meta")]
+
+    if write:
+        scribe = MetadataScribeService(core_context.cognitive_service)
+        executor = ActionExecutor(core_context)
+        if not unassigned:
+            console.print(
+                "[green]✅ All commands have explicit metadata. Nothing to scribe.[/green]"
+            )
+            return
+        console.print(
+            f"[bold cyan]🖋️  Metascribe: Analyzing {len(unassigned)} unassigned commands...[/bold cyan]\n"
+        )
+        for cmd in unassigned:
+            f_path = Path(cmd["file_path"])
+            if not f_path.exists():
+                continue
+            source = f_path.read_text(encoding="utf-8")
+            meta_draft = await scribe.draft_metadata(
+                function_name=cmd["entrypoint"],
+                docstring=cmd["summary"] or "",
+                file_path=cmd["file_path"],
+                source_code=source,
+            )
+            if meta_draft:
+                console.print(
+                    f"   → Proposed for [yellow]{cmd['name']}[/yellow]: {meta_draft['canonical_name']}"
+                )
+                decorator = (
+                    f'@command_meta(\n    canonical_name="{meta_draft["canonical_name"]}",\n'
+                    f"    behavior=CommandBehavior.{meta_draft['behavior'].upper()},\n"
+                    f"    layer=CommandLayer.{meta_draft['layer'].upper()},\n"
+                    f'    summary="{meta_draft["summary"]}",\n'
+                    f"    dangerous={meta_draft['dangerous']}\n)\n"
+                )
+                target_def = f"def {cmd['entrypoint']}"
+                if f"async def {cmd['entrypoint']}" in source:
+                    target_def = f"async def {cmd['entrypoint']}"
+                new_source = source.replace(target_def, f"{decorator}{target_def}")
+                rel_path = str(f_path.relative_to(core_context.git_service.repo_path))
+                await executor.execute(
+                    "file.edit", write=True, file_path=rel_path, code=new_source
+                )
+        return
+
+    repo = get_intent_repository()
+    repo.initialize()
+    loader = EnforcementMappingLoader(intent_root=repo.root)
+    cli_gate_engine = EngineRegistry.get("cli_gate")
+
+    findings_by_rule: dict[str, list[AuditFinding]] = {}
+    skipped: list[str] = []
+    for rule_id in _CLI_GATE_RULE_IDS:
+        strategy = loader.get_enforcement_strategy(rule_id)
+        if not strategy or strategy.get("engine") != "cli_gate":
+            skipped.append(rule_id)
+            continue
+        params: dict[str, Any] = dict(strategy.get("params", {}))
+        findings = await cli_gate_engine.verify_context(
+            core_context.auditor_context, params
+        )
+        if findings:
+            findings_by_rule[rule_id] = findings
+
+    total_findings = sum(len(v) for v in findings_by_rule.values())
+
+    console.print("\n[bold cyan]🔍 CLI Registry Audit Results[/bold cyan]\n")
+
+    if findings_by_rule:
+        console.print("[bold red]❌ CONSTITUTIONAL VIOLATIONS:[/bold red]")
+        for rule_id, findings in findings_by_rule.items():
+            console.print(f"  [bold]{rule_id}[/bold] — {len(findings)} finding(s)")
+            for finding in findings:
+                item = finding.context.get("command_name") or finding.file_path or "?"
+                console.print(f"    • {finding.message} ([dim]{item}[/dim])")
+        console.print("")
+
+    if skipped:
+        console.print(f"[yellow]⚠️  Unmapped (skipped): {', '.join(skipped)}[/yellow]\n")
+
+    console.print(f"  Total commands:            [bold]{len(commands)}[/bold]")
+    console.print(f"  Total findings:            [bold]{total_findings}[/bold]")
+    console.print(
+        f"  Missing explicit @meta:    [bold yellow]{len(unassigned)}[/bold yellow]"
+    )
+    if unassigned:
+        console.print(
+            "\n[yellow]💡 Run with --write to autonomously assign metadata via AI.[/yellow]"
+        )
+
+    if not findings_by_rule and not skipped:
+        console.print(
+            "\n[bold green]✅ CLI Registry is healthy and aligned.[/bold green]"
+        )

cli/resources/admin/status.py

@@ -0,0 +1,66 @@
+# src/cli/resources/admin/status.py
+"""
+Admin Status Command - Infrastructure Health Sensation.
+"""
+
+from __future__ import annotations
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from cli.utils import core_command
+from shared.cli.command_meta import CommandBehavior, CommandLayer, command_meta
+from shared.infrastructure.diagnostic_service import DiagnosticService
+
+from .hub import app
+
+
+console = Console()
+
+
+@app.command("status")
+@command_meta(
+    canonical_name="admin.status",
+    behavior=CommandBehavior.READ,
+    layer=CommandLayer.BODY,
+    summary="Sensory check of system infrastructure and connectivity.",
+)
+@core_command(dangerous=False, requires_context=True)
+# ID: 142e8bb4-c0cf-4913-890d-0eaa49913ec0
+async def admin_status_cmd(ctx: typer.Context) -> None:
+    """
+    Perform a sensory check of the Body's physical connections.
+    Validates Database, Vector store, and Environment coordinates.
+    """
+    core_context = ctx.obj
+    service = DiagnosticService(core_context.git_service.repo_path)
+    console.print(
+        "\n[bold cyan]📡 Sensation: Probing System Infrastructure...[/bold cyan]\n"
+    )
+    connectivity = await service.check_connectivity()
+    table = Table(
+        title="Infrastructure Connectivity",
+        show_header=True,
+        header_style="bold magenta",
+    )
+    table.add_column("Component", style="cyan")
+    table.add_column("Status", justify="center")
+    table.add_column("Detail", style="dim")
+    for name, result in connectivity.items():
+        status_icon = "[green]OK[/green]" if result["ok"] else "[red]FAIL[/red]"
+        table.add_row(name.capitalize(), status_icon, result["detail"])
+    console.print(table)
+    fs_errors = service.check_file_system()
+    if not fs_errors:
+        console.print("\n[green]✅ All mandatory constitutional roots found.[/green]")
+    else:
+        console.print("\n[bold red]❌ File System Gaps Detected:[/bold red]")
+        for err in fs_errors:
+            console.print(f"  [yellow]•[/yellow] {err}")
+    all_ok = all(r["ok"] for r in connectivity.values()) and (not fs_errors)
+    if all_ok:
+        console.print("\n[bold green]🛡️  Body Health: OPTIMAL[/bold green]\n")
+    else:
+        console.print("\n[bold red]⚠️  Body Health: DEGRADED[/bold red]\n")
+        raise typer.Exit(code=1)

cli/resources/admin/summary.py

@@ -0,0 +1,67 @@
+# src/cli/resources/admin/summary.py
+"""
+Admin Summary Command - Operational Health Visualization.
+Provides a high-level overview of recent Body actions and failures.
+"""
+
+from __future__ import annotations
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from cli.logic.governance.limb_status_service import LimbStatusService
+from cli.utils import core_command
+from shared.cli.command_meta import CommandBehavior, CommandLayer, command_meta
+
+from .hub import app
+
+
+console = Console()
+
+
+@app.command("summary")
+@command_meta(
+    canonical_name="admin.summary",
+    behavior=CommandBehavior.READ,
+    layer=CommandLayer.BODY,
+    summary="Display a summary of recent operational health and failures.",
+)
+@core_command(dangerous=False, requires_context=True)
+# ID: 12f53c63-d4f9-42ab-8d12-ba027ee84eea
+async def admin_summary_cmd(
+    ctx: typer.Context,
+    limit: int = typer.Option(
+        15, "--limit", "-n", help="Number of recent actions to analyze."
+    ),
+) -> None:
+    """
+    Summarizes the most recent actions in the Body's ledger.
+    Explicitly highlights 'Pain Signals' (errors) for human review.
+    """
+    core_context = ctx.obj
+    service = LimbStatusService(session_factory=core_context.registry.session)
+    console.print(
+        "\n[bold cyan]🧬 Sensation: Aggregating Limb Health Summary...[/bold cyan]\n"
+    )
+    health = await service.get_recent_limb_health(limit=limit)
+    status_color = "green" if health["status"] == "OPTIMAL" else "yellow"
+    status_text = f"Limb State  : [bold {status_color}]{health['status']}[/bold {status_color}]\nScan Depth  : {health['total_checked']} actions\nPain Signals: {health['failure_count']} detected"
+    console.print(Panel(status_text, title="Operational Sensation", expand=False))
+    if health["issues"]:
+        console.print(
+            "\n[bold red]🚨 Detected Pain Signals (Recent Failures):[/bold red]"
+        )
+        table = Table(show_header=True, header_style="bold red")
+        table.add_column("Action / Neuron", style="cyan")
+        table.add_column("Error Message", style="yellow")
+        table.add_column("Time", style="dim", justify="right")
+        for issue in health["issues"]:
+            table.add_row(issue["action"], issue["error"], str(issue["time"])[:19])
+        console.print(table)
+    else:
+        console.print(
+            "\n[bold green]✅ System Harmony: No recent pain signals detected in the ledger.[/bold green]"
+        )
+    console.print()

cli/resources/admin/traces.py

@@ -0,0 +1,46 @@
+# src/cli/resources/admin/traces.py
+
+import typer
+
+from body.infrastructure.repositories.decision_trace_repository import (
+    DecisionTraceRepository,
+)
+from cli.utils import core_command
+from shared.infrastructure.database.session_manager import get_session
+
+from .hub import app
+
+
+@app.command("traces")
+@core_command(dangerous=False, requires_context=False)
+# ID: 63d5864d-b16c-474e-8c44-0d28083c9999
+async def admin_traces_cmd(
+    limit: int = typer.Option(
+        10, "--limit", "-n", help="Number of recent traces to show."
+    ),
+    session_id: str = typer.Option(
+        None, "--session", "-s", help="Show specific session details."
+    ),
+    failures_only: bool = typer.Option(
+        False, "--failures", help="Show only traces with violations."
+    ),
+):
+    """
+    Inspect autonomous decision traces.
+
+    Provides forensics on why AI agents chose specific implementations
+    or strategy pivots.
+    """
+    from cli.logic.decision_inspect_logic import (
+        list_recent_traces_logic,
+        show_session_trace_logic,
+    )
+
+    async with get_session() as session:
+        repo = DecisionTraceRepository(session)
+        if session_id:
+            await show_session_trace_logic(repo, session_id, details=True)
+        else:
+            await list_recent_traces_logic(
+                repo, limit, agent=None, failures_only=failures_only
+            )