@aws/ml-container-creator 1.0.3 → 1.1.0

package/templates/do/.train_helper.py

@@ -0,0 +1,433 @@
+#!/usr/bin/env python3
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""SageMaker Training Job helper (SDK v3).
+
+Subcommands:
+    submit  - Create a training job via TrainingJob.create()
+    status  - Get job status via TrainingJob.get()
+    resolve - Extract artifact path from completed job
+    stop    - Stop a running training job
+
+All output is JSON on stdout for bash consumption.
+Pattern: grep -E '^\\{' | tail -1 to extract JSON from mixed output.
+"""
+
+import argparse
+import json
+import os
+import sys
+import warnings
+
+# Suppress noisy dependency warnings
+warnings.filterwarnings("ignore", category=DeprecationWarning)
+warnings.filterwarnings("ignore", message=".*urllib3.*")
+
+# Suppress ALL logging to prevent sagemaker-core/rich from writing to stdout
+import logging as _logging
+_logging.disable(_logging.CRITICAL)
+os.environ.setdefault("SAGEMAKER_LOG_LEVEL", "CRITICAL")
+
+
+# ── Utility functions ─────────────────────────────────────────────────────────
+
+def _error_exit(message):
+    """Print JSON error to stdout and exit with code 1."""
+    print(json.dumps({"error": True, "message": message}))
+    sys.exit(1)
+
+
+def _output(data):
+    """Print JSON result to stdout."""
+    print(json.dumps(data))
+    sys.exit(0)
+
+
+def _sanitize_for_json(value):
+    """Convert sagemaker-core Unassigned sentinel values to None."""
+    if value is None:
+        return None
+    type_name = type(value).__name__
+    if type_name in ("Unassigned", "UnassignedValue"):
+        return None
+    return value
+
+
+# ── cmd_submit ────────────────────────────────────────────────────────────────
+
+def cmd_submit(args):
+    """Create a SageMaker Training Job via SDK v3.
+
+    Reads job configuration from a JSON file (same format as the old
+    CreateTrainingJob CLI input), then submits via TrainingJob.create().
+
+    Returns: {"job_name": str, "job_arn": str, "status": "InProgress"}
+    """
+    # Set region BEFORE any sagemaker import (Bug 26 pattern)
+    region = getattr(args, 'region', None) or os.environ.get('AWS_DEFAULT_REGION') or os.environ.get('AWS_REGION')
+    if region:
+        os.environ['AWS_DEFAULT_REGION'] = region
+        os.environ.setdefault('AWS_REGION', region)
+
+    # Read config file
+    try:
+        with open(args.config, 'r') as f:
+            config = json.load(f)
+    except (IOError, json.JSONDecodeError) as e:
+        _error_exit(f"Failed to read config file: {e}")
+
+    # Import SDK v3 TrainingJob (same pattern as .tune_helper.py cmd_status)
+    try:
+        from sagemaker.core.resources import TrainingJob
+    except ImportError:
+        _error_exit(
+            "sagemaker SDK v3 not installed. "
+            "Install: pip install 'sagemaker>=3.0'"
+        )
+
+    # Extract fields from the CreateTrainingJob-format config
+    job_name = config.get('TrainingJobName', '')
+    role_arn = config.get('RoleArn', '')
+    algo_spec = config.get('AlgorithmSpecification', {})
+    resource_config = config.get('ResourceConfig', {})
+    input_data_config = config.get('InputDataConfig', [])
+    output_data_config = config.get('OutputDataConfig', {})
+    stopping_condition = config.get('StoppingCondition', {})
+    hyper_parameters = config.get('HyperParameters', {})
+    checkpoint_config = config.get('CheckpointConfig')
+    environment = config.get('Environment', {})
+    enable_spot = config.get('EnableManagedSpotTraining', False)
+    tags = config.get('Tags', [])
+
+    # Build SDK v3 create kwargs (snake_case per Pydantic v2)
+    create_kwargs = {
+        'training_job_name': job_name,
+        'role_arn': role_arn,
+        'algorithm_specification': {
+            'training_image': algo_spec.get('TrainingImage', ''),
+            'training_input_mode': algo_spec.get('TrainingInputMode', 'File'),
+        },
+        'resource_config': {
+            'instance_type': resource_config.get('InstanceType', 'ml.g5.xlarge'),
+            'instance_count': resource_config.get('InstanceCount', 1),
+            'volume_size_in_gb': resource_config.get('VolumeSizeInGB', 50),
+        },
+        'output_data_config': {
+            's3_output_path': output_data_config.get('S3OutputPath', ''),
+        },
+        'stopping_condition': {
+            'max_runtime_in_seconds': stopping_condition.get('MaxRuntimeInSeconds', 86400),
+        },
+    }
+
+    # Input data channels
+    if input_data_config:
+        channels = []
+        for channel in input_data_config:
+            ch = {
+                'channel_name': channel.get('ChannelName', 'training'),
+                'data_source': {
+                    's3_data_source': {
+                        's3_data_type': channel.get('DataSource', {}).get('S3DataSource', {}).get('S3DataType', 'S3Prefix'),
+                        's3_uri': channel.get('DataSource', {}).get('S3DataSource', {}).get('S3Uri', ''),
+                        's3_data_distribution_type': channel.get('DataSource', {}).get('S3DataSource', {}).get('S3DataDistributionType', 'FullyReplicated'),
+                    }
+                }
+            }
+            channels.append(ch)
+        create_kwargs['input_data_config'] = channels
+
+    # Hyperparameters (all values must be strings)
+    if hyper_parameters:
+        create_kwargs['hyper_parameters'] = {
+            str(k): str(v) for k, v in hyper_parameters.items()
+        }
+
+    # Metric definitions
+    metric_defs = algo_spec.get('MetricDefinitions', [])
+    if metric_defs:
+        create_kwargs['algorithm_specification']['metric_definitions'] = [
+            {'name': m.get('Name', ''), 'regex': m.get('Regex', '')}
+            for m in metric_defs
+        ]
+
+    # Managed spot training
+    if enable_spot:
+        create_kwargs['enable_managed_spot_training'] = True
+        max_wait = stopping_condition.get('MaxWaitTimeInSeconds')
+        if max_wait:
+            create_kwargs['stopping_condition']['max_wait_time_in_seconds'] = max_wait
+
+    # Checkpoint config
+    if checkpoint_config:
+        create_kwargs['checkpoint_config'] = {
+            's3_uri': checkpoint_config.get('S3Uri', ''),
+        }
+
+    # Environment
+    if environment:
+        create_kwargs['environment'] = environment
+
+    # Tags
+    if tags:
+        create_kwargs['tags'] = [
+            {'key': t.get('Key', ''), 'value': t.get('Value', '')}
+            for t in tags
+        ]
+
+    # Submit the job
+    try:
+        job = TrainingJob.create(**create_kwargs)
+        job_arn = getattr(job, 'training_job_arn', '') or ''
+        _output({
+            "job_name": job_name,
+            "job_arn": _sanitize_for_json(job_arn) or job_name,
+            "status": "InProgress"
+        })
+    except Exception as e:
+        error_msg = str(e)
+        if "AccessDenied" in error_msg or "AccessDeniedException" in error_msg:
+            _error_exit(
+                f"Access denied when submitting training job. "
+                f"Ensure the role has sagemaker:CreateTrainingJob permission. "
+                f"Details: {error_msg}"
+            )
+        else:
+            _error_exit(f"Failed to create training job: {error_msg}")
+
+
+# ── cmd_status ────────────────────────────────────────────────────────────────
+
+def cmd_status(args):
+    """Query job status via TrainingJob.get().
+
+    Returns: {"status": str, "secondary_status": str, "failure_reason": str|null,
+              "elapsed_seconds": int|null, "metrics": dict|null,
+              "display": str, "model_artifacts": str|null}
+    """
+    region = getattr(args, 'region', None) or os.environ.get('AWS_DEFAULT_REGION') or os.environ.get('AWS_REGION')
+    if region:
+        os.environ['AWS_DEFAULT_REGION'] = region
+        os.environ.setdefault('AWS_REGION', region)
+
+    try:
+        from sagemaker.core.resources import TrainingJob
+    except ImportError:
+        _error_exit("sagemaker SDK v3 not installed.")
+
+    # Get job
+    try:
+        job = TrainingJob.get(training_job_name=args.job_name)
+    except Exception as e:
+        _error_exit(f"Failed to describe training job '{args.job_name}': {e}")
+
+    status = _sanitize_for_json(getattr(job, 'training_job_status', 'Unknown')) or 'Unknown'
+    secondary = _sanitize_for_json(getattr(job, 'secondary_status', '')) or ''
+    failure_reason = _sanitize_for_json(getattr(job, 'failure_reason', None))
+
+    # Elapsed time
+    elapsed_seconds = None
+    start_time = _sanitize_for_json(getattr(job, 'training_start_time', None))
+    end_time = _sanitize_for_json(getattr(job, 'training_end_time', None))
+    if start_time:
+        from datetime import datetime, timezone
+        try:
+            if end_time:
+                elapsed_seconds = int((end_time - start_time).total_seconds())
+            else:
+                now = datetime.now(timezone.utc)
+                elapsed_seconds = int((now - start_time).total_seconds())
+        except (TypeError, AttributeError):
+            pass
+
+    # Metrics
+    metrics = None
+    final_metrics = _sanitize_for_json(getattr(job, 'final_metric_data_list', None))
+    if final_metrics:
+        try:
+            metrics = {
+                m.metric_name: m.value
+                for m in final_metrics
+                if hasattr(m, 'metric_name') and hasattr(m, 'value')
+            }
+        except (TypeError, AttributeError):
+            pass
+
+    # Model artifacts
+    model_artifacts = None
+    artifacts_obj = _sanitize_for_json(getattr(job, 'model_artifacts', None))
+    if artifacts_obj:
+        model_artifacts = _sanitize_for_json(getattr(artifacts_obj, 's3_model_artifacts', None))
+
+    # Build display line
+    emoji_map = {'InProgress': '🔄', 'Completed': '✅', 'Failed': '❌', 'Stopped': '⏹️'}
+    emoji = emoji_map.get(status, '❓')
+    display_parts = [f"   {emoji} {status}"]
+    if secondary:
+        display_parts.append(f"| {secondary}")
+    if elapsed_seconds is not None:
+        hours = elapsed_seconds // 3600
+        mins = (elapsed_seconds % 3600) // 60
+        secs = elapsed_seconds % 60
+        if hours > 0:
+            display_parts.append(f"| elapsed: {hours}h {mins}m {secs}s")
+        elif mins > 0:
+            display_parts.append(f"| elapsed: {mins}m {secs}s")
+        else:
+            display_parts.append(f"| elapsed: {secs}s")
+
+    _output({
+        "status": status,
+        "secondary_status": secondary,
+        "failure_reason": failure_reason,
+        "elapsed_seconds": elapsed_seconds,
+        "metrics": metrics,
+        "model_artifacts": model_artifacts,
+        "display": " ".join(display_parts),
+    })
+
+
+# ── cmd_resolve ───────────────────────────────────────────────────────────────
+
+def cmd_resolve(args):
+    """Extract model artifact or checkpoint S3 path from a training job.
+
+    With --checkpoints: returns checkpoint_config.s3_uri (for --resume).
+    Without: returns model artifacts path (for adapter staging).
+
+    Returns: {"artifact_path": str, "output_type": str, "checkpoint_path": str|null}
+    """
+    region = getattr(args, 'region', None) or os.environ.get('AWS_DEFAULT_REGION') or os.environ.get('AWS_REGION')
+    if region:
+        os.environ['AWS_DEFAULT_REGION'] = region
+        os.environ.setdefault('AWS_REGION', region)
+
+    try:
+        from sagemaker.core.resources import TrainingJob
+    except ImportError:
+        _error_exit("sagemaker SDK v3 not installed.")
+
+    try:
+        job = TrainingJob.get(training_job_name=args.job_name)
+    except Exception as e:
+        _error_exit(f"Failed to describe training job '{args.job_name}': {e}")
+
+    # If --checkpoints flag, return checkpoint path (job can be any status)
+    if getattr(args, 'checkpoints', False):
+        checkpoint_config = _sanitize_for_json(getattr(job, 'checkpoint_config', None))
+        checkpoint_path = None
+        if checkpoint_config:
+            checkpoint_path = _sanitize_for_json(getattr(checkpoint_config, 's3_uri', None))
+
+        # Fallback: derive from output path
+        if not checkpoint_path:
+            output_config = _sanitize_for_json(getattr(job, 'output_data_config', None))
+            if output_config:
+                s3_output = _sanitize_for_json(getattr(output_config, 's3_output_path', None))
+                if s3_output:
+                    checkpoint_path = f"{s3_output.rstrip('/')}/checkpoints/"
+
+        _output({
+            "checkpoint_path": checkpoint_path or "",
+            "job_name": args.job_name,
+        })
+        return
+
+    # Normal resolve: require completed status
+    status = _sanitize_for_json(getattr(job, 'training_job_status', 'Unknown')) or 'Unknown'
+    if status != 'Completed':
+        _error_exit(f"Job '{args.job_name}' is not completed (status: {status})")
+
+    artifacts_obj = _sanitize_for_json(getattr(job, 'model_artifacts', None))
+    if not artifacts_obj:
+        _error_exit(f"No model artifacts found for job '{args.job_name}'")
+
+    artifact_path = _sanitize_for_json(getattr(artifacts_obj, 's3_model_artifacts', None))
+    if not artifact_path:
+        _error_exit(f"No S3 model artifacts path for job '{args.job_name}'")
+
+    # Detect output type based on technique hint
+    output_type = "full-model"
+    technique = getattr(args, 'technique', None)
+    if technique and technique in ('sft', 'dpo'):
+        output_type = "adapter"
+
+    _output({
+        "artifact_path": artifact_path,
+        "output_type": output_type,
+    })
+
+
+# ── cmd_stop ──────────────────────────────────────────────────────────────────
+
+def cmd_stop(args):
+    """Stop a running training job.
+
+    Returns: {"stopped": true, "job_name": str}
+    """
+    region = getattr(args, 'region', None) or os.environ.get('AWS_DEFAULT_REGION') or os.environ.get('AWS_REGION')
+    if region:
+        os.environ['AWS_DEFAULT_REGION'] = region
+        os.environ.setdefault('AWS_REGION', region)
+
+    try:
+        from sagemaker.core.resources import TrainingJob
+    except ImportError:
+        _error_exit("sagemaker SDK v3 not installed.")
+
+    try:
+        job = TrainingJob.get(training_job_name=args.job_name)
+        job.stop()
+        _output({"stopped": True, "job_name": args.job_name})
+    except Exception as e:
+        _error_exit(f"Failed to stop training job '{args.job_name}': {e}")
+
+
+# ── Main ──────────────────────────────────────────────────────────────────────
+
+def main():
+    """Parse arguments and dispatch to subcommand handler."""
+    parser = argparse.ArgumentParser(description='SageMaker Training Job helper (SDK v3)')
+    subparsers = parser.add_subparsers(dest='command', required=True)
+
+    # submit
+    submit_parser = subparsers.add_parser('submit', help='Create a training job')
+    submit_parser.add_argument('--config', required=True, help='Path to job config JSON')
+    submit_parser.add_argument('--region', help='AWS region')
+
+    # status
+    status_parser = subparsers.add_parser('status', help='Get job status')
+    status_parser.add_argument('--job-name', required=True, help='Training job name')
+    status_parser.add_argument('--region', help='AWS region')
+
+    # resolve
+    resolve_parser = subparsers.add_parser('resolve', help='Resolve artifacts from completed job')
+    resolve_parser.add_argument('--job-name', required=True, help='Training job name')
+    resolve_parser.add_argument('--technique', help='Training technique (for output type hint)')
+    resolve_parser.add_argument('--checkpoints', action='store_true', help='Return checkpoint S3 path instead of model artifacts')
+    resolve_parser.add_argument('--region', help='AWS region')
+
+    # stop
+    stop_parser = subparsers.add_parser('stop', help='Stop a running job')
+    stop_parser.add_argument('--job-name', required=True, help='Training job name')
+    stop_parser.add_argument('--region', help='AWS region')
+
+    args = parser.parse_args()
+
+    commands = {
+        'submit': cmd_submit,
+        'status': cmd_status,
+        'resolve': cmd_resolve,
+        'stop': cmd_stop,
+    }
+
+    handler = commands.get(args.command)
+    if handler:
+        handler(args)
+    else:
+        _error_exit(f"Unknown command: {args.command}")
+
+
+if __name__ == '__main__':
+    main()

package/templates/do/adapter

@@ -35,6 +35,7 @@ _usage() {
     echo "  add <name> --weights <s3-uri>        Add a new LoRA adapter from S3"
     echo "  add <name> --from-hub <hf-repo-id>   Add a new LoRA adapter from HuggingFace Hub"
     echo "  add <name> --from-tune [technique]   Add adapter from do/tune output"
+    echo "  add <name> --from-train [technique]  Add adapter from do/train output"
     echo "  add <name> --from-registry [arn]     Add adapter from model registry"
     echo "  list                                  List all adapters on the endpoint"
     echo "  remove <name>                         Remove an adapter"
@@ -375,6 +376,8 @@ _adapter_add() {
     local from_hub=""
     local from_tune=""
     local from_tune_technique=""
+    local from_train=""
+    local from_train_technique=""
     local from_registry=""
     local registry_arn=""
     local use_local=""
@@ -413,6 +416,16 @@ _adapter_add() {
                     shift
                 fi
                 ;;
+            --from-train)
+                from_train="true"
+                # Check if next argument is a technique (not another flag and not empty)
+                if [ -n "${2:-}" ] && [[ "${2}" != -* ]]; then
+                    from_train_technique="$2"
+                    shift 2
+                else
+                    shift
+                fi
+                ;;
             --from-registry)
                 from_registry="true"
                 # Check if next argument is an ARN (starts with arn:)
@@ -508,6 +521,7 @@ _adapter_add() {
     [ -n "${weights_uri}" ] && source_count=$((source_count + 1))
     [ -n "${from_hub}" ] && source_count=$((source_count + 1))
     [ -n "${from_tune}" ] && source_count=$((source_count + 1))
+    [ -n "${from_train}" ] && source_count=$((source_count + 1))
     [ -n "${from_registry}" ] && source_count=$((source_count + 1))
 
     if [ "${source_count}" -gt 1 ]; then
@@ -868,6 +882,96 @@ _adapter_add() {
         fi  # end --local else branch
     fi
 
+    # ── Resolve --from-train to weights_uri ───────────────────────────────
+    if [ -n "${from_train}" ]; then
+        if [ -n "${from_train_technique}" ]; then
+            local technique_upper
+            technique_upper=$(echo "${from_train_technique}" | tr '[:lower:]' '[:upper:]')
+            local train_var="TRAIN_ADAPTER_PATH_${technique_upper}"
+            local train_path="${!train_var:-}"
+
+            if [ -z "${train_path}" ]; then
+                echo "❌ No training adapter output found for technique: ${from_train_technique}"
+                echo ""
+                echo "   ${train_var} is not set in do/config."
+                echo ""
+                echo "   Run a training job first:"
+                echo "   ./do/train --technique ${from_train_technique} --dataset <source>"
+                exit 1
+            fi
+
+            weights_uri="${train_path}"
+            echo "📦 Using train adapter output for technique '${from_train_technique}': ${weights_uri}"
+        else
+            # No technique: read TRAIN_OUTPUT_PATH_LATEST
+            if [ -z "${TRAIN_OUTPUT_PATH_LATEST:-}" ]; then
+                echo "❌ No training output found."
+                echo ""
+                echo "   TRAIN_OUTPUT_PATH_LATEST is not set in do/config."
+                echo ""
+                echo "   Run a training job first:"
+                echo "   ./do/train --technique <technique> --dataset <source>"
+                exit 1
+            fi
+
+            weights_uri="${TRAIN_OUTPUT_PATH_LATEST}"
+            echo "📦 Using latest train adapter output: ${weights_uri}"
+        fi
+        echo ""
+
+        # Use same staging path as --from-tune (Processing Job or local)
+        if [ -z "${use_local}" ]; then
+            echo "🚀 Submitting Processing Job to stage adapter from training output..."
+            echo ""
+
+            local exec_role="${EXECUTION_ROLE_ARN:-}"
+            if [ -z "${exec_role}" ]; then
+                exec_role="${ROLE_ARN:-}"
+            fi
+            if [ -z "${exec_role}" ]; then
+                exec_role="${SAGEMAKER_ROLE_ARN:-}"
+            fi
+            if [ -z "${exec_role}" ]; then
+                echo "❌ No execution role found."
+                echo "   Run 'ml-container-creator bootstrap' to set up your profile."
+                exit 1
+            fi
+
+            local adapter_bucket="${ADAPTER_S3_BUCKET:-}"
+            if [ -z "${adapter_bucket}" ]; then
+                local account_id
+                account_id=$(aws sts get-caller-identity --query Account --output text 2>/dev/null || echo "")
+                adapter_bucket="sagemaker-${AWS_REGION:-us-east-1}-${account_id}"
+            fi
+
+            local adapter_s3_prefix="s3://${adapter_bucket}/${PROJECT_NAME}/adapters/${adapter_name}"
+
+            local stage_args=(
+                --source-uri "${weights_uri}"
+                --output-uri "${adapter_s3_prefix}/"
+                --role-arn "${exec_role}"
+                --region "${AWS_REGION}"
+            )
+            if [ -n "${no_wait}" ]; then
+                stage_args+=(--no-wait)
+            fi
+
+            local stage_result
+            stage_result=$(python3 "${SCRIPT_DIR}/.adapter_helper.py" stage "${stage_args[@]}" 2>/dev/null | grep -E '^\{' | tail -1) || {
+                echo "❌ Failed to submit adapter staging job"
+                exit 1
+            }
+
+            weights_uri=$(echo "${stage_result}" | python3 -c "import sys,json; print(json.load(sys.stdin).get('adapter_s3_uri',''))" 2>/dev/null) || weights_uri=""
+            if [ -z "${weights_uri}" ]; then
+                echo "❌ Failed to extract staged adapter URI"
+                exit 1
+            fi
+            echo "   ✅ Adapter staged to: ${weights_uri}"
+        fi
+        echo ""
+    fi
+
     # ── Resolve --from-registry to weights_uri ────────────────────────────
     if [ -n "${from_registry}" ]; then
         if [ -z "${registry_arn}" ]; then
@@ -986,6 +1090,13 @@ _adapter_add() {
         # Extract model data URL (weights path)
         weights_uri=$(echo "${version_line}" | python3 -c "import sys,json; data=json.loads(sys.stdin.read()); print(data.get('modelDataUrl',''))" 2>/dev/null || echo "")
 
+        # Ensure adapter weights URI ends with / (S3 prefix for directory-style adapters).
+        # Registry metadata may have the slash stripped (Bug 52 rstrip), but SageMaker IC
+        # ModelDataUrl requires it to download all objects under the prefix.
+        if [ -n "${weights_uri}" ] && ! echo "${weights_uri}" | grep -q '\.tar\.gz$'; then
+            weights_uri="${weights_uri%/}/"
+        fi
+
         if [ -z "${weights_uri}" ]; then
             echo "❌ No model data URL found for registry version: ${registry_arn}"
             echo ""
@@ -1294,6 +1405,16 @@ EOF
         fi
     fi
 
+    # Add train-specific metadata if --from-train was used
+    if [ -n "${from_train}" ]; then
+        local train_technique_meta="${from_train_technique:-${TRAIN_TECHNIQUE:-custom}}"
+        cat >> "${SCRIPT_DIR}/adapters/${adapter_name}.conf" <<EOF
+export ADAPTER_SOURCE="train"
+export ADAPTER_TECHNIQUE="${train_technique_meta}"
+export ADAPTER_TRAIN_JOB="${TRAIN_JOB_NAME:-}"
+EOF
+    fi
+
     # Add registry-specific metadata if --from-registry was used
     if [ -n "${from_registry}" ]; then
         cat >> "${SCRIPT_DIR}/adapters/${adapter_name}.conf" <<EOF
@@ -1425,6 +1546,42 @@ if endpoint_name:
     except Exception:
         print("⚠️  Could not query endpoint — showing local confs only.", file=sys.stderr)
 
+# ── Data source 3: Registry (MPG) adapters ──
+# Query the deployment MPG for registered adapter versions (if .register_helper.py exists)
+helper_path = os.path.join(script_dir, ".register_helper.py")
+if os.path.exists(helper_path):
+    try:
+        result = subprocess.run(
+            ["python3", helper_path, "list-adapters",
+             "--project-name", project_name, "--region", region],
+            capture_output=True, text=True, timeout=15)
+        if result.returncode == 0:
+            # Extract JSON line
+            for line in result.stdout.strip().split("\n"):
+                if line.startswith("{"):
+                    reg_data = json.loads(line)
+                    for adapter in reg_data.get("adapters", []):
+                        reg_name = adapter.get("name", "")
+                        if not reg_name:
+                            continue
+                        # Only add if not already tracked locally
+                        if reg_name not in adapters:
+                            adapters[reg_name] = {
+                                "source": "registry",
+                                "ic_name": "",
+                                "technique": adapter.get("technique", ""),
+                                "dataset": "",
+                                "status": f"v{adapter.get('version', '?')}",
+                            }
+                        else:
+                            # Annotate existing entry with registry version
+                            ver = adapter.get("version", "")
+                            if ver:
+                                adapters[reg_name]["status"] += f" (reg:v{ver})"
+                    break
+    except Exception:
+        pass  # Registry query is best-effort
+
 # ── Output ──
 if not adapters:
     print("No adapters found.")