@ngocsangairvds/vsaf 3.2.16 → 4.0.1

package/tools/vds-scripts/memory_orchestrator/src/vds_memory_orchestrator/cli.py

@@ -1,1457 +0,0 @@
-"""VDS AI Memory CLI — search, store, and manage cross-session memories.
-
-Follows the standard VDS orchestrator pattern (Typer + hatchling + vds-cli-common).
-See db_query_orchestrator and structure_orchestrator for reference implementations.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import json
-import os
-import sys
-import time
-from typing import Annotated
-
-import typer
-from rich.live import Live
-from rich.table import Table
-from websockets.exceptions import ConnectionClosedError
-
-from vds_cli_common import (
-    CLIContext,
-    ErrorHandler,
-    ExitCodes,
-    OutputManager,
-    create_version_callback,
-)
-from vds_cli_common.env import load_shared_env
-from vds_memory_client.client import _is_machine_context
-from vds_memory_orchestrator.client import MemoryClient
-from vds_memory_orchestrator.formatters import format_search_results
-
-# Phase 220 W4 — create-user command (FR-220.S.11)
-from vds_memory_orchestrator.service.use_cases.auth.create_user_use_case import (
-    CreateUserUseCase,
-)
-from vds_memory_orchestrator.service.use_cases.auth.exceptions import (
-    OperationNotPermittedInDevMode,
-    WeakPassword,
-)
-
-# Ensure `~/.vds/.env` is loaded for direct `vds-memory` usage.
-load_shared_env()
-
-APP_NAME = "vds-memory-orchestrator"
-VALID_COMMANDS = [
-    "search",
-    "store",
-    "get",
-    "delete",
-    "sessions",
-    "health",
-    "stats",
-    "cleanup",
-    "dedup",
-    "reconcile",
-    "replay-dlq",
-    "embedding-status",
-    "re-embed",
-    "promotion-status",
-    "repush",
-    "analytics-stream",
-    "entity-backfill",
-    "triage",
-    "evolution-status",
-]
-
-app = typer.Typer(
-    name="vds-memory",
-    help="VDS AI Memory — cross-session decision and evidence store",
-    rich_markup_mode="rich",
-)
-version_callback = create_version_callback(APP_NAME)
-
-
-def _default_api_url() -> str:
-    explicit_url = os.environ.get("VDS_MEMORY_API_URL", "").strip()
-    if explicit_url:
-        return explicit_url
-
-    api_port = os.environ.get("API_PORT", "").strip()
-    if api_port:
-        return f"http://localhost:{api_port}"
-
-    return "http://localhost:8000"
-
-
-def _get_state(ctx: typer.Context) -> tuple[OutputManager, ErrorHandler, MemoryClient]:
-    """Recover state from Typer context (set in callback)."""
-    obj = ctx.obj or {}
-    output = obj.get("output", OutputManager(CLIContext()))
-    error_handler = obj.get("error_handler", ErrorHandler(output))
-    client = obj.get("client", MemoryClient())
-    return output, error_handler, client
-
-
-@app.callback()
-def callback(
-    ctx: typer.Context,
-    _version: Annotated[
-        bool,
-        typer.Option(
-            "--version",
-            "-V",
-            callback=version_callback,
-            is_eager=True,
-            help="Show version and exit",
-        ),
-    ] = False,
-    json_only: Annotated[
-        bool,
-        typer.Option("--json-only", "-j", help="Output clean JSON only"),
-    ] = False,
-    quiet: Annotated[
-        bool,
-        typer.Option("--quiet", "-q", help="Suppress non-essential output"),
-    ] = False,
-    api_url: Annotated[
-        str,
-        typer.Option("--api-url", help="API base URL", envvar="VDS_MEMORY_API_URL"),
-    ] = _default_api_url(),
-    user_id: Annotated[
-        str,
-        typer.Option("--user-id", help="User ID for API calls", envvar="VDS_MEMORY_USER_ID"),
-    ] = "claude-agent",
-) -> None:
-    """VDS AI Memory — cross-session decision and evidence store."""
-    cli_ctx = CLIContext.from_options(json_only=json_only, quiet=quiet)
-    output = OutputManager(cli_ctx)
-    error_handler = ErrorHandler(output, valid_commands=VALID_COMMANDS)
-    client = MemoryClient(base_url=api_url, default_user_id=user_id)
-    ctx.obj = {
-        "cli_ctx": cli_ctx,
-        "output": output,
-        "error_handler": error_handler,
-        "client": client,
-    }
-
-    if ctx.invoked_subcommand is None:
-        output.ctx.console.print(ctx.get_help())
-        raise typer.Exit(ExitCodes.SUCCESS)
-
-
-@app.command("search")
-def search_cmd(
-    ctx: typer.Context,
-    query: Annotated[str, typer.Argument(help="Semantic search query")],
-    category: Annotated[
-        str | None,
-        typer.Option(
-            "--category",
-            "-c",
-            help="Filter by category. Valid: general, project, research, note, idea, task, reference, code, work, meeting, session-summary, validation, security, error, performance, hook-insight, business-logic, api-call, debug, user_preference, personal, tutorial, document, email, chat, web, other",
-        ),
-    ] = None,
-    importance: Annotated[
-        str | None,
-        typer.Option(
-            "--importance", "-i", help="Filter by importance. Valid: low, medium, high, critical"
-        ),
-    ] = None,
-    limit: Annotated[int, typer.Option("--limit", "-n")] = 10,
-    session_id: Annotated[
-        str | None,
-        typer.Option(
-            "--session-id",
-            "-s",
-            help="Restrict results to a single session ID (220.L L-2).",
-        ),
-    ] = None,
-    timeout: Annotated[
-        float | None,
-        typer.Option(
-            "--timeout",
-            "-T",
-            help="Request timeout in seconds. Overrides VDS_MEMORY_TIMEOUT_SECONDS env var.",
-        ),
-    ] = None,
-) -> None:
-    """Search memories by meaning. Searches all sessions unless --session-id is given."""
-    output, error_handler, client = _get_state(ctx)
-    if timeout is not None:
-        client._timeout = timeout
-    try:
-        result = asyncio.run(
-            client.search(query, category, importance, limit, session_id=session_id)
-        )
-        if output.ctx.json_only:
-            output.output_json(result)
-        else:
-            format_search_results(output, result)
-    except Exception as exc:
-        error_handler.handle_http_error(exc, url=client._base_url)
-
-
-@app.command("delete")
-def delete_cmd(
-    ctx: typer.Context,
-    memory_id: Annotated[str, typer.Argument(help="Memory ID to delete")],
-    timeout: Annotated[
-        float | None,
-        typer.Option(
-            "--timeout",
-            "-T",
-            help="Request timeout in seconds. Overrides VDS_MEMORY_TIMEOUT_SECONDS env var.",
-        ),
-    ] = None,
-) -> None:
-    """Delete a single memory by ID (soft delete). Closes 220.L L-3."""
-    output, error_handler, client = _get_state(ctx)
-    if timeout is not None:
-        client._timeout = timeout
-    try:
-        result = asyncio.run(client.delete(memory_id))
-        if output.ctx.json_only:
-            output.output_json(result)
-        else:
-            msg = result.get("message", "Memory deleted")
-            output.output_success(f"{msg}: {memory_id}")
-    except Exception as exc:
-        error_handler.handle_http_error(exc, url=client._base_url)
-
-
-@app.command("store")
-def store_cmd(
-    ctx: typer.Context,
-    content: Annotated[str, typer.Argument(help="Memory content to store")],
-    category: Annotated[
-        str,
-        typer.Option(
-            "--category",
-            "-c",
-            help="Valid: general, project, research, note, idea, task, reference, code, work, meeting, session-summary, validation, security, error, performance, hook-insight, business-logic, api-call, debug, user_preference, personal, tutorial, document, email, chat, web, other",
-        ),
-    ] = "general",
-    importance: Annotated[
-        str,
-        typer.Option("--importance", "-i", help="Valid: low, medium, high, critical"),
-    ] = "medium",
-    tags: Annotated[
-        str | None,
-        typer.Option("--tags", "-t", help="Comma-separated tags (stored in metadata.tags)"),
-    ] = None,
-    timeout: Annotated[
-        float | None,
-        typer.Option(
-            "--timeout",
-            "-T",
-            help="Request timeout in seconds. Overrides VDS_MEMORY_TIMEOUT_SECONDS env var.",
-        ),
-    ] = None,
-) -> None:
-    """Store a decision, fact, or evidence for cross-session reuse.
-
-    Tags are stored in metadata.tags because the API's create endpoint
-    does not persist a top-level tags field (live-verified).
-    """
-    output, error_handler, client = _get_state(ctx)
-    if timeout is not None:
-        client._timeout = timeout
-    tag_list = [t.strip() for t in tags.split(",")] if tags else None
-    try:
-        result = asyncio.run(client.store(content, category, importance, tag_list))
-        output.output_json(result)
-        if output.ctx.show_hints:
-            memory_id = result.get("memory_id", result.get("id", "?"))
-            output.output_success(f"Memory stored: {memory_id}")
-            output.ctx.console.print(
-                "[dim]Note: May take a few seconds to appear in search (async indexing).[/dim]"
-            )
-    except Exception as exc:
-        error_handler.handle_http_error(exc, url=client._base_url)
-
-
-@app.command("get")
-def get_cmd(
-    ctx: typer.Context,
-    memory_id: Annotated[str, typer.Argument(help="Memory ID to retrieve")],
-    timeout: Annotated[
-        float | None,
-        typer.Option(
-            "--timeout",
-            "-T",
-            help="Request timeout in seconds. Overrides VDS_MEMORY_TIMEOUT_SECONDS env var.",
-        ),
-    ] = None,
-) -> None:
-    """Retrieve a single memory by ID."""
-    output, error_handler, client = _get_state(ctx)
-    if timeout is not None:
-        client._timeout = timeout
-    try:
-        result = asyncio.run(client.get(memory_id))
-        output.output_json(result)
-    except Exception as exc:
-        # VAMI-026 P2: use the new resource_id/resource_type kwargs added
-        # to handle_http_error. On 404, emits "Memory not found:
-        # '<memory_id>'" instead of the base-URL leak. Replaces the
-        # VAMI-025 local try/except/isinstance wrapper.
-        error_handler.handle_http_error(
-            exc,
-            url=client._base_url,
-            resource_id=memory_id,
-            resource_type="Memory",
-        )
-
-
-@app.command("sessions")
-def sessions_cmd(ctx: typer.Context) -> None:
-    """List sessions for the current user."""
-    output, error_handler, client = _get_state(ctx)
-    try:
-        result = asyncio.run(client.list_sessions())
-        output.output_json(result)
-    except Exception as exc:
-        error_handler.handle_http_error(exc, url=client._base_url)
-
-
-@app.command("health")
-def health_cmd(ctx: typer.Context) -> None:
-    """Check VDS AI Memory service health."""
-    output, error_handler, client = _get_state(ctx)
-    try:
-        result = asyncio.run(client.health())
-        status = "unknown"
-        status_data = result.get("status")
-        if isinstance(status_data, dict):
-            status = status_data.get("overall", "unknown")
-        elif isinstance(status_data, str):
-            status = status_data
-
-        if output.ctx.json_only:
-            output.output_json(result)
-        else:
-            output.output_success(f"VDS AI Memory: {status}")
-            # Render mem0_sync section if present (AC-5.2)
-            mem0_sync = result.get("mem0_sync") or {}
-            if mem0_sync:
-                sync_status = mem0_sync.get("status", "unknown")
-                stall_rate = mem0_sync.get("stall_rate_percent", 0.0)
-                total = mem0_sync.get("total_memories", "?")
-                stalled = mem0_sync.get("stalled_mem0_count", 0)
-                missing = mem0_sync.get("stalled_reason_missing_in_list_count", 0)
-                perm = mem0_sync.get("permanently_stalled_count", 0)
-                if sync_status == "healthy":
-                    color = "green"
-                elif sync_status == "warning":
-                    color = "yellow"
-                else:
-                    color = "red"
-                output._console.print(
-                    f"  Mem0 sync: [{color}]{sync_status}[/{color}] (stall rate: {stall_rate}%)"
-                )
-                # Phase 220.M L-1: surface cloud_status so operator can see when
-                # cloud sync is silently skipping (mem0_not_configured / DNS fail).
-                cloud_status = mem0_sync.get("cloud_status")
-                if cloud_status:
-                    cloud_color = (
-                        "red" if cloud_status in ("not_configured", "unreachable") else "green"
-                    )
-                    mode = mem0_sync.get("mode", "unknown")
-                    output._console.print(
-                        f"    Cloud: [{cloud_color}]{cloud_status}[/{cloud_color}] (mode: {mode})"
-                    )
-                output._console.print(f"    Total memories: {total}")
-                output._console.print(f"    Stalled (mem0_status): {stalled}")
-                output._console.print(f"    Stalled (missing in list): {missing}")
-                output._console.print(f"    Permanently stalled: {perm}")
-            # FR-1: Render per-layer degradation detail (Phase 174)
-            if status != "healthy":
-                layers = result.get("layers") or {}
-                for layer_name, layer_data in layers.items():
-                    if isinstance(layer_data, dict):
-                        layer_status = layer_data.get("status", "unknown")
-                        if layer_status not in (None, "healthy"):
-                            color = "yellow" if layer_status == "warning" else "red"
-                            output._console.print(
-                                f"  Layer [{color}]{layer_name}[/{color}]: {layer_status}"
-                            )
-                for warn in result.get("warnings") or []:
-                    output._console.print(f"  [yellow]\u26a0[/yellow] {warn}")
-        raise typer.Exit(ExitCodes.SUCCESS if status == "healthy" else ExitCodes.GENERAL_ERROR)
-    except typer.Exit:
-        raise
-    except Exception as exc:
-        error_handler.handle_http_error(exc, url=client._base_url)
-
-
-@app.command("stats")
-def stats_cmd(
-    ctx: typer.Context,
-    include_internal: Annotated[
-        bool,
-        typer.Option("--include-internal", help="Include internal/_-prefixed user data in stats."),
-    ] = False,
-) -> None:
-    """Show VDS AI Memory statistics."""
-    output, error_handler, client = _get_state(ctx)
-    try:
-        result = asyncio.run(client.stats(include_internal=include_internal))
-        output.output_json(result)
-    except Exception as exc:
-        error_handler.handle_http_error(exc, url=client._base_url)
-
-
-@app.command("reconcile")
-def reconcile_cmd(
-    ctx: typer.Context,
-    limit: Annotated[
-        int, typer.Option("--limit", "-n", help="Max records to reconcile per run")
-    ] = 100,
-    dry_run: Annotated[
-        bool, typer.Option("--dry-run", help="Report without changing data")
-    ] = False,
-    json_only: Annotated[
-        bool, typer.Option("--json-only", "-j", help="Output clean JSON only")
-    ] = False,
-) -> None:
-    """Trigger memory reconciliation to repair inconsistencies."""
-    output, error_handler, client = _get_state(ctx)
-    if json_only:
-        output.ctx.json_only = True
-    try:
-        result = asyncio.run(client.reconcile(limit=limit, dry_run=dry_run))
-        output.output_json(result)
-    except Exception as exc:
-        error_handler.handle_http_error(exc, url=client._base_url)
-
-
-@app.command("replay-dlq")
-def replay_dlq_cmd(
-    ctx: typer.Context,
-    limit: Annotated[
-        int,
-        typer.Option(
-            "--limit",
-            "-n",
-            help="Max DLQ events to replay this batch (1-1000)",
-            min=1,
-            max=1000,
-        ),
-    ] = 25,
-    json_only: Annotated[
-        bool, typer.Option("--json-only", "-j", help="Output clean JSON only")
-    ] = False,
-) -> None:
-    """Synchronously drain the memory-evolution DLQ.
-
-    Replaces the raw `curl -X POST .../api/v1/tasks/replay-dlq` recipe.
-    Same async helper Celery beat runs every 15 minutes, but blocking so
-    the operator gets a drain confirmation in the response body.
-    """
-    output, error_handler, client = _get_state(ctx)
-    if json_only:
-        output.ctx.json_only = True
-    try:
-        result = asyncio.run(client.replay_dlq(limit=limit))
-        output.output_json(result)
-    except Exception as exc:
-        error_handler.handle_http_error(exc, url=client._base_url)
-
-
-@app.command("cleanup")
-def cleanup_cmd(
-    ctx: typer.Context,
-    remove_health_debris: Annotated[
-        bool,
-        typer.Option("--remove-health-debris", help="Remove health-probe sessions and memories"),
-    ] = False,
-    remove_stale_sessions: Annotated[
-        bool,
-        typer.Option(
-            "--remove-stale-sessions", help="Remove sessions inactive longer than --stale-days"
-        ),
-    ] = False,
-    stale_days: Annotated[
-        int, typer.Option("--stale-days", help="Days of inactivity before stale")
-    ] = 90,
-    dry_run: Annotated[
-        bool,
-        typer.Option("--dry-run", help="Report what would be removed without deleting"),
-    ] = True,
-    confirm: Annotated[
-        bool,
-        typer.Option("--confirm", help="Actually perform removal (overrides --dry-run)"),
-    ] = False,
-    json_only: Annotated[
-        bool, typer.Option("--json-only", "-j", help="Output clean JSON only")
-    ] = False,
-) -> None:
-    """Clean up health-check debris and stale sessions.
-
-    Default is dry-run — pass --confirm to apply changes.
-    """
-    output, error_handler, client = _get_state(ctx)
-    if json_only:
-        output.ctx.json_only = True
-    effective_dry_run = not confirm
-    try:
-        result = asyncio.run(
-            client.cleanup(
-                remove_health_debris=remove_health_debris,
-                remove_stale_sessions=remove_stale_sessions,
-                stale_days=stale_days,
-                dry_run=effective_dry_run,
-            )
-        )
-        output.output_json(result)
-        if output.ctx.show_hints and effective_dry_run:
-            output.ctx.console.print("[dim]Dry-run mode. Pass --confirm to apply changes.[/dim]")
-    except Exception as exc:
-        error_handler.handle_http_error(exc, url=client._base_url)
-
-
-@app.command("dedup")
-def dedup_cmd(
-    ctx: typer.Context,
-    threshold: Annotated[
-        float,
-        typer.Option("--threshold", "-t", help="Similarity threshold (0.0-1.0)"),
-    ] = 0.95,
-    dry_run: Annotated[
-        bool,
-        typer.Option("--dry-run", help="Detect only, do not resolve groups"),
-    ] = False,
-    confirm: Annotated[
-        bool,
-        typer.Option("--confirm", help="Resolve all detected duplicate groups"),
-    ] = False,
-    json_only: Annotated[
-        bool, typer.Option("--json-only", "-j", help="Output clean JSON only")
-    ] = False,
-    auto_resolve: Annotated[
-        bool,
-        typer.Option("--auto-resolve", help="Run auto-resolution cycle (FR-229.1)"),
-    ] = False,
-    strategy: Annotated[
-        str,
-        typer.Option("--strategy", help="Keeper strategy: keep-newest, keep-most-imported, merge-content"),
-    ] = "keep-newest",
-    max_groups: Annotated[
-        int,
-        typer.Option("--max-groups", help="Max groups to auto-resolve per cycle"),
-    ] = 10,
-    cosine_min: Annotated[
-        float,
-        typer.Option("--cosine-min", help="Minimum cosine similarity for auto-resolve"),
-    ] = 1.0,
-    restore: Annotated[
-        str | None,
-        typer.Option("--restore", help="Restore a tombstoned memory by original_memory_id"),
-    ] = None,
-) -> None:
-    """Detect (and optionally resolve) duplicate memories.
-
-    Default detects duplicates only. Pass --confirm to resolve all groups found.
-    Pass --auto-resolve for scheduled-style auto-resolution (FR-229.1).
-    Pass --restore <memory_id> to restore from tombstones (FR-229.5).
-    """
-    output, error_handler, client = _get_state(ctx)
-
-    # --restore: restore tombstoned memory (FR-229.5)
-    if restore:
-        if json_only:
-            output.ctx.json_only = True
-        try:
-            result = asyncio.run(client.restore_tombstone(original_memory_id=restore))
-            if result.get("status") == "RestoreWindowExpired":
-                output.ctx.console.print(
-                    f"[red]Restore window expired for memory {restore}[/red]"
-                )
-            else:
-                output.ctx.console.print(
-                    f"[green]Restored memory {restore}[/green]"
-                )
-            output.output_json(result)
-        except Exception as exc:
-            error_handler.handle_http_error(exc, url=client._base_url)
-        return
-
-    # --auto-resolve: run idempotent auto-resolution cycle (FR-229.1)
-    if auto_resolve:
-        if json_only:
-            output.ctx.json_only = True
-        try:
-            result = asyncio.run(
-                client.dedup_auto_resolve(
-                    max_groups=max_groups,
-                    cosine_min=cosine_min,
-                    strategy=strategy,
-                )
-            )
-            output.output_json(result)
-            if not json_only and output.ctx.show_hints:
-                output.ctx.console.print(
-                    f"[dim]Processed {result.get('groups_processed', 0)} groups, "
-                    f"tombstoned {result.get('memories_tombstoned', 0)} memories "
-                    f"(strategy: {result.get('strategy_used', 'unknown')})[/dim]"
-                )
-        except Exception as exc:
-            error_handler.handle_http_error(exc, url=client._base_url)
-        return
-
-    # Default: detect + optional confirm
-    if json_only:
-        output.ctx.json_only = True
-    try:
-        detect_result = asyncio.run(client.dedup_detect(threshold=threshold))
-        output.output_json(detect_result)
-
-        if confirm and not dry_run:
-            groups = detect_result.get("groups", [])
-            resolve_results = []
-            for group in groups:
-                group_id = group.get("group_id") or group.get("id", "")
-                if group_id:
-                    resolve_result = asyncio.run(client.dedup_resolve(group_id=group_id))
-                    resolve_results.append(resolve_result)
-            if resolve_results:
-                output.output_json({"resolved": resolve_results})
-        elif not confirm and output.ctx.show_hints:
-            groups = detect_result.get("groups", [])
-            if groups:
-                output.ctx.console.print(
-                    f"[dim]Found {len(groups)} group(s). Pass --confirm to resolve.[/dim]"
-                )
-    except Exception as exc:
-        error_handler.handle_http_error(exc, url=client._base_url)
-
-
-@app.command("embedding-status")
-def embedding_status_cmd(
-    ctx: typer.Context,
-    json_only: Annotated[
-        bool, typer.Option("--json-only", "-j", help="Output clean JSON only")
-    ] = False,
-) -> None:
-    """Show current embedding provider, model, dimension, and memory distribution."""
-    output, error_handler, client = _get_state(ctx)
-    if json_only:
-        output.ctx.json_only = True
-    try:
-        result = asyncio.run(client.embedding_status())
-        if output.ctx.json_only:
-            output.output_json(result)
-        else:
-            output.output_success("Embedding Status")
-            output._console.print(f"  Provider: {result.get('provider', '?')}")
-            output._console.print(f"  Model: {result.get('model', '?')}")
-            output._console.print(f"  Dimension: {result.get('dimension', '?')}")
-            output._console.print(
-                f"  Knowledge docs: {result.get('total_knowledge_documents', '?')}"
-            )
-            output._console.print(
-                f"  Memory fragments: {result.get('total_memory_fragments', '?')}"
-            )
-            output._console.print(f"  With embedding: {result.get('with_embedding', '?')}")
-            output._console.print(f"  Without embedding: {result.get('without_embedding', '?')}")
-    except Exception as exc:
-        error_handler.handle_http_error(exc, url=client._base_url)
-
-
-@app.command("re-embed")
-def re_embed_cmd(
-    ctx: typer.Context,
-    batch_size: Annotated[
-        int,
-        typer.Option("--batch-size", "-b", help="Memories per batch"),
-    ] = 32,
-    dry_run: Annotated[
-        bool,
-        typer.Option("--dry-run", help="Count and estimate only"),
-    ] = True,
-    confirm: Annotated[
-        bool,
-        typer.Option("--confirm", help="Execute re-embedding (overrides --dry-run)"),
-    ] = False,
-) -> None:
-    """Trigger batch re-embedding of all memories with current provider.
-
-    Default is dry-run — pass --confirm to apply.
-    Requires server-side /api/v1/embedding/re-embed endpoint.
-    For direct migration, use: docker exec vds-ai-memory-api-1 python3 /app/scripts/migrate_embeddings.py --apply
-    """
-    output, error_handler, client = _get_state(ctx)
-    effective_dry_run = not confirm
-    try:
-        result = asyncio.run(client.re_embed(batch_size=batch_size, dry_run=effective_dry_run))
-        output.output_json(result)
-        if output.ctx.show_hints and effective_dry_run:
-            output.ctx.console.print("[dim]Dry-run mode. Pass --confirm to apply.[/dim]")
-    except Exception as exc:
-        error_handler.handle_http_error(exc, url=client._base_url)
-
-
-@app.command("promotion-status")
-def promotion_status_cmd(
-    ctx: typer.Context,
-    json_only: Annotated[
-        bool, typer.Option("--json-only", "-j", help="Output clean JSON only")
-    ] = False,
-) -> None:
-    """Show memory counts grouped by mem0_status (promotion queue snapshot).
-
-    Displays a Rich table with pending/synced/stalled/local-only counts
-    or outputs clean JSON with --json-only.
-    """
-    output, error_handler, client = _get_state(ctx)
-    if json_only:
-        output.ctx.json_only = True
-    try:
-        result = asyncio.run(client.promotion_status())
-        if output.ctx.json_only:
-            output.output_json(result)
-        else:
-            counts: dict = result.get("counts", {})
-            total: int = result.get("total", 0)
-            queried_at: str = result.get("queried_at", "")
-            output.output_success("Promotion Queue Status")
-            output._console.print(f"  Total memories: {total}")
-            if queried_at:
-                output._console.print(f"  As of: {queried_at}")
-            output._console.print("")
-            output._console.print("  [bold]Status[/bold]          [bold]Count[/bold]")
-            output._console.print("  " + "-" * 30)
-            for status_key in ("local-only", "pending", "stalled", "synced", "skipped"):
-                count = counts.get(status_key, 0)
-                if status_key == "local-only":
-                    color = "yellow" if count > 0 else "dim"
-                elif status_key == "stalled":
-                    color = "red" if count > 0 else "dim"
-                elif status_key == "synced":
-                    color = "green"
-                else:
-                    color = "cyan" if count > 0 else "dim"
-                output._console.print(f"  [{color}]{status_key:<16}[/{color}] {count}")
-            # Show any unexpected statuses (e.g. 'unknown')
-            for status_key, count in sorted(counts.items()):
-                if status_key not in ("local-only", "pending", "stalled", "synced", "skipped"):
-                    output._console.print(f"  [dim]{status_key:<16}[/dim] {count}")
-    except Exception as exc:
-        error_handler.handle_http_error(exc, url=client._base_url)
-
-
-@app.command("repush")
-def repush_cmd(
-    ctx: typer.Context,
-    status: Annotated[
-        str,
-        typer.Option("--status", "-s", help="mem0_status bucket to repush (e.g. local-only)"),
-    ] = "local-only",
-    limit: Annotated[int, typer.Option("--limit", "-n", help="Max rows to repush per run")] = 100,
-    dry_run: Annotated[
-        bool, typer.Option("--dry-run", help="Count candidates without making changes")
-    ] = False,
-    json_only: Annotated[
-        bool, typer.Option("--json-only", "-j", help="Output clean JSON only")
-    ] = False,
-) -> None:
-    """Repush memories stuck in a given mem0_status bucket to the mem0 adapter.
-
-    Marks each row as pending and queues mem0.push_memory via Celery.
-    Use --dry-run to preview the candidate count without making changes.
-
-    Example:
-      vds-cli memory repush --status local-only --limit 50
-      vds-cli memory repush --status local-only --dry-run
-    """
-    output, error_handler, client = _get_state(ctx)
-    if json_only:
-        output.ctx.json_only = True
-    try:
-        result = asyncio.run(client.repush(status=status, limit=limit, dry_run=dry_run))
-        if output.ctx.json_only:
-            output.output_json(result)
-        else:
-            queued = result.get("queued", 0)
-            candidates = result.get("candidates", 0)
-            errors = result.get("errors", 0)
-            if dry_run:
-                output.output_success(f"Dry-run: {candidates} candidate(s) with status={status!r}")
-                output._console.print("[dim]Pass without --dry-run to queue repush tasks.[/dim]")
-            else:
-                output.output_success(f"Repush queued: {queued}/{candidates} (errors: {errors})")
-                if errors:
-                    output._console.print(f"  [red]{errors} row(s) failed to queue[/red]")
-    except Exception as exc:
-        error_handler.handle_http_error(exc, url=client._base_url)
-
-
-@app.command("analytics-stream")
-def analytics_stream_cmd(
-    ctx: typer.Context,
-    interval: Annotated[
-        float,
-        typer.Option(
-            "--interval",
-            "-i",
-            min=0.1,
-            max=60.0,
-            help="Server-side metric refresh interval (seconds)",
-        ),
-    ] = 2.0,
-    token: Annotated[
-        str | None,
-        typer.Option(
-            "--token",
-            envvar="VDS_MEMORY_JWT",
-            help="JWT for WS auth (acquired via /auth/login if omitted)",
-        ),
-    ] = None,
-    login_user: Annotated[
-        str,
-        typer.Option(
-            "--login-user",
-            envvar="VDS_MEMORY_LOGIN_USER",
-            help="Username for auto-login when --token is omitted",
-        ),
-    ] = "claude-agent",
-    login_pass: Annotated[
-        str,
-        typer.Option(
-            "--login-pass",
-            envvar="VDS_MEMORY_LOGIN_PASS",
-            help="Password for auto-login when --token is omitted",
-        ),
-    ] = "vds-cli",
-    json_lines: Annotated[
-        bool,
-        typer.Option(
-            "--json", "--jsonl", help="Emit one JSON envelope per line; suppress Rich dashboard"
-        ),
-    ] = False,
-    no_reconnect: Annotated[
-        bool,
-        typer.Option(
-            "--no-reconnect", help="Exit on first disconnect instead of auto-reconnecting"
-        ),
-    ] = False,
-    max_retries: Annotated[
-        int,
-        typer.Option(
-            "--max-retries", min=0, max=100, help="Cap on auto-reconnect attempts (0 = unlimited)"
-        ),
-    ] = 10,
-    duration: Annotated[
-        float | None,
-        typer.Option(
-            "--duration",
-            "-d",
-            min=0,
-            help="Auto-exit after N seconds (0 / None = run until Ctrl-C)",
-        ),
-    ] = None,
-) -> None:
-    """Stream real-time analytics metrics from the WebSocket endpoint (VAMI-030).
-
-    Replaces the raw `python -m websockets ws://...?token=<jwt>` recipe.
-    Same per-tick payload as the WS endpoint (metrics + timestamp), rendered
-    as a live Rich table by default or JSON-Lines via --json.
-
-    JWT acquisition order (per ADR-50):
-      1. --token <jwt> explicit option (highest priority)
-      2. VDS_MEMORY_JWT env var
-      3. Auto-login: POST {--login-user, --login-pass} to /api/v1/auth/login.
-
-    Auto-reconnects on transient errors (per ADR-51); auth failures
-    (close-1008) are terminal and surface as exit-1 with operator hint.
-    Output mode (per ADR-52): Rich Live for tty, JSON-Lines for non-tty
-    (auto-switch via sys.stdout.isatty() unless --json forces JSON-Lines).
-    """
-    output, error_handler, client = _get_state(ctx)
-    use_jsonl = json_lines or not sys.stdout.isatty()
-
-    try:
-        asyncio.run(
-            _run_analytics_stream(
-                client=client,
-                output=output,
-                token=token,
-                login_user=login_user,
-                login_pass=login_pass,
-                interval=interval,
-                use_jsonl=use_jsonl,
-                no_reconnect=no_reconnect,
-                max_retries=max_retries,
-                duration=duration,
-            )
-        )
-    except KeyboardInterrupt:
-        # Ctrl-C → clean exit (per FR-30.5). Rich Live cleared via transient=True.
-        raise typer.Exit(code=0) from None
-    except ConnectionClosedError as exc:
-        # Auth failures (1008) are terminal per ADR-51. Surface to operator.
-        # Use .rcvd.{code,reason} per websockets v13.1+ API (avoid deprecated .code).
-        rcvd = getattr(exc, "rcvd", None)
-        code = getattr(rcvd, "code", None)
-        reason = getattr(rcvd, "reason", "")
-        if code == 1008:
-            output.output_error(
-                f"Authentication failed (close-1008): {reason or 'Authentication required'}",
-                hint="Pass --token <jwt> or VDS_MEMORY_JWT env, "
-                "or use --login-user/--login-pass for auto-login (ADR-50).",
-            )
-        else:
-            output.output_error(f"WebSocket closed unexpectedly: code={code} reason={reason!r}")
-        raise typer.Exit(code=1) from exc
-    except (ConnectionRefusedError, OSError) as exc:
-        output.output_error(
-            f"Cannot reach API at {client._base_url}: {exc}",
-            hint="Check VDS_MEMORY_API_URL or service health: vds-cli memory health.",
-        )
-        raise typer.Exit(code=2) from exc
-    except Exception as exc:
-        error_handler.handle_http_error(exc, url=client._base_url)
-
-
-async def _run_analytics_stream(
-    *,
-    client,
-    output,
-    token: str | None,
-    login_user: str,
-    login_pass: str,
-    interval: float,
-    use_jsonl: bool,
-    no_reconnect: bool,
-    max_retries: int,
-    duration: float | None,
-) -> None:
-    """Inner async impl for analytics_stream_cmd. Resolves JWT then streams."""
-    # FR-220.M.4: machine context safety check — must precede any JWT
-    # acquisition attempt so operators get a clear hint before hitting
-    # /auth/login (which returns 501 in production anyway).
-    if _is_machine_context() and not (
-        os.environ.get("VDS_MEMORY_CLIENT_SERVICE_TOKEN")
-        or os.environ.get("VDS_SCHEDULER_SERVICE_TOKEN")
-    ):
-        print(
-            "Error: machine context detected (CI / VDS_CLIENT_KIND=service / non-interactive shell)\n"
-            "but no service token is set.\n"
-            "\n"
-            "Mint a service-account JWT and set VDS_MEMORY_CLIENT_SERVICE_TOKEN:\n"
-            "  python -m vds_memory_orchestrator.scripts.mint_memory_client_service_token \\\n"
-            "    --sub svc:claude-agent --scopes memory:read,memory:write \\\n"
-            "    --output-format env-var > /tmp/svc_token.sh\n"
-            "  source /tmp/svc_token.sh\n"
-            "  vds-cli memory analytics-stream ...",
-            file=sys.stderr,
-        )
-        sys.exit(2)
-
-    # JWT acquisition order per ADR-50
-    if not token:
-        # Phase 219 FR-219.6 (ADR-80): warn when dev-only defaults are used
-        # in production-mode. The /auth/login endpoint will return 501 in prod
-        # regardless; this warning gives operators an actionable hint before
-        # they hit the wire.
-        if os.getenv("ENVIRONMENT", "development").lower() == "production":
-            warning_msg = (
-                f"WARNING: Using DEV-MODE-ONLY login defaults (user={login_user}) "
-                f"against an ENVIRONMENT=production endpoint. /auth/login will "
-                f"return 501 (Phase 219 ADR-80). Provide --token or VDS_MEMORY_JWT instead."
-            )
-            if use_jsonl:
-                print(json.dumps({"warning": warning_msg}), file=sys.stderr)
-            else:
-                output._console.print(f"[yellow]{warning_msg}[/yellow]")
-        token = await client.acquire_jwt_token(username=login_user, password=login_pass)
-        if not use_jsonl:
-            output._console.print(f"[dim]✓ Acquired JWT via /auth/login as user={login_user}[/dim]")
-
-    started = time.monotonic()
-    count = 0
-    deadline = (started + duration) if duration else None
-
-    stream = client.stream_real_time_metrics(
-        token=token,
-        interval=interval,
-        auto_reconnect=not no_reconnect,
-        max_retries=max_retries,
-    )
-
-    if use_jsonl:
-        async for envelope in stream:
-            print(json.dumps(envelope), flush=True)
-            count += 1
-            if deadline and time.monotonic() >= deadline:
-                break
-    else:
-        table = _build_metrics_table(None)
-        with Live(table, refresh_per_second=10, transient=True, console=output._console) as live:
-            async for envelope in stream:
-                live.update(_build_metrics_table(envelope))
-                count += 1
-                if deadline and time.monotonic() >= deadline:
-                    break
-
-    elapsed = time.monotonic() - started
-    if not use_jsonl:
-        output._console.print(f"[green]✓[/green] Streamed {count} envelope(s) in {elapsed:.1f}s")
-
-
-def _build_metrics_table(envelope: dict | None) -> Table:
-    """Render a 2-column Rich table for the RealTimeMetrics envelope.
-
-    cache_performance dict is flattened into one row per cache key.
-    Returns an empty placeholder when envelope is None (initial state).
-    """
-    table = Table(title="VDS AI Memory — Real-Time Metrics", show_lines=False)
-    table.add_column("Metric", style="cyan", no_wrap=True)
-    table.add_column("Value", style="bold green")
-
-    if envelope is None:
-        table.add_row("[dim]waiting for first tick…[/dim]", "")
-        return table
-
-    metrics = envelope.get("metrics", {})
-    timestamp = envelope.get("timestamp", "")
-
-    for key in (
-        "active_users",
-        "concurrent_searches",
-        "memory_creation_rate",
-        "search_rate",
-        "avg_response_time",
-        "error_rate",
-        "system_load",
-        "database_connections",
-        "queue_depth",
-    ):
-        if key in metrics:
-            value = metrics[key]
-            formatted = f"{value:.3f}" if isinstance(value, float) else str(value)
-            table.add_row(key.replace("_", " "), formatted)
-
-    cache_perf = metrics.get("cache_performance", {})
-    if isinstance(cache_perf, dict):
-        for cache_key, cache_value in cache_perf.items():
-            table.add_row(
-                f"  cache_performance.{cache_key}",
-                f"{cache_value:.3f}" if isinstance(cache_value, float) else str(cache_value),
-            )
-
-    table.add_row("[dim]timestamp[/dim]", f"[dim]{timestamp}[/dim]")
-    return table
-
-
-@app.command("entity-backfill")
-def entity_backfill_cmd(
-    ctx: typer.Context,
-    dry_run: Annotated[
-        bool,
-        typer.Option(
-            "--dry-run", help="Preview candidate count without writing (default behaviour)"
-        ),
-    ] = True,
-    confirm: Annotated[
-        bool,
-        typer.Option(
-            "--confirm",
-            help="Actually perform writes. Required to move beyond dry-run mode.",
-        ),
-    ] = False,
-    limit: Annotated[
-        int,
-        typer.Option("--limit", "-n", help="Max memories to process per run"),
-    ] = 50,
-    user_id: Annotated[
-        str | None,
-        typer.Option("--user-id", help="Restrict backfill to a single user's memories"),
-    ] = None,
-) -> None:
-    """Backfill missing entity records into the mem0 qdrant entities collection.
-
-    Finds memories that carry ``metadata.entities`` arrays (extracted by mem0
-    during ingestion) but whose entity data is absent from the qdrant entities
-    collection, then upserts the missing points.
-
-    Runs as a **dry-run by default** — pass ``--confirm`` to write.
-
-    Examples::
-
-      vds-memory entity-backfill                       # dry-run, limit=50
-      vds-memory entity-backfill --confirm             # write, limit=50
-      vds-memory entity-backfill --confirm --limit 200 --user-id agent-001
-    """
-    # Phase 201 ADR-65: HTTP-routed via MemoryClient (was direct service import)
-    output, error_handler, client = _get_state(ctx)
-
-    # --confirm overrides --dry-run; safety gate prevents accidental writes.
-    effective_dry_run = not confirm
-
-    try:
-        result = asyncio.run(
-            client.entity_backfill(
-                dry_run=effective_dry_run,
-                limit=limit,
-                user_id=user_id,
-            )
-        )
-        output.output_json(result)
-    except Exception as exc:
-        error_handler.handle_http_error(exc, url=client._base_url)
-
-
-@app.command("triage")
-def triage_cmd(
-    ctx: typer.Context,
-    status: Annotated[
-        str,
-        typer.Option(
-            "--status",
-            "-s",
-            help="mem0_status bucket to inspect: stalled / pending / local-only",
-        ),
-    ],
-    limit: Annotated[
-        int,
-        typer.Option("--limit", "-n", help="Max items to list (read-only mode)"),
-    ] = 50,
-    json_only: Annotated[
-        bool, typer.Option("--json-only", "-j", help="Output clean JSON only")
-    ] = False,
-    max_age_days: Annotated[
-        int | None,
-        typer.Option(
-            "--max-age-days",
-            help="Only show/delete records older than N days",
-        ),
-    ] = None,
-    confirm_delete: Annotated[
-        bool,
-        typer.Option(
-            "--confirm-delete",
-            help="Enable delete mode (requires --max-age-days AND --yes)",
-        ),
-    ] = False,
-    yes: Annotated[
-        bool,
-        typer.Option("--yes", "-y", help="Confirm destructive operation"),
-    ] = False,
-) -> None:
-    """Inspect (and optionally delete) memories by mem0_status bucket.
-
-    Read-only by default — lists matching rows with age, retry count, and
-    last-error metadata so operators can decide what to clean up.
-
-    Deletion requires ALL THREE of --confirm-delete + --max-age-days + --yes
-    (Phase 200 ADR-62 compound-flag safety gate).
-
-    Examples:
-
-      vds-cli memory triage --status stalled
-      vds-cli memory triage --status stalled --max-age-days 30
-      vds-cli memory triage --status stalled --max-age-days 30 --confirm-delete --yes
-    """
-    # Compound-flag validator (CRITICAL — FR-200.4 + ADR-62)
-    if confirm_delete and (max_age_days is None or not yes):
-        raise typer.BadParameter(
-            "--confirm-delete requires BOTH --max-age-days and --yes (Phase 200 ADR-62 safety gate)"
-        )
-
-    # Phase 201 ADR-65: HTTP-routed via MemoryClient (was direct service import)
-    output, error_handler, client = _get_state(ctx)
-    if json_only:
-        output.ctx.json_only = True
-
-    try:
-        result = asyncio.run(
-            client.triage(
-                status=status,
-                limit=limit,
-                max_age_days=max_age_days,
-                confirm_delete=confirm_delete,
-                yes=yes,
-            )
-        )
-        if output.ctx.json_only:
-            output.output_json(result)
-            return
-
-        if confirm_delete:
-            deleted = result.get("deleted", 0)
-            requested = result.get("requested_count", 0)
-            errors = result.get("errors", [])
-            color = "green" if not errors else "yellow"
-            output.output_success(
-                f"Triage delete: [{color}]{deleted}/{requested}[/{color}] deleted "
-                f"(status={status!r}, max_age_days={max_age_days})"
-            )
-            if errors:
-                output._console.print(f"  [red]{len(errors)} error(s)[/red]")
-        else:
-            total_matching = result.get("total_matching", 0)
-            items = result.get("items", [])
-            output.output_success(f"Triage: {total_matching} item(s) with status={status!r}")
-            if items:
-                output._console.print("")
-                output._console.print(
-                    "  [bold]Memory ID                [/bold]"
-                    "[bold]  Age[/bold]  [bold]Retries[/bold]  "
-                    "[bold]Last Error[/bold]"
-                )
-                output._console.print("  " + "-" * 70)
-                for item in items:
-                    error_str = (item.get("last_error") or "—")[:32]
-                    output._console.print(
-                        f"  {item.get('memory_id', '')[:24]:<24}  "
-                        f"{item.get('age_days', 0):>4}d  "
-                        f"{item.get('retry_count', 0):>7}  "
-                        f"{error_str}"
-                    )
-    except Exception as exc:
-        error_handler.handle_http_error(exc, url=client._base_url)
-
-
-@app.command("drain-evolution")
-def drain_evolution_cmd(
-    ctx: typer.Context,
-    max_passes: Annotated[
-        int,
-        typer.Option("--max-passes", help="Max processor passes (stops early at 0 processed)"),
-    ] = 10,
-    batch_size: Annotated[
-        int,
-        typer.Option("--batch-size", "-n", help="Rows per pass (1-200)"),
-    ] = 25,
-    json_only: Annotated[
-        bool, typer.Option("--json-only", "-j", help="Output clean JSON only")
-    ] = False,
-) -> None:
-    """Drain pending memory_evolution_events to clear lag SLO (Phase 207 ADR-70).
-
-    HTTP-routes to MemoryEvolutionProcessor.run() so operators don't need
-    docker-exec when scheduler_orchestrator is off (the default per kill-switch).
-    Runs up to --max-passes batches; stops early when a pass returns 0 processed.
-
-    Examples:
-      vds-cli memory drain-evolution
-      vds-cli memory drain-evolution --max-passes 20 --batch-size 50
-    """
-    output, error_handler, client = _get_state(ctx)
-    if json_only:
-        output.ctx.json_only = True
-    try:
-        result = asyncio.run(client.drain_evolution(max_passes=max_passes, batch_size=batch_size))
-        if output.ctx.json_only:
-            output.output_json(result)
-        else:
-            total = result.get("total_processed", 0)
-            passes = result.get("passes_run", 0)
-            output.output_success(f"Drained {total} evolution event(s) across {passes} pass(es)")
-            for p in result.get("passes", []):
-                output._console.print(
-                    f"  pass {p.get('pass'):>2}: status={p.get('status'):<12} processed={p.get('processed')}"
-                )
-    except Exception as exc:
-        error_handler.handle_http_error(exc, url=client._base_url)
-
-
-@app.command("evolution-status")
-def evolution_status_cmd(
-    ctx: typer.Context,
-    json_only: Annotated[
-        bool, typer.Option("--json-only", "-j", help="Output clean JSON only")
-    ] = False,
-) -> None:
-    """Show memory evolution state per org — disabled/shadow/pilot/all (Phase 232 FR-232.3).
-
-    Displays: status, wildcard_active, shadow_mode, per-org event/consolidation counts,
-    queue depths, DLQ size, pending lag, rate-limit budget.
-
-    Examples:
-      vds-cli memory evolution-status
-      vds-cli memory evolution-status --json-only
-    """
-    output, error_handler, client = _get_state(ctx)
-    if json_only:
-        output.ctx.json_only = True
-    try:
-        result = asyncio.run(client.evolution_status())
-        if output.ctx.json_only:
-            output.output_json(result)
-        else:
-            _print_evolution_status(output, result)
-    except Exception as exc:
-        error_handler.handle_http_error(exc, url=client._base_url)
-
-
-def _print_evolution_status(output, result: dict) -> None:
-    """Render evolution status as a rich table."""
-    from rich.table import Table
-
-    status = result.get("status", "unknown")
-    wildcard = result.get("wildcard_active", False)
-    shadow = result.get("shadow_mode", True)
-    rate_limit = result.get("rate_limit_budget", {})
-    budget = rate_limit.get("max_consolidations_per_session", "?")
-
-    output.ctx.console.print(f"[bold]Memory Evolution Status[/bold]  ({status})")
-    if wildcard:
-        output.ctx.console.print("  [cyan]wildcard_active[/cyan]: true (all orgs enrolled)")
-    output.ctx.console.print(f"  shadow_mode: {shadow}")
-    output.ctx.console.print(f"  rate_limit_budget: {budget}/session")
-
-    org_stats = result.get("org_statistics", [])
-    if org_stats:
-        table = Table(title="Per-Org Statistics", show_header=True, header_style="bold")
-        table.add_column("Org")
-        table.add_column("Status")
-        table.add_column("Total Events")
-        table.add_column("Recent Events")
-        table.add_column("Blocked")
-        for org in org_stats:
-            flag = "[green]PILOT[/green]" if org.get("pilot") else "[dim]non-pilot[/dim]"
-            table.add_row(
-                org.get("org_id", "?"),
-                flag,
-                str(org.get("total_events", 0)),
-                str(org.get("recent_events", 0)),
-                str(org.get("blocked_events", 0)),
-            )
-        output.ctx.console.print(table)
-    else:
-        output.ctx.console.print("  [dim]No org statistics available[/dim]")
-
-    actions = result.get("actions", {})
-    if actions:
-        output.ctx.console.print(
-            f"  Consolidations: total={actions.get('total', 0)}, "
-            f"recent={actions.get('recent', 0)}, conflicts={actions.get('conflicts', 0)}"
-        )
-
-    queues = result.get("queues", {})
-    if queues:
-        for qname, qdata in queues.items():
-            depth = qdata.get("depth", "?")
-            output.ctx.console.print(f"  Queue [{qname}]: depth={depth}")
-
-    soak = result.get("soak")
-    if soak:
-        output.ctx.console.print("")
-        output.ctx.console.print("[bold]Shadow Soak[/bold]")
-        output.ctx.console.print(f"  status: {soak.get('soak_status', '?')}")
-        started = soak.get("soak_started_at", "?")
-        output.ctx.console.print(f"  started_at: {started}")
-        days_e = soak.get("days_elapsed", "?")
-        days_r = soak.get("days_remaining", "?")
-        dur = soak.get("soak_duration_days", "?")
-        output.ctx.console.print(f"  progress: {days_e}/{dur} days (ready={soak.get('ready_for_promotion', False)}, {days_r} remaining)")
-        anomalies = soak.get("anomaly_count", 0)
-        if anomalies:
-            output.ctx.console.print(f"  [yellow]anomalies: {anomalies}[/yellow]")
-        promoted = soak.get("promoted_at")
-        if promoted:
-            output.ctx.console.print(f"  promoted_at: {promoted}")
-
-    warnings = result.get("warnings", [])
-    if warnings:
-        for w in warnings:
-            output.ctx.console.print(f"  [yellow]! {w}[/yellow]")
-
-
-@app.command("create-user")
-def create_user_cmd(
-    username: Annotated[str, typer.Argument(help="Unique username for the new account")],
-    email: Annotated[str, typer.Argument(help="Email address")],
-    full_name: Annotated[str, typer.Argument(help="Display name")],
-    password_stdin: Annotated[
-        bool,
-        typer.Option(
-            "--password-stdin",
-            help=(
-                "Read password from stdin (REQUIRED for security). "
-                "Example: echo 'mypassword' | vds-cli memory create-user alice alice@x.com Alice --password-stdin"
-            ),
-        ),
-    ] = False,
-) -> None:
-    """Create a new human user account in the VDS AI Memory service.
-
-    Password MUST be supplied via --password-stdin (never via argv) to prevent
-    the password from appearing in shell history or process listings.
-
-    Example::
-
-      echo 'mysecurepassword' | vds-cli memory create-user alice alice@x.com "Alice Smith" --password-stdin
-    """
-    # FR-220.S.11: reject if --password-stdin is False
-    if not password_stdin:
-        typer.echo(
-            "Password must be provided via --password-stdin for security reasons. "
-            "Pipe via: `echo 'pw' | vds-cli memory create-user ... --password-stdin`.",
-            err=True,
-        )
-        raise typer.Exit(2)
-
-    password = sys.stdin.read().strip()
-
-    # FR-220.S.11: minimum 12 characters
-    if len(password) < 12:
-        typer.echo("Password must be at least 12 characters.", err=True)
-        raise typer.Exit(2)
-
-    # Dev/prod repository routing — mirrors dependencies.py logic for CLI context
-    _env = os.getenv("ENVIRONMENT", "development").lower()
-    _dev_envs = frozenset({"development", "dev", "local"})
-
-    if _env in _dev_envs:
-        from vds_memory_orchestrator.service.repositories.dev_mode_user_repository import (
-            DevModeUserRepository,
-        )
-
-        repo = DevModeUserRepository()
-    else:
-        from vds_memory_orchestrator.service.database.postgres_manager import (
-            database_service,
-        )
-        from vds_memory_orchestrator.service.repositories.postgres_user_repository import (
-            PostgresUserRepository,
-        )
-
-        repo = PostgresUserRepository(session_factory=database_service.get_session)  # type: ignore[assignment]
-
-    use_case = CreateUserUseCase(repo)
-
-    try:
-        user = asyncio.run(
-            use_case.execute(
-                username=username,
-                email=email,
-                password=password,
-                full_name=full_name,
-            )
-        )
-        typer.echo(f"Created user: {user.username} ({user.id})")
-    except WeakPassword as exc:
-        typer.echo(str(exc), err=True)
-        raise typer.Exit(2) from exc
-    except OperationNotPermittedInDevMode as exc:
-        typer.echo(str(exc), err=True)
-        raise typer.Exit(1) from exc
-    except Exception:
-        import traceback
-
-        traceback.print_exc()
-        raise typer.Exit(1) from None
-
-
-def main() -> None:
-    """Entrypoint wrapper."""
-    app()
-
-
-if __name__ == "__main__":
-    main()