arkaos 4.10.0 → 4.12.0

package/core/hooks/user_prompt_submit.py

@@ -102,6 +102,26 @@ _VAGUE_PHRASES = (
     "esse ficheiro", "esse erro", "aquele bug",
 )
 
+# A prompt is CONCRETE (never refine-worthy) when it names a real
+# target: a file (foo.py, README.md, path/to/x), a CamelCase or
+# snake_case code identifier (AuthService, user_repo), or a backticked
+# term. Kills the "no files → +20 constant" false positives the scorer
+# alone can't distinguish (QG 2026-07-09).
+# NOTE: NOT case-insensitive — the CamelCase alternation depends on real
+# case (IGNORECASE would match any two-syllable lowercase word like
+# "melhor" and defeat the whole carve-out).
+_CONCRETE_TARGET_RE = re.compile(
+    r"[\w./-]+\.[A-Za-z]{1,5}\b"        # file with a real extension
+    r"|[\w-]+/[\w./-]+"                 # path segments (a/b/c)
+    r"|\b[A-Z][a-z0-9]+[A-Z]\w+\b"      # CamelCase identifier
+    r"|\b[a-z]+_[a-z0-9_]+\b"           # snake_case identifier
+    r"|`[^`]+`"                         # backticked term
+)
+
+
+def _names_concrete_target(text: str) -> bool:
+    return bool(_CONCRETE_TARGET_RE.search(text or ""))
+
 
 # ─── Sections 1-2: migration + sync detection ────────────────────────────
 
@@ -573,9 +593,56 @@ def main(stdin_json: dict | None = None, raw: str = "") -> int:
     )
 
     workflow_directive = ""
+    refine_hint = ""
     if user_input and _wf_classify(user_input):
         _wf_mark_required(session_id)
         workflow_directive = _WORKFLOW_DIRECTIVE
+        # Interaction Reform PR5 — a vague code-modifying request is a
+        # signal to refine the prompt (ask about the topic) BEFORE the
+        # workflow. SUGGESTION only; /do decides. Not a slash command.
+        # Calibration (QG 2026-07-09): the scorer's +20 "no files" branch
+        # is a constant in the hook context (the hook never has files), so
+        # 70 is the floor for ANY short prompt. Two guards keep clear asks
+        # out — a higher threshold (85, above that constant) AND a
+        # concrete-target carve-out: a prompt that names a file or a code
+        # identifier ("fix the typo in README.md", "add a test to
+        # AuthService") is specific, never refine-worthy.
+        if (
+            not user_input.strip().startswith("/")
+            and not _names_concrete_target(user_input)
+        ):
+            try:
+                from core.forge.complexity import score_prompt_ambiguity
+                score = score_prompt_ambiguity(user_input)
+                if score >= 85:
+                    refine_hint = (
+                        f"[arka:refine-suggested] score={score}/100 — the "
+                        f"request may be vague; consider /arka refine to ask "
+                        f"about the topic and compile a precise prompt "
+                        f"before building."
+                    )
+            except Exception:
+                pass
+
+    # Interaction Reform PR3 — when the previous turn ended at Gate 2
+    # (plan on the table), classify THIS message as approval/rejection.
+    # UserPromptSubmit runs before the turn's tool calls, so the token
+    # is visible to the PreToolUse enforcer with no marker-invisibility
+    # problem. Never blocks the hook.
+    try:
+        from core.workflow import plan_approval
+        if session_id and user_input and plan_approval.is_presented(session_id):
+            verdict = plan_approval.classify_reply(
+                user_input, has_creation_verb=_wf_classify(user_input)
+            )
+            if verdict == "approve":
+                plan_approval.mark_approved(
+                    session_id, source="text", excerpt=user_input
+                )
+            elif verdict == "reject":
+                plan_approval.mark_rejected(session_id)
+    except Exception:
+        pass
 
     context_hits = _cognitive_hits(session_id)
 
@@ -591,6 +658,8 @@ def main(stdin_json: dict | None = None, raw: str = "") -> int:
     )
     if hygiene:
         out = f"{out} {hygiene}"
+    if refine_hint:
+        out = f"{out}\n{refine_hint}"
     for nudge in (kb_cite_nudge, meta_tag_nudge, closing_marker_nudge):
         if nudge:
             out = f"{out}\n{nudge}"

