eq-layer 0.2.4__tar.gz → 0.2.5__tar.gz

eq_layer-0.2.5/.gitignore

@@ -0,0 +1,23 @@
+__pycache__/
+*.py[cod]
+.venv/
+venv/
+.env
+.npmrc
+.DS_Store
+.idea/
+.vscode/
+
+# Python test/build outputs
+.coverage
+coverage.xml
+htmlcov/
+dist/
+build/
+*.egg-info/
+.pytest_cache/
+
+# Retired release trigger files (publishing is dispatched explicitly; see
+# .github/workflows/create-release.yml and .github/workflows/publish-npm.yml)
+.npm-release-request
+.release-trigger

{eq_layer-0.2.4 → eq_layer-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: eq-layer
-Version: 0.2.4
+Version: 0.2.5
 Summary: Inspectable intent, affect, repair, uncertainty, and factored-action control for LLM responses
 Project-URL: Homepage, https://github.com/Furox-Art/eq-layer
 Project-URL: Repository, https://github.com/Furox-Art/eq-layer
@@ -112,12 +112,19 @@ paths and source documentation.
 
 ## Quick start
 
-Install the learned intent tracker:
+Install the Python runtime:
 
 ```bash
 pip install "eq-layer[ml]"
 ```
 
+Install the npm skill installer and CLI bridge (Node >= 22.14):
+
+```bash
+npm install -g eq-layer
+npx eq-layer --help
+```
+
 ```python
 from eq_layer import ConversationTracker, Selector, Steer, TrainedAffect, TrainedIntent, TrainedSubtext, compose_action
 
@@ -147,6 +154,18 @@ prompt = Steer.build(
 ).apply_to_prompt(messages[-1]["content"])
 ```
 
+The two `.joblib` files under `artifacts/` are **not shipped** in the
+repository, the PyPI wheel, or the npm tarball. Produce them with the training
+commands below (`tools/train_emobank_affect.py` and
+`tools/train_xdailydialog_subtext.py`) before running this block. Without those
+artifacts, use the zero-dependency route, which reports
+`"runtime_mode": "lightweight-local"` and needs no `.joblib` file:
+
+```bash
+printf '%s' '[{"role":"user","content":"devam et"}]' \
+  | python -m eq_layer.cli route --intent-mode heuristic --pretty
+```
+
 Run the seeded cases. Exits non-zero on any mismatch or any policy that no
 case can reach:
 
@@ -562,16 +581,20 @@ bridge). Each side keeps its version in exactly one canonical location, and the
 release workflows verify the GitHub release tag against those fields before
 uploading.
 
-npm publishing picks its credential mode at run time, based on repository
-settings only:
-
-- `NPM_TOKEN` configured: token mode, `npm publish --access public
-  --no-provenance`;
-- no `NPM_TOKEN`: trusted publishing over GitHub OIDC, `npm publish
-  --access public --provenance`.
-
-Provenance is an OIDC-only attestation, so it is only requested when no token is
-configured. See `docs/PUBLISHING.md` for the full flow.
+`.github/workflows/create-release.yml` is the release entry point: a push to
+`main` that changes `.release-request` creates the GitHub release when missing
+and explicitly dispatches both publishers (`release.yml` for PyPI and
+`publish-npm.yml` for npm). A release tag on its own does not publish npm;
+GitHub suppresses the `release` event for releases created with `GITHUB_TOKEN`,
+so the explicit dispatch is required.
+
+npm publishing uses trusted publishing over GitHub OIDC by default and requests
+a provenance attestation (`npm publish --access public --provenance`). The
+presence of an `NPM_TOKEN` secret does **not** change that: token mode runs only
+when a maintainer explicitly dispatches `publish-npm.yml` with
+`use_token_fallback=true`. That fallback publishes with
+`npm publish --access public --no-provenance`, because provenance is an
+OIDC-only attestation. See `docs/PUBLISHING.md` for the full flow.
 
 ## Contributing
 

{eq_layer-0.2.4 → eq_layer-0.2.5}/README.md

@@ -77,12 +77,19 @@ paths and source documentation.
 
 ## Quick start
 
-Install the learned intent tracker:
+Install the Python runtime:
 
 ```bash
 pip install "eq-layer[ml]"
 ```
 
