Upload folder using huggingface_hub

app.py

@@ -217,18 +217,12 @@ async def generate_patch(request: Request):
     state = sessions[session_id]
     compact = compress_state(state)
 
-    # ─── Evidence Gate: check BEFORE calling observe (prevents LLM crash on empty sessions) ───
+    # ─── Evidence Gate: Sensory Proprietary Compiler V1 — Fallback Ladder ───
+    # Gate NEVER blocks. It assigns a fallback level (1-5) and artifact_type.
     ev_result = evidence_gate("", compact)
     log_gate_decision("evidence_gate", ev_result, patch_hash="")
-    if not ev_result.passed:
-        return JSONResponse({
-            "error": "Code generation blocked by Evidence Gate",
-            "gate_reason": ev_result.reason,
-            "evidence_type": ev_result.evidence_type,
-            "intent_sources": ev_result.intent_sources,
-            "observer_output": "",
-        }, 403)
 
+    # Observe with the gate result — observer gets context about what level we're at
     observation = observe(state, compact)
     state.observer_state = observation
     state.last_observer_ts = time.time()
@@ -236,16 +230,9 @@ async def generate_patch(request: Request):
     # Re-check Evidence Gate with observer output now available
     ev_result2 = evidence_gate(observation.get("observer_output", ""), compact)
     log_gate_decision("evidence_gate", ev_result2, patch_hash="")
-    if not ev_result2.passed:
-        return JSONResponse({
-            "error": "Code generation blocked by Evidence Gate",
-            "gate_reason": ev_result2.reason,
-            "evidence_type": ev_result2.evidence_type,
-            "intent_sources": ev_result2.intent_sources,
-            "observer_output": observation.get("observer_output", ""),
-        }, 403)
-
-    result = build(state, observation)
+
+    # Build with fallback level — always produces an artifact
+    result = build(state, observation, gate_result=ev_result2)
     state.current_artifact = result["patch_output"]
     state.last_patch_hash = result["patch_hash"]
     state.last_builder_ts = time.time()
@@ -253,17 +240,8 @@ async def generate_patch(request: Request):
 
     save_receipt(result["receipt"])
 
-    # Check if builder returned INSUFFICIENT_EVIDENCE
-    patch_output = result["patch_output"]
-    if "INSUFFICIENT_EVIDENCE" in patch_output:
-        return {
-            "patch_output": patch_output,
-            "patch_hash": result["patch_hash"],
-            "receipt": result["receipt"],
-            "insufficient_evidence": True,
-        }
-
     # Auto-store artifact so patch_hash can be resolved and executed
+    patch_output = result["patch_output"]
     extracted_code = extract_code_from_output(patch_output)
     if not extracted_code:
         extracted_code = patch_output  # fallback: store raw output as code
@@ -273,11 +251,24 @@ async def generate_patch(request: Request):
         "observer_output": patch_output,
         "timestamp": time.time(),
         "session_id": session_id,
+        "fallback_level": result.get("fallback_level", 0),
+        "artifact_type": result.get("artifact_type", ""),
+        "sensory_channels": ev_result2.sensory_channels,
+        "feature_attribution": ev_result2.feature_attribution,
     }
     artifact_store[result["patch_hash"]] = artifact_data
     save_artifact_disk(result["patch_hash"], artifact_data)
 
-    return result
+    return {
+        **result,
+        "gate": {
+            "fallback_level": ev_result2.fallback_level,
+            "artifact_type": ev_result2.artifact_type,
+            "sensory_channels": ev_result2.sensory_channels,
+            "feature_attribution": ev_result2.feature_attribution,
+            "reason": ev_result2.reason,
+        },
+    }
 
 
 # In-memory artifact store: patch_hash -> {code, output, timestamp}

src/builder_llm.py

@@ -12,26 +12,53 @@ import requests
 from .stream_state import SessionState, sha256_text
 
 
-BUILDER_PROMPT = """You are the Builder in a Continuity Sensory Code Engine.
+BUILDER_PROMPT = """You are the Builder in a Continuity Sensory Code Engine — Sensory Proprietary Compiler V1.
 
-You receive an observation from the Observer LLM and must produce a structured artifact.
+You receive an observation from the Observer LLM and a FALLBACK LEVEL. You MUST produce a structured artifact. NEVER return empty. NEVER return INSUFFICIENT_EVIDENCE.
 
 CRITICAL RULES — VIOLATION = REJECTION:
 1. The CODE section MUST contain ONLY valid, executable Python code.
 2. Do NOT put prose, explanations, or English text in the CODE section.
 3. Do NOT put code in the EVIDENCE or REASONING sections.
