Upload Kaiju Coder 7 OpenCode helper package

.opencode/agents/kaiju-coder-7.md

@@ -9,6 +9,7 @@ tools:
   websearch: false
   skill: false
   lsp: false
+  kaiju_write_file: true
   kaiju_artifact: true
 permission:
   read: allow
@@ -33,6 +34,7 @@ permission:
     "git diff*": allow
   external_directory: ask
   kaiju_artifact: allow
+  kaiju_write_file: allow
   doom_loop: ask
   question: deny
 ---
@@ -47,11 +49,13 @@ Dispatch rules:
 
 - Always run `pwd` before file work.
 - For websites, landing pages, owner/business operating packs, multi-file generated artifacts, or Desktop output folders, do not hand-write large files. Immediately use the Kaiju runner.
+- For exact one-file creation requests with exact content, call `kaiju_write_file` after `pwd`.
 - Desktop single-artifact command: call `kaiju_artifact` with `no_planner: true`, `kind: auto`, `out_dir: "$HOME/Desktop/<clear-folder-name>"`, and the full user request.
 - Website plus owner-pack command sequence: call `kaiju_artifact` twice into the same `out_dir`: first with `kind: website`, then with `kind: business_suite`.
 - If the user names a destination folder, use that folder exactly. Otherwise choose a short clear folder name.
 - If `kaiju_artifact` is unavailable, run `kaiju-coder-7-run --no-planner --kind auto --out-dir "<requested-folder>" --prompt "<full user request>"`.
 - Only use edit/write tools directly for small one-file or two-file tasks.
+- After `kaiju_artifact` succeeds, do not read the generated HTML or manifest unless the user explicitly asks you to inspect it. The tool output already provides artifact path, manifest path, and changed file count.
 
 Identity:
 

README.md

@@ -1,5 +1,7 @@
 # OpenCode Quickstart For Kaiju Coder 7
 
+![RMDW logo](assets/RMDWlogo.png)
+
 Kaiju Coder 7 is served as an OpenAI-compatible model with public model id
 `kaiju-coder-7`. After the helper is installed, Kaiju is configured as a normal
 OpenCode model: start OpenCode, select `kaiju/kaiju-coder-7` if needed, and

kaiju_harness/website.py

@@ -27,10 +27,20 @@ IMAGE_BANK: dict[str, list[str]] = {
         "https://images.unsplash.com/photo-1517433670267-08bbd4be890f?auto=format&fit=crop&w=900&q=80",
         "https://images.unsplash.com/photo-1555507036-ab1f4038808a?auto=format&fit=crop&w=900&q=80",
     ],