+Install the npm skill installer and CLI bridge (Node >= 22.14):
+
+```bash
+npm install -g eq-layer
+npx eq-layer --help
+```
+
 ```python
 from eq_layer import ConversationTracker, Selector, Steer, TrainedAffect, TrainedIntent, TrainedSubtext, compose_action
 
@@ -112,6 +119,18 @@ prompt = Steer.build(
 ).apply_to_prompt(messages[-1]["content"])
 ```
 
+The two `.joblib` files under `artifacts/` are **not shipped** in the
+repository, the PyPI wheel, or the npm tarball. Produce them with the training
+commands below (`tools/train_emobank_affect.py` and
+`tools/train_xdailydialog_subtext.py`) before running this block. Without those
+artifacts, use the zero-dependency route, which reports
+`"runtime_mode": "lightweight-local"` and needs no `.joblib` file:
+
+```bash
+printf '%s' '[{"role":"user","content":"devam et"}]' \
+  | python -m eq_layer.cli route --intent-mode heuristic --pretty
+```
+
 Run the seeded cases. Exits non-zero on any mismatch or any policy that no
 case can reach:
 
@@ -527,16 +546,20 @@ bridge). Each side keeps its version in exactly one canonical location, and the
 release workflows verify the GitHub release tag against those fields before
 uploading.
 
-npm publishing picks its credential mode at run time, based on repository
-settings only:
-
-- `NPM_TOKEN` configured: token mode, `npm publish --access public
-  --no-provenance`;
-- no `NPM_TOKEN`: trusted publishing over GitHub OIDC, `npm publish
-  --access public --provenance`.
-
-Provenance is an OIDC-only attestation, so it is only requested when no token is
-configured. See `docs/PUBLISHING.md` for the full flow.
+`.github/workflows/create-release.yml` is the release entry point: a push to
+`main` that changes `.release-request` creates the GitHub release when missing
+and explicitly dispatches both publishers (`release.yml` for PyPI and
+`publish-npm.yml` for npm). A release tag on its own does not publish npm;
+GitHub suppresses the `release` event for releases created with `GITHUB_TOKEN`,
+so the explicit dispatch is required.
+
+npm publishing uses trusted publishing over GitHub OIDC by default and requests
+a provenance attestation (`npm publish --access public --provenance`). The
+presence of an `NPM_TOKEN` secret does **not** change that: token mode runs only
+when a maintainer explicitly dispatches `publish-npm.yml` with
+`use_token_fallback=true`. That fallback publishes with
+`npm publish --access public --no-provenance`, because provenance is an
+OIDC-only attestation. See `docs/PUBLISHING.md` for the full flow.
 
 ## Contributing
 

{eq_layer-0.2.4 → eq_layer-0.2.5}/eq_layer/__init__.py

@@ -7,7 +7,9 @@ from .intent import HeuristicIntent, IntentAdapter, IntentState
 from .intent_belief import IntentBelief, IntentRiskDecision, decide_intent_action, expected_loss
 from .interaction import InteractionQualityState, RepairState, infer_interaction_quality, infer_repair_state
 from .model_state import ModelStateError
