@tangle-network/starter-foundry 0.5.3 → 0.7.0

package/registry/families/lora-training/files/config/train.yaml

@@ -0,0 +1,54 @@
+# LoRA / QLoRA training config. Load via `python train.py --config config/train.yaml`.
+
+model:
+  base_model_id: "{{baseModelId}}"
+  # Load the base in 4-bit (QLoRA). Set to false for plain fp16 LoRA if you
+  # have enough VRAM (needs ~2x the 4-bit footprint).
+  load_in_4bit: true
+  bnb_4bit_quant_type: "nf4"
+  bnb_4bit_compute_dtype: "bfloat16"
+  bnb_4bit_use_double_quant: true
+  # 'flash_attention_2' on A100+/H100 with flash-attn installed;
+  # 'sdpa' on older GPUs; 'eager' for debugging.
+  attn_implementation: "sdpa"
+
+lora:
+  r: {{loraR}}
+  alpha: {{loraAlpha}}
+  dropout: 0.05
+  bias: "none"
+  task_type: "CAUSAL_LM"
+  # MODEL-SPECIFIC. Llama + Mistral share this list; Gemma/Phi differ.
+  # Wrong list = training runs but adapter learns nothing.
+  target_modules:
+    - q_proj
+    - k_proj
+    - v_proj
+    - o_proj
+    - gate_proj
+    - up_proj
+    - down_proj
+
+data:
+  path: "data/sample.jsonl"
+  # Column with chat messages. Alternative: 'text' for raw-text SFT.
+  messages_column: "messages"
+  max_seq_length: 2048
+
+training:
+  output_dir: "{{outputDir}}"
+  num_train_epochs: {{epochs}}
+  per_device_train_batch_size: 2
+  gradient_accumulation_steps: 8
+  learning_rate: {{learningRate}}
+  lr_scheduler_type: "cosine"
+  warmup_ratio: 0.03
+  weight_decay: 0.0
+  optim: "paged_adamw_8bit"
+  logging_steps: 5
+  save_steps: 50
+  save_total_limit: 3
+  bf16: true
+  gradient_checkpointing: true
+  report_to: "none"
+  seed: 42

package/registry/families/lora-training/files/data/sample.jsonl

@@ -0,0 +1,5 @@
+{"messages": [{"role": "system", "content": "You are a concise technical assistant."}, {"role": "user", "content": "What is LoRA?"}, {"role": "assistant", "content": "Low-Rank Adaptation freezes the base model and trains small rank-r matrices inserted into the attention/MLP projections. Adapters are 10-500MB instead of 14GB+ for a 7B merged model."}]}
+{"messages": [{"role": "system", "content": "You are a concise technical assistant."}, {"role": "user", "content": "Why 4-bit quantization for QLoRA?"}, {"role": "assistant", "content": "4-bit NF4 cuts base model memory 4x vs fp16. A 7B model fits on 8GB of VRAM, and training a LoRA on top is dominated by the adapter gradients, not the frozen base."}]}
+{"messages": [{"role": "system", "content": "You are a concise technical assistant."}, {"role": "user", "content": "When should I NOT use LoRA?"}, {"role": "assistant", "content": "Full fine-tuning wins when you need to change the base model's world knowledge or tokenizer, or when you have many thousands of diverse tasks. LoRA shines for narrow behavior shifts on top of a competent base."}]}
+{"messages": [{"role": "system", "content": "You are a concise technical assistant."}, {"role": "user", "content": "What's lora_alpha?"}, {"role": "assistant", "content": "A scaling factor applied to the LoRA update: effective scale = alpha / r. Keep alpha/r constant across rank changes (standard: alpha = 2r) so learning rate stays comparable."}]}
+{"messages": [{"role": "system", "content": "You are a concise technical assistant."}, {"role": "user", "content": "How do I serve a LoRA adapter?"}, {"role": "assistant", "content": "Load the base model once and attach the adapter at runtime. vLLM supports --enable-lora with --lora-modules name=path; TGI and SGLang have similar multi-LoRA serving modes. For a single adapter, PeftModel.from_pretrained works."}]}

package/registry/families/lora-training/files/pyproject.toml