-4. All imports MUST be from packages available in the environment: fastapi, uvicorn, pillow, numpy, requests, openai, huggingface_hub, python-multipart, and Python stdlib (os, sys, json, math, re, collections, datetime, etc.).
+4. All imports MUST be from packages available in the environment: fastapi, uvicorn, pillow, numpy, requests, openai, huggingface_hub, python-multipart, and Python stdlib (os, sys, json, math, re, collections, datetime, hashlib, time, uuid, etc.).
 5. Do NOT import cv2, torch, tensorflow, pandas, matplotlib, scipy, sklearn, or any package not listed above.
 6. Do NOT use input() or any interactive call — code must run non-interactively.
-7. If the observation does not contain enough intent (no speech, no visible screen text, no explicit goal), return INSUFFICIENT_EVIDENCE instead of generating task-specific code.
+
+FALLBACK LADDER — you are at the level indicated. Generate code appropriate to that level:
+
+LEVEL 1 (task_code): Explicit user intent detected. Generate task-specific code that does what the user asked.
+
+LEVEL 2 (instrumentation_code): No explicit intent, but rich sensory features (camera, motion, audio). Generate instrumentation code that:
+  - Captures and quantifies the sensory channels present (motion metrics, audio energy, frame entropy)
+  - Creates reusable measurement utilities
+  - Produces a feature vector or data structure from the sensory input
+  - Example: motion rhythm analyzer, audio energy spectrum, frame entropy tracker
+
+LEVEL 3 (aesthetic_motif): Distinctive visual features but no clear intent. Generate code that:
+  - Extracts aesthetic features from described visual input (color palette, light patterns, composition)
+  - Creates a UI theme, color scheme, or visual motif from the sensory description
+  - Produces a design grammar or style specification
+  - Example: color palette generator from room description, UI theme from lighting conditions
+
+LEVEL 4 (topic_association): Only background audio/speech detected. Generate code that:
+  - Maps detected topics to relevant tools or code patterns
+  - Creates a topic-to-tool association dictionary
+  - Generates a transcript summarizer or topic classifier
+  - Example: TV topic to code domain mapper, background speech topic extractor
+
+LEVEL 5 (capture_protocol): Minimal sensory signal. Generate code that:
+  - Improves the capture protocol itself
+  - Creates a better sampling strategy or capture diagnostic
+  - Produces a session health check or capture quality report
+  - Example: adaptive frame rate calculator, audio sensitivity tuner, capture health monitor
 
 Output format (use exactly these headers):
 
 EVIDENCE:
-- List specific sensory evidence from the observation.
+- List specific sensory evidence from the observation. Include channel names and feature values.
 
 REASONING:
