Upload folder using huggingface_hub

app.py

@@ -12,7 +12,11 @@ import hashlib
 import subprocess
 import tempfile
 import base64
+import uuid
+import signal
+import threading
 from datetime import datetime, timezone
+from collections import deque
 
 from fastapi import FastAPI, WebSocket, WebSocketDisconnect, UploadFile, File
 from fastapi.middleware.cors import CORSMiddleware
@@ -576,3 +580,291 @@ async def ws_stream(ws: WebSocket):
 
     except WebSocketDisconnect:
         sessions.pop(state.session_id, None)
+
+
+# ─── Long-Running Terminal Sessions ───
+
+class TerminalSession:
+    """Persistent terminal session for long-running processes like backtests."""
+    def __init__(self, session_id: str, cwd: str = "/tmp", shell: str = "/bin/bash"):
+        self.session_id = session_id
+        self.cwd = cwd
+        self.shell = shell
+        self.proc = None
+        self.output_buffer = deque(maxlen=10000)
+        self.created_at = time.time()
+        self.last_command = None
+        self.lock = threading.Lock()
+        self._reader_thread = None
+
+    def start(self):
+        self.proc = subprocess.Popen(
+            [self.shell, "-i"],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            cwd=self.cwd,
+            bufsize=1,
+            env={**os.environ, "PS1": "csc$ ", "TERM": "dumb"},
+        )
+        self._reader_thread = threading.Thread(target=self._read_output, daemon=True)
+        self._reader_thread.start()
+
+    def _read_output(self):
+        try:
+            for line in self.proc.stdout:
+                self.output_buffer.append({"ts": time.time(), "line": line})
+        except Exception:
+            pass
+
+    def exec(self, command: str, timeout: float = 300) -> dict:
+        with self.lock:
+            if not self.proc or self.proc.poll() is not None:
+                return {"error": "Session terminated", "exit_code": self.proc.returncode if self.proc else -1}
+            self.last_command = command
+            buf_start = len(self.output_buffer)
+            try:
+                self.proc.stdin.write(command + "\n")
+                self.proc.stdin.flush()
+            except (BrokenPipeError, OSError):
+                return {"error": "Session pipe broken", "exit_code": -1}
+            # Wait for output to stabilize (no new lines for 500ms) or timeout
+            time.sleep(0.3)
+            deadline = time.time() + timeout
+            last_count = 0
+            while time.time() < deadline:
+                current = len(self.output_buffer)
+                if current == last_count and current > buf_start:
+                    break
+                last_count = current
+                time.sleep(0.5)
+            new_lines = list(self.output_buffer)[buf_start:]
+            output = "".join(item["line"] for item in new_lines)
+            return {"output": output[-8000:], "lines": len(new_lines), "command": command}
+
+    def get_output(self, since: int = 0) -> dict:
+        lines = [item for item in self.output_buffer if item["ts"] >= since]
+        return {
+            "output": "".join(item["line"] for item in lines)[-16000:],
+            "line_count": len(self.output_buffer),
+            "is_alive": self.proc and self.proc.poll() is None,
+        }
+
+    def kill(self):
+        if self.proc and self.proc.poll() is None:
+            try:
+                os.killpg(os.getpgid(self.proc.pid), signal.SIGTERM)
+            except (ProcessLookupError, PermissionError):
+                self.proc.kill()
+        return {"killed": True, "session_id": self.session_id}
+
+    def status(self) -> dict:
+        return {
+            "session_id": self.session_id,
+            "alive": self.proc and self.proc.poll() is None,
+            "created_at": self.created_at,
+            "uptime_s": round(time.time() - self.created_at, 1),
+            "last_command": self.last_command,
+            "buffer_lines": len(self.output_buffer),
+            "cwd": self.cwd,
+        }
+
+
+terminal_sessions: dict[str, TerminalSession] = {}
+
+
+@app.post("/terminal/create")
+async def terminal_create(cwd: str = "/tmp"):
+    """Create a long-running terminal session for backtesting, training, etc."""
+    sid = f"term_{uuid.uuid4().hex[:12]}"
+    session = TerminalSession(sid, cwd=cwd)
+    session.start()
+    terminal_sessions[sid] = session
+    return {"session_id": sid, "created_at": session.created_at, "cwd": cwd}
+
+
+@app.post("/terminal/{session_id}/exec")
+async def terminal_exec(session_id: str, command: str = "", timeout: float = 300):
+    """Execute a command in a terminal session. Supports long-running commands."""
+    if session_id not in terminal_sessions:
+        return JSONResponse({"error": "Terminal session not found"}, 404)
+    session = terminal_sessions[session_id]
+    if not command.strip():
+        return JSONResponse({"error": "No command provided"}, 400)
+    return session.exec(command, timeout=timeout)
+
+
+@app.get("/terminal/{session_id}/output")
+async def terminal_output(session_id: str, since: float = 0):
+    """Get accumulated output from a terminal session."""
+    if session_id not in terminal_sessions:
+        return JSONResponse({"error": "Terminal session not found"}, 404)
+    return terminal_sessions[session_id].get_output(since=since)
+
+
+@app.post("/terminal/{session_id}/kill")
+async def terminal_kill(session_id: str):
+    """Kill a terminal session."""
+    if session_id not in terminal_sessions:
+        return JSONResponse({"error": "Terminal session not found"}, 404)
+    result = terminal_sessions[session_id].kill()
+    del terminal_sessions[session_id]
+    return result
+
+
+@app.get("/terminal/{session_id}/status")
+async def terminal_status(session_id: str):
+    """Get status of a terminal session."""
+    if session_id not in terminal_sessions:
+        return JSONResponse({"error": "Terminal session not found"}, 404)
+    return terminal_sessions[session_id].status()
+
+
+@app.get("/terminal/sessions")
+async def terminal_list():
+    """List all active terminal sessions."""
+    return {"sessions": [s.status() for s in terminal_sessions.values()]}
+
+
+# ─── API Help & OpenAPI for ChatGPT ───
+
+@app.get("/api/help")
+async def api_help():
+    """List all available endpoints with descriptions — for ChatGPT custom GPT discovery."""
+    return {
+        "app": "CSC Engine",
+        "version": "1.0.0",
+        "description": "Live multimodal code compiler: camera + audio + speech → observer LLM → builder LLM → code patches. Supports long-running terminal sessions for backtesting.",
+        "base_url": f"https://josephrw-csc-engine.hf.space",
+        "endpoints": [
+            {"method": "GET", "path": "/health", "description": "Health check — returns provider, version, active sessions"},
+            {"method": "POST", "path": "/session/start", "description": "Start a CSC Engine session"},
+            {"method": "POST", "path": "/session/stop", "description": "Stop a session by session_id"},
+            {"method": "GET", "path": "/state/current", "description": "Get current session state (requires session_id)"},
+            {"method": "POST", "path": "/generate/patch", "description": "Force a code generation cycle (requires session_id)"},
+            {"method": "POST", "path": "/run", "description": "Execute Python code — pass code or patch_hash. Returns stdout/stderr/exit_code"},
+            {"method": "POST", "path": "/debug", "description": "Send failed code + stderr to LLM for auto-fix. Pass patch_hash or code+stderr"},
+            {"method": "POST", "path": "/store-artifact", "description": "Store generated code + metadata for diary. Pass patch_hash, code, reasoning, evidence, observer_output"},
+            {"method": "GET", "path": "/artifact/{patch_hash}", "description": "View artifact as HTML page with Run and Debug buttons"},
+            {"method": "GET", "path": "/api/artifacts", "description": "List all artifacts as JSON (limit param, default 50)"},
+            {"method": "GET", "path": "/api/artifacts/{patch_hash}", "description": "Get single artifact as JSON"},
+            {"method": "GET", "path": "/receipts", "description": "List all patch receipts (limit param)"},
+            {"method": "GET", "path": "/receipts/{receipt_id}", "description": "Get a specific receipt"},
+            {"method": "POST", "path": "/audio/store", "description": "Store base64-encoded audio recording alongside an artifact"},
+            {"method": "GET", "path": "/audio/{filename}", "description": "Serve an audio file"},
+            {"method": "GET", "path": "/diary", "description": "Lab diary page — notebook-style view of all artifacts"},
+            {"method": "POST", "path": "/terminal/create", "description": "Create a long-running terminal session for backtesting. Pass cwd (default /tmp)"},
+            {"method": "POST", "path": "/terminal/{session_id}/exec", "description": "Execute a command in a terminal session. Pass command string. Supports 300s timeout"},
+            {"method": "GET", "path": "/terminal/{session_id}/output", "description": "Get accumulated output from a terminal session. Pass since=timestamp to get only new output"},
+            {"method": "POST", "path": "/terminal/{session_id}/kill", "description": "Kill a terminal session"},
+            {"method": "GET", "path": "/terminal/{session_id}/status", "description": "Get status of a terminal session"},
+            {"method": "GET", "path": "/terminal/sessions", "description": "List all active terminal sessions"},
+            {"method": "GET", "path": "/api/help", "description": "This endpoint — lists all available endpoints"},
+            {"method": "GET", "path": "/openapi.json", "description": "OpenAPI 3.1 schema for ChatGPT custom GPT integration"},
+        ],
+        "chatgpt_integration": {
+            "schema_url": "/openapi.json",
+            "auth": "none",
+            "description": "Add this URL as an Action in your ChatGPT custom GPT: https://josephrw-csc-engine.hf.space/openapi.json",
+        },
+    }
+
+
+@app.get("/gpt-actions.json")
+async def gpt_actions_schema():
+    """ChatGPT Custom GPT Actions schema — OpenAPI 3.1 with all endpoints."""
+    return {
+        "openapi": "3.1.0",
+        "info": {
+            "title": "CSC Engine",
+            "version": "1.0.0",
+            "description": "Live multimodal code compiler with long-running terminal sessions. Camera + audio → observer LLM → builder LLM → code patches. Execute Python, debug with LLM, run backtests in persistent terminals.",
+        },
+        "servers": [{"url": "https://josephrw-csc-engine.hf.space"}],
+        "paths": {
+            "/health": {
+                "get": {"summary": "Health check", "operationId": "health", "responses": {"200": {"description": "OK"}}}
+            },
+            "/session/start": {
+                "post": {"summary": "Start session", "operationId": "startSession", "responses": {"200": {"description": "Session created"}}}
+            },
+            "/session/stop": {
+                "post": {"summary": "Stop session", "operationId": "stopSession",
+                    "parameters": [{"name": "session_id", "in": "query", "required": True, "schema": {"type": "string"}}],
+                    "responses": {"200": {"description": "Session stopped"}}}
+            },
+            "/generate/patch": {
+                "post": {"summary": "Generate code patch from current state", "operationId": "generatePatch",
+                    "parameters": [{"name": "session_id", "in": "query", "required": True, "schema": {"type": "string"}}],
+                    "responses": {"200": {"description": "Patch generated"}}}
+            },
+            "/run": {
+                "post": {"summary": "Execute Python code", "operationId": "runCode",
+                    "parameters": [
+                        {"name": "code", "in": "query", "required": False, "schema": {"type": "string"}, "description": "Python code to execute"},
+                        {"name": "patch_hash", "in": "query", "required": False, "schema": {"type": "string"}, "description": "Hash of stored artifact to run"},
+                    ],
+                    "responses": {"200": {"description": "Execution result with stdout, stderr, exit_code"}}}
+            },
+            "/debug": {
+                "post": {"summary": "Debug and fix failed code with LLM", "operationId": "debugCode",
+                    "parameters": [
+                        {"name": "patch_hash", "in": "query", "required": False, "schema": {"type": "string"}},
+                        {"name": "code", "in": "query", "required": False, "schema": {"type": "string"}},
+                        {"name": "stderr", "in": "query", "required": False, "schema": {"type": "string"}},
+                    ],
+                    "responses": {"200": {"description": "Fixed code with new patch_hash"}}}
+            },
+            "/api/artifacts": {
+                "get": {"summary": "List all artifacts", "operationId": "listArtifacts",
+                    "parameters": [{"name": "limit", "in": "query", "schema": {"type": "integer", "default": 50}}],
+                    "responses": {"200": {"description": "List of artifacts"}}}
+            },
+            "/api/artifacts/{patch_hash}": {
+                "get": {"summary": "Get artifact by hash", "operationId": "getArtifact",
+                    "parameters": [{"name": "patch_hash", "in": "path", "required": True, "schema": {"type": "string"}}],
+                    "responses": {"200": {"description": "Artifact JSON"}}}
+            },
+            "/terminal/create": {
+                "post": {"summary": "Create long-running terminal session", "operationId": "createTerminal",
+                    "parameters": [{"name": "cwd", "in": "query", "schema": {"type": "string", "default": "/tmp"}}],
+                    "responses": {"200": {"description": "Terminal session created with session_id"}}}
+            },
+            "/terminal/{session_id}/exec": {
+                "post": {"summary": "Execute command in terminal session", "operationId": "execTerminal",
+                    "parameters": [
+                        {"name": "session_id", "in": "path", "required": True, "schema": {"type": "string"}},
+                        {"name": "command", "in": "query", "required": True, "schema": {"type": "string"}, "description": "Shell command to execute"},
+                        {"name": "timeout", "in": "query", "schema": {"type": "number", "default": 300}},
+                    ],
+                    "responses": {"200": {"description": "Command output"}}}
+            },
+            "/terminal/{session_id}/output": {
+                "get": {"summary": "Get terminal output", "operationId": "getTerminalOutput",
+                    "parameters": [
+                        {"name": "session_id", "in": "path", "required": True, "schema": {"type": "string"}},
+                        {"name": "since", "in": "query", "schema": {"type": "number", "default": 0}},
+                    ],
+                    "responses": {"200": {"description": "Accumulated output"}}}
+            },
+            "/terminal/{session_id}/kill": {
+                "post": {"summary": "Kill terminal session", "operationId": "killTerminal",
+                    "parameters": [{"name": "session_id", "in": "path", "required": True, "schema": {"type": "string"}}],
+                    "responses": {"200": {"description": "Session killed"}}}
+            },
+            "/terminal/sessions": {
+                "get": {"summary": "List active terminal sessions", "operationId": "listTerminals",
+                    "responses": {"200": {"description": "List of terminal sessions"}}}
+            },
+            "/receipts": {
+                "get": {"summary": "List all receipts", "operationId": "listReceipts",
+                    "parameters": [{"name": "limit", "in": "query", "schema": {"type": "integer", "default": 50}}],
+                    "responses": {"200": {"description": "List of receipts"}}}
+            },
+            "/api/help": {
+                "get": {"summary": "List all endpoints", "operationId": "apiHelp",
+                    "responses": {"200": {"description": "Endpoint listing"}}}
+            },
+        },
+    }

