ltcai 11.1.0 → 11.4.0

package/latticeai/core/file_generation/repair.py

@@ -0,0 +1,114 @@
+"""Deterministic scaffolds — step 5, the last resort after the retries.
+
+The user asked for a file, so the request must still end in a well-formed file
+of the target type, never an error. Nothing here calls a model: whatever the
+model did produce is salvaged where it can be, and honestly labelled where it
+cannot.
+"""
+
+from __future__ import annotations
+
+import ast
+import html as html_lib
+import json
+import re
+
+from .extraction import _ext, _slice_html_document, _slice_json_document
+from .validation import looks_like_refusal
+
+
+def repair_file_content(content: str, target_path: str, user_request: str) -> str:
+    """Turn whatever the model produced into a valid file of the target type.
+
+    This is the last resort after retries: the user asked for a file, so the
+    request must still end in a well-formed file, never an error.
+    """
+    ext = _ext(target_path)
+    salvage = content.strip()
+    if looks_like_refusal(salvage):
+        salvage = ""
+
+    if ext in (".html", ".htm"):
+        return _repair_html(salvage, user_request)
+    if ext == ".json":
+        sliced = _slice_json_document(salvage)
+        if sliced is not None:
+            return sliced
+        return json.dumps(
+            {"request": user_request, "content": salvage},
+            ensure_ascii=False,
+            indent=2,
+        )
+    if ext == ".py" and salvage:
+        # The repair guarantee for Python is parseability: unparseable output
+        # is preserved honestly as a commented-out draft, never as a broken
+        # module the user has to debug.
+        try:
+            ast.parse(salvage)
+            return salvage
+        except SyntaxError:
+            commented = "\n".join(f"# {line}" for line in salvage.splitlines())
+            return (
+                f"# TODO: model produced invalid Python for: {user_request}\n"
+                "# The draft below is preserved as comments — fix and uncomment.\n"
+                f"{commented}\n"
+            )
+    if salvage:
+        return salvage
+    # Nothing usable at all — leave an honest placeholder in the right format.
+    comment = {
+        ".py": "# TODO: model produced no usable content for: ",
+        ".js": "// TODO: model produced no usable content for: ",
+        ".jsx": "// TODO: model produced no usable content for: ",
+        ".ts": "// TODO: model produced no usable content for: ",
+        ".tsx": "// TODO: model produced no usable content for: ",
+        ".css": "/* TODO: model produced no usable content for: ",
+        ".sh": "# TODO: model produced no usable content for: ",
+        ".sql": "-- TODO: model produced no usable content for: ",
+    }.get(ext, "")
+    if ext == ".css":
+        return f"{comment}{user_request} */\n"
+    if comment:
+        return f"{comment}{user_request}\n"
+    return f"{user_request}\n"
+
+
+def _repair_html(salvage: str, user_request: str) -> str:
+    lower = salvage.lower()
+    if "<html" in lower or "<!doctype" in lower:
+        # A real document that is merely truncated — close it.
+        doc = _slice_html_document(salvage)
+        low = doc.lower()
+        if "</body>" not in low and "<body" in low:
+            doc += "\n</body>"
+        if "</html>" not in low:
+            doc += "\n</html>"
+        return doc
+    if re.search(r"<\w+[^>]*>", salvage):
+        body = salvage  # an HTML fragment — embed as-is
+    elif salvage:
+        body = "\n".join(
+            f"  <p>{html_lib.escape(line)}</p>"
+            for line in salvage.splitlines()
+            if line.strip()
+        )
+    else:
+        body = f"  <p>{html_lib.escape(user_request)}</p>"
+    title = html_lib.escape(user_request[:60] or "Generated page")
+    return (
+        "<!DOCTYPE html>\n"
+        "<html lang=\"ko\">\n"
+        "<head>\n"
+        "  <meta charset=\"utf-8\">\n"
+        "  <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\n"
+        f"  <title>{title}</title>\n"
+        "  <style>\n"
+        "    body { font-family: system-ui, sans-serif; margin: 2rem auto; "
+        "max-width: 720px; line-height: 1.6; padding: 0 1rem; }\n"
+        "  </style>\n"
+        "</head>\n"
+        "<body>\n"
+        f"{body}\n"
+        "</body>\n"
+        "</html>"
+    )