-from .policies import POLICIES, REGISTRY, SUBTEXTS, AffectState, Policy, Register, Selector
+from . import policies as _policies
+from .policies import REGISTRY, SUBTEXTS, AffectState, Policy, Register, Selector
+
 from .preferences import SessionPreferences, infer_session_preferences
 from .response_experiment import (
     CommandModel,
@@ -22,6 +24,10 @@ from .trained_intent import TrainedIntent
 from .trained_subtext import DialogueSignals, SubtextDecision, TrainedSubtext
 from .tracker import AnnotationStanceResolver, ConversationTracker, StanceDecision, TrackingResult
 
+# Snapshot re-export: code that must observe runtime overrides reads
+# eq_layer.policies.POLICIES instead.
+POLICIES = _policies.POLICIES
+
 __all__ = [
     "__version__",
     "OptionalDependencyError",

{eq_layer-0.2.4 → eq_layer-0.2.5}/eq_layer/ab_eval.py

@@ -6,6 +6,7 @@ import random
 from dataclasses import dataclass
 from pathlib import Path
 
+from .json_contract import loads as strict_json_loads
 
 DIMENSIONS = (
     "intent_fidelity",
@@ -17,8 +18,20 @@ DIMENSIONS = (
 
 
 def load_jsonl(path: str | Path) -> list[dict]:
+    """Read human-evaluation artifacts without ambiguous JSON interpretation."""
+    rows: list[dict] = []
     with open(path, encoding="utf-8") as fh:
-        return [json.loads(line) for line in fh if line.strip()]
+        for lineno, line in enumerate(fh, start=1):
+            if not line.strip():
+                continue
+            try:
+                row = strict_json_loads(line)
+            except (ValueError, UnicodeError) as exc:
+                raise ValueError(f"{path}:{lineno}: invalid evaluation JSON: {exc}") from exc
+            if not isinstance(row, dict):
+                raise ValueError(f"{path}:{lineno}: evaluation row must be an object")
+            rows.append(row)
+    return rows
 
 
 def write_jsonl(path: str | Path, rows: list[dict]) -> None:
@@ -47,15 +60,25 @@ def prepare_blinded(
 
     seen: set[str] = set()
     for row in pairs:
-        case_id = str(row["id"])
+        case_id = row["id"]
+        if not isinstance(case_id, str) or not case_id.strip():
+            raise ValueError("A/B case id must be a non-empty string")
         if case_id in seen:
             raise ValueError(f"Duplicate A/B case id: {case_id}")
         seen.add(case_id)
 
-        baseline = str(row["baseline"])
-        eq_response = str(row["eq"])
-        if not baseline.strip() or not eq_response.strip():
-            raise ValueError(f"Empty response in A/B case: {case_id}")
+        baseline = row["baseline"]
+        eq_response = row["eq"]
+        if (
+            not isinstance(baseline, str)
+            or not isinstance(eq_response, str)
+            or not baseline.strip()
+            or not eq_response.strip()
+        ):
+            raise ValueError(f"A/B responses must be non-empty strings: {case_id}")
+        source = row.get("source") or {}
+        if not isinstance(source, dict):
+            raise ValueError(f"A/B case source must be an object: {case_id}")
 
         eq_is_a = bool(rng.getrandbits(1))
         response_a = eq_response if eq_is_a else baseline
@@ -67,7 +90,7 @@ def prepare_blinded(
         ballot.append(
             {
                 "id": case_id,
-                "stratum": (row.get("source") or {}).get("stratum"),
+                "stratum": source.get("stratum"),
                 "context": row.get("context", []),
                 "response_A": response_a,
                 "response_B": response_b,
@@ -89,7 +112,9 @@ class PreferenceSummary:
     exact_p_two_sided: float | None
 
 
-def _wilson_interval(successes: int, total: int, z: float = 1.959963984540054) -> tuple[float, float]:
+def _wilson_interval(
+    successes: int, total: int, z: float = 1.959963984540054
+) -> tuple[float, float]:
     if total <= 0:
         raise ValueError("Wilson interval requires total > 0.")
     p = successes / total
@@ -141,6 +166,20 @@ def summarize(wins: int, losses: int, ties: int) -> PreferenceSummary:
     )
 
 
+def _validate_decode_arms(case_id: str, key: dict) -> dict[str, str]:
+    """A blinded pair must decode to one EQ arm and one control arm."""
+    mapping = key.get(case_id)
+    if mapping is None:
+        raise ValueError(f"Missing decode key for case: {case_id}")
+    if (
+        not isinstance(mapping, dict)
+        or set(mapping) != {"A", "B"}
+        or {mapping["A"], mapping["B"]} != {"eq", "baseline"}
+    ):
+        raise ValueError(f"Invalid or non-blinded decode key for case: {case_id}")
+    return mapping
+
+
 def score_blinded(
     rated_ballot: list[dict],
     key: dict,
@@ -152,15 +191,17 @@ def score_blinded(
         for dimension in DIMENSIONS
     }
     excluded: list[str] = []
+    seen_ids: set[str] = set()
 
     for row in rated_ballot:
         case_id = str(row["id"])
+        if case_id in seen_ids:
+            raise ValueError(f"Duplicate case id in rated ballot: {case_id}")
+        seen_ids.add(case_id)
         if exclude_ids and case_id in exclude_ids:
             excluded.append(case_id)
             continue
-        if case_id not in key:
-            raise ValueError(f"Missing decode key for case: {case_id}")
-
+        arm_mapping = _validate_decode_arms(case_id, key)
         ratings = row.get("ratings") or {}
         for dimension in DIMENSIONS:
             vote = str(ratings.get(dimension, "")).strip().upper()
@@ -173,13 +214,12 @@ def score_blinded(
                 counts[dimension]["ties"] += 1
                 continue
 
-            winner = key[case_id][vote]
+            winner = arm_mapping[vote]
+            # _validate_decode_arms already proves the target is eq or baseline.
             if winner == "eq":
                 counts[dimension]["wins"] += 1
-            elif winner == "baseline":
-                counts[dimension]["losses"] += 1
             else:
-                raise ValueError(f"Invalid decode key target: {winner}")
+                counts[dimension]["losses"] += 1
 
     report = {
         "design": "blind-pairwise-human-evaluation",
@@ -204,8 +244,7 @@ def score_blinded(
 
 def _decoded_vote(row: dict, key: dict, dimension: str) -> str:
     case_id = str(row["id"])
-    if case_id not in key:
-        raise ValueError(f"Missing decode key for case: {case_id}")
+    arm_mapping = _validate_decode_arms(case_id, key)
     ratings = row.get("ratings") or {}
     vote = str(ratings.get(dimension, "")).strip().upper()
     if vote == "TIE":
@@ -214,10 +253,8 @@ def _decoded_vote(row: dict, key: dict, dimension: str) -> str:
         raise ValueError(
             f"{case_id}/{dimension}: expected A, B, or tie; got {vote!r}"
         )
-    winner = key[case_id][vote]
-    if winner not in {"eq", "baseline"}:
-        raise ValueError(f"Invalid decode key target: {winner}")
-    return winner
+    # _validate_decode_arms has already rejected every other mapping target.
+    return arm_mapping[vote]
 
 
 def _fleiss_kappa(case_votes: list[list[str]]) -> float | None:
@@ -275,6 +312,8 @@ def score_multiple_blinded(
         rows_by_rater[rater_id] = mapping
 
     assert case_ids is not None
+    if not case_ids:
+        raise ValueError("Multi-rater scoring requires at least one rated case.")
     report = {
         "design": "blind-pairwise-multi-rater-human-evaluation",
         "n_raters": len(rated_ballots),

{eq_layer-0.2.4 → eq_layer-0.2.5}/eq_layer/affect.py

@@ -1,9 +1,10 @@
 from __future__ import annotations
 
-import json
+from collections.abc import Iterable
 from dataclasses import dataclass
-from typing import Iterable, Protocol
+from typing import Protocol
 
+from .json_contract import loads as strict_json_loads
 from .policies import AffectState
 
 
@@ -15,7 +16,8 @@ class AffectAdapter(Protocol):
         messages: list[dict],
         turn_index: int = 0,
         annotated: dict | None = None,
-    ) -> AffectState: ...
+    ) -> AffectState:
+        pass  # pragma: no cover - Protocol stub
 
 
 # --- detectors -----------------------------------------------------------
@@ -148,7 +150,6 @@ class HeuristicAffect:
         has_prior_assistant: bool = False,
     ) -> str:
         current = user_turns[-1] if user_turns else ""
-        low = current.lower()
 
         if has_prior_assistant and self._has(current, CORRECTION_MARKERS):
             return "correction"
@@ -227,5 +228,16 @@ class HeuristicAffect:
 
 
 def load_cases(path: str) -> list[dict]:
+    cases: list[dict] = []
     with open(path, encoding="utf-8") as fh:
-        return [json.loads(line) for line in fh if line.strip()]
+        for lineno, line in enumerate(fh, start=1):
+            if not line.strip():
+                continue
+            try:
+                case = strict_json_loads(line)
+            except (ValueError, UnicodeError) as exc:
+                raise ValueError(f"{path}:{lineno}: invalid JSON case: {exc}") from exc
+            if not isinstance(case, dict):
+                raise ValueError(f"{path}:{lineno}: JSON case must be an object")
+            cases.append(case)
+    return cases

{eq_layer-0.2.4 → eq_layer-0.2.5}/eq_layer/cli.py

@@ -8,10 +8,11 @@ import sys
 from dataclasses import asdict
 
 from ._deps import ML_INSTALL_COMMAND, OptionalDependencyError, ml_extra_available
+from .json_contract import loads as strict_json_loads
 
 
 def _load_messages(raw: str) -> list[dict]:
-    payload = json.loads(raw)
+    payload = strict_json_loads(raw)
     if isinstance(payload, dict):
         payload = payload.get("messages")
     if not isinstance(payload, list) or not payload:
@@ -20,12 +21,18 @@ def _load_messages(raw: str) -> list[dict]:
     for index, item in enumerate(payload):
         if not isinstance(item, dict):
             raise ValueError(f"message {index} must be an object")
-        role = str(item.get("role") or "")
-        content = str(item.get("content") or "")
-        if role not in {"user", "assistant", "system"}:
+        role = item.get("role")
+        content = item.get("content")
+        if not isinstance(role, str) or role not in {"user", "assistant", "system"}:
             raise ValueError(f"message {index} has unsupported role {role!r}")
+        if not isinstance(content, str):
+            raise ValueError(f"message {index} content must be a string")
         if not content.strip():
             raise ValueError(f"message {index} has empty content")
+        try:
+            content.encode("utf-8")
+        except UnicodeError as exc:
+            raise ValueError(f"message {index} content must be valid UTF-8") from exc
         messages.append({"role": role, "content": content})
     if not any(message["role"] == "user" for message in messages):
         raise ValueError("Transcript must contain at least one user turn.")
@@ -179,8 +186,9 @@ def main(argv: list[str] | None = None) -> int:
         print(f"{parser.prog}: error: {exc}", file=sys.stderr)
         return 2
     except (ValueError, json.JSONDecodeError, ImportError) as exc:
+        # ArgumentParser.error terminates with SystemExit(2).
         parser.error(str(exc))
-    return 2
+        return 2  # pragma: no cover - parser.error raises SystemExit
 
 
 if __name__ == "__main__":

{eq_layer-0.2.4 → eq_layer-0.2.5}/eq_layer/intent.py

@@ -27,7 +27,8 @@ class IntentState:
 class IntentAdapter(Protocol):
     name: str
 
-    def infer(self, messages: list[dict]) -> IntentState: ...
+    def infer(self, messages: list[dict]) -> IntentState:
+        pass  # pragma: no cover - Protocol stub
 
 
 ACTION_MARKERS = (

eq_layer-0.2.5/eq_layer/json_contract.py

@@ -0,0 +1,41 @@
+"""Unambiguous finite UTF-8 JSON for externally supplied transcripts and cases."""
+
+from __future__ import annotations
+
+import json
+import math
+from typing import Any
+
+
+def _unique_keys(pairs: list[tuple[str, Any]]) -> dict[str, Any]:
+    output: dict[str, Any] = {}
+    for key, value in pairs:
+        if key in output:
+            raise ValueError("duplicate JSON object key")
+        output[key] = value
+    return output
+
+
+def _finite_float(value: str) -> float:
+    number = float(value)
+    if not math.isfinite(number):
+        raise ValueError("non-finite JSON number")
+    return number
+
+
+def _reject_constant(value: str) -> None:
+    raise ValueError(f"non-standard JSON constant: {value}")
+
+
+def loads(text: str) -> Any:
+    data = json.loads(
+        text,
+        object_pairs_hook=_unique_keys,
+        parse_float=_finite_float,
+        parse_constant=_reject_constant,
+    )
+    try:
+        json.dumps(data, ensure_ascii=False, allow_nan=False).encode("utf-8")
+    except UnicodeError as exc:
+        raise ValueError("JSON text must contain valid UTF-8") from exc
+    return data

{eq_layer-0.2.4 → eq_layer-0.2.5}/eq_layer/model_state.py

@@ -21,8 +21,6 @@ from typing import Any
 # estimator, so its concrete type is deliberately not pinned here.
 FITTED = object()
 
-_FLOAT_TYPES = (int, float)
-
 
 class ModelStateError(ValueError):
     """A persisted model artifact failed schema validation at load time."""

{eq_layer-0.2.4 → eq_layer-0.2.5}/eq_layer/preferences.py

@@ -5,7 +5,6 @@ from dataclasses import asdict, dataclass, replace
 
 from .textnorm import normalise_light as _normalise
 
-
 SESSION_SCOPE_PATTERNS = (
     r"\bbundan sonra\b",
     r"\bbu sohbet(?:te| boyunca)\b",
@@ -51,8 +50,7 @@ def _session_scoped(text: str) -> bool:
     if any(re.search(pattern, low) for pattern in SESSION_SCOPE_PATTERNS):
         return True
     return bool(
-        STRONG_TURKISH_STYLE_PATTERN.search(low)
-        or STRONG_ENGLISH_STYLE_PATTERN.search(low)
+        STRONG_TURKISH_STYLE_PATTERN.search(low) or STRONG_ENGLISH_STYLE_PATTERN.search(low)
     )
 
 
@@ -60,7 +58,7 @@ def _updates(text: str) -> dict:
     low = _normalise(text)
     updates: dict[str, object] = {}
 
-    if re.search(r"\b(kısa|öz|brief|concise)\b", low):
+    if re.search(r"\b(kısa|öz|brief|briefly|concise)\b", low):
         updates["verbosity"] = "low"
     if re.search(r"\b(detaylı|ayrıntılı|detailed)\b|\bin detail\b", low):
         updates["verbosity"] = "high"
@@ -68,12 +66,7 @@ def _updates(text: str) -> dict:
     if re.search(r"\b(net|direkt|doğrudan|direct)\b|\bstraight to the point\b", low):
         updates["directness"] = "high"
 
-    if (
-        "tahmin etme" in low
-        or "uydurma" in low
-        or "don't guess" in low
-        or "do not guess" in low
-    ):
+    if "tahmin etme" in low or "uydurma" in low or "don't guess" in low or "do not guess" in low:
         updates["no_guess"] = True
 
     if (

{eq_layer-0.2.4 → eq_layer-0.2.5}/eq_layer/response_experiment.py

@@ -19,8 +19,6 @@ from .trained_affect import TrainedAffect
 from .trained_intent import TrainedIntent
 from .trained_subtext import TrainedSubtext
 
-
-
 LEAKAGE_FIELDS = {
     "expected_policy",
     "expected_intent",
@@ -49,19 +47,23 @@ def _force_kill(process: subprocess.Popen) -> None:
     try:
         process.terminate()
     except OSError:
+        # The child may already have been reaped by the OS.
         pass
     try:
         process.wait(timeout=5)
         return
     except subprocess.TimeoutExpired:
+        # Ignored the graceful signal; escalate to kill below.
         pass
     try:
         process.kill()
     except OSError:
+        # The child exited between the timeout and the kill.
         pass
     try:
         process.wait(timeout=5)
     except subprocess.TimeoutExpired:
+        # Last-resort wait; nothing further can be done without a block.
         pass
 
 
@@ -162,17 +164,16 @@ def select_stratified_cases(cases: list[dict], limit: int) -> list[dict]:
             deficit += quotas[stratum] - available
             quotas[stratum] = available
 
+    # target <= len(cases), and quota sums to target. Therefore when a
+    # deficit exists, at least one stratum has spare capacity; an exhausted
+    # full pass is mathematically impossible for valid inputs.
     while deficit > 0:
-        progressed = False
         for stratum in strata:
             if quotas[stratum] < len(groups[stratum]):
                 quotas[stratum] += 1
                 deficit -= 1
-                progressed = True
                 if deficit == 0:
                     break
-        if not progressed:
-            break
 
     selected: list[dict] = []
     max_quota = max(quotas.values(), default=0)
@@ -360,7 +361,7 @@ class CommandModel:
 
     @staticmethod
     def _decode_response(raw: str) -> str:
-        if not raw:
+        if not raw.strip():
             raise RuntimeError("Model command returned an empty response.")
 
         try:

{eq_layer-0.2.4 → eq_layer-0.2.5}/eq_layer/tracker.py

@@ -30,7 +30,8 @@ class StanceResolver(Protocol):
         self,
         messages: list[dict],
         annotated: dict | None = None,
-    ) -> StanceDecision: ...
+    ) -> StanceDecision:
+        pass  # pragma: no cover - Protocol stub
 
 
 @dataclass

{eq_layer-0.2.4 → eq_layer-0.2.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "eq-layer"
-version = "0.2.4"
+version = "0.2.5"
 description = "Inspectable intent, affect, repair, uncertainty, and factored-action control for LLM responses"
 readme = "README.md"
 license = { text = "MIT" }

eq_layer-0.2.4/.gitignore

@@ -1,9 +0,0 @@
-__pycache__/
-*.py[cod]
-.venv/
-venv/
-.env
-.npmrc
-.DS_Store
-.idea/
-.vscode/