frontend/index.html

@@ -696,6 +696,407 @@
     .ide-artifact-link:hover {
       background: rgba(0, 212, 255, .2);
     }
+
+    /* ─── Terminal Dock ─── */
+    .terminal-dock {
+      position: fixed;
+      bottom: 0;
+      left: 0;
+      right: 0;
+      height: 280px;
+      background: var(--panel);
+      border-top: 1px solid var(--border2);
+      z-index: 100;
+      display: flex;
+      flex-direction: column;
+      transition: height .2s ease;
+    }
+
+    .terminal-dock.collapsed {
+      height: 32px;
+    }
+
+    .terminal-dock-header {
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      padding: 4px 12px;
+      height: 32px;
+      flex-shrink: 0;
+      background: var(--panel2);
+      border-bottom: 1px solid var(--border);
+      cursor: pointer;
+      user-select: none;
+    }
+
+    .terminal-dock-tabs {
+      display: flex;
+      gap: 2px;
+    }
+
+    .term-tab {
+      padding: 3px 10px;
+      border-radius: 4px 4px 0 0;
+      font-size: 11px;
+      font-family: var(--mono);
+      cursor: pointer;
+      border: none;
+      background: none;
+      color: var(--text2);
+      transition: .15s;
+    }
+
+    .term-tab.active {
+      background: var(--panel);
+      color: var(--accent);
+    }
+
+    .term-tab:hover {
+      color: var(--text);
+    }
+
+    .term-tab-close {
+      margin-left: 4px;
+      opacity: .5;
+    }
+
+    .term-tab-close:hover {
+      opacity: 1;
+    }
+
+    .terminal-dock-body {
+      flex: 1;
+      overflow: hidden;
+      display: flex;
+    }
+
+    .terminal-output {
+      flex: 1;
+      overflow-y: auto;
+      padding: 8px 12px;
+      font-family: var(--mono);
+      font-size: 12px;
+      line-height: 1.5;
+      color: #c8d3f5;
+      white-space: pre-wrap;
+      word-break: break-all;
+    }
+
+    .terminal-output .term-line {
+      min-height: 18px;
+    }
+
+    .terminal-output .term-prompt {
+      color: var(--accent);
+    }
+
+    .terminal-output .term-err {
+      color: var(--red);
+    }
+
+    .terminal-output .term-out {
+      color: var(--green);
+    }
+
+    .terminal-input-row {
+      display: flex;
+      align-items: center;
+      padding: 4px 12px;
+      gap: 8px;
+      border-top: 1px solid var(--border);
+      background: var(--panel2);
+    }
+
+    .terminal-input-row .prompt {
+      color: var(--accent);
+      font-family: var(--mono);
+      font-size: 12px;
+    }
+
+    .terminal-input {
+      flex: 1;
+      background: none;
+      border: none;
+      outline: none;
+      color: var(--text);
+      font-family: var(--mono);
+      font-size: 12px;
+    }
+
+    .terminal-side {
+      width: 200px;
+      border-left: 1px solid var(--border);
+      padding: 8px;
+      overflow-y: auto;
+      font-size: 11px;
+      flex-shrink: 0;
+    }
+
+    .terminal-side h4 {
+      font-size: 10px;
+      color: var(--text2);
+      text-transform: uppercase;
+      margin-bottom: 6px;
+    }
+
+    .terminal-side .ts-row {
+      padding: 3px 0;
+      color: var(--text2);
+      display: flex;
+      justify-content: space-between;
+    }
+
+    .terminal-side .ts-row .ts-val {
+      color: var(--text);
+      font-family: var(--mono);
+    }
+
+    .terminal-side .ts-btn {
+      width: 100%;
+      padding: 4px;
+      margin-top: 4px;
+      border-radius: 4px;
+      border: 1px solid var(--border);
+      background: var(--panel);
+      color: var(--text2);
+      font-size: 10px;
+      cursor: pointer;
+      text-align: center;
+    }
+
+    .terminal-side .ts-btn:hover {
+      border-color: var(--accent);
+      color: var(--accent);
+    }
+
+    /* ─── Command Palette ─── */
+    .cmd-palette {
+      position: fixed;
+      top: 20%;
+      left: 50%;
+      transform: translateX(-50%);
+      width: 520px;
+      max-width: 90vw;
+      z-index: 200;
+      background: var(--panel);
+      border: 1px solid var(--border2);
+      border-radius: 12px;
+      box-shadow: 0 20px 60px rgba(0, 0, 0, .5);
+      display: none;
+    }
+
+    .cmd-palette.open {
+      display: block;
+    }
+
+    .cmd-palette input {
+      width: 100%;
+      padding: 14px 16px;
+      background: none;
+      border: none;
+      outline: none;
+      color: var(--text);
+      font-size: 15px;
+      border-bottom: 1px solid var(--border);
+    }
+
+    .cmd-palette-results {
+      max-height: 320px;
+      overflow-y: auto;
+    }
+
+    .cmd-item {
+      padding: 10px 16px;
+      cursor: pointer;
+      display: flex;
+      align-items: center;
+      gap: 10px;
+      border-bottom: 1px solid var(--border);
+      transition: .1s;
+    }
+
+    .cmd-item:hover,
+    .cmd-item.selected {
+      background: var(--panel2);
+    }
+
+    .cmd-item .cmd-icon {
+      width: 20px;
+      color: var(--accent);
+      font-size: 14px;
+    }
+
+    .cmd-item .cmd-label {
+      font-size: 13px;
+      color: var(--text);
+    }
+
+    .cmd-item .cmd-desc {
+      font-size: 11px;
+      color: var(--text2);
+      margin-left: auto;
+    }
+
+    .cmd-overlay {
+      position: fixed;
+      inset: 0;
+      background: rgba(0, 0, 0, .4);
+      z-index: 199;
+      display: none;
+    }
+
+    .cmd-overlay.open {
+      display: block;
+    }
+
+    /* ─── API Explorer Panel ─── */
+    .api-panel {
+      position: fixed;
+      right: 0;
+      top: 0;
+      bottom: 0;
+      width: 420px;
+      background: var(--panel);
+      border-left: 1px solid var(--border2);
+      z-index: 150;
+      transform: translateX(100%);
+      transition: transform .25s ease;
+      display: flex;
+      flex-direction: column;
+    }
+
+    .api-panel.open {
+      transform: translateX(0);
+    }
+
+    .api-panel-header {
+      padding: 12px 16px;
+      border-bottom: 1px solid var(--border);
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+    }
+
+    .api-panel-header h3 {
+      font-size: 13px;
+      color: var(--accent);
+    }
+
+    .api-panel-body {
+      flex: 1;
+      overflow-y: auto;
+      padding: 12px;
+    }
+
+    .api-endpoint {
+      padding: 10px;
+      margin-bottom: 8px;
+      border-radius: 8px;
+      background: var(--panel2);
+      border: 1px solid var(--border);
+      cursor: pointer;
+      transition: .15s;
+    }
+
+    .api-endpoint:hover {
+      border-color: var(--accent);
+    }
+
+    .api-method {
+      font-size: 10px;
+      font-weight: 700;
+      padding: 2px 6px;
+      border-radius: 3px;
+    }
+
+    .api-method.GET {
+      background: rgba(52, 211, 153, .15);
+      color: var(--green);
+    }
+
+    .api-method.POST {
+      background: rgba(0, 212, 255, .15);
+      color: var(--accent);
+    }
+
+    .api-path {
+      font-family: var(--mono);
+      font-size: 12px;
+      color: var(--text);
+      margin-left: 8px;
+    }
+
+    .api-desc {
+      font-size: 11px;
+      color: var(--text2);
+      margin-top: 4px;
+    }
+
+    .api-try-btn {
+      padding: 3px 8px;
+      border-radius: 4px;
+      font-size: 10px;
+      border: 1px solid var(--border);
+      background: var(--panel);
+      color: var(--text2);
+      cursor: pointer;
+      margin-top: 6px;
+    }
+
+    .api-try-btn:hover {
+      border-color: var(--accent);
+      color: var(--accent);
+    }
+
+    .api-response {
+      margin-top: 8px;
+      padding: 8px;
+      border-radius: 6px;
+      background: var(--bg);
+      border: 1px solid var(--border);
+      font-family: var(--mono);
+      font-size: 11px;
+      color: var(--green);
+      max-height: 200px;
+      overflow-y: auto;
+      white-space: pre-wrap;
+      word-break: break-all;
+      display: none;
+    }
+
+    .api-response.open {
+      display: block;
+    }
+
+    /* ─── Toolbar buttons ─── */
+    .toolbar-btn {
+      padding: 4px 10px;
+      border-radius: 6px;
+      border: 1px solid var(--border);
+      background: var(--panel);
+      color: var(--text2);
+      font-size: 11px;
+      cursor: pointer;
+      display: inline-flex;
+      align-items: center;
+      gap: 4px;
+      transition: .15s;
+    }
+
+    .toolbar-btn:hover {
+      border-color: var(--accent);
+      color: var(--accent);
+    }
+
+    .kbd {
+      padding: 1px 5px;
+      border-radius: 3px;
+      background: var(--panel2);
+      border: 1px solid var(--border);
+      font-size: 10px;
+      font-family: var(--mono);
+      color: var(--text2);
+    }
   </style>
 </head>
 