package/core/knowledge/recipes.py

@@ -0,0 +1,237 @@
+"""Validated feature recipes (Interaction Reform PR7).
+
+A Recipe is the missing artifact between the Pattern Library (short text
+hints) and scaffold (whole generic starter repos): a QG-APPROVED feature
+implementation captured with its reference files so the same feature —
+"Laravel login the ArkaOS-approved way" — is reused across projects
+instead of re-derived from documentation every time.
+
+Layout on disk (``~/.arkaos/recipes/<slug>/``):
+    recipe.json   # structured metadata (source of truth for retrieval)
+    RECIPE.md     # narrative: problem, approach, decisions, how to apply
+    files/        # SANITIZED reference files (exemplary feature code)
+
+Confidentiality is NON-NEGOTIABLE (v2.18.0 npm leak precedent): capture
+runs every text field and every reference file through
+``core.evals.sanitizer.sanitize_text`` BEFORE writing. No redaction
+config → ``SanitizerConfigMissing`` → capture REFUSED. There is no write
+path that skips sanitization, and ``sanitized`` must be True to persist.
+
+Admission: only a verdict of APPROVED with a timestamp that ties back to
+``~/.arkaos/telemetry/qg-verdicts.jsonl`` promotes a deliverable to a
+recipe, and capture is always operator-confirmed (the QG skill proposes
+it; it never fires silently).
+"""
+
+from __future__ import annotations
+
+import os
+import shutil
+from pathlib import Path
+from typing import Literal
+
+from pydantic import BaseModel, Field, field_validator
+
+from core.evals.sanitizer import sanitize_text
+from core.governance.leak_scanner import load_redaction_patterns
+from core.shared.safe_session_id import safe_session_id
+
+MAX_FILES = 20
+MAX_TOTAL_BYTES = 200 * 1024
+
+
+def _recipes_root() -> Path:
+    override = os.environ.get("ARKA_RECIPES_DIR", "").strip()
+    return Path(override) if override else Path.home() / ".arkaos" / "recipes"
+
+
+class RecipeProvenance(BaseModel):
+    """Where a recipe came from — all fields already sanitized."""
+
+    source_project: str = Field(description="Origin project ([CLIENT-N] if client)")
+    qg_verdict: Literal["APPROVED"]
+    qg_verdict_ts: str = Field(description="Ties to qg-verdicts.jsonl")
+    captured_at: str
+    department: str = ""
+
+
+class Recipe(BaseModel):
+    """A reusable, QG-approved feature implementation."""
+
+    slug: str
+    name: str
+    problem: str = Field(min_length=10)
+    stack: list[str] = Field(min_length=1)
+    feature_keywords: list[str] = Field(min_length=1)
+    files: list[str] = Field(default_factory=list)
+    acceptance_criteria: list[str] = Field(default_factory=list)
+    apply_notes: str = ""
+    provenance: RecipeProvenance
+    sanitized: bool = False
+
+    @field_validator("slug")
+    @classmethod
+    def _slug_is_path_safe(cls, value: str) -> str:
+        if safe_session_id(value) != value:
+            raise ValueError(
+                f"unsafe recipe slug {value!r} — must be a path-safe token"
+            )
+        return value
+
+    @field_validator("files")
+    @classmethod
+    def _within_file_cap(cls, value: list[str]) -> list[str]:
+        if len(value) > MAX_FILES:
+            raise ValueError(
+                f"recipe has {len(value)} files, cap is {MAX_FILES}"
+            )
+        return value
+
+
+class RecipeCaptureRefused(RuntimeError):
+    """Capture cannot proceed safely (unsanitized, oversize, bad verdict)."""
+
+
+def _recipe_dir(slug: str) -> Path:
+    return _recipes_root() / slug
+
+
+def _redaction_patterns(config_path: Path | None) -> tuple[str, ...]:
+    """Lowercased client patterns for substring filename screening."""
+    return tuple(p.lower() for p in load_redaction_patterns(config_path))
+
+
+def _is_safe_relpath(rel_path: str) -> bool:
+    """Reject absolute paths, '..' escapes, backslashes, and leading dots.
+
+    Reference files live strictly under ``files/`` (CWE-22 guard). They
+    cannot collide with the recipe's own metadata because they are
+    written into the ``files/`` subdirectory, never the recipe root.
+    """
+    if not rel_path or rel_path.startswith(("/", ".")) or "\\" in rel_path:
+        return False
+    if Path(rel_path).is_absolute():
+        return False
+    return all(part not in ("..", "") for part in Path(rel_path).parts)
+
+
+def capture_recipe(
+    recipe: Recipe,
+    narrative: str,
+    reference_files: dict[str, str],
+    config_path: Path | None = None,
+) -> Path:
+    """Sanitize everything, then persist a recipe. Fail-closed.
+
+    ``reference_files`` maps a relative path under ``files/`` to its raw
+    content. Every text field, the narrative, and each file are run
+    through the sanitizer first; ``SanitizerConfigMissing`` propagates
+    (capture refused). Raises ``RecipeCaptureRefused`` on oversize input
+    or a non-APPROVED verdict.
+    """
+    if recipe.provenance.qg_verdict != "APPROVED":
+        raise RecipeCaptureRefused("only APPROVED deliverables become recipes")
+    if len(reference_files) > MAX_FILES:
+        raise RecipeCaptureRefused(
+            f"{len(reference_files)} files exceeds the {MAX_FILES} cap"
+        )
+    total = sum(len(c.encode("utf-8")) for c in reference_files.values())
+    if total > MAX_TOTAL_BYTES:
+        raise RecipeCaptureRefused(
+            f"reference files total {total} B exceeds {MAX_TOTAL_BYTES} B"
+        )
+    def _clean(text: str) -> str:
+        return sanitize_text(text, config_path=config_path)[0]
+
+    patterns = _redaction_patterns(config_path)
+    for rel_path in reference_files:
+        if not _is_safe_relpath(rel_path):
+            raise RecipeCaptureRefused(
+                f"unsafe reference path {rel_path!r} — must stay under files/"
+            )
+        # A filename can carry a client identifier that reaches both
+        # recipe.json and the on-disk path. Filenames are not free text
+        # to rewrite, so REFUSE rather than mangle. The word-bounded
+        # sanitizer misses a name GLUED into a CamelCase filename
+        # (GlobexAuthService.php), so check the redaction patterns as
+        # plain case-insensitive substrings here (confidentiality is
+        # NON-NEGOTIABLE, QG 2026-07-09).
+        lowered = rel_path.lower()
+        if any(p in lowered for p in patterns):
+            raise RecipeCaptureRefused(
+                f"reference filename {rel_path!r} carries a client "
+                f"identifier — rename it before capture"
+            )
+
+    clean_narrative = _clean(narrative)
+    clean_files = {
+        rel_path: _clean(content)
+        for rel_path, content in reference_files.items()
+    }
+
+    # EVERY free-text field that reaches recipe.json must be sanitized.
+    # The model_copy update dict is the single sanitize gate — if a new
+    # free-text field is added to Recipe, add it here or it leaks
+    # (confidentiality is NON-NEGOTIABLE).
+    clean_provenance = recipe.provenance.model_copy(update={
+        "source_project": _clean(recipe.provenance.source_project),
+        "department": _clean(recipe.provenance.department),
+    })
+    stored = recipe.model_copy(update={
+        "name": _clean(recipe.name),
+        "problem": _clean(recipe.problem),
+        "stack": [_clean(s) for s in recipe.stack],
+        "feature_keywords": [_clean(k) for k in recipe.feature_keywords],
+        "acceptance_criteria": [_clean(c) for c in recipe.acceptance_criteria],
+        "apply_notes": _clean(recipe.apply_notes),
+        "files": sorted(clean_files.keys()),
+        "provenance": clean_provenance,
+        "sanitized": True,
+    })
+
+    target = _recipe_dir(stored.slug)
+    (target / "files").mkdir(parents=True, exist_ok=True)
+    (target / "recipe.json").write_text(
+        stored.model_dump_json(indent=2) + "\n", encoding="utf-8"
+    )
+    (target / "RECIPE.md").write_text(clean_narrative + "\n", encoding="utf-8")
+    for rel_path, content in clean_files.items():
+        dest = target / "files" / rel_path
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        dest.write_text(content, encoding="utf-8")
+    return target
+
+
+def load_recipe(slug: str) -> Recipe | None:
+    if safe_session_id(slug) != slug:
+        return None
+    path = _recipe_dir(slug) / "recipe.json"
+    if not path.exists():
+        return None
+    try:
+        return Recipe.model_validate_json(path.read_text(encoding="utf-8"))
+    except Exception:  # noqa: BLE001 — corrupt recipe is simply skipped
+        return None
+
+
+def list_recipes() -> list[Recipe]:
+    root = _recipes_root()
+    if not root.exists():
+        return []
+    out: list[Recipe] = []
+    for entry in sorted(root.iterdir()):
+        if entry.is_dir():
+            recipe = load_recipe(entry.name)
+            if recipe is not None:
+                out.append(recipe)
+    return out
+
+
+def delete_recipe(slug: str) -> bool:
+    if safe_session_id(slug) != slug:
+        return False
+    target = _recipe_dir(slug)
+    if not target.exists():
+        return False
+    shutil.rmtree(target)
+    return True