-- Step by step: why this code should be written. Connect evidence to decisions.
+- Step by step: why this artifact should exist. Connect sensory evidence to code decisions. Explain which fallback level triggered this.
 
 CODE:
 ```python
@@ -46,10 +73,7 @@ TEST:
 - Minimal verification step.
 
 ATTRIBUTION:
-- Which sensory evidence (frame hashes, audio segments, motion scores) triggered this code.
-
-If evidence is insufficient, output:
-INSUFFICIENT_EVIDENCE: [explanation of what's missing]
+- Which sensory evidence (frame hashes, audio segments, motion scores, visual features) triggered this code. Be specific.
 """
 
 
@@ -106,11 +130,22 @@ def call_hf_inference(prompt: str) -> str:
     return response.choices[0].message.content
 
 
-def build(state: SessionState, observation: dict) -> dict:
+def build(state: SessionState, observation: dict, gate_result=None) -> dict:
     """Run builder LLM on observer output.
 
     Returns code patch with attribution receipt.
+    Now accepts gate_result with fallback_level and feature_attribution.
     """
+    fallback_level = 1
+    artifact_type = "task_code"
+    sensory_channels = []
+    feature_attribution = {}
+    if gate_result:
+        fallback_level = gate_result.fallback_level
+        artifact_type = gate_result.artifact_type
+        sensory_channels = gate_result.sensory_channels
+        feature_attribution = gate_result.feature_attribution
+
     prompt = f"""{BUILDER_PROMPT}
 
 OBSERVER OUTPUT:
@@ -118,7 +153,12 @@ OBSERVER OUTPUT:
 
 MODE: {state.mode}
 
-The observer has inferred the intent from camera + audio. Generate code based on that inferred intent now."""
+FALLBACK LEVEL: {fallback_level}
+ARTIFACT TYPE: {artifact_type}
+SENSORY CHANNELS: {', '.join(sensory_channels) if sensory_channels else 'none'}
+FEATURE ATTRIBUTION: {json.dumps(feature_attribution, default=str)}
+
+You are at FALLBACK LEVEL {fallback_level}. Generate {artifact_type} based on the available sensory evidence. NEVER return INSUFFICIENT_EVIDENCE. Always produce a CODE section with runnable Python."""
 
     provider = os.getenv("PROVIDER", "groq").lower().strip()
     if provider == "ollama":
@@ -151,12 +191,18 @@ The observer has inferred the intent from camera + audio. Generate code based on
         "uncertainty": _extract_uncertainty(observation),
         "mode": state.mode,
         "provider": provider,
+        "fallback_level": fallback_level,
+        "artifact_type": artifact_type,
+        "sensory_channels": sensory_channels,
+        "feature_attribution": feature_attribution,
     }
 
     return {
         "patch_output": output,
         "patch_hash": patch_hash,
         "receipt": receipt,
+        "fallback_level": fallback_level,
+        "artifact_type": artifact_type,
     }
 
 

src/gate.py

@@ -120,72 +120,159 @@ class EvidenceGateResult:
     reason: str
     evidence_type: str = ""
     intent_sources: list[str] = field(default_factory=list)
+    fallback_level: int = 0
+    artifact_type: str = ""
+    sensory_channels: list[str] = field(default_factory=list)
+    feature_attribution: dict = field(default_factory=dict)
 
 
 def evidence_gate(observer_output: str, state_dict: dict) -> EvidenceGateResult:
-    """Validate that sufficient intent exists before task-specific code generation.
+    """Sensory Proprietary Compiler V1 — Fallback Ladder.
     
-    Rules:
-    - Camera-only evidence → observation/instrumentation code only
-    - Task-specific code requires: user speech, visible screen text, typed intent, or prior session goal
-    - Empty audio + empty transcript → block task-specific generation
+    NEVER returns zero artifact. Every sensory input produces something useful.
+    
+    Fallback levels:
+    1. Explicit intent → task code
+    2. Weak intent + rich sensory → instrumentation code
+    3. Distinctive sensory features → aesthetic/system motifs
+    4. Background audio only → topic-to-tool associations
+    5. Minimal signal → capture protocol improvement
     """
     obs = (observer_output or "").lower()
     
     # Gather intent sources
     intent_sources = []
+    sensory_channels = []
+    feature_attribution = {}
     
     # Check for user speech / transcript
     speakers = state_dict.get("speakers", {})
     user_transcript = speakers.get("user", {}).get("transcript", "")
     if user_transcript and user_transcript.strip():
         intent_sources.append("user_speech")
+        sensory_channels.append("user_voice")
+        feature_attribution["user_speech"] = user_transcript[:200]
     
     # Check for any audio chunks with content
     audio_chunks = state_dict.get("audio", {}).get("chunks", [])
     has_audio_content = any(c.get("transcript", "").strip() for c in audio_chunks if isinstance(c, dict))
     if has_audio_content:
         intent_sources.append("audio_transcript")
+        sensory_channels.append("audio")
+    
+    # Check for background speakers (TV, other people)
+    for spk, info in speakers.items():
+        if spk != "user" and info.get("transcript", "").strip():
+            sensory_channels.append(f"background_voice:{spk}")
+            feature_attribution[f"background_{spk}"] = info["transcript"][:200]
     
     # Check for visible screen text / code in observer output
     screen_indicators = ["screen", "code on", "text on", "monitor", "display", "laptop", "ide", "editor", "terminal"]
     has_screen_evidence = any(s in obs for s in screen_indicators)
     if has_screen_evidence:
         intent_sources.append("visible_screen")
+        sensory_channels.append("screen")
     
     # Check for explicit typed intent / prior goal
     if "goal" in obs or "intent" in obs or "task" in obs or "want" in obs:
         intent_sources.append("explicit_intent")
     
-    # Check for motion / objects (camera-only evidence)
-    camera_indicators = ["face", "person", "movement", "object", "light", "wall", "fabric", "hand", "gesture"]
+    # Check for camera sensory features
+    camera_indicators = ["face", "person", "movement", "object", "light", "wall", "fabric", "hand", "gesture",
+                         "hair", "color", "purple", "brown", "breathing", "motion", "room"]
     has_camera_evidence = any(s in obs for s in camera_indicators)
+    if has_camera_evidence:
+        sensory_channels.append("camera")
+        # Extract specific features
+        for indicator in camera_indicators:
+            if indicator in obs:
+                feature_attribution[f"visual_{indicator}"] = True
+    
+    # Check motion score
+    motion_score = state_dict.get("motion_score", 0.0)
+    if motion_score > 0.01:
+        sensory_channels.append("motion")
+        feature_attribution["motion_score"] = round(motion_score, 4)
+    
+    # Check frame count (camera active)
+    visual = state_dict.get("visual", {})
+    frame_count = visual.get("frame_count", 0)
+    if frame_count > 0:
+        sensory_channels.append("frames")
+        feature_attribution["frame_count"] = frame_count
+        feature_attribution["avg_entropy"] = visual.get("avg_entropy", 0)
+        feature_attribution["avg_motion"] = visual.get("avg_motion", 0)
     
-    # Determine evidence type
+    # Check audio chunk count
+    audio_chunk_count = state_dict.get("audio", {}).get("chunk_count", 0)
+    if audio_chunk_count > 0:
+        feature_attribution["audio_chunks"] = audio_chunk_count
+    
+    # ─── Fallback Ladder ───
+    
+    # Level 1: Explicit intent → task code
     if intent_sources:
-        evidence_type = "sufficient_intent"
         return EvidenceGateResult(
             passed=True,
-            reason=f"Intent sources: {', '.join(intent_sources)}",
-            evidence_type=evidence_type,
+            reason=f"Level 1: Explicit intent detected. Sources: {', '.join(intent_sources)}",
+            evidence_type="sufficient_intent",
             intent_sources=intent_sources,
+            fallback_level=1,
+            artifact_type="task_code",
+            sensory_channels=sensory_channels,
+            feature_attribution=feature_attribution,
+        )
+    
+    # Level 2: Weak intent but rich sensory features → instrumentation code
+    if has_camera_evidence and (len(sensory_channels) >= 2 or motion_score > 0.05):
+        return EvidenceGateResult(
+            passed=True,
+            reason=f"Level 2: Rich sensory evidence ({', '.join(sensory_channels)}). Generating instrumentation code.",
+            evidence_type="sensory_rich",
+            intent_sources=[],
+            fallback_level=2,
+            artifact_type="instrumentation_code",
+            sensory_channels=sensory_channels,
+            feature_attribution=feature_attribution,
         )
-    elif has_camera_evidence:
-        evidence_type = "camera_only"
+    
+    # Level 3: Distinctive sensory features → aesthetic/system motifs
+    if has_camera_evidence or frame_count > 0:
         return EvidenceGateResult(
-            passed=False,
-            reason="Camera-only evidence detected. Task-specific code requires user speech, visible screen text, or explicit intent. Observation/instrumentation code is allowed.",
-            evidence_type=evidence_type,
+            passed=True,
+            reason=f"Level 3: Distinctive sensory features ({', '.join(sensory_channels)}). Generating motif/design artifact.",
+            evidence_type="sensory_distinctive",
             intent_sources=[],
+            fallback_level=3,
+            artifact_type="aesthetic_motif",
+            sensory_channels=sensory_channels,
+            feature_attribution=feature_attribution,
         )
-    else:
-        evidence_type = "insufficient"
+    
+    # Level 4: Background audio only → topic-to-tool associations
+    if audio_chunk_count > 0 or any("background_voice" in ch for ch in sensory_channels):
         return EvidenceGateResult(
-            passed=False,
-            reason="Insufficient evidence for code generation. No camera, audio, or intent signals detected.",
-            evidence_type=evidence_type,
+            passed=True,
+            reason="Level 4: Audio evidence only. Generating topic-to-tool association artifact.",
+            evidence_type="audio_only",
             intent_sources=[],
+            fallback_level=4,
+            artifact_type="topic_association",
+            sensory_channels=sensory_channels,
+            feature_attribution=feature_attribution,
         )
+    
+    # Level 5: Minimal signal → capture protocol improvement
+    return EvidenceGateResult(
+        passed=True,
+        reason="Level 5: Minimal sensory signal. Generating capture protocol improvement artifact.",
+        evidence_type="minimal_signal",
+        intent_sources=[],
+        fallback_level=5,
+        artifact_type="capture_protocol",
+        sensory_channels=sensory_channels,
+        feature_attribution=feature_attribution,
+    )
 
 
 # ─── Gate log for audit ───
@@ -208,6 +295,11 @@ def log_gate_decision(gate_type: str, result, patch_hash: str = "", code_preview
     if hasattr(result, "evidence_type"):
         entry["evidence_type"] = result.evidence_type
         entry["intent_sources"] = result.intent_sources
+    if hasattr(result, "fallback_level"):
+        entry["fallback_level"] = result.fallback_level
+        entry["artifact_type"] = result.artifact_type
+        entry["sensory_channels"] = result.sensory_channels
+        entry["feature_attribution"] = result.feature_attribution
     _gate_log.append(entry)
     if len(_gate_log) > 100:
         _gate_log.pop(0)