@@ -710,6 +1111,29 @@
         </div>
       </div>
       <div class="status-pill" id="status"><span class="status-dot dot-idle"></span>Idle</div>
+      <div style="display:flex;gap:6px;margin-left:8px">
+        <button class="toolbar-btn" onclick="openCmdPalette()" title="Command Palette">
+          <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+            <path d="M21 21l-4.35-4.35" />
+            <circle cx="11" cy="11" r="8" />
+          </svg>
+          <span class="kbd">⌘K</span>
+        </button>
+        <button class="toolbar-btn" onclick="toggleApiPanel()" title="API Explorer">
+          <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+            <polyline points="16 18 22 12 16 6" />
+            <polyline points="8 6 2 12 8 18" />
+          </svg>
+          API
+        </button>
+        <button class="toolbar-btn" onclick="toggleTerminalDock()" title="Terminal">
+          <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+            <polyline points="4 17 10 11 4 5" />
+            <line x1="12" y1="19" x2="20" y2="19" />
+          </svg>
+          Terminal
+        </button>
+      </div>
     </header>
 
     <div class="controls">
@@ -837,6 +1261,68 @@
     </div>
   </main>
 
+  <!-- Command Palette Overlay -->
+  <div class="cmd-overlay" id="cmdOverlay" onclick="closeCmdPalette()"></div>
+  <div class="cmd-palette" id="cmdPalette">
+    <input type="text" id="cmdInput" placeholder="Search commands..." oninput="filterCmds()"
+      onkeydown="handleCmdKey(event)" />
+    <div class="cmd-palette-results" id="cmdResults"></div>
+  </div>
+
+  <!-- API Explorer Panel -->
+  <div class="api-panel" id="apiPanel">
+    <div class="api-panel-header">
+      <h3>API Explorer</h3>
+      <button class="toolbar-btn" onclick="toggleApiPanel()">✕</button>
+    </div>
+    <div class="api-panel-body" id="apiPanelBody">
+      <div style="font-size:11px;color:var(--text2);margin-bottom:12px">
+        ChatGPT Integration: <a href="/gpt-actions.json" target="_blank"
+          style="color:var(--accent)">/gpt-actions.json</a><br>
+        Full Help: <a href="/api/help" target="_blank" style="color:var(--accent)">/api/help</a>
+      </div>
+      <div id="apiEndpoints"></div>
+    </div>
+  </div>
+
+  <!-- Terminal Dock -->
+  <div class="terminal-dock collapsed" id="termDock">
+    <div class="terminal-dock-header" onclick="toggleTerminalDock()">
+      <div class="terminal-dock-tabs" id="termTabs">
+        <div class="term-tab active" onclick="event.stopPropagation()">Terminal</div>
+      </div>
+      <div style="display:flex;gap:6px;align-items:center">
+        <span style="font-size:10px;color:var(--text2)" id="termStatus">no session</span>
+        <button class="toolbar-btn" onclick="event.stopPropagation();createTerminalSession()"
+          style="font-size:10px;padding:2px 8px">+ New</button>
+        <span style="font-size:10px;color:var(--text2)">▾</span>
+      </div>
+    </div>
+    <div class="terminal-dock-body">
+      <div style="flex:1;display:flex;flex-direction:column">
+        <div class="terminal-output" id="termOutput">
+          <div class="term-line" style="color:var(--text2)">Click "+ New" to create a terminal session. Supports
+            long-running backtests.</div>
+        </div>
+        <div class="terminal-input-row">
+          <span class="prompt">csc$</span>
+          <input class="terminal-input" id="termInput" placeholder="Type a command..."
+            onkeydown="handleTermInput(event)" disabled />
+        </div>
+      </div>
+      <div class="terminal-side" id="termSide">
+        <h4>Session Info</h4>
+        <div class="ts-row"><span>Status</span><span class="ts-val" id="tsStatus">—</span></div>
+        <div class="ts-row"><span>Uptime</span><span class="ts-val" id="tsUptime">—</span></div>
+        <div class="ts-row"><span>Lines</span><span class="ts-val" id="tsLines">—</span></div>
+        <div class="ts-row"><span>Last cmd</span><span class="ts-val" id="tsLastCmd">—</span></div>
+        <button class="ts-btn" onclick="pollTerminalOutput()">Refresh Output</button>
+        <button class="ts-btn" onclick="killTerminalSession()"
+          style="color:var(--red);border-color:rgba(248,113,113,.2)">Kill Session</button>
+      </div>
+    </div>
+  </div>
+
   <script>
     const video = document.getElementById("video");
     const canvas = document.getElementById("canvas");