package/core/knowledge/recipes_cli.py

@@ -0,0 +1,99 @@
+"""Recipe capture/list/show CLI (Interaction Reform PR7).
+
+The QG skill (step 7) proposes promoting an APPROVED reusable feature
+to a recipe; on operator confirmation it calls `capture` here. Capture
+is fail-closed: no redaction config → refused (SanitizerConfigMissing),
+because a client identifier reaching the recipe corpus is the exact
+confidentiality breach the sanitizer exists to prevent.
+
+Usage:
+    arka-py -m core.knowledge.recipes_cli capture --spec <recipe.json>
+    arka-py -m core.knowledge.recipes_cli list
+    arka-py -m core.knowledge.recipes_cli show <slug>
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from pydantic import ValidationError
+
+from core.evals.sanitizer import SanitizerConfigMissing
+from core.knowledge.recipes import (
+    Recipe,
+    RecipeCaptureRefused,
+    capture_recipe,
+    list_recipes,
+    load_recipe,
+)
+
+
+def _cmd_capture(args: argparse.Namespace) -> int:
+    """Capture from a spec JSON: {recipe, narrative, files:{path:content}}."""
+    raw = (
+        Path(args.spec).read_text(encoding="utf-8")
+        if args.spec
+        else sys.stdin.read()
+    )
+    try:
+        payload = json.loads(raw)
+        recipe = Recipe.model_validate(payload["recipe"])
+    except (json.JSONDecodeError, KeyError, ValidationError) as exc:
+        print(f"error: invalid recipe spec — {exc}", file=sys.stderr)
+        return 1
+    try:
+        target = capture_recipe(
+            recipe,
+            narrative=payload.get("narrative", ""),
+            reference_files=payload.get("files", {}),
+        )
+    except SanitizerConfigMissing as exc:
+        print(f"error: capture refused — {exc}", file=sys.stderr)
+        return 2
+    except RecipeCaptureRefused as exc:
+        print(f"error: capture refused — {exc}", file=sys.stderr)
+        return 3
+    print(json.dumps({"captured": True, "slug": recipe.slug,
+                      "path": str(target)}))
+    return 0
+
+
+def _cmd_list(_args: argparse.Namespace) -> int:
+    recipes = list_recipes()
+    for recipe in recipes:
+        print(f"{recipe.slug:30s} {', '.join(recipe.stack):20s} {recipe.name}")
+    print(f"\n{len(recipes)} recipe(s)")
+    return 0
+
+
+def _cmd_show(args: argparse.Namespace) -> int:
+    recipe = load_recipe(args.slug)
+    if recipe is None:
+        print(f"error: no recipe {args.slug!r}", file=sys.stderr)
+        return 1
+    print(recipe.model_dump_json(indent=2))
+    return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    sub = parser.add_subparsers(dest="cmd", required=True)
+    p_capture = sub.add_parser("capture")
+    p_capture.add_argument("--spec", help="spec JSON file (default: stdin)")
+    sub.add_parser("list")
+    p_show = sub.add_parser("show")
+    p_show.add_argument("slug")
+    args = parser.parse_args(argv)
+
+    return {
+        "capture": _cmd_capture,
+        "list": _cmd_list,
+        "show": _cmd_show,
+    }[args.cmd](args)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/core/shared/safe_session_id.py

@@ -21,15 +21,21 @@ import re
 
 
 SAFE_SESSION_ID_RE = re.compile(r"^[A-Za-z0-9._-]{1,128}$")
+# A token made ONLY of dots ("." / ".." / "...") passes the char
+# allowlist but is a filesystem traversal/self-reference — it must
+# reject (QG 2026-07-09: `safe_session_id('..') == '..'` would let a
+# future `recipes delete ..` rmtree ~/.arkaos).
+_DOT_ONLY_RE = re.compile(r"^\.+$")
 
 
 def safe_session_id(session_id: str) -> str | None:
     """Validate ``session_id`` against the strict allowlist.
 
     Returns the id unchanged when safe, or ``None`` when it contains
