refactor: remove experimental test files and enable production mode in Dockerfile

Dockerfile

@@ -7,7 +7,7 @@ RUN pip install --no-cache-dir -r requirements.txt
 
 COPY . .
 
-ENV STEP_ZERO_MOCK=1
+ENV STEP_ZERO_MOCK=0
 EXPOSE 7860
 
 CMD ["python", "app.py"]

app.py

@@ -25,9 +25,33 @@ NEMOTRON_MODEL_PATH = os.getenv("NEMOTRON_MODEL_PATH", "./models/step-zero-nemot
 MINICPM_MODEL_PATH = os.getenv("MINICPM_MODEL_PATH", "./models/minicpm-3-4b.gguf")
 
 if not MOCK_MODE:
+    import os
+    from huggingface_hub import hf_hub_download
     from llama_cpp import Llama
     from llama_cpp import LlamaGrammar
 
+    os.makedirs("./models", exist_ok=True)
+    
+    if not os.path.exists(NEMOTRON_MODEL_PATH):
+        print(f"Downloading Nemotron model to {NEMOTRON_MODEL_PATH}...", flush=True)
+        hf_hub_download(
+            repo_id="tc043/step-zero-nemotron",
+            filename="step-zero-nemotron-finetuned.gguf",
+            local_dir="./models"
+        )
+        
+    if not os.path.exists(MINICPM_MODEL_PATH):
+        print(f"Downloading MiniCPM model to {MINICPM_MODEL_PATH}...", flush=True)
+        downloaded = hf_hub_download(
+            repo_id="mradermacher/MiniCPM3-4B-GGUF",
+            filename="MiniCPM3-4B.Q4_K_M.gguf",
+            local_dir="./models"
+        )
+        expected_path = os.path.abspath(MINICPM_MODEL_PATH)
+        downloaded_path = os.path.abspath(downloaded)
+        if downloaded_path != expected_path and os.path.exists(downloaded_path):
+            os.rename(downloaded_path, expected_path)
+
     grammar = LlamaGrammar.from_file(str(GRAMMAR_PATH))
 
     # Use small context windows to save RAM.
@@ -77,6 +101,41 @@ def is_semantic_repeat(new_task: str, history: list) -> bool:
             return True
     return False
 
+def clean_and_validate_task(raw_output: str, history: list, skipped_history: list) -> tuple[str, bool]:
+    import re
+    if not raw_output:
+        return "", False
+        
+    # Split by sentence boundaries and take the first sentence
+    sentences = re.split(r'(?<=[.!?])\s+', raw_output)
+    first_sentence = sentences[0].strip() if sentences else raw_output
+    
+    # Strip quotes, punctuation, numbers, etc. at ends
+    cleaned = first_sentence.strip('"\' ,.-1234567890)')
+    if not cleaned:
+        return "", False
+        
+    # Check for prompt leakage and scaffolding words
+    invalid_keywords = [
+        "completed tasks", "failures", "system", "user", "assistant", 
+        "next step", "done", "fail", "gbnf", "pacemaker", "extra_id_",
+        "instruction", "output", "goal:", "failures:"
+    ]
+    contains_scaffold = any(k in cleaned.lower() for k in invalid_keywords)
+    
+    # Check for reasonable length (under 12 words)
+    word_count = len(cleaned.split())
+    if word_count > 12:
+        return cleaned, False
+        
+    if contains_scaffold:
+        return cleaned, False
+        
+    if is_semantic_repeat(cleaned, history + skipped_history):
+        return cleaned, False
+        
+    return cleaned, True
+
 async def generate_atomic_task(goal: str, previous_failures: int, history: list = None, skipped_history: list = None, rejected_task: str = None) -> str:
     if history is None:
         history = []
@@ -116,9 +175,9 @@ async def generate_atomic_task(goal: str, previous_failures: int, history: list
                 max_tokens=64, 
                 temperature=0.1
             )
-            content = fallback_res['choices'][0]['message']['content'].strip()
-            print(f"MINICPM BREAKDOWN OUT: {content}", flush=True)
-            content = content.strip('"\' ,.-1234567890)')
+            raw_fallback = fallback_res['choices'][0]['message']['content'].strip()
+            print(f"MINICPM BREAKDOWN OUT: {raw_fallback}", flush=True)
+            content, _ = clean_and_validate_task(raw_fallback, [], [])
             return content or "Focus on the screen."
 
         # REAL INFERENCE using the exact string template used during fine-tuning
@@ -136,13 +195,13 @@ async def generate_atomic_task(goal: str, previous_failures: int, history: list
             stop=["\n", "<extra_id_1>"],
             grammar=grammar # Enforcing grammar here!
         )
-        content = response['choices'][0]['text'].strip()
+        raw_content = response['choices'][0]['text'].strip()
+        print(f"NEMOTRON RAW OUT: {raw_content}", flush=True)
         
-        # Check if output is empty or a repetition
-        is_invalid = not content or is_semantic_repeat(content, history + skipped_history)
+        content, is_valid = clean_and_validate_task(raw_content, history, skipped_history)
         
-        if is_invalid:
-            print(f"NEMOTRON OUTPUT INVALID OR REPETITION ('{content}'). FALLING BACK TO MINICPM...", flush=True)
+        if not is_valid:
+            print(f"NEMOTRON OUTPUT INVALID OR REPETITION ('{raw_content}'). FALLING BACK TO MINICPM...", flush=True)
             last_task = history[-1] if history else ""
             last_skipped = skipped_history[-1] if skipped_history else ""
             
@@ -164,14 +223,15 @@ async def generate_atomic_task(goal: str, previous_failures: int, history: list
                 max_tokens=64, 
                 temperature=0.1
             )
-            content = fallback_res['choices'][0]['message']['content'].strip()
-            print(f"MINICPM FALLBACK OUT: {content}", flush=True)
-        else:
-            print(f"NEMOTRON RAW OUT: {content}", flush=True)
-            
-        content = content.strip('"\' ,.-1234567890)')
+            raw_fallback = fallback_res['choices'][0]['message']['content'].strip()
+            print(f"MINICPM FALLBACK OUT: {raw_fallback}", flush=True)
+            content, _ = clean_and_validate_task(raw_fallback, [], [])
+            if not content:
+                content = raw_fallback.strip('"\' ,.-1234567890)')
+        
         return content or "Focus on the screen."
 
+
 async def apply_activation_style(task: str, style="direct") -> str:
     if MOCK_MODE:
         await asyncio.sleep(0.5)
@@ -228,8 +288,30 @@ async def apply_activation_style(task: str, style="direct") -> str:
 # --- GRADIO UI ---
 
 custom_css = """
-body { background-color: #0a0a0a; color: #ffffff; font-family: 'Helvetica Neue', sans-serif; }
-.gradio-container { background-color: transparent !important; border: none !important; }
+:root, .dark {
+    --body-background-fill: #0a0a0a !important;
+    --background-fill-primary: #0a0a0a !important;
+    --background-fill-secondary: #121212 !important;
+    --border-color-primary: #1f2937 !important;
+    --border-color-secondary: #374151 !important;
+    --text-color-primary: #ffffff !important;
+    --text-color-secondary: #d1d5db !important;
+    --input-background-fill: #121212 !important;
+    --input-border-width: 1px !important;
+    --input-border-color: #1f2937 !important;
+}
+
+body {
+    background-color: #0a0a0a !important;
+    color: #ffffff !important;
+    font-family: 'Helvetica Neue', sans-serif !important;
+}
+
+.gradio-container {
+    background-color: #0a0a0a !important;
+    border: none !important;
+}
+
 footer { display: none !important; }
 .fog { opacity: 0.3; filter: blur(2px); transition: all 0.5s ease; }
 .fade-in { animation: fadeIn 0.5s ease-in forwards; }
@@ -256,7 +338,7 @@ footer { display: none !important; }
 #btn-trace:hover { color: #d1d5db !important; }
 
 /* Big Task Text */
-#current-task { text-align: center; font-size: 3rem; font-weight: 800; min-height: 150px; display: flex; align-items: center; justify-content: center; }
+#current-task { text-align: center; font-size: 3rem; font-weight: 800; min-height: 150px; display: flex; align-items: center; justify-content: center; color: #ffffff !important; }
 @media (min-width: 768px) { #current-task { font-size: 4.5rem; } }
 """
 
@@ -341,7 +423,7 @@ async def process_step(state, action: str, goal: str = None, style: str = None,
     
     return state, generate_task_html(styled_task), generate_breadcrumbs_html(state["history"][-3:]), gr.Row(visible=True)
 
-with gr.Blocks(css=custom_css, title="Step-Zero") as app:
+with gr.Blocks(css=custom_css, js="() => { document.documentElement.classList.add('dark'); }", title="Step-Zero") as app:
     session_state = gr.State()
     
     with gr.Column(visible=True) as screen_start:

app_test.py

@@ -1,379 +0,0 @@
-import asyncio
-import json
-import os
-from pathlib import Path
-from dotenv import load_dotenv
-load_dotenv()
-
-import gradio as gr
-
-ROOT = Path(__file__).parent
-GRAMMAR_PATH = ROOT / "grammar.gbnf"
-
-# Keep the demo runnable while the GGUF files are still being prepared.
-MOCK_MODE = os.getenv("STEP_ZERO_MOCK", "1") != "0"
-NEMOTRON_MODEL_PATH = os.getenv("NEMOTRON_MODEL_PATH", "./models/step-zero-nemotron-finetuned.gguf")
-MINICPM_MODEL_PATH = os.getenv("MINICPM_MODEL_PATH", "./models/minicpm-3-4b.gguf")
-
-if not MOCK_MODE:
-    from llama_cpp import Llama
-    from llama_cpp import LlamaGrammar
-
-    grammar = LlamaGrammar.from_file(str(GRAMMAR_PATH))
-
-    # Use small context windows to save RAM.
-    nemotron = Llama(model_path=NEMOTRON_MODEL_PATH, n_ctx=1024)
-    minicpm = Llama(model_path=MINICPM_MODEL_PATH, n_ctx=1024)
-
-# Per-model locks for concurrency
-nemotron_lock = asyncio.Lock()
-minicpm_lock = asyncio.Lock()
-
-async def run_nemotron(func, *args, **kwargs):
-    async with nemotron_lock:
-        return await asyncio.to_thread(func, *args, **kwargs)
-
-async def run_minicpm(func, *args, **kwargs):
-    async with minicpm_lock:
-        return await asyncio.to_thread(func, *args, **kwargs)
-
-MAX_TRACE_EVENTS = 50
-MAX_HISTORY_ITEMS = 20
-
-def append_trace(state, event: dict) -> None:
-    state["trace"].append(event)
-    if len(state["trace"]) > MAX_TRACE_EVENTS:
-        state["trace"] = state["trace"][-MAX_TRACE_EVENTS:]
-
-def append_history(state, displayed_task: str, raw_task: str) -> None:
-    state["history"].append(displayed_task)
-    state["raw_history"].append(raw_task)
-    if len(state["history"]) > MAX_HISTORY_ITEMS:
-        state["history"] = state["history"][-MAX_HISTORY_ITEMS:]
-    if len(state["raw_history"]) > MAX_HISTORY_ITEMS:
-        state["raw_history"] = state["raw_history"][-MAX_HISTORY_ITEMS:]
-
-def is_semantic_repeat(new_task: str, history: list) -> bool:
-    if not history:
-        return False
-    new_words = set(new_task.lower().split())
-    if not new_words:
-        return False
-    for past in history[-3:]:
-        past_words = set(past.lower().split())
-        if not past_words:
-            continue
-        overlap = len(new_words & past_words) / max(len(new_words | past_words), 1)
-        if overlap > 0.7:  # 70% word overlap = semantic repeat
-            return True
-    return False
-
-async def generate_atomic_task(goal: str, previous_failures: int, history: list = None, rejected_task: str = None) -> str:
-    if history is None:
-        history = []
-    
-    recent_history = history[-3:] if history else []
-    history_str = "\n".join([f"- {t}" for t in recent_history]) if recent_history else "None"
-    
-    if MOCK_MODE:
-        await asyncio.sleep(1) # Simulate inference latency
-        demo_steps = [
-            "Open a new browser tab.",
-            "Create a blank document.",
-            "Write the first sentence.",
-            "Save the file.",
-        ]
-        if previous_failures == 1:
-            return "Move your mouse to the browser icon."
-        return demo_steps[min(len(history), len(demo_steps) - 1)]
-            
-    else:
-        # If a task was rejected as too hard, route to MiniCPM to break it down further
-        if previous_failures > 0 and rejected_task:
-            print(f"TASK WAS REJECTED ('{rejected_task}'). ROUTING TO MINICPM FOR SUB-STEP BREAKDOWN...", flush=True)
-            messages = [
-                {"role": "system", "content": "You are a cognitive pacemaker. When a task is too hard, break it down into a single, even simpler, tiny physical starting action under 8 words. Return ONLY the starting action. CRITICAL: Focus strictly on the physical movement. Do NOT suggest thinking, planning, or remembering."},
-                {"role": "user", "content": f"The task '{rejected_task}' was too hard. Break it down into a single, even simpler physical starting action."}
-            ]
-            fallback_res = await run_minicpm(
-                minicpm.create_chat_completion,
-                messages=messages,
-                max_tokens=20, 
-                temperature=0.1
-            )
-            content = fallback_res['choices'][0]['message']['content'].strip()
-            print(f"MINICPM BREAKDOWN OUT: {content}", flush=True)
-            content = content.strip('"\' ,.-1234567890)')
-            return content or "Focus on the screen."
-
-        # REAL INFERENCE using the exact string template used during fine-tuning
-        system_msg = "You are a cognitive pacemaker. Break down goals into extremely tiny, atomic physical actions under 8 words."
-        
-        prompt = f"<extra_id_0>System\n{system_msg}\n\n"
-        prompt += f"<extra_id_1>User\nGoal: {goal}\nCompleted Tasks: {history_str}\nFailures: {previous_failures}\nOutput the NEXT step.\n"
-        prompt += f"<extra_id_1>Assistant\n"
-        
-        response = await run_nemotron(
-            nemotron,
-            prompt,
-            max_tokens=20, 
-            temperature=0.3,
-            stop=["\n", "<extra_id_1>"],
-            grammar=grammar # Enforcing grammar here!
-        )
-        content = response['choices'][0]['text'].strip()
-        
-        # Check if output is empty or a repetition
-        is_invalid = not content or is_semantic_repeat(content, history)
-        
-        if is_invalid:
-            print(f"NEMOTRON OUTPUT INVALID OR REPETITION ('{content}'). FALLING BACK TO MINICPM...", flush=True)
-            last_task = history[-1] if history else ""
-            user_content = f"Goal: {goal}\nCompleted Tasks: {history_str}\nFailures: {previous_failures}\n"
-            if last_task:
-                user_content += f"CRITICAL: Do NOT output '{last_task}'. Output the strictly NEXT new physical step."
-            else:
-                user_content += "Output the NEXT step."
-            
-            messages = [
-                {"role": "system", "content": "You are a cognitive pacemaker. Focus strictly on the physical goal and break it down into an extremely tiny, atomic physical action under 8 words. Ignore mental blocks or feelings of being stuck and output ONLY the single physical action step."},
-                {"role": "user", "content": user_content}
-            ]
-            fallback_res = await run_minicpm(
-                minicpm.create_chat_completion,
-                messages=messages,
-                max_tokens=20, 
-                temperature=0.1
-            )
-            content = fallback_res['choices'][0]['message']['content'].strip()
-            print(f"MINICPM FALLBACK OUT: {content}", flush=True)
-        else:
-            print(f"NEMOTRON RAW OUT: {content}", flush=True)
-            
-        content = content.strip('"\' ,.-1234567890)')
-        return content or "Focus on the screen."
-
-async def apply_activation_style(task: str, style="direct") -> str:
-    if MOCK_MODE:
-        await asyncio.sleep(0.5)
-        if style == "calm":
-            return f"When you are ready, {task[0].lower()}{task[1:]}"
-        if style == "encouraging":
-            return f"You can do this: {task}"
-        return f"{task} Now."
-        
-    else:
-        # REAL INFERENCE
-        if style == "direct":
-            return f"{task.capitalize()}."
-            
-        if style == "encouraging":
-            system_prompt = (
-                "You are a cognitive pacemaker. Rewrite the given task into an encouraging, supportive tone.\n"
-                "RULES:\n"
-                "1. Keep it as an action/command the user MUST do now. Start or end with an encouraging phrase like 'You got this!', 'Let's do it!', or 'Go ahead and...'.\n"
-                "2. Do NOT write in the past tense, do NOT congratulate the user, and do NOT treat the task as already completed.\n"
-                "3. Limit your response to EXACTLY ONE short sentence (under 12 words) and output ONLY the final rewritten task."
-            )
-        elif style == "calm":
-            system_prompt = (
-                "You are a cognitive pacemaker. Rewrite the given task into a calm, gentle tone.\n"
-                "RULES:\n"
-                "1. Keep it as an action/command. Use gentle prefixes like 'When you are ready, ...' or 'Take your time and ...'.\n"
-                "2. Do NOT write in the past tense and do NOT congratulate the user.\n"
-                "3. Limit your response to EXACTLY ONE short sentence (under 12 words) and output ONLY the final rewritten task."
-            )
-        else:
-            system_prompt = (
-                f"You are a cognitive pacemaker. Rewrite the given task into a {style} tone.\n"
-                "RULES:\n"
-                "1. Keep it as an action/command the user MUST do now.\n"
-                "2. Do NOT write in the past tense, do NOT congratulate the user, and do NOT treat the task as already completed.\n"
-                "3. Limit your response to EXACTLY ONE short sentence (under 12 words) and output ONLY the final rewritten task."
-            )
-
-        messages = [
-            {"role": "system", "content": system_prompt},
-            {"role": "user", "content": f"Task: {task}"}
-        ]
-        response = await run_minicpm(
-            minicpm.create_chat_completion,
-            messages=messages,
-            max_tokens=40,
-            temperature=0.2
-        )
-        content = response['choices'][0]['message']['content'].strip()
-        print(f"MINICPM RAW OUT: {content}", flush=True)
-        return content
-
-# --- GRADIO UI ---
-
-custom_css = """
-body { background-color: #0a0a0a; color: #ffffff; font-family: 'Helvetica Neue', sans-serif; }
-.gradio-container { background-color: transparent !important; border: none !important; }
-footer { display: none !important; }
-.fog { opacity: 0.3; filter: blur(2px); transition: all 0.5s ease; }
-.fade-in { animation: fadeIn 0.5s ease-in forwards; }
-@keyframes fadeIn { from { opacity: 0; transform: translateY(10px); } to { opacity: 1; transform: translateY(0); } }
-
-/* Goal Input Styling */
-#goal-input textarea {
-    background: transparent !important;
-    border: none !important;
-    border-bottom: 2px solid #4b5563 !important;
-    color: white !important;
-    font-size: 1.5rem !important;
-    text-align: center !important;
-    box-shadow: none !important;
-    border-radius: 0 !important;
-}
-#goal-input textarea:focus { border-bottom: 2px solid white !important; }
-
-/* Buttons */
-#btn-done { background-color: #16a34a !important; color: white !important; font-weight: bold; font-size: 1.25rem !important; }
-#btn-skip { background-color: #4b5563 !important; color: white !important; font-weight: bold; font-size: 1.25rem !important; }
-#btn-hard { background-color: #1f2937 !important; color: #d1d5db !important; font-weight: bold; font-size: 1.25rem !important; }
-#btn-trace { background: transparent !important; border: none !important; color: #4b5563 !important; text-transform: uppercase; letter-spacing: 0.1em; font-size: 0.75rem !important; }
-#btn-trace:hover { color: #d1d5db !important; }
-
-/* Big Task Text */
-#current-task { text-align: center; font-size: 3rem; font-weight: 800; min-height: 150px; display: flex; align-items: center; justify-content: center; }
-@media (min-width: 768px) { #current-task { font-size: 4.5rem; } }
-"""
-
-def generate_breadcrumbs_html(history: list) -> str:
-    html = "<div class='fog text-sm space-y-2'>"
-    for t in history:
-        html += f"<div>✓ {t}</div>"
-    html += "</div>"
-    return html
-
-def generate_task_html(task: str, animate=True) -> str:
-    class_str = "fade-in" if animate else ""
-    return f"<div id='current-task' class='{class_str}'>{task}</div>"
-
-async def process_step(state, action: str, goal: str = None, style: str = None, last_task: str = None):
-    if not state:
-        state = {}
-    # Initialization
-    if action == "start":
-        state["goal"] = goal
-        state["style"] = style
-        state["current_task"] = ""
-        state["current_raw_task"] = ""
-        state["too_hard_count"] = 0
-        state["history"] = []
-        state["raw_history"] = []
-        state["trace"] = [{"event": "start", "goal": state["goal"], "style": state["style"]}]
-        
-    elif action == "too_hard":
-        state["too_hard_count"] += 1
-        append_trace(state, {
-            "event": "too_hard",
-            "task": state["current_task"],
-            "too_hard_count": state["too_hard_count"],
-        })
-        
-    elif action == "skip":
-        append_trace(state, {"event": "skip", "task": state["current_task"]})
-        # Note: Do not increment too_hard_count
-        
-    elif action == "done":
-        state["too_hard_count"] = 0
-        if last_task:
-            raw_task_done = state.get("current_raw_task") or last_task
-            append_history(state, last_task, raw_task_done)
-            append_trace(state, {"event": "done", "task": last_task})
-    
-    # HARD CIRCUIT BREAKER
-    if state["too_hard_count"] >= 3:
-        breaker_task = "You are out of activation energy. Step away from the screen for 3 minutes. I will be here."
-        state["current_task"] = breaker_task
-        append_trace(state, {"event": "circuit_breaker", "task": breaker_task})
-        state["too_hard_count"] = 0 # Reset after breaking
-        return state, generate_task_html(breaker_task), generate_breadcrumbs_html(state["history"][-3:]), gr.update(visible=False)
-
-    # Standard Loop
-    rejected_task = state["current_task"] if state["too_hard_count"] > 0 else None
-    
-    raw_task = await generate_atomic_task(
-        state["goal"],
-        state["too_hard_count"],
-        history=state["raw_history"],
-        rejected_task=rejected_task,
-    )
-    styled_task = await apply_activation_style(raw_task, state["style"])
-    state["current_task"] = styled_task
-    state["current_raw_task"] = raw_task
-    
-    append_trace(state, {
-        "event": "generated_step",
-        "raw_task": raw_task,
-        "styled_task": styled_task,
-        "style": state["style"],
-        "too_hard_count": state["too_hard_count"],
-    })
-    
-    return state, generate_task_html(styled_task), generate_breadcrumbs_html(state["history"][-3:]), gr.update(visible=True)
-
-with gr.Blocks(css=custom_css, title="Step-Zero") as app:
-    session_state = gr.State()
-    
-    with gr.Column(visible=True) as screen_start:
-        gr.HTML("<h1 class='text-4xl font-bold mb-8 text-center mt-20'>What is paralyzing you?</h1>")
-        goal_input = gr.Textbox(elem_id="goal-input", show_label=False, placeholder="e.g. Write my thesis...", lines=1)
-        
-        with gr.Row(elem_classes="justify-center mt-8"):
-            style_radio = gr.Radio(
-                choices=["direct", "calm", "encouraging"], 
-                value="direct", 
-                show_label=False,
-                container=False
-            )
-            
-        start_btn = gr.Button("Start", variant="primary", elem_classes="mt-8 mx-auto w-48")
-        
-    with gr.Column(visible=False) as screen_task:
-        breadcrumbs_display = gr.HTML(elem_id="breadcrumbs-container")
-        task_display = gr.HTML(elem_id="task-container")
-        
-        with gr.Row(elem_id="controls-container") as controls_row:
-            btn_done = gr.Button("I DID THIS", elem_id="btn-done")
-            btn_skip = gr.Button("SKIP", elem_id="btn-skip")
-            btn_hard = gr.Button("TOO HARD", elem_id="btn-hard")
-            
-        with gr.Row(elem_classes="justify-center mt-4 gap-4"):
-            btn_trace = gr.Button("Export Trace", elem_id="btn-trace")
-            btn_push = gr.Button("Push to Hub", elem_id="btn-trace")
-            
-        trace_download = gr.File(visible=False)
-        hub_status = gr.HTML(visible=False, elem_classes="text-center text-sm text-gray-400 mt-2")
-
-    # Temporary Loading State Function
-    def show_loading():
-        return gr.update(visible=False), gr.update(visible=True), generate_task_html("<span class='text-gray-600 animate-pulse'>Calculating constraint...</span>", animate=False), gr.update(visible=False)
-
-    def show_loading_step():
-        return generate_task_html("<span class='text-gray-600 animate-pulse'>Loading next step...</span>", animate=False), gr.update(visible=False)
-        
-    # --- Event Handlers ---
-    
-    async def handle_start(state, goal, style):
-        return await process_step(state, "start", goal=goal, style=style)
-        
-    async def handle_done(state):
-        if not state: state = {}
-        return await process_step(state, "done", last_task=state.get("current_task"))
-        
-    async def handle_skip(state):
-        return await process_step(state, "skip")
-        
-    async def handle_too_hard(state):
-        return await process_step(state, "too_hard")
-    
-    # Start Session
-    start_btn.click(
-        fn=show_loading,
-        outputs=[screen_start, screen_task, task_display, controls_row]
-    ).then(
-        fn=handle_start,

field_notes.md

@@ -0,0 +1,71 @@
+# Field Notes: Building Step-Zero (Cognitive Pacemaker)
+
+Step-Zero is a local-first "Cognitive Pacemaker" application designed to break down overwhelming goals into atomic physical actions to overcome executive dysfunction.
+
+During development, we encountered several unique challenges in aligning very small language models (≤4B parameters) to produce strictly physical actions under strict grammar constraints. Here is the report of what we built, what we learned, and how we optimized the system.
+
+---
+
+## 1. System Architecture
+
+The core of Step-Zero is a **dual-model orchestrator** that runs entirely locally on CPU/laptop hardware via `llama.cpp` runtimes.
+
+```
+                  ┌──────────────────────┐
+                  │ Goal & UI Input      │
+                  └──────────┬───────────┘
+                             │
+                             ▼
+               ┌───────────────────────────┐
+               │ Primary Model (Nemotron)  │
+               └─────────────┬─────────────┘
+                             │
+                     [Output Valid?]
+                     /             \
+                   Yes              No (or "Too Hard")
+                   /                 \
+                  ▼                   ▼
+      ┌──────────────────────┐   ┌───────────────────────┐
+      │ Render Action in UI  │   │ Fallback (MiniCPM)    │
+      └──────────────────────┘   └───────────────────────┘
+```
+
+1. **Primary Model (Nemotron-Mini-4B):** Fine-tuned specifically for step breakdown using a synthetic task-reduction dataset (`verbs.jsonl`).
+2. **Fallback Model (MiniCPM-3-4B):** An instruction-following model used for stylistic adjustment, semantic repetition recovery, and breaking down actions when the user signals "Too Hard".
+
+---
+
+## 2. Technical Alignments & Guardrails
+
+Deploying small LLMs locally introduces high variability in output formatting. We implemented three layers of guardrails to enforce strict formatting:
+
+### A. GBNF Grammars
+We defined a GBNF grammar (`[a-zA-Z0-9 ,.!?'-]+`) to force the models to generate raw plain text rather than markdown lists, JSON objects, or verbose chat commentary. This bypasses the need for complex output parser libraries.
+
+### B. Output Validation & First-Sentence Extraction
+Small fine-tuned models can experience "prompt leakage" or echo prompt formatting when encountering out-of-distribution user inputs. To solve this, we implemented a custom post-processing pipeline that:
+- Splits output at sentence boundaries to extract only the *first* sentence (guaranteeing one atomic starting action).
+- Validates the output against a list of prompt scaffolding keywords (e.g. `Completed Tasks`, `User`, `Assistant`, `Failures`).
+- Immediately routes any invalid or overly verbose output to the fallback MiniCPM model.
+
+### C. Semantic Repetition Guard
+Instead of exact string matching, we implemented a sliding-window overlap check. If a newly generated action has >70% word overlap with the user's recent history or skipped tasks, the system intercepts it as a repetition loop and routes it to MiniCPM to generate a novel alternative.
+
+### D. Hard Circuit Breaker
+If the user indicates a task is "Too Hard" three times consecutively, the app triggers a hard-coded cooldown screen: *"You are out of activation energy. Step away from the screen for 3 minutes. I will be here."* This prevents the AI from entering infinite breakdown loops that increase user frustration.
+
+---
+
+## 3. Custom UI/UX: The "Fog of War"
+
+To support the cognitive design of the pacemaker (which aims to reduce cognitive load), the app features a minimal, custom dark theme. By leveraging Gradio's CSS custom properties on `:root` and `.dark`, we overrode Gradio's standard elements to deliver a clean, borderless dark UI styled like a game interface:
+- **Fog of War:** Completed history is styled with low opacity (`opacity: 0.3`) and blurred (`filter: blur(2px)`) to keep the user's attention anchored on the single next step.
+- **Minimalist Controls:** Big, clear action buttons ("I DID THIS", "SKIP", "TOO HARD") keep user interactions simple.
+
+---
+
+## 4. Key Takeaways & Small Model Constraints
+
+1. **Alignment Tax on Small Models:** Fine-tuning a 4B model changes its distribution significantly. Even mild discrepancies between fine-tuning format and inference prompts can lead to format breakdown. A strict post-validation filter is essential when building production applications around them.
+2. **Grammar Constraints are a Superpower:** Restricting token generation at the sampler level is far more efficient than prompt-engineering a small model to follow output rules.
+3. **Local-First is Ready:** With optimized GGUF quantizations, both Nemotron and MiniCPM run under 50ms per token on modern consumer laptops.

implemention_plan.md

@@ -1,72 +0,0 @@
-This is your **Final Execution Playbook**. All the VC fluff, fake science, and over-engineered bloat have been stripped out.
-
-What remains is a brutally effective, highly defensible 48-hour sprint to build **Step-Zero: The Cognitive Pacemaker**.
-
-The core thesis you are building (and pitching) is this: *“What if an AI refused to let you think about more than one thing at a time?”*
-
-Here is the step-by-step implementation plan to build the tech, hit the corporate bounties, and record the winning demo.
-
----
-
-### The Bounty Matrix (Your Checklist)
-
-* **Track:** Backyard AI 🏡 (Target: Anyone paralyzed by task friction).
-* **NVIDIA ($10k) + Llama Champion:** `Nemotron-Mini-4B` running locally via `llama-cpp-python` to generate the strict logic steps.
-* **OpenBMB ($10k):** `MiniCPM-3-4B` running locally to translate the logic step into the user's chosen "Activation Style" (Calm, Structured, Direct).
-* **Modal ($20k) + Well-Tuned:** A fast LoRA fine-tune on Nemotron explicitly for *Syntactic Verb Enforcement* (forcing outputs under 8 words starting with an action verb).
-* **OpenAI ($10k) + Off-Brand:** Custom HTML/JS "Fog of War" frontend generated 100% by GitHub Copilot/Codex, served over Gradio `gr.Server`.
-* **Badges:** Tiny Titan (≤4B models), Off the Grid (100% offline inference), Sharing is Caring (Agent JSON trace export).
-
----
-
-### Phase 1: The Modal Fine-Tuning Sprint (Friday Night)
-
-*You do this first so you can use the fine-tuned model all weekend.*
-
-1. **The Dataset (`verbs.jsonl`):** Create 200 rows of training data.
-* *Input:* "I need to clean my room but I am paralyzed."
-* *Output:* "Pick up one sock." *(Notice: No conversational fluff. Starts with a verb. Under 8 words).*
-
-
-2. **The Modal Script:** Use Modal's serverless GPU to run an Unsloth script. Fine-tune `Nemotron-Mini-4B` on this dataset to heavily bias it toward strict, atomic, imperative statements.
-3. **The Export:** Download the adapter weights, convert to `.gguf`, and save it to your local machine as `nemotron_atomic_v1.gguf`.
-
-### Phase 2: The Local Engine & Circuit Breaker (Saturday Morning)
-
-*You build the Python backend that hot-swaps the models to keep RAM under 6GB.*
-
-1. **The GBNF Grammar:** Write a `Llama.cpp` grammar file that forces Nemotron to *only* output a single string, stripping its ability to hallucinate markdown or lists.
-2. **The State Machine (`app.py`):** * Initialize a fastAPI/Gradio backend with a simple Python dictionary for state: `{"current_task": "", "too_hard_count": 0, "past_steps": []}`.
-3. **The `[TOO HARD]` Fallback Loop:** * If the user hits `[TOO HARD]`, Python increments the counter.
-* It passes the current task back to Nemotron: *"The user failed to do: [Task]. Provide a physically smaller, easier pre-requisite action."*
-
-
-4. **The Hard Circuit Breaker:** * If `too_hard_count == 2`, the backend bypasses the LLM entirely and hard-returns: *"You are out of activation energy. Step away from the screen for 3 minutes. Leave this window open."* (This proves to judges you care about UX, not just spamming AI outputs).
-
-### Phase 3: The OpenBMB Stylizer (Saturday Afternoon)
-
-1. **The Pipeline:** Once Nemotron outputs the raw atomic step (e.g., "Open the PDF"), Python pipes that string into OpenBMB.
-2. **The Persona Prompt:** OpenBMB receives: *"Rewrite this task: 'Open the PDF' in a [Calm/Direct/Encouraging] tone. Keep it under 2 sentences."*
-3. **WebSocket Broadcast:** The final stylized text is pushed to the frontend via Gradio's Async API or a raw WebSocket.
-
-### Phase 4: The Codex "Fog of War" UI (Saturday Night)
-
-*Do not write this yourself. You must use Codex/Copilot to win the OpenAI track.*
-
-1. Open VS Code and use the Copilot Chat panel.
-2. **Your exact prompt to Copilot:** > *"Generate a single-page HTML/JS/Tailwind interface. It must have a pure black background. At the top, put a very faint, blurred text area called 'Breadcrumbs'. In the dead center, place a massive text block (72px font, white) for a single instruction. Below it, place two buttons: A green [I DID THIS] button, and a muted gray [THIS IS TOO HARD] button. Write the WebSocket JS to connect to a local backend at `ws://localhost:7860`. When the user clicks [I DID THIS], the center text fades out, moves to the blurred 'Breadcrumbs' section, and the new text fades in. Do not use standard chatbot layouts."*
-3. **Commit the Code:** Make a git commit with the message: `feat: Generated proprietary Fog of War SPA interface using OpenAI Codex`.
-4. Serve this `index.html` file using `gr.Server(serve_static=["index.html"])`.
-
-### Phase 5: The Demo & The Pitch (Sunday)
-
-The demo video is where you separate yourselves from the "wrapper" projects.
-
-**The Video Script (Keep it tight and grounded):**
-
-1. **The Hook (0:00-0:15):** *"Standard AI assistants are built for conversation and expansion. But when a user is experiencing executive dysfunction or task paralysis, a conversational list is overwhelming. We built Step-Zero: a local-only Cognitive Pacemaker that enforces strict attentional constraints. It refuses to let you see the future."*
-2. **The Tech Flex (0:15-0:45):** *"Because this involves sensitive behavioral friction, it runs 100% off-the-grid. We used Modal to fine-tune Nemotron-4B to strictly output 8-word imperative verbs. Nemotron manages our hidden friction-state machine. Once a task is scaled to the user's capability, OpenBMB-4B dynamically translates the tone to match the user's required activation energy."*
-3. **The UI Flex (0:45-1:15):** *"Gradio's default chat interface couldn't handle our 'Fog of War' design, so we used OpenAI Codex to generate a completely custom, headless DOM overlay hosted via `gr.Server`."*
-4. **The Live Demo (1:15-2:00):** Show the app. Type *"I need to write my tax report."* Show the screen displaying only *"Open a new folder."* Hit `[TOO HARD]`. Show Nemotron dynamically downgrading the task to *"Click the finder icon."* Hit `[TOO HARD]` again. Show the Circuit Breaker activating: *"Walk away for 3 minutes."*
-
-**Final check:** Does this plan align with your team's capability to split the work? One person on the Llama.cpp backend (Python), one person wrangling the Copilot frontend (HTML/JS), and one person managing the Modal Fine-tune (Data/Unsloth)?

output.txt

@@ -1,417 +0,0 @@
-ERROR:    Exception in ASGI application
-Traceback (most recent call last):
-  File "/usr/local/lib/python3.12/dist-packages/uvicorn/protocols/http/httptools_impl.py", line 409, in run_asgi
-    result = await app(  # type: ignore[func-returns-value]
-             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/uvicorn/middleware/proxy_headers.py", line 60, in __call__
-    return await self.app(scope, receive, send)
-           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/fastapi/applications.py", line 1054, in __call__
-    await super().__call__(scope, receive, send)
-  File "/usr/local/lib/python3.12/dist-packages/starlette/applications.py", line 113, in __call__
-    await self.middleware_stack(scope, receive, send)
-  File "/usr/local/lib/python3.12/dist-packages/starlette/middleware/errors.py", line 187, in __call__
-    raise exc
-  File "/usr/local/lib/python3.12/dist-packages/starlette/middleware/errors.py", line 165, in __call__
-    await self.app(scope, receive, _send)
-  File "/usr/local/lib/python3.12/dist-packages/gradio/route_utils.py", line 789, in __call__
-    await self.app(scope, receive, send)
-  File "/usr/local/lib/python3.12/dist-packages/starlette/middleware/exceptions.py", line 62, in __call__
-    await wrap_app_handling_exceptions(self.app, conn)(scope, receive, send)
-  File "/usr/local/lib/python3.12/dist-packages/starlette/_exception_handler.py", line 53, in wrapped_app
-    raise exc
-  File "/usr/local/lib/python3.12/dist-packages/starlette/_exception_handler.py", line 42, in wrapped_app
-    await app(scope, receive, sender)
-  File "/usr/local/lib/python3.12/dist-packages/starlette/routing.py", line 715, in __call__
-    await self.middleware_stack(scope, receive, send)
-  File "/usr/local/lib/python3.12/dist-packages/starlette/routing.py", line 735, in app
-    await route.handle(scope, receive, send)
-  File "/usr/local/lib/python3.12/dist-packages/starlette/routing.py", line 288, in handle
-    await self.app(scope, receive, send)
-  File "/usr/local/lib/python3.12/dist-packages/starlette/routing.py", line 76, in app
-    await wrap_app_handling_exceptions(app, request)(scope, receive, send)
-  File "/usr/local/lib/python3.12/dist-packages/starlette/_exception_handler.py", line 53, in wrapped_app
-    raise exc
-  File "/usr/local/lib/python3.12/dist-packages/starlette/_exception_handler.py", line 42, in wrapped_app
-    await app(scope, receive, sender)
-  File "/usr/local/lib/python3.12/dist-packages/starlette/routing.py", line 73, in app
-    response = await f(request)
-               ^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/fastapi/routing.py", line 301, in app
-    raw_response = await run_endpoint_function(
-                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/fastapi/routing.py", line 214, in run_endpoint_function
-    return await run_in_threadpool(dependant.call, **values)
-           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/starlette/concurrency.py", line 39, in run_in_threadpool
-    return await anyio.to_thread.run_sync(func, *args)
-           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/anyio/to_thread.py", line 63, in run_sync
-    return await get_async_backend().run_sync_in_worker_thread(
-           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/anyio/_backends/_asyncio.py", line 2502, in run_sync_in_worker_thread
-    return await future
-           ^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/anyio/_backends/_asyncio.py", line 986, in run
-    result = context.run(func, *args)
-             ^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/gradio/routes.py", line 552, in main
-    gradio_api_info = api_info(request)
-                      ^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/gradio/routes.py", line 582, in api_info
-    api_info = utils.safe_deepcopy(app.get_blocks().get_api_info())
-                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/gradio/blocks.py", line 2992, in get_api_info
-    python_type = client_utils.json_schema_to_python_type(info)
-                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/gradio_client/utils.py", line 920, in json_schema_to_python_type
-    type_ = _json_schema_to_python_type(schema, schema.get("$defs"))
-            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/gradio_client/utils.py", line 975, in _json_schema_to_python_type
-    f"{n}: {_json_schema_to_python_type(v, defs)}{get_desc(v)}"
-            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/gradio_client/utils.py", line 982, in _json_schema_to_python_type
-    f"str, {_json_schema_to_python_type(schema['additionalProperties'], defs)}"
-            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/gradio_client/utils.py", line 928, in _json_schema_to_python_type
-    type_ = get_type(schema)
-            ^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/gradio_client/utils.py", line 887, in get_type
-    if "const" in schema:
-       ^^^^^^^^^^^^^^^^^
-TypeError: argument of type 'bool' is not iterable
-ERROR:    Exception in ASGI application
-Traceback (most recent call last):
-  File "/usr/local/lib/python3.12/dist-packages/uvicorn/protocols/http/httptools_impl.py", line 409, in run_asgi
-    result = await app(  # type: ignore[func-returns-value]
-             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/uvicorn/middleware/proxy_headers.py", line 60, in __call__
-    return await self.app(scope, receive, send)
-           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/fastapi/applications.py", line 1054, in __call__
-    await super().__call__(scope, receive, send)
-  File "/usr/local/lib/python3.12/dist-packages/starlette/applications.py", line 113, in __call__
-    await self.middleware_stack(scope, receive, send)
-  File "/usr/local/lib/python3.12/dist-packages/starlette/middleware/errors.py", line 187, in __call__
-    raise exc
-  File "/usr/local/lib/python3.12/dist-packages/starlette/middleware/errors.py", line 165, in __call__
-    await self.app(scope, receive, _send)
-  File "/usr/local/lib/python3.12/dist-packages/gradio/route_utils.py", line 789, in __call__
-    await self.app(scope, receive, send)
-  File "/usr/local/lib/python3.12/dist-packages/starlette/middleware/exceptions.py", line 62, in __call__
-    await wrap_app_handling_exceptions(self.app, conn)(scope, receive, send)
-  File "/usr/local/lib/python3.12/dist-packages/starlette/_exception_handler.py", line 53, in wrapped_app
-    raise exc
-  File "/usr/local/lib/python3.12/dist-packages/starlette/_exception_handler.py", line 42, in wrapped_app
-    await app(scope, receive, sender)
-  File "/usr/local/lib/python3.12/dist-packages/starlette/routing.py", line 715, in __call__
-    await self.middleware_stack(scope, receive, send)
-  File "/usr/local/lib/python3.12/dist-packages/starlette/routing.py", line 735, in app
-    await route.handle(scope, receive, send)
-  File "/usr/local/lib/python3.12/dist-packages/starlette/routing.py", line 288, in handle
-    await self.app(scope, receive, send)
-  File "/usr/local/lib/python3.12/dist-packages/starlette/routing.py", line 76, in app
-    await wrap_app_handling_exceptions(app, request)(scope, receive, send)
-  File "/usr/local/lib/python3.12/dist-packages/starlette/_exception_handler.py", line 53, in wrapped_app
-    raise exc
-  File "/usr/local/lib/python3.12/dist-packages/starlette/_exception_handler.py", line 42, in wrapped_app
-    await app(scope, receive, sender)
-  File "/usr/local/lib/python3.12/dist-packages/starlette/routing.py", line 73, in app
-    response = await f(request)
-               ^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/fastapi/routing.py", line 301, in app
-    raw_response = await run_endpoint_function(
-                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/fastapi/routing.py", line 214, in run_endpoint_function
-    return await run_in_threadpool(dependant.call, **values)
-           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/starlette/concurrency.py", line 39, in run_in_threadpool
-    return await anyio.to_thread.run_sync(func, *args)
-           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/anyio/to_thread.py", line 63, in run_sync
-    return await get_async_backend().run_sync_in_worker_thread(
-           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/anyio/_backends/_asyncio.py", line 2502, in run_sync_in_worker_thread
-    return await future
-           ^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/anyio/_backends/_asyncio.py", line 986, in run
-    result = context.run(func, *args)
-             ^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/gradio/routes.py", line 552, in main
-    gradio_api_info = api_info(request)
-                      ^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/gradio/routes.py", line 582, in api_info
-    api_info = utils.safe_deepcopy(app.get_blocks().get_api_info())
-                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/gradio/blocks.py", line 2992, in get_api_info
-    python_type = client_utils.json_schema_to_python_type(info)
-                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/gradio_client/utils.py", line 920, in json_schema_to_python_type
-    type_ = _json_schema_to_python_type(schema, schema.get("$defs"))
-            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/gradio_client/utils.py", line 975, in _json_schema_to_python_type
-    f"{n}: {_json_schema_to_python_type(v, defs)}{get_desc(v)}"
-            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/gradio_client/utils.py", line 982, in _json_schema_to_python_type
-    f"str, {_json_schema_to_python_type(schema['additionalProperties'], defs)}"
-            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/gradio_client/utils.py", line 928, in _json_schema_to_python_type
-    type_ = get_type(schema)
-            ^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/gradio_client/utils.py", line 887, in get_type
-    if "const" in schema:
-       ^^^^^^^^^^^^^^^^^
-TypeError: argument of type 'bool' is not iterable
-ERROR:    Exception in ASGI application
-Traceback (most recent call last):
-  File "/usr/local/lib/python3.12/dist-packages/uvicorn/protocols/http/httptools_impl.py", line 409, in run_asgi
-    result = await app(  # type: ignore[func-returns-value]
-             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/uvicorn/middleware/proxy_headers.py", line 60, in __call__
-    return await self.app(scope, receive, send)
-           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/fastapi/applications.py", line 1054, in __call__
-    await super().__call__(scope, receive, send)
-  File "/usr/local/lib/python3.12/dist-packages/starlette/applications.py", line 113, in __call__
-    await self.middleware_stack(scope, receive, send)
-  File "/usr/local/lib/python3.12/dist-packages/starlette/middleware/errors.py", line 187, in __call__
-    raise exc
-  File "/usr/local/lib/python3.12/dist-packages/starlette/middleware/errors.py", line 165, in __call__
-    await self.app(scope, receive, _send)
-  File "/usr/local/lib/python3.12/dist-packages/gradio/route_utils.py", line 789, in __call__
-    await self.app(scope, receive, send)
-  File "/usr/local/lib/python3.12/dist-packages/starlette/middleware/exceptions.py", line 62, in __call__
-    await wrap_app_handling_exceptions(self.app, conn)(scope, receive, send)
-  File "/usr/local/lib/python3.12/dist-packages/starlette/_exception_handler.py", line 53, in wrapped_app
-    raise exc
-  File "/usr/local/lib/python3.12/dist-packages/starlette/_exception_handler.py", line 42, in wrapped_app
-    await app(scope, receive, sender)
-  File "/usr/local/lib/python3.12/dist-packages/starlette/routing.py", line 715, in __call__
-    await self.middleware_stack(scope, receive, send)
-  File "/usr/local/lib/python3.12/dist-packages/starlette/routing.py", line 735, in app
-    await route.handle(scope, receive, send)
-  File "/usr/local/lib/python3.12/dist-packages/starlette/routing.py", line 288, in handle
-    await self.app(scope, receive, send)
-  File "/usr/local/lib/python3.12/dist-packages/starlette/routing.py", line 76, in app
-    await wrap_app_handling_exceptions(app, request)(scope, receive, send)
-  File "/usr/local/lib/python3.12/dist-packages/starlette/_exception_handler.py", line 53, in wrapped_app
-    raise exc
-  File "/usr/local/lib/python3.12/dist-packages/starlette/_exception_handler.py", line 42, in wrapped_app
-    await app(scope, receive, sender)
-  File "/usr/local/lib/python3.12/dist-packages/starlette/routing.py", line 73, in app
-    response = await f(request)
-               ^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/fastapi/routing.py", line 301, in app
-    raw_response = await run_endpoint_function(
-                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/fastapi/routing.py", line 214, in run_endpoint_function
-    return await run_in_threadpool(dependant.call, **values)
-           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/starlette/concurrency.py", line 39, in run_in_threadpool
-    return await anyio.to_thread.run_sync(func, *args)
-           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/anyio/to_thread.py", line 63, in run_sync
-    return await get_async_backend().run_sync_in_worker_thread(
-           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/anyio/_backends/_asyncio.py", line 2502, in run_sync_in_worker_thread
-    return await future
-           ^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/anyio/_backends/_asyncio.py", line 986, in run
-    result = context.run(func, *args)
-             ^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/gradio/routes.py", line 552, in main
-    gradio_api_info = api_info(request)
-                      ^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/gradio/routes.py", line 582, in api_info
-    api_info = utils.safe_deepcopy(app.get_blocks().get_api_info())
-                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/gradio/blocks.py", line 2992, in get_api_info
-    python_type = client_utils.json_schema_to_python_type(info)
-                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/gradio_client/utils.py", line 920, in json_schema_to_python_type
-    type_ = _json_schema_to_python_type(schema, schema.get("$defs"))
-            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/gradio_client/utils.py", line 975, in _json_schema_to_python_type
-    f"{n}: {_json_schema_to_python_type(v, defs)}{get_desc(v)}"
-            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/gradio_client/utils.py", line 982, in _json_schema_to_python_type
-    f"str, {_json_schema_to_python_type(schema['additionalProperties'], defs)}"
-            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/gradio_client/utils.py", line 928, in _json_schema_to_python_type
-    type_ = get_type(schema)
-            ^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/gradio_client/utils.py", line 887, in get_type
-    if "const" in schema:
-       ^^^^^^^^^^^^^^^^^
-TypeError: argument of type 'bool' is not iterable
-ERROR:    Exception in ASGI application
-Traceback (most recent call last):
-  File "/usr/local/lib/python3.12/dist-packages/uvicorn/protocols/http/httptools_impl.py", line 409, in run_asgi
-    result = await app(  # type: ignore[func-returns-value]
-             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/uvicorn/middleware/proxy_headers.py", line 60, in __call__
-    return await self.app(scope, receive, send)
-           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/fastapi/applications.py", line 1054, in __call__
-    await super().__call__(scope, receive, send)
-  File "/usr/local/lib/python3.12/dist-packages/starlette/applications.py", line 113, in __call__
-    await self.middleware_stack(scope, receive, send)
-  File "/usr/local/lib/python3.12/dist-packages/starlette/middleware/errors.py", line 187, in __call__
-    raise exc
-  File "/usr/local/lib/python3.12/dist-packages/starlette/middleware/errors.py", line 165, in __call__
-    await self.app(scope, receive, _send)
-  File "/usr/local/lib/python3.12/dist-packages/gradio/route_utils.py", line 789, in __call__
-    await self.app(scope, receive, send)
-  File "/usr/local/lib/python3.12/dist-packages/starlette/middleware/exceptions.py", line 62, in __call__
-    await wrap_app_handling_exceptions(self.app, conn)(scope, receive, send)
-  File "/usr/local/lib/python3.12/dist-packages/starlette/_exception_handler.py", line 53, in wrapped_app
-    raise exc
-  File "/usr/local/lib/python3.12/dist-packages/starlette/_exception_handler.py", line 42, in wrapped_app
-    await app(scope, receive, sender)
-  File "/usr/local/lib/python3.12/dist-packages/starlette/routing.py", line 715, in __call__
-    await self.middleware_stack(scope, receive, send)
-  File "/usr/local/lib/python3.12/dist-packages/starlette/routing.py", line 735, in app
-    await route.handle(scope, receive, send)
-  File "/usr/local/lib/python3.12/dist-packages/starlette/routing.py", line 288, in handle
-    await self.app(scope, receive, send)
-  File "/usr/local/lib/python3.12/dist-packages/starlette/routing.py", line 76, in app
-    await wrap_app_handling_exceptions(app, request)(scope, receive, send)
-  File "/usr/local/lib/python3.12/dist-packages/starlette/_exception_handler.py", line 53, in wrapped_app
-    raise exc
-  File "/usr/local/lib/python3.12/dist-packages/starlette/_exception_handler.py", line 42, in wrapped_app
-    await app(scope, receive, sender)
-  File "/usr/local/lib/python3.12/dist-packages/starlette/routing.py", line 73, in app
-    response = await f(request)
-               ^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/fastapi/routing.py", line 301, in app
-    raw_response = await run_endpoint_function(
-                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/fastapi/routing.py", line 214, in run_endpoint_function
-    return await run_in_threadpool(dependant.call, **values)
-           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/starlette/concurrency.py", line 39, in run_in_threadpool
-    return await anyio.to_thread.run_sync(func, *args)
-           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/anyio/to_thread.py", line 63, in run_sync
-    return await get_async_backend().run_sync_in_worker_thread(
-           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/anyio/_backends/_asyncio.py", line 2502, in run_sync_in_worker_thread
-    return await future
-           ^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/anyio/_backends/_asyncio.py", line 986, in run
-    result = context.run(func, *args)
-             ^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/gradio/routes.py", line 552, in main
-    gradio_api_info = api_info(request)
-                      ^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/gradio/routes.py", line 582, in api_info
-    api_info = utils.safe_deepcopy(app.get_blocks().get_api_info())
-                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/gradio/blocks.py", line 2992, in get_api_info
-    python_type = client_utils.json_schema_to_python_type(info)
-                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/gradio_client/utils.py", line 920, in json_schema_to_python_type
-    type_ = _json_schema_to_python_type(schema, schema.get("$defs"))
-            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/gradio_client/utils.py", line 975, in _json_schema_to_python_type
-    f"{n}: {_json_schema_to_python_type(v, defs)}{get_desc(v)}"
-            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/gradio_client/utils.py", line 982, in _json_schema_to_python_type
-    f"str, {_json_schema_to_python_type(schema['additionalProperties'], defs)}"
-            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/gradio_client/utils.py", line 928, in _json_schema_to_python_type
-    type_ = get_type(schema)
-            ^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/gradio_client/utils.py", line 887, in get_type
-    if "const" in schema:
-       ^^^^^^^^^^^^^^^^^
-TypeError: argument of type 'bool' is not iterable
-ERROR:    Exception in ASGI application
-Traceback (most recent call last):
-  File "/usr/local/lib/python3.12/dist-packages/uvicorn/protocols/http/httptools_impl.py", line 409, in run_asgi
-    result = await app(  # type: ignore[func-returns-value]
-             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/uvicorn/middleware/proxy_headers.py", line 60, in __call__
-    return await self.app(scope, receive, send)
-           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/fastapi/applications.py", line 1054, in __call__
-    await super().__call__(scope, receive, send)
-  File "/usr/local/lib/python3.12/dist-packages/starlette/applications.py", line 113, in __call__
-    await self.middleware_stack(scope, receive, send)
-  File "/usr/local/lib/python3.12/dist-packages/starlette/middleware/errors.py", line 187, in __call__
-    raise exc
-  File "/usr/local/lib/python3.12/dist-packages/starlette/middleware/errors.py", line 165, in __call__
-    await self.app(scope, receive, _send)
-  File "/usr/local/lib/python3.12/dist-packages/gradio/route_utils.py", line 789, in __call__
-    await self.app(scope, receive, send)
-  File "/usr/local/lib/python3.12/dist-packages/starlette/middleware/exceptions.py", line 62, in __call__
-    await wrap_app_handling_exceptions(self.app, conn)(scope, receive, send)
-  File "/usr/local/lib/python3.12/dist-packages/starlette/_exception_handler.py", line 53, in wrapped_app
-    raise exc
-  File "/usr/local/lib/python3.12/dist-packages/starlette/_exception_handler.py", line 42, in wrapped_app
-    await app(scope, receive, sender)
-  File "/usr/local/lib/python3.12/dist-packages/starlette/routing.py", line 715, in __call__
-    await self.middleware_stack(scope, receive, send)
-  File "/usr/local/lib/python3.12/dist-packages/starlette/routing.py", line 735, in app
-    await route.handle(scope, receive, send)
-  File "/usr/local/lib/python3.12/dist-packages/starlette/routing.py", line 288, in handle
-    await self.app(scope, receive, send)
-  File "/usr/local/lib/python3.12/dist-packages/starlette/routing.py", line 76, in app
-    await wrap_app_handling_exceptions(app, request)(scope, receive, send)
-  File "/usr/local/lib/python3.12/dist-packages/starlette/_exception_handler.py", line 53, in wrapped_app
-    raise exc
-  File "/usr/local/lib/python3.12/dist-packages/starlette/_exception_handler.py", line 42, in wrapped_app
-    await app(scope, receive, sender)
-  File "/usr/local/lib/python3.12/dist-packages/starlette/routing.py", line 73, in app
-    response = await f(request)
-               ^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/fastapi/routing.py", line 301, in app
-    raw_response = await run_endpoint_function(
-                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/fastapi/routing.py", line 214, in run_endpoint_function
-    return await run_in_threadpool(dependant.call, **values)
-           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/starlette/concurrency.py", line 39, in run_in_threadpool
-    return await anyio.to_thread.run_sync(func, *args)
-           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/anyio/to_thread.py", line 63, in run_sync
-    return await get_async_backend().run_sync_in_worker_thread(
-           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/anyio/_backends/_asyncio.py", line 2502, in run_sync_in_worker_thread
-    return await future
-           ^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/anyio/_backends/_asyncio.py", line 986, in run
-    result = context.run(func, *args)
-             ^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/gradio/routes.py", line 552, in main
-    gradio_api_info = api_info(request)
-                      ^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/gradio/routes.py", line 582, in api_info
-    api_info = utils.safe_deepcopy(app.get_blocks().get_api_info())
-                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/gradio/blocks.py", line 2992, in get_api_info
-    python_type = client_utils.json_schema_to_python_type(info)
-                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/gradio_client/utils.py", line 920, in json_schema_to_python_type
-    type_ = _json_schema_to_python_type(schema, schema.get("$defs"))
-            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/gradio_client/utils.py", line 975, in _json_schema_to_python_type
-    f"{n}: {_json_schema_to_python_type(v, defs)}{get_desc(v)}"
-            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/gradio_client/utils.py", line 982, in _json_schema_to_python_type
-    f"str, {_json_schema_to_python_type(schema['additionalProperties'], defs)}"
-            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/gradio_client/utils.py", line 928, in _json_schema_to_python_type
-    type_ = get_type(schema)
-            ^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.12/dist-packages/gradio_client/utils.py", line 887, in get_type
-    if "const" in schema:
-       ^^^^^^^^^^^^^^^^^
-TypeError: argument of type 'bool' is not iterable
-* Running on local URL:  http://0.0.0.0:7860
-Traceback (most recent call last):
-  File "/root/step-zero/app.py", line 470, in <module>
-    app.launch(server_name="0.0.0.0", server_port=7860)
-  File "/usr/local/lib/python3.12/dist-packages/gradio/blocks.py", line 2619, in launch
-    raise ValueError(
-ValueError: When localhost is not accessible, a shareable link must be created. Please set share=True or check your proxy settings to allow access to localhost.

print_template.py

@@ -1,4 +0,0 @@
-from llama_cpp import Llama
-import json
-nem = Llama(model_path="./models/nemotron-mini-4b.gguf", n_ctx=1024, verbose=False)
-print("TEMPLATE:", nem.metadata.get("tokenizer.chat_template"))

requirements.txt

@@ -1,7 +1,4 @@
-fastapi==0.115.6
 gradio==5.9.1
-uvicorn[standard]==0.32.1
-websockets==14.1
 requests
 python-dotenv
 llama-cpp-python

scratch/test_models.py

@@ -0,0 +1,29 @@
+from llama_cpp import Llama, LlamaGrammar
+import os
+
+grammar = LlamaGrammar.from_file("grammar.gbnf")
+nemotron = Llama(model_path="./models/step-zero-nemotron-finetuned.gguf", n_ctx=1024, verbose=False)
+
+system_msg = "You are a cognitive pacemaker. Break down goals into extremely tiny, atomic physical actions under 8 words."
+
+goals = [
+    "I want to study",
+    "I want to clean my room",
+    "I need to write a python script"
+]
+
+for goal in goals:
+    prompt = f"<extra_id_0>System\n{system_msg}\n\n"
+    prompt += f"<extra_id_1>User\nGoal: {goal}\nCompleted Tasks: None\nFailures: 0\nOutput the NEXT step.\n"
+    prompt += f"<extra_id_1>Assistant\n"
+    
+    response = nemotron(
+        prompt,
+        max_tokens=64,
+        temperature=0.3,
+        stop=["\n", "<extra_id_1>"],
+        grammar=grammar
+    )
+    print(f"Goal: {goal}")
+    print(f"Response: {response['choices'][0]['text']}")
+    print("-" * 40)

semantic_test.py

@@ -1,38 +0,0 @@
-import asyncio
-import websockets
-import json
-
-GOALS = [
-    "clean my messy bedroom",
-    "write a python script to parse a csv",
-    "i feel overwhelmed by my taxes",
-    "cook dinner for 4 people",
-    "learn to play the guitar",
-    "i don't know what to do",
-    "read a 500 page book",
-    "plan a vacation to japan"
-]
-
-async def semantic_test():
-    uri = "ws://127.0.0.1:7860/ws"
-    
-    print("Running Semantic Stress Test...\n")
-    
-    for goal in GOALS:
-        async with websockets.connect(uri) as ws:
-            # Action: Start
-            await ws.send(json.dumps({"action": "start", "goal": goal, "style": "direct"}))
-            resp1 = await ws.recv()
-            task1 = json.loads(resp1)['task']
-            
-            # Action: Done (Get the NEXT logical step)
-            await ws.send(json.dumps({"action": "done", "last_task": task1}))
-            resp2 = await ws.recv()
-            task2 = json.loads(resp2)['task']
-            
-            print(f"GOAL: '{goal}'")
-            print(f"  -> STEP 1: {task1}")
-            print(f"  -> STEP 2: {task2}\n")
-
-if __name__ == "__main__":
-    asyncio.run(semantic_test())

stress_test.py

@@ -1,87 +0,0 @@
-#!/usr/bin/env python3
-"""Stress test for the fine-tuned Step-Zero model."""
-
-import asyncio
-import json
-import websockets
-
-TEST_PROMPTS = [
-    "I want to clean my room",
-    "I need to write a python script",
-    "I should study for my exam",
-    "I want to cook dinner",
-    "I need to do laundry",
-    "I want to start exercising",
-    "I should organize my desk",
-    "I want to learn guitar",
-    "I need to fix my bike",
-    "I want to read a book",
-    "I should call my mom",
-    "I want to meditate",
-    "I need to pay my bills",
-    "I want to go grocery shopping",
-    "I should write in my journal",
-]
-
-async def test_prompt(prompt: str) -> dict:
-    uri = "ws://localhost:7860/ws"
-    try:
-        async with websockets.connect(uri, open_timeout=30) as ws:
-            # Send the goal
-            await ws.send(json.dumps({
-                "action": "start",
-                "goal": prompt
-            }))
-            
-            # Wait for the task response
-            response = await asyncio.wait_for(ws.recv(), timeout=120)
-            data = json.loads(response)
-            return {"prompt": prompt, "response": data, "status": "OK"}
-    except Exception as e:
-        return {"prompt": prompt, "error": str(e), "status": "ERROR"}
-
-async def main():
-    print("=" * 70)
-    print("STEP-ZERO FINE-TUNED MODEL STRESS TEST")
-    print("=" * 70)
-    print()
-    
-    results = []
-    for i, prompt in enumerate(TEST_PROMPTS, 1):
-        print(f"[{i}/{len(TEST_PROMPTS)}] Testing: \"{prompt}\"")
-        result = await test_prompt(prompt)
-        results.append(result)
-        
-        if result["status"] == "OK":
-            task = result["response"].get("task", result["response"])
-            print(f"  → Task: {task}")
-            word_count = len(str(task).split())
-            if word_count > 8:
-                print(f"  ⚠️  OVER 8 WORDS ({word_count} words)")
-            else:
-                print(f"  ✅ {word_count} words")
-        else:
-            print(f"  ❌ ERROR: {result['error']}")
-        print()
-    
-    # Summary
-    print("=" * 70)
-    print("SUMMARY")
-    print("=" * 70)
-    ok_count = sum(1 for r in results if r["status"] == "OK")
-    err_count = sum(1 for r in results if r["status"] == "ERROR")
-    over_8 = 0
-    for r in results:
-        if r["status"] == "OK":
-            task = str(r["response"].get("task", r["response"]))
-            if len(task.split()) > 8:
-                over_8 += 1
-    
-    print(f"  Total: {len(results)}")
-    print(f"  Success: {ok_count}")
-    print(f"  Errors: {err_count}")
-    print(f"  Over 8 words: {over_8}")
-    print(f"  Pass rate: {((ok_count - over_8) / len(results) * 100):.1f}%")
-
-if __name__ == "__main__":
-    asyncio.run(main())

test_app.py

@@ -1,6 +0,0 @@
-try:
-    import app
-    app.app.get_api_info()
-except Exception as e:
-    import traceback
-    traceback.print_exc()

test_async_dict.py

@@ -1,8 +0,0 @@
-import gradio as gr
-with gr.Blocks() as app:
-    state = gr.State()
-    b = gr.Button()
-    async def fn(s):
-        return {"a": 1}
-    b.click(fn=fn, inputs=state, outputs=state)
-app.get_api_info()

test_bisect.py

@@ -1,27 +0,0 @@
-import gradio as gr
-from app import show_loading, handle_start, process_step
-
-with gr.Blocks() as app:
-    session_state = gr.State()
-    goal_input = gr.Textbox()
-    style_radio = gr.Radio(["direct"])
-    screen_start = gr.Column()
-    screen_task = gr.Column()
-    task_display = gr.HTML()
-    controls_row = gr.Row()
-    start_btn = gr.Button()
-    
-    start_btn.click(
-        fn=show_loading,
-        outputs=[screen_start, screen_task, task_display, controls_row]
-    ).then(
-        fn=handle_start,
-        inputs=[session_state, goal_input, style_radio],
-        outputs=[session_state, task_display, task_display, controls_row]
-    )
-
-try:
-    print(type(app.get_api_info()))
-except Exception as e:
-    import traceback
-    traceback.print_exc()

test_bisect2.py

@@ -1,30 +0,0 @@
-import sys
-
-with open("app.py", "r") as f:
-    lines = f.readlines()
-
-import tempfile
-import subprocess
-
-def test_lines(end_line):
-    with tempfile.NamedTemporaryFile("w", suffix=".py", delete=False) as f:
-        f.writelines(lines[:end_line])
-        if "app.launch" not in lines[end_line-1]:
-            f.write("\napp.get_api_info()\n")
-        name = f.name
-    
-    res = subprocess.run(["python3", name], capture_output=True, text=True)
-    return "TypeError: argument of type 'bool' is not iterable" in res.stderr
-
-print("Testing...")
-# Binary search
-low = 315
-high = 450
-while low < high:
-    mid = (low + high) // 2
-    if test_lines(mid):
-        high = mid
-    else:
-        low = mid + 1
-
-print(f"First failing line is {low}: {lines[low-1].strip()}")

test_breakdown.py

@@ -1,20 +0,0 @@
-from llama_cpp import Llama
-
-minicpm = Llama(model_path="./models/minicpm-3-4b.gguf", n_ctx=1024, verbose=False)
-
-system_msg = "You are a cognitive pacemaker. When a task is too hard, break it down into a single, even simpler, tiny physical starting action under 8 words. Return ONLY the starting action."
-
-rejected_tasks = [
-    "Sweeping the kitchen floor.",
-    "Organize the top left drawer.",
-    "Open the textbook to chapter one.",
-    "Pay the minimum payment on my credit card bill."
-]
-
-for task in rejected_tasks:
-    messages = [
-        {"role": "system", "content": system_msg},
-        {"role": "user", "content": f"The task '{task}' was too hard. Break it down into a single, even simpler physical starting action."}
-    ]
-    response = minicpm.create_chat_completion(messages=messages, max_tokens=20, temperature=0.1)
-    print(f"Rejected: '{task}' -> Simpler: {repr(response['choices'][0]['message']['content'].strip())}")

test_comp.py

@@ -1,10 +0,0 @@
-import app
-from gradio_client import utils
-
-for block_id, comp in app.app.blocks.items():
-    if hasattr(comp, "api_info"):
-        try:
-            info = comp.api_info()
-            utils.json_schema_to_python_type(info)
-        except Exception as e:
-            print(f"FAILED ON COMPONENT: {comp.__class__.__name__}")

test_debug.py

@@ -1,6 +0,0 @@
-import app
-import traceback
-try:
-    app.app.get_api_info()
-except Exception as e:
-    traceback.print_exc()

test_dict.py

@@ -1,8 +0,0 @@
-import gradio as gr
-with gr.Blocks() as app:
-    state = gr.State()
-    b = gr.Button()
-    def fn(s):
-        return {"a": 1}
-    b.click(fn=fn, inputs=state, outputs=state)
-app.get_api_info()

test_exact.py

@@ -1,7 +0,0 @@
-import app
-try:
-    app.app.get_api_info()
-    print("SUCCESS")
-except Exception as e:
-    import traceback
-    traceback.print_exc()

test_extract.py

@@ -1,16 +0,0 @@
-import asyncio
-from llama_cpp import Llama
-
-minicpm = Llama(model_path="./models/minicpm-3-4b.gguf", n_ctx=1024, verbose=False)
-
-def extract(text):
-    messages = [
-        {"role": "system", "content": "You extract the very first physical action from the user's text. Return ONLY a single physical action under 8 words. Do not include any other words."},
-        {"role": "user", "content": f"Text: {text}"}
-    ]
-    response = minicpm.create_chat_completion(messages=messages, max_tokens=15, temperature=0.1)
-    return response['choices'][0]['message']['content'].strip()
-
-print("1:", extract("Clean bedroom floor, tidy bed, organize drawers, dust surfaces, vacuum carpet."))
-print("2:", extract("Sure, here's a python script that uses the pandas library to parse a csv file:"))
-print("3:", extract("Fail to identify goal."))

test_file_update.py

@@ -1,13 +0,0 @@
-import gradio as gr
-with gr.Blocks() as app:
-    f = gr.File(visible=False)
-    b = gr.Button("Test")
-    def fn():
-        return gr.File(value="test.txt", visible=True)
-    b.click(fn=fn, outputs=[f])
-try:
-    app.get_api_info()
-    print("SUCCESS")
-except Exception as e:
-    import traceback
-    traceback.print_exc()

test_find_fn.py

@@ -1,11 +0,0 @@
-import app
-import copy
-from gradio_client import utils
-
-for idx, fn in enumerate(app.app.fns.values()):
-    try:
-        info = fn.get_api_info(None)
-        client_utils_info = utils.safe_deepcopy(info)
-        client_utils.json_schema_to_python_type(client_utils_info)
-    except Exception as e:
-        print(f"FAILED ON FUNCTION: {fn.name or fn.__class__.__name__} (index {idx})")

test_find_fn2.py

@@ -1,10 +0,0 @@
-import app
-from gradio_client import utils
-
-for idx, fn in enumerate(app.app.fns.values()):
-    try:
-        info = fn.get_api_info(app.app.blocks)
-        client_utils_info = utils.safe_deepcopy(info)
-        utils.json_schema_to_python_type(client_utils_info)
-    except Exception as e:
-        print(f"FAILED ON FUNCTION: {fn.name or fn.__class__.__name__} (index {idx})")

test_gradio.py

@@ -1,4 +0,0 @@
-import gradio as gr
-with gr.Blocks() as app:
-    session_state = gr.State({})
-app.launch(server_name="0.0.0.0", server_port=7860, share=False)

test_intercept.py

@@ -1,18 +0,0 @@
-import gradio as gr
-from gradio_client import utils as client_utils
-
-original = client_utils.json_schema_to_python_type
-
-def hook(schema):
-    try:
-        return original(schema)
-    except Exception as e:
-        print("CRASHING SCHEMA:")
-        import pprint
-        pprint.pprint(schema)
-        raise e
-
-client_utils.json_schema_to_python_type = hook
-
-import app
-app.app.get_api_info()

test_isolate.py

@@ -1,6 +0,0 @@
-import gradio as gr
-with gr.Blocks() as app:
-    state = gr.State({})
-    b = gr.Button("Test")
-    # b.click(fn=lambda s: s, inputs=state, outputs=state)
-app.get_api_info()

test_isolate2.py

@@ -1,6 +0,0 @@
-import gradio as gr
-with gr.Blocks() as app:
-    state = gr.State({})
-    b = gr.Button("Test")
-    b.click(fn=lambda s: s, inputs=state, outputs=state)
-app.get_api_info()

test_isolate3.py

@@ -1,9 +0,0 @@
-import gradio as gr
-from app import push_to_hub_fn, export_trace_fn, show_loading, show_loading_step, handle_start, handle_done, handle_skip, handle_too_hard
-with gr.Blocks() as app:
-    session_state = gr.State({})
-    b = gr.Button("Test")
-    # Uncomment one by one
-    # b.click(fn=export_trace_fn, inputs=[session_state], outputs=[session_state])
-    # b.click(fn=push_to_hub_fn, inputs=[session_state], outputs=[session_state])
-app.get_api_info()

test_isolate4.py

@@ -1,14 +0,0 @@
-import gradio as gr
-from app import push_to_hub_fn, export_trace_fn, show_loading, show_loading_step, handle_start, handle_done, handle_skip, handle_too_hard
-
-funcs = [export_trace_fn, push_to_hub_fn, show_loading, show_loading_step, handle_start, handle_done, handle_skip, handle_too_hard]
-
-for f in funcs:
-    with gr.Blocks() as app:
-        state = gr.State({})
-        b = gr.Button("Test")
-        b.click(fn=f, inputs=[state], outputs=[state])
-    try:
-        app.get_api_info()
-    except Exception as e:
-        print(f"FAILED on {f.__name__}")

test_isolate5.py

@@ -1,11 +0,0 @@
-import gradio as gr
-with gr.Blocks() as app:
-    col = gr.Column()
-    b = gr.Button()
-    def fn():
-        return gr.update(visible=False)
-    b.click(fn=fn, outputs=[col])
-try:
-    app.get_api_info()
-except Exception as e:
-    print("FAILED on col update")

test_isolate6.py

@@ -1,13 +0,0 @@
-import gradio as gr
-with gr.Blocks() as app:
-    row = gr.Row()
-    b = gr.Button()
-    def fn():
-        return gr.update(visible=False)
-    b.click(fn=fn, outputs=[row])
-try:
-    app.get_api_info()
-except Exception as e:
-    import traceback
-    traceback.print_exc()
-    print("FAILED on row update")

test_isolate7.py

@@ -1,11 +0,0 @@
-import gradio as gr
-with gr.Blocks() as app:
-    f = gr.File(visible=False)
-    b = gr.Button()
-    def fn():
-        return gr.update(visible=True)
-    b.click(fn=fn, outputs=[f])
-try:
-    app.get_api_info()
-except Exception as e:
-    print("FAILED on file")

test_lambda.py

@@ -1,10 +0,0 @@
-import gradio as gr
-
-def test():
-    pass
-
-with gr.Blocks() as app:
-    b = gr.Button()
-    b.click(fn=lambda x: x, inputs=[b], outputs=[b])
-
-app.get_api_info()

test_modal_ls.py

@@ -1,16 +0,0 @@
-import modal
-
-image = modal.Image.from_registry("ubuntu:22.04")
-
-app = modal.App("step-zero-test-ls")
-vol = modal.Volume.from_name("step-zero-volume")
-
-@app.function(image=image, volumes={"/vol": vol})
-def check_vol():
-    import os
-    print("Files in /vol:")
-    os.system("ls -la /vol")
-
-@app.local_entrypoint()
-def main():
-    check_vol.remote()

test_modal_mount.py

@@ -1,2 +0,0 @@
-import modal
-print(hasattr(modal.Image, 'add_local_file'))

test_monkeypatch.py

@@ -1,15 +0,0 @@
-import gradio_client.utils as client_utils
-original_get_type = client_utils.get_type
-def safe_get_type(schema):
-    if isinstance(schema, bool):
-        return "Any"
-    return original_get_type(schema)
-client_utils.get_type = safe_get_type
-
-import app
-try:
-    app.app.get_api_info()
-    print("SUCCESS")
-except Exception as e:
-    import traceback
-    traceback.print_exc()

test_nem_out.txt

@@ -1,4 +0,0 @@
-Error in sitecustomize; set PYTHONVERBOSE for traceback:
-ModuleNotFoundError: No module named 'wrapt'
-llama_context: n_ctx_seq (1024) < n_ctx_train (4096) -- the full capacity of the model will not be utilized
-NEMOTRON: '{\n  "task": "vacuum, dust, mop, clean bathroom, clean kitchen,'

test_nemotron.py

@@ -1,9 +0,0 @@
-import json
-from llama_cpp import Llama
-nemotron = Llama(model_path="./models/nemotron-mini-4b.gguf", n_ctx=1024, verbose=False)
-messages = [
-    {"role": "system", "content": "You are a cognitive pacemaker. Break down goals into extremely tiny, atomic physical actions under 8 words. Return ONLY a JSON object with a 'task' key."},
-    {"role": "user", "content": "Goal: clean the house. Failures: 0."}
-]
-response = nemotron.create_chat_completion(messages=messages, max_tokens=20, temperature=0.1, response_format={"type": "json_object"})
-print("NEMOTRON:", repr(response['choices'][0]['message']['content']))

test_rut.py

@@ -1,31 +0,0 @@
-from llama_cpp import Llama
-
-minicpm = Llama(model_path="./models/minicpm-3-4b.gguf", n_ctx=1024, verbose=False)
-
-rut_history = [
-    "Move towards the living room",
-    "Move the laundry basket to the laundry room",
-    "Move the dirty dishes to the sink",
-    "Move the empty dishwasher to the kitchen counter",
-    "Move the empty trash can to the curb",
-    "Move the dirty laundry into the laundry basket",
-    "Move the empty mop bucket to the bathroom",
-    "Move the empty mop bucket to the laundry room"
-]
-
-def test_minicpm(history_items, temperature):
-    history_str = "\n".join([f"- {t}" for t in history_items]) if history_items else "None"
-    goal = "i wanna do some chores but im mentally stuck"
-    
-    last_task = history_items[-1] if history_items else ""
-    messages = [
-        {"role": "system", "content": "You are a cognitive pacemaker. Focus strictly on the physical goal and break it down into an extremely tiny, atomic physical action under 8 words. Ignore mental blocks or feelings of being stuck and output ONLY the single physical action step."},
-        {"role": "user", "content": f"Goal: {goal}\nCompleted Tasks:\n{history_str}\nFailures: 0\nCRITICAL: Do NOT output '{last_task}'. Output the strictly NEXT new physical step."}
-    ]
-    
-    res = minicpm.create_chat_completion(messages=messages, max_tokens=20, temperature=temperature)
-    return res['choices'][0]['message']['content'].strip()
-
-print("Full rut history (temp 0.1):", repr(test_minicpm(rut_history, 0.1)))
-print("Short history (last 2) (temp 0.1):", repr(test_minicpm(rut_history[-2:], 0.1)))
-print("Short history (last 2) (temp 0.4):", repr(test_minicpm(rut_history[-2:], 0.4)))

test_schema.py

@@ -1,7 +0,0 @@
-import gradio as gr
-from gradio_client import utils
-schema = {"type": "object", "additionalProperties": False}
-try:
-    print(utils.json_schema_to_python_type(schema))
-except Exception as e:
-    print("ERROR:", type(e), str(e))

test_ws.py

@@ -1,11 +0,0 @@
-import asyncio
-import websockets
-import json
-
-async def test():
-    async with websockets.connect("ws://127.0.0.1:7860/ws") as websocket:
-        await websocket.send(json.dumps({"action": "start", "goal": "clean the house", "style": "direct"}))
-        response = await websocket.recv()
-        print(f"WS RESPONSE: {response}")
-
-asyncio.run(test())