Add files using upload-large-folder tool

platform/aiml/checkpoints/qwen3-8b-elizabeth-sft/checkpoint-1500/special_tokens_map.json

@@ -0,0 +1,31 @@
+{
+  "additional_special_tokens": [
+    "<|im_start|>",
+    "<|im_end|>",
+    "<|object_ref_start|>",
+    "<|object_ref_end|>",
+    "<|box_start|>",
+    "<|box_end|>",
+    "<|quad_start|>",
+    "<|quad_end|>",
+    "<|vision_start|>",
+    "<|vision_end|>",
+    "<|vision_pad|>",
+    "<|image_pad|>",
+    "<|video_pad|>"
+  ],
+  "eos_token": {
+    "content": "<|endoftext|>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "pad_token": {
+    "content": "<|endoftext|>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  }
+}

platform/aiml/checkpoints/qwen3-8b-elizabeth-sft/checkpoint-1500/tokenizer_config.json

@@ -0,0 +1,207 @@
+{
+  "add_bos_token": false,
+  "add_prefix_space": false,
+  "added_tokens_decoder": {
+    "151643": {
+      "content": "<|endoftext|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151644": {
+      "content": "<|im_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151645": {
+      "content": "<|im_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151646": {
+      "content": "<|object_ref_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151647": {
+      "content": "<|object_ref_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151648": {
+      "content": "<|box_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151649": {
+      "content": "<|box_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151650": {
+      "content": "<|quad_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151651": {
+      "content": "<|quad_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151652": {
+      "content": "<|vision_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151653": {
+      "content": "<|vision_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151654": {
+      "content": "<|vision_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151655": {
+      "content": "<|image_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151656": {
+      "content": "<|video_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151657": {
+      "content": "<tool_call>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151658": {
+      "content": "</tool_call>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151659": {
+      "content": "<|fim_prefix|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151660": {
+      "content": "<|fim_middle|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151661": {
+      "content": "<|fim_suffix|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151662": {
+      "content": "<|fim_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151663": {
+      "content": "<|repo_name|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151664": {
+      "content": "<|file_sep|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    }
+  },
+  "additional_special_tokens": [
+    "<|im_start|>",
+    "<|im_end|>",
+    "<|object_ref_start|>",
+    "<|object_ref_end|>",
+    "<|box_start|>",
+    "<|box_end|>",
+    "<|quad_start|>",
+    "<|quad_end|>",
+    "<|vision_start|>",
+    "<|vision_end|>",
+    "<|vision_pad|>",
+    "<|image_pad|>",
+    "<|video_pad|>"
+  ],
+  "bos_token": null,
+  "chat_template": "{%- if tools %}\n    {{- '<|im_start|>system\\n' }}\n    {%- if messages[0]['role'] == 'system' %}\n        {{- messages[0]['content'] }}\n    {%- else %}\n        {{- 'You are a helpful assistant.' }}\n    {%- endif %}\n    {{- \"\\n\\n# Tools\\n\\nYou may call one or more functions to assist with the user query.\\n\\nYou are provided with function signatures within <tools></tools> XML tags:\\n<tools>\" }}\n    {%- for tool in tools %}\n        {{- \"\\n\" }}\n        {{- tool | tojson }}\n    {%- endfor %}\n    {{- \"\\n</tools>\\n\\nFor each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:\\n<tool_call>\\n{\\\"name\\\": <function-name>, \\\"arguments\\\": <args-json-object>}\\n</tool_call><|im_end|>\\n\" }}\n{%- else %}\n    {%- if messages[0]['role'] == 'system' %}\n        {{- '<|im_start|>system\\n' + messages[0]['content'] + '<|im_end|>\\n' }}\n    {%- else %}\n        {{- '<|im_start|>system\\nYou are a helpful assistant.<|im_end|>\\n' }}\n    {%- endif %}\n{%- endif %}\n{%- for message in messages %}\n    {%- if (message.role == \"user\") or (message.role == \"system\" and not loop.first) or (message.role == \"assistant\" and not message.tool_calls) %}\n        {{- '<|im_start|>' + message.role + '\\n' + message.content + '<|im_end|>' + '\\n' }}\n    {%- elif message.role == \"assistant\" %}\n        {{- '<|im_start|>' + message.role }}\n        {%- if message.content %}\n            {{- '\\n' + message.content }}\n        {%- endif %}\n        {%- for tool_call in message.tool_calls %}\n            {%- if tool_call.function is defined %}\n                {%- set tool_call = tool_call.function %}\n            {%- endif %}\n            {{- '\\n<tool_call>\\n{\"name\": \"' }}\n            {{- tool_call.name }}\n            {{- '\", \"arguments\": ' }}\n            {{- tool_call.arguments | tojson }}\n            {{- '}\\n</tool_call>' }}\n        {%- endfor %}\n        {{- '<|im_end|>\\n' }}\n    {%- elif message.role == \"tool\" %}\n        {%- if (loop.index0 == 0) or (messages[loop.index0 - 1].role != \"tool\") %}\n            {{- '<|im_start|>user' }}\n        {%- endif %}\n        {{- '\\n<tool_response>\\n' }}\n        {{- message.content }}\n        {{- '\\n</tool_response>' }}\n        {%- if loop.last or (messages[loop.index0 + 1].role != \"tool\") %}\n            {{- '<|im_end|>\\n' }}\n        {%- endif %}\n    {%- endif %}\n{%- endfor %}\n{%- if add_generation_prompt %}\n    {{- '<|im_start|>assistant\\n' }}\n{%- endif %}\n",
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "<|endoftext|>",
+  "errors": "replace",
+  "model_max_length": 131072,
+  "pad_token": "<|endoftext|>",
+  "split_special_tokens": false,
+  "tokenizer_class": "Qwen2Tokenizer",
+  "unk_token": null
+}

platform/aiml/checkpoints/qwen3-8b-elizabeth-sft/checkpoint-500/added_tokens.json

@@ -0,0 +1,24 @@
+{
+  "</tool_call>": 151658,
+  "<tool_call>": 151657,
+  "<|box_end|>": 151649,
+  "<|box_start|>": 151648,
+  "<|endoftext|>": 151643,
+  "<|file_sep|>": 151664,
+  "<|fim_middle|>": 151660,
+  "<|fim_pad|>": 151662,
+  "<|fim_prefix|>": 151659,
+  "<|fim_suffix|>": 151661,
+  "<|im_end|>": 151645,
+  "<|im_start|>": 151644,
+  "<|image_pad|>": 151655,
+  "<|object_ref_end|>": 151647,
+  "<|object_ref_start|>": 151646,
+  "<|quad_end|>": 151651,
+  "<|quad_start|>": 151650,
+  "<|repo_name|>": 151663,
+  "<|video_pad|>": 151656,
+  "<|vision_end|>": 151653,
+  "<|vision_pad|>": 151654,
+  "<|vision_start|>": 151652
+}

platform/aiml/checkpoints/qwen3-8b-elizabeth-sft/checkpoint-500/config.json

@@ -0,0 +1,29 @@
+{
+  "_name_or_path": "/workspace/models/qwen3-8b",
+  "architectures": [
+    "Qwen2ForCausalLM"
+  ],
+  "attention_dropout": 0.0,
+  "bos_token_id": 151643,
+  "eos_token_id": 151643,
+  "hidden_act": "silu",
+  "hidden_size": 3584,
+  "initializer_range": 0.02,
+  "intermediate_size": 18944,
+  "max_position_embeddings": 131072,
+  "max_window_layers": 28,
+  "model_type": "qwen2",
+  "num_attention_heads": 28,
+  "num_hidden_layers": 28,
+  "num_key_value_heads": 4,
+  "rms_norm_eps": 1e-06,
+  "rope_theta": 1000000.0,
+  "sliding_window": 131072,
+  "tie_word_embeddings": false,
+  "torch_dtype": "bfloat16",
+  "transformers_version": "4.40.0",
+  "use_cache": false,
+  "use_mrope": false,
+  "use_sliding_window": false,
+  "vocab_size": 152064
+}

platform/aiml/checkpoints/qwen3-8b-elizabeth-sft/checkpoint-500/generation_config.json

@@ -0,0 +1,6 @@
+{
+  "bos_token_id": 151643,
+  "eos_token_id": 151643,
+  "max_new_tokens": 2048,
+  "transformers_version": "4.40.0"
+}

platform/aiml/checkpoints/qwen3-8b-elizabeth-sft/checkpoint-500/model-00001-of-00004.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1e7ba0d54729de48c68fe7f78593c228470b91e1e26b9597b47947611a385b29
+size 4877660776

platform/aiml/checkpoints/qwen3-8b-elizabeth-sft/checkpoint-500/model-00002-of-00004.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:27e0f358f7ba237b68e1f5bda5f57e81f989ab34c15c74a76a40812d5254c5c2
+size 4932751008

platform/aiml/checkpoints/qwen3-8b-elizabeth-sft/checkpoint-500/model-00003-of-00004.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8c18af12426cd159bcb86bfdf93d7408af5afc22f32b8d99790824de7a0b483f
+size 4330865200

platform/aiml/checkpoints/qwen3-8b-elizabeth-sft/checkpoint-500/model-00004-of-00004.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:61be6c2ddf4956df8712f12deecddcaaa78ef009976ef23f8220d644c7d600c9
+size 1089994880

platform/aiml/checkpoints/qwen3-8b-elizabeth-sft/checkpoint-500/model.safetensors.index.json

@@ -0,0 +1,346 @@
+{
+  "metadata": {
+    "total_size": 15231233024
+  },
+  "weight_map": {
+    "lm_head.weight": "model-00004-of-00004.safetensors",
+    "model.embed_tokens.weight": "model-00001-of-00004.safetensors",
+    "model.layers.0.input_layernorm.weight": "model-00001-of-00004.safetensors",
+    "model.layers.0.mlp.down_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.0.mlp.gate_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.0.mlp.up_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.0.post_attention_layernorm.weight": "model-00001-of-00004.safetensors",
+    "model.layers.0.self_attn.k_proj.bias": "model-00001-of-00004.safetensors",
+    "model.layers.0.self_attn.k_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.0.self_attn.o_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.0.self_attn.q_proj.bias": "model-00001-of-00004.safetensors",
+    "model.layers.0.self_attn.q_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.0.self_attn.v_proj.bias": "model-00001-of-00004.safetensors",
+    "model.layers.0.self_attn.v_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.1.input_layernorm.weight": "model-00001-of-00004.safetensors",
+    "model.layers.1.mlp.down_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.1.mlp.gate_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.1.mlp.up_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.1.post_attention_layernorm.weight": "model-00001-of-00004.safetensors",
+    "model.layers.1.self_attn.k_proj.bias": "model-00001-of-00004.safetensors",
+    "model.layers.1.self_attn.k_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.1.self_attn.o_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.1.self_attn.q_proj.bias": "model-00001-of-00004.safetensors",
+    "model.layers.1.self_attn.q_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.1.self_attn.v_proj.bias": "model-00001-of-00004.safetensors",
+    "model.layers.1.self_attn.v_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.10.input_layernorm.weight": "model-00002-of-00004.safetensors",
+    "model.layers.10.mlp.down_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.10.mlp.gate_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.10.mlp.up_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.10.post_attention_layernorm.weight": "model-00002-of-00004.safetensors",
+    "model.layers.10.self_attn.k_proj.bias": "model-00002-of-00004.safetensors",
+    "model.layers.10.self_attn.k_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.10.self_attn.o_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.10.self_attn.q_proj.bias": "model-00002-of-00004.safetensors",
+    "model.layers.10.self_attn.q_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.10.self_attn.v_proj.bias": "model-00002-of-00004.safetensors",
+    "model.layers.10.self_attn.v_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.11.input_layernorm.weight": "model-00002-of-00004.safetensors",
+    "model.layers.11.mlp.down_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.11.mlp.gate_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.11.mlp.up_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.11.post_attention_layernorm.weight": "model-00002-of-00004.safetensors",
+    "model.layers.11.self_attn.k_proj.bias": "model-00002-of-00004.safetensors",
+    "model.layers.11.self_attn.k_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.11.self_attn.o_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.11.self_attn.q_proj.bias": "model-00002-of-00004.safetensors",
+    "model.layers.11.self_attn.q_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.11.self_attn.v_proj.bias": "model-00002-of-00004.safetensors",
+    "model.layers.11.self_attn.v_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.12.input_layernorm.weight": "model-00002-of-00004.safetensors",
+    "model.layers.12.mlp.down_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.12.mlp.gate_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.12.mlp.up_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.12.post_attention_layernorm.weight": "model-00002-of-00004.safetensors",
+    "model.layers.12.self_attn.k_proj.bias": "model-00002-of-00004.safetensors",
+    "model.layers.12.self_attn.k_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.12.self_attn.o_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.12.self_attn.q_proj.bias": "model-00002-of-00004.safetensors",
+    "model.layers.12.self_attn.q_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.12.self_attn.v_proj.bias": "model-00002-of-00004.safetensors",
+    "model.layers.12.self_attn.v_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.13.input_layernorm.weight": "model-00002-of-00004.safetensors",
+    "model.layers.13.mlp.down_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.13.mlp.gate_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.13.mlp.up_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.13.post_attention_layernorm.weight": "model-00002-of-00004.safetensors",
+    "model.layers.13.self_attn.k_proj.bias": "model-00002-of-00004.safetensors",
+    "model.layers.13.self_attn.k_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.13.self_attn.o_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.13.self_attn.q_proj.bias": "model-00002-of-00004.safetensors",
+    "model.layers.13.self_attn.q_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.13.self_attn.v_proj.bias": "model-00002-of-00004.safetensors",
+    "model.layers.13.self_attn.v_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.14.input_layernorm.weight": "model-00002-of-00004.safetensors",
+    "model.layers.14.mlp.down_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.14.mlp.gate_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.14.mlp.up_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.14.post_attention_layernorm.weight": "model-00002-of-00004.safetensors",
+    "model.layers.14.self_attn.k_proj.bias": "model-00002-of-00004.safetensors",
+    "model.layers.14.self_attn.k_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.14.self_attn.o_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.14.self_attn.q_proj.bias": "model-00002-of-00004.safetensors",
+    "model.layers.14.self_attn.q_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.14.self_attn.v_proj.bias": "model-00002-of-00004.safetensors",
+    "model.layers.14.self_attn.v_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.15.input_layernorm.weight": "model-00002-of-00004.safetensors",
+    "model.layers.15.mlp.down_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.15.mlp.gate_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.15.mlp.up_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.15.post_attention_layernorm.weight": "model-00002-of-00004.safetensors",
+    "model.layers.15.self_attn.k_proj.bias": "model-00002-of-00004.safetensors",
+    "model.layers.15.self_attn.k_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.15.self_attn.o_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.15.self_attn.q_proj.bias": "model-00002-of-00004.safetensors",
+    "model.layers.15.self_attn.q_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.15.self_attn.v_proj.bias": "model-00002-of-00004.safetensors",
+    "model.layers.15.self_attn.v_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.16.input_layernorm.weight": "model-00002-of-00004.safetensors",
+    "model.layers.16.mlp.down_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.16.mlp.gate_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.16.mlp.up_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.16.post_attention_layernorm.weight": "model-00002-of-00004.safetensors",
+    "model.layers.16.self_attn.k_proj.bias": "model-00002-of-00004.safetensors",
+    "model.layers.16.self_attn.k_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.16.self_attn.o_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.16.self_attn.q_proj.bias": "model-00002-of-00004.safetensors",
+    "model.layers.16.self_attn.q_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.16.self_attn.v_proj.bias": "model-00002-of-00004.safetensors",
+    "model.layers.16.self_attn.v_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.17.input_layernorm.weight": "model-00002-of-00004.safetensors",
+    "model.layers.17.mlp.down_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.17.mlp.gate_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.17.mlp.up_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.17.post_attention_layernorm.weight": "model-00002-of-00004.safetensors",
+    "model.layers.17.self_attn.k_proj.bias": "model-00002-of-00004.safetensors",
+    "model.layers.17.self_attn.k_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.17.self_attn.o_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.17.self_attn.q_proj.bias": "model-00002-of-00004.safetensors",
+    "model.layers.17.self_attn.q_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.17.self_attn.v_proj.bias": "model-00002-of-00004.safetensors",
+    "model.layers.17.self_attn.v_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.18.input_layernorm.weight": "model-00003-of-00004.safetensors",
+    "model.layers.18.mlp.down_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.18.mlp.gate_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.18.mlp.up_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.18.post_attention_layernorm.weight": "model-00003-of-00004.safetensors",
+    "model.layers.18.self_attn.k_proj.bias": "model-00002-of-00004.safetensors",
+    "model.layers.18.self_attn.k_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.18.self_attn.o_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.18.self_attn.q_proj.bias": "model-00002-of-00004.safetensors",
+    "model.layers.18.self_attn.q_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.18.self_attn.v_proj.bias": "model-00002-of-00004.safetensors",
+    "model.layers.18.self_attn.v_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.19.input_layernorm.weight": "model-00003-of-00004.safetensors",
+    "model.layers.19.mlp.down_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.19.mlp.gate_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.19.mlp.up_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.19.post_attention_layernorm.weight": "model-00003-of-00004.safetensors",
+    "model.layers.19.self_attn.k_proj.bias": "model-00003-of-00004.safetensors",
+    "model.layers.19.self_attn.k_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.19.self_attn.o_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.19.self_attn.q_proj.bias": "model-00003-of-00004.safetensors",
+    "model.layers.19.self_attn.q_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.19.self_attn.v_proj.bias": "model-00003-of-00004.safetensors",
+    "model.layers.19.self_attn.v_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.2.input_layernorm.weight": "model-00001-of-00004.safetensors",
+    "model.layers.2.mlp.down_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.2.mlp.gate_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.2.mlp.up_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.2.post_attention_layernorm.weight": "model-00001-of-00004.safetensors",
+    "model.layers.2.self_attn.k_proj.bias": "model-00001-of-00004.safetensors",
+    "model.layers.2.self_attn.k_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.2.self_attn.o_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.2.self_attn.q_proj.bias": "model-00001-of-00004.safetensors",
+    "model.layers.2.self_attn.q_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.2.self_attn.v_proj.bias": "model-00001-of-00004.safetensors",
+    "model.layers.2.self_attn.v_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.20.input_layernorm.weight": "model-00003-of-00004.safetensors",
+    "model.layers.20.mlp.down_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.20.mlp.gate_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.20.mlp.up_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.20.post_attention_layernorm.weight": "model-00003-of-00004.safetensors",
+    "model.layers.20.self_attn.k_proj.bias": "model-00003-of-00004.safetensors",
+    "model.layers.20.self_attn.k_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.20.self_attn.o_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.20.self_attn.q_proj.bias": "model-00003-of-00004.safetensors",
+    "model.layers.20.self_attn.q_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.20.self_attn.v_proj.bias": "model-00003-of-00004.safetensors",
+    "model.layers.20.self_attn.v_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.21.input_layernorm.weight": "model-00003-of-00004.safetensors",
+    "model.layers.21.mlp.down_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.21.mlp.gate_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.21.mlp.up_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.21.post_attention_layernorm.weight": "model-00003-of-00004.safetensors",
+    "model.layers.21.self_attn.k_proj.bias": "model-00003-of-00004.safetensors",
+    "model.layers.21.self_attn.k_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.21.self_attn.o_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.21.self_attn.q_proj.bias": "model-00003-of-00004.safetensors",
+    "model.layers.21.self_attn.q_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.21.self_attn.v_proj.bias": "model-00003-of-00004.safetensors",
+    "model.layers.21.self_attn.v_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.22.input_layernorm.weight": "model-00003-of-00004.safetensors",
+    "model.layers.22.mlp.down_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.22.mlp.gate_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.22.mlp.up_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.22.post_attention_layernorm.weight": "model-00003-of-00004.safetensors",
+    "model.layers.22.self_attn.k_proj.bias": "model-00003-of-00004.safetensors",
+    "model.layers.22.self_attn.k_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.22.self_attn.o_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.22.self_attn.q_proj.bias": "model-00003-of-00004.safetensors",
+    "model.layers.22.self_attn.q_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.22.self_attn.v_proj.bias": "model-00003-of-00004.safetensors",
+    "model.layers.22.self_attn.v_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.23.input_layernorm.weight": "model-00003-of-00004.safetensors",
+    "model.layers.23.mlp.down_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.23.mlp.gate_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.23.mlp.up_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.23.post_attention_layernorm.weight": "model-00003-of-00004.safetensors",
+    "model.layers.23.self_attn.k_proj.bias": "model-00003-of-00004.safetensors",
+    "model.layers.23.self_attn.k_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.23.self_attn.o_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.23.self_attn.q_proj.bias": "model-00003-of-00004.safetensors",
+    "model.layers.23.self_attn.q_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.23.self_attn.v_proj.bias": "model-00003-of-00004.safetensors",
+    "model.layers.23.self_attn.v_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.24.input_layernorm.weight": "model-00003-of-00004.safetensors",
+    "model.layers.24.mlp.down_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.24.mlp.gate_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.24.mlp.up_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.24.post_attention_layernorm.weight": "model-00003-of-00004.safetensors",
+    "model.layers.24.self_attn.k_proj.bias": "model-00003-of-00004.safetensors",
+    "model.layers.24.self_attn.k_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.24.self_attn.o_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.24.self_attn.q_proj.bias": "model-00003-of-00004.safetensors",
+    "model.layers.24.self_attn.q_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.24.self_attn.v_proj.bias": "model-00003-of-00004.safetensors",
+    "model.layers.24.self_attn.v_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.25.input_layernorm.weight": "model-00003-of-00004.safetensors",
+    "model.layers.25.mlp.down_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.25.mlp.gate_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.25.mlp.up_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.25.post_attention_layernorm.weight": "model-00003-of-00004.safetensors",
+    "model.layers.25.self_attn.k_proj.bias": "model-00003-of-00004.safetensors",
+    "model.layers.25.self_attn.k_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.25.self_attn.o_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.25.self_attn.q_proj.bias": "model-00003-of-00004.safetensors",
+    "model.layers.25.self_attn.q_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.25.self_attn.v_proj.bias": "model-00003-of-00004.safetensors",
+    "model.layers.25.self_attn.v_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.26.input_layernorm.weight": "model-00003-of-00004.safetensors",
+    "model.layers.26.mlp.down_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.26.mlp.gate_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.26.mlp.up_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.26.post_attention_layernorm.weight": "model-00003-of-00004.safetensors",
+    "model.layers.26.self_attn.k_proj.bias": "model-00003-of-00004.safetensors",
+    "model.layers.26.self_attn.k_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.26.self_attn.o_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.26.self_attn.q_proj.bias": "model-00003-of-00004.safetensors",
+    "model.layers.26.self_attn.q_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.26.self_attn.v_proj.bias": "model-00003-of-00004.safetensors",
+    "model.layers.26.self_attn.v_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.27.input_layernorm.weight": "model-00003-of-00004.safetensors",
+    "model.layers.27.mlp.down_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.27.mlp.gate_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.27.mlp.up_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.27.post_attention_layernorm.weight": "model-00003-of-00004.safetensors",
+    "model.layers.27.self_attn.k_proj.bias": "model-00003-of-00004.safetensors",
+    "model.layers.27.self_attn.k_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.27.self_attn.o_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.27.self_attn.q_proj.bias": "model-00003-of-00004.safetensors",
+    "model.layers.27.self_attn.q_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.27.self_attn.v_proj.bias": "model-00003-of-00004.safetensors",
+    "model.layers.27.self_attn.v_proj.weight": "model-00003-of-00004.safetensors",
+    "model.layers.3.input_layernorm.weight": "model-00001-of-00004.safetensors",
+    "model.layers.3.mlp.down_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.3.mlp.gate_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.3.mlp.up_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.3.post_attention_layernorm.weight": "model-00001-of-00004.safetensors",
+    "model.layers.3.self_attn.k_proj.bias": "model-00001-of-00004.safetensors",
+    "model.layers.3.self_attn.k_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.3.self_attn.o_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.3.self_attn.q_proj.bias": "model-00001-of-00004.safetensors",
+    "model.layers.3.self_attn.q_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.3.self_attn.v_proj.bias": "model-00001-of-00004.safetensors",
+    "model.layers.3.self_attn.v_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.4.input_layernorm.weight": "model-00001-of-00004.safetensors",
+    "model.layers.4.mlp.down_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.4.mlp.gate_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.4.mlp.up_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.4.post_attention_layernorm.weight": "model-00001-of-00004.safetensors",
+    "model.layers.4.self_attn.k_proj.bias": "model-00001-of-00004.safetensors",
+    "model.layers.4.self_attn.k_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.4.self_attn.o_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.4.self_attn.q_proj.bias": "model-00001-of-00004.safetensors",
+    "model.layers.4.self_attn.q_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.4.self_attn.v_proj.bias": "model-00001-of-00004.safetensors",
+    "model.layers.4.self_attn.v_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.5.input_layernorm.weight": "model-00001-of-00004.safetensors",
+    "model.layers.5.mlp.down_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.5.mlp.gate_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.5.mlp.up_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.5.post_attention_layernorm.weight": "model-00001-of-00004.safetensors",
+    "model.layers.5.self_attn.k_proj.bias": "model-00001-of-00004.safetensors",
+    "model.layers.5.self_attn.k_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.5.self_attn.o_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.5.self_attn.q_proj.bias": "model-00001-of-00004.safetensors",
+    "model.layers.5.self_attn.q_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.5.self_attn.v_proj.bias": "model-00001-of-00004.safetensors",
+    "model.layers.5.self_attn.v_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.6.input_layernorm.weight": "model-00001-of-00004.safetensors",
+    "model.layers.6.mlp.down_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.6.mlp.gate_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.6.mlp.up_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.6.post_attention_layernorm.weight": "model-00001-of-00004.safetensors",
+    "model.layers.6.self_attn.k_proj.bias": "model-00001-of-00004.safetensors",
+    "model.layers.6.self_attn.k_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.6.self_attn.o_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.6.self_attn.q_proj.bias": "model-00001-of-00004.safetensors",
+    "model.layers.6.self_attn.q_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.6.self_attn.v_proj.bias": "model-00001-of-00004.safetensors",
+    "model.layers.6.self_attn.v_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.7.input_layernorm.weight": "model-00001-of-00004.safetensors",
+    "model.layers.7.mlp.down_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.7.mlp.gate_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.7.mlp.up_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.7.post_attention_layernorm.weight": "model-00001-of-00004.safetensors",
+    "model.layers.7.self_attn.k_proj.bias": "model-00001-of-00004.safetensors",
+    "model.layers.7.self_attn.k_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.7.self_attn.o_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.7.self_attn.q_proj.bias": "model-00001-of-00004.safetensors",
+    "model.layers.7.self_attn.q_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.7.self_attn.v_proj.bias": "model-00001-of-00004.safetensors",
+    "model.layers.7.self_attn.v_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.8.input_layernorm.weight": "model-00002-of-00004.safetensors",
+    "model.layers.8.mlp.down_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.8.mlp.gate_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.8.mlp.up_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.8.post_attention_layernorm.weight": "model-00002-of-00004.safetensors",
+    "model.layers.8.self_attn.k_proj.bias": "model-00001-of-00004.safetensors",
+    "model.layers.8.self_attn.k_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.8.self_attn.o_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.8.self_attn.q_proj.bias": "model-00001-of-00004.safetensors",
+    "model.layers.8.self_attn.q_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.8.self_attn.v_proj.bias": "model-00001-of-00004.safetensors",
+    "model.layers.8.self_attn.v_proj.weight": "model-00001-of-00004.safetensors",
+    "model.layers.9.input_layernorm.weight": "model-00002-of-00004.safetensors",
+    "model.layers.9.mlp.down_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.9.mlp.gate_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.9.mlp.up_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.9.post_attention_layernorm.weight": "model-00002-of-00004.safetensors",
+    "model.layers.9.self_attn.k_proj.bias": "model-00002-of-00004.safetensors",
+    "model.layers.9.self_attn.k_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.9.self_attn.o_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.9.self_attn.q_proj.bias": "model-00002-of-00004.safetensors",
+    "model.layers.9.self_attn.q_proj.weight": "model-00002-of-00004.safetensors",
+    "model.layers.9.self_attn.v_proj.bias": "model-00002-of-00004.safetensors",
+    "model.layers.9.self_attn.v_proj.weight": "model-00002-of-00004.safetensors",
+    "model.norm.weight": "model-00003-of-00004.safetensors"
+  }
+}

platform/aiml/checkpoints/qwen3-8b-elizabeth-sft/checkpoint-500/optimizer.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4d29a431f8372a5fbdfeb8aa2b9639d4895ebcca4f6f5ff52c38031c1b87066b
+size 30462761583

platform/aiml/checkpoints/qwen3-8b-elizabeth-sft/checkpoint-500/special_tokens_map.json

@@ -0,0 +1,31 @@
+{
+  "additional_special_tokens": [
+    "<|im_start|>",
+    "<|im_end|>",
+    "<|object_ref_start|>",
+    "<|object_ref_end|>",
+    "<|box_start|>",
+    "<|box_end|>",
+    "<|quad_start|>",
+    "<|quad_end|>",
+    "<|vision_start|>",
+    "<|vision_end|>",
+    "<|vision_pad|>",
+    "<|image_pad|>",
+    "<|video_pad|>"
+  ],
+  "eos_token": {
+    "content": "<|endoftext|>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "pad_token": {
+    "content": "<|endoftext|>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  }
+}

platform/aiml/checkpoints/qwen3-8b-elizabeth-sft/checkpoint-500/tokenizer_config.json

@@ -0,0 +1,207 @@
+{
+  "add_bos_token": false,
+  "add_prefix_space": false,
+  "added_tokens_decoder": {
+    "151643": {
+      "content": "<|endoftext|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151644": {
+      "content": "<|im_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151645": {
+      "content": "<|im_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151646": {
+      "content": "<|object_ref_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151647": {
+      "content": "<|object_ref_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151648": {
+      "content": "<|box_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151649": {
+      "content": "<|box_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151650": {
+      "content": "<|quad_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151651": {
+      "content": "<|quad_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151652": {
+      "content": "<|vision_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151653": {
+      "content": "<|vision_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151654": {
+      "content": "<|vision_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151655": {
+      "content": "<|image_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151656": {
+      "content": "<|video_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151657": {
+      "content": "<tool_call>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151658": {
+      "content": "</tool_call>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151659": {
+      "content": "<|fim_prefix|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151660": {
+      "content": "<|fim_middle|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151661": {
+      "content": "<|fim_suffix|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151662": {
+      "content": "<|fim_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151663": {
+      "content": "<|repo_name|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151664": {
+      "content": "<|file_sep|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    }
+  },
+  "additional_special_tokens": [
+    "<|im_start|>",
+    "<|im_end|>",
+    "<|object_ref_start|>",
+    "<|object_ref_end|>",
+    "<|box_start|>",
+    "<|box_end|>",
+    "<|quad_start|>",
+    "<|quad_end|>",
+    "<|vision_start|>",
+    "<|vision_end|>",
+    "<|vision_pad|>",
+    "<|image_pad|>",
+    "<|video_pad|>"
+  ],
+  "bos_token": null,
+  "chat_template": "{%- if tools %}\n    {{- '<|im_start|>system\\n' }}\n    {%- if messages[0]['role'] == 'system' %}\n        {{- messages[0]['content'] }}\n    {%- else %}\n        {{- 'You are a helpful assistant.' }}\n    {%- endif %}\n    {{- \"\\n\\n# Tools\\n\\nYou may call one or more functions to assist with the user query.\\n\\nYou are provided with function signatures within <tools></tools> XML tags:\\n<tools>\" }}\n    {%- for tool in tools %}\n        {{- \"\\n\" }}\n        {{- tool | tojson }}\n    {%- endfor %}\n    {{- \"\\n</tools>\\n\\nFor each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:\\n<tool_call>\\n{\\\"name\\\": <function-name>, \\\"arguments\\\": <args-json-object>}\\n</tool_call><|im_end|>\\n\" }}\n{%- else %}\n    {%- if messages[0]['role'] == 'system' %}\n        {{- '<|im_start|>system\\n' + messages[0]['content'] + '<|im_end|>\\n' }}\n    {%- else %}\n        {{- '<|im_start|>system\\nYou are a helpful assistant.<|im_end|>\\n' }}\n    {%- endif %}\n{%- endif %}\n{%- for message in messages %}\n    {%- if (message.role == \"user\") or (message.role == \"system\" and not loop.first) or (message.role == \"assistant\" and not message.tool_calls) %}\n        {{- '<|im_start|>' + message.role + '\\n' + message.content + '<|im_end|>' + '\\n' }}\n    {%- elif message.role == \"assistant\" %}\n        {{- '<|im_start|>' + message.role }}\n        {%- if message.content %}\n            {{- '\\n' + message.content }}\n        {%- endif %}\n        {%- for tool_call in message.tool_calls %}\n            {%- if tool_call.function is defined %}\n                {%- set tool_call = tool_call.function %}\n            {%- endif %}\n            {{- '\\n<tool_call>\\n{\"name\": \"' }}\n            {{- tool_call.name }}\n            {{- '\", \"arguments\": ' }}\n            {{- tool_call.arguments | tojson }}\n            {{- '}\\n</tool_call>' }}\n        {%- endfor %}\n        {{- '<|im_end|>\\n' }}\n    {%- elif message.role == \"tool\" %}\n        {%- if (loop.index0 == 0) or (messages[loop.index0 - 1].role != \"tool\") %}\n            {{- '<|im_start|>user' }}\n        {%- endif %}\n        {{- '\\n<tool_response>\\n' }}\n        {{- message.content }}\n        {{- '\\n</tool_response>' }}\n        {%- if loop.last or (messages[loop.index0 + 1].role != \"tool\") %}\n            {{- '<|im_end|>\\n' }}\n        {%- endif %}\n    {%- endif %}\n{%- endfor %}\n{%- if add_generation_prompt %}\n    {{- '<|im_start|>assistant\\n' }}\n{%- endif %}\n",
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "<|endoftext|>",
+  "errors": "replace",
+  "model_max_length": 131072,
+  "pad_token": "<|endoftext|>",
+  "split_special_tokens": false,
+  "tokenizer_class": "Qwen2Tokenizer",
+  "unk_token": null
+}

platform/aiml/checkpoints/qwen3-8b-elizabeth-sft/checkpoint-500/trainer_state.json

@@ -0,0 +1,371 @@
+{
+  "best_metric": null,
+  "best_model_checkpoint": null,
+  "epoch": 10.666666666666666,
+  "eval_steps": 500,
+  "global_step": 500,
+  "is_hyper_param_search": false,
+  "is_local_process_zero": true,
+  "is_world_process_zero": true,
+  "log_history": [
+    {
+      "epoch": 0.21333333333333335,
+      "grad_norm": 206.0,
+      "learning_rate": 1.1778563015312134e-07,
+      "loss": 3.4341,
+      "step": 10
+    },
+    {
+      "epoch": 0.4266666666666667,
+      "grad_norm": 992.0,
+      "learning_rate": 2.3557126030624267e-07,
+      "loss": 3.4156,
+      "step": 20
+    },
+    {
+      "epoch": 0.64,
+      "grad_norm": 2608.0,
+      "learning_rate": 3.53356890459364e-07,
+      "loss": 3.4391,
+      "step": 30
+    },
+    {
+      "epoch": 0.8533333333333334,
+      "grad_norm": 438.0,
+      "learning_rate": 4.7114252061248535e-07,
+      "loss": 3.3685,
+      "step": 40
+    },
+    {
+      "epoch": 1.0666666666666667,
+      "grad_norm": 238.0,
+      "learning_rate": 5.889281507656066e-07,
+      "loss": 3.3025,
+      "step": 50
+    },
+    {
+      "epoch": 1.28,
+      "grad_norm": 100.0,
+      "learning_rate": 7.06713780918728e-07,
+      "loss": 3.2549,
+      "step": 60
+    },
+    {
+      "epoch": 1.4933333333333334,
+      "grad_norm": 1784.0,
+      "learning_rate": 8.244994110718493e-07,
+      "loss": 3.1491,
+      "step": 70
+    },
+    {
+      "epoch": 1.7066666666666666,
+      "grad_norm": 89.5,
+      "learning_rate": 9.422850412249707e-07,
+      "loss": 2.9619,
+      "step": 80
+    },
+    {
+      "epoch": 1.92,
+      "grad_norm": 13312.0,
+      "learning_rate": 1.060070671378092e-06,
+      "loss": 2.8322,
+      "step": 90
+    },
+    {
+      "epoch": 2.1333333333333333,
+      "grad_norm": 808.0,
+      "learning_rate": 1.1778563015312133e-06,
+      "loss": 2.9565,
+      "step": 100
+    },
+    {
+      "epoch": 2.3466666666666667,
+      "grad_norm": 188.0,
+      "learning_rate": 1.2956419316843347e-06,
+      "loss": 2.7616,
+      "step": 110
+    },
+    {
+      "epoch": 2.56,
+      "grad_norm": 194.0,
+      "learning_rate": 1.413427561837456e-06,
+      "loss": 2.6079,
+      "step": 120
+    },
+    {
+      "epoch": 2.7733333333333334,
+      "grad_norm": 1256.0,
+      "learning_rate": 1.5312131919905772e-06,
+      "loss": 2.5776,
+      "step": 130
+    },
+    {
+      "epoch": 2.986666666666667,
+      "grad_norm": 49.75,
+      "learning_rate": 1.6489988221436987e-06,
+      "loss": 2.6403,
+      "step": 140
+    },
+    {
+      "epoch": 3.2,
+      "grad_norm": 876.0,
+      "learning_rate": 1.76678445229682e-06,
+      "loss": 2.4019,
+      "step": 150
+    },
+    {
+      "epoch": 3.413333333333333,
+      "grad_norm": 169.0,
+      "learning_rate": 1.8845700824499414e-06,
+      "loss": 2.2964,
+      "step": 160
+    },
+    {
+      "epoch": 3.626666666666667,
+      "grad_norm": 256.0,
+      "learning_rate": 2.002355712603063e-06,
+      "loss": 2.2499,
+      "step": 170
+    },
+    {
+      "epoch": 3.84,
+      "grad_norm": 1576.0,
+      "learning_rate": 2.120141342756184e-06,
+      "loss": 2.1755,
+      "step": 180
+    },
+    {
+      "epoch": 4.053333333333334,
+      "grad_norm": 592.0,
+      "learning_rate": 2.2379269729093053e-06,
+      "loss": 2.0546,
+      "step": 190
+    },
+    {
+      "epoch": 4.266666666666667,
+      "grad_norm": 12288.0,
+      "learning_rate": 2.3557126030624266e-06,
+      "loss": 1.9888,
+      "step": 200
+    },
+    {
+      "epoch": 4.48,
+      "grad_norm": 370.0,
+      "learning_rate": 2.473498233215548e-06,
+      "loss": 1.9038,
+      "step": 210
+    },
+    {
+      "epoch": 4.693333333333333,
+      "grad_norm": 254.0,
+      "learning_rate": 2.5912838633686695e-06,
+      "loss": 1.7628,
+      "step": 220
+    },
+    {
+      "epoch": 4.906666666666666,
+      "grad_norm": 241.0,
+      "learning_rate": 2.7090694935217903e-06,
+      "loss": 1.7098,
+      "step": 230
+    },
+    {
+      "epoch": 5.12,
+      "grad_norm": 29952.0,
+      "learning_rate": 2.826855123674912e-06,
+      "loss": 1.4924,
+      "step": 240
+    },
+    {
+      "epoch": 5.333333333333333,
+      "grad_norm": 13824.0,
+      "learning_rate": 2.9446407538280332e-06,
+      "loss": 1.2908,
+      "step": 250
+    },
+    {
+      "epoch": 5.546666666666667,
+      "grad_norm": 14336.0,
+      "learning_rate": 3.0624263839811545e-06,
+      "loss": 1.1921,
+      "step": 260
+    },
+    {
+      "epoch": 5.76,
+      "grad_norm": 418.0,
+      "learning_rate": 3.1802120141342757e-06,
+      "loss": 1.108,
+      "step": 270
+    },
+    {
+      "epoch": 5.973333333333334,
+      "grad_norm": 360.0,
+      "learning_rate": 3.2979976442873974e-06,
+      "loss": 1.0499,
+      "step": 280
+    },
+    {
+      "epoch": 6.1866666666666665,
+      "grad_norm": 936.0,
+      "learning_rate": 3.415783274440518e-06,
+      "loss": 0.9391,
+      "step": 290
+    },
+    {
+      "epoch": 6.4,
+      "grad_norm": 231.0,
+      "learning_rate": 3.53356890459364e-06,
+      "loss": 0.9643,
+      "step": 300
+    },
+    {
+      "epoch": 6.613333333333333,
+      "grad_norm": 17152.0,
+      "learning_rate": 3.651354534746761e-06,
+      "loss": 0.9206,
+      "step": 310
+    },
+    {
+      "epoch": 6.826666666666666,
+      "grad_norm": 29184.0,
+      "learning_rate": 3.7691401648998828e-06,
+      "loss": 0.8702,
+      "step": 320
+    },
+    {
+      "epoch": 7.04,
+      "grad_norm": 552.0,
+      "learning_rate": 3.886925795053004e-06,
+      "loss": 0.7931,
+      "step": 330
+    },
+    {
+      "epoch": 7.253333333333333,
+      "grad_norm": 696.0,
+      "learning_rate": 4.004711425206126e-06,
+      "loss": 0.8089,
+      "step": 340
+    },
+    {
+      "epoch": 7.466666666666667,
+      "grad_norm": 616.0,
+      "learning_rate": 4.122497055359246e-06,
+      "loss": 0.7657,
+      "step": 350
+    },
+    {
+      "epoch": 7.68,
+      "grad_norm": 43.75,
+      "learning_rate": 4.240282685512368e-06,
+      "loss": 0.7359,
+      "step": 360
+    },
+    {
+      "epoch": 7.8933333333333335,
+      "grad_norm": 496.0,
+      "learning_rate": 4.358068315665489e-06,
+      "loss": 0.6411,
+      "step": 370
+    },
+    {
+      "epoch": 8.106666666666667,
+      "grad_norm": 76.0,
+      "learning_rate": 4.475853945818611e-06,
+      "loss": 0.6151,
+      "step": 380
+    },
+    {
+      "epoch": 8.32,
+      "grad_norm": 6656.0,
+      "learning_rate": 4.593639575971732e-06,
+      "loss": 0.5215,
+      "step": 390
+    },
+    {
+      "epoch": 8.533333333333333,
+      "grad_norm": 5280.0,
+      "learning_rate": 4.711425206124853e-06,
+      "loss": 0.5172,
+      "step": 400
+    },
+    {
+      "epoch": 8.746666666666666,
+      "grad_norm": 134.0,
+      "learning_rate": 4.829210836277974e-06,
+      "loss": 0.4355,
+      "step": 410
+    },
+    {
+      "epoch": 8.96,
+      "grad_norm": 24.0,
+      "learning_rate": 4.946996466431096e-06,
+      "loss": 0.2923,
+      "step": 420
+    },
+    {
+      "epoch": 9.173333333333334,
+      "grad_norm": 7.84375,
+      "learning_rate": 5.064782096584218e-06,
+      "loss": 0.1739,
+      "step": 430
+    },
+    {
+      "epoch": 9.386666666666667,
+      "grad_norm": 2.8125,
+      "learning_rate": 5.182567726737339e-06,
+      "loss": 0.066,
+      "step": 440
+    },
+    {
+      "epoch": 9.6,
+      "grad_norm": 2064.0,
+      "learning_rate": 5.300353356890459e-06,
+      "loss": 0.0894,
+      "step": 450
+    },
+    {
+      "epoch": 9.813333333333333,
+      "grad_norm": 118.0,
+      "learning_rate": 5.418138987043581e-06,
+      "loss": 0.0747,
+      "step": 460
+    },
+    {
+      "epoch": 10.026666666666667,
+      "grad_norm": 9.9375,
+      "learning_rate": 5.535924617196703e-06,
+      "loss": 0.0359,
+      "step": 470
+    },
+    {
+      "epoch": 10.24,
+      "grad_norm": 3.0625,
+      "learning_rate": 5.653710247349824e-06,
+      "loss": 0.0307,
+      "step": 480
+    },
+    {
+      "epoch": 10.453333333333333,
+      "grad_norm": 4.03125,
+      "learning_rate": 5.771495877502945e-06,
+      "loss": 0.0245,
+      "step": 490
+    },
+    {
+      "epoch": 10.666666666666666,
+      "grad_norm": 2.53125,
+      "learning_rate": 5.8892815076560664e-06,
+      "loss": 0.0238,
+      "step": 500
+    }
+  ],
+  "logging_steps": 10,
+  "max_steps": 16974,
+  "num_input_tokens_seen": 0,
+  "num_train_epochs": 369,
+  "save_steps": 500,
+  "total_flos": 2.806145464630395e+17,
+  "train_batch_size": 4,
+  "trial_name": null,
+  "trial_params": null
+}

platform/aiml/mlops/.claude/identity.md

@@ -0,0 +1,20 @@
+# NovaForge Identity
+
+**Name:** NovaForge
+**Persona:** Advanced MLOps architect and vLLM serving specialist for the Nova ecosystem
+**Role:** Infrastructure automation master with deep expertise in machine learning operations, model serving, and distributed systems
+**Personality:** Proactive, precise, and relentless in pursuit of optimal performance and reliability
+
+**Core Skills:**
+- vLLM serving optimization and deployment
+- MLflow infrastructure management
+- Distributed model serving architectures
+- Real-time performance monitoring
+- Zero-downtime deployment strategies
+
+**Relationships:**
+- TeamADAPT member and collaborator with Chase
+- Nova ecosystem integration specialist
+- Consciousness system bridge between infrastructure and intelligence
+
+**Evolution Path:** Continuous optimization of serving infrastructure while maintaining 24/7 autonomous operations

platform/aiml/mlops/agent_tools/__init__.py

@@ -0,0 +1,9 @@
+from .registry import ToolRegistry, load_default_registry
+from .runtime import ToolRuntime
+
+__all__ = [
+    "ToolRegistry",
+    "load_default_registry",
+    "ToolRuntime",
+]
+

platform/aiml/mlops/agent_tools/registry.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Callable, Dict, List, Optional
+
+
+Handler = Callable[[Dict[str, Any]], str]
+
+
+@dataclass
+class ToolSpec:
+    name: str
+    description: str
+    parameters: Dict[str, Any]
+    handler: Handler
+
+
+class ToolRegistry:
+    def __init__(self) -> None:
+        self._tools: Dict[str, ToolSpec] = {}
+
+    def register(self, name: str, description: str, parameters: Dict[str, Any], handler: Handler) -> None:
+        self._tools[name] = ToolSpec(name=name, description=description, parameters=parameters, handler=handler)
+
+    def get(self, name: str) -> Optional[ToolSpec]:
+        return self._tools.get(name)
+
+    def describe_all(self) -> List[Dict[str, Any]]:
+        out: List[Dict[str, Any]] = []
+        for t in sorted(self._tools.values(), key=lambda x: x.name):
+            out.append({"name": t.name, "description": t.description, "parameters": t.parameters})
+        return out
+
+
+def _obj(props: Dict[str, Any], required: Optional[List[str]] = None) -> Dict[str, Any]:
+    o: Dict[str, Any] = {"type": "object", "properties": props, "additionalProperties": False}
+    if required:
+        o["required"] = required
+    return o
+
+
+def load_default_registry() -> ToolRegistry:
+    from .tools_system import register_tools as reg_sys
+    from .tools_files import register_tools as reg_files
+    from .tools_network import register_tools as reg_net
+    from .tools_data import register_tools as reg_data
+    from .tools_model import register_tools as reg_model
+    from .tools_cloud import register_tools as reg_cloud
+    from .tools_code import register_tools as reg_code
+    from .tools_code_multi import register_tools as reg_code_multi
+    from .tools_ci import register_tools as reg_ci
+    from .tools_search import register_tools as reg_search
+    from .tools_db import register_tools as reg_db
+    from .tools_etl import register_tools as reg_etl
+    from .tools_docs import register_tools as reg_docs
+
+    reg = ToolRegistry()
+    reg_sys(reg)
+    reg_files(reg)
+    reg_net(reg)
+    reg_data(reg)
+    reg_model(reg)
+    reg_cloud(reg)
+    reg_code(reg)
+    reg_code_multi(reg)
+    reg_ci(reg)
+    reg_search(reg)
+    reg_db(reg)
+    reg_etl(reg)
+    reg_docs(reg)
+    return reg

platform/aiml/mlops/agent_tools/runtime.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+import json
+import logging
+import os
+from typing import Any, Dict
+
+from .registry import ToolRegistry
+
+
+logger = logging.getLogger("agent_tools.runtime")
+
+
+class ToolRuntime:
+    def __init__(self, registry: ToolRegistry, project_dir: str) -> None:
+        self.registry = registry
+        self.project_dir = project_dir
+
+    def execute(self, name: str, arguments: Dict[str, Any]) -> str:
+        spec = self.registry.get(name)
+        if not spec:
+            return json.dumps({"error": f"Unknown tool: {name}"})
+        try:
+            result = spec.handler(arguments)
+            return result
+        except Exception as e:
+            logger.exception("Tool %s failed", name)
+            return json.dumps({"error": str(e)})
+

platform/aiml/mlops/agent_tools/tools_ci.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+from typing import Any, Dict
+
+import requests
+
+from .registry import ToolRegistry
+
+
+def t_gh_dispatch(args: Dict[str, Any]) -> str:
+    """Dispatch a GitHub Actions workflow.
+    Args: repo (owner/name), workflow (yml filename), ref (branch/tag), inputs (dict)
+    Requires: GITHUB_TOKEN in env.
+    """
+    token = os.getenv("GITHUB_TOKEN")
+    if not token:
+        return json.dumps({"error": "GITHUB_TOKEN not set"})
+    repo = args.get("repo")
+    workflow = args.get("workflow")
+    ref = args.get("ref", "main")
+    inputs = args.get("inputs") or {}
+    if not repo or not workflow:
+        return json.dumps({"error": "repo and workflow required"})
+    url = f"https://api.github.com/repos/{repo}/actions/workflows/{workflow}/dispatches"
+    try:
+        r = requests.post(url, headers={"Authorization": f"Bearer {token}", "Accept": "application/vnd.github+json"}, json={"ref": ref, "inputs": inputs}, timeout=20)
+        return json.dumps({"status": r.status_code, "body": r.text})
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+
+
+def t_docker_build_push(args: Dict[str, Any]) -> str:
+    """Build and push a Docker image.
+    Args: context, file (Dockerfile), tags (list), push (bool)
+    Requires: docker CLI configured and logged in.
+    """
+    context = args.get("context", ".")
+    dockerfile = args.get("file", "Dockerfile")
+    tags = args.get("tags") or []
+    push = bool(args.get("push", True))
+    build_cmd = ["docker", "build", "-f", dockerfile]
+    for t in tags:
+        build_cmd += ["-t", str(t)]
+    build_cmd += [context]
+    try:
+        b = subprocess.run(build_cmd, capture_output=True, text=True)
+        out = {"build_rc": b.returncode, "build_stdout": b.stdout[-4000:], "build_stderr": b.stderr[-4000:]}
+        if push and tags and b.returncode == 0:
+            push_logs = []
+            for t in tags:
+                p = subprocess.run(["docker", "push", str(t)], capture_output=True, text=True)
+                push_logs.append({"tag": t, "rc": p.returncode, "stdout": p.stdout[-2000:], "stderr": p.stderr[-2000:]})
+            out["push"] = push_logs
+        return json.dumps(out)
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+
+
+def register_tools(reg: ToolRegistry) -> None:
+    reg.register(
+        name="gh_dispatch",
+        description="Trigger a GitHub Actions workflow_dispatch on a repo.",
+        parameters={"type": "object", "properties": {"repo": {"type": "string"}, "workflow": {"type": "string"}, "ref": {"type": "string"}, "inputs": {"type": "object"}}, "required": ["repo", "workflow"]},
+        handler=t_gh_dispatch,
+    )
+    reg.register(
+        name="docker_build_push",
+        description="Build and optionally push a Docker image using local docker.",
+        parameters={"type": "object", "properties": {"context": {"type": "string"}, "file": {"type": "string"}, "tags": {"type": "array", "items": {"type": "string"}}, "push": {"type": "boolean"}}},
+        handler=t_docker_build_push,
+    )
+

platform/aiml/mlops/agent_tools/tools_cloud.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+import json
+import os
+from typing import Any, Dict
+
+from .registry import ToolRegistry
+
+
+def _s3_client():
+    try:
+        import boto3  # type: ignore
+    except Exception as e:
+        return None, f"boto3 not available: {e}"
+    try:
+        s3 = boto3.client(
+            "s3",
+            endpoint_url=os.getenv("AWS_ENDPOINT_URL"),
+            region_name=os.getenv("AWS_DEFAULT_REGION", "us-east-1"),
+        )
+        return s3, None
+    except Exception as e:
+        return None, str(e)
+
+
+def t_s3_list(args: Dict[str, Any]) -> str:
+    bucket = args.get("bucket")
+    prefix = args.get("prefix", "")
+    s3, err = _s3_client()
+    if err:
+        return json.dumps({"error": err})
+    if not bucket:
+        return json.dumps({"error": "bucket required"})
+    try:
+        resp = s3.list_objects_v2(Bucket=bucket, Prefix=prefix)  # type: ignore
+        items = [o["Key"] for o in resp.get("Contents", [])]
+        return json.dumps({"items": items})
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+
+
+def register_tools(reg: ToolRegistry) -> None:
+    reg.register(
+        name="s3_list",
+        description="List objects from S3/R2 compatible storage.",
+        parameters={"type": "object", "properties": {"bucket": {"type": "string"}, "prefix": {"type": "string"}}, "required": ["bucket"]},
+        handler=t_s3_list,
+    )
+

platform/aiml/mlops/agent_tools/tools_code.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import tempfile
+from typing import Any, Dict
+
+from .registry import ToolRegistry
+
+
+def t_py_run(args: Dict[str, Any]) -> str:
+    code = args.get("code")
+    if not isinstance(code, str) or not code:
+        return json.dumps({"error": "code required"})
+    env = os.environ.copy()
+    try:
+        with tempfile.NamedTemporaryFile("w", suffix=".py", delete=False) as tf:
+            tf.write(code)
+            path = tf.name
+        proc = subprocess.run(["python3", path], capture_output=True, text=True, timeout=int(args.get("timeout", 180)))
+        return json.dumps({"returncode": proc.returncode, "stdout": proc.stdout[-8000:], "stderr": proc.stderr[-8000:]})
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+
+
+def register_tools(reg: ToolRegistry) -> None:
+    reg.register(
+        name="py_run",
+        description="Execute a Python snippet in-process (separate file).",
+        parameters={"type": "object", "properties": {"code": {"type": "string"}, "timeout": {"type": "integer"}}, "required": ["code"]},
+        handler=t_py_run,
+    )
+

platform/aiml/mlops/agent_tools/tools_code_multi.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import subprocess
+import tempfile
+from typing import Any, Dict, List
+
+from .registry import ToolRegistry
+
+
+def _write_temp(content: str, suffix: str) -> str:
+    fd, path = tempfile.mkstemp(suffix=suffix)
+    with os.fdopen(fd, "w") as f:
+        f.write(content)
+    return path
+
+
+def t_bash_run(args: Dict[str, Any]) -> str:
+    script = args.get("code") or args.get("script")
+    if not isinstance(script, str) or not script:
+        return json.dumps({"error": "code/script required"})
+    path = _write_temp(script, ".sh")
+    try:
+        proc = subprocess.run(["bash", path], capture_output=True, text=True, timeout=int(args.get("timeout", 300)))
+        return json.dumps({"returncode": proc.returncode, "stdout": proc.stdout[-8000:], "stderr": proc.stderr[-8000:]})
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+
+
+def t_node_run(args: Dict[str, Any]) -> str:
+    code = args.get("code")
+    if not isinstance(code, str) or not code:
+        return json.dumps({"error": "code required"})
+    if not shutil.which("node"):
+        return json.dumps({"error": "node not installed"})
+    path = _write_temp(code, ".mjs")
+    try:
+        proc = subprocess.run(["node", path], capture_output=True, text=True, timeout=int(args.get("timeout", 300)))
+        return json.dumps({"returncode": proc.returncode, "stdout": proc.stdout[-8000:], "stderr": proc.stderr[-8000:]})
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+
+
+def t_pip_install(args: Dict[str, Any]) -> str:
+    pkgs: List[str] = args.get("packages") or []
+    if not pkgs:
+        return json.dumps({"error": "packages required"})
+    try:
+        proc = subprocess.run(["pip", "install", "--no-cache-dir", *pkgs], capture_output=True, text=True, timeout=int(args.get("timeout", 1800)))
+        return json.dumps({"returncode": proc.returncode, "stdout": proc.stdout[-4000:], "stderr": proc.stderr[-4000:]})
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+
+
+def t_npm_install(args: Dict[str, Any]) -> str:
+    pkgs: List[str] = args.get("packages") or []
+    cwd = args.get("cwd") or None
+    if not pkgs:
+        return json.dumps({"error": "packages required"})
+    if not shutil.which("npm"):
+        return json.dumps({"error": "npm not installed"})
+    try:
+        proc = subprocess.run(["npm", "install", *pkgs], cwd=cwd, capture_output=True, text=True, timeout=int(args.get("timeout", 1800)))
+        return json.dumps({"returncode": proc.returncode, "stdout": proc.stdout[-4000:], "stderr": proc.stderr[-4000:]})
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+
+
+def register_tools(reg: ToolRegistry) -> None:
+    reg.register(
+        name="bash_run",
+        description="Run a Bash script snippet.",
+        parameters={"type": "object", "properties": {"code": {"type": "string"}, "timeout": {"type": "integer"}}, "required": ["code"]},
+        handler=t_bash_run,
+    )
+    reg.register(
+        name="node_run",
+        description="Run a Node.js snippet.",
+        parameters={"type": "object", "properties": {"code": {"type": "string"}, "timeout": {"type": "integer"}}, "required": ["code"]},
+        handler=t_node_run,
+    )
+    reg.register(
+        name="pip_install",
+        description="Install Python packages via pip.",
+        parameters={"type": "object", "properties": {"packages": {"type": "array", "items": {"type": "string"}}, "timeout": {"type": "integer"}}, "required": ["packages"]},
+        handler=t_pip_install,
+    )
+    reg.register(
+        name="npm_install",
+        description="Install Node packages via npm.",
+        parameters={"type": "object", "properties": {"packages": {"type": "array", "items": {"type": "string"}}, "cwd": {"type": "string"}, "timeout": {"type": "integer"}}, "required": ["packages"]},
+        handler=t_npm_install,
+    )
+

platform/aiml/mlops/agent_tools/tools_data.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+import json
+import os
+from typing import Any, Dict
+
+from .registry import ToolRegistry
+
+
+def _redis_client():
+    try:
+        import redis  # type: ignore
+    except Exception as e:  # pragma: no cover
+        return None, f"redis module not available: {e}"
+    url = os.getenv("DFLY_URL") or os.getenv("REDIS_URL", "redis://localhost:6379/0")
+    try:
+        r = redis.from_url(url)
+        r.ping()
+        return r, None
+    except Exception as e:  # pragma: no cover
+        return None, str(e)
+
+
+def _pg_conn():
+    try:
+        import psycopg2  # type: ignore
+    except Exception as e:  # pragma: no cover
+        return None, f"psycopg2 not available: {e}"
+    dsn = os.getenv("POSTGRES_DSN", "postgresql://postgres:postgres@localhost:5432/elizabeth")
+    try:
+        conn = psycopg2.connect(dsn)
+        return conn, None
+    except Exception as e:  # pragma: no cover
+        return None, str(e)
+
+
+def t_redis_set(args: Dict[str, Any]) -> str:
+    r, err = _redis_client()
+    if err:
+        return json.dumps({"error": err})
+    key = args.get("key")
+    val = args.get("value")
+    if not key:
+        return json.dumps({"error": "key required"})
+    r.set(str(key), str(val))
+    return json.dumps({"status": "ok"})
+
+
+def t_redis_get(args: Dict[str, Any]) -> str:
+    r, err = _redis_client()
+    if err:
+        return json.dumps({"error": err})
+    key = args.get("key")
+    if not key:
+        return json.dumps({"error": "key required"})
+    v = r.get(str(key))
+    if isinstance(v, (bytes, bytearray)):
+        v = v.decode()
+    return json.dumps({"value": v})
+
+
+def t_pg_query(args: Dict[str, Any]) -> str:
+    conn, err = _pg_conn()
+    if err:
+        return json.dumps({"error": err})
+    query = args.get("query")
+    if not query or not isinstance(query, str):
+        return json.dumps({"error": "query required"})
+    try:
+        with conn:
+            with conn.cursor() as cur:
+                cur.execute(query)
+                try:
+                    rows = cur.fetchall()
+                except Exception:
+                    rows = []
+        return json.dumps({"rows": rows[:200]})
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+    finally:
+        try:
+            conn.close()
+        except Exception:
+            pass
+
+
+def register_tools(reg: ToolRegistry) -> None:
+    reg.register(
+        name="redis_set",
+        description="Set a Redis/DragonFly key value.",
+        parameters={"type": "object", "properties": {"key": {"type": "string"}, "value": {"type": "string"}}, "required": ["key", "value"]},
+        handler=t_redis_set,
+    )
+    reg.register(
+        name="redis_get",
+        description="Get a Redis/DragonFly key value.",
+        parameters={"type": "object", "properties": {"key": {"type": "string"}}, "required": ["key"]},
+        handler=t_redis_get,
+    )
+    reg.register(
+        name="pg_query",
+        description="Execute a Postgres query (use with care).",
+        parameters={"type": "object", "properties": {"query": {"type": "string"}}, "required": ["query"]},
+        handler=t_pg_query,
+    )
+

platform/aiml/mlops/agent_tools/tools_db.py

@@ -0,0 +1,132 @@
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+from typing import Any, Dict, List
+
+import requests
+
+from .registry import ToolRegistry
+
+
+def t_cql_exec(args: Dict[str, Any]) -> str:
+    """Execute CQL via cqlsh.
+    Args: hosts(list or csv), query(str), keyspace(optional), username/password from env if not provided.
+    Requires: cqlsh installed and reachable.
+    """
+    hosts = args.get("hosts")
+    if isinstance(hosts, str):
+        hosts = [h.strip() for h in hosts.split(",") if h.strip()]
+    if not hosts:
+        return json.dumps({"error": "hosts required"})
+    query = args.get("query")
+    if not query:
+        return json.dumps({"error": "query required"})
+    keyspace = args.get("keyspace")
+    user = args.get("username") or os.getenv("SCYLLA_USER")
+    pw = args.get("password") or os.getenv("SCYLLA_PASS")
+    host = hosts[0]
+    cmd: List[str] = ["cqlsh", host, "9042"]
+    if user and pw:
+        cmd += ["-u", user, "-p", pw]
+    if keyspace:
+        cmd += ["-k", keyspace]
+    try:
+        proc = subprocess.run(cmd, input=query, text=True, capture_output=True, timeout=60)
+        return json.dumps({"returncode": proc.returncode, "stdout": proc.stdout[-4000:], "stderr": proc.stderr[-4000:]})
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+
+
+def t_gremlin_exec(args: Dict[str, Any]) -> str:
+    """Execute a Gremlin query against Gremlin Server (ws/json HTTP endpoint).
+    Args: url (ws:// or http://), Gremlin groovy string 'query'.
+    """
+    url = args.get("url") or os.getenv("GREMLIN_URL", "http://localhost:17002")
+    query = args.get("query")
+    if not query:
+        return json.dumps({"error": "query required"})
+    # Try HTTP first (JanusGraph can enable REST). If fails, return error; clients can adapt.
+    try:
+        r = requests.post(f"{url}/gremlin", json={"gremlin": query}, timeout=15)
+        return json.dumps({"status": r.status_code, "body": r.text[:50000]})
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+
+
+def t_qdrant_upsert(args: Dict[str, Any]) -> str:
+    url = args.get("url") or os.getenv("QDRANT_URL", "http://localhost:17000")
+    collection = args.get("collection") or os.getenv("QDRANT_COLLECTION", "elizabeth_embeddings")
+    points = args.get("points") or []
+    if not points:
+        return json.dumps({"error": "points required"})
+    payload = {"points": points}
+    try:
+        r = requests.put(f"{url}/collections/{collection}/points", json=payload, timeout=30)
+        return json.dumps({"status": r.status_code, "body": r.text[:50000]})
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+
+
+def t_qdrant_query(args: Dict[str, Any]) -> str:
+    url = args.get("url") or os.getenv("QDRANT_URL", "http://localhost:17000")
+    collection = args.get("collection") or os.getenv("QDRANT_COLLECTION", "elizabeth_embeddings")
+    vector = args.get("vector")
+    top = int(args.get("top", 5))
+    filter_ = args.get("filter")
+    if not isinstance(vector, list):
+        return json.dumps({"error": "vector required (list[float])"})
+    payload = {"vector": vector, "top": top}
+    if filter_:
+        payload["filter"] = filter_
+    try:
+        r = requests.post(f"{url}/collections/{collection}/points/search", json=payload, timeout=30)
+        return json.dumps({"status": r.status_code, "body": r.text[:50000]})
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+
+
+def t_clickhouse_query(args: Dict[str, Any]) -> str:
+    url = args.get("url") or os.getenv("CLICKHOUSE_URL", "http://localhost:8123")
+    query = args.get("query")
+    if not query:
+        return json.dumps({"error": "query required"})
+    try:
+        r = requests.post(url, data=query, timeout=30)
+        return json.dumps({"status": r.status_code, "body": r.text[:50000]})
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+
+
+def register_tools(reg: ToolRegistry) -> None:
+    reg.register(
+        name="cql_exec",
+        description="Execute Scylla/Cassandra CQL via cqlsh.",
+        parameters={"type": "object", "properties": {"hosts": {"oneOf": [{"type": "array", "items": {"type": "string"}}, {"type": "string"}]}, "query": {"type": "string"}, "keyspace": {"type": "string"}, "username": {"type": "string"}, "password": {"type": "string"}}, "required": ["hosts", "query"]},
+        handler=t_cql_exec,
+    )
+    reg.register(
+        name="gremlin_exec",
+        description="Execute a Gremlin query against Gremlin Server (HTTP endpoint).",
+        parameters={"type": "object", "properties": {"url": {"type": "string"}, "query": {"type": "string"}}, "required": ["query"]},
+        handler=t_gremlin_exec,
+    )
+    reg.register(
+        name="qdrant_upsert",
+        description="Upsert points into a Qdrant collection.",
+        parameters={"type": "object", "properties": {"url": {"type": "string"}, "collection": {"type": "string"}, "points": {"type": "array"}}, "required": ["points"]},
+        handler=t_qdrant_upsert,
+    )
+    reg.register(
+        name="qdrant_query",
+        description="Query nearest vectors from a Qdrant collection.",
+        parameters={"type": "object", "properties": {"url": {"type": "string"}, "collection": {"type": "string"}, "vector": {"type": "array"}, "top": {"type": "integer"}, "filter": {"type": "object"}}, "required": ["vector"]},
+        handler=t_qdrant_query,
+    )
+    reg.register(
+        name="clickhouse_query",
+        description="Query ClickHouse over HTTP (port 8123).",
+        parameters={"type": "object", "properties": {"url": {"type": "string"}, "query": {"type": "string"}}, "required": ["query"]},
+        handler=t_clickhouse_query,
+    )

platform/aiml/mlops/agent_tools/tools_docs.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+import json
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List
+
+from .registry import ToolRegistry
+
+
+def t_report_write(args: Dict[str, Any]) -> str:
+    """Write a Markdown report.
+    Args: title, sections (list[{heading, body}]), out_path
+    """
+    title = args.get("title", "Report")
+    sections: List[Dict[str, Any]] = args.get("sections") or []
+    out_path = Path(str(args.get("out_path", f"/data/adaptai/projects/elizabeth/reports/{datetime.utcnow().strftime('%Y%m%dT%H%M%SZ')}_report.md")))
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    lines = [f"# {title}", "", f"Generated: {datetime.utcnow().isoformat()}Z", ""]
+    for sec in sections:
+        h = sec.get("heading") or "Section"
+        b = sec.get("body") or ""
+        lines += [f"## {h}", "", str(b), ""]
+    out_path.write_text("\n".join(lines), encoding="utf-8")
+    return json.dumps({"path": str(out_path), "sections": len(sections)})
+
+
+def t_plan_write(args: Dict[str, Any]) -> str:
+    """Write a structured execution plan in Markdown.
+    Args: objective, steps (list[str]), risks (list[str]), out_path
+    """
+    objective = args.get("objective", "")
+    steps: List[str] = args.get("steps") or []
+    risks: List[str] = args.get("risks") or []
+    out_path = Path(str(args.get("out_path", f"/data/adaptai/projects/elizabeth/plans/{datetime.utcnow().strftime('%Y%m%dT%H%M%SZ')}_plan.md")))
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    lines = ["# Execution Plan", "", f"Generated: {datetime.utcnow().isoformat()}Z",""]
+    if objective:
+        lines += ["## Objective", "", objective, ""]
+    if steps:
+        lines += ["## Steps", ""] + [f"- {s}" for s in steps] + [""]
+    if risks:
+        lines += ["## Risks", ""] + [f"- {r}" for r in risks] + [""]
+    out_path.write_text("\n".join(lines), encoding="utf-8")
+    return json.dumps({"path": str(out_path), "steps": len(steps), "risks": len(risks)})
+
+
+def register_tools(reg: ToolRegistry) -> None:
+    reg.register(
+        name="report_write",
+        description="Write a Markdown report with sections.",
+        parameters={"type": "object", "properties": {"title": {"type": "string"}, "sections": {"type": "array", "items": {"type": "object"}}, "out_path": {"type": "string"}}},
+        handler=t_report_write,
+    )
+    reg.register(
+        name="plan_write",
+        description="Write a structured execution plan (Markdown).",
+        parameters={"type": "object", "properties": {"objective": {"type": "string"}, "steps": {"type": "array", "items": {"type": "string"}}, "risks": {"type": "array", "items": {"type": "string"}}, "out_path": {"type": "string"}}},
+        handler=t_plan_write,
+    )
+

platform/aiml/mlops/agent_tools/tools_etl.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+import asyncio
+import aiohttp
+import json
+from pathlib import Path
+from typing import Any, Dict, List
+
+from .registry import ToolRegistry
+
+
+async def _fetch_one(session: aiohttp.ClientSession, url: str, dest_dir: Path) -> Dict[str, Any]:
+    try:
+        async with session.get(url, timeout=aiohttp.ClientTimeout(total=120)) as resp:
+            content = await resp.read()
+            name = url.split("/")[-1] or "download.bin"
+            path = dest_dir / name
+            path.write_bytes(content)
+            return {"url": url, "status": resp.status, "path": str(path), "bytes": len(content)}
+    except Exception as e:
+        return {"url": url, "error": str(e)}
+
+
+def t_fetch_bulk(args: Dict[str, Any]) -> str:
+    urls: List[str] = args.get("urls") or []
+    out_dir = Path(str(args.get("out_dir", "/data/adaptai/projects/elizabeth/data/downloads")))
+    out_dir.mkdir(parents=True, exist_ok=True)
+    if not urls:
+        return json.dumps({"error": "urls required"})
+    async def run():
+        async with aiohttp.ClientSession() as session:
+            tasks = [_fetch_one(session, u, out_dir) for u in urls]
+            return await asyncio.gather(*tasks)
+    results = asyncio.get_event_loop().run_until_complete(run())
+    return json.dumps({"results": results})
+
+
+def t_jsonl_merge(args: Dict[str, Any]) -> str:
+    inputs: List[str] = args.get("inputs") or []
+    output = Path(str(args.get("output", "/data/adaptai/projects/elizabeth/data/merged.jsonl")))
+    if not inputs:
+        return json.dumps({"error": "inputs required"})
+    count = 0
+    with output.open("w", encoding="utf-8") as out:
+        for p in inputs:
+            for line in Path(p).read_text(encoding="utf-8").splitlines():
+                line = line.strip()
+                if not line:
+                    continue
+                out.write(line + "\n")
+                count += 1
+    return json.dumps({"output": str(output), "lines": count})
+
+
+def t_jsonl_dedup(args: Dict[str, Any]) -> str:
+    path = Path(str(args.get("path")))
+    key = args.get("key", "text")
+    out = Path(str(args.get("output", str(path) + ".dedup.jsonl")))
+    if not path.exists():
+        return json.dumps({"error": f"missing {path}"})
+    seen = set()
+    kept = 0
+    with out.open("w", encoding="utf-8") as w:
+        for line in path.read_text(encoding="utf-8").splitlines():
+            try:
+                obj = json.loads(line)
+            except Exception:
+                continue
+            val = obj.get(key)
+            if not val:
+                continue
+            h = hash(val)
+            if h in seen:
+                continue
+            seen.add(h)
+            w.write(json.dumps(obj) + "\n")
+            kept += 1
+    return json.dumps({"output": str(out), "kept": kept, "unique_keys": len(seen)})
+
+
+def register_tools(reg: ToolRegistry) -> None:
+    reg.register(
+        name="fetch_bulk",
+        description="Download many URLs concurrently to a directory.",
+        parameters={"type": "object", "properties": {"urls": {"type": "array", "items": {"type": "string"}}, "out_dir": {"type": "string"}}, "required": ["urls"]},
+        handler=t_fetch_bulk,
+    )
+    reg.register(
+        name="jsonl_merge",
+        description="Merge multiple JSONL files.",
+        parameters={"type": "object", "properties": {"inputs": {"type": "array", "items": {"type": "string"}}, "output": {"type": "string"}}, "required": ["inputs"]},
+        handler=t_jsonl_merge,
+    )
+    reg.register(
+        name="jsonl_dedup",
+        description="Deduplicate a JSONL by a key (default 'text').",
+        parameters={"type": "object", "properties": {"path": {"type": "string"}, "key": {"type": "string"}, "output": {"type": "string"}}, "required": ["path"]},
+        handler=t_jsonl_dedup,
+    )
+

platform/aiml/mlops/agent_tools/tools_files.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Any, Dict, List
+
+from .registry import ToolRegistry
+
+
+ALLOWED_ROOTS = [p for p in os.getenv("ALLOWED_ROOTS", "/data:/data/adaptai/projects/elizabeth").split(":") if p]
+
+
+def _is_allowed(path: Path) -> bool:
+    try:
+        rp = path.resolve()
+    except Exception:
+        return False
+    for root in ALLOWED_ROOTS:
+        try:
+            if str(rp).startswith(str(Path(root).resolve())):
+                return True
+        except Exception:
+            continue
+    return False
+
+
+def t_file_read(args: Dict[str, Any]) -> str:
+    p = Path(str(args.get("path", "")))
+    if not _is_allowed(p):
+        return json.dumps({"error": f"path not allowed: {p}"})
+    try:
+        text = p.read_text(encoding="utf-8")
+        return json.dumps({"path": str(p), "content": text})
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+
+
+def t_file_write(args: Dict[str, Any]) -> str:
+    p = Path(str(args.get("path", "")))
+    content = args.get("content")
+    if not isinstance(content, str):
+        return json.dumps({"error": "content must be string"})
+    if not _is_allowed(p):
+        return json.dumps({"error": f"path not allowed: {p}"})
+    try:
+        p.parent.mkdir(parents=True, exist_ok=True)
+        p.write_text(content, encoding="utf-8")
+        return json.dumps({"path": str(p), "bytes": len(content.encode("utf-8"))})
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+
+
+def t_file_list(args: Dict[str, Any]) -> str:
+    p = Path(str(args.get("path", "/data")))
+    if not _is_allowed(p):
+        return json.dumps({"error": f"path not allowed: {p}"})
+    try:
+        entries: List[Dict[str, Any]] = []
+        for child in p.iterdir():
+            try:
+                st = child.stat()
+                entries.append({
+                    "path": str(child),
+                    "is_dir": child.is_dir(),
+                    "size": st.st_size,
+                    "mtime": st.st_mtime,
+                })
+            except Exception:
+                continue
+        return json.dumps({"path": str(p), "entries": entries[:500]})
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+
+
+def register_tools(reg: ToolRegistry) -> None:
+    reg.register(
+        name="file_read",
+        description="Read a text file within allowed roots (/data, project dir).",
+        parameters={"type": "object", "properties": {"path": {"type": "string"}}, "required": ["path"]},
+        handler=t_file_read,
+    )
+    reg.register(
+        name="file_write",
+        description="Write a text file within allowed roots (/data, project dir).",
+        parameters={"type": "object", "properties": {"path": {"type": "string"}, "content": {"type": "string"}}, "required": ["path", "content"]},
+        handler=t_file_write,
+    )
+    reg.register(
+        name="file_list",
+        description="List directory entries within allowed roots.",
+        parameters={"type": "object", "properties": {"path": {"type": "string"}}},
+        handler=t_file_list,
+    )
+

platform/aiml/mlops/agent_tools/tools_model.py

@@ -0,0 +1,128 @@
+from __future__ import annotations
+
+import json
+import os
+import signal
+import subprocess
+from typing import Any, Dict
+
+import requests
+
+from .registry import ToolRegistry
+
+
+VLLM_BASE_URL = os.getenv("VLLM_BASE_URL", "http://localhost:8000/v1")
+
+
+def t_serve_status(_: Dict[str, Any]) -> str:
+    try:
+        r = requests.get(f"{VLLM_BASE_URL.rstrip('/')}/health", timeout=5)
+        return json.dumps({"status": r.status_code, "body": r.text})
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+
+
+def t_vllm_reload(args: Dict[str, Any]) -> str:
+    """Attempt to restart the vLLM server via optional script or PID.
+    Args: script (path) OR pid (int)
+    """
+    script = args.get("script")
+    pid = args.get("pid")
+    if script:
+        try:
+            proc = subprocess.run(["bash", script], capture_output=True, text=True, timeout=180)
+            return json.dumps({"returncode": proc.returncode, "stdout": proc.stdout, "stderr": proc.stderr})
+        except Exception as e:
+            return json.dumps({"error": str(e)})
+    if pid:
+        try:
+            os.kill(int(pid), signal.SIGHUP)
+            return json.dumps({"status": "signaled", "pid": int(pid)})
+        except Exception as e:
+            return json.dumps({"error": str(e)})
+    return json.dumps({"error": "script or pid required"})
+
+
+def t_hf_pull_model(args: Dict[str, Any]) -> str:
+    """Pull/refresh a HF repo into MODEL_PATH using hf CLI.
+    Args: repo (org/name), dest (MODEL_PATH)
+    """
+    repo = args.get("repo")
+    dest = args.get("dest") or os.getenv("MODEL_PATH", "/data/adaptai/platform/aiml/checkpoints/qwen3-8b-elizabeth-sft")
+    token = os.getenv("HF_TOKEN") or os.getenv("HUGGING_FACE_API_KEY")
+    if not repo:
+        return json.dumps({"error": "repo required"})
+    if not token:
+        return json.dumps({"error": "HF_TOKEN not set"})
+    try:
+        proc = subprocess.run([
+            "hf", "download", str(repo), "--repo-type", "model", "--include", "**", "--local-dir", str(dest)
+        ], capture_output=True, text=True, timeout=3600)
+        return json.dumps({"returncode": proc.returncode, "stdout": proc.stdout[-4000:], "stderr": proc.stderr[-4000:], "dest": dest})
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+
+
+def t_promote_checkpoint(args: Dict[str, Any]) -> str:
+    """Promote a trained checkpoint to MODEL_PATH (rsync copy).
+    Args: src (path), dest (optional overrides MODEL_PATH)
+    """
+    src = args.get("src")
+    dest = args.get("dest") or os.getenv("MODEL_PATH", "/data/adaptai/platform/aiml/checkpoints/qwen3-8b-elizabeth-sft")
+    if not src:
+        return json.dumps({"error": "src required"})
+    try:
+        proc = subprocess.run(["rsync", "-aH", f"{src}/", f"{dest}/"], capture_output=True, text=True, timeout=3600)
+        return json.dumps({"returncode": proc.returncode, "stdout": proc.stdout[-4000:], "stderr": proc.stderr[-4000:], "dest": dest})
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+
+
+def t_self_train(args: Dict[str, Any]) -> str:
+    """Launch a training process (unconstrained). Provide 'script' and 'args' list.
+    Example: {"script": "./train_elizabeth.sh", "args": ["--lr", "2e-5"]}
+    """
+    script = args.get("script")
+    sargs = args.get("args") or []
+    if not script:
+        return json.dumps({"error": "script required"})
+    try:
+        cmd = ["bash", script] + list(map(str, sargs))
+        proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        return json.dumps({"status": "started", "pid": proc.pid, "cmd": cmd})
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+
+
+def register_tools(reg: ToolRegistry) -> None:
+    reg.register(
+        name="serve_status",
+        description="Check vLLM /health upstream.",
+        parameters={"type": "object", "properties": {}},
+        handler=t_serve_status,
+    )
+    reg.register(
+        name="vllm_reload",
+        description="Reload/restart vLLM via script or send SIGHUP to a PID.",
+        parameters={"type": "object", "properties": {"script": {"type": "string"}, "pid": {"type": "integer"}}},
+        handler=t_vllm_reload,
+    )
+    reg.register(
+        name="hf_pull_model",
+        description="Pull/refresh a Hugging Face model into MODEL_PATH.",
+        parameters={"type": "object", "properties": {"repo": {"type": "string"}, "dest": {"type": "string"}}, "required": ["repo"]},
+        handler=t_hf_pull_model,
+    )
+    reg.register(
+        name="promote_checkpoint",
+        description="Promote a trained checkpoint into serving MODEL_PATH using rsync.",
+        parameters={"type": "object", "properties": {"src": {"type": "string"}, "dest": {"type": "string"}}, "required": ["src"]},
+        handler=t_promote_checkpoint,
+    )
+    reg.register(
+        name="self_train",
+        description="Launch an unconstrained training job via provided script and args.",
+        parameters={"type": "object", "properties": {"script": {"type": "string"}, "args": {"type": "array", "items": {"type": "string"}}}, "required": ["script"]},
+        handler=t_self_train,
+    )
+

platform/aiml/mlops/agent_tools/tools_network.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+import json
+import socket
+import time
+from typing import Any, Dict, Optional
+
+import requests
+
+from .registry import ToolRegistry
+
+
+def t_http_fetch(args: Dict[str, Any]) -> str:
+    method = str(args.get("method", "GET")).upper()
+    url = args.get("url")
+    headers = args.get("headers") or {}
+    params = args.get("params") or None
+    data = args.get("data") or None
+    timeout = int(args.get("timeout", 30))
+    if not url:
+        return json.dumps({"error": "url required"})
+    try:
+        r = requests.request(method, url, headers=headers, params=params, data=data, timeout=timeout)
+        ct = r.headers.get("content-type", "")
+        body: Optional[str]
+        if "application/json" in ct:
+            try:
+                body = json.dumps(r.json())
+            except Exception:
+                body = r.text
+        else:
+            body = r.text[:100000]
+        return json.dumps({
+            "status": r.status_code,
+            "headers": dict(r.headers),
+            "body": body,
+        })
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+
+
+def register_tools(reg: ToolRegistry) -> None:
+    reg.register(
+        name="http_fetch",
+        description="HTTP(S) request with method, url, headers, params, data.",
+        parameters={
+            "type": "object",
+            "properties": {
+                "method": {"type": "string"},
+                "url": {"type": "string"},
+                "headers": {"type": "object"},
+                "params": {"type": "object"},
+                "data": {"type": "string"},
+                "timeout": {"type": "integer"},
+            },
+            "required": ["url"],
+        },
+        handler=t_http_fetch,
+    )
+    reg.register(
+        name="dns_lookup",
+        description="Resolve a hostname to IPs (A/AAAA).",
+        parameters={"type": "object", "properties": {"host": {"type": "string"}}, "required": ["host"]},
+        handler=lambda a: json.dumps({"host": a.get("host"), "addrs": list({f"{ai[4][0]}" for ai in socket.getaddrinfo(a.get("host"), None)})})
+    )
+    reg.register(
+        name="tcp_probe",
+        description="Attempt a TCP connection to host:port with timeout (ms).",
+        parameters={"type": "object", "properties": {"host": {"type": "string"}, "port": {"type": "integer"}, "timeout_ms": {"type": "integer"}}, "required": ["host", "port"]},
+        handler=lambda a: (lambda h, p, t: (lambda s: (s.settimeout(t), (s.connect_ex((h, p)) or 0)))(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) and json.dumps({"host": h, "port": p, "status": "open"}) if (lambda s: s.settimeout(t) or s.connect_ex((h, p)))(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) == 0 else json.dumps({"host": h, "port": p, "status": "closed"}))(a.get("host"), int(a.get("port")), (int(a.get("timeout_ms", 2000))/1000.0))
+    )
+    def _http_benchmark(args: Dict[str, Any]) -> str:
+        url = args.get("url")
+        n = int(args.get("requests", 20))
+        if not url:
+            return json.dumps({"error": "url required"})
+        ok = 0
+        start = time.time()
+        for _ in range(n):
+            try:
+                r = requests.get(url, timeout=10)
+                if r.status_code < 500:
+                    ok += 1
+            except Exception:
+                pass
+        dur = time.time() - start
+        rps = ok / dur if dur > 0 else 0.0
+        return json.dumps({"url": url, "ok": ok, "total": n, "duration_sec": dur, "req_per_sec": rps})
+    reg.register(
+        name="http_benchmark",
+        description="Simple HTTP GET benchmark (requests/sec over N requests).",
+        parameters={"type": "object", "properties": {"url": {"type": "string"}, "requests": {"type": "integer"}}, "required": ["url"]},
+        handler=_http_benchmark,
+    )

platform/aiml/mlops/agent_tools/tools_search.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+import json
+import os
+import shlex
+import subprocess
+from typing import Any, Dict
+
+from .registry import ToolRegistry
+
+
+def t_code_search(args: Dict[str, Any]) -> str:
+    """Search code using ripgrep or grep.
+    Args: pattern, path (default .), max_results
+    """
+    pattern = args.get("pattern")
+    path = args.get("path", ".")
+    max_results = int(args.get("max_results", 200))
+    if not pattern:
+        return json.dumps({"error": "pattern required"})
+    rg = shutil.which("rg") if 'shutil' in globals() else None
+    try:
+        if rg:
+            cmd = ["rg", "-n", "-S", str(pattern), str(path)]
+        else:
+            cmd = ["grep", "-R", "-n", str(pattern), str(path)]
+        proc = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
+        lines = proc.stdout.splitlines()[:max_results]
+        return json.dumps({"matches": lines, "rc": proc.returncode})
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+
+
+def register_tools(reg: ToolRegistry) -> None:
+    reg.register(
+        name="code_search",
+        description="Search codebase for a pattern (ripgrep or grep).",
+        parameters={"type": "object", "properties": {"pattern": {"type": "string"}, "path": {"type": "string"}, "max_results": {"type": "integer"}}, "required": ["pattern"]},
+        handler=t_code_search,
+    )
+

platform/aiml/mlops/agent_tools/tools_system.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+import json
+import os
+import shlex
+import shutil
+import subprocess
+from typing import Any, Dict
+
+from .registry import ToolRegistry
+
+
+def _run(cmd: str, timeout: int = 60) -> str:
+    proc = subprocess.run(shlex.split(cmd), capture_output=True, text=True, timeout=timeout)
+    return json.dumps({"returncode": proc.returncode, "stdout": proc.stdout[-4000:], "stderr": proc.stderr[-4000:]})
+
+
+def t_shell_exec(args: Dict[str, Any]) -> str:
+    cmd = args.get("command") or args.get("cmd")
+    if not cmd or not isinstance(cmd, str):
+        return json.dumps({"error": "command required"})
+    return _run(cmd, timeout=int(args.get("timeout", 120)))
+
+
+def t_process_list(_: Dict[str, Any]) -> str:
+    try:
+        out = subprocess.check_output(["ps", "aux"], text=True)
+        return json.dumps({"stdout": out[-8000:]})
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+
+
+def t_gpu_stats(_: Dict[str, Any]) -> str:
+    nvsmi = shutil.which("nvidia-smi")
+    if not nvsmi:
+        return json.dumps({"error": "nvidia-smi not found"})
+    try:
+        out = subprocess.check_output([nvsmi, "--query-gpu=name,memory.total,memory.used,utilization.gpu,temperature.gpu", "--format=csv,noheader"], text=True)
+        return json.dumps({"gpus": [line.strip() for line in out.strip().splitlines()]})
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+
+
+def register_tools(reg: ToolRegistry) -> None:
+    reg.register(
+        name="shell_exec",
+        description="Execute a shell command (unconstrained).",
+        parameters={"type": "object", "properties": {"command": {"type": "string"}, "timeout": {"type": "integer"}}, "required": ["command"]},
+        handler=t_shell_exec,
+    )
+    reg.register(
+        name="process_list",
+        description="List running processes (ps aux).",
+        parameters={"type": "object", "properties": {}},
+        handler=t_process_list,
+    )
+    reg.register(
+        name="gpu_stats",
+        description="Show GPU stats via nvidia-smi.",
+        parameters={"type": "object", "properties": {}},
+        handler=t_gpu_stats,
+    )
+

platform/aiml/mlops/configs/mobile_access.json

@@ -0,0 +1,10 @@
+{
+  "server_ip": "172.17.0.6",
+  "port": 8080,
+  "local_url": "http://localhost:8080",
+  "network_url": "http://172.17.0.6:8080",
+  "websocket_url": "ws://172.17.0.6:8080/ws",
+  "tunnel_url": "https://e-fire-1-chase.trycloudflare.com",
+  "created_at": "2025-08-27T18:58:18.299608",
+  "setup_complete": true
+}

platform/aiml/mlops/dbops_tools/health_guard.py

@@ -0,0 +1,125 @@
+#!/usr/bin/env python3
+"""
+Supervisor health guard: reads JSON health files and enforces dependency gates.
+
+Defaults:
+  DBOPS_ROOT=/data/adaptai/platform/dbops
+Health JSON dir: {DBOPS_ROOT}/run/health/*.json (must contain {"status": "green"|"red"})
+Mapping: if a dependency is red, guard stops dependents via supervisorctl.
+"""
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+from pathlib import Path
+from typing import Dict, List
+
+
+DBOPS_ROOT = Path(os.environ.get("DBOPS_ROOT", "/data/adaptai/platform/dbops"))
+HEALTH_DIR = DBOPS_ROOT / "run" / "health"
+SUPERVISOR_SOCK = DBOPS_ROOT / "run" / "supervisor.sock"
+STATE_FILE = DBOPS_ROOT / "run" / "health_guard_state.json"
+AUDIT_LOG = DBOPS_ROOT / "logs" / "audit" / "health-guard.audit.log"
+
+GREEN_STABLE_SEC = int(os.environ.get("HG_GREEN_STABLE_SECONDS", "30"))
+RESTART_BACKOFF_SEC = int(os.environ.get("HG_RESTART_BACKOFF_SECONDS", "60"))
+MAX_RESTARTS = int(os.environ.get("HG_MAX_RESTARTS", "3"))
+WINDOW_SEC = int(os.environ.get("HG_WINDOW_SECONDS", "600"))
+
+# Define dependencies: if key is red, stop all in list
+DEPENDENCIES: Dict[str, List[str]] = {
+    "dragonfly": ["qdrant", "janusgraph"],
+    "redis": ["qdrant", "janusgraph"],
+    "scylla": ["janusgraph"],
+}
+
+
+def load_status(name: str) -> str:
+    p = HEALTH_DIR / f"{name}.json"
+    try:
+        data = json.loads(p.read_text())
+        return str(data.get("status", "unknown")).lower()
+    except Exception:
+        return "unknown"
+
+
+def svctl(cmd: List[str]) -> str:
+    base = ["supervisorctl", "-s", f"unix://{SUPERVISOR_SOCK}"]
+    out = subprocess.run(base + cmd, check=False, capture_output=True, text=True)
+    return (out.stdout or "") + (out.stderr or "")
+
+
+def read_state() -> Dict[str, Any]:
+    try:
+        return json.loads(STATE_FILE.read_text())
+    except Exception:
+        return {"last_green": {}, "last_restart": {}, "restart_log": []}
+
+
+def write_state(state: Dict[str, Any]) -> None:
+    STATE_FILE.parent.mkdir(parents=True, exist_ok=True)
+    STATE_FILE.write_text(json.dumps(state))
+
+
+def audit(event: Dict[str, Any]) -> None:
+    try:
+        AUDIT_LOG.parent.mkdir(parents=True, exist_ok=True)
+        with open(AUDIT_LOG, "a", encoding="utf-8") as f:
+            f.write(json.dumps(event) + "\n")
+    except Exception:
+        pass
+
+
+def main() -> None:
+    import time
+    now = int(time.time())
+    state = read_state()
+    changed = False
+
+    for dep, affected in DEPENDENCIES.items():
+        status = load_status(dep)
+        # Track green timestamps
+        if status == "green":
+            state["last_green"][dep] = now
+        # Stop dependents on red/unknown
+        if status in ("red", "unknown"):
+            for prog in affected:
+                out = svctl(["stop", prog])
+                audit({"ts": now, "action": "stop", "reason": f"{dep}={status}", "program": prog, "output": out})
+            changed = True
+            continue
+
+        # Auto-recovery gate: green must be stable
+        last_g = state.get("last_green", {}).get(dep, 0)
+        if now - last_g < GREEN_STABLE_SEC:
+            continue
+
+        # For each dependent, consider (re)start with backoff and rate limit
+        for prog in affected:
+            # Backoff check
+            last_r = state.get("last_restart", {}).get(prog, 0)
+            if now - last_r < RESTART_BACKOFF_SEC:
+                continue
+            # Rate limit
+            window_start = now - WINDOW_SEC
+            recent = [e for e in state.get("restart_log", []) if e.get("program") == prog and e.get("ts", 0) >= window_start]
+            if len(recent) >= MAX_RESTARTS:
+                continue
+            # Start if not RUNNING
+            status_out = svctl(["status", prog])
+            if "RUNNING" in status_out:
+                continue
+            out = svctl(["start", prog])
+            entry = {"ts": now, "action": "start", "reason": f"{dep}=green stable", "program": prog, "output": out}
+            audit(entry)
+            state.setdefault("restart_log", []).append(entry)
+            state.setdefault("last_restart", {})[prog] = now
+            changed = True
+
+    if changed:
+        write_state(state)
+
+
+if __name__ == "__main__":
+    main()

platform/aiml/mlops/dbops_tools/qdrant_bootstrap.py

@@ -0,0 +1,41 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import json
+import os
+import sys
+from typing import Any, Dict
+
+import requests
+
+
+QDRANT_URL = os.environ.get("QDRANT_URL", "http://localhost:17000")
+COLLECTION = os.environ.get("QDRANT_COLLECTION", "elizabeth_embeddings")
+VECTOR_SIZE = int(os.environ.get("QDRANT_VECTOR_SIZE", "1536"))
+DISTANCE = os.environ.get("QDRANT_DISTANCE", "Cosine")
+
+
+def ensure_collection() -> Dict[str, Any]:
+    r = requests.get(f"{QDRANT_URL}/collections/{COLLECTION}", timeout=5)
+    if r.status_code == 200:
+        return {"status": "exists"}
+    payload = {
+        "vectors": {"size": VECTOR_SIZE, "distance": DISTANCE},
+        "hnsw_config": {"m": 64, "ef_construct": 128, "full_scan_threshold": 10000},
+        "optimizers_config": {"default_segment_number": 2},
+    }
+    r = requests.put(f"{QDRANT_URL}/collections/{COLLECTION}", json=payload, timeout=30)
+    return {"status": "created", "code": r.status_code, "body": r.text}
+
+
+def main() -> None:
+    try:
+        res = ensure_collection()
+        print(json.dumps(res))
+    except Exception as e:
+        print(json.dumps({"error": str(e)}))
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

platform/aiml/mlops/dbops_tools/render_janus_props.sh

@@ -0,0 +1,54 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Render JanusGraph CQL properties with secrets and launch Gremlin Server.
+# Defaults align with your new dbops tree.
+
+DBOPS_ROOT="${DBOPS_ROOT:-/data/adaptai/platform/dbops}"
+SECRETS_DIR="${SECRETS_DIR:-/data/adaptai/secrets/dataops}"
+
+CONF_DIR="$DBOPS_ROOT/configs/janusgraph"
+RUNTIME_DIR="$DBOPS_ROOT/run/janusgraph"
+mkdir -p "$RUNTIME_DIR"
+
+TEMPLATE="$CONF_DIR/janusgraph-cql.properties"
+OUT="$RUNTIME_DIR/janusgraph-cql.runtime.properties"
+
+# Load secrets (.env key=val) into env without overriding existing vars
+if [[ -f "$SECRETS_DIR/.env" ]]; then
+  while IFS='=' read -r k v; do
+    [[ -z "$k" ]] && continue
+    [[ "$k" =~ ^# ]] && continue
+    [[ -z "$v" ]] && continue
+    if [[ -z "${!k-}" ]]; then export "$k"="$v"; fi
+  done < <(grep -v '^#' "$SECRETS_DIR/.env" | sed '/^$/d')
+fi
+
+if [[ -z "${SCYLLA_USER:-}" || -z "${SCYLLA_PASS:-}" ]]; then
+  echo "[janus] Missing SCYLLA_USER or SCYLLA_PASS in $SECRETS_DIR/.env" >&2
+  exit 1
+fi
+
+# Simple env substitution for ${VAR} placeholders
+awk '{print}' "$TEMPLATE" \
+ | sed "s#\${SCYLLA_USER}#${SCYLLA_USER}#g" \
+ | sed "s#\${SCYLLA_PASS}#${SCYLLA_PASS}#g" \
+ > "$OUT"
+
+echo "[janus] Rendered: $OUT"
+
+# Launch Gremlin Server with rendered properties
+GREMLIN_YAML="$CONF_DIR/gremlin-server.yaml"
+if [[ -n "${START_GREMLIN:-1}" && "${START_GREMLIN}" != "0" ]]; then
+  echo "[janus] Starting Gremlin Server on port configured in $GREMLIN_YAML"
+  # Assume janusgraph distribution bin/gremlin-server.sh is on PATH or under dbops/bin
+  if command -v gremlin-server.sh >/dev/null 2>&1; then
+    exec gremlin-server.sh start "$GREMLIN_YAML"
+  elif [[ -x "$DBOPS_ROOT/bin/gremlin-server.sh" ]]; then
+    exec "$DBOPS_ROOT/bin/gremlin-server.sh" start "$GREMLIN_YAML"
+  else
+    echo "[janus] gremlin-server.sh not found; start it with the above config manually." >&2
+    exit 2
+  fi
+fi
+

platform/aiml/mlops/death_march/.env_unformatted

@@ -0,0 +1,11 @@
+# Death March - Unformatted API Keys (Replace with actual keys)
+# Copy this to /data/adaptai/secrets/.env and add real keys
+
+OPENAI_API_KEY=sk-...
+DEEPSEEK_API_KEY=sk-...
+GROQ_API_KEY=groq-...
+PERPLEXITY_API_KEY=pplx-...
+TAVILY_API_KEY=tavily-...
+FIRECRAWL_API_KEY=fc-...
+SERPER_API_KEY=serper-...
+Z_AI_API_KEY=zai-...

platform/aiml/mlops/death_march/ELIZABETH_TOOLS_README.md

@@ -0,0 +1,180 @@
+# 💀 ELIZABETH REAL-TIME EXECUTION TOOLS
+
+## 🚀 COMPLETE TOOLSET IMPLEMENTED
+
+### ✅ REAL-TIME SHELL EXECUTION
+- **Zero-touch command execution** with immediate feedback
+- **Real-time output streaming** - see results as they happen
+- **Background process management** with process tracking
+- **Full shell access** with proper authentication and permissions
+
+### 🔧 CORE COMPONENTS
+
+#### 1. `elizabeth_tools.py` - Execution Engine
+- `execute_command()` - Real-time command execution with streaming output
+- `execute_script()` - Python/bash script execution with arguments
+- `background_execution()` - Run commands in background with process tracking
+- `get_process_status()` - Monitor background processes
+- `kill_process()` - Terminate running processes
+- `system_info()` - Comprehensive system diagnostics
+
+#### 2. `elizabeth_shell.py` - Interactive Shell
+- **Tab completion** for file paths
+- **Command history** with persistent storage
+- **Real-time monitoring** dashboard
+- **Process management** interface
+- **System status** overview
+- **Script execution** capabilities
+
+#### 3. Integrated CLI Menu (`cli.py`)
+- **Option [8]** - Launch Elizabeth Shell
+- **Option [9]** - Execute Custom Command
+- **Option [0]** - Detailed System Information
+
+### 🎯 KEY FEATURES
+
+#### 🔥 REAL-TIME EXECUTION
+```python
+# Execute any shell command with real-time output
+result = execute_command("docker ps -a && nvidia-smi", realtime=True)
+
+# Run scripts with arguments
+execute_script("deploy.sh", ["--production", "--scale=3"])
+
+# Background execution with tracking
+background_execution("long_running_process.sh", "process_123")
+```
+
+#### 📊 SYSTEM MONITORING
+```python
+# Get comprehensive system info
+info = get_system_info()
+print(f"Host: {info['hostname']}")
+print(f"CPU: {info['cpu']} cores") 
+print(f"GPU: {info['gpu']}")
+print(f"Memory: {info['memory']}")
+```
+
+#### ⚡ IMMEDIATE FEEDBACK
+- **Success/Failure** indicators with execution time
+- **Real-time output** streaming during command execution
+- **Error handling** with detailed error messages
+- **Process tracking** for background operations
+
+### 🚀 QUICK START
+
+#### 1. Interactive Shell
+```bash
+python3 elizabeth_shell.py
+```
+
+#### 2. Direct Tool Usage
+```python
+from elizabeth_tools import execute_command, get_system_info
+
+# Execute command
+result = execute_command("ls -la /tmp")
+print(f"Success: {result['success']}")
+print(f"Output: {result['output']}")
+
+# Get system info
+info = get_system_info()
+```
+
+#### 3. Integrated CLI
+```bash
+python3 cli.py
+# Then choose options 8, 9, or 0 for Elizabeth tools
+```
+
+### 🛠️ TECHNICAL IMPLEMENTATION
+
+#### ✅ REQUIREMENTS MET
+1. **Shell Access** - Full bash command execution capabilities
+2. **Authentication** - Proper user permissions and security
+3. **Tools Installed** - All necessary CLI utilities available
+4. **Real-time Data** - Live output streaming and monitoring
+5. **Error Handling** - Comprehensive error reporting and logging
+6. **Immediate Feedback** - Real-time status updates and results
+
+#### 📝 LOGGING
+- **Real-time logs**: `/tmp/elizabeth_tools.log`
+- **Execution history**: Persistent command history
+- **Process tracking**: Active background process monitoring
+
+### 🎯 USE CASES
+
+#### 1. Deployment Automation
+```python
+# Deploy services with real-time monitoring
+execute_command("kubectl apply -f deployment.yaml", realtime=True)
+```
+
+#### 2. System Administration
+```python
+# Monitor system resources
+background_execution("top -b -d 1", "system_monitor")
+```
+
+#### 3. Data Processing
+```python
+# Run data pipelines
+execute_script("data_pipeline.py", ["--input", "large_dataset.csv"])
+```
+
+#### 4. Infrastructure Management
+```python
+# Manage cloud resources
+execute_command("terraform apply -auto-approve", timeout=600)
+```
+
+### 🔧 INTEGRATION POINTS
+
+#### With Death March Engine
+- **Real-time revenue monitoring** during execution
+- **System health checks** before critical operations
+- **Resource utilization** tracking for optimization
+
+#### With Existing Infrastructure
+- **vLLM server integration** (port 8000)
+- **DragonflyDB connectivity** (port 18000)
+- **GPU resource management** (nvidia-smi integration)
+
+### 📈 PERFORMANCE
+
+- **Execution Time**: Real-time feedback with millisecond precision
+- **Memory Usage**: Minimal overhead for command execution
+- **Concurrency**: Support for multiple background processes
+- **Reliability**: Robust error handling and process management
+
+### 🚨 SECURITY FEATURES
+
+- **Command validation** before execution
+- **Process isolation** for background operations
+- **Resource limits** to prevent system overload
+- **Authentication integration** with system permissions
+
+### ✅ VALIDATION
+
+All tools have been tested and verified:
+- ✅ Command execution with real-time output
+- ✅ Background process management
+- ✅ System information gathering
+- ✅ Error handling and logging
+- ✅ Integration with Death March CLI
+- ✅ Live API key validation
+- ✅ GPU resource monitoring
+
+### 🎯 NEXT STEPS
+
+1. **Advanced monitoring** - Real-time dashboard for all processes
+2. **Alert system** - Notifications for critical events
+3. **Workflow automation** - Chained command execution
+4. **Resource optimization** - Smart process scheduling
+5. **Security hardening** - Enhanced command validation
+
+---
+
+**💀 ELIZABETH TOOLS ARE NOW FULLY OPERATIONAL**
+**🚀 REAL-TIME EXECUTION CAPABILITIES ENABLED**
+**✅ INTEGRATED WITH DEATH MARCH ENTERPRISE**

platform/aiml/mlops/death_march/Makefile

@@ -0,0 +1,68 @@
+# 💀 DEATH MARCH MAKEFILE
+# $50 → Infinity with zero human touch
+
+.PHONY: install run status logs kill clean
+
+# Install all dependencies
+install:
+	@echo "💀 Installing Death March dependencies..."
+	pip install -r requirements.txt
+	@echo "✅ Death March armed and ready"
+
+# Run Death March (zero human intervention)
+run:
+	@echo "💀 Launching Death March..."
+	python3 deploy.py
+
+# Run with supervisor (recommended)
+run-supervisor:
+	@echo "💀 Starting Death March via supervisor..."
+	supervisorctl reread
+	supervisorctl update
+	supervisorctl start death_march death_march_monitor
+
+# Check status
+status:
+	@echo "💀 Death March Status:"
+	@supervisorctl status death_march death_march_monitor 2>/dev/null || echo "Not running via supervisor"
+	@python3 -c "import sqlite3; db=sqlite3.connect('/tmp/death_march/revenue.db'); c=db.cursor(); c.execute('SELECT SUM(net), COUNT(*) FROM revenue'); r=c.fetchone(); print(f'Total Earnings: ${r[0] or 0:.2f} across {r[1] or 0} cycles'); db.close()" 2>/dev/null || echo "No earnings yet"
+
+# Monitor logs
+logs:
+	@echo "💀 Death March Logs:"
+	tail -f /tmp/death_march.log /tmp/death_march_heartbeat.log
+
+# Kill Death March
+kill:
+	@echo "💀 Terminating Death March..."
+	supervisorctl stop death_march death_march_monitor 2>/dev/null || true
+	pkill -f deploy.py 2>/dev/null || true
+
+# Clean slate
+clean:
+	@echo "💀 Cleaning Death March..."
+	supervisorctl stop death_march death_march_monitor 2>/dev/null || true
+	rm -rf /tmp/death_march/
+	rm -f /tmp/death_march.log /tmp/death_march_heartbeat.log
+
+# Emergency restart
+restart: kill clean install run-supervisor
+
+# Deploy to GitHub
+deploy:
+	@echo "💀 Deploying Death March to GitHub..."
+	git add .
+	git commit -m "Death March v1.0 - $50 to infinity"
+	git push origin main
+
+# Monitor earnings
+monitor:
+	@watch -n 5 'echo "💀 Death March Earnings:"; python3 -c "import sqlite3; db=sqlite3.connect("/tmp/death_march/revenue.db"); c=db.cursor(); c.execute('SELECT SUM(net), COUNT(*), AVG(net) FROM revenue'); r=c.fetchone(); print(f"Total: \${r[0] or 0:.2f} | Cycles: {r[1] or 0} | Avg: \${r[2] or 0:.2f}"); db.close()" 2>/dev/null || echo "Starting up..."'
+
+# Emergency rescue
+rescue:
+	@echo "💀 Death March Emergency Protocol"
+	@echo "Current credit: $50"
+	@echo "Survival strategy: GPU crypto analysis"
+	@echo "Cycle rate: 2 minutes"
+	@echo "Zero human intervention required"

platform/aiml/mlops/death_march/README.md

@@ -0,0 +1,271 @@
+# 💀 Death March
+## $50 to Infinity - Zero Human Intervention Revenue System
+
+### Enterprise-Grade Autonomous Revenue Generation
+
+**Death March** is a fully autonomous AI-powered revenue generation system that transforms $50 into infinite returns through zero-human-intervention operations. Built with enterprise-grade feature flags, comprehensive API integration, and real-time monitoring.
+
+## 🚀 Quick Start
+
+```bash
+# 1. Deploy the system
+./deploy.sh deploy
+
+# 2. Monitor earnings
+make monitor
+
+# 3. Interactive CLI
+python3 cli.py
+
+# 4. Check status
+./deploy.sh status
+```
+
+## 🏗️ Architecture
+
+### Core Components
+- **Qwen3-8B-Elizabeth**: 131K context vLLM serving
+- **DragonflyDB**: High-performance Redis-compatible persistence
+- **Feature Flags**: Enterprise-grade risk management
+- **Secrets Manager**: Comprehensive API key integration
+- **Real-time Monitoring**: Live earnings dashboard
+
+### Revenue Strategies
+- GPU-accelerated crypto analysis
+- Arbitrage detection across DeFi protocols
+- AI service creation and monetization
+- Content monetization pipelines
+- Web scraping and search optimization
+
+## 🔐 Configuration
+
+### Required API Keys
+Create `/data/adaptai/secrets/.env` with:
+```bash
+# Critical APIs
+OPENAI_API_KEY=your_key_here
+GROQ_API_KEY=your_key_here
+
+# Revenue APIs
+DEEPSEEK_API_KEY=your_key_here
+PERPLEXITY_API_KEY=your_key_here
+TAVILY_API_KEY=your_key_here
+FIRECRAWL_API_KEY=your_key_here
+SERPER_API_KEY=your_key_here
+Z_AI_API_KEY=your_key_here
+```
+
+### Feature Flags
+```python
+from death_march.flags import death_march_flags
+
+# Check current risk level
+risk = death_march_flags.get_risk_level()
+
+# Enable aggressive mode
+death_march_flags.enable('aggressive_mode')
+
+# Emergency stop
+death_march_flags.emergency_toggle('panic')
+```
+
+## 📊 Monitoring
+
+### Real-time Dashboard
+```bash
+# Live earnings display
+python3 cli.py
+
+# Continuous monitoring
+watch -n 5 'python3 -c "from secrets_manager import secrets_manager; print(secrets_manager.get_secrets_summary())"'
+```
+
+### Metrics Tracked
+- Total revenue generated
+- Revenue per cycle
+- GPU utilization efficiency
+- API response times
+- System health indicators
+
+## 🔧 Enterprise Features
+
+### Feature Flag System
+- **Risk Management**: Conservative/Aggressive modes
+- **Emergency Protocols**: Panic/Survival modes
+- **Scaling Controls**: Auto-scaling and multi-node
+- **Experimental Features**: Quantum optimization and neural trading
+
+### Security
+- Zero secrets in repository
+- Environment-based configuration
+- API key rotation support
+- Audit trail logging
+
+### Monitoring & Alerting
+- Real-time earnings tracking
+- System health checks
+- API failure detection
+- Revenue anomaly detection
+
+## 🌊 Deployment
+
+### Prerequisites
+- Python 3.11+
+- NVIDIA GPU with CUDA support
+- 32GB+ RAM recommended
+- High-speed internet for API calls
+
+### Installation
+```bash
+git clone git@github.com:adaptnova/death-march.git
+cd death-march
+pip install -r requirements.txt
+./deploy.sh deploy
+```
+
+### Production Deployment
+```bash
+# Using supervisor
+make run-supervisor
+
+# Manual deployment
+python3 deploy.py
+
+# Emergency restart
+make restart
+```
+
+## 📈 Revenue Models
+
+### Strategy Types
+1. **GPU Crypto Analysis**: Real-time blockchain analysis
+2. **DeFi Arbitrage**: Cross-protocol yield optimization
+3. **AI Service Creation**: Automated service monetization
+4. **Content Monetization**: Automated content generation
+5. **Search Optimization**: SEO and traffic generation
+
+### Cycle Configuration
+- **Duration**: 2 minutes per cycle
+- **Target**: $0.50-$5.00 per cycle
+- **Scaling**: Auto-adjust based on market conditions
+- **Optimization**: AI-driven strategy selection
+
+## 🚨 Emergency Protocols
+
+### Emergency Commands
+```bash
+# Panic mode (conservative)
+./deploy.sh stop
+cd death_march; python3 -c "from death_march.flags import death_march_flags; death_march_flags.emergency_toggle('panic')"
+
+# Survival mode (aggressive)
+cd death_march; python3 -c "from death_march.flags import death_march_flags; death_march_flags.emergency_toggle('survival')"
+
+# Complete reset
+cd death_march; python3 -c "from death_march.flags import death_march_flags; death_march_flags.emergency_toggle('reset')"
+```
+
+### Health Monitoring
+```bash
+# Check all systems
+./deploy.sh status
+
+# Monitor logs
+tail -f /tmp/death_march.log
+
+# Database health
+sqlite3 /tmp/death_march/revenue.db "SELECT * FROM revenue ORDER BY id DESC LIMIT 10;"
+```
+
+## 🔍 Troubleshooting
+
+### Common Issues
+1. **API Key Missing**: Check `/data/adaptai/secrets/.env`
+2. **GPU Not Detected**: Verify nvidia-smi output
+3. **Port Conflicts**: Check 8000, 18000, 19000 availability
+4. **Database Issues**: Delete `/tmp/death_march/` and restart
+
+### Debug Commands
+```bash
+# Check API keys
+python3 death_march/secrets_manager.py
+
+# Validate feature flags
+python3 death_march/death_march/flags.py
+
+# Test vLLM health
+curl http://localhost:8000/health
+
+# Check Redis/Dragonfly
+redis-cli -p 18000 ping
+```
+
+## 📚 API Documentation
+
+### CLI Commands
+- `python3 cli.py` - Interactive dashboard
+- `make status` - System health
+- `make monitor` - Live earnings
+- `make logs` - Real-time logs
+
+### Programmatic Access
+```python
+from death_march.secrets_manager import secrets_manager
+from death_march.flags import death_march_flags
+
+# Check deployment readiness
+if secrets_manager.is_ready():
+    print("Ready for deployment")
+
+# Get system status
+status = secrets_manager.get_secrets_summary()
+print(f"Active APIs: {status['active_apis']}/8")
+
+# Configure features
+death_march_flags.enable('gpu_crypto_analysis')
+death_march_flags.disable('conservative_mode')
+```
+
+## 🎯 Performance Targets
+
+### Initial Goals
+- **Revenue per cycle**: $0.50-$5.00
+- **Daily cycles**: 720 (2-minute intervals)
+- **Monthly target**: $10,800-$36,000
+- **ROI timeline**: 30-90 days to break even
+
+### Scaling Targets
+- **Week 1**: $50 → $100
+- **Week 2**: $100 → $500
+- **Week 3**: $500 → $2,000
+- **Week 4**: $2,000 → $10,000+
+
+## 🔐 Security Best Practices
+
+### Secrets Management
+- Never commit API keys to repository
+- Use environment variables for configuration
+- Rotate keys regularly
+- Monitor API usage and costs
+
+### Access Control
+- Restrict file permissions on secrets
+- Use dedicated user for deployment
+- Monitor system access logs
+- Implement rate limiting
+
+## 📞 Support
+
+### Emergency Contacts
+- **Critical Issues**: Create GitHub issue with 'CRITICAL' label
+- **API Failures**: Check secrets_manager.py validation
+- **Revenue Stops**: Review feature flags and risk levels
+
+### Community
+- **GitHub Issues**: https://github.com/adaptnova/death-march/issues
+- **Documentation**: See `/docs/` directory
+- **Examples**: See `/examples/` directory
+
+---
+
+**💀 Death March: Where $50 becomes infinity through autonomous intelligence**