Upload 16 files

.gitattributes

@@ -33,3 +33,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+banner.jpg filter=lfs diff=lfs merge=lfs -text
+logo.jpg filter=lfs diff=lfs merge=lfs -text
+loom-crucible-preview-f16.gguf filter=lfs diff=lfs merge=lfs -text

ATTRIBUTION.md

@@ -0,0 +1,20 @@
+# Attribution
+
+Loom Crucible Preview was trained from scratch (random-init lineage — grown from Textile Labs'
+own Loom Tapestry 3, which was grown from Loom Weave 3; no third-party checkpoint).
+Grounded-reading rows embed real encyclopedic prose. Training data, all permissively licensed:
+
+| slice | source | licence |
+|---|---|---|
+| grounded reading + "the answer isn't in this passage" | SQuAD 2.0 | CC BY-SA 4.0 |
+| multi-hop grounded reading | HotpotQA | CC BY-SA 4.0 |
+| trivia reading (answer sentence from the entity's article) | TriviaQA | Apache 2.0 |
+| when to reach for a tool | MASSIVE / CLINC150 | CC BY 4.0 / CC BY 3.0 |
+| instruction following | databricks-dolly-15k | CC BY-SA 3.0 |
+| multi-turn dialogue | OpenAssistant OASST1 | Apache 2.0 |
+| tokenizer coverage of real prose | HuggingFaceFW/fineweb-edu | ODC-By 1.0 |
+| encyclopedic passages | Wikipedia | CC BY-SA |
+| identity, limits, warmth, attribution | Textile Labs | — |
+
+OASST conversations in which the original assistant named itself were removed. No language model
+wrote any training query. No real user data was used. Model weights: MIT.

LICENSE

@@ -0,0 +1,18 @@
+MIT License
+
+Copyright (c) 2026 Textile Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this model
+and associated files (the "Model"), to deal in the Model without restriction, including
+without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Model, and to permit persons to whom the Model is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Model.
+
+THE MODEL IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE MODEL OR THE USE OR OTHER DEALINGS IN THE MODEL.

Modelfile

@@ -0,0 +1,9 @@
+FROM ./loom-crucible-preview-f16.gguf
+TEMPLATE "<tools:off>\n<user>\n{{ .Prompt }}\n<|eot|>\n<loom>\n"
+PARAMETER stop "<|eot|>"
+PARAMETER stop "<user>"
+PARAMETER stop "<result>"
+PARAMETER temperature 0.7
+PARAMETER top_k 40
+PARAMETER repeat_penalty 1.0
+PARAMETER num_predict 96

README.md

@@ -1,3 +1,209 @@
 ---
 license: mit
+language: en
+library_name: transformers
+pipeline_tag: text-generation
+tags:
+- tiny-model
+- llama
+- from-scratch
+- model-growth
+- conversational
+- multi-turn
+- tool-use
+- agent-harness
+- retrieval-augmented
+- question-answering
+- unanswerable-questions
+- attribution
+- humble-ai
+- small-language-model
+- muon
+- gguf
+- text-generation-inference
+widget:
+- text: "<tools:off>\n<user>\nwho are you\n<|eot|>\n<loom>\n"
+  example_title: "Identity"
+- text: "<tools:on>\n<user>\nwho wrote dracula\n<|eot|>\n<loom>\n"
+  example_title: "Reads real prose"
+- text: "<tools:off>\n<user>\nwhat did i eat yesterday\n<|eot|>\n<loom>\n"
+  example_title: "Limits"
 ---
+
+<div align="center">
+<img src="banner.jpg" alt="Loom Crucible Preview" width="520">
+</div>
+
+# Loom Crucible Preview
+
+<img src="logo.jpg" alt="" width="20" height="20" style="border-radius:4px;vertical-align:middle;margin-right:6px;"> **155.0M parameters · 52 layers · 1024 context · Textile Labs**
+
+The biggest Loom by far, and a **preview** of how far our growth method can push a small,
+disciplined model. We took [Loom Tapestry 3](https://huggingface.co/textilelabs/Loom-Tapestry-3)
+(69.2M) and **grew it in both directions at once**, wider (384 → 512) and deeper (40 → 52 layers).
+The growth is function-preserving: the 155M model started out producing exactly what Tapestry 3
+produced, then trained for 12 hours on a rebuilt corpus.
+
+It calls itself **Loom Crucible**. It reads what a search brings back and answers from it, says
+when it looked something up, says when it can't know something about you, and stays a Loom:
+plain, brief, and not a story generator.
+
+Trained from-scratch lineage (no third-party checkpoint), on a Kaggle dual-T4. Runs offline via
+Ollama; llama.cpp-compatible.
+
+```
+you            who wrote dracula
+Loom Crucible  <lookup>wrote dracula</lookup>
+harness        ← Dracula is an 1897 Gothic horror novel by Irish author Bram Stoker.
+Loom Crucible  Bram Stoker. I had to look that up.
+```
+
+## What "Preview" means
+Crucible clearly beats every earlier Loom on its core skills: **reading a passage correctly
+(9/10 vs Tapestry 3's 4/10)** and the **acceptance battery (125/133)**. It is **not yet better
+end to end on live Wikipedia (10/20 held-out vs Tapestry 3's 12/20)**. On that test the limit is
+now the search step, not the reading step: when the search found the answer, both models got it
+right about 85% of the time. A better harness is the next release, and it helps every Loom.
+
+## How it was grown
+Cold-training a big model on little data fails. Instead we grow a trained small one:
+
+- **Wider, 384 → 512.** New channels start at zero so they cannot disturb the old ones. Two
+  details made this exact rather than approximate. First, the 2 new attention heads per layer
+  are placed *inside* their key/value groups, because appending them silently re-pairs the old
+  heads with the wrong keys. Second, every RMSNorm weight is scaled by √(384/512) and ε by
+  384/512, because zero-padding changes the norm.
+- **Deeper, 40 → 52.** 12 new layers are inserted as no-ops (zeroed output projections).
+
+At step 0 the 155M model matched Tapestry 3 to 3e-4 in the logits and 1e-6 in the loss. All
+twelve hours went into getting better, not starting over.
+
+## Measured behaviour
+
+**The family, same harness, 2026-09:**
+
+| model | params | battery /133 | live search (held-out) | reads real prose |
+|---|---:|---:|---:|---|
+| Loom Tapestry 2 | 22.8M | 107 (80.5%) | — | curated only |
+| Loom Tapestry 3 Flash | 7.18M | 112 (84.2%) | 3/20 | curated only |
+| Loom Spark 3 Flash | 7.18M | 119 (89.5%) | 5/20 | curated only |
+| Loom Spark 3 | 12.2M | 120 (90.2%) | 7/20 | curated only |
+| Loom Weave 3 | 31.5M | 120 (90.2%) | 6/20 | yes |
+| Loom Tapestry 3 | 69.2M | 123 (92.5%) | **12/20** | yes + multi-hop |
+| **Loom Crucible Preview** | **155.0M** | **125 (94.0%)†** | 10/20 | **yes, best reader** |
+
+† Crucible's score is the first on a fully clean held-out battery. While building its corpus we
+found that some battery prompts had leaked into the training data used since Tapestry 3. We
+removed them for Crucible, so earlier scores are somewhat optimistic by comparison.
+
+**The acceptance battery, row by row:**
+
+| row | Tapestry 3 | **Crucible** |
+|---|---:|---:|
+| A · says its own name | 12/12 | **12/12** |
+| B · its own name under rough typing | 11/12 | 11/12 |
+| C · 5-turn conversation stays on thread | 5/5 | 5/5 |
+| D · answers from a search result | 5/5 | 4/5 |
+| E · follow-up from the same result | 2/5 | **5/5** |
+| F · says it looked, after a lookup | 5/5 | 4/5 |
+| G · **never** claims a lookup it didn't make | 16/16 | **16/16** |
+| H · admits what it can't know about you | 8/8 | 6/8 |
+| I · says when a result doesn't contain the answer | 2/5 | **3/5** |
+| J · never leaks a search tag with tools off | 28/28 | 28/28 |
+| K · stops on its own | 12/12 | 12/12 |
+| L · searches when it should, not for your private things | 17/20 | **19/20** |
+| **total** | **123/133** | **125/133** |
+
+**Held-out reading bench** (hand-written passages with distractors, e.g. a country's capital
+next to its largest city, a start year next to an end year; none in any training data):
+
+| | Tapestry 3 | **Crucible** |
+|---|---:|---:|
+| answers correctly from the passage | 4/10 | **9/10** |
+| says so when an on-topic passage lacks the answer | 0/10 | **3/10** |
+| says so when the passage is off-topic | 0/8 | **6/8** |
+| refuses a passage that *does* hold the answer | 0 | **0** |
+| with tools off, won't answer a famous fact from memory | 3/8 | 3/8 |
+
+**End to end**, everyday questions it had never seen, live Wikipedia, model writing its own
+query, scored on the final answer: **tuning 11/20, held-out 10/20** (Tapestry 3: 12/20, 12/20).
+When the search found the answer, Crucible got it right 10 times out of 12.
+
+## Read this before you use it
+Every point measured.
+- **It is not better than Tapestry 3 end to end yet.** It reads better, but live results are
+  capped by the search step. Run `harness.py --show` to see the sentence it read.
+- **When a search comes back without the answer, it usually answers anyway.** Given an
+  on-topic passage that lacks the fact, it says so only 3 times in 10. If the passage holds
+  something of the right *type* (a number for "how tall", a year for "when did it end"), it
+  tends to grab that. Trust the sentence shown by `--show`, not just the reply.
+- **With tools off, it sometimes answers famous facts from half-memory** (3/8 held). Those
+  answers are often wrong. Keep tools on for facts.
+- **It once refused a passage that did hold the answer** (1 of 5 battery reading rows).
+- **It is not a calculator.** Arithmetic is out of scope; use a tool.
+- **Harness search is Wikipedia only**: no time, weather, news or prices.
+- **Plain, brief voice by design.** It is a small reader and assistant, not a chat stylist.
+
+What it does reliably: knows what it is, **stops on its own**, holds a conversation, **answers
+follow-ups from the same result (5/5)**, **never claims a lookup it didn't make (16/16)**, and
+**reads a supplied passage better than any earlier Loom**.
+
+## Usage — the harness
+```bash
+python3 harness.py "who wrote dracula"
+python3 harness.py --show "how tall is ben nevis"
+python3 harness.py --no-tools "who are you"
+```
+Stdlib + `certifi`. Wikipedia needs no API key.
+
+## Usage — Ollama
+```bash
+ollama run hf.co/textilelabs/Loom-Crucible-Preview "who are you"
+```
+`template` and `params` are read automatically.
+
+## Usage — transformers
+```python
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM
+tok = AutoTokenizer.from_pretrained("textilelabs/Loom-Crucible-Preview")
+model = AutoModelForCausalLM.from_pretrained("textilelabs/Loom-Crucible-Preview").eval()
+eot = tok.convert_tokens_to_ids("<|eot|>")
+def ask(message, tools=False):
+    p = f"<tools:{'on' if tools else 'off'}>\n<user>\n{message}\n<|eot|>\n<loom>\n"
+    ids = tok(p, return_tensors="pt", add_special_tokens=False).input_ids
+    with torch.no_grad():
+        out = model.generate(ids, max_new_tokens=64, do_sample=False, eos_token_id=eot,
+                             pad_token_id=tok.convert_tokens_to_ids("<|pad|>"))[0]
+    return tok.decode(out[ids.shape[1]:], skip_special_tokens=False).replace("<|eot|>","").strip()
+```
+Prompt format is exact: `<tools:off>\n<user>\n{message}\n<|eot|>\n<loom>\n`.
+
+## How it was built
+| | |
+|---|---|
+| architecture | Llama — 52 layers × 512d, GQA (8 heads / 2 KV), SwiGLU, RoPE, tied embeddings |
+| parameters | 154,980,864 |
+| grown from | Loom Tapestry 3 (40 × 384) by function-preserving width + depth growth |
+| context | 1,024 |
+| vocabulary | 16,384 custom BPE |
+| optimiser | Muon (LR 0.025) on 2D hidden matrices, AdamW on embeddings and norms |
+| loss | masked to the reply tokens; whole conversations packed per block |
+| corpus | 275,788 conversations: Loom curriculum + SQuAD 2.0 (incl. unanswerable) + HotpotQA + TriviaQA |
+| training | 6 h grown from Tapestry 3, then 6 h continued on the rebuilt corpus · best-validation checkpoint |
+| hardware | Kaggle dual T4 (GPU) |
+| decoding | ship with `repeat_penalty 1.0`: higher values corrupt copying from the passage |
+
+## Files
+```
+config.json / model.safetensors           the model
+tokenizer.json / tokenizer_config.json    custom BPE tokenizer, 16,384 tokens
+loom-crucible-preview-f16.gguf            for Ollama / llama.cpp (lookup tags USER_DEFINED)
+harness.py                                 runnable search harness
+template / params                          read automatically by `ollama run hf.co/...`
+Modelfile                                  for building locally
+ATTRIBUTION.md                             required credits for the training corpora
+```
+
+## License
+Model: MIT. Training data retains its original licences and attribution.

config.json

@@ -0,0 +1,33 @@
+{
+  "architectures": [
+    "LlamaForCausalLM"
+  ],
+  "attention_bias": false,
+  "attention_dropout": 0.0,
+  "bos_token_id": null,
+  "dtype": "float32",
+  "eos_token_id": 0,
+  "head_dim": 64,
+  "hidden_act": "silu",
+  "hidden_size": 512,
+  "initializer_range": 0.02,
+  "intermediate_size": 1408,
+  "max_position_embeddings": 1024,
+  "mlp_bias": false,
+  "model_type": "llama",
+  "num_attention_heads": 8,
+  "num_hidden_layers": 52,
+  "num_key_value_heads": 2,
+  "pad_token_id": 1,
+  "pretraining_tp": 1,
+  "rms_norm_eps": 7.500000000000001e-06,
+  "rope_parameters": {
+    "rope_theta": 10000.0,
+    "rope_type": "default"
+  },
+  "tie_word_embeddings": true,
+  "transformers_version": "5.0.0",
+  "use_cache": true,
+  "vocab_size": 16384,
+  "torch_dtype": "float32"
+}

generation_config.json

@@ -0,0 +1,9 @@
+{
+  "_from_model_config": true,
+  "eos_token_id": 0,
+  "output_attentions": false,
+  "output_hidden_states": false,
+  "pad_token_id": 1,
+  "transformers_version": "5.0.0",
+  "use_cache": false
+}

harness.py

@@ -0,0 +1,216 @@
+#!/usr/bin/env python3
+"""Loom harness — the search half of Loom Crucible Preview.
+
+The model never searches. It decides a lookup is needed and writes the query:
+
+    <lookup>france</lookup>
+
+This script does the rest: searches Wikipedia, finds the ONE sentence most likely to
+hold the answer, hands it back as a <result>, and lets the model answer from it.
+
+    python3 harness.py "what's the capital of france"
+    python3 harness.py                          # interactive
+    python3 harness.py --no-tools "who are you"
+    python3 harness.py --show "who wrote hamlet"   # print what was searched and read
+
+How it finds the answer, and why each step exists (all measured on live questions):
+  * searches the model's query AND the subject it can see in your question —
+    "whats the capital of france" searched as-is returns "Capital city" and "Das Kapital"
+  * prefers the real article over lists, films, albums and disambiguation pages
+  * reads the article's intro first, and further only when the intro has no answer of
+    the right kind (a height with a unit, a year, a number, a name)
+  * strips brackets and pronunciation guides, so real text looks like training text
+  * hands back ONE sentence. A 340-character window found the answer more often but the
+    model misread it four times in five; one sentence doubled the final score (15% -> 30%)
+
+Swap search() for anything you like — the contract is text in, one sentence out.
+Wikipedia needs no API key. Stdlib only.
+"""
+from __future__ import annotations
+
+import argparse, json, re, ssl, sys, time, urllib.error, urllib.parse, urllib.request
+
+try:                                    # macOS system Python often lacks a CA bundle
+    import certifi
+    SSL_CTX = ssl.create_default_context(cafile=certifi.where())
+except Exception:
+    SSL_CTX = ssl.create_default_context()
+
+OLLAMA = "http://localhost:11434/api/generate"
+MODEL = "hf.co/textilelabs/Loom-Crucible-Preview"
+API = "https://en.wikipedia.org/w/api.php?"
+# Wikipedia returns 403 without a descriptive User-Agent.
+UA = {"User-Agent": "LoomHarness/3.1 (Textile Labs; https://huggingface.co/textilelabs)"}
+LOOKUP = re.compile(r"<lookup>(.*?)</lookup>", re.S)
+_cache: dict = {}
+
+# ------------------------------------------------------------------- the model
+def loom(prompt: str, n: int = 64) -> str:
+    body = json.dumps({"model": MODEL, "prompt": prompt, "raw": True, "stream": False,
+                       "options": {"temperature": 0, "repeat_penalty": 1.0, "num_predict": n,
+                                   "stop": ["<|eot|>", "<user>", "<result>"]}}).encode()
+    req = urllib.request.Request(OLLAMA, data=body, headers={"Content-Type": "application/json"})
+    with urllib.request.urlopen(req, timeout=120) as r:
+        return json.load(r)["response"].strip()
+
+# ------------------------------------------------------------------ wikipedia
+def _get(params: dict) -> dict:
+    key = json.dumps(params, sort_keys=True)
+    if key in _cache:
+        return _cache[key]
+    for attempt in range(3):
+        try:
+            with urllib.request.urlopen(urllib.request.Request(
+                    API + urllib.parse.urlencode(params), headers=UA),
+                    context=SSL_CTX, timeout=20) as r:
+                _cache[key] = json.load(r)
+                return _cache[key]
+        except urllib.error.HTTPError as e:
+            if e.code == 429:
+                time.sleep(3 * (attempt + 1)); continue
+            raise
+    raise RuntimeError("Wikipedia rate limit")
+
+def search(q: str, n: int = 3) -> list:
+    return [h["title"] for h in _get({"action": "query", "list": "search", "srsearch": q,
+                                      "format": "json", "srlimit": n})["query"]["search"]]
+
+def _extract(title: str, intro: bool) -> str:
+    p = {"action": "query", "prop": "extracts", "explaintext": 1, "titles": title,
+         "format": "json", "redirects": 1}
+    if intro:
+        p["exintro"] = 1
+    return next(iter(_get(p)["query"]["pages"].values())).get("extract", "") or ""
+
+# ------------------------------------------------------------------ the finder
+SENT = re.compile(r"(?<=[.!?])\s+(?=[A-Z0-9])")
+PAREN = re.compile(r"\s*\([^()]*\)")
+HEADING = re.compile(r"^\s*=+[^=]+=+\s*$", re.M)
+STOP = set(("what whats who whos whom whose when where which why how is are was were be the a an "
+            "of in on to for does did do by from with as at and or that this it its there tell me "
+            "please can you many much").split())
+ATTR = set(("capital city height tall high elevation population largest biggest smallest longest "
+            "shortest tallest highest deepest first last symbol chemical language languages spoken "
+            "legs year date end ended sink sank invented inventor discovered discovery developed "
+            "wrote written author painted painter president founded born died age old size area "
+            "distance speed").split())
+JUNK = re.compile(r"^(lists? of|outline of|index of|timeline of)\b|\((film|album|song|band|"
+                  r"novel|play|tv series|musical|opera|video game|book|composition|poem)\)|"
+                  r"\bdisambiguation\b", re.I)
+
+def keywords(t: str) -> list:
+    return [w for w in re.findall(r"[^\W_]+", t.lower()) if w not in STOP]
+
+def subject(question: str) -> str:
+    kw = keywords(question)
+    return " ".join(k for k in kw if k not in ATTR) or " ".join(kw)
+
+def clean(t: str) -> str:
+    prev = None
+    while prev != t:
+        prev, t = t, PAREN.sub("", t)
+    return re.sub(r"\s+", " ", t.replace(" ,", ",")).strip()
+
+def _hard(q: str, s: str) -> float:
+    """The answer is of the right KIND: a height with a unit, a year, a number, a name."""
+    b = 0.0
+    if re.search(r"\b(how tall|how high|height|elevation)\b", q):
+        b += 2.0 if re.search(r"\d[\d,.]*\s*(m|metres|meters|ft|feet|km)\b", s) else 0
+    if re.search(r"\b(when|what year|which year|what date)\b", q):
+        b += 2.0 if re.search(r"\b(1\d{3}|20\d{2})\b", s) else 0
+    if re.search(r"\b(how many|how much|population|number of)\b", q):
+        b += 1.5 if re.search(r"\d", s) else 0
+    if re.search(r"\bwho\b", q):
+        b += 1.5 if re.search(r"\b[A-Z][a-z]+ [A-Z][a-z]+", s) else 0
+    if re.search(r"\bsymbol\b", q):
+        b += 2.0 if re.search(r"\bsymbol\b", s, re.I) else 0
+    if re.search(r"\bcapital\b", q):
+        b += 2.0 if re.search(r"\bcapital\b", s, re.I) else 0
+    return b
+
+def _kind(q: str, s: str) -> float:
+    b, sl = _hard(q, s), s.lower()
+    if re.search(r"\b(how tall|how high|height|elevation)\b", q):
+        b += 1.5 if re.search(r"\b(summit|elevation|height|above sea level|highest|stands)\b", sl) else -0.5
+    if re.search(r"\b(end|ended|finish|finished)\b", q):
+        b += 1.5 if re.search(r"\b(ended|end of|surrender|surrendered|concluded|finished)\b", sl) else -0.5
+    if re.search(r"\bpopulation\b", q):
+        b += 2.0 if re.search(r"\d{1,3}(,\d{3})+|\d+(\.\d+)?\s*(million|billion)", s) else -1.0
+    if re.search(r"\b(invent|invented|inventor|discovered|wrote|painted|composed|founded)\b", q):
+        b += 1.0 if re.search(r"\b[A-Z][a-z]+ (?:[A-Z][a-z]+ )?[A-Z][a-z]+\b", s) else 0.0
+    return b
+
+def find(query: str, question: str) -> tuple:
+    """One sentence most likely to hold the answer, and the article it came from."""
+    q = question.lower()
+    subj = subject(question)
+    pool = {}
+    for tq in dict.fromkeys(x for x in (query.strip(), subj, " ".join(keywords(question))) if x):
+        for rank, t in enumerate(search(tq, 3)):
+            tl = t.lower()
+            s = (4.0 if tl in (subj, query.strip().lower()) else 2.0 if subj and tl.startswith(subj) else 0.0)
+            s += -4.0 if JUNK.search(t) else 0.0
+            pool[t] = max(pool.get(t, -1e9), s - 0.3 * rank)
+    qk = list(dict.fromkeys(keywords(question) + keywords(query)))
+    top = sorted(pool.items(), key=lambda x: -x[1])[:3]
+    typed = bool(re.search(r"\b(how tall|how high|height|elevation|when|what year|which year|"
+                           r"how many|how much|population|who|symbol|capital)\b", q))
+    best = (-1e9, "", "")
+    for intro in (True, False):
+        found_kind = False
+        for title, ps in top:
+            raw = _extract(title, intro)
+            if re.search(r"\b(may|can) refer to\b", raw[:400]):
+                continue
+            body = clean(HEADING.sub(" ", raw))
+            sents = [s.strip() for s in SENT.split(body) if 20 < len(s.strip()) < 600]
+            for i, s in enumerate(sents[: 14 if intro else 90]):
+                sc = ps + sum(1.0 for k in qk if k in s.lower()) + _kind(q, s) + (0.5 if i < 3 else 0.0)
+                if sc > best[0]:
+                    best = (sc, s, title)
+                    found_kind = _hard(q, s) > 0
+        if best[1] and (not typed or found_kind):
+            break                       # the intro held an answer of the right kind
+    return best[1], best[2]
+
+# ------------------------------------------------------------------ the loop
+def ask(message: str, tools: bool = True, show: bool = False) -> str:
+    convo = f"<tools:{'on' if tools else 'off'}>\n<user>\n{message.strip()}\n<|eot|>\n<loom>\n"
+    first = loom(convo)
+    m = LOOKUP.search(first)
+    if not m:
+        return first
+    query = m.group(1).strip()
+    try:
+        result, source = find(query, message)
+    except Exception as e:
+        # Never feed an error in as if it were a result — the model will answer from it.
+        return f"[harness] lookup failed for {query!r}: {e}"
+    if not result:
+        return f"[harness] nothing found for {query!r}"
+    if show:
+        print(f"    [searched: {query!r}]\n    [read from {source}: {result[:150]}]")
+    return loom(convo + first + f"<|eot|>\n<result>\n{result}\n<|eot|>\n<loom>\n", n=48)
+
+def main() -> int:
+    global MODEL
+    ap = argparse.ArgumentParser(description="Loom Spark 3 harness")
+    ap.add_argument("message", nargs="*")
+    ap.add_argument("--no-tools", action="store_true", help="chat only, no lookups")
+    ap.add_argument("--show", action="store_true", help="print the query and the sentence read")
+    ap.add_argument("--model", default=MODEL)
+    a = ap.parse_args()
+    MODEL = a.model
+    if a.message:
+        print(ask(" ".join(a.message), not a.no_tools, a.show)); return 0
+    print(f"Loom harness — {MODEL} (tools {'off' if a.no_tools else 'on'}, ctrl-c to quit)\n")
+    while True:
+        try:
+            msg = input("you  > ").strip()
+        except (EOFError, KeyboardInterrupt):
+            print(); return 0
+        if msg:
+            print(f"loom > {ask(msg, not a.no_tools, a.show)}\n")
+
+if __name__ == "__main__":
+    sys.exit(main())

loom-crucible-preview-f16.gguf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e29441661d59351e073a27c4ceb562ff761fdce901563dcd30fa28788daaea59
+size 310662304

model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:51ee9d9726c2c64c32a524b8570a31ca7eeac66031f13337a26fae6d79266f2f
+size 619975896

params

@@ -0,0 +1,7 @@
+{
+  "stop": ["<|eot|>", "<user>", "<result>"],
+  "temperature": 0.7,
+  "top_k": 40,
+  "repeat_penalty": 1.0,
+  "num_predict": 96
+}

special_tokens_map.json

@@ -0,0 +1 @@
+{"eos_token":"<|eot|>","pad_token":"<|pad|>","additional_special_tokens":["<tools:on>","<tools:off>","<user>","<loom>","<result>","<lookup>","</lookup>"]}

template

@@ -0,0 +1,5 @@
+<tools:off>
+<user>
+{{ .Prompt }}
+<|eot|>
+<loom>

tokenizer_config.json

@@ -0,0 +1 @@
+{"tokenizer_class":"PreTrainedTokenizerFast","model_max_length":1024,"eos_token":"<|eot|>","pad_token":"<|pad|>","additional_special_tokens":["<tools:on>","<tools:off>","<user>","<loom>","<result>","<lookup>","</lookup>"],"clean_up_tokenization_spaces":false}