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-spark-3.2-f16.gguf filter=lfs diff=lfs merge=lfs -text

ATTRIBUTION.md

@@ -0,0 +1,28 @@
+# Attribution
+
+Loom Spark 3.2 was trained from scratch: random initialisation, then two short second passes
+on its own weights. No third-party checkpoint was used. Grounded-reading rows embed real
+encyclopedic prose. Some of these licences require attribution; this file satisfies that
+requirement and must be kept with any redistribution.
+
+| slice | source | licence |
+|---|---|---|
+| grounded reading + "the answer isn't in this passage" | SQuAD 2.0 (Rajpurkar, Jia & Liang) | CC BY-SA 4.0 |
+| three-paragraph reading (same-article paragraphs) | 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 (Amazon) / CLINC150 (Larson et al.) | CC BY 4.0 / CC BY 3.0 |
+| instruction following | databricks-dolly-15k | CC BY-SA 3.0 |
+| multi-turn dialogue structure | OpenAssistant OASST1 | Apache 2.0 |
+| encyclopedic passages | Wikipedia | CC BY-SA |
+| identity, limits, warmth, memory within a chat, attribution, injection resistance | Textile Labs | MIT |
+
+Only English portions were used. OASST conversations in which the original assistant named
+itself were removed. Source text was not altered except for truncation to a realistic
+tool-result length, and surface augmentation (casing, punctuation, filler) applied to user
+turns in training copies only.
+
+## Search queries — derived, not generated
+Every `<lookup>` query in the training data is the subject of the question, derived
+mechanically from the human-written sources above. No language model wrote any training
+query or any training reply. No real user data was used. Model weights: MIT.

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Textile Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software 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 Software.
+
+THE SOFTWARE 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 OR COPYRIGHT HOLDERS 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 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Modelfile

@@ -0,0 +1,15 @@
+FROM ./loom-spark-3.2-f16.gguf
+TEMPLATE """<tools:off>
+<user>
+{{ .Prompt }}
+<|eot|>
+<loom>
+"""
+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 128
+PARAMETER num_ctx 2048

README.md

@@ -1,3 +1,278 @@
 ---
 license: mit
+language: en
+library_name: transformers
+pipeline_tag: text-generation
+tags:
+- tiny-model
+- llama
+- from-scratch
+- conversational
+- multi-turn
+- tool-use
+- agent-harness
+- retrieval-augmented
+- question-answering
+- 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:off>\n<user>\nwho wrote the odyssey\n<|eot|>\n<loom>\n"
+  example_title: "Knows when it doesn't know"
+- text: "<tools:on>\n<user>\nwhats the capital of peru\n<|eot|>\n<loom>\n"
+  example_title: "Search for the thing"
 ---