package/latticeai/core/file_generation/sanitize.py

@@ -0,0 +1,61 @@
+"""The single write-side guarantee for model-produced file content.
+
+``sanitize_write_content`` is the one door every write entry point goes
+through — the direct chat path, the agent JSON loop, the tools layer — so a
+fenced or chatty payload can never be persisted verbatim no matter which
+surface produced it.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Tuple
+
+from .extraction import extract_file_content
+from .repair import repair_file_content
+from .validation import validate_file_content
+
+# Extensions the Brain UI can render inline (preview) after creation.
+PREVIEWABLE_EXTENSIONS = frozenset({
+    ".html", ".htm", ".md", ".markdown", ".txt", ".json", ".css", ".js",
+    ".csv", ".py", ".yaml", ".yml", ".xml", ".sql", ".sh",
+    ".jsx", ".ts", ".tsx", ".vue", ".svelte",
+})
+
+
+def sanitize_write_content(
+    target_path: str,
+    content: Any,
+    user_request: str = "",
+) -> Tuple[str, Dict[str, Any]]:
+    """Single write-side guarantee for model-produced file content.
+
+    The direct chat path already runs the full generate→validate→repair
+    pipeline, but the agent JSON loop historically wrote ``args.content``
+    verbatim — weak models routinely put fenced/chatty payloads there. This
+    conservative sanitizer closes that gap for *any* write entry point:
+
+    1. content that already validates is returned byte-for-byte unchanged
+       (trusted/user-authored content is never mangled);
+    2. otherwise the extraction pass strips fences/think-blocks/chat noise
+       and is used only when the extracted payload validates;
+    3. otherwise deterministic repair guarantees a structurally valid file.
+
+    Empty content is left untouched (creating an empty file is a legitimate,
+    intentional action — e.g. ``__init__.py``). Returns ``(content, meta)``
+    where meta is ``{"sanitized": bool, "repaired": bool, "reason": str}``.
+    """
+    raw = str(content or "")
+    if not raw.strip():
+        return raw, {"sanitized": False, "repaired": False, "reason": "empty"}
+    ok, reason = validate_file_content(raw, target_path)
+    if ok:
+        return raw, {"sanitized": False, "repaired": False, "reason": "ok"}
+    extracted = extract_file_content(raw, target_path)
+    if extracted:
+        extracted_ok, _ = validate_file_content(extracted, target_path)
+        if extracted_ok:
+            return extracted, {"sanitized": True, "repaired": False, "reason": reason}
+    repaired = repair_file_content(
+        extracted or raw, target_path, user_request or f"content for {target_path}"
+    )
+    return repaired, {"sanitized": True, "repaired": True, "reason": reason}

package/latticeai/core/file_generation/validation.py

@@ -0,0 +1,201 @@
+"""Per-extension structural checks — step 3 of the pipeline.
+
+Answers one question about an already-extracted payload: *is this a file of the
+requested type?* HTML document shape, JSON parses, CSS has rule blocks, Python
+parses, braced code is balanced, components close their blocks — and, for prose
+types with no grammar to check, that the reply is not merely talk about the
+file.
+"""
+
+from __future__ import annotations
+
+import ast
+import json
+import re
+from typing import List, Tuple
+
+from .extraction import _ext
+
+_REFUSAL_RE = re.compile(
+    r"(i can('|no)?t|i'?m (sorry|unable)|as an ai|cannot assist"
+    r"|죄송(하지만|합니다)|할 수 없|불가능합니다|도와드릴 수 없)",
+    re.IGNORECASE,
+)
+
+
+def looks_like_refusal(content: str) -> bool:
+    head = content[:300]
+    return bool(_REFUSAL_RE.search(head)) and len(content) < 600
+
+
+# Braced code types validated structurally (balanced delimiters, no fences).
+_BRACED_CODE_EXTENSIONS = frozenset({".js", ".jsx", ".ts", ".tsx"})
+# Single-file components validated by their block tags being closed.
+_COMPONENT_EXTENSIONS = frozenset({".vue", ".svelte"})
+
+
+def _strip_code_literals(text: str) -> str:
+    """Remove string literals and comments so delimiter counting stays honest.
+
+    A cheap single-pass scanner (not a parser): quotes ('', "", ``), line
+    comments (//) and block comments (/* */) commonly contain lone braces
+    that would otherwise false-flag valid JS/TS as unbalanced.
+    """
+    out: List[str] = []
+    i, n = 0, len(text)
+    while i < n:
+        ch = text[i]
+        nxt = text[i + 1] if i + 1 < n else ""
+        if ch == "\\":
+            i += 2  # escaped char (inside or outside a literal — always skip)
+            continue
+        if ch in ("'", '"', "`"):
+            quote = ch
+            i += 1
+            while i < n:
+                if text[i] == "\\":
+                    i += 2
+                    continue
+                if text[i] == quote:
+                    i += 1
+                    break
+                i += 1
+            continue
+        if ch == "/" and nxt == "/":
+            while i < n and text[i] != "\n":
+                i += 1
+            continue
+        if ch == "/" and nxt == "*":
+            end = text.find("*/", i + 2)
+            i = n if end < 0 else end + 2
+            continue
+        out.append(ch)
+        i += 1
+    return "".join(out)
+
+
+def _check_balanced_delimiters(content: str) -> Tuple[bool, str]:
+    """Lenient count-based balance check for braced code (js/ts family).
+
+    Only *counts* are compared, never ordering, so valid-but-unusual code is
+    not rejected; a truncated file with a dangling ``{`` still fails.
+    """
+    stripped = _strip_code_literals(content)
+    for opener, closer, label in (("{", "}", "braces"), ("(", ")", "parentheses"), ("[", "]", "brackets")):
+        if stripped.count(opener) != stripped.count(closer):
+            return False, f"unbalanced {label} ({opener}{closer}) — the file looks truncated"
+    return True, "ok"
+
+
+def _check_component_blocks(content: str) -> Tuple[bool, str]:
+    """Vue/Svelte SFC sanity: every opened block tag must be closed."""
+    lower = content.lower()
+    for tag in ("template", "script", "style"):
+        opened = len(re.findall(rf"<{tag}(?:\s[^>]*)?>", lower))
+        closed = lower.count(f"</{tag}>")
+        if opened != closed:
+            return False, f"<{tag}> block is not closed — the component looks truncated"
+    return True, "ok"
+
+
+def validate_file_content(content: str, target_path: str) -> Tuple[bool, str]:
+    """Structural sanity check per file type. Returns (ok, reason)."""
+    if not content.strip():
+        return False, "empty output"
+    if looks_like_refusal(content):
+        return False, "the reply was a refusal/chat message, not file content"
+
+    ext = _ext(target_path)
+    if ext in (".html", ".htm"):
+        lower = content.lower()
+        if "<html" not in lower and "<!doctype" not in lower:
+            return False, "not a complete HTML document (missing <!DOCTYPE html>/<html>)"
+        if "</html>" not in lower:
+            return False, "HTML document is truncated (missing </html>)"
+        # A document that merely *contains* html somewhere is not a valid
+        # file payload: fenced/chat-wrapped replies must fail here so the
+        # extraction pass gets a chance to slice out the real document.
+        stripped = content.lstrip()
+        if not (stripped.lower().startswith("<!doctype") or stripped.lower().startswith("<html")):
+            return False, "HTML document is wrapped in prose or fences"
+        if "```" in content:
+            return False, "output still contains Markdown fences"
+        return True, "ok"
+    if ext == ".json":
+        try:
+            json.loads(content)
+        except (ValueError, TypeError) as exc:
+            return False, f"invalid JSON: {exc}"
+        return True, "ok"
+    if ext == ".css":
+        if "```" in content:
+            return False, "output still contains Markdown fences"
+        if "{" not in content or "}" not in content:
+            return False, "no CSS rule blocks found"
+        return True, "ok"
+    if ext == ".py":
+        if "```" in content:
+            return False, "output still contains Markdown fences"
+        try:
+            ast.parse(content)
+        except SyntaxError as exc:
+            return False, f"invalid Python syntax: {exc.msg} (line {exc.lineno})"
+        return True, "ok"
+    if ext in _BRACED_CODE_EXTENSIONS:
+        if "```" in content:
+            return False, "output still contains Markdown fences"
+        return _check_balanced_delimiters(content)
+    if ext in _COMPONENT_EXTENSIONS:
+        if "```" in content:
+            return False, "output still contains Markdown fences"
+        return _check_component_blocks(content)
+    if ext in (".sh", ".sql"):
+        if "```" in content:
+            return False, "output still contains Markdown fences"
+        return True, "ok"
+    # Prose types (.md, .txt, .csv, …) have no grammar to check, which used to
+    # mean *nothing* was checked: a 1–4B model that answered "Sure! Here is the
+    # document you asked for:" and stopped had its sentence saved as the file,
+    # because the fence stripper only removes conversational lines it can
+    # recognise and the length guard on `looks_like_refusal` lets a wordy
+    # refusal through. The two checks below are the only ones that generalise
+    # without inventing a grammar: it must not still be wearing fences, and it
+    # must not be *only* an answer about the file.
+    if "```" in content:
+        return False, "output still contains Markdown fences"
+    if _looks_like_commentary(content):
+        return False, "the reply talks about the file instead of being the file"
+    return True, "ok"
+
+
+# Openers that mean "I am about to give you the thing" — if the whole reply is
+# one of these, the thing never arrived.
+_COMMENTARY_RE = re.compile(
+    r"^\s*("
+    r"(sure|of course|certainly|okay|ok|alright|here|below|the following)\b"
+    r"|i('ve| have| will|'ll)\b"
+    r"|(물론|네[,!. ]|알겠|다음은|아래(는|의)?|요청하신|원하시는)"
+    r")",
+    re.IGNORECASE,
+)
+
+
+def _looks_like_commentary(content: str) -> bool:
+    """True when the reply reads as an answer *about* a file, not the file.
+
+    Deliberately conservative — a long document that merely opens with "The
+    following" is a document. Only a short reply that both opens
+    conversationally and never grows into content is rejected, so a real file
+    is never thrown away to catch a chat line.
+    """
+    stripped = content.strip()
+    if len(stripped) > 400:
+        return False
+    if not _COMMENTARY_RE.match(stripped):
+        return False
+    # Structure means content arrived after the preamble: a heading, a list, a
+    # table row, a delimiter, or simply several lines of body text.
+    body = stripped.split("\n", 1)[1].strip() if "\n" in stripped else ""
+    if re.search(r"^\s*(#{1,6}\s|[-*+]\s|\d+[.)]\s|\||>)", body, re.MULTILINE):
+        return False
+    return len(body) < 120

package/latticeai/core/legacy_compatibility.py

@@ -13,7 +13,7 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Dict, List
 
-LEGACY_COMPATIBILITY_VERSION = "11.1.0"
+LEGACY_COMPATIBILITY_VERSION = "11.4.0"
 
 
 @dataclass(frozen=True)

package/latticeai/core/marketplace.py

@@ -10,7 +10,7 @@ from __future__ import annotations
 from copy import deepcopy
 from typing import Any, Dict, List, Optional
 
-MARKETPLACE_VERSION = "11.1.0"
+MARKETPLACE_VERSION = "11.4.0"
 TEMPLATE_KINDS = ("plugin", "workflow", "agent", "ingestion_bridge")
 
 

package/latticeai/core/messages.py

@@ -307,6 +307,31 @@ MESSAGES: Dict[str, Dict[str, str]] = {
         "ko": "'{status}' 상태의 검토 항목은 승인할 수 없습니다.",
         "en": "A review item in status '{status}' cannot be approved.",
     },
+    "review.bulk_ids_required": {
+        "ko": "한꺼번에 처리할 검토 항목을 하나 이상 골라 주세요.",
+        "en": "Choose at least one review item to act on.",
+    },
+    "review.bulk_too_many": {
+        "ko": "한 번에 최대 {cap}개까지 처리할 수 있습니다.",
+        "en": "At most {cap} items can be handled in one request.",
+    },
+    # ── interop bridges (Notion export / git / mail / calendar) ──────────
+    "ingestion.interop_path_required": {
+        "ko": "불러올 파일이나 폴더 경로가 필요합니다.",
+        "en": "A file or folder path to read is required.",
+    },
+    "ingestion.interop_unknown_source": {
+        "ko": "알 수 없는 연동 종류입니다: {source}",
+        "en": "Unknown interop source: {source}",
+    },
+    "ingestion.vault_watch_unavailable": {
+        "ko": "보관함 자동 확인 기능을 사용할 수 없습니다.",
+        "en": "Vault watch is unavailable.",
+    },
+    "ingestion.vault_watch_disabled": {
+        "ko": "보관함 자동 확인은 기본으로 꺼져 있습니다. 설정에서 켜야 사용할 수 있습니다.",
+        "en": "Vault watch is off by default; turn it on in settings to use it.",
+    },
     # ── projects ────────────────────────────────────────────────────────
     "project.not_found": {
         "ko": "프로젝트를 찾을 수 없습니다.",
@@ -317,6 +342,124 @@ MESSAGES: Dict[str, Dict[str, str]] = {
         "ko": "혼합 검색 정책 서비스가 설정되지 않았습니다.",
         "en": "The hybrid policy service is not configured.",
     },
+    # ── feature toggles ─────────────────────────────────────────────────
+    # The switchboard renders from the server (see
+    # ``latticeai/services/feature_toggles.py``), so every label and one-line
+    # explanation a person reads lives here. The rule for the summaries: say
+    # what turning it *on* does, in the words someone who never read the
+    # environment-variable docs would use.
+    "features.note": {
+        "ko": "모두 지금 바로 적용됩니다. 다시 시작하지 않아도 됩니다.",
+        "en": "Every switch here takes effect right away — no restart needed.",
+    },
+    "features.unknown": {
+        "ko": "그런 기능은 없습니다: {feature}",
+        "en": "There is no such feature: {feature}",
+    },
+    "features.invalid_value": {
+        "ko": "이 기능에 쓸 수 없는 값입니다: {value}",
+        "en": "That is not a value this feature can take: {value}",
+    },
+    "features.choice.install_required": {
+        "ko": "설치 필요 — {reason}",
+        "en": "Install required — {reason}",
+    },
+    "features.allow_multimodal.label": {
+        "ko": "사진·녹음도 기억하기",
+        "en": "Remember pictures and recordings",
+    },
+    "features.allow_multimodal.summary": {
+        "ko": "폴더를 읽을 때 글뿐 아니라 사진과 녹음도 함께 저장합니다.",
+        "en": "A folder scan stores pictures and recordings too, not just text.",
+    },
+    "features.video_ingest.label": {
+        "ko": "영상도 함께",
+        "en": "Include videos",
+    },
+    "features.video_ingest.summary": {
+        "ko": "사진·녹음을 켠 상태에서, 영상은 장면과 자막으로 저장합니다.",
+        "en": "With the switch above on, videos are stored as keyframes and subtitles.",
+    },
+    "features.vault_watch.label": {
+        "ko": "노트 보관함 지켜보기",
+        "en": "Watch my notes vault",
+    },
+    "features.vault_watch.summary": {
+        "ko": "밖에 있는 노트 보관함이 바뀌면 알아서 다시 읽어옵니다.",
+        "en": "When an outside notes vault changes, it is re-read on its own.",
+    },
+    "features.brain_network.label": {
+        "ko": "골라서 나누기",
+        "en": "Share selected knowledge",
+    },
+    "features.brain_network.summary": {
+        "ko": "내가 고른 기억 묶음만 다른 기기로 내보내고 받아올 수 있습니다.",
+        "en": "Lets you export a hand-picked slice of memory to another device, and receive one.",
+    },
+    "features.brain_network.caution": {
+        "ko": "이 기능만 기억을 이 컴퓨터 밖으로 내보냅니다. 받은 내용은 바로 합쳐지지 않고 검토함으로 갑니다.",
+        "en": "This is the one switch that sends memory off this computer. Anything received waits in the review inbox instead of merging.",
+    },
+    "features.synthesis.label": {
+        "ko": "스스로 정리하기",
+        "en": "Tidy up on its own",
+    },
+    "features.synthesis.summary": {
+        "ko": "자료가 쌓이면 알아서 훑어보고, 고칠 거리를 검토함에 제안합니다.",
+        "en": "As material piles up, the Brain reviews it and proposes tidy-ups in the review inbox.",
+    },
+    "features.auto_vector_index.label": {
+        "ko": "넣자마자 검색 준비",
+        "en": "Make new material searchable at once",
+    },
+    "features.auto_vector_index.summary": {
+        "ko": "새 자료를 넣으면 바로 의미 검색까지 준비합니다. 끄면 나중에 한 번에 만듭니다.",
+        "en": "New material is prepared for meaning-based search immediately; off means you rebuild later.",
+    },
+    "features.auto_late_fusion.label": {
+        "ko": "글로 사진 찾기",
+        "en": "Find pictures by typing",
+    },
+    "features.auto_late_fusion.summary": {
+        "ko": "글로 물어봐도 사진까지 함께 찾습니다. 사진을 읽는 모델이 있어야 켜집니다.",
+        "en": "A typed question also searches pictures — needs a vision model that shares the same space.",
+    },
+    "features.fusion_rrf.label": {
+        "ko": "검색 결과 합치는 방식 바꾸기",
+        "en": "Blend search results by rank",
+    },
+    "features.fusion_rrf.summary": {
+        "ko": "점수 대신 순위로 합칩니다. 검색 채널마다 점수 크기가 달라도 흔들리지 않습니다.",
+        "en": "Combines channels by position instead of score, so mismatched score scales stop skewing results.",
+    },
+    "features.graph_expansion.label": {
+        "ko": "옆에 있는 기억까지 보기",
+        "en": "Look at neighbouring memories",
+    },
+    "features.graph_expansion.summary": {
+        "ko": "찾은 기억과 바로 이어진 기억도 후보로 넣습니다. 답은 넓어지고 조금 흐려집니다.",
+        "en": "Adds memories one link away from a hit as candidates — wider answers, slightly less focused.",
+    },
+    "features.vector_backend.label": {
+        "ko": "의미 검색 방식",
+        "en": "Meaning-search engine",
+    },
+    "features.vector_backend.summary": {
+        "ko": "빠르기와 정확함 사이에서 고릅니다. 기본값은 전부 훑어보는 정확한 방식입니다.",
+        "en": "Trade speed against exactness. The default compares everything and is exact.",
+    },
+    "features.vector_backend.choice.brute": {
+        "ko": "전부 비교 (정확)",
+        "en": "Compare everything (exact)",
+    },
+    "features.vector_backend.choice.quantized": {
+        "ko": "간추려 비교 (빠름)",
+        "en": "Compare compressed (faster)",
+    },
+    "features.vector_backend.choice.hnsw": {
+        "ko": "근사 검색 (가장 빠름)",
+        "en": "Approximate search (fastest)",
+    },
     # ── models ──────────────────────────────────────────────────────────
     "models.other_user_credentials": {
         "ko": "다른 사용자의 모델 자격 증명을 사용할 수 없습니다.",
@@ -379,6 +522,15 @@ MESSAGES: Dict[str, Dict[str, str]] = {
         "ko": "디렉터리를 찾을 수 없습니다.",
         "en": "That directory was not found.",
     },
+    # ── chronicle ───────────────────────────────────────────────────────
+    "chronicle.bad_date": {
+        "ko": "날짜를 읽을 수 없습니다. 2026-08-11 처럼 연-월-일로 적어 주세요.",
+        "en": "That date could not be read. Write it as year-month-day, like 2026-08-11.",
+    },
+    "chronicle.bad_timestamp": {
+        "ko": "시점을 읽을 수 없습니다. 2026-08-11T09:00:00 처럼 적어 주세요.",
+        "en": "That moment could not be read. Write it like 2026-08-11T09:00:00.",
+    },
     # ── MCP / setup ─────────────────────────────────────────────────────
     "mcp.connector_not_found": {
         "ko": "커넥터를 찾을 수 없습니다.",

package/latticeai/core/model_compat.py

@@ -32,14 +32,54 @@ FAMILY_PATTERNS: List[Tuple[str, re.Pattern]] = [
     ("qwen", re.compile(r"qwen", re.I)),
     ("llama", re.compile(r"\bllama|meta[-_]?llama", re.I)),
     ("claude", re.compile(r"claude", re.I)),
+    # gpt-oss is its own local family with its own chat format, so it must be
+    # matched before the cloud `gpt` pattern rather than falling into it.
+    ("gpt_oss", re.compile(r"gpt[-_]?oss", re.I)),
     ("gpt", re.compile(r"gpt[-_]?(?:4|5)|openai", re.I)),
     ("gemini", re.compile(r"gemini", re.I)),
     ("grok", re.compile(r"grok|x[-_]?ai", re.I)),
+    ("lfm2", re.compile(r"\blfm[-_]?2", re.I)),
 ]
 
+#: HF ``config.json`` ``model_type`` → family code. An id is a name somebody
+#: chose; an architecture is what mlx-lm / mlx-vlm actually dispatches on, so it
+#: is the more reliable signal when we have it. Values here are the architectures
+#: pinned in the model capability registry (11.2.0) plus the ones that came
+#: before, so a model already on disk keeps its profile after its generation
+#: stops being offered.
+ARCHITECTURE_FAMILIES: Dict[str, str] = {
+    "gemma2": "gemma",
+    "gemma3": "gemma",
+    "gemma4": "gemma",
+    "gemma4_unified": "gemma",
+    "qwen2_5_vl": "qwen",
+    "qwen3_vl": "qwen",
+    "qwen3_vl_moe": "qwen",
+    "qwen3_5": "qwen",
+    "qwen3_5_moe": "qwen",
+    "llama": "llama",
+    "llama4": "llama",
+    "mllama": "llama",
+    "gpt_oss": "gpt_oss",
+    "lfm2": "lfm2",
+}
+
+
+def family_for_architecture(architecture: Optional[str]) -> str:
+    """Map an HF ``model_type`` to a family code (``"unknown"`` when unmapped)."""
+    return ARCHITECTURE_FAMILIES.get(str(architecture or "").strip().lower(), "unknown")
+
 
-def detect_model_family(model_id: str) -> str:
-    """주어진 model_id 문자열에서 family 코드를 추론한다."""
+def detect_model_family(model_id: str, architecture: Optional[str] = None) -> str:
+    """주어진 model_id 문자열에서 family 코드를 추론한다.
+
+    ``architecture`` (HF config ``model_type``) 가 주어지고 알려진 값이면 그것을
+    우선한다 — 로더가 실제로 분기하는 값이기 때문이다.
+    """
+    if architecture:
+        by_arch = family_for_architecture(architecture)
+        if by_arch != "unknown":
+            return by_arch
     if not model_id:
         return "unknown"
     raw = str(model_id)
@@ -96,6 +136,35 @@ FAMILY_PROFILES: Dict[str, Dict[str, Any]] = {
         "disable_draft": False,
         "postprocess": ["strip_role_tokens"],
     },
+    # gpt-oss speaks the "harmony" response format: the channel markers are
+    # stop sequences, not text, so the reply never has to be salvaged from them.
+    "gpt_oss": {
+        "family": "gpt_oss",
+        "supports_system": True,
+        "supports_vision": False,
+        "chat_template": "tokenizer_default",
+        "preferred_engines": ["local_mlx", "ollama", "llamacpp"],
+        "temperature": 0.2,
+        "top_p": 0.9,
+        "max_tokens": 4096,
+        "stop_sequences": ["<|return|>", "<|call|>", "<|endoftext|>"],
+        "disable_draft": False,
+        "postprocess": ["strip_role_tokens"],
+    },
+    # LFM2 uses a ChatML-style template; text only, so no vision claim.
+    "lfm2": {
+        "family": "lfm2",
+        "supports_system": True,
+        "supports_vision": False,
+        "chat_template": "tokenizer_default",
+        "preferred_engines": ["local_mlx", "ollama", "llamacpp"],
+        "temperature": 0.2,
+        "top_p": 0.9,
+        "max_tokens": 4096,
+        "stop_sequences": ["<|im_end|>", "<|endoftext|>"],
+        "disable_draft": False,
+        "postprocess": ["strip_role_tokens"],
+    },
     "unknown": {
         "family": "unknown",
         "supports_system": True,
@@ -623,9 +692,11 @@ def get_stop_sequences(model_id: str, engine: Optional[str] = None) -> List[str]
 
 
 __all__ = [
+    "ARCHITECTURE_FAMILIES",
     "FAMILY_PROFILES",
     "CompatProfile",
     "detect_model_family",
+    "family_for_architecture",
     "friendly_model_runtime_error",
     "get_model_profile",
     "model_runtime_compatibility",