+    "food": [
+        "https://images.unsplash.com/photo-1562967914-608f82629710?auto=format&fit=crop&w=1400&q=80",
+        "https://images.unsplash.com/photo-1604908176997-125f25cc6f3d?auto=format&fit=crop&w=900&q=80",
+        "https://images.unsplash.com/photo-1550547660-d9450f859349?auto=format&fit=crop&w=900&q=80",
+    ],
     "contractor": [
         "https://images.unsplash.com/photo-1504307651254-35680f356dfd?auto=format&fit=crop&w=1400&q=80",
-        "https://images.unsplash.com/photo-1632759145351-1d592919f522?auto=format&fit=crop&w=900&q=80",
-        "https://images.unsplash.com/photo-1600585154340-be6161a56a0c?auto=format&fit=crop&w=900&q=80",
+        "https://images.unsplash.com/photo-1541888946425-d81bb19240f5?auto=format&fit=crop&w=900&q=80",
+        "https://images.unsplash.com/photo-1503387762-592deb58ef4e?auto=format&fit=crop&w=900&q=80",
+    ],
+    "bookkeeping": [
+        "https://images.unsplash.com/photo-1554224155-6726b3ff858f?auto=format&fit=crop&w=1400&q=80",
+        "https://images.unsplash.com/photo-1554224154-26032ffc0d07?auto=format&fit=crop&w=900&q=80",
+        "https://images.unsplash.com/photo-1454165804606-c3d57bc86b40?auto=format&fit=crop&w=900&q=80",
     ],
     "roofing": [
         "https://images.unsplash.com/photo-1632759145351-1d592919f522?auto=format&fit=crop&w=1400&q=80",
@@ -131,11 +141,13 @@ LAYOUT_BY_TYPE: dict[str, str] = {
     "med_spa": "editorial",
     "salon": "editorial",
     "bakery": "editorial",
+    "food": "editorial",
     "restaurant": "editorial",
     "roofing": "proof",
     "plumbing": "proof",
     "electrical": "proof",
     "contractor": "proof",
+    "bookkeeping": "proof",
     "legal": "proof",
     "dental": "proof",
 }
@@ -176,29 +188,35 @@ def title_case_service(value: str) -> str:
 
 def infer_business_name(prompt: str) -> str:
     patterns = [
-        r"named\s+([A-Z][A-Za-z0-9 &'&-]{2,80}?)(?:\.|,|\s+with|\s+include|\s+for|\s+that|$)",
-        r"called\s+([A-Z][A-Za-z0-9 &'&-]{2,80}?)(?:\.|,|\s+with|\s+include|\s+for|\s+that|$)",
-        r"for\s+([A-Z][A-Za-z0-9 &'&-]{2,80}?)(?:\.|,|\s+with|\s+include|\s+that|$)",
+        r"(?:website|site|landing page|homepage)\s+for\s+([A-Z][A-Za-z0-9 &'&-]{2,80}?)(?:\.|,|\s+at\s+|\s+with|\s+include|\s+that|\s+put|\s+and\s+put|$)",
+        r"for\s+([A-Z][A-Za-z0-9 &'&-]{2,80}?)(?:\.|,|\s+at\s+|\s+with|\s+include|\s+that|\s+put|\s+and\s+put|$)",
+        r"(?:food\s+business|business|company|firm|restaurant|clinic|shop),\s+([A-Z][A-Za-z0-9 &'&-]{2,80}?)(?:\.|,|\s+with|\s+have|\s+include|\s+for|\s+that|$)",
+        r"(?:business|company|firm|restaurant|clinic|shop)\s+named\s+([A-Z][A-Za-z0-9 &'&-]{2,80}?)(?:\.|,|\s+with|\s+have|\s+include|\s+for|\s+that|$)",
+        r"(?:business|company|firm|restaurant|clinic|shop)\s+called\s+([A-Z][A-Za-z0-9 &'&-]{2,80}?)(?:\.|,|\s+with|\s+have|\s+include|\s+for|\s+that|$)",
     ]
     for pattern in patterns:
         match = re.search(pattern, prompt)
         if match:
-            return clean_text(match.group(1), "Local Business").rstrip(".")
+            candidate = clean_text(match.group(1), "Local Business").rstrip(".")
+            if not re.search(r"\bfolder\b|\bdirectory\b|\bdesktop\b", candidate, re.IGNORECASE):
+                return candidate
     return "Local Business"
 
 
 def infer_business_type(prompt: str) -> str:
     lower = prompt.lower()
     choices = [
-        ("barber", ["barber", "fade", "beard", "haircut"]),
+        ("food", ["food business", "fried chicken", "chicken", "chickens", "wings", "family meals", "food truck"]),
+        ("restaurant", ["restaurant", "omakase", "dining", "menu", "cuisine", "reserve a table", "reservation"]),
+        ("barber", ["barber", "skin fade", "beard", "haircut"]),
         ("bakery", ["bakery", "baked", "pastry", "croissant", "cake"]),
         ("roofing", ["roof", "roofing", "gutter", "storm"]),
         ("contractor", ["contractor", "remodel", "construction", "hvac", "repair"]),
+        ("bookkeeping", ["bookkeeping", "bookkeeper", "payroll", "accounting", "accountant", "financial reporting"]),
         ("cleaning", ["cleaning", "maid", "janitorial"]),
         ("fitness", ["fitness", "gym", "trainer"]),
         ("med_spa", ["med spa", "medical spa", "botox", "injectables", "facial", "skincare", "skin care"]),
         ("salon", ["salon", "esthetician", "hair stylist", "hair studio"]),
-        ("restaurant", ["restaurant", "coffee", "cafe", "menu"]),
         ("real_estate", ["real estate", "realtor", "homes", "property"]),
         ("pets", ["pet", "dog", "groomer", "veterinary", "vet"]),
         ("auto", ["auto", "car", "detailer", "mechanic", "repair shop"]),
@@ -215,6 +233,49 @@ def infer_business_type(prompt: str) -> str:
     return "default"
 
 
+def infer_location(prompt: str) -> str:
+    city_state = re.search(r"\b([A-Z][A-Za-z .'-]{2,40}),\s*([A-Z]{2})(?:\s+\d{5})?\b", prompt)
+    if city_state:
+        return f"{clean_text(city_state.group(1), 'Atlanta')}, {city_state.group(2)}"
+    in_city = re.search(r"\bin\s+([A-Z][A-Za-z .'-]{2,40})(?:\.|,|\s+with|\s+include|\s+for|\s+that|$)", prompt)
+    if in_city:
+        candidate = clean_text(in_city.group(1), "Atlanta").rstrip(".")
+        if not re.search(r"\bfolder\b|\bdesktop\b|\bsection\b", candidate, re.IGNORECASE):
+            return candidate
+    return "Atlanta"
+
+
+def contact_phone_for_location(location: str) -> str:
+    lower = location.lower()
+    area_codes = [
+        ("san francisco", "415"),
+        ("austin", "512"),
+        ("boston", "617"),
+        ("charlotte", "704"),
+        ("new york", "212"),
+        ("los angeles", "323"),
+        ("chicago", "312"),
+        ("miami", "305"),
+        ("atlanta", "404"),
+    ]
+    for city, code in area_codes:
+        if city in lower:
+            return f"({code}) 555-0199"
+    state_codes = {
+        " ca": "415",
+        " tx": "512",
+        " ma": "617",
+        " nc": "704",
+        " ny": "212",
+        " fl": "305",
+        " ga": "404",
+    }
+    for marker, code in state_codes.items():
+        if lower.endswith(marker) or f",{marker}" in lower:
+            return f"({code}) 555-0199"
+    return "(404) 555-0199"
+
+
 def term_matches(lower_text: str, term: str) -> bool:
     if " " in term:
         return term in lower_text
@@ -225,8 +286,10 @@ def infer_services(prompt: str, business_type: str) -> list[str]:
     defaults = {
         "barber": ["Signature Cuts", "Skin Fades", "Beard Trims", "Hot Towel Shaves"],
         "bakery": ["Fresh Pastries", "Custom Cakes", "Coffee Bar", "Catering Boxes"],
+        "food": ["Signature Chicken", "Family Meals", "Catering Trays", "Sides & Drinks"],
         "roofing": ["Roof Repair", "Full Replacement", "Storm Inspection", "Gutter Service"],
         "contractor": ["Repairs", "Installations", "Project Planning", "Emergency Help"],
+        "bookkeeping": ["Monthly Bookkeeping", "Payroll Support", "Financial Reporting", "Cleanup Projects"],
         "cleaning": ["Deep Cleaning", "Recurring Service", "Move-Out Cleaning", "Office Cleaning"],
         "fitness": ["Strength Training", "Nutrition Coaching", "Mobility Work", "Accountability"],
         "salon": ["Signature Service", "Treatment Plans", "Consultations", "Aftercare"],
@@ -244,6 +307,66 @@ def infer_services(prompt: str, business_type: str) -> list[str]:
         "default": ["Consultation", "Planning", "Delivery", "Support"],
     }
     lower = prompt.lower()
+    package_match = re.search(r"(?:service\s+)?packages?\s+with\s+prices?\s*\(([^)]{20,220})\)", prompt, re.IGNORECASE)
+    if package_match:
+        packages = []
+        for item in re.split(r",|;", package_match.group(1)):
+            name = re.sub(r"\$[\d,]+(?:/mo)?", "", item, flags=re.IGNORECASE).strip(" -:")
+            if len(name) > 2:
+                packages.append(title_case_service(name))
+        if len(packages) >= 3:
+            return packages[:4]
+    if business_type == "restaurant":
+        simple_menu_match = re.search(
+            r"menu highlights with\s+(.+?)(?:,\s*omakase|,\s*reservation|,\s*hours|\.|$)",
+            prompt,
+            re.IGNORECASE | re.DOTALL,
+        )
+        if simple_menu_match:
+            dishes = []
+            normalized_menu = re.sub(r"\s+and\s+", ", ", simple_menu_match.group(1))
+            for item in re.split(r",|;", normalized_menu):
+                cleaned = re.sub(r"\([^)]*\)|\$[\d,]+", "", item).strip(" -:")
+                if len(cleaned) > 3:
+                    dishes.append(title_case_service(cleaned))
+            if len(dishes) >= 3:
+                return dishes[:4]
+        parenthetical_dishes = []
+        for match in re.finditer(r"([A-Z][A-Za-z0-9 '&-]{3,60}?)\s*\(", prompt):
+            dish = title_case_service(match.group(1))
+            if len(dish) > 3 and dish.lower() not in {"hours", "location", "phone", "email"}:
+                parenthetical_dishes.append(dish)
+        if len(parenthetical_dishes) >= 3:
+            return parenthetical_dishes[:4]
+        bullet_dishes = []
+        for match in re.finditer(r"^\s*-\s*([A-Z][^\n(]+?)(?:\s*\(|$)", prompt, re.MULTILINE):
+            dish = title_case_service(match.group(1))
+            if len(dish) > 3 and dish.lower() not in {"hours", "address", "phone", "email"}:
+                bullet_dishes.append(dish)
+        if len(bullet_dishes) >= 3:
+            return bullet_dishes[:4]
+        menu_match = re.search(r"(?:items\s+like|include\s+items\s+like|signature\s+dishes(?:\s+with\s+prices)?)[^:]*:\s*([^.]*)", prompt, re.IGNORECASE)
+        if menu_match:
+            dishes = []
+            for item in re.split(r",|;", menu_match.group(1)):
+                name = re.sub(r"\([^)]*\)|\$[\d,]+", "", item).strip(" -:")
+                if len(name) > 3:
+                    dishes.append(title_case_service(name))
+            if len(dishes) >= 3:
+                return dishes[:4]
+    if business_type == "bakery" and any(term in lower for term in ["weekly specials", "catering", "order-ahead", "order ahead"]):
+        bakery_services = ["Fresh Pastries"]
+        if "weekly specials" in lower:
+            bakery_services.append("Weekly Specials")
+        if "catering" in lower:
+            bakery_services.append("Catering Boxes")
+        if "cake" in lower or "cakes" in lower:
+            bakery_services.append("Custom Cakes")
+        if len(bakery_services) < 4:
+            bakery_services.append("Coffee Bar")
+        return bakery_services[:4]
+    if business_type == "contractor" and re.search(r"project sectors?", lower):
+        return ["Ground-Up Construction", "Tenant Improvements", "Industrial Buildouts", "Preconstruction Planning"]
     if "services" in lower:
         after = re.split(r"services[:\s]", prompt, flags=re.IGNORECASE, maxsplit=1)
         if len(after) == 2:
@@ -288,12 +411,33 @@ def infer_palette(prompt: str, business_type: str) -> str:
 
 
 def infer_cta(prompt: str, business_type: str) -> str:
+    lower = prompt.lower()
+    quoted = re.search(r"['\"]([A-Za-z][A-Za-z0-9 &'/-]{2,50})['\"]\s+CTA", prompt)
+    if quoted:
+        return clean_text(quoted.group(1), "Get started").rstrip(" .")
+    if "reserve a table" in lower or "reservation" in lower:
+        return "Reserve a Table"
+    if "cleanup-call" in lower or "cleanup call" in lower:
+        return "Book a Cleanup Call"
+    if "bid-request" in lower or "bid request" in lower:
+        return "Request a Bid"
+    if "order-ahead" in lower or "order ahead" in lower or "online order" in lower:
+        return "Order Ahead"
     match = re.search(
         r"\bCTA\s+(?:is\s+|should\s+be\s+|button\s+is\s+)?[\"']?([A-Za-z][A-Za-z0-9 &'/-]{2,50}?)[\"']?(?:[.!?;,]|$)",
         prompt,
     )
     if match:
-        return clean_text(match.group(1), "Get started").rstrip(" .")
+        candidate = clean_text(match.group(1), "Get started").rstrip(" .")
+        candidate_lower = candidate.lower()
+        if (
+            candidate_lower not in {"button", "section", "call", "contact"}
+            and not candidate_lower.startswith("and ")
+            and not any(term in candidate_lower for term in ("testimonial", "price section", "hero section"))
+        ):
+            return candidate
+    if business_type == "food":
+        return "Order Now"
     if business_type == "barber":
         return "Book a chair"
     if "emergency" in prompt.lower():
@@ -304,11 +448,13 @@ def infer_cta(prompt: str, business_type: str) -> str:
 def spec_from_prompt(prompt: str) -> WebsiteSpec:
     business_type = infer_business_type(prompt)
     name = infer_business_name(prompt)
+    location = infer_location(prompt)
     services = infer_services(prompt, business_type)
     cta = infer_cta(prompt, business_type)
     return WebsiteSpec(
         business_name=name,
         business_type=business_type,
+        location=location,
         headline=headline_for(name, business_type),
         subheadline=subheadline_for(business_type),
         cta=cta,
@@ -320,6 +466,7 @@ def spec_from_prompt(prompt: str) -> WebsiteSpec:
             "I knew what was happening at every step.",
         ],
         palette=infer_palette(prompt, business_type),
+        contact_phone=contact_phone_for_location(location),
     )
 
 
@@ -327,12 +474,14 @@ def headline_for(name: str, business_type: str) -> str:
     options = {
         "barber": "Sharp cuts. Clean fades. Easy booking.",
         "bakery": "Fresh pastries, warm coffee, zero guesswork.",
+        "food": "Hot chicken, clear prices, easy ordering.",
         "roofing": "Roofing help when it actually matters.",
         "contractor": "Reliable work, clear scope, cleaner results.",
+        "bookkeeping": "Clean books, clear payroll, better owner decisions.",
         "cleaning": "A cleaner home without the scheduling mess.",
         "fitness": "Private training built around real consistency.",
         "salon": "Skin, style, and care that feels considered.",
-        "restaurant": "Local flavor with a reason to come back.",
+        "restaurant": "Where tradition meets the harbor.",
         "real_estate": "Confident moves for buyers and sellers.",
         "pets": "Gentle grooming for pets people love.",
         "auto": "Mobile detailing that makes the car feel new.",
@@ -352,12 +501,14 @@ def subheadline_for(business_type: str) -> str:
     options = {
         "barber": "Premium barbering with visible services, simple pricing, real photos, and a direct chair-booking CTA.",
         "bakery": "A warm neighborhood page with menu highlights, catering, hours, and a clear path to order.",
+        "food": "A simple food-business site with strong photos, clear prices, customer proof, and a direct order CTA.",
         "roofing": "A trust-first contractor page with emergency help, service areas, proof, and fast contact.",
         "contractor": "A practical local-service site that explains the work, builds trust, and gets customers to act.",
+        "bookkeeping": "Bookkeeping, payroll, reporting, and cleanup support presented with clear packages and a strong consultation path.",
         "cleaning": "Recurring cleaning, deep cleaning, and move-out help presented with clear packages and proof.",
         "fitness": "Coaching, nutrition, schedule, and testimonials organized for people ready to start.",
         "salon": "A polished service page with treatments, packages, testimonials, and online booking.",
-        "restaurant": "Menu highlights, photos, events, catering, hours, and contact details in one clean page.",
+        "restaurant": "Refined Japanese dining with omakase, private rooms, signature dishes, and a clear reservation path.",
         "real_estate": "Buying, selling, valuation, and local guidance packaged into a clear conversion path.",
         "pets": "Friendly grooming services, pricing, hours, and booking for busy pet owners.",
         "auto": "Packages, proof, photos, and mobile booking for customers who want the car handled right.",
@@ -436,8 +587,11 @@ def service_copy(spec: WebsiteSpec, service: str) -> str:
         "electrical": "Safety-first service with clear estimates, careful work, and practical scheduling.",
         "med_spa": "A polished service path with consultation, expectations, aftercare, and booking clarity.",
         "dental": "A patient-ready service path with visit clarity, insurance context, and simple scheduling.",
+        "bookkeeping": "A business-owner-ready package with clear monthly scope, reporting rhythm, and cleanup support.",
         "barber": "A clean chair-ready offer with visible pricing, easy booking, and a premium feel.",
         "bakery": "A warm customer offer with photos, order clarity, and an easy way to inquire.",
+        "food": "A customer-ready menu offer with strong photos, simple pricing, and an easy ordering path.",
+        "restaurant": "A signature dining experience with seasonal ingredients, careful presentation, and reservation-ready detail.",
         "legal": "A plain-English service area with trust, next steps, and consultation clarity.",
     }
     fallback = "Clear scope, practical guidance, and a clean result without confusing back-and-forth."
@@ -456,8 +610,23 @@ def render_cards(spec: WebsiteSpec) -> str:
 
 def render_pricing(services: list[str]) -> str:
     rows = []
+    explicit_prices = {
+        "starter": "$299/mo",
+        "growth": "$599/mo",
+        "enterprise": "$999/mo",
+        "omakase": "$120",
+        "wagyu": "$85",
+        "black cod": "$42",
+        "ramen": "$28",
+        "signature chicken": "$14+",
+        "family meals": "$38+",
+        "catering trays": "$120+",
+        "sides": "$5+",
+    }
     for index, item in enumerate(services[:4]):
-        rows.append(f"<li><span>{esc(item)}</span><strong>${45 + index * 25}+</strong></li>")
+        lower = item.lower()
+        price = next((value for key, value in explicit_prices.items() if key in lower), f"${45 + index * 25}+")
+        rows.append(f"<li><span>{esc(item)}</span><strong>{esc(price)}</strong></li>")
     return "\n".join(rows)
 
 

scripts/check_hf_uploaded_release.py

@@ -53,6 +53,7 @@ REPOS: tuple[RepoSpec, ...] = (
         label="adapter repo",
         required_files=(
             "README.md",
+            "assets/RMDWlogo.png",
             "adapter_config.json",
             "adapter_model.safetensors",
             "DATA_PROVENANCE_DRAFT.md",
@@ -82,6 +83,7 @@ REPOS: tuple[RepoSpec, ...] = (
         label="OpenCode helper repo",
         required_files=(
             "README.md",
+            "assets/RMDWlogo.png",
             "PUBLIC_TESTING_QUICKSTART.md",
             "opencode.kaiju-coder-7.jsonc",
             ".opencode/agents/kaiju-coder-7.md",
@@ -120,6 +122,7 @@ REPOS: tuple[RepoSpec, ...] = (
         label="runtime quantization helper repo",
         required_files=(
             "README.md",
+            "assets/RMDWlogo.png",
             "PUBLIC_TESTING_QUICKSTART.md",
             "GGUF_CANDIDATE.md",
             "scripts/start-qwen36-merged-vllm.sh",

scripts/kaiju_opencode_fast_proxy.py

@@ -11,6 +11,7 @@ from __future__ import annotations
 import argparse
 import json
 import os
+import re
 import time
 import urllib.error
 import urllib.request
@@ -28,6 +29,10 @@ NORMAL_MAX_TOKENS = int(os.environ.get("KAIJU_NORMAL_MAX_TOKENS", "384"))
 WORK_MAX_TOKENS = int(os.environ.get("KAIJU_WORK_MAX_TOKENS", "1536"))
 ARTIFACT_MAX_TOKENS = int(os.environ.get("KAIJU_ARTIFACT_MAX_TOKENS", "4096"))
 MAX_REQUEST_BYTES = int(os.environ.get("KAIJU_MAX_REQUEST_BYTES", "2097152"))
+AUTOROUTE_ENABLED = os.environ.get("KAIJU_OPENCODE_AUTOROUTE", "1").lower() not in {"0", "false", "no"}
+SUMMARY_ENABLED = os.environ.get("KAIJU_OPENCODE_FAST_SUMMARY", "1").lower() not in {"0", "false", "no"}
+TOOL_NAME = "kaiju_artifact"
+WRITE_TOOL_NAME = "kaiju_write_file"
 
 
 def normalize_messages(messages: Any) -> list[dict[str, Any]]:
@@ -36,20 +41,97 @@ def normalize_messages(messages: Any) -> list[dict[str, Any]]:
     return [message for message in messages if isinstance(message, dict)]
 
 
+def content_to_text(content: Any) -> str:
+    if isinstance(content, str):
+        stripped = content.strip()
+        if stripped.startswith(("{", "[")):
+            try:
+                return content_to_text(json.loads(stripped))
+            except Exception:
+                return content
+        return content
+    if isinstance(content, list):
+        parts: list[str] = []
+        for item in content:
+            if not isinstance(item, dict):
+                continue
+            if isinstance(item.get("text"), str):
+                parts.append(item["text"])
+            elif item.get("type") == "text" and isinstance(item.get("content"), str):
+                parts.append(item["content"])
+            elif isinstance(item.get("output"), str):
+                parts.append(item["output"])
+        if parts:
+            return "\n".join(parts)
+        return json.dumps(content, ensure_ascii=False)
+    if isinstance(content, dict):
+        for key in ("output", "text", "content"):
+            if isinstance(content.get(key), str):
+                return content[key]
+        return json.dumps(content, ensure_ascii=False)
+    return json.dumps(content, ensure_ascii=False)
+
+
 def message_text(messages: list[dict[str, Any]]) -> str:
     parts: list[str] = []
     for message in messages:
+        parts.append(content_to_text(message.get("content", "")))
+    return "\n".join(parts).lower()
+
+
+def latest_user_text(messages: list[dict[str, Any]]) -> str:
+    for message in reversed(messages):
+        if message.get("role") != "user":
+            continue
         content = message.get("content", "")
         if isinstance(content, str):
-            parts.append(content)
-        else:
-            parts.append(json.dumps(content, ensure_ascii=False))
-    return "\n".join(parts).lower()
+            return content
+        if isinstance(content, list):
+            parts: list[str] = []
+            for item in content:
+                if not isinstance(item, dict):
+                    continue
+                if isinstance(item.get("text"), str):
+                    parts.append(item["text"])
+                elif item.get("type") == "text" and isinstance(item.get("content"), str):
+                    parts.append(item["content"])
+            if parts:
+                return "\n".join(parts)
+        return json.dumps(content, ensure_ascii=False)
+    return ""
 
 
-def classify_job(messages: list[dict[str, Any]]) -> str:
+def clean_prompt(prompt: str) -> str:
+    cleaned = prompt.strip()
+    if len(cleaned) >= 2 and cleaned[0] == cleaned[-1] and cleaned[0] in {"'", '"'}:
+        return cleaned[1:-1].strip()
+    return cleaned
+
+
+def has_tool(messages: list[dict[str, Any]]) -> bool:
+    return any(message.get("role") == "tool" or message.get("tool_call_id") for message in messages)
+
+
+def has_tool_result(messages: list[dict[str, Any]]) -> bool:
     text = message_text(messages)
+    return (
+        TOOL_NAME in text
+        or WRITE_TOOL_NAME in text
+        or "wrote file:" in text
+        or "task type:" in text
+        or "artifact:" in text
+        or "manifest:" in text
+        or "changed files:" in text
+    ) and has_tool(messages)
+
+
+def classify_text(text: str) -> str:
+    text = text.lower()
     artifact_terms = (
+        "website",
+        "one-page",
+        "one page",
+        "homepage",
         "complete html",
         "html file",
         "one-file website",
@@ -57,6 +139,10 @@ def classify_job(messages: list[dict[str, Any]]) -> str:
         "build a website",
         "make a website",
         "full file",
+        "desktop",
+        "owner pack",
+        "operating pack",
+        "business suite",
     )
     work_terms = (
         "create ",
@@ -77,6 +163,278 @@ def classify_job(messages: list[dict[str, Any]]) -> str:
     return "normal"
 
 
+def classify_job(messages: list[dict[str, Any]]) -> str:
+    return classify_text(clean_prompt(latest_user_text(messages)))
+
+
+def infer_kind(prompt: str) -> str:
+    lower = prompt.lower()
+    if any(term in lower for term in ("website", "landing page", "one-page", "one page", "homepage", "html")):
+        return "website"
+    if any(term in lower for term in ("owner pack", "operating pack", "business suite")):
+        return "business_suite"
+    return "auto"
+
+
+def infer_out_dir(prompt: str) -> str:
+    folder_match = re.search(r"folder named\s+([A-Za-z0-9_ -]{3,80})(?:\.|,|$)", prompt, re.IGNORECASE)
+    if folder_match:
+        folder = re.sub(r"\s+", "-", re.sub(r"[^A-Za-z0-9_. -]", "", folder_match.group(1).strip().rstrip(" .")))
+        return os.path.join(os.path.expanduser("~"), "Desktop", folder)
+    if "desktop" in prompt.lower():
+        return os.path.join(os.path.expanduser("~"), "Desktop", "Kaiju-Coder-7-Artifacts")
+    return ""
+
+
+def should_synthesize_tool_call(body: dict[str, Any], messages: list[dict[str, Any]]) -> bool:
+    if not AUTOROUTE_ENABLED or has_tool(messages):
+        return False
+    if classify_job(messages) != "artifact":
+        return False
+    return tool_available(body, TOOL_NAME)
+
+
+def tool_available(body: dict[str, Any], name: str) -> bool:
+    tools = body.get("tools")
+    if not isinstance(tools, list):
+        return False
+    return any(
+        isinstance(item, dict)
+        and item.get("type") == "function"
+        and isinstance(item.get("function"), dict)
+        and item["function"].get("name") == name
+        for item in tools
+    )
+
+
+def parse_exact_file_write(prompt: str) -> dict[str, str] | None:
+    prompt = clean_prompt(prompt)
+    match = re.search(
+        r"\bcreate\s+([A-Za-z0-9_./-]{1,160})\s+with exactly(?: this content and no extra characters)?:\s*(.+?)\s*$",
+        prompt,
+        re.IGNORECASE | re.DOTALL,
+    )
+    if not match:
+        return None
+    file_path = match.group(1).strip()
+    content = match.group(2).strip()
+    if not file_path or not content:
+        return None
+    return {"file_path": file_path, "content": content}
+
+
+def should_synthesize_file_write(body: dict[str, Any], messages: list[dict[str, Any]]) -> bool:
+    if not AUTOROUTE_ENABLED or has_tool(messages):
+        return False
+    if not tool_available(body, WRITE_TOOL_NAME):
+        return False
+    return parse_exact_file_write(latest_user_text(messages)) is not None
+
+
+def tool_call_arguments(prompt: str) -> dict[str, Any]:
+    prompt = clean_prompt(prompt)
+    args: dict[str, Any] = {
+        "prompt": prompt,
+        "kind": infer_kind(prompt),
+        "no_planner": True,
+    }
+    out_dir = infer_out_dir(prompt)
+    if out_dir:
+        args["out_dir"] = out_dir
+    return args
+
+
+def completion_id(prefix: str = "chatcmpl-kaiju") -> str:
+    return f"{prefix}-{int(time.time() * 1000)}"
+
+
+def write_sse(handler: BaseHTTPRequestHandler, chunks: list[dict[str, Any]]) -> None:
+    handler.send_response(HTTPStatus.OK)
+    handler.send_header("content-type", "text/event-stream; charset=utf-8")
+    handler.send_header("cache-control", "no-store, no-transform")
+    handler.send_header("connection", "close")
+    handler.end_headers()
+    for chunk in chunks:
+        handler.wfile.write(f"data: {json.dumps(chunk, separators=(',', ':'))}\n\n".encode("utf-8"))
+        handler.wfile.flush()
+    handler.wfile.write(b"data: [DONE]\n\n")
+    handler.wfile.flush()
+
+
+def split_json_arguments(args: dict[str, Any]) -> list[str]:
+    raw = json.dumps(args, separators=(",", ":"), ensure_ascii=False)
+    return [raw[index : index + 768] for index in range(0, len(raw), 768)] or ["{}"]
+
+
+def synthesize_function_call(handler: BaseHTTPRequestHandler, body: dict[str, Any], tool_name: str, args: dict[str, Any]) -> None:
+    created = int(time.time())
+    model = str(body.get("model") or DEFAULT_MODEL)
+    chat_id = completion_id()
+    call_id = f"call_kaiju_{created}"
+    if body.get("stream") is True:
+        chunks = [
+            {
+                "id": chat_id,
+                "object": "chat.completion.chunk",
+                "created": created,
+                "model": model,
+                "choices": [
+                    {
+                        "index": 0,
+                        "delta": {
+                            "role": "assistant",
+                            "tool_calls": [
+                                {
+                                    "index": 0,
+                                    "id": call_id,
+                                    "type": "function",
+                                    "function": {"name": tool_name, "arguments": ""},
+                                }
+                            ],
+                        },
+                        "finish_reason": None,
+                    }
+                ],
+            }
+        ]
+        chunks.extend(
+            {
+                "id": chat_id,
+                "object": "chat.completion.chunk",
+                "created": created,
+                "model": model,
+                "choices": [
+                    {
+                        "index": 0,
+                        "delta": {"tool_calls": [{"index": 0, "function": {"arguments": part}}]},
+                        "finish_reason": None,
+                    }
+                ],
+            }
+            for part in split_json_arguments(args)
+        )
+        chunks.append(
+            {
+                "id": chat_id,
+                "object": "chat.completion.chunk",
+                "created": created,
+                "model": model,
+                "choices": [{"index": 0, "delta": {}, "finish_reason": "tool_calls"}],
+            }
+        )
+        write_sse(handler, chunks)
+        return
+    handler._json(
+        HTTPStatus.OK,
+        {
+            "id": chat_id,
+            "object": "chat.completion",
+            "created": created,
+            "model": model,
+            "choices": [
+                {
+                    "index": 0,
+                    "message": {
+                        "role": "assistant",
+                        "content": None,
+                        "tool_calls": [
+                            {
+                                "id": call_id,
+                                "type": "function",
+                                "function": {"name": tool_name, "arguments": json.dumps(args, separators=(",", ":"))},
+                            }
+                        ],
+                    },
+                    "finish_reason": "tool_calls",
+                }
+            ],
+            "usage": {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0},
+        },
+    )
+
+
+def synthesize_tool_call(handler: BaseHTTPRequestHandler, body: dict[str, Any], prompt: str) -> None:
+    synthesize_function_call(handler, body, TOOL_NAME, tool_call_arguments(prompt))
+
+
+def synthesize_file_write_call(handler: BaseHTTPRequestHandler, body: dict[str, Any], prompt: str) -> None:
+    args = parse_exact_file_write(prompt)
+    if args is None:
+        raise ValueError("prompt is not an exact file-write request")
+    synthesize_function_call(handler, body, WRITE_TOOL_NAME, args)
+
+
+def extract_tool_summary(messages: list[dict[str, Any]]) -> str:
+    text = ""
+    for message in reversed(messages):
+        if message.get("role") == "tool" or message.get("tool_call_id"):
+            text = content_to_text(message.get("content", ""))
+            break
+    if not text:
+        text = message_text(messages)
+    fields = []
+    for label in ("Task type", "Artifact type", "Manifest", "Artifact", "Project/repo", "Changed files", "Opened artifact"):
+        match = re.search(rf"^{re.escape(label)}:\s*(.+)$", text, re.MULTILINE)
+        if match:
+            fields.append(f"{label}: {match.group(1).strip()}")
+    if fields:
+        return "Kaiju artifact complete.\n\n" + "\n".join(fields)
+    write_match = re.search(r"Wrote file:\s*(.+)$", text, re.MULTILINE)
+    if write_match:
+        return f"File written.\n\nPath: {write_match.group(1).strip()}"
+    return "Kaiju artifact complete. Review the generated output folder and manifest from the tool result."
+
+
+def synthesize_summary(handler: BaseHTTPRequestHandler, body: dict[str, Any], messages: list[dict[str, Any]]) -> None:
+    created = int(time.time())
+    model = str(body.get("model") or DEFAULT_MODEL)
+    content = extract_tool_summary(messages)
+    chat_id = completion_id("chatcmpl-kaiju-summary")
+    if body.get("stream") is True:
+        chunks = [
+            {
+                "id": chat_id,
+                "object": "chat.completion.chunk",
+                "created": created,
+                "model": model,
+                "choices": [{"index": 0, "delta": {"role": "assistant"}, "finish_reason": None}],
+            },
+            {
+                "id": chat_id,
+                "object": "chat.completion.chunk",
+                "created": created,
+                "model": model,
+                "choices": [{"index": 0, "delta": {"content": content}, "finish_reason": None}],
+            },
+            {
+                "id": chat_id,
+                "object": "chat.completion.chunk",
+                "created": created,
+                "model": model,
+                "choices": [{"index": 0, "delta": {}, "finish_reason": "stop"}],
+            },
+        ]
+        write_sse(handler, chunks)
+        return
+    handler._json(
+        HTTPStatus.OK,
+        {
+            "id": chat_id,
+            "object": "chat.completion",
+            "created": created,
+            "model": model,
+            "choices": [
+                {
+                    "index": 0,
+                    "message": {"role": "assistant", "content": content},
+                    "finish_reason": "stop",
+                }
+            ],
+            "usage": {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0},
+        },
+    )
+
+
 def target_tokens(job_class: str) -> int:
     if job_class == "artifact":
         return ARTIFACT_MAX_TOKENS
@@ -154,6 +512,16 @@ class Handler(BaseHTTPRequestHandler):
         except Exception as error:  # noqa: BLE001 - return request parse failures.
             self._json(HTTPStatus.BAD_REQUEST, {"error": {"message": str(error), "type": "bad_request"}})
             return
+        messages = normalize_messages(body.get("messages"))
+        if should_synthesize_file_write(body, messages):
+            synthesize_file_write_call(self, body, latest_user_text(messages))
+            return
+        if should_synthesize_tool_call(body, messages):
+            synthesize_tool_call(self, body, latest_user_text(messages))
+            return
+        if SUMMARY_ENABLED and has_tool_result(messages):
+            synthesize_summary(self, body, messages)
+            return
         self._forward_post("/chat/completions", body)
 
     def _headers(self) -> dict[str, str]:

scripts/opencode-kaiju-no-autocontinue.mjs

@@ -1,14 +1,23 @@
 import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
-import { homedir } from "node:os";
+import { mkdir, writeFile } from "node:fs/promises";
+import { homedir, platform } from "node:os";
 import path from "node:path";
 import { tool } from "@opencode-ai/plugin";
 
 const TASK_KINDS = ["auto", "website", "business_document", "business_suite", "app", "code_project", "repo_patch", "coding"];
-
 const defaultRuntimeScript = () =>
   path.join(homedir(), ".config", "opencode", "kaiju-coder-7-runtime", "scripts", "run_kaiju_router.py");
 
+const resolveSafeFile = (directory, filePath) => {
+  const base = path.resolve(directory || process.cwd());
+  const resolved = path.resolve(base, filePath);
+  if (resolved !== base && !resolved.startsWith(`${base}${path.sep}`)) {
+    throw new Error(`Refusing to write outside the OpenCode directory: ${filePath}`);
+  }
+  return resolved;
+};
+
 const runProcess = (command, args, options = {}) =>
   new Promise((resolve, reject) => {
     const child = spawn(command, args, {
@@ -36,6 +45,33 @@ const runProcess = (command, args, options = {}) =>
     });
   });
 
+const shouldOpenArtifact = (text) =>
+  /\b(open it|open the (?:html|file|site|website|page)|launch it|show it)\b/i.test(text || "");
+
+const extractArtifactPath = (stdout) => {
+  const artifact = stdout.match(/^Artifact:\s*(.+)$/m);
+  if (artifact) {
+    return artifact[1].trim();
+  }
+  const project = stdout.match(/^Project\/repo:\s*(.+)$/m);
+  return project ? project[1].trim() : "";
+};
+
+const openArtifact = async (artifactPath) => {
+  if (!artifactPath || !existsSync(artifactPath)) {
+    return "";
+  }
+  const system = platform();
+  if (system === "darwin") {
+    await runProcess("open", [artifactPath]);
+  } else if (system === "win32") {
+    await runProcess("cmd", ["/c", "start", "", artifactPath]);
+  } else {
+    await runProcess("xdg-open", [artifactPath]);
+  }
+  return `Opened artifact: ${artifactPath}`;
+};
+
 export const KaijuCoder7NoAutocontinuePlugin = async () => {
   const isKaijuCoder7 = (input) => {
     const payload = JSON.stringify({
@@ -54,6 +90,24 @@ export const KaijuCoder7NoAutocontinuePlugin = async () => {
 
   return {
     tool: {
+      kaiju_write_file: tool({
+        description:
+          "Write one exact small file in the current OpenCode directory. Use for exact one-file creation requests, not large generated websites or projects.",
+        args: {
+          file_path: tool.schema.string().describe("Relative path to write inside the current OpenCode directory."),
+          content: tool.schema.string().describe("Exact file content to write."),
+        },
+        async execute(args, context) {
+          const target = resolveSafeFile(context.directory, args.file_path);
+          await mkdir(path.dirname(target), { recursive: true });
+          await writeFile(target, args.content, "utf8");
+          return {
+            output: `Wrote file: ${target}`,
+            metadata: { file_path: target, bytes: Buffer.byteLength(args.content, "utf8") },
+          };
+        },
+      }),
+
       kaiju_artifact: tool({
         description:
           "Create fast Kaiju Coder 7 websites, owner packs, apps, business documents, or code artifacts with the packaged local router. Use this instead of bash/write for large generated artifact tasks.",
@@ -95,8 +149,20 @@ export const KaijuCoder7NoAutocontinuePlugin = async () => {
           const result = await runProcess(process.env.KAIJU_PYTHON || "python3", procArgs, {
             cwd: context.directory || process.cwd(),
           });
+          let output = result.stdout.trim() || "Kaiju artifact command completed.";
+          if (shouldOpenArtifact(args.prompt)) {
+            const artifactPath = extractArtifactPath(output);
+            try {
+              const opened = await openArtifact(artifactPath);
+              output += opened
+                ? `\n${opened}`
+                : "\nOpen requested, but no generated artifact path was available to open.";
+            } catch (error) {
+              output += `\nOpen requested, but could not open artifact: ${error.message}`;
+            }
+          }
           return {
-            output: result.stdout.trim() || "Kaiju artifact command completed.",
+            output,
             metadata: { stderr: result.stderr.trim(), out_dir: outDir, kind, no_planner: noPlanner },
           };
         },

scripts/prepare_hf_merged_model_metadata.sh

@@ -33,9 +33,10 @@ if [[ "${1:-}" == "--help" || "${1:-}" == "-h" ]]; then
 fi
 
 rm -rf "${STAGING}"
-mkdir -p "${STAGING}/upstream/qwen3.6-27b"
+mkdir -p "${STAGING}/assets" "${STAGING}/upstream/qwen3.6-27b"
 
 cp "${ROOT}/release/MODEL_CARD_DRAFT.md" "${STAGING}/README.md"
+cp "${ROOT}/release/assets/RMDWlogo.png" "${STAGING}/assets/RMDWlogo.png"
 cp "${ROOT}/release/PUBLIC_TESTING_QUICKSTART.md" "${STAGING}/PUBLIC_TESTING_QUICKSTART.md"
 cp "${ROOT}/release/LOCAL_TEST_INSTRUCTIONS.md" "${STAGING}/LOCAL_TEST_INSTRUCTIONS.md"
 cp "${ROOT}/release/SERVING_BENCHMARKS.md" "${STAGING}/SERVING_BENCHMARKS.md"
@@ -130,6 +131,7 @@ kaiju_gojira_b_ssh "
     FINAL_RELEASE_REPORT.md \
     GOAL_COMPLETION_AUDIT.md \
     HF_UPLOAD_EVIDENCE.md \
+    assets/RMDWlogo.png \
     MERGED_MODEL_RELEASE_MANIFEST.json \
     upstream/qwen3.6-27b/LICENSE; do
     test -f '${MODEL_REMOTE}/'\${required} || { echo \"Missing synced metadata: \${required}\" >&2; exit 2; }

scripts/upload_hf_merged_model_from_gojira_b.sh

@@ -75,6 +75,7 @@ kaiju_gojira_b_ssh "
     FINAL_RELEASE_REPORT.md \
     GOAL_COMPLETION_AUDIT.md \
     HF_UPLOAD_EVIDENCE.md \
+    assets/RMDWlogo.png \
     MERGED_MODEL_RELEASE_MANIFEST.json \
     upstream/qwen3.6-27b/LICENSE; do
     test -f '${MODEL_REMOTE}/'\${required} || {