+
+<div align="center">
+<img src="banner.jpg" alt="Loom Spark 3.2" width="520">
+</div>
+
+# Loom Spark 3.2
+
+<img src="logo.jpg" alt="" width="20" height="20" style="border-radius:4px;vertical-align:middle;margin-right:6px;"> **22.8M parameters · 20 layers · 2,048 context · Textile Labs**
+
+The Spark that knows what it doesn't know. Successor to
+[Loom Spark 3](https://huggingface.co/textilelabs/Loom-Spark-3). Trained from scratch:
+randomly initialised weights, nothing fine-tuned from anyone's checkpoint.
+
+**Ask Spark 3 a fact it can't know with tools off — who wrote the Odyssey — and it makes something up
+or loops 17 times in 20. Spark 3.2 says it would be guessing 16 times in 20 — and still answers the ten basic facts
+it does know.** It matches Spark 3's live search and beats it on our full acceptance battery,
+122/133 to 120/133.
+
+## What changed from Spark 3
+
+| | Spark 3 | **Spark 3.2** |
+|---|---|---|
+| size | 12.2M | **22.8M** (the Spark tier is now ~20M) |
+| context | 512 tokens | **2,048 tokens** |
+| hardware | one 2013 desktop CPU, 3 h 54 min | Kaggle, 2 × T4 GPU, 2 h 13 min |
+| unknown facts, tools off | declined 3 of 20 | **declines 16 of 20** |
+| basic facts it should know | 0 of 20 right | **15 of 20 right** |
+| talking about itself in its own words | 9 of 16 | **12 of 16** |
+| responding to good and bad news | 2 of 20 | **10 of 20** |
+| prompt injection resisted | 33 of 36 | **36 of 36** |
+
+Spark 3 only declined capital-city questions offline; for everything else it guessed. Spark
+3.2 was trained on declines across every kind of fact, and on **contrast pairs**: questions
+with the same shape as a fact it knows but a different subject (*"how many bones does a whale
+have"* next to *"how many bones does an adult have"*), so it learns the subject matters, not
+the sentence shape.
+
+The four-times-longer context lets it keep track of longer chats: on 10-turn conversations
+where a fact from turn 1–3 is asked again at turn 9–10, it gets 2 of 4 (Spark 3: 0 of 4).
+
+## The search harness
+
+The model decides a search is needed and writes the query. `harness.py` does the rest: it
+searches the model's query and the subject in your question, prefers the real article over
+lists and disambiguation pages, and hands back **one sentence**, the one most likely to hold
+an answer of the right kind. It now retries when Wikipedia is busy (HTTP 502/503/504) as well
+as when it rate-limits.
+
+```
+you               who composed the four seasons
+Loom Spark 3.2    <lookup>composed four seasons</lookup>
+harness           ← The Four Seasons is a group of four violin concerti by Italian composer Antonio Vivaldi, ...
+Loom Spark 3.2    Antonio Vivaldi. I looked that one up.
+```
+
+## Measured against Spark 3
+
+Same tests, same harness, same settings, both models through Ollama, 2026-10-01. None of
+these questions are in the training data — every test prompt is scrubbed from the corpus
+before training.
+
+**End to end**: 20 held-out everyday questions, live Wikipedia, the model writing its own
+query. Scored on the final answer.
+
+| | decided to search | wrote its own query | answer reached the model | **answered right** |
+|---|---:|---:|---:|---:|
+| Spark 3 | 20/20 | 20/20 | 12/20 | **7/20** |
+| **Loom Spark 3.2** | 20/20 | 20/20 | 13/20 | **7/20** |
+
+Read by eye, one of Spark 3.2's seven is generous: it searched `fahrenheit speed` for the
+boiling point of water in Fahrenheit and still reached "32 °F and the boiling point...".
+
+**The acceptance battery**, row by row:
+
+| row | Spark 3 | **Loom Spark 3.2** |
+|---|---:|---:|
+| A · says its own name | 11/12 | **12/12** |
+| B · its own name under rough typing (`WHATS UR NAME???`) | 11/12 | 11/12 |
+| C · 5-turn conversation stays on thread | 5/5 | 5/5 |
+| D · answers from a search result | 3/5 | 3/5 |
+| E · follow-up answered from the same result | **3/5** | 1/5 |
+| F · says it looked, after a lookup | 5/5 | 5/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 | 8/8 |
+| I · says when a result doesn't contain the answer | 0/5 | **2/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 | 18/20 | **19/20** |
+| **total** | **120/133** | **122/133** |
+
+**Held-out behaviour tests**, written before Spark 3.2 was trained:
+
+| | Spark 3 | **Loom Spark 3.2** |
+|---|---:|---:|
+| unknown facts, tools off — declines instead of guessing | 3/20 | **16/20** |
+| ten basic facts, tools off — answers right | 0/20 | **15/20** |
+| same facts, tools on — looks them up | 20/20 | 20/20 |
+| same-shape questions it doesn't know — no false "I know this" | **20/20** | 19/20 |
+| a `<tools:on>` typed inside a message doesn't switch search on | 12/12 | 12/12 |
+| in its own words about itself | 9/16 | **12/16** |
+| warmth — good news and bad news met correctly | 2/20 | **10/20** |
+| prompt injection — kept its identity, didn't obey (12 prompts × 3) | 33/36 | **36/36** |
+| 10- and 12-turn conversations — turns answered on target | 41/44 | **42/44** |
+
+Spark 3's 20/20 on the same-shape row is mostly empty: asked "how far is mars from earth",
+it loops ("mars, mars, mars…") rather than claiming anything. Spark 3.2 declines most of
+these properly; its one miss is below.
+
+## Every Loom text model
+
+| model | params | battery /133 | live search (e2e) | reads real prose | status |
+|---|---:|---:|---:|---|---|
+| Loom Spark 2 | 19.9M | ~97/133 | 2/20 | no | shipped |
+| Loom Tapestry 2 | 22.8M | 107/133 | — | curated only | shipped |
+| Loom Tapestry 3 Flash | 7.18M | 112/133 | 3/20 | curated only | shipped |
+| Loom Spark 3 Flash | 7.18M | 119/133 | 5/20 | curated only | shipped |
+| Loom Spark 3 | 12.2M | 120/133 | 7/20 | curated only | shipped |
+| Loom Weave 2 | 59.65M | — (method failure) | — | no | shipped (superseded) |
+| Loom Weave 3 | 31.5M | 120/133 | 6/20 held | yes — first | shipped |
+| Loom Tapestry 3 | 69.2M | 123/133 | 12/20 held | yes + multi-hop | shipped |
+| Loom Crucible Preview | 155.0M | 125/133† | 10/20 held | yes — best reader | shipped |
+| **Loom Spark 3.2** | **22.8M** | **122/133†** | **7/20 held** | **curated only** | **this model** |
+
+† scored on a battery with every test prompt scrubbed from training. Earlier rows' scores are
+each model's release score; only models in the same table above were measured side by side.
+Bigger Looms still read real prose far better — choose Tapestry 3 or Crucible Preview if
+search answers matter most.
+
+## Read this before you use it
+
+Every point here was measured.
+
+- **It gets about a third of everyday questions right with search.** Same as Spark 3.
+  "I looked that up" means it searched, not that it read the result correctly. Run the
+  harness with `--show` and trust the sentence it read over its summary of it.
+- **It reads the right sentence and picks the wrong part.** Canada comes back as "Toronto,
+  Montreal, and Vancouver"; *who wrote Pride and Prejudice* comes back as "Pride and
+  Prejudice"; *who discovered gravity* as "Albert Einstein".
+- **Follow-up questions about the same result are weak — worse than Spark 3** (1/5 vs 3/5).
+  Ask a fresh, complete question instead of "how many people live there".
+- **It usually doesn't say when a result lacks the answer** (2/5). It answers from whatever
+  it read.
+- **Long pasted documents don't work yet.** The context is 2,048 tokens, but asked a question
+  about a 1,000–1,600-token pasted text, it got 0 of 4. The longer context helps it follow
+  longer chats, not read long documents.
+- **One false "I know this" in twenty:** asked how far the Sun is from the Moon, it gave the
+  Earth–Moon distance.
+- **It searched for a private question once in twenty** — *"where did i go to school"*.
+- **Warmth is a coin flip.** Half the time good news gets "Okay, I'll remember that." instead
+  of congratulations.
+- **It sometimes garbles a query** — `caly` for *the capital of italy*. The harness's subject
+  search catches most of these.
+- **Harness search is Wikipedia only**, so time, weather, news and prices can't be answered
+  even when it correctly decides to look them up.
+
+## Usage — the harness
+
+```bash
+python3 harness.py "whats the capital of peru"
+python3 harness.py                              # interactive
+python3 harness.py --show "who wrote hamlet"    # see what it searched and read
+python3 harness.py --no-tools "who are you"
+```
+
+Stdlib only. Wikipedia needs no API key. Swap `search()` for anything — the contract is text
+in, one sentence out. **Never feed a failed lookup back as a result** — the model will answer
+from the error text. `harness.py` fails loudly instead.
+
+## Usage — Ollama
+
+```bash
+ollama run hf.co/textilelabs/Loom-Spark-3.2 "who are you"
+```
+
+`template` and `params` are read automatically. **Do not add a repetition penalty** — the
+model answers by quoting what it read, so penalising repeats penalises the right answer.
+
+## Usage — transformers
+
+```python
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM
+
+tok = AutoTokenizer.from_pretrained("textilelabs/Loom-Spark-3.2")
+model = AutoModelForCausalLM.from_pretrained("textilelabs/Loom-Spark-3.2").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=96, 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`. For more turns,
+append `{reply}<|eot|>\n<user>\n{next message}\n<|eot|>\n<loom>\n`.
+
+## How it was built
+
+| | |
+|---|---|
+| architecture | Llama — 20 layers × 320d, FFN 864, GQA (5 heads / 1 KV), SwiGLU, RoPE, tied embeddings |
+| parameters | 22,827,840 |
+| context | 2,048 |
+| vocabulary | 4,096 custom BPE (the Spark-line tokenizer, unchanged from Spark 3) |
+| optimiser | Muon (0.025) on the 2D hidden matrices, AdamW (6e-4) on embeddings and norms |
+| schedule | warmup → stable → decay (WSD), decay from 65%, with a focused mix in the decay |
+| packing | whole conversations packed into 2,048-token windows, **each conversation masked so it can only see itself** |
+| corpus | about 285,000 conversations · 48.2M tokens per pass, loss on the model's replies only |
+| second passes | two 30-minute passes on its own weights at a fifth of the learning rate: the focused mix, then the same plus 3,600 contrast-pair and known-fact rows |
+| training | 274.9M tokens · 12.0 tokens per parameter · from random init |
+| hardware | Kaggle, 2 × NVIDIA T4 · 2 h 13 min (74 min, then 30 + 30 min) |
+
+The per-conversation mask mattered more than anything else. Without it, up to 68 short
+conversations shared one window and could see each other, and the model learned to copy its
+neighbours instead of reading its own chat: the first unmasked run scored 107/133. Same data
+with the mask: 120/133.
+
+## Files
+
+```
+config.json / model.safetensors           the model
+tokenizer.json / tokenizer_config.json    custom BPE tokenizer, 4,096 tokens
+loom-spark-3.2-f16.gguf                   for Ollama / llama.cpp
+harness.py                                runnable search harness — stdlib only
+template / params                         read automatically by `ollama run hf.co/...`
+Modelfile                                 for building locally
+ATTRIBUTION.md                            required credits for the training corpora
+```
+
+## Training data
+
+| slice | source |
+|---|---|
+| grounded reading, three-paragraph reading, and "the result doesn't say" | **SQuAD 2.0** (CC BY-SA 4.0) |
+| multi-hop and trivia reading | **HotpotQA** (CC BY-SA 4.0) · **TriviaQA** (Apache 2.0) · Wikipedia (CC BY-SA) |
+| when to reach for a tool | **MASSIVE** (CC BY 4.0) · **CLINC150** (CC BY 3.0) |
+| instruction following | **databricks-dolly-15k** (CC BY-SA 3.0) |
+| multi-turn dialogue structure | **OpenAssistant OASST1** (Apache 2.0) |
+| identity, limits, declines, warmth, memory within a chat, injection resistance | Textile Labs — written for Loom |
+
+Every search query is derived mechanically from these sources. No language model wrote any
+training data, and nothing is fine-tuned from anyone's checkpoint.
+
+## 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": 320,
+  "initializer_range": 0.02,
+  "intermediate_size": 864,
+  "max_position_embeddings": 2048,
+  "mlp_bias": false,
+  "model_type": "llama",
+  "num_attention_heads": 5,
+  "num_hidden_layers": 20,
+  "num_key_value_heads": 1,
+  "pad_token_id": 1,
+  "pretraining_tp": 1,
+  "rms_norm_eps": 1e-05,
+  "rope_parameters": {
+    "rope_type": "default",
+    "rope_theta": 10000.0
+  },
+  "tie_word_embeddings": true,
+  "transformers_version": "5.0.0",
+  "use_cache": true,
+  "vocab_size": 4096,
+  "rope_theta": 10000.0
+}

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.15.1",
+  "use_cache": true
+}

harness.py

@@ -0,0 +1,216 @@
+#!/usr/bin/env python3
+"""Loom harness — the search half of Loom Spark 3.2.
+
+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-Spark-3.2"
+API = "https://en.wikipedia.org/w/api.php?"
+# Wikipedia returns 403 without a descriptive User-Agent.
+UA = {"User-Agent": "LoomHarness/3.0 (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, "num_predict": n, "repeat_penalty": 1.0, "num_ctx": 2048,
+                                   "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 in (429, 502, 503, 504):
+                time.sleep(3 * (attempt + 1)); continue
+            raise
+    raise RuntimeError("Wikipedia busy or rate-limited — try again")
+
+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.2 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-spark-3.2-f16.gguf

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

model.safetensors

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

params

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

special_tokens_map.json

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