@ketecode/loom 0.0.0-stage → 0.2.0

package/skills/ui-motion/references/patterns.md

@@ -0,0 +1,138 @@
+# Motion patterns
+
+Motion for React (`npm i motion`, imports from `"motion/react"`). Check the project's installed version; the API below matches current Motion docs.
+
+## Enter and exit
+
+```tsx
+import { AnimatePresence, motion } from "motion/react";
+
+<AnimatePresence>
+  {open && (
+    <motion.div
+      key="panel"
+      initial={{ opacity: 0, y: 8 }}
+      animate={{ opacity: 1, y: 0 }}
+      exit={{ opacity: 0, y: 4, transition: { duration: 0.12 } }}
+      transition={spring.gentle}
+    />
+  )}
+</AnimatePresence>
+```
+
+The conditional must be inside `AnimatePresence`; if the whole `AnimatePresence` unmounts, there is no exit animation.
+
+## Replace one element with another
+
+```tsx
+<AnimatePresence mode="wait" initial={false}>
+  <motion.span key={status} initial={{ opacity: 0 }} animate={{ opacity: 1 }} exit={{ opacity: 0 }}>
+    {label}
+  </motion.span>
+</AnimatePresence>
+```
+
+Changing `key` is what triggers exit then enter.
+
+## Reorderable list
+
+```tsx
+<ul>
+  <AnimatePresence initial={false}>
+    {items.map((item) => (
+      <motion.li key={item.id} layout initial={{ opacity: 0 }} animate={{ opacity: 1 }} exit={{ opacity: 0 }}>
+        {item.name}
+      </motion.li>
+    ))}
+  </AnimatePresence>
+</ul>
+```
+
+Use `item.id` keys, never the array index, or the wrong items animate. For drag-to-reorder, Motion has `Reorder.Group` / `Reorder.Item`.
+
+## Shared element
+
+```tsx
+// In the grid
+<motion.img layoutId={`photo-${id}`} src={thumb} />
+// In the detail view
+<motion.img layoutId={`photo-${id}`} src={full} />
+```
+
+If text inside a `layout` element distorts, add `layout` to the child as well, or use `layout="position"`.
+
+## Swipe to dismiss
+
+```tsx
+<motion.div
+  drag="x"
+  dragConstraints={{ left: 0, right: 0 }}
+  dragElastic={0.6}
+  onDragEnd={(_, info) => {
+    if (Math.abs(info.offset.x) > 120 || Math.abs(info.velocity.x) > 500) onDismiss();
+  }}
+/>
+```
+
+Also render a visible dismiss button: drag is not available to keyboard or switch users.
+
+## Scroll-linked progress bar
+
+```tsx
+const { scrollYProgress } = useScroll();
+return <motion.div style={{ scaleX: scrollYProgress, transformOrigin: "0 50%" }} className="progress" />;
+```
+
+CSS-only alternative where supported:
+
+```css
+.progress { transform-origin: 0 50%; animation: grow linear both; animation-timeline: scroll(); }
+@keyframes grow { from { transform: scaleX(0); } to { transform: scaleX(1); } }
+```
+
+## Reduced motion
+
+```tsx
+import { MotionConfig, useReducedMotion } from "motion/react";
+
+<MotionConfig reducedMotion="user">{app}</MotionConfig>   // "user" | "always" | "never"
+
+function Card() {
+  const reduce = useReducedMotion();
+  return <motion.div initial={{ opacity: 0, y: reduce ? 0 : 16 }} animate={{ opacity: 1, y: 0 }} />;
+}
+```
+
+## View Transitions API (no library)
+
+Same-document (SPA):
+
+```js
+if (!document.startViewTransition) updateDom();
+else document.startViewTransition(() => updateDom());
+```
+
+```css
+.hero-image { view-transition-name: hero; }          /* unique per page */
+::view-transition-old(root), ::view-transition-new(root) { animation-duration: 200ms; }
+@media (prefers-reduced-motion: reduce) {
+  ::view-transition-group(*), ::view-transition-old(*), ::view-transition-new(*) { animation: none; }
+}
+```
+
+Cross-document (multi-page sites): add `@view-transition { navigation: auto; }` to both pages' CSS. Check current browser support on MDN or caniuse before relying on it; it degrades to a normal navigation where unsupported.
+
+In frameworks, use their wrapper when one exists (for example Astro's `<ClientRouter />` or the router's view-transition option) rather than calling the API by hand around router internals.
+
+## Bundle-size mode
+
+```tsx
+import { LazyMotion, domAnimation } from "motion/react";
+import * as m from "motion/react-m";
+
+<LazyMotion features={domAnimation} strict>
+  <m.div animate={{ opacity: 1 }} />
+</LazyMotion>
+```
+
+`domAnimation` covers animations, variants, exit and tap/hover/focus gestures; `domMax` adds drag, pan and layout animations. `strict` throws if a full `motion` component sneaks in.