@@ -1384,6 +1870,226 @@
       };
       reader.readAsDataURL(blob);
     }
+
+    // ─── Terminal Dock ───
+    let currentTermSession = null;
+    let termPollTimer = null;
+
+    function toggleTerminalDock() {
+      const dock = document.getElementById("termDock");
+      dock.classList.toggle("collapsed");
+      if (!dock.classList.contains("collapsed") && !currentTermSession) {
+        createTerminalSession();
+      }
+    }
+
+    async function createTerminalSession() {
+      try {
+        const resp = await fetch("/terminal/create", { method: "POST" });
+        const data = await resp.json();
+        currentTermSession = data.session_id;
+        document.getElementById("termInput").disabled = false;
+        document.getElementById("termStatus").textContent = data.session_id.slice(0, 12);
+        document.getElementById("termOutput").innerHTML = '<div class="term-line term-prompt">Terminal session created: ' + data.session_id + '</div>';
+        document.getElementById("termInput").focus();
+        startTermPolling();
+      } catch (e) {
+        document.getElementById("termOutput").innerHTML = '<div class="term-line term-err">Error: ' + escapeHtml(e.message) + '</div>';
+      }
+    }
+
+    async function handleTermInput(event) {
+      if (event.key !== "Enter") return;
+      const input = document.getElementById("termInput");
+      const cmd = input.value.trim();
+      if (!cmd || !currentTermSession) return;
+      input.value = "";
+      const outEl = document.getElementById("termOutput");
+      outEl.innerHTML += '<div class="term-line"><span class="term-prompt">csc$</span> ' + escapeHtml(cmd) + '</div>';
+      outEl.scrollTop = outEl.scrollHeight;
+      try {
+        const resp = await fetch("/terminal/" + currentTermSession + "/exec?command=" + encodeURIComponent(cmd), { method: "POST" });
+        const data = await resp.json();
+        if (data.error) {
+          outEl.innerHTML += '<div class="term-line term-err">' + escapeHtml(data.error) + '</div>';
+        } else if (data.output) {
+          outEl.innerHTML += '<div class="term-line term-out">' + escapeHtml(data.output) + '</div>';
+        }
+        outEl.scrollTop = outEl.scrollHeight;
+        updateTermSide(data);
+      } catch (e) {
+        outEl.innerHTML += '<div class="term-line term-err">' + escapeHtml(e.message) + '</div>';
+      }
+    }
+
+    function startTermPolling() {
+      if (termPollTimer) clearInterval(termPollTimer);
+      termPollTimer = setInterval(pollTerminalOutput, 3000);
+    }
+
+    async function pollTerminalOutput() {
+      if (!currentTermSession) return;
+      try {
+        const resp = await fetch("/terminal/" + currentTermSession + "/output");
+        const data = await resp.json();
+        if (data.output) {
+          const outEl = document.getElementById("termOutput");
+          const existing = outEl.querySelector(".term-poll-out");
+          if (existing) existing.remove();
+          outEl.innerHTML += '<div class="term-line term-out term-poll-out">' + escapeHtml(data.output.slice(-2000)) + '</div>';
+          outEl.scrollTop = outEl.scrollHeight;
+        }
+        document.getElementById("tsStatus").textContent = data.is_alive ? "alive" : "dead";
+        document.getElementById("tsLines").textContent = data.line_count || 0;
+      } catch (e) { }
+    }
+
+    async function updateTermSide(data) {
+      try {
+        const resp = await fetch("/terminal/" + currentTermSession + "/status");
+        const s = await resp.json();
+        document.getElementById("tsStatus").textContent = s.alive ? "alive" : "dead";
+        document.getElementById("tsUptime").textContent = s.uptime_s + "s";
+        document.getElementById("tsLines").textContent = s.buffer_lines;
+        document.getElementById("tsLastCmd").textContent = (s.last_command || "—").slice(0, 20);
+      } catch (e) { }
+    }
+
+    async function killTerminalSession() {
+      if (!currentTermSession) return;
+      try {
+        await fetch("/terminal/" + currentTermSession + "/kill", { method: "POST" });
+        document.getElementById("termOutput").innerHTML += '<div class="term-line term-err">Session killed</div>';
+        currentTermSession = null;
+        document.getElementById("termInput").disabled = true;
+        document.getElementById("termStatus").textContent = "no session";
+        if (termPollTimer) { clearInterval(termPollTimer); termPollTimer = null; }
+      } catch (e) { }
+    }
+
+    // ─── Command Palette ───
+    const commands = [
+      { icon: "▶", label: "Start Engine", desc: "Begin live capture", action: () => startLive().catch(e => setStatus(e.message, "dot-error")) },
+      { icon: "■", label: "Stop Engine", desc: "Stop live capture", action: stopLive },
+      { icon: "⚡", label: "Force Generate", desc: "Force code generation", action: () => sendFrame(true) },
+      { icon: "🎤", label: "Start Speech", desc: "Begin speech recognition", action: startSpeech },
+      { icon: "🔴", label: "Record Audio", desc: "Toggle audio recording", action: toggleRecording },
+      { icon: "📖", label: "Open Lab Diary", desc: "View all artifacts", action: () => window.open("/diary", "_blank") },
+      { icon: "📐", label: "Open API Help", desc: "List all endpoints", action: () => window.open("/api/help", "_blank") },
+      { icon: "🔌", label: "GPT Actions Schema", desc: "ChatGPT integration schema", action: () => window.open("/gpt-actions.json", "_blank") },
+      { icon: "🖥", label: "Toggle Terminal", desc: "Open/close terminal dock", action: toggleTerminalDock },
+      { icon: "🔍", label: "Toggle API Explorer", desc: "Open/close API panel", action: toggleApiPanel },
+      { icon: "📊", label: "List Artifacts", desc: "Fetch all artifacts as JSON", action: () => fetch("/api/artifacts").then(r => r.json()).then(d => console.log(d)) },
+      { icon: "📋", label: "List Terminal Sessions", desc: "Show active terminals", action: () => fetch("/terminal/sessions").then(r => r.json()).then(d => console.log(d)) },
+      { icon: "🏥", label: "Health Check", desc: "Check server status", action: () => fetch("/health").then(r => r.json()).then(d => setStatus(JSON.stringify(d).slice(0, 80), "dot-active")) },
+      { icon: "🧪", label: "New Terminal Session", desc: "Create long-running terminal", action: () => { toggleTerminalDock(); if (!currentTermSession) createTerminalSession(); } },
+    ];
+
+    let cmdSelectedIndex = 0;
+
+    function openCmdPalette() {
+      document.getElementById("cmdOverlay").classList.add("open");
+      document.getElementById("cmdPalette").classList.add("open");
+      const input = document.getElementById("cmdInput");
+      input.value = "";
+      input.focus();
+      cmdSelectedIndex = 0;
+      renderCmds(commands);
+    }
+
+    function closeCmdPalette() {
+      document.getElementById("cmdOverlay").classList.remove("open");
+      document.getElementById("cmdPalette").classList.remove("open");
+    }
+
+    function filterCmds() {
+      const q = document.getElementById("cmdInput").value.toLowerCase();
+      const filtered = commands.filter(c => c.label.toLowerCase().includes(q) || c.desc.toLowerCase().includes(q));
+      cmdSelectedIndex = 0;
+      renderCmds(filtered);
+    }
+
+    function renderCmds(cmds) {
+      const el = document.getElementById("cmdResults");
+      el.innerHTML = cmds.map((c, i) =>
+        '<div class="cmd-item' + (i === cmdSelectedIndex ? ' selected' : '') + '" onclick="execCmd(' + commands.indexOf(c) + ')">' +
+        '<span class="cmd-icon">' + c.icon + '</span>' +
+        '<span class="cmd-label">' + c.label + '</span>' +
+        '<span class="cmd-desc">' + c.desc + '</span></div>'
+      ).join("");
+    }
+
+    function execCmd(idx) {
+      closeCmdPalette();
+      if (commands[idx]) commands[idx].action();
+    }
+
+    function handleCmdKey(event) {
+      const q = document.getElementById("cmdInput").value.toLowerCase();
+      const filtered = commands.filter(c => c.label.toLowerCase().includes(q) || c.desc.toLowerCase().includes(q));
+      if (event.key === "ArrowDown") { event.preventDefault(); cmdSelectedIndex = Math.min(cmdSelectedIndex + 1, filtered.length - 1); renderCmds(filtered); }
+      else if (event.key === "ArrowUp") { event.preventDefault(); cmdSelectedIndex = Math.max(cmdSelectedIndex - 1, 0); renderCmds(filtered); }
+      else if (event.key === "Enter") { event.preventDefault(); if (filtered[cmdSelectedIndex]) execCmd(commands.indexOf(filtered[cmdSelectedIndex])); }
+      else if (event.key === "Escape") { closeCmdPalette(); }
+    }
+
+    // ─── API Explorer ───
+    function toggleApiPanel() {
+      document.getElementById("apiPanel").classList.toggle("open");
+      if (document.getElementById("apiPanel").classList.contains("open")) loadApiEndpoints();
+    }
+
+    async function loadApiEndpoints() {
+      try {
+        const resp = await fetch("/api/help");
+        const data = await resp.json();
+        const el = document.getElementById("apiEndpoints");
+        el.innerHTML = data.endpoints.map((e, i) =>
+          '<div class="api-endpoint" onclick="toggleApiResponse(' + i + ')">' +
+          '<span class="api-method ' + e.method + '">' + e.method + '</span>' +
+          '<span class="api-path">' + e.path + '</span>' +
+          '<div class="api-desc">' + e.description + '</div>' +
+          '<button class="api-try-btn" onclick="event.stopPropagation();tryEndpoint(' + i + ')">Try it</button>' +
+          '<div class="api-response" id="apiResp' + i + '"></div>' +
+          '</div>'
+        ).join("");
+        window._apiEndpoints = data.endpoints;
+      } catch (e) {
+        document.getElementById("apiEndpoints").innerHTML = '<div style="color:var(--red)">Error loading: ' + escapeHtml(e.message) + '</div>';
+      }
+    }
+
+    function toggleApiResponse(i) {
+      const el = document.getElementById("apiResp" + i);
+      el.classList.toggle("open");
+    }
+
+    async function tryEndpoint(i) {
+      const ep = window._apiEndpoints[i];
+      const el = document.getElementById("apiResp" + i);
+      el.classList.add("open");
+      el.textContent = "Loading...";
+      try {
+        const opts = { method: ep.method };
+        const resp = await fetch(ep.path, opts);
+        const text = await resp.text();
+        el.textContent = text.slice(0, 2000);
+      } catch (e) {
+        el.textContent = "Error: " + e.message;
+      }
+    }
+
+    // ─── Keyboard Shortcuts ───
+    document.addEventListener("keydown", (e) => {
+      if ((e.metaKey || e.ctrlKey) && e.key === "k") {
+        e.preventDefault();
+        openCmdPalette();
+      }
+      if (e.key === "Escape") {
+        closeCmdPalette();
+        if (document.getElementById("apiPanel").classList.contains("open")) document.getElementById("apiPanel").classList.remove("open");
+      }
+    });
   </script>
 </body>