-    path separators, ``..`` traversal fragments, whitespace, unicode,
-    NUL bytes, or any character outside ``[A-Za-z0-9._-]``. Length is
-    capped at 128 characters to prevent pathological filesystem paths.
+    path separators, ``..`` traversal fragments, a dot-only token,
+    whitespace, unicode, NUL bytes, or any character outside
+    ``[A-Za-z0-9._-]``. Length is capped at 128 characters to prevent
+    pathological filesystem paths.
 
     Callers MUST treat ``None`` as reject — never construct a path or
     shell argument from the raw input when this returns ``None``.
@@ -38,4 +44,6 @@ def safe_session_id(session_id: str) -> str | None:
         return None
     if not SAFE_SESSION_ID_RE.match(session_id):
         return None
+    if _DOT_ONLY_RE.match(session_id):
+        return None
     return session_id

package/core/synapse/engine.py

@@ -204,6 +204,7 @@ def create_default_engine(
     from core.synapse.agent_experiences_layer import AgentExperiencesLayer
     from core.synapse.graph_context_layer import GraphContextLayer
     from core.synapse.pattern_library_layer import PatternLibraryLayer
+    from core.synapse.recipe_layer import RecipeLayer
 
     engine = SynapseEngine()
 
@@ -245,6 +246,11 @@ def create_default_engine(
     # specs and dispatched specialists start from prior art rather than
     # reinventing.
     engine.register_layer(PatternLibraryLayer())
+    # L7.6 (Interaction Reform PR8) — validated Recipe injection.
+    # Sibling of L7.5: surfaces QG-approved prior BUILDS (reference files
+    # on disk) when the prompt matches, so the build loop reuses proven
+    # work. Inert when no recipes are captured.
+    engine.register_layer(RecipeLayer())
     engine.register_layer(SessionContextLayer())
 
     return engine

package/core/synapse/pattern_library_layer.py

@@ -42,8 +42,12 @@ _STOPWORDS: frozenset[str] = frozenset({
 })
 
 
-def _extract_keywords(text: str, max_n: int = 10) -> list[str]:
-    """Return the first `max_n` distinct meaningful words from `text`."""
+def extract_keywords(text: str, max_n: int = 10) -> list[str]:
+    """Return the first `max_n` distinct meaningful words from `text`.
+
+    Public: shared by L7.5 (patterns) and L7.6 (recipes) — a single
+    extractor keeps the two prior-art layers matching on the same tokens.
+    """
     seen: list[str] = []
     seen_set: set[str] = set()
     for word in _WORD_RE.findall(text or ""):
@@ -57,6 +61,10 @@ def _extract_keywords(text: str, max_n: int = 10) -> list[str]:
     return seen
 
 
+# Back-compat alias (was private before Interaction Reform PR8).
+_extract_keywords = extract_keywords
+
+
 class PatternLibraryLayer(Layer):
     """L7.5 — surface prior implementations matching the user prompt."""
 

package/core/synapse/recipe_layer.py

@@ -0,0 +1,114 @@
+"""Synapse layer L7.6 — validated Recipe injection (Interaction Reform PR8).
+
+Sibling of L7.5 (Pattern Library): where a PatternCard is a short text
+hint, a Recipe points at QG-approved reference files on disk that can be
+adapted. When the prompt's keywords overlap a captured recipe, this
+layer surfaces the top matches as `[recipes:N]` so the orchestrator
+starts from "we have a validated build of this" — the `/arka refine` →
+build loop reuses proven work instead of re-deriving it.
+
+Keyword extraction is shared with L7.5 (imported, not duplicated).
+Matching is keyword-overlap on the recipe's feature_keywords + stack for
+v1; semantic ranking is a follow-up.
+"""
+
+from __future__ import annotations
+
+import time
+
+from core.knowledge.recipes import Recipe, list_recipes
+from core.synapse.layers import Layer, LayerResult, PromptContext
+from core.synapse.pattern_library_layer import extract_keywords
+
+
+class RecipeLayer(Layer):
+    """L7.6 — surface validated recipes matching the user prompt."""
+
+    def __init__(self, limit: int = 3) -> None:
+        self._limit = limit
+
+    @property
+    def id(self) -> str:
+        return "L7.6"
+
+    @property
+    def name(self) -> str:
+        return "Recipes"
+
+    @property
+    def input_sensitive(self) -> bool:
+        return True
+
+    @property
+    def cache_ttl(self) -> int:
+        return 60
+
+    @property
+    def priority(self) -> int:
+        # 76 — right after L7.5 Pattern Library (75), before L8 Forge (80),
+        # so both prior-art sources reach Forge's plan synthesis.
+        return 76
+
+    def compute(self, ctx: PromptContext) -> LayerResult:
+        start = time.time()
+        keywords = extract_keywords(ctx.user_input)
+        if not keywords:
+            return self._empty(start)
+        matches = _match_recipes(keywords, self._limit)
+        if not matches:
+            return self._empty(start, tag="[recipes:none]")
+        content = format_recipes(matches)
+        return LayerResult(
+            layer_id=self.id,
+            tag=f"[recipes:{len(matches)}]",
+            content=content,
+            tokens_est=max(1, len(content) // 4),
+            compute_ms=int((time.time() - start) * 1000),
+            cached=False,
+        )
+
+    def _empty(self, start: float, tag: str = "") -> LayerResult:
+        return LayerResult(
+            layer_id=self.id,
+            tag=tag,
+            content="",
+            tokens_est=0,
+            compute_ms=int((time.time() - start) * 1000),
+            cached=False,
+        )
+
+
+def _match_recipes(keywords: list[str], limit: int) -> list[Recipe]:
+    """Rank recipes by keyword overlap with feature_keywords + stack."""
+    kw = set(keywords)
+    scored: list[tuple[int, Recipe]] = []
+    for recipe in list_recipes():
+        haystack = {
+            w.lower()
+            for w in (recipe.feature_keywords + recipe.stack)
+        }
+        overlap = len(kw & haystack)
+        if overlap:
+            scored.append((overlap, recipe))
+    scored.sort(key=lambda pair: (-pair[0], pair[1].slug))
+    return [recipe for _, recipe in scored[:limit]]
+
+
+def format_recipes(recipes: list[Recipe]) -> str:
+    """Compact, model-readable summary pointing at the on-disk files."""
+    lines = [
+        "Validated recipes found (QG-approved prior builds — read "
+        "RECIPE.md + files/ and adapt via the normal flow, never "
+        "copy-paste blind):"
+    ]
+    for i, r in enumerate(recipes, start=1):
+        head = f"  {i}. {r.name} (~/.arkaos/recipes/{r.slug}/)"
+        if r.stack:
+            head += f" — stack: {', '.join(r.stack[:4])}"
+        lines.append(head)
+        lines.append(f"     {r.problem}")
+        if r.files:
+            lines.append(f"     files/: {', '.join(r.files[:4])}")
+        if r.apply_notes:
+            lines.append(f"     adapt: {r.apply_notes}")
+    return "\n".join(lines)

package/core/sync/mcp_optimizer.py

@@ -81,7 +81,10 @@ def _do_optimize(
 
     return mcp_result.model_copy(update={
         "final_mcp_list": sorted(active),
-        "mcps_deferred": sorted(deferred),
+        # Merge, never replace: the syncer defers entries whose
+        # requires_binary is absent (never written to .mcp.json) and
+        # that skip must survive into the report (PR6).
+        "mcps_deferred": sorted(deferred | set(mcp_result.mcps_deferred)),
         "optimizer_warnings": warnings,
     })