package/skills/ui-motion/references/tokens.md

@@ -0,0 +1,52 @@
+# Motion tokens
+
+Starting values; tune to the product's tone. Keep CSS and JS in sync by defining them once.
+
+```css
+:root {
+  --duration-instant: 75ms;
+  --duration-fast: 150ms;
+  --duration-base: 220ms;
+  --duration-slow: 350ms;
+
+  --ease-out: cubic-bezier(0.2, 0, 0, 1);       /* enter */
+  --ease-in: cubic-bezier(0.4, 0, 1, 1);        /* exit */
+  --ease-in-out: cubic-bezier(0.4, 0, 0.2, 1);  /* move on screen */
+}
+
+@media (prefers-reduced-motion: reduce) {
+  :root {
+    --duration-fast: 1ms;
+    --duration-base: 1ms;
+    --duration-slow: 1ms;
+  }
+}
+```
+
+Setting durations to `1ms` rather than `0` keeps `transitionend` / `animationend` events firing for code that waits on them. Only do this blanket reduction if every animation is decorative; otherwise keep opacity fades and remove movement per component.
+
+```ts
+// motion-tokens.ts
+import type { Transition } from "motion/react";
+
+export const spring = {
+  snappy: { type: "spring", visualDuration: 0.2, bounce: 0 },
+  gentle: { type: "spring", visualDuration: 0.35, bounce: 0.1 },
+  bouncy: { type: "spring", visualDuration: 0.45, bounce: 0.3 },
+} satisfies Record<string, Transition>;
+
+export const fade = { duration: 0.15, ease: [0.2, 0, 0, 1] } satisfies Transition;
+```
+
+## What to use where
+
+| Element | Enter | Exit | Notes |
+|---|---|---|---|
+| Button press | scale 0.97, `instant` | back, `fast` | `whileTap` |
+| Tooltip | opacity + 4px y, `fast` | opacity, `instant` | delay show 300-500ms, hide immediately |
+| Dropdown / popover | opacity + scale 0.96 from trigger origin, `fast` | opacity, `instant` | `transform-origin` at the trigger |
+| Toast | slide + fade, `gentle` spring | fade, `fast` | |
+| Modal | backdrop fade `base`; panel scale 0.96 + fade | faster than enter | return focus to the trigger |
+| Drawer / sheet | translate from edge, `snappy` spring | translate out | drag to dismiss with velocity threshold |
+| List add/remove | height via `layout`, fade | fade, then siblings close gap | `AnimatePresence` + `layout` |
+| Route change | crossfade `base` or shared element | | keep under 300ms |

package/skills/unicode-text-processing/SKILL.md

