arkaos 4.16.0 → 4.18.0

package/core/governance/harness_scanner_cli.py

@@ -0,0 +1,131 @@
+"""`npx arkaos shield` — the operator-facing surface of the harness scanner.
+
+Two roots matter and both are scanned by default: the user config
+(``~/.claude``) and the project the operator is standing in. Splitting
+them would be a footgun — the MCP servers that run with the agent's
+permissions usually live in the project's ``.mcp.json``, while the
+permissions themselves live in the user settings. A tool that reports a
+clean bill of health because it only looked at one of them is worse than
+no tool.
+
+Exit codes: 0 = grade A/B, 1 = grade C/D, 2 = grade F or a CRITICAL
+finding. CI can gate on it.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from core.governance.harness_scanner import (
+    PENALTY,
+    Finding,
+    ScanReport,
+    Severity,
+    scan,
+)
+
+_ICON = {
+    Severity.CRITICAL: "✗",
+    Severity.HIGH: "✗",
+    Severity.MEDIUM: "⚠",
+    Severity.LOW: "·",
+}
+
+
+def merge(reports: list[ScanReport]) -> ScanReport:
+    """One grade for the operator, not one per file they must add up."""
+    merged = ScanReport(root=reports[0].root if reports else Path("."))
+    for report in reports:
+        merged.files_scanned += report.files_scanned
+        for finding in report.findings:
+            merged.findings.append(_qualify(finding, report.root))
+    merged.findings.sort(key=lambda f: (-PENALTY[f.severity], f.rule))
+    return merged
+
+
+def _qualify(finding: Finding, root: Path) -> Finding:
+    """Name the root in `where` so two scans cannot be confused."""
+    return Finding(
+        rule=finding.rule,
+        severity=finding.severity,
+        where=f"{root}/{finding.where}",
+        detail=finding.detail,
+        fix=finding.fix,
+    )
+
+
+def _plural(count: int, noun: str) -> str:
+    return f"{count} {noun}" if count == 1 else f"{count} {noun}s"
+
+
+def render(report: ScanReport) -> str:
+    scanned = _plural(report.files_scanned, "config file")
+    lines = ["", f"  ArkaOS Shield — {scanned} scanned", ""]
+    if not report.findings:
+        lines += [f"  Grade {report.grade} ({report.score}/100) — nothing "
+                  f"to report.", ""]
+        return "\n".join(lines)
+    for severity in Severity:
+        found = report.by_severity(severity)
+        if not found:
+            continue
+        lines.append(f"  {severity.value.upper()}")
+        for finding in found:
+            lines.append(f"    {_ICON[severity]} {finding.rule}  "
+                         f"({finding.where})")
+            lines.append(f"      {finding.detail}")
+            lines.append(f"      fix: {finding.fix}")
+        lines.append("")
+    summary = _plural(len(report.findings), "finding")
+    lines += [f"  Grade {report.grade} ({report.score}/100) — {summary}.", ""]
+    return "\n".join(lines)
+
+
+def exit_code(report: ScanReport) -> int:
+    # grade already collapses to F on any CRITICAL, so the letter is the
+    # single source of the exit contract.
+    if report.grade == "F":
+        return 2
+    return 1 if report.grade in ("C", "D") else 0
+
+
+def _roots(args: argparse.Namespace) -> list[Path]:
+    if args.path:
+        return [Path(p).expanduser() for p in args.path]
+    return [Path.home() / ".claude", Path.cwd()]
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="arkaos shield",
+        description=(
+            "Scan the agent harness configuration for vulnerabilities: "
+            "over-permissive allow rules, secrets in config, hook command "
+            "injection, unpinned MCP servers, prompt injection in "
+            "instruction files."
+        ),
+        epilog="Exit: 0 = A/B, 1 = C/D, 2 = F or any CRITICAL finding.",
+    )
+    parser.add_argument(
+        "path", nargs="*",
+        help="Config roots to scan. Default: ~/.claude and the cwd.",
+    )
+    parser.add_argument(
+        "--json", action="store_true", dest="as_json",
+        help="Machine-readable output.",
+    )
+    args = parser.parse_args(argv)
+
+    report = merge([scan(root) for root in _roots(args) if root.is_dir()])
+    if args.as_json:
+        print(json.dumps(report.to_dict(), indent=2))
+    else:
+        print(render(report))
+    return exit_code(report)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/core/hooks/pre_tool_use.py

@@ -220,6 +220,61 @@ def _frontend_gate(
     return None
 
 
+# Config edits only ever land through file_path tools. NotebookEdit
+# addresses a notebook_path, never a linter config, so it is not in the
+# set — a notebook can never be a protected config file.
+_CONFIG_GATED_TOOLS = frozenset({"Write", "Edit", "MultiEdit"})
+
+
+def _operator_messages(transcript_path: str) -> list[str]:
+    """Recent OPERATOR messages, never the agent's own — reading the
+    assistant scope would let the guarded actor authorise itself."""
+    try:
+        from core.workflow.transcript_scope import user_messages_from_path
+        return user_messages_from_path(transcript_path)
+    except Exception:
+        return []  # unreadable → no override found → fail closed
+
+
+def _config_gate(
+    root: str,
+    tool_name: str,
+    transcript_path: str,
+    tool_input: dict,
+) -> int | None:
+    """Config-protection gate. Refuses edits to linter/formatter configs
+    so the agent fixes the code instead of weakening the check. Returns 2
+    on deny (hard mode), None to continue."""
+    if tool_name not in _CONFIG_GATED_TOOLS:
+        return None
+    if not (Path(root) / "core" / "workflow" / "config_guard.py").is_file():
+        return None
+    try:
+        from core.workflow.config_guard import (
+            evaluate,
+            is_protected_config,
+            mode,
+        )
+    except Exception:
+        return None  # config-guard-import-failed → allow (chain contract)
+    # Zero-read fast path: only a protected-config edit can ever be
+    # denied, and only then is the transcript read for an override.
+    file_path = str(tool_input.get("file_path", ""))
+    if not is_protected_config(file_path):
+        return None
+    guard_mode = mode()
+    if guard_mode == "off":
+        return None
+    decision = evaluate(file_path, _operator_messages(transcript_path))
+    if decision.allow:
+        return None
+    message = decision.to_stderr_message()
+    if guard_mode == "hard":
+        return _deny(message)
+    print(message, file=sys.stderr)  # warn: surface, do not block
+    return None
+
+
 def _budget_check(session_id: str) -> tuple[bool, str]:
     """CostGovernor gate (stdlib-only). Returns (allow, warning)."""
     try:
@@ -307,6 +362,10 @@ def main(stdin_json: dict | None = None) -> int:
     if code is not None:
         return code
 
+    code = _config_gate(root, tool_name, transcript_path, tool_input)
+    if code is not None:
+        return code
+
     # Fast allow: not a flow-gated tool (Bash stays — classified per-command
     # by the enforcer via bash_is_effect()).
     if tool_name not in _FLOW_GATED_TOOLS:

package/core/provenance.py

@@ -0,0 +1,108 @@
+"""Provenance — supply-chain lineage for any ArkaOS artifact.
+
+A skill, an agent, or anything else in the tree either originates in
+ArkaOS or is derived from someone else's work. Third-party lineage is a
+security property, not trivia: a tree with no origin field cannot be
+audited after the fact, and "which licence is this under?" becomes
+unanswerable the moment the author who ported it moves on.
+
+This module owns the artifact-agnostic core — the ``Provenance`` model
+and the block validator. The file-format parsers live with the artifact
+that uses them: ``core/skills/provenance.py`` reads a SKILL.md
+frontmatter block, ``core/agents/provenance.py`` reads an agent YAML
+key. Both funnel through ``provenance_from_block`` so the validation
+rules are defined once.
+
+Rules:
+
+- ``origin`` is a lowercase slug (``^[a-z][a-z0-9-]*$``). ``arkaos`` — or
+  no block at all — is first-party and needs nothing else.
+- Any other origin MUST declare ``source`` (an https URL) and
+  ``license``. https only: a licence trail that can be MITM'd is not a
+  trail.
+- ``arkaos`` carrying a source/licence is an unresolved contradiction and
+  is rejected — silence would let a bad port keep its upstream URL while
+  claiming to be ours.
+- A block present but incoherent (unknown keys, non-mapping) is an
+  ERROR, never a silent fallback to first-party.
+"""
+
+from __future__ import annotations
+
+import re
+
+from pydantic import BaseModel, Field, model_validator
+
+FIRST_PARTY = "arkaos"
+METADATA_FIELDS = ("origin", "source", "license")
+
+_ORIGIN_SLUG = re.compile(r"^[a-z][a-z0-9-]*$")
+_URL = re.compile(r"^https://\S+$")
+
+
+class ProvenanceError(ValueError):
+    """The provenance block is present but cannot be trusted."""
+
+
+class Provenance(BaseModel):
+    """Where an artifact came from, and under what licence."""
+
+    origin: str = Field(default=FIRST_PARTY)
+    source: str | None = None
+    license: str | None = None
+
+    @model_validator(mode="after")
+    def _derived_needs_a_trail(self) -> Provenance:
+        if not _ORIGIN_SLUG.match(self.origin):
+            raise ValueError(
+                f"origin {self.origin!r} is not a lowercase slug "
+                f"(^[a-z][a-z0-9-]*$)"
+            )
+        if self.origin == FIRST_PARTY:
+            return self._first_party_carries_no_trail()
+        missing = [f for f in ("source", "license") if not getattr(self, f)]
+        if missing:
+            raise ValueError(
+                f"origin {self.origin!r} is third-party — "
+                f"{', '.join(missing)} required"
+            )
+        if not _URL.match(self.source or ""):
+            raise ValueError(f"source {self.source!r} is not an https URL")
+        return self
+
+    def _first_party_carries_no_trail(self) -> Provenance:
+        """`arkaos` plus a source/licence is a contradiction.
+
+        Either the artifact is ours and there is nothing to attribute, or
+        it is not and the origin is wrong.
+        """
+        declared = [f for f in ("source", "license") if getattr(self, f)]
+        if declared:
+            raise ValueError(
+                f"origin {FIRST_PARTY!r} is first-party but declares "
+                f"{', '.join(declared)} — set a third-party origin or "
+                f"drop the field"
+            )
+        return self
+
+    @property
+    def is_first_party(self) -> bool:
+        return self.origin == FIRST_PARTY
+
+
+def provenance_from_block(block: dict | None) -> Provenance:
+    """Validate a metadata mapping into a ``Provenance``.
+
+    ``None`` (no block) is first-party. A block with keys outside
+    origin/source/license is an error — a misspelt field must not be
+    silently dropped into a first-party default.
+    """
+    if block is None:
+        return Provenance()
+    unknown = sorted(str(k) for k in block if k not in METADATA_FIELDS)
+    if unknown:
+        raise ProvenanceError(
+            f"unknown metadata keys: {', '.join(unknown)} "
+            f"(expected {', '.join(METADATA_FIELDS)})"
+        )
+    return Provenance(**block)

package/core/skills/__init__.py

@@ -0,0 +1,21 @@
+"""Skill-layer models and validators (provenance, schema)."""
+
+from core.skills.provenance import (
+    FIRST_PARTY,
+    METADATA_FIELDS,
+    ProvenanceError,
+    SkillProvenance,
+    declares_provenance,
+    parse_provenance,
+    provenance_issues,
+)
+
+__all__ = [
+    "FIRST_PARTY",
+    "METADATA_FIELDS",
+    "ProvenanceError",
+    "SkillProvenance",
+    "declares_provenance",
+    "parse_provenance",
+    "provenance_issues",
+]

package/core/skills/provenance.py

@@ -0,0 +1,157 @@
+"""Skill provenance — supply-chain lineage for every SKILL.md.
+
+A skill either originates in ArkaOS or it is derived from someone
+else's work. Third-party lineage is a security property, not trivia: a
+skill tree with no origin field cannot be audited after the fact, and
+"which licence is this under?" becomes unanswerable the moment the
+author who ported it moves on.
+
+Contract (opt-in, absence means first-party):
+
+    ---
+    name: dev/silent-failure-hunter
+    description: ...
+    allowed-tools: [Read, Grep, Glob]
+    metadata:
+      origin: ecc-derived
+      source: https://github.com/affaan-m/ecc
+      license: MIT
+    ---
+
+``origin`` is a lowercase slug (``^[a-z][a-z0-9-]*$``). ``arkaos`` — or
+no metadata block at all — is first-party and needs nothing else. ANY
+other origin MUST declare ``source`` (an https URL) and ``license``.
+
+**Fail closed.** A block that is present but unusable — unparseable
+YAML, a tab-indented body, ``metadata`` bound to a scalar, a misspelt
+key (``metadatas:``, ``orgin:``) — is an ERROR, never a silent fall
+back to first-party. Laundering a derived skill into ``arkaos`` by
+typo is the one failure this module exists to prevent.
+
+No parser can see the last vector: a port that simply never writes the
+block reads as first-party, and a typo net will always have a hole
+(``metdata:``, ``provenance:``, ``metadata: {}``). Omission is closed
+somewhere else — ``config/skills-provenance.yaml`` classifies every
+skill in the tree as baseline, derived, or self-declaring, and
+``tests/python/test_skill_provenance.py`` fails CI on any skill that is
+none of the three. A new skill must therefore say what it is. This
+module cannot enforce that and does not claim to.
+
+Consumed by ``scripts/skill_validator.py`` (per-skill score) and
+``scripts/marketplace_gen.py`` (``knowledge/skills-manifest.json``,
+which carries the full origin/source/licence triple, not just origin).
+
+The artifact-agnostic core — the model, the constants, the block
+validator — lives in ``core/provenance.py`` and is shared with agent
+provenance (``core/agents/provenance.py``). This module is only the
+SKILL.md-frontmatter reader. ``SkillProvenance`` is re-exported as an
+alias of the generic ``Provenance`` so existing imports keep working.
+"""
+
+from __future__ import annotations
+
+import re
+
+import yaml
+from pydantic import ValidationError
+
+from core.provenance import (
+    FIRST_PARTY,
+    METADATA_FIELDS,
+    Provenance,
+    ProvenanceError,
+    provenance_from_block,
+)
+
+# Back-compat alias: a skill's provenance is just Provenance.
+SkillProvenance = Provenance
+
+__all__ = [
+    "FIRST_PARTY",
+    "METADATA_FIELDS",
+    "Provenance",
+    "ProvenanceError",
+    "SkillProvenance",
+    "declares_provenance",
+    "parse_provenance",
+    "provenance_issues",
+]
+
+_FRONTMATTER = re.compile(r"^---\s*\n(.*?)\n---", re.DOTALL)
+# Near-misses for `metadata` — a typo must not read as "no block".
+_METADATA_TYPO = re.compile(r"^meta[-_ ]?datas?$", re.IGNORECASE)
+
+
+def _frontmatter(content: str) -> dict:
+    """The YAML frontmatter mapping. Raises when present but broken."""
+    match = _FRONTMATTER.match(content)
+    if not match:
+        return {}
+    try:
+        data = yaml.safe_load(match.group(1))
+    except yaml.YAMLError as exc:
+        detail = str(exc).replace("\n", " ")[:120]
+        raise ProvenanceError(
+            f"frontmatter YAML does not parse: {detail}"
+        ) from exc
+    if data is None:
+        return {}
+    if not isinstance(data, dict):
+        raise ProvenanceError("frontmatter is not a mapping")
+    return data
+
+
+def _metadata_block(frontmatter: dict) -> dict | None:
+    """The `metadata` mapping, or None when genuinely absent."""
+    if "metadata" in frontmatter:
+        block = frontmatter["metadata"]
+        if not isinstance(block, dict):
+            raise ProvenanceError(
+                "metadata must be a mapping of origin/source/license"
+            )
+        return block
+    typos = [
+        key for key in frontmatter
+        if isinstance(key, str) and _METADATA_TYPO.match(key)
+    ]
+    if typos:
+        raise ProvenanceError(
+            f"key {typos[0]!r} is not read — did you mean 'metadata'?"
+        )
+    return None
+
+
+def parse_provenance(content: str) -> SkillProvenance:
+    """Read a SKILL.md body. Absent metadata means first-party.
+
+    Raises ``ProvenanceError``/``ValidationError`` when the block is
+    present but incoherent — callers that must not raise use
+    ``provenance_issues`` instead.
+    """
+    return provenance_from_block(_metadata_block(_frontmatter(content)))
+
+
+def declares_provenance(content: str) -> bool:
+    """Did the author WRITE a block, or is this the default?
+
+    ``parse_provenance`` collapses "declared arkaos" and "said nothing"
+    into the same value — correct for reading, useless for the one
+    question the classification control has to answer.
+    """
+    try:
+        return _metadata_block(_frontmatter(content)) is not None
+    except ProvenanceError:
+        return True  # broken but attempted; provenance_issues owns it
+
+
+def provenance_issues(content: str) -> list[str]:
+    """Non-raising validation. Empty list means the skill is clean."""
+    try:
+        parse_provenance(content)
+    except ProvenanceError as exc:
+        return [str(exc)]
+    except ValidationError as exc:
+        return [
+            err["msg"].removeprefix("Value error, ") for err in exc.errors()
+        ]
+    return []

package/core/workflow/config_guard.py

@@ -0,0 +1,177 @@
+"""Config-protection gate — the agent fixes the code, not the linter.
+
+An agent that hits a lint or type error has two ways out: fix the code,
+or edit the config so the check stops firing. The second is faster and
+almost always wrong — it silences the signal for the whole team, not
+just this change. The ECC teardown found a hook for exactly this
+(`config-protection`), and it is the cheapest high-value control in the
+set: refuse edits to linter/formatter/type-checker configs, and the
+agent is left with the honest path.
+
+This is a PreToolUse gate. It denies a Write/Edit to a protected config
+file and tells the agent to fix the underlying code instead. Two escape
+hatches, because the rule is a heuristic and the operator is in charge:
+
+- ``ARKA_BYPASS_CONFIG_GUARD=1`` in the environment — a deliberate,
+  auditable override for the sessions where editing the config IS the
+  task (bumping a rule set, adopting a new formatter).
+- an explicit instruction in a recent USER message that names the config
+  file — if the operator asked for it, the agent is not sneaking around a
+  check, it is doing what it was told.
+
+The override reads the operator's messages, never the agent's. Reading
+the agent's own turns would invert the control: the guarded actor could
+authorise its own edit by naming the file, while the operator's real
+request went unseen. The user-message source is the whole point.
+
+Failure directions, chosen deliberately:
+- The GATE CHAIN degrades open on infrastructure failure (missing module,
+  import error) — a broken guard must not block all edits.
+- The OVERRIDE fails closed: when the operator's intent cannot be read
+  (no transcript, unreadable), the edit is treated as unauthorised and
+  denied in hard mode. The env bypass is the escape hatch that never
+  depends on the transcript, so a locked-out operator is never stuck.
+
+Feature-flagged off by default via ``hooks.configGuard`` (off | warn |
+hard) until telemetry says promote.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+from dataclasses import dataclass
+from pathlib import Path
+
+CONFIG_PATH = Path.home() / ".arkaos" / "config.json"
+
+# Config files whose whole purpose is to define a quality bar. Matched on
+# the basename, case-insensitively. A change here weakens the check for
+# everyone, so the agent must not reach for it to get unblocked.
+_PROTECTED_BASENAMES = frozenset({
+    # JS/TS linters & formatters
+    ".eslintrc", ".eslintrc.js", ".eslintrc.cjs", ".eslintrc.json",
+    ".eslintrc.yml", ".eslintrc.yaml", "eslint.config.js",
+    "eslint.config.mjs", "eslint.config.cjs", ".prettierrc",
+    ".prettierrc.json", ".prettierrc.js", ".prettierrc.yml",
+    ".prettierrc.yaml", "prettier.config.js", "biome.json", "biome.jsonc",
+    ".editorconfig",
+    # Python
+    "ruff.toml", ".ruff.toml", ".flake8", ".pylintrc", "mypy.ini",
+    ".mypy.ini", ".pre-commit-config.yaml",
+    # PHP / Ruby / Go / Rust
+    ".php-cs-fixer.php", ".php-cs-fixer.dist.php", "phpstan.neon",
+    "phpstan.neon.dist", "psalm.xml", ".rubocop.yml", ".golangci.yml",
+    ".golangci.yaml", "rustfmt.toml", ".rustfmt.toml", "clippy.toml",
+})
+# Files that CARRY tool config among other things — protect only the
+# lint/format/type sections conceptually, but at the file level we can
+# only warn, not know. These are NOT hard-denied (they hold real project
+# config too); they are left to the operator. Documented, not enforced:
+#   pyproject.toml, package.json, setup.cfg, tox.ini
+# The basename set above is deliberately the "config IS the check" tier.
+
+_ENV_BYPASS = "ARKA_BYPASS_CONFIG_GUARD"
+
+
+def mode() -> str:
+    """Resolve ``hooks.configGuard`` to 'off' | 'warn' | 'hard'.
+
+    Default 'warn': the gate observes and nudges but never blocks, so it
+    ships dark and earns 'hard' on telemetry (the frontend-gate and
+    specialist-gate rollout pattern). Unreadable config degrades to
+    'warn', never to 'hard' — a guard must not start blocking because a
+    file failed to parse.
+    """
+    if not CONFIG_PATH.exists():
+        return "warn"
+    try:
+        data = json.loads(CONFIG_PATH.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, OSError):
+        return "warn"
+    raw = data.get("hooks", {}).get("configGuard", "warn")
+    if raw in (False, "off", "false"):
+        return "off"
+    if raw in (True, "hard", "true"):
+        return "hard"
+    return "warn"
+
+
+@dataclass(frozen=True)
+class ConfigGuardDecision:
+    """Allow or deny, with the reason on record."""
+
+    allow: bool
+    reason: str = ""
+    file_path: str = ""
+
+    def to_stderr_message(self) -> str:
+        if self.allow:
+            return ""
+        return (
+            f"[arka:config-guard] Refusing to edit {self.file_path}. That "
+            f"file defines the quality bar; editing it to clear a lint, "
+            f"type, or format error silences the check for the whole team "
+            f"instead of fixing the code. Fix the underlying code.\n"
+            f"To lift this, the OPERATOR must name {self.file_path} in a "
+            f"message (an agent cannot authorise its own config edit), or "
+            f"set {_ENV_BYPASS}=1 in the environment."
+        )
+
+
+def is_protected_config(file_path: str) -> bool:
+    """Whether a path is a config file whose edit weakens a check."""
+    if not file_path:
+        return False
+    return Path(file_path).name.lower() in _PROTECTED_BASENAMES
+
+
+def _operator_named_file(
+    user_messages: list[str] | None, file_path: str
+) -> bool:
+    """Did the OPERATOR name this config file in a recent message?
+
+    The whole basename must appear as its own token. The trailing guard
+    blocks a sibling file — ``ruff.toml.bak``, ``ruff.toml~``,
+    ``ruff.toml-old`` must not authorise an edit to ``ruff.toml`` — while
+    still allowing a sentence-ending period (``edit ruff.toml.`` should
+    match): the negative lookahead fires on a dot/tilde/hyphen only when
+    it continues into a filename, not on end punctuation. Case-insensitive
+    to match ``is_protected_config``, which lowercases the basename.
+    """
+    if not user_messages or not file_path:
+        return False
+    name = re.escape(Path(file_path).name)
+    pattern = re.compile(
+        rf"(?<![\w.]){name}(?![\w])(?!\.\w)(?![~-])", re.IGNORECASE
+    )
+    return any(
+        pattern.search(m) for m in user_messages if isinstance(m, str)
+    )
+
+
+def evaluate(
+    file_path: str,
+    user_messages: list[str] | None = None,
+) -> ConfigGuardDecision:
+    """Decide whether to allow an edit to a protected config file.
+
+    Allows everything that is not a protected config; denies a protected
+    config edit unless the env bypass is set or the OPERATOR named the
+    file in a recent message. ``user_messages`` must be operator turns —
+    passing the agent's own messages inverts the control.
+    """
+    if not is_protected_config(file_path):
+        return ConfigGuardDecision(allow=True)
+    if os.environ.get(_ENV_BYPASS) == "1":
+        return ConfigGuardDecision(
+            allow=True, reason="env-bypass", file_path=file_path
+        )
+    if _operator_named_file(user_messages, file_path):
+        return ConfigGuardDecision(
+            allow=True, reason="operator-named-file", file_path=file_path
+        )
+    return ConfigGuardDecision(
+        allow=False, reason="protected-config", file_path=file_path
+    )