@@ -0,0 +1,29 @@
+[project]
+name = "{{serviceName}}"
+version = "0.1.0"
+description = "LoRA / QLoRA fine-tuning starter — PEFT + TRL + bitsandbytes"
+requires-python = ">=3.10"
+dependencies = [
+  "transformers>=4.44.0",
+  "peft>=0.13.0",
+  "trl>=0.11.0",
+  "accelerate>=0.34.0",
+  "bitsandbytes>=0.44.0",
+  "datasets>=3.0.0",
+  "pyyaml>=6.0.2",
+  "python-dotenv>=1.0.0",
+  "sentencepiece>=0.2.0",
+  "protobuf>=4.25.0",
+]
+
+[project.optional-dependencies]
+# Optional on Ampere+/Hopper GPUs. Skip on older cards or set
+# attn_implementation: 'sdpa' in config/train.yaml.
+flash = ["flash-attn>=2.6.0"]
+
+[build-system]
+requires = ["setuptools>=69", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+py-modules = ["train", "infer"]

package/registry/families/lora-training/files/validate-lora.mjs

@@ -0,0 +1,63 @@
+import fs from "node:fs/promises";
+
+const [pyproject, trainCfg, sampleData, trainPy, inferPy, readme] = await Promise.all([
+  fs.readFile("pyproject.toml", "utf8"),
+  fs.readFile("config/train.yaml", "utf8"),
+  fs.readFile("data/sample.jsonl", "utf8"),
+  fs.readFile("train.py", "utf8"),
+  fs.readFile("infer.py", "utf8"),
+  fs.readFile("README.md", "utf8"),
+]);
+
+for (const dep of ["peft", "transformers", "bitsandbytes", "datasets", "accelerate", "trl"]) {
+  if (!pyproject.includes(dep)) {
+    throw new Error(`pyproject.toml missing ${dep}`);
+  }
+}
+
+for (const key of ["base_model_id", "lora:", "target_modules", "num_train_epochs", "learning_rate"]) {
+  if (!trainCfg.includes(key)) {
+    throw new Error(`config/train.yaml missing ${key}`);
+  }
+}
+if (!trainCfg.includes("r:") || !trainCfg.includes("alpha:")) {
+  throw new Error("config/train.yaml must declare lora r and alpha");
+}
+
+// data/sample.jsonl must be real JSONL with messages column
+const lines = sampleData.split("\n").filter((l) => l.trim().length > 0);
+if (lines.length < 3) {
+  throw new Error(`data/sample.jsonl must contain at least 3 SFT rows, found ${lines.length}`);
+}
+for (const line of lines) {
+  let row;
+  try {
+    row = JSON.parse(line);
+  } catch (err) {
+    throw new Error(`data/sample.jsonl malformed JSON line: ${line.slice(0, 60)}...`);
+  }
+  if (!Array.isArray(row.messages) || row.messages.length === 0) {
+    throw new Error("data/sample.jsonl rows must have a messages array");
+  }
+}
+
+for (const token of ["SFTTrainer", "LoraConfig", "BitsAndBytesConfig", "AutoModelForCausalLM"]) {
+  if (!trainPy.includes(token)) {
+    throw new Error(`train.py missing ${token}`);
+  }
+}
+if (!trainPy.includes("--config")) {
+  throw new Error("train.py must accept --config");
+}
+
+for (const token of ["PeftModel", "AutoModelForCausalLM", "--adapter", "--prompt"]) {
+  if (!inferPy.includes(token)) {
+    throw new Error(`infer.py missing ${token}`);
+  }
+}
+
+if (!readme.includes("python train.py") || !readme.includes("python infer.py")) {
+  throw new Error("README.md should document both train and infer flows");
+}
+
+console.log("lora training starter ok");

package/registry/families/lora-training/manifest.json

@@ -0,0 +1,183 @@
+{
+  "id": "lora-training",
+  "description": "LoRA / QLoRA fine-tuning starter — PEFT adapters on top of a 4-bit-quantized base model via bitsandbytes, trained with TRL's SFTTrainer on a JSONL dataset. Ships a complete config-driven train.py, an infer.py that loads base + adapter, and a tiny sample dataset. For teams that want to customize a pretrained LLM without the memory footprint of full fine-tuning.",
+  "tags": [
+    "ml",
+    "llm",
+    "training",
+    "fine-tuning",
+    "lora",
+    "qlora",
+    "peft",
+    "python"
+  ],
+  "taxonomy": {
+    "language": "python",
+    "runtime": "python",
+    "surface": "inference"
+  },
+  "slots": {},
+  "defaults": {
+    "projectType": "inference",
+    "serviceName": "starter-foundry-lora",
+    "baseModelId": "meta-llama/Meta-Llama-3.1-8B-Instruct",
+    "outputDir": "./outputs/lora-adapter",
+    "loraR": 16,
+    "loraAlpha": 32,
+    "learningRate": 0.0002,
+    "epochs": 3
+  },
+  "files": [
+    {
+      "source": "files/pyproject.toml",
+      "target": "pyproject.toml"
+    },
+    {
+      "source": "files/config/train.yaml",
+      "target": "config/train.yaml"
+    },
+    {
+      "source": "files/data/sample.jsonl",
+      "target": "data/sample.jsonl"
+    },
+    {
+      "source": "files/.env.example",
+      "target": ".env.example"
+    },
+    {
+      "source": "files/README-lora.md",
+      "target": "README.md"
+    },
+    {
+      "source": "files/validate-lora.mjs",
+      "target": "validate-lora.mjs"
+    }
+  ],
+  "validationChecks": [
+    {
+      "type": "file-exists",
+      "path": "pyproject.toml"
+    },
+    {
+      "type": "file-exists",
+      "path": "config/train.yaml"
+    },
+    {
+      "type": "file-exists",
+      "path": "data/sample.jsonl"
+    },
+    {
+      "type": "file-exists",
+      "path": "train.py"
+    },
+    {
+      "type": "file-exists",
+      "path": "infer.py"
+    },
+    {
+      "type": "command-success",
+      "command": [
+        "node",
+        "validate-lora.mjs"
+      ],
+      "expect": "lora training starter ok"
+    }
+  ],
+  "contextHints": {
+    "commands": [
+      "pip install -e .",
+      "python train.py --config config/train.yaml",
+      "python infer.py --adapter {{outputDir}} --prompt 'hello'"
+    ],
+    "entrypoints": [
+      "train.py",
+      "infer.py",
+      "config/train.yaml",
+      "data/sample.jsonl"
+    ],
+    "preview": null,
+    "extensionPoints": [
+      "config/train.yaml",
+      "data/sample.jsonl"
+    ]
+  },
+  "keywords": [
+    "lora",
+    "qlora",
+    "peft",
+    "fine-tune",
+    "finetune",
+    "adapter training",
+    "lora adapter",
+    "sft",
+    "sfttrainer",
+    "instruction tuning",
+    "bitsandbytes",
+    "4-bit quantization",
+    "trl",
+    "parameter efficient"
+  ],
+  "scoring": {
+    "boost": {
+      "lora": 4,
+      "qlora": 4,
+      "peft": 3,
+      "fine-tune": 3
+    }
+  },
+  "tieredKeywords": {
+    "tier1": [
+      "lora",
+      "qlora",
+      "peft",
+      "fine-tune a model",
+      "adapter training"
+    ],
+    "tier2": [
+      "sfttrainer",
+      "instruction tuning",
+      "4-bit fine-tuning",
+      "trl lora"
+    ],
+    "archetypes": [
+      "domain-specific llm adapter",
+      "custom fine-tuned model",
+      "instruction-tuned adapter",
+      "task-specific lora"
+    ]
+  },
+  "buildHints": {
+    "whenToUse": "Pick this when you need a custom model behavior (domain language, instruction style, task-specific format) but can't / won't run full fine-tuning. QLoRA 4-bit lets a 7B-8B model tune on a single 24GB GPU; 70B on a single 80GB GPU. For pure inference, use vllm-server / tgi-server / ollama-server. For RAG-style grounding without training, use rag-pipeline-py.",
+    "firstSteps": [
+      "pip install -e . — installs peft, transformers, bitsandbytes, trl, accelerate, datasets",
+      "Replace data/sample.jsonl with your real training set (each line: {\"messages\": [{\"role\": ..., \"content\": ...}, ...]})",
+      "Edit config/train.yaml — base model id, lora_r/alpha, epochs, learning rate",
+      "Set HUGGING_FACE_HUB_TOKEN for gated base models (Llama, Mistral, Gemma)",
+      "python train.py --config config/train.yaml (checkpoints land in {{outputDir}})",
+      "python infer.py --adapter {{outputDir}} --prompt 'test' to smoke-test"
+    ],
+    "gotchas": [
+      "bitsandbytes 4-bit requires CUDA. There is no working CPU path for QLoRA — attempting this on a Mac silently falls back to fp16 and OOMs.",
+      "LoRA target_modules is model-architecture-specific. Llama uses ['q_proj','k_proj','v_proj','o_proj']; Gemma and Mistral differ. Copy the wrong list and training runs but adapters learn nothing.",
+      "lora_r above 64 stops helping and starts overfitting. lora_alpha = 2 * lora_r is the standard ratio.",
+      "Checkpoint sizes: LoRA adapters are 10-500MB. Full merged models are 14-30GB. Don't commit merged models; ship the adapter.",
+      "Gated base models need HUGGING_FACE_HUB_TOKEN AND license acceptance on the Hub — token alone 403s.",
+      "TRL's SFTTrainer expects either `text` or `messages` columns in the dataset. Mixing schemas in one file silently trains on the wrong field.",
+      "flash-attention-2 requires torch >= 2.1 and a SM >= 8.0 GPU (A100/H100). Older GPUs: set `attn_implementation: 'sdpa'` in config/train.yaml."
+    ],
+    "placeholders": [
+      {
+        "path": "src/main.py",
+        "description": "data/sample.jsonl (replace with the real training set)"
+      },
+      {
+        "path": "src/main.py",
+        "description": "config/train.yaml (base model id, hyperparameters, target_modules)"
+      },
+      {
+        "path": "src/main.py",
+        "description": ".env (HUGGING_FACE_HUB_TOKEN for gated base models)"
+      }
+    ]
+  }
+}

package/registry/families/move-contracts/files/validate-move.mjs

@@ -10,7 +10,7 @@ if (!manifestSource.includes('name = "{{projectName}}"')) {
   throw new Error("Move.toml missing expected package name");
 }
 
-if (!moduleSource.includes("module {{projectName}}::{{moduleName}}")) {
+if (!moduleSource.includes("module package::{{moduleName}}")) {
   throw new Error("Move module path mismatch");
 }
 

package/registry/families/move-contracts/manifest.json

@@ -65,7 +65,6 @@
   "tieredKeywords": {
     "tier1": [
       "move contract",
-      "aptos",
       "sui move",
       "move module",
       "sui",

package/registry/families/multimodal-agent/files/api/README.md

@@ -0,0 +1,108 @@
+# Multimodal agent backend wiring
+
+The React client posts `multipart/form-data` to `/api/multimodal` with up
+to three parts:
+
+| field   | type       | required |
+|---------|------------|----------|
+| `text`  | string     | always present (may be empty) |
+| `image` | File (JPEG/PNG/WebP) | optional |
+| `audio` | File (audio/webm or audio/mp4) | optional |
+
+Your backend extracts them, forwards to a multimodal LLM, and returns the
+response. Streamed newline-delimited JSON works best — the client already
+handles partial responses and renders as chunks arrive.
+
+## Contract
+
+### `POST /api/multimodal`
+
+**Request:** `multipart/form-data` (set by `FormData`, don't force
+`Content-Type` yourself — the browser picks the boundary).
+
+**Response (non-streaming):**
+```json
+{ "reply": "the multimodal LLM's answer" }
+```
+
+**Response (streaming):** `text/plain` or `application/x-ndjson`, chunks of
+`{"delta":"words as they arrive"}` separated by `\n`. The React client
+flushes each arrival into `pre#out` as it lands.
+
+## Provider recipes
+
+### Anthropic Claude (recommended)
+
+```ts
+import Anthropic from '@anthropic-ai/sdk'
+import express from 'express'
+import multer from 'multer'
+
+const app = express()
+const upload = multer({ storage: multer.memoryStorage(), limits: { fileSize: 20 * 1024 * 1024 } })
+const client = new Anthropic({
+  baseURL: 'https://router.tangle.tools/anthropic',
+  apiKey: process.env.TANGLE_ROUTER_USER_KEY,
+})
+
+app.post('/api/multimodal', upload.fields([{ name: 'image' }, { name: 'audio' }]), async (req, res) => {
+  const files = req.files as Record<string, Express.Multer.File[] | undefined>
+  const image = files.image?.[0]
+  const audio = files.audio?.[0]
+  const text = (req.body.text as string | undefined) ?? ''
+
+  const content: Anthropic.Messages.ContentBlockParam[] = []
+  if (image) {
+    content.push({
+      type: 'image',
+      source: {
+        type: 'base64',
+        media_type: image.mimetype as 'image/jpeg' | 'image/png' | 'image/webp',
+        data: image.buffer.toString('base64'),
+      },
+    })
+  }
+  if (audio) {
+    // Claude's text API doesn't accept audio directly — run STT first
+    // (Whisper, Deepgram) and append the transcript as text:
+    //   const transcript = await transcribe(audio.buffer, audio.mimetype)
+    //   content.push({ type: 'text', text: `[audio transcript] ${transcript}` })
+  }
+  content.push({ type: 'text', text: text || 'Describe what you see/hear.' })
+
+  const msg = await client.messages.create({
+    model: 'claude-sonnet-4-5',
+    max_tokens: 1024,
+    messages: [{ role: 'user', content }],
+  })
+  const reply = msg.content[0]?.type === 'text' ? msg.content[0].text : ''
+  res.json({ reply })
+})
+
+app.listen(8787)
+```
+
+### OpenAI GPT-4o (image + audio natively)
+
+GPT-4o-audio accepts audio blocks directly without STT:
+```ts
+messages: [{
+  role: 'user',
+  content: [
+    { type: 'input_image', image_url: { url: imageDataUrl } },
+    { type: 'input_audio', input_audio: { data: audioBase64, format: 'webm' } },
+    { type: 'input_text', text },
+  ],
+}]
+```
+
+### Google Gemini 2.x
+
+Accepts all three modalities in a single `parts` array. Use the Files API
+for anything over ~5MB.
+
+## Security
+
+- Cap `multer` file sizes (20MB is reasonable for image+audio).
+- Validate MIME type server-side — clients can lie about `Content-Type`.
+- Never log the raw bytes. Image buffers can leak PII.

package/registry/families/multimodal-agent/files/index.html

@@ -0,0 +1,105 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width,initial-scale=1" />
+    <title>{{headline}}</title>
+    <style>
+      :root { color-scheme: dark; }
+      * { box-sizing: border-box; }
+      body {
+        font-family: system-ui, -apple-system, sans-serif;
+        margin: 0;
+        min-height: 100vh;
+        background: #0a0a0a;
+        color: #f2f2f2;
+      }
+      #root { max-width: 760px; margin: 0 auto; padding: 1.5rem; }
+      h1 { margin: 0 0 0.25rem 0; font-size: 1.3rem; }
+      .sub { margin: 0 0 1.25rem 0; color: #888; }
+      .panels {
+        display: grid;
+        grid-template-columns: 1fr 1fr 1fr;
+        gap: 0.75rem;
+      }
+      @media (max-width: 620px) { .panels { grid-template-columns: 1fr; } }
+      .panel {
+        background: #111;
+        border: 1px solid #222;
+        border-radius: 10px;
+        padding: 0.75rem;
+        min-height: 160px;
+        display: flex;
+        flex-direction: column;
+        gap: 0.5rem;
+      }
+      .panel h3 { margin: 0; font-size: 0.85rem; color: #aaa; font-weight: 500; }
+      textarea {
+        flex: 1;
+        background: #0a0a0a;
+        color: #f2f2f2;
+        border: 1px solid #222;
+        border-radius: 6px;
+        padding: 0.5rem;
+        resize: none;
+        font-family: inherit;
+        font-size: 0.9rem;
+      }
+      .drop {
+        flex: 1;
+        border: 2px dashed #333;
+        border-radius: 8px;
+        display: grid;
+        place-items: center;
+        color: #666;
+        font-size: 0.85rem;
+        text-align: center;
+        padding: 0.5rem;
+        cursor: pointer;
+      }
+      .drop.active { border-color: #5fa; color: #5fa; }
+      .drop img { max-width: 100%; max-height: 120px; border-radius: 4px; }
+      button {
+        padding: 0.5rem 0.75rem;
+        font-size: 0.9rem;
+        border: 0;
+        border-radius: 6px;
+        background: #357;
+        color: white;
+        cursor: pointer;
+      }
+      button.danger { background: #933; }
+      button:disabled { opacity: 0.4; cursor: wait; }
+      button.send {
+        width: 100%;
+        margin-top: 1rem;
+        padding: 0.9rem;
+        font-size: 1rem;
+        background: #2a8;
+      }
+      pre#out {
+        margin-top: 1rem;
+        padding: 1rem;
+        background: #111;
+        border: 1px solid #222;
+        border-radius: 8px;
+        min-height: 4rem;
+        white-space: pre-wrap;
+        font-size: 0.9rem;
+      }
+      .pill {
+        display: inline-block;
+        padding: 0.125rem 0.5rem;
+        background: #222;
+        border-radius: 99px;
+        font-size: 0.75rem;
+        color: #aaa;
+      }
+      .recording { color: #f66; }
+    </style>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

package/registry/families/multimodal-agent/files/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "{{packageName}}",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview",
+    "validate": "node validate-multimodal.mjs"
+  },
+  "dependencies": {
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.17.0",
+    "@types/react": "^19.2.0",
+    "@types/react-dom": "^19.2.0",
+    "@vitejs/plugin-react": "^4.7.0",
+    "typescript": "^5.9.0",
+    "vite": "^6.4.2"
+  },
+  "overrides": {
+    "vite": "^6.4.2"
+  },
+  "pnpm": {
+    "overrides": {
+      "vite": "^6.4.2"
+    }
+  }
+}

package/registry/families/multimodal-agent/files/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "jsx": "react-jsx",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "types": ["node", "vite/client"]
+  },
+  "include": ["src/**/*.ts", "src/**/*.tsx", "vite.config.ts"]
+}

package/registry/families/multimodal-agent/files/validate-multimodal.mjs

@@ -0,0 +1,64 @@
+// Structural validator for multimodal-agent. Does NOT open a browser or
+// hit any LLM — just cross-checks the scaffold wiring is coherent.
+
+import fs from "node:fs/promises";
+import { stripTypeScriptTypes } from "node:module";
+
+const [pkgSource, indexHtml, mainTsx, appTsx, viteConfig] = await Promise.all([
+  fs.readFile("package.json", "utf8"),
+  fs.readFile("index.html", "utf8"),
+  fs.readFile("src/main.tsx", "utf8"),
+  fs.readFile("src/App.tsx", "utf8"),
+  fs.readFile("vite.config.ts", "utf8"),
+]);
+
+const pkg = JSON.parse(pkgSource);
+if (pkg.name !== "{{packageName}}") {
+  throw new Error(`package.json name should be "{{packageName}}", got "${pkg.name}"`);
+}
+if (!pkg.dependencies?.react || !pkg.dependencies?.["react-dom"]) {
+  throw new Error("package.json must depend on react + react-dom");
+}
+if (!pkg.devDependencies?.["@vitejs/plugin-react"]) {
+  throw new Error("package.json must devDepend on @vitejs/plugin-react");
+}
+
+if (!indexHtml.includes('id="root"')) {
+  throw new Error('index.html must contain <div id="root"> for React mount');
+}
+if (!indexHtml.includes("/src/main.tsx")) {
+  throw new Error("index.html must reference /src/main.tsx as the module entry");
+}
+
+if (!mainTsx.includes("createRoot") || !mainTsx.includes("react-dom/client")) {
+  throw new Error("src/main.tsx must mount via createRoot from react-dom/client");
+}
+
+// App must exercise all three modalities + the send pipeline.
+if (!appTsx.includes("MediaRecorder")) {
+  throw new Error("src/App.tsx must use MediaRecorder for the audio panel");
+}
+if (!appTsx.includes("FormData")) {
+  throw new Error("src/App.tsx must pack fields into FormData — JSON bloats base64 payloads");
+}
+if (!appTsx.includes("/api/multimodal")) {
+  throw new Error("src/App.tsx must POST to /api/multimodal — the wiring contract");
+}
+if (!appTsx.includes("preventDefault")) {
+  throw new Error("src/App.tsx must call preventDefault on dragover or the drop handler never fires");
+}
+if (!appTsx.includes("revokeObjectURL")) {
+  throw new Error("src/App.tsx must revokeObjectURL on previews — blob leaks stack up fast");
+}
+
+if (!viteConfig.includes("@vitejs/plugin-react")) {
+  throw new Error("vite.config.ts must load @vitejs/plugin-react");
+}
+if (!viteConfig.includes("/api")) {
+  throw new Error("vite.config.ts must proxy /api to the backend in dev");
+}
+
+stripTypeScriptTypes(appTsx);
+stripTypeScriptTypes(mainTsx);
+
+console.log("multimodal-agent starter ok");