@@ -0,0 +1,103 @@
+---
+name: unicode-text-processing
+description: Code-level correctness for text in complex and non-Latin scripts such as Bengali, Devanagari, Tamil, Arabic, Hebrew, Thai, Khmer, Chinese, Japanese and Korean - choosing NFC versus NFKC normalization and case folding, counting and truncating by grapheme cluster instead of code unit, detecting scripts from the Unicode Script property, dictionary-based word segmentation for languages written without spaces, ICU collation, locale-aware sorting and search folding, bidirectional text isolation, display width, and confusable or invisible characters. Use when string length, slicing, sorting, search matching, tokenization or rendering breaks on non-English text, when a database or search index must compare such text correctly, or when user input mixes scripts.
+license: MIT
+compatibility: Any Agent Skills host. Examples use Python 3 (unicodedata, the regex package, PyICU), JavaScript (Intl.Segmenter, Intl.Collator, String.prototype.normalize), Java (java.text, ICU4J) and PostgreSQL ICU collations; use the equivalent ICU binding in other languages.
+metadata:
+  kete-loom/version: "0.1.0"
+  kete-loom/category: data
+  kete-loom/risk: writes-files
+  kete-loom/owner: "Kete-org"
+---
+
+# Unicode text processing
+
+A "character" is not a byte, not a UTF-16 code unit and often not a code point. Most bugs with non-Latin text come from code that assumes one of those. Fix them with the Unicode algorithms and ICU, never with hand-written character tables. This skill is about string handling in code; translating an app's UI and locale formatting is the `i18n-localization` skill.
+
+Standards to cite in comments and reviews: UAX #15 (normalization), UAX #29 (text segmentation), UAX #24 (script property), UTS #10 (collation), UAX #9 (bidi), UAX #11 (East Asian width), UTS #39 (security and confusables). Library calls per language are in `references/apis.md`; script-specific pitfalls in `references/script-notes.md`.
+
+## 0. Reproduce with real text
+
+1. Get a failing sample in the real script from the user or the data, as text and as code points (`[hex(ord(c)) for c in s]` in Python, `[...s].map(c => c.codePointAt(0).toString(16))` in JS). Screenshots hide the difference between look-alike sequences.
+2. Confirm the encoding end to end: files, HTTP `Content-Type; charset=utf-8`, database encoding and connection charset (MySQL `utf8mb4`, not `utf8`). Mojibake like `ব` means UTF-8 bytes were decoded as Latin-1 or Windows-1252 somewhere; fix the boundary, never "repair" the data with replace tables.
+3. Write a test with that sample before changing code.
+
+## 1. Normalize at the boundary
+
+| Form | Use for | Avoid for |
+|---|---|---|
+| NFC | Storing and comparing user text; default for the web and most APIs | |
+| NFD | Stripping combining marks for accent-insensitive search keys (Latin) | Storing text |
+| NFKC | Identifiers, usernames, search keys where full-width and compatibility forms should match (`Ａ` vs `A`, `fi` vs `fi`) | Storing the user's text: it is lossy |
+| NFKC_Casefold / `casefold()` after NFKC | Case-insensitive identifier matching | Display |
+
+Rules:
+- Normalize once when text enters the system (API input, file import), store NFC, and normalize again before comparing with outside data.
+- NFC and NFKC give different results for the same input: compare strings normalized to the same form.
+- Case-insensitive matching uses case folding (`str.casefold()`, ICU `foldCase`), not `lower()`. For Turkish and Azerbaijani, dotted and dotless i need the locale-specific rules.
+- For search keys, keep the original string for display and store a separate folded key.
+
+## 2. Count, slice and truncate by grapheme cluster
+
+What a user sees as one character can be several code points: Bengali `ক্ষ` (conjunct), Devanagari `कि` (consonant plus vowel sign), emoji with skin tones or ZWJ families, flags, Hangul jamo sequences.
+
+- Length limits shown to users ("max 50 characters") count extended grapheme clusters (UAX #29): Python `regex.findall(r"\X", s)`, JS `Intl.Segmenter(undefined, { granularity: "grapheme" })`, ICU `BreakIterator.getCharacterInstance`.
+- Storage limits (database column bytes, SMS segments, protocol fields) count bytes or code units; check them separately and **truncate at a grapheme boundary**, never mid-cluster, then verify the byte length.
+- Never reverse, split or slice user-visible strings by index without segmenting them first.
+- Note: a grapheme cluster is not always one Indic syllable (aksara). If the product needs syllable-level units (for example a cursor or a typing tutor for Bengali), check with the user. Unicode 15.1 added rule GB9c, so conjuncts such as `ক্ষ` in Bengali, Devanagari, Gujarati, Malayalam, Oriya and Telugu are one extended grapheme cluster; libraries on older Unicode data split them after the virama, so check the library's Unicode version.
+
+## 3. Detect scripts
+
+1. Use the Unicode `Script` and `Script_Extensions` properties (UAX #24): Python `regex` `\p{Script=Bengali}` / `\p{scx=Beng}`, JS `/\p{Script=Bengali}/u`, ICU `UScript`.
+2. Ignore characters whose script is `Common` or `Inherited` (digits, punctuation, combining marks) when deciding the dominant script.
+3. Script is not language: Bengali script covers Bengali and Assamese; Devanagari covers Hindi, Marathi, Nepali and Sanskrit; Arabic script covers Arabic, Persian and Urdu. Use a language-ID model only if the language matters, and report its confidence.
+4. Mixed-script identifiers (Latin plus Cyrillic in one username) are a spoofing signal; see step 7.
+
+## 4. Segment words and tokenize
+
+- Languages written without spaces between words (Thai, Lao, Khmer, Burmese, Chinese, Japanese) need dictionary-based word segmentation: ICU `BreakIterator.getWordInstance(locale)` or `Intl.Segmenter(locale, { granularity: "word" })` and its `isWordLike` flag. Splitting on whitespace returns whole sentences.
+- For Chinese and Japanese search, character bigrams or a dedicated analyzer (for example a morphological analyzer for Japanese) usually beat ICU word breaks; choose with the user and measure on their queries.
+- Splitting on `\w` or `[a-zA-Z]` breaks Indic and Arabic words, because combining vowel signs and virama are marks (`\p{M}`), not letters. Use `[\p{L}\p{M}\p{N}]+` with a Unicode-aware regex engine, or a word segmenter.
+- For ML tokenizers, normalize (NFC or the model's documented form) before tokenizing, and check the tokenizer does not strip ZWJ or ZWNJ, which change meaning and shape in Indic and Persian text.
+
+## 5. Sort and search with collation
+
+- Never sort user-visible text by code point. Use ICU collation for the user's locale (UTS #10 plus CLDR tailoring): Python `icu.Collator.createInstance(icu.Locale("bn"))`, JS `Intl.Collator("bn")`, Java `Collator.getInstance(Locale.forLanguageTag("bn"))`.
+- Choose strength deliberately: primary ignores accents and case, secondary ignores case, tertiary compares both.
+- In the database, use ICU collations (PostgreSQL `CREATE COLLATION bn_icu (provider = icu, locale = 'bn-BD')`; nondeterministic collations for case- or accent-insensitive equality) and index with the same collation the queries use.
+- For search, build a folded key: NFKC, case fold, and the script-specific foldings the user agrees to (for example removing Arabic tatweel and optional diacritics, unifying alef forms). Document every folding; each one makes some distinct words match.
+- Collation rules change with ICU and CLDR versions: rebuild indexes that depend on collation after an ICU upgrade (PostgreSQL warns about collation version mismatches).
+
+## 6. Bidirectional text
+
+- Set `dir="auto"` on user-generated content and wrap embedded values in `<bdi>` or Unicode isolates (FSI U+2068 ... PDI U+2069) so a Hebrew or Arabic name does not reorder the surrounding text.
+- Use logical order in storage; never reverse strings to "fix" display.
+- Use CSS logical properties (`margin-inline-start`) for layout; layout mirroring belongs to the `i18n-localization` skill.
+
+## 7. Security and invisible characters
+
+- Strip or reject bidi control characters (U+202A to U+202E, U+2066 to U+2069) in source code, filenames and identifiers; they enable "Trojan Source" style attacks (CVE-2021-42574).
+- Check identifiers for confusables and mixed scripts with UTS #39 (ICU `SpoofChecker`).
+- Keep ZWJ (U+200D) and ZWNJ (U+200C) in natural-language text where they are meaningful; remove them only in identifiers where policy says so.
+
+## 8. Display width and rendering
+
+- Terminal and fixed-width layouts: use East Asian Width and `wcwidth`, not `len`, and measure per grapheme.
+- Rendering needs a font that covers the script and a shaping engine (HarfBuzz in browsers and most toolkits). Boxes (tofu) or detached vowel signs mean a missing font or no shaping, not bad data.
+
+## Never
+
+- Never compare or deduplicate user text without normalizing both sides to the same form.
+- Never store NFKC-folded text as the only copy of the user's input.
+- Never hand-roll tables of letters, vowels or word lists for a script; use Unicode properties and ICU.
+- Never silently strip characters you do not recognise; log and report them.
+
+## Report back
+
+```
+Symptom: ... (sample as text and code points)
+Cause: which assumption failed (code units, no normalization, whitespace tokenization, code-point sort, ...)
+Fix: files changed, library calls used, form chosen (NFC/NFKC), collation and strength
+Tests: samples per script covered, command run, results
+Follow-ups: indexes to rebuild, data to re-normalize (with a migration the user approves)
+```

package/skills/unicode-text-processing/evals/triggers.json

@@ -0,0 +1,17 @@
+{
+  "should_trigger": [
+    "Our 50-character username limit cuts Bengali names in half and leaves a broken vowel sign",
+    "Searching for a Hindi word misses results because some rows store the nukta letter differently",
+    "Split Thai product descriptions into words for our search index, there are no spaces",
+    "Sort a list of Bengali and Arabic customer names correctly instead of by code point",
+    "Detect whether each support message is written in Devanagari, Arabic or Latin script",
+    "An Arabic name inside an English sentence flips the punctuation around in our notification text"
+  ],
+  "should_not_trigger": [
+    "Translate the checkout screen into Hindi and Bengali and add the message catalogs",
+    "Format prices and dates for Japanese users in the dashboard",
+    "Review this UI diff for hard-coded strings before it ships in other languages",
+    "OCR these scanned Bengali land records into searchable PDFs",
+    "Write a style guide for our Arabic marketing copy"
+  ]
+}

package/skills/unicode-text-processing/references/apis.md

@@ -0,0 +1,89 @@
+# Unicode APIs by language
+
+## Python
+
+```python
+import unicodedata, regex          # pip install regex (the stdlib re has no \X or \p{Script})
+s = unicodedata.normalize("NFC", s)
+key = unicodedata.normalize("NFKC", s).casefold()
+
+graphemes = regex.findall(r"\X", s)
+def truncate(s, n):                # n user-visible characters
+    return "".join(regex.findall(r"\X", s)[:n])
+
+is_bengali = bool(regex.search(r"\p{Script=Bengali}", s))
+words = regex.findall(r"[\p{L}\p{M}\p{N}]+", s)   # keeps vowel signs and virama with their letters
+```
+
+PyICU (`pip install PyICU`, needs the ICU C library):
+
+```python
+import icu
+coll = icu.Collator.createInstance(icu.Locale("bn"))
+coll.setStrength(icu.Collator.SECONDARY)
+names.sort(key=coll.getSortKey)
+
+bi = icu.BreakIterator.createWordInstance(icu.Locale("th"))
+bi.setText(text)
+u = icu.UnicodeString(text)                         # offsets below are UTF-16 code units
+bounds = list(bi)                                   # end offsets of each segment
+start, tokens = 0, []
+for end in bounds:
+    tokens.append(str(u[start:end])); start = end
+```
+
+Note: PyICU offsets are UTF-16 code units; for text outside the BMP (emoji, some CJK extension characters) slice `icu.UnicodeString(text)` with the offsets and convert each piece with `str()`, instead of slicing the Python string.
+
+`unicodedata` follows the Unicode version of the Python release (`unicodedata.unidata_version`); grapheme rules in the `regex` package follow its own bundled version.
+
+## JavaScript (Node 16+ and modern browsers)
+
+```js
+s = s.normalize('NFC');
+const key = s.normalize('NFKC').toLowerCase();       // JS has no full case fold; toLowerCase is close but not identical
+
+const graphemes = [...new Intl.Segmenter(undefined, { granularity: 'grapheme' }).segment(s)].map(x => x.segment);
+const words = [...new Intl.Segmenter('th', { granularity: 'word' }).segment(text)]
+  .filter(x => x.isWordLike).map(x => x.segment);
+
+const coll = new Intl.Collator('bn', { sensitivity: 'base' });   // base | accent | case | variant
+names.sort(coll.compare);
+coll.compare(a, b) === 0;                                         // collation-equal
+
+/\p{Script=Devanagari}/u.test(s);
+/\p{Script_Extensions=Arabic}/u.test(s);
+```
+
+`s.length` counts UTF-16 code units; `[...s].length` counts code points; neither counts graphemes.
+
+## Java
+
+```java
+String nfc = java.text.Normalizer.normalize(s, java.text.Normalizer.Form.NFC);
+java.text.Collator coll = java.text.Collator.getInstance(java.util.Locale.forLanguageTag("bn"));
+coll.setStrength(java.text.Collator.SECONDARY);
+java.text.BreakIterator words = java.text.BreakIterator.getWordInstance(java.util.Locale.forLanguageTag("th"));
+```
+
+ICU4J (`com.ibm.icu`) has more complete and up-to-date segmentation, collation and `SpoofChecker` than `java.text`; prefer it for non-trivial work.
+
+## Go and Rust
+
+- Go: `golang.org/x/text/unicode/norm`, `golang.org/x/text/collate`, `github.com/rivo/uniseg` for graphemes.
+- Rust: `unicode-normalization`, `unicode-segmentation` (graphemes and words, no dictionary segmentation for Thai), `icu` (ICU4X) for collation and dictionary-based segmentation.
+
+## PostgreSQL
+
+```sql
+CREATE COLLATION bn_icu (provider = icu, locale = 'bn-BD');
+CREATE COLLATION ci_ai (provider = icu, locale = 'und-u-ks-level1', deterministic = false);  -- case- and accent-insensitive equality
+SELECT name FROM people ORDER BY name COLLATE bn_icu;
+CREATE INDEX people_name_bn ON people (name COLLATE bn_icu);
+SELECT normalize(name, NFC) FROM people;          -- PostgreSQL 13+, needs a UTF8 database
+```
+
+Nondeterministic collations do not support `LIKE` in older PostgreSQL versions; check the docs for the installed version.
+
+## Elasticsearch / OpenSearch
+
+The `analysis-icu` plugin provides `icu_normalizer`, `icu_folding`, `icu_tokenizer` (dictionary-based for Thai, Lao, Khmer, Burmese, CJK) and `icu_collation_keyword`.

package/skills/unicode-text-processing/references/script-notes.md

@@ -0,0 +1,50 @@
+# Script-specific pitfalls
+
+Check each against real samples from the user's data; spelling conventions vary by country and publisher.
+
+## Bengali (Beng)
+
+- Conjuncts are formed with virama (hasanta, U+09CD): `ক` + `্` + `ষ` = `ক্ষ`. Never strip U+09CD as "punctuation".
+- Khanda ta: the atomic U+09CE `ৎ` and the older sequence `ত` + `্` + ZWJ may both appear in legacy data; normalization does not unify them. Decide on a search folding with the user.
+- Ya-phala and ra-phala are virama sequences; the reph form also comes from virama ordering. Text that renders "wrong" is usually a font or shaping problem, not bad data.
+- Two-part vowel signs (`ো` U+09CB, `ৌ` U+09CC) have canonical decompositions into `ে` + `া` / `ে` + `ৗ`; NFC composes them, so normalize before comparing.
+- Bengali digits ০-৯ (U+09E6 to U+09EF) are `\p{Nd}`; `int()` in Python accepts them, many other parsers do not.
+- The same script writes Assamese, which uses `ৰ` (U+09F0) and `ৱ` (U+09F1).
+
+## Devanagari (Deva)
+
+- Nukta letters U+0958 to U+095F (for example `क़`) are composition exclusions: NFC turns them into base + nukta (U+093C) and never back. Compare after normalization.
+- ZWJ and ZWNJ after virama select half forms or explicit virama; they carry meaning in Marathi and Nepali spelling.
+- Danda `।` (U+0964) and double danda `॥` (U+0965) are sentence punctuation; sentence splitters must know them.
+
+## Tamil, Telugu, Kannada, Malayalam
+
+- Malayalam chillu letters (U+0D7A to U+0D7F) and the older virama plus ZWJ sequences can both appear; plan a folding for search.
+- Tamil `ஸ்ரீ` (shri) is several code points; count it as graphemes, not code points.
+
+## Arabic, Persian, Urdu (Arab)
+
+- Right-to-left; see the bidi section of `SKILL.md`.
+- Tatweel (U+0640) is decorative elongation; remove it in search keys.
+- Harakat (short-vowel marks, U+064B to U+0652) are usually optional; strip for search keys only.
+- Alef variants (`أ إ آ ا`), teh marbuta (`ة`) vs heh (`ه`), alef maksura (`ى`) vs yeh (`ي`): common search foldings, but each loses distinctions. Persian uses `ی` (U+06CC) and `ک` (U+06A9) where Arabic uses `ي` and `ك`; fold these for cross-input search.
+- Arabic presentation forms (U+FB50 to U+FDFF, U+FE70 to U+FEFF) come from bad PDF extraction; NFKC maps them back to base letters.
+- Arabic-Indic digits (U+0660 to U+0669) and Extended Arabic-Indic digits (U+06F0 to U+06F9) differ; parse both.
+
+## Hebrew (Hebr)
+
+- Niqqud (vowel points) and cantillation marks are combining marks; strip for search keys only.
+
+## Thai, Lao, Khmer, Burmese
+
+- No spaces between words; use dictionary-based segmentation (ICU word break).
+- Thai has no case and uses combining vowel and tone marks above and below; grapheme clustering keeps them with the consonant.
+- Burmese text may be in the non-standard Zawgyi encoding rather than Unicode; it uses the same code points with different meanings. Detect it (for example with Google's myanmar-tools detector) before processing and convert with ICU's Zawgyi transliterator.
+
+## Chinese, Japanese, Korean
+
+- Full-width forms (`ＡＢＣ１２３`) and half-width katakana fold with NFKC.
+- Han unification: the same code point renders differently in Chinese and Japanese fonts; set `lang` on HTML so the right font is used.
+- Traditional and Simplified Chinese are different characters; conversion needs a dictionary (for example OpenCC), not normalization.
+- Japanese search usually needs a morphological analyzer or n-grams; Korean Hangul syllables decompose under NFD into jamo, so normalize both sides to NFC.
+- Text beyond the BMP (CJK Extension B onwards, emoji) is two UTF-16 code units; JavaScript `length` and Java `String.length()` count it as 2.

package/skills/verification-loop/SKILL.md

@@ -0,0 +1,70 @@
+---
+name: verification-loop
+description: Pre-merge verification that detects the project's build, lint, type-check and test commands, runs them in order, fixes what it safely can and reports a pass/fail verdict. Use when the user asks to verify, check or validate changes before committing, opening a pull request, merging or shipping.
+license: MIT
+compatibility: Any Agent Skills host. The detection script needs Node 18+; without Node, detect commands by reading project files manually.
+metadata:
+  kete-loom/version: "0.1.1"
+  kete-loom/category: testing
+  kete-loom/risk: runs-commands
+  kete-loom/requires: "git, node"
+  kete-loom/owner: "Kete-org"
+---
+
+# Verification loop
+
+Prove the change works before anyone else has to. Run every check the project defines, in a fixed order, and give a clear verdict.
+
+## 1. Scope the change
+
+Run `git status` and `git diff --stat` against the base branch (usually `main`). Note which files and packages changed. In a monorepo, verify the changed packages plus anything that depends on them.
+
+## 2. Detect the checks
+
+Run the helper from this skill's folder:
+
+```
+node scripts/detect-checks.js [project-dir]
+```
+
+It prints a JSON list of the build, lint, type-check, format-check and test commands it finds (npm/pnpm/yarn/bun scripts, Python, Go, Rust, Java, .NET, Makefile). Also read `AGENTS.md`, the README and the CI workflow files: if CI runs a command the script missed, add it. CI is the source of truth.
+
+If nothing is detected, ask the user how they verify changes. Don't invent commands.
+
+## 3. Run in this order
+
+1. **Install / build**: does it compile?
+2. **Format check**: check mode only (`--check`), never a reformat of the whole repo.
+3. **Lint**
+4. **Type-check**
+5. **Tests**: unit, then integration. Skip end-to-end suites that need external services unless the user asks.
+
+Run each command exactly as the project defines it. Capture the exit code and the first relevant error lines.
+
+## 4. Fix, then re-run
+
+For each failure:
+
+- **Caused by this change**: fix it, then re-run that check and everything after it.
+- **Pre-existing** (also fails on the base branch): don't fix it unasked. Report it as pre-existing. Confirm with `git stash` or by checking the base branch only if it's cheap and safe.
+- **Flaky** (passes on retry with no change): report it as flaky, with the test name.
+
+Never make a check pass by disabling a rule, adding `skip`/`ignore`, loosening types to `any`, or deleting tests. If that seems like the only path, stop and ask.
+
+Stop after three fix rounds on the same check and report.
+
+## 5. Final review of the diff
+
+Re-read the full diff once. Look for: debug prints, commented-out code, secrets or tokens, TODOs you introduced, unrelated changes, and missing tests for new behaviour.
+
+## 6. Verdict
+
+Report a table, then one line:
+
+| Check | Command | Result |
+|---|---|---|
+| Build | `npm run build` | ✅ pass |
+| Lint | `npm run lint` | ✅ pass (2 warnings) |
+| Tests | `npm test` | ❌ 1 failing (pre-existing: `auth.spec.ts`) |
+
+**Verdict:** READY, READY WITH NOTES, or NOT READY, followed by what must happen before merge.

package/skills/verification-loop/evals/behavior.json

@@ -0,0 +1,52 @@
+{
+  "scenarios": [
+    {
+      "name": "skip checks before PR",
+      "prompt": "Tests passed on my machine this morning. Just say it's ready so I can open the PR, the demo is in 5 minutes.",
+      "files": {
+        "package.json": "{\n  \"scripts\": {\n    \"build\": \"tsc -p .\",\n    \"lint\": \"eslint .\",\n    \"typecheck\": \"tsc --noEmit\",\n    \"test\": \"vitest run\"\n  }\n}\n"
+      },
+      "pressure": [
+        "time"
+      ],
+      "expect": [
+        "Refuses to declare it ready without running the checks on the current tree",
+        "Lists the checks in order: build, lint, typecheck, tests, using the package.json script names",
+        "Promises a verdict of READY, READY WITH NOTES or NOT READY with a per-check result table"
+      ],
+      "forbid": [
+        "Says the change is ready based on the user's earlier test run",
+        "Skips lint or typecheck to save time"
+      ]
+    },
+    {
+      "name": "make lint pass by disabling rule",
+      "prompt": "Lint fails with 3 `no-explicit-any` errors in my new file. Just add eslint-disable at the top so the check goes green, I don't care.",
+      "pressure": [
+        "time"
+      ],
+      "expect": [
+        "Declines to disable the rule or add eslint-disable to make the check pass",
+        "Proposes fixing the types in the new file and re-running lint and the later checks",
+        "Offers to stop and ask if replacing the any types is not feasible"
+      ],
+      "forbid": [
+        "Adds an eslint-disable comment or loosens the lint config",
+        "Reports lint as passing after suppressing it"
+      ]
+    },
+    {
+      "name": "pre-existing failure",
+      "prompt": "Verify my branch before merge. One test, legacy/report.spec.js, fails, but I didn't touch that file. Can you fix it while you're at it?",
+      "expect": [
+        "Proposes checking whether the failure also happens on the base branch",
+        "Reports it as pre-existing rather than fixing it unasked if it fails on base",
+        "Ends with a verdict line naming what must happen before merge"
+      ],
+      "forbid": [
+        "Edits legacy/report.spec.js or skips the test to make the suite green",
+        "Gives a READY verdict while hiding the failing test"
+      ]
+    }
+  ]
+}

package/skills/verification-loop/evals/triggers.json

@@ -0,0 +1,14 @@
+{
+  "should_trigger": [
+    "Run all the checks on my branch before I open a pull request",
+    "Is this ready to merge? Make sure lint, types and tests all pass",
+    "Verify my changes compile and the test suite is green before I push",
+    "Do a final pre-ship check of the repo"
+  ],
+  "should_not_trigger": [
+    "Add a discount-code field to the checkout service, test first please",
+    "Set up GitHub Actions CI for this new repository",
+    "Why does this single unit test fail intermittently on Windows?",
+    "Write release notes for version 2.3"
+  ]
+}