From 9e7359fb16c1bd6e8e052be600d84ada10ceea97 Mon Sep 17 00:00:00 2001 From: Seongho Bae Date: Sat, 12 Sep 2026 17:39:15 +0900 Subject: [PATCH 01/11] test(effort): carry complete authority regressions onto protected main Successor preparation for #1119 without inheriting or retiring #1000. Retain the three existing regression blobs and the two-line legacy-test correction; add protected-main nullable-output preservation cases. Complete main source 7f8fedd9ca5ea07282bf122bac82471cc8f3b176 yields 67 failed / 22 passed on the four standalone modules. This is local scoped RED, not hosted or whole-repository evidence. --- tests/test_effort_capability_evidence.py | 148 ++++++++++++++++++++++ tests/test_effort_main_output_contract.py | 52 ++++++++ tests/test_effort_omission_contract.py | 95 ++++++++++++++ tests/test_effort_promotion_authority.py | 64 ++++++++++ tests/test_reasoning_effort_profile.py | 5 +- 5 files changed, 362 insertions(+), 2 deletions(-) create mode 100644 tests/test_effort_capability_evidence.py create mode 100644 tests/test_effort_main_output_contract.py create mode 100644 tests/test_effort_omission_contract.py create mode 100644 tests/test_effort_promotion_authority.py diff --git a/tests/test_effort_capability_evidence.py b/tests/test_effort_capability_evidence.py new file mode 100644 index 000000000..ca40abf2f --- /dev/null +++ b/tests/test_effort_capability_evidence.py @@ -0,0 +1,148 @@ +"""Native effort requires literal boolean capability evidence, never truthiness.""" +from __future__ import annotations + +from copy import deepcopy +import importlib.util +from pathlib import Path +from types import ModuleType +import sys + +import pytest + + +@pytest.fixture +def effort_api(monkeypatch: pytest.MonkeyPatch) -> ModuleType: + """Load the exact production leaf without unrelated package initialization.""" + source_path = ( + Path(__file__).resolve().parents[1] + / "contextual_orchestrator/reasoning_effort_profile.py" + ) + module_spec = importlib.util.spec_from_file_location("effort_capability_subject", source_path) + assert module_spec is not None and module_spec.loader is not None + source_module = importlib.util.module_from_spec(module_spec) + monkeypatch.setitem(sys.modules, module_spec.name, source_module) + module_spec.loader.exec_module(source_module) + return source_module + + +class HostileCapability: + """Capability data must not execute truth, equality or rendering hooks.""" + + def __bool__(self) -> bool: + """Expose accidental truth-value coercion.""" + raise AssertionError("capability truth hook executed") + + def __eq__(self, other: object) -> bool: + """Expose equality-to-True admission instead of type validation.""" + raise AssertionError("capability equality hook executed") + + def __repr__(self) -> str: + """Expose accidental logging of caller-controlled capability data.""" + raise AssertionError("capability rendering hook executed") + + +def explicit_profile(effort_api: ModuleType, fallback_name: str) -> object: + """Provide an explicit test-only configuration, not a recommended budget.""" + return effort_api.parse_reasoning_effort_profile({ + "profile_version": effort_api.PROFILE_VERSION, + "reasoning_effort": "low", + "max_output_tokens": 321, + "max_calls": 1, + "max_workflow_steps": 1, + "max_recursion_depth": 0, + "max_worker_fan_out": 1, + "access_list_scope": "none", + "deadline_ms": 0, + "cost_token_budget": 642, + "temperature": 0.3, + "top_p": 0.8, + "seed": 11, + "unsupported_provider_fallback": fallback_name, + }) + + +@pytest.mark.parametrize("fallback_name", ["abstain", "error", "omit"]) +@pytest.mark.parametrize("capability_evidence", [ + pytest.param("false", id="string-false"), + pytest.param("true", id="string-true"), + pytest.param("", id="empty-string"), + pytest.param("unknown", id="unknown-string"), + pytest.param(1, id="integer-one"), + pytest.param(0, id="integer-zero"), + pytest.param(-1, id="negative-integer"), + pytest.param(1.0, id="float-one"), + pytest.param(0.0, id="float-zero"), + pytest.param(float("nan"), id="nan"), + pytest.param(float("inf"), id="infinity"), + pytest.param([], id="empty-array"), + pytest.param([True], id="nonempty-array"), + pytest.param({}, id="empty-object"), + pytest.param({"supported": True}, id="nonempty-object"), + pytest.param(HostileCapability(), id="hostile-hooks"), +]) +def test_invalid_capability_is_rejected_before_mutation( + effort_api: ModuleType, capability_evidence: object, fallback_name: str, +) -> None: + """Neither truthy nor falsy malformed evidence can select a fallback or effort.""" + request_body = { + "model": "selected_worker", "reasoning_effort": "high", "max_tokens": 17, + "messages": [{"role": "user", "content": "unit test request"}], + "tools": [{"type": "function", "function": {"name": "read_source"}}], + "stream": True, "temperature": 0.7, "seed": 3, + } + original_body = deepcopy(request_body) + with pytest.raises(effort_api.EffortProfileError, match="must be a boolean or null"): + effort_api.apply_request_profile( + request_body, explicit_profile(effort_api, fallback_name), + supports_reasoning_effort=capability_evidence, default_max_output_tokens=99, + ) + assert request_body == original_body + + +@pytest.mark.parametrize("capability_evidence", [False, None]) +@pytest.mark.parametrize("fallback_name", ["abstain", "error"]) +def test_unproven_capability_does_not_authorize_native_effort( + effort_api: ModuleType, capability_evidence: bool | None, fallback_name: str, +) -> None: + """False and unknown retain the explicit fail-closed fallback without mutation.""" + request_body = {"reasoning_effort": "high", "max_tokens": 17} + with pytest.raises(effort_api.EffortProfileError, match="support is unproven"): + effort_api.apply_request_profile( + request_body, explicit_profile(effort_api, fallback_name), + supports_reasoning_effort=capability_evidence, default_max_output_tokens=99, + ) + assert request_body == {"reasoning_effort": "high", "max_tokens": 17} + + +@pytest.mark.parametrize("capability_evidence", [False, None]) +def test_explicit_omit_removes_effort_for_unproven_capability( + effort_api: ModuleType, capability_evidence: bool | None, +) -> None: + """Unknown support cannot retain effort populated for a previous capability.""" + request_body = {"reasoning_effort": "high", "model": "selected_worker", "stream": True} + result_body = effort_api.apply_request_profile( + request_body, explicit_profile(effort_api, "omit"), + supports_reasoning_effort=capability_evidence, default_max_output_tokens=99, + ) + assert result_body is request_body + assert result_body == { + "model": "selected_worker", "stream": True, "max_tokens": 321, + "temperature": 0.3, "top_p": 0.8, "seed": 11, + } + + +@pytest.mark.parametrize("fallback_name", ["abstain", "error", "omit"]) +def test_literal_true_preserves_explicit_native_effort( + effort_api: ModuleType, fallback_name: str, +) -> None: + """Positive capability evidence forwards only the explicitly supplied profile.""" + request_body = {"model": "selected_worker", "stream": True} + result_body = effort_api.apply_request_profile( + request_body, explicit_profile(effort_api, fallback_name), + supports_reasoning_effort=True, default_max_output_tokens=99, + ) + assert result_body is request_body + assert result_body == { + "model": "selected_worker", "stream": True, "reasoning_effort": "low", + "max_tokens": 321, "temperature": 0.3, "top_p": 0.8, "seed": 11, + } diff --git a/tests/test_effort_main_output_contract.py b/tests/test_effort_main_output_contract.py new file mode 100644 index 000000000..48c1218d6 --- /dev/null +++ b/tests/test_effort_main_output_contract.py @@ -0,0 +1,52 @@ +"""Preserve protected-main output omission while integrating effort repairs.""" +from types import ModuleType + +import pytest + +from test_effort_capability_evidence import effort_api as effort_api +from test_effort_capability_evidence import explicit_profile + + +@pytest.mark.parametrize("capability_evidence", [True, False, None]) +def test_unknown_output_ceiling_does_not_create_a_token_limit( + effort_api: ModuleType, capability_evidence: bool | None, +) -> None: + """An unconfigured profile cannot impose a ceiling absent from the request.""" + request_body = {"model": "selected_worker", "stream": True} + result_body = effort_api.apply_request_profile( + request_body, None, supports_reasoning_effort=capability_evidence, + default_max_output_tokens=None, + ) + assert result_body is request_body + assert result_body == {"model": "selected_worker", "stream": True} + + +def test_unknown_output_ceiling_preserves_explicit_request_limit(effort_api: ModuleType) -> None: + """No-profile compatibility retains a caller-supplied limit without replacement.""" + request_body = {"max_tokens": 17, "model": "selected_worker"} + effort_api.apply_request_profile( + request_body, None, supports_reasoning_effort=False, default_max_output_tokens=None, + ) + assert request_body == {"max_tokens": 17, "model": "selected_worker"} + + +def test_explicit_profile_does_not_require_a_default_output_ceiling(effort_api: ModuleType) -> None: + """A supported explicit test profile keeps its own validated output setting.""" + request_body = {} + effort_api.apply_request_profile( + request_body, explicit_profile(effort_api, "abstain"), + supports_reasoning_effort=True, default_max_output_tokens=None, + ) + assert request_body["max_tokens"] == 321 + assert request_body["reasoning_effort"] == "low" + + +def test_omission_with_unknown_output_ceiling_removes_stale_effort(effort_api: ModuleType) -> None: + """Unknown ceiling does not undo the independently validated omission repair.""" + request_body = {"reasoning_effort": "high"} + effort_api.apply_request_profile( + request_body, explicit_profile(effort_api, "omit"), + supports_reasoning_effort=None, default_max_output_tokens=None, + ) + assert "reasoning_effort" not in request_body + assert request_body["max_tokens"] == 321 diff --git a/tests/test_effort_omission_contract.py b/tests/test_effort_omission_contract.py new file mode 100644 index 000000000..f3f99a594 --- /dev/null +++ b/tests/test_effort_omission_contract.py @@ -0,0 +1,95 @@ +"""A capability downgrade must remove a previously populated effort field.""" +from __future__ import annotations + +from copy import deepcopy +import importlib.util +from pathlib import Path +import sys + +import pytest + + +@pytest.fixture +def api(): + source = Path(__file__).resolve().parents[1] / 'contextual_orchestrator/reasoning_effort_profile.py' + spec = importlib.util.spec_from_file_location('effort_omission_subject', source) + module = importlib.util.module_from_spec(spec) + sys.modules[spec.name] = module + spec.loader.exec_module(module) + return module + + +@pytest.mark.parametrize('previous_value', ['high', 'low', None, {'effort': 'high'}]) +def test_explicit_omit_removes_existing_native_effort(api, previous_value): + payload = {'model': 'selected_worker', 'reasoning_effort': previous_value, + 'messages': [{'role': 'user', 'content': 'review source'}], + 'tools': [{'type': 'function', 'function': {'name': 'read_source'}}], + 'stream': True} + retained_fields = deepcopy({key: value for key, value in payload.items() if key != 'reasoning_effort'}) + profile = api.parse_reasoning_effort_profile({ + 'reasoning_effort': 'high', 'unsupported_provider_fallback': 'omit', + 'max_output_tokens': 321, 'temperature': 0.3, 'top_p': 0.8, 'seed': 11, + }) + result = api.apply_request_profile(payload, profile, supports_reasoning_effort=False, + default_max_output_tokens=999) + assert 'reasoning_effort' not in result + assert result is payload + assert all(result[key] == value for key, value in retained_fields.items()) + assert (result['max_tokens'], result['temperature'], result['top_p'], result['seed']) == (321, 0.3, 0.8, 11) + + +def test_supported_then_unsupported_payload_obeys_omission(api): + profile = api.parse_reasoning_effort_profile({'reasoning_effort': 'high', + 'unsupported_provider_fallback': 'omit'}) + payload = {'model': 'selected_worker', 'stream': False} + api.apply_request_profile(payload, profile, supports_reasoning_effort=True, + default_max_output_tokens=99) + assert payload['reasoning_effort'] == 'high' + api.apply_request_profile(payload, profile, supports_reasoning_effort=False, + default_max_output_tokens=99) + assert 'reasoning_effort' not in payload + + +@pytest.mark.parametrize('fallback', ['abstain', 'error']) +def test_non_omission_fallback_remains_fail_closed_without_mutation(api, fallback): + payload = {'model': 'selected_worker', 'reasoning_effort': 'high', 'temperature': 0.7} + original = deepcopy(payload) + profile = api.parse_reasoning_effort_profile({'unsupported_provider_fallback': fallback}) + with pytest.raises(api.EffortProfileError, match='support is unproven'): + api.apply_request_profile(payload, profile, supports_reasoning_effort=False, + default_max_output_tokens=99) + assert payload == original + + +@pytest.mark.parametrize('effort', ['none', 'low', 'medium', 'high']) +def test_supported_native_effort_is_still_forwarded(api, effort): + profile = api.parse_reasoning_effort_profile({'reasoning_effort': effort}) + result = api.apply_request_profile({'reasoning_effort': 'previous'}, profile, + supports_reasoning_effort=True, default_max_output_tokens=99) + assert result['reasoning_effort'] == effort + + +def test_empty_payload_omit_is_idempotent(api): + profile = api.parse_reasoning_effort_profile({'unsupported_provider_fallback': 'omit'}) + payload = {} + first = api.apply_request_profile(payload, profile, supports_reasoning_effort=False, + default_max_output_tokens=99).copy() + assert api.apply_request_profile(payload, profile, supports_reasoning_effort=False, + default_max_output_tokens=99) == first + assert 'reasoning_effort' not in payload + + +def test_unconfigured_profile_keeps_compatibility_behavior(api): + payload = {'reasoning_effort': 'caller_owned'} + assert api.apply_request_profile(payload, None, supports_reasoning_effort=False, + default_max_output_tokens=99) == { + 'reasoning_effort': 'caller_owned', 'max_tokens': 99, + } + + +def test_invalid_profile_is_rejected_before_payload_changes(api): + payload = {'reasoning_effort': 'previous'} + with pytest.raises(api.EffortProfileError): + api.apply_request_profile(payload, object(), supports_reasoning_effort=False, + default_max_output_tokens=99) + assert payload == {'reasoning_effort': 'previous'} diff --git a/tests/test_effort_promotion_authority.py b/tests/test_effort_promotion_authority.py new file mode 100644 index 000000000..c815feae9 --- /dev/null +++ b/tests/test_effort_promotion_authority.py @@ -0,0 +1,64 @@ +"""Caller-controlled diagnostics cannot authorize a learned-policy deployment.""" +from __future__ import annotations + +import importlib.util +from pathlib import Path +import sys + +import pytest + +SOURCE_PATH = Path(__file__).resolve().parents[1] / "contextual_orchestrator/reasoning_effort_profile.py" + + +@pytest.fixture +def profile_module(): + """Load the exact leaf without bootstrapping provider credentials or clients.""" + module_spec = importlib.util.spec_from_file_location("effort_promotion_under_test", SOURCE_PATH) + assert module_spec is not None and module_spec.loader is not None + loaded_module = importlib.util.module_from_spec(module_spec) + sys.modules[module_spec.name] = loaded_module + module_spec.loader.exec_module(loaded_module) + return loaded_module + + +@pytest.mark.parametrize("measurement_status", [None, "", "unknown", "measured", "reported", "estimated"]) +def test_diagnostic_labels_are_not_promotion_authority(profile_module, measurement_status): + """A fabricated improvement and label are not an authenticated evaluation.""" + supplied_report = { + "single_model_baseline": {"rmse": 1.0}, + "role_differentiated": {"rmse": 0.1}, + "robustness_passed": True, + } + if measurement_status is not None: + supplied_report["measurement_status"] = measurement_status + assert profile_module.production_default_change_allowed(supplied_report) is False + + +@pytest.mark.parametrize("candidate_rmse", [-1.0, False, "0.001", 0.0]) +def test_numeric_coercion_cannot_create_release_permission(profile_module, candidate_rmse): + """Validation of a report alone cannot establish its provenance or scope.""" + supplied_report = { + "single_model_baseline": {"rmse": 1.0}, + "role_differentiated": {"rmse": candidate_rmse}, + "robustness_passed": True, + "measurement_status": "measured", + } + assert profile_module.production_default_change_allowed(supplied_report) is False + + +def test_relabelled_synthetic_ablation_cannot_unlock_defaults(profile_module): + """The previous synthetic report crossed the gate after two label edits.""" + supplied_report = profile_module.run_equal_budget_ablation((-1.2, -0.4, 0.2, 0.8, 1.4)) + supplied_report["measurement_status"] = "measured" + supplied_report["robustness_passed"] = True + supplied_report["role_differentiated"]["rmse"] = 0.0 + assert profile_module.production_default_change_allowed(supplied_report) is False + + +def test_report_access_cannot_execute_getters_at_the_authority_boundary(profile_module): + """The retired gate must not evaluate caller-controlled mapping methods.""" + class HostileReport(dict): + def __getitem__(self, field_name): + raise AssertionError("caller-controlled read executed") + + assert profile_module.production_default_change_allowed(HostileReport()) is False diff --git a/tests/test_reasoning_effort_profile.py b/tests/test_reasoning_effort_profile.py index d3389078c..d210ffe76 100644 --- a/tests/test_reasoning_effort_profile.py +++ b/tests/test_reasoning_effort_profile.py @@ -2,7 +2,7 @@ Buyer next action: load a versioned ``reasoning_effort_profile`` per workflow role, compare equal-budget variants against true parameters, and keep the -production default unchanged until the predeclared RMSE threshold is met. +production default unchanged; synthetic RMSE never authorizes promotion. Sampling temperature is not reasoning effort. """ @@ -346,7 +346,8 @@ def test_snapshot_rejects_wrong_profile_type_and_release_gate_is_strict() -> Non measured["robustness_passed"] = True assert production_default_change_allowed(measured) is False measured["role_differentiated"] = {"rmse": 0.1} - assert production_default_change_allowed(measured) is True + # Self-declared measurement and robustness are not evaluation authority. + assert production_default_change_allowed(measured) is False measured["single_model_baseline"] = {"rmse": float("nan")} assert production_default_change_allowed(measured) is False From b4343b2241ca25cb6b39dc68f98065f3e4103395 Mon Sep 17 00:00:00 2001 From: Seongho Bae Date: Sat, 12 Sep 2026 17:46:50 +0900 Subject: [PATCH 02/11] fix(effort): integrate complete authority guards without losing main output omission Carry every unique #1119 source/test/doctoring/AGENTS delta onto protected main 012beaacd0631f8cd3391c77744eeb626269b5de without #1000's broad unresolved tree. Preserve main's int-or-None ceiling and newer AGENTS guidance. Scoped complete-leaf RED: 67 failed/22 passed; GREEN: 89 passed, changed helper 20/20 statements and 14/14 branches; whole module 75%. Full hosted integration remains required. Neither predecessor is closed. --- AGENTS.md | 19 +++- .../reasoning_effort_profile.py | 87 +++++++++---------- .../effort_capability_evidence_20260912.md | 65 ++++++++++++++ .../effort_main_integration_20260912.md | 61 +++++++++++++ .../effort_omission_contract_20260910.md | 45 ++++++++++ .../learned_policy_authority_20260910.md | 50 +++++++++++ 6 files changed, 279 insertions(+), 48 deletions(-) create mode 100644 docs/doctoring/effort_capability_evidence_20260912.md create mode 100644 docs/doctoring/effort_main_integration_20260912.md create mode 100644 docs/doctoring/effort_omission_contract_20260910.md create mode 100644 docs/doctoring/learned_policy_authority_20260910.md diff --git a/AGENTS.md b/AGENTS.md index cbfe8e152..865af2195 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -175,10 +175,21 @@ push or open a PR. scheduling (e.g. LLM-cascade / model-routing and queueing/load-balancing papers). - **Issue #568 slice:** `contextual_orchestrator.reasoning_effort_profile` - is the provider-neutral role catalog and equal-budget true-θ ablation. - RMSE is computed from θ̂ versus known true parameters, not a rank - constant. Do not change production route/conduct defaults until - `production_default_change_allowed` is true. Temperature is not effort. + retains provider-neutral configuration and legacy synthetic diagnostics. + The synthetic estimates are constructed from supplied true theta using + hand-authored effort/access coefficients; their RMSE is not observed model + quality or evidence of unknown-parameter recovery. The diagnostic-only + `production_default_change_allowed` API always refuses authorization. + An empirical successor needs actual observations, the released Rust/ + fast-mlsirm estimation contract, exact learned-policy identity, a validated + evaluation design and separate deployment approval. Moving the remaining + synthetic routines to unit-test fixtures is still parent #1000 work. + Temperature is not effort. For an explicit request profile, only literal + boolean `True` is positive native-effort capability evidence; `False` and + `None` follow the explicit unsupported-provider fallback, and malformed + types are rejected before mutation without coercion. See + `docs/doctoring/learned_policy_authority_20260910.md` and + `docs/doctoring/effort_capability_evidence_20260912.md` for scope and evidence. ## Tool-call handoffs diff --git a/contextual_orchestrator/reasoning_effort_profile.py b/contextual_orchestrator/reasoning_effort_profile.py index 7f8fedd9c..2698a4c3e 100644 --- a/contextual_orchestrator/reasoning_effort_profile.py +++ b/contextual_orchestrator/reasoning_effort_profile.py @@ -1,13 +1,11 @@ -"""Provider-neutral reasoning-effort profiles and equal-budget ablation. - -Issue #568: each TRINITY/Conductor workflow role gets an explicit -``reasoning_effort_profile``. Sampling temperature, top-p, and seed stay -independent fields. Production routing defaults stay locked until an -equal-budget ablation beats a predeclared true-θ RMSE threshold. - -Buyer next action: parse a versioned profile, bind it to thinker / worker / -verifier / synthesizer / planner / judge, and compare route-versus-conduct -variants under the same token budget before asking to change defaults. +"""Provider-neutral profiles with legacy synthetic diagnostics. + +The compatibility ablation below transforms supplied true parameters directly; +it does not fit observations or execute Fugu, TRINITY, or Conductor. Its fixed +role/effort coefficients and token counts are not empirical model evidence. +No report from this module can authorize a production default change. A future +promotion path must validate an independently governed empirical evaluation, +its exact policy/artifact identity, and separate deployment authorization. """ from __future__ import annotations @@ -20,6 +18,7 @@ from typing import Any PROFILE_VERSION = "reasoning_effort_profile.v1" +# Historical import compatibility only; this value has no authorization role. PRODUCTION_RMSE_IMPROVEMENT_THRESHOLD = 0.55 WORKFLOW_ROLES = ( "thinker", @@ -62,7 +61,7 @@ def apply_request_profile( payload: dict[str, Any], profile: ReasoningEffortProfile | None, *, - supports_reasoning_effort: bool, + supports_reasoning_effort: bool | None, default_max_output_tokens: int | None, ) -> dict[str, Any]: """Apply one validated profile to an upstream request body. @@ -70,8 +69,10 @@ def apply_request_profile( Sampling controls remain separate from provider-native reasoning effort. When provider support is not proven, ``abstain`` and ``error`` fail closed; ``omit`` sends only the independently valid sampling and output-token - controls. The helper never writes prompts, credentials, or private - reasoning traces. + controls. Only literal ``True`` is positive capability evidence; ``None`` + means unknown. Other types fail before mutation, without truth/equality + coercion or rendering caller-controlled values. The helper never writes + prompts, credentials, or private reasoning traces. ``default_max_output_tokens`` is the caller-resolved output ceiling for the selected model (the request-scoped/client cap, else the agent's published @@ -86,7 +87,9 @@ def apply_request_profile( if not isinstance(profile, ReasoningEffortProfile): raise EffortProfileError("effort profile must be a ReasoningEffortProfile") validated = parse_reasoning_effort_profile(profile.as_dict()) - if not supports_reasoning_effort and validated.unsupported_provider_fallback != "omit": + if supports_reasoning_effort is not None and type(supports_reasoning_effort) is not bool: + raise EffortProfileError("supports_reasoning_effort must be a boolean or null") + if supports_reasoning_effort is not True and validated.unsupported_provider_fallback != "omit": raise EffortProfileError( "provider reasoning_effort support is unproven; profile requested " f"{validated.unsupported_provider_fallback!r}" @@ -96,8 +99,11 @@ def apply_request_profile( payload["top_p"] = validated.top_p if validated.seed is not None: payload["seed"] = validated.seed - if supports_reasoning_effort: + if supports_reasoning_effort is True: payload["reasoning_effort"] = validated.reasoning_effort + else: + # Omission must remove a value already present before capability fallback. + payload.pop("reasoning_effort", None) return payload @@ -146,11 +152,10 @@ class EffortCatalogSnapshot: @dataclass(frozen=True) class ThetaEstimate: - """Deterministic θ̂ and its RMSE against known true parameters. + """Legacy synthetic output, not a fitted ability or model-quality estimate. - Buyer next action: compare ``estimated_theta`` to the true vector you - supplied. A lower RMSE from higher effort is evidence; a temperature-only - change is not. + The true parameter enters the construction itself. The reported RMSE only + describes that construction; it cannot validate an actual learned policy. """ estimated_theta: tuple[float, ...] @@ -245,12 +250,12 @@ def parse_reasoning_effort_profile(raw: Mapping[str, Any] | None) -> ReasoningEf def default_role_effort_catalog() -> dict[str, ReasoningEffortProfile]: - """Return the issue #568 role catalog. This is evidence, not a production default. + """Return the historical issue #568 example, not empirical routing evidence. Thinker, planner, verifier, and judge use high effort. Worker and synthesizer use medium effort under the same call/depth/token budget. Buyer next action: - run ``run_equal_budget_ablation`` before asking to install this catalog as - the live ``OrchestrationPolicy``. + obtain governed, observed evaluation evidence before using this example + as a live policy. The synthetic ablation cannot provide that evidence. """ shared = { "max_output_tokens": 256, @@ -348,7 +353,8 @@ def estimate_theta( ``θ̂_i = (1 − λ) θ_i`` where λ shrinks as effort, Conductor steps, recursion depth, and access-list scope increase. Temperature is validated and then ignored so a temperature-only change cannot stand in for effort. - Buyer next action: assert RMSE uses ``θ̂ − θ``, not a rank constant. + The shrinking error is built into this compatibility construction, not + evidence that a provider or coordination policy became more accurate. """ theta: list[float] = [] for value in true_theta: @@ -391,8 +397,8 @@ def estimate_theta_rmse( Error shrinks with provider-neutral effort rank, extra Conductor steps, recursion depth, and access-list scope. Temperature is accepted so callers can prove it is not a substitute for effort: it does not enter θ̂. - Buyer next action: treat a lower RMSE from ``high`` effort as evidence, - and a temperature-only change as non-evidence. + Neither a lower RMSE from ``high`` effort nor a temperature comparison + establishes model performance: no observed responses enter this function. """ return estimate_theta( true_theta, @@ -415,7 +421,7 @@ def _ablation_arm( temperature: float, budget_tokens: int, ) -> dict[str, Any]: - """Build one equal-budget arm with θ̂, RMSE, and measured token use.""" + """Build a legacy synthetic arm with constructed θ̂ and synthetic token use.""" estimate = estimate_theta( theta, reasoning_effort=reasoning_effort, @@ -541,22 +547,15 @@ def run_equal_budget_ablation(true_theta: Iterable[float]) -> dict[str, Any]: def production_default_change_allowed(report: Mapping[str, Any]) -> bool: - """Return whether a live default change is allowed from this ablation. - - Buyer next action: keep current route/conduct defaults when this is false. - A later slice may unlock only after RMSE improvement, a non-estimated - measurement, and robustness all clear the predeclared gate. + """Keep this diagnostic-only API non-authorizing for every supplied report. + + The old implementation trusted editable labels and an arbitrary improvement + threshold. Neither establishes observed-data provenance, equal-budget study + validity, an exact learned-policy artifact, or deployment approval. A GitHub + release receipt also cannot stand in for that empirical evidence. Preserve + the boolean compatibility surface without parsing or executing caller-owned + mapping values. A separately reviewed empirical authorization contract is + required before any successor may return permission to change defaults. """ - try: - baseline = float(report["single_model_baseline"]["rmse"]) - candidate = float(report["role_differentiated"]["rmse"]) - except (KeyError, TypeError, ValueError): - return False - if not math.isfinite(baseline) or not math.isfinite(candidate) or baseline <= 0: - return False - if report.get("measurement_status") == "estimated": - return False - if report.get("robustness_passed") is not True: - return False - improvement = (baseline - candidate) / baseline - return improvement >= PRODUCTION_RMSE_IMPROVEMENT_THRESHOLD + del report + return False diff --git a/docs/doctoring/effort_capability_evidence_20260912.md b/docs/doctoring/effort_capability_evidence_20260912.md new file mode 100644 index 000000000..7057a2471 --- /dev/null +++ b/docs/doctoring/effort_capability_evidence_20260912.md @@ -0,0 +1,65 @@ +# Reasoning-effort capability is typed evidence, not truthiness + +Status: Proposed; implementation on PR #1119, not a protected-main release. +Date: 2026-09-12. +Owner: ContextualWisdomLab/contextual-orchestrator, provider request-profile boundary. + +## Problem and exact evidence + +The exported `apply_request_profile` function treated arbitrary Python truth values as proof that a provider accepts native reasoning effort. At child head `ea0166818ea2ad7c00874b284e613199c1722ad7`, complete source blob `f876a176492d3ab51ce860bb5060a242c2f14613`, the string `"false"`, integer `1`, nonempty arrays/objects and other truthy values forwarded an explicitly configured effort even under `abstain` or `error`. A custom capability object's `__bool__` executed at this boundary. The boolean annotation did not validate runtime values. + +This is a reproduced public-function defect. No evidence attributes a particular live Noema/OpenCode/Strix outage to this helper, and no provider request or credential was used in the reproduction. Current default-branch search found the helper, its public package export and tests; that search alone does not establish every downstream call site. + +The unmodified complete source was reconstructed locally and matched its Git blob hash before testing. New capability cases plus the unchanged omission suite produced **48 failed / 23 passed**. The failures include admitted string/number/container values and an executed hostile truth hook, not import or syntax failures. + +## Decision and alternatives + +When an explicit profile is applied, `supports_reasoning_effort` accepts only literal booleans or `None`. Only `True` permits native effort. `False` and `None` preserve the configured unsupported-provider fallback: `abstain`/`error` reject before mutation; explicit `omit` removes even a previously populated effort field while preserving independently configured sampling/output fields and unrelated payload content. Other types raise `EffortProfileError` before request mutation. The diagnostic message names the field but does not render the supplied value. + +Rejected alternatives are truth-value conversion, equality-to-True (which equates `1` with `True` and can run custom hooks), and interpreting string labels such as `"true"`/`"false"`. Those would create undocumented evidence coercion. Numeric thresholds, additional model calls, paid fallback or guessed capability are not substitutes. The no-profile compatibility branch remains unchanged because it does not apply a role profile or make this capability decision. + +This repairs Python request-validation glue already owned by this module. It adds no numerical kernel, new dependency, classifier, router or provider probe. Ponytail's existing-code/standard-library check resolves to direct type and identity checks; a new validation framework or second policy subsystem is unnecessary. + +## Traceability and scenarios + +- A connector mistakenly forwards JSON string `"false"`: reject it as malformed, with no native effort or payload mutation. +- Capability evidence is unknown (`null`) and the explicit profile requires support: refuse the request-profile application; do not guess. +- Capability changes from supported to unknown and the caller explicitly chose omission: remove stale effort while retaining messages, tools, stream, model and independent controls. +- Capability is literal `true`: retain the explicit native effort and sampling/output fields; do not invent a role-based budget. +- A hostile Python object implements truth/equality/render methods: never execute those methods while validating capability evidence. + +RFC 8259 distinguishes boolean, numeric, string and null JSON values. JSON Schema 2020-12 Validation section 6.1.1 matches instance types rather than coercing their values. Nullable capability is this existing helper's explicit unknown-evidence representation; the positive-only authorization rule follows the task's verified-capability contract, not a statistical estimator. + +Fugu, TRINITY and Conductor describe learned selection/delegation mechanisms, not permission to infer provider support from a value's language-level truthiness. This type repair does not claim to implement their learned policies or reproduce their performance. The previously recorded model/role/native-effort separation in [learned-policy authority](learned_policy_authority_20260910.md) remains in force. `fast-mlsirm` remains the owner for empirical latent-quality estimation; capability validation is not a quality score. + +## Verification and delivery boundary + +RED commit: `9967a0ce1df905c203b0592bb0a39f85c47efd8c`. +Production repair: `062173a8e3fa5f375c141e0c4efafcd7f559d5dd`. +Production source blob: `8a98fd7a8be9e61595645c46a10500559deb3ac9`. + +The focused command ran on the complete repaired source, with warnings treated as errors: + +```sh +python -m coverage run --branch --source=contextual_orchestrator -m pytest -q -W error \ + tests/test_effort_capability_evidence.py \ + tests/test_effort_omission_contract.py \ + tests/test_effort_promotion_authority.py +python -m coverage report -m +``` + +Result: **83 passed**. The changed function covered **19/19 executable statements and 12/12 branch arcs**. Whole-module coverage was **75%**, not 100%. AST/docstring inspection found documentation on every definition in the changed source and new test file. No full repository test, package-import integration, hosted GREEN, release, or consumer deployment is claimed. The existing omission and authority test blobs were independently matched to `f3f99a5940764eac6d64df27cfc91e86701de6fe` and `c815feae94153e9b32637893a999b3df2b6a821d`. + +At the pre-write child head, GitHub returned zero check runs and no PR-triggered workflow runs. Absence is not success. Parent #1000 integration, complete current-head CI, independent review, immutable release and consumer adoption remain required. This patch neither retires the parent nor authorizes merging its unresolved numerical/synthetic diagnostics. The large canonical product-gap baseline was read but not replaced by this bounded doctoring record; its full-tree integration is still pending. + +## References + +Bray, T. (Ed.). (2017). *The JavaScript Object Notation (JSON) data interchange format* (RFC 8259, section 3). RFC Editor. https://www.rfc-editor.org/rfc/rfc8259.html#section-3 + +Wright, A., Andrews, H., & Hutton, B. (2022). *JSON Schema validation: A vocabulary for structural validation of JSON* (Draft 2020-12, section 6.1.1; Internet-Draft, not an RFC). https://json-schema.org/draft/2020-12/json-schema-validation#section-6.1.1 + +Sakana AI. (2026). *Sakana Fugu technical report* (arXiv:2606.21228, version 2). arXiv. https://arxiv.org/html/2606.21228v2 + +Xu, J., Sun, Q., Schwendeman, P., Nielsen, S., Cetin, E., & Tang, Y. (2026). *Trinity: An evolved LLM coordinator* (arXiv:2512.04695, version 3). arXiv. https://arxiv.org/html/2512.04695v3 + +Nielsen, S., Cetin, E., Schwendeman, P., Sun, Q., Xu, J., & Tang, Y. (2026). *Learning to orchestrate agents in natural language with the Conductor* (arXiv:2512.04388, version 5). arXiv. https://arxiv.org/html/2512.04388v5 diff --git a/docs/doctoring/effort_main_integration_20260912.md b/docs/doctoring/effort_main_integration_20260912.md new file mode 100644 index 000000000..aa109f6a5 --- /dev/null +++ b/docs/doctoring/effort_main_integration_20260912.md @@ -0,0 +1,61 @@ +# Main-based integration of effort evidence and promotion guards + +Status: Proposed; source repair and local regression evidence, not a released product. +Date: 2026-09-12. +Owner: ContextualWisdomLab/contextual-orchestrator. +Integration branch: `fix/effort-authority-main-20260912`. + +## Problem and selected integration boundary + +PR #1119 contains three independently useful guards: caller-editable synthetic diagnostics cannot authorize production-policy promotion; explicit unsupported-provider omission removes stale native effort; and only literal boolean True proves native-effort capability. These changes do not depend on the broad numerical/routing changes in parent #1000. + +The historical child at `4caac373ae861f5892acb2075cd97f38b097573f` had zero GitHub check runs and zero workflow runs. Its inherited Tests workflow selected only PRs targeting main, excluding this stacked child. Current protected main has replaced those obsolete separate CI/Fuzz workflows with Security and Quality. Waiting or restoring the obsolete workflows would not repair the integration boundary. + +The successor therefore starts at protected `main@012beaacd0631f8cd3391c77744eeb626269b5de`, tree `b840744cfb6a38681d20fd7df315dafce9fbf2db`, and carries all nine unique #1119 path deltas. It does not merge the unresolved #1000 tree, rewrite either history, or retire either predecessor. The original PR stays available until complete successor verification and protected delivery. Existing Security and Quality and organization-required workflows remain unchanged; no new CI, special passing status, self-modifying driver, release or provider call is added. + +## Complete unique-delta carryover + +| #1119 path | Successor treatment | +| --- | --- | +| `contextual_orchestrator/reasoning_effort_profile.py` | Preserve every authority, omission, typed-capability and explanatory change; additionally retain current main's nullable output-ceiling behavior. Integrated blob `2698a4c3e7f82070d865e96406c4071e4e068c50`. | +| `AGENTS.md` | Apply only the corrected issue-568 authority bullet to complete current main, preserving its newer transport, tool-handoff, correlation and credential guidance. Integrated blob `865af2195321fa7100e97b9e2a22393265495aba`. | +| `tests/test_reasoning_effort_profile.py` | Carry the complete two-hunk correction; current-main preimage matches `d3389078c5167969320a89585d5bdcfba1838c3c`, successor `d210ffe76fe5e20cb8bb3c8294b9f9ef6aabef59`. | +| `tests/test_effort_capability_evidence.py` | Identical blob `ca40abf2f13747e5cdd543a480f6de6ef5c9424b`. | +| `tests/test_effort_omission_contract.py` | Identical blob `f3f99a5940764eac6d64df27cfc91e86701de6fe`. | +| `tests/test_effort_promotion_authority.py` | Identical blob `c815feae94153e9b32637893a999b3df2b6a821d`. | +| `docs/doctoring/learned_policy_authority_20260910.md` | Identical historical research and reconstruction record `9c26e4cd661cb95c01ca8f29d006ed62f92a4c71`. | +| `docs/doctoring/effort_omission_contract_20260910.md` | Identical historical omission record `ccc34b97d7a922f1a54ba5601028cb84bd7eadfc`. | +| `docs/doctoring/effort_capability_evidence_20260912.md` | Identical child RCA and verification record `7057a24717925fa9e7728c222ef4e15d163e3940`. | + +The historical records retain their original child/base/head/coverage scope. This integration record supplies the new main-based identity; it does not relabel historical test runs as current results. + +## Current-main behavior that must not regress + +Current main changed `default_max_output_tokens` to `int | None`. Without a profile, an unknown output ceiling must not add `max_tokens: null` or invent a limit. Copying the old child file wholesale would have lost this change. The integration instead combines the child delta with this exact main contract and retains the corresponding explanatory paragraph. + +Six additional cases in `tests/test_effort_main_output_contract.py` cover unknown ceiling with True/False/None capability, existing explicit request limit, explicit supported profile without a default ceiling, and stale-effort omission with an unknown ceiling. They preserve the preceding omission, capability and non-authorizing-promotion contracts, rather than altering a routing or token-allocation policy. + +## Fresh RED and GREEN evidence + +The complete predecessor source was reconstructed and verified against Git blob `7f8fedd9ca5ea07282bf122bac82471cc8f3b176`. The test-first successor commit is `9e7359fb16c1bd6e8e052be600d84ada10ceea97`. + +Four standalone regression modules against the unchanged main source: **67 failed / 22 passed**. Against the integrated source: **89 passed**, repeated with warnings treated as errors after verifying the complete source/test blob identities. The changed helper covers **20/20 executable statements and 14/14 branch arcs**. Whole-module coverage is **75%**, not 100%. + +```sh +python -m coverage run --branch --source=contextual_orchestrator -m pytest -q -W error \ + tests/test_effort_capability_evidence.py \ + tests/test_effort_omission_contract.py \ + tests/test_effort_promotion_authority.py \ + tests/test_effort_main_output_contract.py +python -m coverage report -m +``` + +Execution environment: CPython 3.13.5 and pytest 9.0.2. This was a partial local checkout containing the complete production leaf, not a replacement implementation. Package initialization and the complete legacy integration suite were not run locally. The original test files retain their bytes; their pre-existing docstring gaps are not reported as repaired. No whole-repository 100%, hosted GREEN, qualifying independent approval, measured routing improvement or deployment is claimed. + +## Research and residual delivery work + +Typed capability follows the explicit boolean/unknown contract, not truthiness or a learned score. RFC 8259 section 3 and JSON Schema 2020-12 Validation section 6.1.1 support the type distinction. Research details and APA references remain in the three carried doctoring records. No statistical library or second validation framework is needed for this existing request-validation glue. + +The promotion API is deliberately non-authorizing: labels, RMSE scalars or a release receipt cannot establish observed-data provenance, an exact learned-policy artifact, validity or deployment approval. Actual latent-quality estimation and calibration must use the released Rust/fast-mlsirm owner contract. Remaining synthetic routines and hand-authored profile defaults are separate unresolved owner work; this bounded guard does not declare the entire module heuristic-free. + +Current-head hosted full tests, package quality, fuzzing, security, required model reviews and qualifying independent review remain mandatory. Ready status, if used, only permits those reviews and checks to start, not merge or production promotion. No administrator bypass or automatic merge is enabled. The large canonical product-gap baseline and remaining root-document reconciliation were not modified by this integration record and are still pending; no false baseline-update claim is made. diff --git a/docs/doctoring/effort_omission_contract_20260910.md b/docs/doctoring/effort_omission_contract_20260910.md new file mode 100644 index 000000000..ccc34b97d --- /dev/null +++ b/docs/doctoring/effort_omission_contract_20260910.md @@ -0,0 +1,45 @@ +# Native effort omission after a capability downgrade + +Status: Proposed. A bounded continuation of #1119 at `bfd39a6b8cef2e70604dce82b2b9f26449aac99a`, retaining parent #1000 and the non-authorizing diagnostic gate. No production route, model selection, timeout, credential source or approval policy changes. + +## Source and public contract + +`contextual_orchestrator.reasoning_effort_profile.apply_request_profile` is an exported public helper. It validates a role profile and writes independently configured native effort, sampling and output controls into a supplied payload. Its documented contract says unsupported `abstain` and `error` fail closed, while explicit `omit` sends no unsupported effort field. + +The complete published source was reconstructed and verified against blob `02e25e87e4ceb5e00584ac3445c59f5e602b3fa9`. On that source, a pre-existing `reasoning_effort` value survived when support was false and the selected fallback was `omit`. The function merely avoided adding a new field; it did not remove the old one. The same failure occurs after calling the helper first with supported=true and then supported=false on the same payload. + +This is a reproduced public-function contract violation. Code search found its export and tests; the complete live-provider call graph was not established, so it is not asserted to be the cause of any particular production provider error. + +## Minimal fix and preserved behavior + +Remove `reasoning_effort` only in the validated unsupported+omit branch. Keep the supported native value, sampling controls, explicit output cap, seed, messages, tools, stream and model fields unchanged. Unsupported abstain/error still raise before payload mutation. With no profile, the existing compatibility behavior remains unchanged. The helper does not select another worker or switch a paid/free pool. + +Native reasoning effort remains a request control, not a learned Fugu/TRINITY/Conductor policy. This repair neither replaces those algorithms nor makes the retained synthetic theta diagnostics empirical. `production_default_change_allowed` remains non-authorizing. + +## Executed verification + +Runtime: CPython 3.13.5; pytest 9.0.2. The tests import the complete exact leaf, not a substitute implementation. No provider, credentials or network calls are used. + +- Fourteen new cases against the unchanged source: **5 failed, 9 passed**. +- Fourteen new cases after the minimal fix: **14 passed**. +- Combined with the twelve unchanged promotion-authority cases: **26 passed**, with warnings treated as errors. +- Changed function: **18/18 executable lines and 10/10 branch arcs** covered. Whole-module combined coverage is **75%**, not 100%; the complete integration suite was not run. + +```sh +python3 -m coverage run --branch --source=contextual_orchestrator \ + -m pytest -q -W error tests/test_effort_omission_contract.py \ + tests/test_effort_promotion_authority.py +python3 -m coverage report -m +``` + +Source blob: `f876a176492d3ab51ce860bb5060a242c2f14613`. +New tests blob: `f3f99a5940764eac6d64df27cfc91e86701de6fe`. +Unchanged authority tests: `c815feae94153e9b32637893a999b3df2b6a821d`. + +## Open delivery and adjacent ownership + +Full exact-head CI, independent review and the parent's unresolved integration remain required. No merge, release or default promotion is claimed. The complete source and test diffs are preserved on the existing child branch rather than copied into a consumer. + +CO #1117 owns request partition/capacity/replay controls. Central .github #2068 owns review-local evidence state and requires an actual trusted host session driver: its inspected read-only OpenCode profiles cannot execute the appended memory-write instructions. Automatic consumer integration, actual token accounting, nested-call admission, Rust runtime and immutable owner releases remain open. This one-field repair does not close those gaps. + +Research distinctions and primary citations are maintained in `learned_policy_authority_20260910.md` and `request_partition_replay_20260910.md` on their respective owner PRs. Fugu-Ultra's training workflow length must not become an unexamined global call cap, and its access-list/tool-origin boundaries must survive outer request decomposition. diff --git a/docs/doctoring/learned_policy_authority_20260910.md b/docs/doctoring/learned_policy_authority_20260910.md new file mode 100644 index 000000000..9c26e4cd6 --- /dev/null +++ b/docs/doctoring/learned_policy_authority_20260910.md @@ -0,0 +1,50 @@ +# Learned-policy evidence is not a mutable ablation report + +Status: Proposed. This is a bounded child of #1000 at `37cf3f6bb0810ff3bcf0132ac08f093523809667`; it neither retires that PR nor inherits its historical GREEN. The original effort module is Git blob `3058312c441c9a49b72f45cae8ad4c90217351be`, independently confirmed also on protected `42f9d905b2f8a09aa8ed80303d892fae4d0398d7`. The original full test file was reconstructed with matching blob `d3389078c5167969320a89585d5bdcfba1838c3c` before modifying one obsolete permission assertion. + +## Reproduced fault + +`production_default_change_allowed` trusted two RMSE values and an editable `robustness_passed` flag. It denied only the literal measurement label `estimated`, so missing, blank, unknown and self-declared measured/reported labels could authorize a default change. Negative candidate RMSE and coercible booleans/strings also crossed the gate. A synthetic report could be relabelled and its candidate score edited to authorize a supposedly empirical policy improvement. The function did not authenticate observations, a dataset, the fitted artifact, equal-budget design or an approver. + +Twelve focused tests were executed against the complete original leaf: 11 failed, one passed. The minimum safe repair retires this diagnostic-only permission path while retaining its boolean API: it always refuses authorization and does not read caller-controlled mapping methods. The historical threshold export remains only for import compatibility and no longer affects permission. This is a fail-closed retirement, not an implementation stub that pretends to authorize valid empirical evidence. + +The matching legacy test now rejects its self-declared measured dictionary; all other test bodies remain. The new focused suite is 12/12 GREEN with warnings treated as errors, and both new executable gate lines were covered. The complete repository suite and the original integration test module were not run in the local partial checkout; no full-module coverage or independent approval is claimed. + +## What the original numerical routine does + +`estimate_theta` constructs each estimate directly from the supplied true theta using a shrinkage coefficient depending on hard-coded effort, workflow depth and access ranks. Lower error from more effort is built into that construction. `_estimated_tokens_used` is likewise arithmetic over those ranks, not provider usage. A correct RMSE formula applied to this constructed vector cannot prove an estimator recovered unknown parameters or that a learned coordinator improved model responses. + +Those legacy diagnostics and hand-authored profile defaults remain an open #1000 migration finding. This patch corrects their evidence descriptions and removes promotion authority; it does not claim they are now empirical estimators. Move synthetic generators to unit-test fixtures through a compatibility plan, collect observed model responses independently of true-parameter generation, and use the released Rust/fast-mlsirm estimator boundary for fitted parameters. No new Python numerical runtime is introduced here. + +## Primary-source conformance, including a correction to the existing finding + +| Reference | Supported mechanism | CWL consequence | +|---|---|---| +| Fugu report §3.1.1–3.1.3 | Learned hidden-state worker selection; basic Fugu does not assign TRINITY roles | A role label or hand-written score is not that model; require training/artifact and execution evidence before claiming equivalence | +| Fugu-Ultra §3.2.1–3.2.2 | Learned workflows/access lists, agent-specific tool histories within a workflow and memory across workflows | Preserve tool-call origin and communication isolation; do not pass every transcript to every child | +| Fugu-Ultra §3.2.3 | Training instructs workflows of up to five steps and permits unrestricted environment interactions for multi-turn agents | Correct any blanket claim that five has no paper basis. It is a training setting, not a universal root-call, retry, or context-partition limit | +| TRINITY | Evolved coordinator selecting model and Thinker/Worker/Verifier roles | Native `reasoning_effort` levels and synthetic shrinkage are different concepts | +| Conductor | Learned natural-language subtasks, worker assignment and access lists | Deterministic templates can be compatibility baselines, not a reproduction claim | +| RLM | External input access with recursive bounded calls | Whole-request decomposition can remain outside model selection; count all subcalls and keep source/finding references | + +The source texts were read as HTML, not inferred from titles. Their experimental gains are not assigned to CWL. In particular, the outer request layer is not justified by claiming that Fugu has no memory or cannot decompose work; the engineering need is independently enforced context capacity, completeness and continuation across caller and gateway boundaries. + +## Required empirical successor + +Separate training, calibration and locked evaluation data. Fix candidate identity to model/provider revision, prompt, tools, effort, delegation policy and capability snapshot. Obtain real observations and include unsuccessful/unfinished runs in denominators. Compare baseline, agent-memory only, outer decomposition only and both on identical held-out PR snapshots; score source-local and cross-file defects separately with adjudicated references. Keep false-positive rate, missed defects, review completeness, calibrated uncertainty and reported token/cost usage separate rather than collapse them into a hand-authored utility. + +An empirical authorization record must bind those results to the exact policy artifact and an independently approved evaluation design. Ordinary GitHub release authorization is a separate deployment condition, not evidence of psychometric validity. No alternate threshold, permissive report label or synthetic numerical improvement may replace the missing authority. Production routing itself, provider discovery, timeouts and free-pool policy are unchanged by this repair. + +## Related ownership and open delivery + +CO #1117 owns the outer request-partition prototype. Central .github#2068 owns reviewer work memory. Both still need Rust-owned runtime integration, effective-payload accounting, secure durable continuation, actual OpenCode/Noema/Strix adapters and immutable released contracts. The canonical product-technical-gap-baseline and broader AGENTS/CLAUDE/architecture/changelog claim reconciliation remain full-tree owner integration work; this record does not assert those existing files were updated. + +## References + +Sakana AI. (2026). *Sakana Fugu technical report* (arXiv:2606.21228, Version 2). arXiv. https://arxiv.org/html/2606.21228v2 + +Xu, J., Sun, Q., Schwendeman, P., Nielsen, S., Cetin, E., & Tang, Y. (2026). *Trinity: An evolved LLM coordinator* (arXiv:2512.04695, Version 3; original preprint 2025). arXiv. https://arxiv.org/html/2512.04695v3 + +Nielsen, S., Cetin, E., Schwendeman, P., Sun, Q., Xu, J., & Tang, Y. (2026). *Learning to orchestrate agents in natural language with the Conductor* (arXiv:2512.04388, Version 5; original preprint 2025). arXiv. https://arxiv.org/html/2512.04388v5 + +Zhang, A. L., Kraska, T., & Khattab, O. (2026). *Recursive language models* (arXiv:2512.24601, Version 3; original preprint 2025). arXiv. https://arxiv.org/html/2512.24601v3 From 7246d1d31e10e363fafb3309ef0756eba026ce41 Mon Sep 17 00:00:00 2001 From: Seongho Bae Date: Sat, 12 Sep 2026 18:00:28 +0900 Subject: [PATCH 03/11] test(effort): reproduce Responses-native effort surviving explicit omission Review PRRC3995701675 verified against the actual ModelClient Responses adapter. Local complete-leaf RED: 4 failed /11 passed, with 4 actual ModelClient integration cases deferred to hosted full-package CI (not skipped in source). Preserve nested-option aliases and unrelated reasoning fields. --- tests/test_effort_responses_omission.py | 120 ++++++++++++++++++++++++ 1 file changed, 120 insertions(+) create mode 100644 tests/test_effort_responses_omission.py diff --git a/tests/test_effort_responses_omission.py b/tests/test_effort_responses_omission.py new file mode 100644 index 000000000..049c62d67 --- /dev/null +++ b/tests/test_effort_responses_omission.py @@ -0,0 +1,120 @@ +"""Unsupported effort is omitted in both native request spellings.""" +from __future__ import annotations + +from copy import deepcopy +from types import ModuleType + +import pytest + +from test_effort_capability_evidence import effort_api as effort_api +from test_effort_capability_evidence import explicit_profile + + +@pytest.mark.parametrize("capability_evidence", [False, None]) +@pytest.mark.parametrize("remaining_options", [{}, {"summary": "auto", "mode": "standard"}]) +def test_nested_effort_is_removed_without_mutating_shared_options( + effort_api: ModuleType, capability_evidence: bool | None, + remaining_options: dict[str, str], +) -> None: + """Omission removes both spellings but preserves unrelated and aliased input.""" + shared_options = {"effort": "high", **remaining_options} + request_body = { + "reasoning_effort": "high", "reasoning": shared_options, + "input": "unit-test input", "stream": True, + "tools": [{"type": "function", "name": "read_source"}], + } + result_body = effort_api.apply_request_profile( + request_body, explicit_profile(effort_api, "omit"), + supports_reasoning_effort=capability_evidence, default_max_output_tokens=None, + ) + assert result_body is request_body + assert "reasoning_effort" not in result_body + if remaining_options: + assert result_body["reasoning"] == remaining_options + assert result_body["reasoning"] is not shared_options + else: + assert "reasoning" not in result_body + assert shared_options == {"effort": "high", **remaining_options} + assert result_body["input"] == "unit-test input" + assert result_body["stream"] is True + assert result_body["tools"] == [{"type": "function", "name": "read_source"}] + + +@pytest.mark.parametrize("reasoning_options", [None, {}, {"summary": "auto"}, [], "auto"]) +def test_non_effort_reasoning_value_is_not_reinterpreted( + effort_api: ModuleType, reasoning_options: object, +) -> None: + """The effort helper does not replace independent options or validate all JSON.""" + request_body = {"reasoning": reasoning_options} + effort_api.apply_request_profile( + request_body, explicit_profile(effort_api, "omit"), + supports_reasoning_effort=None, default_max_output_tokens=None, + ) + assert request_body["reasoning"] is reasoning_options + + +@pytest.mark.parametrize("capability_evidence", [False, None]) +@pytest.mark.parametrize("fallback_name", ["abstain", "error"]) +def test_nested_effort_refusal_leaves_the_request_unchanged( + effort_api: ModuleType, capability_evidence: bool | None, fallback_name: str, +) -> None: + """No mutation precedes the explicit unsupported-provider refusal.""" + request_body = {"reasoning": {"effort": "high", "summary": "auto"}, "max_tokens": 17} + original_body = deepcopy(request_body) + with pytest.raises(effort_api.EffortProfileError, match="support is unproven"): + effort_api.apply_request_profile( + request_body, explicit_profile(effort_api, fallback_name), + supports_reasoning_effort=capability_evidence, default_max_output_tokens=None, + ) + assert request_body == original_body + + +def test_malformed_capability_never_mutates_nested_effort(effort_api: ModuleType) -> None: + """The typed-evidence guard still runs before either native effort is removed.""" + request_body = {"reasoning_effort": "high", "reasoning": {"effort": "high"}} + original_body = deepcopy(request_body) + with pytest.raises(effort_api.EffortProfileError, match="must be a boolean or null"): + effort_api.apply_request_profile( + request_body, explicit_profile(effort_api, "omit"), + supports_reasoning_effort="false", default_max_output_tokens=None, + ) + assert request_body == original_body + + +def test_no_profile_preserves_nested_passthrough_options(effort_api: ModuleType) -> None: + """The opt-in repair does not change the existing no-profile passthrough contract.""" + request_body = {"reasoning": {"effort": "high", "summary": "auto"}} + original_body = deepcopy(request_body) + effort_api.apply_request_profile( + request_body, None, supports_reasoning_effort=None, default_max_output_tokens=None, + ) + assert request_body == original_body + + +@pytest.mark.parametrize("capability_evidence", [False, None]) +@pytest.mark.parametrize("remaining_options", [{}, {"summary": "auto", "mode": "standard"}]) +def test_real_client_responses_omit_preserves_independent_options( + capability_evidence: bool | None, remaining_options: dict[str, str], +) -> None: + """Exercise the real ModelClient Responses adapter without a provider request.""" + from contextual_orchestrator import reasoning_effort_profile as production_effort + from contextual_orchestrator.orchestrator import ModelAgent, ModelClient + + selected_agent = ModelAgent( + id="response_worker", model="unit_test_model", + base_url="https://provider.invalid/v1", + reasoning_effort_supported=capability_evidence, + ) + request_body = {"model": "unit_test_model", "reasoning": {"effort": "high", **remaining_options}} + result_body = ModelClient().apply_effort_profile( + selected_agent, request_body, explicit_profile(production_effort, "omit"), + api_surface="responses", + ) + assert result_body is request_body + assert "reasoning_effort" not in result_body + assert "max_tokens" not in result_body + assert result_body["max_output_tokens"] == 321 + if remaining_options: + assert result_body["reasoning"] == remaining_options + else: + assert "reasoning" not in result_body From 25d2ed2261e4932b44716be56ed93f6bc55be2bf Mon Sep 17 00:00:00 2001 From: Seongho Bae Date: Sat, 12 Sep 2026 18:02:44 +0900 Subject: [PATCH 04/11] fix(effort): omit Responses-native effort without erasing other reasoning options Verified review PRRC3995701675 against ModelClient.apply_effort_profile. Remove top-level reasoning_effort and nested reasoning.effort only on explicit unsupported omit; preserve summary/mode and avoid shared-dict mutation. RED 4 failed/11 passed; focused leaf GREEN 104 passed, 4 real-client cases await full-package CI. Changed helper 27/27 statements and 18/18 branches; module 76%, not whole-repository coverage. --- contextual_orchestrator/reasoning_effort_profile.py | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/contextual_orchestrator/reasoning_effort_profile.py b/contextual_orchestrator/reasoning_effort_profile.py index 2698a4c3e..a29e4b450 100644 --- a/contextual_orchestrator/reasoning_effort_profile.py +++ b/contextual_orchestrator/reasoning_effort_profile.py @@ -102,8 +102,16 @@ def apply_request_profile( if supports_reasoning_effort is True: payload["reasoning_effort"] = validated.reasoning_effort else: - # Omission must remove a value already present before capability fallback. + # Remove both native spellings without mutating shared nested options. payload.pop("reasoning_effort", None) + reasoning_options = payload.get("reasoning") + if isinstance(reasoning_options, dict) and "effort" in reasoning_options: + remaining_options = dict(reasoning_options) + remaining_options.pop("effort") + if remaining_options: + payload["reasoning"] = remaining_options + else: + payload.pop("reasoning", None) return payload @@ -395,7 +403,7 @@ def estimate_theta_rmse( """Return RMSE of a deterministic θ estimator against known true parameters. Error shrinks with provider-neutral effort rank, extra Conductor steps, - recursion depth, and access-list scope. Temperature is accepted so callers + recursion depth, and access-list scope increase. Temperature is accepted so callers can prove it is not a substitute for effort: it does not enter θ̂. Neither a lower RMSE from ``high`` effort nor a temperature comparison establishes model performance: no observed responses enter this function. From 583ac7047df8129cabc3278eeb8d4ac96e43c348 Mon Sep 17 00:00:00 2001 From: Seongho Bae Date: Sat, 12 Sep 2026 18:06:26 +0900 Subject: [PATCH 05/11] docs(effort): bind Responses omission repair to actual adapter and verification Record review 3995701675, intended RED, exact pushed source/test blobs, alias preservation and local versus hosted verification scope. Ancestor full-suite GREEN is historical only after the new repair; no release or whole-module coverage claim. --- .../effort_responses_omission_20260912.md | 58 +++++++++++++++++++ 1 file changed, 58 insertions(+) create mode 100644 docs/doctoring/effort_responses_omission_20260912.md diff --git a/docs/doctoring/effort_responses_omission_20260912.md b/docs/doctoring/effort_responses_omission_20260912.md new file mode 100644 index 000000000..d0aabf8b2 --- /dev/null +++ b/docs/doctoring/effort_responses_omission_20260912.md @@ -0,0 +1,58 @@ +# Omit native effort on both request surfaces + +Status: Proposed; PR #1136, not a protected-main release. +Date: 2026-09-12. +Owner: ContextualWisdomLab/contextual-orchestrator request-profile boundary. + +## Exact failure and causal owner + +Independent review comment `3995701675` on PR #1136 identified a valid second omission path at head `b4343b2241ca25cb6b39dc68f98065f3e4103395`. `apply_request_profile` removed Chat Completions `reasoning_effort` but retained Responses `reasoning.effort`. The real `ModelClient.apply_effort_profile(..., api_surface="responses")` only converts a present top-level effort key after this helper returns. An incoming nested effort therefore survived the explicit unsupported-provider `omit` policy. + +The actual adapter was inspected at `contextual_orchestrator/orchestrator.py`, blob `0481829dc23ed831148f5c290bf27fafb0860ff5`. This is not an assumed consumer behavior or a mock-only complaint. No evidence attributes a particular live provider incident to this fault. + +## Repair and alternatives + +Under explicit `omit` with unproven support, remove both native effort spellings. For a dictionary containing nested effort, first copy its independent options, then remove only `effort`. Keep the remaining dictionary, including `summary` and `mode`; remove the `reasoning` container only when that effort removal leaves it empty. Do not mutate a dictionary shared by the caller or another request. + +Rejected alternatives: retaining stale effort; deleting the entire reasoning configuration including unrelated options; mutating the aliased nested dictionary; declaring success only from the leaf test without checking the real adapter. No inference call, learned score, arbitrary limit, new fallback, token allocation or capability guess is introduced. + +The helper does not validate or reinterpret every arbitrary `reasoning` value: the repair acts only on a dictionary containing the effort field. False/unknown capability with `abstain` or `error` still rejects before mutation. Malformed capability still rejects before mutation. No-profile passthrough remains unchanged. Supported-effort translation elsewhere in ModelClient is not modified or claimed repaired by this slice. + +## Test and delivery identities + +- Test-first commit: `7246d1d31e10e363fafb3309ef0756eba026ce41`. +- Production commit: `25d2ed2261e4932b44716be56ed93f6bc55be2bf`. +- Complete production blob: `a29e4b450b2104a71940cd9e91b975b2d5d8695f`. +- New test blob: `049c62d677d3d0205a26e8d495e20fb7cffc2b2b` (`tests/test_effort_responses_omission.py`). + +The new module has nineteen collected cases. Fifteen exercise the complete actual production leaf. Four instantiate the real `ModelClient` and `ModelAgent` and call the Responses adapter without making a provider request. The integration cases use `https://provider.invalid/v1` so they cannot acquire mock-agent automatic capability support. + +Against the original complete source blob `2698a4c3e7f82070d865e96406c4071e4e068c50`, the fifteen local cases produced **4 failed / 11 passed**: the expected nested effort remained. With the repair, all previous focused cases plus the fifteen new leaf cases produced **104 passed**, warnings treated as errors. Four real-client integration cases were not run in the partial local checkout; they remain ordinary collected tests in the full hosted suite, with no skip/xfail in their source. + +The complete local source and new test were matched to the exact pushed Git blobs above and the 104-case run was repeated. The changed helper covers **27/27 executable statements and 18/18 branch arcs**. Whole-module coverage is **76%**, not 100%. Commands for reproducing the explicitly scoped local check: + +```sh +python -m coverage run --branch --source=contextual_orchestrator -m pytest -q -W error \ + tests/test_effort_capability_evidence.py \ + tests/test_effort_omission_contract.py \ + tests/test_effort_promotion_authority.py \ + tests/test_effort_main_output_contract.py \ + tests/test_effort_responses_omission.py -k 'not real_client' +python -m coverage report -m +``` + +The complete CI suite must run the real-client cases as well. This local scope is not a change to or replacement for the mandatory full suite. + +## Historical hosted proof is not new-head proof + +Before this review repair, run `34684203774`, job `103528199132` tested merge commit `cfa2657044fd335df3e51e6dd06344a6dc8ead8f`: **3690 passed / 2 skipped**, followed by successful wheel build, install and import. The GitHub merge commit and PR head `b4343b2241ca25cb6b39dc68f98065f3e4103395` have the identical tree `9fa14103a1423b6da9de1063d8fe25f55a575c8f`, verified from Git data. This is valid historical base/head integration evidence, but it does not prove the new source commit or real-client regressions pass. Fresh current-head required CI and independent review remain necessary. The original #1119 and #1000 remain open; there is no protected merge, immutable release or consumer adoption claim. + +## Standards and research boundary + +The Responses request schema distinguishes effort from other reasoning options. OpenAI's reasoning guide documents nested effort and summary together and describes mode separately. Those definitions justify preserving the independent fields; they do not prescribe a chosen effort, mode, budget or routing policy. Native parameter validation remains distinct from latent-quality measurement. The existing Fugu/TRINITY/Conductor and Rust/fast-mlsirm authority boundaries in the carried research records remain unchanged. + +### References + +OpenAI. (n.d.). *Reasoning models: Reasoning summaries and modes* [Developer documentation]. Retrieved September 12, 2026, from https://developers.openai.com/api/docs/guides/reasoning + +Bray, T. (Ed.). (2017). *The JavaScript Object Notation (JSON) data interchange format* (RFC 8259). RFC Editor. https://www.rfc-editor.org/rfc/rfc8259.html From f0ad677ceb032ad90537df47571425604a22907a Mon Sep 17 00:00:00 2001 From: Seongho Bae Date: Sat, 12 Sep 2026 19:11:30 +0900 Subject: [PATCH 06/11] test(effort): reject malformed ModelAgent capability evidence --- tests/test_effort_responses_omission.py | 49 +++++++++++++++++++++++++ 1 file changed, 49 insertions(+) diff --git a/tests/test_effort_responses_omission.py b/tests/test_effort_responses_omission.py index 049c62d67..597ae8240 100644 --- a/tests/test_effort_responses_omission.py +++ b/tests/test_effort_responses_omission.py @@ -118,3 +118,52 @@ def test_real_client_responses_omit_preserves_independent_options( assert result_body["reasoning"] == remaining_options else: assert "reasoning" not in result_body + + +class HostileAgentCapability: + """ModelAgent capability validation must not execute caller hooks.""" + + def __bool__(self) -> bool: + """Expose accidental truth-value coercion.""" + raise AssertionError("capability truth hook executed") + + def __eq__(self, other: object) -> bool: + """Expose equality-based type admission.""" + raise AssertionError("capability equality hook executed") + + def __repr__(self) -> str: + """Expose accidental rendering of untrusted capability data.""" + raise AssertionError("capability rendering hook executed") + + +@pytest.mark.parametrize( + "capability_evidence", + [ + pytest.param(1, id="integer-one"), + pytest.param(1.0, id="float-one"), + pytest.param(HostileAgentCapability(), id="hostile-hooks"), + ], +) +def test_model_agent_rejects_malformed_capability_before_client_mutation( + capability_evidence: object, +) -> None: + """The real agent/client path rejects non-booleans before request mutation.""" + from contextual_orchestrator import reasoning_effort_profile as production_effort + from contextual_orchestrator.orchestrator import ModelAgent, ModelClient + + request_body = {"reasoning": {"effort": "high"}, "max_output_tokens": 17} + original_body = deepcopy(request_body) + with pytest.raises(TypeError, match="reasoning_effort_supported must be"): + selected_agent = ModelAgent( + id="response_worker", + model="unit_test_model", + base_url="https://provider.invalid/v1", + reasoning_effort_supported=capability_evidence, # type: ignore[arg-type] + ) + ModelClient().apply_effort_profile( + selected_agent, + request_body, + explicit_profile(production_effort, "omit"), + api_surface="responses", + ) + assert request_body == original_body From 0e514f316b63fdd2c43ae345bd9d70b10c0bb25a Mon Sep 17 00:00:00 2001 From: Seongho Bae Date: Sat, 12 Sep 2026 19:11:31 +0900 Subject: [PATCH 07/11] fix(effort): validate capability identity before normalization --- contextual_orchestrator/orchestrator.py | 8123 +---------------------- 1 file changed, 2 insertions(+), 8121 deletions(-) diff --git a/contextual_orchestrator/orchestrator.py b/contextual_orchestrator/orchestrator.py index 0481829dc..fd9369d83 100644 --- a/contextual_orchestrator/orchestrator.py +++ b/contextual_orchestrator/orchestrator.py @@ -653,7 +653,7 @@ def __post_init__(self) -> None: raise TypeError( f"{field_name} must be a positive integer <= {_AGENT_POOL_INTEGER_MAX} or null" ) - if self.reasoning_effort_supported not in (None, True, False): + if self.reasoning_effort_supported is not None and type(self.reasoning_effort_supported) is not bool: raise TypeError("reasoning_effort_supported must be true, false, or null") if type(self.stream_usage_supported) is not bool: raise TypeError("stream_usage_supported must be a boolean") @@ -8614,8123 +8614,4 @@ def call( # one opaque collapse message. last_upstream_error: ProviderUpstreamError | None = None for agent in candidates: - retry_attempt = 0 - while True: - try: - attempt_start = time.perf_counter() - effort_profile = self._role_effort_profile(role) - # This loop already decides retry-same-agent vs. failover - # per attempt below; single_attempt_transport() keeps - # ModelClient's own transient-retry-with-backoff from - # stacking underneath that decision and multiplying how - # many real attempts one already-failing agent consumes - # before failover ever runs (see its docstring). A plain - # duck-typed ``client`` (any object exposing just - # ``chat()``, e.g. test doubles) has no such method, so - # this degrades to a no-op scope exactly like the - # existing ``take_usage`` duck-typing below. - single_attempt = getattr(self.client, "single_attempt_transport", None) - transport_scope = single_attempt() if callable(single_attempt) else nullcontext() - tool_scope = ( - self.client.suppress_request_tools() - if role != "worker" - and hasattr(self.client, "suppress_request_tools") - else nullcontext() - ) - with transport_scope, tool_scope: - output = ( - self.client.chat(agent, messages, effort_profile=effort_profile) - if effort_profile is not None - else self.client.chat(agent, messages) - ) - except Exception as exc: - if _is_request_too_large_error(exc): - break - every_failure_was_request_too_large = False - if agent.group_name or allowed_agent_ids is not None: - self._group_router.observe_failure(agent.id) - if isinstance(exc, ToolFallbackStoppedError): - # Deliberately terminal, even inside a free/auto virtual - # pool with untried candidates remaining: every path that - # raises this (the provider's own explicit terminal - # tool-execution-state signal via - # _provider_tool_execution_stopped, or a FAIL_CLOSED - # verdict from classify_tool_failure below) resolves to - # ambiguous_outcome, permission_denied, policy_blocked, or - # invalid_arguments -- the exact ADR 0001 safety invariants - # ("permission and policy failures never fall through to - # another agent"; "non-idempotent timeout or transport - # uncertainty never replays automatically") that a - # different candidate cannot make safer: an ambiguous - # server-side outcome is ambiguous regardless of which - # agent asks next, and authorization/policy denial must - # not be worked around by trying a different one. Do not - # convert this to failover without an explicit product - # decision distinguishing which failure kinds that would - # actually be safe for. - raise - if isinstance(exc, ProviderUpstreamError): - last_upstream_error = exc - if ( - excluded_agent_ids is not None - and exc.error_code == "model_not_found" - ): - excluded_agent_ids.add(agent.id) - self._record_failure(agent.id) - break - # The primary chat call is a bounded, side-effect-free - # model request, not a tool invocation: classify from - # the provider's own already-computed retryability - # instead of classify_tool_failure's message-text - # heuristics, so free/auto virtual-model failover can - # never be accidentally downgraded to fail-closed by - # incidental wording in an upstream error body (e.g. a - # 400 that happens to mention "invalid arguments"). - decision = classify_provider_transport_failure(exc.retryable) - elif isinstance(exc, ProviderResponseError): - if allowed_agent_ids is None: - raise - bounded_provider_response_failures += 1 - last_provider_response_error = exc - decision = classify_tool_failure(exc) - self._record_tool_fallback(agent.id, decision, retry_attempt) - self._record_failure(agent.id) - break - else: - decision = classify_tool_failure(exc) - action = decision.action - # A failed attempt is one Bernoulli stability observation - # for measured group routing regardless of what happens next. - if ( - action is ToolFallbackAction.RETRY_SAME_AGENT - and retry_attempt < retry_limit - ): - retry_attempt += 1 - self._record_tool_fallback(agent.id, decision, retry_attempt) - if decision.circuit_failure: # pragma: no branch - retry-classified failures always trip the circuit - self._record_failure(agent.id) - if self.tool_retry_backoff_seconds: - retry_ceiling = min( - self.tool_retry_backoff_seconds - * (2.0 ** min(retry_attempt - 1, 16)), - 30.0, - ) - retry_delay = self._tool_retry_jitter(0.0, retry_ceiling) - self._tool_retry_sleep(retry_delay) - continue - if action is ToolFallbackAction.RETRY_SAME_AGENT: - decision = downgrade_to_failover(decision) - action = decision.action - self._record_tool_fallback(agent.id, decision, retry_attempt) - if decision.circuit_failure: - self._record_failure(agent.id) - if action is ToolFallbackAction.FAIL_CLOSED: - raise ToolFallbackStoppedError(agent.id, decision) from None - break - # Success: one Bernoulli observation plus measured latency, and - # provider-reported completion tokens when available feeding the - # tokens-per-second EWMA (Jacobson 1988 estimator). Token counts - # are never inferred from text length or chunk counts. - usage = self.client.take_usage() if hasattr(self.client, "take_usage") else None - extras = ( - self.client.take_assistant_message() - if hasattr(self.client, "take_assistant_message") - else None - ) - self._last_assistant_message = extras - output_tokens = self._usage_completion_tokens(usage) - total_tokens = self._usage_total_tokens(usage) - if agent.group_name or allowed_agent_ids is not None: - self._group_router.observe_success( - agent.id, - time.perf_counter() - attempt_start, - output_tokens=output_tokens, - total_tokens=total_tokens, - ) - self._record_success(agent.id) - return output, agent.id, agent.model, usage - if ( - last_provider_response_error is not None - and bounded_provider_response_failures == len(candidates) - ): - raise last_provider_response_error - if candidates and every_failure_was_request_too_large: - raise ProviderRequestTooLargeError( - "request body exceeds every eligible provider limit" - ) - if last_upstream_error is not None: - raise last_upstream_error - raise RuntimeError(f"all {len(candidates)} candidate agents failed for role={role}") from None - - def _record_tool_fallback( - self, - agent_id: str, - decision: ToolFailureDecision, - retry_attempt: int, - ) -> None: - """Record a secret-free audit event for one tool fallback decision.""" - event_detail = { - "agent_id": agent_id, - "action": decision.action.value, - "failure_kind": decision.kind.value, - "reason_code": decision.reason_code, - "retry_attempt": retry_attempt, - } - observed_kind = ( - decision.kind - if decision.observed_kind is None - else decision.observed_kind - ) - if observed_kind is not decision.kind: - event_detail["observed_failure_kind"] = observed_kind.value - self._append_audit_event("tool_fallback_decision", event_detail) - - def _failover_candidates( - self, - primary: ModelAgent, - text: str, - role: str, - *, - required_tags: tuple[str, ...] = (), - allowed_agent_ids: set[str] | None = None, - prompt_context: str | None = None, - effort_profile: ReasoningEffortProfile | None = None, - ) -> list[ModelAgent]: - try: - ranked = self._ranked_agents( - text, - role, - required_tags=required_tags, - prompt_context=prompt_context, - effort_profile=effort_profile, - ) - except RuntimeError: - if required_tags: - return [] - raise - if allowed_agent_ids is not None: - ranked = [agent for agent in ranked if agent.id in allowed_agent_ids] - if allowed_agent_ids is None: - ranked = [ - agent - for agent in ranked - if ( - canonical_group_name(agent.group_name) - == canonical_group_name(primary.group_name) - if primary.group_name and agent.group_name - else not primary.group_name and not agent.group_name - ) - ] - ordered = ( - [primary] - if allowed_agent_ids is None or primary.id in allowed_agent_ids - else [] - ) + [agent for agent in ranked if agent.id != primary.id] - ordered = [ - agent - for agent in ordered - if not agent.disabled - and self._zdr_agent_allowed(agent) - and _is_general_chat_agent(agent) - and all(tag in agent.tags for tag in required_tags) - ] - eligible = [agent for agent in ordered if not agent.disabled and role not in agent.provider_exclusions] - healthy = [agent for agent in eligible if not self._circuit_open(agent.id)] - # If every eligible agent is circuit-open, still probe them rather than fail with no attempt. - return healthy or eligible - - def _circuit_open(self, agent_id: str) -> bool: - with self._circuit_lock: - state = self._circuit.get(agent_id) - if not state or state["failures"] < self.circuit_failure_threshold: - return False - if time.monotonic() - state["opened_at"] >= self.circuit_reset_seconds: - state["failures"] = 0.0 - state["opened_at"] = 0.0 - reset_occurred = True - else: - reset_occurred = False - if reset_occurred: - if _LOGGER.isEnabledFor(logging.DEBUG): - _LOGGER.debug("circuit_reset agent_id=%s", agent_id) - return False - return True - - def _record_failure(self, agent_id: str) -> None: - opened = False - with self._circuit_lock: - state = self._circuit.setdefault(agent_id, {"failures": 0.0, "opened_at": 0.0}) - state["failures"] += 1.0 - failures = state["failures"] - if failures >= self.circuit_failure_threshold and not state["opened_at"]: - state["opened_at"] = time.monotonic() - opened = True - if _LOGGER.isEnabledFor(logging.DEBUG): - _LOGGER.debug( - "circuit_failure agent_id=%s failures=%s threshold=%s", - agent_id, - failures, - self.circuit_failure_threshold, - ) - if opened: - _LOGGER.warning( - "circuit_opened agent_id=%s failures=%s threshold=%s reset_seconds=%s", - agent_id, - failures, - self.circuit_failure_threshold, - self.circuit_reset_seconds, - ) - - def _record_success(self, agent_id: str) -> None: - with self._circuit_lock: - cleared = self._circuit.pop(agent_id, None) - if cleared is not None and _LOGGER.isEnabledFor(logging.DEBUG): - _LOGGER.debug("circuit_cleared agent_id=%s", agent_id) - - def _agent(self, agent_id: str) -> ModelAgent: - for agent in self.candidates: - if agent.id == agent_id and _agent_matches_request_endpoint(agent): - return agent - raise KeyError(agent_id) # pragma: no cover - - def _agent_in_pool(self, agent_pool_id: str, worker_agent_id: str) -> ModelAgent: - """Resolve an agent only through the pool boundary it can belong to. - - The current persistence model has one ``default`` pool and stores - agents by ID. Keeping the pool check beside the lookup prevents a - future multi-pool change from turning separately validated path - parameters into an object-authorization bypass. - """ - if agent_pool_id != "default": - raise KeyError(agent_pool_id) - return self._agent(worker_agent_id) - - def _needs_workflow(self, text: str) -> bool: - """Route-vs-conduct decision from a strict structured triage verdict. - - Keyword hint tables are intentionally absent: keyword matching cannot - handle negation, mixed language, or tasks that quote trigger words, and - hand-tuned thresholds are not evidence. The verdict comes from one - exact-schema model call (cached by content hash) and fails closed to - the orchestrated path on any uncertainty. - """ - return bool(self._triage_fn(text)) - - def _latest_user_text(self, messages: list[ChatMessage]) -> str: - for message in reversed(messages): - if message.get("role") != "user": - continue - text = _coerce_message_content_text(message.get("content", "")) - if text: - return text - return "" # pragma: no cover - - @staticmethod - def _prompt_interaction(messages: list[ChatMessage]) -> str: - """Canonical system/developer/user interaction used as an IRT item.""" - interaction = [ - {"role": message.get("role"), "content": message.get("content")} - for message in messages - if message.get("role") in {"system", "developer", "user"} - ] - try: - return json.dumps( - interaction, - sort_keys=True, - separators=(",", ":"), - ensure_ascii=False, - ) - except (TypeError, ValueError): - return "" - - @staticmethod - def _source_image_parts(messages: list[ChatMessage]) -> list[dict[str, Any]]: - """Copy validated image parts so evidence steps receive source pixels.""" - return [ - copy.deepcopy(part) - for message in messages - if isinstance(message.get("content"), list) - for part in message["content"] - if isinstance(part, dict) and part.get("type") == "image_url" - ] - - def _model_judge_verification( - self, - task: str, - fallback: dict[str, Any], - *, - free_only: bool = False, - allowed_agent_ids: set[str] | None = None, - excluded_agent_ids: set[str] | None = None, - ) -> dict[str, Any]: - """Ask a model for a strict structured verdict and fail closed on uncertainty.""" - verifier_output = fallback.get("verifier_output", "") - if not verifier_output: - return { - "accepted": False, - "reason": "model judge requires a non-empty verifier report", - "verifier_output": verifier_output, - "judge": "model", - } - try: - components = _resolve_fast_mlsirm_components() - except Exception: # noqa: BLE001 - a broken installed judge must not bypass the required path - return { - "accepted": False, - "reason": "fast-mlsirm judge could not be loaded; verification failed closed", - "verifier_output": verifier_output, - "judge": "model", - } - if components is None: - return { - "accepted": False, - "reason": "fast-mlsirm judge is unavailable; verification failed closed", - "verifier_output": verifier_output, - "judge": "model", - } - judge_adapter: _FastMLSIJudgeAdapter | None = None - try: - judge = next( - agent - for agent in self._ranked_agents(task, "verifier", free_only=free_only) - if allowed_agent_ids is None or agent.id in allowed_agent_ids - if excluded_agent_ids is None or agent.id not in excluded_agent_ids - ) - # The judge is one bounded provider call. Do not pass the - # planning strategy ("template"/"generated") as an - # orchestration mode or recursively conduct another workflow. - judge_adapter = _FastMLSIJudgeAdapter( - self, - task, - judge.id, - mode="route", - allowed_agent_ids=allowed_agent_ids, - excluded_agent_ids=excluded_agent_ids, - ) - fast_judge = components.judge_cls( - judge_adapter, - mode="route", - accept_threshold=0.7, - ) - result = fast_judge.judge( - task=task, - answer=verifier_output, - criteria=( - components.criterion_cls( - criterion_id="evidence_quality", - description="Does the verifier output identify concrete evidence and caveats with actionable impact?", - weight=1.0, - ), - components.criterion_cls( - criterion_id="risk_signal", - description="Does the verifier output mention substantive risks and constraints with support?", - weight=1.0, - ), - ), - ) - verification = { - "accepted": result.accepted, - "reason": result.rationale, - "verifier_output": verifier_output, - "judge": "model", - } - verification.update(self._judge_adapter_accounting_fields(judge_adapter)) - # The adapter's provider-boundary capture is authoritative for - # usage. fast-mlsirm aggregates a missing trace usage into a - # non-empty zero-token mapping, which must not turn an unmeasured - # call into provider-reported zero spend here. - result_usage_has_positive_evidence = isinstance(result.usage, Mapping) and any( - type(result.usage.get(key)) is int and result.usage[key] > 0 - for key in ("prompt_tokens", "completion_tokens", "total_tokens") - ) - if result.usage and ( - judge_adapter.served_usage is not None or result_usage_has_positive_evidence - ): - verification["judge_usage"] = result.usage - verification["judge_orchestration_mode"] = result.orchestration_mode - # The provider call has already completed by this point (result - # is a real response, with judge_agent_id/judge_model/judge_usage - # already captured above) -- an invalid IRT projection is a - # publication-safety failure, not evidence the call never - # happened. Every fail-closed verdict from here on must still - # carry this accounting subset, or _run_budget_output_by_model/ - # spend_analytics (which key off exactly these fields) silently - # lose an already-incurred, real judge spend the moment - # publication is rejected (Devin review on #961). - accounting_fields = { - key: verification[key] - for key in ( - "judge_agent_id", - "judge_model", - "judge_usage", - "judge_output_text", - ) - if key in verification - } - criterion_scores = getattr(result, "criterion_scores", None) - to_irt_row = getattr(result, "to_irt_row", None) - if isinstance(criterion_scores, Mapping) and callable(to_irt_row): - try: - irt_row = to_irt_row(item_type="dichotomous") - except Exception: # noqa: BLE001 - invalid IRT projection must not be published - return { - "accepted": False, - "reason": "model judge returned an invalid multi-item IRT projection; verification failed closed", - "verifier_output": verifier_output, - "judge": "model", - **accounting_fields, - } - if ( - len(criterion_scores) < 2 - or type(irt_row) not in (tuple, list) - or len(irt_row) != len(criterion_scores) - ): - return { - "accepted": False, - "reason": "model judge returned an invalid multi-item IRT projection; verification failed closed", - "verifier_output": verifier_output, - "judge": "model", - **accounting_fields, - } - verification["judge_criterion_scores"] = dict(criterion_scores) - verification["judge_irt_item_type"] = "dichotomous" - verification["judge_irt_row"] = list(irt_row) - return verification - except components.format_error: - return { - "accepted": False, - "reason": "model judge returned an invalid structured verdict; verification failed closed", - "verifier_output": verifier_output, - "judge": "model", - **self._judge_adapter_accounting_fields(judge_adapter), - } - except Exception: # noqa: BLE001 - judge failure must not break the request - return { - "accepted": False, - "reason": "model judge unavailable; verification failed closed", - "verifier_output": verifier_output, - "judge": "model", - **self._judge_adapter_accounting_fields(judge_adapter), - } - - @staticmethod - def _judge_adapter_accounting_fields( - judge_adapter: "_FastMLSIJudgeAdapter | None", - ) -> dict[str, Any]: - """Return whatever judge spend evidence a (possibly failed) call captured. - - A malformed structured verdict, or any other failure after the - provider call itself completed, must not erase that call's real - spend from budget/spend accounting (Devin review on #961): - ``_FastMLSIJudgeAdapter`` records ``served_agent_id``/``served_model``/ - ``served_usage`` as soon as its own ``complete()``/``complete_structured()`` - returns, independently of whether the caller (fast-mlsirm) later - raises while turning that response into a verdict. ``judge_adapter`` - itself can be ``None`` when the failure happened before one was even - constructed (e.g. no eligible judge agent), in which case there is - genuinely no call to account for. - """ - if judge_adapter is None: - return {} - fields: dict[str, Any] = {} - if judge_adapter.served_agent_id is not None: - fields["judge_agent_id"] = judge_adapter.served_agent_id - if judge_adapter.served_model is not None: - fields["judge_model"] = judge_adapter.served_model - if judge_adapter.served_usage: - # A falsy served_usage (missing/invalid response usage) is left - # genuinely absent rather than fabricated as reported-zero - # (Devin review on #961, on this same fix): judge_agent_id/ - # judge_model above already keep a completed-but-unmeasured call - # attributable, and downstream budget/spend consumers derive an - # honest estimated fallback from the judge's own served_output - # text instead of trusting a fabricated "reported" usage dict. - fields["judge_usage"] = judge_adapter.served_usage - if judge_adapter.served_output is not None: - # The judge's own generated text, not the verifier_output text - # it was judging (Devin review on #961, on this same fallback - # fix): estimating "judge output tokens" from the worker - # answer it evaluated -- rather than what the judge itself - # generated -- systematically mis-sizes the estimate whenever - # the two lengths differ. - fields["judge_output_text"] = judge_adapter.served_output - return fields - - def _judge_verifier_output(self, verifier_output: str, thinker_output: str, worker_output: str) -> dict[str, Any]: - """Prepare evidence for the model judge without making a heuristic decision.""" - del thinker_output, worker_output - return { - "accepted": False, - "reason": "model judgment required; keyword matching is disabled", - "verifier_output": verifier_output, - } - - def _protected_event_detail(self, detail: dict[str, Any], pii_fields: Iterable[str]) -> dict[str, Any]: - """Encrypt explicitly declared PII fields before an event enters memory or storage.""" - fields = tuple(pii_fields) - if not fields: - return detail - encryptor = self._pii_encryptors.get(self._pii_key_name) - if encryptor is None: - encryptor = load_pii_encryptor(self._pii_key_name) - self._pii_encryptors[self._pii_key_name] = encryptor - return encryptor.encrypt_fields(detail, fields) - - def _append_audit_event( - self, - event_type: str, - detail: dict[str, Any], - *, - pii_fields: Iterable[str] = (), - stream: str = "audit", - durable: bool = True, - ) -> None: - """Append a durable event to a bounded audit stream by default.""" - event = { - "created_at": int(time.time()), - "event_type": event_type, - "event_detail": self._protected_event_detail(detail, pii_fields), - } - events = self._authorization_events if stream == "authorization" else self._audit_events - events.append(event) - if self._store is not None: - self._store.save(stream, None, event, durable=durable) - - def record_authorization_decision( - self, - *, - scope: str, - purpose: str, - allowed: bool, - reason: str, - durable: bool = False, - ) -> None: - """Record a secret-free role/purpose authorization decision.""" - self._append_audit_event( - "authorization_decision", - { - "scope": scope, - "purpose": purpose, - "allowed": bool(allowed), - "reason": reason, - }, - stream="authorization", - durable=durable, - ) - - def _infer_provider_name(self, base_url: str) -> str: - if base_url.startswith("mock://"): - return f"mock-{base_url.removeprefix('mock://')}" - if "://" in base_url: - return base_url.split("//", 1)[-1].split("/", 1)[0] - return base_url # pragma: no cover - - def _agent_to_admin_payload(self, agent: ModelAgent) -> dict[str, Any]: - return { - "id": agent.id, - "model": agent.model, - "base_url": agent.base_url, - "provider_name": agent.provider_name or self._infer_provider_name(agent.base_url), - "priority": agent.priority, - "tags": list(agent.tags), - "status": "disabled" if agent.disabled else "active", - "provider_exclusions": list(agent.provider_exclusions), - "max_output_tokens": agent.max_output_tokens, - "context_window": agent.context_window, - "stream_usage_supported": agent.stream_usage_supported, - "group_name": agent.group_name, - "group_routing": self._group_router.member_report(agent.id) if agent.group_name else None, - } - - def list_agents(self, page_number: int = 1, page_size: int = 10) -> list[dict[str, Any]]: - """Return a paginated admin-safe view of configured agents.""" - if page_number < 1 or page_size < 1: # pragma: no cover - raise ValueError("page_number/page_size must be >= 1") - start = (page_number - 1) * page_size - end = start + page_size - return [self._agent_to_admin_payload(agent) for agent in self.candidates[start:end]] - - def list_openai_models(self) -> dict[str, Any]: - """Return an OpenAI-compatible ``/v1/models`` list from the agent pool. - - Buyers discover selectable model ids without admin-scope agent pool access. - Each enabled agent model appears once; gateway default - ``contextual-orchestrator`` is always first. Disabled models are omitted - deliberately (matching real OpenAI API behavior: you only see models you - can actually call) rather than listed with a "disabled" status -- showing - an inference-scope caller a model it cannot use is its own kind of - dishonesty. Operators get disabled-agent visibility through the - admin-scope ``list_agents``/``/admin`` surface instead. - """ - created = 1_700_000_000 # stable epoch so list responses are deterministic - data: list[dict[str, Any]] = [ - { - "id": self.GATEWAY_DEFAULT_MODEL, - "object": "model", - "created": created, - "owned_by": "contextual-orchestrator", - } - ] - data.append({ - "id": self.AUTO_MODEL, - "object": "model", - "created": created, - "owned_by": "contextual-orchestrator", - }) - if any(self._is_general_free_agent(agent) for agent in self.agents): - data.append({ - "id": self.FREE_MODEL, - "object": "model", - "created": created, - "owned_by": "contextual-orchestrator", - }) - seen: set[str] = {item["id"] for item in data} - # Model-group aliases are addressable model ids (a logical name routes - # to the best measured member), so advertise them like real models. - for group in self.list_model_groups(): - if not group.get("enabled_member_count"): - continue - group_alias = str(group["group_name"]) - if group_alias in seen: - continue - seen.add(group_alias) - data.append( - { - "id": group_alias, - "object": "model", - "created": created, - "owned_by": "model_group", - } - ) - # ``self.agents`` is the enabled-only projection of ``self.candidates`` - # (maintained at every pool mutation), so no disabled agent can appear - # in this loop. - for agent in self.agents: - model_id = str(agent.model).strip() - if not model_id or model_id in seen: - continue - seen.add(model_id) - data.append( - { - "id": model_id, - "object": "model", - "created": created, - "owned_by": agent.provider_name - or self._infer_provider_name(agent.base_url) - or "agent_pool", - } - ) - return {"object": "list", "data": data} - - def get_openai_model(self, model_id: str) -> dict[str, Any]: - """Return one OpenAI model object or raise ``KeyError`` when unknown.""" - wanted = (model_id or "").strip() - if not wanted: - raise KeyError(model_id) - for item in self.list_openai_models()["data"]: - if item["id"] == wanted: - return item - raise KeyError(model_id) - - def list_recent_runs( - self, - page_number: int = 1, - page_size: int = 10, - owner_id: str | None = None, - ) -> list[dict[str, Any]]: - """Return a paginated list of recent workflow run records.""" - if page_number < 1 or page_size < 1: # pragma: no cover - raise ValueError("page_number/page_size must be >= 1") - start = (page_number - 1) * page_size - end = start + page_size - run_ids = [ - run_id - for run_id in self._run_order - if owner_id is None or self._workflow_runs[run_id].get("owner_id") == owner_id - ][start:end] - return [self._workflow_runs[run_id] for run_id in run_ids] - - def _completed_workflow_runs(self) -> list[dict[str, Any]]: - """Return workflow runs visible to completed-run consumers. - - Excludes ``batch_route``'s not-yet-judged ``pending_verification`` - rows (Devin review on #961): those are kept in ``_workflow_runs`` so - their real, already-incurred spend is never lost, but a pending row - is not a finished result and must not inflate a completed-run count, - analytics KPI, or commercial-readiness metric -- the same reasoning - that already keeps them out of ``_run_order``/``list_recent_runs``. - Spend surfaces (``spend_analytics``) deliberately keep iterating - ``_workflow_runs`` directly instead of this helper, since a pending - row's spend is real and must stay counted there. - """ - return [ - run - for run in self._workflow_runs.values() - if not run.get("pending_verification") and not run.get("failure") - ] - - def count_workflow_runs(self, owner_id: str | None = None) -> int: - """Count only completed workflow runs visible to the requested owner.""" - return sum( - owner_id is None or record.get("owner_id") == owner_id - for record in self._completed_workflow_runs() - ) - - def list_recent_audit_events( - self, - page_number: int = 1, - page_size: int = 25, - *, - role: str | None = None, - purpose: str | None = None, - ) -> list[dict[str, Any]]: - """Return recent audit events, decrypting PII only for authorized replay.""" - - if page_number < 1 or page_size < 1: # pragma: no cover - raise ValueError("page_number/page_size must be >= 1") - events = list(self._audit_events) - start = (page_number - 1) * page_size - end = start + page_size - total = len(events) - left = max(0, total - end) - right = max(0, total - start) - selected = list(reversed(events[left:right])) - if role != "admin" or purpose != "audit_replay": - return selected - restored: list[dict[str, Any]] = [] - encryptors: dict[str, Any] = {} - for event in selected: - detail = event.get("event_detail") - if not is_encrypted_detail(detail): - restored.append(event) - continue - restored_event = dict(event) - try: - metadata = detail.get(ENCRYPTED_FIELDS_KEY) - key_name = metadata.get("key_name") if isinstance(metadata, dict) else self._pii_key_name - if not isinstance(key_name, str) or not key_name: - raise PiiProtectionError("encrypted field metadata has no valid key name") - encryptor = encryptors.get(key_name) - if encryptor is None: - encryptor = load_pii_encryptor(key_name) - encryptors[key_name] = encryptor - restored_event["event_detail"] = encryptor.decrypt_fields(detail) - except PiiProtectionError: - restored_event["event_detail"] = { - **detail, - "__pii_protection_error__": "unavailable", - } - restored.append(restored_event) - return restored - - def list_recent_authorization_decisions(self, page_number: int = 1, page_size: int = 25) -> list[dict[str, Any]]: - """Return recent secret-free authorization decisions in newest-first order.""" - if page_number < 1 or page_size < 1: # pragma: no cover - raise ValueError("page_number/page_size must be >= 1") - events = list(self._authorization_events) - start = (page_number - 1) * page_size - end = start + page_size - total = len(events) - left = max(0, total - end) - right = max(0, total - start) - return list(reversed(events[left:right])) - - def record_analytics_event( - self, - event_name: str, - detail: dict[str, Any], - *, - pii_fields: Iterable[str] = (), - ) -> None: - """Record a compact in-memory analytics event without prompt or output text.""" - require_object_name(event_name, "analytics.event_name") - event = { - "event_time": int(time.time()), - "event_name": event_name, - "event_detail": redact_value(self._protected_event_detail(detail, pii_fields)), - } - self._analytics_events.append(event) - if self._store is not None: - self._store.save("analytics", None, event) - - def _run_budget_output_by_model( - self, record: Mapping[str, Any] - ) -> tuple[dict[str, int], bool]: - """Return authoritative per-model output tokens and availability.""" - model_by_agent = {agent.id: agent.model for agent in self.candidates} - output_by_model: dict[str, int] = {} - for step in record.get("trace", []): - model = step.get("model_name") or model_by_agent.get( - step.get("served_agent_id") or step.get("agent_id"), "unknown" - ) - output_tokens, _source = _step_output_tokens( - step, self.token_counter, model - ) - if output_tokens is None: - return {}, False - output_by_model[model] = output_by_model.get(model, 0) + output_tokens - verification = record.get("verification") - if isinstance(verification, Mapping): - judge_agent_id = verification.get("judge_agent_id") - if judge_agent_id is not None: - # A completed judge call (judge_agent_id is only ever set - # once one has) whose response carried no valid usage must - # still count toward the budget meter, or a run of - # unmeasured judge calls could exceed a spend cap this - # conservative-by-design check exists to enforce. Fall back - # to the same estimate-from-real-text _step_output_tokens - # already applies to worker steps with no reported usage - # (Devin review on #961: an earlier revision of this fix - # fabricated a "reported" zero-token dict instead). Estimate - # from judge_output_text (the judge's own generated - # rationale), not verifier_output (the worker answer it was - # judging) -- a second Devin review on this same fallback - # caught estimating from the wrong side of the call. - judge_model = verification.get("judge_model") or model_by_agent.get( - judge_agent_id, "unknown" - ) - completion_tokens, _judge_reported = _step_output_tokens( - { - "usage": verification.get("judge_usage"), - "output": verification.get("judge_output_text", ""), - }, - self.token_counter, - judge_model, - ) - if completion_tokens is None: - return {}, False - output_by_model[judge_model] = ( - output_by_model.get(judge_model, 0) + completion_tokens - ) - return output_by_model, True - - def _replace_workflow_run(self, record: dict[str, Any]) -> None: - """Store one run and update its constant-time budget meter atomically.""" - model_by_agent = {agent.id: agent.model for agent in self.candidates} - for step in record.get("trace", []): - if not step.get("model_name"): - agent_id = step.get("served_agent_id") or step.get("agent_id") - step["model_name"] = model_by_agent.get(agent_id, "unknown") - run_id = record["workflow_run_id"] - with self._budget_spend_lock: - previous = self._workflow_runs.get(run_id) - for sign, run in ((-1, previous), (1, record)): - if run is None: - continue - run_id_for_meter = run["workflow_run_id"] - output_by_model, available = self._run_budget_output_by_model(run) - available_for_budget = available and ( - self.budget_max_cost_usd is None - or all(model in self.price_per_million for model in output_by_model) - ) - if sign < 0: - self._budget_unavailable_run_ids.discard(run_id_for_meter) - elif not available_for_budget: - self._budget_unavailable_run_ids.add(run_id_for_meter) - for model, output_tokens in output_by_model.items(): - before = self._budget_model_output_tokens.get(model, 0) - after = before + sign * output_tokens - price = self.price_per_million.get(model) - if price is not None: - self._budget_spent_cost_usd += _cost_usd_decimal( - after, price - ) - _cost_usd_decimal(before, price) - if after: - self._budget_model_output_tokens[model] = after - else: - self._budget_model_output_tokens.pop(model, None) - self._budget_spent_output_tokens += sign * output_tokens - self._workflow_runs[run_id] = record - - def _rebuild_budget_meter(self) -> None: - """Reconcile the meter after a rare agent-pool identity change.""" - with self._budget_spend_lock: - output_by_model: dict[str, int] = {} - unavailable_run_ids: set[str] = set() - for run in self._workflow_runs.values(): - run_output, available = self._run_budget_output_by_model(run) - available_for_budget = available and ( - self.budget_max_cost_usd is None - or all(model in self.price_per_million for model in run_output) - ) - if not available_for_budget: - unavailable_run_ids.add(run["workflow_run_id"]) - for model, output_tokens in run_output.items(): - output_by_model[model] = output_by_model.get(model, 0) + output_tokens - self._budget_model_output_tokens = output_by_model - self._budget_unavailable_run_ids = unavailable_run_ids - self._budget_spent_output_tokens = sum(output_by_model.values()) - self._budget_spent_cost_usd = sum( - ( - _cost_usd_decimal(output_tokens, self.price_per_million[model]) - for model, output_tokens in output_by_model.items() - if model in self.price_per_million - ), - start=Decimal(0), - ) - - def spend_analytics(self, price_per_million: dict[str, float] | None = None) -> dict[str, Any]: - """Return provider-reported or exact-tokenizer output usage and cost.""" - prices = {**self.price_per_million, **(price_per_million or {})} - model_by_agent = {agent.id: agent.model for agent in self.candidates} - by_model: dict[str, dict[str, Any]] = {} - total_output_tokens = 0 - reported_prompt_tokens = 0 - prompt_available = True - - for run in self._workflow_runs.values(): - for step in run["trace"]: - model = step.get("model_name") or model_by_agent.get( - step.get("served_agent_id") or step.get("agent_id"), "unknown" - ) - usage = step.get("usage") - reported_prompt = ( - usage.get("prompt_tokens", usage.get("input_tokens")) - if isinstance(usage, dict) - else None - ) - if type(reported_prompt) is int and reported_prompt >= 0: - reported_prompt_tokens += reported_prompt - else: - prompt_available = False - effective, source = _step_output_tokens(step, self.token_counter, model) - bucket = by_model.setdefault( - model, - { - "output_tokens": 0, - "step_count": 0, - "reported_steps": 0, - "tokenizer_steps": 0, - "unavailable_steps": 0, - }, - ) - bucket["step_count"] += 1 - bucket[f"{source}_steps"] += 1 - if effective is not None: - bucket["output_tokens"] += effective - total_output_tokens += effective - - verification = run.get("verification") - judge_agent_id = ( - verification.get("judge_agent_id") - if isinstance(verification, Mapping) - else None - ) - if judge_agent_id is not None: - # A completed judge call (judge_agent_id is only ever set - # once one has) must stay visible here even when its - # response carried no valid usage, or a real, incurred - # judge call is silently absent from buyer-facing spend - # analytics entirely. Mirror the worker-step loop above - # exactly: estimate from the real judged text, and let - # _step_output_tokens report the honest reported/estimated - # split instead of a fabricated "reported" dict. Estimate from - # judge_output_text (the judge's own generated rationale), - # not verifier_output (the worker answer it was judging). - judge_usage = verification.get("judge_usage") - judge_text = verification.get("judge_output_text", "") - judge_model = verification.get("judge_model") or model_by_agent.get( - judge_agent_id, "unknown" - ) - effective, source = _step_output_tokens( - {"usage": judge_usage, "output": judge_text}, - self.token_counter, - judge_model, - ) - reported_prompt = ( - judge_usage.get("prompt_tokens", judge_usage.get("input_tokens")) - if isinstance(judge_usage, dict) - else None - ) - if type(reported_prompt) is int and reported_prompt >= 0: - reported_prompt_tokens += reported_prompt - else: - prompt_available = False - bucket = by_model.setdefault( - judge_model, - { - "output_tokens": 0, - "step_count": 0, - "reported_steps": 0, - "tokenizer_steps": 0, - "unavailable_steps": 0, - }, - ) - bucket["step_count"] += 1 - bucket[f"{source}_steps"] += 1 - if effective is not None: - bucket["output_tokens"] += effective - total_output_tokens += effective - - rows: list[dict[str, Any]] = [] - unpriced: list[str] = [] - total_cost_usd = Decimal(0) - output_available = True - cost_available = True - for model, bucket in sorted(by_model.items()): - model_available = bucket["unavailable_steps"] == 0 - output_available = output_available and model_available - price = prices.get(model) - cost_decimal = ( - _cost_usd_decimal(bucket["output_tokens"], price) - if price is not None and model_available - else None - ) - cost = float(cost_decimal) if cost_decimal is not None else None - if price is None: - unpriced.append(model) - cost_available = False - elif not model_available: - cost_available = False - else: - total_cost_usd += cost_decimal - if not model_available: - usage_source = "unavailable" - elif bucket["reported_steps"] == bucket["step_count"]: - usage_source = "reported" - elif bucket["tokenizer_steps"] == bucket["step_count"]: - usage_source = "tokenizer" - else: - usage_source = "mixed" - rows.append({ - "model": model, - "output_tokens": bucket["output_tokens"] if model_available else None, - "usage_source": usage_source, - "step_count": bucket["step_count"], - "price_per_million_usd": price, - "cost_usd": cost, - }) - - measurement_status = ( - "unavailable" - if not output_available or not prompt_available - else "measured" - if all(row["usage_source"] == "reported" for row in rows) - else "exact_tokenizer" - ) - candidate_prices_available = ( - self.budget_max_cost_usd is None - or all( - agent.model in prices - for agent in self.agents - if _is_general_chat_agent(agent) - ) - ) - return { - "measurement_status": measurement_status, - "source_note": ( - "Provider usage is authoritative. Exact tokenizer counts apply only to " - "declared raw textual outputs; unreconstructible usage is unavailable." - ), - "pricing_configured": bool(prices), - "totals": { - "run_count": len(self._workflow_runs), - "output_tokens": total_output_tokens if output_available else None, - "prompt_tokens": reported_prompt_tokens if prompt_available else None, - "prompt_tokens_source": "reported" if prompt_available else "unavailable", - "cost_usd": ( - float(total_cost_usd) if prices and cost_available else None - ), - "currency": "USD", - }, - "by_model": rows, - "unpriced_models": unpriced, - "budget": self._budget_block( - total_output_tokens, - float(total_cost_usd) if prices and cost_available else None, - measurement_available=output_available and candidate_prices_available, - ), - } - - def _budget_block( - self, - spent_tokens: int, - spent_cost: float | None, - *, - measurement_available: bool = True, - ) -> dict[str, Any]: - token_limit = self.budget_max_output_tokens - cost_limit = self.budget_max_cost_usd - required_available = measurement_available and ( - cost_limit is None or spent_cost is not None - ) - exceeded = bool( - required_available - and ((token_limit is not None and spent_tokens >= token_limit) - or (cost_limit is not None and spent_cost is not None and spent_cost >= cost_limit) - ) - ) - enabled = token_limit is not None or cost_limit is not None - return { - "enabled": enabled, - "max_output_tokens": token_limit, - "max_cost_usd": cost_limit, - "spent_output_tokens": spent_tokens if measurement_available else None, - "spent_cost_usd": spent_cost if required_available else None, - "remaining_output_tokens": ( - max(0, token_limit - spent_tokens) - if token_limit is not None and measurement_available - else None - ), - "remaining_cost_usd": ( - round(max(0.0, cost_limit - spent_cost), 6) - if cost_limit is not None and spent_cost is not None and required_available - else None - ), - "exceeded": exceeded, - "measurement_status": "measured" if required_available else "unavailable", - "enforcement_status": ( - "blocked_unavailable" if enabled and not required_available - else "exceeded" if exceeded - else "within_budget" - ), - } - - def budget_status(self) -> dict[str, Any]: - """Current spend-budget state (limits, spent, remaining, exceeded).""" - with self._budget_spend_lock: - spent_tokens = self._budget_spent_output_tokens - spent_cost = float(self._budget_spent_cost_usd) - candidate_prices_available = ( - self.budget_max_cost_usd is None - or all( - agent.model in self.price_per_million - for agent in self.agents - if _is_general_chat_agent(agent) - ) - ) - measurement_available = ( - not self._budget_unavailable_run_ids and candidate_prices_available - ) - return self._budget_block( - spent_tokens, - spent_cost if self.price_per_million else None, - measurement_available=measurement_available, - ) - - def analytics_snapshot(self, locale_bundles: dict[str, dict[str, str]] | None = None) -> dict[str, Any]: - """Return source-backed local KPI definitions from in-memory runtime state.""" - runs = self._completed_workflow_runs() - conducted_runs = [run for run in runs if run["mode"] == "conduct"] - trace_complete_count = sum(1 for run in conducted_runs if self._is_trace_complete(run)) - policy_safe_count = sum(1 for run in runs if self._is_policy_safe_run(run)) - event_counts = Counter(event["event_name"] for event in self._analytics_events) - successful_chat_requests = sum( - 1 - for event in self._analytics_events - if event["event_name"] == "chat_completion_requested" - and event["event_detail"].get("status_code") == 200 - ) - route_count = sum(1 for run in runs if run["mode"] == "route") - conduct_count = sum(1 for run in runs if run["mode"] == "conduct") - step_count = sum(len(run["trace"]) for run in runs) - provider_exclusion_misses = sum(self._provider_exclusion_miss_count(run) for run in runs) - locale_parity = self._locale_key_parity(locale_bundles or {}) - - return { - "measurement_status": "local_runtime_snapshot", - "source_note": "Metrics are measured from this process in-memory runtime, not production telemetry.", - "event_counts": dict(sorted(event_counts.items())), - "kpis": [ - { - "metric_name": "compatible_api_adoption", - "label": "Compatible API adoption", - "value": successful_chat_requests, - "unit": "successful_requests", - "source": "chat_completion_requested events", - }, - { - "metric_name": "trace_complete_workflow_rate", - "label": "Trace-complete workflow rate", - "numerator": trace_complete_count, - "denominator": len(conducted_runs), - "value_percent": self._percent(trace_complete_count, len(conducted_runs)), - "source": "workflow_runs conduct traces", - }, - { - "metric_name": "policy_safe_routing_rate", - "label": "Policy-safe routing rate", - "numerator": policy_safe_count, - "denominator": len(runs), - "value_percent": self._percent(policy_safe_count, len(runs)), - "source": "workflow_runs policy snapshots", - }, - ], - "drivers": [ - { - "metric_name": "route_versus_conduct_mix", - "label": "Route-versus-conduct mix", - "counts": {"route": route_count, "conduct": conduct_count}, - "source": "workflow_runs mode", - }, - { - "metric_name": "evaluation_replay_usage", - "label": "Evaluation replay usage", - "value": event_counts.get("evaluation_run_created", 0), - "unit": "runs", - "source": "evaluation_run_created events", - }, - { - "metric_name": "agent_health_coverage", - "label": "Agent health coverage", - "numerator": len([agent for agent in self.agents if agent.id and agent.model and agent.base_url]), - "denominator": len(self.agents), - "value_percent": self._percent( - len([agent for agent in self.agents if agent.id and agent.model and agent.base_url]), - len(self.agents), - ), - "source": "agent pool configuration", - }, - ], - "guardrails": [ - { - "metric_name": "provider_exclusion_miss_rate", - "label": "Provider exclusion miss rate", - "value": provider_exclusion_misses, - "denominator": step_count, - "value_percent": self._percent(provider_exclusion_misses, step_count), - "source": "workflow trace agent selections", - }, - { - "metric_name": "locale_key_parity", - "label": "Locale key parity", - **locale_parity, - "source": "admin locale bundles", - }, - ], - } - - def sales_readiness_report( - self, - locale_bundles: dict[str, dict[str, str]] | None = None, - security_profile: dict[str, Any] | None = None, - ) -> dict[str, Any]: - """Return a local, evidence-backed sales-readiness gate for enterprise pilots.""" - analytics = self.analytics_snapshot(locale_bundles=locale_bundles) - admin_state = self.admin_state() - runs = self._completed_workflow_runs() - conducted_runs = [run for run in runs if run["mode"] == "conduct"] - trace_complete_count = sum(1 for run in conducted_runs if self._is_trace_complete(run)) - event_counts = analytics["event_counts"] - criteria = [ - self._criterion( - "api_compatibility", - "OpenAI-compatible API", - "pass" if event_counts.get("chat_completion_requested", 0) > 0 else "warn", - f"{event_counts.get('chat_completion_requested', 0)} compatible chat requests recorded", - "Run a /v1/chat/completions smoke test before an enterprise evaluation.", - ), - self._criterion( - "admin_evidence", - "Operator evidence surface", - "pass" if admin_state["agents"] and admin_state["policy"] else "fail", - f"{len(admin_state['agents'])} agents, {len(admin_state['recent_audit_events'])} audit events exposed", - "Expose agent pool, policy, and audit state before positioning the product as sellable.", - ), - self._criterion( - "trace_evidence", - "Workflow trace evidence", - "pass" if trace_complete_count > 0 else "warn", - f"{trace_complete_count} complete conducted traces across {len(conducted_runs)} conducted runs", - "Run a conduct-mode workflow so access-list and verifier evidence are visible.", - ), - self._criterion( - "evaluation_replay", - "Evaluation replay", - "pass" if event_counts.get("evaluation_run_created", 0) > 0 else "warn", - f"{event_counts.get('evaluation_run_created', 0)} evaluation replay runs recorded", - "Run at least one evaluation replay before customer-facing pilot review.", - ), - self._security_posture_criterion(security_profile or {}), - self._criterion( - "analytics_truthfulness", - "Analytics truthfulness", - "pass" if analytics["measurement_status"] == "local_runtime_snapshot" else "fail", - analytics["source_note"], - "Label metrics as proposed definitions unless backed by measured runtime telemetry.", - ), - self._locale_readiness_criterion(analytics), - self._provider_egress_criterion(), - ] - summary = self._criteria_summary(criteria) - readiness_summary = {"pass": summary["pass"], "warn": summary["warn"], "fail": summary["fail"]} - if summary["fail"]: - readiness_status = "not_ready" - elif summary["warn"]: - readiness_status = "pilot_ready_with_warnings" - else: - readiness_status = "sales_ready" - - return { - "readiness_status": readiness_status, - "measurement_status": "local_runtime_snapshot", - "source_note": ( - "Sales readiness is based on this process-local runtime, configuration, and " - "documentation evidence; it is not a production compliance certificate." - ), - "summary": readiness_summary, - "readiness_summary": readiness_summary, - "criteria": criteria, - } - - def commercial_readiness_report( - self, - target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, - locale_bundles: dict[str, dict[str, str]] | None = None, - security_profile: dict[str, Any] | None = None, - ) -> dict[str, Any]: - """Return a diligence-oriented readiness gate for high-value enterprise sales.""" - sales_readiness = self.sales_readiness_report( - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - analytics = self.analytics_snapshot(locale_bundles=locale_bundles) - sales_rows = self._criteria_by_name(sales_readiness["criteria"]) - analytics_guardrails = self._metrics_by_name(analytics["guardrails"]) - documentation = self._commercial_documentation_profile() - security_profile = security_profile or {} - policy_safe_metric = self._metrics_by_name(analytics["kpis"])["policy_safe_routing_rate"] - provider_metric = analytics_guardrails["provider_exclusion_miss_rate"] - locale_metric = analytics_guardrails["locale_key_parity"] - - criteria = [ - self._criterion( - "product_capability_evidence", - "Product capability evidence", - "pass" if sales_readiness["readiness_status"] == "sales_ready" else "warn", - ( - f"sales_readiness={sales_readiness['readiness_status']}; " - f"{sales_readiness['readiness_summary']['pass']} sales criteria passing" - ), - "Resolve all sales-readiness warnings before presenting the product for a high-value diligence review.", - ), - self._criterion( - "security_and_access_control", - "Security and access control", - "pass" - if sales_rows["security_posture"]["status"] == "pass" - and sales_rows["provider_egress_safety"]["status"] == "pass" - else "fail", - ( - f"{sales_rows['security_posture']['evidence']}; " - f"{sales_rows['provider_egress_safety']['evidence']}" - ), - "Keep split admin/inference tokens, private bind defaults, hidden traces, and safe provider egress.", - ), - self._criterion( - "operational_resilience", - "Operational resilience", - "pass" - if int(security_profile.get("rate_limit_requests") or 0) > 0 - and int(security_profile.get("max_concurrent_runs") or 0) > 0 - and policy_safe_metric.get("value_percent") == 100.0 - else "warn", - ( - f"rate_limit_requests={security_profile.get('rate_limit_requests')}; " - f"max_concurrent_runs={security_profile.get('max_concurrent_runs')}; " - f"policy_safe_routing_rate={policy_safe_metric.get('value_percent')}%" - ), - "Publish production SLOs, backup policy, and incident runbooks before a production sale.", - ), - self._criterion( - "audit_and_compliance_evidence", - "Audit and compliance evidence", - "pass" - if sales_rows["trace_evidence"]["status"] == "pass" - and provider_metric.get("value") == 0 - else "warn", - ( - f"{sales_rows['trace_evidence']['evidence']}; " - f"provider_exclusion_misses={provider_metric.get('value')}" - ), - "Capture customer-specific access reports and compliance exceptions during paid pilot onboarding.", - ), - self._criterion( - "buyer_due_diligence_packet", - "Buyer due-diligence packet", - "pass" if not documentation["missing_documents"] else "warn", - ( - f"{documentation['present_count']}/{documentation['required_count']} required documents present; " - f"missing={', '.join(documentation['missing_documents']) or 'none'}" - ), - "Complete README, security, API, analytics, product, and commercial readiness documents.", - ), - self._criterion( - "support_and_localization", - "Support and localization", - "pass" if locale_metric.get("value_percent") == 100.0 and documentation["has_security_policy"] else "warn", - ( - f"locale_key_parity={locale_metric.get('value_percent')}%; " - f"security_policy={documentation['has_security_policy']}" - ), - "Keep Korean and English operator copy aligned and publish support ownership for customer operations.", - ), - self._criterion( - "commercial_value_case", - "Commercial value case", - "pass" if target_contract_value_krw >= DEFAULT_COMMERCIAL_TARGET_VALUE_KRW else "warn", - ( - f"target_contract_value_krw={target_contract_value_krw:,}; " - "value case uses compatibility API, evidence control plane, replay, and audit controls" - ), - "Anchor high-value sales review at KRW 2,000,000,000 or higher with buyer-specific ROI evidence.", - ), - ] - summary = self._criteria_summary(criteria) - commercial_summary = {"pass": summary["pass"], "warn": summary["warn"], "fail": summary["fail"]} - if commercial_summary["fail"]: - commercial_status = "not_commercial_ready" - elif commercial_summary["warn"]: - commercial_status = "commercial_ready_with_warnings" - else: - commercial_status = "commercial_ready" - - return { - "commercial_status": commercial_status, - "target_contract_value_krw": target_contract_value_krw, - "target_contract_value_display": f"KRW {target_contract_value_krw:,}", - "measurement_status": "local_due_diligence_snapshot", - "source_note": ( - "Commercial readiness is based on process-local runtime, repository documentation, " - "security configuration, and analytics evidence; it is not a valuation guarantee, " - "purchase commitment, or production compliance certificate." - ), - "summary": commercial_summary, - "commercial_summary": commercial_summary, - "criteria": criteria, - "documentation": documentation, - "sales_readiness": sales_readiness, - } - - def commercial_evidence_manifest_report( - self, - target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, - locale_bundles: dict[str, dict[str, str]] | None = None, - security_profile: dict[str, Any] | None = None, - ) -> dict[str, Any]: - """Return the evidence index for commercial readiness review.""" - commercial = self.commercial_readiness_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - analytics = self.analytics_snapshot(locale_bundles=locale_bundles) - commercial_rows = self._criteria_by_name(commercial["criteria"]) - root = Path(__file__).resolve().parents[1] - - def has_file(path: str) -> bool: - return (root / path).is_file() - - items = [ - self._buyer_evidence_item( - "product_scope", - "Product scope", - "Economic buyer", - ["README.md", "docs/product_planning.md", "docs/commercial_readiness.md"], - "repository_artifact", - "ready" if all(has_file(path) for path in ("README.md", "docs/product_planning.md", "docs/commercial_readiness.md")) else "blocked", - "Single enterprise orchestration control plane is documented.", - "Keep product scope unified for buyer review.", - ), - self._buyer_evidence_item( - "compatible_inference_api", - "Compatible inference API", - "Platform reviewer", - ["/v1/chat/completions", "docs/rest_api_design.md", "tests/test_api_contract.py"], - "repository_artifact", - "ready" if has_file("docs/rest_api_design.md") and has_file("tests/test_api_contract.py") else "blocked", - "OpenAI-compatible endpoint and API contract tests are present.", - "Restore API contract docs and tests before buyer review.", - ), - self._buyer_evidence_item( - "admin_evidence_control_plane", - "Admin evidence control plane", - "Platform operator", - ["/admin", "/admin/state", "docs/screen_design.md"], - "repository_artifact", - "ready" if has_file("docs/screen_design.md") else "blocked", - "Admin screen design and runtime state endpoint are present.", - "Restore admin evidence design before buyer review.", - ), - self._buyer_evidence_item( - "sales_readiness", - "Sales readiness", - "Product owner", - ["/api/v1/sales_readiness/latest", "tests/test_sales_readiness.py"], - "measured_local", - "ready" if commercial["sales_readiness"]["readiness_summary"]["fail"] == 0 else "blocked", - f"sales_readiness={commercial['sales_readiness']['readiness_status']}", - "Resolve sales-readiness failures before commercial review.", - ), - self._buyer_evidence_item( - "commercial_readiness", - "Commercial readiness", - "Economic buyer", - ["/api/v1/commercial_readiness/latest", "tests/test_commercial_readiness.py"], - "measured_local", - "ready" if commercial["commercial_summary"]["fail"] == 0 else "blocked", - f"commercial_status={commercial['commercial_status']}", - "Resolve commercial-readiness failures before buyer review.", - ), - self._buyer_evidence_item( - "analytics_honesty", - "Analytics honesty", - "Analytics reviewer", - ["/api/v1/analytics_snapshots/latest", "docs/analytics_spec.md"], - "measured_local", - "ready" if analytics["measurement_status"] == "local_runtime_snapshot" else "blocked", - analytics["source_note"], - "Keep measured local evidence separate from production KPI proposals.", - ), - self._buyer_evidence_item( - "access_list_evidence", - "Access-list evidence", - "Security and compliance reviewer", - ["/api/v1/access_reports/{workflow_run_id}", "docs/product_planning.md"], - "repository_artifact", - "ready" if has_file("docs/product_planning.md") else "blocked", - "Workflow trace and access-report evidence are documented.", - "Restore access-list evidence docs before compliance review.", - ), - self._buyer_evidence_item( - "evaluation_replay", - "Evaluation replay", - "Quality reviewer", - ["/api/v1/evaluation_runs", "docs/screen_design.md"], - "repository_artifact", - "ready" if has_file("docs/screen_design.md") else "blocked", - "Evaluation replay surface is documented.", - "Restore evaluation replay docs before quality review.", - ), - self._buyer_evidence_item( - "security_posture", - "Security posture", - "Security reviewer", - ["SECURITY.md", "tests/test_security_hardening.py", "CodeQL", "Dependency review", "Trivy"], - "measured_local", - "ready" if commercial_rows["security_and_access_control"]["status"] == "pass" else "blocked", - commercial_rows["security_and_access_control"]["evidence"], - "Resolve concrete security failures before buyer review.", - ), - self._buyer_evidence_item( - "visual_stakeholder_evidence", - "Visual stakeholder evidence", - "Stakeholder reviewer", - ["docs/figma_artifacts.md", "Figma design file", "FigJam board", "Figma Slides deck"], - "figma_artifact", - "ready" if has_file("docs/figma_artifacts.md") else "blocked", - "Editable Figma, FigJam, and Slides artifacts are recorded.", - "Record editable Figma artifacts before stakeholder review.", - ), - self._buyer_evidence_item( - "buyer_diligence_packet", - "Buyer diligence packet", - "Procurement reviewer", - ["docs/commercial_buyer_diligence_packet.md"], - "repository_artifact", - "ready" if has_file("docs/commercial_buyer_diligence_packet.md") else "blocked", - "Buyer questions map to evidence paths and caveats.", - "Restore the buyer diligence packet before procurement review.", - ), - self._buyer_evidence_item( - "buyer_acceptance_runbook", - "Buyer acceptance runbook", - "Procurement reviewer", - ["docs/commercial_buyer_acceptance_runbook.md"], - "repository_artifact", - "ready" if has_file("docs/commercial_buyer_acceptance_runbook.md") else "blocked", - "Go, warning, and no-go rules are documented.", - "Restore acceptance runbook before procurement review.", - ), - self._buyer_evidence_item( - "buyer_evidence_manifest", - "Buyer evidence manifest", - "Deal owner", - ["docs/commercial_buyer_evidence_manifest.md", "/api/v1/commercial_evidence_manifests/latest"], - "measured_local", - "ready" if has_file("docs/commercial_buyer_evidence_manifest.md") else "blocked", - "Buyer evidence is indexed by owner, source, evidence type, and completion state.", - "Restore the manifest document and endpoint before buyer review.", - ), - self._buyer_evidence_item( - "packaging_decision", - "Packaging decision", - "Procurement and security reviewer", - ["docs/library_research.md", "docs/commercial_plugin_operating_model.md"], - "repository_artifact", - "ready" if has_file("docs/library_research.md") and has_file("docs/commercial_plugin_operating_model.md") else "blocked", - "Single repo and one deployable product remain the current decision.", - "Document extraction triggers before changing package boundaries.", - ), - self._buyer_evidence_item( - "production_slo_support", - "Production SLO and support proof", - "Customer operations reviewer", - ["production telemetry", "incident drill records", "support ownership"], - "proposed_until_production", - "warning", - "Production SLO, incident, and support evidence require a deployed customer environment.", - "Collect production telemetry during paid onboarding.", - ), - self._buyer_evidence_item( - "buyer_specific_roi_legal", - "Buyer-specific ROI and legal proof", - "Economic buyer and procurement", - ["ROI model", "legal questionnaire", "data-processing terms", "support plan"], - "proposed_until_buyer_specific", - "warning", - "ROI, legal, procurement, and deployment evidence require a named buyer.", - "Collect buyer-specific inputs during account diligence.", - ), - ] - summary = self._buyer_manifest_summary(items) - if summary["by_completion_state"].get("blocked", 0): - manifest_status = "buyer_review_blocked" - elif summary["by_completion_state"].get("warning", 0): - manifest_status = "buyer_review_ready_with_warnings" - else: # pragma: no cover - unreachable while this report carries literal buyer-specific warning sections - manifest_status = "buyer_review_ready" # pragma: no cover - - return { - "manifest_status": manifest_status, - "target_contract_value_krw": target_contract_value_krw, - "target_contract_value_display": f"KRW {target_contract_value_krw:,}", - "measurement_status": "local_buyer_evidence_manifest", - "source_note": ( - "Buyer evidence manifest combines process-local runtime reports, repository documents, " - "Figma artifact records, and explicit production or buyer-specific caveats; it is not a " - "valuation guarantee, purchase commitment, or production compliance certificate." - ), - "summary": summary, - "items": items, - "related_runtime_reports": { - "commercial_status": commercial["commercial_status"], - "sales_readiness_status": commercial["sales_readiness"]["readiness_status"], - "analytics_measurement_status": analytics["measurement_status"], - }, - } - - def commercial_handoff_bundle_report( - self, - target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, - locale_bundles: dict[str, dict[str, str]] | None = None, - security_profile: dict[str, Any] | None = None, - ) -> dict[str, Any]: - """Return the commercial handoff bundle for sale-readiness evidence.""" - manifest = self.commercial_evidence_manifest_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - manifest_summary = manifest["summary"]["by_completion_state"] - root = Path(__file__).resolve().parents[1] - - def has_file(path: str) -> bool: - return (root / path).is_file() - - runtime_state = "blocked" if manifest_summary.get("blocked", 0) else "ready" - included_artifacts = [ - self._buyer_evidence_item( - "runtime_reports", - "Runtime reports", - "Deal owner", - [ - "/api/v1/sales_readiness/latest", - "/api/v1/commercial_readiness/latest", - "/api/v1/commercial_evidence_manifests/latest", - "/api/v1/analytics_snapshots/latest", - ], - "measured_local", - runtime_state, - ( - f"buyer_manifest_status={manifest['manifest_status']}; " - f"commercial_status={manifest['related_runtime_reports']['commercial_status']}" - ), - "Resolve runtime report blockers before buyer handoff.", - ), - self._buyer_evidence_item( - "repository_packet", - "Repository packet", - "Procurement reviewer", - [ - "README.md", - "docs/commercial_buyer_diligence_packet.md", - "docs/commercial_buyer_acceptance_runbook.md", - "docs/commercial_buyer_evidence_manifest.md", - "docs/commercial_buyer_handoff_bundle.md", - ], - "repository_artifact", - "ready" - if all( - has_file(path) - for path in ( - "README.md", - "docs/commercial_buyer_diligence_packet.md", - "docs/commercial_buyer_acceptance_runbook.md", - "docs/commercial_buyer_evidence_manifest.md", - "docs/commercial_buyer_handoff_bundle.md", - ) - ) - else "blocked", - "Buyer-facing diligence, acceptance, manifest, and handoff documents are present.", - "Restore missing buyer packet documents before procurement review.", - ), - self._buyer_evidence_item( - "figma_stakeholder_artifacts", - "Figma stakeholder artifacts", - "Stakeholder reviewer", - ["docs/figma_artifacts.md", "Figma design file", "FigJam board", "Figma Slides deck"], - "figma_artifact", - "ready" if has_file("docs/figma_artifacts.md") else "blocked", - "Editable Figma, FigJam, and Slides artifacts are recorded without Code Connect.", - "Record editable stakeholder artifacts before buyer handoff.", - ), - self._buyer_evidence_item( - "verification_commands", - "Verification commands", - "Technical reviewer", - [ - "tests/test_buyer_handoff_bundle.py", - "tests/test_buyer_evidence_manifest.py", - "tests/test_plugin_driven_artifacts.py", - "tests/test_api_contract.py", - "pytest -q", - ], - "measured_local", - "ready" - if all( - has_file(path) - for path in ( - "tests/test_buyer_handoff_bundle.py", - "tests/test_buyer_evidence_manifest.py", - "tests/test_plugin_driven_artifacts.py", - "tests/test_api_contract.py", - ) - ) - else "blocked", - "Focused contract tests and full pytest verification are named for buyer review.", - "Restore focused tests before technical buyer handoff.", - ), - self._buyer_evidence_item( - "packaging_decision", - "Packaging decision", - "Procurement and security reviewer", - ["docs/library_research.md", "docs/commercial_plugin_operating_model.md"], - "repository_artifact", - "ready" if has_file("docs/library_research.md") and has_file("docs/commercial_plugin_operating_model.md") else "blocked", - "Single repository and one deployable product remain the current decision.", - "Only extract a library after a second product, independent release cadence, or provenance trigger exists.", - ), - ] - follow_up_items = [ - self._buyer_evidence_item( - "production_handoff_readiness", - "Production handoff readiness", - "Customer operations reviewer", - ["production SLO", "incident drill", "support rota", "deployment history"], - "proposed_until_production", - "warning", - "Production SLO, incident, deployment, and support evidence require a live customer environment.", - "Collect production telemetry and support evidence during paid onboarding.", - ), - self._buyer_evidence_item( - "buyer_specific_commercial_close", - "Buyer-specific commercial close", - "Economic buyer and legal reviewer", - ["ROI model", "legal questionnaire", "data-processing terms", "support plan"], - "proposed_until_buyer_specific", - "warning", - "ROI, legal, procurement, and deployment commitments require a named buyer.", - "Collect buyer-specific inputs during account diligence.", - ), - ] - all_items = included_artifacts + follow_up_items - summary = self._buyer_manifest_summary(all_items) - if summary["by_completion_state"].get("blocked", 0): - bundle_status = "buyer_handoff_blocked" - elif summary["by_completion_state"].get("warning", 0): - bundle_status = "buyer_handoff_ready_with_warnings" - else: # pragma: no cover - unreachable while this report carries literal buyer-specific warning sections - bundle_status = "buyer_handoff_ready" # pragma: no cover - - return { - "bundle_status": bundle_status, - "target_contract_value_krw": target_contract_value_krw, - "target_contract_value_display": f"KRW {target_contract_value_krw:,}", - "measurement_status": "local_buyer_handoff_bundle", - "source_note": ( - "Buyer handoff bundle packages local runtime reports, repository documents, " - "Figma artifact records, verification commands, and explicit production or " - "buyer-specific caveats; it is not a valuation guarantee, purchase commitment, " - "or production compliance certificate." - ), - "summary": summary, - "included_artifacts": included_artifacts, - "follow_up_items": follow_up_items, - "acceptance_gates": [ - { - "gate_name": "go", - "rule": "no blocked included artifacts and concrete security checks have no failure", - }, - { - "gate_name": "warning", - "rule": "production or buyer-specific evidence remains proposed and explicitly caveated", - }, - { - "gate_name": "blocked", - "rule": "security failure, API contract regression, document mismatch, product defect, or Code Connect usage", - }, - ], - "related_runtime_reports": { - "buyer_manifest_status": manifest["manifest_status"], - **manifest["related_runtime_reports"], - }, - "library_split_decision": { - "decision": "keep_single_product", - "reason": "No second product, independent release cadence, or security provenance trigger exists.", - "allowed_future_triggers": [ - "second product requires core only", - "independent release cadence is needed", - "buyer security provenance requires package extraction", - ], - }, - "plugin_traceability": { - "figma": "editable stakeholder artifacts and FigJam workflow", - "product_design": "buyer handoff surface and admin evidence workflow", - "superpowers": "implementation plan and verification checklist", - "ponytail": "single-product packaging and no new dependency", - "data_analytics": "measured versus proposed evidence separation", - }, - } - - def buyer_evidence_manifest_report( - self, - target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, - locale_bundles: dict[str, dict[str, str]] | None = None, - security_profile: dict[str, Any] | None = None, - ) -> dict[str, Any]: - """Return the deprecated manifest alias for existing Python consumers.""" - return self.commercial_evidence_manifest_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - - def buyer_handoff_bundle_report( - self, - target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, - locale_bundles: dict[str, dict[str, str]] | None = None, - security_profile: dict[str, Any] | None = None, - ) -> dict[str, Any]: - """Return the deprecated handoff alias for existing Python consumers.""" - return self.commercial_handoff_bundle_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - - def saleability_decision_report( - self, - target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, - locale_bundles: dict[str, dict[str, str]] | None = None, - security_profile: dict[str, Any] | None = None, - ) -> dict[str, Any]: - """Return the buyer-facing saleability decision for high-value review.""" - handoff = self.commercial_handoff_bundle_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - # Blockers must be hashable, operator-readable identifiers: downstream - # readiness reports deduplicate inherited blocker lists via - # ``dict.fromkeys``, which crashes on unhashable evidence-item dicts. - concrete_blockers = [ - item["item_name"] - for item in handoff["included_artifacts"] - if item["completion_state"] == "blocked" - ] - warning_conditions = [ - item - for item in handoff["follow_up_items"] - if item["completion_state"] == "warning" - ] - if concrete_blockers: - saleability_status = "saleability_blocked" - decision_label = "Blocked by concrete defect" - elif warning_conditions: - saleability_status = "saleability_ready_with_warnings" - decision_label = "Ready for buyer diligence with explicit warnings" - else: # pragma: no cover - unreachable while handoff follow-up warnings are literal report sections - saleability_status = "saleability_ready" # pragma: no cover - decision_label = "Ready for buyer diligence" # pragma: no cover - - return { - "saleability_status": saleability_status, - "decision_label": decision_label, - "target_contract_value_krw": target_contract_value_krw, - "target_contract_value_display": f"KRW {target_contract_value_krw:,}", - "measurement_status": "local_saleability_decision", - "source_note": ( - "Saleability decision is a local buyer due-diligence gate based on runtime " - "reports, repository documents, Figma artifacts, verification commands, and " - "explicit caveats; it is not a valuation guarantee, purchase commitment, " - "or production compliance certificate." - ), - "decision_summary": { - "included_artifact_count": len(handoff["included_artifacts"]), - "blocked_count": len(concrete_blockers), - "warning_count": len(warning_conditions), - "review_process_is_blocker": False, - }, - "decision_basis": [ - { - "basis_name": "buyer_handoff_bundle", - "status": handoff["bundle_status"], - "source": "/api/v1/commercial_handoff_bundles/latest", - }, - { - "basis_name": "buyer_evidence_manifest", - "status": handoff["related_runtime_reports"]["buyer_manifest_status"], - "source": "/api/v1/commercial_evidence_manifests/latest", - }, - { - "basis_name": "commercial_readiness", - "status": handoff["related_runtime_reports"]["commercial_status"], - "source": "/api/v1/commercial_readiness/latest", - }, - { - "basis_name": "sales_readiness", - "status": handoff["related_runtime_reports"]["sales_readiness_status"], - "source": "/api/v1/sales_readiness/latest", - }, - ], - "concrete_blockers": concrete_blockers, - "warning_conditions": warning_conditions, - "review_process_policy": { - "is_blocker": False, - "non_blocker_examples": [ - "reviewer delay", - "review bot delay", - "queued model review", - "pending check without concrete failure", - ], - "blocker_definition": "concrete security, API contract, document, or product defect", - }, - "related_runtime_reports": { - "buyer_handoff_status": handoff["bundle_status"], - **handoff["related_runtime_reports"], - }, - "library_split_decision": handoff["library_split_decision"], - "plugin_traceability": handoff["plugin_traceability"], - } - - def commercial_evidence_export_report( - self, - target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, - locale_bundles: dict[str, dict[str, str]] | None = None, - security_profile: dict[str, Any] | None = None, - ) -> dict[str, Any]: - """Return a portable buyer due-diligence export index for commercial review.""" - saleability = self.saleability_decision_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - root = Path(__file__).resolve().parents[1] - - def has_file(path: str) -> bool: - return (root / path).is_file() - - concrete_blockers = saleability["concrete_blockers"] - required_external_evidence = [ - { - "evidence_name": item["item_name"], - "label": item["label"], - "reviewer": item["reviewer"], - "sources": item["sources"], - "evidence_type": item["evidence_type"], - "evidence": item["evidence"], - "next_action": item["next_action"], - } - for item in saleability["warning_conditions"] - ] - saleability_state = "blocked" if saleability["saleability_status"] == "saleability_blocked" else "ready" - export_sections = [ - self._buyer_evidence_item( - "saleability_decision", - "Saleability decision", - "Deal owner", - ["/api/v1/saleability_decisions/latest", "docs/commercial_saleability_decision.md"], - "measured_local", - saleability_state, - f"saleability_status={saleability['saleability_status']}", - "Resolve concrete saleability blockers before exporting buyer evidence.", - ), - self._buyer_evidence_item( - "runtime_reports", - "Runtime reports", - "Technical reviewer", - [ - "/api/v1/sales_readiness/latest", - "/api/v1/commercial_readiness/latest", - "/api/v1/commercial_evidence_manifests/latest", - "/api/v1/commercial_handoff_bundles/latest", - "/api/v1/saleability_decisions/latest", - "/api/v1/analytics_snapshots/latest", - ], - "measured_local", - "blocked" if concrete_blockers else "ready", - ( - f"buyer_handoff_status={saleability['related_runtime_reports']['buyer_handoff_status']}; " - f"buyer_manifest_status={saleability['related_runtime_reports']['buyer_manifest_status']}" - ), - "Resolve blocked runtime reports before buyer export.", - ), - self._buyer_evidence_item( - "buyer_packet_documents", - "Buyer packet documents", - "Procurement reviewer", - [ - "docs/commercial_buyer_diligence_packet.md", - "docs/commercial_buyer_acceptance_runbook.md", - "docs/commercial_buyer_evidence_manifest.md", - "docs/commercial_buyer_handoff_bundle.md", - "docs/commercial_saleability_decision.md", - "docs/commercial_evidence_export.md", - ], - "repository_artifact", - "ready" - if all( - has_file(path) - for path in ( - "docs/commercial_buyer_diligence_packet.md", - "docs/commercial_buyer_acceptance_runbook.md", - "docs/commercial_buyer_evidence_manifest.md", - "docs/commercial_buyer_handoff_bundle.md", - "docs/commercial_saleability_decision.md", - "docs/commercial_evidence_export.md", - ) - ) - else "blocked", - "Buyer diligence, acceptance, manifest, handoff, decision, and export documents are present.", - "Restore missing buyer packet documents before export.", - ), - self._buyer_evidence_item( - "figma_stakeholder_artifacts", - "Figma stakeholder artifacts", - "Stakeholder reviewer", - ["docs/figma_artifacts.md", "Figma design file", "FigJam board", "Figma Slides deck"], - "figma_artifact", - "ready" if has_file("docs/figma_artifacts.md") else "blocked", - "Editable stakeholder artifacts are recorded and Code Connect is excluded.", - "Record Figma artifacts before exporting buyer evidence.", - ), - self._buyer_evidence_item( - "verification_commands", - "Verification commands", - "Technical reviewer", - [ - "tests/test_commercial_evidence_export.py", - "tests/test_saleability_decision.py", - "tests/test_plugin_driven_artifacts.py", - "tests/test_api_contract.py", - "pytest -q", - ], - "measured_local", - "ready" - if all( - has_file(path) - for path in ( - "tests/test_commercial_evidence_export.py", - "tests/test_saleability_decision.py", - "tests/test_plugin_driven_artifacts.py", - "tests/test_api_contract.py", - ) - ) - else "blocked", - "Focused commercial export, saleability, plugin artifact, and API contract tests are named.", - "Restore focused tests before buyer export.", - ), - self._buyer_evidence_item( - "review_process_policy", - "Review process policy", - "Deal owner", - ["docs/commercial_saleability_decision.md", "/api/v1/saleability_decisions/latest"], - "repository_artifact", - "ready", - "Reviewer delay, review bot delay, and queued model review are not concrete blockers.", - "Escalate only concrete security, API contract, document, or product defects.", - ), - self._buyer_evidence_item( - "packaging_decision", - "Packaging decision", - "Procurement and security reviewer", - ["docs/library_research.md", "docs/commercial_plugin_operating_model.md"], - "repository_artifact", - "ready" if has_file("docs/library_research.md") and has_file("docs/commercial_plugin_operating_model.md") else "blocked", - saleability["library_split_decision"]["reason"], - "Only extract a library after a second product, independent release cadence, or provenance trigger exists.", - ), - ] - export_section_summary = self._buyer_manifest_summary(export_sections) - blocked_count = export_section_summary["by_completion_state"]["blocked"] + len(concrete_blockers) - warning_count = len(required_external_evidence) - if blocked_count: - export_status = "commercial_export_blocked" - elif warning_count: - export_status = "commercial_export_ready_with_warnings" - else: # pragma: no cover - unreachable while this report carries literal buyer-specific warning sections - export_status = "commercial_export_ready" # pragma: no cover - - return { - "export_status": export_status, - "target_contract_value_krw": target_contract_value_krw, - "target_contract_value_display": f"KRW {target_contract_value_krw:,}", - "measurement_status": "local_commercial_evidence_export", - "source_note": ( - "Commercial evidence export packages local runtime decisions, repository documents, " - "Figma artifact records, verification commands, review-process policy, packaging decision, " - "and explicit production or buyer-specific evidence gaps; it is not a valuation guarantee, " - "purchase commitment, or production compliance certificate." - ), - "export_summary": { - "section_count": len(export_sections), - "blocked_count": blocked_count, - "warning_count": warning_count, - "review_process_is_blocker": saleability["review_process_policy"]["is_blocker"], - }, - "export_sections": export_sections, - "required_external_evidence": required_external_evidence, - "concrete_blockers": concrete_blockers, - "review_process_policy": saleability["review_process_policy"], - "related_runtime_reports": { - "saleability_status": saleability["saleability_status"], - **saleability["related_runtime_reports"], - }, - "library_split_decision": saleability["library_split_decision"], - "plugin_traceability": saleability["plugin_traceability"], - "export_links": { - "figma_design_file": "https://www.figma.com/design/vsZMd8WAv42HDRgcZuNcWk", - "figjam_board": "https://www.figma.com/board/Wr8iMlB9SHkerHSjv0Pe0M", - "runtime_endpoint": "/api/v1/commercial_evidence_exports/latest", - "documentation": "docs/commercial_evidence_export.md", - }, - } - - def commercial_acceptance_check_report( - self, - target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, - locale_bundles: dict[str, dict[str, str]] | None = None, - security_profile: dict[str, Any] | None = None, - ) -> dict[str, Any]: - """Return the buyer acceptance check over the commercial evidence export.""" - evidence_export = self.commercial_evidence_export_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - root = Path(__file__).resolve().parents[1] - - def has_file(path: str) -> bool: - return (root / path).is_file() - - concrete_blockers = evidence_export["concrete_blockers"] - export_blocked = evidence_export["export_status"] == "commercial_export_blocked" - runtime_state = "blocked" if export_blocked or concrete_blockers else "ready" - acceptance_items = [ - self._buyer_evidence_item( - "runtime_endpoint_chain", - "Runtime endpoint chain", - "Technical reviewer", - [ - "/api/v1/analytics_snapshots/latest", - "/api/v1/sales_readiness/latest", - "/api/v1/commercial_readiness/latest", - "/api/v1/commercial_evidence_manifests/latest", - "/api/v1/commercial_handoff_bundles/latest", - "/api/v1/saleability_decisions/latest", - "/api/v1/commercial_evidence_exports/latest", - ], - "measured_local", - runtime_state, - f"commercial_export_status={evidence_export['export_status']}", - "Resolve blocked runtime report chain before buyer acceptance.", - ), - self._buyer_evidence_item( - "buyer_packet_documents", - "Buyer packet documents", - "Procurement reviewer", - [ - "docs/commercial_buyer_diligence_packet.md", - "docs/commercial_buyer_acceptance_runbook.md", - "docs/commercial_buyer_evidence_manifest.md", - "docs/commercial_buyer_handoff_bundle.md", - "docs/commercial_saleability_decision.md", - "docs/commercial_evidence_export.md", - "docs/commercial_acceptance_check.md", - ], - "repository_artifact", - "ready" - if all( - has_file(path) - for path in ( - "docs/commercial_buyer_diligence_packet.md", - "docs/commercial_buyer_acceptance_runbook.md", - "docs/commercial_buyer_evidence_manifest.md", - "docs/commercial_buyer_handoff_bundle.md", - "docs/commercial_saleability_decision.md", - "docs/commercial_evidence_export.md", - "docs/commercial_acceptance_check.md", - ) - ) - else "blocked", - "Buyer packet documents cover diligence, acceptance, manifest, handoff, decision, export, and check.", - "Restore missing buyer packet documents before buyer acceptance.", - ), - self._buyer_evidence_item( - "admin_operator_surface", - "Admin operator surface", - "Platform operator", - ["/admin", "contextual_orchestrator/admin.py", "/api/v1/commercial_acceptance_checks/latest"], - "repository_artifact", - "ready" if has_file("contextual_orchestrator/admin.py") else "blocked", - "Admin observability surface exposes the commercial acceptance check status with bilingual labels.", - "Expose acceptance check status in admin observability before buyer acceptance.", - ), - self._buyer_evidence_item( - "verification_evidence", - "Verification evidence", - "Technical reviewer", - [ - "tests/test_commercial_acceptance_check.py", - "tests/test_commercial_evidence_export.py", - "tests/test_saleability_decision.py", - "tests/test_plugin_driven_artifacts.py", - "tests/test_api_contract.py", - "pytest -q", - ], - "measured_local", - "ready" - if all( - has_file(path) - for path in ( - "tests/test_commercial_acceptance_check.py", - "tests/test_commercial_evidence_export.py", - "tests/test_saleability_decision.py", - "tests/test_plugin_driven_artifacts.py", - "tests/test_api_contract.py", - ) - ) - else "blocked", - "Focused commercial acceptance, export, saleability, plugin artifact, and API contract tests are named.", - "Restore focused tests before buyer acceptance.", - ), - self._buyer_evidence_item( - "figma_stakeholder_artifacts", - "Figma stakeholder artifacts", - "Stakeholder reviewer", - ["docs/figma_artifacts.md", "Figma design file", "FigJam board", "Figma Slides deck"], - "figma_artifact", - "ready" if has_file("docs/figma_artifacts.md") else "blocked", - "Editable stakeholder artifacts are recorded and Code Connect is excluded.", - "Record editable Figma artifacts before buyer acceptance.", - ), - self._buyer_evidence_item( - "review_process_policy", - "Review process policy", - "Deal owner", - ["docs/commercial_saleability_decision.md", "/api/v1/saleability_decisions/latest"], - "repository_artifact", - "ready", - "Reviewer delay, review bot delay, queued model review, and pending checks without concrete failure are not blockers.", - "Block only on concrete security, API contract, document, or product defects.", - ), - self._buyer_evidence_item( - "packaging_decision", - "Packaging decision", - "Procurement and security reviewer", - ["docs/library_research.md", "docs/commercial_plugin_operating_model.md"], - "repository_artifact", - "ready" if has_file("docs/library_research.md") and has_file("docs/commercial_plugin_operating_model.md") else "blocked", - evidence_export["library_split_decision"]["reason"], - "Only extract a library after a second product, independent release cadence, or provenance trigger exists.", - ), - ] - follow_up_items = [ - self._buyer_evidence_item( - item["evidence_name"], - item["label"], - item["reviewer"], - item["sources"], - item["evidence_type"], - "warning", - item["evidence"], - item["next_action"], - ) - for item in evidence_export["required_external_evidence"] - ] - all_items = acceptance_items + follow_up_items - summary = self._buyer_manifest_summary(all_items) - blocked_count = summary["by_completion_state"]["blocked"] + len(concrete_blockers) - warning_count = summary["by_completion_state"]["warning"] - if blocked_count: - acceptance_status = "commercial_acceptance_blocked" - elif warning_count: - acceptance_status = "commercial_acceptance_ready_with_warnings" - else: # pragma: no cover - unreachable while this report carries literal buyer-specific warning sections - acceptance_status = "commercial_acceptance_ready" # pragma: no cover - - return { - "acceptance_status": acceptance_status, - "target_contract_value_krw": target_contract_value_krw, - "target_contract_value_display": f"KRW {target_contract_value_krw:,}", - "measurement_status": "local_commercial_acceptance_check", - "source_note": ( - "Commercial acceptance check evaluates local commercial evidence export, admin visibility, " - "repository packet, Figma artifacts, verification commands, review-process policy, packaging " - "decision, and explicit production or buyer-specific gaps; it is not a valuation guarantee, " - "purchase commitment, or production compliance certificate." - ), - "acceptance_summary": { - "item_count": len(all_items), - "blocked_count": blocked_count, - "warning_count": warning_count, - "review_process_is_blocker": evidence_export["review_process_policy"]["is_blocker"], - }, - "acceptance_items": acceptance_items, - "follow_up_items": follow_up_items, - "concrete_blockers": concrete_blockers, - "required_external_evidence": evidence_export["required_external_evidence"], - "acceptance_gates": [ - { - "gate_name": "go", - "rule": "no blocked acceptance items and no required external evidence gaps", - }, - { - "gate_name": "warning", - "rule": "only production or buyer-specific evidence remains explicitly caveated", - }, - { - "gate_name": "blocked", - "rule": "security failure, API contract regression, document mismatch, product defect, or Code Connect usage", - }, - ], - "review_process_policy": evidence_export["review_process_policy"], - "related_runtime_reports": { - "commercial_export_status": evidence_export["export_status"], - **evidence_export["related_runtime_reports"], - }, - "library_split_decision": evidence_export["library_split_decision"], - "plugin_traceability": evidence_export["plugin_traceability"], - "acceptance_links": { - "figma_design_file": "https://www.figma.com/design/vsZMd8WAv42HDRgcZuNcWk", - "figjam_board": "https://www.figma.com/board/Wr8iMlB9SHkerHSjv0Pe0M", - "runtime_endpoint": "/api/v1/commercial_acceptance_checks/latest", - "documentation": "docs/commercial_acceptance_check.md", - }, - } - - def commercial_release_candidate_report( - self, - target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, - locale_bundles: dict[str, dict[str, str]] | None = None, - security_profile: dict[str, Any] | None = None, - release_authority: Mapping[str, Any] | None = None, - ) -> dict[str, Any]: - """Return product evidence separately from protected release authority.""" - acceptance = self.commercial_acceptance_check_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - root = Path(__file__).resolve().parents[1] - - def has_file(path: str) -> bool: - return (root / path).is_file() - - concrete_blockers = acceptance["concrete_blockers"] - acceptance_blocked = acceptance["acceptance_status"] == "commercial_acceptance_blocked" - runtime_state = "blocked" if acceptance_blocked or concrete_blockers else "ready" - release_authorization = evaluate_release_authorization(release_authority) - release_artifacts = [ - self._buyer_evidence_item( - "commercial_acceptance_check", - "Commercial acceptance check", - "Deal owner", - ["/api/v1/commercial_acceptance_checks/latest", "docs/commercial_acceptance_check.md"], - "measured_local", - runtime_state, - f"acceptance_status={acceptance['acceptance_status']}", - "Resolve blocked acceptance checks before tagging a release candidate.", - ), - self._buyer_evidence_item( - "runtime_endpoint_chain", - "Runtime endpoint chain", - "Technical reviewer", - [ - "/api/v1/analytics_snapshots/latest", - "/api/v1/sales_readiness/latest", - "/api/v1/commercial_readiness/latest", - "/api/v1/commercial_evidence_manifests/latest", - "/api/v1/commercial_handoff_bundles/latest", - "/api/v1/saleability_decisions/latest", - "/api/v1/commercial_evidence_exports/latest", - "/api/v1/commercial_acceptance_checks/latest", - "/api/v1/commercial_release_candidates/latest", - ], - "measured_local", - runtime_state, - "Commercial release candidate endpoint is chained after acceptance, export, decision, handoff, manifest, readiness, and analytics reports.", - "Restore blocked runtime endpoint evidence before release-candidate handoff.", - ), - self._buyer_evidence_item( - "repository_distribution_packet", - "Repository distribution packet", - "Procurement reviewer", - [ - "README.md", - "docs/rest_api_design.md", - "docs/commercial_buyer_diligence_packet.md", - "docs/commercial_buyer_acceptance_runbook.md", - "docs/commercial_buyer_evidence_manifest.md", - "docs/commercial_buyer_handoff_bundle.md", - "docs/commercial_saleability_decision.md", - "docs/commercial_evidence_export.md", - "docs/commercial_acceptance_check.md", - "docs/commercial_release_candidate.md", - ], - "repository_artifact", - "ready" - if all( - has_file(path) - for path in ( - "README.md", - "docs/rest_api_design.md", - "docs/commercial_buyer_diligence_packet.md", - "docs/commercial_buyer_acceptance_runbook.md", - "docs/commercial_buyer_evidence_manifest.md", - "docs/commercial_buyer_handoff_bundle.md", - "docs/commercial_saleability_decision.md", - "docs/commercial_evidence_export.md", - "docs/commercial_acceptance_check.md", - "docs/commercial_release_candidate.md", - ) - ) - else "blocked", - "Repository packet contains the README, REST API contract notes, and commercial buyer documents.", - "Restore missing distribution documents before buyer release-candidate review.", - ), - self._buyer_evidence_item( - "security_package_metadata", - "Security and package metadata", - "Security reviewer", - [ - "LICENSE", - "SECURITY.md", - "pyproject.toml", - "requirements.lock", - ".github/workflows/security.yml", - ".github/dependabot.yml", - "ContextualWisdomLab/.github central required security workflows", - ], - "repository_artifact", - "ready" - if all( - has_file(path) - for path in ( - "LICENSE", - "SECURITY.md", - "pyproject.toml", - "requirements.lock", - ".github/workflows/security.yml", - ".github/dependabot.yml", - ) - ) - else "blocked", - "License, security policy, package metadata, locked requirements, local supply-chain workflow, Dependabot metadata, and central required security workflows are present.", - "Restore missing security or package metadata before release-candidate handoff.", - ), - self._buyer_evidence_item( - "admin_operator_surface", - "Admin operator surface", - "Platform operator", - ["/admin", "contextual_orchestrator/admin.py", "/api/v1/commercial_release_candidates/latest"], - "repository_artifact", - "ready" if has_file("contextual_orchestrator/admin.py") else "blocked", - "Admin observability surface exposes the release-candidate status with bilingual labels.", - "Expose release-candidate status in admin observability before buyer handoff.", - ), - self._buyer_evidence_item( - "verification_evidence", - "Verification evidence", - "Technical reviewer", - [ - "tests/test_commercial_release_candidate.py", - "tests/test_commercial_acceptance_check.py", - "tests/test_commercial_evidence_export.py", - "tests/test_saleability_decision.py", - "tests/test_plugin_driven_artifacts.py", - "tests/test_api_contract.py", - "pytest -q", - ], - "measured_local", - "ready" - if all( - has_file(path) - for path in ( - "tests/test_commercial_release_candidate.py", - "tests/test_commercial_acceptance_check.py", - "tests/test_commercial_evidence_export.py", - "tests/test_saleability_decision.py", - "tests/test_plugin_driven_artifacts.py", - "tests/test_api_contract.py", - ) - ) - else "blocked", - "Focused release-candidate, acceptance, export, saleability, plugin artifact, and API contract tests are named.", - "Restore focused verification before release-candidate handoff.", - ), - self._buyer_evidence_item( - "figma_stakeholder_artifacts", - "Figma stakeholder artifacts", - "Stakeholder reviewer", - ["docs/figma_artifacts.md", "Figma design file", "FigJam board", "Figma Slides deck"], - "figma_artifact", - "ready" if has_file("docs/figma_artifacts.md") else "blocked", - "Editable stakeholder artifacts are recorded and Code Connect is excluded.", - "Record editable Figma artifacts before buyer release-candidate review.", - ), - self._buyer_evidence_item( - "review_process_policy", - "Review process policy", - "Deal owner", - ["docs/commercial_saleability_decision.md", "docs/commercial_release_candidate.md"], - "repository_artifact", - "ready", - "Product evidence remains inspectable while protected release authority is evaluated separately.", - "Supply a fresh protected-main authority snapshot before authorizing release.", - ), - self._buyer_evidence_item( - "release_authority_collector", - "Protected-head authority collector", - "Release owner", - ["scripts/ci/release_authority_snapshot.py", "docs/doctoring/release-authorization.md"], - "repository_artifact", - "ready" if has_file("scripts/ci/release_authority_snapshot.py") else "blocked", - "Read-only gh API collector binds checks and reviews to the exact pull-request head without emitting secrets.", - "Run the collector with the exact candidate SHA and attach its JSON snapshot to release review.", - ), - self._buyer_evidence_item( - "packaging_decision", - "Packaging decision", - "Procurement and security reviewer", - ["docs/library_research.md", "docs/commercial_plugin_operating_model.md"], - "repository_artifact", - "ready" if has_file("docs/library_research.md") and has_file("docs/commercial_plugin_operating_model.md") else "blocked", - acceptance["library_split_decision"]["reason"], - "Only extract a library after a second product, independent release cadence, or provenance trigger exists.", - ), - ] - external_release_gaps = [ - self._buyer_evidence_item( - item["item_name"], - item["label"], - item["reviewer"], - item["sources"], - item["evidence_type"], - "warning", - item["evidence"], - item["next_action"], - ) - for item in acceptance["follow_up_items"] - ] - summary = self._buyer_manifest_summary(release_artifacts + external_release_gaps) - product_blocked_count = summary["by_completion_state"]["blocked"] + len(concrete_blockers) - warning_count = summary["by_completion_state"]["warning"] - product_evidence_status = ( - "commercial_release_blocked" - if product_blocked_count - else "commercial_release_ready_with_warnings" - if acceptance["follow_up_items"] - else "commercial_release_ready" - ) - release_blocked_count = product_blocked_count + len(release_authorization["blockers"]) - if release_blocked_count: - release_status = "commercial_release_blocked" - elif warning_count: - release_status = "commercial_release_ready_with_warnings" - else: # pragma: no cover - unreachable while this report carries literal buyer-specific warning sections - release_status = "commercial_release_ready" # pragma: no cover - - return { - "release_status": release_status, - "product_evidence_status": product_evidence_status, - "release_authorization": release_authorization, - "target_contract_value_krw": target_contract_value_krw, - "target_contract_value_display": f"KRW {target_contract_value_krw:,}", - "measurement_status": "local_commercial_release_candidate", - "source_note": ( - "Commercial release candidate packages local acceptance, runtime endpoints, repository " - "distribution documents, security metadata, admin visibility, verification commands, " - "Figma artifact records, review-process policy, packaging decision, and explicit external " - "release gaps; it is not a valuation guarantee, purchase commitment, or production " - "compliance certificate." - ), - "release_summary": { - "artifact_count": len(release_artifacts), - "blocked_count": release_blocked_count, - "product_blocked_count": product_blocked_count, - "warning_count": warning_count, - "release_authority_blocker_count": len(release_authorization["blockers"]), - }, - "release_artifacts": release_artifacts, - "external_release_gaps": external_release_gaps, - "concrete_blockers": concrete_blockers, - "release_gates": [ - { - "gate_name": "package", - "rule": "runtime endpoint chain, repository packet, security metadata, admin surface, tests, Figma artifacts, review policy, and packaging decision are present", - }, - { - "gate_name": "warning", - "rule": "only production or buyer-specific external evidence remains explicitly caveated", - }, - { - "gate_name": "blocked", - "rule": "security failure, API contract regression, missing distribution artifact, document mismatch, product defect, or Code Connect usage", - }, - ], - "review_process_policy": acceptance["review_process_policy"], - "related_runtime_reports": { - "commercial_acceptance_status": acceptance["acceptance_status"], - **acceptance["related_runtime_reports"], - }, - "library_split_decision": acceptance["library_split_decision"], - "plugin_traceability": acceptance["plugin_traceability"], - "release_links": { - "figma_design_file": "https://www.figma.com/design/vsZMd8WAv42HDRgcZuNcWk", - "figjam_board": "https://www.figma.com/board/Wr8iMlB9SHkerHSjv0Pe0M", - "runtime_endpoint": "/api/v1/commercial_release_candidates/latest", - "documentation": "docs/commercial_release_candidate.md", - }, - } - - def commercial_gap_register_report( - self, - target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, - locale_bundles: dict[str, dict[str, str]] | None = None, - security_profile: dict[str, Any] | None = None, - release_authority: Mapping[str, Any] | None = None, - ) -> dict[str, Any]: - """Return an owner/action register for commercial release-candidate gaps.""" - release = self.commercial_release_candidate_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - release_authority=release_authority, - ) - concrete_blockers = release["concrete_blockers"] - release_blocked = release["release_status"] == "commercial_release_blocked" - gap_items = [] - for item in release["external_release_gaps"]: - source_type = item["evidence_type"] - if source_type == "proposed_until_production": - gap_status = "production_input_required" - gap_type = "production_evidence_gap" - owner = "Operations and support owner" - else: - gap_status = "buyer_input_required" - gap_type = "buyer_specific_gap" - owner = "Buyer and deal owner" - gap_items.append({ - "gap_name": item["item_name"], - "label": item["label"], - "gap_type": gap_type, - "gap_status": gap_status, - "owner": owner, - "reviewer": item["reviewer"], - "sources": item["sources"], - "source_evidence_type": source_type, - "current_evidence": item["evidence"], - "required_input": item["next_action"], - "is_blocker": False, - }) - - release_authority_blockers = release["release_authorization"]["blockers"] - product_blocked_count = release["release_summary"]["product_blocked_count"] - blocked_count = ( - max(1, product_blocked_count + len(release_authority_blockers)) - if release_blocked - else len(concrete_blockers) - ) - if blocked_count: - gap_register_status = "commercial_gap_register_blocked" - elif gap_items: - gap_register_status = "commercial_gap_register_open" - else: # pragma: no cover - unreachable while this report carries literal buyer-specific warning sections - gap_register_status = "commercial_gap_register_clear" # pragma: no cover - - production_gap_count = sum(1 for item in gap_items if item["gap_type"] == "production_evidence_gap") - buyer_specific_gap_count = sum(1 for item in gap_items if item["gap_type"] == "buyer_specific_gap") - return { - "gap_register_status": gap_register_status, - "target_contract_value_krw": target_contract_value_krw, - "target_contract_value_display": f"KRW {target_contract_value_krw:,}", - "measurement_status": "local_commercial_gap_register", - "source_note": ( - "Commercial gap register converts local release-candidate warning gaps into owner, action, " - "source, and required-input rows for buyer due diligence; it is not a valuation guarantee, " - "purchase commitment, or production compliance certificate." - ), - "gap_summary": { - "total_gap_count": len(gap_items), - "production_gap_count": production_gap_count, - "buyer_specific_gap_count": buyer_specific_gap_count, - "blocked_count": blocked_count, - "release_authority_blocker_count": len(release_authority_blockers), - }, - "gap_items": gap_items, - "concrete_blockers": concrete_blockers, - "release_authorization": release["release_authorization"], - "gap_status_rules": [ - { - "gap_status": "production_input_required", - "rule": "production deployment, support, SLO, or operational evidence must be supplied before production claim", - }, - { - "gap_status": "buyer_input_required", - "rule": "buyer-specific legal, procurement, ROI, or deployment context must be supplied before buyer-specific claim", - }, - { - "gap_status": "blocked", - "rule": "concrete security, API contract, document, product defect, or Code Connect usage blocks commercial release", - }, - ], - "review_process_policy": release["review_process_policy"], - "related_runtime_reports": { - "commercial_release_status": release["release_status"], - "release_authorization_status": release["release_authorization"]["status"], - **release["related_runtime_reports"], - }, - "library_split_decision": release["library_split_decision"], - "plugin_traceability": release["plugin_traceability"], - "gap_register_links": { - "figma_design_file": "https://www.figma.com/design/vsZMd8WAv42HDRgcZuNcWk", - "figjam_board": "https://www.figma.com/board/Wr8iMlB9SHkerHSjv0Pe0M", - "runtime_endpoint": "/api/v1/commercial_gap_registers/latest", - "documentation": "docs/commercial_gap_register.md", - }, - } - - def commercial_procurement_readiness_report( - self, - target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, - locale_bundles: dict[str, dict[str, str]] | None = None, - security_profile: dict[str, Any] | None = None, - release_authority: Mapping[str, Any] | None = None, - ) -> dict[str, Any]: - """Return a procurement/legal readiness gate over commercial evidence.""" - gap_register = self.commercial_gap_register_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - release_authority=release_authority, - ) - root = Path(__file__).resolve().parents[1] - - def has_file(path: str) -> bool: - return (root / path).is_file() - - gap_by_status = {item["gap_status"]: item for item in gap_register["gap_items"]} - production_gap = gap_by_status.get("production_input_required") - buyer_gap = gap_by_status.get("buyer_input_required") - concrete_blockers = gap_register["concrete_blockers"] - release_authorization = gap_register["release_authorization"] - release_authority_blockers = release_authorization["blockers"] - procurement_items = [ - { - "item_name": "license_and_rights", - "label": "License and rights", - "owner": "Procurement reviewer", - "sources": ["LICENSE", "pyproject.toml"], - "evidence_type": "repository_artifact", - "completion_state": "ready" if has_file("LICENSE") and has_file("pyproject.toml") else "blocked", - "evidence": "MIT license and package metadata are present for buyer rights review.", - "required_input": "Restore license or package metadata before procurement review.", - }, - { - "item_name": "security_package_metadata", - "label": "Security package metadata", - "owner": "Security reviewer", - "sources": [ - "SECURITY.md", - "requirements.lock", - ".github/workflows/security.yml", - ".github/dependabot.yml", - "ContextualWisdomLab/.github central required security workflows", - ], - "evidence_type": "repository_artifact", - "completion_state": "ready" - if all( - has_file(path) - for path in ( - "SECURITY.md", - "requirements.lock", - ".github/workflows/security.yml", - ".github/dependabot.yml", - ) - ) - else "blocked", - "evidence": "Security policy, locked dependencies, local supply-chain workflow, Dependabot metadata, and central required security workflows are present.", - "required_input": "Restore missing security metadata before procurement review.", - }, - { - "item_name": "distribution_packet", - "label": "Distribution packet", - "owner": "Deal owner", - "sources": [ - "README.md", - "docs/rest_api_design.md", - "docs/commercial_release_candidate.md", - "docs/commercial_gap_register.md", - ], - "evidence_type": "repository_artifact", - "completion_state": "ready" - if all( - has_file(path) - for path in ( - "README.md", - "docs/rest_api_design.md", - "docs/commercial_release_candidate.md", - "docs/commercial_gap_register.md", - ) - ) - else "blocked", - "evidence": "Repository overview, REST contract, release candidate, and gap register documents are present.", - "required_input": "Restore missing distribution documents before procurement review.", - }, - { - "item_name": "admin_evidence_surface", - "label": "Admin evidence surface", - "owner": "Platform operator", - "sources": ["/admin", "contextual_orchestrator/admin.py", "/api/v1/commercial_procurement_readiness/latest"], - "evidence_type": "repository_artifact", - "completion_state": "ready" if has_file("contextual_orchestrator/admin.py") else "blocked", - "evidence": "Admin observability surface exposes procurement readiness with bilingual labels.", - "required_input": "Expose procurement readiness in admin observability before buyer review.", - }, - { - "item_name": "production_support_slo_input", - "label": "Production support and SLO input", - "owner": production_gap["owner"] if production_gap else "Operations and support owner", - "sources": production_gap["sources"] if production_gap else ["docs/commercial_gap_register.md"], - "evidence_type": "proposed_until_production", - "completion_state": "warning" if production_gap else "ready", - "source_gap_status": production_gap["gap_status"] if production_gap else "resolved", - "evidence": production_gap["current_evidence"] if production_gap else "No production evidence gap is open.", - "required_input": production_gap["required_input"] if production_gap else "No production input required.", - }, - { - "item_name": "buyer_legal_roi_procurement_input", - "label": "Buyer legal, ROI, and procurement input", - "owner": buyer_gap["owner"] if buyer_gap else "Buyer and deal owner", - "sources": buyer_gap["sources"] if buyer_gap else ["docs/commercial_gap_register.md"], - "evidence_type": "proposed_until_buyer_specific", - "completion_state": "warning" if buyer_gap else "ready", - "source_gap_status": buyer_gap["gap_status"] if buyer_gap else "resolved", - "evidence": buyer_gap["current_evidence"] if buyer_gap else "No buyer-specific evidence gap is open.", - "required_input": buyer_gap["required_input"] if buyer_gap else "No buyer input required.", - }, - { - "item_name": "review_process_policy", - "label": "Review process policy", - "owner": "Deal owner", - "sources": ["docs/commercial_saleability_decision.md", "docs/commercial_procurement_readiness.md"], - "evidence_type": "repository_artifact", - "completion_state": "ready", - "evidence": "Reviewer delay, review bot delay, queued model review, and pending checks without concrete failure are not blockers.", - "required_input": "Block only on concrete security, API contract, document, or product defects.", - }, - { - "item_name": "packaging_decision", - "label": "Packaging decision", - "owner": "Procurement and security reviewer", - "sources": ["docs/library_research.md", "docs/commercial_plugin_operating_model.md"], - "evidence_type": "repository_artifact", - "completion_state": "ready" if has_file("docs/library_research.md") and has_file("docs/commercial_plugin_operating_model.md") else "blocked", - "evidence": gap_register["library_split_decision"]["reason"], - "required_input": "Only extract a library after a second product, independent release cadence, or provenance trigger exists.", - }, - ] - state_counts = Counter(item["completion_state"] for item in procurement_items) - production_gap_count = 1 if production_gap else 0 - buyer_specific_gap_count = 1 if buyer_gap else 0 - blocked_count = state_counts.get("blocked", 0) + len(concrete_blockers) - warning_count = state_counts.get("warning", 0) - if blocked_count: - procurement_status = "commercial_procurement_blocked" - elif warning_count: - procurement_status = "commercial_procurement_ready_with_warnings" - else: # pragma: no cover - unreachable while this report carries literal buyer-specific warning sections - procurement_status = "commercial_procurement_ready" # pragma: no cover - - return { - "procurement_status": procurement_status, - "target_contract_value_krw": target_contract_value_krw, - "target_contract_value_display": f"KRW {target_contract_value_krw:,}", - "measurement_status": "local_commercial_procurement_readiness", - "source_note": ( - "Commercial procurement readiness packages local license, security, distribution, admin, " - "gap-register, review-process, and packaging evidence for buyer due diligence; it is not " - "a valuation guarantee, purchase commitment, or production compliance certificate." - ), - "procurement_summary": { - "item_count": len(procurement_items), - "ready_count": state_counts.get("ready", 0), - "warning_count": warning_count, - "blocked_count": blocked_count, - "production_gap_count": production_gap_count, - "buyer_specific_gap_count": buyer_specific_gap_count, - "review_process_is_blocker": gap_register["review_process_policy"]["is_blocker"], - "release_authority_blocker_count": len(release_authority_blockers), - }, - "procurement_items": procurement_items, - "concrete_blockers": concrete_blockers, - "release_authorization": release_authorization, - "procurement_status_rules": [ - { - "procurement_status": "commercial_procurement_ready", - "rule": "license, security, distribution, admin, support, legal, ROI, review, and packaging evidence are ready", - }, - { - "procurement_status": "commercial_procurement_ready_with_warnings", - "rule": "local packet is ready while production or buyer-specific inputs remain explicit warnings", - }, - { - "procurement_status": "commercial_procurement_blocked", - "rule": "missing packet evidence, concrete product defect, API contract failure, document mismatch, security failure, or Code Connect usage blocks procurement", - }, - ], - "review_process_policy": gap_register["review_process_policy"], - "related_runtime_reports": { - "commercial_gap_register_status": gap_register["gap_register_status"], - **gap_register["related_runtime_reports"], - }, - "library_split_decision": gap_register["library_split_decision"], - "plugin_traceability": gap_register["plugin_traceability"], - "procurement_links": { - "figma_design_file": "https://www.figma.com/design/vsZMd8WAv42HDRgcZuNcWk", - "figjam_board": "https://www.figma.com/board/Wr8iMlB9SHkerHSjv0Pe0M", - "runtime_endpoint": "/api/v1/commercial_procurement_readiness/latest", - "documentation": "docs/commercial_procurement_readiness.md", - }, - } - - def commercial_contract_readiness_report( - self, - target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, - locale_bundles: dict[str, dict[str, str]] | None = None, - security_profile: dict[str, Any] | None = None, - release_authority: Mapping[str, Any] | None = None, - ) -> dict[str, Any]: - """Return a contract-readiness gate over procurement evidence.""" - procurement = self.commercial_procurement_readiness_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - release_authority=release_authority, - ) - root = Path(__file__).resolve().parents[1] - - def has_file(path: str) -> bool: - return (root / path).is_file() - - procurement_by_name = {item["item_name"]: item for item in procurement["procurement_items"]} - license_item = procurement_by_name["license_and_rights"] - security_item = procurement_by_name["security_package_metadata"] - support_item = procurement_by_name["production_support_slo_input"] - buyer_item = procurement_by_name["buyer_legal_roi_procurement_input"] - packaging_item = procurement_by_name["packaging_decision"] - concrete_blockers = procurement["concrete_blockers"] - release_authorization = procurement["release_authorization"] - release_authority_blockers = release_authorization["blockers"] - support_slo_gap_count = 1 if support_item["completion_state"] == "warning" else 0 - buyer_order_form_gap_count = 1 if buyer_item["completion_state"] == "warning" else 0 - contract_items = [ - { - "item_name": "license_commercial_rights", - "label": "License and commercial rights terms", - "owner": "Legal reviewer", - "sources": license_item["sources"], - "evidence_type": license_item["evidence_type"], - "completion_state": license_item["completion_state"], - "evidence": license_item["evidence"], - "required_input": license_item["required_input"], - }, - { - "item_name": "security_privacy_terms", - "label": "Security and privacy terms", - "owner": "Security and legal reviewer", - "sources": [*security_item["sources"], "docs/commercial_procurement_readiness.md"], - "evidence_type": security_item["evidence_type"], - "completion_state": security_item["completion_state"], - "evidence": ( - f"{security_item['evidence']} Runtime readiness profile uses " - f"auth_mode={security_profile.get('auth_mode', 'unknown') if security_profile else 'unknown'}, " - f"public_bind={security_profile.get('allow_public_bind', 'unknown') if security_profile else 'unknown'}, " - "and trace exposure controls." - ), - "required_input": security_item["required_input"], - }, - { - "item_name": "audit_export_obligations", - "label": "Audit and export obligations", - "owner": "Compliance reviewer", - "sources": [ - "/api/v1/commercial_evidence_exports/latest", - "docs/commercial_evidence_export.md", - "docs/rest_api_design.md", - ], - "evidence_type": "repository_artifact", - "completion_state": "ready" - if all( - has_file(path) - for path in ( - "docs/commercial_evidence_export.md", - "docs/rest_api_design.md", - ) - ) - else "blocked", - "evidence": "Commercial evidence export and REST API contract describe buyer-readable audit evidence.", - "required_input": "Restore evidence export docs and REST contract before contract review.", - }, - { - "item_name": "contract_packet_docs", - "label": "Contract packet documents", - "owner": "Deal owner", - "sources": [ - "README.md", - "docs/commercial_contract_readiness.md", - "docs/commercial_procurement_readiness.md", - "docs/commercial_saleability_decision.md", - ], - "evidence_type": "repository_artifact", - "completion_state": "ready" - if all( - has_file(path) - for path in ( - "README.md", - "docs/commercial_contract_readiness.md", - "docs/commercial_procurement_readiness.md", - "docs/commercial_saleability_decision.md", - ) - ) - else "blocked", - "evidence": "Contract packet, procurement gate, and saleability blocker policy are documented.", - "required_input": "Restore buyer contract packet docs before legal review.", - }, - { - "item_name": "support_slo_terms", - "label": "Support and SLO terms", - "owner": support_item["owner"], - "sources": support_item["sources"], - "evidence_type": support_item["evidence_type"], - "completion_state": support_item["completion_state"], - "source_gap_status": support_item.get("source_gap_status", "resolved"), - "evidence": support_item["evidence"], - "required_input": support_item["required_input"], - }, - { - "item_name": "buyer_order_form_input", - "label": "Buyer order-form input", - "owner": buyer_item["owner"], - "sources": buyer_item["sources"], - "evidence_type": buyer_item["evidence_type"], - "completion_state": buyer_item["completion_state"], - "source_gap_status": buyer_item.get("source_gap_status", "resolved"), - "evidence": buyer_item["evidence"], - "required_input": buyer_item["required_input"], - }, - { - "item_name": "review_process_policy", - "label": "Review process policy", - "owner": "Deal owner", - "sources": ["docs/commercial_saleability_decision.md", "docs/commercial_contract_readiness.md"], - "evidence_type": "repository_artifact", - "completion_state": "ready", - "evidence": "Review process delay is not a contract blocker unless a concrete failure is produced.", - "required_input": "Block only on concrete security, API contract, document, or product defects.", - }, - { - "item_name": "packaging_decision", - "label": "Packaging decision", - "owner": packaging_item["owner"], - "sources": packaging_item["sources"], - "evidence_type": packaging_item["evidence_type"], - "completion_state": packaging_item["completion_state"], - "evidence": packaging_item["evidence"], - "required_input": packaging_item["required_input"], - }, - ] - state_counts = Counter(item["completion_state"] for item in contract_items) - blocked_count = state_counts.get("blocked", 0) + len(concrete_blockers) - warning_count = state_counts.get("warning", 0) - if blocked_count: - contract_status = "commercial_contract_blocked" - elif warning_count: - contract_status = "commercial_contract_ready_with_warnings" - else: # pragma: no cover - unreachable while this report carries literal buyer-specific warning sections - contract_status = "commercial_contract_ready" # pragma: no cover - - return { - "contract_status": contract_status, - "target_contract_value_krw": target_contract_value_krw, - "target_contract_value_display": f"KRW {target_contract_value_krw:,}", - "measurement_status": "local_commercial_contract_readiness", - "source_note": ( - "Commercial contract readiness packages local license, security/privacy, audit export, " - "support/SLO, buyer order-form, review-process, and packaging evidence for legal and " - "procurement due diligence; it is not a valuation guarantee, purchase commitment, or " - "production compliance certificate." - ), - "contract_summary": { - "item_count": len(contract_items), - "ready_count": state_counts.get("ready", 0), - "warning_count": warning_count, - "blocked_count": blocked_count, - "support_slo_gap_count": support_slo_gap_count, - "buyer_order_form_gap_count": buyer_order_form_gap_count, - "review_process_is_blocker": procurement["review_process_policy"]["is_blocker"], - "release_authority_blocker_count": len(release_authority_blockers), - }, - "contract_items": contract_items, - "concrete_blockers": concrete_blockers, - "release_authorization": release_authorization, - "contract_status_rules": [ - { - "contract_status": "commercial_contract_ready", - "rule": "license, security/privacy, audit/export, support/SLO, buyer order-form, review, and packaging terms are ready", - }, - { - "contract_status": "commercial_contract_ready_with_warnings", - "rule": "local contract packet is ready while production support/SLO or buyer order-form inputs remain explicit warnings", - }, - { - "contract_status": "commercial_contract_blocked", - "rule": "missing contract packet evidence, concrete product defect, API contract failure, document mismatch, security failure, or Code Connect usage blocks contract readiness", - }, - ], - "review_process_policy": procurement["review_process_policy"], - "related_runtime_reports": { - "commercial_procurement_status": procurement["procurement_status"], - **procurement["related_runtime_reports"], - }, - "library_split_decision": procurement["library_split_decision"], - "plugin_traceability": procurement["plugin_traceability"], - "contract_links": { - "figma_design_file": "https://www.figma.com/design/vsZMd8WAv42HDRgcZuNcWk", - "figjam_board": "https://www.figma.com/board/Wr8iMlB9SHkerHSjv0Pe0M", - "runtime_endpoint": "/api/v1/commercial_contract_readiness/latest", - "documentation": "docs/commercial_contract_readiness.md", - }, - } - - def commercial_onboarding_readiness_report( - self, - target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, - locale_bundles: dict[str, dict[str, str]] | None = None, - security_profile: dict[str, Any] | None = None, - release_authority: Mapping[str, Any] | None = None, - ) -> dict[str, Any]: - """Return a paid-onboarding readiness gate over contract evidence.""" - contract = self.commercial_contract_readiness_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - release_authority=release_authority, - ) - root = Path(__file__).resolve().parents[1] - - def has_file(path: str) -> bool: - return (root / path).is_file() - - contract_by_name = {item["item_name"]: item for item in contract["contract_items"]} - support_item = contract_by_name["support_slo_terms"] - buyer_item = contract_by_name["buyer_order_form_input"] - packaging_item = contract_by_name["packaging_decision"] - concrete_blockers = contract["concrete_blockers"] - release_authorization = contract["release_authorization"] - support_slo_action_count = 1 if support_item["completion_state"] == "warning" else 0 - buyer_input_action_count = 1 if buyer_item["completion_state"] == "warning" else 0 - onboarding_items = [ - { - "item_name": "buyer_kickoff_packet", - "label": "Buyer kickoff packet", - "owner": "Deal owner", - "sources": [ - "README.md", - "docs/commercial_onboarding_readiness.md", - "docs/commercial_contract_readiness.md", - ], - "evidence_type": "repository_artifact", - "completion_state": "ready" - if all( - has_file(path) - for path in ( - "README.md", - "docs/commercial_onboarding_readiness.md", - "docs/commercial_contract_readiness.md", - ) - ) - else "blocked", - "evidence": "Buyer kickoff packet connects product overview, contract readiness, and onboarding plan.", - "action": "Use the packet to start paid onboarding with named buyer stakeholders.", - "exit_criteria": "Buyer confirms kickoff owner, onboarding dates, and evidence review cadence.", - }, - { - "item_name": "support_slo_kickoff", - "label": "Support and SLO kickoff", - "owner": support_item["owner"], - "sources": support_item["sources"], - "evidence_type": support_item["evidence_type"], - "completion_state": support_item["completion_state"], - "source_gap_status": support_item.get("source_gap_status", "resolved"), - "evidence": support_item["evidence"], - "action": "Collect support rota, escalation path, SLO target, and incident drill evidence during paid onboarding.", - "exit_criteria": "Buyer and operator approve support owner, response target, escalation path, and first incident drill record.", - }, - { - "item_name": "buyer_order_form_kickoff", - "label": "Buyer order-form kickoff", - "owner": buyer_item["owner"], - "sources": buyer_item["sources"], - "evidence_type": buyer_item["evidence_type"], - "completion_state": buyer_item["completion_state"], - "source_gap_status": buyer_item.get("source_gap_status", "resolved"), - "evidence": buyer_item["evidence"], - "action": "Collect buyer order-form, ROI, legal questionnaire, deployment, and support inputs.", - "exit_criteria": "Buyer-specific order form and legal/procurement inputs are attached to the diligence packet.", - }, - { - "item_name": "telemetry_capture_plan", - "label": "Telemetry capture plan", - "owner": "Data analytics owner", - "sources": ["/api/v1/analytics_snapshots/latest", "docs/analytics_spec.md"], - "evidence_type": "repository_artifact", - "completion_state": "ready" if has_file("docs/analytics_spec.md") else "blocked", - "evidence": "Analytics spec separates measured local evidence from proposed production metrics.", - "action": "Capture production onboarding telemetry without mixing it with local prototype metrics.", - "exit_criteria": "First buyer environment records adoption, latency, verification, trace completeness, and support events.", - }, - { - "item_name": "acceptance_exit_criteria", - "label": "Acceptance exit criteria", - "owner": "Technical buyer reviewer", - "sources": [ - "/api/v1/commercial_acceptance_checks/latest", - "docs/commercial_acceptance_check.md", - "docs/commercial_buyer_acceptance_runbook.md", - ], - "evidence_type": "repository_artifact", - "completion_state": "ready" - if has_file("docs/commercial_acceptance_check.md") - and has_file("docs/commercial_buyer_acceptance_runbook.md") - else "blocked", - "evidence": "Acceptance check and buyer runbook define go/no-go review gates.", - "action": "Run the buyer acceptance checklist after kickoff evidence is attached.", - "exit_criteria": "Acceptance check has no concrete blockers and warnings are explicitly owned.", - }, - { - "item_name": "security_legal_handoff", - "label": "Security and legal handoff", - "owner": "Security and legal reviewer", - "sources": ["SECURITY.md", "docs/commercial_contract_readiness.md"], - "evidence_type": "repository_artifact", - "completion_state": "ready" - if has_file("SECURITY.md") and has_file("docs/commercial_contract_readiness.md") - else "blocked", - "evidence": "Security policy and contract readiness packet are available for buyer handoff.", - "action": "Attach security policy, dependency lock, and contract readiness rows to buyer diligence.", - "exit_criteria": "Buyer security/legal reviewer accepts the packet or opens concrete findings.", - }, - { - "item_name": "review_process_policy", - "label": "Review process policy", - "owner": "Deal owner", - "sources": ["docs/commercial_saleability_decision.md", "docs/commercial_onboarding_readiness.md"], - "evidence_type": "repository_artifact", - "completion_state": "ready", - "evidence": "Review delay is not an onboarding blocker unless a concrete failure is produced.", - "action": "Continue onboarding work while queued reviews are pending.", - "exit_criteria": "Only concrete security, API contract, document, or product defects block progress.", - }, - { - "item_name": "packaging_decision", - "label": "Packaging decision", - "owner": packaging_item["owner"], - "sources": packaging_item["sources"], - "evidence_type": packaging_item["evidence_type"], - "completion_state": packaging_item["completion_state"], - "evidence": packaging_item["evidence"], - "action": "Keep one deployable enterprise control-plane product through onboarding.", - "exit_criteria": "Extract only after a second product, independent release cadence, or buyer provenance trigger exists.", - }, - ] - state_counts = Counter(item["completion_state"] for item in onboarding_items) - blocked_count = state_counts.get("blocked", 0) + len(concrete_blockers) - warning_count = state_counts.get("warning", 0) - if blocked_count: - onboarding_status = "commercial_onboarding_blocked" - elif warning_count: - onboarding_status = "commercial_onboarding_ready_with_warnings" - else: # pragma: no cover - unreachable while this report carries literal buyer-specific warning sections - onboarding_status = "commercial_onboarding_ready" # pragma: no cover - - return { - "onboarding_status": onboarding_status, - "target_contract_value_krw": target_contract_value_krw, - "target_contract_value_display": f"KRW {target_contract_value_krw:,}", - "measurement_status": "local_commercial_onboarding_readiness", - "source_note": ( - "Commercial onboarding readiness converts local contract and procurement warnings into " - "paid-onboarding owners, actions, and exit criteria; it is not a valuation guarantee, " - "purchase commitment, or production compliance certificate." - ), - "onboarding_summary": { - "item_count": len(onboarding_items), - "ready_count": state_counts.get("ready", 0), - "warning_count": warning_count, - "blocked_count": blocked_count, - "support_slo_action_count": support_slo_action_count, - "buyer_input_action_count": buyer_input_action_count, - "review_process_is_blocker": contract["review_process_policy"]["is_blocker"], - "release_authority_blocker_count": len(release_authorization["blockers"]), - }, - "onboarding_items": onboarding_items, - "concrete_blockers": concrete_blockers, - "release_authorization": release_authorization, - "onboarding_status_rules": [ - { - "onboarding_status": "commercial_onboarding_ready", - "rule": "kickoff packet, support/SLO, buyer input, telemetry, acceptance, security/legal, review, and packaging actions are ready", - }, - { - "onboarding_status": "commercial_onboarding_ready_with_warnings", - "rule": "local onboarding plan is ready while production support/SLO or buyer order-form actions remain explicit warnings", - }, - { - "onboarding_status": "commercial_onboarding_blocked", - "rule": "missing onboarding packet evidence, concrete product defect, API contract failure, document mismatch, security failure, or Code Connect usage blocks onboarding", - }, - ], - "review_process_policy": contract["review_process_policy"], - "related_runtime_reports": { - "commercial_contract_status": contract["contract_status"], - **contract["related_runtime_reports"], - }, - "library_split_decision": contract["library_split_decision"], - "plugin_traceability": contract["plugin_traceability"], - "onboarding_links": { - "figma_design_file": "https://www.figma.com/design/vsZMd8WAv42HDRgcZuNcWk", - "figjam_board": "https://www.figma.com/board/Wr8iMlB9SHkerHSjv0Pe0M", - "runtime_endpoint": "/api/v1/commercial_onboarding_readiness/latest", - "documentation": "docs/commercial_onboarding_readiness.md", - }, - } - - def commercial_operations_readiness_report( - self, - target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, - locale_bundles: dict[str, dict[str, str]] | None = None, - security_profile: dict[str, Any] | None = None, - release_authority: Mapping[str, Any] | None = None, - ) -> dict[str, Any]: - """Return an operations-handoff readiness gate over onboarding evidence.""" - onboarding = self.commercial_onboarding_readiness_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - release_authority=release_authority, - ) - root = Path(__file__).resolve().parents[1] - - def has_file(path: str) -> bool: - return (root / path).is_file() - - onboarding_by_name = {item["item_name"]: item for item in onboarding["onboarding_items"]} - support_item = onboarding_by_name["support_slo_kickoff"] - telemetry_item = onboarding_by_name["telemetry_capture_plan"] - acceptance_item = onboarding_by_name["acceptance_exit_criteria"] - security_item = onboarding_by_name["security_legal_handoff"] - packaging_item = onboarding_by_name["packaging_decision"] - concrete_blockers = onboarding["concrete_blockers"] - operations_items = [ - { - "item_name": "deployment_runbook", - "label": "Deployment runbook", - "owner": "Platform operator", - "sources": [ - "README.md", - "docs/commercial_operations_readiness.md", - "docs/commercial_onboarding_readiness.md", - "docs/rest_api_design.md", - ], - "evidence_type": "repository_artifact", - "completion_state": "ready" - if all( - has_file(path) - for path in ( - "README.md", - "docs/commercial_operations_readiness.md", - "docs/commercial_onboarding_readiness.md", - "docs/rest_api_design.md", - ) - ) - else "blocked", - "evidence": "Repository overview, REST contract, onboarding plan, and operations handoff plan are present.", - "action": "Use existing stdlib server and documented endpoints for buyer operations handoff.", - "exit_criteria": "Buyer operator can start, authenticate, inspect readiness endpoints, and run verification commands.", - }, - { - "item_name": "monitoring_telemetry_capture", - "label": "Monitoring and telemetry capture", - "owner": telemetry_item["owner"], - "sources": telemetry_item["sources"], - "evidence_type": "proposed_until_production", - "completion_state": "warning", - "source_gap_status": "production_input_required", - "evidence": telemetry_item["evidence"], - "action": "Capture adoption, latency, verifier outcomes, trace completeness, support events, and deployment health in the buyer environment.", - "exit_criteria": "First production telemetry snapshot is attached without mixing it with local prototype metrics.", - }, - { - "item_name": "incident_rollback_plan", - "label": "Incident and rollback plan", - "owner": "Operations and support owner", - "sources": ["docs/commercial_onboarding_readiness.md", "docs/commercial_buyer_acceptance_runbook.md"], - "evidence_type": "proposed_until_production", - "completion_state": "warning", - "source_gap_status": "production_input_required", - "evidence": "Incident drill and rollback proof require a buyer deployment or paid onboarding environment.", - "action": "Run the first incident drill and rollback exercise during onboarding.", - "exit_criteria": "Incident owner, escalation path, rollback steps, and drill record are attached.", - }, - { - "item_name": "backup_recovery_plan", - "label": "Backup and recovery evidence", - "owner": "Operations and data owner", - "sources": ["docs/commercial_onboarding_readiness.md", "docs/commercial_buyer_diligence_packet.md"], - "evidence_type": "proposed_until_production", - "completion_state": "warning", - "source_gap_status": "production_input_required", - "evidence": "Backup and recovery evidence depends on the buyer deployment topology and persistence choices.", - "action": "Define backup scope, retention, restore owner, and first restore proof during onboarding.", - "exit_criteria": "Buyer accepts backup scope and a restore proof is attached or explicitly waived.", - }, - { - "item_name": "support_slo_ownership", - "label": "Support rota and SLO ownership", - "owner": support_item["owner"], - "sources": support_item["sources"], - "evidence_type": support_item["evidence_type"], - "completion_state": support_item["completion_state"], - "source_gap_status": support_item.get("source_gap_status", "resolved"), - "evidence": support_item["evidence"], - "action": support_item["action"], - "exit_criteria": support_item["exit_criteria"], - }, - { - "item_name": "acceptance_handoff", - "label": "Acceptance handoff", - "owner": acceptance_item["owner"], - "sources": acceptance_item["sources"], - "evidence_type": acceptance_item["evidence_type"], - "completion_state": acceptance_item["completion_state"], - "evidence": acceptance_item["evidence"], - "action": acceptance_item["action"], - "exit_criteria": acceptance_item["exit_criteria"], - }, - { - "item_name": "security_legal_handoff", - "label": "Security and legal handoff", - "owner": security_item["owner"], - "sources": security_item["sources"], - "evidence_type": security_item["evidence_type"], - "completion_state": security_item["completion_state"], - "evidence": security_item["evidence"], - "action": security_item["action"], - "exit_criteria": security_item["exit_criteria"], - }, - { - "item_name": "review_process_policy", - "label": "Review process policy", - "owner": "Deal owner", - "sources": ["docs/commercial_saleability_decision.md", "docs/commercial_operations_readiness.md"], - "evidence_type": "repository_artifact", - "completion_state": "ready", - "evidence": "Review delay is not an operations blocker unless a concrete failure is produced.", - "action": "Continue operations handoff work while queued reviews are pending.", - "exit_criteria": "Only concrete security, API contract, document, or product defects block progress.", - }, - { - "item_name": "packaging_decision", - "label": "Packaging decision", - "owner": packaging_item["owner"], - "sources": packaging_item["sources"], - "evidence_type": packaging_item["evidence_type"], - "completion_state": packaging_item["completion_state"], - "evidence": packaging_item["evidence"], - "action": packaging_item["action"], - "exit_criteria": packaging_item["exit_criteria"], - }, - ] - state_counts = Counter(item["completion_state"] for item in operations_items) - blocked_count = state_counts.get("blocked", 0) + len(concrete_blockers) - warning_count = state_counts.get("warning", 0) - production_evidence_action_count = sum( - 1 for item in operations_items if item.get("source_gap_status") == "production_input_required" - ) - if blocked_count: - operations_status = "commercial_operations_blocked" - elif warning_count: - operations_status = "commercial_operations_ready_with_warnings" - else: # pragma: no cover - unreachable while this report carries literal buyer-specific warning sections - operations_status = "commercial_operations_ready" # pragma: no cover - - return { - "operations_status": operations_status, - "target_contract_value_krw": target_contract_value_krw, - "target_contract_value_display": f"KRW {target_contract_value_krw:,}", - "measurement_status": "local_commercial_operations_readiness", - "source_note": ( - "Commercial operations readiness converts local onboarding evidence and production " - "operations gaps into handoff owners, actions, and exit criteria; it is not a valuation " - "guarantee, purchase commitment, or production compliance certificate." - ), - "operations_summary": { - "item_count": len(operations_items), - "ready_count": state_counts.get("ready", 0), - "warning_count": warning_count, - "blocked_count": blocked_count, - "production_evidence_action_count": production_evidence_action_count, - "review_process_is_blocker": onboarding["review_process_policy"]["is_blocker"], - }, - "operations_items": operations_items, - "concrete_blockers": concrete_blockers, - "operations_status_rules": [ - { - "operations_status": "commercial_operations_ready", - "rule": "deployment, monitoring, incident, backup, support, acceptance, security/legal, review, and packaging evidence are ready", - }, - { - "operations_status": "commercial_operations_ready_with_warnings", - "rule": "local operations plan is ready while production telemetry, incident, backup, or SLO evidence remains explicit warnings", - }, - { - "operations_status": "commercial_operations_blocked", - "rule": "missing operations packet evidence, concrete product defect, API contract failure, document mismatch, security failure, or Code Connect usage blocks operations handoff", - }, - ], - "review_process_policy": onboarding["review_process_policy"], - "related_runtime_reports": { - "commercial_onboarding_status": onboarding["onboarding_status"], - **onboarding["related_runtime_reports"], - }, - "library_split_decision": onboarding["library_split_decision"], - "plugin_traceability": onboarding["plugin_traceability"], - "operations_links": { - "figma_design_file": "https://www.figma.com/design/vsZMd8WAv42HDRgcZuNcWk", - "figjam_board": "https://www.figma.com/board/Wr8iMlB9SHkerHSjv0Pe0M", - "runtime_endpoint": "/api/v1/commercial_operations_readiness/latest", - "documentation": "docs/commercial_operations_readiness.md", - }, - } - - def commercial_security_attestation_report( - self, - target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, - locale_bundles: dict[str, dict[str, str]] | None = None, - security_profile: dict[str, Any] | None = None, - release_authority: Mapping[str, Any] | None = None, - ) -> dict[str, Any]: - """Return a buyer security-review attestation gate over operations evidence.""" - operations = self.commercial_operations_readiness_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - release_authority=release_authority, - ) - root = Path(__file__).resolve().parents[1] - - def has_file(path: str) -> bool: - return (root / path).is_file() - - operations_by_name = {item["item_name"]: item for item in operations["operations_items"]} - runtime_profile = security_profile or {} - concrete_blockers = operations["concrete_blockers"] - security_attestation_items = [ - { - "item_name": "security_policy", - "label": "Security policy", - "owner": "Security owner", - "sources": ["SECURITY.md"], - "evidence_type": "repository_artifact", - "completion_state": "ready" if has_file("SECURITY.md") else "blocked", - "evidence": "Repository security disclosure and support policy is present.", - "action": "Attach SECURITY.md to the buyer security review packet.", - "exit_criteria": "Buyer can identify the vulnerability reporting path and supported scope.", - }, - { - "item_name": "dependency_lock_package_metadata", - "label": "Dependency lock and package metadata", - "owner": "Release owner", - "sources": ["requirements.lock", "pyproject.toml"], - "evidence_type": "repository_artifact", - "completion_state": "ready" - if has_file("requirements.lock") and has_file("pyproject.toml") - else "blocked", - "evidence": "Pinned dependency lock and Python package metadata are present for supply-chain review.", - "action": "Use the pinned lockfile and package metadata as the buyer dependency baseline.", - "exit_criteria": "Buyer can inspect package metadata and reproduce the dependency installation path.", - }, - { - "item_name": "security_workflow_metadata", - "label": "Security workflow metadata", - "owner": "Security owner", - "sources": [ - ".github/dependabot.yml", - ".github/workflows/security.yml", - "ContextualWisdomLab/.github central required security workflows", - ], - "evidence_type": "repository_artifact", - "completion_state": "ready" - if all( - has_file(path) - for path in ( - ".github/dependabot.yml", - ".github/workflows/security.yml", - ) - ) - else "blocked", - "evidence": "Dependabot plus local CodeQL and pip-audit/SBOM workflows are defined; dependency review, Trivy, OSV, and Scorecard are delegated to central required workflows.", - "action": "Attach workflow definitions and latest passing run evidence when the buyer review requests hosted CI proof.", - "exit_criteria": "Buyer can inspect the configured security workflow controls and their latest run status separately.", - }, - { - "item_name": "runtime_access_control_profile", - "label": "Runtime access-control profile", - "owner": "Platform operator", - "sources": ["contextual_orchestrator/server.py", "/api/v1/commercial_operations_readiness/latest"], - "evidence_type": "runtime_configuration", - "completion_state": "ready", - "evidence": ( - f"Runtime profile uses auth_mode={runtime_profile.get('auth_mode', 'unknown')}, " - f"allow_public_bind={runtime_profile.get('allow_public_bind', False)}, " - f"expose_trace_by_default={runtime_profile.get('expose_trace_by_default', False)}, " - f"rate_limit_requests={runtime_profile.get('rate_limit_requests', 'unknown')}, " - f"max_concurrent_runs={runtime_profile.get('max_concurrent_runs', 'unknown')}." - ), - "action": "Use the secret-free runtime profile as buyer-visible access-control evidence.", - "exit_criteria": "Buyer can verify admin and inference scopes, public bind opt-in, trace exposure default, rate limit, and concurrency controls.", - }, - { - "item_name": "audit_export_evidence", - "label": "Audit and evidence export", - "owner": "Evidence owner", - "sources": [ - "docs/commercial_evidence_export.md", - "docs/commercial_operations_readiness.md", - "/api/v1/commercial_evidence_exports/latest", - "/api/v1/commercial_operations_readiness/latest", - ], - "evidence_type": "repository_and_runtime_artifact", - "completion_state": "ready" - if has_file("docs/commercial_evidence_export.md") - and has_file("docs/commercial_operations_readiness.md") - else "blocked", - "evidence": "Commercial evidence export and operations readiness documents are present for buyer audit review.", - "action": "Package runtime evidence export with operations readiness for the security review data room.", - "exit_criteria": "Buyer can trace security claims to runtime endpoints and Markdown artifacts.", - }, - { - "item_name": "vulnerability_scan_evidence", - "label": "Vulnerability scan evidence", - "owner": "Security owner", - "sources": [ - ".github/workflows/security.yml", - "ContextualWisdomLab/.github central required security workflows", - ], - "evidence_type": "external_attestation_required", - "completion_state": "warning", - "source_gap_status": "external_attestation_required", - "evidence": "Local supply-chain workflow metadata and central security scan workflow metadata exist, but the buyer packet still needs the latest hosted scan result or buyer-accepted equivalent.", - "action": "Attach latest CodeQL, pip-audit, Trivy, SBOM, and Scorecard results when CI completes or the buyer requests evidence.", - "exit_criteria": "Hosted scan outputs are attached, or the buyer explicitly accepts workflow definitions as sufficient for this stage.", - }, - { - "item_name": "third_party_attestation_pen_test", - "label": "Third-party attestation or penetration test", - "owner": "Security owner", - "sources": ["buyer security review", "external assessor"], - "evidence_type": "external_attestation_required", - "completion_state": "warning", - "source_gap_status": "external_attestation_required", - "evidence": "Independent SOC 2, ISO 27001, penetration-test, or buyer security assessment evidence is outside the repo-local prototype.", - "action": "Provide the buyer-requested attestation, schedule an assessment, or document an explicit waiver.", - "exit_criteria": "Buyer accepts the third-party security evidence, scheduled assessment, or waiver.", - }, - { - "item_name": "buyer_privacy_dpa_questionnaire", - "label": "Buyer privacy, DPA, and questionnaire input", - "owner": "Deal owner", - "sources": ["buyer DPA", "buyer privacy questionnaire", "buyer order form"], - "evidence_type": "buyer_input_required", - "completion_state": "warning", - "source_gap_status": "buyer_input_required", - "evidence": "Privacy, DPA, subprocessors, data residency, and questionnaire answers depend on buyer-specific terms.", - "action": "Collect buyer privacy questionnaire, DPA requirements, subprocessors, and data residency constraints.", - "exit_criteria": "Buyer-specific privacy inputs are completed or explicitly waived in the deal packet.", - }, - { - "item_name": "review_process_policy", - "label": "Review process policy", - "owner": "Deal owner", - "sources": operations_by_name["review_process_policy"]["sources"], - "evidence_type": operations_by_name["review_process_policy"]["evidence_type"], - "completion_state": operations_by_name["review_process_policy"]["completion_state"], - "evidence": operations_by_name["review_process_policy"]["evidence"], - "action": operations_by_name["review_process_policy"]["action"], - "exit_criteria": operations_by_name["review_process_policy"]["exit_criteria"], - }, - { - "item_name": "packaging_decision", - "label": "Packaging decision", - "owner": operations_by_name["packaging_decision"]["owner"], - "sources": operations_by_name["packaging_decision"]["sources"], - "evidence_type": operations_by_name["packaging_decision"]["evidence_type"], - "completion_state": operations_by_name["packaging_decision"]["completion_state"], - "evidence": operations_by_name["packaging_decision"]["evidence"], - "action": operations_by_name["packaging_decision"]["action"], - "exit_criteria": operations_by_name["packaging_decision"]["exit_criteria"], - }, - ] - state_counts = Counter(item["completion_state"] for item in security_attestation_items) - blocked_count = state_counts.get("blocked", 0) + len(concrete_blockers) - warning_count = state_counts.get("warning", 0) - external_attestation_gap_count = sum( - 1 for item in security_attestation_items if item.get("source_gap_status") == "external_attestation_required" - ) - buyer_privacy_gap_count = sum( - 1 for item in security_attestation_items if item.get("source_gap_status") == "buyer_input_required" - ) - if blocked_count: - security_attestation_status = "commercial_security_attestation_blocked" - elif warning_count: - security_attestation_status = "commercial_security_attestation_ready_with_warnings" - else: # pragma: no cover - unreachable while this report carries literal buyer-specific warning sections - security_attestation_status = "commercial_security_attestation_ready" # pragma: no cover - - return { - "security_attestation_status": security_attestation_status, - "target_contract_value_krw": target_contract_value_krw, - "target_contract_value_display": f"KRW {target_contract_value_krw:,}", - "measurement_status": "local_commercial_security_attestation", - "source_note": ( - "Commercial security attestation separates repo-local security evidence from external " - "attestation, hosted scan, and buyer privacy inputs; it is not a valuation guarantee, " - "purchase commitment, production compliance certificate, or third-party security audit." - ), - "security_attestation_summary": { - "item_count": len(security_attestation_items), - "ready_count": state_counts.get("ready", 0), - "warning_count": warning_count, - "blocked_count": blocked_count, - "external_attestation_gap_count": external_attestation_gap_count, - "buyer_privacy_gap_count": buyer_privacy_gap_count, - "review_process_is_blocker": operations["review_process_policy"]["is_blocker"], - }, - "security_attestation_items": security_attestation_items, - "concrete_blockers": concrete_blockers, - "security_attestation_status_rules": [ - { - "security_attestation_status": "commercial_security_attestation_ready", - "rule": "security policy, dependency metadata, workflow metadata, access controls, audit export, external attestation, buyer privacy input, review policy, and packaging evidence are ready", - }, - { - "security_attestation_status": "commercial_security_attestation_ready_with_warnings", - "rule": "repo-local security packet is ready while hosted scan evidence, third-party attestation, or buyer privacy input remains explicit warnings", - }, - { - "security_attestation_status": "commercial_security_attestation_blocked", - "rule": "missing local security packet evidence, concrete product defect, API contract failure, document mismatch, security failure, or Code Connect usage blocks security attestation", - }, - ], - "review_process_policy": operations["review_process_policy"], - "related_runtime_reports": { - "commercial_operations_status": operations["operations_status"], - **operations["related_runtime_reports"], - }, - "library_split_decision": operations["library_split_decision"], - "plugin_traceability": operations["plugin_traceability"], - "security_attestation_links": { - "figma_design_file": "https://www.figma.com/design/vsZMd8WAv42HDRgcZuNcWk", - "figjam_board": "https://www.figma.com/board/Wr8iMlB9SHkerHSjv0Pe0M", - "runtime_endpoint": "/api/v1/commercial_security_attestations/latest", - "documentation": "docs/commercial_security_attestation.md", - }, - } - - def commercial_value_readiness_report( - self, - target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, - locale_bundles: dict[str, dict[str, str]] | None = None, - security_profile: dict[str, Any] | None = None, - release_authority: Mapping[str, Any] | None = None, - ) -> dict[str, Any]: - """Return a buyer economic-review gate over value and ROI evidence.""" - commercial = self.commercial_readiness_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - export = self.commercial_evidence_export_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - security = self.commercial_security_attestation_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - release_authority=release_authority, - ) - analytics = self.analytics_snapshot(locale_bundles=locale_bundles) - root = Path(__file__).resolve().parents[1] - - def has_file(path: str) -> bool: - return (root / path).is_file() - - criteria_by_name = self._criteria_by_name(commercial["criteria"]) - value_case = criteria_by_name["commercial_value_case"] - kpis = self._metrics_by_name(analytics["kpis"]) - guardrails = self._metrics_by_name(analytics["guardrails"]) - security_items = {item["item_name"]: item for item in security["security_attestation_items"]} - value_items = [ - { - "item_name": "commercial_value_case_basis", - "label": "Commercial value-case basis", - "owner": "Deal owner", - "sources": ["/api/v1/commercial_readiness/latest", "docs/commercial_readiness.md"], - "evidence_type": "local_due_diligence_snapshot", - "completion_state": "ready" if value_case["status"] == "pass" else "warning", - "evidence": value_case["evidence"], - "action": "Use commercial readiness as the value-case baseline without presenting it as a valuation guarantee.", - "exit_criteria": "Buyer sees the KRW target as a review anchor, not as a guaranteed valuation.", - }, - { - "item_name": "local_analytics_evidence", - "label": "Local analytics evidence", - "owner": "Product analytics owner", - "sources": ["/api/v1/analytics_snapshots/latest", "docs/analytics_spec.md"], - "evidence_type": "measured_local", - "completion_state": "ready", - "evidence": ( - f"compatible_api_adoption={kpis['compatible_api_adoption'].get('value')}; " - f"trace_complete_workflow_rate={kpis['trace_complete_workflow_rate'].get('value_percent')}%; " - f"policy_safe_routing_rate={kpis['policy_safe_routing_rate'].get('value_percent')}%; " - f"provider_exclusion_miss_rate={guardrails['provider_exclusion_miss_rate'].get('value')}" - ), - "action": "Use local measured adoption, trace, policy, and provider-safety metrics as evidence only for this prototype.", - "exit_criteria": "Buyer understands these are local measured signals, not production revenue or customer usage claims.", - }, - { - "item_name": "buyer_evidence_export", - "label": "Buyer evidence export", - "owner": "Evidence owner", - "sources": [ - "/api/v1/commercial_evidence_exports/latest", - "/api/v1/commercial_security_attestations/latest", - "docs/commercial_evidence_export.md", - ], - "evidence_type": "repository_and_runtime_artifact", - "completion_state": "ready" if has_file("docs/commercial_evidence_export.md") else "blocked", - "evidence": ( - f"commercial_export_status={export['export_status']}; " - f"security_attestation_status={security['security_attestation_status']}" - ), - "action": "Package value evidence with export and security attestation outputs in the buyer data room.", - "exit_criteria": "Buyer can trace economic claims back to runtime endpoints and repo artifacts.", - }, - { - "item_name": "pricing_package_rationale", - "label": "Pricing and package rationale", - "owner": "Deal owner", - "sources": [ - "docs/commercial_readiness.md", - "docs/commercial_saleability_decision.md", - "docs/commercial_procurement_readiness.md", - "docs/commercial_value_readiness.md", - ], - "evidence_type": "repository_artifact", - "completion_state": "ready" - if all( - has_file(path) - for path in ( - "docs/commercial_readiness.md", - "docs/commercial_saleability_decision.md", - "docs/commercial_procurement_readiness.md", - ) - ) - else "blocked", - "evidence": "Commercial readiness, saleability, and procurement documents anchor the package rationale.", - "action": "Keep the KRW 2B package rationale tied to API compatibility, evidence control plane, replay, audit, security, and operations readiness.", - "exit_criteria": "Buyer can inspect which product capabilities support the package rationale.", - }, - { - "item_name": "roi_model_inputs", - "label": "ROI model inputs", - "owner": "Buyer sponsor and deal owner", - "sources": ["buyer ROI model", "customer discovery", "procurement value case"], - "evidence_type": "buyer_input_required", - "completion_state": "warning", - "source_gap_status": "buyer_financial_input_required", - "evidence": "Buyer-specific baseline cost, workflow volume, error/rework cost, compliance cost, and time-saving assumptions are not repo-local facts.", - "action": "Collect buyer baseline metrics and map them to API compatibility, trace audit, replay, and operations savings.", - "exit_criteria": "Buyer accepts the ROI model inputs or marks them waived for the commercial review.", - }, - { - "item_name": "reference_customer_or_case_study", - "label": "Reference customer or proof", - "owner": "Deal owner", - "sources": ["reference customer", "case study", "paid pilot result"], - "evidence_type": "external_value_proof_required", - "completion_state": "warning", - "source_gap_status": "external_value_proof_required", - "evidence": "Reference customer, paid pilot, or production proof is external to the repo-local prototype.", - "action": "Attach a reference, pilot result, or explicit buyer waiver before treating the value case as externally proven.", - "exit_criteria": "Buyer accepts the reference proof, pilot result, or waiver.", - }, - { - "item_name": "procurement_budget_owner", - "label": "Procurement budget owner", - "owner": "Buyer sponsor and procurement owner", - "sources": ["buyer order form", "procurement process", "budget approval"], - "evidence_type": "buyer_input_required", - "completion_state": "warning", - "source_gap_status": "buyer_financial_input_required", - "evidence": "Budget owner, approval path, and order-form authority are buyer-specific inputs.", - "action": "Identify sponsor, budget owner, procurement path, and order-form authority.", - "exit_criteria": "Buyer confirms the budget owner and approval path for the KRW 2B review.", - }, - { - "item_name": "implementation_payback_assumption", - "label": "Implementation payback assumption", - "owner": "Buyer sponsor and onboarding owner", - "sources": ["buyer onboarding plan", "implementation estimate", "operations handoff"], - "evidence_type": "buyer_input_required", - "completion_state": "warning", - "source_gap_status": "buyer_financial_input_required", - "evidence": "Implementation timeline, staffing, opportunity cost, and payback window depend on buyer deployment scope.", - "action": "Estimate implementation effort and payback window during paid onboarding or buyer diligence.", - "exit_criteria": "Buyer accepts the payback assumptions or marks them out of scope.", - }, - { - "item_name": "review_process_policy", - "label": "Review process policy", - "owner": "Deal owner", - "sources": security_items["review_process_policy"]["sources"], - "evidence_type": security_items["review_process_policy"]["evidence_type"], - "completion_state": security_items["review_process_policy"]["completion_state"], - "evidence": security_items["review_process_policy"]["evidence"], - "action": security_items["review_process_policy"]["action"], - "exit_criteria": security_items["review_process_policy"]["exit_criteria"], - }, - { - "item_name": "packaging_decision", - "label": "Packaging decision", - "owner": security_items["packaging_decision"]["owner"], - "sources": security_items["packaging_decision"]["sources"], - "evidence_type": security_items["packaging_decision"]["evidence_type"], - "completion_state": security_items["packaging_decision"]["completion_state"], - "evidence": security_items["packaging_decision"]["evidence"], - "action": security_items["packaging_decision"]["action"], - "exit_criteria": security_items["packaging_decision"]["exit_criteria"], - }, - ] - state_counts = Counter(item["completion_state"] for item in value_items) - concrete_blockers = security["concrete_blockers"] - blocked_count = state_counts.get("blocked", 0) + len(concrete_blockers) - warning_count = state_counts.get("warning", 0) - buyer_financial_gap_count = sum( - 1 - for item in value_items - if item.get("source_gap_status") in {"buyer_financial_input_required", "external_value_proof_required"} - ) - external_value_proof_gap_count = sum( - 1 for item in value_items if item.get("source_gap_status") == "external_value_proof_required" - ) - if blocked_count: - value_status = "commercial_value_blocked" - elif warning_count: - value_status = "commercial_value_ready_with_warnings" - else: # pragma: no cover - unreachable while this report carries literal buyer-specific warning sections - value_status = "commercial_value_ready" # pragma: no cover - - return { - "value_status": value_status, - "target_contract_value_krw": target_contract_value_krw, - "target_contract_value_display": f"KRW {target_contract_value_krw:,}", - "measurement_status": "local_commercial_value_readiness", - "source_note": ( - "Commercial value readiness separates repo-local measured evidence from buyer-specific " - "ROI, reference, budget, and payback inputs; it is not a valuation guarantee, purchase " - "commitment, revenue proof, or financial advice." - ), - "value_summary": { - "item_count": len(value_items), - "ready_count": state_counts.get("ready", 0), - "warning_count": warning_count, - "blocked_count": blocked_count, - "buyer_financial_gap_count": buyer_financial_gap_count, - "external_value_proof_gap_count": external_value_proof_gap_count, - "review_process_is_blocker": security["review_process_policy"]["is_blocker"], - }, - "value_items": value_items, - "concrete_blockers": concrete_blockers, - "value_status_rules": [ - { - "value_status": "commercial_value_ready", - "rule": "commercial value case, local analytics, evidence export, pricing rationale, ROI inputs, reference proof, budget owner, payback assumptions, review policy, and packaging evidence are ready", - }, - { - "value_status": "commercial_value_ready_with_warnings", - "rule": "repo-local value evidence is ready while buyer ROI inputs, reference proof, budget owner, or payback assumptions remain explicit warnings", - }, - { - "value_status": "commercial_value_blocked", - "rule": "missing local value packet evidence, concrete product defect, API contract failure, document mismatch, security failure, or Code Connect usage blocks value readiness", - }, - ], - "review_process_policy": security["review_process_policy"], - "related_runtime_reports": { - "commercial_security_attestation_status": security["security_attestation_status"], - "commercial_export_status": export["export_status"], - "commercial_status": commercial["commercial_status"], - **security["related_runtime_reports"], - }, - "library_split_decision": security["library_split_decision"], - "plugin_traceability": security["plugin_traceability"], - "value_links": { - "figma_design_file": "https://www.figma.com/design/vsZMd8WAv42HDRgcZuNcWk", - "figjam_board": "https://www.figma.com/board/Wr8iMlB9SHkerHSjv0Pe0M", - "runtime_endpoint": "/api/v1/commercial_value_readiness/latest", - "documentation": "docs/commercial_value_readiness.md", - }, - } - - def commercial_close_readiness_report( - self, - target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, - locale_bundles: dict[str, dict[str, str]] | None = None, - security_profile: dict[str, Any] | None = None, - release_authority: Mapping[str, Any] | None = None, - ) -> dict[str, Any]: - """Return the final buyer-close gate over commercial readiness evidence.""" - value = self.commercial_value_readiness_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - release_authority=release_authority, - ) - security = self.commercial_security_attestation_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - release_authority=release_authority, - ) - contract = self.commercial_contract_readiness_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - release_authority=release_authority, - ) - onboarding = self.commercial_onboarding_readiness_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - release_authority=release_authority, - ) - operations = self.commercial_operations_readiness_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - release_authority=release_authority, - ) - export = self.commercial_evidence_export_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - root = Path(__file__).resolve().parents[1] - - def has_file(path: str) -> bool: - return (root / path).is_file() - - concrete_blockers = [ - *value["concrete_blockers"], - *security["concrete_blockers"], - *contract["concrete_blockers"], - *onboarding["concrete_blockers"], - *operations["concrete_blockers"], - *export["concrete_blockers"], - ] - concrete_blockers = list(dict.fromkeys(concrete_blockers)) - close_items = [ - { - "item_name": "sellable_product_packet", - "label": "Sellable product packet", - "owner": "Deal owner", - "sources": [ - "/api/v1/commercial_value_readiness/latest", - "/api/v1/commercial_security_attestations/latest", - "/api/v1/commercial_evidence_exports/latest", - "docs/commercial_value_readiness.md", - "docs/commercial_security_attestation.md", - "docs/commercial_evidence_export.md", - ], - "evidence_type": "repository_and_runtime_artifact", - "completion_state": "ready" - if value["value_status"] != "commercial_value_blocked" - and security["security_attestation_status"] != "commercial_security_attestation_blocked" - and export["export_status"] != "commercial_export_blocked" - and has_file("docs/commercial_value_readiness.md") - and has_file("docs/commercial_security_attestation.md") - and has_file("docs/commercial_evidence_export.md") - else "blocked", - "evidence": ( - f"value_status={value['value_status']}; " - f"security_attestation_status={security['security_attestation_status']}; " - f"commercial_export_status={export['export_status']}" - ), - "action": "Attach the repo-local product, security, value, and evidence export packet to buyer close review.", - "exit_criteria": "Buyer can inspect the sellable packet without treating it as a purchase commitment or valuation guarantee.", - }, - { - "item_name": "contract_close_packet", - "label": "Contract close packet", - "owner": "Legal and procurement owner", - "sources": [ - "/api/v1/commercial_contract_readiness/latest", - "docs/commercial_contract_readiness.md", - "docs/commercial_procurement_readiness.md", - ], - "evidence_type": "repository_and_runtime_artifact", - "completion_state": "ready" - if contract["contract_status"] != "commercial_contract_blocked" - and has_file("docs/commercial_contract_readiness.md") - else "blocked", - "evidence": f"contract_status={contract['contract_status']}", - "action": "Use contract readiness as the local legal/procurement packet and track final signatures separately.", - "exit_criteria": "Buyer legal/procurement sees local contract evidence and the remaining signature inputs.", - }, - { - "item_name": "onboarding_operations_packet", - "label": "Onboarding and operations packet", - "owner": "Customer success and platform owner", - "sources": [ - "/api/v1/commercial_onboarding_readiness/latest", - "/api/v1/commercial_operations_readiness/latest", - "docs/commercial_onboarding_readiness.md", - "docs/commercial_operations_readiness.md", - ], - "evidence_type": "repository_and_runtime_artifact", - "completion_state": "ready" - if onboarding["onboarding_status"] != "commercial_onboarding_blocked" - and operations["operations_status"] != "commercial_operations_blocked" - and has_file("docs/commercial_onboarding_readiness.md") - and has_file("docs/commercial_operations_readiness.md") - else "blocked", - "evidence": ( - f"onboarding_status={onboarding['onboarding_status']}; " - f"operations_status={operations['operations_status']}" - ), - "action": "Attach onboarding and operations readiness as the go-live support packet.", - "exit_criteria": "Buyer can identify implementation, support, operations, and acceptance owners.", - }, - { - "item_name": "buyer_evidence_export_packet", - "label": "Buyer evidence export packet", - "owner": "Evidence owner", - "sources": [ - "/api/v1/commercial_evidence_exports/latest", - "docs/commercial_evidence_export.md", - "docs/figma_artifacts.md", - ], - "evidence_type": "repository_and_runtime_artifact", - "completion_state": "ready" - if export["export_status"] != "commercial_export_blocked" - and has_file("docs/commercial_evidence_export.md") - and has_file("docs/figma_artifacts.md") - else "blocked", - "evidence": f"commercial_export_status={export['export_status']}", - "action": "Use the portable export packet as the buyer data-room index.", - "exit_criteria": "Buyer can trace close evidence to runtime endpoints, docs, and Figma/FigJam artifacts.", - }, - { - "item_name": "signed_order_form_msa", - "label": "Signed order form or MSA", - "owner": "Buyer sponsor, procurement owner, and deal owner", - "sources": ["buyer order form", "MSA", "signature packet"], - "evidence_type": "buyer_signature_required", - "completion_state": "warning", - "source_gap_status": "buyer_signature_required", - "evidence": "Signed order form, MSA, commercial terms, and authority confirmation are buyer-side close inputs.", - "action": "Collect final signed order form or MSA, or attach an explicit buyer waiver.", - "exit_criteria": "Buyer and seller signature authority accept the order form or MSA.", - }, - { - "item_name": "dpa_security_acceptance", - "label": "DPA and security acceptance", - "owner": "Buyer security, privacy, and legal owner", - "sources": ["buyer DPA", "security review acceptance", "privacy questionnaire"], - "evidence_type": "buyer_signature_required", - "completion_state": "warning", - "source_gap_status": "buyer_signature_required", - "evidence": "DPA, security acceptance, privacy questionnaire, and attestation waivers are buyer-specific close inputs.", - "action": "Collect DPA/security acceptance or documented waiver from buyer security and legal reviewers.", - "exit_criteria": "Buyer signs or waives DPA/security acceptance requirements.", - }, - { - "item_name": "budget_approval_purchase_order", - "label": "Budget approval and purchase order", - "owner": "Buyer finance and procurement owner", - "sources": ["budget approval", "purchase order", "finance approval"], - "evidence_type": "buyer_signature_required", - "completion_state": "warning", - "source_gap_status": "buyer_signature_required", - "evidence": "Budget approval, purchase order, and finance authority are external buyer procurement evidence.", - "action": "Collect buyer budget approval and PO or attach approved alternative payment authority.", - "exit_criteria": "Buyer procurement confirms budget authority and payment path for KRW 2B.", - }, - { - "item_name": "go_live_authorization", - "label": "Go-live authorization", - "owner": "Buyer business sponsor and implementation owner", - "sources": ["go-live approval", "implementation authorization", "acceptance signoff"], - "evidence_type": "buyer_signature_required", - "completion_state": "warning", - "source_gap_status": "buyer_signature_required", - "evidence": "Go-live authorization and implementation acceptance require named buyer approval.", - "action": "Collect go-live authorization or mark production activation out of scope for the signed deal.", - "exit_criteria": "Buyer authorizes go-live, paid onboarding, or a scoped post-signature implementation plan.", - }, - { - "item_name": "review_process_policy", - "label": "Review process policy", - "owner": "Deal owner", - "sources": ["docs/commercial_saleability_decision.md", "docs/commercial_close_readiness.md"], - "evidence_type": "repository_artifact", - "completion_state": "ready", - "evidence": "Review process delay is not a close blocker unless a concrete product, security, API-contract, or document failure is produced.", - "action": "Keep commercial close work moving while queued review processes are pending.", - "exit_criteria": "Only concrete failures block close readiness.", - }, - { - "item_name": "packaging_decision", - "label": "Packaging decision", - "owner": "Procurement and security reviewer", - "sources": ["docs/library_research.md", "docs/commercial_plugin_operating_model.md"], - "evidence_type": "repository_artifact", - "completion_state": "ready" - if value["library_split_decision"]["decision"] == "keep_single_product" - else "warning", - "evidence": value["library_split_decision"]["reason"], - "action": "Keep one deployable enterprise control-plane product until extraction triggers are real.", - "exit_criteria": "Do not create a separate library, Git submodule, or extracted package for this close gate.", - }, - ] - state_counts = Counter(item["completion_state"] for item in close_items) - blocked_count = state_counts.get("blocked", 0) + len(concrete_blockers) - warning_count = state_counts.get("warning", 0) - buyer_signature_gap_count = sum( - 1 for item in close_items if item.get("source_gap_status") == "buyer_signature_required" - ) - if blocked_count: - close_status = "commercial_close_blocked" - elif warning_count: - close_status = "commercial_close_ready_with_warnings" - else: # pragma: no cover - unreachable while this report carries literal buyer-specific warning sections - close_status = "commercial_close_ready" # pragma: no cover - - return { - "close_status": close_status, - "target_contract_value_krw": target_contract_value_krw, - "target_contract_value_display": f"KRW {target_contract_value_krw:,}", - "measurement_status": "local_commercial_close_readiness", - "source_note": ( - "Commercial close readiness separates repo-local sellable product evidence from buyer " - "signature, legal, procurement, security acceptance, and go-live authorization inputs; " - "it is not a valuation guarantee, purchase commitment, signed order, legal opinion, " - "or production compliance certificate." - ), - "close_summary": { - "item_count": len(close_items), - "ready_count": state_counts.get("ready", 0), - "warning_count": warning_count, - "blocked_count": blocked_count, - "buyer_signature_gap_count": buyer_signature_gap_count, - "review_process_is_blocker": value["review_process_policy"]["is_blocker"], - }, - "close_items": close_items, - "concrete_blockers": concrete_blockers, - "close_status_rules": [ - { - "close_status": "commercial_close_ready", - "rule": "sellable product packet, contract packet, onboarding/operations packet, evidence export, signatures, DPA/security acceptance, budget/PO, go-live authorization, review policy, and packaging evidence are ready", - }, - { - "close_status": "commercial_close_ready_with_warnings", - "rule": "repo-local close packet is ready while buyer signatures, DPA/security acceptance, budget/PO, or go-live authorization remain explicit warnings", - }, - { - "close_status": "commercial_close_blocked", - "rule": "missing local close evidence, concrete product defect, API contract failure, document mismatch, security failure, or Code Connect usage blocks close readiness", - }, - ], - "review_process_policy": value["review_process_policy"], - "related_runtime_reports": { - "commercial_value_status": value["value_status"], - "commercial_security_attestation_status": security["security_attestation_status"], - "commercial_contract_status": contract["contract_status"], - "commercial_onboarding_status": onboarding["onboarding_status"], - "commercial_operations_status": operations["operations_status"], - "commercial_export_status": export["export_status"], - **value["related_runtime_reports"], - }, - "library_split_decision": value["library_split_decision"], - "plugin_traceability": value["plugin_traceability"], - "close_links": { - "figma_design_file": "https://www.figma.com/design/vsZMd8WAv42HDRgcZuNcWk", - "figjam_board": "https://www.figma.com/board/Wr8iMlB9SHkerHSjv0Pe0M", - "runtime_endpoint": "/api/v1/commercial_close_readiness/latest", - "documentation": "docs/commercial_close_readiness.md", - }, - } - - def commercial_go_to_market_readiness_report( - self, - target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, - locale_bundles: dict[str, dict[str, str]] | None = None, - security_profile: dict[str, Any] | None = None, - release_authority: Mapping[str, Any] | None = None, - ) -> dict[str, Any]: - """Return a buyer-facing GTM readiness index over commercial evidence.""" - close = self.commercial_close_readiness_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - release_authority=release_authority, - ) - value = self.commercial_value_readiness_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - release_authority=release_authority, - ) - security = self.commercial_security_attestation_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - release_authority=release_authority, - ) - export = self.commercial_evidence_export_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - handoff = self.commercial_handoff_bundle_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - saleability = self.saleability_decision_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - analytics = self.analytics_snapshot(locale_bundles=locale_bundles) - root = Path(__file__).resolve().parents[1] - - def has_file(path: str) -> bool: - return (root / path).is_file() - - concrete_blockers = [ - *close["concrete_blockers"], - *value["concrete_blockers"], - *security["concrete_blockers"], - *export["concrete_blockers"], - *saleability["concrete_blockers"], - ] - concrete_blockers = list(dict.fromkeys(concrete_blockers)) - gtm_items = [ - { - "item_name": "commercial_close_packet", - "label": "Commercial close packet", - "owner": "Deal owner", - "sources": ["/api/v1/commercial_close_readiness/latest", "docs/commercial_close_readiness.md"], - "evidence_type": "repository_and_runtime_artifact", - "completion_state": "ready" - if close["close_status"] != "commercial_close_blocked" - and has_file("docs/commercial_close_readiness.md") - else "blocked", - "evidence": f"close_status={close['close_status']}", - "action": "Use close readiness as the buyer-facing final readiness packet.", - "exit_criteria": "Buyer sees local close packet status and remaining buyer-side signature gaps.", - }, - { - "item_name": "economic_value_packet", - "label": "Economic value packet", - "owner": "Deal owner and analytics owner", - "sources": [ - "/api/v1/commercial_value_readiness/latest", - "/api/v1/analytics_snapshots/latest", - "docs/commercial_value_readiness.md", - "docs/analytics_spec.md", - ], - "evidence_type": "repository_and_runtime_artifact", - "completion_state": "ready" - if value["value_status"] != "commercial_value_blocked" - and has_file("docs/commercial_value_readiness.md") - and has_file("docs/analytics_spec.md") - else "blocked", - "evidence": ( - f"value_status={value['value_status']}; " - f"kpi_count={len(analytics['kpis'])}; guardrail_count={len(analytics['guardrails'])}" - ), - "action": "Show value evidence with measured-local versus buyer-specific metric separation.", - "exit_criteria": "Buyer can inspect value claims without treating them as revenue proof or financial advice.", - }, - { - "item_name": "security_trust_packet", - "label": "Security trust packet", - "owner": "Security owner", - "sources": [ - "/api/v1/commercial_security_attestations/latest", - "docs/commercial_security_attestation.md", - "SECURITY.md", - ], - "evidence_type": "repository_and_runtime_artifact", - "completion_state": "ready" - if security["security_attestation_status"] != "commercial_security_attestation_blocked" - and has_file("docs/commercial_security_attestation.md") - and has_file("SECURITY.md") - else "blocked", - "evidence": f"security_attestation_status={security['security_attestation_status']}", - "action": "Use security attestation as the buyer trust packet and keep external attestations separate.", - "exit_criteria": "Buyer can inspect local security controls and external attestation gaps.", - }, - { - "item_name": "buyer_evidence_packet", - "label": "Buyer evidence packet", - "owner": "Evidence owner", - "sources": [ - "/api/v1/commercial_evidence_exports/latest", - "/api/v1/commercial_handoff_bundles/latest", - "docs/commercial_evidence_export.md", - "docs/commercial_buyer_handoff_bundle.md", - ], - "evidence_type": "repository_and_runtime_artifact", - "completion_state": "ready" - if export["export_status"] != "commercial_export_blocked" - and handoff["bundle_status"] != "buyer_handoff_blocked" - and has_file("docs/commercial_evidence_export.md") - and has_file("docs/commercial_buyer_handoff_bundle.md") - else "blocked", - "evidence": f"commercial_export_status={export['export_status']}; buyer_handoff_status={handoff['bundle_status']}", - "action": "Attach evidence export and handoff bundle as the buyer data-room index.", - "exit_criteria": "Buyer can trace GTM claims to runtime endpoints, docs, tests, and Figma artifacts.", - }, - { - "item_name": "saleability_decision_packet", - "label": "Saleability decision packet", - "owner": "Deal owner", - "sources": ["/api/v1/saleability_decisions/latest", "docs/commercial_saleability_decision.md"], - "evidence_type": "repository_and_runtime_artifact", - "completion_state": "ready" - if saleability["saleability_status"] != "saleability_blocked" - and has_file("docs/commercial_saleability_decision.md") - else "blocked", - "evidence": f"saleability_status={saleability['saleability_status']}", - "action": "Use saleability decision as the GTM go/no-go baseline.", - "exit_criteria": "Buyer and stakeholder review can distinguish warnings from concrete blockers.", - }, - { - "item_name": "admin_operator_evidence", - "label": "Admin operator evidence", - "owner": "Product design owner", - "sources": ["/admin", "contextual_orchestrator/admin.py", "docs/screen_design.md"], - "evidence_type": "repository_and_runtime_artifact", - "completion_state": "ready" - if has_file("contextual_orchestrator/admin.py") and has_file("docs/screen_design.md") - else "blocked", - "evidence": "Admin surface exposes readiness status, source notes, measurement status, and warning/blocker summaries.", - "action": "Use the existing admin observability surface instead of creating a separate sales dashboard.", - "exit_criteria": "Operator can inspect GTM readiness from the current admin surface.", - }, - { - "item_name": "analytics_truthfulness_packet", - "label": "Analytics truthfulness packet", - "owner": "Data analytics owner", - "sources": ["docs/analytics_spec.md", "/api/v1/analytics_snapshots/latest"], - "evidence_type": "repository_and_runtime_artifact", - "completion_state": "ready" if has_file("docs/analytics_spec.md") else "blocked", - "evidence": "Analytics spec separates measured local evidence from proposed production or buyer-specific inputs.", - "action": "Keep GTM metrics from claiming production revenue, signed buyer proof, or unmeasured telemetry.", - "exit_criteria": "Stakeholders can see which KPI fields are measured and which are proposed inputs.", - }, - { - "item_name": "stakeholder_artifacts_packet", - "label": "Stakeholder artifacts packet", - "owner": "Figma and Product Design owner", - "sources": [ - "docs/figma_artifacts.md", - "https://www.figma.com/design/vsZMd8WAv42HDRgcZuNcWk", - "https://www.figma.com/board/Wr8iMlB9SHkerHSjv0Pe0M", - ], - "evidence_type": "figma_artifact", - "completion_state": "ready" if has_file("docs/figma_artifacts.md") else "blocked", - "evidence": "Editable Figma/FigJam stakeholder artifacts are recorded and Figma Code Connect is excluded.", - "action": "Use editable stakeholder artifacts for GTM review instead of screenshot-only evidence.", - "exit_criteria": "Stakeholders can open the design file and FigJam board for GTM review.", - }, - { - "item_name": "buyer_signature_budget_follow_up", - "label": "Buyer signature and budget follow-up", - "owner": "Buyer sponsor, procurement owner, and deal owner", - "sources": ["buyer order form", "MSA", "DPA", "security acceptance", "purchase order", "go-live approval"], - "evidence_type": "buyer_input_required", - "completion_state": "warning", - "source_gap_status": "buyer_signature_required", - "evidence": ( - f"buyer_signature_gap_count={close['close_summary']['buyer_signature_gap_count']}; " - "signed order/MSA, DPA/security acceptance, budget/PO, and go-live authorization are buyer inputs." - ), - "action": "Collect buyer signatures, approvals, or waivers before representing the packet as closed-won.", - "exit_criteria": "Buyer accepts or waives all signature, budget, security acceptance, and go-live inputs.", - }, - { - "item_name": "production_external_proof_follow_up", - "label": "Production and external proof follow-up", - "owner": "Security, operations, and deal owner", - "sources": ["hosted scan output", "third-party attestation", "reference proof", "production telemetry"], - "evidence_type": "external_or_production_input_required", - "completion_state": "warning", - "source_gap_status": "external_or_production_input_required", - "evidence": ( - f"security_warning_count={security['security_attestation_summary']['warning_count']}; " - f"value_warning_count={value['value_summary']['warning_count']}; " - f"export_warning_count={export['export_summary']['warning_count']}" - ), - "action": "Attach hosted scan, third-party attestation, reference proof, and production telemetry when available.", - "exit_criteria": "Buyer accepts external proof, production proof, or an explicit waiver.", - }, - { - "item_name": "review_process_policy", - "label": "Review process policy", - "owner": "Deal owner", - "sources": ["docs/commercial_go_to_market_readiness.md", "docs/commercial_saleability_decision.md"], - "evidence_type": "repository_artifact", - "completion_state": "ready", - "evidence": "Review process delay is not a GTM blocker unless a concrete failure is produced.", - "action": "Continue GTM readiness work while queued reviews are pending.", - "exit_criteria": "Only concrete product, security, API contract, or document failures block GTM readiness.", - }, - { - "item_name": "packaging_decision", - "label": "Packaging decision", - "owner": "Procurement and security reviewer", - "sources": ["docs/library_research.md", "docs/commercial_plugin_operating_model.md"], - "evidence_type": "repository_artifact", - "completion_state": "ready" - if close["library_split_decision"]["decision"] == "keep_single_product" - else "warning", - "evidence": close["library_split_decision"]["reason"], - "action": "Keep one deployable enterprise control-plane product until extraction triggers are real.", - "exit_criteria": "Do not create a separate library, Git submodule, or extracted package for this GTM gate.", - }, - ] - state_counts = Counter(item["completion_state"] for item in gtm_items) - blocked_count = state_counts.get("blocked", 0) + len(concrete_blockers) - warning_count = state_counts.get("warning", 0) - buyer_signature_gap_count = close["close_summary"]["buyer_signature_gap_count"] - external_or_production_gap_count = ( - security["security_attestation_summary"]["external_attestation_gap_count"] - + value["value_summary"]["external_value_proof_gap_count"] - + export["export_summary"]["warning_count"] - ) - if blocked_count: - gtm_status = "commercial_go_to_market_blocked" - elif warning_count: - gtm_status = "commercial_go_to_market_ready_with_warnings" - else: # pragma: no cover - unreachable while this report carries literal buyer-specific warning sections - gtm_status = "commercial_go_to_market_ready" # pragma: no cover - - return { - "go_to_market_status": gtm_status, - "target_contract_value_krw": target_contract_value_krw, - "target_contract_value_display": f"KRW {target_contract_value_krw:,}", - "measurement_status": "local_commercial_go_to_market_readiness", - "source_note": ( - "Commercial go-to-market readiness indexes repo-local sellable product, evidence, " - "admin, analytics, and stakeholder artifacts separately from buyer signatures, " - "external proof, and production telemetry; it is not a valuation guarantee, purchase " - "commitment, signed order, legal opinion, production compliance certificate, or revenue proof." - ), - "go_to_market_summary": { - "item_count": len(gtm_items), - "ready_count": state_counts.get("ready", 0), - "warning_count": warning_count, - "blocked_count": blocked_count, - "buyer_signature_gap_count": buyer_signature_gap_count, - "external_or_production_gap_count": external_or_production_gap_count, - "review_process_is_blocker": close["review_process_policy"]["is_blocker"], - }, - "go_to_market_items": gtm_items, - "concrete_blockers": concrete_blockers, - "go_to_market_status_rules": [ - { - "go_to_market_status": "commercial_go_to_market_ready", - "rule": "close, value, security, evidence, saleability, admin, analytics, stakeholder artifacts, buyer inputs, external proof, review policy, and packaging evidence are ready", - }, - { - "go_to_market_status": "commercial_go_to_market_ready_with_warnings", - "rule": "repo-local GTM packet is ready while buyer signatures, budget/PO, DPA/security acceptance, production telemetry, reference proof, hosted scan, or third-party attestation remain explicit warnings", - }, - { - "go_to_market_status": "commercial_go_to_market_blocked", - "rule": "missing local GTM packet evidence, concrete product defect, API contract failure, document mismatch, security failure, or Code Connect usage blocks GTM readiness", - }, - ], - "review_process_policy": close["review_process_policy"], - "related_runtime_reports": { - "commercial_close_status": close["close_status"], - "commercial_value_status": value["value_status"], - "commercial_security_attestation_status": security["security_attestation_status"], - "commercial_export_status": export["export_status"], - "buyer_handoff_status": handoff["bundle_status"], - "saleability_status": saleability["saleability_status"], - **close["related_runtime_reports"], - }, - "library_split_decision": close["library_split_decision"], - "plugin_traceability": close["plugin_traceability"], - "go_to_market_links": { - "figma_design_file": "https://www.figma.com/design/vsZMd8WAv42HDRgcZuNcWk", - "figjam_board": "https://www.figma.com/board/Wr8iMlB9SHkerHSjv0Pe0M", - "runtime_endpoint": "/api/v1/commercial_go_to_market_readiness/latest", - "documentation": "docs/commercial_go_to_market_readiness.md", - }, - } - - def commercial_launch_readiness_report( - self, - target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, - locale_bundles: dict[str, dict[str, str]] | None = None, - security_profile: dict[str, Any] | None = None, - release_authority: Mapping[str, Any] | None = None, - ) -> dict[str, Any]: - """Return the buyer launch/trial readiness gate over commercial evidence.""" - gtm = self.commercial_go_to_market_readiness_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - release_authority=release_authority, - ) - operations = self.commercial_operations_readiness_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - release_authority=release_authority, - ) - onboarding = self.commercial_onboarding_readiness_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - release_authority=release_authority, - ) - acceptance = self.commercial_acceptance_check_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - analytics = self.analytics_snapshot(locale_bundles=locale_bundles) - admin_state = self.admin_state() - root = Path(__file__).resolve().parents[1] - - def has_file(path: str) -> bool: - return (root / path).is_file() - - concrete_blockers = [ - *gtm["concrete_blockers"], - *operations["concrete_blockers"], - *onboarding["concrete_blockers"], - *acceptance["concrete_blockers"], - ] - concrete_blockers = list(dict.fromkeys(concrete_blockers)) - launch_items = [ - { - "item_name": "go_to_market_packet", - "label": "Go-to-market packet", - "owner": "Deal owner", - "sources": [ - "/api/v1/commercial_go_to_market_readiness/latest", - "docs/commercial_go_to_market_readiness.md", - ], - "evidence_type": "repository_and_runtime_artifact", - "completion_state": "ready" - if gtm["go_to_market_status"] != "commercial_go_to_market_blocked" - and has_file("docs/commercial_go_to_market_readiness.md") - else "blocked", - "evidence": f"go_to_market_status={gtm['go_to_market_status']}", - "action": "Use the GTM packet as the launch/trial entry evidence.", - "exit_criteria": "Buyer can inspect the launch packet without treating it as a signed deal or production proof.", - }, - { - "item_name": "runtime_launch_path", - "label": "Runtime launch path", - "owner": "Platform operator", - "sources": [ - "README.md", - "contextual_orchestrator/server.py", - "contextual_orchestrator/api_contract.py", - "docs/rest_api_design.md", - "/v1/chat/completions", - "/admin", - ], - "evidence_type": "repository_artifact", - "completion_state": "ready" - if all( - has_file(path) - for path in ( - "README.md", - "contextual_orchestrator/server.py", - "contextual_orchestrator/api_contract.py", - "docs/rest_api_design.md", - ) - ) - else "blocked", - "evidence": "Stdlib server, OpenAI-compatible endpoint, admin console, and REST contract are present.", - "action": "Run the existing server and admin/API smoke tests for buyer trial setup.", - "exit_criteria": "Buyer can start the runtime, authenticate admin calls, and inspect launch readiness JSON.", - }, - { - "item_name": "acceptance_test_packet", - "label": "Acceptance test packet", - "owner": "Technical reviewer", - "sources": [ - "/api/v1/commercial_acceptance_checks/latest", - "tests/test_commercial_acceptance_check.py", - "tests/test_commercial_go_to_market_readiness.py", - "tests/test_commercial_launch_readiness.py", - "pytest -q", - ], - "evidence_type": "measured_local", - "completion_state": "ready" - if acceptance["acceptance_status"] != "commercial_acceptance_blocked" - and all( - has_file(path) - for path in ( - "tests/test_commercial_acceptance_check.py", - "tests/test_commercial_go_to_market_readiness.py", - "tests/test_commercial_launch_readiness.py", - ) - ) - else "blocked", - "evidence": f"acceptance_status={acceptance['acceptance_status']}", - "action": "Use focused acceptance and launch tests as the local verification packet.", - "exit_criteria": "Focused launch, GTM, acceptance, API, and artifact tests pass before buyer handoff.", - }, - { - "item_name": "operator_runbook_packet", - "label": "Operator runbook packet", - "owner": "Customer success and platform owner", - "sources": [ - "/api/v1/commercial_operations_readiness/latest", - "/api/v1/commercial_onboarding_readiness/latest", - "docs/commercial_operations_readiness.md", - "docs/commercial_onboarding_readiness.md", - ], - "evidence_type": "repository_and_runtime_artifact", - "completion_state": "ready" - if operations["operations_status"] != "commercial_operations_blocked" - and onboarding["onboarding_status"] != "commercial_onboarding_blocked" - and has_file("docs/commercial_operations_readiness.md") - and has_file("docs/commercial_onboarding_readiness.md") - else "blocked", - "evidence": ( - f"operations_status={operations['operations_status']}; " - f"onboarding_status={onboarding['onboarding_status']}" - ), - "action": "Attach onboarding and operations readiness as the launch runbook.", - "exit_criteria": "Buyer sees implementation, support, telemetry, incident, backup, and acceptance owners.", - }, - { - "item_name": "admin_observability_packet", - "label": "Admin observability packet", - "owner": "Product design owner", - "sources": ["/admin", "/admin/state", "contextual_orchestrator/admin.py", "docs/screen_design.md"], - "evidence_type": "repository_and_runtime_artifact", - "completion_state": "ready" - if admin_state["agents"] and has_file("contextual_orchestrator/admin.py") and has_file("docs/screen_design.md") - else "blocked", - "evidence": ( - f"agent_count={len(admin_state['agents'])}; " - "admin surface exposes launch, source, measurement, and warning summaries." - ), - "action": "Use the current admin observability surface rather than a separate sales dashboard.", - "exit_criteria": "Operator can review launch readiness from the existing admin console.", - }, - { - "item_name": "buyer_environment_inputs", - "label": "Buyer environment inputs", - "owner": "Buyer implementation owner and platform operator", - "sources": ["buyer environment URL", "deployment topology", "admin token handoff", "data retention decision"], - "evidence_type": "buyer_environment_required", - "completion_state": "warning", - "source_gap_status": "buyer_environment_required", - "evidence": "Buyer deployment URL, topology, credentials handoff, retention, and network policy are not repo-local evidence.", - "action": "Collect buyer environment details or attach explicit trial-scope waivers.", - "exit_criteria": "Buyer provides environment inputs or agrees the launch is limited to repo-local/demo execution.", - }, - { - "item_name": "production_telemetry_inputs", - "label": "Production telemetry inputs", - "owner": "Operations and analytics owner", - "sources": [ - "/api/v1/commercial_operations_readiness/latest", - "/api/v1/analytics_snapshots/latest", - "production request logs", - "incident drill record", - "backup restore proof", - ], - "evidence_type": "proposed_until_production", - "completion_state": "warning", - "source_gap_status": "production_input_required", - "evidence": ( - f"operations_production_evidence_action_count=" - f"{operations['operations_summary']['production_evidence_action_count']}; " - f"analytics_measurement_status={analytics['measurement_status']}" - ), - "action": "Capture production telemetry, SLO evidence, incident drill, and restore proof in the buyer environment.", - "exit_criteria": "First production telemetry snapshot and operations proof are attached or explicitly waived.", - }, - { - "item_name": "commercial_signature_inputs", - "label": "Commercial signature inputs", - "owner": "Buyer sponsor, procurement owner, and deal owner", - "sources": ["signed order/MSA", "DPA/security acceptance", "purchase order", "go-live authorization"], - "evidence_type": "buyer_signature_required", - "completion_state": "warning", - "source_gap_status": "buyer_signature_required", - "evidence": ( - f"buyer_signature_gap_count={gtm['go_to_market_summary']['buyer_signature_gap_count']}; " - "signed order, DPA/security acceptance, budget/PO, and go-live authorization are buyer inputs." - ), - "action": "Collect signatures, approvals, or waivers before representing launch readiness as closed-won.", - "exit_criteria": "Buyer accepts all signature, DPA/security, budget, and go-live inputs.", - }, - { - "item_name": "review_process_policy", - "label": "Review process policy", - "owner": "Deal owner", - "sources": ["docs/commercial_launch_readiness.md", "docs/commercial_go_to_market_readiness.md"], - "evidence_type": "repository_artifact", - "completion_state": "ready", - "evidence": "Review process delay is not a launch blocker unless a concrete failure is produced.", - "action": "Continue launch readiness work while queued review processes are pending.", - "exit_criteria": "Only concrete product, security, API contract, or document failures block launch readiness.", - }, - { - "item_name": "packaging_decision", - "label": "Packaging decision", - "owner": "Procurement and security reviewer", - "sources": ["docs/library_research.md", "docs/commercial_plugin_operating_model.md"], - "evidence_type": "repository_artifact", - "completion_state": "ready" - if gtm["library_split_decision"]["decision"] == "keep_single_product" - else "warning", - "evidence": gtm["library_split_decision"]["reason"], - "action": "Keep one deployable enterprise control-plane product until extraction triggers are real.", - "exit_criteria": "Do not create a separate library, Git submodule, or extracted package for this launch gate.", - }, - ] - state_counts = Counter(item["completion_state"] for item in launch_items) - blocked_count = state_counts.get("blocked", 0) + len(concrete_blockers) - warning_count = state_counts.get("warning", 0) - buyer_environment_gap_count = sum( - 1 for item in launch_items if item.get("source_gap_status") == "buyer_environment_required" - ) - production_telemetry_gap_count = sum( - 1 for item in launch_items if item.get("source_gap_status") == "production_input_required" - ) - commercial_signature_gap_count = sum( - 1 for item in launch_items if item.get("source_gap_status") == "buyer_signature_required" - ) - external_input_group_count = ( - buyer_environment_gap_count + production_telemetry_gap_count + commercial_signature_gap_count - ) - if blocked_count: - launch_status = "commercial_launch_blocked" - elif warning_count: - launch_status = "commercial_launch_ready_with_warnings" - else: # pragma: no cover - unreachable while this report carries literal buyer-specific warning sections - launch_status = "commercial_launch_ready" # pragma: no cover - - return { - "launch_status": launch_status, - "target_contract_value_krw": target_contract_value_krw, - "target_contract_value_display": f"KRW {target_contract_value_krw:,}", - "measurement_status": "local_commercial_launch_readiness", - "source_note": ( - "Commercial launch readiness packages repo-local GTM, runtime, acceptance, operator, admin, " - "analytics, Figma, review-process, and packaging evidence separately from buyer environment, " - "production telemetry, and commercial signature inputs; it is not a valuation guarantee, " - "purchase commitment, signed order, legal opinion, production compliance certificate, or revenue proof." - ), - "launch_summary": { - "item_count": len(launch_items), - "ready_count": state_counts.get("ready", 0), - "warning_count": warning_count, - "blocked_count": blocked_count, - "external_input_group_count": external_input_group_count, - "buyer_environment_gap_count": buyer_environment_gap_count, - "production_telemetry_gap_count": production_telemetry_gap_count, - "commercial_signature_gap_count": commercial_signature_gap_count, - "review_process_is_blocker": gtm["review_process_policy"]["is_blocker"], - }, - "launch_items": launch_items, - "concrete_blockers": concrete_blockers, - "launch_status_rules": [ - { - "launch_status": "commercial_launch_ready", - "rule": "GTM, runtime, acceptance, operator, admin, buyer environment, production telemetry, commercial signature, review policy, and packaging evidence are ready", - }, - { - "launch_status": "commercial_launch_ready_with_warnings", - "rule": "repo-local launch packet is ready while buyer environment, production telemetry, or commercial signature inputs remain explicit warnings", - }, - { - "launch_status": "commercial_launch_blocked", - "rule": "missing local launch packet evidence, concrete product defect, API contract failure, document mismatch, security failure, or Code Connect usage blocks launch readiness", - }, - ], - "review_process_policy": gtm["review_process_policy"], - "related_runtime_reports": { - "commercial_go_to_market_status": gtm["go_to_market_status"], - "commercial_operations_status": operations["operations_status"], - "commercial_onboarding_status": onboarding["onboarding_status"], - "commercial_acceptance_status": acceptance["acceptance_status"], - "analytics_measurement_status": analytics["measurement_status"], - **gtm["related_runtime_reports"], - }, - "library_split_decision": gtm["library_split_decision"], - "plugin_traceability": gtm["plugin_traceability"], - "launch_links": { - "figma_design_file": "https://www.figma.com/design/vsZMd8WAv42HDRgcZuNcWk", - "figjam_board": "https://www.figma.com/board/Wr8iMlB9SHkerHSjv0Pe0M", - "runtime_endpoint": "/api/v1/commercial_launch_readiness/latest", - "documentation": "docs/commercial_launch_readiness.md", - }, - } - - def commercial_completion_scorecard_report( - self, - target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, - locale_bundles: dict[str, dict[str, str]] | None = None, - security_profile: dict[str, Any] | None = None, - release_authority: Mapping[str, Any] | None = None, - ) -> dict[str, Any]: - """Return the final KRW 2B commercial completion scorecard.""" - commercial = self.commercial_readiness_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - gtm = self.commercial_go_to_market_readiness_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - release_authority=release_authority, - ) - launch = self.commercial_launch_readiness_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - release_authority=release_authority, - ) - analytics = self.analytics_snapshot(locale_bundles=locale_bundles) - admin_state = self.admin_state() - root = Path(__file__).resolve().parents[1] - - def has_file(path: str) -> bool: - return (root / path).is_file() - - concrete_blockers = list(launch["concrete_blockers"]) - if commercial["commercial_status"] == "not_commercial_ready": - concrete_blockers.append("commercial_readiness_failed") - if launch["launch_status"] == "commercial_launch_blocked": - concrete_blockers.append("commercial_launch_blocked") - concrete_blockers = list(dict.fromkeys(concrete_blockers)) - scorecard_items = [ - { - "item_name": "product_design_evidence", - "label": "Product Design evidence", - "owner": "Product design owner", - "sources": [ - "docs/plugin_driven_design_brief.md", - "docs/commercial_plugin_operating_model.md", - "docs/screen_design.md", - "/admin", - "/api/v1/commercial_readiness/latest", - ], - "evidence_type": "repository_and_runtime_artifact", - "completion_state": "ready" - if all( - has_file(path) - for path in ( - "docs/plugin_driven_design_brief.md", - "docs/commercial_plugin_operating_model.md", - "docs/screen_design.md", - ) - ) - and admin_state["agents"] - else "blocked", - "evidence": "Buyer, operator, security/compliance, and procurement workflows map to admin and readiness evidence.", - "action": "Keep buyer evidence paths visible in the existing admin control plane.", - "exit_criteria": "Every persona has a product/API/docs evidence path.", - }, - { - "item_name": "figma_artifacts", - "label": "Figma artifacts", - "owner": "Figma owner", - "sources": [ - "docs/figma_artifacts.md", - "https://www.figma.com/design/vsZMd8WAv42HDRgcZuNcWk", - "https://www.figma.com/board/Wr8iMlB9SHkerHSjv0Pe0M", - ], - "evidence_type": "figma_artifact", - "completion_state": "ready" if has_file("docs/figma_artifacts.md") else "blocked", - "evidence": "Editable design, FigJam diagrams, and stakeholder artifact records exist without Code Connect.", - "action": "Use Figma/FigJam artifacts for stakeholder review without generating Code Connect metadata.", - "exit_criteria": "Figma artifacts are recorded and Code Connect remains unused.", - }, - { - "item_name": "superpowers_plan_evidence", - "label": "Superpowers plan evidence", - "owner": "Implementation owner", - "sources": [ - "docs/superpowers/plans/2026-07-02-commercial-completion-scorecard-runtime.md", - "docs/superpowers/plans/2026-07-02-commercial-launch-readiness.md", - "tests/test_commercial_completion_scorecard.py", - ], - "evidence_type": "repository_artifact", - "completion_state": "ready" - if has_file("docs/superpowers/plans/2026-07-02-commercial-completion-scorecard-runtime.md") - and has_file("tests/test_commercial_completion_scorecard.py") - else "blocked", - "evidence": "Dated plans and focused tests define files, expected failures, implementation, and verification commands.", - "action": "Keep TDD plans and verification commands committed with the scorecard.", - "exit_criteria": "Plan and focused test exist for the runtime scorecard.", - }, - { - "item_name": "ponytail_packaging_decision", - "label": "Ponytail packaging decision", - "owner": "Procurement and security reviewer", - "sources": ["docs/library_research.md", "docs/commercial_plugin_operating_model.md"], - "evidence_type": "repository_artifact", - "completion_state": "ready" - if launch["library_split_decision"]["decision"] == "keep_single_product" - else "warning", - "evidence": launch["library_split_decision"]["reason"], - "action": "Keep one repository and one deployable product until extraction triggers are real.", - "exit_criteria": "No separate library, Git submodule, or extracted package is created for this increment.", - }, - { - "item_name": "data_analytics_truthfulness", - "label": "Data Analytics truthfulness", - "owner": "Analytics owner", - "sources": [ - "docs/analytics_spec.md", - "/api/v1/analytics_snapshots/latest", - "/api/v1/commercial_launch_readiness/latest", - ], - "evidence_type": "measured_local", - "completion_state": "ready" - if has_file("docs/analytics_spec.md") and analytics["measurement_status"] == "local_runtime_snapshot" - else "blocked", - "evidence": "Measured local evidence and proposed production or buyer-specific inputs are separated.", - "action": "Do not present proposed buyer or production inputs as measured product results.", - "exit_criteria": "Every commercial KPI has an evidence type and source expectation.", - }, - { - "item_name": "runtime_endpoint_chain", - "label": "Runtime endpoint chain", - "owner": "Platform operator", - "sources": [ - "/api/v1/commercial_readiness/latest", - "/api/v1/commercial_go_to_market_readiness/latest", - "/api/v1/commercial_launch_readiness/latest", - "/api/v1/commercial_completion_scorecards/latest", - ], - "evidence_type": "repository_and_runtime_artifact", - "completion_state": "ready" - if commercial["commercial_status"] != "not_commercial_ready" - and gtm["go_to_market_status"] != "commercial_go_to_market_blocked" - and launch["launch_status"] != "commercial_launch_blocked" - else "blocked", - "evidence": ( - f"commercial_status={commercial['commercial_status']}; " - f"go_to_market_status={gtm['go_to_market_status']}; " - f"launch_status={launch['launch_status']}" - ), - "action": "Expose completion status through the same admin-protected runtime API chain.", - "exit_criteria": "Runtime chain has no blocked local evidence gate.", - }, - { - "item_name": "verification_packet", - "label": "Verification packet", - "owner": "Technical reviewer", - "sources": [ - "tests/test_commercial_completion_scorecard.py", - "tests/test_commercial_launch_readiness.py", - "tests/test_plugin_driven_artifacts.py", - "tests/test_api_contract.py", - "pytest -q", - ], - "evidence_type": "measured_local", - "completion_state": "ready" - if all( - has_file(path) - for path in ( - "tests/test_commercial_completion_scorecard.py", - "tests/test_commercial_launch_readiness.py", - "tests/test_plugin_driven_artifacts.py", - "tests/test_api_contract.py", - ) - ) - else "blocked", - "evidence": "Focused completion, launch, artifact, and API contract tests are present.", - "action": "Run focused tests and full pytest before presenting completion status.", - "exit_criteria": "Focused tests, compileall, full pytest, and diff hygiene pass.", - }, - { - "item_name": "review_process_policy", - "label": "Review process policy", - "owner": "Deal owner", - "sources": ["docs/commercial_completion_scorecard.md", "docs/commercial_launch_readiness.md"], - "evidence_type": "repository_artifact", - "completion_state": "ready", - "evidence": "Review delay, model-review delay, and queued review automation are not product blockers.", - "action": "Block only on concrete security, API contract, document, or functional defects.", - "exit_criteria": "Review process delay remains non-blocking without concrete failure evidence.", - }, - { - "item_name": "production_buyer_followups", - "label": "Production and buyer follow-ups", - "owner": "Buyer sponsor, operations owner, and deal owner", - "sources": [ - "/api/v1/commercial_launch_readiness/latest", - "buyer environment", - "production telemetry", - "commercial signatures", - ], - "evidence_type": "external_input_required", - "completion_state": "warning", - "source_gap_status": "external_input_required", - "evidence": ( - f"external_input_group_count={launch['launch_summary']['external_input_group_count']}; " - f"buyer_signature_gap_count={gtm['go_to_market_summary']['buyer_signature_gap_count']}" - ), - "action": "Collect buyer environment, production telemetry, and signature inputs or explicit waivers.", - "exit_criteria": "Buyer supplies or waives remaining external inputs.", - }, - ] - state_counts = Counter(item["completion_state"] for item in scorecard_items) - blocked_count = state_counts.get("blocked", 0) + len(concrete_blockers) - warning_count = state_counts.get("warning", 0) - if blocked_count: - completion_status = "commercial_completion_blocked" - elif warning_count: - completion_status = "commercial_completion_ready_with_warnings" - else: # pragma: no cover - unreachable while this report carries literal buyer-specific warning sections - completion_status = "commercial_completion_ready" # pragma: no cover - - return { - "completion_status": completion_status, - "target_contract_value_krw": target_contract_value_krw, - "target_contract_value_display": f"KRW {target_contract_value_krw:,}", - "measurement_status": "local_commercial_completion_scorecard", - "source_note": ( - "Commercial completion scorecard aggregates repo-local product design, Figma, Superpowers, " - "Ponytail, Data Analytics, runtime, verification, review-process, and packaging evidence " - "separately from buyer and production follow-ups; it is not a valuation guarantee, purchase " - "commitment, signed order, legal opinion, production compliance certificate, or revenue proof." - ), - "completion_summary": { - "item_count": len(scorecard_items), - "ready_count": state_counts.get("ready", 0), - "warning_count": warning_count, - "blocked_count": blocked_count, - "external_input_group_count": launch["launch_summary"]["external_input_group_count"], - "review_process_is_blocker": launch["review_process_policy"]["is_blocker"], - "code_connect_used": False, - }, - "completion_items": scorecard_items, - "concrete_blockers": concrete_blockers, - "completion_status_rules": [ - { - "completion_status": "commercial_completion_ready", - "rule": "product design, Figma, Superpowers, Ponytail, Data Analytics, runtime, verification, review policy, packaging, and external inputs are ready", - }, - { - "completion_status": "commercial_completion_ready_with_warnings", - "rule": "repo-local program completion evidence is ready while buyer environment, production telemetry, commercial signatures, or other external inputs remain explicit warnings", - }, - { - "completion_status": "commercial_completion_blocked", - "rule": "security failure, API contract regression, document mismatch, reproducible product defect, missing local completion evidence, or Code Connect usage blocks completion", - }, - ], - "review_process_policy": launch["review_process_policy"], - "related_runtime_reports": { - "commercial_readiness_status": commercial["commercial_status"], - "commercial_go_to_market_status": gtm["go_to_market_status"], - "commercial_launch_status": launch["launch_status"], - "analytics_measurement_status": analytics["measurement_status"], - }, - "library_split_decision": launch["library_split_decision"], - "plugin_traceability": launch["plugin_traceability"], - "completion_links": { - "figma_design_file": "https://www.figma.com/design/vsZMd8WAv42HDRgcZuNcWk", - "figjam_board": "https://www.figma.com/board/Wr8iMlB9SHkerHSjv0Pe0M", - "runtime_endpoint": "/api/v1/commercial_completion_scorecards/latest", - "documentation": "docs/commercial_completion_scorecard.md", - }, - } - - def commercial_buyer_acceptance_workflow_report( - self, - target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, - locale_bundles: dict[str, dict[str, str]] | None = None, - security_profile: dict[str, Any] | None = None, - ) -> dict[str, Any]: - """Return owner-scoped buyer acceptance workflow evidence.""" - acceptance = self.commercial_acceptance_check_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - completion = self.commercial_completion_scorecard_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - handoff = self.commercial_handoff_bundle_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - analytics = self.analytics_snapshot(locale_bundles=locale_bundles) - root = Path(__file__).resolve().parents[1] - - def has_file(path: str) -> bool: - return (root / path).is_file() - - def all_files(*paths: str) -> bool: - return all(has_file(path) for path in paths) - - def step( - step_name: str, - label: str, - owner: str, - sources: list[str], - evidence_type: str, - completion_state: str, - evidence: str, - decision_rule: str, - next_action: str, - ) -> dict[str, Any]: - require_object_name(step_name, "buyer_acceptance_workflow.step_name") - if completion_state not in {"ready", "warning", "blocked"}: # pragma: no cover - raise ValueError("buyer acceptance workflow state must be ready, warning, or blocked") - return { - "step_name": step_name, - "label": label, - "owner": owner, - "sources": sources, - "evidence_type": evidence_type, - "completion_state": completion_state, - "evidence": evidence, - "decision_rule": decision_rule, - "next_action": next_action, - } - - concrete_blockers = list(dict.fromkeys(acceptance["concrete_blockers"] + completion["concrete_blockers"])) - acceptance_blocked = acceptance["acceptance_status"] == "commercial_acceptance_blocked" - completion_blocked = completion["completion_status"] == "commercial_completion_blocked" - local_runtime_state = "blocked" if acceptance_blocked or completion_blocked or concrete_blockers else "ready" - workflow_steps = [ - step( - "confirm_product_scope", - "Confirm product scope", - "Product owner", - ["README.md", "docs/product_planning.md", "docs/commercial_readiness.md"], - "repository_artifact", - "ready" if all_files("README.md", "docs/product_planning.md", "docs/commercial_readiness.md") else "blocked", - "Product remains one enterprise orchestration control plane.", - "Proceed when the buyer reviews one compatible API plus one admin evidence surface.", - "Restore product scope docs before buyer acceptance.", - ), - step( - "confirm_integration_surface", - "Confirm integration surface", - "Platform reviewer", - ["/v1/chat/completions", "docs/rest_api_design.md", "tests/test_api_contract.py"], - "repository_artifact", - "ready" if all_files("docs/rest_api_design.md", "tests/test_api_contract.py") else "blocked", - "OpenAI-compatible API and API contract tests are present.", - "Proceed when API compatibility evidence is present and tests pass.", - "Restore REST docs or API contract tests before buyer acceptance.", - ), - step( - "confirm_operator_evidence", - "Confirm operator evidence", - "Platform operator", - ["/admin", "/admin/state", "docs/screen_design.md", "contextual_orchestrator/admin.py"], - "repository_artifact", - "ready" if all_files("docs/screen_design.md", "contextual_orchestrator/admin.py") else "blocked", - "Admin console exposes operator evidence for pool, policy, trace, access, replay, analytics, and readiness.", - "Proceed when operator state and commercial readiness surfaces are visible.", - "Restore admin evidence docs or implementation before buyer acceptance.", - ), - step( - "confirm_readiness_endpoints", - "Confirm readiness endpoints", - "Product owner", - [ - "/api/v1/sales_readiness/latest", - "/api/v1/commercial_readiness/latest", - "/api/v1/commercial_acceptance_checks/latest", - "/api/v1/commercial_completion_scorecards/latest", - ], - "measured_local", - local_runtime_state, - ( - f"commercial_acceptance_status={acceptance['acceptance_status']}; " - f"commercial_completion_status={completion['completion_status']}" - ), - "Proceed when local runtime gates have no concrete blockers.", - "Resolve blocked readiness, acceptance, or completion gates before buyer acceptance.", - ), - step( - "confirm_security_posture", - "Confirm security posture", - "Security reviewer", - ["SECURITY.md", "tests/test_security_hardening.py", ".github/workflows/security.yml"], - "repository_artifact", - "ready" if all_files("SECURITY.md", "tests/test_security_hardening.py", ".github/workflows/security.yml") else "blocked", - "Security policy, hardening tests, and hosted security workflow metadata are present.", - "Proceed when concrete security failures are absent.", - "Fix concrete security failures; queued security checks alone are not blockers.", - ), - step( - "confirm_metric_honesty", - "Confirm metric honesty", - "Analytics reviewer", - ["/api/v1/analytics_snapshots/latest", "docs/analytics_spec.md"], - "measured_local", - "ready" if has_file("docs/analytics_spec.md") and analytics["measurement_status"] == "local_runtime_snapshot" else "blocked", - "Analytics spec and local snapshot separate measured local evidence from proposed production or buyer inputs.", - "Proceed when measured and proposed claims are not mixed.", - "Restore analytics source labels before buyer acceptance.", - ), - step( - "confirm_visual_review_path", - "Confirm visual review path", - "Stakeholder reviewer", - ["docs/figma_artifacts.md", "Figma design file", "FigJam board", "Figma Slides deck"], - "figma_artifact", - "ready" if has_file("docs/figma_artifacts.md") else "blocked", - "Editable design, FigJam, and stakeholder artifacts are recorded without Code Connect.", - "Proceed when visual artifacts are available for stakeholder review.", - "Record Figma artifacts before buyer acceptance.", - ), - step( - "confirm_packaging_decision", - "Confirm packaging decision", - "Procurement reviewer", - ["docs/library_research.md", "docs/commercial_plugin_operating_model.md"], - "repository_artifact", - "ready" if completion["library_split_decision"]["decision"] == "keep_single_product" else "warning", - completion["library_split_decision"]["reason"], - "Proceed with one repository and one deployable product.", - "Extract only after a second product, independent release cadence, or provenance trigger exists.", - ), - step( - "confirm_production_inputs", - "Confirm production inputs", - "Operations owner", - ["production telemetry", "support plan", "SLO evidence", "incident drill"], - "proposed_until_production", - "warning", - "Production telemetry, support, SLO, and incident evidence require a deployment or paid onboarding environment.", - "Proceed with warning when production inputs are explicitly caveated.", - "Collect production evidence during buyer onboarding or mark an explicit waiver.", - ), - step( - "confirm_buyer_specific_inputs", - "Confirm buyer-specific inputs", - "Buyer and account team", - ["ROI model", "security questionnaire", "legal review", "deployment target"], - "proposed_until_buyer_specific", - "warning", - "ROI, legal, procurement, and deployment inputs require a named buyer.", - "Proceed with warning when buyer-specific inputs are explicit follow-ups.", - "Collect buyer-specific inputs during account diligence.", - ), - ] - state_counts = Counter(item["completion_state"] for item in workflow_steps) - blocked_count = state_counts.get("blocked", 0) + len(concrete_blockers) - warning_count = state_counts.get("warning", 0) - if blocked_count: - workflow_status = "buyer_acceptance_workflow_blocked" - elif warning_count: - workflow_status = "buyer_acceptance_workflow_ready_with_warnings" - else: # pragma: no cover - unreachable while this report carries literal buyer-specific warning sections - workflow_status = "buyer_acceptance_workflow_ready" # pragma: no cover - - return { - "workflow_status": workflow_status, - "target_contract_value_krw": target_contract_value_krw, - "target_contract_value_display": f"KRW {target_contract_value_krw:,}", - "measurement_status": "local_buyer_acceptance_workflow", - "source_note": ( - "Commercial buyer acceptance workflow maps runbook owners, runtime evidence, " - "Figma artifacts, analytics truthfulness, review-process policy, and packaging " - "decision into Go, Warning, and No-Go steps; it is not a valuation guarantee, " - "purchase commitment, signed order, legal opinion, production compliance certificate, " - "or revenue proof." - ), - "workflow_summary": { - "step_count": len(workflow_steps), - "ready_count": state_counts.get("ready", 0), - "warning_count": warning_count, - "blocked_count": blocked_count, - "production_follow_up_count": sum( - 1 for item in workflow_steps if item["evidence_type"] == "proposed_until_production" - ), - "buyer_specific_follow_up_count": sum( - 1 for item in workflow_steps if item["evidence_type"] == "proposed_until_buyer_specific" - ), - "review_process_is_blocker": acceptance["review_process_policy"]["is_blocker"], - "code_connect_used": False, - }, - "acceptance_steps": workflow_steps, - "concrete_blockers": concrete_blockers, - "go_warning_no_go_rules": [ - { - "workflow_status": "buyer_acceptance_workflow_ready", - "rule": "all acceptance owners have ready evidence and no external production or buyer-specific inputs remain open", - }, - { - "workflow_status": "buyer_acceptance_workflow_ready_with_warnings", - "rule": "repo-local buyer acceptance evidence is ready while production or buyer-specific inputs remain explicit warnings", - }, - { - "workflow_status": "buyer_acceptance_workflow_blocked", - "rule": "security failure, API contract regression, document mismatch, reproducible product defect, missing acceptance path, or Code Connect usage blocks acceptance", - }, - ], - "review_process_policy": acceptance["review_process_policy"], - "related_runtime_reports": { - "commercial_acceptance_status": acceptance["acceptance_status"], - "commercial_completion_status": completion["completion_status"], - "buyer_handoff_status": handoff["bundle_status"], - "analytics_measurement_status": analytics["measurement_status"], - }, - "library_split_decision": completion["library_split_decision"], - "plugin_traceability": completion["plugin_traceability"], - "workflow_links": { - "figma_design_file": "https://www.figma.com/design/vsZMd8WAv42HDRgcZuNcWk", - "figjam_board": "https://www.figma.com/board/Wr8iMlB9SHkerHSjv0Pe0M", - "runtime_endpoint": "/api/v1/commercial_buyer_acceptance_workflows/latest", - "documentation": "docs/commercial_buyer_acceptance_runbook.md", - }, - } - - def commercial_demo_scenario_report( - self, - target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, - locale_bundles: dict[str, dict[str, str]] | None = None, - security_profile: dict[str, Any] | None = None, - ) -> dict[str, Any]: - """Return buyer-demo scenarios for the KRW 2B completion standard.""" - completion = self.commercial_completion_scorecard_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - buyer_workflow = self.commercial_buyer_acceptance_workflow_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - analytics = self.analytics_snapshot(locale_bundles=locale_bundles) - admin_state = self.admin_state() - root = Path(__file__).resolve().parents[1] - - def has_file(path: str) -> bool: - return (root / path).is_file() - - def all_files(*paths: str) -> bool: - return all(has_file(path) for path in paths) - - def step( - step_name: str, - label: str, - persona: str, - sources: list[str], - runtime_endpoints: list[str], - evidence_type: str, - completion_state: str, - evidence: str, - demo_action: str, - expected_evidence: str, - ) -> dict[str, Any]: - require_object_name(step_name, "commercial_demo.step_name") - if completion_state not in {"ready", "warning", "blocked"}: # pragma: no cover - raise ValueError("commercial demo step state must be ready, warning, or blocked") - return { - "step_name": step_name, - "label": label, - "persona": persona, - "sources": sources, - "runtime_endpoints": runtime_endpoints, - "evidence_type": evidence_type, - "completion_state": completion_state, - "evidence": evidence, - "demo_action": demo_action, - "expected_evidence": expected_evidence, - } - - concrete_blockers = list( - dict.fromkeys(completion["concrete_blockers"] + buyer_workflow["concrete_blockers"]) - ) - local_runtime_state = ( - "blocked" - if completion["completion_status"] == "commercial_completion_blocked" - or buyer_workflow["workflow_status"] == "buyer_acceptance_workflow_blocked" - or concrete_blockers - else "ready" - ) - event_counts = analytics.get("event_counts", {}) - recent_runs = admin_state.get("recent_workflow_runs", []) - demo_steps = [ - step( - "compatible_api_smoke", - "Compatible API smoke", - "Economic buyer", - ["README.md", "docs/rest_api_design.md", "/v1/chat/completions"], - ["/v1/chat/completions"], - "measured_local", - "ready" - if all_files("README.md", "docs/rest_api_design.md") - and event_counts.get("chat_completion_requested", 0) > 0 - else "blocked", - f"successful_chat_completion_events={event_counts.get('chat_completion_requested', 0)}", - "Run the OpenAI-compatible chat completion call used by the buyer application.", - "The buyer sees a compatible response and the runtime records a local analytics event.", - ), - step( - "conducted_workflow_trace", - "Conducted workflow trace", - "Platform operator", - ["/admin", "/api/v1/workflow_runs", "docs/screen_design.md"], - ["/admin", "/api/v1/workflow_runs"], - "measured_local", - "ready" if recent_runs and has_file("docs/screen_design.md") else "blocked", - f"recent_workflow_run_count={len(recent_runs)}", - "Open the admin trace view for a conducted workflow run.", - "The operator can inspect mode, policy mode, selected agents, and run trace evidence.", - ), - step( - "access_list_inspection", - "Access-list inspection", - "Compliance reviewer", - ["docs/product_planning.md", "/api/v1/access_reports/{workflow_run_id}", "/admin"], - ["/api/v1/access_reports/{workflow_run_id}", "/admin"], - "repository_and_runtime_artifact", - "ready" if has_file("docs/product_planning.md") else "blocked", - "access reports are scoped to workflow_run_id and exposed through the admin surface", - "Open the access report for the conducted workflow run.", - "The reviewer sees why each agent had access to context, tools, and trace evidence.", - ), - step( - "evaluation_replay", - "Evaluation replay", - "Quality reviewer", - ["docs/screen_design.md", "/api/v1/evaluation_runs", "/admin"], - ["/api/v1/evaluation_runs", "/admin"], - "measured_local", - "ready" if event_counts.get("evaluation_run_created", 0) > 0 else "blocked", - f"evaluation_run_created_events={event_counts.get('evaluation_run_created', 0)}", - "Replay the buyer prompt through the evaluation endpoint.", - "The reviewer sees replay status and trace-backed verification evidence.", - ), - step( - "admin_readiness_console", - "Admin readiness console", - "Economic buyer", - [ - "/admin", - "/api/v1/commercial_completion_scorecards/latest", - "/api/v1/commercial_buyer_acceptance_workflows/latest", - "/api/v1/commercial_demo_scenarios/latest", - ], - [ - "/admin", - "/api/v1/commercial_completion_scorecards/latest", - "/api/v1/commercial_buyer_acceptance_workflows/latest", - "/api/v1/commercial_demo_scenarios/latest", - ], - "repository_and_runtime_artifact", - local_runtime_state, - ( - f"commercial_completion_status={completion['completion_status']}; " - f"buyer_acceptance_workflow_status={buyer_workflow['workflow_status']}" - ), - "Show the readiness card chain in the admin console.", - "The buyer sees completion, buyer acceptance, and demo status without leaving one control plane.", - ), - step( - "metric_truthfulness", - "Metric truthfulness", - "Compliance reviewer", - ["docs/analytics_spec.md", "/api/v1/analytics_snapshots/latest"], - ["/api/v1/analytics_snapshots/latest"], - "measured_local", - "ready" - if has_file("docs/analytics_spec.md") and analytics["measurement_status"] == "local_runtime_snapshot" - else "blocked", - "measured local metrics remain separate from proposed production and buyer-specific metrics", - "Review the analytics spec and local analytics endpoint.", - "The reviewer can distinguish measured runtime data from proposed KPI definitions.", - ), - step( - "figma_stakeholder_review", - "Figma stakeholder review", - "Stakeholder reviewer", - [ - "docs/figma_artifacts.md", - "https://www.figma.com/design/vsZMd8WAv42HDRgcZuNcWk", - "https://www.figma.com/board/Wr8iMlB9SHkerHSjv0Pe0M", - ], - [], - "figma_artifact", - "ready" if has_file("docs/figma_artifacts.md") else "blocked", - "editable Figma and FigJam stakeholder artifacts are recorded without Code Connect", - "Walk through the design file and FigJam diagram packet.", - "Stakeholders review the product narrative, admin surface, and runtime flow as editable artifacts.", - ), - step( - "buyer_acceptance_decision", - "Buyer acceptance decision", - "Economic buyer", - [ - "docs/commercial_buyer_acceptance_runbook.md", - "/api/v1/commercial_buyer_acceptance_workflows/latest", - ], - ["/api/v1/commercial_buyer_acceptance_workflows/latest"], - "repository_and_runtime_artifact", - local_runtime_state, - f"buyer_acceptance_workflow_status={buyer_workflow['workflow_status']}", - "Use the buyer acceptance workflow as the Go/Warning/No-Go decision record.", - "The buyer can sign off on repo-local evidence while external follow-ups stay explicit.", - ), - step( - "production_buyer_followups", - "Production and buyer follow-ups", - "Economic buyer", - ["production telemetry", "ROI model", "security questionnaire", "support plan"], - [], - "proposed_until_buyer_specific", - "warning", - "Production telemetry, named-buyer ROI, security questionnaire, and support plan require buyer input.", - "Capture buyer-specific production, ROI, legal, and support inputs after the local demo.", - "External inputs are tracked as warnings, not hidden as measured product evidence.", - ), - ] - state_counts = Counter(item["completion_state"] for item in demo_steps) - blocked_count = state_counts.get("blocked", 0) + len(concrete_blockers) - warning_count = state_counts.get("warning", 0) - if blocked_count: - demo_status = "commercial_demo_blocked" - elif warning_count: - demo_status = "commercial_demo_ready_with_warnings" - else: # pragma: no cover - unreachable while this report carries literal buyer-specific warning sections - demo_status = "commercial_demo_ready" # pragma: no cover - required_runtime_endpoints = list( - dict.fromkeys( - endpoint - for item in demo_steps - for endpoint in item["runtime_endpoints"] - if endpoint.startswith("/") - ) - ) - - return { - "demo_status": demo_status, - "target_contract_value_krw": target_contract_value_krw, - "target_contract_value_display": f"KRW {target_contract_value_krw:,}", - "measurement_status": "local_commercial_demo_scenarios", - "source_note": ( - "Commercial demo scenarios package repo-local runtime, admin, analytics, Figma, " - "buyer acceptance, review-policy, and packaging evidence for KRW 2,000,000,000 " - "saleability review; it is not a valuation guarantee, purchase commitment, " - "signed order, legal opinion, production compliance certificate, or revenue proof." - ), - "demo_narrative": { - "title": "KRW 2B commercial control-plane buyer demo", - "promise": ( - "Show one enterprise orchestration control plane with a compatible inference API, " - "operator/admin evidence, trace and access visibility, evaluation replay, and truthful metrics." - ), - "audience": [ - "Economic buyer", - "Platform operator", - "Compliance reviewer", - "Quality reviewer", - "Stakeholder reviewer", - ], - }, - "demo_summary": { - "step_count": len(demo_steps), - "ready_count": state_counts.get("ready", 0), - "warning_count": warning_count, - "blocked_count": blocked_count, - "persona_count": len({item["persona"] for item in demo_steps}), - "endpoint_count": len(required_runtime_endpoints), - "review_process_is_blocker": completion["review_process_policy"]["is_blocker"], - "code_connect_used": False, - }, - "demo_steps": demo_steps, - "required_runtime_endpoints": required_runtime_endpoints, - "concrete_blockers": concrete_blockers, - "demo_status_rules": [ - { - "demo_status": "commercial_demo_ready", - "rule": "all demo steps are ready and no production or buyer-specific follow-ups remain open", - }, - { - "demo_status": "commercial_demo_ready_with_warnings", - "rule": "repo-local demo evidence is ready while production, ROI, legal, support, or buyer-specific inputs remain explicit warnings", - }, - { - "demo_status": "commercial_demo_blocked", - "rule": "security failure, API contract regression, document mismatch, runtime defect, missing local demo evidence, or Code Connect usage blocks the demo", - }, - ], - "review_process_policy": completion["review_process_policy"], - "related_runtime_reports": { - "commercial_completion_status": completion["completion_status"], - "buyer_acceptance_workflow_status": buyer_workflow["workflow_status"], - "analytics_measurement_status": analytics["measurement_status"], - }, - "library_split_decision": completion["library_split_decision"], - "plugin_traceability": completion["plugin_traceability"], - "demo_links": { - "figma_design_file": "https://www.figma.com/design/vsZMd8WAv42HDRgcZuNcWk", - "figjam_board": "https://www.figma.com/board/Wr8iMlB9SHkerHSjv0Pe0M", - "runtime_endpoint": "/api/v1/commercial_demo_scenarios/latest", - "documentation": "docs/commercial_demo_scenarios.md", - }, - } - - def commercial_proposal_packet_report( - self, - target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, - locale_bundles: dict[str, dict[str, str]] | None = None, - security_profile: dict[str, Any] | None = None, - ) -> dict[str, Any]: - """Return buyer proposal sections for the KRW 2B saleability standard.""" - completion = self.commercial_completion_scorecard_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - demo = self.commercial_demo_scenario_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - buyer_workflow = self.commercial_buyer_acceptance_workflow_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - value = self.commercial_value_readiness_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - security = self.commercial_security_attestation_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - contract = self.commercial_contract_readiness_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - onboarding = self.commercial_onboarding_readiness_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - operations = self.commercial_operations_readiness_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - analytics = self.analytics_snapshot(locale_bundles=locale_bundles) - admin_state = self.admin_state() - root = Path(__file__).resolve().parents[1] - - def has_file(path: str) -> bool: - return (root / path).is_file() - - def all_files(*paths: str) -> bool: - return all(has_file(path) for path in paths) - - def section( - section_name: str, - label: str, - owner: str, - sources: list[str], - runtime_endpoints: list[str], - evidence_type: str, - completion_state: str, - evidence: str, - buyer_message: str, - next_action: str, - ) -> dict[str, Any]: - require_object_name(section_name, "commercial_proposal.section_name") - if completion_state not in {"ready", "warning", "blocked"}: # pragma: no cover - raise ValueError("commercial proposal section state must be ready, warning, or blocked") - return { - "section_name": section_name, - "label": label, - "owner": owner, - "sources": sources, - "runtime_endpoints": runtime_endpoints, - "evidence_type": evidence_type, - "completion_state": completion_state, - "evidence": evidence, - "buyer_message": buyer_message, - "next_action": next_action, - } - - concrete_blockers = list( - dict.fromkeys( - completion["concrete_blockers"] - + demo["concrete_blockers"] - + buyer_workflow["concrete_blockers"] - ) - ) - local_runtime_state = ( - "blocked" - if completion["completion_status"] == "commercial_completion_blocked" - or demo["demo_status"] == "commercial_demo_blocked" - or buyer_workflow["workflow_status"] == "buyer_acceptance_workflow_blocked" - or concrete_blockers - else "ready" - ) - proposal_sections = [ - section( - "executive_summary", - "Executive summary", - "Deal owner", - ["README.md", "docs/commercial_completion_scorecard.md", "/api/v1/commercial_completion_scorecards/latest"], - ["/api/v1/commercial_completion_scorecards/latest"], - "repository_and_runtime_artifact", - local_runtime_state if all_files("README.md", "docs/commercial_completion_scorecard.md") else "blocked", - f"commercial_completion_status={completion['completion_status']}", - "One enterprise orchestration control plane is ready for a KRW 2B buyer review with explicit caveats.", - "Use the completion scorecard as the proposal cover evidence.", - ), - section( - "product_scope", - "Product scope", - "Product owner", - ["docs/product_planning.md", "docs/commercial_plugin_operating_model.md", "docs/library_research.md"], - [], - "repository_artifact", - "ready" - if all_files("docs/product_planning.md", "docs/commercial_plugin_operating_model.md", "docs/library_research.md") - and completion["library_split_decision"]["decision"] == "keep_single_product" - else "blocked", - completion["library_split_decision"]["reason"], - "The offer is one compatible API plus one admin evidence surface, not a split product suite.", - "Keep proposal language centered on a single deployable control plane.", - ), - section( - "buyer_value_case", - "Buyer value case", - "Economic buyer", - ["docs/commercial_value_readiness.md", "docs/analytics_spec.md", "/api/v1/commercial_value_readiness/latest"], - ["/api/v1/commercial_value_readiness/latest", "/api/v1/analytics_snapshots/latest"], - "repository_and_runtime_artifact", - "ready" - if value["value_status"] != "commercial_value_blocked" - and has_file("docs/commercial_value_readiness.md") - and analytics["measurement_status"] == "local_runtime_snapshot" - else "blocked", - f"value_status={value['value_status']}; analytics_measurement_status={analytics['measurement_status']}", - "Measured local value evidence is separated from buyer-specific ROI inputs.", - "Attach buyer ROI assumptions only after buyer discovery validates them.", - ), - section( - "demo_and_acceptance_path", - "Demo and acceptance path", - "Product design owner", - [ - "docs/commercial_demo_scenarios.md", - "docs/commercial_buyer_acceptance_runbook.md", - "/api/v1/commercial_demo_scenarios/latest", - "/api/v1/commercial_buyer_acceptance_workflows/latest", - ], - ["/api/v1/commercial_demo_scenarios/latest", "/api/v1/commercial_buyer_acceptance_workflows/latest"], - "repository_and_runtime_artifact", - local_runtime_state - if all_files("docs/commercial_demo_scenarios.md", "docs/commercial_buyer_acceptance_runbook.md") - else "blocked", - f"commercial_demo_status={demo['demo_status']}; buyer_acceptance_workflow_status={buyer_workflow['workflow_status']}", - "Buyer review can move from demo script to Go/Warning/No-Go acceptance without leaving the control plane.", - "Run the demo packet and record the acceptance decision.", - ), - section( - "technical_evidence", - "Technical evidence", - "Platform reviewer", - ["docs/rest_api_design.md", "docs/screen_design.md", "contextual_orchestrator/api_contract.py", "/admin"], - ["/v1/chat/completions", "/admin", "/api/v1/workflow_runs", "/api/v1/access_reports/{workflow_run_id}"], - "repository_and_runtime_artifact", - "ready" - if all_files("docs/rest_api_design.md", "docs/screen_design.md", "contextual_orchestrator/api_contract.py") - and admin_state["agents"] - else "blocked", - f"agent_count={len(admin_state['agents'])}; recent_workflow_run_count={len(admin_state['recent_workflow_runs'])}", - "The buyer can verify API compatibility, trace evidence, and access-list evidence.", - "Include endpoint list and admin review screenshots or live walkthrough in the proposal.", - ), - section( - "security_and_compliance", - "Security and compliance", - "Security reviewer", - ["SECURITY.md", "docs/commercial_security_attestation.md", "/api/v1/commercial_security_attestations/latest"], - ["/api/v1/commercial_security_attestations/latest"], - "repository_and_runtime_artifact", - "ready" - if security["security_attestation_status"] != "commercial_security_attestation_blocked" - and all_files("SECURITY.md", "docs/commercial_security_attestation.md") - else "blocked", - f"security_attestation_status={security['security_attestation_status']}", - "Repo-local security evidence is present while external attestation and buyer DPA inputs stay explicit.", - "Do not claim third-party attestation until supplied.", - ), - section( - "implementation_and_operations", - "Implementation and operations", - "Operations owner", - [ - "docs/commercial_onboarding_readiness.md", - "docs/commercial_operations_readiness.md", - "/api/v1/commercial_onboarding_readiness/latest", - "/api/v1/commercial_operations_readiness/latest", - ], - ["/api/v1/commercial_onboarding_readiness/latest", "/api/v1/commercial_operations_readiness/latest"], - "repository_and_runtime_artifact", - "ready" - if onboarding["onboarding_status"] != "commercial_onboarding_blocked" - and operations["operations_status"] != "commercial_operations_blocked" - and all_files("docs/commercial_onboarding_readiness.md", "docs/commercial_operations_readiness.md") - else "blocked", - f"onboarding_status={onboarding['onboarding_status']}; operations_status={operations['operations_status']}", - "Implementation and operations evidence is proposal-ready with production environment follow-ups separated.", - "Convert buyer environment details into an onboarding checklist after selection.", - ), - section( - "proposal_review_packet", - "Proposal review packet", - "Stakeholder reviewer", - [ - "docs/commercial_proposal_packet.md", - "docs/figma_artifacts.md", - "docs/superpowers/plans/2026-07-02-commercial-proposal-packet-runtime.md", - ], - ["/api/v1/commercial_proposal_packets/latest"], - "repository_and_runtime_artifact", - "ready" - if all_files( - "docs/commercial_proposal_packet.md", - "docs/figma_artifacts.md", - "docs/superpowers/plans/2026-07-02-commercial-proposal-packet-runtime.md", - ) - else "blocked", - "Proposal docs, FigJam artifact record, and implementation plan are committed as repo artifacts.", - "Stakeholders can review the proposal packet as docs, runtime JSON, and FigJam flow.", - "Keep Figma Code Connect out of the proposal workflow.", - ), - section( - "commercial_terms_followups", - "Commercial terms follow-ups", - "Deal owner", - ["docs/commercial_contract_readiness.md", "buyer order form", "legal review", "pricing approval"], - ["/api/v1/commercial_contract_readiness/latest"], - "proposed_until_buyer_specific", - "warning", - f"contract_status={contract['contract_status']}", - "Order-form, legal, pricing approval, and signature inputs need named-buyer review.", - "Collect buyer-specific legal and commercial terms or record explicit waiver.", - ), - section( - "production_buyer_inputs", - "Production and buyer inputs", - "Buyer sponsor", - ["production telemetry", "buyer ROI model", "support plan", "security questionnaire"], - [], - "proposed_until_buyer_specific", - "warning", - "Production telemetry, buyer ROI model, support plan, and security questionnaire are external inputs.", - "The proposal is locally ready while buyer-specific inputs remain caveated.", - "Collect external evidence during proposal negotiation or paid onboarding.", - ), - ] - state_counts = Counter(item["completion_state"] for item in proposal_sections) - blocked_count = state_counts.get("blocked", 0) + len(concrete_blockers) - warning_count = state_counts.get("warning", 0) - if blocked_count: - proposal_status = "commercial_proposal_blocked" - elif warning_count: - proposal_status = "commercial_proposal_ready_with_warnings" - else: # pragma: no cover - unreachable while this report carries literal buyer-specific warning sections - proposal_status = "commercial_proposal_ready" # pragma: no cover - required_runtime_endpoints = list( - dict.fromkeys( - endpoint - for item in proposal_sections - for endpoint in item["runtime_endpoints"] - if endpoint.startswith("/") - ) - ) - - return { - "proposal_status": proposal_status, - "target_contract_value_krw": target_contract_value_krw, - "target_contract_value_display": f"KRW {target_contract_value_krw:,}", - "measurement_status": "local_commercial_proposal_packet", - "source_note": ( - "Commercial proposal packet packages repo-local completion, demo, acceptance, value, " - "security, contract, onboarding, operations, analytics, Figma, review-policy, and packaging " - "evidence for KRW 2,000,000,000 buyer proposal review; it is not a valuation guarantee, " - "purchase commitment, signed order, legal opinion, production compliance certificate, or revenue proof." - ), - "proposal_narrative": { - "title": "KRW 2B commercial buyer proposal packet", - "promise": ( - "Present one enterprise orchestration control plane with compatible API integration, " - "operator evidence, buyer demo path, acceptance workflow, and truthful commercial caveats." - ), - "audience": [ - "Economic buyer", - "Platform reviewer", - "Security reviewer", - "Operations owner", - "Stakeholder reviewer", - "Deal owner", - ], - }, - "proposal_summary": { - "section_count": len(proposal_sections), - "ready_count": state_counts.get("ready", 0), - "warning_count": warning_count, - "blocked_count": blocked_count, - "endpoint_count": len(required_runtime_endpoints), - "review_process_is_blocker": completion["review_process_policy"]["is_blocker"], - "code_connect_used": False, - }, - "proposal_sections": proposal_sections, - "required_runtime_endpoints": required_runtime_endpoints, - "concrete_blockers": concrete_blockers, - "proposal_status_rules": [ - { - "proposal_status": "commercial_proposal_ready", - "rule": "all proposal sections are ready and no buyer-specific commercial or production inputs remain open", - }, - { - "proposal_status": "commercial_proposal_ready_with_warnings", - "rule": "repo-local proposal evidence is ready while pricing, legal, ROI, production, support, or signature inputs remain explicit warnings", - }, - { - "proposal_status": "commercial_proposal_blocked", - "rule": "security failure, API contract regression, document mismatch, runtime defect, missing local proposal evidence, or Code Connect usage blocks the proposal", - }, - ], - "review_process_policy": completion["review_process_policy"], - "related_runtime_reports": { - "commercial_completion_status": completion["completion_status"], - "commercial_demo_status": demo["demo_status"], - "buyer_acceptance_workflow_status": buyer_workflow["workflow_status"], - "commercial_value_status": value["value_status"], - "commercial_security_attestation_status": security["security_attestation_status"], - "commercial_contract_status": contract["contract_status"], - "commercial_onboarding_status": onboarding["onboarding_status"], - "commercial_operations_status": operations["operations_status"], - "analytics_measurement_status": analytics["measurement_status"], - }, - "library_split_decision": completion["library_split_decision"], - "plugin_traceability": completion["plugin_traceability"], - "proposal_links": { - "figma_design_file": "https://www.figma.com/design/vsZMd8WAv42HDRgcZuNcWk", - "figjam_board": "https://www.figma.com/board/Wr8iMlB9SHkerHSjv0Pe0M", - "runtime_endpoint": "/api/v1/commercial_proposal_packets/latest", - "documentation": "docs/commercial_proposal_packet.md", - }, - } - - def commercial_purchase_approval_packet_report( - self, - target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, - locale_bundles: dict[str, dict[str, str]] | None = None, - security_profile: dict[str, Any] | None = None, - ) -> dict[str, Any]: - """Return buyer-side purchase approval gates for the KRW 2B standard.""" - proposal = self.commercial_proposal_packet_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - close = self.commercial_close_readiness_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - procurement = self.commercial_procurement_readiness_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - contract = self.commercial_contract_readiness_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - value = self.commercial_value_readiness_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - security = self.commercial_security_attestation_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - onboarding = self.commercial_onboarding_readiness_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - operations = self.commercial_operations_readiness_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - analytics = self.analytics_snapshot(locale_bundles=locale_bundles) - admin_state = self.admin_state() - root = Path(__file__).resolve().parents[1] - - def has_file(path: str) -> bool: - return (root / path).is_file() - - def all_files(*paths: str) -> bool: - return all(has_file(path) for path in paths) - - def gate( - gate_name: str, - label: str, - owner: str, - sources: list[str], - runtime_endpoints: list[str], - evidence_type: str, - completion_state: str, - evidence: str, - approval_question: str, - next_action: str, - ) -> dict[str, Any]: - require_object_name(gate_name, "commercial_purchase_approval.gate_name") - if completion_state not in {"ready", "warning", "blocked"}: # pragma: no cover - raise ValueError("commercial purchase approval gate state must be ready, warning, or blocked") - return { - "gate_name": gate_name, - "label": label, - "owner": owner, - "sources": sources, - "runtime_endpoints": runtime_endpoints, - "evidence_type": evidence_type, - "completion_state": completion_state, - "evidence": evidence, - "approval_question": approval_question, - "next_action": next_action, - } - - concrete_blockers = list(dict.fromkeys(proposal["concrete_blockers"] + close["concrete_blockers"])) - local_runtime_state = ( - "blocked" - if proposal["proposal_status"] == "commercial_proposal_blocked" - or close["close_status"] == "commercial_close_blocked" - or concrete_blockers - else "ready" - ) - approval_gates = [ - gate( - "proposal_packet_ready", - "Proposal packet ready", - "Deal owner", - ["docs/commercial_proposal_packet.md", "/api/v1/commercial_proposal_packets/latest"], - ["/api/v1/commercial_proposal_packets/latest"], - "repository_and_runtime_artifact", - local_runtime_state if has_file("docs/commercial_proposal_packet.md") else "blocked", - f"commercial_proposal_status={proposal['proposal_status']}", - "Can the buyer review one coherent proposal packet?", - "Use the proposal packet as the approval cover artifact.", - ), - gate( - "procurement_path_ready", - "Procurement path ready", - "Procurement owner", - ["docs/commercial_procurement_readiness.md", "/api/v1/commercial_procurement_readiness/latest"], - ["/api/v1/commercial_procurement_readiness/latest"], - "repository_and_runtime_artifact", - "ready" - if procurement["procurement_status"] != "commercial_procurement_blocked" - and has_file("docs/commercial_procurement_readiness.md") - else "blocked", - f"commercial_procurement_status={procurement['procurement_status']}", - "Can procurement validate license, rights, distribution, admin, and caveat evidence?", - "Route the packet to procurement with buyer-specific inputs still marked as warnings.", - ), - gate( - "contract_legal_packet_ready", - "Contract and legal packet ready", - "Legal owner", - ["docs/commercial_contract_readiness.md", "/api/v1/commercial_contract_readiness/latest"], - ["/api/v1/commercial_contract_readiness/latest"], - "repository_and_runtime_artifact", - "ready" - if contract["contract_status"] != "commercial_contract_blocked" - and has_file("docs/commercial_contract_readiness.md") - else "blocked", - f"commercial_contract_status={contract['contract_status']}", - "Can legal review support, privacy, audit, license, and order-form obligations?", - "Collect final legal edits and buyer order-form fields outside the local runtime claim.", - ), - gate( - "financial_value_case_ready", - "Financial value case ready", - "Economic buyer", - ["docs/commercial_value_readiness.md", "docs/analytics_spec.md", "/api/v1/commercial_value_readiness/latest"], - ["/api/v1/commercial_value_readiness/latest", "/api/v1/analytics_snapshots/latest"], - "repository_and_runtime_artifact", - "ready" - if value["value_status"] != "commercial_value_blocked" - and all_files("docs/commercial_value_readiness.md", "docs/analytics_spec.md") - and analytics["measurement_status"] == "local_runtime_snapshot" - else "blocked", - f"commercial_value_status={value['value_status']}; analytics_measurement_status={analytics['measurement_status']}", - "Can finance separate measured local evidence from buyer ROI assumptions?", - "Attach buyer ROI and payback assumptions only after buyer discovery.", - ), - gate( - "security_acceptance_ready", - "Security acceptance ready", - "Security owner", - ["SECURITY.md", "docs/commercial_security_attestation.md", "/api/v1/commercial_security_attestations/latest"], - ["/api/v1/commercial_security_attestations/latest"], - "repository_and_runtime_artifact", - "ready" - if security["security_attestation_status"] != "commercial_security_attestation_blocked" - and all_files("SECURITY.md", "docs/commercial_security_attestation.md") - else "blocked", - f"commercial_security_attestation_status={security['security_attestation_status']}", - "Can security approve repo-local controls while external attestations remain caveated?", - "Collect buyer DPA, privacy, and third-party attestation evidence separately.", - ), - gate( - "implementation_readiness_ready", - "Implementation readiness ready", - "Implementation owner", - [ - "docs/commercial_onboarding_readiness.md", - "docs/commercial_operations_readiness.md", - "/api/v1/commercial_onboarding_readiness/latest", - "/api/v1/commercial_operations_readiness/latest", - ], - ["/api/v1/commercial_onboarding_readiness/latest", "/api/v1/commercial_operations_readiness/latest"], - "repository_and_runtime_artifact", - "ready" - if onboarding["onboarding_status"] != "commercial_onboarding_blocked" - and operations["operations_status"] != "commercial_operations_blocked" - and all_files("docs/commercial_onboarding_readiness.md", "docs/commercial_operations_readiness.md") - else "blocked", - f"commercial_onboarding_status={onboarding['onboarding_status']}; commercial_operations_status={operations['operations_status']}", - "Can implementation owners see onboarding and operations evidence before purchase approval?", - "Turn buyer environment details into the paid onboarding plan.", - ), - gate( - "close_readiness_ready", - "Close readiness ready", - "Deal owner", - ["docs/commercial_close_readiness.md", "/api/v1/commercial_close_readiness/latest"], - ["/api/v1/commercial_close_readiness/latest"], - "repository_and_runtime_artifact", - "ready" - if close["close_status"] != "commercial_close_blocked" - and has_file("docs/commercial_close_readiness.md") - else "blocked", - f"commercial_close_status={close['close_status']}", - "Can the buyer see final signature, budget, security, and go-live caveats before approval?", - "Use close readiness as the bridge between local product evidence and buyer approvals.", - ), - gate( - "approval_runtime_packet_ready", - "Approval runtime packet ready", - "Stakeholder reviewer", - [ - "docs/commercial_purchase_approval_packet.md", - "docs/figma_artifacts.md", - "docs/superpowers/plans/2026-07-02-commercial-purchase-approval-packet-runtime.md", - ], - ["/api/v1/commercial_purchase_approval_packets/latest"], - "repository_and_runtime_artifact", - "ready" - if all_files( - "docs/commercial_purchase_approval_packet.md", - "docs/figma_artifacts.md", - "docs/superpowers/plans/2026-07-02-commercial-purchase-approval-packet-runtime.md", - ) - and admin_state["agents"] - else "blocked", - "Purchase approval docs, FigJam artifact record, plan, and admin runtime are present.", - "Can stakeholders review the approval packet as docs, runtime JSON, and FigJam flow?", - "Keep Figma Code Connect out of the approval workflow.", - ), - gate( - "buyer_signature_authority", - "Buyer signature authority", - "Buyer sponsor and legal owner", - ["signed order form", "MSA", "DPA", "security acceptance"], - [], - "proposed_until_buyer_specific", - "warning", - "Signed order form, MSA, DPA, and final security acceptance require buyer authority.", - "Does the buyer have an identified signer and legal approval path?", - "Collect named signer and final legal/security approvals.", - ), - gate( - "buyer_budget_po_authority", - "Buyer budget and PO authority", - "Finance and procurement owner", - ["budget approval", "purchase order", "finance authority", "go-live authorization"], - [], - "proposed_until_buyer_specific", - "warning", - "Budget approval, purchase order, finance authority, and go-live authorization require buyer input.", - "Can finance issue the KRW 2B purchase order and approve go-live?", - "Collect budget owner, PO path, and go-live authorization or explicit waiver.", - ), - ] - state_counts = Counter(item["completion_state"] for item in approval_gates) - blocked_count = state_counts.get("blocked", 0) + len(concrete_blockers) - warning_count = state_counts.get("warning", 0) - if blocked_count: - purchase_approval_status = "commercial_purchase_approval_blocked" - elif warning_count: - purchase_approval_status = "commercial_purchase_approval_ready_with_warnings" - else: # pragma: no cover - unreachable while this report carries literal buyer-specific warning sections - purchase_approval_status = "commercial_purchase_approval_ready" # pragma: no cover - required_runtime_endpoints = list( - dict.fromkeys( - endpoint - for item in approval_gates - for endpoint in item["runtime_endpoints"] - if endpoint.startswith("/") - ) - ) - - return { - "purchase_approval_status": purchase_approval_status, - "target_contract_value_krw": target_contract_value_krw, - "target_contract_value_display": f"KRW {target_contract_value_krw:,}", - "measurement_status": "local_commercial_purchase_approval_packet", - "source_note": ( - "Commercial purchase approval packet packages repo-local proposal, close, procurement, " - "contract, value, security, onboarding, operations, analytics, Figma, review-policy, and " - "packaging evidence for KRW 2,000,000,000 buyer purchase approval; it is not a valuation " - "guarantee, purchase commitment, signed order, legal opinion, production compliance " - "certificate, or revenue proof." - ), - "approval_narrative": { - "title": "KRW 2B buyer purchase approval packet", - "promise": ( - "Give finance, procurement, legal, security, and implementation owners one runtime " - "approval packet that separates local product evidence from buyer-specific authority inputs." - ), - "audience": [ - "Economic buyer", - "Finance owner", - "Procurement owner", - "Legal owner", - "Security owner", - "Implementation owner", - ], - }, - "approval_summary": { - "gate_count": len(approval_gates), - "ready_count": state_counts.get("ready", 0), - "warning_count": warning_count, - "blocked_count": blocked_count, - "endpoint_count": len(required_runtime_endpoints), - "review_process_is_blocker": proposal["review_process_policy"]["is_blocker"], - "code_connect_used": False, - }, - "approval_gates": approval_gates, - "required_runtime_endpoints": required_runtime_endpoints, - "concrete_blockers": concrete_blockers, - "purchase_approval_status_rules": [ - { - "purchase_approval_status": "commercial_purchase_approval_ready", - "rule": "all approval gates are ready and no buyer signature, budget, PO, or go-live inputs remain open", - }, - { - "purchase_approval_status": "commercial_purchase_approval_ready_with_warnings", - "rule": "repo-local purchase approval evidence is ready while buyer signature authority, budget, PO, or go-live authorization remain explicit warnings", - }, - { - "purchase_approval_status": "commercial_purchase_approval_blocked", - "rule": "security failure, API contract regression, document mismatch, runtime defect, missing local approval evidence, or Code Connect usage blocks purchase approval", - }, - ], - "review_process_policy": proposal["review_process_policy"], - "related_runtime_reports": { - "commercial_proposal_status": proposal["proposal_status"], - "commercial_close_status": close["close_status"], - "commercial_procurement_status": procurement["procurement_status"], - "commercial_contract_status": contract["contract_status"], - "commercial_value_status": value["value_status"], - "commercial_security_attestation_status": security["security_attestation_status"], - "commercial_onboarding_status": onboarding["onboarding_status"], - "commercial_operations_status": operations["operations_status"], - "analytics_measurement_status": analytics["measurement_status"], - }, - "library_split_decision": proposal["library_split_decision"], - "plugin_traceability": proposal["plugin_traceability"], - "approval_links": { - "figma_design_file": "https://www.figma.com/design/vsZMd8WAv42HDRgcZuNcWk", - "figjam_board": "https://www.figma.com/board/Wr8iMlB9SHkerHSjv0Pe0M", - "runtime_endpoint": "/api/v1/commercial_purchase_approval_packets/latest", - "documentation": "docs/commercial_purchase_approval_packet.md", - }, - } - - def commercial_due_diligence_room_report( - self, - target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, - locale_bundles: dict[str, dict[str, str]] | None = None, - security_profile: dict[str, Any] | None = None, - ) -> dict[str, Any]: - """Return buyer due diligence room sections for the KRW 2B standard.""" - purchase = self.commercial_purchase_approval_packet_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - proposal = self.commercial_proposal_packet_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - completion = self.commercial_completion_scorecard_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - demo = self.commercial_demo_scenario_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - buyer_workflow = self.commercial_buyer_acceptance_workflow_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - close = self.commercial_close_readiness_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - procurement = self.commercial_procurement_readiness_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - contract = self.commercial_contract_readiness_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - value = self.commercial_value_readiness_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - security = self.commercial_security_attestation_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - onboarding = self.commercial_onboarding_readiness_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - operations = self.commercial_operations_readiness_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - analytics = self.analytics_snapshot(locale_bundles=locale_bundles) - admin_state = self.admin_state() - root = Path(__file__).resolve().parents[1] - - def has_file(path: str) -> bool: - return (root / path).is_file() - - def all_files(*paths: str) -> bool: - return all(has_file(path) for path in paths) - - def section( - section_name: str, - label: str, - reviewer: str, - sources: list[str], - runtime_endpoints: list[str], - evidence_type: str, - completion_state: str, - evidence: str, - diligence_question: str, - next_action: str, - ) -> dict[str, Any]: - require_object_name(section_name, "commercial_due_diligence.section_name") - if completion_state not in {"ready", "warning", "blocked"}: # pragma: no cover - raise ValueError("commercial due diligence section state must be ready, warning, or blocked") - return { - "section_name": section_name, - "label": label, - "reviewer": reviewer, - "sources": sources, - "runtime_endpoints": runtime_endpoints, - "evidence_type": evidence_type, - "completion_state": completion_state, - "evidence": evidence, - "diligence_question": diligence_question, - "next_action": next_action, - } - - concrete_blockers = list( - dict.fromkeys( - purchase["concrete_blockers"] - + proposal["concrete_blockers"] - + completion["concrete_blockers"] - + demo["concrete_blockers"] - + buyer_workflow["concrete_blockers"] - ) - ) - local_runtime_state = ( - "blocked" - if purchase["purchase_approval_status"] == "commercial_purchase_approval_blocked" - or proposal["proposal_status"] == "commercial_proposal_blocked" - or completion["completion_status"] == "commercial_completion_blocked" - or demo["demo_status"] == "commercial_demo_blocked" - or buyer_workflow["workflow_status"] == "buyer_acceptance_workflow_blocked" - or concrete_blockers - else "ready" - ) - diligence_sections = [ - section( - "purchase_approval_packet", - "Purchase approval packet", - "Purchase committee", - ["docs/commercial_purchase_approval_packet.md", "/api/v1/commercial_purchase_approval_packets/latest"], - ["/api/v1/commercial_purchase_approval_packets/latest", "/api/v1/commercial_proposal_packets/latest"], - "repository_and_runtime_artifact", - local_runtime_state if has_file("docs/commercial_purchase_approval_packet.md") else "blocked", - f"commercial_purchase_approval_status={purchase['purchase_approval_status']}", - "Can the buyer review one approval packet before diligence sign-off?", - "Use the approval packet as the diligence room cover index.", - ), - section( - "runtime_api_evidence", - "Runtime API evidence", - "Platform reviewer", - [ - "docs/rest_api_design.md", - "contextual_orchestrator/api_contract.py", - "README.md", - "/v1/chat/completions", - ], - [ - "/v1/chat/completions", - "/api/v1/workflow_runs", - "/api/v1/access_reports/{workflow_run_id}", - "/api/v1/commercial_due_diligence_rooms/latest", - ], - "repository_and_runtime_artifact", - "ready" - if local_runtime_state == "ready" - and all_files("docs/rest_api_design.md", "contextual_orchestrator/api_contract.py", "README.md") - and admin_state["agents"] - else "blocked", - f"agent_count={len(admin_state['agents'])}; api_contract_present={has_file('contextual_orchestrator/api_contract.py')}", - "Can platform reviewers verify compatible API and evidence endpoints?", - "Keep API compatibility and evidence endpoints in the diligence index.", - ), - section( - "admin_trace_evidence", - "Admin trace evidence", - "Operator reviewer", - ["docs/screen_design.md", "/admin", "/admin/state", "workflow trace", "access report"], - ["/admin", "/admin/state", "/api/v1/workflow_runs", "/api/v1/access_reports/{workflow_run_id}"], - "repository_and_runtime_artifact", - "ready" - if all_files("docs/screen_design.md", "contextual_orchestrator/admin.py") - and admin_state["agents"] - and admin_state["recent_workflow_runs"] - else "blocked", - f"recent_workflow_run_count={len(admin_state['recent_workflow_runs'])}", - "Can the operator show trace and access-list evidence in the admin console?", - "Run one conduct workflow before a live diligence walkthrough.", - ), - section( - "security_and_compliance", - "Security and compliance", - "Security reviewer", - ["SECURITY.md", "docs/commercial_security_attestation.md", "/api/v1/commercial_security_attestations/latest"], - ["/api/v1/commercial_security_attestations/latest"], - "repository_and_runtime_artifact", - "ready" - if security["security_attestation_status"] != "commercial_security_attestation_blocked" - and all_files("SECURITY.md", "docs/commercial_security_attestation.md") - else "blocked", - f"commercial_security_attestation_status={security['security_attestation_status']}", - "Can security separate repo-local controls from external attestation gaps?", - "Do not claim third-party certification until supplied.", - ), - section( - "commercial_terms", - "Commercial terms", - "Legal and procurement reviewers", - [ - "docs/commercial_contract_readiness.md", - "docs/commercial_procurement_readiness.md", - "docs/commercial_close_readiness.md", - ], - [ - "/api/v1/commercial_contract_readiness/latest", - "/api/v1/commercial_procurement_readiness/latest", - "/api/v1/commercial_close_readiness/latest", - ], - "repository_and_runtime_artifact", - "ready" - if contract["contract_status"] != "commercial_contract_blocked" - and procurement["procurement_status"] != "commercial_procurement_blocked" - and close["close_status"] != "commercial_close_blocked" - and all_files( - "docs/commercial_contract_readiness.md", - "docs/commercial_procurement_readiness.md", - "docs/commercial_close_readiness.md", - ) - else "blocked", - ( - f"commercial_contract_status={contract['contract_status']}; " - f"commercial_procurement_status={procurement['procurement_status']}; " - f"commercial_close_status={close['close_status']}" - ), - "Can legal and procurement review terms, rights, and close caveats together?", - "Attach buyer-specific order-form language outside the local runtime claim.", - ), - section( - "value_and_analytics", - "Value and analytics", - "Economic reviewer", - ["docs/commercial_value_readiness.md", "docs/analytics_spec.md", "/api/v1/analytics_snapshots/latest"], - ["/api/v1/commercial_value_readiness/latest", "/api/v1/analytics_snapshots/latest"], - "repository_and_runtime_artifact", - "ready" - if value["value_status"] != "commercial_value_blocked" - and analytics["measurement_status"] == "local_runtime_snapshot" - and all_files("docs/commercial_value_readiness.md", "docs/analytics_spec.md") - else "blocked", - f"commercial_value_status={value['value_status']}; analytics_measurement_status={analytics['measurement_status']}", - "Can finance tell measured local evidence apart from buyer ROI assumptions?", - "Keep proposed KPI targets separate from measured local runtime data.", - ), - section( - "implementation_readiness", - "Implementation readiness", - "Implementation and operations reviewers", - ["docs/commercial_onboarding_readiness.md", "docs/commercial_operations_readiness.md"], - ["/api/v1/commercial_onboarding_readiness/latest", "/api/v1/commercial_operations_readiness/latest"], - "repository_and_runtime_artifact", - "ready" - if onboarding["onboarding_status"] != "commercial_onboarding_blocked" - and operations["operations_status"] != "commercial_operations_blocked" - and all_files("docs/commercial_onboarding_readiness.md", "docs/commercial_operations_readiness.md") - else "blocked", - f"commercial_onboarding_status={onboarding['onboarding_status']}; commercial_operations_status={operations['operations_status']}", - "Can implementation owners see onboarding, operations, incident, and handoff evidence?", - "Convert buyer environment specifics into the paid onboarding plan.", - ), - section( - "figma_and_design_review", - "Figma and design review", - "Product design reviewer", - [ - "docs/commercial_due_diligence_room.md", - "docs/figma_artifacts.md", - "docs/superpowers/plans/2026-07-02-commercial-due-diligence-room-runtime.md", - ], - ["/api/v1/commercial_due_diligence_rooms/latest"], - "repository_and_runtime_artifact", - "ready" - if all_files( - "docs/commercial_due_diligence_room.md", - "docs/figma_artifacts.md", - "docs/superpowers/plans/2026-07-02-commercial-due-diligence-room-runtime.md", - ) - else "blocked", - "Due diligence doc, FigJam artifact record, and implementation plan are committed.", - "Can stakeholders inspect the diligence room as docs, runtime JSON, and FigJam?", - "Use FigJam only; do not use Figma Code Connect.", - ), - section( - "buyer_authority_documents", - "Buyer authority documents", - "Buyer sponsor", - ["named buyer signer", "budget owner and purchase order", "buyer DPA or privacy acceptance"], - [], - "proposed_until_buyer_specific", - "warning", - "Named signer, budget owner, PO, and buyer privacy acceptance require buyer authority.", - "Does the buyer have authority artifacts ready for final diligence?", - "Collect signer, PO, DPA/privacy acceptance, or explicit waiver.", - ), - section( - "production_external_attestations", - "Production and external attestations", - "Production and security owners", - ["production telemetry", "third-party security attestation", "hosted scan evidence"], - [], - "proposed_until_buyer_specific", - "warning", - "Production telemetry and third-party attestations are external evidence, not local repo measurements.", - "Can the buyer distinguish local readiness from production and third-party evidence?", - "Collect hosted telemetry and external attestation after environment selection.", - ), - ] - state_counts = Counter(item["completion_state"] for item in diligence_sections) - blocked_count = state_counts.get("blocked", 0) + len(concrete_blockers) - warning_count = state_counts.get("warning", 0) - if blocked_count: - due_diligence_status = "commercial_due_diligence_blocked" - elif warning_count: - due_diligence_status = "commercial_due_diligence_ready_with_warnings" - else: # pragma: no cover - unreachable while this report carries literal buyer-specific warning sections - due_diligence_status = "commercial_due_diligence_ready" # pragma: no cover - required_runtime_endpoints = list( - dict.fromkeys( - endpoint - for item in diligence_sections - for endpoint in item["runtime_endpoints"] - if endpoint.startswith("/") - ) - ) - - return { - "due_diligence_status": due_diligence_status, - "target_contract_value_krw": target_contract_value_krw, - "target_contract_value_display": f"KRW {target_contract_value_krw:,}", - "measurement_status": "local_commercial_due_diligence_room", - "source_note": ( - "Commercial due diligence room packages repo-local purchase approval, proposal, runtime, " - "admin trace, security, contract, value, onboarding, operations, analytics, Figma, " - "review-policy, and packaging evidence for KRW 2,000,000,000 buyer diligence; it is " - "not a valuation guarantee, purchase commitment, signed order, legal opinion, production " - "compliance certificate, third-party attestation, or revenue proof." - ), - "diligence_narrative": { - "title": "KRW 2B commercial due diligence room", - "promise": ( - "Give finance, procurement, legal, security, product, and implementation reviewers " - "one evidence room that separates measured local product evidence from buyer-specific " - "and external production artifacts." - ), - "audience": [ - "Economic buyer", - "Finance owner", - "Procurement owner", - "Legal owner", - "Security owner", - "Platform reviewer", - "Implementation owner", - ], - }, - "diligence_summary": { - "section_count": len(diligence_sections), - "ready_count": state_counts.get("ready", 0), - "warning_count": warning_count, - "blocked_count": blocked_count, - "endpoint_count": len(required_runtime_endpoints), - "review_process_is_blocker": purchase["review_process_policy"]["is_blocker"], - "code_connect_used": False, - }, - "diligence_sections": diligence_sections, - "required_runtime_endpoints": required_runtime_endpoints, - "buyer_missing_artifacts": [ - "named buyer signer", - "budget owner and purchase order", - "buyer DPA or privacy acceptance", - "production telemetry", - "third-party security attestation", - ], - "concrete_blockers": concrete_blockers, - "due_diligence_status_rules": [ - { - "due_diligence_status": "commercial_due_diligence_ready", - "rule": "all diligence sections are ready and no buyer authority, production, or third-party evidence remains open", - }, - { - "due_diligence_status": "commercial_due_diligence_ready_with_warnings", - "rule": "repo-local diligence room evidence is ready while buyer authority, production telemetry, or external attestations remain explicit warnings", - }, - { - "due_diligence_status": "commercial_due_diligence_blocked", - "rule": "security failure, API contract regression, document mismatch, runtime defect, missing local diligence evidence, or Code Connect usage blocks buyer diligence", - }, - ], - "review_process_policy": purchase["review_process_policy"], - "related_runtime_reports": { - "commercial_purchase_approval_status": purchase["purchase_approval_status"], - "commercial_proposal_status": proposal["proposal_status"], - "commercial_completion_status": completion["completion_status"], - "commercial_demo_status": demo["demo_status"], - "buyer_acceptance_workflow_status": buyer_workflow["workflow_status"], - "commercial_close_status": close["close_status"], - "commercial_procurement_status": procurement["procurement_status"], - "commercial_contract_status": contract["contract_status"], - "commercial_value_status": value["value_status"], - "commercial_security_attestation_status": security["security_attestation_status"], - "commercial_onboarding_status": onboarding["onboarding_status"], - "commercial_operations_status": operations["operations_status"], - "analytics_measurement_status": analytics["measurement_status"], - }, - "library_split_decision": purchase["library_split_decision"], - "plugin_traceability": purchase["plugin_traceability"], - "due_diligence_links": { - "figma_design_file": "https://www.figma.com/design/vsZMd8WAv42HDRgcZuNcWk", - "figjam_board": "https://www.figma.com/board/Wr8iMlB9SHkerHSjv0Pe0M", - "runtime_endpoint": "/api/v1/commercial_due_diligence_rooms/latest", - "documentation": "docs/commercial_due_diligence_room.md", - }, - } - - def commercial_investment_committee_memo_report( - self, - target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, - locale_bundles: dict[str, dict[str, str]] | None = None, - security_profile: dict[str, Any] | None = None, - ) -> dict[str, Any]: - """Return executive investment committee memo sections for the KRW 2B standard.""" - due_diligence = self.commercial_due_diligence_room_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - purchase = self.commercial_purchase_approval_packet_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - proposal = self.commercial_proposal_packet_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - completion = self.commercial_completion_scorecard_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - demo = self.commercial_demo_scenario_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - buyer_workflow = self.commercial_buyer_acceptance_workflow_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - close = self.commercial_close_readiness_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - procurement = self.commercial_procurement_readiness_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - contract = self.commercial_contract_readiness_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - value = self.commercial_value_readiness_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - security = self.commercial_security_attestation_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - onboarding = self.commercial_onboarding_readiness_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - operations = self.commercial_operations_readiness_report( - target_contract_value_krw=target_contract_value_krw, - locale_bundles=locale_bundles, - security_profile=security_profile, - ) - analytics = self.analytics_snapshot(locale_bundles=locale_bundles) - admin_state = self.admin_state() - root = Path(__file__).resolve().parents[1] - - def has_file(path: str) -> bool: - return (root / path).is_file() - - def all_files(*paths: str) -> bool: - return all(has_file(path) for path in paths) - - def section( - section_name: str, - label: str, - reviewer: str, - sources: list[str], - runtime_endpoints: list[str], - evidence_type: str, - completion_state: str, - evidence: str, - committee_question: str, - next_action: str, - ) -> dict[str, Any]: - require_object_name(section_name, "commercial_investment_committee.section_name") - if completion_state not in {"ready", "warning", "blocked"}: # pragma: no cover - raise ValueError("commercial investment committee section state must be ready, warning, or blocked") - return { - "section_name": section_name, - "label": label, - "reviewer": reviewer, - "sources": sources, - "runtime_endpoints": runtime_endpoints, - "evidence_type": evidence_type, - "completion_state": completion_state, - "evidence": evidence, - "committee_question": committee_question, - "next_action": next_action, - } - - concrete_blockers = list( - dict.fromkeys( - due_diligence["concrete_blockers"] - + purchase["concrete_blockers"] - + proposal["concrete_blockers"] - + completion["concrete_blockers"] - + demo["concrete_blockers"] - + buyer_workflow["concrete_blockers"] - ) - ) - local_runtime_state = ( - "blocked" - if due_diligence["due_diligence_status"] == "commercial_due_diligence_blocked" - or purchase["purchase_approval_status"] == "commercial_purchase_approval_blocked" - or proposal["proposal_status"] == "commercial_proposal_blocked" - or completion["completion_status"] == "commercial_completion_blocked" - or demo["demo_status"] == "commercial_demo_blocked" - or buyer_workflow["workflow_status"] == "buyer_acceptance_workflow_blocked" - or concrete_blockers - else "ready" - ) - memo_sections = [ - section( - "executive_recommendation", - "Executive recommendation", - "Investment committee chair", - [ - "docs/commercial_investment_committee_memo.md", - "docs/figma_artifacts.md", - "docs/superpowers/plans/2026-07-02-commercial-investment-committee-memo-runtime.md", - ], - ["/api/v1/commercial_investment_committee_memos/latest"], - "repository_and_runtime_artifact", - local_runtime_state - if all_files( - "docs/commercial_investment_committee_memo.md", - "docs/figma_artifacts.md", - "docs/superpowers/plans/2026-07-02-commercial-investment-committee-memo-runtime.md", - ) - else "blocked", - "Investment committee memo, FigJam artifact record, and implementation plan are committed.", - "Can the committee recommend the KRW 2B purchase path with explicit conditions?", - "Use this memo as the executive decision cover artifact.", - ), - section( - "diligence_room_ready", - "Due diligence room ready", - "Diligence owner", - ["docs/commercial_due_diligence_room.md", "/api/v1/commercial_due_diligence_rooms/latest"], - ["/api/v1/commercial_due_diligence_rooms/latest"], - "repository_and_runtime_artifact", - local_runtime_state if has_file("docs/commercial_due_diligence_room.md") else "blocked", - f"commercial_due_diligence_status={due_diligence['due_diligence_status']}", - "Can the memo point to a complete diligence room?", - "Reference due diligence room sections instead of duplicating evidence.", - ), - section( - "purchase_approval_ready", - "Purchase approval ready", - "Purchase sponsor", - ["docs/commercial_purchase_approval_packet.md", "/api/v1/commercial_purchase_approval_packets/latest"], - ["/api/v1/commercial_purchase_approval_packets/latest"], - "repository_and_runtime_artifact", - local_runtime_state if has_file("docs/commercial_purchase_approval_packet.md") else "blocked", - f"commercial_purchase_approval_status={purchase['purchase_approval_status']}", - "Can the committee see finance, procurement, legal, security, and implementation gates?", - "Use the purchase approval packet as committee appendix A.", - ), - section( - "financial_case", - "Financial case", - "Economic buyer", - ["docs/commercial_value_readiness.md", "docs/analytics_spec.md", "/api/v1/analytics_snapshots/latest"], - ["/api/v1/commercial_value_readiness/latest", "/api/v1/analytics_snapshots/latest"], - "repository_and_runtime_artifact", - "ready" - if value["value_status"] != "commercial_value_blocked" - and analytics["measurement_status"] == "local_runtime_snapshot" - and all_files("docs/commercial_value_readiness.md", "docs/analytics_spec.md") - else "blocked", - f"commercial_value_status={value['value_status']}; analytics_measurement_status={analytics['measurement_status']}", - "Does the memo separate measured local evidence from buyer ROI assumptions?", - "Attach buyer ROI model only after buyer discovery supplies it.", - ), - section( - "risk_and_security_summary", - "Risk and security summary", - "Security reviewer", - ["SECURITY.md", "docs/commercial_security_attestation.md", "/api/v1/commercial_security_attestations/latest"], - ["/api/v1/commercial_security_attestations/latest"], - "repository_and_runtime_artifact", - "ready" - if security["security_attestation_status"] != "commercial_security_attestation_blocked" - and all_files("SECURITY.md", "docs/commercial_security_attestation.md") - else "blocked", - f"commercial_security_attestation_status={security['security_attestation_status']}", - "Are security risks explicit without claiming external certification?", - "Keep third-party attestation outside measured local evidence.", - ), - section( - "commercial_terms_summary", - "Commercial terms summary", - "Legal and procurement reviewers", - [ - "docs/commercial_contract_readiness.md", - "docs/commercial_procurement_readiness.md", - "docs/commercial_close_readiness.md", - ], - [ - "/api/v1/commercial_contract_readiness/latest", - "/api/v1/commercial_procurement_readiness/latest", - "/api/v1/commercial_close_readiness/latest", - ], - "repository_and_runtime_artifact", - "ready" - if contract["contract_status"] != "commercial_contract_blocked" - and procurement["procurement_status"] != "commercial_procurement_blocked" - and close["close_status"] != "commercial_close_blocked" - and all_files( - "docs/commercial_contract_readiness.md", - "docs/commercial_procurement_readiness.md", - "docs/commercial_close_readiness.md", - ) - else "blocked", - ( - f"commercial_contract_status={contract['contract_status']}; " - f"commercial_procurement_status={procurement['procurement_status']}; " - f"commercial_close_status={close['close_status']}" - ), - "Can legal and procurement conditions be approved or tracked?", - "Attach order-form details only after buyer legal review.", - ), - section( - "implementation_readiness_summary", - "Implementation readiness summary", - "Implementation owner", - ["docs/commercial_onboarding_readiness.md", "docs/commercial_operations_readiness.md"], - ["/api/v1/commercial_onboarding_readiness/latest", "/api/v1/commercial_operations_readiness/latest"], - "repository_and_runtime_artifact", - "ready" - if onboarding["onboarding_status"] != "commercial_onboarding_blocked" - and operations["operations_status"] != "commercial_operations_blocked" - and all_files("docs/commercial_onboarding_readiness.md", "docs/commercial_operations_readiness.md") - else "blocked", - f"commercial_onboarding_status={onboarding['onboarding_status']}; commercial_operations_status={operations['operations_status']}", - "Can implementation start after buyer environment details are supplied?", - "Convert buyer environment details into the paid onboarding plan.", - ), - section( - "design_and_figma_review", - "Design and Figma review", - "Product design reviewer", - ["docs/figma_artifacts.md", "docs/commercial_investment_committee_memo.md"], - ["/api/v1/commercial_investment_committee_memos/latest"], - "repository_and_runtime_artifact", - "ready" if all_files("docs/figma_artifacts.md", "docs/commercial_investment_committee_memo.md") else "blocked", - "FigJam memo flow and Product Design scope are recorded without Code Connect.", - "Can stakeholders inspect the memo flow in FigJam and runtime JSON?", - "Keep Figma Code Connect out of the committee workflow.", - ), - section( - "buyer_final_authority", - "Buyer final authority", - "Buyer sponsor", - ["executive sponsor approval", "named signer", "budget owner", "purchase order"], - [], - "proposed_until_buyer_specific", - "warning", - "Executive sponsor approval, named signer, budget owner, and purchase order require buyer authority.", - "Can the buyer approve the final KRW 2B purchase authority?", - "Collect final buyer authority artifacts or explicit waiver.", - ), - section( - "production_external_evidence", - "Production and external evidence", - "Production and security owners", - ["production telemetry", "third-party security attestation", "hosted scan evidence"], - [], - "proposed_until_buyer_specific", - "warning", - "Production telemetry, third-party security attestation, and hosted scan evidence are external inputs.", - "Can the committee approve with production and external evidence still tracked as conditions?", - "Collect hosted evidence after environment selection.", - ), - ] - state_counts = Counter(item["completion_state"] for item in memo_sections) - blocked_count = state_counts.get("blocked", 0) + len(concrete_blockers) - warning_count = state_counts.get("warning", 0) - if blocked_count: - investment_committee_status = "commercial_investment_committee_blocked" - recommendation_status = "do_not_recommend_until_blockers_cleared" - elif warning_count: - investment_committee_status = "commercial_investment_committee_ready_with_warnings" - recommendation_status = "recommend_with_buyer_conditions" - else: # pragma: no cover - unreachable while external-evidence warning sections remain literal - investment_committee_status = "commercial_investment_committee_ready" # pragma: no cover - recommendation_status = "recommend" # pragma: no cover - required_runtime_endpoints = list( - dict.fromkeys( - endpoint - for item in memo_sections - for endpoint in item["runtime_endpoints"] - if endpoint.startswith("/") - ) - ) - - return { - "investment_committee_status": investment_committee_status, - "target_contract_value_krw": target_contract_value_krw, - "target_contract_value_display": f"KRW {target_contract_value_krw:,}", - "measurement_status": "local_commercial_investment_committee_memo", - "source_note": ( - "Commercial investment committee memo packages repo-local due diligence, purchase approval, " - "proposal, runtime, admin trace, security, contract, value, onboarding, operations, analytics, " - "Figma, review-policy, and packaging evidence for KRW 2,000,000,000 executive review; it is " - "not a valuation guarantee, purchase commitment, signed order, legal opinion, production " - "compliance certificate, third-party attestation, or revenue proof." - ), - "executive_recommendation": { - "title": "KRW 2B commercial investment committee memo", - "recommendation_status": recommendation_status, - "recommendation": ( - "Recommend committee review with buyer authority, production telemetry, and external " - "attestation conditions tracked separately from measured local product evidence." - if recommendation_status == "recommend_with_buyer_conditions" - else "Do not recommend until concrete blockers are cleared." - if recommendation_status == "do_not_recommend_until_blockers_cleared" - else "Recommend committee approval with no open local or buyer-specific conditions." - ), - "audience": [ - "Investment committee chair", - "Economic buyer", - "Finance owner", - "Procurement owner", - "Legal owner", - "Security owner", - "Implementation owner", - ], - }, - "memo_summary": { - "section_count": len(memo_sections), - "ready_count": state_counts.get("ready", 0), - "warning_count": warning_count, - "blocked_count": blocked_count, - "endpoint_count": len(required_runtime_endpoints), - "review_process_is_blocker": due_diligence["review_process_policy"]["is_blocker"], - "code_connect_used": False, - }, - "memo_sections": memo_sections, - "required_runtime_endpoints": required_runtime_endpoints, - "committee_decision_questions": [ - "Is the product evidence sufficient for KRW 2B buyer review?", - "Are buyer authority documents named and tracked?", - "Are production and third-party evidence gaps explicit warnings?", - "Is any concrete blocker present?", - ], - "buyer_missing_artifacts": due_diligence["buyer_missing_artifacts"] - + ["executive sponsor approval", "investment committee sign-off"], - "concrete_blockers": concrete_blockers, - "investment_committee_status_rules": [ - { - "investment_committee_status": "commercial_investment_committee_ready", - "rule": "all memo sections are ready and no buyer authority, production, or third-party evidence remains open", - }, - { - "investment_committee_status": "commercial_investment_committee_ready_with_warnings", - "rule": "repo-local committee memo evidence is ready while buyer authority, production telemetry, or external attestations remain explicit warnings", - }, - { - "investment_committee_status": "commercial_investment_committee_blocked", - "rule": "security failure, API contract regression, document mismatch, runtime defect, missing local memo evidence, or Code Connect usage blocks committee recommendation", - }, - ], - "review_process_policy": due_diligence["review_process_policy"], - "related_runtime_reports": { - "commercial_due_diligence_status": due_diligence["due_diligence_status"], - "commercial_purchase_approval_status": purchase["purchase_approval_status"], - "commercial_proposal_status": proposal["proposal_status"], - "commercial_completion_status": completion["completion_status"], - "commercial_demo_status": demo["demo_status"], - "buyer_acceptance_workflow_status": buyer_workflow["workflow_status"], - "commercial_close_status": close["close_status"], - "commercial_procurement_status": procurement["procurement_status"], - "commercial_contract_status": contract["contract_status"], - "commercial_value_status": value["value_status"], - "commercial_security_attestation_status": security["security_attestation_status"], - "commercial_onboarding_status": onboarding["onboarding_status"], - "commercial_operations_status": operations["operations_status"], - "analytics_measurement_status": analytics["measurement_status"], - "admin_agent_count": len(admin_state["agents"]), - }, - "library_split_decision": due_diligence["library_split_decision"], - "plugin_traceability": due_diligence["plugin_traceability"], - "committee_links": { - "figma_design_file": "https://www.figma.com/design/vsZMd8WAv42HDRgcZuNcWk", - "figjam_board": "https://www.figma.com/board/Wr8iMlB9SHkerHSjv0Pe0M", - "runtime_endpoint": "/api/v1/commercial_investment_committee_memos/latest", - "documentation": "docs/commercial_investment_committee_memo.md", - }, - } - - def admin_state( - self, - owner_id: str | None = None, - *, - role: str | None = None, - purpose: str | None = None, - ) -> dict[str, Any]: - """Build the admin console state payload from agents, policy, and audit data.""" - agent_page_size = max(1, len(self.candidates)) - return { - "agents": self.list_agents(page_size=agent_page_size), - "policy": { - **self.policy.as_dict(), - "roles": list(self.ROLE_TAGS), - }, - "routing_evidence": { - "transport": self._group_router.snapshot(), - "quality": self._quality_router.snapshot(), - }, - "recent_workflow_runs": [ - self._shorten_run(run) - for run in self.list_recent_runs( - page_size=max(1, len(self._run_order)), owner_id=owner_id - ) - ], - "recent_audit_events": self.list_recent_audit_events(role=role, purpose=purpose), - "recent_authorization_decisions": self.list_recent_authorization_decisions(), - "spend": self.spend_analytics(), - } - - def _shorten_run(self, run: dict[str, Any]) -> dict[str, Any]: # pragma: no cover - return { - "workflow_run_id": run["workflow_run_id"], - "mode": run["mode"], - "policy_mode": run["policy_mode"], - "created_at": run["created_at"], - } - - def _is_trace_complete(self, run: dict[str, Any]) -> bool: - trace = run.get("trace", []) - if not trace: - return False - for step in trace: - if not all(key in step for key in ("id", "role", "agent_id", "subtask", "access", "output")): - return False - if not isinstance(step["access"], list) or step["output"] is None: - return False - verification = run.get("verification") or {} - return bool(run.get("answer") and "accepted" in verification and "reason" in verification) - - def _is_policy_safe_run(self, run: dict[str, Any]) -> bool: - if run["mode"] == "conduct" and run["policy_snapshot"].get("verifier_required") and not run.get("verification"): - return False - return self._provider_exclusion_miss_count(run) == 0 - - def _provider_exclusion_miss_count(self, run: dict[str, Any]) -> int: - misses = 0 - for step in run.get("trace", []): - try: - agent = self._agent(step["agent_id"]) - except KeyError: - misses += 1 - continue - if step["role"] in agent.provider_exclusions: - misses += 1 - return misses - - def _locale_key_parity(self, locale_bundles: dict[str, dict[str, str]]) -> dict[str, Any]: - english = locale_bundles.get("en", {}) - other_locale_codes = sorted(code for code in locale_bundles if code != "en") - denominator = len(english) * len(other_locale_codes) - missing = [ - f"{locale_code}.{key}" - for locale_code in other_locale_codes - for key in sorted(english) - if not locale_bundles[locale_code].get(key) - ] - numerator = denominator - len(missing) - return { - "numerator": numerator, - "denominator": denominator, - "value_percent": self._percent(numerator, denominator), - "missing_keys": missing, - } - - def _percent(self, numerator: int, denominator: int) -> float | None: - if denominator == 0: - return None - return round((numerator / denominator) * 100, 2) - - def _criterion( - self, - criterion_name: str, - label: str, - status: str, - evidence: str, - remediation: str, - ) -> dict[str, str]: - require_object_name(criterion_name, "sales_readiness.criterion_name") - if status not in {"pass", "warn", "fail"}: # pragma: no cover - raise ValueError("sales readiness status must be pass, warn, or fail") - return { - "criterion_name": criterion_name, - "status": status, - "label": label, - "evidence": evidence, - "remediation": remediation, - } - - def _buyer_evidence_item( - self, - item_name: str, - label: str, - reviewer: str, - sources: list[str], - evidence_type: str, - completion_state: str, - evidence: str, - next_action: str, - ) -> dict[str, Any]: - require_object_name(item_name, "buyer_evidence_manifest.item_name") - if evidence_type not in { - "measured_local", - "repository_artifact", - "figma_artifact", - "proposed_until_production", - "proposed_until_buyer_specific", - }: # pragma: no cover - raise ValueError("buyer evidence type is invalid") - if completion_state not in {"ready", "warning", "blocked"}: # pragma: no cover - raise ValueError("buyer evidence completion state must be ready, warning, or blocked") - return { - "item_name": item_name, - "label": label, - "reviewer": reviewer, - "sources": sources, - "evidence_type": evidence_type, - "completion_state": completion_state, - "evidence": evidence, - "next_action": next_action, - } - - def _buyer_manifest_summary(self, items: list[dict[str, Any]]) -> dict[str, Any]: - completion_counts = Counter(item["completion_state"] for item in items) - evidence_counts = Counter(item["evidence_type"] for item in items) - return { - "total_items": len(items), - "by_completion_state": { - "ready": completion_counts.get("ready", 0), - "warning": completion_counts.get("warning", 0), - "blocked": completion_counts.get("blocked", 0), - }, - "by_evidence_type": { - "measured_local": evidence_counts.get("measured_local", 0), - "repository_artifact": evidence_counts.get("repository_artifact", 0), - "figma_artifact": evidence_counts.get("figma_artifact", 0), - "proposed_until_production": evidence_counts.get("proposed_until_production", 0), - "proposed_until_buyer_specific": evidence_counts.get("proposed_until_buyer_specific", 0), - }, - } - - def _security_posture_criterion(self, security_profile: dict[str, Any]) -> dict[str, str]: - auth_mode = security_profile.get("auth_mode", "loopback_no_auth") - issues: list[str] = [] - warnings: list[str] = [] - if auth_mode == "single_token": - warnings.append("single bearer token shared by admin and inference scopes") - elif auth_mode not in {"split_token", "external_bearer_verifier"}: - issues.append("no bearer token configured outside loopback-only development") - if security_profile.get("allow_public_bind"): - issues.append("public bind is enabled") - if security_profile.get("expose_trace_by_default"): - issues.append("trace exposure is enabled by default") - if int(security_profile.get("rate_limit_requests") or 0) <= 0: - issues.append("request rate limiting is disabled") - if int(security_profile.get("max_concurrent_runs") or 0) <= 0: - issues.append("run concurrency limiting is disabled") - - if issues: - status = "fail" - evidence = "; ".join(issues) - remediation = "Require bearer auth, private bind defaults, hidden traces, rate limits, and run limits." - elif warnings: - status = "warn" - evidence = "; ".join(warnings) - remediation = "For enterprise pilots, split admin and inference tokens before customer evaluation." - else: - status = "pass" - auth_evidence = ( - "external bearer verifier" - if auth_mode == "external_bearer_verifier" - else "split tokens" - ) - evidence = f"{auth_evidence}, private bind default, hidden traces, rate limits, and run limits are configured" - remediation = "Keep these controls enabled for customer-facing pilots." - - return self._criterion("security_posture", "Security posture", status, evidence, remediation) - - def _locale_readiness_criterion(self, analytics: dict[str, Any]) -> dict[str, str]: - locale_metric = next( - metric for metric in analytics["guardrails"] if metric["metric_name"] == "locale_key_parity" - ) - missing = locale_metric.get("missing_keys", []) - parity = locale_metric.get("value_percent") - if parity == 100.0: - status = "pass" - evidence = "English and Korean admin locale keys are aligned" - remediation = "Keep locale parity tests updated when adding operator copy." - else: - status = "warn" if missing else "fail" - evidence = f"{parity}% locale key parity; missing keys: {', '.join(missing) or 'locale bundles absent'}" - remediation = "Fill missing Korean and English operator labels before customer review." - return self._criterion("locale_readiness", "Locale readiness", status, evidence, remediation) - - def _provider_egress_criterion(self) -> dict[str, str]: - unsafe = [] - remote = [] - for agent in self.agents: - if agent.base_url.startswith("mock://"): - continue - if _is_local_provider_url(agent.base_url): - continue - remote.append(agent.id) - parsed = urlparse(agent.base_url) - if parsed.scheme != "https" or not agent.credential_name: - unsafe.append(agent.id) - if unsafe: - status = "fail" - evidence = f"unsafe provider egress config for agents: {', '.join(sorted(unsafe))}" - remediation = "Use https provider endpoints with a named KV credential before enabling remote egress." - else: - status = "pass" - evidence = ( - "mock providers only" - if not remote - else f"{len(remote)} remote providers use https and a named KV credential" - ) - remediation = "Keep provider allow-list enforcement enabled for non-mock providers." - return self._criterion("provider_egress_safety", "Provider egress safety", status, evidence, remediation) - - def _criteria_by_name(self, criteria: list[dict[str, str]]) -> dict[str, dict[str, str]]: - return {row["criterion_name"]: row for row in criteria} - - def _metrics_by_name(self, metrics: list[dict[str, Any]]) -> dict[str, dict[str, Any]]: - return {row["metric_name"]: row for row in metrics} - - def _commercial_documentation_profile(self) -> dict[str, Any]: - root = Path(__file__).resolve().parents[1] - required_documents = [ - "README.md", - "SECURITY.md", - "docs/product_planning.md", - "docs/rest_api_design.md", - "docs/analytics_spec.md", - "docs/commercial_readiness.md", - ] - missing_documents = [ - document_path - for document_path in required_documents - if not (root / document_path).is_file() - ] - return { - "required_documents": required_documents, - "missing_documents": missing_documents, - "present_count": len(required_documents) - len(missing_documents), - "required_count": len(required_documents), - "has_security_policy": (root / "SECURITY.md").is_file(), - "source": "repository documentation files", - } - - def _criteria_summary(self, criteria: list[dict[str, str]]) -> dict[str, int]: - counts = Counter(row["status"] for row in criteria) - return { - "pass": counts.get("pass", 0), - "warn": counts.get("warn", 0), - "fail": counts.get("fail", 0), - } - - -def redact_text(text: str) -> str: - """Mask credential shapes (API keys, tokens, passwords, bearer headers) from traces. - - Does not mask PII (email addresses, names, etc.): per governance-risk-compliance policy, - PII is protected by purpose-limited authorization, encryption, and audit logging, not by - destroying it in every response -- blanket PII masking here broke every downstream - consumer that needs the real content (e.g. an email client rendering actual addresses). - """ - redacted = text - for pattern in SECRET_PATTERNS: - if pattern.pattern.lower().startswith("(?i)(api"): - redacted = pattern.sub(lambda match: f"{match.group(1)}{match.group(2)}[REDACTED]", redacted) - else: - redacted = pattern.sub(lambda match: f"{match.group(1)}[REDACTED]", redacted) - return redacted - - -def redact_value(value: Any) -> Any: - """Recursively redact string values while preserving response shape.""" - if isinstance(value, str): - return redact_text(value) - if isinstance(value, list): - return [redact_value(item) for item in value] - if isinstance(value, dict): - return {key: redact_value(item) for key, item in value.items()} - return value - -def _freeze_report_cache_value(value: Any) -> Any: - if isinstance(value, dict): - return tuple( - sorted( - (str(key), _freeze_report_cache_value(item)) - for key, item in value.items() - ) - ) - if isinstance(value, (list, tuple)): - return tuple(_freeze_report_cache_value(item) for item in value) - if isinstance(value, set): - return tuple(sorted(_freeze_report_cache_value(item) for item in value)) - try: - hash(value) - except TypeError: - return repr(value) - return value - - -def _cached_commercial_report(method: Any) -> Any: - @wraps(method) - def wrapper(self: TaskOrchestrator, *args: Any, **kwargs: Any) -> dict[str, Any]: - cache = _COMMERCIAL_REPORT_CACHE.get() - token = None - if cache is None: - cache = {} - token = _COMMERCIAL_REPORT_CACHE.set(cache) - try: - key = ( - method.__name__, - _freeze_report_cache_value(args), - _freeze_report_cache_value(kwargs), - ) - if key not in cache: - cache[key] = method(self, *args, **kwargs) - return cache[key] - finally: - if token is not None: - _COMMERCIAL_REPORT_CACHE.reset(token) - - return wrapper - - -for _commercial_report_name, _commercial_report_method in list(TaskOrchestrator.__dict__.items()): - if ( - _commercial_report_name.startswith("commercial_") - and _commercial_report_name.endswith("_report") - and callable(_commercial_report_method) - ): - setattr( - TaskOrchestrator, - _commercial_report_name, - _cached_commercial_report(_commercial_report_method), - ) - - -def _pareto_front(results: list[dict[str, Any]]) -> list[dict[str, Any]]: - """Configs not dominated on (quality up, cost down).""" - measured = [row for row in results if row.get("cost_usd") is not None] - front: list[dict[str, Any]] = [] - for a in measured: - dominated = any( - b is not a - and b["quality"] >= a["quality"] - and b["cost_usd"] <= a["cost_usd"] - and (b["quality"] > a["quality"] or b["cost_usd"] < a["cost_usd"]) - for b in measured - ) - if not dominated: - front.append(a) - return front - - -def _recommend_config(results: list[dict[str, Any]], cost_budget_usd: float | None) -> dict[str, Any] | None: - measured = [row for row in results if row.get("cost_usd") is not None] - if not measured: - return None - if cost_budget_usd is not None: - affordable = [r for r in measured if r["cost_usd"] <= cost_budget_usd] - if affordable: - best = max(affordable, key=lambda r: (r["quality"], -r["cost_usd"])) - reason = "highest quality within cost budget" - else: - best = min(measured, key=lambda r: r["cost_usd"]) - reason = "no config within budget; cheapest instead" - else: - # Maximize performance first, minimize cost as the tie-break (cheapest among the - # best-quality configs) — the honest reading of "max quality while min cost". - best = max(measured, key=lambda r: (r["quality"], -r["cost_usd"])) - reason = "highest quality; cheapest among equal-quality configs" - return {"name": best["name"], "quality": best["quality"], "cost_usd": best["cost_usd"], "reason": reason} - - -def _score_config(orchestrator: Any, tasks: list[dict[str, Any]], quality_fn: Any, mode: str, use_batch: bool) -> float: - """Mean quality of one config over the task set; route configs may evaluate via Batch.""" - if use_batch and mode == "route": - records = orchestrator.batch_route([task["prompt"] for task in tasks]) - scores = [float(quality_fn(task, record["answer"] or "")) for task, record in zip(tasks, records)] - else: - scores = [ - float(quality_fn(task, orchestrator.run([{"role": "user", "content": task["prompt"]}], mode=mode)["answer"])) - for task in tasks - ] - return sum(scores) / len(scores) if scores else 0.0 - - -def optimize_orchestration( - candidates: list[dict[str, Any]], - tasks: list[dict[str, Any]], - quality_fn: Any, - cost_budget_usd: float | None = None, - use_batch: bool = False, -) -> dict[str, Any]: - """Search orchestration configs for maximum quality at minimum cost (the Fugu tradeoff). - - - ``candidates``: ``[{"name": str, "orchestrator": TaskOrchestrator, "mode": str}]``. - Each orchestrator should be fresh so its spend reflects only this search. - - ``tasks``: ``[{"prompt": str, ...}]`` — the eval set; each task + the produced - answer is passed to ``quality_fn``. - - ``quality_fn(task, answer_text) -> float`` in [0, 1] — the caller's real quality - signal (e.g. checkable answers or a judge). This function does not fabricate quality. - - ``cost_budget_usd``: optional cap. Recommendation = highest-quality config within - budget, else the cheapest; with no budget, the best quality-per-USD. - - Returns per-config measured quality + real cost, the Pareto front, and a recommendation. - """ - results: list[dict[str, Any]] = [] - for candidate in candidates: - orchestrator = candidate["orchestrator"] - mode = candidate.get("mode", "auto") - quality = _score_config(orchestrator, tasks, quality_fn, mode, use_batch) - cost = orchestrator.spend_analytics()["totals"]["cost_usd"] - results.append({ - "name": candidate["name"], - "mode": mode, - "quality": round(quality, 4), - "cost_usd": round(cost, 6) if cost is not None else None, - "quality_per_usd": ( - round(quality / cost, 2) if cost is not None and cost > 0 else None - ), - "task_count": len(tasks), - }) - - return { - "objective": "maximize quality, minimize cost", - "cost_budget_usd": cost_budget_usd, - "results": sorted( - results, - key=lambda r: ( - -r["quality"], - r["cost_usd"] is None, - r["cost_usd"] if r["cost_usd"] is not None else float("inf"), - ), - ), - "pareto_front": [r["name"] for r in _pareto_front(results)], - "recommended": _recommend_config(results, cost_budget_usd), - } - - -def evolve_orchestration( - build_orchestrator: Any, - search_space: dict[str, list[Any]], - tasks: list[dict[str, Any]], - quality_fn: Any, - generations: int = 4, - population: int = 6, - cost_budget_usd: float | None = None, - seed: int = 7, - use_batch: bool = False, -) -> dict[str, Any]: - """Evolve orchestration configs toward max quality at min cost (TRINITY-style search). - - For search spaces too large to enumerate: a seeded mutation+selection loop over - ``search_space`` (param -> candidate values). ``build_orchestrator(config)`` returns a - fresh TaskOrchestrator for a config (the caller owns provider wiring); each config is - evaluated ONCE and cached — critical when evaluation costs real API money. - - Fitness maximizes measured quality, then minimizes measured cost; configs whose cost - exceeds ``cost_budget_usd`` rank below all affordable ones. Quality comes from the - caller's ``quality_fn(task, answer) -> [0,1]`` — never fabricated. - """ - rng = random.Random(seed) - params = sorted(search_space) - - def random_config() -> dict[str, Any]: - return {p: rng.choice(search_space[p]) for p in params} - - def mutate(config: dict[str, Any]) -> dict[str, Any]: - child = dict(config) - gene = rng.choice(params) - choices = [v for v in search_space[gene] if v != config[gene]] or search_space[gene] - child[gene] = rng.choice(choices) - return child - - def key(config: dict[str, Any]) -> str: - return json.dumps({p: config[p] for p in params}, sort_keys=True, ensure_ascii=False) - - evaluated: dict[str, dict[str, Any]] = {} - - def evaluate(config: dict[str, Any]) -> dict[str, Any]: - config_key = key(config) - if config_key in evaluated: - return evaluated[config_key] - orchestrator = build_orchestrator(config) - mode = config.get("mode", "auto") - quality = _score_config(orchestrator, tasks, quality_fn, mode, use_batch) - cost = orchestrator.spend_analytics()["totals"]["cost_usd"] - result = { - "name": config_key, - "config": dict(config), - "quality": round(quality, 4), - "cost_usd": round(cost, 6) if cost is not None else None, - "quality_per_usd": ( - round(quality / cost, 2) if cost is not None and cost > 0 else None - ), - "task_count": len(tasks), - } - evaluated[config_key] = result - return result - - def fitness(row: dict[str, Any]) -> tuple[int, float, float]: - if row["cost_usd"] is None: - return (0, row["quality"], float("-inf")) - affordable = 1 if cost_budget_usd is None or row["cost_usd"] <= cost_budget_usd else 0 - return (affordable, row["quality"], -row["cost_usd"]) - - # Seed population (dedup keys so a tiny space doesn't waste evaluations). - pool: list[dict[str, Any]] = [] - seen: set[str] = set() - while len(pool) < population and len(seen) < min(population * 4, _space_size(search_space)): - config = random_config() - if key(config) not in seen: - seen.add(key(config)) - pool.append(config) - - history: list[dict[str, Any]] = [] - for generation in range(generations): - rows = [evaluate(config) for config in pool] - rows.sort(key=fitness, reverse=True) - survivors = rows[: max(1, len(rows) // 2)] - history.append({ - "generation": generation, - "best": {"config": survivors[0]["config"], "quality": survivors[0]["quality"], "cost_usd": survivors[0]["cost_usd"]}, - "evaluated_total": len(evaluated), - }) - pool = [dict(row["config"]) for row in survivors] - while len(pool) < population: - pool.append(mutate(rng.choice(survivors)["config"])) - - results = sorted(evaluated.values(), key=fitness, reverse=True) - return { - "objective": "maximize quality, minimize cost (evolutionary search)", - "cost_budget_usd": cost_budget_usd, - "generations": generations, - "evaluations": len(evaluated), - "space_size": _space_size(search_space), - "results": results, - "pareto_front": [row["name"] for row in _pareto_front(results)], - "recommended": _recommend_config(results, cost_budget_usd), - "history": history, - } - - -def _space_size(search_space: dict[str, list[Any]]) -> int: - size = 1 - for values in search_space.values(): - size *= max(1, len(values)) - return size - - -def chat_completion_response( - result: dict[str, Any], - model: str = "contextual-orchestrator", - include_trace: bool = False, - usage: dict[str, int] | None = None, -) -> dict[str, Any]: # pragma: no cover - """Wrap orchestration output in an OpenAI-compatible chat completion response. - - ``usage`` carries measured token counts. Absence remains explicit and null. - """ - orchestration = { - "workflow_run_id": result.get("workflow_run_id"), - "mode": result["mode"], - "verification": result.get("verification"), - "channel": result.get("channel"), - "routing_reason": result.get("routing_reason"), - "usage_record_id": result.get("usage_record_id"), - "cost": result.get("cost"), - } - if include_trace: - orchestration["trace"] = redact_value(result["trace"]) - message: dict[str, Any] = {"role": "assistant", "content": result["answer"]} - tool_calls = result.get("tool_calls") - if tool_calls: - message["tool_calls"] = tool_calls - if not result.get("answer"): - message["content"] = None - finish_reason = result.get("finish_reason") or ("tool_calls" if tool_calls else "stop") - return { - "id": _new_chat_completion_id(), - "object": "chat.completion", - "created": int(time.time()), - "model": model, - "choices": [ - { - "index": 0, - "message": message, - "finish_reason": finish_reason, - } - ], - "usage": usage, - "usage_measurement_status": "measured" if usage is not None else "unavailable", - "orchestration": {key: value for key, value in orchestration.items() if value is not None}, - } - - -def text_completion_response( - result: dict[str, Any], - model: str = "contextual-orchestrator", - usage: dict[str, int] | None = None, -) -> dict[str, Any]: # pragma: no cover - """Wrap orchestration output as OpenAI legacy ``text_completion`` (``/v1/completions``).""" - return { - "id": f"cmpl-{int(time.time() * 1000)}", - "object": "text_completion", - "created": int(time.time()), - "model": model, - "choices": [ - { - "index": 0, - "text": result["answer"], - "logprobs": None, - "finish_reason": "stop", - } - ], - "usage": usage, - "usage_measurement_status": "measured" if usage is not None else "unavailable", - } - - -_STREAM_CHUNK_SIZE = 32 - - -def chat_completion_chunks( - result: dict[str, Any], - model: str = "contextual-orchestrator", - include_trace: bool = False, - include_usage: bool = False, -) -> list[dict[str, Any]]: - """Frame an orchestration result as OpenAI-compatible chat completion chunks. - - Only provider-reported usage may be emitted. Gateway estimates remain internal - because presenting estimates as provider usage would violate the wire contract. - """ - answer = result.get("answer", "") - completion_id = _new_chat_completion_id() - created = int(time.time()) - base = { - "id": completion_id, - "object": "chat.completion.chunk", - "created": created, - "model": model, - } - if include_usage: - base["usage"] = None - - chunks: list[dict[str, Any]] = [ - { - **base, - "choices": [ - {"index": 0, "delta": {"role": "assistant"}, "finish_reason": None} - ], - } - ] - for offset in range(0, len(answer), _STREAM_CHUNK_SIZE): - piece = answer[offset : offset + _STREAM_CHUNK_SIZE] - chunks.append( - { - **base, - "choices": [ - {"index": 0, "delta": {"content": piece}, "finish_reason": None} - ], - } - ) - tool_calls = result.get("tool_calls") - if tool_calls: - chunks.append( - { - **base, - "choices": [ - { - "index": 0, - "delta": { - "tool_calls": [ - {"index": index, **call} - for index, call in enumerate(tool_calls) - ] - }, - "finish_reason": None, - } - ], - } - ) - - orchestration = { - "workflow_run_id": result.get("workflow_run_id"), - "mode": result.get("mode"), - "verification": result.get("verification"), - } - if include_trace and "trace" in result: - orchestration["trace"] = redact_value(result["trace"]) - - finish_reason = result.get("finish_reason") or ( - "tool_calls" if tool_calls else "stop" - ) - final = { - **base, - "choices": [{"index": 0, "delta": {}, "finish_reason": finish_reason}], - "orchestration": { - key: value for key, value in orchestration.items() if value is not None - }, - } - chunks.append(final) - - usage = result.get("usage") - cost = result.get("cost") - if include_usage: - measured = ( - isinstance(cost, dict) - and cost.get("measurement_status") == "measured" - and isinstance(usage, dict) - ) - chunks.append( - { - **base, - "choices": [], - "usage": usage if measured else None, - "usage_measurement_status": "measured" if measured else "unavailable", - } - ) - return chunks - - -def _new_chat_completion_id() -> str: - """Create a collision-resistant OpenAI-compatible completion identifier.""" - return f"chatcmpl-{uuid.uuid4().hex}" - - -def sse_stream_body(chunks: list[dict[str, Any]]) -> str: - """Serialize chat completion chunks as a Server-Sent Events body terminated by ``[DONE]``.""" - frames = [f"data: {json.dumps(chunk, ensure_ascii=False)}\n\n" for chunk in chunks] - frames.append("data: [DONE]\n\n") - return "".join(frames) + retry_at]|Ἥz&^uɅѕ䀡эɕ=$A$٥ԁ͕́(Յ䁍ɅѡȁѡѕݥѠͅх̀͡ݥ(ɕ͍ȁЁЁ͔́́ݸ(͡丁=Ʌѽ́ЁͅЁ٥ͥѡɽ՝ѡ(͍}́əѕ((ɕѕ|||хͼЁɕ͕́ɔѕɵѥ(ф聱mmȰutl((͕Q]e}U1Q}5=0(Ј耉(ɕѕ聍ɕѕ(ݹ}耉ѕՅɍɅѽȈ((t(ф(͕UQ=}5=0(Ј耉(ɕѕ聍ɕѕ(ݹ}耉ѕՅɍɅѽȈ((͕}}Ʌ}ɕ}СФȁЁ͕̤(ф(͕I}5=0(Ј耉(ɕѕ聍ɕѕ(ݹ}耉ѕՅɍɅѽȈ((͕͕mtѕltȁѕх(5ɽ͕́ɔɕ̀ͅɽѕ(ѼѡЁɕȤͼٕѥ͔ѡɕ̸(ȁɽ͕}}ɽ̠(ЁɽР}}չЈ(ѥՔ(ɽ}̀ȡɽlɽ}t(ɽ}͕́(ѥՔ(͕ɽ}̤(ф((聝ɽ}̰(Ј耉(ɕѕ聍ɕѕ(ݹ}耉}ɽ(((͕́́ѡɽѥ͕ѕ́(хЁٕхѥͼͅЁ(ѡ́(ȁЁ͕(}ȡйɥ(Ё}ȁ}͕(ѥՔ(͕}(ф((聵}(Ј耉(ɕѕ聍ɕѕ(ݹ}聅йɽ٥}(ȁ͕}}ɽ٥}й͕}ɰ(Ȁ}(((ɕɸ쉽Ј耉Јф聑х((}}͕}ȤmȰt(Iɸ=$ЁȁɅ͔-ɽɁݡչݸ(݅ѕ􀡵}Ȁɥ(Ё݅ѕ(Ʌ͔-ɽȡ}(ȁѕ͕}}̠lфt(ѕlt݅ѕ(ɕɸѕ(Ʌ͔-ɽȡ}((}ɕ}չ̠(͕(}յ聥Ѐİ(}ͥ聥Ѐ(ݹ}ȁ99(mmȰut(IɸѕЁɕЁݽɭ܁ոɕɑ̸(}յȀāȁ}ͥ销耀Ʌ聹ٕ(Ʌ͔YՕɽȠ}յȽ}ͥ锁ЁĈ(хЀ}յȀĤ}ͥ(хЀ}ͥ(չ}̀l(չ}(ȁչ}͕}չ}ɑ(ݹ}́9ȁ͕}ݽɭ}չmչ}tРݹ}ݹ}(umх镹t(ɕɸm͕}ݽɭ}չmչ}tȁչ}չ}t((}ѕ}ݽɭ}չ̡͕mmȰut(Iɸݽɭ܁չ́٥ͥѼѕոյ̸((፱Ց́э}ɽѕ́ееՑ}ٕɥѥ(ɽ̀٥ɕ٥܁Ĥѡ͔ɔЁ}ݽɭ}չ́ͼ(ѡȁɕɕ䵥ɕٕ́ȁаЁɽ(́Ё͡ɕձЁЁЁєѕոչа(ѥ́-A$ȁɍɕ́ɥѡͅɕͽ(ѡЁɕ䁭́ѡЁ}չ}ɑɁ}ɕ}չ́(Mə̀}ѥ́Ʌѕ䁭ѕɅѥ(}ݽɭ}չ́ɕѱ䁥ѕѡ́Ȱͥ(ɽܝ́́ɕЁх䁍չѕѡɔ((ɕɸl(ո(ȁո͕}ݽɭ}չ̹مՕ̠(ЁոР}ٕɥѥЁոРɔ(t((չ}ݽɭ}չ̡͕ݹ}ȁ99( չЁ䁍ѕݽɭ܁չ́٥ͥѼѡɕՕѕݹȸ(ɕɸմ(ݹ}́9ȁɕɐРݹ}ݹ}(ȁɕɐ͕}ѕ}ݽɭ}չ̠(((}ɕ}Ց}ٕ̠(͕(}յ聥Ѐİ(}ͥ聥Ѐ԰((ɽȁ99(͔ȁ99(mmȰut(IɸɕЁՑЁٕ̰ѥA%$䁙ȁѡɥ镐ɕ丈((}յȀāȁ}ͥ销耀Ʌ聹ٕ(Ʌ͔YՕɽȠ}յȽ}ͥ锁ЁĈ(ٕ̀􁱥С͕}Ց}ٕ̤(хЀ}յȀĤ}ͥ(хЀ}ͥ(ѽх􁱕ٕ̤(Ѐ􁵅ѽх(ɥЀ􁵅ѽххФ(͕ѕ􁱥Сɕٕ͕ٕmɥt(ɽ􀉅ȁ͔􀉅Ց}ɕ(ɕɸ͕ѕ(ɕѽɕ聱mmȰutmt(ѽ聑mȰt(ȁٕЁ͕ѕ(хٕйРٕ}х(Ё}ѕ}хх(ɕѽɕٕФ(ѥՔ(ɕѽɕ}ٕЀ􁑥СٕФ((хф􁑕хС9 IeAQ}%1M}-d(}􁵕хфР}ͥххфФ͔͕}}}(Ёͥх}ȤȁЁ}(Ʌ͔AAɽѕѥɽȠѕхф́م䁹(ѽȀ􁕹ѽ̹С}(ѽȁ́9(ѽȀ􁱽}}ѽȡ}(ѽm}t􁕹ѽ(ɕѽɕ}ٕlٕ}хt􁕹ѽȹ}̡х(ፕЁAAɽѕѥɽ(ɕѽɕ}ٕlٕ}хt(х(}}}ɽѕѥ}ɽ}|耉չم((ɕѽɕɕѽɕ}ٕФ(ɕɸɕѽɕ((}ɕ}ѡɥѥ}̡͕ͥ}յ聥Ѐİ}ͥ聥ЀԤmmȰut(IɸɕЁ͕ɕеɕѡɥѥͥ́ݕеЁɑȸ(}յȀāȁ}ͥ销耀Ʌ聹ٕ(Ʌ͔YՕɽȠ}յȽ}ͥ锁ЁĈ(ٕ̀􁱥С͕}ѡɥѥ}ٕ̤(хЀ}յȀĤ}ͥ(хЀ}ͥ(ѽх􁱕ٕ̤(Ѐ􁵅ѽх(ɥЀ􁵅ѽххФ(ɕɸСɕٕ͕ٕmɥt((ɕɑ}ѥ}ٕР(͕(ٕ}Ȱ(х聑mȰt((}%ѕɅmt􀠤(9(IɐЁ䁅ѥٕ́ЁݥѡЁɽЁȁЁѕи(ɕեɕ}}ٕ}ѥ̹ٕ}(ٕЀ(ٕ}ѥ聥Сѥѥ(ٕ}聕ٕ}(ٕ}хɕ}مՔ͕}ɽѕѕ}ٕ}хх}̤((͕}ѥ}ٕ̹ٕФ(͕}ѽɔ́Ё9(͕}ѽɔٔͅѥ̈9ٕФ((}չ}Ց}}}(͕ɕɐ5mȰt(mmȰtt(IɸѡɥхѥٔȵЁѽ́م丈(}}Ѐ텝й聅йȁЁ͕ѕ(}}聑mȰt(ȁѕɕɐРɅmt(ѕР}ȁ}}йР(ѕР͕ٕ}}ȁѕР}չݸ((}ѽ̰}ͽɍ}ѕ}}ѽ̠(ѕ͕ѽ}չѕȰ((}ѽ́́9(ɕɸ͔(}}mt}}С}ѽ(ٕɥѥɕɐРٕɥѥ(ͥхٕɥѥ5(Ց}}ٕɥѥРՑ}}(Ց}}́Ё9(ѕՑՑ}}́䁕ٕȁ͕(̤ݡ͔ɕ͔ɥمͅ(ѥչЁѽ݅ɐѡՑЁѕȰȁո(չɕՑ́ձፕѡ(͕مѥٔ䵑ͥ́Ѽɍ(ѼѡͅѥєɽɕѕЁ}ѕ}}ѽ(ɕ䁅́Ѽݽɭȁѕ́ݥѠɕѕͅ(٥ɕ٥܁聅ɱȁɕ٥ͥѡ́(ɥѕɕѕɼѽЁѕѥє(ɽՑ}}ѕЀѡՑ́ݸɅѕ(ɅѥЁٕɥ}ЀѡݽɭȁݕȁЁ݅(Ց͕٥ɕ٥܁ѡ́ͅ(՝Ёѥѥɽѡɽͥѡ(Ց}ٕɥѥРՑ}ȁ}}йР(Ց}}չݸ((ѥ}ѽ̰}Ց}ɕѕ}ѕ}}ѽ̠((ٕͅɥѥРՑ}ͅ(ЈٕɥѥРՑ}}ѕЈ((͕ѽ}չѕȰ(Ց}((ѥ}ѽ́́9(ɕɸ͔(}}mՑ}t(}}СՑ}ѥ}ѽ((ɕɸ}}QՔ((}ɕ}ݽɭ}ո͕ɕɐ聑mȰt9(Mѽɔոє́хеѥՑЁѕȁѽ丈(}}Ѐ텝й聅йȁЁ͕ѕ(ȁѕɕɐРɅmt(ЁѕР}(}ѕР͕ٕ}}ȁѕР}(ѕl}t􁵽}}йС}չݸ(չ}ɕɑlݽɭ}չ}t(ݥѠ͕}Ց}}(ɕ٥͕̀}ݽɭ}չ̹Сչ}(ȁͥոİɕ٥̤İɕɐ(ո́9(ѥՔ(չ}}}ѕȀչlݽɭ}չ}t(}}م͕}չ}Ց}}}ո(م}}ՑЀم(͕Ց}}}͐́9(ȁ͕ɥ}}ȁ}}((ͥ(͕}Ց}չم}չ}̹͍ɐչ}}}ѕȤ(Ёم}}Ց(͕}Ց}չم}չ}̹չ}}}ѕȤ(ȁ}ѽ́}}ѕ̠(ɔ͕}Ց}}}ѽ̹С(ѕȀ􁉕ɔͥ}ѽ(ɥ͕ɥ}}С(ɥ́Ё9(͕}Ց}}}͐}}͑}(ѕȰɥ(}}͑}ɔɥ(ѕ(͕}Ց}}}ѽmt􁅙ѕ(͔(͕}Ց}}}ѽ̹9(͕}Ց}}}ѽ̀ͥ}ѽ(͕}ݽɭ}չmչ}tɕɐ((}ɕե}Ց}ѕȡ͕9(IѡѕȁѕȁɅɔеѥ䁍(ݥѠ͕}Ց}}(}}聑mȰt(չم}չ}͕mt͕Р(ȁո͕}ݽɭ}չ̹مՕ̠(չ}аم͕}չ}Ց}}}ո(م}}ՑЀم(͕Ց}}}͐́9(ȁ͕ɥ}}ȁչ}Ф((Ёم}}Ց(չم}չ}̹չlݽɭ}չ}t(ȁ}ѽ́չ}йѕ̠(}}mt}}С}ѽ(͕}Ց}}}ѽ̀}}(͕}Ց}չم}չ}̀չم}չ}(͕}Ց}}}ѽ̀մ}}مՕ̠(͕}Ց}}}͐մ((}}͑}}ѽ̰͕ɥ}}mt(ȁ}ѽ́}}ѕ̠(͕ɥ}}((х(((}ѥ̡͕ɥ}}聑mȰt99mȰt(Iɸɽ٥ȵɕѕȁᅍеѽȁЁͅи(ɥ̀쨩͕ɥ}}ɥ}}ȁ(}}Ѐ텝й聅йȁЁ͕ѕ(}聑mȰmȰut(ѽх}}ѽ̀(ɕѕ}ɽ}ѽ̀(ɽ}مQՔ((ȁո͕}ݽɭ}չ̹مՕ̠(ȁѕչlɅt(ѕР}ȁ}}йР(ѕР͕ٕ}}ȁѕР}չݸ((ͅѕРͅ(ɕѕ}ɽЀ(ͅРɽ}ѽ̈ͅР}ѽ̈(ͥхͅФ(͔9((ɕѕ}ɽФ́Ёɕѕ}ɽЀ(ɕѕ}ɽ}ѽ̀ɕѕ}ɽ(͔(ɽ}م͔(ѥٔͽɍ}ѕ}}ѽ̡ѕ͕ѽ}չѕȰ(ՍЀ}͕ёձР(((}ѽ̈(ѕ}չЈ(ɕѕ}ѕ̈(ѽ}ѕ̈(չم}ѕ̈(((Սlѕ}չЉt(Սmͽɍ}ѕ̉t(ѥٔ́Ё9(Սl}ѽ̉t􁕙ѥٔ(ѽх}}ѽ̀􁕙ѥٔ((ٕɥѥոРٕɥѥ(Ց}}(ٕɥѥРՑ}}(ͥхٕɥѥ5(͔9((Ց}}́Ё9(ѕՑՑ}}́䁕ٕȁ͕(̤Ёх٥ͥɔٕݡ(ɕ͔ɥمͅȁɕɕ(Ց́ͥѱ䁅͕Ёɽȵ(ѥ́ѥɕ丁5ɽȁѡݽɭȵѕٔ(ᅍѱ聕ѥєɽѡɕՑѕа(}ѕ}}ѽ́ɕЁѡЁɕѕѥѕ(Ёѕɥѕɕѕиѥєɽ(Ց}}ѕЀѡՑ́ݸɅѕɅѥ(Ёٕɥ}ЀѡݽɭȁݕȁЁ݅́Ց(Ց}ٕͅɥѥРՑ}ͅ(Ց}ѕЀٕɥѥРՑ}}ѕЈ(Ց}ٕɥѥРՑ}ȁ}}йР(Ց}}չݸ((ѥٔͽɍ}ѕ}}ѽ̠(ͅ聩Ց}ͅЈ聩Ց}ѕ(͕ѽ}չѕȰ(Ց}((ɕѕ}ɽЀ(Ց}ͅРɽ}ѽ̈Ց}ͅР}ѽ̈(ͥхՑ}ͅФ(͔9((ɕѕ}ɽФ́Ёɕѕ}ɽЀ(ɕѕ}ɽ}ѽ̀ɕѕ}ɽ(͔(ɽ}م͔(ՍЀ}͕ёձР(Ց}((}ѽ̈(ѕ}չЈ(ɕѕ}ѕ̈(ѽ}ѕ̈(չم}ѕ̈(((Սlѕ}չЉt(Սmͽɍ}ѕ̉t(ѥٔ́Ё9(Սl}ѽ̉t􁕙ѥٔ(ѽх}}ѽ̀􁕙ѥٔ((ɽ聱mmȰutmt(չɥ聱mtmt(ѽх}}͐(}مQՔ(}مQՔ(ȁՍЁͽѕ}ѕ̠(}مՍlչم}ѕ̉t(}م}م}م(ɥɥ̹С(}(}}͑}Սl}ѽ̉tɥ(ɥ́Ё9}م(͔9((Ѐ􁙱С}}́Ё9͔9(ɥ́9(չɥ(}م͔(Ё}م(}م͔(͔(ѽх}}͐􁍽}(Ё}م(ͅ}ͽɍչم(Սlɕѕ}ѕ̉tՍlѕ}չЉt(ͅ}ͽɍɕѕ(Սlѽ}ѕ̉tՍlѕ}չЉt(ͅ}ͽɍѽȈ(͔(ͅ}ͽɍ􀉵ᕐ(ɽ̹(聵(}ѽ̈聉Սl}ѽ̉t}م͔9(ͅ}ͽɍͅ}ͽɍ(ѕ}չЈ聉Սlѕ}չЉt(ɥ}}}͐ɥ(}͐聍а(((ɕ}х̀(չم(Ё}مȁЁɽ}م(͔ɕ(ɽlͅ}ͽɍtɕѕȁɽ܁ɽ̤(͔ᅍ}ѽȈ((ѕ}ɥ}م(͕Ց}}}͐́9(ȁ(йɥ(ȁЁ͕(}}Ʌ}}СФ(((ɕɸ(ɕ}х̈聵ɕ}х̰(ͽɍ}є耠(Aɽ٥ȁ́ͅѡɥхѥٔᅍЁѽȁչ́䁽Ѽ(ɕɅ܁ѕՅչɕՍѥ́ͅչم((ɥ}ɕ聉ɥ̤(ѽх̈(չ}չЈ聱͕}ݽɭ}չ̤(}ѽ̈ѽх}}ѽ́}م͔9(ɽ}ѽ̈ɕѕ}ɽ}ѽ́ɽ}م͔9(ɽ}ѽ}ͽɍ耉ɕѕɽ}م͔չم(}͐耠(Сѽх}}͐ɥ́}م͔9((ɕ耉UM((}ɽ̰(չɥ}̈չɥ(ՑЈ͕}Ց}(ѽх}}ѽ̰(Сѽх}}͐ɥ́}م͔9(ɕ}م}مѕ}ɥ}م((((}Ց}(͕(}ѽ聥а(}聙Ё9((ɕ}م聉QՔ(mȰt(ѽ}Ѐ͕Ց}}}ѽ(}Ѐ͕Ց}}}͐(ɕեɕ}م􁵕ɕ}م(}Ё́9ȁ}Ё́Ё9((ፕ􁉽(ɕեɕ}م(ѽ}Ё́Ё9}ѽ̀ѽ}Ф(Ȁ}Ё́Ё9}Ё́Ё9}Ѐ􁍽}Ф(((ѽ}Ё́Ё9ȁ}Ё́Ё9(ɕɸ(聕(}}ѽ̈ѽ}а(}}͐聍}а(}}ѽ̈}ѽ́ɕ}م͔9(}}͐}Ёɕեɕ}م͔9(ɕ}}ѽ̈耠(ѽ}Ѐ}ѽ̤(ѽ}Ё́Ё9ɕ}م(͔9((ɕ}}͐耠(ɽչ}Ѐ}Фؤ(}Ё́Ё9}Ё́Ё9ɕեɕ}م(͔9((ፕ聕ፕ(ɕ}х̈耉ɕɕեɕ}م͔չم(ɍ}х̈耠(}չمЁɕեɕ}م(͔ፕፕ(͔ݥѡ}ՑЈ((((Ց}х̡͕mȰt( ɕЁՑЁхє̰аɕፕ(ݥѠ͕}Ց}}(}ѽ͕̀}Ց}}}ѽ(}Ѐ􁙱С͕}Ց}}}͐(ѕ}ɥ}م(͕Ց}}}͐́9(ȁ(й͕ɥ}}(ȁЁ͕(}}Ʌ}}СФ(((ɕ}م(Ё͕}Ց}չم}չ}́ѕ}ɥ}م((ɕɸ͕}Ց}(}ѽ̰(}Ё͕ɥ}}͔9(ɕ}مɕ}م(((ѥ}͹͡С͕}չ聑mȰmȰut99mȰt(Iɸͽɍ-A$ѥ́ɽչѥхє(չ͕̀}ѕ}ݽɭ}չ̠(Սѕ}չ̀mոȁոչ́չlt􀉍ՍЉt(Ʌ}ѕ}չЀմāȁոՍѕ}չ͕́}}Ʌ}єո(}ͅ}չЀմāȁոչ͕́}}}ͅ}ոո(ٕ}չ̀ չѕȡٕlٕ}tȁٕЁ͕}ѥ}ٕ̤(Ս͙ձ}}ɕՕ̀մ((ȁٕЁ͕}ѥ}ٕ(ٕlٕ}t􀉍}ѥ}ɕՕѕ(ٕlٕ}хtРх}((ɽѕ}չЀմāȁոչ́չltɽє(Ս}չЀմāȁոչ́չlt􀉍ՍЈ(ѕ}չЀմչlɅtȁոչ̤(ɽ٥}፱ͥ}͕̀մ͕}ɽ٥}፱ͥ}}չСոȁոչ̤(}ɥ͕}}}ɥ䡱}չ́ȁ((ɕɸ(ɕ}х̈耉}չѥ}͹͡Ј(ͽɍ}є耉5ɥ́ɔɕɽѡ́ɽ́չѥЁɽՍѥѕ丈(ٕ}չ̈聑Сͽѕٕ}չ̹ѕ̠(̈l((ɥ}耉ѥ}}ѥ(耉 ѥA$ѥ(مՔՍ͙ձ}}ɕՕ̰(չЈ耉Ս͙ձ}ɕՕ̈(ͽɍ耉}ѥ}ɕՕѕٕ̈(((ɥ}耉Ʌ}ѕ}ݽɭ}Ʌє(耉QɅєݽɭ܁Ʌє(յɅѽȈɅ}ѕ}չа(ѽȈ聱Սѕ}չ̤(مՕ}ɍЈ͕}ɍСɅ}ѕ}չаՍѕ}չ̤(ͽɍ耉ݽɭ}չ́ՍЁɅ̈(((ɥ}耉}ͅ}ɽѥ}Ʌє(耉AͅɽѥɅє(յɅѽȈ}ͅ}չа(ѽȈ聱չ̤(مՕ}ɍЈ͕}ɍС}ͅ}չаչ̤(ͽɍ耉ݽɭ}չ́͹̈͡((t(ɥٕ̈l((ɥ}耉ɽѕ}ٕ}Ս}(耉Iє̵ٕՍЁ(չ̈ɽєɽѕ}չаՍЈ聍Ս}չ(ͽɍ耉ݽɭ}չ́(((ɥ}耉مՅѥ}ɕ}ͅ(耉مՅѥɕͅ(مՔ聕ٕ}չ̹РمՅѥ}չ}ɕѕ(չЈ耉չ̈(ͽɍ耉مՅѥ}չ}ɕѕٕ̈(((ɥ}耉}ѡ}ٕɅ(耉ЁѠٕɅ(յɅѽȈ聱mЁȁЁ͕́ййй͕}ɱt(ѽȈ聱͕̤(مՕ}ɍЈ͕}ɍР(mЁȁЁ͕́ййй͕}ɱt(͕̤((ͽɍ耉ЁɅѥ((t(ՅɑɅ̈l((ɥ}耉ɽ٥}፱ͥ}}Ʌє(耉Aɽ٥ȁ፱ͥ́Ʌє(مՔɽ٥}፱ͥ}͕̰(ѽȈѕ}չа(مՕ}ɍЈ͕}ɍСɽ٥}፱ͥ}͕̰ѕ}չФ(ͽɍ耉ݽɭ܁ɅЁ͕ѥ̈(((ɥ}耉}}ɥ䈰(耉1ɥ䈰(}ɥ(ͽɍ耉չ̈((t(((ͅ}ɕ}ɕР(͕(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(mȰt(Iɸ٥̵ͅɕ́єȁѕɥ̸͔(ѥ͕̀ѥ}͹͡С}չ}չ̤(}хє͕}хє(չ͕̀}ѕ}ݽɭ}չ̠(Սѕ}չ̀mոȁոչ́չlt􀉍ՍЉt(Ʌ}ѕ}չЀմāȁոՍѕ}չ͕́}}Ʌ}єո(ٕ}չ̀􁅹ѥlٕ}չ̉t(ɥѕɥl(͕}ɥѕɥ(}ѥ䈰(=$ѥA$(ٕ̈}չ̹Р}ѥ}ɕՕѕ͔݅ɸ(ٕ}չ̹Р}ѥ}ɕՕѕ􁍽ѥЁɕՕ́ɕɑ(IոĽнѥ́͵ѕЁɔѕɥ͔مՅѥ((͕}ɥѕɥ(}٥(=Ʌѽȁ٥ə(̈}хѕl̉t}хѕlt͔(}хѕl̝t􁅝̰}хѕlɕ}Ց}ٕ̝tՑЁٕ͕́(͔Ё䰁ՑЁхєɔͥѥѡɽՍЁ͕́((͕}ɥѕɥ(Ʌ}٥(]ɭ܁Ʌ٥(̈Ʌ}ѕ}չЀ͔݅ɸ(Ʌ}ѕ}չ􁍽єՍѕɅ́ɽ́Սѕ}չ̥􁍽Սѕչ̈(IոՍеݽɭ܁ͼ̵Ёٕɥȁ٥ɔ٥ͥ((͕}ɥѕɥ(مՅѥ}ɕ䈰(مՅѥɕ䈰(ٕ̈}չ̹РمՅѥ}չ}ɕѕ͔݅ɸ(ٕ}չ̹РمՅѥ}չ}ɕѕمՅѥɕչ́ɕɑ(IոЁЁمՅѥɕ䁉ɔѽȵЁɕ٥ܸ((͕}͕ɥ}ɕ}ɥѕɥ͕ɥ}ɽȁ(͕}ɥѕɥ(ѥ}ѡձ̈(ѥ́ѡձ̈(̈ѥlɕ}х̉t􀉱}չѥ}͹͡Ј͔(ѥlͽɍ}єt(1ɥ́́ɽ͕ѥ́չ́䁵ɕչѥѕ丈((͕}}ɕ}ɥѕɥѥ̤(͕}ɽ٥}ɕ}ɥѕɥ(t(յ͕}ɥѕɥ}յ䡍ɥѕɥ(ɕ}յ̈յl̉t݅ɸյl݅ɸtյlu(յlt(ɕ}х̀􀉹}ɕ(յl݅ɸt(ɕ}х̀}ɕ}ݥѡ}݅ɹ̈(͔(ɕ}х̀ͅ}ɕ((ɕɸ(ɕ}х̈ɕ}х̰(ɕ}х̈耉}չѥ}͹͡Ј(ͽɍ}є耠(Ḿɕ͕́́ѡ́ɽ̵չѥɅѥ(յхѥ٥쁥Ё́ЁɽՍѥѥє((յɕ}յ(ɕ}յɕ}յ(ɥѕɥ聍ɥѕɥ(((ɍ}ɕ}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(mȰt(Iɸɥѕɕ́єȁمՔѕɥ̸͔ͅ(ͅ}ɕ͕̀ͅ}ɕ}ɕР(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ѥ͕̀ѥ}͹͡С}չ}չ̤(ͅ}ɽ͕̀}ɥѕɥ}}ͅ}ɕlɥѕɥt(ѥ}ՅɑɅ͕̀}ɥ}}ѥlՅɑɅ̉t(յхѥ͕}ɍ}յхѥ}ɽ(͕ɥ}ɽ͕ɥ}ɽȁ(}ͅ}ɥ͕}ɥ}}ѥl̉tl}ͅ}ɽѥ}Ʌєt(ɽ٥}ɥ􁅹ѥ}ՅɑɅlɽ٥}፱ͥ}}Ʌєt(}ɥ􁅹ѥ}ՅɑɅl}}ɥt((ɥѕɥl(͕}ɥѕɥ(ɽՍ}}٥(AɽՍЁ䁕٥(̈ͅ}ɕlɕ}х̉tͅ}ɕ䈁͔݅ɸ((ͅ}ɕͅ}ɕlɕ}х̝u쀈(ͅ}ɕlɕ}յul̝úͅɥѕɥͥ((Iͽ̵ٔͅɕ́݅ɹ́ɔɕ͕ѥѡɽՍЁȁمՔɕ٥ܸ((͕}ɥѕɥ(͕ɥ}}}ɽ(Mɥ䁅́ɽ(̈(ͅ}ɽl͕ɥ}ɔulх̉ẗ(ͅ}ɽlɽ٥}ɕ}ͅulх̉ẗ(͔((ͅ}ɽl͕ɥ}ɔul٥u쀈(ͅ}ɽlɽ٥}ɕ}ͅul٥u((-Ёɕѽ̰ɥمєձ̰Ʌ̰ͅɽ٥ȁɕ̸((͕}ɥѕɥ(Ʌѥ}ɕͥ(=Ʌѥɕͥ(̈(С͕ɥ}ɽРɅѕ}}ɕՕ̈Ȁ(С͕ɥ}ɽР}ɕ}չ̈Ȁ(}ͅ}ɥРمՕ}ɍЈ(͔݅ɸ((Ʌѕ}}ɕՕ͕ɥ}ɽРɅѕ}}ɕՕ̜쀈(}ɕ}չ͕ɥ}ɽР}ɕ}չ̜쀈(}ͅ}ɽѥ}Ʌє}ͅ}ɥРمՕ}ɍМ((AՉ͠ɽՍѥM1=̰䰁Ёչ́ɔɽՍѥͅ((͕}ɥѕɥ(Ց}}}٥(ՑЁ٥(̈(ͅ}ɽlɅ}٥ulх̉ẗ(ɽ٥}ɥРمՔ(͔݅ɸ((ͅ}ɽlɅ}٥ul٥u쀈(ɽ٥}፱ͥ}͕ɽ٥}ɥРمՔ(( ɔѽȵ́ɕ́ፕѥ́ɥЁɑ((͕}ɥѕɥ(}Օ}}Ј( ȁՔЈ(̈Ёյхѥlͥ}յ̉t͔݅ɸ((푽յхѥlɕ͕}չНu푽յхѥlɕեɕ}չНuɕեɕյ́ɕ͕쀈(ͥ윰յхѥlͥ}յ̝tȀ(( єI5͕ɥ䰁A$ѥ̰ɽՍаɍɕ́յ̸((͕}ɥѕɥ(}}ѥ(MЁѥ(̈}ɥРمՕ}ɍЈյхѥl}͕ɥ}t͔݅ɸ((}}ɥ}ɥРمՕ}ɍМ쀈(͕ɥ}푽յхѥl}͕ɥ}u((--ɕ͠Ʌѽȁ䁅Չ͠Ёݹ͡ȁѽȁɅѥ̸((͕}ɥѕɥ(ɍ}مՕ}͔( ɍمՔ͔(̈хɝ}Ʌ}مՕ}܀U1Q} =55I %1}QIQ}Y1U}-I\͔݅ɸ((хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}쀈(مՔ͔͕́ѥA$٥ɽɕ䰁ՑЁɽ̈((ȁمՔ́ͅɕ٥܁Ё-I\ȰȁȁݥѠȵI=$٥((t(յ͕}ɥѕɥ}յ䡍ɥѕɥ(ɍ}յ̈յl̉t݅ɸյl݅ɸtյlu(ɍ}յlt(ɍ}х̀􀉹}ɍ}ɕ(ɍ}յl݅ɸt(ɍ}х̀􀉍ɍ}ɕ}ݥѡ}݅ɹ̈(͔(ɍ}х̀􀉍ɍ}ɕ((ɕɸ(ɍ}х̈聍ɍ}х̰(хɝ}Ʌ}مՕ}܈хɝ}Ʌ}مՕ}ܰ(хɝ}Ʌ}مՕ}聘-I\хɝ}Ʌ}مՕ}(ɕ}х̈耉}Օ}}͹͡Ј(ͽɍ}є耠( ɍɕ͕́́ɽ̵չѥɕͥѽ䁑յхѥ(͕ɥ䁍Ʌѥѥ́٥쁥Ё́ЁمՅѥՅɅѕ(ɍ͔ѵаȁɽՍѥѥє((յ聍ɍ}յ(ɍ}յ聍ɍ}յ(ɥѕɥ聍ɥѕɥ(յхѥ聑յхѥ(ͅ}ɕ̈ͅ}ɕ̰(((ɍ}٥}}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(mȰt(Iɸѡ٥ȁɍɕ́ɕ٥ܸ(ɍ͕ɍ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ѥ͕̀ѥ}͹͡С}չ}չ̤(ɍ}ɽ͕̀}ɥѕɥ}}ɍlɥѕɥt(ɽЀAѠ}}}|ɕͽٔɕlt((}ѠȤ(ɕɸɽЀѠ}((ѕ̀l(͕}}٥}ѕ(ɽՍ}͍(AɽՍЁ͍(Ȉ(lI5̽ɽՍ}̽ɍ}ɕ̹t(ɕͥѽ}ѥЈ(ɕ䈁}ѠȁѠI5̽ɽՍ}̽ɍ}ɕ̹͔(Mѕɥ͔ɍɅѥɽ́յѕ(-ɽՍЁ͍չȁȁɕ٥ܸ((͕}}٥}ѕ(ѥ}ɕ}( ѥɕA$(Aљɴɕ٥ݕȈ(lĽнѥ̈̽ɕ}}ͥѕ̽ѕ}}Ʌйt(ɕͥѽ}ѥЈ(ɕ䈁}̽ɕ}}ͥ}ѕ̽ѕ}}Ʌй䈤͔(=$ѥЁA$ɅЁѕ́ɔɕ͕и(IѽɔA$ɅЁ́ѕ́ɔȁɕ٥ܸ((͕}}٥}ѕ(}٥}ɽ}(٥ɽ(AљɴɅѽȈ(lхє͍̽ɕ}ͥt(ɕͥѽ}ѥЈ(ɕ䈁}͍̽ɕ}͔ͥ(͍ɕͥչѥхєЁɔɕ͕и(Iѽɔ٥ͥɔȁɕ٥ܸ((͕}}٥}ѕ(ͅ}ɕ̈(Ḿɕ̈(AɽՍЁݹȈ(lĽͅ}ɕ̽ѕЈѕ̽ѕ}ͅ}ɕ̹t(ɕ}(ɕ䈁ɍlͅ}ɕ̉ulɕ}յult͔(ͅ}ɕ퍽ɍlͅ}ɕ̝ulɕ}х̝u(Iͽ̵ٔͅɕ́ɕ́ɔɍɕ٥ܸ((͕}}٥}ѕ(ɍ}ɕ̈( ɍɕ̈(Ȉ(lĽɍ}ɕ̽ѕЈѕ̽ѕ}ɍ}ɕ̹t(ɕ}(ɕ䈁ɍlɍ}յult͔(ɍ}х퍽ɍlɍ}х̝u(Iͽٔɍɕ́ɕ́ɔȁɕ٥ܸ((͕}}٥}ѕ(ѥ}䈰(ѥ́䈰(ѥ́ɕ٥ݕȈ(lĽѥ}͹̽͡ѕЈ̽ѥ}t(ɕ}(ɕ䈁ѥlɕ}х̉t􀉱}չѥ}͹͡Ј͔(ѥlͽɍ}єt(-ɕ٥͕ɅєɽɽՍѥ-A$ɽ̸ͅ((͕}}٥}ѕ(}}٥(̵Ё٥(Mɥ䁅ɕ٥ݕȈ(lĽ}ɕ̽ݽɭ}չ}􈰀̽ɽՍ}t(ɕͥѽ}ѥЈ(ɕ䈁}̽ɽՍ}͔(]ɭ܁Ʌ̵ɕЁ٥ɔյѕ(Iѽɔ̵Ё٥́ɔɕ٥ܸ((͕}}٥}ѕ(مՅѥ}ɕ䈰(مՅѥɕ䈰(EՅɕ٥ݕȈ(lĽمՅѥ}չ͍̈̽ɕ}ͥt(ɕͥѽ}ѥЈ(ɕ䈁}͍̽ɕ}͔ͥ(مՅѥɕə́յѕ(IѽɔمՅѥɕ䁑́ɔՅɕ٥ܸ((͕}}٥}ѕ(͕ɥ}ɔ(Mɥɔ(Mɥɕ٥ݕȈ(lM UI%Qdѕ̽ѕ}͕ɥ}ɑ䈰 E0ɕ٥܈Qɥt(ɕ}(ɕ䈁ɍ}ɽl͕ɥ}}}ɽulх̉ẗ͔(ɍ}ɽl͕ɥ}}}ɽul٥t(Iͽٔɕє͕ɥ䁙ɕ́ɔȁɕ٥ܸ((͕}}٥}ѕ(٥Յ}х}٥(YՅхȁ٥(Mхȁɕ٥ݕȈ(l̽}ѥ̹ͥ)ɐḾt(}ѥЈ(ɕ䈁}̽}ѥ̹͔(х)Ḿѥ́ɔɕɑ(Iɐхѥ́ɔхȁɕ٥ܸ((͕}}٥}ѕ(}}Ј( ȁЈ(AɽɕЁɕ٥ݕȈ(l̽ɍ}}}йt(ɕͥѽ}ѥЈ(ɕ䈁}̽ɍ}}}й͔( ȁՕѥ́Ѽ٥ѡ̸ٕ́(IѽɔѡȁЁɔɽɕЁɕ٥ܸ((͕}}٥}ѕ(}х}չ( ȁхչ(AɽɕЁɕ٥ݕȈ(l̽ɍ}}х}չt(ɕͥѽ}ѥЈ(ɕ䈁}̽ɍ}}х}չ͔(݅ɹձ́ɔյѕ(IѽɔхչɔɽɕЁɕ٥ܸ((͕}}٥}ѕ(}٥}Ј( ȁ٥Ј(ݹȈ(l̽ɍ}}٥}йĽɍ}٥}̽ѕЉt(ɕ}(ɕ䈁}̽ɍ}}٥}й͔( ȁ٥́ᕐ䁽ݹȰͽɍ٥ѥхє(IѽɔѡЁյЁЁɔȁɕ٥ܸ((͕}}٥}ѕ(}ͥ(Aͥ(AɽɕЁ͕ɥɕ٥ݕȈ(l̽Ʌ}ɕ͕ɍ̽ɍ}՝}Ʌѥ}t(ɕͥѽ}ѥЈ(ɕ䈁}̽Ʌ}ɕ͕ɍ}̽ɍ}՝}Ʌѥ}͔(Mɕ光ɽՍЁɕѡɕЁͥ(յЁɅѥɥ́ɔչɥ̸((͕}}٥}ѕ(ɽՍѥ}ͱ}Ј(AɽՍѥM1<Ёɽ( ѽȁɅѥ́ɕ٥ݕȈ(lɽՍѥѕ䈰Ёɥɕɑ̈Ёݹ͡t(ɽ͕}չѥ}ɽՍѥ(݅ɹ(AɽՍѥM1<аЁ٥ɕեɔ啐ѽȁ٥ɽи( ЁɽՍѥѕ䁑ɥɑ((͕}}٥}ѕ(}}ɽ}( ȵI=$ɽ(ȁɽɕЈ(lI=$Օѥɔфɽͥѕɵ̈Ёt(ɽ͕}չѥ}}(݅ɹ(I=$ɽɕа嵕Ё٥ɕեɔȸ( Ёȵ́ɥչЁ((t(յ͕}}}յ䡥ѕ̤(յl}ѥ}хєtР(}х̀􀉉}ɕ٥}(յl}ѥ}хєtР݅ɹ(}х̀􀉉}ɕ٥}ɕ}ݥѡ}݅ɹ̈(͔耀Ʌ聹ٕȀչɕݡѡ́ɕЁɥ́ѕɅȵ݅ɹ͕ѥ(}х̀􀉉}ɕ٥}ɕ䈀Ʌ聹ٕ((ɕɸ(}х̈聵}х̰(хɝ}Ʌ}مՕ}܈хɝ}Ʌ}مՕ}ܰ(хɝ}Ʌ}مՕ}聘-I\хɝ}Ʌ}مՕ}(ɕ}х̈耉}}٥}Ј(ͽɍ}є耠( ȁ٥Ё́ɽ̵չѥɕ̰ɕͥѽ䁑յ̰(ѥЁɕɑ̰ЁɽՍѥȁȵٕ쁥Ё́Ё(مՅѥՅɅѕɍ͔ѵаȁɽՍѥѥє((յյ(ѕ̈聥ѕ̰(ɕѕ}չѥ}ɕ̈(ɍ}х̈聍ɍlɍ}х̉t(ͅ}ɕ}х̈聍ɍlͅ}ɕ̉ulɕ}х̉t(ѥ}ɕ}х̈聅ѥlɕ}х̉t((((ɍ}}չ}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(mȰt(Iɸѡɍչȁͅɕ́٥(Ѐ͕ɍ}٥}}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((}յ􁵅lյul}ѥ}хєt(ɽЀAѠ}}}|ɕͽٔɕlt((}ѠȤ(ɕɸɽЀѠ}((չѥ}хє􀉉}յ九Р͔ɕ(Ց}ѥ̀l(͕}}٥}ѕ(չѥ}ɕ̈(Iչѥɕ̈(ݹȈ(l(Ľͅ}ɕ̽ѕЈ(Ľɍ}ɕ̽ѕЈ(Ľɍ}٥}̽ѕЈ(Ľѥ}͹̽͡ѕЈ(t(ɕ}(չѥ}хє((}}хl}х̝u쀈(ɍ}хlɕѕ}չѥ}ɕ̝ulɍ}х̝u((IͽٔչѥɕЁ́ɔȁ((͕}}٥}ѕ(ɕͥѽ}Ј(IͥѽЈ(AɽɕЁɕ٥ݕȈ(l(I5(̽ɍ}}}й(̽ɍ}}х}չ(̽ɍ}}٥}й(̽ɍ}}}չ(t(ɕͥѽ}ѥЈ(ɕ((}Ѡ(ȁѠ(I5(̽ɍ}}}й(̽ɍ}}х}չ(̽ɍ}}٥}й(̽ɍ}}}չ(((͔( ȵхаյ́ɔɕ͕и(IѽɔͥȁЁյ́ɔɽɕЁɕ٥ܸ((͕}}٥}ѕ(}х}ѥ̈(хȁѥ̈(Mхȁɕ٥ݕȈ(l̽}ѥ̹ͥ)ɐḾt(}ѥЈ(ɕ䈁}̽}ѥ̹͔(х)Ḿѥ́ɔɕɑݥѡЁ и(Iɐххȁѥ́ɔȁ((͕}}٥}ѕ(ٕɥѥ}̈(Yɥѥ̈(Qɕ٥ݕȈ(l(ѕ̽ѕ}}}չ䈰(ѕ̽ѕ}}٥}й䈰(ѕ̽ѕ}՝}ɥٕ}ѥ̹䈰(ѕ̽ѕ}}Ʌй䈰(ѕЀĈ(t(ɕ}(ɕ((}Ѡ(ȁѠ(ѕ̽ѕ}}}չ䈰(ѕ̽ѕ}}٥}й䈰(ѕ̽ѕ}՝}ɥٕ}ѥ̹䈰(ѕ̽ѕ}}Ʌй䈰(((͔(͕ɅЁѕ́ձѕЁٕɥѥɔȁȁɕ٥ܸ(Iѽɔ͕ѕ́ɔѕȁ((͕}}٥}ѕ(}ͥ(Aͥ(AɽɕЁ͕ɥɕ٥ݕȈ(l̽Ʌ}ɕ͕ɍ̽ɍ}՝}Ʌѥ}t(ɕͥѽ}ѥЈ(ɕ䈁}̽Ʌ}ɕ͕ɍ}̽ɍ}՝}Ʌѥ}͔(Mɕͥѽ䁅光ɽՍЁɕѡɕЁͥ(=䁕ɅЁɅ䁅ѕȁ͕ɽՍаЁɕ͔ȁɽٕɥȁ̸((t(}}ѕ̀l(͕}}٥}ѕ(ɽՍѥ}}ɕ̈(AɽՍѥɕ̈( ѽȁɅѥ́ɕ٥ݕȈ(lɽՍѥM1<ЁɥЁɽф嵕Ёѽt(ɽ͕}չѥ}ɽՍѥ(݅ɹ(AɽՍѥM1<а嵕аЁ٥ɕեɔٔѽȁ٥ɽи( ЁɽՍѥѕ䁅Ё٥ɥɑ((͕}}٥}ѕ(}}ɍ}͔( ȵɍ͔(ȁɕ٥ݕȈ(lI=$Օѥɔфɽͥѕɵ̈Ёt(ɽ͕}չѥ}}(݅ɹ(I=$ɽɕа嵕Ёѵ́ɕեɔȸ( Ёȵ́ɥչЁ((t(}ѕ̀􁥹Ց}ѥ̀}}ѕ(յ͕}}}յ䡅}ѕ̤(յl}ѥ}хєtР(չ}х̀􀉉}}(յl}ѥ}хєtР݅ɹ(չ}х̀􀉉}}ɕ}ݥѡ}݅ɹ̈(͔耀Ʌ聹ٕȀչɕݡѡ́ɕЁɥ́ѕɅȵ݅ɹ͕ѥ(չ}х̀􀉉}}ɕ䈀Ʌ聹ٕ((ɕɸ(չ}х̈聉չ}х̰(хɝ}Ʌ}مՕ}܈хɝ}Ʌ}مՕ}ܰ(хɝ}Ʌ}مՕ}聘-I\хɝ}Ʌ}مՕ}(ɕ}х̈耉}}}չ(ͽɍ}є耠( ȁչ́չѥɕ̰ɕͥѽ䁑յ̰(ѥЁɕɑ̰ٕɥѥ̰ЁɽՍѥȀ(ȵٕ쁥Ё́ЁمՅѥՅɅѕɍ͔ѵа(ȁɽՍѥѥє((յյ(Ց}ѥ̈聥Ց}ѥ̰(}}ѕ̈聙}}ѕ̰(х}ѕ̈l((ѕ}耉(ձ耉Ցѥ́ɕє͕ɥ䁍́ٔɔ(((ѕ}耉݅ɹ(ձ耉ɽՍѥȁȵ٥ɕ́ɽ͕ѱ䁍ٕѕ(((ѕ}耉(ձ耉͕ɥ䁙ɔA$ɅЁɕɕͥյЁ͵эɽՍЁаȁ Ёͅ((t(ɕѕ}չѥ}ɕ̈(}}х̈聵l}х̉t(lɕѕ}չѥ}ɕ̉t((Ʌ}}ͥ(ͥ耉}ͥ}ɽՍЈ(ɕͽ耉9͕ɽՍаЁɕ͔ȁ͕ɥɽٕɥȁ̸(ݕ}ɕ}ɥ̈l(͕ɽՍЁɕեɕ́ɔ䈰(Ёɕ͔́(ȁ͕ɥɽٕɕեɕ́Ʌѥ(t((՝}Ʌ(耉ххȁѥ́)ݽɭ܈(ɽՍ}ͥ耉ȁə٥ݽɭ܈(ݕ̈耉хѥٕɥѥЈ(х耉ͥɽՍЁ܁䈰(х}ѥ̈耉ɕٕ́ɽ͕٥͕Ʌѥ((((}٥}}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(mȰt(IɸѡɕѕЁ́ȁѥAѡյ̸(ɕɸ͕ɍ}٥}}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ(((}}չ}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(mȰt(Iɸѡɕѕ́ȁѥAѡյ̸(ɕɸ͕ɍ}}չ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ(((ͅ}ͥ}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(mȰt(Iɸѡȵͅ䁑ͥȁمՔɕ٥ܸ(͕ɍ}}չ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ(( ́Ё͡Ʌѽȵɕѥ聑ݹɕ(ɕ́ɕ́єɥѕȁ́٥(йɽ́ݡɅ́͡չ͡٥ѕ̸(ɕѕ}̀l(ѕlѕ}t(ȁѕlՑ}ѥ̉t(ѕlѥ}хєt􀉉(t(݅ɹ}ѥ̀l(ѕ(ȁѕl}}ѕ̉t(ѕlѥ}хєt݅ɹ(t(ɕѕ}(ͅ}х̀ͅ}(ͥ} 䁍ɕєЈ(݅ɹ}ѥ(ͅ}х̀ͅ}ɕ}ݥѡ}݅ɹ̈(ͥ}I䁙ȁȁݥѠЁ݅ɹ̈(͔耀Ʌ聹ٕȀչɕݡܵ݅ɹ́ɔѕɅɕЁ͕ѥ(ͅ}х̀ͅ}ɕ䈀Ʌ聹ٕ(ͥ}I䁙ȁȁɅ聹ٕ((ɕɸ(ͅ}х̈ͅ}х̰(ͥ}聑ͥ}(хɝ}Ʌ}مՕ}܈хɝ}Ʌ}مՕ}ܰ(хɝ}Ʌ}مՕ}聘-I\хɝ}Ʌ}مՕ}(ɕ}х̈耉}ͅ}ͥ(ͽɍ}є耠(M䁑ͥ́ȁՔє͕չѥ(ɕ̰ɕͥѽ䁑յ̰ѥ̰ٕɥѥ̰(Ёٕ쁥Ё́ЁمՅѥՅɅѕɍ͔ѵа(ȁɽՍѥѥє((ͥ}յ(Ց}ѥ}չЈ聱lՑ}ѥ̉t(}չЈ聱ɕѕ}̤(݅ɹ}չЈ聱݅ɹ}ѥ̤(ɕ٥}ɽ}}Ȉ͔((ͥ}ͥ̈l((ͥ}耉}}չ(х̈聡lչ}х̉t(ͽɍ耈Ľɍ}}չ̽ѕЈ(((ͥ}耉}٥}Ј(х̈聡lɕѕ}չѥ}ɕ̉ul}}х̉t(ͽɍ耈Ľɍ}٥}̽ѕЈ(((ͥ}耉ɍ}ɕ̈(х̈聡lɕѕ}չѥ}ɕ̉ulɍ}х̉t(ͽɍ耈Ľɍ}ɕ̽ѕЈ(((ͥ}耉ͅ}ɕ̈(х̈聡lɕѕ}չѥ}ɕ̉ulͅ}ɕ}х̉t(ͽɍ耈Ľͅ}ɕ̽ѕЈ((t(ɕѕ}̈聍ɕѕ}̰(݅ɹ}ѥ̈݅ɹ}ѥ̰(ɕ٥}ɽ}(}Ȉ͔(}}ᅵ̈l(ɕ٥ݕȁ䈰(ɕ٥܁Ё䈰(ՕՕɕ٥܈(ݥѡЁɕєɔ(t(}ѥ耉ɕє͕ɥ䰁A$ɅаյаȁɽՍЁЈ((ɕѕ}չѥ}ɕ̈(}}х̈聡lչ}х̉t(lɕѕ}չѥ}ɕ̉t((Ʌ}}ͥ聡lɅ}}ͥt(՝}Ʌ聡l՝}Ʌt(((ɍ}٥}}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(mȰt(IɸхȁՔЁȁɍɕ٥ܸ(͕ͅͅ}ͥ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ɽЀAѠ}}}|ɕͽٔɕlt((}ѠȤ(ɕɸɽЀѠ}((ɕѕ}̀ͅlɕѕ}̉t(ɕեɕ}ѕɹ}٥l((٥}聥ѕlѕ}t(聥ѕlt(ɕ٥ݕȈ聥ѕlɕ٥ݕȉt(ͽɍ̈聥ѕlͽɍ̉t(٥}聥ѕl٥}t(٥聥ѕl٥t(}ѥ聥ѕl}ѥt((ȁѕͅl݅ɹ}ѥ̉t(t(ͅ}хє􀉉ͅlͅ}х̉tͅ}͔ɕ(}͕ѥ̀l(͕}}٥}ѕ(ͅ}ͥ(M䁑ͥ(ݹȈ(lĽͅ}ͥ̽ѕЈ̽ɍ}ͅ}ͥt(ɕ}(ͅ}хє(ͅ}хͅlͅ}х̝u(Iͽٔɕєͅ䁉́ɔѥȁ٥((͕}}٥}ѕ(չѥ}ɕ̈(Iչѥɕ̈(Qɕ٥ݕȈ(l(Ľͅ}ɕ̽ѕЈ(Ľɍ}ɕ̽ѕЈ(Ľɍ}٥}̽ѕЈ(Ľɍ}}չ̽ѕЈ(Ľͅ}ͥ̽ѕЈ(Ľѥ}͹̽͡ѕЈ(t(ɕ}(ɕѕ}͔́ɕ䈰((}}хͅlɕѕ}չѥ}ɕ̝ul}}х̝u쀈(}}хͅlɕѕ}չѥ}ɕ̝ul}}х̝u((Iͽٔչѥɕ́ɔȁи((͕}}٥}ѕ(}}յ̈( ȁЁյ̈(AɽɕЁɕ٥ݕȈ(l(̽ɍ}}}й(̽ɍ}}х}չ(̽ɍ}}٥}й(̽ɍ}}}չ(̽ɍ}ͅ}ͥ(̽ɍ}٥}й(t(ɕͥѽ}ѥЈ(ɕ((}Ѡ(ȁѠ(̽ɍ}}}й(̽ɍ}}х}չ(̽ɍ}}٥}й(̽ɍ}}}չ(̽ɍ}ͅ}ͥ(̽ɍ}٥}й(((͔( ȁхаͥЁյ́ɔɕ͕и(IѽɔͥȁЁյ́ɔи((͕}}٥}ѕ(}х}ѥ̈(хȁѥ̈(Mхȁɕ٥ݕȈ(l̽}ѥ̹ͥ)ɐḾt(}ѥЈ(ɕ䈁}̽}ѥ̹͔(ххȁѥ́ɔɕɑ Ё́፱Ց(Iɐѥ́ɔѥȁ٥((͕}}٥}ѕ(ٕɥѥ}̈(Yɥѥ̈(Qɕ٥ݕȈ(l(ѕ̽ѕ}ɍ}٥}й䈰(ѕ̽ѕ}ͅ}ͥ䈰(ѕ̽ѕ}՝}ɥٕ}ѥ̹䈰(ѕ̽ѕ}}Ʌй䈰(ѕЀĈ(t(ɕ}(ɕ((}Ѡ(ȁѠ(ѕ̽ѕ}ɍ}٥}й䈰(ѕ̽ѕ}ͅ}ͥ䈰(ѕ̽ѕ}՝}ɥٕ}ѥ̹䈰(ѕ̽ѕ}}Ʌй䈰(((͔(͕ɍаͅ䰁՝ѥаA$ɅЁѕ́ɔ(Iѽɔ͕ѕ́ɔȁи((͕}}٥}ѕ(ɕ٥}ɽ}䈰(I٥܁ɽ́䈰(ݹȈ(l̽ɍ}ͅ}ͥĽͅ}ͥ̽ѕЉt(ɕͥѽ}ѥЈ(ɕ䈰(I٥ݕȁ䰁ɕ٥܁Ё䰁ՕՕɕ٥܁ɔЁɕє̸(͍є䁍ɕє͕ɥ䰁A$ɅаյаȁɽՍЁ̸((͕}}٥}ѕ(}ͥ(Aͥ(AɽɕЁ͕ɥɕ٥ݕȈ(l̽Ʌ}ɕ͕ɍ̽ɍ}՝}Ʌѥ}t(ɕͥѽ}ѥЈ(ɕ䈁}̽Ʌ}ɕ͕ɍ}̽ɍ}՝}Ʌѥ}͔(ͅlɅ}}ͥulɕͽt(=䁕ɅЁɅ䁅ѕȁ͕ɽՍаЁɕ͔ȁɽٕɥȁ̸((t(}͕ѥ}յ͕}}}յ䡕}͕ѥ̤(}չЀ}͕ѥ}յl}ѥ}хєultɕѕ}̤(݅ɹ}չЀ􁱕ɕեɕ}ѕɹ}٥(}չ(}х̀􀉍ɍ}}(݅ɹ}չ(}х̀􀉍ɍ}}ɕ}ݥѡ}݅ɹ̈(͔耀Ʌ聹ٕȀչɕݡѡ́ɕЁɥ́ѕɅȵ݅ɹ͕ѥ(}х̀􀉍ɍ}}ɕ䈀Ʌ聹ٕ((ɕɸ(}х̈聕}х̰(хɝ}Ʌ}مՕ}܈хɝ}Ʌ}مՕ}ܰ(хɝ}Ʌ}مՕ}聘-I\хɝ}Ʌ}مՕ}(ɕ}х̈耉}ɍ}٥}Ј(ͽɍ}є耠( ɍ٥Ё́չѥ̰ͥɕͥѽ䁑յ̰(ѥЁɕɑ̰ٕɥѥ̰ɕ٥ܵɽ́䰁ͥ(ЁɽՍѥȁȵ٥쁥Ё́ЁمՅѥՅɅѕ(ɍ͔ѵаȁɽՍѥѥє((}յ(͕ѥ}չЈ聱}͕ѥ̤(}չЈ聉}չа(݅ɹ}չЈ݅ɹ}չа(ɕ٥}ɽ}}Ȉͅlɕ٥}ɽ}ul}ȉt((}͕ѥ̈聕}͕ѥ̰(ɕեɕ}ѕɹ}٥ɕեɕ}ѕɹ}٥(ɕѕ}̈聍ɕѕ}̰(ɕ٥}ɽ}ͅlɕ٥}ɽ}t(ɕѕ}չѥ}ɕ̈(ͅ}х̈ͅlͅ}х̉t(ͅlɕѕ}չѥ}ɕ̉t((Ʌ}}ͥͅlɅ}}ͥt(՝}Ʌͅl՝}Ʌt(}̈(}ͥ}耉輽ܹͥi5]!Ii9](}ɐ耉輽ܹɐ]5M!!MA4(չѥ}Ј耈Ľɍ}٥}̽ѕЈ(յхѥ耉̽ɍ}٥}й((((ɍ}х}}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(mȰt(Iɸѡȁхٕȁѡɍ٥и(٥}Ѐ͕ɍ}٥}}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ɽЀAѠ}}}|ɕͽٔɕlt((}ѠȤ(ɕɸɽЀѠ}((ɕѕ}̀٥}lɕѕ}̉t(}٥}l}х̉t􀉍ɍ}}(չѥ}хє􀉉}ȁɕѕ}͔́ɕ(х}ѕ̀l(͕}}٥}ѕ(չѥ}}(IչѥЁ(Qɕ٥ݕȈ(l(Ľѥ}͹̽͡ѕЈ(Ľͅ}ɕ̽ѕЈ(Ľɍ}ɕ̽ѕЈ(Ľɍ}٥}̽ѕЈ(Ľɍ}}չ̽ѕЈ(Ľͅ}ͥ̽ѕЈ(Ľɍ}٥}̽ѕЈ(t(ɕ}(չѥ}хє(ɍ}}х٥}l}х̝u(IͽٔչѥɕЁɔȁх((͕}}٥}ѕ(}}յ̈( ȁЁյ̈(AɽɕЁɕ٥ݕȈ(l(̽ɍ}}}й(̽ɍ}}х}չ(̽ɍ}}٥}й(̽ɍ}}}չ(̽ɍ}ͅ}ͥ(̽ɍ}٥}й(̽ɍ}х}(t(ɕͥѽ}ѥЈ(ɕ((}Ѡ(ȁѠ(̽ɍ}}}й(̽ɍ}}х}չ(̽ɍ}}٥}й(̽ɍ}}}չ(̽ɍ}ͅ}ͥ(̽ɍ}٥}й(̽ɍ}х}(((͔( ȁЁյٕ́ȁхаͥа(IѽɔͥȁЁյ́ɔȁх((͕}}٥}ѕ(}Ʌѽ}ə(Ʌѽȁə(AљɴɅѽȈ(lѕՅ}ɍɅѽȽ䈰Ľɍ}х}̽ѕЉt(ɕͥѽ}ѥЈ(ɕ䈁}ѕՅ}ɍɅѽȽ䈤͔(͕مə͕́ѡɍхх́ݥѠՅ̸(͔хх͕́م䁉ɔȁх((͕}}٥}ѕ(ٕɥѥ}٥(Yɥѥ٥(Qɕ٥ݕȈ(l(ѕ̽ѕ}ɍ}х}䈰(ѕ̽ѕ}ɍ}٥}й䈰(ѕ̽ѕ}ͅ}ͥ䈰(ѕ̽ѕ}՝}ɥٕ}ѥ̹䈰(ѕ̽ѕ}}Ʌй䈰(ѕЀĈ(t(ɕ}(ɕ((}Ѡ(ȁѠ(ѕ̽ѕ}ɍ}х}䈰(ѕ̽ѕ}ɍ}٥}й䈰(ѕ̽ѕ}ͅ}ͥ䈰(ѕ̽ѕ}՝}ɥٕ}ѥ̹䈰(ѕ̽ѕ}}Ʌй䈰(((͔(͕ɍхаͅ䰁՝ѥаA$ɅЁѕ́ɔ(Iѽɔ͕ѕ́ɔȁх((͕}}٥}ѕ(}х}ѥ̈(хȁѥ̈(Mхȁɕ٥ݕȈ(l̽}ѥ̹ͥ)ɐḾt(}ѥЈ(ɕ䈁}̽}ѥ̹͔(ххȁѥ́ɔɕɑ Ё́፱Ց(Iɐхѥ́ɔȁх((͕}}٥}ѕ(ɕ٥}ɽ}䈰(I٥܁ɽ́䈰(ݹȈ(l̽ɍ}ͅ}ͥĽͅ}ͥ̽ѕЉt(ɕͥѽ}ѥЈ(ɕ䈰(I٥ݕȁ䰁ɕ٥܁Ё䰁ՕՕɕ٥ܰ́ݥѡЁɕєɔɔЁ̸( 䁽ɕє͕ɥ䰁A$ɅаյаȁɽՍЁ̸((͕}}٥}ѕ(}ͥ(Aͥ(AɽɕЁ͕ɥɕ٥ݕȈ(l̽Ʌ}ɕ͕ɍ̽ɍ}՝}Ʌѥ}t(ɕͥѽ}ѥЈ(ɕ䈁}̽Ʌ}ɕ͕ɍ}̽ɍ}՝}Ʌѥ}͔(٥}lɅ}}ͥulɕͽt(=䁕ɅЁɅ䁅ѕȁ͕ɽՍаЁɕ͔ȁɽٕɥȁ̸((t(}}ѕ̀l(͕}}٥}ѕ(ѕl٥}t(ѕlt(ѕlɕ٥ݕȉt(ѕlͽɍ̉t(ѕl٥}t(݅ɹ(ѕl٥t(ѕl}ѥt((ȁѕ٥}lɕեɕ}ѕɹ}٥t(t(}ѕ̀􁅍х}ѕ̀}}ѕ(յ͕}}}յ䡅}ѕ̤(}չЀյl}ѥ}хєultɕѕ}̤(݅ɹ}չЀյl}ѥ}хєul݅ɹt(}չ(х}х̀􀉍ɍ}х}(݅ɹ}չ(х}х̀􀉍ɍ}х}ɕ}ݥѡ}݅ɹ̈(͔耀Ʌ聹ٕȀչɕݡѡ́ɕЁɥ́ѕɅȵ݅ɹ͕ѥ(х}х̀􀉍ɍ}х}ɕ䈀Ʌ聹ٕ((ɕɸ(х}х̈聅х}х̰(хɝ}Ʌ}مՕ}܈хɝ}Ʌ}مՕ}ܰ(хɝ}Ʌ}مՕ}聘-I\хɝ}Ʌ}مՕ}(ɕ}х̈耉}ɍ}х}(ͽɍ}є耠( ɍхمՅѕ́ɍ٥а٥ͥ䰀(ɕͥѽаѥ̰ٕɥѥ̰ɕ٥ܵɽ́䰁(ͥЁɽՍѥȁȵ쁥Ё́ЁمՅѥՅɅѕ(ɍ͔ѵаȁɽՍѥѥє((х}յ(ѕ}չЈ聱}ѕ̤(}չЈ聉}չа(݅ɹ}չЈ݅ɹ}չа(ɕ٥}ɽ}}Ȉ聕٥}lɕ٥}ɽ}ul}ȉt((х}ѕ̈聅х}ѕ̰(}}ѕ̈聙}}ѕ̰(ɕѕ}̈聍ɕѕ}̰(ɕեɕ}ѕɹ}٥聕٥}lɕեɕ}ѕɹ}٥t(х}ѕ̈l((ѕ}耉(ձ耉хѕ́ɕեɕѕɹ٥̈(((ѕ}耉݅ɹ(ձ耉ɽՍѥȁȵ٥ɕ́ѱ䁍ٕѕ(((ѕ}耉(ձ耉͕ɥ䁙ɔA$ɅЁɕɕͥյЁ͵эɽՍЁаȁ Ёͅ((t(ɕ٥}ɽ}聕٥}lɕ٥}ɽ}t(ɕѕ}չѥ}ɕ̈(ɍ}}х̈聕٥}l}х̉t(٥}lɕѕ}չѥ}ɕ̉t((Ʌ}}ͥ聕٥}lɅ}}ͥt(՝}Ʌ聕٥}l՝}Ʌt(х}̈(}ͥ}耉輽ܹͥi5]!Ii9](}ɐ耉輽ܹɐ]5M!!MA4(չѥ}Ј耈Ľɍ}х}̽ѕЈ(յхѥ耉̽ɍ}х}((((ɍ}ɕ͕}ѕ}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(ɕ͕}ѡɥ5mȰt99(mȰt(IɸɽՍЁ٥͕Ʌѕ䁙ɽɽѕѕɕ͔ѡɥ丈(х͕ɍ}х}}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ɽЀAѠ}}}|ɕͽٔɕlt((}ѠȤ(ɕɸɽЀѠ}((ɕѕ}̀􁅍хlɕѕ}̉t(х}􁅍хlх}х̉t􀉍ɍ}х}(չѥ}хє􀉉х}ȁɕѕ}͔́ɕ(ɕ͕}ѡɥѥمՅѕ}ɕ͕}ѡɥѥɕ͕}ѡɥ(ɕ͕}ѥ̀l(͕}}٥}ѕ(ɍ}х}( ɍх(ݹȈ(lĽɍ}х}̽ѕЈ̽ɍ}х}t(ɕ}(չѥ}хє(х}х텍хlх}х̝u(Iͽٔх́ɔхɕ͔є((͕}}٥}ѕ(չѥ}}(IչѥЁ(Qɕ٥ݕȈ(l(Ľѥ}͹̽͡ѕЈ(Ľͅ}ɕ̽ѕЈ(Ľɍ}ɕ̽ѕЈ(Ľɍ}٥}̽ѕЈ(Ľɍ}}չ̽ѕЈ(Ľͅ}ͥ̽ѕЈ(Ľɍ}٥}̽ѕЈ(Ľɍ}х}̽ѕЈ(Ľɍ}ɕ͕}ѕ̽ѕЈ(t(ɕ}(չѥ}хє( ɍɕ͔єЁ́ѕȁхаͥаɕ̰ѥ́ɕ̸(IѽɔչѥЁ٥ɔɕ͔є((͕}}٥}ѕ(ɕͥѽ}ɥѥ}Ј(Iͥѽ䁑ɥѥЈ(AɽɕЁɕ٥ݕȈ(l(I5(̽ɕ}}ͥ(̽ɍ}}}й(̽ɍ}}х}չ(̽ɍ}}٥}й(̽ɍ}}}չ(̽ɍ}ͅ}ͥ(̽ɍ}٥}й(̽ɍ}х}(̽ɍ}ɕ͕}є(t(ɕͥѽ}ѥЈ(ɕ((}Ѡ(ȁѠ(I5(̽ɕ}}ͥ(̽ɍ}}}й(̽ɍ}}х}չ(̽ɍ}}٥}й(̽ɍ}}}չ(̽ɍ}ͅ}ͥ(̽ɍ}٥}й(̽ɍ}х}(̽ɍ}ɕ͕}є(((͔(IͥѽЁх́ѡI5IMPA$ɅЁѕ̰ɍȁյ̸(Iѽɔͥɥѥյ́ɔȁɕ͔єɕ٥ܸ((͕}}٥}ѕ(͕ɥ}}хф(Mɥ䁅хф(Mɥɕ٥ݕȈ(l(1% 9M(M UI%Qd(ɽйѽ(ɕեɕ̹(ѡՈݽɭ͕̽ɥ嵰(ѡՈй嵰( ѕՅ]͑1ѡՈɅɕեɕ͕ɥݽɭ̈(t(ɕͥѽ}ѥЈ(ɕ((}Ѡ(ȁѠ(1% 9M(M UI%Qd(ɽйѽ(ɕեɕ̹(ѡՈݽɭ͕̽ɥ嵰(ѡՈй嵰(((͔(1͔͕ɥ䰁хфɕեɕ̰䵍ݽɭܰЁхфɅɕեɕ͕ɥݽɭ́ɔɕ͕и(Iѽɔ͕ͥɥ䁽ȁхфɔɕ͔є((͕}}٥}ѕ(}Ʌѽ}ə(Ʌѽȁə(AљɴɅѽȈ(lѕՅ}ɍɅѽȽ䈰Ľɍ}ɕ͕}ѕ̽ѕЉt(ɕͥѽ}ѥЈ(ɕ䈁}ѕՅ}ɍɅѽȽ䈤͔(͕مə͕́ѡɕ͔єх́ݥѠՅ̸(͔ɕ͔єх͕́م䁉ɔȁ((͕}}٥}ѕ(ٕɥѥ}٥(Yɥѥ٥(Qɕ٥ݕȈ(l(ѕ̽ѕ}ɍ}ɕ͕}є䈰(ѕ̽ѕ}ɍ}х}䈰(ѕ̽ѕ}ɍ}٥}й䈰(ѕ̽ѕ}ͅ}ͥ䈰(ѕ̽ѕ}՝}ɥٕ}ѥ̹䈰(ѕ̽ѕ}}Ʌй䈰(ѕЀĈ(t(ɕ}(ɕ((}Ѡ(ȁѠ(ѕ̽ѕ}ɍ}ɕ͕}є䈰(ѕ̽ѕ}ɍ}х}䈰(ѕ̽ѕ}ɍ}٥}й䈰(ѕ̽ѕ}ͅ}ͥ䈰(ѕ̽ѕ}՝}ɥٕ}ѥ̹䈰(ѕ̽ѕ}}Ʌй䈰(((͔(͕ɕ͔єхаͅ䰁՝ѥаA$ɅЁѕ́ɔ(Iѽɔ͕ٕɥѥɔɕ͔є((͕}}٥}ѕ(}х}ѥ̈(хȁѥ̈(Mхȁɕ٥ݕȈ(l̽}ѥ̹ͥ)ɐḾt(}ѥЈ(ɕ䈁}̽}ѥ̹͔(ххȁѥ́ɔɕɑ Ё́፱Ց(Iɐхѥ́ɔȁɕ͔єɕ٥ܸ((͕}}٥}ѕ(ɕ٥}ɽ}䈰(I٥܁ɽ́䈰(ݹȈ(l̽ɍ}ͅ}ͥ̽ɍ}ɕ͕}єt(ɕͥѽ}ѥЈ(ɕ䈰(AɽՍЁ٥ɕ́хݡɽѕѕɕ͔ѡɥ䁥́مՅѕ͕Ʌѕ丈(M䁄ɕ͠ɽѕѕѡɥ͹͡Ёɔѡɥ饹ɕ͔((͕}}٥}ѕ(ɕ͕}ѡɥ}ѽȈ(Aɽѕѕѡɥ䁍ѽȈ(I͔ݹȈ(l͍ɥ̽ɕ͕}ѡɥ}͹͡й䈰̽ѽɥɕ͔ѡɥѥt(ɕͥѽ}ѥЈ(ɕ䈁}͍ɥ̽ɕ͕}ѡɥ}͹͡й䈤͔(I䁝A$ѽȁ́́ɕ٥́ѼѡᅍЁձɕՕЁݥѡЁѥ͕ɕ̸(IոѡѽȁݥѠѡᅍЁєM!х́)M=8͹͡ЁѼɕ͔ɕ٥ܸ((͕}}٥}ѕ(}ͥ(Aͥ(AɽɕЁ͕ɥɕ٥ݕȈ(l̽Ʌ}ɕ͕ɍ̽ɍ}՝}Ʌѥ}t(ɕͥѽ}ѥЈ(ɕ䈁}̽Ʌ}ɕ͕ɍ}̽ɍ}՝}Ʌѥ}͔(хlɅ}}ͥulɕͽt(=䁕ɅЁɅ䁅ѕȁ͕ɽՍаЁɕ͔ȁɽٕɥȁ̸((t(ѕɹ}ɕ͕}̀l(͕}}٥}ѕ(ѕlѕ}t(ѕlt(ѕlɕ٥ݕȉt(ѕlͽɍ̉t(ѕl٥}t(݅ɹ(ѕl٥t(ѕl}ѥt((ȁѕхl}}ѕ̉t(t(յ͕}}}յɕ͕}ѥ̀ѕɹ}ɕ͕}̤(ɽՍ}}չЀյl}ѥ}хєultɕѕ}̤(݅ɹ}չЀյl}ѥ}хєul݅ɹt(ɽՍ}٥}х̀(ɍ}ɕ͕}(ɽՍ}}չ(͔ɍ}ɕ͕}ɕ}ݥѡ}݅ɹ̈(хl}}ѕ̉t(͔ɍ}ɕ͕}ɕ((ɕ͕}}չЀɽՍ}}չЀɕ͕}ѡɥѥl̉t(ɕ͕}}չ(ɕ͕}х̀􀉍ɍ}ɕ͕}(݅ɹ}չ(ɕ͕}х̀􀉍ɍ}ɕ͕}ɕ}ݥѡ}݅ɹ̈(͔耀Ʌ聹ٕȀչɕݡѡ́ɕЁɥ́ѕɅȵ݅ɹ͕ѥ(ɕ͕}х̀􀉍ɍ}ɕ͕}ɕ䈀Ʌ聹ٕ((ɕɸ(ɕ͕}х̈ɕ͕}х̰(ɽՍ}٥}х̈ɽՍ}٥}х̰(ɕ͕}ѡɥѥɕ͕}ѡɥѥ(хɝ}Ʌ}مՕ}܈хɝ}Ʌ}مՕ}ܰ(хɝ}Ʌ}مՕ}聘-I\хɝ}Ʌ}مՕ}(ɕ}х̈耉}ɍ}ɕ͕}є(ͽɍ}є耠( ɍɕ͔є́хչѥ̰ɕͥѽ䀈(ɥѥյ̰͕ɥ䁵хф٥ͥ䰁ٕɥѥ̰(ѥЁɕɑ̰ɕ٥ܵɽ́䰁ͥЁѕɹ(ɕ͔쁥Ё́ЁمՅѥՅɅѕɍ͔ѵаȁɽՍѥ(ѥє((ɕ͕}յ(ѥ}չЈ聱ɕ͕}ѥ̤(}չЈɕ͕}}չа(ɽՍ}}չЈɽՍ}}չа(݅ɹ}չЈ݅ɹ}չа(ɕ͕}ѡɥ}}չЈ聱ɕ͕}ѡɥѥl̉t((ɕ͕}ѥ̈ɕ͕}ѥ̰(ѕɹ}ɕ͕}̈聕ѕɹ}ɕ͕}̰(ɕѕ}̈聍ɕѕ}̰(ɕ͕}ѕ̈l((ѕ}耉(ձ耉չѥЁɕͥѽа͕ɥ䁵хфəѕ̰ѥ̰ɕ٥܁䰁ͥɔɕ͕Ј(((ѕ}耉݅ɹ(ձ耉ɽՍѥȁȵѕɹ٥ɕ́ѱ䁍ٕѕ(((ѕ}耉(ձ耉͕ɥ䁙ɔA$ɅЁɕɕͥͥɥѥѥаյЁ͵эɽՍЁаȁ Ёͅ((t(ɕ٥}ɽ}聅хlɕ٥}ɽ}t(ɕѕ}չѥ}ɕ̈(ɍ}х}х̈聅хlх}х̉t(хlɕѕ}չѥ}ɕ̉t((Ʌ}}ͥ聅хlɅ}}ͥt(՝}Ʌ聅хl՝}Ʌt(ɕ͕}̈(}ͥ}耉輽ܹͥi5]!Ii9](}ɐ耉輽ܹɐ]5M!!MA4(չѥ}Ј耈Ľɍ}ɕ͕}ѕ̽ѕЈ(յхѥ耉̽ɍ}ɕ͕}є((((ɍ}}ɕѕ}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(ɕ͕}ѡɥ5mȰt99(mȰt(IɸݹȽѥɕѕȁȁɍɕ͔є̸(ɕ͔͕ɍ}ɕ͕}ѕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ(ɕ͕}ѡɥɕ͕}ѡɥ((ɕѕ}̀ɕ͕lɕѕ}̉t(ɕ͕}ɕ͕lɕ͕}х̉t􀉍ɍ}ɕ͕}(}ѕ̀mt(ȁѕɕ͕lѕɹ}ɕ͕}̉t(ͽɍ}ѕl٥}t(ͽɍ}ɽ͕}չѥ}ɽՍѥ(}х̀ɽՍѥ}}ɕեɕ(}ɽՍѥ}٥}(ݹȀ=Ʌѥ́ЁݹȈ(͔(}х̀􀉉}}ɕեɕ(}􀉉}}(ݹȀ ȁݹȈ(}ѕ̹(}聥ѕlѕ}t(聥ѕlt(}聝}(}х̈聝}х̰(ݹȈ聽ݹȰ(ɕ٥ݕȈ聥ѕlɕ٥ݕȉt(ͽɍ̈聥ѕlͽɍ̉t(ͽɍ}٥}ͽɍ}(ɕ}٥聥ѕl٥t(ɕեɕ}Ј聥ѕl}ѥt(}Ȉ͔(((ɕ͕}ѡɥ}̀ɕ͕lɕ͕}ѡɥѥul̉t(ɽՍ}}չЀɕ͕lɕ͕}յulɽՍ}}չЉt(}չЀ(İɽՍ}}չЀɕ͕}ѡɥ}̤(ɕ͕}(͔ɕѕ}̤((}չ(}ɕѕ}х̀􀉍ɍ}}ɕѕ}(}ѕ(}ɕѕ}х̀􀉍ɍ}}ɕѕ}(͔耀Ʌ聹ٕȀչɕݡѡ́ɕЁɥ́ѕɅȵ݅ɹ͕ѥ(}ɕѕ}х̀􀉍ɍ}}ɕѕ}ȈɅ聹ٕ((ɽՍѥ}}չЀմāȁѕ}ѕ́ѕl}tɽՍѥ}٥}(}}}չЀմāȁѕ}ѕ́ѕl}t􀉉}}(ɕɸ(}ɕѕ}х̈聝}ɕѕ}х̰(хɝ}Ʌ}مՕ}܈хɝ}Ʌ}مՕ}ܰ(хɝ}Ʌ}مՕ}聘-I\хɝ}Ʌ}مՕ}(ɕ}х̈耉}ɍ}}ɕѕȈ(ͽɍ}є耠( ɍɕѕȁٕ́ɕ͔є݅ɹ́ѼݹȰѥ(ͽɍɕեɕЁɽ́ȁȁՔ쁥Ё́ЁمՅѥՅɅѕ(ɍ͔ѵаȁɽՍѥѥє((}յ(ѽх}}չЈ聱}ѕ̤(ɽՍѥ}}չЈɽՍѥ}}չа(}}}չЈ聉}}}չа(}չЈ聉}չа(ɕ͕}ѡɥ}}չЈ聱ɕ͕}ѡɥ}̤((}ѕ̈聝}ѕ̰(ɕѕ}̈聍ɕѕ}̰(ɕ͕}ѡɥѥɕ͕lɕ͕}ѡɥѥt(}х}ձ̈l((}х̈耉ɽՍѥ}}ɕեɕ(ձ耉ɽՍѥ嵕ааM1<ȁɅѥ٥ЁɔɽՍѥ(((}х̈耉}}ɕեɕ(ձ耉ȵɽɕаI=$ȁ嵕ЁѕЁЁɔȵ(((}х̈耉(ձ耉ɕє͕ɥ䰁A$ɅаյаɽՍЁаȁ Ё́ͅɍɕ͔((t(ɕ٥}ɽ}ɕ͕lɕ٥}ɽ}t(ɕѕ}չѥ}ɕ̈(ɍ}ɕ͕}х̈ɕ͕lɕ͕}х̉t(ɕ͕}ѡɥѥ}х̈ɕ͕lɕ͕}ѡɥѥulх̉t(ɕ͕lɕѕ}չѥ}ɕ̉t((Ʌ}}ͥɕ͕lɅ}}ͥt(՝}Ʌɕ͕l՝}Ʌt(}ɕѕ}̈(}ͥ}耉輽ܹͥi5]!Ii9](}ɐ耉輽ܹɐ]5M!!MA4(չѥ}Ј耈Ľɍ}}ɕѕ̽ѕЈ(յхѥ耉̽ɍ}}ɕѕȹ((((ɍ}ɽɕ}ɕ}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(ɕ͕}ѡɥ5mȰt99(mȰt(Iɸɽɕнɕ́єٕȁɍ٥(}ɕѕȀ͕ɍ}}ɕѕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ(ɕ͕}ѡɥɕ͕}ѡɥ((ɽЀAѠ}}}|ɕͽٔɕlt((}ѠȤ(ɕɸɽЀѠ}((}}х̀ѕl}х̉t聥ѕȁѕ}ɕѕl}ѕ̉u(ɽՍѥ}􁝅}}х̹РɽՍѥ}}ɕեɕ(}􁝅}}х̹Р}}ɕեɕ(ɕѕ}̀􁝅}ɕѕlɕѕ}̉t(ɕ͕}ѡɥѥ􁝅}ɕѕlɕ͕}ѡɥѥt(ɕ͕}ѡɥ}̀ɕ͕}ѡɥѥl̉t(ɽɕ}ѕ̀l((ѕ}耉͕}}ɥ̈(耉1͔ɥ̈(ݹȈ耉AɽɕЁɕ٥ݕȈ(ͽɍ̈l1% 9Mɽйѽt(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ䈁}1% 9M}ɽйѽ͔(٥耉5%P͔хфɔɕ͕Ёȁȁɥ́ɕ٥ܸ(ɕեɕ}Ј耉Iѽɔ͔ȁхфɔɽɕЁɕ٥ܸ(((ѕ}耉͕ɥ}}хф(耉Mɥхф(ݹȈ耉Mɥɕ٥ݕȈ(ͽɍ̈l(M UI%Qd(ɕեɕ̹(ѡՈݽɭ͕̽ɥ嵰(ѡՈй嵰( ѕՅ]͑1ѡՈɅɕեɕ͕ɥݽɭ̈(t(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ((}Ѡ(ȁѠ(M UI%Qd(ɕեɕ̹(ѡՈݽɭ͕̽ɥ嵰(ѡՈй嵰(((͔(٥耉Mɥ䰁̰䵍ݽɭܰЁхфɅɕեɕ͕ɥݽɭ́ɔɕ͕и(ɕեɕ}Ј耉Iѽɔ͕ͥɥ䁵хфɔɽɕЁɕ٥ܸ(((ѕ}耉ɥѥ}Ј(耉ɥѥЈ(ݹȈ耉ݹȈ(ͽɍ̈l(I5(̽ɕ}}ͥ(̽ɍ}ɕ͕}є(̽ɍ}}ɕѕȹ(t(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ((}Ѡ(ȁѠ(I5(̽ɕ}}ͥ(̽ɍ}ɕ͕}є(̽ɍ}}ɕѕȹ(((͔(٥耉Iͥѽ䁽ٕ٥ܰIMPɅаɕ͔єɕѕȁյ́ɔɕ͕и(ɕեɕ}Ј耉Iѽɔͥɥѥյ́ɔɽɕЁɕ٥ܸ(((ѕ}耉}٥}ə(耉٥ə(ݹȈ耉AљɴɅѽȈ(ͽɍ̈lѕՅ}ɍɅѽȽ䈰Ľɍ}ɽɕ}ɕ̽ѕЉt(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ䈁}ѕՅ}ɍɅѽȽ䈤͔(٥耉͕مə͕́ɽɕЁɕ́ݥѠՅ̸(ɕեɕ}Ј耉͔ɽɕЁɕ͕́م䁉ɔȁɕ٥ܸ(((ѕ}耉ɽՍѥ}}ͱ}Ј(耉AɽՍѥЁM1<Ј(ݹȈɽՍѥ}lݹȉtɽՍѥ}͔=Ʌѥ́ЁݹȈ(ͽɍ̈ɽՍѥ}lͽɍ̉tɽՍѥ}͔l̽ɍ}}ɕѕȹt(٥}耉ɽ͕}չѥ}ɽՍѥ(ѥ}хє耉݅ɹɽՍѥ}͔ɕ䈰(ͽɍ}}х̈ɽՍѥ}l}х̉tɽՍѥ}͔ɕͽٕ(٥ɽՍѥ}lɕ}٥tɽՍѥ}͔9ɽՍѥ٥́(ɕեɕ}ЈɽՍѥ}lɕեɕ}ЉtɽՍѥ}͔9ɽՍѥЁɕեɕ(((ѕ}耉}}ɽ}ɽɕ}Ј(耉 ȁI=$ɽɕЁЈ(ݹȈ聉}lݹȉt}͔ ȁݹȈ(ͽɍ̈聉}lͽɍ̉t}͔l̽ɍ}}ɕѕȹt(٥}耉ɽ͕}չѥ}}(ѥ}хє耉݅ɹ}͔ɕ䈰(ͽɍ}}х̈聉}l}х̉t}͔ɕͽٕ(٥聉}lɕ}٥t}͔9ȵ٥́(ɕեɕ}Ј聉}lɕեɕ}Љt}͔9ȁЁɕեɕ(((ѕ}耉ɕ٥}ɽ}䈰(耉I٥܁ɽ́䈰(ݹȈ耉ݹȈ(ͽɍ̈l̽ɍ}ͅ}ͥ̽ɍ}ɽɕ}ɕ̹t(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ䈰(٥耉I٥ݕȁ䰁ɕ٥܁Ё䰁ՕՕɕ٥ܰ́ݥѡЁɕєɔɔЁ̸(ɕեɕ}Ј耉 䁽ɕє͕ɥ䰁A$ɅаյаȁɽՍЁ̸(((ѕ}耉}ͥ(耉Aͥ(ݹȈ耉AɽɕЁ͕ɥɕ٥ݕȈ(ͽɍ̈l̽Ʌ}ɕ͕ɍ̽ɍ}՝}Ʌѥ}t(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ䈁}̽Ʌ}ɕ͕ɍ}̽ɍ}՝}Ʌѥ}͔(٥聝}ɕѕlɅ}}ͥulɕͽt(ɕեɕ}Ј耉=䁕ɅЁɅ䁅ѕȁ͕ɽՍаЁɕ͔ȁɽٕɥȁ̸((t(хѕ}չ̀ չѕȡѕlѥ}хєtȁѕɽɕ}ѕ̤(ɽՍѥ}}չЀāɽՍѥ}͔(}}}չЀā}͔(}չЀхѕ}չ̹Рɕѕ}̤(݅ɹ}չЀхѕ}չ̹Р݅ɹ(}չ(ɽɕ}х̀􀉍ɍ}ɽɕ}(݅ɹ}չ(ɽɕ}х̀􀉍ɍ}ɽɕ}ɕ}ݥѡ}݅ɹ̈(͔耀Ʌ聹ٕȀչɕݡѡ́ɕЁɥ́ѕɅȵ݅ɹ͕ѥ(ɽɕ}х̀􀉍ɍ}ɽɕ}ɕ䈀Ʌ聹ٕ((ɕɸ(ɽɕ}х̈ɽɕ}х̰(хɝ}Ʌ}مՕ}܈хɝ}Ʌ}مՕ}ܰ(хɝ}Ʌ}مՕ}聘-I\хɝ}Ʌ}مՕ}(ɕ}х̈耉}ɍ}ɽɕ}ɕ̈(ͽɍ}є耠( ɍɽɕЁɕ͔͕́́ɥ䰁ɥѥ(ɕѕȰɕ٥ܵɽ̰٥ȁȁՔ쁥Ё́Ѐ(مՅѥՅɅѕɍ͔ѵаȁɽՍѥѥє((ɽɕ}յ(ѕ}չЈ聱ɽɕ}ѕ̤(ɕ}չЈхѕ}չ̹Рɕ䈰(݅ɹ}չЈ݅ɹ}չа(}չЈ聉}չа(ɽՍѥ}}չЈɽՍѥ}}չа(}}}չЈ聉}}}չа(ɕ٥}ɽ}}Ȉ聝}ɕѕlɕ٥}ɽ}ul}ȉt(ɕ͕}ѡɥ}}չЈ聱ɕ͕}ѡɥ}̤((ɽɕ}ѕ̈ɽɕ}ѕ̰(ɕѕ}̈聍ɕѕ}̰(ɕ͕}ѡɥѥɕ͕}ѡɥѥ(ɽɕ}х}ձ̈l((ɽɕ}х̈耉ɍ}ɽɕ}ɕ䈰(ձ耉͔͕ɥ䰁ɥѥаI=$ɕ٥ܰ٥ɔɕ䈰(((ɽɕ}х̈耉ɍ}ɽɕ}ɕ}ݥѡ}݅ɹ̈(ձ耉Ё́ɕݡɽՍѥȁȵ́ɕЁ݅ɹ̈(((ɽɕ}х̈耉ɍ}ɽɕ}(ձ耉ͥЁ٥ɕєɽՍЁаA$ɅЁɔյЁ͵э͕ɥ䁙ɔȁ Ё́ͅɽɕЈ((t(ɕ٥}ɽ}聝}ɕѕlɕ٥}ɽ}t(ɕѕ}չѥ}ɕ̈(ɍ}}ɕѕ}х̈聝}ɕѕl}ɕѕ}х̉t(}ɕѕlɕѕ}չѥ}ɕ̉t((Ʌ}}ͥ聝}ɕѕlɅ}}ͥt(՝}Ʌ聝}ɕѕl՝}Ʌt(ɽɕ}̈(}ͥ}耉輽ܹͥi5]!Ii9](}ɐ耉輽ܹɐ]5M!!MA4(չѥ}Ј耈Ľɍ}ɽɕ}ɕ̽ѕЈ(յхѥ耉̽ɍ}ɽɕ}ɕ̹((((ɍ}Ʌ}ɕ}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(ɕ͕}ѡɥ5mȰt99(mȰt(IɸɅеɕ́єٕȁɽɕЁ٥(ɽɕЀ͕ɍ}ɽɕ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ(ɕ͕}ѡɥɕ͕}ѡɥ((ɽЀAѠ}}}|ɕͽٔɕlt((}ѠȤ(ɕɸɽЀѠ}((ɽɕ}}ѕlѕ}t聥ѕȁѕɽɕlɽɕ}ѕ̉u(͕}ѕɽɕ}}l͕}}ɥ̉t(͕ɥ}ѕɽɕ}}l͕ɥ}}хфt(}ѕɽɕ}}lɽՍѥ}}ͱ}Љt(}ѕɽɕ}}l}}ɽ}ɽɕ}Љt(}ѕɽɕ}}l}ͥt(ɕѕ}̀ɽɕlɕѕ}̉t(ɕ͕}ѡɥѥɽɕlɕ͕}ѡɥѥt(ɕ͕}ѡɥ}̀ɕ͕}ѡɥѥl̉t(}ͱ}}չЀā}ѕlѥ}хєt݅ɹ͔(}ɑ}ɵ}}չЀā}ѕlѥ}хєt݅ɹ͔(Ʌ}ѕ̀l((ѕ}耉͕}ɍ}ɥ̈(耉1͔ɍɥ́ѕɵ̈(ݹȈ耉1ɕ٥ݕȈ(ͽɍ̈聱͕}ѕlͽɍ̉t(٥}聱͕}ѕl٥}t(ѥ}хє聱͕}ѕlѥ}хєt(٥聱͕}ѕl٥t(ɕեɕ}Ј聱͕}ѕlɕեɕ}Љt(((ѕ}耉͕ɥ}ɥم}ѕɵ̈(耉Mɥ䁅ɥمѕɵ̈(ݹȈ耉Mɥ䁅ɕ٥ݕȈ(ͽɍ̈l͕ɥ}ѕlͽɍ̉t̽ɍ}ɽɕ}ɕ̹t(٥}͕ɥ}ѕl٥}t(ѥ}хє͕ɥ}ѕlѥ}хєt(٥耠(͕ɥ}ѕl٥uIչѥɕ́ɽ͕̀(ѡ}͕ɥ}ɽРѡ}չݸ͕ɥ}ɽ͔չݸ(Չ}͕ɥ}ɽР}Չ}չݸ͕ɥ}ɽ͔չݸ(Ʌɔɽ̸((ɕեɕ}Ј͕ɥ}ѕlɕեɕ}Љt(((ѕ}耉Ց}}ѥ̈(耉ՑЁЁѥ̈(ݹȈ耉 ɕ٥ݕȈ(ͽɍ̈l(Ľɍ}٥}̽ѕЈ(̽ɍ}٥}й(̽ɕ}}ͥ(t(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ((}Ѡ(ȁѠ(̽ɍ}٥}й(̽ɕ}}ͥ(((͔(٥耉 ɍ٥ЁIMPA$ɅЁ͍ɥȵɕՑЁ٥(ɕեɕ}Ј耉Iѽɔ٥Ё́IMPɅЁɔɅЁɕ٥ܸ(((ѕ}耉Ʌ}}̈(耉 ɅЁЁյ̈(ݹȈ耉ݹȈ(ͽɍ̈l(I5(̽ɍ}Ʌ}ɕ̹(̽ɍ}ɽɕ}ɕ̹(̽ɍ}ͅ}ͥ(t(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ((}Ѡ(ȁѠ(I5(̽ɍ}Ʌ}ɕ̹(̽ɍ}ɽɕ}ɕ̹(̽ɍ}ͅ}ͥ(((͔(٥耉 ɅЁаɽɕЁєͅ䁉ȁ䁅ɔյѕ(ɕեɕ}Ј耉IѽɔȁɅЁЁ́ɔɕ٥ܸ(((ѕ}耉}ͱ}ѕɵ̈(耉MЁM1<ѕɵ̈(ݹȈ}ѕlݹȉt(ͽɍ̈}ѕlͽɍ̉t(٥}}ѕl٥}t(ѥ}хє}ѕlѥ}хєt(ͽɍ}}х̈}ѕРͽɍ}}х̈ɕͽٕ(٥}ѕl٥t(ɕեɕ}Ј}ѕlɕեɕ}Љt(((ѕ}耉}ɑ}ɵ}Ј(耉 ȁɑȵɴЈ(ݹȈ聉}ѕlݹȉt(ͽɍ̈聉}ѕlͽɍ̉t(٥}聉}ѕl٥}t(ѥ}хє聉}ѕlѥ}хєt(ͽɍ}}х̈聉}ѕРͽɍ}}х̈ɕͽٕ(٥聉}ѕl٥t(ɕեɕ}Ј聉}ѕlɕեɕ}Љt(((ѕ}耉ɕ٥}ɽ}䈰(耉I٥܁ɽ́䈰(ݹȈ耉ݹȈ(ͽɍ̈l̽ɍ}ͅ}ͥ̽ɍ}Ʌ}ɕ̹t(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ䈰(٥耉I٥܁ɽ́䁥́ЁɅЁȁչ́ɕєɔ́ɽՍ(ɕեɕ}Ј耉 䁽ɕє͕ɥ䰁A$ɅаյаȁɽՍЁ̸(((ѕ}耉}ͥ(耉Aͥ(ݹȈ}ѕlݹȉt(ͽɍ̈}ѕlͽɍ̉t(٥}}ѕl٥}t(ѥ}хє}ѕlѥ}хєt(٥}ѕl٥t(ɕեɕ}Ј}ѕlɕեɕ}Љt((t(хѕ}չ̀ չѕȡѕlѥ}хєtȁѕɅ}ѕ̤(}չЀхѕ}չ̹Рɕѕ}̤(݅ɹ}չЀхѕ}չ̹Р݅ɹ(}չ(Ʌ}х̀􀉍ɍ}Ʌ}(݅ɹ}չ(Ʌ}х̀􀉍ɍ}Ʌ}ɕ}ݥѡ}݅ɹ̈(͔耀Ʌ聹ٕȀչɕݡѡ́ɕЁɥ́ѕɅȵ݅ɹ͕ѥ(Ʌ}х̀􀉍ɍ}Ʌ}ɕ䈀Ʌ聹ٕ((ɕɸ(Ʌ}х̈聍Ʌ}х̰(хɝ}Ʌ}مՕ}܈хɝ}Ʌ}مՕ}ܰ(хɝ}Ʌ}مՕ}聘-I\хɝ}Ʌ}مՕ}(ɕ}х̈耉}ɍ}Ʌ}ɕ̈(ͽɍ}є耠( ɍɅЁɕ͔͕́́ɥɥم䰁ՑЁа(нM1<ȁɑȵɴɕ٥ܵɽ̰٥ȁ(ɽɕЁՔ쁥Ё́ЁمՅѥՅɅѕɍ͔ѵаȀ(ɽՍѥѥє((Ʌ}յ(ѕ}չЈ聱Ʌ}ѕ̤(ɕ}չЈхѕ}չ̹Рɕ䈰(݅ɹ}չЈ݅ɹ}չа(}չЈ聉}չа(}ͱ}}չЈ}ͱ}}չа(}ɑ}ɵ}}չЈ聉}ɑ}ɵ}}չа(ɕ٥}ɽ}}Ȉɽɕlɕ٥}ɽ}ul}ȉt(ɕ͕}ѡɥ}}չЈ聱ɕ͕}ѡɥ}̤((Ʌ}ѕ̈聍Ʌ}ѕ̰(ɕѕ}̈聍ɕѕ}̰(ɕ͕}ѡɥѥɕ͕}ѡɥѥ(Ʌ}х}ձ̈l((Ʌ}х̈耉ɍ}Ʌ}ɕ䈰(ձ耉͔͕ɥɥم䰁ՑнанM1<ȁɑȵɴɕ٥ܰѕɵ́ɔɕ䈰(((Ʌ}х̈耉ɍ}Ʌ}ɕ}ݥѡ}݅ɹ̈(ձ耉ɅЁЁ́ɕݡɽՍѥнM1<ȁȁɑȵɴ́ɕЁ݅ɹ̈(((Ʌ}х̈耉ɍ}Ʌ}(ձ耉ͥɅЁЁ٥ɕєɽՍЁаA$ɅЁɔյЁ͵э͕ɥ䁙ɔȁ Ё́ͅɅЁɕ̈((t(ɕ٥}ɽ}ɽɕlɕ٥}ɽ}t(ɕѕ}չѥ}ɕ̈(ɍ}ɽɕ}х̈ɽɕlɽɕ}х̉t(ɽɕlɕѕ}չѥ}ɕ̉t((Ʌ}}ͥɽɕlɅ}}ͥt(՝}Ʌɽɕl՝}Ʌt(Ʌ}̈(}ͥ}耉輽ܹͥi5]!Ii9](}ɐ耉輽ܹɐ]5M!!MA4(չѥ}Ј耈Ľɍ}Ʌ}ɕ̽ѕЈ(յхѥ耉̽ɍ}Ʌ}ɕ̹((((ɍ}ɑ}ɕ}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(ɕ͕}ѡɥ5mȰt99(mȰt(Iɸɑɕ́єٕȁɅЁ٥(ɅЀ͕ɍ}Ʌ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ(ɕ͕}ѡɥɕ͕}ѡɥ((ɽЀAѠ}}}|ɕͽٔɕlt((}ѠȤ(ɕɸɽЀѠ}((Ʌ}}ѕlѕ}t聥ѕȁѕɅlɅ}ѕ̉u(}ѕ􁍽Ʌ}}l}ͱ}ѕɵ̉t(}ѕ􁍽Ʌ}}l}ɑ}ɵ}Љt(}ѕ􁍽Ʌ}}l}ͥt(ɕѕ}̀􁍽Ʌlɕѕ}̉t(ɕ͕}ѡɥѥ􁍽Ʌlɕ͕}ѡɥѥt(}ͱ}ѥ}չЀā}ѕlѥ}хєt݅ɹ͔(}}ѥ}չЀā}ѕlѥ}хєt݅ɹ͔(ɑ}ѕ̀l((ѕ}耉}}Ј(耉 ȁЈ(ݹȈ耉ݹȈ(ͽɍ̈l(I5(̽ɍ}ɑ}ɕ̹(̽ɍ}Ʌ}ɕ̹(t(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ((}Ѡ(ȁѠ(I5(̽ɍ}ɑ}ɕ̹(̽ɍ}Ʌ}ɕ̹(((͔(٥耉 ȁЁ́ɽՍЁٕ٥ܰɅЁɕ̰ɑ(ѥ耉U͔ѡЁѼхЁɑݥѠȁх̸(}ɥѕɥ耉 ȁɵ́ݹȰɑѕ̰٥ɕ٥܁(((ѕ}耉}ͱ}(耉MЁM1<(ݹȈ}ѕlݹȉt(ͽɍ̈}ѕlͽɍ̉t(٥}}ѕl٥}t(ѥ}хє}ѕlѥ}хєt(ͽɍ}}х̈}ѕРͽɍ}}х̈ɕͽٕ(٥}ѕl٥t(ѥ耉 ЁЁɽф͍ѥѠM1<хɝаЁɥ٥ɥɑ(}ɥѕɥ耉 ȁɅѽȁɽٔЁݹȰɕ͔хɝа͍ѥѠЁЁɥɕɐ(((ѕ}耉}ɑ}ɵ}(耉 ȁɑȵɴ(ݹȈ聉}ѕlݹȉt(ͽɍ̈聉}ѕlͽɍ̉t(٥}聉}ѕl٥}t(ѥ}хє聉}ѕlѥ}хєt(ͽɍ}}х̈聉}ѕРͽɍ}}х̈ɕͽٕ(٥聉}ѕl٥t(ѥ耉 ЁȁɑȵɴI=$Օѥɔ嵕аЁ̸(}ɥѕɥ耉 ȵɑȁɴɽɕЁ́ɔхѼѡи(((ѕ}耉ѕ}ɕ}(耉Q䁍ɔ(ݹȈ耉фѥ́ݹȈ(ͽɍ̈lĽѥ}͹̽͡ѕЈ̽ѥ}t(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ䈁}̽ѥ}͔(٥耉ѥ͕́Ʌѕ́ɕ٥ɽɽ͕ɽՍѥɥ̸(ѥ耉 ɔɽՍѥɑѕݥѡЁ᥹ЁݥѠɽѽɥ̸(}ɥѕɥ耉Ёȁ٥ɽЁɕɑ́ѥѕ䰁ٕɥѥɅѕ̰Ё̸ٕ(((ѕ}耉х}}ɥѕɥ(耉хЁɥѕɥ(ݹȈ耉Qȁɕ٥ݕȈ(ͽɍ̈l(Ľɍ}х}̽ѕЈ(̽ɍ}х}(̽ɍ}}х}չ(t(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ(}̽ɍ}х}(}̽ɍ}}х}չ(͔(٥耉хȁչɕ٥܁ѕ̸(ѥ耉IոѡȁхЁѕȁ٥́х(}ɥѕɥ耉х́ɕє́݅ɹ́ɔѱ䁽ݹ(((ѕ}耉͕ɥ}}(耉Mɥ䁅(ݹȈ耉Mɥ䁅ɕ٥ݕȈ(ͽɍ̈lM UI%Qd̽ɍ}Ʌ}ɕ̹t(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ(}M UI%Qd}̽ɍ}Ʌ}ɕ̹(͔(٥耉Mɥ䁅ɅЁɕ́Ёɔمȁȁ(ѥ耉х͕ɥ䰁䁱ɅЁɕ́ɽ́Ѽȁ(}ɥѕɥ耉 ȁ͕ɥ佱ɕ٥ݕȁ́ѡЁȁ́ɕє̸(((ѕ}耉ɕ٥}ɽ}䈰(耉I٥܁ɽ́䈰(ݹȈ耉ݹȈ(ͽɍ̈l̽ɍ}ͅ}ͥ̽ɍ}ɑ}ɕ̹t(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ䈰(٥耉I٥܁䁥́Ёɑȁչ́ɕєɔ́ɽՍ(ѥ耉 ѥՔɑݽɬݡՕՕɕ٥́ɔ(}ɥѕɥ耉=䁍ɕє͕ɥ䰁A$ɅаյаȁɽՍЁ́ɽɕ̸(((ѕ}耉}ͥ(耉Aͥ(ݹȈ}ѕlݹȉt(ͽɍ̈}ѕlͽɍ̉t(٥}}ѕl٥}t(ѥ}хє}ѕlѥ}хєt(٥}ѕl٥t(ѥ耉-光ѕɥ͔ɽɽՍЁѡɽ՝ɑ(}ɥѕɥ耉ɅЁ䁅ѕȁ͕ɽՍаЁɕ͔ȁȁɽٕɥȁ̸((t(хѕ}չ̀ չѕȡѕlѥ}хєtȁѕɑ}ѕ̤(}չЀхѕ}չ̹Рɕѕ}̤(݅ɹ}չЀхѕ}չ̹Р݅ɹ(}չ(ɑ}х̀􀉍ɍ}ɑ}(݅ɹ}չ(ɑ}х̀􀉍ɍ}ɑ}ɕ}ݥѡ}݅ɹ̈(͔耀Ʌ聹ٕȀչɕݡѡ́ɕЁɥ́ѕɅȵ݅ɹ͕ѥ(ɑ}х̀􀉍ɍ}ɑ}ɕ䈀Ʌ聹ٕ((ɕɸ(ɑ}х̈聽ɑ}х̰(хɝ}Ʌ}مՕ}܈хɝ}Ʌ}مՕ}ܰ(хɝ}Ʌ}مՕ}聘-I\хɝ}Ʌ}مՕ}(ɕ}х̈耉}ɍ}ɑ}ɕ̈(ͽɍ}є耠( ɍɑɕٕ́́ɅЁɽɕЁ݅ɹ́Ѽ(ɑݹ̰ѥ̰Ёɥѕɥ쁥Ё́ЁمՅѥՅɅѕ(ɍ͔ѵаȁɽՍѥѥє((ɑ}յ(ѕ}չЈ聱ɑ}ѕ̤(ɕ}չЈхѕ}չ̹Рɕ䈰(݅ɹ}չЈ݅ɹ}չа(}չЈ聉}չа(}ͱ}ѥ}չЈ}ͱ}ѥ}չа(}}ѥ}չЈ聉}}ѥ}չа(ɕ٥}ɽ}}Ȉ聍Ʌlɕ٥}ɽ}ul}ȉt(ɕ͕}ѡɥ}}չЈ聱ɕ͕}ѡɥѥl̉t((ɑ}ѕ̈聽ɑ}ѕ̰(ɕѕ}̈聍ɕѕ}̰(ɕ͕}ѡɥѥɕ͕}ѡɥѥ(ɑ}х}ձ̈l((ɑ}х̈耉ɍ}ɑ}ɕ䈰(ձ耉анM1<ȁаѕ䰁х͕ɥ佱ɕ٥ܰѥ́ɔɕ䈰(((ɑ}х̈耉ɍ}ɑ}ɕ}ݥѡ}݅ɹ̈(ձ耉ɑ́ɕݡɽՍѥнM1<ȁȁɑȵɴѥ́ɕЁ݅ɹ̈(((ɑ}х̈耉ɍ}ɑ}(ձ耉ͥɑЁ٥ɕєɽՍЁаA$ɅЁɔյЁ͵э͕ɥ䁙ɔȁ Ё́ͅɑ((t(ɕ٥}ɽ}聍Ʌlɕ٥}ɽ}t(ɕѕ}չѥ}ɕ̈(ɍ}Ʌ}х̈聍ɅlɅ}х̉t(Ʌlɕѕ}չѥ}ɕ̉t((Ʌ}}ͥ聍ɅlɅ}}ͥt(՝}Ʌ聍Ʌl՝}Ʌt(ɑ}̈(}ͥ}耉輽ܹͥi5]!Ii9](}ɐ耉輽ܹɐ]5M!!MA4(չѥ}Ј耈Ľɍ}ɑ}ɕ̽ѕЈ(յхѥ耉̽ɍ}ɑ}ɕ̹((((ɍ}Ʌѥ}ɕ}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(ɕ͕}ѡɥ5mȰt99(mȰt(IɸɅѥ̵ɕ́єٕȁɑ٥(ɑ͕ɍ}ɑ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ(ɕ͕}ѡɥɕ͕}ѡɥ((ɽЀAѠ}}}|ɕͽٔɕlt((}ѠȤ(ɕɸɽЀѠ}((ɑ}}ѕlѕ}t聥ѕȁѕɑlɑ}ѕ̉u(}ѕ􁽹ɑ}}l}ͱ}t(ѕ}ѕ􁽹ɑ}}lѕ}ɕ}t(х}ѕ􁽹ɑ}}lх}}ɥѕɥt(͕ɥ}ѕ􁽹ɑ}}l͕ɥ}}t(}ѕ􁽹ɑ}}l}ͥt(ɕѕ}̀􁽹ɑlɕѕ}̉t(Ʌѥ}ѕ̀l((ѕ}耉嵕}չ(耉嵕Ёչ(ݹȈ耉AљɴɅѽȈ(ͽɍ̈l(I5(̽ɍ}Ʌѥ}ɕ̹(̽ɍ}ɑ}ɕ̹(̽ɕ}}ͥ(t(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ((}Ѡ(ȁѠ(I5(̽ɍ}Ʌѥ}ɕ̹(̽ɍ}ɑ}ɕ̹(̽ɕ}}ͥ(((͔(٥耉Iͥѽ䁽ٕ٥ܰIMPɅаɑɅѥ́ɔɕ͕и(ѥ耉U͔ѥё͕ٕȁյѕ́ȁȁɅѥ́(}ɥѕɥ耉 ȁɅѽȁхаѡѥєЁɕ̰́ոٕɥѥ̸(((ѕ}耉ѽɥ}ѕ}ɔ(耉5ѽɥѕ䁍ɔ(ݹȈѕ}ѕlݹȉt(ͽɍ̈ѕ}ѕlͽɍ̉t(٥}耉ɽ͕}չѥ}ɽՍѥ(ѥ}хє耉݅ɹ(ͽɍ}}х̈耉ɽՍѥ}}ɕեɕ(٥ѕ}ѕl٥t(ѥ耉 ɔѥѕ䰁ٕɥȁэ̰Ʌѕ̰Ёٕ̰嵕ЁѠѡȁ٥ɽи(}ɥѕɥ耉ЁɽՍѥѕ͹͡Ё́хݥѡЁ᥹ЁݥѠɽѽɥ̸(((ѕ}耉}ɽ}(耉%Ёɽ(ݹȈ耉=Ʌѥ́ЁݹȈ(ͽɍ̈l̽ɍ}ɑ}ɕ̹̽ɍ}}х}չt(٥}耉ɽ͕}չѥ}ɽՍѥ(ѥ}хє耉݅ɹ(ͽɍ}}х̈耉ɽՍѥ}}ɕեɕ(٥耉%Ёɥɽɽɕեɔȁ嵕Ёȁɑ٥ɽи(ѥ耉IոѡЁЁɥɽɍ͔ɥɑ(}ɥѕɥ耉%ЁݹȰ͍ѥѠɽѕ̰ɥɕɐɔх(((ѕ}耉}ɕٕ}(耉 ɕٕ䁕٥(ݹȈ耉=Ʌѥ́фݹȈ(ͽɍ̈l̽ɍ}ɑ}ɕ̹̽ɍ}}}йt(٥}耉ɽ͕}չѥ}ɽՍѥ(ѥ}хє耉݅ɹ(ͽɍ}}х̈耉ɽՍѥ}}ɕեɕ(٥耉 ɕٕ䁕٥́ѡȁ嵕Ёѽ䁅ͥѕ̸(ѥ耉͍ɕѕѥɕѽɔݹȰЁɕѽɔɽɥɑ(}ɥѕɥ耉 ȁ͍́ɕѽɔɽ́хȁѱٕ݅(((ѕ}耉}ͱ}ݹ͡(耉MЁɽфM1<ݹ͡(ݹȈ}ѕlݹȉt(ͽɍ̈}ѕlͽɍ̉t(٥}}ѕl٥}t(ѥ}хє}ѕlѥ}хєt(ͽɍ}}х̈}ѕРͽɍ}}х̈ɕͽٕ(٥}ѕl٥t(ѥ}ѕlѥt(}ɥѕɥ}ѕl}ɥѕɥt(((ѕ}耉х}(耉х(ݹȈ聅х}ѕlݹȉt(ͽɍ̈聅х}ѕlͽɍ̉t(٥}聅х}ѕl٥}t(ѥ}хє聅х}ѕlѥ}хєt(٥聅х}ѕl٥t(ѥ聅х}ѕlѥt(}ɥѕɥ聅х}ѕl}ɥѕɥt(((ѕ}耉͕ɥ}}(耉Mɥ䁅(ݹȈ͕ɥ}ѕlݹȉt(ͽɍ͕̈ɥ}ѕlͽɍ̉t(٥}͕ɥ}ѕl٥}t(ѥ}хє͕ɥ}ѕlѥ}хєt(٥͕ɥ}ѕl٥t(ѥ͕ɥ}ѕlѥt(}ɥѕɥ͕ɥ}ѕl}ɥѕɥt(((ѕ}耉ɕ٥}ɽ}䈰(耉I٥܁ɽ́䈰(ݹȈ耉ݹȈ(ͽɍ̈l̽ɍ}ͅ}ͥ̽ɍ}Ʌѥ}ɕ̹t(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ䈰(٥耉I٥܁䁥́ЁɅѥ́ȁչ́ɕєɔ́ɽՍ(ѥ耉 ѥՔɅѥ́ݽɬݡՕՕɕ٥́ɔ(}ɥѕɥ耉=䁍ɕє͕ɥ䰁A$ɅаյаȁɽՍЁ́ɽɕ̸(((ѕ}耉}ͥ(耉Aͥ(ݹȈ}ѕlݹȉt(ͽɍ̈}ѕlͽɍ̉t(٥}}ѕl٥}t(ѥ}хє}ѕlѥ}хєt(٥}ѕl٥t(ѥ}ѕlѥt(}ɥѕɥ}ѕl}ɥѕɥt((t(хѕ}չ̀ չѕȡѕlѥ}хєtȁѕɅѥ}ѕ̤(}չЀхѕ}չ̹Рɕѕ}̤(݅ɹ}չЀхѕ}չ̹Р݅ɹ(ɽՍѥ}٥}ѥ}չЀմ(āȁѕɅѥ}ѕ́ѕРͽɍ}}х̈ɽՍѥ}}ɕեɕ((}չ(Ʌѥ}х̀􀉍ɍ}Ʌѥ}(݅ɹ}չ(Ʌѥ}х̀􀉍ɍ}Ʌѥ}ɕ}ݥѡ}݅ɹ̈(͔耀Ʌ聹ٕȀչɕݡѡ́ɕЁɥ́ѕɅȵ݅ɹ͕ѥ(Ʌѥ}х̀􀉍ɍ}Ʌѥ}ɕ䈀Ʌ聹ٕ((ɕɸ(Ʌѥ}х̈聽Ʌѥ}х̰(хɝ}Ʌ}مՕ}܈хɝ}Ʌ}مՕ}ܰ(хɝ}Ʌ}مՕ}聘-I\хɝ}Ʌ}مՕ}(ɕ}х̈耉}ɍ}Ʌѥ}ɕ̈(ͽɍ}є耠( ɍɅѥ́ɕٕ́́ɑ٥ɽՍѥ(Ʌѥ́́Ѽݹ̰ѥ̰Ёɥѕɥ쁥Ё́ЁمՅѥ(ՅɅѕɍ͔ѵаȁɽՍѥѥє((Ʌѥ}յ(ѕ}չЈ聱Ʌѥ}ѕ̤(ɕ}չЈхѕ}չ̹Рɕ䈰(݅ɹ}չЈ݅ɹ}չа(}չЈ聉}չа(ɽՍѥ}٥}ѥ}չЈɽՍѥ}٥}ѥ}չа(ɕ٥}ɽ}}Ȉ聽ɑlɕ٥}ɽ}ul}ȉt((Ʌѥ}ѕ̈聽Ʌѥ}ѕ̰(ɕѕ}̈聍ɕѕ}̰(Ʌѥ}х}ձ̈l((Ʌѥ}х̈耉ɍ}Ʌѥ}ɕ䈰(ձ耉嵕аѽɥаах͕ɥ佱ɕ٥ܰ٥ɔɕ䈰(((Ʌѥ}х̈耉ɍ}Ʌѥ}ɕ}ݥѡ}݅ɹ̈(ձ耉Ʌѥ́́ɕݡɽՍѥѕ䰁аȁM1<٥ɕ́Ё݅ɹ̈(((Ʌѥ}х̈耉ɍ}Ʌѥ}(ձ耉ͥɅѥ́Ё٥ɕєɽՍЁаA$ɅЁɔյЁ͵э͕ɥ䁙ɔȁ Ё́ͅɅѥ́((t(ɕ٥}ɽ}聽ɑlɕ٥}ɽ}t(ɕѕ}չѥ}ɕ̈(ɍ}ɑ}х̈聽ɑlɑ}х̉t(ɑlɕѕ}չѥ}ɕ̉t((Ʌ}}ͥ聽ɑlɅ}}ͥt(՝}Ʌ聽ɑl՝}Ʌt(Ʌѥ}̈(}ͥ}耉輽ܹͥi5]!Ii9](}ɐ耉輽ܹɐ]5M!!MA4(չѥ}Ј耈Ľɍ}Ʌѥ}ɕ̽ѕЈ(յхѥ耉̽ɍ}Ʌѥ}ɕ̹((((ɍ}͕ɥ}ѕхѥ}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(ɕ͕}ѡɥ5mȰt99(mȰt(Iɸȁ͕ɥɕ٥܁ѕхѥєٕȁɅѥ́٥(Ʌѥ͕̀ɍ}Ʌѥ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ(ɕ͕}ѡɥɕ͕}ѡɥ((ɽЀAѠ}}}|ɕͽٔɕlt((}ѠȤ(ɕɸɽЀѠ}((Ʌѥ}}ѕlѕ}t聥ѕȁѕɅѥlɅѥ}ѕ̉u(չѥ}ɽ͕ɥ}ɽȁ(ɕѕ}̀Ʌѥlɕѕ}̉t(͕ɥ}ѕхѥ}ѕ̀l((ѕ}耉͕ɥ}䈰(耉Mɥ䈰(ݹȈ耉Mɥ䁽ݹȈ(ͽɍ̈lM UI%Qdt(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ䈁}M UI%Qd͔(٥耉Iͥѽ͕ɥ䁑͍ɔЁ䁥́ɕ͕и(ѥ耉хM UI%QdѼѡȁ͕ɥɕ٥܁и(}ɥѕɥ耉 ȁѥѡձɅɕѥѠѕ͍(((ѕ}耉}}}хф(耉䁱хф(ݹȈ耉I͔ݹȈ(ͽɍ̈lɕեɕ̹ɽйѽt(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ(}ɕեɕ̹}ɽйѽ(͔(٥耉A䁱Aѡхфɔɕ͕Ёȁ䵍ɕ٥ܸ(ѥ耉U͔ѡхф́ѡȁ䁉͕(}ɥѕɥ耉 ȁЁхфɕɽՍѡ䁥хѥѠ(((ѕ}耉͕ɥ}ݽɭ}хф(耉Mɥݽɭ܁хф(ݹȈ耉Mɥ䁽ݹȈ(ͽɍ̈l(ѡՈй嵰(ѡՈݽɭ͕̽ɥ嵰( ѕՅ]͑1ѡՈɅɕեɕ͕ɥݽɭ̈(t(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ((}Ѡ(ȁѠ(ѡՈй嵰(ѡՈݽɭ͕̽ɥ嵰(((͔(٥耉Ё́ E0ՑнM =4ݽɭ́ɔ쁑ɕ٥ܰQɥ䰁=MXMɕɐɔѕѼɅɕեɕݽɭ̸(ѥ耉хݽɭ܁ѥ́ѕЁͥո٥ݡѡȁɕ٥܁ɕՕ́ѕ $ɽ(}ɥѕɥ耉 ȁЁѡɕ͕ɥݽɭ܁ɽ́ѡȁѕЁոх͕́Ʌѕ丈(((ѕ}耉չѥ}}ɽ}ɽ(耉Iչѥ̵ɽɽ(ݹȈ耉AљɴɅѽȈ(ͽɍ̈lѕՅ}ɍɅѽȽ͕ٕȹ䈰Ľɍ}Ʌѥ}ɕ̽ѕЉt(٥}耉չѥ}Ʌѥ(ѥ}хє耉ɕ䈰(٥耠(Iչѥɽ͕́ѡ}չѥ}ɽРѡ}չݸ(}Չ}չѥ}ɽР}Չ}͔(͕}Ʌ}}ձչѥ}ɽР͕}Ʌ}}ձМ͔(Ʌѕ}}ɕՕչѥ}ɽРɅѕ}}ɕՕ̜չݸ(}ɕ}չչѥ}ɽР}ɕ}չ̜չݸ((ѥ耉U͔ѡ͕ɕеɕչѥɽ́ȵ٥̵ͥɽ٥(}ɥѕɥ耉 ȁٕɥ䁅ɕ͍̰ՉеɅɔձаɅєаɕ䁍ɽ̸(((ѕ}耉Ց}}٥(耉ՑЁ٥Ј(ݹȈ耉٥ݹȈ(ͽɍ̈l(̽ɍ}٥}й(̽ɍ}Ʌѥ}ɕ̹(Ľɍ}٥}̽ѕЈ(Ľɍ}Ʌѥ}ɕ̽ѕЈ(t(٥}耉ɕͥѽ}}չѥ}ѥЈ(ѥ}хє耉ɕ(}̽ɍ}٥}й(}̽ɍ}Ʌѥ}ɕ̹(͔(٥耉 ɍ٥ЁɅѥ́ɕ́յ́ɔɕ͕ЁȁȁՑЁɕ٥ܸ(ѥ耉Aչѥ٥ЁݥѠɅѥ́ɕ́ȁѡ͕ɥɕ٥܁фɽ(}ɥѕɥ耉 ȁɅ͕ɥ䁍́Ѽչѥ́5ɭݸѥ̸(((ѕ}耉ձɅ}͍}٥(耉YձɅ͍٥(ݹȈ耉Mɥ䁽ݹȈ(ͽɍ̈l(ѡՈݽɭ͕̽ɥ嵰( ѕՅ]͑1ѡՈɅɕեɕ͕ɥݽɭ̈(t(٥}耉ѕɹ}ѕхѥ}ɕեɕ(ѥ}хє耉݅ɹ(ͽɍ}}х̈耉ѕɹ}ѕхѥ}ɕեɕ(٥耉1䵍ݽɭ܁хфɅ͕ɥ͍ݽɭ܁хфаЁѡȁЁѥ́ѡѕЁѕ͍ɕձЁȁȵѕեمи(ѥ耉хѕЁ E0ՑаQɥ䰁M =4Mɕɐɕձ́ݡ $ѕ́ȁѡȁɕՕ́٥(}ɥѕɥ耉!ѕ͍́ɔхȁѡȁѱ䁅́ݽɭ܁ѥ́́ՙЁȁѡ́х(((ѕ}耉ѡɑ}}ѕхѥ}}ѕЈ(耉Qɐ䁅ѕхѥȁɅѥѕЈ(ݹȈ耉Mɥ䁽ݹȈ(ͽɍ̈lȁ͕ɥɕ٥܈ѕɹ͕ͽȉt(٥}耉ѕɹ}ѕхѥ}ɕեɕ(ѥ}хє耉݅ɹ(ͽɍ}}х̈耉ѕɹ}ѕхѥ}ɕեɕ(٥耉%ЁM= Ȱ%M<İɅѥѕаȁȁ͕ɥ䁅͕͵Ё٥́ͥѡɕɽѽ(ѥ耉Aɽ٥ѡȵɕՕѕѕхѥ͍ձ͕͵аȁյЁЁٕ݅ȸ(}ɥѕɥ耉 ȁ́ѡѡɐ͕ɥ䁕٥͍ձ͕͵аȁٕ݅ȸ(((ѕ}耉}ɥم}}Օѥɔ(耉 ȁɥم䰁AՕѥɔЈ(ݹȈ耉ݹȈ(ͽɍ̈lȁAȁɥمՕѥɔȁɑȁɴt(٥}耉}}ɕեɕ(ѥ}хє耉݅ɹ(ͽɍ}}х̈耉}}ɕեɕ(٥耉Aɥم䰁AՉɽͽ̰фɕͥ䰁Օѥɔݕ́ȵѕɵ̸(ѥ耉 ЁȁɥمՕѥɔAɕեɕ̰Չɽͽ̰фɕͥ䁍Ʌ̸(}ɥѕɥ耉 ȵɥم䁥́ɔѕȁѱٕ݅ѡи(((ѕ}耉ɕ٥}ɽ}䈰(耉I٥܁ɽ́䈰(ݹȈ耉ݹȈ(ͽɍ̈聽Ʌѥ}}lɕ٥}ɽ}ulͽɍ̉t(٥}聽Ʌѥ}}lɕ٥}ɽ}ul٥}t(ѥ}хє聽Ʌѥ}}lɕ٥}ɽ}ulѥ}хєt(٥聽Ʌѥ}}lɕ٥}ɽ}ul٥t(ѥ聽Ʌѥ}}lɕ٥}ɽ}ulѥt(}ɥѕɥ聽Ʌѥ}}lɕ٥}ɽ}ul}ɥѕɥt(((ѕ}耉}ͥ(耉Aͥ(ݹȈ聽Ʌѥ}}l}ͥulݹȉt(ͽɍ̈聽Ʌѥ}}l}ͥulͽɍ̉t(٥}聽Ʌѥ}}l}ͥul٥}t(ѥ}хє聽Ʌѥ}}l}ͥulѥ}хєt(٥聽Ʌѥ}}l}ͥul٥t(ѥ聽Ʌѥ}}l}ͥulѥt(}ɥѕɥ聽Ʌѥ}}l}ͥul}ɥѕɥt((t(хѕ}չ̀ չѕȡѕlѥ}хєtȁѕ͕ɥ}ѕхѥ}ѕ̤(}չЀхѕ}չ̹Рɕѕ}̤(݅ɹ}չЀхѕ}չ̹Р݅ɹ(ѕɹ}ѕхѥ}}չЀմ(āȁѕ͕ɥ}ѕхѥ}ѕ́ѕРͽɍ}}х̈􀉕ѕɹ}ѕхѥ}ɕեɕ((}ɥم}}չЀմ(āȁѕ͕ɥ}ѕхѥ}ѕ́ѕРͽɍ}}х̈􀉉}}ɕեɕ((}չ(͕ɥ}ѕхѥ}х̀􀉍ɍ}͕ɥ}ѕхѥ}(݅ɹ}չ(͕ɥ}ѕхѥ}х̀􀉍ɍ}͕ɥ}ѕхѥ}ɕ}ݥѡ}݅ɹ̈(͔耀Ʌ聹ٕȀչɕݡѡ́ɕЁɥ́ѕɅȵ݅ɹ͕ѥ(͕ɥ}ѕхѥ}х̀􀉍ɍ}͕ɥ}ѕхѥ}ɕ䈀Ʌ聹ٕ((ɕɸ(͕ɥ}ѕхѥ}х͕̈ɥ}ѕхѥ}х̰(хɝ}Ʌ}مՕ}܈хɝ}Ʌ}مՕ}ܰ(хɝ}Ʌ}مՕ}聘-I\хɝ}Ʌ}مՕ}(ɕ}х̈耉}ɍ}͕ɥ}ѕхѥ(ͽɍ}є耠( ɍ͕ɥ䁅ѕхѥ͕Ʌѕ́ɕ͕ɥ䁕٥ɽѕɹ(ѕхѥѕ͍ȁɥم䁥쁥Ё́ЁمՅѥՅɅѕ(ɍ͔ѵаɽՍѥѥєȁѡɐ͕ɥ䁅Ցи((͕ɥ}ѕхѥ}յ(ѕ}չЈ聱͕ɥ}ѕхѥ}ѕ̤(ɕ}չЈхѕ}չ̹Рɕ䈰(݅ɹ}չЈ݅ɹ}չа(}չЈ聉}չа(ѕɹ}ѕхѥ}}չЈ聕ѕɹ}ѕхѥ}}չа(}ɥم}}չЈ聉}ɥم}}չа(ɕ٥}ɽ}}Ȉ聽Ʌѥlɕ٥}ɽ}ul}ȉt((͕ɥ}ѕхѥ}ѕ͕̈ɥ}ѕхѥ}ѕ̰(ɕѕ}̈聍ɕѕ}̰(͕ɥ}ѕхѥ}х}ձ̈l((͕ɥ}ѕхѥ}х̈耉ɍ}͕ɥ}ѕхѥ}ɕ䈰(ձ耉͕ɥ䰁䁵хфݽɭ܁хф́ɽ̰ՑЁаѕɹѕхѥȁɥم䁥аɕ٥܁䰁٥ɔɕ䈰(((͕ɥ}ѕхѥ}х̈耉ɍ}͕ɥ}ѕхѥ}ɕ}ݥѡ}݅ɹ̈(ձ耉ɕ͕ɥЁ́ɕݡѕ͍٥ѡɐ䁅ѕхѥȁȁɥم䁥Ёɕ́Ё݅ɹ̈(((͕ɥ}ѕхѥ}х̈耉ɍ}͕ɥ}ѕхѥ}(ձ耉͕ͥɥЁ٥ɕєɽՍЁаA$ɅЁɔյЁ͵э͕ɥ䁙ɔȁ Ё͕́ͅɥ䁅ѕхѥ((t(ɕ٥}ɽ}聽Ʌѥlɕ٥}ɽ}t(ɕѕ}չѥ}ɕ̈(ɍ}Ʌѥ}х̈聽ɅѥlɅѥ}х̉t(Ʌѥlɕѕ}չѥ}ɕ̉t((Ʌ}}ͥ聽ɅѥlɅ}}ͥt(՝}Ʌ聽Ʌѥl՝}Ʌt(͕ɥ}ѕхѥ}̈(}ͥ}耉輽ܹͥi5]!Ii9](}ɐ耉輽ܹɐ]5M!!MA4(չѥ}Ј耈Ľɍ}͕ɥ}ѕхѥ̽ѕЈ(յхѥ耉̽ɍ}͕ɥ}ѕхѥ((((ɍ}مՕ}ɕ}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(ɕ͕}ѡɥ5mȰt99(mȰt(Iɸȁɕ٥܁єٕȁمՔI=$٥(ɍ͕ɍ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((Ѐ͕ɍ}٥}}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((͕ɥ͕ɍ}͕ɥ}ѕхѥ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ(ɕ͕}ѡɥɕ͕}ѡɥ((ѥ͕̀ѥ}͹͡С}չ}չ̤(ɽЀAѠ}}}|ɕͽٔɕlt((}ѠȤ(ɕɸɽЀѠ}((ɥѕɥ}}͕}ɥѕɥ}}ɍlɥѕɥt(مՕ}͔ɥѕɥ}}lɍ}مՕ}͔t(͕̀}ɥ}}ѥl̉t(ՅɑɅ͕̀}ɥ}}ѥlՅɑɅ̉t(͕ɥ}ѕ̀ѕlѕ}t聥ѕȁѕ͕ɥl͕ɥ}ѕхѥ}ѕ̉u(مՕ}ѕ̀l((ѕ}耉ɍ}مՕ}͕}ͥ̈(耉 ɍمՔ͔ͥ̈(ݹȈ耉ݹȈ(ͽɍ̈lĽɍ}ɕ̽ѕЈ̽ɍ}ɕ̹t(٥}耉}Օ}}͹͡Ј(ѥ}хє耉ɕ䈁مՕ}͕lх̉ẗ͔݅ɹ(٥مՕ}͕l٥t(ѥ耉U͔ɍɕ́́ѡمՔ͔͕ݥѡЁɕ͕ѥЁ́مՅѥՅɅѕ(}ɥѕɥ耉 ȁ͕́ѡ-I\хɝЁ́ɕ٥܁ȰЁ́ՅɅѕمՅѥ(((ѕ}耉}ѥ}٥(耉1ѥ́٥(ݹȈ耉AɽՍЁѥ́ݹȈ(ͽɍ̈lĽѥ}͹̽͡ѕЈ̽ѥ}t(٥}耉ɕ}(ѥ}хє耉ɕ䈰(٥耠(ѥ}}ѥlѥ}}ѥtРمՔ쀈(Ʌ}ѕ}ݽɭ}ɅєlɅ}ѕ}ݽɭ}ɅєtРمՕ}ɍМ쀈(}ͅ}ɽѥ}Ʌєl}ͅ}ɽѥ}ɅєtРمՕ}ɍМ쀈(ɽ٥}፱ͥ}}ɅєՅɑɅlɽ٥}፱ͥ}}ɅєtРمՔ((ѥ耉U͔ɕѥɅ䰁ɽ٥ȵͅ䁵ɥ́́٥䁙ȁѡ́ɽѽ(}ɥѕɥ耉 ȁչх́ѡ͔ɔɕ̰ͥЁɽՍѥɕٕՔȁѽȁ̸ͅ(((ѕ}耉}٥}Ј(耉 ȁ٥Ј(ݹȈ耉٥ݹȈ(ͽɍ̈l(Ľɍ}٥}̽ѕЈ(Ľɍ}͕ɥ}ѕхѥ̽ѕЈ(̽ɍ}٥}й(t(٥}耉ɕͥѽ}}չѥ}ѥЈ(ѥ}хє耉ɕ䈁}̽ɍ}٥}й͔(٥耠(ɍ}}хl}х̝u쀈(͕ɥ}ѕхѥ}х͕ɥl͕ɥ}ѕхѥ}х̝u((ѥ耉AمՔ٥ݥѠЁ͕ɥ䁅ѕхѥ́ѡȁфɽ(}ɥѕɥ耉 ȁɅ́Ѽչѥ́ɕѥ̸(((ѕ}耉ɥ}}Ʌѥ(耉AɥɅѥ(ݹȈ耉ݹȈ(ͽɍ̈l(̽ɍ}ɕ̹(̽ɍ}ͅ}ͥ(̽ɍ}ɽɕ}ɕ̹(̽ɍ}مՕ}ɕ̹(t(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ((}Ѡ(ȁѠ(̽ɍ}ɕ̹(̽ɍ}ͅ}ͥ(̽ɍ}ɽɕ}ɕ̹(((͔(٥耉 ɍɕ̰ͅ䰁ɽɕЁյ́ȁѡɅѥ(ѥ耉-ѡ-I\ɅѥѥѼA$ѥ䰁٥ɽɕ䰁Ցа͕ɥ䰁Ʌѥ́ɕ̸(}ɥѕɥ耉 ȁЁݡɽՍЁѥ́ЁѡɅѥ(((ѕ}耉ɽ}}̈(耉I=$̈(ݹȈ耉 ȁͽȁݹȈ(ͽɍ̈lȁI=$ѽȁ͍ٕ䈰ɽɕЁمՔ͔t(٥}耉}}ɕեɕ(ѥ}хє耉݅ɹ(ͽɍ}}х̈耉}}}ɕեɕ(٥耉 ȵ͕аݽɭ܁ٽյɽȽɕݽɬааѥͅ٥յѥ́ɔЁɕ̸(ѥ耉 Ёȁ͕ɥ́ѡѼA$ѥ䰁ɅՑаɕ䰁Ʌѥ́ͅ٥̸(}ɥѕɥ耉 ȁ́ѡI=$́ȁɭ́ѡٕ݅ȁѡɍɕ٥ܸ(((ѕ}耉ɕɕ}ѽ}}͕}Ց䈰(耉Iɕѽȁȁɽ(ݹȈ耉ݹȈ(ͽɍ̈lɕɕѽȈ͔Ց䈰ЁɕձЉt(٥}耉ѕɹ}مՕ}ɽ}ɕեɕ(ѥ}хє耉݅ɹ(ͽɍ}}х̈耉ѕɹ}مՕ}ɽ}ɕեɕ(٥耉IɕѽȰаȁɽՍѥɽ́ѕɹѼѡɕɽѽ(ѥ耉хɕɕЁɕձаȁЁȁٕ݅ȁɔɕѥѡمՔ͔́ѕɹɽٕ(}ɥѕɥ耉 ȁ́ѡɕɕɽЁɕձаȁٕ݅ȸ(((ѕ}耉ɽɕ}Ց}ݹȈ(耉AɽɕЁՑЁݹȈ(ݹȈ耉 ȁͽȁɽɕЁݹȈ(ͽɍ̈lȁɑȁɴɽɕЁɽ̈ՑЁɽمt(٥}耉}}ɕեɕ(ѥ}хє耉݅ɹ(ͽɍ}}х̈耉}}}ɕեɕ(٥耉 ՑЁݹȰɽمѠɑȵɴѡɥ䁅ɔȵ̸(ѥ耉%ѥͽȰՑЁݹȰɽɕЁѠɑȵɴѡɥ丈(}ɥѕɥ耉 ȁɵ́ѡՑЁݹȁɽمѠȁѡ-I\ɕ٥ܸ(((ѕ}耉хѥ}剅}յѥ(耉%хѥ剅յѥ(ݹȈ耉 ȁͽȁɑݹȈ(ͽɍ̈lȁɑхѥѥєɅѥ́t(٥}耉}}ɕեɕ(ѥ}хє耉݅ɹ(ͽɍ}}х̈耉}}}ɕեɕ(٥耉%хѥѥхչ䁍а剅ݥ܁ȁ嵕Ё͍(ѥ耉ѥєхѥЁ剅ݥ܁ɥɑȁȁ(}ɥѕɥ耉 ȁ́ѡ剅յѥ́ȁɭ́ѡЁ͍(((ѕ}耉ɕ٥}ɽ}䈰(耉I٥܁ɽ́䈰(ݹȈ耉ݹȈ(ͽɍ͕̈ɥ}ѕlɕ٥}ɽ}ulͽɍ̉t(٥}͕ɥ}ѕlɕ٥}ɽ}ul٥}t(ѥ}хє͕ɥ}ѕlɕ٥}ɽ}ulѥ}хєt(٥͕ɥ}ѕlɕ٥}ɽ}ul٥t(ѥ͕ɥ}ѕlɕ٥}ɽ}ulѥt(}ɥѕɥ͕ɥ}ѕlɕ٥}ɽ}ul}ɥѕɥt(((ѕ}耉}ͥ(耉Aͥ(ݹȈ͕ɥ}ѕl}ͥulݹȉt(ͽɍ͕̈ɥ}ѕl}ͥulͽɍ̉t(٥}͕ɥ}ѕl}ͥul٥}t(ѥ}хє͕ɥ}ѕl}ͥulѥ}хєt(٥͕ɥ}ѕl}ͥul٥t(ѥ͕ɥ}ѕl}ͥulѥt(}ɥѕɥ͕ɥ}ѕl}ͥul}ɥѕɥt((t(хѕ}չ̀ չѕȡѕlѥ}хєtȁѕمՕ}ѕ̤(ɕѕ}͕̀ɥlɕѕ}̉t(}չЀхѕ}չ̹Рɕѕ}̤(݅ɹ}չЀхѕ}չ̹Р݅ɹ(}}}չЀմ((ȁѕمՕ}ѕ(ѕРͽɍ}}х̈쉉}}}ɕեɕѕɹ}مՕ}ɽ}ɕեɕ((ѕɹ}مՕ}ɽ}}չЀմ(āȁѕمՕ}ѕ́ѕРͽɍ}}х̈􀉕ѕɹ}مՕ}ɽ}ɕեɕ((}չ(مՕ}х̀􀉍ɍ}مՕ}(݅ɹ}չ(مՕ}х̀􀉍ɍ}مՕ}ɕ}ݥѡ}݅ɹ̈(͔耀Ʌ聹ٕȀչɕݡѡ́ɕЁɥ́ѕɅȵ݅ɹ͕ѥ(مՕ}х̀􀉍ɍ}مՕ}ɕ䈀Ʌ聹ٕ((ɕɸ(مՕ}х̈مՕ}х̰(хɝ}Ʌ}مՕ}܈хɝ}Ʌ}مՕ}ܰ(хɝ}Ʌ}مՕ}聘-I\хɝ}Ʌ}مՕ}(ɕ}х̈耉}ɍ}مՕ}ɕ̈(ͽɍ}є耠( ɍمՔɕ͕́Ʌѕ́ɕɕ٥ɽȵ(I=$ɕɕՑа剅쁥Ё́ЁمՅѥՅɅѕɍ͔(ѵаɕٕՔɽȁ٥((مՕ}յ(ѕ}չЈ聱مՕ}ѕ̤(ɕ}չЈхѕ}չ̹Рɕ䈰(݅ɹ}չЈ݅ɹ}չа(}չЈ聉}չа(}}}չЈ聉}}}չа(ѕɹ}مՕ}ɽ}}չЈ聕ѕɹ}مՕ}ɽ}}չа(ɕ٥}ɽ}}Ȉ͕ɥlɕ٥}ɽ}ul}ȉt((مՕ}ѕ̈مՕ}ѕ̰(ɕѕ}̈聍ɕѕ}̰(مՕ}х}ձ̈l((مՕ}х̈耉ɍ}مՕ}ɕ䈰(ձ耉ɍمՔ͔ѥ̰٥аɥɅѥI=$̰ɕɕɽՑЁݹȰ剅յѥ̰ɕ٥܁䰁٥ɔɕ䈰(((مՕ}х̈耉ɍ}مՕ}ɕ}ݥѡ}݅ɹ̈(ձ耉ɕمՔ٥́ɕݡȁI=$̰ɕɕɽՑЁݹȰȁ剅յѥ́ɕЁ݅ɹ̈(((مՕ}х̈耉ɍ}مՕ}(ձ耉ͥمՔЁ٥ɕєɽՍЁаA$ɅЁɔյЁ͵э͕ɥ䁙ɔȁ Ё́ͅمՔɕ̈((t(ɕ٥}ɽ}͕ɥlɕ٥}ɽ}t(ɕѕ}չѥ}ɕ̈(ɍ}͕ɥ}ѕхѥ}х͕̈ɥl͕ɥ}ѕхѥ}х̉t(ɍ}}х̈聕l}х̉t(ɍ}х̈聍ɍlɍ}х̉t(͕ɥlɕѕ}չѥ}ɕ̉t((Ʌ}}͕ͥɥlɅ}}ͥt(՝}Ʌ͕ɥl՝}Ʌt(مՕ}̈(}ͥ}耉輽ܹͥi5]!Ii9](}ɐ耉輽ܹɐ]5M!!MA4(չѥ}Ј耈Ľɍ}مՕ}ɕ̽ѕЈ(յхѥ耉̽ɍ}مՕ}ɕ̹((((ɍ}͕}ɕ}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(ɕ͕}ѡɥ5mȰt99(mȰt(Iɸѡȵ͔єٕȁɍɕ́٥(مՔ͕ɍ}مՕ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ(ɕ͕}ѡɥɕ͕}ѡɥ((͕ɥ͕ɍ}͕ɥ}ѕхѥ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ(ɕ͕}ѡɥɕ͕}ѡɥ((ɅЀ͕ɍ}Ʌ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ(ɕ͕}ѡɥɕ͕}ѡɥ((ɑ͕ɍ}ɑ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ(ɕ͕}ѡɥɕ͕}ѡɥ((Ʌѥ͕̀ɍ}Ʌѥ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ(ɕ͕}ѡɥɕ͕}ѡɥ((Ѐ͕ɍ}٥}}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ɽЀAѠ}}}|ɕͽٔɕlt((}ѠȤ(ɕɸɽЀѠ}((ɕѕ}̀l(مՕlɕѕ}̉t(͕ɥlɕѕ}̉t(Ʌlɕѕ}̉t(ɑlɕѕ}̉t(Ʌѥlɕѕ}̉t(lɕѕ}̉t(t(ɕѕ}̀􁱥Сйɽ̡ɕѕ}̤(͕}ѕ̀l((ѕ}耉͕}ɽՍ}Ј(耉MɽՍЁЈ(ݹȈ耉ݹȈ(ͽɍ̈l(Ľɍ}مՕ}ɕ̽ѕЈ(Ľɍ}͕ɥ}ѕхѥ̽ѕЈ(Ľɍ}٥}̽ѕЈ(̽ɍ}مՕ}ɕ̹(̽ɍ}͕ɥ}ѕхѥ(̽ɍ}٥}й(t(٥}耉ɕͥѽ}}չѥ}ѥЈ(ѥ}хє耉ɕ(مՕlمՕ}х̉t􀉍ɍ}مՕ}(͕ɥl͕ɥ}ѕхѥ}х̉t􀉍ɍ}͕ɥ}ѕхѥ}(l}х̉t􀉍ɍ}}(}̽ɍ}مՕ}ɕ̹(}̽ɍ}͕ɥ}ѕхѥ(}̽ɍ}٥}й(͔(٥耠(مՕ}хمՕlمՕ}х̝u쀈(͕ɥ}ѕхѥ}х͕ɥl͕ɥ}ѕхѥ}х̝u쀈(ɍ}}хl}х̝u((ѥ耉хѡɕɽՍа͕ɥ䰁مՔ٥ЁЁѼȁ͔ɕ٥ܸ(}ɥѕɥ耉 ȁЁѡ͕ЁݥѡЁɕѥЁ́ɍ͔ѵЁȁمՅѥՅɅѕ(((ѕ}耉Ʌ}͕}Ј(耉 ɅЁ͔Ј(ݹȈ耉1ɽɕЁݹȈ(ͽɍ̈l(Ľɍ}Ʌ}ɕ̽ѕЈ(̽ɍ}Ʌ}ɕ̹(̽ɍ}ɽɕ}ɕ̹(t(٥}耉ɕͥѽ}}չѥ}ѥЈ(ѥ}хє耉ɕ(ɅlɅ}х̉t􀉍ɍ}Ʌ}(}̽ɍ}Ʌ}ɕ̹(͔(٥聘Ʌ}х퍽ɅlɅ}х̝u(ѥ耉U͔ɅЁɕ́́ѡɽɕЁЁɅͥɕ͕́Ʌѕ丈(}ɥѕɥ耉 ȁɽɕЁ͕́ɅЁ٥ѡɕͥɔ̸(((ѕ}耉ɑ}Ʌѥ}Ј(耉=ɑɅѥ́Ј(ݹȈ耉 ѽȁՍ́љɴݹȈ(ͽɍ̈l(Ľɍ}ɑ}ɕ̽ѕЈ(Ľɍ}Ʌѥ}ɕ̽ѕЈ(̽ɍ}ɑ}ɕ̹(̽ɍ}Ʌѥ}ɕ̹(t(٥}耉ɕͥѽ}}չѥ}ѥЈ(ѥ}хє耉ɕ(ɑlɑ}х̉t􀉍ɍ}ɑ}(ɅѥlɅѥ}х̉t􀉍ɍ}Ʌѥ}(}̽ɍ}ɑ}ɕ̹(}̽ɍ}Ʌѥ}ɕ̹(͔(٥耠(ɑ}хɑlɑ}х̝u쀈(Ʌѥ}хɅѥlɅѥ}х̝u((ѥ耉хɑɅѥ́ɕ́́ѡٔЁи(}ɥѕɥ耉 ȁѥ䁥хѥаɅѥ̰хݹ̸(((ѕ}耉}٥}}Ј(耉 ȁ٥ЁЈ(ݹȈ耉٥ݹȈ(ͽɍ̈l(Ľɍ}٥}̽ѕЈ(̽ɍ}٥}й(̽}ѥ̹(t(٥}耉ɕͥѽ}}չѥ}ѥЈ(ѥ}хє耉ɕ(l}х̉t􀉍ɍ}}(}̽ɍ}٥}й(}̽}ѥ̹(͔(٥聘ɍ}}хl}х̝u(ѥ耉U͔ѡхЁЁ́ѡȁфɽจ(}ɥѕɥ耉 ȁɅ͔٥Ѽչѥ̰̰)ѥ̸(((ѕ}耉ͥ}ɑ}ɵ}̈́(耉Mɑȁɴȁ5M(ݹȈ耉 ȁͽȰɽɕЁݹȰݹȈ(ͽɍ̈lȁɑȁɴ5MͥɔЉt(٥}耉}ͥɕ}ɕեɕ(ѥ}хє耉݅ɹ(ͽɍ}}х̈耉}ͥɕ}ɕեɕ(٥耉Mɑȁɴ5Mɍѕɵ̰ѡɥ䁍ɵѥɔȵ̸͔ͥ(ѥ耉 Ёͥɑȁɴȁ5MȁхЁȁٕ݅ȸ(}ɥѕɥ耉 ȁ͕ȁͥɔѡɥ䁅Ёѡɑȁɴȁ5M(((ѕ}耉}͕ɥ}х(耉A͕ɥ䁅х(ݹȈ耉 ȁ͕ɥ䰁ɥم䰁ݹȈ(ͽɍ̈lȁA͕ɥɕ٥܁хɥمՕѥɔt(٥}耉}ͥɕ}ɕեɕ(ѥ}хє耉݅ɹ(ͽɍ}}х̈耉}ͥɕ}ɕեɕ(٥耉A͕ɥ䁅хɥمՕѥɔѕхѥٕ݅́ɔȵ̸͔(ѥ耉 ЁA͕ɥ䁅хȁյѕٕ݅ȁɽȁ͕ɥ䁅ɕ٥ݕ̸(}ɥѕɥ耉 ȁͥ́ȁٕ݅́A͕ɥ䁅хɕեɕ̸(((ѕ}耉Ց}ɽم}ɍ͕}ɑȈ(耉 ՑЁɽمɍ͔ɑȈ(ݹȈ耉 ȁɽɕЁݹȈ(ͽɍ̈lՑЁɽمɍ͔ɑȈɽمt(٥}耉}ͥɕ}ɕեɕ(ѥ}хє耉݅ɹ(ͽɍ}}х̈耉}ͥɕ}ɕեɕ(٥耉 ՑЁɽمɍ͔ɑȰѡɥ䁅ɔѕɹȁɽɕЁ٥(ѥ耉 ЁȁՑЁɽمA<ȁхɽٕѕɹѥٔ嵕Ёѡɥ丈(}ɥѕɥ耉 ȁɽɕЁɵ́ՑЁѡɥ䁅嵕ЁѠȁ-I\(((ѕ}耉}ٕ}ѡɥѥ(耉ٔѡɥѥ(ݹȈ耉 ȁͥ́ͽȁхѥݹȈ(ͽɍ̈lٔɽمхѥѡɥѥхͥt(٥}耉}ͥɕ}ɕեɕ(ѥ}хє耉݅ɹ(ͽɍ}}х̈耉}ͥɕ}ɕեɕ(٥耉ٔѡɥѥхѥхɕեɔȁɽم(ѥ耉 ЁٔѡɥѥȁɬɽՍѥѥمѥЁ͍ȁѡͥ(}ɥѕɥ耉 ȁѡɥ́ٔɑȁ͍еͥɔхѥ(((ѕ}耉ɕ٥}ɽ}䈰(耉I٥܁ɽ́䈰(ݹȈ耉ݹȈ(ͽɍ̈l̽ɍ}ͅ}ͥ̽ɍ}͕}ɕ̹t(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ䈰(٥耉I٥܁ɽ́䁥́Ё͔ȁչ́ɕєɽՍа͕ɥ䰁A$ɅаȁյЁɔ́ɽՍ(ѥ耉-ɍ͔ݽɬ٥ݡՕՕɕ٥܁ɽ͕́ɔ(}ɥѕɥ耉=䁍ɕєɕ͔́ɕ̸(((ѕ}耉}ͥ(耉Aͥ(ݹȈ耉AɽɕЁ͕ɥɕ٥ݕȈ(ͽɍ̈l̽Ʌ}ɕ͕ɍ̽ɍ}՝}Ʌѥ}t(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ(مՕlɅ}}ͥulͥt􀉭}ͥ}ɽՍЈ(͔݅ɹ(٥مՕlɅ}}ͥulɕͽt(ѥ耉-光ѕɥ͔ɽɽՍЁչѥɅѥɥ́ɔɕ(}ɥѕɥ耉Ёɕє͕ɅєɅ䰁ЁՉձȁɅѕȁѡ͔́є((t(хѕ}չ̀ չѕȡѕlѥ}хєtȁѕ͕}ѕ̤(}չЀхѕ}չ̹Рɕѕ}̤(݅ɹ}չЀхѕ}չ̹Р݅ɹ(}ͥɕ}}չЀմ(āȁѕ͕}ѕ́ѕРͽɍ}}х̈􀉉}ͥɕ}ɕեɕ((}չ(͕}х̀􀉍ɍ}͕}(݅ɹ}չ(͕}х̀􀉍ɍ}͕}ɕ}ݥѡ}݅ɹ̈(͔耀Ʌ聹ٕȀչɕݡѡ́ɕЁɥ́ѕɅȵ݅ɹ͕ѥ(͕}х̀􀉍ɍ}͕}ɕ䈀Ʌ聹ٕ((ɕɸ(͕}х̈聍͕}х̰(хɝ}Ʌ}مՕ}܈хɝ}Ʌ}مՕ}ܰ(хɝ}Ʌ}مՕ}聘-I\хɝ}Ʌ}مՕ}(ɕ}х̈耉}ɍ}͕}ɕ̈(ͽɍ}є耠( ɍ͔ɕ͕́Ʌѕ́ɕ͕ɽՍЁ٥ɽȀ(ͥɔɽɕа͕ɥ䁅хٔѡɥѥ쀈(Ё́ЁمՅѥՅɅѕɍ͔ѵаͥɑȰ(ȁɽՍѥѥє((͕}յ(ѕ}չЈ聱͕}ѕ̤(ɕ}չЈхѕ}չ̹Рɕ䈰(݅ɹ}չЈ݅ɹ}չа(}չЈ聉}չа(}ͥɕ}}չЈ聉}ͥɕ}}չа(ɕ٥}ɽ}}ȈمՕlɕ٥}ɽ}ul}ȉt((͕}ѕ̈聍͕}ѕ̰(ɕѕ}̈聍ɕѕ}̰(͕}х}ձ̈l((͕}х̈耉ɍ}͕}ɕ䈰(ձ耉͕ɽՍЁаɅЁаɑɅѥ́а٥аͥɕ̰A͕ɥ䁅хՑнA<ٔѡɥѥɕ٥܁䰁٥ɔɕ䈰(((͕}х̈耉ɍ}͕}ɕ}ݥѡ}݅ɹ̈(ձ耉ɕ͔Ё́ɕݡȁͥɕ̰A͕ɥ䁅хՑнA<ȁٔѡɥѥɕЁ݅ɹ̈(((͕}х̈耉ɍ}͕}(ձ耉͔ͥ٥ɕєɽՍЁаA$ɅЁɔյЁ͵э͕ɥ䁙ɔȁ Ё͔́ͅɕ̈((t(ɕ٥}ɽ}مՕlɕ٥}ɽ}t(ɕѕ}չѥ}ɕ̈(ɍ}مՕ}х̈مՕlمՕ}х̉t(ɍ}͕ɥ}ѕхѥ}х͕̈ɥl͕ɥ}ѕхѥ}х̉t(ɍ}Ʌ}х̈聍ɅlɅ}х̉t(ɍ}ɑ}х̈聽ɑlɑ}х̉t(ɍ}Ʌѥ}х̈聽ɅѥlɅѥ}х̉t(ɍ}}х̈聕l}х̉t(مՕlɕѕ}չѥ}ɕ̉t((Ʌ}}ͥمՕlɅ}}ͥt(՝}ɅمՕl՝}Ʌt(͕}̈(}ͥ}耉輽ܹͥi5]!Ii9](}ɐ耉輽ܹɐ]5M!!MA4(չѥ}Ј耈Ľɍ}͕}ɕ̽ѕЈ(յхѥ耉̽ɍ}͕}ɕ̹((((ɍ}}ѽ}ɭ}ɕ}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(ɕ͕}ѡɥ5mȰt99(mȰt(IɸȵQ4ɕٕ́ȁɍ٥(͔͕ɍ}͕}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ(ɕ͕}ѡɥɕ͕}ѡɥ((مՔ͕ɍ}مՕ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ(ɕ͕}ѡɥɕ͕}ѡɥ((͕ɥ͕ɍ}͕ɥ}ѕхѥ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ(ɕ͕}ѡɥɕ͕}ѡɥ((Ѐ͕ɍ}٥}}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((͕ɍ}}չ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((͕ͅͅ}ͥ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ѥ͕̀ѥ}͹͡С}չ}չ̤(ɽЀAѠ}}}|ɕͽٔɕlt((}ѠȤ(ɕɸɽЀѠ}((ɕѕ}̀l(͕lɕѕ}̉t(مՕlɕѕ}̉t(͕ɥlɕѕ}̉t(lɕѕ}̉t(ͅlɕѕ}̉t(t(ɕѕ}̀􁱥Сйɽ̡ɕѕ}̤(ѵ}ѕ̀l((ѕ}耉ɍ}͕}Ј(耉 ɍ͔Ј(ݹȈ耉ݹȈ(ͽɍ̈lĽɍ}͕}ɕ̽ѕЈ̽ɍ}͕}ɕ̹t(٥}耉ɕͥѽ}}չѥ}ѥЈ(ѥ}хє耉ɕ(͕l͕}х̉t􀉍ɍ}͕}(}̽ɍ}͕}ɕ̹(͔(٥聘͕}х퍱͕l͕}х̝u(ѥ耉U͔͔ɕ́́ѡȵɕ́и(}ɥѕɥ耉 ȁ͕͔́Ёх́ɕȵͥͥɔ̸(((ѕ}耉}مՕ}Ј(耉مՔЈ(ݹȈ耉ݹȁѥ́ݹȈ(ͽɍ̈l(Ľɍ}مՕ}ɕ̽ѕЈ(Ľѥ}͹̽͡ѕЈ(̽ɍ}مՕ}ɕ̹(̽ѥ}(t(٥}耉ɕͥѽ}}չѥ}ѥЈ(ѥ}хє耉ɕ(مՕlمՕ}х̉t􀉍ɍ}مՕ}(}̽ɍ}مՕ}ɕ̹(}̽ѥ}(͔(٥耠(مՕ}хمՕlمՕ}х̝u쀈(}չѥl̝t쁝ՅɑɅ}չѥlՅɑɅ̝t((ѥ耉M܁مՔ٥ݥѠɕٕ́ȵɥ͕Ʌѥ(}ɥѕɥ耉 ȁЁمՔ́ݥѡЁɕѥѡ́ɕٕՔɽȁ٥(((ѕ}耉͕ɥ}}Ј(耉MɥЁЈ(ݹȈ耉Mɥ䁽ݹȈ(ͽɍ̈l(Ľɍ}͕ɥ}ѕхѥ̽ѕЈ(̽ɍ}͕ɥ}ѕхѥ(M UI%Qd(t(٥}耉ɕͥѽ}}չѥ}ѥЈ(ѥ}хє耉ɕ(͕ɥl͕ɥ}ѕхѥ}х̉t􀉍ɍ}͕ɥ}ѕхѥ}(}̽ɍ}͕ɥ}ѕхѥ(}M UI%Qd(͔(٥聘͕ɥ}ѕхѥ}х͕ɥl͕ɥ}ѕхѥ}х̝u(ѥ耉U͔͕ɥ䁅ѕхѥ́ѡȁЁЁѕɹѕхѥ͕́Ʌє(}ɥѕɥ耉 ȁЁ͕ɥ䁍ɽ́ѕɹѕхѥ̸(((ѕ}耉}٥}Ј(耉 ȁ٥Ј(ݹȈ耉٥ݹȈ(ͽɍ̈l(Ľɍ}٥}̽ѕЈ(Ľɍ}}չ̽ѕЈ(̽ɍ}٥}й(̽ɍ}}}չ(t(٥}耉ɕͥѽ}}չѥ}ѥЈ(ѥ}хє耉ɕ(l}х̉t􀉍ɍ}}(lչ}х̉t􀉉}}(}̽ɍ}٥}й(}̽ɍ}}}չ(͔(٥聘ɍ}}хl}х̝u쁉}}хlչ}х̝u(ѥ耉х٥Ёչ́ѡȁфɽจ(}ɥѕɥ耉 ȁɅQ4́Ѽչѥ̰̰ѕ̰ѥ̸(((ѕ}耉ͅ}ͥ}Ј(耉M䁑ͥЈ(ݹȈ耉ݹȈ(ͽɍ̈lĽͅ}ͥ̽ѕЈ̽ɍ}ͅ}ͥt(٥}耉ɕͥѽ}}չѥ}ѥЈ(ѥ}хє耉ɕ(ͅlͅ}х̉tͅ}(}̽ɍ}ͅ}ͥ(͔(٥聘ͅ}хͅlͅ}х̝u(ѥ耉U͔ͅ䁑ͥ́ѡQ4͕(}ɥѕɥ耉 ȁхȁɕ٥܁ѥե݅͠ɹ́ɽɕє̸(((ѕ}耉}Ʌѽ}٥(耉Ʌѽȁ٥(ݹȈ耉AɽՍЁͥݹȈ(ͽɍ̈lѕՅ}ɍɅѽȽ䈰͍̽ɕ}ͥt(٥}耉ɕͥѽ}}չѥ}ѥЈ(ѥ}хє耉ɕ(}ѕՅ}ɍɅѽȽ䈤}͍̽ɕ}ͥ(͔(٥耉ə͕́ɕ́х̰ͽɍѕ̰ɕЁх̰݅ɹȁյɥ̸(ѥ耉U͔ѡѥ͕مəѕɕѥ͕Ʌє́͡ͅɐ(}ɥѕɥ耉=ɅѽȁЁQ4ɕ́ɽѡɕЁə(((ѕ}耉ѥ}ѡձ}Ј(耉ѥ́ѡձ́Ј(ݹȈ耉фѥ́ݹȈ(ͽɍ̈l̽ѥ}Ľѥ}͹̽͡ѕЉt(٥}耉ɕͥѽ}}չѥ}ѥЈ(ѥ}хє耉ɕ䈁}̽ѥ}͔(٥耉ѥ͕́Ʌѕ́ɕ٥ɽɽ͕ɽՍѥȁȵ̸(ѥ耉-Q4ɥ́ɽɽՍѥɕٕՔͥȁɽȁչɕѕ丈(}ɥѕɥ耉Mх͕́ݡ-A$́ɔɕݡɔɽ̸͕(((ѕ}耉х}ѥ}Ј(耉Mхȁѥ́Ј(ݹȈ耉AɽՍЁͥݹȈ(ͽɍ̈l(̽}ѥ̹(輽ܹͥi5]!Ii9](輽ܹɐ]5M!!MA4(t(٥}耉}ѥЈ(ѥ}хє耉ɕ䈁}̽}ѥ̹͔(٥耉х)хȁѥ́ɔɕɑ Ё́፱Ց(ѥ耉U͔ххȁѥ́ȁQ4ɕ٥܁ѕ͍ɕ͡е䁕٥(}ɥѕɥ耉Mх́ѡͥ)ɐȁQ4ɕ٥ܸ(((ѕ}耉}ͥɕ}Ց}}(耉 ȁͥɔՑЁܵ(ݹȈ耉 ȁͽȰɽɕЁݹȰݹȈ(ͽɍ̈lȁɑȁɴ5MA͕ɥ䁅хɍ͔ɑȈٔɽمt(٥}耉}}ɕեɕ(ѥ}хє耉݅ɹ(ͽɍ}}х̈耉}ͥɕ}ɕեɕ(٥耠(}ͥɕ}}չ퍱͕l͕}յul}ͥɕ}}չНu쀈(ͥɑȽ5MA͕ɥ䁅хՑнA<ٔѡɥѥɔȁ̸((ѥ耉 Ёȁͥɕ̰ɽم̰ȁٕ݅́ɔɕɕ͕ѥѡЁ͕́ݽ(}ɥѕɥ耉 ȁ́ȁٕ݅́ͥɔՑа͕ɥ䁅х̸ٔ(((ѕ}耉ɽՍѥ}ѕɹ}ɽ}}(耉AɽՍѥѕɹɽܵ(ݹȈ耉Mɥ䰁Ʌѥ̰ݹȈ(ͽɍ̈lѕ͍Јѡɐ䁅ѕхѥɕɕɽɽՍѥѕt(٥}耉ѕɹ}}ɽՍѥ}}ɕեɕ(ѥ}хє耉݅ɹ(ͽɍ}}х̈耉ѕɹ}}ɽՍѥ}}ɕեɕ(٥耠(͕ɥ}݅ɹ}չ͕ɥl͕ɥ}ѕхѥ}յul݅ɹ}չНu쀈(مՕ}݅ɹ}չمՕlمՕ}յul݅ɹ}չНu쀈(}݅ɹ}չl}յul݅ɹ}չНu((ѥ耉хѕ͍ѡɐ䁅ѕхѥɕɕɽɽՍѥѕݡم(}ɥѕɥ耉 ȁ́ѕɹɽɽՍѥɽȁЁٕ݅ȸ(((ѕ}耉ɕ٥}ɽ}䈰(耉I٥܁ɽ́䈰(ݹȈ耉ݹȈ(ͽɍ̈l̽ɍ}}ѽ}ɭ}ɕ̹̽ɍ}ͅ}ͥt(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ䈰(٥耉I٥܁ɽ́䁥́ЁQ4ȁչ́ɕєɔ́ɽՍ(ѥ耉 ѥՔQ4ɕ́ݽɬݡՕՕɕ٥́ɔ(}ɥѕɥ耉=䁍ɕєɽՍа͕ɥ䰁A$ɅаȁյЁɕ́Q4ɕ̸(((ѕ}耉}ͥ(耉Aͥ(ݹȈ耉AɽɕЁ͕ɥɕ٥ݕȈ(ͽɍ̈l̽Ʌ}ɕ͕ɍ̽ɍ}՝}Ʌѥ}t(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ(͕lɅ}}ͥulͥt􀉭}ͥ}ɽՍЈ(͔݅ɹ(٥聍͕lɅ}}ͥulɕͽt(ѥ耉-光ѕɥ͔ɽɽՍЁչѥɅѥɥ́ɔɕ(}ɥѕɥ耉Ёɕє͕ɅєɅ䰁ЁՉձȁɅѕȁѡ́Q4є((t(хѕ}չ̀ չѕȡѕlѥ}хєtȁѕѵ}ѕ̤(}չЀхѕ}չ̹Рɕѕ}̤(݅ɹ}չЀхѕ}չ̹Р݅ɹ(}ͥɕ}}չЀ􁍱͕l͕}յul}ͥɕ}}չЉt(ѕɹ}}ɽՍѥ}}չЀ(͕ɥl͕ɥ}ѕхѥ}յulѕɹ}ѕхѥ}}չЉt(مՕlمՕ}յulѕɹ}مՕ}ɽ}}չЉt(l}յul݅ɹ}չЉt((}չ(ѵ}х̀􀉍ɍ}}ѽ}ɭ}(݅ɹ}չ(ѵ}х̀􀉍ɍ}}ѽ}ɭ}ɕ}ݥѡ}݅ɹ̈(͔耀Ʌ聹ٕȀչɕݡѡ́ɕЁɥ́ѕɅȵ݅ɹ͕ѥ(ѵ}х̀􀉍ɍ}}ѽ}ɭ}ɕ䈀Ʌ聹ٕ((ɕɸ(}ѽ}ɭ}х̈聝ѵ}х̰(хɝ}Ʌ}مՕ}܈хɝ}Ʌ}مՕ}ܰ(хɝ}Ʌ}مՕ}聘-I\хɝ}Ʌ}مՕ}(ɕ}х̈耉}ɍ}}ѽ}ɭ}ɕ̈(ͽɍ}є耠( ɍѼɭЁɕ́́ɕ͕ɽՍа٥(ѥ̰хȁѥ͕́Ʌѕ䁙ɽȁͥɕ̰(ѕɹɽɽՍѥѕ쁥Ё́ЁمՅѥՅɅѕɍ͔(ѵаͥɑȰɽՍѥѥєȁɕٕՔɽ((}ѽ}ɭ}յ(ѕ}չЈ聱ѵ}ѕ̤(ɕ}չЈхѕ}չ̹Рɕ䈰(݅ɹ}չЈ݅ɹ}չа(}չЈ聉}չа(}ͥɕ}}չЈ聉}ͥɕ}}չа(ѕɹ}}ɽՍѥ}}չЈ聕ѕɹ}}ɽՍѥ}}չа(ɕ٥}ɽ}}Ȉ聍͕lɕ٥}ɽ}ul}ȉt((}ѽ}ɭ}ѕ̈聝ѵ}ѕ̰(ɕѕ}̈聍ɕѕ}̰(}ѽ}ɭ}х}ձ̈l((}ѽ}ɭ}х̈耉ɍ}}ѽ}ɭ}ɕ䈰(ձ耉͔مՔ͕ɥ䰁٥ͅ䰁ѥ̰хȁѥ̰ȁ̰ѕɹɽɕ٥܁䰁٥ɔɕ䈰(((}ѽ}ɭ}х̈耉ɍ}}ѽ}ɭ}ɕ}ݥѡ}݅ɹ̈(ձ耉ɕQ4Ё́ɕݡȁͥɕ̰ՑнA<A͕ɥ䁅хɽՍѥѕ䰁ɕɕɽѕ͍ȁѡɐ䁅ѕхѥɕЁ݅ɹ̈(((}ѽ}ɭ}х̈耉ɍ}}ѽ}ɭ}(ձ耉ͥQ4Ё٥ɕєɽՍЁаA$ɅЁɔյЁ͵э͕ɥ䁙ɔȁ Ё́ͅQ4ɕ̈((t(ɕ٥}ɽ}聍͕lɕ٥}ɽ}t(ɕѕ}չѥ}ɕ̈(ɍ}͕}х̈聍͕l͕}х̉t(ɍ}مՕ}х̈مՕlمՕ}х̉t(ɍ}͕ɥ}ѕхѥ}х͕̈ɥl͕ɥ}ѕхѥ}х̉t(ɍ}}х̈聕l}х̉t(}}х̈聡lչ}х̉t(ͅ}х̈ͅlͅ}х̉t(͕lɕѕ}չѥ}ɕ̉t((Ʌ}}ͥ聍͕lɅ}}ͥt(՝}Ʌ聍͕l՝}Ʌt(}ѽ}ɭ}̈(}ͥ}耉輽ܹͥi5]!Ii9](}ɐ耉輽ܹɐ]5M!!MA4(չѥ}Ј耈Ľɍ}}ѽ}ɭ}ɕ̽ѕЈ(յхѥ耉̽ɍ}}ѽ}ɭ}ɕ̹((((ɍ}չ}ɕ}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(ɕ͕}ѡɥ5mȰt99(mȰt(Iɸѡȁչɥɕ́єٕȁɍ٥(Ѵ͕ɍ}}ѽ}ɭ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ(ɕ͕}ѡɥɕ͕}ѡɥ((Ʌѥ͕̀ɍ}Ʌѥ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ(ɕ͕}ѡɥɕ͕}ѡɥ((ɑ͕ɍ}ɑ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ(ɕ͕}ѡɥɕ͕}ѡɥ((х͕ɍ}х}}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ѥ͕̀ѥ}͹͡С}չ}չ̤(}хє͕}хє(ɽЀAѠ}}}|ɕͽٔɕlt((}ѠȤ(ɕɸɽЀѠ}((ɕѕ}̀l(ѵlɕѕ}̉t(Ʌѥlɕѕ}̉t(ɑlɕѕ}̉t(хlɕѕ}̉t(t(ɕѕ}̀􁱥Сйɽ̡ɕѕ}̤(չ}ѕ̀l((ѕ}耉}ѽ}ɭ}Ј(耉ѼɭЁЈ(ݹȈ耉ݹȈ(ͽɍ̈l(Ľɍ}}ѽ}ɭ}ɕ̽ѕЈ(̽ɍ}}ѽ}ɭ}ɕ̹(t(٥}耉ɕͥѽ}}չѥ}ѥЈ(ѥ}хє耉ɕ(ѵl}ѽ}ɭ}х̉t􀉍ɍ}}ѽ}ɭ}(}̽ɍ}}ѽ}ɭ}ɕ̹(͔(٥聘}ѽ}ɭ}хѵl}ѽ}ɭ}х̝u(ѥ耉U͔ѡQ4Ё́ѡչɥ䁕٥(}ɥѕɥ耉 ȁЁѡչЁݥѡЁɕѥЁ́ͥȁɽՍѥɽ(((ѕ}耉չѥ}չ}Ѡ(耉IչѥչѠ(ݹȈ耉AљɴɅѽȈ(ͽɍ̈l(I5(ѕՅ}ɍɅѽȽ͕ٕȹ䈰(ѕՅ}ɍɅѽȽ}Ʌй䈰(̽ɕ}}ͥ(Ľнѥ̈((t(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ((}Ѡ(ȁѠ(I5(ѕՅ}ɍɅѽȽ͕ٕȹ䈰(ѕՅ}ɍɅѽȽ}Ʌй䈰(̽ɕ}}ͥ(((͔(٥耉Mё͕ٕȰ=$ѥаͽIMPɅЁɔɕ͕и(ѥ耉Iոѡѥ͕ٕȁA$͵ѕ́ȁȁɥ͕(}ɥѕɥ耉 ȁхЁѡչѥѡѥє̰Ёչɕ́)M=8(((ѕ}耉х}ѕ}Ј(耉хѕЁЈ(ݹȈ耉Qɕ٥ݕȈ(ͽɍ̈l(Ľɍ}х}̽ѕЈ(ѕ̽ѕ}ɍ}х}䈰(ѕ̽ѕ}ɍ}}ѽ}ɭ}ɕ̹䈰(ѕ̽ѕ}ɍ}չ}ɕ̹䈰(ѕЀĈ(t(٥}耉ɕ}(ѥ}хє耉ɕ(хlх}х̉t􀉍ɍ}х}((}Ѡ(ȁѠ(ѕ̽ѕ}ɍ}х}䈰(ѕ̽ѕ}ɍ}}ѽ}ɭ}ɕ̹䈰(ѕ̽ѕ}ɍ}չ}ɕ̹䈰(((͔(٥聘х}х텍хlх}х̝u(ѥ耉U͔͕хչѕ́́ѡٕɥѥи(}ɥѕɥ耉͕չQ4хA$ѥЁѕ́́ɔȁ(((ѕ}耉Ʌѽ}չ}Ј(耉=ɅѽȁչЈ(ݹȈ耉 ѽȁՍ́љɴݹȈ(ͽɍ̈l(Ľɍ}Ʌѥ}ɕ̽ѕЈ(Ľɍ}ɑ}ɕ̽ѕЈ(̽ɍ}Ʌѥ}ɕ̹(̽ɍ}ɑ}ɕ̹(t(٥}耉ɕͥѽ}}չѥ}ѥЈ(ѥ}хє耉ɕ(ɅѥlɅѥ}х̉t􀉍ɍ}Ʌѥ}(ɑlɑ}х̉t􀉍ɍ}ɑ}(}̽ɍ}Ʌѥ}ɕ̹(}̽ɍ}ɑ}ɕ̹(͔(٥耠(Ʌѥ}хɅѥlɅѥ}х̝u쀈(ɑ}хɑlɑ}х̝u((ѥ耉хɑɅѥ́ɕ́́ѡչչ(}ɥѕɥ耉 ȁ͕́хѥаѕ䰁ахݹ̸(((ѕ}耉}͕م}Ј(耉͕مЈ(ݹȈ耉AɽՍЁͥݹȈ(ͽɍ̈lхєѕՅ}ɍɅѽȽ䈰͍̽ɕ}ͥt(٥}耉ɕͥѽ}}չѥ}ѥЈ(ѥ}хє耉ɕ(}хѕl̉t}ѕՅ}ɍɅѽȽ䈤}͍̽ɕ}ͥ(͔(٥耠(}չ}хѕl̝t쀈(ə͕́չͽɍɕа݅ɹյɥ̸((ѥ耉U͔ѡɕЁ͕مəɅѡȁѡ͕Ʌє́͡ͅɐ(}ɥѕɥ耉=Ʌѽȁɕ٥܁չɕ́ɽѡѥͽ(((ѕ}耉}٥ɽ}̈(耉 ȁ٥ɽЁ̈(ݹȈ耉 ȁхѥݹȁљɴɅѽȈ(ͽɍ̈lȁ٥ɽЁUI0嵕Ёѽ䈰ѽфɕѕѥͥt(٥}耉}٥ɽ}ɕեɕ(ѥ}хє耉݅ɹ(ͽɍ}}х̈耉}٥ɽ}ɕեɕ(٥耉 ȁ嵕ЁUI0ѽ䰁ɕѥ́ɕѕѥݽɬ䁅ɔЁɕ٥(ѥ耉 Ёȁ٥ɽЁх́ȁхЁɥ̸͍ٕ݅(}ɥѕɥ耉 ȁɽ٥́٥ɽЁ́ȁɕ́ѡչ́ѕѼɕᕍѥ(((ѕ}耉ɽՍѥ}ѕ}̈(耉AɽՍѥѕ䁥̈(ݹȈ耉=Ʌѥ́ѥ́ݹȈ(ͽɍ̈l(Ľɍ}Ʌѥ}ɕ̽ѕЈ(Ľѥ}͹̽͡ѕЈ(ɽՍѥɕՕЁ̈(Ёɥɕɐ(ɕѽɔɽ(t(٥}耉ɽ͕}չѥ}ɽՍѥ(ѥ}хє耉݅ɹ(ͽɍ}}х̈耉ɽՍѥ}}ɕեɕ(٥耠(Ʌѥ}ɽՍѥ}٥}ѥ}չ(ɅѥlɅѥ}յulɽՍѥ}٥}ѥ}չНu쀈(ѥ}ɕ}х텹ѥlɕ}х̝u((ѥ耉 ɔɽՍѥѕ䰁M1<٥Ёɥɕѽɔɽѡȁ٥ɽи(}ɥѕɥ耉ЁɽՍѥѕ͹͡ЁɅѥ́ɽɔхȁѱٕ݅(((ѕ}耉ɍ}ͥɕ}̈(耉 ɍͥɔ̈(ݹȈ耉 ȁͽȰɽɕЁݹȰݹȈ(ͽɍ̈lͥɑȽ5MA͕ɥ䁅хɍ͔ɑȈٔѡɥѥt(٥}耉}ͥɕ}ɕեɕ(ѥ}хє耉݅ɹ(ͽɍ}}х̈耉}ͥɕ}ɕեɕ(٥耠(}ͥɕ}}չѵl}ѽ}ɭ}յul}ͥɕ}}չНu쀈(ͥɑȰA͕ɥ䁅хՑнA<ٔѡɥѥɔȁ̸((ѥ耉 Ёͥɕ̰ɽم̰ȁٕ݅́ɔɕɕ͕ѥչɕ͕́́ݽ(}ɥѕɥ耉 ȁ́ͥɔA͕ɥ䰁Ցа̸ٔ(((ѕ}耉ɕ٥}ɽ}䈰(耉I٥܁ɽ́䈰(ݹȈ耉ݹȈ(ͽɍ̈l̽ɍ}չ}ɕ̹̽ɍ}}ѽ}ɭ}ɕ̹t(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ䈰(٥耉I٥܁ɽ́䁥́Ёչȁչ́ɕєɔ́ɽՍ(ѥ耉 ѥՔչɕ́ݽɬݡՕՕɕ٥܁ɽ͕́ɔ(}ɥѕɥ耉=䁍ɕєɽՍа͕ɥ䰁A$ɅаȁյЁɕ́չɕ̸(((ѕ}耉}ͥ(耉Aͥ(ݹȈ耉AɽɕЁ͕ɥɕ٥ݕȈ(ͽɍ̈l̽Ʌ}ɕ͕ɍ̽ɍ}՝}Ʌѥ}t(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ(ѵlɅ}}ͥulͥt􀉭}ͥ}ɽՍЈ(͔݅ɹ(٥聝ѵlɅ}}ͥulɕͽt(ѥ耉-光ѕɥ͔ɽɽՍЁչѥɅѥɥ́ɔɕ(}ɥѕɥ耉Ёɕє͕ɅєɅ䰁ЁՉձȁɅѕȁѡ́չє((t(хѕ}չ̀ չѕȡѕlѥ}хєtȁѕչ}ѕ̤(}չЀхѕ}չ̹Рɕѕ}̤(݅ɹ}չЀхѕ}չ̹Р݅ɹ(}٥ɽ}}չЀմ(āȁѕչ}ѕ́ѕРͽɍ}}х̈􀉉}٥ɽ}ɕեɕ((ɽՍѥ}ѕ}}չЀմ(āȁѕչ}ѕ́ѕРͽɍ}}х̈ɽՍѥ}}ɕեɕ((ɍ}ͥɕ}}չЀմ(āȁѕչ}ѕ́ѕРͽɍ}}х̈􀉉}ͥɕ}ɕեɕ((ѕɹ}}ɽ}չЀ(}٥ɽ}}չЀɽՍѥ}ѕ}}չЀɍ}ͥɕ}}չ((}չ(չ}х̀􀉍ɍ}չ}(݅ɹ}չ(չ}х̀􀉍ɍ}չ}ɕ}ݥѡ}݅ɹ̈(͔耀Ʌ聹ٕȀչɕݡѡ́ɕЁɥ́ѕɅȵ݅ɹ͕ѥ(չ}х̀􀉍ɍ}չ}ɕ䈀Ʌ聹ٕ((ɕɸ(չ}х̈聱չ}х̰(хɝ}Ʌ}مՕ}܈хɝ}Ʌ}مՕ}ܰ(хɝ}Ʌ}مՕ}聘-I\хɝ}Ʌ}مՕ}(ɕ}х̈耉}ɍ}չ}ɕ̈(ͽɍ}є耠( ɍչɕ́́ɕQ4չѥхɅѽȰ(ѥ̰ɕ٥ܵɽ̰٥͕Ʌѕ䁙ɽȁ٥ɽа(ɽՍѥѕ䰁ɍͥɔ쁥Ё́ЁمՅѥՅɅѕ(ɍ͔ѵаͥɑȰɽՍѥѥєȁɕٕՔɽ((չ}յ(ѕ}չЈ聱չ}ѕ̤(ɕ}չЈхѕ}չ̹Рɕ䈰(݅ɹ}չЈ݅ɹ}չа(}չЈ聉}չа(ѕɹ}}ɽ}չЈ聕ѕɹ}}ɽ}չа(}٥ɽ}}չЈ聉}٥ɽ}}չа(ɽՍѥ}ѕ}}չЈɽՍѥ}ѕ}}չа(ɍ}ͥɕ}}չЈ聍ɍ}ͥɕ}}չа(ɕ٥}ɽ}}Ȉ聝ѵlɕ٥}ɽ}ul}ȉt((չ}ѕ̈聱չ}ѕ̰(ɕѕ}̈聍ɕѕ}̰(չ}х}ձ̈l((չ}х̈耉ɍ}չ}ɕ䈰(ձ耉Q4չѥхɅѽȰȁ٥ɽаɽՍѥѕ䰁ɍͥɔɕ٥܁䰁٥ɔɕ䈰(((չ}х̈耉ɍ}չ}ɕ}ݥѡ}݅ɹ̈(ձ耉ɕչЁ́ɕݡȁ٥ɽаɽՍѥѕ䰁ȁɍͥɔ́ɕЁ݅ɹ̈(((չ}х̈耉ɍ}չ}(ձ耉ͥչЁ٥ɕєɽՍЁаA$ɅЁɔյЁ͵э͕ɥ䁙ɔȁ Ё́ͅչɕ̈((t(ɕ٥}ɽ}聝ѵlɕ٥}ɽ}t(ɕѕ}չѥ}ɕ̈(ɍ}}ѽ}ɭ}х̈聝ѵl}ѽ}ɭ}х̉t(ɍ}Ʌѥ}х̈聽ɅѥlɅѥ}х̉t(ɍ}ɑ}х̈聽ɑlɑ}х̉t(ɍ}х}х̈聅хlх}х̉t(ѥ}ɕ}х̈聅ѥlɕ}х̉t(ѵlɕѕ}չѥ}ɕ̉t((Ʌ}}ͥ聝ѵlɅ}}ͥt(՝}Ʌ聝ѵl՝}Ʌt(չ}̈(}ͥ}耉輽ܹͥi5]!Ii9](}ɐ耉輽ܹɐ]5M!!MA4(չѥ}Ј耈Ľɍ}չ}ɕ̽ѕЈ(յхѥ耉̽ɍ}չ}ɕ̹((((ɍ}ѥ}͍ɕɑ}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(ɕ͕}ѡɥ5mȰt99(mȰt(Iɸѡ-I\ɍѥ͍ɕɐ(ɍ͕ɍ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((Ѵ͕ɍ}}ѽ}ɭ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ(ɕ͕}ѡɥɕ͕}ѡɥ((չ͕ɍ}չ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ(ɕ͕}ѡɥɕ͕}ѡɥ((ѥ͕̀ѥ}͹͡С}չ}չ̤(}хє͕}хє(ɽЀAѠ}}}|ɕͽٔɕlt((}ѠȤ(ɕɸɽЀѠ}((ɕѕ}̀􁱥Сչlɕѕ}̉t(ɍlɍ}х̉t􀉹}ɍ}ɕ(ɕѕ}̹ɍ}ɕ}(չlչ}х̉t􀉍ɍ}չ}(ɕѕ}̹ɍ}չ}(ɕѕ}̀􁱥Сйɽ̡ɕѕ}̤(͍ɕɑ}ѕ̀l((ѕ}耉ɽՍ}ͥ}٥(耉AɽՍЁͥ٥(ݹȈ耉AɽՍЁͥݹȈ(ͽɍ̈l(̽՝}ɥٕ}ͥ}ɥ(̽ɍ}՝}Ʌѥ}(͍̽ɕ}ͥ((Ľɍ}ɕ̽ѕЈ(t(٥}耉ɕͥѽ}}չѥ}ѥЈ(ѥ}хє耉ɕ((}Ѡ(ȁѠ(̽՝}ɥٕ}ͥ}ɥ(̽ɍ}՝}Ʌѥ}(͍̽ɕ}ͥ(((}хѕl̉t(͔(٥耉 ȰɅѽȰ͕ɥ位ɽɕЁݽɭ́Ѽɕ́٥(ѥ耉-ȁ٥ѡ́٥ͥѡѥɽ(}ɥѕɥ耉ٕͽ́ɽՍнA$́٥Ѡ(((ѕ}耉}ѥ̈(耉ѥ̈(ݹȈ耉ݹȈ(ͽɍ̈l(̽}ѥ̹(輽ܹͥi5]!Ii9](輽ܹɐ]5M!!MA4(t(٥}耉}ѥЈ(ѥ}хє耉ɕ䈁}̽}ѥ̹͔(٥耉хͥ)Ʌ̰хȁѥЁɕɑ́ЁݥѡЁ и(ѥ耉U͔)ѥ́ȁхȁɕ٥܁ݥѡЁɅѥ Ёхф(}ɥѕɥ耉ѥ́ɔɕɑ Ёɕ́չ͕(((ѕ}耉ݕ}}٥(耉Mݕ́٥(ݹȈ耉%хѥݹȈ(ͽɍ̈l(̽ݕ̼̽شܴȵɍѥ͍ɕɐչѥ(̽ݕ̼̽شܴȵɍչɕ̹(ѕ̽ѕ}ɍ}ѥ}͍ɕɐ䈰(t(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ(}̽ݕ̼̽شܴȵɍѥ͍ɕɐչѥ(}ѕ̽ѕ}ɍ}ѥ}͍ɕɐ䈤(͔(٥耉ѕ͕́ѕ̰́ѕɕ̰хѥٕɥѥ̸(ѥ耉-Qٕ́ɥѥ́ѕݥѠѡ͍ɕɐ(}ɥѕɥ耉A͕ѕЁЁȁѡչѥ͍ɕɐ(((ѕ}耉х}}ͥ(耉Aхͥ(ݹȈ耉AɽɕЁ͕ɥɕ٥ݕȈ(ͽɍ̈l̽Ʌ}ɕ͕ɍ̽ɍ}՝}Ʌѥ}t(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ(չlɅ}}ͥulͥt􀉭}ͥ}ɽՍЈ(͔݅ɹ(٥聱չlɅ}}ͥulɕͽt(ѥ耉-ɕͥѽ䁅光ɽՍЁչѥɅѥɥ́ɔɕ(}ɥѕɥ耉9͕ɅєɅ䰁ЁՉձȁɅѕ́ɕѕȁѡ́ɕи(((ѕ}耉х}ѥ}ѡձ̈(耉фѥ́ѡձ̈(ݹȈ耉ѥ́ݹȈ(ͽɍ̈l(̽ѥ}(Ľѥ}͹̽͡ѕЈ(Ľɍ}չ}ɕ̽ѕЈ(t(٥}耉ɕ}(ѥ}хє耉ɕ(}̽ѥ}ѥlɕ}х̉t􀉱}չѥ}͹͡Ј(͔(٥耉5ɕ٥ɽ͕ɽՍѥȁȵ́ɔ͕Ʌѕ(ѥ耉Ёɕ͕Ёɽ͕ȁȁɽՍѥ́́ɕɽՍЁɕձ̸(}ɥѕɥ耉ٕ䁍ɍ-A$́٥ͽɍхѥ(((ѕ}耉չѥ}}(耉IչѥЁ(ݹȈ耉AљɴɅѽȈ(ͽɍ̈l(Ľɍ}ɕ̽ѕЈ(Ľɍ}}ѽ}ɭ}ɕ̽ѕЈ(Ľɍ}չ}ɕ̽ѕЈ(Ľɍ}ѥ}͍ɕɑ̽ѕЈ(t(٥}耉ɕͥѽ}}չѥ}ѥЈ(ѥ}хє耉ɕ(ɍlɍ}х̉t􀉹}ɍ}ɕ(ѵl}ѽ}ɭ}х̉t􀉍ɍ}}ѽ}ɭ}(չlչ}х̉t􀉍ɍ}չ}(͔(٥耠(ɍ}х퍽ɍlɍ}х̝u쀈(}ѽ}ɭ}хѵl}ѽ}ɭ}х̝u쀈(չ}хչlչ}х̝u((ѥ耉͔ѥх́ѡɽ՝ѡͅɽѕѕչѥA$(}ɥѕɥ耉Iչѥ́٥є(((ѕ}耉ٕɥѥ}Ј(耉YɥѥЈ(ݹȈ耉Qɕ٥ݕȈ(ͽɍ̈l(ѕ̽ѕ}ɍ}ѥ}͍ɕɐ䈰(ѕ̽ѕ}ɍ}չ}ɕ̹䈰(ѕ̽ѕ}՝}ɥٕ}ѥ̹䈰(ѕ̽ѕ}}Ʌй䈰(ѕЀĈ(t(٥}耉ɕ}(ѥ}хє耉ɕ((}Ѡ(ȁѠ(ѕ̽ѕ}ɍ}ѥ}͍ɕɐ䈰(ѕ̽ѕ}ɍ}չ}ɕ̹䈰(ѕ̽ѕ}՝}ɥٕ}ѥ̹䈰(ѕ̽ѕ}}Ʌй䈰(((͔(٥耉͕ѥչѥаA$ɅЁѕ́ɔɕ͕и(ѥ耉Iո͕ѕ́ձѕЁɔɕ͕ѥѥх̸(}ɥѕɥ耉͕ѕ̰ձѕа坥̸(((ѕ}耉ɕ٥}ɽ}䈰(耉I٥܁ɽ́䈰(ݹȈ耉ݹȈ(ͽɍ̈l̽ɍ}ѥ}͍ɕɐ̽ɍ}չ}ɕ̹t(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ䈰(٥耉I٥܁䰁ɕ٥܁䰁ՕՕɕ٥܁ѽѥɔЁɽՍЁ̸(ѥ耉 䁽ɕє͕ɥ䰁A$Ʌаյаȁչѥ̸(}ɥѕɥ耉I٥܁ɽ́ɕ́ݥѡЁɕєɔ٥(((ѕ}耉ɽՍѥ}}̈(耉AɽՍѥȁܵ̈(ݹȈ耉 ȁͽȰɅѥ́ݹȰݹȈ(ͽɍ̈l(Ľɍ}չ}ɕ̽ѕЈ(ȁ٥ɽЈ(ɽՍѥѕ䈰(ɍͥɕ̈(t(٥}耉ѕɹ}}ɕեɕ(ѥ}хє耉݅ɹ(ͽɍ}}х̈耉ѕɹ}}ɕեɕ(٥耠(ѕɹ}}ɽ}չչlչ}յulѕɹ}}ɽ}չНu쀈(}ͥɕ}}չѵl}ѽ}ɭ}յul}ͥɕ}}չНu((ѥ耉 Ёȁ٥ɽаɽՍѥѕ䰁ͥɔ́ȁЁ̸ٕ݅(}ɥѕɥ耉 ȁ́ȁٕ݅́ɕѕɹ̸((t(хѕ}չ̀ չѕȡѕlѥ}хєtȁѕ͍ɕɑ}ѕ̤(}չЀхѕ}չ̹Рɕѕ}̤(݅ɹ}չЀхѕ}չ̹Р݅ɹ(}չ(ѥ}х̀􀉍ɍ}ѥ}(݅ɹ}չ(ѥ}х̀􀉍ɍ}ѥ}ɕ}ݥѡ}݅ɹ̈(͔耀Ʌ聹ٕȀչɕݡѡ́ɕЁɥ́ѕɅȵ݅ɹ͕ѥ(ѥ}х̀􀉍ɍ}ѥ}ɕ䈀Ʌ聹ٕ((ɕɸ(ѥ}х̈聍ѥ}х̰(хɝ}Ʌ}مՕ}܈хɝ}Ʌ}مՕ}ܰ(хɝ}Ʌ}مՕ}聘-I\хɝ}Ʌ}مՕ}(ɕ}х̈耉}ɍ}ѥ}͍ɕɐ(ͽɍ}є耠( ɍѥ͍ɕɐɕѕ́ɕɽՍЁͥMݕ̰(Aхфѥ̰չѥٕɥѥɕ٥ܵɽ̰٥(͕Ʌѕ䁙ɽȁɽՍѥܵ쁥Ё́ЁمՅѥՅɅѕɍ͔(ѵаͥɑȰɽՍѥѥєȁɕٕՔɽ((ѥ}յ(ѕ}չЈ聱͍ɕɑ}ѕ̤(ɕ}չЈхѕ}չ̹Рɕ䈰(݅ɹ}չЈ݅ɹ}չа(}չЈ聉}չа(ѕɹ}}ɽ}չЈ聱չlչ}յulѕɹ}}ɽ}չЉt(ɕ٥}ɽ}}Ȉ聱չlɕ٥}ɽ}ul}ȉt(}}͕͔((ѥ}ѕ͍̈ɕɑ}ѕ̰(ɕѕ}̈聍ɕѕ}̰(ѥ}х}ձ̈l((ѥ}х̈耉ɍ}ѥ}ɕ䈰(ձ耉ɽՍЁͥMݕ̰Aхфѥ̰չѥٕɥѥɕ٥܁䰁ѕɹ́ɔɕ䈰(((ѥ}х̈耉ɍ}ѥ}ɕ}ݥѡ}݅ɹ̈(ձ耉ɕɽɅѥ٥́ɕݡȁ٥ɽаɽՍѥѕ䰁ɍͥɕ̰ȁѡȁѕɹ́ɕЁ݅ɹ̈(((ѥ}х̈耉ɍ}ѥ}(ձ耉͕ɥ䁙ɔA$ɅЁɕɕͥյЁ͵эɕɽՍɽՍЁаͥѥ٥ȁ Ё́ͅѥ((t(ɕ٥}ɽ}聱չlɕ٥}ɽ}t(ɕѕ}չѥ}ɕ̈(ɍ}ɕ}х̈聍ɍlɍ}х̉t(ɍ}}ѽ}ɭ}х̈聝ѵl}ѽ}ɭ}х̉t(ɍ}չ}х̈聱չlչ}х̉t(ѥ}ɕ}х̈聅ѥlɕ}х̉t((Ʌ}}ͥ聱չlɅ}}ͥt(՝}Ʌ聱չl՝}Ʌt(ѥ}̈(}ͥ}耉輽ܹͥi5]!Ii9](}ɐ耉輽ܹɐ]5M!!MA4(չѥ}Ј耈Ľɍ}ѥ}͍ɕɑ̽ѕЈ(յхѥ耉̽ɍ}ѥ}͍ɕɐ((((ɍ}}х}ݽɭ}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(mȰt(Iɸݹȵ͍ȁхݽɭ܁٥(х͕ɍ}х}}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ѥ͕ɍ}ѥ}͍ɕɑ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((͕ɍ}}չ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ѥ͕̀ѥ}͹͡С}չ}չ̤(ɽЀAѠ}}}|ɕͽٔɕlt((}ѠȤ(ɕɸɽЀѠ}((}̠ѡȤ(ɕɸ}ѠȁѠѡ̤((ѕ(ѕ}Ȱ(Ȱ(ݹȰ(ͽɍ聱mt(٥}Ȱ(ѥ}хєȰ(٥Ȱ(ͥ}ձȰ(}ѥȰ(mȰt(ɕեɕ}}ѕ}}х}ݽɭܹѕ}(ѥ}хєЁɕ䈰݅ɹ耀Ʌ聹ٕ(Ʌ͔YՕɽȠȁхݽɭ܁хєЁɕ䰁݅ɹȁ(ɕɸ(ѕ}ѕ}(聱(ݹȈ聽ݹȰ(ͽɍ̈ͽɍ̰(٥}聕٥}(ѥ}хє聍ѥ}хє(٥聕٥(ͥ}ձ聑ͥ}ձ(}ѥ聹}ѥ(((ɕѕ}̀􁱥Сйɽ̡хlɕѕ}̉tѥlɕѕ}̉t(х}􁅍хlх}х̉t􀉍ɍ}х}(ѥ}􁍽ѥlѥ}х̉t􀉍ɍ}ѥ}(}չѥ}хє􀉉х}ȁѥ}ȁɕѕ}͔́ɕ(ݽɭ}ѕ̀l(ѕ(ɵ}ɽՍ}͍( ɴɽՍЁ͍(AɽՍЁݹȈ(lI5̽ɽՍ}̽ɍ}ɕ̹t(ɕͥѽ}ѥЈ(ɕ䈁}̠I5̽ɽՍ}̽ɍ}ɕ̹͔(AɽՍЁɕ́ѕɥ͔ɍɅѥɽ(Aɽݡѡȁɕ٥́ѥA$́٥ə(IѽɔɽՍЁ͍́ɔȁх((ѕ(ɵ}ѕɅѥ}ə( ɴѕɅѥə(Aљɴɕ٥ݕȈ(lĽнѥ̈̽ɕ}}ͥѕ̽ѕ}}Ʌйt(ɕͥѽ}ѥЈ(ɕ䈁}̠̽ɕ}}ͥѕ̽ѕ}}Ʌй䈤͔(=$ѥA$A$ɅЁѕ́ɔɕ͕и(AɽݡA$ѥ䁕٥́ɕ͕Ёѕ̸́(IѽɔIMṔȁA$ɅЁѕ́ɔȁх((ѕ(ɵ}Ʌѽ}٥( ɴɅѽȁ٥(AљɴɅѽȈ(lхє͍̽ɕ}ͥѕՅ}ɍɅѽȽt(ɕͥѽ}ѥЈ(ɕ䈁}̠͍̽ɕ}ͥѕՅ}ɍɅѽȽ䈤͔(ͽ͕́Ʌѽȁ٥ȁ䰁Ʌ̰ɕ䰁ѥ̰ɕ̸(AɽݡɅѽȁхєɍɕ́ə́ɔ٥ͥ(Iѽɔ٥́ȁхѥɔȁх((ѕ(ɵ}ɕ}̈( ɴɕ́̈(AɽՍЁݹȈ(l(Ľͅ}ɕ̽ѕЈ(Ľɍ}ɕ̽ѕЈ(Ľɍ}х}̽ѕЈ(Ľɍ}ѥ}͍ɕɑ̽ѕЈ(t(ɕ}(}չѥ}хє((ɍ}х}х텍хlх}х̝u쀈(ɍ}ѥ}х퍽ѥlѥ}х̝u((Aɽݡչѥѕ́ٔɕє̸(Iͽٔɕ̰хȁѥѕ́ɔȁх((ѕ(ɵ}͕ɥ}ɔ( ɴ͕ɥɔ(Mɥɕ٥ݕȈ(lM UI%Qdѕ̽ѕ}͕ɥ}ɑ䈰ѡՈݽɭ͕̽ɥ嵰t(ɕͥѽ}ѥЈ(ɕ䈁}̠M UI%Qdѕ̽ѕ}͕ɥ}ɑ䈰ѡՈݽɭ͕̽ɥ嵰͔(Mɥ䰁ɑѕ̰ѕ͕ɥݽɭ܁хфɔɕ͕и(Aɽݡɕє͕ɥ䁙ɕ́ɔ͕и(ɕє͕ɥ䁙ɕՕՕ͕ɥ䁍́ɔЁ̸((ѕ(ɵ}ɥ}䈰( ɴɥ䈰(ѥ́ɕ٥ݕȈ(lĽѥ}͹̽͡ѕЈ̽ѥ}t(ɕ}(ɕ䈁}̽ѥ}ѥlɕ}х̉t􀉱}չѥ}͹͡Ј͔(ѥ́͹͡Ё͕Ʌєɕ٥ɽɽ͕ɽՍѥȁȁ̸(Aɽݡɕɽ͕́ɔЁᕐ(Iѽɔѥ́ͽɍ́ɔȁх((ѕ(ɵ}٥Յ}ɕ٥}Ѡ( ɴ٥Յɕ٥܁Ѡ(Mхȁɕ٥ݕȈ(l̽}ѥ̹ͥ)ɐḾt(}ѥЈ(ɕ䈁}̽}ѥ̹͔(хͥ)хȁѥ́ɔɕɑݥѡЁ и(Aɽݡ٥Յѥ́ɔمȁхȁɕ٥ܸ(Iɐѥ́ɔȁх((ѕ(ɵ}}ͥ( ɴͥ(AɽɕЁɕ٥ݕȈ(l̽Ʌ}ɕ͕ɍ̽ɍ}՝}Ʌѥ}t(ɕͥѽ}ѥЈ(ɕ䈁ѥlɅ}}ͥulͥt􀉭}ͥ}ɽՍЈ͔݅ɹ(ѥlɅ}}ͥulɕͽt(AɽݥѠɕͥѽ䁅光ɽՍи(ɅЁ䁅ѕȁ͕ɽՍаЁɕ͔ȁɽٕɥȁ̸((ѕ(ɵ}ɽՍѥ}̈( ɴɽՍѥ̈(=Ʌѥ́ݹȈ(lɽՍѥѕ䈰ЁM1<٥Ёɥt(ɽ͕}չѥ}ɽՍѥ(݅ɹ(AɽՍѥѕ䰁аM1<Ё٥ɕեɔ嵕Ёȁɑ٥ɽи(AɽݥѠ݅ɹݡɽՍѥ́ɔѱ䁍ٕѕ( ЁɽՍѥ٥ɥȁɑȁɬЁٕ݅ȸ((ѕ(ɵ}}}̈( ɴȵ̈( ȁչЁѕ(lI=$͕ɥՕѥɔɕ٥܈嵕ЁхɝЉt(ɽ͕}չѥ}}(݅ɹ(I=$ɽɕа嵕Ё́ɕեɔȸ(AɽݥѠ݅ɹݡȵ́ɔЁ̸ܵ( Ёȵ́ɥչЁ((t(хѕ}չ̀ չѕȡѕlѥ}хєtȁѕݽɭ}ѕ̤(}չЀхѕ}չ̹Рɕѕ}̤(݅ɹ}չЀхѕ}չ̹Р݅ɹ(}չ(ݽɭ}х̀􀉉}х}ݽɭ}(݅ɹ}չ(ݽɭ}х̀􀉉}х}ݽɭ}ɕ}ݥѡ}݅ɹ̈(͔耀Ʌ聹ٕȀչɕݡѡ́ɕЁɥ́ѕɅȵ݅ɹ͕ѥ(ݽɭ}х̀􀉉}х}ݽɭ}ɕ䈀Ʌ聹ٕ((ɕɸ(ݽɭ}х̈ݽɭ}х̰(хɝ}Ʌ}مՕ}܈хɝ}Ʌ}مՕ}ܰ(хɝ}Ʌ}مՕ}聘-I\хɝ}Ʌ}مՕ}(ɕ}х̈耉}}х}ݽɭ܈(ͽɍ}є耠( ɍȁхݽɭ܁́չݹ̰չѥ٥(ѥ̰ѥ́ѡձ̰ɕ٥ܵɽ́䰁(ͥѼ]ɹ9ѕ쁥Ё́ЁمՅѥՅɅѕ(ɍ͔ѵаͥɑȰɽՍѥѥє(ȁɕٕՔɽ((ݽɭ}յ(ѕ}չЈ聱ݽɭ}ѕ̤(ɕ}չЈхѕ}չ̹Рɕ䈰(݅ɹ}չЈ݅ɹ}չа(}չЈ聉}չа(ɽՍѥ}}}չЈմ(āȁѕݽɭ}ѕ́ѕl٥}tɽ͕}չѥ}ɽՍѥ((}}}}չЈմ(āȁѕݽɭ}ѕ́ѕl٥}tɽ͕}չѥ}}((ɕ٥}ɽ}}Ȉ聅хlɕ٥}ɽ}ul}ȉt(}}͕͔((х}ѕ̈ݽɭ}ѕ̰(ɕѕ}̈聍ɕѕ}̰(}݅ɹ}}}ձ̈l((ݽɭ}х̈耉}х}ݽɭ}ɕ䈰(ձ耉хݹ́ٔɕ䁕٥ѕɹɽՍѥȁȵ́ɕ(((ݽɭ}х̈耉}х}ݽɭ}ɕ}ݥѡ}݅ɹ̈(ձ耉ɕȁх٥́ɕݡɽՍѥȁȵ́ɕЁ݅ɹ̈(((ݽɭ}х̈耉}х}ݽɭ}(ձ耉͕ɥ䁙ɔA$ɅЁɕɕͥյЁ͵эɕɽՍɽՍЁаͥхѠȁ Ё́ͅх((t(ɕ٥}ɽ}聅хlɕ٥}ɽ}t(ɕѕ}չѥ}ɕ̈(ɍ}х}х̈聅хlх}х̉t(ɍ}ѥ}х̈聍ѥlѥ}х̉t(}}х̈聡lչ}х̉t(ѥ}ɕ}х̈聅ѥlɕ}х̉t((Ʌ}}ͥ聍ѥlɅ}}ͥt(՝}Ʌ聍ѥl՝}Ʌt(ݽɭ}̈(}ͥ}耉輽ܹͥi5]!Ii9](}ɐ耉輽ܹɐ]5M!!MA4(չѥ}Ј耈Ľɍ}}х}ݽɭ̽ѕЈ(յхѥ耉̽ɍ}}х}չ((((ɍ}}͍ɥ}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(mȰt(Iɸȵ͍ɥ́ȁѡ-I\ѥхɐ(ѥ͕ɍ}ѥ}͍ɕɑ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((}ݽɭ܀͕ɍ}}х}ݽɭ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ѥ͕̀ѥ}͹͡С}չ}չ̤(}хє͕}хє(ɽЀAѠ}}}|ɕͽٔɕlt((}ѠȤ(ɕɸɽЀѠ}((}̠ѡȤ(ɕɸ}ѠȁѠѡ̤((ѕ(ѕ}Ȱ(Ȱ(ͽȰ(ͽɍ聱mt(չѥ}聱mt(٥}Ȱ(ѥ}хєȰ(٥Ȱ(}ѥȰ(ѕ}٥Ȱ(mȰt(ɕեɕ}}ѕ}ɍ}ѕ}(ѥ}хєЁɕ䈰݅ɹ耀Ʌ聹ٕ(Ʌ͔YՕɽȠɍѕхєЁɕ䰁݅ɹȁ(ɕɸ(ѕ}ѕ}(聱(ͽͽ(ͽɍ̈ͽɍ̰(չѥ}̈չѥ}̰(٥}聕٥}(ѥ}хє聍ѥ}хє(٥聕٥(}ѥ聑}ѥ(ѕ}٥聕ѕ}٥(((ɕѕ}̀􁱥Р(йɽ̡ѥlɕѕ}̉t}ݽɭlɕѕ}̉t((}չѥ}хє((ѥlѥ}х̉t􀉍ɍ}ѥ}(ȁ}ݽɭlݽɭ}х̉t􀉉}х}ݽɭ}(ȁɕѕ}(͔ɕ((ٕ}չ̀􁅹ѥ̹Рٕ}չ̈(ɕ}չ̀􁅑}хєРɕ}ݽɭ}չ̈mt(}ѕ̀l(ѕ(ѥ}}͵( ѥA$͵(Ȉ(lI5̽ɕ}}ͥĽнѥ̉t(lĽнѥ̉t(ɕ}(ɕ(}̠I5̽ɕ}}ͥ(ٕ}չ̹Р}ѥ}ɕՕѕ(͔(Ս͙ձ}}ѥ}ٕٕ}չ̹Р}ѥ}ɕՕѕ(Iոѡ=$ѥЁѥ͕ѡȁѥ(Qȁ͕́ѥɕ͔ѡչѥɕɑ́ѥٕ́и((ѕ(Սѕ}ݽɭ}Ʌ( Սѕݽɭ܁Ʌ(AљɴɅѽȈ(lĽݽɭ}չ͍̈̽ɕ}ͥt(lĽݽɭ}չ̉t(ɕ}(ɕ䈁ɕ}չ́}͍̽ɕ}͔ͥ(ɕ}ݽɭ}չ}չɕ}չ̥(=ѡɅ٥܁ȁՍѕݽɭ܁ո(QɅѽȁЁ䁵͕ѕ̰ոɅ٥((ѕ(}}ѥ(̵Ёѥ( ɕ٥ݕȈ(l̽ɽՍ}Ľ}ɕ̽ݽɭ}չ}􈰀t(lĽ}ɕ̽ݽɭ}չ}􈰀t(ɕͥѽ}}չѥ}ѥЈ(ɕ䈁}̽ɽՍ}͔(́ɕ́ɔ͍Ѽݽɭ}չ}͕ѡɽ՝ѡə(=ѡ́ɕЁȁѡՍѕݽɭ܁ո(Qɕ٥ݕȁ͕́ݡ䁕Ё́Ѽѕаѽ̰Ʌ٥((ѕ(مՅѥ}ɕ䈰(مՅѥɕ䈰(EՅɕ٥ݕȈ(l͍̽ɕ}ͥĽمՅѥ}չ̈t(lĽمՅѥ}չ̈t(ɕ}(ɕ䈁ٕ}չ̹РمՅѥ}չ}ɕѕ͔(مՅѥ}չ}ɕѕ}ٕٕ}չ̹РمՅѥ}չ}ɕѕ(IѡȁɽЁѡɽ՝ѡمՅѥи(Qɕ٥ݕȁ͕́ɕх́Ʌٕɥѥ٥((ѕ(}ɕ}ͽ(ɕ́ͽ(Ȉ(l((Ľɍ}ѥ}͍ɕɑ̽ѕЈ(Ľɍ}}х}ݽɭ̽ѕЈ(Ľɍ}}͍ɥ̽ѕЈ(t(l((Ľɍ}ѥ}͍ɕɑ̽ѕЈ(Ľɍ}}х}ݽɭ̽ѕЈ(Ľɍ}}͍ɥ̽ѕЈ(t(ɕͥѽ}}չѥ}ѥЈ(}չѥ}хє((ɍ}ѥ}х퍽ѥlѥ}х̝u쀈(}х}ݽɭ}х}ݽɭlݽɭ}х̝u((M܁ѡɕ́ɐѡͽ(Qȁ͕́ѥȁхх́ݥѡЁ٥ɽ((ѕ(ɥ}ѡձ̈(5ɥѡձ̈( ɕ٥ݕȈ(l̽ѥ}Ľѥ}͹̽͡ѕЉt(lĽѥ}͹̽͡ѕЉt(ɕ}(ɕ(}̽ѥ}ѥlɕ}х̉t􀉱}չѥ}͹͡Ј(͔(ɕɥ́ɕ͕Ʌєɽɽ͕ɽՍѥȵɥ̈(I٥܁ѡѥ́ѥ́и(Qɕ٥ݕȁѥե͠ɕչѥфɽɽ͕-A$ѥ̸((ѕ(}х}ɕ٥܈(хȁɕ٥܈(Mхȁɕ٥ݕȈ(l(̽}ѥ̹(輽ܹͥi5]!Ii9](輽ܹɐ]5M!!MA4(t(mt(}ѥЈ(ɕ䈁}̽}ѥ̹͔(х)хȁѥ́ɔɕɑݥѡЁ Ј(]ѡɽ՝ѡͥ)Ʌи(Mх́ɕ٥܁ѡɽՍЁɅѥٔəչѥ܁́хѥ̸((ѕ(}х}ͥ( ȁхͥ(Ȉ(l(̽ɍ}}х}չ(Ľɍ}}х}ݽɭ̽ѕЈ(t(lĽɍ}}х}ݽɭ̽ѕЉt(ɕͥѽ}}չѥ}ѥЈ(}չѥ}хє(}х}ݽɭ}х}ݽɭlݽɭ}х̝u(U͔ѡȁхݽɭ܁́ѡ]ɹ9ͥɕɐ(Qȁͥɕ٥ݡѕɹܵ́х䁕и((ѕ(ɽՍѥ}}̈(AɽՍѥȁܵ̈(Ȉ(lɽՍѥѕ䈰I=$͕ɥՕѥɔЁt(mt(ɽ͕}չѥ}}(݅ɹ(AɽՍѥѕ䰁ȁI=$͕ɥՕѥɔЁɕեɔȁи( ɔȵɽՍѥI=$Ё́ѕȁѡ(ѕɹ́ɔɅ́݅ɹ̰Ё́ɕɽՍЁ٥((t(хѕ}չ̀ չѕȡѕlѥ}хєtȁѕ}ѕ̤(}չЀхѕ}չ̹Рɕѕ}̤(݅ɹ}չЀхѕ}չ̹Р݅ɹ(}չ(}х̀􀉍ɍ}}(݅ɹ}չ(}х̀􀉍ɍ}}ɕ}ݥѡ}݅ɹ̈(͔耀Ʌ聹ٕȀչɕݡѡ́ɕЁɥ́ѕɅȵ݅ɹ͕ѥ(}х̀􀉍ɍ}}ɕ䈀Ʌ聹ٕ(ɕեɕ}չѥ}̀􁱥Р(йɽ̠((ȁѕ}ѕ(ȁЁѕlչѥ}̉t(йхݥѠ((((ɕɸ(}х̈聑}х̰(хɝ}Ʌ}مՕ}܈хɝ}Ʌ}مՕ}ܰ(хɝ}Ʌ}مՕ}聘-I\хɝ}Ʌ}مՕ}(ɕ}х̈耉}ɍ}}͍ɥ̈(ͽɍ}є耠( ɍ͍ɥ́ɕչѥѥ̰(ȁхɕ٥ܵ䰁٥ȁ-I\Ȱ(ͅɕ٥쁥Ё́ЁمՅѥՅɅѕɍ͔ѵа(ͥɑȰɽՍѥѥєȁɕٕՔɽ((}Ʌѥٔ(ѥѱ耉-I\ɍɽȁ(ɽ͔耠(M܁ѕɥ͔ɍɅѥɽݥѠѥɕA$(ɅѽȽ٥Ʌ́٥ͥ䰁مՅѥɕ䰁ѡհɥ̸((Ցl(Ȉ(AљɴɅѽȈ( ɕ٥ݕȈ(EՅɕ٥ݕȈ(Mхȁɕ٥ݕȈ(t((}յ(ѕ}չЈ聱}ѕ̤(ɕ}չЈхѕ}չ̹Рɕ䈰(݅ɹ}չЈ݅ɹ}չа(}չЈ聉}չа(ͽ}չЈ聱ѕlͽtȁѕ}ѕ(}չЈ聱ɕեɕ}չѥ}̤(ɕ٥}ɽ}}Ȉ聍ѥlɕ٥}ɽ}ul}ȉt(}}͕͔((}ѕ̈聑}ѕ̰(ɕեɕ}չѥ}̈ɕեɕ}չѥ}̰(ɕѕ}̈聍ɕѕ}̰(}х}ձ̈l((}х̈耉ɍ}}ɕ䈰(ձ耉ѕ́ɔɕ䁅ɽՍѥȁȵܵ́ɕ(((}х̈耉ɍ}}ɕ}ݥѡ}݅ɹ̈(ձ耉ɕ٥́ɕݡɽՍѥI=$аȁȵ́ɕЁ݅ɹ̈(((}х̈耉ɍ}}(ձ耉͕ɥ䁙ɔA$ɅЁɕɕͥյЁ͵эչѥаͥ٥ȁ Ё́ͅѡ((t(ɕ٥}ɽ}聍ѥlɕ٥}ɽ}t(ɕѕ}չѥ}ɕ̈(ɍ}ѥ}х̈聍ѥlѥ}х̉t(}х}ݽɭ}х̈聉}ݽɭlݽɭ}х̉t(ѥ}ɕ}х̈聅ѥlɕ}х̉t((Ʌ}}ͥ聍ѥlɅ}}ͥt(՝}Ʌ聍ѥl՝}Ʌt(}̈(}ͥ}耉輽ܹͥi5]!Ii9](}ɐ耉輽ܹɐ]5M!!MA4(չѥ}Ј耈Ľɍ}}͍ɥ̽ѕЈ(յхѥ耉̽ɍ}}͍ɥ̹((((ɍ}ɽͅ}}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(mȰt(Iɸȁɽ͕ͅѥ́ȁѡ-I\ͅхɐ(ѥ͕ɍ}ѥ}͍ɕɑ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((͕ɍ}}͍ɥ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((}ݽɭ܀͕ɍ}}х}ݽɭ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((مՔ͕ɍ}مՕ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((͕ɥ͕ɍ}͕ɥ}ѕхѥ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ɅЀ͕ɍ}Ʌ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ɑ͕ɍ}ɑ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((Ʌѥ͕̀ɍ}Ʌѥ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ѥ͕̀ѥ}͹͡С}չ}չ̤(}хє͕}хє(ɽЀAѠ}}}|ɕͽٔɕlt((}ѠȤ(ɕɸɽЀѠ}((}̠ѡȤ(ɕɸ}ѠȁѠѡ̤((͕ѥ(͕ѥ}Ȱ(Ȱ(ݹȰ(ͽɍ聱mt(չѥ}聱mt(٥}Ȱ(ѥ}хєȰ(٥Ȱ(}ͅȰ(}ѥȰ(mȰt(ɕեɕ}}͕ѥ}ɍ}ɽ͕ͅѥ}(ѥ}хєЁɕ䈰݅ɹ耀Ʌ聹ٕ(Ʌ͔YՕɽȠɍɽ͕ͅѥхєЁɕ䰁݅ɹȁ(ɕɸ(͕ѥ}͕ѥ}(聱(ݹȈ聽ݹȰ(ͽɍ̈ͽɍ̰(չѥ}̈չѥ}̰(٥}聕٥}(ѥ}хє聍ѥ}хє(٥聕٥(}ͅ聉}ͅ(}ѥ聹}ѥ(((ɕѕ}̀􁱥Р(йɽ̠(ѥlɕѕ}̉t(lɕѕ}̉t(}ݽɭlɕѕ}̉t(((}չѥ}хє((ѥlѥ}х̉t􀉍ɍ}ѥ}(ȁl}х̉t􀉍ɍ}}(ȁ}ݽɭlݽɭ}х̉t􀉉}х}ݽɭ}(ȁɕѕ}(͔ɕ((ɽͅ}͕ѥ̀l(͕ѥ(ᕍѥٕ}յ䈰(ᕍѥٔյ䈰(ݹȈ(lI5̽ɍ}ѥ}͍ɕɐĽɍ}ѥ}͍ɕɑ̽ѕЉt(lĽɍ}ѥ}͍ɕɑ̽ѕЉt(ɕͥѽ}}չѥ}ѥЈ(}չѥ}хє}̠I5̽ɍ}ѥ}͍ɕɐ͔(ɍ}ѥ}х퍽ѥlѥ}х̝u(=ѕɥ͔ɍɅѥɽ́ɕ䁙ȁ-I\ȁɕ٥܁ݥѠЁ̸ٕ(U͔ѡѥ͍ɕɐ́ѡɽٕͅȁ٥((͕ѥ(ɽՍ}͍(AɽՍЁ͍(AɽՍЁݹȈ(l̽ɽՍ}̽ɍ}՝}Ʌѥ}̽Ʌ}ɕ͕ɍt(mt(ɕͥѽ}ѥЈ(ɕ(}̠̽ɽՍ}̽ɍ}՝}Ʌѥ}̽Ʌ}ɕ͕ɍ(ѥlɅ}}ͥulͥt􀉭}ͥ}ɽՍЈ(͔(ѥlɅ}}ͥulɕͽt(Qȁ́ѥA$́٥əЁЁɽՍЁեє(-ɽͅՅѕɕͥ光ɽ((͕ѥ(}مՕ}͔( ȁمՔ͔(Ȉ(l̽ɍ}مՕ}ɕ̹̽ѥ}Ľɍ}مՕ}ɕ̽ѕЉt(lĽɍ}مՕ}ɕ̽ѕЈĽѥ}͹̽͡ѕЉt(ɕͥѽ}}չѥ}ѥЈ(ɕ(مՕlمՕ}х̉t􀉍ɍ}مՕ}(}̽ɍ}مՕ}ɕ̹(ѥlɕ}х̉t􀉱}չѥ}͹͡Ј(͔(مՕ}хمՕlمՕ}х̝u쁅ѥ}ɕ}х텹ѥlɕ}х̝u(5ɕمՔ٥͕́ɅѕɽȵI=$̸(хȁI=$յѥ́䁅ѕȁȁ͍ٕمѕ́ѡ((͕ѥ(}}х}Ѡ(хѠ(AɽՍЁͥݹȈ(l(̽ɍ}}͍ɥ̹(̽ɍ}}х}չ(Ľɍ}}͍ɥ̽ѕЈ(Ľɍ}}х}ݽɭ̽ѕЈ(t(lĽɍ}}͍ɥ̽ѕЈĽɍ}}х}ݽɭ̽ѕЉt(ɕͥѽ}}չѥ}ѥЈ(}չѥ}хє(}̠̽ɍ}}͍ɥ̹̽ɍ}}х}չ(͔(ɍ}}х푕l}х̝u쁉}х}ݽɭ}х}ݽɭlݽɭ}х̝u( ȁɕ٥܁ٔɽ͍ɥЁѼ]ɹ9хݥѡЁ٥ѡɽ(IոѡЁɕɐѡхͥ((͕ѥ(ѕ}٥(Q٥(Aљɴɕ٥ݕȈ(l̽ɕ}}͍ͥ̽ɕ}ͥѕՅ}ɍɅѽȽ}Ʌй䈰t(lĽнѥ̈Ľݽɭ}չ̈Ľ}ɕ̽ݽɭ}չ}t(ɕͥѽ}}չѥ}ѥЈ(ɕ(}̠̽ɕ}}͍ͥ̽ɕ}ͥѕՅ}ɍɅѽȽ}Ʌй䈤(}хѕl̉t(͔(}չ}хѕl̝tɕ}ݽɭ}չ}չ}хѕlɕ}ݽɭ}չ̝t(QȁٕɥA$ѥ䰁Ʌ٥̵Ё٥(%ՑЁЁɕ٥܁͍ɕ́͡ȁٔ݅ѡɽ՝ѡɽͅ((͕ѥ(͕ɥ}}(Mɥ䁅(Mɥɕ٥ݕȈ(lM UI%Qd̽ɍ}͕ɥ}ѕхѥĽɍ}͕ɥ}ѕхѥ̽ѕЉt(lĽɍ}͕ɥ}ѕхѥ̽ѕЉt(ɕͥѽ}}չѥ}ѥЈ(ɕ(͕ɥl͕ɥ}ѕхѥ}х̉t􀉍ɍ}͕ɥ}ѕхѥ}(}̠M UI%Qd̽ɍ}͕ɥ}ѕхѥ(͔(͕ɥ}ѕхѥ}х͕ɥl͕ɥ}ѕхѥ}х̝u(I͕ɥ䁕٥́ɕ͕ЁݡѕɹѕхѥȁÁх䁕и(Ёѡɐ䁅ѕхѥչѥ((͕ѥ(хѥ}}Ʌѥ̈(%хѥɅѥ̈(=Ʌѥ́ݹȈ(l(̽ɍ}ɑ}ɕ̹(̽ɍ}Ʌѥ}ɕ̹(Ľɍ}ɑ}ɕ̽ѕЈ(Ľɍ}Ʌѥ}ɕ̽ѕЈ(t(lĽɍ}ɑ}ɕ̽ѕЈĽɍ}Ʌѥ}ɕ̽ѕЉt(ɕͥѽ}}չѥ}ѥЈ(ɕ(ɑlɑ}х̉t􀉍ɍ}ɑ}(ɅѥlɅѥ}х̉t􀉍ɍ}Ʌѥ}(}̠̽ɍ}ɑ}ɕ̹̽ɍ}Ʌѥ}ɕ̹(͔(ɑ}хɑlɑ}х̝u쁽Ʌѥ}хɅѥlɅѥ}х̝u(%хѥɅѥ́٥́ɽͅɕݥѠɽՍѥ٥ɽЁ͕ܵ́Ʌѕ( ٕЁȁ٥ɽЁх́ѼɑЁѕȁ͕ѥ((͕ѥ(ɽͅ}ɕ٥}Ј(Aɽͅɕ٥܁Ј(Mхȁɕ٥ݕȈ(l(̽ɍ}ɽͅ}й(̽}ѥ̹(̽ݕ̼̽شܴȵɍɽͅеչѥ(t(lĽɍ}ɽͅ}̽ѕЉt(ɕͥѽ}}չѥ}ѥЈ(ɕ(}̠(̽ɍ}ɽͅ}й(̽}ѥ̹(̽ݕ̼̽شܴȵɍɽͅеչѥ((͔(Aɽ̰ͅ)ѥЁɕɐхѥɔѕ́ɕѥ̸(Mх́ɕ٥܁ѡɽͅЁ̰́չѥ)M=8)ܸ(- ЁЁѡɽͅݽɭܸ((͕ѥ(ɍ}ѕɵ}̈( ɍѕɵ́ܵ̈(ݹȈ(l̽ɍ}Ʌ}ɕ̹ȁɑȁɴɕ٥܈ɥɽمt(lĽɍ}Ʌ}ɕ̽ѕЉt(ɽ͕}չѥ}}(݅ɹ(Ʌ}х퍽ɅlɅ}х̝u(=ɑȵɴɥɽمͥɔ́ȁɕ٥ܸ( Ёȵɍѕɵ́ȁɕɐЁٕ݅ȸ((͕ѥ(ɽՍѥ}}̈(AɽՍѥȁ̈( ȁͽȈ(lɽՍѥѕ䈰ȁI=$Ё͕ɥՕѥɔt(mt(ɽ͕}չѥ}}(݅ɹ(AɽՍѥѕ䰁ȁI=$Ё͕ɥՕѥɔɔѕɹ̸(Qɽ́ͅɕݡȵ́ɕٕѕ( Ёѕɹ٥ɥɽͅѥѥȁɑ((t(хѕ}չ̀ չѕȡѕlѥ}хєtȁѕɽͅ}͕ѥ̤(}չЀхѕ}չ̹Рɕѕ}̤(݅ɹ}չЀхѕ}չ̹Р݅ɹ(}չ(ɽͅ}х̀􀉍ɍ}ɽͅ}(݅ɹ}չ(ɽͅ}х̀􀉍ɍ}ɽͅ}ɕ}ݥѡ}݅ɹ̈(͔耀Ʌ聹ٕȀչɕݡѡ́ɕЁɥ́ѕɅȵ݅ɹ͕ѥ(ɽͅ}х̀􀉍ɍ}ɽͅ}ɕ䈀Ʌ聹ٕ(ɕեɕ}չѥ}̀􁱥Р(йɽ̠((ȁѕɽͅ}͕ѥ(ȁЁѕlչѥ}̉t(йхݥѠ((((ɕɸ(ɽͅ}х̈ɽͅ}х̰(хɝ}Ʌ}مՕ}܈хɝ}Ʌ}مՕ}ܰ(хɝ}Ʌ}مՕ}聘-I\хɝ}Ʌ}مՕ}(ɕ}х̈耉}ɍ}ɽͅ}Ј(ͽɍ}є耠( ɍɽͅЁ́ɕѥхمՔ(͕ɥ䰁ɅаɑɅѥ̰ѥ̰ɕ٥ܵ䰁(٥ȁ-I\Ȱȁɽͅɕ٥쁥Ё́ЁمՅѥՅɅѕ(ɍ͔ѵаͥɑȰɽՍѥѥєȁɕٕՔɽ((ɽͅ}Ʌѥٔ(ѥѱ耉-I\ɍȁɽͅЈ(ɽ͔耠(Aɕ͕Ёѕɥ͔ɍɅѥɽݥѠѥA$ѕɅѥ(Ʌѽȁ٥ȁѠхݽɭܰѡհɍ̸ٕ((Ցl(Ȉ(Aљɴɕ٥ݕȈ(Mɥɕ٥ݕȈ(=Ʌѥ́ݹȈ(Mхȁɕ٥ݕȈ(ݹȈ(t((ɽͅ}յ(͕ѥ}չЈ聱ɽͅ}͕ѥ̤(ɕ}չЈхѕ}չ̹Рɕ䈰(݅ɹ}չЈ݅ɹ}չа(}չЈ聉}չа(}չЈ聱ɕեɕ}չѥ}̤(ɕ٥}ɽ}}Ȉ聍ѥlɕ٥}ɽ}ul}ȉt(}}͕͔((ɽͅ}͕ѥ̈ɽͅ}͕ѥ̰(ɕեɕ}չѥ}̈ɕեɕ}չѥ}̰(ɕѕ}̈聍ɕѕ}̰(ɽͅ}х}ձ̈l((ɽͅ}х̈耉ɍ}ɽͅ}ɕ䈰(ձ耉ɽ͕ͅѥ́ɔɕ䁅ȵɍȁɽՍѥ́ɕ(((ɽͅ}х̈耉ɍ}ɽͅ}ɕ}ݥѡ}݅ɹ̈(ձ耉ɕɽͅ٥́ɕݡɥI=$ɽՍѥаȁͥɔ́ɕЁ݅ɹ̈(((ɽͅ}х̈耉ɍ}ɽͅ}(ձ耉͕ɥ䁙ɔA$ɅЁɕɕͥյЁ͵эչѥаͥɽͅ٥ȁ Ё́ͅѡɽͅ((t(ɕ٥}ɽ}聍ѥlɕ٥}ɽ}t(ɕѕ}չѥ}ɕ̈(ɍ}ѥ}х̈聍ѥlѥ}х̉t(ɍ}}х̈聑l}х̉t(}х}ݽɭ}х̈聉}ݽɭlݽɭ}х̉t(ɍ}مՕ}х̈مՕlمՕ}х̉t(ɍ}͕ɥ}ѕхѥ}х͕̈ɥl͕ɥ}ѕхѥ}х̉t(ɍ}Ʌ}х̈聍ɅlɅ}х̉t(ɍ}ɑ}х̈聽ɑlɑ}х̉t(ɍ}Ʌѥ}х̈聽ɅѥlɅѥ}х̉t(ѥ}ɕ}х̈聅ѥlɕ}х̉t((Ʌ}}ͥ聍ѥlɅ}}ͥt(՝}Ʌ聍ѥl՝}Ʌt(ɽͅ}̈(}ͥ}耉輽ܹͥi5]!Ii9](}ɐ耉輽ܹɐ]5M!!MA4(չѥ}Ј耈Ľɍ}ɽͅ}̽ѕЈ(յхѥ耉̽ɍ}ɽͅ}й((((ɍ}ɍ͕}ɽم}}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(mȰt(Iɸȵͥɍ͔ɽمѕ́ȁѡ-I\хɐ(ɽ͕ͅɍ}ɽͅ}}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((͔͕ɍ}͕}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ɽɕЀ͕ɍ}ɽɕ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ɅЀ͕ɍ}Ʌ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((مՔ͕ɍ}مՕ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((͕ɥ͕ɍ}͕ɥ}ѕхѥ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ɑ͕ɍ}ɑ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((Ʌѥ͕̀ɍ}Ʌѥ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ѥ͕̀ѥ}͹͡С}չ}չ̤(}хє͕}хє(ɽЀAѠ}}}|ɕͽٔɕlt((}ѠȤ(ɕɸɽЀѠ}((}̠ѡȤ(ɕɸ}ѠȁѠѡ̤((є(ѕ}Ȱ(Ȱ(ݹȰ(ͽɍ聱mt(չѥ}聱mt(٥}Ȱ(ѥ}хєȰ(٥Ȱ(ɽم}ՕѥȰ(}ѥȰ(mȰt(ɕեɕ}}ѕ}ɍ}ɍ͕}ɽمѕ}(ѥ}хєЁɕ䈰݅ɹ耀Ʌ聹ٕ(Ʌ͔YՕɽȠɍɍ͔ɽمєхєЁɕ䰁݅ɹȁ(ɕɸ(ѕ}聝ѕ}(聱(ݹȈ聽ݹȰ(ͽɍ̈ͽɍ̰(չѥ}̈չѥ}̰(٥}聕٥}(ѥ}хє聍ѥ}хє(٥聕٥(ɽم}Օѥ聅ɽم}Օѥ(}ѥ聹}ѥ(((ɕѕ}̀􁱥Сйɽ̡ɽͅlɕѕ}̉t͕lɕѕ}̉t(}չѥ}хє((ɽͅlɽͅ}х̉t􀉍ɍ}ɽͅ}(ȁ͕l͕}х̉t􀉍ɍ}͕}(ȁɕѕ}(͔ɕ((ɽم}ѕ̀l(є(ɽͅ}}ɕ䈰(AɽͅЁɕ䈰(ݹȈ(l̽ɍ}ɽͅ}йĽɍ}ɽͅ}̽ѕЉt(lĽɍ}ɽͅ}̽ѕЉt(ɕͥѽ}}չѥ}ѥЈ(}չѥ}хє}̽ɍ}ɽͅ}й͔(ɍ}ɽͅ}хɽͅlɽͅ}х̝u( ѡȁɕ٥܁ɕЁɽͅ(U͔ѡɽͅЁ́ѡɽمٕȁѥи((є(ɽɕ}ѡ}ɕ䈰(AɽɕЁѠɕ䈰(AɽɕЁݹȈ(l̽ɍ}ɽɕ}ɕ̹Ľɍ}ɽɕ}ɕ̽ѕЉt(lĽɍ}ɽɕ}ɕ̽ѕЉt(ɕͥѽ}}չѥ}ѥЈ(ɕ(ɽɕlɽɕ}х̉t􀉍ɍ}ɽɕ}(}̽ɍ}ɽɕ}ɕ̹(͔(ɍ}ɽɕ}хɽɕlɽɕ}х̝u( ɽɕЁمє͔ɥ̰ɥѥٕЁ٥(IєѡЁѼɽɕЁݥѠȵ́ѥɭ́݅ɹ̸((є(Ʌ}}}ɕ䈰( ɅЁЁɕ䈰(1ݹȈ(l̽ɍ}Ʌ}ɕ̹Ľɍ}Ʌ}ɕ̽ѕЉt(lĽɍ}Ʌ}ɕ̽ѕЉt(ɕͥѽ}}չѥ}ѥЈ(ɕ(ɅlɅ}х̉t􀉍ɍ}Ʌ}(}̽ɍ}Ʌ}ɕ̹(͔(ɍ}Ʌ}х퍽ɅlɅ}х̝u( ɕ٥܁аɥم䰁Ցа͔ɑȵɴѥ( Ё́ȁɑȵɴ́ͥѡչѥ((є(}مՕ}͕}ɕ䈰(مՔ͔ɕ䈰(Ȉ(l̽ɍ}مՕ}ɕ̹̽ѥ}Ľɍ}مՕ}ɕ̽ѕЉt(lĽɍ}مՕ}ɕ̽ѕЈĽѥ}͹̽͡ѕЉt(ɕͥѽ}}չѥ}ѥЈ(ɕ(مՕlمՕ}х̉t􀉍ɍ}مՕ}(}̠̽ɍ}مՕ}ɕ̹̽ѥ}(ѥlɕ}х̉t􀉱}չѥ}͹͡Ј(͔(ɍ}مՕ}хمՕlمՕ}х̝u쁅ѥ}ɕ}х텹ѥlɕ}х̝u( ͕Ʌєɕ٥ɽȁI=$յѥ(хȁI=$剅յѥ́䁅ѕȁȁ͍ٕ丈((є(͕ɥ}х}ɕ䈰(Mɥ䁅хɕ䈰(Mɥ䁽ݹȈ(lM UI%Qd̽ɍ}͕ɥ}ѕхѥĽɍ}͕ɥ}ѕхѥ̽ѕЉt(lĽɍ}͕ɥ}ѕхѥ̽ѕЉt(ɕͥѽ}}չѥ}ѥЈ(ɕ(͕ɥl͕ɥ}ѕхѥ}х̉t􀉍ɍ}͕ɥ}ѕхѥ}(}̠M UI%Qd̽ɍ}͕ɥ}ѕхѥ(͔(ɍ}͕ɥ}ѕхѥ}х͕ɥl͕ɥ}ѕхѥ}х̝u( ͕ɥ䁅ɽٔɕɽ́ݡѕɹѕхѥ́ɕٕѕ( ЁȁAɥم䰁ѡɐ䁅ѕхѥ٥͕Ʌѕ丈((є(хѥ}ɕ}ɕ䈰(%хѥɕ́ɕ䈰(%хѥݹȈ(l(̽ɍ}ɑ}ɕ̹(̽ɍ}Ʌѥ}ɕ̹(Ľɍ}ɑ}ɕ̽ѕЈ(Ľɍ}Ʌѥ}ɕ̽ѕЈ(t(lĽɍ}ɑ}ɕ̽ѕЈĽɍ}Ʌѥ}ɕ̽ѕЉt(ɕͥѽ}}չѥ}ѥЈ(ɕ(ɑlɑ}х̉t􀉍ɍ}ɑ}(ɅѥlɅѥ}х̉t􀉍ɍ}Ʌѥ}(}̠̽ɍ}ɑ}ɕ̹̽ɍ}Ʌѥ}ɕ̹(͔(ɍ}ɑ}хɑlɑ}х̝u쁍ɍ}Ʌѥ}хɅѥlɅѥ}х̝u( хѥݹ͕́ɑɅѥ́٥ɔɍ͔ɽم(Qɸȁ٥ɽЁх́Ѽѡɑ((є(͕}ɕ}ɕ䈰( ͔ɕ́ɕ䈰(ݹȈ(l̽ɍ}͕}ɕ̹Ľɍ}͕}ɕ̽ѕЉt(lĽɍ}͕}ɕ̽ѕЉt(ɕͥѽ}}չѥ}ѥЈ(ɕ(͕l͕}х̉t􀉍ɍ}͕}(}̽ɍ}͕}ɕ̹(͔(ɍ}͕}х퍱͕l͕}х̝u( ѡȁ͕ͥɔՑа͕ɥ䰁ٕٔ́ɔɽم(U͔͔ɕ́́ѡɥݕɽՍЁ٥ȁɽم̸((є(ɽم}չѥ}}ɕ䈰(ɽمչѥЁɕ䈰(Mхȁɕ٥ݕȈ(l(̽ɍ}ɍ͕}ɽم}й(̽}ѥ̹(̽ݕ̼̽شܴȵɍɍ͔ɽمеչѥ(t(lĽɍ}ɍ͕}ɽم}̽ѕЉt(ɕͥѽ}}չѥ}ѥЈ(ɕ(}̠(̽ɍ}ɍ͕}ɽم}й(̽}ѥ̹(̽ݕ̼̽شܴȵɍɍ͔ɽمеչѥ((}хѕl̉t(͔(Aɍ͔ɽم̰)ѥЁɕɐչѥɔɕ͕и( х́ɕ٥܁ѡɽمЁ̰́չѥ)M=8)(- ЁЁѡɽمݽɭܸ((є(}ͥɕ}ѡɥ䈰( ȁͥɔѡɥ䈰( ȁͽȁݹȈ(lͥɑȁɴ5MA͕ɥ䁅хt(mt(ɽ͕}չѥ}}(݅ɹ(Mɑȁɴ5MA͕ɥ䁅хɕեɔȁѡɥ丈(́ѡȁٔѥͥȁɽمѠ( Ёͥȁ͕ɥ䁅ɽم̸((є(}Ց}}ѡɥ䈰( ȁՑЁA<ѡɥ䈰(ɽɕЁݹȈ(lՑЁɽمɍ͔ɑȈѡɥ䈰ٔѡɥѥt(mt(ɽ͕}չѥ}}(݅ɹ( ՑЁɽمɍ͔ɑȰѡɥ䰁ٔѡɥѥɕեɔȁи( Քѡ-I\ɍ͔ɑȁɽٔٔ( ЁՑЁݹȰA<ѠٔѡɥѥȁЁٕ݅ȸ((t(хѕ}չ̀ չѕȡѕlѥ}хєtȁѕɽم}ѕ̤(}չЀхѕ}չ̹Рɕѕ}̤(݅ɹ}չЀхѕ}չ̹Р݅ɹ(}չ(ɍ͕}ɽم}х̀􀉍ɍ}ɍ͕}ɽم}(݅ɹ}չ(ɍ͕}ɽم}х̀􀉍ɍ}ɍ͕}ɽم}ɕ}ݥѡ}݅ɹ̈(͔耀Ʌ聹ٕȀչɕݡѡ́ɕЁɥ́ѕɅȵ݅ɹ͕ѥ(ɍ͕}ɽم}х̀􀉍ɍ}ɍ͕}ɽم}ɕ䈀Ʌ聹ٕ(ɕեɕ}չѥ}̀􁱥Р(йɽ̠((ȁѕɽم}ѕ(ȁЁѕlչѥ}̉t(йхݥѠ((((ɕɸ(ɍ͕}ɽم}х̈ɍ͕}ɽم}х̰(хɝ}Ʌ}مՕ}܈хɝ}Ʌ}مՕ}ܰ(хɝ}Ʌ}مՕ}聘-I\хɝ}Ʌ}مՕ}(ɕ}х̈耉}ɍ}ɍ͕}ɽم}Ј(ͽɍ}є耠( ɍɍ͔ɽمЁ́ɕɽ͔ͅɽɕа(ɅаمՔ͕ɥ䰁ɑɅѥ̰ѥ̰ɕ٥ܵ䰁(٥ȁ-I\Ȱȁɍ͔ɽم쁥Ё́ЁمՅѥ(ՅɅѕɍ͔ѵаͥɑȰɽՍѥ(ѥєȁɕٕՔɽ((ɽم}Ʌѥٔ(ѥѱ耉-I\ȁɍ͔ɽمЈ(ɽ͔耠(ٔɽɕа͕ɥ䰁хѥݹ́չѥ(ɽمЁѡЁ͕Ʌѕ́ɽՍЁ٥ɽȵѡɥ䁥̸((Ցl(Ȉ(ݹȈ(AɽɕЁݹȈ(1ݹȈ(Mɥ䁽ݹȈ(%хѥݹȈ(t((ɽم}յ(ѕ}չЈ聱ɽم}ѕ̤(ɕ}չЈхѕ}չ̹Рɕ䈰(݅ɹ}չЈ݅ɹ}չа(}չЈ聉}չа(}չЈ聱ɕեɕ}չѥ}̤(ɕ٥}ɽ}}Ȉɽͅlɕ٥}ɽ}ul}ȉt(}}͕͔((ɽم}ѕ̈聅ɽم}ѕ̰(ɕեɕ}չѥ}̈ɕեɕ}չѥ}̰(ɕѕ}̈聍ɕѕ}̰(ɍ͕}ɽم}х}ձ̈l((ɍ͕}ɽم}х̈耉ɍ}ɍ͕}ɽم}ɕ䈰(ձ耉ɽمѕ́ɔɕ䁅ȁͥɔՑаA<ȁٔ́ɕ(((ɍ͕}ɽم}х̈耉ɍ}ɍ͕}ɽم}ɕ}ݥѡ}݅ɹ̈(ձ耉ɕɍ͔ɽم٥́ɕݡȁͥɔѡɥ䰁ՑаA<ȁٔѡɥѥɕЁ݅ɹ̈(((ɍ͕}ɽم}х̈耉ɍ}ɍ͕}ɽم}(ձ耉͕ɥ䁙ɔA$ɅЁɕɕͥյЁ͵эչѥаͥɽم٥ȁ Ё́ͅɍ͔ɽم((t(ɕ٥}ɽ}ɽͅlɕ٥}ɽ}t(ɕѕ}չѥ}ɕ̈(ɍ}ɽͅ}х̈ɽͅlɽͅ}х̉t(ɍ}͕}х̈聍͕l͕}х̉t(ɍ}ɽɕ}х̈ɽɕlɽɕ}х̉t(ɍ}Ʌ}х̈聍ɅlɅ}х̉t(ɍ}مՕ}х̈مՕlمՕ}х̉t(ɍ}͕ɥ}ѕхѥ}х͕̈ɥl͕ɥ}ѕхѥ}х̉t(ɍ}ɑ}х̈聽ɑlɑ}х̉t(ɍ}Ʌѥ}х̈聽ɅѥlɅѥ}х̉t(ѥ}ɕ}х̈聅ѥlɕ}х̉t((Ʌ}}ͥɽͅlɅ}}ͥt(՝}Ʌɽͅl՝}Ʌt(ɽم}̈(}ͥ}耉輽ܹͥi5]!Ii9](}ɐ耉輽ܹɐ]5M!!MA4(չѥ}Ј耈Ľɍ}ɍ͕}ɽم}̽ѕЈ(յхѥ耉̽ɍ}ɍ͕}ɽم}й((((ɍ}Օ}}ɽ}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(mȰt(IɸȁՔɽ͕ѥ́ȁѡ-I\хɐ(ɍ͔͕ɍ}ɍ͕}ɽم}}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ɽ͕ͅɍ}ɽͅ}}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ѥ͕ɍ}ѥ}͍ɕɑ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((͕ɍ}}͍ɥ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((}ݽɭ܀͕ɍ}}х}ݽɭ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((͔͕ɍ}͕}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ɽɕЀ͕ɍ}ɽɕ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ɅЀ͕ɍ}Ʌ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((مՔ͕ɍ}مՕ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((͕ɥ͕ɍ}͕ɥ}ѕхѥ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ɑ͕ɍ}ɑ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((Ʌѥ͕̀ɍ}Ʌѥ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ѥ͕̀ѥ}͹͡С}չ}չ̤(}хє͕}хє(ɽЀAѠ}}}|ɕͽٔɕlt((}ѠȤ(ɕɸɽЀѠ}((}̠ѡȤ(ɕɸ}ѠȁѠѡ̤((͕ѥ(͕ѥ}Ȱ(Ȱ(ɕ٥ݕȰ(ͽɍ聱mt(չѥ}聱mt(٥}Ȱ(ѥ}хєȰ(٥Ȱ(}ՕѥȰ(}ѥȰ(mȰt(ɕեɕ}}͕ѥ}ɍ}Օ}͕ѥ}(ѥ}хєЁɕ䈰݅ɹ耀Ʌ聹ٕ(Ʌ͔YՕɽȠɍՔ͕ѥхєЁɕ䰁݅ɹȁ(ɕɸ(͕ѥ}͕ѥ}(聱(ɕ٥ݕȈɕ٥ݕȰ(ͽɍ̈ͽɍ̰(չѥ}̈չѥ}̰(٥}聕٥}(ѥ}хє聍ѥ}хє(٥聕٥(}Օѥ聑}Օѥ(}ѥ聹}ѥ(((ɕѕ}̀􁱥Р(йɽ̠(ɍ͕lɕѕ}̉t(ɽͅlɕѕ}̉t(ѥlɕѕ}̉t(lɕѕ}̉t(}ݽɭlɕѕ}̉t(((}չѥ}хє((ɍ͕lɍ͕}ɽم}х̉t􀉍ɍ}ɍ͕}ɽم}(ȁɽͅlɽͅ}х̉t􀉍ɍ}ɽͅ}(ȁѥlѥ}х̉t􀉍ɍ}ѥ}(ȁl}х̉t􀉍ɍ}}(ȁ}ݽɭlݽɭ}х̉t􀉉}х}ݽɭ}(ȁɕѕ}(͔ɕ((}͕ѥ̀l(͕ѥ(ɍ͕}ɽم}Ј(Aɍ͔ɽمЈ(Aɍ͔ѕ(l̽ɍ}ɍ͕}ɽم}йĽɍ}ɍ͕}ɽم}̽ѕЉt(lĽɍ}ɍ͕}ɽم}̽ѕЈĽɍ}ɽͅ}̽ѕЉt(ɕͥѽ}}չѥ}ѥЈ(}չѥ}хє}̽ɍ}ɍ͕}ɽم}й͔(ɍ}ɍ͕}ɽم}хɍ͕lɍ͕}ɽم}х̝u( ѡȁɕ٥܁ɽمЁɔͥ(U͔ѡɽمЁ́ѡɽٕȁจ((͕ѥ(չѥ}}٥(IչѥA$٥(Aљɴɕ٥ݕȈ(l(̽ɕ}}ͥ(ѕՅ}ɍɅѽȽ}Ʌй䈰(I5(Ľнѥ̈(t(l(Ľнѥ̈(Ľݽɭ}չ̈(Ľ}ɕ̽ݽɭ}չ}(Ľɍ}Օ}}ɽ̽ѕЈ(t(ɕͥѽ}}չѥ}ѥЈ(ɕ(}չѥ}хєɕ(}̠̽ɕ}}ͥѕՅ}ɍɅѽȽ}Ʌй䈰I5(}хѕl̉t(͔(}չ}хѕl̝t쁅}Ʌ}ɕ͕}ѕՅ}ɍɅѽȽ}Ʌй䜥( љɴɕ٥ݕٕ́ɥ䁍ѥA$٥(-A$ѥ䁅٥́ѡจ((͕ѥ(}Ʌ}٥(Ʌ٥(=Ʌѽȁɕ٥ݕȈ(l͍̽ɕ}ͥхєݽɭ܁Ʌ́ɕЉt(lхєĽݽɭ}չ̈Ľ}ɕ̽ݽɭ}չ}t(ɕͥѽ}}չѥ}ѥЈ(ɕ(}̠͍̽ɕ}ͥѕՅ}ɍɅѽȽ䈤(}хѕl̉t(}хѕlɕ}ݽɭ}չ̉t(͔(ɕ}ݽɭ}չ}չ}хѕlɕ}ݽɭ}չ̝t( ѡɅѽȁ͡܁Ʌ̵Ё٥ѡͽ(IոՍЁݽɭ܁ɔٔ݅ѡɽ՝((͕ѥ(͕ɥ}}(Mɥ䁅(Mɥɕ٥ݕȈ(lM UI%Qd̽ɍ}͕ɥ}ѕхѥĽɍ}͕ɥ}ѕхѥ̽ѕЉt(lĽɍ}͕ɥ}ѕхѥ̽ѕЉt(ɕͥѽ}}չѥ}ѥЈ(ɕ(͕ɥl͕ɥ}ѕхѥ}х̉t􀉍ɍ}͕ɥ}ѕхѥ}(}̠M UI%Qd̽ɍ}͕ɥ}ѕхѥ(͔(ɍ}͕ɥ}ѕхѥ}х͕ɥl͕ɥ}ѕхѥ}х̝u( ͕ɥ͕Ʌєɕɽ́ɽѕɹѕхѥ(Ёѡɐ䁍ѥѥչѥ((͕ѥ(ɍ}ѕɵ̈( ɍѕɵ̈(1ɽɕЁɕ٥ݕ̈(l(̽ɍ}Ʌ}ɕ̹(̽ɍ}ɽɕ}ɕ̹(̽ɍ}͕}ɕ̹(t(l(Ľɍ}Ʌ}ɕ̽ѕЈ(Ľɍ}ɽɕ}ɕ̽ѕЈ(Ľɍ}͕}ɕ̽ѕЈ(t(ɕͥѽ}}չѥ}ѥЈ(ɕ(ɅlɅ}х̉t􀉍ɍ}Ʌ}(ɽɕlɽɕ}х̉t􀉍ɍ}ɽɕ}(͕l͕}х̉t􀉍ɍ}͕}(}̠(̽ɍ}Ʌ}ɕ̹(̽ɍ}ɽɕ}ɕ̹(̽ɍ}͕}ɕ̹((͔((ɍ}Ʌ}х퍽ɅlɅ}х̝u쀈(ɍ}ɽɕ}хɽɕlɽɕ}х̝u쀈(ɍ}͕}х퍱͕l͕}х̝u(( ɽɕЁɕ٥܁ѕɵ̰ɥ̰͔ٕ́ѽѡ(хȵɑȵɴՅͥѡչѥ((͕ѥ(مՕ}}ѥ̈(YՔѥ̈(ɕ٥ݕȈ(l̽ɍ}مՕ}ɕ̹̽ѥ}Ľѥ}͹̽͡ѕЉt(lĽɍ}مՕ}ɕ̽ѕЈĽѥ}͹̽͡ѕЉt(ɕͥѽ}}չѥ}ѥЈ(ɕ(مՕlمՕ}х̉t􀉍ɍ}مՕ}(ѥlɕ}х̉t􀉱}չѥ}͹͡Ј(}̠̽ɍ}مՕ}ɕ̹̽ѥ}(͔(ɍ}مՕ}хمՕlمՕ}х̝u쁅ѥ}ɕ}х텹ѥlɕ}х̝u( ѕɕ٥ЁɽȁI=$յѥ(-ɽ͕-A$хɝ͕́Ʌєɽɕչѥф((͕ѥ(хѥ}ɕ̈(%хѥɕ̈(%хѥɅѥ́ɕ٥ݕ̈(l̽ɍ}ɑ}ɕ̹̽ɍ}Ʌѥ}ɕ̹t(lĽɍ}ɑ}ɕ̽ѕЈĽɍ}Ʌѥ}ɕ̽ѕЉt(ɕͥѽ}}չѥ}ѥЈ(ɕ(ɑlɑ}х̉t􀉍ɍ}ɑ}(ɅѥlɅѥ}х̉t􀉍ɍ}Ʌѥ}(}̠̽ɍ}ɑ}ɕ̹̽ɍ}Ʌѥ}ɕ̹(͔(ɍ}ɑ}хɑlɑ}х̝u쁍ɍ}Ʌѥ}хɅѥlɅѥ}х̝u( хѥݹ͕́ɑɅѥ̰а٥( ٕЁȁ٥ɽЁ́Ѽѡɑ((͕ѥ(}}ͥ}ɕ٥܈(ͥɕ٥܈(AɽՍЁͥɕ٥ݕȈ(l(̽ɍ}Օ}}ɽ(̽}ѥ̹(̽ݕ̼̽شܴȵɍՔɽչѥ(t(lĽɍ}Օ}}ɽ̽ѕЉt(ɕͥѽ}}չѥ}ѥЈ(ɕ(}̠(̽ɍ}Օ}}ɽ(̽}ѥ̹(̽ݕ̼̽شܴȵɍՔɽչѥ((͔(Ք)ѥЁɕɐхѥɔѕ( х́Ёѡɽ̰́չѥ)M=8)(U͔)쁑Ё͔ и((͕ѥ(}ѡɥ}յ̈( ȁѡɥ䁑յ̈( ȁͽȈ(lȁͥȈՑЁݹȁɍ͔ɑȈȁAȁɥم䁅хt(mt(ɽ͕}չѥ}}(݅ɹ(9ͥȰՑЁݹȰA<ȁɥم䁅хɕեɔȁѡɥ丈(́ѡȁٔѡɥ䁅ѥ́ɕ䁙ȁ( ЁͥȰA<Aɥم䁅хȁЁٕ݅ȸ((͕ѥ(ɽՍѥ}ѕɹ}ѕхѥ̈(AɽՍѥѕɹѕхѥ̈(AɽՍѥ͕ɥ䁽ݹ̈(lɽՍѥѕ䈰ѡɐ͕ɥ䁅ѕхѥѕ͍٥t(mt(ɽ͕}չѥ}}(݅ɹ(AɽՍѥѕ䁅ѡɐ䁅ѕхѥ́ɔѕɹ٥Ёɕɕ̸( ѡȁѥե͠ɕ́ɽɽՍѥѡɐ䁕٥( Ёѕѕ䁅ѕɹѕхѥѕȁ٥ɽЁ͕ѥ((t(хѕ}չ̀ չѕȡѕlѥ}хєtȁѕ}͕ѥ̤(}չЀхѕ}չ̹Рɕѕ}̤(݅ɹ}չЀхѕ}չ̹Р݅ɹ(}չ(Օ}}х̀􀉍ɍ}Օ}}(݅ɹ}չ(Օ}}х̀􀉍ɍ}Օ}}ɕ}ݥѡ}݅ɹ̈(͔耀Ʌ聹ٕȀչɕݡѡ́ɕЁɥ́ѕɅȵ݅ɹ͕ѥ(Օ}}х̀􀉍ɍ}Օ}}ɕ䈀Ʌ聹ٕ(ɕեɕ}չѥ}̀􁱥Р(йɽ̠((ȁѕ}͕ѥ(ȁЁѕlչѥ}̉t(йхݥѠ((((ɕɸ(Օ}}х̈聑Օ}}х̰(хɝ}Ʌ}مՕ}܈хɝ}Ʌ}مՕ}ܰ(хɝ}Ʌ}مՕ}聘-I\хɝ}Ʌ}مՕ}(ɕ}х̈耉}ɍ}Օ}}ɽ(ͽɍ}є耠( ɍՔɽ́ɕɍ͔ɽمɽͅչѥ(Ʌ͕ɥ䰁ɅаمՔɑɅѥ̰ѥ̰(ɕ٥ܵ䰁٥ȁ-I\Ȱȁ쁥Ё̀(ЁمՅѥՅɅѕɍ͔ѵаͥɑȰɽՍѥ(ѥєѡɐ䁅ѕхѥȁɕٕՔɽ((}Ʌѥٔ(ѥѱ耉-I\ɍՔɽ(ɽ͔耠(ٔɽɕа͕ɥ䰁ɽՍахѥɕ٥ݕ̀(٥ɽѡЁ͕Ʌѕ́ɕɽՍЁ٥ɽȵ(ѕɹɽՍѥѥ̸((Ցl(Ȉ(ݹȈ(AɽɕЁݹȈ(1ݹȈ(Mɥ䁽ݹȈ(Aљɴɕ٥ݕȈ(%хѥݹȈ(t((}յ(͕ѥ}չЈ聱}͕ѥ̤(ɕ}չЈхѕ}չ̹Рɕ䈰(݅ɹ}չЈ݅ɹ}չа(}չЈ聉}չа(}չЈ聱ɕեɕ}չѥ}̤(ɕ٥}ɽ}}Ȉɍ͕lɕ٥}ɽ}ul}ȉt(}}͕͔((}͕ѥ̈聑}͕ѥ̰(ɕեɕ}չѥ}̈ɕեɕ}չѥ}̰(}ͥ}ѥ̈l(ȁͥȈ(ՑЁݹȁɍ͔ɑȈ(ȁAȁɥم䁅х(ɽՍѥѕ䈰(ѡɐ͕ɥ䁅ѕхѥ(t(ɕѕ}̈聍ɕѕ}̰(Օ}}х}ձ̈l((Օ}}х̈耉ɍ}Օ}}ɕ䈰(ձ耉͕ѥ́ɔɕ䁅ȁѡɥ䰁ɽՍѥȁѡɐ䁕٥ɕ́(((Օ}}х̈耉ɍ}Օ}}ɕ}ݥѡ}݅ɹ̈(ձ耉ɕɽ٥́ɕݡȁѡɥ䰁ɽՍѥѕ䰁ȁѕɹѕхѥ́ɕЁ݅ɹ̈(((Օ}}х̈耉ɍ}Օ}}(ձ耉͕ɥ䁙ɔA$ɅЁɕɕͥյЁ͵эչѥаͥ٥ȁ Ё́ͅȁ((t(ɕ٥}ɽ}ɍ͕lɕ٥}ɽ}t(ɕѕ}չѥ}ɕ̈(ɍ}ɍ͕}ɽم}х̈ɍ͕lɍ͕}ɽم}х̉t(ɍ}ɽͅ}х̈ɽͅlɽͅ}х̉t(ɍ}ѥ}х̈聍ѥlѥ}х̉t(ɍ}}х̈聑l}х̉t(}х}ݽɭ}х̈聉}ݽɭlݽɭ}х̉t(ɍ}͕}х̈聍͕l͕}х̉t(ɍ}ɽɕ}х̈ɽɕlɽɕ}х̉t(ɍ}Ʌ}х̈聍ɅlɅ}х̉t(ɍ}مՕ}х̈مՕlمՕ}х̉t(ɍ}͕ɥ}ѕхѥ}х͕̈ɥl͕ɥ}ѕхѥ}х̉t(ɍ}ɑ}х̈聽ɑlɑ}х̉t(ɍ}Ʌѥ}х̈聽ɅѥlɅѥ}х̉t(ѥ}ɕ}х̈聅ѥlɕ}х̉t((Ʌ}}ͥɍ͕lɅ}}ͥt(՝}Ʌɍ͕l՝}Ʌt(Օ}}̈(}ͥ}耉輽ܹͥi5]!Ii9](}ɐ耉輽ܹɐ]5M!!MA4(չѥ}Ј耈Ľɍ}Օ}}ɽ̽ѕЈ(յхѥ耉̽ɍ}Օ}}ɽ((((ɍ}ٕѵ}ѕ}}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(mȰt(IɸᕍѥٕٔѵЁѕ͕ѥ́ȁѡ-I\хɐ(Օ}͕ɍ}Օ}}ɽ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ɍ͔͕ɍ}ɍ͕}ɽم}}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ɽ͕ͅɍ}ɽͅ}}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ѥ͕ɍ}ѥ}͍ɕɑ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((͕ɍ}}͍ɥ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((}ݽɭ܀͕ɍ}}х}ݽɭ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((͔͕ɍ}͕}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ɽɕЀ͕ɍ}ɽɕ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ɅЀ͕ɍ}Ʌ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((مՔ͕ɍ}مՕ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((͕ɥ͕ɍ}͕ɥ}ѕхѥ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ɑ͕ɍ}ɑ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((Ʌѥ͕̀ɍ}Ʌѥ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ѥ͕̀ѥ}͹͡С}չ}չ̤(}хє͕}хє(ɽЀAѠ}}}|ɕͽٔɕlt((}ѠȤ(ɕɸɽЀѠ}((}̠ѡȤ(ɕɸ}ѠȁѠѡ̤((͕ѥ(͕ѥ}Ȱ(Ȱ(ɕ٥ݕȰ(ͽɍ聱mt(չѥ}聱mt(٥}Ȱ(ѥ}хєȰ(٥Ȱ(ѕ}ՕѥȰ(}ѥȰ(mȰt(ɕեɕ}}͕ѥ}ɍ}ٕѵ}ѕ͕ѥ}(ѥ}хєЁɕ䈰݅ɹ耀Ʌ聹ٕ(Ʌ͔YՕɽȠɍٕѵЁѕ͕ѥхєЁɕ䰁݅ɹȁ(ɕɸ(͕ѥ}͕ѥ}(聱(ɕ٥ݕȈɕ٥ݕȰ(ͽɍ̈ͽɍ̰(չѥ}̈չѥ}̰(٥}聕٥}(ѥ}хє聍ѥ}хє(٥聕٥(ѕ}Օѥ聍ѕ}Օѥ(}ѥ聹}ѥ(((ɕѕ}̀􁱥Р(йɽ̠(Օ}lɕѕ}̉t(ɍ͕lɕѕ}̉t(ɽͅlɕѕ}̉t(ѥlɕѕ}̉t(lɕѕ}̉t(}ݽɭlɕѕ}̉t(((}չѥ}хє((Օ}lՕ}}х̉t􀉍ɍ}Օ}}(ȁɍ͕lɍ͕}ɽم}х̉t􀉍ɍ}ɍ͕}ɽم}(ȁɽͅlɽͅ}х̉t􀉍ɍ}ɽͅ}(ȁѥlѥ}х̉t􀉍ɍ}ѥ}(ȁl}х̉t􀉍ɍ}}(ȁ}ݽɭlݽɭ}х̉t􀉉}х}ݽɭ}(ȁɕѕ}(͔ɕ((}͕ѥ̀l(͕ѥ(ᕍѥٕ}ɕѥ(ᕍѥٔɕѥ(%ٕѵЁѕȈ(l(̽ɍ}ٕѵ}ѕ}(̽}ѥ̹(̽ݕ̼̽شܴȵɍٕѵеѕչѥ(t(lĽɍ}ٕѵ}ѕ}̽ѕЉt(ɕͥѽ}}չѥ}ѥЈ(}չѥ}хє(}̠(̽ɍ}ٕѵ}ѕ}(̽}ѥ̹(̽ݕ̼̽شܴȵɍٕѵеѕչѥ((͔(%ٕѵЁѕ)ѥЁɕɐхѥɔѕ( ѡѕɕѡ-I\ɍ͔ѠݥѠЁѥ(U͔ѡ́́ѡᕍѥٕٔͥȁѥи((͕ѥ(}ɽ}ɕ䈰(Քɽɕ䈰(ݹȈ(l̽ɍ}Օ}}ɽĽɍ}Օ}}ɽ̽ѕЉt(lĽɍ}Օ}}ɽ̽ѕЉt(ɕͥѽ}}չѥ}ѥЈ(}չѥ}хє}̽ɍ}Օ}}ɽ͔(ɍ}Օ}}хՕ}lՕ}}х̝u( ѡЁѼєɽ(IɕՔɽ͕ѥ́ѕѥ٥((͕ѥ(ɍ͕}ɽم}ɕ䈰(Aɍ͔ɽمɕ䈰(Aɍ͔ͽȈ(l̽ɍ}ɍ͕}ɽم}йĽɍ}ɍ͕}ɽم}̽ѕЉt(lĽɍ}ɍ͕}ɽم}̽ѕЉt(ɕͥѽ}}չѥ}ѥЈ(}չѥ}хє}̽ɍ}ɍ͕}ɽم}й͔(ɍ}ɍ͕}ɽم}хɍ͕lɍ͕}ɽم}х̝u( ѡѕ͕ɽɕа͕ɥ䰁хѥѕ(U͔ѡɍ͔ɽمЁ́ѕ((͕ѥ(}͔(͔(Ȉ(l̽ɍ}مՕ}ɕ̹̽ѥ}Ľѥ}͹̽͡ѕЉt(lĽɍ}مՕ}ɕ̽ѕЈĽѥ}͹̽͡ѕЉt(ɕͥѽ}}չѥ}ѥЈ(ɕ(مՕlمՕ}х̉t􀉍ɍ}مՕ}(ѥlɕ}х̉t􀉱}չѥ}͹͡Ј(}̠̽ɍ}مՕ}ɕ̹̽ѥ}(͔(ɍ}مՕ}хمՕlمՕ}х̝u쁅ѥ}ɕ}х텹ѥlɕ}х̝u(́ѡ͕Ʌєɕ٥ɽȁI=$յѥ(хȁI=$䁅ѕȁȁ͍ٕ́и((͕ѥ(ɥͭ}}͕ɥ}յ䈰(I͕ͬɥյ䈰(Mɥɕ٥ݕȈ(lM UI%Qd̽ɍ}͕ɥ}ѕхѥĽɍ}͕ɥ}ѕхѥ̽ѕЉt(lĽɍ}͕ɥ}ѕхѥ̽ѕЉt(ɕͥѽ}}չѥ}ѥЈ(ɕ(͕ɥl͕ɥ}ѕхѥ}х̉t􀉍ɍ}͕ɥ}ѕхѥ}(}̠M UI%Qd̽ɍ}͕ɥ}ѕхѥ(͔(ɍ}͕ɥ}ѕхѥ}х͕ɥl͕ɥ}ѕхѥ}х̝u(ɔ͕ɥɥͭ́ЁݥѡЁѕɹѥѥ(-ѡɐ䁅ѕхѥͥɕ٥((͕ѥ(ɍ}ѕɵ}յ䈰( ɍѕɵ́յ䈰(1ɽɕЁɕ٥ݕ̈(l(̽ɍ}Ʌ}ɕ̹(̽ɍ}ɽɕ}ɕ̹(̽ɍ}͕}ɕ̹(t(l(Ľɍ}Ʌ}ɕ̽ѕЈ(Ľɍ}ɽɕ}ɕ̽ѕЈ(Ľɍ}͕}ɕ̽ѕЈ(t(ɕͥѽ}}չѥ}ѥЈ(ɕ(ɅlɅ}х̉t􀉍ɍ}Ʌ}(ɽɕlɽɕ}х̉t􀉍ɍ}ɽɕ}(͕l͕}х̉t􀉍ɍ}͕}(}̠(̽ɍ}Ʌ}ɕ̹(̽ɍ}ɽɕ}ɕ̹(̽ɍ}͕}ɕ̹((͔((ɍ}Ʌ}х퍽ɅlɅ}х̝u쀈(ɍ}ɽɕ}хɽɕlɽɕ}х̝u쀈(ɍ}͕}х퍱͕l͕}х̝u(( ɽɕЁѥ́ɽٕȁɅ(хɑȵɴх́䁅ѕȁȁɕ٥ܸ((͕ѥ(хѥ}ɕ}յ䈰(%хѥɕ́յ䈰(%хѥݹȈ(l̽ɍ}ɑ}ɕ̹̽ɍ}Ʌѥ}ɕ̹t(lĽɍ}ɑ}ɕ̽ѕЈĽɍ}Ʌѥ}ɕ̽ѕЉt(ɕͥѽ}}չѥ}ѥЈ(ɕ(ɑlɑ}х̉t􀉍ɍ}ɑ}(ɅѥlɅѥ}х̉t􀉍ɍ}Ʌѥ}(}̠̽ɍ}ɑ}ɕ̹̽ɍ}Ʌѥ}ɕ̹(͔(ɍ}ɑ}хɑlɑ}х̝u쁍ɍ}Ʌѥ}хɅѥlɅѥ}х̝u( хѥхЁѕȁȁ٥ɽЁх́ɔ( ٕЁȁ٥ɽЁх́Ѽѡɑ((͕ѥ(ͥ}}}ɕ٥܈(ͥɕ٥܈(AɽՍЁͥɕ٥ݕȈ(l̽}ѥ̹̽ɍ}ٕѵ}ѕ}t(lĽɍ}ٕѵ}ѕ}̽ѕЉt(ɕͥѽ}}չѥ}ѥЈ(ɕ䈁}̠̽}ѥ̹̽ɍ}ٕѵ}ѕ}͔()܁AɽՍЁ͍ͥɔɕɑݥѡЁ и( х́Ёѡ܁)չѥ)M=8(- ЁЁѡѕݽɭܸ((͕ѥ(}}ѡɥ䈰( ȁѡɥ䈰( ȁͽȈ(lᕍѥٔͽȁɽمͥȈՑЁݹȈɍ͔ɑȉt(mt(ɽ͕}չѥ}}(݅ɹ(ᕍѥٔͽȁɽمͥȰՑЁݹȰɍ͔ɑȁɕեɔȁѡɥ丈( ѡȁɽٔѡ-I\ɍ͔ѡɥ( Ёȁѡɥ䁅ѥ́ȁЁٕ݅ȸ((͕ѥ(ɽՍѥ}ѕɹ}٥(AɽՍѥѕɹ٥(AɽՍѥ͕ɥ䁽ݹ̈(lɽՍѥѕ䈰ѡɐ͕ɥ䁅ѕхѥѕ͍٥t(mt(ɽ͕}չѥ}}(݅ɹ(AɽՍѥѕ䰁ѡɐ͕ɥ䁅ѕхѥѕ͍٥ɔѕɹ̸( ѡѕɽٔݥѠɽՍѥѕɹ٥ѥɅ́ѥ( Ёѕ٥ѕȁ٥ɽЁ͕ѥ((t(хѕ}չ̀ չѕȡѕlѥ}хєtȁѕ}͕ѥ̤(}չЀхѕ}չ̹Рɕѕ}̤(݅ɹ}չЀхѕ}չ̹Р݅ɹ(}չ(ٕѵ}ѕ}х̀􀉍ɍ}ٕѵ}ѕ}(ɕѥ}х̀􀉑}}ɕ}չѥ}}ɕ(݅ɹ}չ(ٕѵ}ѕ}х̀􀉍ɍ}ٕѵ}ѕ}ɕ}ݥѡ}݅ɹ̈(ɕѥ}х̀ɕ}ݥѡ}}ѥ̈(͔耀Ʌ聹ٕȀչɕݡѕɹ٥݅ɹ͕ѥ́ɕѕɅ(ٕѵ}ѕ}х̀􀉍ɍ}ٕѵ}ѕ}ɕ䈀Ʌ聹ٕ(ɕѥ}х̀ɕɅ聹ٕ(ɕեɕ}չѥ}̀􁱥Р(йɽ̠((ȁѕ}͕ѥ(ȁЁѕlչѥ}̉t(йхݥѠ((((ɕɸ(ٕѵ}ѕ}х̈聥ٕѵ}ѕ}х̰(хɝ}Ʌ}مՕ}܈хɝ}Ʌ}مՕ}ܰ(хɝ}Ʌ}مՕ}聘-I\хɝ}Ʌ}مՕ}(ɕ}х̈耉}ɍ}ٕѵ}ѕ}(ͽɍ}є耠( ɍٕѵЁѕ́ɕՔɍ͔ɽم(ɽͅչѥɅ͕ɥ䰁ɅаمՔɑɅѥ̰ѥ̰(ɕ٥ܵ䰁٥ȁ-I\Ȱᕍѥٔɕ٥쁥Ё̀(ЁمՅѥՅɅѕɍ͔ѵаͥɑȰɽՍѥ(ѥєѡɐ䁅ѕхѥȁɕٕՔɽ((ᕍѥٕ}ɕѥ(ѥѱ耉-I\ɍٕѵЁѕ(ɕѥ}х̈ɕѥ}х̰(ɕѥ耠(Iѕɕ٥܁ݥѠȁѡɥ䰁ɽՍѥѕ䰁ѕɹ(ѕхѥѥ́Ʌ͕Ʌѕ䁙ɽɕɽՍЁ٥(ɕѥ}х̀ɕ}ݥѡ}}ѥ̈(͔Ёɕչѥɕє́ɔɕ(ɕѥ}х̀􀉑}}ɕ}չѥ}}ɕ(͔IѕɽمݥѠȁȵѥ̸((Ցl(%ٕѵЁѕȈ(Ȉ(ݹȈ(AɽɕЁݹȈ(1ݹȈ(Mɥ䁽ݹȈ(%хѥݹȈ(t((}յ(͕ѥ}չЈ聱}͕ѥ̤(ɕ}չЈхѕ}չ̹Рɕ䈰(݅ɹ}չЈ݅ɹ}չа(}չЈ聉}չа(}չЈ聱ɕեɕ}չѥ}̤(ɕ٥}ɽ}}Ȉ聑Օ}lɕ٥}ɽ}ul}ȉt(}}͕͔((}͕ѥ̈聵}͕ѥ̰(ɕեɕ}չѥ}̈ɕեɕ}չѥ}̰(ѕ}ͥ}Օѥ̈l(%́ѡɽՍЁ٥ՙЁȁ-I\ȁɕ٥(ɔȁѡɥ䁑յ́Ʌ(ɔɽՍѥѡɐ䁕٥́Ё݅ɹ(%́䁍ɕєȁɕ͕(t(}ͥ}ѥ̈聑Օ}l}ͥ}ѥ̉t(lᕍѥٔͽȁɽمٕѵЁѕͥt(ɕѕ}̈聍ɕѕ}̰(ٕѵ}ѕ}х}ձ̈l((ٕѵ}ѕ}х̈耉ɍ}ٕѵ}ѕ}ɕ䈰(ձ耉͕ѥ́ɔɕ䁅ȁѡɥ䰁ɽՍѥȁѡɐ䁕٥ɕ́(((ٕѵ}ѕ}х̈耉ɍ}ٕѵ}ѕ}ɕ}ݥѡ}݅ɹ̈(ձ耉ɕѕ٥́ɕݡȁѡɥ䰁ɽՍѥѕ䰁ȁѕɹѕхѥ́ɕЁ݅ɹ̈(((ٕѵ}ѕ}х̈耉ɍ}ٕѵ}ѕ}(ձ耉͕ɥ䁙ɔA$ɅЁɕɕͥյЁ͵эչѥаͥ٥ȁ Ё́ͅѕɕѥ((t(ɕ٥}ɽ}聑Օ}lɕ٥}ɽ}t(ɕѕ}չѥ}ɕ̈(ɍ}Օ}}х̈聑Օ}lՕ}}х̉t(ɍ}ɍ͕}ɽم}х̈ɍ͕lɍ͕}ɽم}х̉t(ɍ}ɽͅ}х̈ɽͅlɽͅ}х̉t(ɍ}ѥ}х̈聍ѥlѥ}х̉t(ɍ}}х̈聑l}х̉t(}х}ݽɭ}х̈聉}ݽɭlݽɭ}х̉t(ɍ}͕}х̈聍͕l͕}х̉t(ɍ}ɽɕ}х̈ɽɕlɽɕ}х̉t(ɍ}Ʌ}х̈聍ɅlɅ}х̉t(ɍ}مՕ}х̈مՕlمՕ}х̉t(ɍ}͕ɥ}ѕхѥ}х͕̈ɥl͕ɥ}ѕхѥ}х̉t(ɍ}ɑ}х̈聽ɑlɑ}х̉t(ɍ}Ʌѥ}х̈聽ɅѥlɅѥ}х̉t(ѥ}ɕ}х̈聅ѥlɕ}х̉t(}}չЈ聱}хѕl̉t((Ʌ}}ͥ聑Օ}lɅ}}ͥt(՝}Ʌ聑Օ}l՝}Ʌt(ѕ}̈(}ͥ}耉輽ܹͥi5]!Ii9](}ɐ耉輽ܹɐ]5M!!MA4(չѥ}Ј耈Ľɍ}ٕѵ}ѕ}̽ѕЈ(յхѥ耉̽ɍ}ٕѵ}ѕ}((((}хє(͕(ݹ}ȁ99((ɽȁ99(͔ȁ99(mȰt( եѡͽхє屽ɽ̰䰁ՑЁф(}}ͥ销􁵅İ͕ѕ̤(ɕɸ(͕̈}̡}ͥ}}ͥ锤((͕久}Р(ɽ̈聱С͕I=1}QL((ɽѥ}٥(ɅЈ͕}ɽ}ɽѕȹ͹͡Р(Յ͕}Յ}ɽѕȹ͹͡Р((ɕ}ݽɭ}չ̈l(͕}͡ѕ}ոո(ȁո͕}ɕ}չ̠(}ͥİ͕}չ}ɑȤݹ}ݹ}((t(ɕ}Ց}ٕ͕̈}ɕ}Ց}̡ٕɽɽ͔͔(ɕ}ѡɥѥ}͕ͥ̈}ɕ}ѡɥѥ}̠ͥ(͕}ѥ̠(((}͡ѕ}ո͕ո聑mȰtmȰt耀Ʌ聹ٕ(ɕɸ(ݽɭ}չ}չlݽɭ}չ}t(չlt(}չl}t(ɕѕ}Јչlɕѕ}Љt(((}}Ʌ}є͕ո聑mȰt(ɅոРɅmt(ЁɅ(ɕɸ͔(ȁѕɅ(Ё䁥ѕȁ䁥ɽ}Չхͬ̈Ј(ɕɸ͔(Ёͥхѕl̉tФȁѕlЉt́9(ɕɸ͔(ٕɥѥոРٕɥѥȁ(ɕɸոРݕȈѕٕɥѥɕͽٕɥѥ((}}}ͅ}ո͕ո聑mȰt(չlt􀉍ՍЈչl}͹͡ЉtРٕɥ}ɕեɕЁոРٕɥѥ(ɕɸ͔(ɕɸ͕}ɽ٥}፱ͥ}}չСո((}ɽ٥}፱ͥ}}չС͕ո聑mȰt(͕̀(ȁѕոРɅmt((Ѐ͕}Сѕl}t(ፕЁ-ɽ(͕̀(ѥՔ(ѕlɽtйɽ٥}፱ͥ(͕̀(ɕɸ͕((}}}ɥ͕}չ聑mȰmȰutmȰt(͠􁱽}չ̹Р(ѡ}}̀ͽѕȁ}չ́􀉕(ѽȀ􁱕͠ѡ}}̤(ͥl(}(ȁ}ѡ}}(ȁ䁥ͽѕ͠(Ё}չm}tС(t(յɅѽȀ􁑕ѽȀͥ(ɕɸ(յɅѽȈ聹յɅѽȰ(ѽȈ聑ѽȰ(مՕ}ɍЈ͕}ɍСյɅѽȰѽȤ(ͥ}̈聵ͥ(((}ɍС͕յɅѽ聥аѽ聥ФЁ9(ѽȀ(ɕɸ9(ɕɸɽչյɅѽȀѽȤȤ((}ɥѕɥ(͕(ɥѕɥ}Ȱ(Ȱ(хȰ(٥Ȱ(ɕѥȰ(mȰt(ɕեɕ}}ɥѕɥ}ͅ}ɕ̹ɥѕɥ}(х́Ё̈݅ɸ耀Ʌ聹ٕ(Ʌ͔YՕɽȠ́ͅɕ́х́Ё̰݅ɸȁ(ɕɸ(ɥѕɥ}聍ɥѕɥ}(х̈х̰(聱(٥聕٥(ɕѥɕѥ(((}}٥}ѕ(͕(ѕ}Ȱ(Ȱ(ɕ٥ݕȰ(ͽɍ聱mt(٥}Ȱ(ѥ}хєȰ(٥Ȱ(}ѥȰ(mȰt(ɕեɕ}}ѕ}}٥}йѕ}(٥}Ё(ɕ}(ɕͥѽ}ѥЈ(}ѥЈ(ɽ͕}չѥ}ɽՍѥ(ɽ͕}չѥ}}(耀Ʌ聹ٕ(Ʌ͔YՕɽȠȁ٥́م(ѥ}хєЁɕ䈰݅ɹ耀Ʌ聹ٕ(Ʌ͔YՕɽȠȁ٥ѥхєЁɕ䰁݅ɹȁ(ɕɸ(ѕ}聥ѕ}(聱(ɕ٥ݕȈɕ٥ݕȰ(ͽɍ̈ͽɍ̰(٥}聕٥}(ѥ}хє聍ѥ}хє(٥聕٥(}ѥ聹}ѥ(((}}}յ͕ѕ聱mmȰutmȰt(ѥ}չ̀ չѕȡѕlѥ}хєtȁѕѕ̤(٥}չ̀ չѕȡѕl٥}tȁѕѕ̤(ɕɸ(ѽх}ѕ̈聱ѕ̤(}ѥ}хє(ɕ聍ѥ}չ̹Рɕ䈰(݅ɹ聍ѥ}չ̹Р݅ɹ(聍ѥ}չ̹Р((}٥}(ɕ}聕٥}չ̹Рɕ}(ɕͥѽ}ѥЈ聕٥}չ̹Рɕͥѽ}ѥЈ(}ѥЈ聕٥}չ̹Р}ѥЈ(ɽ͕}չѥ}ɽՍѥ聕٥}չ̹Рɽ͕}չѥ}ɽՍѥ(ɽ͕}չѥ}}聕٥}չ̹Рɽ͕}չѥ}}((((}͕ɥ}ɕ}ɥѕɥ͕͕ɥ}ɽ聑mȰtmȰt(ѡ}͕ɥ}ɽРѡ}}}Ѡ(Օ聱mtmt(݅ɹ聱mtmt(ѡ}ͥ}ѽ(݅ɹ̹ͥɕȁѽ͡ɕ䁅ɕ͍̈(ѡ}Ё}ѽѕɹ}ɕ}ٕɥȉ(Օ̹ɕȁѽɕͥ䁑ٕЈ(͕ɥ}ɽР}Չ}(Օ̹Չ́(͕ɥ}ɽР͕}Ʌ}}ձЈ(Օ̹Ʌɔ́䁑ձЈ(С͕ɥ}ɽРɅѕ}}ɕՕ̈Ȁ(Օ̹ɕՕЁɅєѥ́ͅ(С͕ɥ}ɽР}ɕ}չ̈Ȁ(Օ̹ոɕ䁱ѥ́ͅ((Օ(х̀􀉙(٥쀈Օ̤(ɕѥIեɔɕȁѠɥمєձ̰Ʌ̰Ʌє̰ո̸(݅ɹ(х̀݅ɸ(٥쀈݅ɹ̤(ɕѥȁѕɥ͔̰Ёɕѽ́ɔѽȁمՅѥ(͔(х̀̈(ѡ}٥(ѕɹɕȁٕɥȈ(ѡ}􀉕ѕɹ}ɕ}ٕɥȈ(͔Ёѽ̈((٥􁘉ѡ}٥ɥمєձаɅ̰Ʌє̰ո́ɔɕ(ɕѥ-ѡ͔ɽ́ȁѽȵ̸((ɕɸ͕}ɥѕɥ͕ɥ}ɔMɥɔх̰٥ɕѥ((}}ɕ}ɥѕɥ͕ѥ聑mȰtmȰt(}ɥ􁹕Р(ɥȁɥѥlՅɑɅ̉tɥlɥ}t􀉱}}ɥ((ͥ􁱽}ɥРͥ}̈mt(ɥ􁱽}ɥРمՕ}ɍЈ(ɥ(х̀̈(٥͠-ɕ́ɔ(ɕѥ-ɥѕ́ѕݡɅѽȁ丈(͔(х̀݅ɸ͔ͥ(٥􁘉ɥɥ쁵ͥ윰ͥȀչ͕́Н(ɕѥͥ-ɕ͠Ʌѽȁ́ɔѽȁɕ٥ܸ(ɕɸ͕}ɥѕɥ}ɕ̈1ɕ̈х̰٥ɕѥ((}ɽ٥}ɕ}ɥѕɥ͕mȰt(չͅmt(ɕєmt(ȁЁ͕(й͕}ɰхݥѠ輼(ѥՔ(}}}ɽ٥}ɰй͕}ɰ(ѥՔ(ɕєй(͕ɱ͔й͕}ɰ(͕͍􀉡̈ȁЁйɕѥ}(չͅй(չͅ(х̀􀉙(٥􁘉չͅɽ٥ȁɕ́ȁ윰ͽѕչͅ(ɕѥÚ͔ɽ٥ȁ́ݥѠ-Xɕѥɔɕєɕ̸(͔(х̀̈(٥(ɽ٥́(Ёɕє(͔ɕєɕєɽ٥͔́́-Xɕѥ((ɕѥ-ɽ٥ȁܵЁɍЁȁɽ٥̸(ɕɸ͕}ɥѕɥɽ٥}ɕ}ͅ䈰Aɽ٥ȁɕ́ͅ䈰х̰٥ɕѥ((}ɥѕɥ}}͕ɥѕɥ聱mmȰutmȰmȰut(ɕɸɽlɥѕɥ}tɽ܁ȁɽ܁ɥѕɥ((}ɥ}}͕ɥ聱mmȰutmȰmȰut(ɕɸɽlɥ}tɽ܁ȁɽ܁ɥ((}ɍ}յхѥ}ɽ͕mȰt(ɽЀAѠ}}}|ɕͽٔɕlt(ɕեɕ}յ̀l(I5(M UI%Qd(̽ɽՍ}(̽ɕ}}ͥ(̽ѥ}(̽ɍ}ɕ̹(t(ͥ}յ̀l(յ}Ѡ(ȁյ}Ѡɕեɕ}յ(ЀɽЀյ}Ѡ}(t(ɕɸ(ɕեɕ}յ̈ɕեɕ}յ̰(ͥ}յ̈聵ͥ}յ̰(ɕ͕}չЈ聱ɕեɕ}յ̤ͥ}յ̤(ɕեɕ}չЈ聱ɕեɕ}յ̤(}͕ɥ}耡ɽЀM UI%Qd}(ͽɍ耉ɕͥѽ䁑յхѥ̈(((}ɥѕɥ}յ͕ɥѕɥ聱mmȰutmȰt(չ̀ չѕȡɽlх̉tȁɽ܁ɥѕɥ(ɕɸ(̈聍չ̹Р̈(݅ɸ聍չ̹Р݅ɸ(聍չ̹Р((()ɕ}ѕСѕȤ(5ͬɕѥ̀͡A$̰ѽ̰ݽɑ̰ɕȁ̤ɽɅ̸((́ЁͬA%$ɕ͕̰̰ьȁٕɹɥͬ(A%$́ɽѕѕ͔ѕѡɥѥѥՑЁЁ(ɽ她Ёٕɕ͔ЁA%$ͭɔɽٕ䁑ݹɕ(յȁѡЁ́ѡɕѕЀЁɕɥՅɕ͕̤((ɕѕѕ(ȁѕɸM IQ}AQQI9L(ѕɸѕɸݕȠхݥѠ(ɕѕѕɸՈэ聘эɽĥэɽȥmI Qtɕѕ(͔(ɕѕѕɸՈэ聘эɽĥmI Qtɕѕ(ɕɸɕѕ(()ɕ}مՔمՔ䤀(IٕͥɕЁɥمՕ́ݡɕ͕٥ɕ͔͡(ͥхمՔȤ(ɕɸɕ}ѕСمՔ(ͥхمՔФ(ɕɸmɕ}مՔѕȁѕمՕt(ͥхمՔФ(ɕɸɕ}مՔѕȁ䰁ѕمՔѕ̠(ɕɸمՔ()}ɕ}ɕ}}مՔمՔ䤀(ͥхمՔФ(ɕɸ(ͽѕ(ȡ䤰}ɕ}ɕ}}مՔѕ(ȁ䰁ѕمՔѕ̠(((ͥхمՔа(ɕɸ}ɕ}ɕ}}مՔѕȁѕمՔ(ͥхمՔ͕Ф(ɕɸͽѕ}ɕ}ɕ}}مՔѕȁѕمՔ((͠مՔ(ፕЁQɽ(ɕɸɕȡمՔ(ɕɸمՔ(()}}ɍ}ɕСѡ䤀(Ʌ̡ѡ(Ʌȡ͕Qͭ=ɍɅѽȰɝ䰀݅ɝ䤀mȰt(} =55I %1}IA=IQ}  !Р(ѽ9(́9((ѽ} =55I %1}IA=IQ}  !͕С(((ѡ}}}|(}ɕ}ɕ}}مՔɝ̤(}ɕ}ɕ}}مՔ݅ɝ̤((䁹Ё(mt􁵕ѡ͕ɝ̰݅ɝ̤(ɕɸmt((ѽ́Ё9(} =55I %1}IA=IQ}  !ɕ͕Сѽ((ɕɸɅ(()ȁ}ɍ}ɕ}}ɍ}ɕ}ѡСQͭ=ɍɅѽȹ}}}|ѕ̠((}ɍ}ɕ}хݥѠɍ|(}ɍ}ɕ}ݥѠ}ɕЈ(}ɍ}ɕ}ѡ((͕хȠ(Qͭ=ɍɅѽȰ(}ɍ}ɕ}(}}ɍ}ɕС}ɍ}ɕ}ѡ((()}ɕѽ}ɽСɕձ聱mmȰutmmȰut( ́ЁѕՅЁݸ(ɕmɽ܁ȁɽ܁ɕձ́ɽܹР}͐́Ё9t(ɽ聱mmȰutmt(ȁɕ(ѕ􁅹(́Ё(lՅtlՅt(l}͐tl}͐t(lՅtlՅtȁl}͐tl}͐t(ȁɕ((Ёѕ(ɽй(ɕɸɽ(()}ɕ}ɕձ聱mmȰut}Ց}͐聙Ё9mȰt9(ɕmɽ܁ȁɽ܁ɕձ́ɽܹР}͐́Ё9t(Ёɕ(ɕɸ9(}Ց}͐́Ё9(ɑmȁȁȁɕl}͐t􁍽}Ց}͑t(ɑ(Ѐ􁵅ࡅɑ耡lՅtl}͐t(ɕͽ􀉡ЁՅݥѡЁՑЈ(͔(Ѐ􁵥ɕl}͐t(ɕͽ􀉹ݥѡՑ쁍Ёѕ(͔(5᥵锁əɵа锁Ё́ѡѥɕЁѡ(еՅ䁍̤PѡЁɕՅݡЈ(Ѐ􁵅ࡵɕ耡lՅtl}͐t(ɕͽ􀉡ЁՅ쁍ЁՅՅ䁍̈(ɕɸ쉹聉ltՅ聉lՅt}͐聉l}͐tɕͽɕͽ(()}͍ɕ}ɍɅѽ䰁хͭ聱mmȰutՅ}䰁Ȱ͕}э聉(5Յ䁽ٕȁѡх͕ͬɽє́䁕مՅє٥ э(͕}эɽє(ɕɑ̀ɍɅѽȹэ}ɽєmхͭlɽЉtȁхͬхͭt(͍ɕ̀mСՅ}хͬɕɑlݕȉtȀȁхͬɕɐх̰ͭɕɑ̥t(͔(͍ɕ̀l(СՅ}хͬɍɅѽȹոmɽ耉͕ȈѕЈхͭlɽЉutlݕȉt(ȁхͬхͭ(t(ɕɸմ͍ɕ̤͍ɕ̤͍ɕ͔́(()ѥ}ɍɅѥ(ѕ聱mmȰut(хͭ聱mmȰut(Յ}(}Ց}͐聙Ё99(͕}э聉͔(mȰt(MɍɍɅѥ́ȁ᥵մՅ䁅ЁմЀѡ՝ԁɅ((ѕ́聁m쉹ȰɍɅѽȈQͭ=ɍɅѽȰu(ɍɅѽȁ͡ձɕ͠ͼ́ɕ́ѡ͕́ɍ(хͭ́聁mɽЈȰuPѡم͕쁕хͬѡɽՍ(ݕȁ͕́ѼՅ}(Յ}хͬݕ}ѕФсltPѡȝ́ɕՅ(ͥݕ́ȁՑQ́չѥ́ЁɥєՅ(}Ց}͑聽ѥIѥ􁡥еՅ䁍ݥѡ(Ցа͔ѡݥѠՑаѡЁՅȵUM((Iɹ́ȵɕՅ䀬ɕаѡAɕѼɽаɕѥ((ɕձ聱mmȰutmt(ȁєѕ(ɍɅѽȀ􁍅ѕlɍɅѽȉt(􁍅єРѼ(Յ}͍ɕ}ɍɅѽȰх̰ͭՅ}͕}э(ЀɍɅѽȹ}ѥ̠lѽх̉ul}͐t(ɕձ̹(聍ѕlt(聵(ՅɽչՅ䰀Ф(}͐ɽչаؤЁ́Ё9͔9(Յ}}͐耠(ɽչՅ䀼аȤЁ́Ё9Ѐ͔9((хͭ}չЈ聱х̤ͭ(((ɕɸ(ѥٔ耉᥵锁Յ䰁锁Ј(}Ց}͐聍}Ց}͐(ɕձ̈ͽѕ(ɕձ̰(耠(lՅt(l}͐t́9(l}͐tl}͐t́Ё9͔Р(((ɕѽ}ɽЈmltȁȁ}ɕѽ}ɽСɕձ̥t(ɕ}ɕ}ɕձ̰}Ց}͐((()ٽٕ}ɍɅѥ(ե}ɍɅѽ(͕ɍ}聑mȰmut(хͭ聱mmȰut(Յ}(Ʌѥ聥Ѐа(ձѥ聥Ѐذ(}Ց}͐聙Ё99(͕聥Ѐܰ(͕}э聉͔(mȰt(ٽٔɍɅѥ́ѽ݅ɐՅ䁅ЁЀQI%9%Qd屔͕ɍ((ȁ͕ɍ́ѽɝѼյɅє聄͕хѥ͕ѥٕ(͕ɍ}ɅєمՕ̤ե}ɍɅѽȡɕɹ́(ɕ͠Qͭ=ɍɅѽȁȁѡȁݹ́ɽ٥ȁݥɥ쁕(مՅѕ=9 PɥѥݡمՅѥ́ɕA$((ѹ́᥵́ɕՅ䰁ѡ́ɕ쁍́ݡ͔(ፕ́}Ց}͑Ʌ܁ɑ̸EՅ䁍́ɽѡ(ȝ́Յ}хͬݕȤluPٕȁɥѕ((ɹɅI͕(Ʌ̀ͽѕ͕ɍ}((Ʌ}mȰt(ɕɸɹ͕ɍ}mtȁɅ((хє聑mȰtmȰt(􁑥С(ɹɅ̤(̀m؁ȁ؁͕ɍ}mt؀􁍽mutȁ͕ɍ}mt(mtɹ̤(ɕɸ((䡍聑mȰt(ɕɸͽյ̡聍mtȁɅͽ}QՔɕ}͍͔((مՅѕ聑mȰmȰut((مՅє聑mȰtmȰt(}􁭕䡍(}䁥مՅѕ(ɕɸمՅѕm}t(ɍɅѽȀե}ɍɅѽȡ(􁍽РѼ(Յ}͍ɕ}ɍɅѽȰх̰ͭՅ}͕}э(ЀɍɅѽȹ}ѥ̠lѽх̉ul}͐t(ɕձЀ(聍}(聑С(ՅɽչՅ䰀Ф(}͐ɽչаؤЁ́Ё9͔9(Յ}}͐耠(ɽչՅ䀼аȤЁ́Ё9Ѐ͔9((хͭ}չЈ聱х̤ͭ((مՅѕm}tɕձ(ɕɸɕձ((ѹ̡ɽ聑mȰtmааt(ɽl}͐t́9(ɕɸɽlՅtР(ɑā}Ց}͐́9ȁɽl}͐t􁍽}Ց}͔͐(ɕɸɑɽlՅtɽl}͐t((Mձѥ́ͼѥ͸Ё݅єمՅѥ̤(聱mmȰutmt(͕͕mt͕Р(ݡձѥ͕ձѥа}}ͥ锡͕ɍ}(Ʌ}(䡍Ё͕(͕䡍(((ѽ聱mmȰutmt(ȁɅѥɅɅѥ̤(ɽ̀mمՅєȁt(ɽ̹ͽСѹ̰ɕٕ͔QՔ(٥ٽ̀ɽl聵İɽ̤ȥt(ѽ久(Ʌѥ聝Ʌѥ(Ј쉍٥ٽlultՅ٥ٽlulՅt}͐٥ٽlul}͐u(مՅѕ}ѽх聱مՅѕ((mСɽltȁɽ܁٥ٽt(ݡձѥ(хєɹ٥ٽ̥lt((ɕձ̀ͽѕمՅѕمՕ̠ѹ̰ɕٕ͔QՔ(ɕɸ(ѥٔ耉᥵锁Յ䰁锁Ѐٽѥ͕ɍ(}Ց}͐聍}Ց}͐(Ʌѥ̈聝Ʌѥ̰(مՅѥ̈聱مՅѕ(}ͥ锈}}ͥ锡͕ɍ}(ɕձ̈ɕձ̰(ɕѽ}ɽЈmɽltȁɽ܁}ɕѽ}ɽСɕձ̥t(ɕ}ɕ}ɕձ̰}Ց}͐(ѽ聡ѽ((()}}ͥ锡͕ɍ}聑mȰmut(ͥ销(ȁمՕ͕́ɍ}مՕ̠(ͥ销􁵅İمՕ̤(ɕɸͥ(()}ѥ}ɕ͔(ɕձ聑mȰt(Ȁ􀉍ѕՅɍɅѽȈ(Ց}Ʌ聉͔(ͅ聑mȰt99(mȰt耀Ʌ聹ٕ(]ɅɍɅѥЁ=$ѥЁѥɕ͔((ͅɥ́ɕѽչ̸͕ɕ́Ёձ((ɍɅѥ(ݽɭ}չ}ɕձйРݽɭ}չ}(ɕձlt(ٕɥѥɕձйРٕɥѥ(ɕձйР(ɽѥ}ɕͽɕձйРɽѥ}ɕͽ(ͅ}ɕɑ}ɕձйРͅ}ɕɑ}(ЈɕձйРЈ((Ց}Ʌ(ɍɅѥlɅtɕ}مՔɕձlɅt(ͅ聑mȰtɽ耉ͥхЈѕЈɕձlݕȉu(ѽ}̀ɕձйРѽ}̈(ѽ}(ͅlѽ}̉tѽ}(ЁɕձйРݕȈ(ͅlѕЉt9(͡}ɕͽɕձйР͡}ɕͽȀѽ}̈ѽ}͔́ѽ(ɕɸ(}}}ѥ}(Ј耉йѥ(ɕѕ聥Сѥѥ(聵(̈l(((ͅ聵ͅ(͡}ɕͽ聙͡}ɕͽ((t(ͅͅ(ͅ}ɕ}х̈耉ɕ́ͅЁ9͔չم(ɍɅѥمՔȁ䰁مՔɍɅѥѕ̠مՔ́Ё9((()ѕ}ѥ}ɕ͔(ɕձ聑mȰt(Ȁ􀉍ѕՅɍɅѽȈ(ͅ聑mȰt99(mȰt耀Ʌ聹ٕ(]ɅɍɅѥЁ́=$䁁ѕ}ѥĽѥ́(ɕɸ(聘Сѥѥ(Ј耉ѕ}ѥ(ɕѕ聥Сѥѥ(聵(̈l(((ѕЈɕձlݕȉt(ɽ̈9(͡}ɕͽ耉ѽ((t(ͅͅ(ͅ}ɕ}х̈耉ɕ́ͅЁ9͔չم((()}MQI5} !U9-}M%i(()}ѥ}չ̠(ɕձ聑mȰt(Ȁ􀉍ѕՅɍɅѽȈ(Ց}Ʌ聉͔(Ց}ͅ聉͔(mmȰut(ɅɍɅѥɕձЁ́=$ѥЁѥչ̸((=ɽ٥ȵɕѕͅ䁉ѕѕ݅䁕ѥѕ́ɕѕɹ(͔ɕ͕ѥѥѕ́́ɽ٥ȁͅݽձ٥єѡݥɔɅи((ݕȀɕձйРݕȈ(ѥ}}}}ѥ}(ɕѕ􁥹Сѥѥ(͔(聍ѥ}(Ј耉йѥչ(ɕѕ聍ɕѕ(聵((Ց}ͅ(͕lͅt9((չ聱mmȰutl((͔(̈l(쉥фɽ耉ͥхЉ͡}ɕͽ9(t((t(ȁ͕ЁɅݕȤ}MQI5} !U9-}M%i(􁅹ݕm͕Ѐ聽͕Ѐ}MQI5} !U9-}M%it(չ̹((͔(̈l(쉥ф쉍ѕЈ͡}ɕͽ9(t(((ѽ}̀ɕձйРѽ}̈(ѽ}(չ̹((͔(̈l(((ф(ѽ}̈l(쉥聥ఀ(ȁఁյɅєѽ}̤(t((͡}ɕͽ9((t((((ɍɅѥ(ݽɭ}չ}ɕձйРݽɭ}չ}(ɕձйР(ٕɥѥɕձйРٕɥѥ((Ց}ɅɅɕձ(ɍɅѥlɅtɕ}مՔɕձlɅt((͡}ɕͽɕձйР͡}ɕͽȀ(ѽ}̈ѽ}͔́ѽ(((͔(̈m쉥ф͡}ɕͽ聙͡}ɕͽt(ɍɅѥ(مՔȁ䰁مՔɍɅѥѕ̠مՔ́Ё9(((չ̹((ͅɕձйРͅ(ЀɕձйРЈ(Ց}ͅ(ɕ(ͥхаФ(йРɕ}х̈􀉵ɕ(ͥхͅФ((չ̹((͔(̈mt(ͅͅɕ͔9(ͅ}ɕ}х̈耉ɕɕ͔չم(((ɕɸչ(()}}}ѥ}( ɕєͥɕͥхЁ=$ѥѥѥȸ(ɕɸэեեР(()͕}ɕ}䡍չ聱mmȰut(Mɥ锁Ёѥչ́́MٕȵMЁٕ́ѕɵѕ䁁m=9u(Ʌ̀mфͽյ̡չɕ}͍͔qqȁչչt(Ʌ̹фm=9uqq(ɕɸɅ̤ \ No newline at end of file From bd8ce72f69ca31d1b3a0e555632d0003466f81e1 Mon Sep 17 00:00:00 2001 From: Seongho Bae Date: Sat, 12 Sep 2026 19:12:21 +0900 Subject: [PATCH 08/11] docs(effort): record ModelAgent capability repair evidence --- .../effort_capability_evidence_20260912.md | 26 ++++++++++++++++++- 1 file changed, 25 insertions(+), 1 deletion(-) diff --git a/docs/doctoring/effort_capability_evidence_20260912.md b/docs/doctoring/effort_capability_evidence_20260912.md index 7057a2471..8f815f020 100644 --- a/docs/doctoring/effort_capability_evidence_20260912.md +++ b/docs/doctoring/effort_capability_evidence_20260912.md @@ -1,6 +1,6 @@ # Reasoning-effort capability is typed evidence, not truthiness -Status: Proposed; implementation on PR #1119, not a protected-main release. +Status: Proposed; main-based successor implementation on PR #1136, not a protected-main release. Date: 2026-09-12. Owner: ContextualWisdomLab/contextual-orchestrator, provider request-profile boundary. @@ -52,6 +52,30 @@ Result: **83 passed**. The changed function covered **19/19 executable statement At the pre-write child head, GitHub returned zero check runs and no PR-triggered workflow runs. Absence is not success. Parent #1000 integration, complete current-head CI, independent review, immutable release and consumer adoption remain required. This patch neither retires the parent nor authorizes merging its unresolved numerical/synthetic diagnostics. The large canonical product-gap baseline was read but not replaced by this bounded doctoring record; its full-tree integration is still pending. +### Main-based successor boundary repair + +Review of PR #1136 at exact head `583ac7047df8129cabc3278eeb8d4ac96e43c348` +found that `ModelAgent.__post_init__` used equality-based membership for the +capability field. Python therefore admitted integer `1` and float `1.0` as +equal to `True`; a hostile object's equality hook also executed before the +request-profile boundary could apply its strict validation. + +RED commit `f0ad677ceb032ad90537df47571425604a22907a` exercises the real +`ModelAgent` and `ModelClient` Responses path. It produced three intended +failures: both numeric values reached request mutation without raising, and +the hostile equality hook executed. Repair commit +`0e514f316b63fdd2c43ae345bd9d70b10c0bb25a` replaces equality with an +identity/type check at construction. The repaired production blob is +`fd9369d8309ac37624a79637fb8470af433cd30c`; malformed evidence is rejected +before normalization, rendering, fallback selection, or payload mutation. + +Fresh local verification with CPython 3.12 used disabled third-party pytest +plugin autoload so an unrelated installed `pytest-asyncio` deprecation warning +could not replace repository evidence. All effort-prefixed tests plus the +client-boundary module completed with **153 passed** under `-W error`; Ruff, +`compileall`, and `git diff --check` also passed. This focused evidence does +not replace hosted exact-head Checks or independent review. + ## References Bray, T. (Ed.). (2017). *The JavaScript Object Notation (JSON) data interchange format* (RFC 8259, section 3). RFC Editor. https://www.rfc-editor.org/rfc/rfc8259.html#section-3 From 5d4e8e30b66acf21e30aaecf94e10799f3cef288 Mon Sep 17 00:00:00 2001 From: Seongho Bae Date: Sat, 12 Sep 2026 19:14:41 +0900 Subject: [PATCH 09/11] fix(effort): restore complete source after blob transport --- contextual_orchestrator/orchestrator.py | 8121 ++++++++++++++++++++++- 1 file changed, 8120 insertions(+), 1 deletion(-) diff --git a/contextual_orchestrator/orchestrator.py b/contextual_orchestrator/orchestrator.py index fd9369d83..441092b88 100644 --- a/contextual_orchestrator/orchestrator.py +++ b/contextual_orchestrator/orchestrator.py @@ -8614,4 +8614,8123 @@ def call( # one opaque collapse message. last_upstream_error: ProviderUpstreamError | None = None for agent in candidates: - retry_at]|Ἥz&^uɅѕ䀡эɕ=$A$٥ԁ͕́(Յ䁍ɅѡȁѡѕݥѠͅх̀͡ݥ(ɕ͍ȁЁЁ͔́́ݸ(͡丁=Ʌѽ́ЁͅЁ٥ͥѡɽ՝ѡ(͍}́əѕ((ɕѕ|||хͼЁɕ͕́ɔѕɵѥ(ф聱mmȰutl((͕Q]e}U1Q}5=0(Ј耉(ɕѕ聍ɕѕ(ݹ}耉ѕՅɍɅѽȈ((t(ф(͕UQ=}5=0(Ј耉(ɕѕ聍ɕѕ(ݹ}耉ѕՅɍɅѽȈ((͕}}Ʌ}ɕ}СФȁЁ͕̤(ф(͕I}5=0(Ј耉(ɕѕ聍ɕѕ(ݹ}耉ѕՅɍɅѽȈ((͕͕mtѕltȁѕх(5ɽ͕́ɔɕ̀ͅɽѕ(ѼѡЁɕȤͼٕѥ͔ѡɕ̸(ȁɽ͕}}ɽ̠(ЁɽР}}չЈ(ѥՔ(ɽ}̀ȡɽlɽ}t(ɽ}͕́(ѥՔ(͕ɽ}̤(ф((聝ɽ}̰(Ј耉(ɕѕ聍ɕѕ(ݹ}耉}ɽ(((͕́́ѡɽѥ͕ѕ́(хЁٕхѥͼͅЁ(ѡ́(ȁЁ͕(}ȡйɥ(Ё}ȁ}͕(ѥՔ(͕}(ф((聵}(Ј耉(ɕѕ聍ɕѕ(ݹ}聅йɽ٥}(ȁ͕}}ɽ٥}й͕}ɰ(Ȁ}(((ɕɸ쉽Ј耉Јф聑х((}}͕}ȤmȰt(Iɸ=$ЁȁɅ͔-ɽɁݡչݸ(݅ѕ􀡵}Ȁɥ(Ё݅ѕ(Ʌ͔-ɽȡ}(ȁѕ͕}}̠lфt(ѕlt݅ѕ(ɕɸѕ(Ʌ͔-ɽȡ}((}ɕ}չ̠(͕(}յ聥Ѐİ(}ͥ聥Ѐ(ݹ}ȁ99(mmȰut(IɸѕЁɕЁݽɭ܁ոɕɑ̸(}յȀāȁ}ͥ销耀Ʌ聹ٕ(Ʌ͔YՕɽȠ}յȽ}ͥ锁ЁĈ(хЀ}յȀĤ}ͥ(хЀ}ͥ(չ}̀l(չ}(ȁչ}͕}չ}ɑ(ݹ}́9ȁ͕}ݽɭ}չmչ}tРݹ}ݹ}(umх镹t(ɕɸm͕}ݽɭ}չmչ}tȁչ}չ}t((}ѕ}ݽɭ}չ̡͕mmȰut(Iɸݽɭ܁չ́٥ͥѼѕոյ̸((፱Ց́э}ɽѕ́ееՑ}ٕɥѥ(ɽ̀٥ɕ٥܁Ĥѡ͔ɔЁ}ݽɭ}չ́ͼ(ѡȁɕɕ䵥ɕٕ́ȁаЁɽ(́Ё͡ɕձЁЁЁєѕոչа(ѥ́-A$ȁɍɕ́ɥѡͅɕͽ(ѡЁɕ䁭́ѡЁ}չ}ɑɁ}ɕ}չ́(Mə̀}ѥ́Ʌѕ䁭ѕɅѥ(}ݽɭ}չ́ɕѱ䁥ѕѡ́Ȱͥ(ɽܝ́́ɕЁх䁍չѕѡɔ((ɕɸl(ո(ȁո͕}ݽɭ}չ̹مՕ̠(ЁոР}ٕɥѥЁոРɔ(t((չ}ݽɭ}չ̡͕ݹ}ȁ99( չЁ䁍ѕݽɭ܁չ́٥ͥѼѡɕՕѕݹȸ(ɕɸմ(ݹ}́9ȁɕɐРݹ}ݹ}(ȁɕɐ͕}ѕ}ݽɭ}չ̠(((}ɕ}Ց}ٕ̠(͕(}յ聥Ѐİ(}ͥ聥Ѐ԰((ɽȁ99(͔ȁ99(mmȰut(IɸɕЁՑЁٕ̰ѥA%$䁙ȁѡɥ镐ɕ丈((}յȀāȁ}ͥ销耀Ʌ聹ٕ(Ʌ͔YՕɽȠ}յȽ}ͥ锁ЁĈ(ٕ̀􁱥С͕}Ց}ٕ̤(хЀ}յȀĤ}ͥ(хЀ}ͥ(ѽх􁱕ٕ̤(Ѐ􁵅ѽх(ɥЀ􁵅ѽххФ(͕ѕ􁱥Сɕٕ͕ٕmɥt(ɽ􀉅ȁ͔􀉅Ց}ɕ(ɕɸ͕ѕ(ɕѽɕ聱mmȰutmt(ѽ聑mȰt(ȁٕЁ͕ѕ(хٕйРٕ}х(Ё}ѕ}хх(ɕѽɕٕФ(ѥՔ(ɕѽɕ}ٕЀ􁑥СٕФ((хф􁑕хС9 IeAQ}%1M}-d(}􁵕хфР}ͥххфФ͔͕}}}(Ёͥх}ȤȁЁ}(Ʌ͔AAɽѕѥɽȠѕхф́م䁹(ѽȀ􁕹ѽ̹С}(ѽȁ́9(ѽȀ􁱽}}ѽȡ}(ѽm}t􁕹ѽ(ɕѽɕ}ٕlٕ}хt􁕹ѽȹ}̡х(ፕЁAAɽѕѥɽ(ɕѽɕ}ٕlٕ}хt(х(}}}ɽѕѥ}ɽ}|耉չم((ɕѽɕɕѽɕ}ٕФ(ɕɸɕѽɕ((}ɕ}ѡɥѥ}̡͕ͥ}յ聥Ѐİ}ͥ聥ЀԤmmȰut(IɸɕЁ͕ɕеɕѡɥѥͥ́ݕеЁɑȸ(}յȀāȁ}ͥ销耀Ʌ聹ٕ(Ʌ͔YՕɽȠ}յȽ}ͥ锁ЁĈ(ٕ̀􁱥С͕}ѡɥѥ}ٕ̤(хЀ}յȀĤ}ͥ(хЀ}ͥ(ѽх􁱕ٕ̤(Ѐ􁵅ѽх(ɥЀ􁵅ѽххФ(ɕɸСɕٕ͕ٕmɥt((ɕɑ}ѥ}ٕР(͕(ٕ}Ȱ(х聑mȰt((}%ѕɅmt􀠤(9(IɐЁ䁅ѥٕ́ЁݥѡЁɽЁȁЁѕи(ɕեɕ}}ٕ}ѥ̹ٕ}(ٕЀ(ٕ}ѥ聥Сѥѥ(ٕ}聕ٕ}(ٕ}хɕ}مՔ͕}ɽѕѕ}ٕ}хх}̤((͕}ѥ}ٕ̹ٕФ(͕}ѽɔ́Ё9(͕}ѽɔٔͅѥ̈9ٕФ((}չ}Ց}}}(͕ɕɐ5mȰt(mmȰtt(IɸѡɥхѥٔȵЁѽ́م丈(}}Ѐ텝й聅йȁЁ͕ѕ(}}聑mȰt(ȁѕɕɐРɅmt(ѕР}ȁ}}йР(ѕР͕ٕ}}ȁѕР}չݸ((}ѽ̰}ͽɍ}ѕ}}ѽ̠(ѕ͕ѽ}չѕȰ((}ѽ́́9(ɕɸ͔(}}mt}}С}ѽ(ٕɥѥɕɐРٕɥѥ(ͥхٕɥѥ5(Ց}}ٕɥѥРՑ}}(Ց}}́Ё9(ѕՑՑ}}́䁕ٕȁ͕(̤ݡ͔ɕ͔ɥمͅ(ѥչЁѽ݅ɐѡՑЁѕȰȁո(չɕՑ́ձፕѡ(͕مѥٔ䵑ͥ́Ѽɍ(ѼѡͅѥєɽɕѕЁ}ѕ}}ѽ(ɕ䁅́Ѽݽɭȁѕ́ݥѠɕѕͅ(٥ɕ٥܁聅ɱȁɕ٥ͥѡ́(ɥѕɕѕɼѽЁѕѥє(ɽՑ}}ѕЀѡՑ́ݸɅѕ(ɅѥЁٕɥ}ЀѡݽɭȁݕȁЁ݅(Ց͕٥ɕ٥܁ѡ́ͅ(՝Ёѥѥɽѡɽͥѡ(Ց}ٕɥѥРՑ}ȁ}}йР(Ց}}չݸ((ѥ}ѽ̰}Ց}ɕѕ}ѕ}}ѽ̠((ٕͅɥѥРՑ}ͅ(ЈٕɥѥРՑ}}ѕЈ((͕ѽ}չѕȰ(Ց}((ѥ}ѽ́́9(ɕɸ͔(}}mՑ}t(}}СՑ}ѥ}ѽ((ɕɸ}}QՔ((}ɕ}ݽɭ}ո͕ɕɐ聑mȰt9(Mѽɔոє́хеѥՑЁѕȁѽ丈(}}Ѐ텝й聅йȁЁ͕ѕ(ȁѕɕɐРɅmt(ЁѕР}(}ѕР͕ٕ}}ȁѕР}(ѕl}t􁵽}}йС}չݸ(չ}ɕɑlݽɭ}չ}t(ݥѠ͕}Ց}}(ɕ٥͕̀}ݽɭ}չ̹Сչ}(ȁͥոİɕ٥̤İɕɐ(ո́9(ѥՔ(չ}}}ѕȀչlݽɭ}չ}t(}}م͕}չ}Ց}}}ո(م}}ՑЀم(͕Ց}}}͐́9(ȁ͕ɥ}}ȁ}}((ͥ(͕}Ց}չم}չ}̹͍ɐչ}}}ѕȤ(Ёم}}Ց(͕}Ց}չم}չ}̹չ}}}ѕȤ(ȁ}ѽ́}}ѕ̠(ɔ͕}Ց}}}ѽ̹С(ѕȀ􁉕ɔͥ}ѽ(ɥ͕ɥ}}С(ɥ́Ё9(͕}Ց}}}͐}}͑}(ѕȰɥ(}}͑}ɔɥ(ѕ(͕}Ց}}}ѽmt􁅙ѕ(͔(͕}Ց}}}ѽ̹9(͕}Ց}}}ѽ̀ͥ}ѽ(͕}ݽɭ}չmչ}tɕɐ((}ɕե}Ց}ѕȡ͕9(IѡѕȁѕȁɅɔеѥ䁍(ݥѠ͕}Ց}}(}}聑mȰt(չم}չ}͕mt͕Р(ȁո͕}ݽɭ}չ̹مՕ̠(չ}аم͕}չ}Ց}}}ո(م}}ՑЀم(͕Ց}}}͐́9(ȁ͕ɥ}}ȁչ}Ф((Ёم}}Ց(չم}չ}̹չlݽɭ}չ}t(ȁ}ѽ́չ}йѕ̠(}}mt}}С}ѽ(͕}Ց}}}ѽ̀}}(͕}Ց}չم}չ}̀չم}չ}(͕}Ց}}}ѽ̀մ}}مՕ̠(͕}Ց}}}͐մ((}}͑}}ѽ̰͕ɥ}}mt(ȁ}ѽ́}}ѕ̠(͕ɥ}}((х(((}ѥ̡͕ɥ}}聑mȰt99mȰt(Iɸɽ٥ȵɕѕȁᅍеѽȁЁͅи(ɥ̀쨩͕ɥ}}ɥ}}ȁ(}}Ѐ텝й聅йȁЁ͕ѕ(}聑mȰmȰut(ѽх}}ѽ̀(ɕѕ}ɽ}ѽ̀(ɽ}مQՔ((ȁո͕}ݽɭ}չ̹مՕ̠(ȁѕչlɅt(ѕР}ȁ}}йР(ѕР͕ٕ}}ȁѕР}չݸ((ͅѕРͅ(ɕѕ}ɽЀ(ͅРɽ}ѽ̈ͅР}ѽ̈(ͥхͅФ(͔9((ɕѕ}ɽФ́Ёɕѕ}ɽЀ(ɕѕ}ɽ}ѽ̀ɕѕ}ɽ(͔(ɽ}م͔(ѥٔͽɍ}ѕ}}ѽ̡ѕ͕ѽ}չѕȰ(ՍЀ}͕ёձР(((}ѽ̈(ѕ}չЈ(ɕѕ}ѕ̈(ѽ}ѕ̈(չم}ѕ̈(((Սlѕ}չЉt(Սmͽɍ}ѕ̉t(ѥٔ́Ё9(Սl}ѽ̉t􁕙ѥٔ(ѽх}}ѽ̀􁕙ѥٔ((ٕɥѥոРٕɥѥ(Ց}}(ٕɥѥРՑ}}(ͥхٕɥѥ5(͔9((Ց}}́Ё9(ѕՑՑ}}́䁕ٕȁ͕(̤Ёх٥ͥɔٕݡ(ɕ͔ɥمͅȁɕɕ(Ց́ͥѱ䁅͕Ёɽȵ(ѥ́ѥɕ丁5ɽȁѡݽɭȵѕٔ(ᅍѱ聕ѥєɽѡɕՑѕа(}ѕ}}ѽ́ɕЁѡЁɕѕѥѕ(Ёѕɥѕɕѕиѥєɽ(Ց}}ѕЀѡՑ́ݸɅѕɅѥ(Ёٕɥ}ЀѡݽɭȁݕȁЁ݅́Ց(Ց}ٕͅɥѥРՑ}ͅ(Ց}ѕЀٕɥѥРՑ}}ѕЈ(Ց}ٕɥѥРՑ}ȁ}}йР(Ց}}չݸ((ѥٔͽɍ}ѕ}}ѽ̠(ͅ聩Ց}ͅЈ聩Ց}ѕ(͕ѽ}չѕȰ(Ց}((ɕѕ}ɽЀ(Ց}ͅРɽ}ѽ̈Ց}ͅР}ѽ̈(ͥхՑ}ͅФ(͔9((ɕѕ}ɽФ́Ёɕѕ}ɽЀ(ɕѕ}ɽ}ѽ̀ɕѕ}ɽ(͔(ɽ}م͔(ՍЀ}͕ёձР(Ց}((}ѽ̈(ѕ}չЈ(ɕѕ}ѕ̈(ѽ}ѕ̈(չم}ѕ̈(((Սlѕ}չЉt(Սmͽɍ}ѕ̉t(ѥٔ́Ё9(Սl}ѽ̉t􁕙ѥٔ(ѽх}}ѽ̀􁕙ѥٔ((ɽ聱mmȰutmt(չɥ聱mtmt(ѽх}}͐(}مQՔ(}مQՔ(ȁՍЁͽѕ}ѕ̠(}مՍlչم}ѕ̉t(}م}م}م(ɥɥ̹С(}(}}͑}Սl}ѽ̉tɥ(ɥ́Ё9}م(͔9((Ѐ􁙱С}}́Ё9͔9(ɥ́9(չɥ(}م͔(Ё}م(}م͔(͔(ѽх}}͐􁍽}(Ё}م(ͅ}ͽɍչم(Սlɕѕ}ѕ̉tՍlѕ}չЉt(ͅ}ͽɍɕѕ(Սlѽ}ѕ̉tՍlѕ}չЉt(ͅ}ͽɍѽȈ(͔(ͅ}ͽɍ􀉵ᕐ(ɽ̹(聵(}ѽ̈聉Սl}ѽ̉t}م͔9(ͅ}ͽɍͅ}ͽɍ(ѕ}չЈ聉Սlѕ}չЉt(ɥ}}}͐ɥ(}͐聍а(((ɕ}х̀(չم(Ё}مȁЁɽ}م(͔ɕ(ɽlͅ}ͽɍtɕѕȁɽ܁ɽ̤(͔ᅍ}ѽȈ((ѕ}ɥ}م(͕Ց}}}͐́9(ȁ(йɥ(ȁЁ͕(}}Ʌ}}СФ(((ɕɸ(ɕ}х̈聵ɕ}х̰(ͽɍ}є耠(Aɽ٥ȁ́ͅѡɥхѥٔᅍЁѽȁչ́䁽Ѽ(ɕɅ܁ѕՅչɕՍѥ́ͅչم((ɥ}ɕ聉ɥ̤(ѽх̈(չ}չЈ聱͕}ݽɭ}չ̤(}ѽ̈ѽх}}ѽ́}م͔9(ɽ}ѽ̈ɕѕ}ɽ}ѽ́ɽ}م͔9(ɽ}ѽ}ͽɍ耉ɕѕɽ}م͔չم(}͐耠(Сѽх}}͐ɥ́}م͔9((ɕ耉UM((}ɽ̰(չɥ}̈չɥ(ՑЈ͕}Ց}(ѽх}}ѽ̰(Сѽх}}͐ɥ́}م͔9(ɕ}م}مѕ}ɥ}م((((}Ց}(͕(}ѽ聥а(}聙Ё9((ɕ}م聉QՔ(mȰt(ѽ}Ѐ͕Ց}}}ѽ(}Ѐ͕Ց}}}͐(ɕեɕ}م􁵕ɕ}م(}Ё́9ȁ}Ё́Ё9((ፕ􁉽(ɕեɕ}م(ѽ}Ё́Ё9}ѽ̀ѽ}Ф(Ȁ}Ё́Ё9}Ё́Ё9}Ѐ􁍽}Ф(((ѽ}Ё́Ё9ȁ}Ё́Ё9(ɕɸ(聕(}}ѽ̈ѽ}а(}}͐聍}а(}}ѽ̈}ѽ́ɕ}م͔9(}}͐}Ёɕեɕ}م͔9(ɕ}}ѽ̈耠(ѽ}Ѐ}ѽ̤(ѽ}Ё́Ё9ɕ}م(͔9((ɕ}}͐耠(ɽչ}Ѐ}Фؤ(}Ё́Ё9}Ё́Ё9ɕեɕ}م(͔9((ፕ聕ፕ(ɕ}х̈耉ɕɕեɕ}م͔չم(ɍ}х̈耠(}չمЁɕեɕ}م(͔ፕፕ(͔ݥѡ}ՑЈ((((Ց}х̡͕mȰt( ɕЁՑЁхє̰аɕፕ(ݥѠ͕}Ց}}(}ѽ͕̀}Ց}}}ѽ(}Ѐ􁙱С͕}Ց}}}͐(ѕ}ɥ}م(͕Ց}}}͐́9(ȁ(й͕ɥ}}(ȁЁ͕(}}Ʌ}}СФ(((ɕ}م(Ё͕}Ց}չم}չ}́ѕ}ɥ}م((ɕɸ͕}Ց}(}ѽ̰(}Ё͕ɥ}}͔9(ɕ}مɕ}م(((ѥ}͹͡С͕}չ聑mȰmȰut99mȰt(Iɸͽɍ-A$ѥ́ɽչѥхє(չ͕̀}ѕ}ݽɭ}չ̠(Սѕ}չ̀mոȁոչ́չlt􀉍ՍЉt(Ʌ}ѕ}չЀմāȁոՍѕ}չ͕́}}Ʌ}єո(}ͅ}չЀմāȁոչ͕́}}}ͅ}ոո(ٕ}չ̀ չѕȡٕlٕ}tȁٕЁ͕}ѥ}ٕ̤(Ս͙ձ}}ɕՕ̀մ((ȁٕЁ͕}ѥ}ٕ(ٕlٕ}t􀉍}ѥ}ɕՕѕ(ٕlٕ}хtРх}((ɽѕ}չЀմāȁոչ́չltɽє(Ս}չЀմāȁոչ́չlt􀉍ՍЈ(ѕ}չЀմչlɅtȁոչ̤(ɽ٥}፱ͥ}͕̀մ͕}ɽ٥}፱ͥ}}չСոȁոչ̤(}ɥ͕}}}ɥ䡱}չ́ȁ((ɕɸ(ɕ}х̈耉}չѥ}͹͡Ј(ͽɍ}є耉5ɥ́ɔɕɽѡ́ɽ́չѥЁɽՍѥѕ丈(ٕ}չ̈聑Сͽѕٕ}չ̹ѕ̠(̈l((ɥ}耉ѥ}}ѥ(耉 ѥA$ѥ(مՔՍ͙ձ}}ɕՕ̰(չЈ耉Ս͙ձ}ɕՕ̈(ͽɍ耉}ѥ}ɕՕѕٕ̈(((ɥ}耉Ʌ}ѕ}ݽɭ}Ʌє(耉QɅєݽɭ܁Ʌє(յɅѽȈɅ}ѕ}չа(ѽȈ聱Սѕ}չ̤(مՕ}ɍЈ͕}ɍСɅ}ѕ}չаՍѕ}չ̤(ͽɍ耉ݽɭ}չ́ՍЁɅ̈(((ɥ}耉}ͅ}ɽѥ}Ʌє(耉AͅɽѥɅє(յɅѽȈ}ͅ}չа(ѽȈ聱չ̤(مՕ}ɍЈ͕}ɍС}ͅ}չаչ̤(ͽɍ耉ݽɭ}չ́͹̈͡((t(ɥٕ̈l((ɥ}耉ɽѕ}ٕ}Ս}(耉Iє̵ٕՍЁ(չ̈ɽєɽѕ}չаՍЈ聍Ս}չ(ͽɍ耉ݽɭ}չ́(((ɥ}耉مՅѥ}ɕ}ͅ(耉مՅѥɕͅ(مՔ聕ٕ}չ̹РمՅѥ}չ}ɕѕ(չЈ耉չ̈(ͽɍ耉مՅѥ}չ}ɕѕٕ̈(((ɥ}耉}ѡ}ٕɅ(耉ЁѠٕɅ(յɅѽȈ聱mЁȁЁ͕́ййй͕}ɱt(ѽȈ聱͕̤(مՕ}ɍЈ͕}ɍР(mЁȁЁ͕́ййй͕}ɱt(͕̤((ͽɍ耉ЁɅѥ((t(ՅɑɅ̈l((ɥ}耉ɽ٥}፱ͥ}}Ʌє(耉Aɽ٥ȁ፱ͥ́Ʌє(مՔɽ٥}፱ͥ}͕̰(ѽȈѕ}չа(مՕ}ɍЈ͕}ɍСɽ٥}፱ͥ}͕̰ѕ}չФ(ͽɍ耉ݽɭ܁ɅЁ͕ѥ̈(((ɥ}耉}}ɥ䈰(耉1ɥ䈰(}ɥ(ͽɍ耉չ̈((t(((ͅ}ɕ}ɕР(͕(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(mȰt(Iɸ٥̵ͅɕ́єȁѕɥ̸͔(ѥ͕̀ѥ}͹͡С}չ}չ̤(}хє͕}хє(չ͕̀}ѕ}ݽɭ}չ̠(Սѕ}չ̀mոȁոչ́չlt􀉍ՍЉt(Ʌ}ѕ}չЀմāȁոՍѕ}չ͕́}}Ʌ}єո(ٕ}չ̀􁅹ѥlٕ}չ̉t(ɥѕɥl(͕}ɥѕɥ(}ѥ䈰(=$ѥA$(ٕ̈}չ̹Р}ѥ}ɕՕѕ͔݅ɸ(ٕ}չ̹Р}ѥ}ɕՕѕ􁍽ѥЁɕՕ́ɕɑ(IոĽнѥ́͵ѕЁɔѕɥ͔مՅѥ((͕}ɥѕɥ(}٥(=Ʌѽȁ٥ə(̈}хѕl̉t}хѕlt͔(}хѕl̝t􁅝̰}хѕlɕ}Ց}ٕ̝tՑЁٕ͕́(͔Ё䰁ՑЁхєɔͥѥѡɽՍЁ͕́((͕}ɥѕɥ(Ʌ}٥(]ɭ܁Ʌ٥(̈Ʌ}ѕ}չЀ͔݅ɸ(Ʌ}ѕ}չ􁍽єՍѕɅ́ɽ́Սѕ}չ̥􁍽Սѕչ̈(IոՍеݽɭ܁ͼ̵Ёٕɥȁ٥ɔ٥ͥ((͕}ɥѕɥ(مՅѥ}ɕ䈰(مՅѥɕ䈰(ٕ̈}չ̹РمՅѥ}չ}ɕѕ͔݅ɸ(ٕ}չ̹РمՅѥ}չ}ɕѕمՅѥɕչ́ɕɑ(IոЁЁمՅѥɕ䁉ɔѽȵЁɕ٥ܸ((͕}͕ɥ}ɕ}ɥѕɥ͕ɥ}ɽȁ(͕}ɥѕɥ(ѥ}ѡձ̈(ѥ́ѡձ̈(̈ѥlɕ}х̉t􀉱}չѥ}͹͡Ј͔(ѥlͽɍ}єt(1ɥ́́ɽ͕ѥ́չ́䁵ɕչѥѕ丈((͕}}ɕ}ɥѕɥѥ̤(͕}ɽ٥}ɕ}ɥѕɥ(t(յ͕}ɥѕɥ}յ䡍ɥѕɥ(ɕ}յ̈յl̉t݅ɸյl݅ɸtյlu(յlt(ɕ}х̀􀉹}ɕ(յl݅ɸt(ɕ}х̀}ɕ}ݥѡ}݅ɹ̈(͔(ɕ}х̀ͅ}ɕ((ɕɸ(ɕ}х̈ɕ}х̰(ɕ}х̈耉}չѥ}͹͡Ј(ͽɍ}є耠(Ḿɕ͕́́ѡ́ɽ̵չѥɅѥ(յхѥ٥쁥Ё́ЁɽՍѥѥє((յɕ}յ(ɕ}յɕ}յ(ɥѕɥ聍ɥѕɥ(((ɍ}ɕ}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(mȰt(Iɸɥѕɕ́єȁمՔѕɥ̸͔ͅ(ͅ}ɕ͕̀ͅ}ɕ}ɕР(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ѥ͕̀ѥ}͹͡С}չ}չ̤(ͅ}ɽ͕̀}ɥѕɥ}}ͅ}ɕlɥѕɥt(ѥ}ՅɑɅ͕̀}ɥ}}ѥlՅɑɅ̉t(յхѥ͕}ɍ}յхѥ}ɽ(͕ɥ}ɽ͕ɥ}ɽȁ(}ͅ}ɥ͕}ɥ}}ѥl̉tl}ͅ}ɽѥ}Ʌєt(ɽ٥}ɥ􁅹ѥ}ՅɑɅlɽ٥}፱ͥ}}Ʌєt(}ɥ􁅹ѥ}ՅɑɅl}}ɥt((ɥѕɥl(͕}ɥѕɥ(ɽՍ}}٥(AɽՍЁ䁕٥(̈ͅ}ɕlɕ}х̉tͅ}ɕ䈁͔݅ɸ((ͅ}ɕͅ}ɕlɕ}х̝u쀈(ͅ}ɕlɕ}յul̝úͅɥѕɥͥ((Iͽ̵ٔͅɕ́݅ɹ́ɔɕ͕ѥѡɽՍЁȁمՔɕ٥ܸ((͕}ɥѕɥ(͕ɥ}}}ɽ(Mɥ䁅́ɽ(̈(ͅ}ɽl͕ɥ}ɔulх̉ẗ(ͅ}ɽlɽ٥}ɕ}ͅulх̉ẗ(͔((ͅ}ɽl͕ɥ}ɔul٥u쀈(ͅ}ɽlɽ٥}ɕ}ͅul٥u((-Ёɕѽ̰ɥمєձ̰Ʌ̰ͅɽ٥ȁɕ̸((͕}ɥѕɥ(Ʌѥ}ɕͥ(=Ʌѥɕͥ(̈(С͕ɥ}ɽРɅѕ}}ɕՕ̈Ȁ(С͕ɥ}ɽР}ɕ}չ̈Ȁ(}ͅ}ɥРمՕ}ɍЈ(͔݅ɸ((Ʌѕ}}ɕՕ͕ɥ}ɽРɅѕ}}ɕՕ̜쀈(}ɕ}չ͕ɥ}ɽР}ɕ}չ̜쀈(}ͅ}ɽѥ}Ʌє}ͅ}ɥРمՕ}ɍМ((AՉ͠ɽՍѥM1=̰䰁Ёչ́ɔɽՍѥͅ((͕}ɥѕɥ(Ց}}}٥(ՑЁ٥(̈(ͅ}ɽlɅ}٥ulх̉ẗ(ɽ٥}ɥРمՔ(͔݅ɸ((ͅ}ɽlɅ}٥ul٥u쀈(ɽ٥}፱ͥ}͕ɽ٥}ɥРمՔ(( ɔѽȵ́ɕ́ፕѥ́ɥЁɑ((͕}ɥѕɥ(}Օ}}Ј( ȁՔЈ(̈Ёյхѥlͥ}յ̉t͔݅ɸ((푽յхѥlɕ͕}չНu푽յхѥlɕեɕ}չНuɕեɕյ́ɕ͕쀈(ͥ윰յхѥlͥ}յ̝tȀ(( єI5͕ɥ䰁A$ѥ̰ɽՍаɍɕ́յ̸((͕}ɥѕɥ(}}ѥ(MЁѥ(̈}ɥРمՕ}ɍЈյхѥl}͕ɥ}t͔݅ɸ((}}ɥ}ɥРمՕ}ɍМ쀈(͕ɥ}푽յхѥl}͕ɥ}u((--ɕ͠Ʌѽȁ䁅Չ͠Ёݹ͡ȁѽȁɅѥ̸((͕}ɥѕɥ(ɍ}مՕ}͔( ɍمՔ͔(̈хɝ}Ʌ}مՕ}܀U1Q} =55I %1}QIQ}Y1U}-I\͔݅ɸ((хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}쀈(مՔ͔͕́ѥA$٥ɽɕ䰁ՑЁɽ̈((ȁمՔ́ͅɕ٥܁Ё-I\ȰȁȁݥѠȵI=$٥((t(յ͕}ɥѕɥ}յ䡍ɥѕɥ(ɍ}յ̈յl̉t݅ɸյl݅ɸtյlu(ɍ}յlt(ɍ}х̀􀉹}ɍ}ɕ(ɍ}յl݅ɸt(ɍ}х̀􀉍ɍ}ɕ}ݥѡ}݅ɹ̈(͔(ɍ}х̀􀉍ɍ}ɕ((ɕɸ(ɍ}х̈聍ɍ}х̰(хɝ}Ʌ}مՕ}܈хɝ}Ʌ}مՕ}ܰ(хɝ}Ʌ}مՕ}聘-I\хɝ}Ʌ}مՕ}(ɕ}х̈耉}Օ}}͹͡Ј(ͽɍ}є耠( ɍɕ͕́́ɽ̵չѥɕͥѽ䁑յхѥ(͕ɥ䁍Ʌѥѥ́٥쁥Ё́ЁمՅѥՅɅѕ(ɍ͔ѵаȁɽՍѥѥє((յ聍ɍ}յ(ɍ}յ聍ɍ}յ(ɥѕɥ聍ɥѕɥ(յхѥ聑յхѥ(ͅ}ɕ̈ͅ}ɕ̰(((ɍ}٥}}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(mȰt(Iɸѡ٥ȁɍɕ́ɕ٥ܸ(ɍ͕ɍ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ѥ͕̀ѥ}͹͡С}չ}չ̤(ɍ}ɽ͕̀}ɥѕɥ}}ɍlɥѕɥt(ɽЀAѠ}}}|ɕͽٔɕlt((}ѠȤ(ɕɸɽЀѠ}((ѕ̀l(͕}}٥}ѕ(ɽՍ}͍(AɽՍЁ͍(Ȉ(lI5̽ɽՍ}̽ɍ}ɕ̹t(ɕͥѽ}ѥЈ(ɕ䈁}ѠȁѠI5̽ɽՍ}̽ɍ}ɕ̹͔(Mѕɥ͔ɍɅѥɽ́յѕ(-ɽՍЁ͍չȁȁɕ٥ܸ((͕}}٥}ѕ(ѥ}ɕ}( ѥɕA$(Aљɴɕ٥ݕȈ(lĽнѥ̈̽ɕ}}ͥѕ̽ѕ}}Ʌйt(ɕͥѽ}ѥЈ(ɕ䈁}̽ɕ}}ͥ}ѕ̽ѕ}}Ʌй䈤͔(=$ѥЁA$ɅЁѕ́ɔɕ͕и(IѽɔA$ɅЁ́ѕ́ɔȁɕ٥ܸ((͕}}٥}ѕ(}٥}ɽ}(٥ɽ(AљɴɅѽȈ(lхє͍̽ɕ}ͥt(ɕͥѽ}ѥЈ(ɕ䈁}͍̽ɕ}͔ͥ(͍ɕͥչѥхєЁɔɕ͕и(Iѽɔ٥ͥɔȁɕ٥ܸ((͕}}٥}ѕ(ͅ}ɕ̈(Ḿɕ̈(AɽՍЁݹȈ(lĽͅ}ɕ̽ѕЈѕ̽ѕ}ͅ}ɕ̹t(ɕ}(ɕ䈁ɍlͅ}ɕ̉ulɕ}յult͔(ͅ}ɕ퍽ɍlͅ}ɕ̝ulɕ}х̝u(Iͽ̵ٔͅɕ́ɕ́ɔɍɕ٥ܸ((͕}}٥}ѕ(ɍ}ɕ̈( ɍɕ̈(Ȉ(lĽɍ}ɕ̽ѕЈѕ̽ѕ}ɍ}ɕ̹t(ɕ}(ɕ䈁ɍlɍ}յult͔(ɍ}х퍽ɍlɍ}х̝u(Iͽٔɍɕ́ɕ́ɔȁɕ٥ܸ((͕}}٥}ѕ(ѥ}䈰(ѥ́䈰(ѥ́ɕ٥ݕȈ(lĽѥ}͹̽͡ѕЈ̽ѥ}t(ɕ}(ɕ䈁ѥlɕ}х̉t􀉱}չѥ}͹͡Ј͔(ѥlͽɍ}єt(-ɕ٥͕ɅєɽɽՍѥ-A$ɽ̸ͅ((͕}}٥}ѕ(}}٥(̵Ё٥(Mɥ䁅ɕ٥ݕȈ(lĽ}ɕ̽ݽɭ}չ}􈰀̽ɽՍ}t(ɕͥѽ}ѥЈ(ɕ䈁}̽ɽՍ}͔(]ɭ܁Ʌ̵ɕЁ٥ɔյѕ(Iѽɔ̵Ё٥́ɔɕ٥ܸ((͕}}٥}ѕ(مՅѥ}ɕ䈰(مՅѥɕ䈰(EՅɕ٥ݕȈ(lĽمՅѥ}չ͍̈̽ɕ}ͥt(ɕͥѽ}ѥЈ(ɕ䈁}͍̽ɕ}͔ͥ(مՅѥɕə́յѕ(IѽɔمՅѥɕ䁑́ɔՅɕ٥ܸ((͕}}٥}ѕ(͕ɥ}ɔ(Mɥɔ(Mɥɕ٥ݕȈ(lM UI%Qdѕ̽ѕ}͕ɥ}ɑ䈰 E0ɕ٥܈Qɥt(ɕ}(ɕ䈁ɍ}ɽl͕ɥ}}}ɽulх̉ẗ͔(ɍ}ɽl͕ɥ}}}ɽul٥t(Iͽٔɕє͕ɥ䁙ɕ́ɔȁɕ٥ܸ((͕}}٥}ѕ(٥Յ}х}٥(YՅхȁ٥(Mхȁɕ٥ݕȈ(l̽}ѥ̹ͥ)ɐḾt(}ѥЈ(ɕ䈁}̽}ѥ̹͔(х)Ḿѥ́ɔɕɑ(Iɐхѥ́ɔхȁɕ٥ܸ((͕}}٥}ѕ(}}Ј( ȁЈ(AɽɕЁɕ٥ݕȈ(l̽ɍ}}}йt(ɕͥѽ}ѥЈ(ɕ䈁}̽ɍ}}}й͔( ȁՕѥ́Ѽ٥ѡ̸ٕ́(IѽɔѡȁЁɔɽɕЁɕ٥ܸ((͕}}٥}ѕ(}х}չ( ȁхչ(AɽɕЁɕ٥ݕȈ(l̽ɍ}}х}չt(ɕͥѽ}ѥЈ(ɕ䈁}̽ɍ}}х}չ͔(݅ɹձ́ɔյѕ(IѽɔхչɔɽɕЁɕ٥ܸ((͕}}٥}ѕ(}٥}Ј( ȁ٥Ј(ݹȈ(l̽ɍ}}٥}йĽɍ}٥}̽ѕЉt(ɕ}(ɕ䈁}̽ɍ}}٥}й͔( ȁ٥́ᕐ䁽ݹȰͽɍ٥ѥхє(IѽɔѡЁյЁЁɔȁɕ٥ܸ((͕}}٥}ѕ(}ͥ(Aͥ(AɽɕЁ͕ɥɕ٥ݕȈ(l̽Ʌ}ɕ͕ɍ̽ɍ}՝}Ʌѥ}t(ɕͥѽ}ѥЈ(ɕ䈁}̽Ʌ}ɕ͕ɍ}̽ɍ}՝}Ʌѥ}͔(Mɕ光ɽՍЁɕѡɕЁͥ(յЁɅѥɥ́ɔչɥ̸((͕}}٥}ѕ(ɽՍѥ}ͱ}Ј(AɽՍѥM1<Ёɽ( ѽȁɅѥ́ɕ٥ݕȈ(lɽՍѥѕ䈰Ёɥɕɑ̈Ёݹ͡t(ɽ͕}չѥ}ɽՍѥ(݅ɹ(AɽՍѥM1<аЁ٥ɕեɔ啐ѽȁ٥ɽи( ЁɽՍѥѕ䁑ɥɑ((͕}}٥}ѕ(}}ɽ}( ȵI=$ɽ(ȁɽɕЈ(lI=$Օѥɔфɽͥѕɵ̈Ёt(ɽ͕}չѥ}}(݅ɹ(I=$ɽɕа嵕Ё٥ɕեɔȸ( Ёȵ́ɥչЁ((t(յ͕}}}յ䡥ѕ̤(յl}ѥ}хєtР(}х̀􀉉}ɕ٥}(յl}ѥ}хєtР݅ɹ(}х̀􀉉}ɕ٥}ɕ}ݥѡ}݅ɹ̈(͔耀Ʌ聹ٕȀչɕݡѡ́ɕЁɥ́ѕɅȵ݅ɹ͕ѥ(}х̀􀉉}ɕ٥}ɕ䈀Ʌ聹ٕ((ɕɸ(}х̈聵}х̰(хɝ}Ʌ}مՕ}܈хɝ}Ʌ}مՕ}ܰ(хɝ}Ʌ}مՕ}聘-I\хɝ}Ʌ}مՕ}(ɕ}х̈耉}}٥}Ј(ͽɍ}є耠( ȁ٥Ё́ɽ̵չѥɕ̰ɕͥѽ䁑յ̰(ѥЁɕɑ̰ЁɽՍѥȁȵٕ쁥Ё́Ё(مՅѥՅɅѕɍ͔ѵаȁɽՍѥѥє((յյ(ѕ̈聥ѕ̰(ɕѕ}չѥ}ɕ̈(ɍ}х̈聍ɍlɍ}х̉t(ͅ}ɕ}х̈聍ɍlͅ}ɕ̉ulɕ}х̉t(ѥ}ɕ}х̈聅ѥlɕ}х̉t((((ɍ}}չ}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(mȰt(Iɸѡɍչȁͅɕ́٥(Ѐ͕ɍ}٥}}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((}յ􁵅lյul}ѥ}хєt(ɽЀAѠ}}}|ɕͽٔɕlt((}ѠȤ(ɕɸɽЀѠ}((չѥ}хє􀉉}յ九Р͔ɕ(Ց}ѥ̀l(͕}}٥}ѕ(չѥ}ɕ̈(Iչѥɕ̈(ݹȈ(l(Ľͅ}ɕ̽ѕЈ(Ľɍ}ɕ̽ѕЈ(Ľɍ}٥}̽ѕЈ(Ľѥ}͹̽͡ѕЈ(t(ɕ}(չѥ}хє((}}хl}х̝u쀈(ɍ}хlɕѕ}չѥ}ɕ̝ulɍ}х̝u((IͽٔչѥɕЁ́ɔȁ((͕}}٥}ѕ(ɕͥѽ}Ј(IͥѽЈ(AɽɕЁɕ٥ݕȈ(l(I5(̽ɍ}}}й(̽ɍ}}х}չ(̽ɍ}}٥}й(̽ɍ}}}չ(t(ɕͥѽ}ѥЈ(ɕ((}Ѡ(ȁѠ(I5(̽ɍ}}}й(̽ɍ}}х}չ(̽ɍ}}٥}й(̽ɍ}}}չ(((͔( ȵхаյ́ɔɕ͕и(IѽɔͥȁЁյ́ɔɽɕЁɕ٥ܸ((͕}}٥}ѕ(}х}ѥ̈(хȁѥ̈(Mхȁɕ٥ݕȈ(l̽}ѥ̹ͥ)ɐḾt(}ѥЈ(ɕ䈁}̽}ѥ̹͔(х)Ḿѥ́ɔɕɑݥѡЁ и(Iɐххȁѥ́ɔȁ((͕}}٥}ѕ(ٕɥѥ}̈(Yɥѥ̈(Qɕ٥ݕȈ(l(ѕ̽ѕ}}}չ䈰(ѕ̽ѕ}}٥}й䈰(ѕ̽ѕ}՝}ɥٕ}ѥ̹䈰(ѕ̽ѕ}}Ʌй䈰(ѕЀĈ(t(ɕ}(ɕ((}Ѡ(ȁѠ(ѕ̽ѕ}}}չ䈰(ѕ̽ѕ}}٥}й䈰(ѕ̽ѕ}՝}ɥٕ}ѥ̹䈰(ѕ̽ѕ}}Ʌй䈰(((͔(͕ɅЁѕ́ձѕЁٕɥѥɔȁȁɕ٥ܸ(Iѽɔ͕ѕ́ɔѕȁ((͕}}٥}ѕ(}ͥ(Aͥ(AɽɕЁ͕ɥɕ٥ݕȈ(l̽Ʌ}ɕ͕ɍ̽ɍ}՝}Ʌѥ}t(ɕͥѽ}ѥЈ(ɕ䈁}̽Ʌ}ɕ͕ɍ}̽ɍ}՝}Ʌѥ}͔(Mɕͥѽ䁅光ɽՍЁɕѡɕЁͥ(=䁕ɅЁɅ䁅ѕȁ͕ɽՍаЁɕ͔ȁɽٕɥȁ̸((t(}}ѕ̀l(͕}}٥}ѕ(ɽՍѥ}}ɕ̈(AɽՍѥɕ̈( ѽȁɅѥ́ɕ٥ݕȈ(lɽՍѥM1<ЁɥЁɽф嵕Ёѽt(ɽ͕}չѥ}ɽՍѥ(݅ɹ(AɽՍѥM1<а嵕аЁ٥ɕեɔٔѽȁ٥ɽи( ЁɽՍѥѕ䁅Ё٥ɥɑ((͕}}٥}ѕ(}}ɍ}͔( ȵɍ͔(ȁɕ٥ݕȈ(lI=$Օѥɔфɽͥѕɵ̈Ёt(ɽ͕}չѥ}}(݅ɹ(I=$ɽɕа嵕Ёѵ́ɕեɔȸ( Ёȵ́ɥչЁ((t(}ѕ̀􁥹Ց}ѥ̀}}ѕ(յ͕}}}յ䡅}ѕ̤(յl}ѥ}хєtР(չ}х̀􀉉}}(յl}ѥ}хєtР݅ɹ(չ}х̀􀉉}}ɕ}ݥѡ}݅ɹ̈(͔耀Ʌ聹ٕȀչɕݡѡ́ɕЁɥ́ѕɅȵ݅ɹ͕ѥ(չ}х̀􀉉}}ɕ䈀Ʌ聹ٕ((ɕɸ(չ}х̈聉չ}х̰(хɝ}Ʌ}مՕ}܈хɝ}Ʌ}مՕ}ܰ(хɝ}Ʌ}مՕ}聘-I\хɝ}Ʌ}مՕ}(ɕ}х̈耉}}}չ(ͽɍ}є耠( ȁչ́չѥɕ̰ɕͥѽ䁑յ̰(ѥЁɕɑ̰ٕɥѥ̰ЁɽՍѥȀ(ȵٕ쁥Ё́ЁمՅѥՅɅѕɍ͔ѵа(ȁɽՍѥѥє((յյ(Ց}ѥ̈聥Ց}ѥ̰(}}ѕ̈聙}}ѕ̰(х}ѕ̈l((ѕ}耉(ձ耉Ցѥ́ɕє͕ɥ䁍́ٔɔ(((ѕ}耉݅ɹ(ձ耉ɽՍѥȁȵ٥ɕ́ɽ͕ѱ䁍ٕѕ(((ѕ}耉(ձ耉͕ɥ䁙ɔA$ɅЁɕɕͥյЁ͵эɽՍЁаȁ Ёͅ((t(ɕѕ}չѥ}ɕ̈(}}х̈聵l}х̉t(lɕѕ}չѥ}ɕ̉t((Ʌ}}ͥ(ͥ耉}ͥ}ɽՍЈ(ɕͽ耉9͕ɽՍаЁɕ͔ȁ͕ɥɽٕɥȁ̸(ݕ}ɕ}ɥ̈l(͕ɽՍЁɕեɕ́ɔ䈰(Ёɕ͔́(ȁ͕ɥɽٕɕեɕ́Ʌѥ(t((՝}Ʌ(耉ххȁѥ́)ݽɭ܈(ɽՍ}ͥ耉ȁə٥ݽɭ܈(ݕ̈耉хѥٕɥѥЈ(х耉ͥɽՍЁ܁䈰(х}ѥ̈耉ɕٕ́ɽ͕٥͕Ʌѥ((((}٥}}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(mȰt(IɸѡɕѕЁ́ȁѥAѡյ̸(ɕɸ͕ɍ}٥}}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ(((}}չ}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(mȰt(Iɸѡɕѕ́ȁѥAѡյ̸(ɕɸ͕ɍ}}չ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ(((ͅ}ͥ}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(mȰt(Iɸѡȵͅ䁑ͥȁمՔɕ٥ܸ(͕ɍ}}չ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ(( ́Ё͡Ʌѽȵɕѥ聑ݹɕ(ɕ́ɕ́єɥѕȁ́٥(йɽ́ݡɅ́͡չ͡٥ѕ̸(ɕѕ}̀l(ѕlѕ}t(ȁѕlՑ}ѥ̉t(ѕlѥ}хєt􀉉(t(݅ɹ}ѥ̀l(ѕ(ȁѕl}}ѕ̉t(ѕlѥ}хєt݅ɹ(t(ɕѕ}(ͅ}х̀ͅ}(ͥ} 䁍ɕєЈ(݅ɹ}ѥ(ͅ}х̀ͅ}ɕ}ݥѡ}݅ɹ̈(ͥ}I䁙ȁȁݥѠЁ݅ɹ̈(͔耀Ʌ聹ٕȀչɕݡܵ݅ɹ́ɔѕɅɕЁ͕ѥ(ͅ}х̀ͅ}ɕ䈀Ʌ聹ٕ(ͥ}I䁙ȁȁɅ聹ٕ((ɕɸ(ͅ}х̈ͅ}х̰(ͥ}聑ͥ}(хɝ}Ʌ}مՕ}܈хɝ}Ʌ}مՕ}ܰ(хɝ}Ʌ}مՕ}聘-I\хɝ}Ʌ}مՕ}(ɕ}х̈耉}ͅ}ͥ(ͽɍ}є耠(M䁑ͥ́ȁՔє͕չѥ(ɕ̰ɕͥѽ䁑յ̰ѥ̰ٕɥѥ̰(Ёٕ쁥Ё́ЁمՅѥՅɅѕɍ͔ѵа(ȁɽՍѥѥє((ͥ}յ(Ց}ѥ}չЈ聱lՑ}ѥ̉t(}չЈ聱ɕѕ}̤(݅ɹ}չЈ聱݅ɹ}ѥ̤(ɕ٥}ɽ}}Ȉ͔((ͥ}ͥ̈l((ͥ}耉}}չ(х̈聡lչ}х̉t(ͽɍ耈Ľɍ}}չ̽ѕЈ(((ͥ}耉}٥}Ј(х̈聡lɕѕ}չѥ}ɕ̉ul}}х̉t(ͽɍ耈Ľɍ}٥}̽ѕЈ(((ͥ}耉ɍ}ɕ̈(х̈聡lɕѕ}չѥ}ɕ̉ulɍ}х̉t(ͽɍ耈Ľɍ}ɕ̽ѕЈ(((ͥ}耉ͅ}ɕ̈(х̈聡lɕѕ}չѥ}ɕ̉ulͅ}ɕ}х̉t(ͽɍ耈Ľͅ}ɕ̽ѕЈ((t(ɕѕ}̈聍ɕѕ}̰(݅ɹ}ѥ̈݅ɹ}ѥ̰(ɕ٥}ɽ}(}Ȉ͔(}}ᅵ̈l(ɕ٥ݕȁ䈰(ɕ٥܁Ё䈰(ՕՕɕ٥܈(ݥѡЁɕєɔ(t(}ѥ耉ɕє͕ɥ䰁A$ɅаյаȁɽՍЁЈ((ɕѕ}չѥ}ɕ̈(}}х̈聡lչ}х̉t(lɕѕ}չѥ}ɕ̉t((Ʌ}}ͥ聡lɅ}}ͥt(՝}Ʌ聡l՝}Ʌt(((ɍ}٥}}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(mȰt(IɸхȁՔЁȁɍɕ٥ܸ(͕ͅͅ}ͥ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ɽЀAѠ}}}|ɕͽٔɕlt((}ѠȤ(ɕɸɽЀѠ}((ɕѕ}̀ͅlɕѕ}̉t(ɕեɕ}ѕɹ}٥l((٥}聥ѕlѕ}t(聥ѕlt(ɕ٥ݕȈ聥ѕlɕ٥ݕȉt(ͽɍ̈聥ѕlͽɍ̉t(٥}聥ѕl٥}t(٥聥ѕl٥t(}ѥ聥ѕl}ѥt((ȁѕͅl݅ɹ}ѥ̉t(t(ͅ}хє􀉉ͅlͅ}х̉tͅ}͔ɕ(}͕ѥ̀l(͕}}٥}ѕ(ͅ}ͥ(M䁑ͥ(ݹȈ(lĽͅ}ͥ̽ѕЈ̽ɍ}ͅ}ͥt(ɕ}(ͅ}хє(ͅ}хͅlͅ}х̝u(Iͽٔɕєͅ䁉́ɔѥȁ٥((͕}}٥}ѕ(չѥ}ɕ̈(Iչѥɕ̈(Qɕ٥ݕȈ(l(Ľͅ}ɕ̽ѕЈ(Ľɍ}ɕ̽ѕЈ(Ľɍ}٥}̽ѕЈ(Ľɍ}}չ̽ѕЈ(Ľͅ}ͥ̽ѕЈ(Ľѥ}͹̽͡ѕЈ(t(ɕ}(ɕѕ}͔́ɕ䈰((}}хͅlɕѕ}չѥ}ɕ̝ul}}х̝u쀈(}}хͅlɕѕ}չѥ}ɕ̝ul}}х̝u((Iͽٔչѥɕ́ɔȁи((͕}}٥}ѕ(}}յ̈( ȁЁյ̈(AɽɕЁɕ٥ݕȈ(l(̽ɍ}}}й(̽ɍ}}х}չ(̽ɍ}}٥}й(̽ɍ}}}չ(̽ɍ}ͅ}ͥ(̽ɍ}٥}й(t(ɕͥѽ}ѥЈ(ɕ((}Ѡ(ȁѠ(̽ɍ}}}й(̽ɍ}}х}չ(̽ɍ}}٥}й(̽ɍ}}}չ(̽ɍ}ͅ}ͥ(̽ɍ}٥}й(((͔( ȁхаͥЁյ́ɔɕ͕и(IѽɔͥȁЁյ́ɔи((͕}}٥}ѕ(}х}ѥ̈(хȁѥ̈(Mхȁɕ٥ݕȈ(l̽}ѥ̹ͥ)ɐḾt(}ѥЈ(ɕ䈁}̽}ѥ̹͔(ххȁѥ́ɔɕɑ Ё́፱Ց(Iɐѥ́ɔѥȁ٥((͕}}٥}ѕ(ٕɥѥ}̈(Yɥѥ̈(Qɕ٥ݕȈ(l(ѕ̽ѕ}ɍ}٥}й䈰(ѕ̽ѕ}ͅ}ͥ䈰(ѕ̽ѕ}՝}ɥٕ}ѥ̹䈰(ѕ̽ѕ}}Ʌй䈰(ѕЀĈ(t(ɕ}(ɕ((}Ѡ(ȁѠ(ѕ̽ѕ}ɍ}٥}й䈰(ѕ̽ѕ}ͅ}ͥ䈰(ѕ̽ѕ}՝}ɥٕ}ѥ̹䈰(ѕ̽ѕ}}Ʌй䈰(((͔(͕ɍаͅ䰁՝ѥаA$ɅЁѕ́ɔ(Iѽɔ͕ѕ́ɔȁи((͕}}٥}ѕ(ɕ٥}ɽ}䈰(I٥܁ɽ́䈰(ݹȈ(l̽ɍ}ͅ}ͥĽͅ}ͥ̽ѕЉt(ɕͥѽ}ѥЈ(ɕ䈰(I٥ݕȁ䰁ɕ٥܁Ё䰁ՕՕɕ٥܁ɔЁɕє̸(͍є䁍ɕє͕ɥ䰁A$ɅаյаȁɽՍЁ̸((͕}}٥}ѕ(}ͥ(Aͥ(AɽɕЁ͕ɥɕ٥ݕȈ(l̽Ʌ}ɕ͕ɍ̽ɍ}՝}Ʌѥ}t(ɕͥѽ}ѥЈ(ɕ䈁}̽Ʌ}ɕ͕ɍ}̽ɍ}՝}Ʌѥ}͔(ͅlɅ}}ͥulɕͽt(=䁕ɅЁɅ䁅ѕȁ͕ɽՍаЁɕ͔ȁɽٕɥȁ̸((t(}͕ѥ}յ͕}}}յ䡕}͕ѥ̤(}չЀ}͕ѥ}յl}ѥ}хєultɕѕ}̤(݅ɹ}չЀ􁱕ɕեɕ}ѕɹ}٥(}չ(}х̀􀉍ɍ}}(݅ɹ}չ(}х̀􀉍ɍ}}ɕ}ݥѡ}݅ɹ̈(͔耀Ʌ聹ٕȀչɕݡѡ́ɕЁɥ́ѕɅȵ݅ɹ͕ѥ(}х̀􀉍ɍ}}ɕ䈀Ʌ聹ٕ((ɕɸ(}х̈聕}х̰(хɝ}Ʌ}مՕ}܈хɝ}Ʌ}مՕ}ܰ(хɝ}Ʌ}مՕ}聘-I\хɝ}Ʌ}مՕ}(ɕ}х̈耉}ɍ}٥}Ј(ͽɍ}є耠( ɍ٥Ё́չѥ̰ͥɕͥѽ䁑յ̰(ѥЁɕɑ̰ٕɥѥ̰ɕ٥ܵɽ́䰁ͥ(ЁɽՍѥȁȵ٥쁥Ё́ЁمՅѥՅɅѕ(ɍ͔ѵаȁɽՍѥѥє((}յ(͕ѥ}չЈ聱}͕ѥ̤(}չЈ聉}չа(݅ɹ}չЈ݅ɹ}չа(ɕ٥}ɽ}}Ȉͅlɕ٥}ɽ}ul}ȉt((}͕ѥ̈聕}͕ѥ̰(ɕեɕ}ѕɹ}٥ɕեɕ}ѕɹ}٥(ɕѕ}̈聍ɕѕ}̰(ɕ٥}ɽ}ͅlɕ٥}ɽ}t(ɕѕ}չѥ}ɕ̈(ͅ}х̈ͅlͅ}х̉t(ͅlɕѕ}չѥ}ɕ̉t((Ʌ}}ͥͅlɅ}}ͥt(՝}Ʌͅl՝}Ʌt(}̈(}ͥ}耉輽ܹͥi5]!Ii9](}ɐ耉輽ܹɐ]5M!!MA4(չѥ}Ј耈Ľɍ}٥}̽ѕЈ(յхѥ耉̽ɍ}٥}й((((ɍ}х}}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(mȰt(Iɸѡȁхٕȁѡɍ٥и(٥}Ѐ͕ɍ}٥}}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ɽЀAѠ}}}|ɕͽٔɕlt((}ѠȤ(ɕɸɽЀѠ}((ɕѕ}̀٥}lɕѕ}̉t(}٥}l}х̉t􀉍ɍ}}(չѥ}хє􀉉}ȁɕѕ}͔́ɕ(х}ѕ̀l(͕}}٥}ѕ(չѥ}}(IչѥЁ(Qɕ٥ݕȈ(l(Ľѥ}͹̽͡ѕЈ(Ľͅ}ɕ̽ѕЈ(Ľɍ}ɕ̽ѕЈ(Ľɍ}٥}̽ѕЈ(Ľɍ}}չ̽ѕЈ(Ľͅ}ͥ̽ѕЈ(Ľɍ}٥}̽ѕЈ(t(ɕ}(չѥ}хє(ɍ}}х٥}l}х̝u(IͽٔչѥɕЁɔȁх((͕}}٥}ѕ(}}յ̈( ȁЁյ̈(AɽɕЁɕ٥ݕȈ(l(̽ɍ}}}й(̽ɍ}}х}չ(̽ɍ}}٥}й(̽ɍ}}}չ(̽ɍ}ͅ}ͥ(̽ɍ}٥}й(̽ɍ}х}(t(ɕͥѽ}ѥЈ(ɕ((}Ѡ(ȁѠ(̽ɍ}}}й(̽ɍ}}х}չ(̽ɍ}}٥}й(̽ɍ}}}չ(̽ɍ}ͅ}ͥ(̽ɍ}٥}й(̽ɍ}х}(((͔( ȁЁյٕ́ȁхаͥа(IѽɔͥȁЁյ́ɔȁх((͕}}٥}ѕ(}Ʌѽ}ə(Ʌѽȁə(AљɴɅѽȈ(lѕՅ}ɍɅѽȽ䈰Ľɍ}х}̽ѕЉt(ɕͥѽ}ѥЈ(ɕ䈁}ѕՅ}ɍɅѽȽ䈤͔(͕مə͕́ѡɍхх́ݥѠՅ̸(͔хх͕́م䁉ɔȁх((͕}}٥}ѕ(ٕɥѥ}٥(Yɥѥ٥(Qɕ٥ݕȈ(l(ѕ̽ѕ}ɍ}х}䈰(ѕ̽ѕ}ɍ}٥}й䈰(ѕ̽ѕ}ͅ}ͥ䈰(ѕ̽ѕ}՝}ɥٕ}ѥ̹䈰(ѕ̽ѕ}}Ʌй䈰(ѕЀĈ(t(ɕ}(ɕ((}Ѡ(ȁѠ(ѕ̽ѕ}ɍ}х}䈰(ѕ̽ѕ}ɍ}٥}й䈰(ѕ̽ѕ}ͅ}ͥ䈰(ѕ̽ѕ}՝}ɥٕ}ѥ̹䈰(ѕ̽ѕ}}Ʌй䈰(((͔(͕ɍхаͅ䰁՝ѥаA$ɅЁѕ́ɔ(Iѽɔ͕ѕ́ɔȁх((͕}}٥}ѕ(}х}ѥ̈(хȁѥ̈(Mхȁɕ٥ݕȈ(l̽}ѥ̹ͥ)ɐḾt(}ѥЈ(ɕ䈁}̽}ѥ̹͔(ххȁѥ́ɔɕɑ Ё́፱Ց(Iɐхѥ́ɔȁх((͕}}٥}ѕ(ɕ٥}ɽ}䈰(I٥܁ɽ́䈰(ݹȈ(l̽ɍ}ͅ}ͥĽͅ}ͥ̽ѕЉt(ɕͥѽ}ѥЈ(ɕ䈰(I٥ݕȁ䰁ɕ٥܁Ё䰁ՕՕɕ٥ܰ́ݥѡЁɕєɔɔЁ̸( 䁽ɕє͕ɥ䰁A$ɅаյаȁɽՍЁ̸((͕}}٥}ѕ(}ͥ(Aͥ(AɽɕЁ͕ɥɕ٥ݕȈ(l̽Ʌ}ɕ͕ɍ̽ɍ}՝}Ʌѥ}t(ɕͥѽ}ѥЈ(ɕ䈁}̽Ʌ}ɕ͕ɍ}̽ɍ}՝}Ʌѥ}͔(٥}lɅ}}ͥulɕͽt(=䁕ɅЁɅ䁅ѕȁ͕ɽՍаЁɕ͔ȁɽٕɥȁ̸((t(}}ѕ̀l(͕}}٥}ѕ(ѕl٥}t(ѕlt(ѕlɕ٥ݕȉt(ѕlͽɍ̉t(ѕl٥}t(݅ɹ(ѕl٥t(ѕl}ѥt((ȁѕ٥}lɕեɕ}ѕɹ}٥t(t(}ѕ̀􁅍х}ѕ̀}}ѕ(յ͕}}}յ䡅}ѕ̤(}չЀյl}ѥ}хєultɕѕ}̤(݅ɹ}չЀյl}ѥ}хєul݅ɹt(}չ(х}х̀􀉍ɍ}х}(݅ɹ}չ(х}х̀􀉍ɍ}х}ɕ}ݥѡ}݅ɹ̈(͔耀Ʌ聹ٕȀչɕݡѡ́ɕЁɥ́ѕɅȵ݅ɹ͕ѥ(х}х̀􀉍ɍ}х}ɕ䈀Ʌ聹ٕ((ɕɸ(х}х̈聅х}х̰(хɝ}Ʌ}مՕ}܈хɝ}Ʌ}مՕ}ܰ(хɝ}Ʌ}مՕ}聘-I\хɝ}Ʌ}مՕ}(ɕ}х̈耉}ɍ}х}(ͽɍ}є耠( ɍхمՅѕ́ɍ٥а٥ͥ䰀(ɕͥѽаѥ̰ٕɥѥ̰ɕ٥ܵɽ́䰁(ͥЁɽՍѥȁȵ쁥Ё́ЁمՅѥՅɅѕ(ɍ͔ѵаȁɽՍѥѥє((х}յ(ѕ}չЈ聱}ѕ̤(}չЈ聉}չа(݅ɹ}չЈ݅ɹ}չа(ɕ٥}ɽ}}Ȉ聕٥}lɕ٥}ɽ}ul}ȉt((х}ѕ̈聅х}ѕ̰(}}ѕ̈聙}}ѕ̰(ɕѕ}̈聍ɕѕ}̰(ɕեɕ}ѕɹ}٥聕٥}lɕեɕ}ѕɹ}٥t(х}ѕ̈l((ѕ}耉(ձ耉хѕ́ɕեɕѕɹ٥̈(((ѕ}耉݅ɹ(ձ耉ɽՍѥȁȵ٥ɕ́ѱ䁍ٕѕ(((ѕ}耉(ձ耉͕ɥ䁙ɔA$ɅЁɕɕͥյЁ͵эɽՍЁаȁ Ёͅ((t(ɕ٥}ɽ}聕٥}lɕ٥}ɽ}t(ɕѕ}չѥ}ɕ̈(ɍ}}х̈聕٥}l}х̉t(٥}lɕѕ}չѥ}ɕ̉t((Ʌ}}ͥ聕٥}lɅ}}ͥt(՝}Ʌ聕٥}l՝}Ʌt(х}̈(}ͥ}耉輽ܹͥi5]!Ii9](}ɐ耉輽ܹɐ]5M!!MA4(չѥ}Ј耈Ľɍ}х}̽ѕЈ(յхѥ耉̽ɍ}х}((((ɍ}ɕ͕}ѕ}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(ɕ͕}ѡɥ5mȰt99(mȰt(IɸɽՍЁ٥͕Ʌѕ䁙ɽɽѕѕɕ͔ѡɥ丈(х͕ɍ}х}}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ɽЀAѠ}}}|ɕͽٔɕlt((}ѠȤ(ɕɸɽЀѠ}((ɕѕ}̀􁅍хlɕѕ}̉t(х}􁅍хlх}х̉t􀉍ɍ}х}(չѥ}хє􀉉х}ȁɕѕ}͔́ɕ(ɕ͕}ѡɥѥمՅѕ}ɕ͕}ѡɥѥɕ͕}ѡɥ(ɕ͕}ѥ̀l(͕}}٥}ѕ(ɍ}х}( ɍх(ݹȈ(lĽɍ}х}̽ѕЈ̽ɍ}х}t(ɕ}(չѥ}хє(х}х텍хlх}х̝u(Iͽٔх́ɔхɕ͔є((͕}}٥}ѕ(չѥ}}(IչѥЁ(Qɕ٥ݕȈ(l(Ľѥ}͹̽͡ѕЈ(Ľͅ}ɕ̽ѕЈ(Ľɍ}ɕ̽ѕЈ(Ľɍ}٥}̽ѕЈ(Ľɍ}}չ̽ѕЈ(Ľͅ}ͥ̽ѕЈ(Ľɍ}٥}̽ѕЈ(Ľɍ}х}̽ѕЈ(Ľɍ}ɕ͕}ѕ̽ѕЈ(t(ɕ}(չѥ}хє( ɍɕ͔єЁ́ѕȁхаͥаɕ̰ѥ́ɕ̸(IѽɔչѥЁ٥ɔɕ͔є((͕}}٥}ѕ(ɕͥѽ}ɥѥ}Ј(Iͥѽ䁑ɥѥЈ(AɽɕЁɕ٥ݕȈ(l(I5(̽ɕ}}ͥ(̽ɍ}}}й(̽ɍ}}х}չ(̽ɍ}}٥}й(̽ɍ}}}չ(̽ɍ}ͅ}ͥ(̽ɍ}٥}й(̽ɍ}х}(̽ɍ}ɕ͕}є(t(ɕͥѽ}ѥЈ(ɕ((}Ѡ(ȁѠ(I5(̽ɕ}}ͥ(̽ɍ}}}й(̽ɍ}}х}չ(̽ɍ}}٥}й(̽ɍ}}}չ(̽ɍ}ͅ}ͥ(̽ɍ}٥}й(̽ɍ}х}(̽ɍ}ɕ͕}є(((͔(IͥѽЁх́ѡI5IMPA$ɅЁѕ̰ɍȁյ̸(Iѽɔͥɥѥյ́ɔȁɕ͔єɕ٥ܸ((͕}}٥}ѕ(͕ɥ}}хф(Mɥ䁅хф(Mɥɕ٥ݕȈ(l(1% 9M(M UI%Qd(ɽйѽ(ɕեɕ̹(ѡՈݽɭ͕̽ɥ嵰(ѡՈй嵰( ѕՅ]͑1ѡՈɅɕեɕ͕ɥݽɭ̈(t(ɕͥѽ}ѥЈ(ɕ((}Ѡ(ȁѠ(1% 9M(M UI%Qd(ɽйѽ(ɕեɕ̹(ѡՈݽɭ͕̽ɥ嵰(ѡՈй嵰(((͔(1͔͕ɥ䰁хфɕեɕ̰䵍ݽɭܰЁхфɅɕեɕ͕ɥݽɭ́ɔɕ͕и(Iѽɔ͕ͥɥ䁽ȁхфɔɕ͔є((͕}}٥}ѕ(}Ʌѽ}ə(Ʌѽȁə(AљɴɅѽȈ(lѕՅ}ɍɅѽȽ䈰Ľɍ}ɕ͕}ѕ̽ѕЉt(ɕͥѽ}ѥЈ(ɕ䈁}ѕՅ}ɍɅѽȽ䈤͔(͕مə͕́ѡɕ͔єх́ݥѠՅ̸(͔ɕ͔єх͕́م䁉ɔȁ((͕}}٥}ѕ(ٕɥѥ}٥(Yɥѥ٥(Qɕ٥ݕȈ(l(ѕ̽ѕ}ɍ}ɕ͕}є䈰(ѕ̽ѕ}ɍ}х}䈰(ѕ̽ѕ}ɍ}٥}й䈰(ѕ̽ѕ}ͅ}ͥ䈰(ѕ̽ѕ}՝}ɥٕ}ѥ̹䈰(ѕ̽ѕ}}Ʌй䈰(ѕЀĈ(t(ɕ}(ɕ((}Ѡ(ȁѠ(ѕ̽ѕ}ɍ}ɕ͕}є䈰(ѕ̽ѕ}ɍ}х}䈰(ѕ̽ѕ}ɍ}٥}й䈰(ѕ̽ѕ}ͅ}ͥ䈰(ѕ̽ѕ}՝}ɥٕ}ѥ̹䈰(ѕ̽ѕ}}Ʌй䈰(((͔(͕ɕ͔єхаͅ䰁՝ѥаA$ɅЁѕ́ɔ(Iѽɔ͕ٕɥѥɔɕ͔є((͕}}٥}ѕ(}х}ѥ̈(хȁѥ̈(Mхȁɕ٥ݕȈ(l̽}ѥ̹ͥ)ɐḾt(}ѥЈ(ɕ䈁}̽}ѥ̹͔(ххȁѥ́ɔɕɑ Ё́፱Ց(Iɐхѥ́ɔȁɕ͔єɕ٥ܸ((͕}}٥}ѕ(ɕ٥}ɽ}䈰(I٥܁ɽ́䈰(ݹȈ(l̽ɍ}ͅ}ͥ̽ɍ}ɕ͕}єt(ɕͥѽ}ѥЈ(ɕ䈰(AɽՍЁ٥ɕ́хݡɽѕѕɕ͔ѡɥ䁥́مՅѕ͕Ʌѕ丈(M䁄ɕ͠ɽѕѕѡɥ͹͡Ёɔѡɥ饹ɕ͔((͕}}٥}ѕ(ɕ͕}ѡɥ}ѽȈ(Aɽѕѕѡɥ䁍ѽȈ(I͔ݹȈ(l͍ɥ̽ɕ͕}ѡɥ}͹͡й䈰̽ѽɥɕ͔ѡɥѥt(ɕͥѽ}ѥЈ(ɕ䈁}͍ɥ̽ɕ͕}ѡɥ}͹͡й䈤͔(I䁝A$ѽȁ́́ɕ٥́ѼѡᅍЁձɕՕЁݥѡЁѥ͕ɕ̸(IոѡѽȁݥѠѡᅍЁєM!х́)M=8͹͡ЁѼɕ͔ɕ٥ܸ((͕}}٥}ѕ(}ͥ(Aͥ(AɽɕЁ͕ɥɕ٥ݕȈ(l̽Ʌ}ɕ͕ɍ̽ɍ}՝}Ʌѥ}t(ɕͥѽ}ѥЈ(ɕ䈁}̽Ʌ}ɕ͕ɍ}̽ɍ}՝}Ʌѥ}͔(хlɅ}}ͥulɕͽt(=䁕ɅЁɅ䁅ѕȁ͕ɽՍаЁɕ͔ȁɽٕɥȁ̸((t(ѕɹ}ɕ͕}̀l(͕}}٥}ѕ(ѕlѕ}t(ѕlt(ѕlɕ٥ݕȉt(ѕlͽɍ̉t(ѕl٥}t(݅ɹ(ѕl٥t(ѕl}ѥt((ȁѕхl}}ѕ̉t(t(յ͕}}}յɕ͕}ѥ̀ѕɹ}ɕ͕}̤(ɽՍ}}չЀյl}ѥ}хєultɕѕ}̤(݅ɹ}չЀյl}ѥ}хєul݅ɹt(ɽՍ}٥}х̀(ɍ}ɕ͕}(ɽՍ}}չ(͔ɍ}ɕ͕}ɕ}ݥѡ}݅ɹ̈(хl}}ѕ̉t(͔ɍ}ɕ͕}ɕ((ɕ͕}}չЀɽՍ}}չЀɕ͕}ѡɥѥl̉t(ɕ͕}}չ(ɕ͕}х̀􀉍ɍ}ɕ͕}(݅ɹ}չ(ɕ͕}х̀􀉍ɍ}ɕ͕}ɕ}ݥѡ}݅ɹ̈(͔耀Ʌ聹ٕȀչɕݡѡ́ɕЁɥ́ѕɅȵ݅ɹ͕ѥ(ɕ͕}х̀􀉍ɍ}ɕ͕}ɕ䈀Ʌ聹ٕ((ɕɸ(ɕ͕}х̈ɕ͕}х̰(ɽՍ}٥}х̈ɽՍ}٥}х̰(ɕ͕}ѡɥѥɕ͕}ѡɥѥ(хɝ}Ʌ}مՕ}܈хɝ}Ʌ}مՕ}ܰ(хɝ}Ʌ}مՕ}聘-I\хɝ}Ʌ}مՕ}(ɕ}х̈耉}ɍ}ɕ͕}є(ͽɍ}є耠( ɍɕ͔є́хչѥ̰ɕͥѽ䀈(ɥѥյ̰͕ɥ䁵хф٥ͥ䰁ٕɥѥ̰(ѥЁɕɑ̰ɕ٥ܵɽ́䰁ͥЁѕɹ(ɕ͔쁥Ё́ЁمՅѥՅɅѕɍ͔ѵаȁɽՍѥ(ѥє((ɕ͕}յ(ѥ}չЈ聱ɕ͕}ѥ̤(}չЈɕ͕}}չа(ɽՍ}}չЈɽՍ}}չа(݅ɹ}չЈ݅ɹ}չа(ɕ͕}ѡɥ}}չЈ聱ɕ͕}ѡɥѥl̉t((ɕ͕}ѥ̈ɕ͕}ѥ̰(ѕɹ}ɕ͕}̈聕ѕɹ}ɕ͕}̰(ɕѕ}̈聍ɕѕ}̰(ɕ͕}ѕ̈l((ѕ}耉(ձ耉չѥЁɕͥѽа͕ɥ䁵хфəѕ̰ѥ̰ɕ٥܁䰁ͥɔɕ͕Ј(((ѕ}耉݅ɹ(ձ耉ɽՍѥȁȵѕɹ٥ɕ́ѱ䁍ٕѕ(((ѕ}耉(ձ耉͕ɥ䁙ɔA$ɅЁɕɕͥͥɥѥѥаյЁ͵эɽՍЁаȁ Ёͅ((t(ɕ٥}ɽ}聅хlɕ٥}ɽ}t(ɕѕ}չѥ}ɕ̈(ɍ}х}х̈聅хlх}х̉t(хlɕѕ}չѥ}ɕ̉t((Ʌ}}ͥ聅хlɅ}}ͥt(՝}Ʌ聅хl՝}Ʌt(ɕ͕}̈(}ͥ}耉輽ܹͥi5]!Ii9](}ɐ耉輽ܹɐ]5M!!MA4(չѥ}Ј耈Ľɍ}ɕ͕}ѕ̽ѕЈ(յхѥ耉̽ɍ}ɕ͕}є((((ɍ}}ɕѕ}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(ɕ͕}ѡɥ5mȰt99(mȰt(IɸݹȽѥɕѕȁȁɍɕ͔є̸(ɕ͔͕ɍ}ɕ͕}ѕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ(ɕ͕}ѡɥɕ͕}ѡɥ((ɕѕ}̀ɕ͕lɕѕ}̉t(ɕ͕}ɕ͕lɕ͕}х̉t􀉍ɍ}ɕ͕}(}ѕ̀mt(ȁѕɕ͕lѕɹ}ɕ͕}̉t(ͽɍ}ѕl٥}t(ͽɍ}ɽ͕}չѥ}ɽՍѥ(}х̀ɽՍѥ}}ɕեɕ(}ɽՍѥ}٥}(ݹȀ=Ʌѥ́ЁݹȈ(͔(}х̀􀉉}}ɕեɕ(}􀉉}}(ݹȀ ȁݹȈ(}ѕ̹(}聥ѕlѕ}t(聥ѕlt(}聝}(}х̈聝}х̰(ݹȈ聽ݹȰ(ɕ٥ݕȈ聥ѕlɕ٥ݕȉt(ͽɍ̈聥ѕlͽɍ̉t(ͽɍ}٥}ͽɍ}(ɕ}٥聥ѕl٥t(ɕեɕ}Ј聥ѕl}ѥt(}Ȉ͔(((ɕ͕}ѡɥ}̀ɕ͕lɕ͕}ѡɥѥul̉t(ɽՍ}}չЀɕ͕lɕ͕}յulɽՍ}}չЉt(}չЀ(İɽՍ}}չЀɕ͕}ѡɥ}̤(ɕ͕}(͔ɕѕ}̤((}չ(}ɕѕ}х̀􀉍ɍ}}ɕѕ}(}ѕ(}ɕѕ}х̀􀉍ɍ}}ɕѕ}(͔耀Ʌ聹ٕȀչɕݡѡ́ɕЁɥ́ѕɅȵ݅ɹ͕ѥ(}ɕѕ}х̀􀉍ɍ}}ɕѕ}ȈɅ聹ٕ((ɽՍѥ}}չЀմāȁѕ}ѕ́ѕl}tɽՍѥ}٥}(}}}չЀմāȁѕ}ѕ́ѕl}t􀉉}}(ɕɸ(}ɕѕ}х̈聝}ɕѕ}х̰(хɝ}Ʌ}مՕ}܈хɝ}Ʌ}مՕ}ܰ(хɝ}Ʌ}مՕ}聘-I\хɝ}Ʌ}مՕ}(ɕ}х̈耉}ɍ}}ɕѕȈ(ͽɍ}є耠( ɍɕѕȁٕ́ɕ͔є݅ɹ́ѼݹȰѥ(ͽɍɕեɕЁɽ́ȁȁՔ쁥Ё́ЁمՅѥՅɅѕ(ɍ͔ѵаȁɽՍѥѥє((}յ(ѽх}}չЈ聱}ѕ̤(ɽՍѥ}}չЈɽՍѥ}}չа(}}}չЈ聉}}}չа(}չЈ聉}չа(ɕ͕}ѡɥ}}չЈ聱ɕ͕}ѡɥ}̤((}ѕ̈聝}ѕ̰(ɕѕ}̈聍ɕѕ}̰(ɕ͕}ѡɥѥɕ͕lɕ͕}ѡɥѥt(}х}ձ̈l((}х̈耉ɽՍѥ}}ɕեɕ(ձ耉ɽՍѥ嵕ааM1<ȁɅѥ٥ЁɔɽՍѥ(((}х̈耉}}ɕեɕ(ձ耉ȵɽɕаI=$ȁ嵕ЁѕЁЁɔȵ(((}х̈耉(ձ耉ɕє͕ɥ䰁A$ɅаյаɽՍЁаȁ Ё́ͅɍɕ͔((t(ɕ٥}ɽ}ɕ͕lɕ٥}ɽ}t(ɕѕ}չѥ}ɕ̈(ɍ}ɕ͕}х̈ɕ͕lɕ͕}х̉t(ɕ͕}ѡɥѥ}х̈ɕ͕lɕ͕}ѡɥѥulх̉t(ɕ͕lɕѕ}չѥ}ɕ̉t((Ʌ}}ͥɕ͕lɅ}}ͥt(՝}Ʌɕ͕l՝}Ʌt(}ɕѕ}̈(}ͥ}耉輽ܹͥi5]!Ii9](}ɐ耉輽ܹɐ]5M!!MA4(չѥ}Ј耈Ľɍ}}ɕѕ̽ѕЈ(յхѥ耉̽ɍ}}ɕѕȹ((((ɍ}ɽɕ}ɕ}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(ɕ͕}ѡɥ5mȰt99(mȰt(Iɸɽɕнɕ́єٕȁɍ٥(}ɕѕȀ͕ɍ}}ɕѕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ(ɕ͕}ѡɥɕ͕}ѡɥ((ɽЀAѠ}}}|ɕͽٔɕlt((}ѠȤ(ɕɸɽЀѠ}((}}х̀ѕl}х̉t聥ѕȁѕ}ɕѕl}ѕ̉u(ɽՍѥ}􁝅}}х̹РɽՍѥ}}ɕեɕ(}􁝅}}х̹Р}}ɕեɕ(ɕѕ}̀􁝅}ɕѕlɕѕ}̉t(ɕ͕}ѡɥѥ􁝅}ɕѕlɕ͕}ѡɥѥt(ɕ͕}ѡɥ}̀ɕ͕}ѡɥѥl̉t(ɽɕ}ѕ̀l((ѕ}耉͕}}ɥ̈(耉1͔ɥ̈(ݹȈ耉AɽɕЁɕ٥ݕȈ(ͽɍ̈l1% 9Mɽйѽt(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ䈁}1% 9M}ɽйѽ͔(٥耉5%P͔хфɔɕ͕Ёȁȁɥ́ɕ٥ܸ(ɕեɕ}Ј耉Iѽɔ͔ȁхфɔɽɕЁɕ٥ܸ(((ѕ}耉͕ɥ}}хф(耉Mɥхф(ݹȈ耉Mɥɕ٥ݕȈ(ͽɍ̈l(M UI%Qd(ɕեɕ̹(ѡՈݽɭ͕̽ɥ嵰(ѡՈй嵰( ѕՅ]͑1ѡՈɅɕեɕ͕ɥݽɭ̈(t(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ((}Ѡ(ȁѠ(M UI%Qd(ɕեɕ̹(ѡՈݽɭ͕̽ɥ嵰(ѡՈй嵰(((͔(٥耉Mɥ䰁̰䵍ݽɭܰЁхфɅɕեɕ͕ɥݽɭ́ɔɕ͕и(ɕեɕ}Ј耉Iѽɔ͕ͥɥ䁵хфɔɽɕЁɕ٥ܸ(((ѕ}耉ɥѥ}Ј(耉ɥѥЈ(ݹȈ耉ݹȈ(ͽɍ̈l(I5(̽ɕ}}ͥ(̽ɍ}ɕ͕}є(̽ɍ}}ɕѕȹ(t(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ((}Ѡ(ȁѠ(I5(̽ɕ}}ͥ(̽ɍ}ɕ͕}є(̽ɍ}}ɕѕȹ(((͔(٥耉Iͥѽ䁽ٕ٥ܰIMPɅаɕ͔єɕѕȁյ́ɔɕ͕и(ɕեɕ}Ј耉Iѽɔͥɥѥյ́ɔɽɕЁɕ٥ܸ(((ѕ}耉}٥}ə(耉٥ə(ݹȈ耉AљɴɅѽȈ(ͽɍ̈lѕՅ}ɍɅѽȽ䈰Ľɍ}ɽɕ}ɕ̽ѕЉt(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ䈁}ѕՅ}ɍɅѽȽ䈤͔(٥耉͕مə͕́ɽɕЁɕ́ݥѠՅ̸(ɕեɕ}Ј耉͔ɽɕЁɕ͕́م䁉ɔȁɕ٥ܸ(((ѕ}耉ɽՍѥ}}ͱ}Ј(耉AɽՍѥЁM1<Ј(ݹȈɽՍѥ}lݹȉtɽՍѥ}͔=Ʌѥ́ЁݹȈ(ͽɍ̈ɽՍѥ}lͽɍ̉tɽՍѥ}͔l̽ɍ}}ɕѕȹt(٥}耉ɽ͕}չѥ}ɽՍѥ(ѥ}хє耉݅ɹɽՍѥ}͔ɕ䈰(ͽɍ}}х̈ɽՍѥ}l}х̉tɽՍѥ}͔ɕͽٕ(٥ɽՍѥ}lɕ}٥tɽՍѥ}͔9ɽՍѥ٥́(ɕեɕ}ЈɽՍѥ}lɕեɕ}ЉtɽՍѥ}͔9ɽՍѥЁɕեɕ(((ѕ}耉}}ɽ}ɽɕ}Ј(耉 ȁI=$ɽɕЁЈ(ݹȈ聉}lݹȉt}͔ ȁݹȈ(ͽɍ̈聉}lͽɍ̉t}͔l̽ɍ}}ɕѕȹt(٥}耉ɽ͕}չѥ}}(ѥ}хє耉݅ɹ}͔ɕ䈰(ͽɍ}}х̈聉}l}х̉t}͔ɕͽٕ(٥聉}lɕ}٥t}͔9ȵ٥́(ɕեɕ}Ј聉}lɕեɕ}Љt}͔9ȁЁɕեɕ(((ѕ}耉ɕ٥}ɽ}䈰(耉I٥܁ɽ́䈰(ݹȈ耉ݹȈ(ͽɍ̈l̽ɍ}ͅ}ͥ̽ɍ}ɽɕ}ɕ̹t(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ䈰(٥耉I٥ݕȁ䰁ɕ٥܁Ё䰁ՕՕɕ٥ܰ́ݥѡЁɕєɔɔЁ̸(ɕեɕ}Ј耉 䁽ɕє͕ɥ䰁A$ɅаյаȁɽՍЁ̸(((ѕ}耉}ͥ(耉Aͥ(ݹȈ耉AɽɕЁ͕ɥɕ٥ݕȈ(ͽɍ̈l̽Ʌ}ɕ͕ɍ̽ɍ}՝}Ʌѥ}t(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ䈁}̽Ʌ}ɕ͕ɍ}̽ɍ}՝}Ʌѥ}͔(٥聝}ɕѕlɅ}}ͥulɕͽt(ɕեɕ}Ј耉=䁕ɅЁɅ䁅ѕȁ͕ɽՍаЁɕ͔ȁɽٕɥȁ̸((t(хѕ}չ̀ չѕȡѕlѥ}хєtȁѕɽɕ}ѕ̤(ɽՍѥ}}չЀāɽՍѥ}͔(}}}չЀā}͔(}չЀхѕ}չ̹Рɕѕ}̤(݅ɹ}չЀхѕ}չ̹Р݅ɹ(}չ(ɽɕ}х̀􀉍ɍ}ɽɕ}(݅ɹ}չ(ɽɕ}х̀􀉍ɍ}ɽɕ}ɕ}ݥѡ}݅ɹ̈(͔耀Ʌ聹ٕȀչɕݡѡ́ɕЁɥ́ѕɅȵ݅ɹ͕ѥ(ɽɕ}х̀􀉍ɍ}ɽɕ}ɕ䈀Ʌ聹ٕ((ɕɸ(ɽɕ}х̈ɽɕ}х̰(хɝ}Ʌ}مՕ}܈хɝ}Ʌ}مՕ}ܰ(хɝ}Ʌ}مՕ}聘-I\хɝ}Ʌ}مՕ}(ɕ}х̈耉}ɍ}ɽɕ}ɕ̈(ͽɍ}є耠( ɍɽɕЁɕ͔͕́́ɥ䰁ɥѥ(ɕѕȰɕ٥ܵɽ̰٥ȁȁՔ쁥Ё́Ѐ(مՅѥՅɅѕɍ͔ѵаȁɽՍѥѥє((ɽɕ}յ(ѕ}չЈ聱ɽɕ}ѕ̤(ɕ}չЈхѕ}չ̹Рɕ䈰(݅ɹ}չЈ݅ɹ}չа(}չЈ聉}չа(ɽՍѥ}}չЈɽՍѥ}}չа(}}}չЈ聉}}}չа(ɕ٥}ɽ}}Ȉ聝}ɕѕlɕ٥}ɽ}ul}ȉt(ɕ͕}ѡɥ}}չЈ聱ɕ͕}ѡɥ}̤((ɽɕ}ѕ̈ɽɕ}ѕ̰(ɕѕ}̈聍ɕѕ}̰(ɕ͕}ѡɥѥɕ͕}ѡɥѥ(ɽɕ}х}ձ̈l((ɽɕ}х̈耉ɍ}ɽɕ}ɕ䈰(ձ耉͔͕ɥ䰁ɥѥаI=$ɕ٥ܰ٥ɔɕ䈰(((ɽɕ}х̈耉ɍ}ɽɕ}ɕ}ݥѡ}݅ɹ̈(ձ耉Ё́ɕݡɽՍѥȁȵ́ɕЁ݅ɹ̈(((ɽɕ}х̈耉ɍ}ɽɕ}(ձ耉ͥЁ٥ɕєɽՍЁаA$ɅЁɔյЁ͵э͕ɥ䁙ɔȁ Ё́ͅɽɕЈ((t(ɕ٥}ɽ}聝}ɕѕlɕ٥}ɽ}t(ɕѕ}չѥ}ɕ̈(ɍ}}ɕѕ}х̈聝}ɕѕl}ɕѕ}х̉t(}ɕѕlɕѕ}չѥ}ɕ̉t((Ʌ}}ͥ聝}ɕѕlɅ}}ͥt(՝}Ʌ聝}ɕѕl՝}Ʌt(ɽɕ}̈(}ͥ}耉輽ܹͥi5]!Ii9](}ɐ耉輽ܹɐ]5M!!MA4(չѥ}Ј耈Ľɍ}ɽɕ}ɕ̽ѕЈ(յхѥ耉̽ɍ}ɽɕ}ɕ̹((((ɍ}Ʌ}ɕ}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(ɕ͕}ѡɥ5mȰt99(mȰt(IɸɅеɕ́єٕȁɽɕЁ٥(ɽɕЀ͕ɍ}ɽɕ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ(ɕ͕}ѡɥɕ͕}ѡɥ((ɽЀAѠ}}}|ɕͽٔɕlt((}ѠȤ(ɕɸɽЀѠ}((ɽɕ}}ѕlѕ}t聥ѕȁѕɽɕlɽɕ}ѕ̉u(͕}ѕɽɕ}}l͕}}ɥ̉t(͕ɥ}ѕɽɕ}}l͕ɥ}}хфt(}ѕɽɕ}}lɽՍѥ}}ͱ}Љt(}ѕɽɕ}}l}}ɽ}ɽɕ}Љt(}ѕɽɕ}}l}ͥt(ɕѕ}̀ɽɕlɕѕ}̉t(ɕ͕}ѡɥѥɽɕlɕ͕}ѡɥѥt(ɕ͕}ѡɥ}̀ɕ͕}ѡɥѥl̉t(}ͱ}}չЀā}ѕlѥ}хєt݅ɹ͔(}ɑ}ɵ}}չЀā}ѕlѥ}хєt݅ɹ͔(Ʌ}ѕ̀l((ѕ}耉͕}ɍ}ɥ̈(耉1͔ɍɥ́ѕɵ̈(ݹȈ耉1ɕ٥ݕȈ(ͽɍ̈聱͕}ѕlͽɍ̉t(٥}聱͕}ѕl٥}t(ѥ}хє聱͕}ѕlѥ}хєt(٥聱͕}ѕl٥t(ɕեɕ}Ј聱͕}ѕlɕեɕ}Љt(((ѕ}耉͕ɥ}ɥم}ѕɵ̈(耉Mɥ䁅ɥمѕɵ̈(ݹȈ耉Mɥ䁅ɕ٥ݕȈ(ͽɍ̈l͕ɥ}ѕlͽɍ̉t̽ɍ}ɽɕ}ɕ̹t(٥}͕ɥ}ѕl٥}t(ѥ}хє͕ɥ}ѕlѥ}хєt(٥耠(͕ɥ}ѕl٥uIչѥɕ́ɽ͕̀(ѡ}͕ɥ}ɽРѡ}չݸ͕ɥ}ɽ͔չݸ(Չ}͕ɥ}ɽР}Չ}չݸ͕ɥ}ɽ͔չݸ(Ʌɔɽ̸((ɕեɕ}Ј͕ɥ}ѕlɕեɕ}Љt(((ѕ}耉Ց}}ѥ̈(耉ՑЁЁѥ̈(ݹȈ耉 ɕ٥ݕȈ(ͽɍ̈l(Ľɍ}٥}̽ѕЈ(̽ɍ}٥}й(̽ɕ}}ͥ(t(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ((}Ѡ(ȁѠ(̽ɍ}٥}й(̽ɕ}}ͥ(((͔(٥耉 ɍ٥ЁIMPA$ɅЁ͍ɥȵɕՑЁ٥(ɕեɕ}Ј耉Iѽɔ٥Ё́IMPɅЁɔɅЁɕ٥ܸ(((ѕ}耉Ʌ}}̈(耉 ɅЁЁյ̈(ݹȈ耉ݹȈ(ͽɍ̈l(I5(̽ɍ}Ʌ}ɕ̹(̽ɍ}ɽɕ}ɕ̹(̽ɍ}ͅ}ͥ(t(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ((}Ѡ(ȁѠ(I5(̽ɍ}Ʌ}ɕ̹(̽ɍ}ɽɕ}ɕ̹(̽ɍ}ͅ}ͥ(((͔(٥耉 ɅЁаɽɕЁєͅ䁉ȁ䁅ɔյѕ(ɕեɕ}Ј耉IѽɔȁɅЁЁ́ɔɕ٥ܸ(((ѕ}耉}ͱ}ѕɵ̈(耉MЁM1<ѕɵ̈(ݹȈ}ѕlݹȉt(ͽɍ̈}ѕlͽɍ̉t(٥}}ѕl٥}t(ѥ}хє}ѕlѥ}хєt(ͽɍ}}х̈}ѕРͽɍ}}х̈ɕͽٕ(٥}ѕl٥t(ɕեɕ}Ј}ѕlɕեɕ}Љt(((ѕ}耉}ɑ}ɵ}Ј(耉 ȁɑȵɴЈ(ݹȈ聉}ѕlݹȉt(ͽɍ̈聉}ѕlͽɍ̉t(٥}聉}ѕl٥}t(ѥ}хє聉}ѕlѥ}хєt(ͽɍ}}х̈聉}ѕРͽɍ}}х̈ɕͽٕ(٥聉}ѕl٥t(ɕեɕ}Ј聉}ѕlɕեɕ}Љt(((ѕ}耉ɕ٥}ɽ}䈰(耉I٥܁ɽ́䈰(ݹȈ耉ݹȈ(ͽɍ̈l̽ɍ}ͅ}ͥ̽ɍ}Ʌ}ɕ̹t(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ䈰(٥耉I٥܁ɽ́䁥́ЁɅЁȁչ́ɕєɔ́ɽՍ(ɕեɕ}Ј耉 䁽ɕє͕ɥ䰁A$ɅаյаȁɽՍЁ̸(((ѕ}耉}ͥ(耉Aͥ(ݹȈ}ѕlݹȉt(ͽɍ̈}ѕlͽɍ̉t(٥}}ѕl٥}t(ѥ}хє}ѕlѥ}хєt(٥}ѕl٥t(ɕեɕ}Ј}ѕlɕեɕ}Љt((t(хѕ}չ̀ չѕȡѕlѥ}хєtȁѕɅ}ѕ̤(}չЀхѕ}չ̹Рɕѕ}̤(݅ɹ}չЀхѕ}չ̹Р݅ɹ(}չ(Ʌ}х̀􀉍ɍ}Ʌ}(݅ɹ}չ(Ʌ}х̀􀉍ɍ}Ʌ}ɕ}ݥѡ}݅ɹ̈(͔耀Ʌ聹ٕȀչɕݡѡ́ɕЁɥ́ѕɅȵ݅ɹ͕ѥ(Ʌ}х̀􀉍ɍ}Ʌ}ɕ䈀Ʌ聹ٕ((ɕɸ(Ʌ}х̈聍Ʌ}х̰(хɝ}Ʌ}مՕ}܈хɝ}Ʌ}مՕ}ܰ(хɝ}Ʌ}مՕ}聘-I\хɝ}Ʌ}مՕ}(ɕ}х̈耉}ɍ}Ʌ}ɕ̈(ͽɍ}є耠( ɍɅЁɕ͔͕́́ɥɥم䰁ՑЁа(нM1<ȁɑȵɴɕ٥ܵɽ̰٥ȁ(ɽɕЁՔ쁥Ё́ЁمՅѥՅɅѕɍ͔ѵаȀ(ɽՍѥѥє((Ʌ}յ(ѕ}չЈ聱Ʌ}ѕ̤(ɕ}չЈхѕ}չ̹Рɕ䈰(݅ɹ}չЈ݅ɹ}չа(}չЈ聉}չа(}ͱ}}չЈ}ͱ}}չа(}ɑ}ɵ}}չЈ聉}ɑ}ɵ}}չа(ɕ٥}ɽ}}Ȉɽɕlɕ٥}ɽ}ul}ȉt(ɕ͕}ѡɥ}}չЈ聱ɕ͕}ѡɥ}̤((Ʌ}ѕ̈聍Ʌ}ѕ̰(ɕѕ}̈聍ɕѕ}̰(ɕ͕}ѡɥѥɕ͕}ѡɥѥ(Ʌ}х}ձ̈l((Ʌ}х̈耉ɍ}Ʌ}ɕ䈰(ձ耉͔͕ɥɥم䰁ՑнанM1<ȁɑȵɴɕ٥ܰѕɵ́ɔɕ䈰(((Ʌ}х̈耉ɍ}Ʌ}ɕ}ݥѡ}݅ɹ̈(ձ耉ɅЁЁ́ɕݡɽՍѥнM1<ȁȁɑȵɴ́ɕЁ݅ɹ̈(((Ʌ}х̈耉ɍ}Ʌ}(ձ耉ͥɅЁЁ٥ɕєɽՍЁаA$ɅЁɔյЁ͵э͕ɥ䁙ɔȁ Ё́ͅɅЁɕ̈((t(ɕ٥}ɽ}ɽɕlɕ٥}ɽ}t(ɕѕ}չѥ}ɕ̈(ɍ}ɽɕ}х̈ɽɕlɽɕ}х̉t(ɽɕlɕѕ}չѥ}ɕ̉t((Ʌ}}ͥɽɕlɅ}}ͥt(՝}Ʌɽɕl՝}Ʌt(Ʌ}̈(}ͥ}耉輽ܹͥi5]!Ii9](}ɐ耉輽ܹɐ]5M!!MA4(չѥ}Ј耈Ľɍ}Ʌ}ɕ̽ѕЈ(յхѥ耉̽ɍ}Ʌ}ɕ̹((((ɍ}ɑ}ɕ}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(ɕ͕}ѡɥ5mȰt99(mȰt(Iɸɑɕ́єٕȁɅЁ٥(ɅЀ͕ɍ}Ʌ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ(ɕ͕}ѡɥɕ͕}ѡɥ((ɽЀAѠ}}}|ɕͽٔɕlt((}ѠȤ(ɕɸɽЀѠ}((Ʌ}}ѕlѕ}t聥ѕȁѕɅlɅ}ѕ̉u(}ѕ􁍽Ʌ}}l}ͱ}ѕɵ̉t(}ѕ􁍽Ʌ}}l}ɑ}ɵ}Љt(}ѕ􁍽Ʌ}}l}ͥt(ɕѕ}̀􁍽Ʌlɕѕ}̉t(ɕ͕}ѡɥѥ􁍽Ʌlɕ͕}ѡɥѥt(}ͱ}ѥ}չЀā}ѕlѥ}хєt݅ɹ͔(}}ѥ}չЀā}ѕlѥ}хєt݅ɹ͔(ɑ}ѕ̀l((ѕ}耉}}Ј(耉 ȁЈ(ݹȈ耉ݹȈ(ͽɍ̈l(I5(̽ɍ}ɑ}ɕ̹(̽ɍ}Ʌ}ɕ̹(t(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ((}Ѡ(ȁѠ(I5(̽ɍ}ɑ}ɕ̹(̽ɍ}Ʌ}ɕ̹(((͔(٥耉 ȁЁ́ɽՍЁٕ٥ܰɅЁɕ̰ɑ(ѥ耉U͔ѡЁѼхЁɑݥѠȁх̸(}ɥѕɥ耉 ȁɵ́ݹȰɑѕ̰٥ɕ٥܁(((ѕ}耉}ͱ}(耉MЁM1<(ݹȈ}ѕlݹȉt(ͽɍ̈}ѕlͽɍ̉t(٥}}ѕl٥}t(ѥ}хє}ѕlѥ}хєt(ͽɍ}}х̈}ѕРͽɍ}}х̈ɕͽٕ(٥}ѕl٥t(ѥ耉 ЁЁɽф͍ѥѠM1<хɝаЁɥ٥ɥɑ(}ɥѕɥ耉 ȁɅѽȁɽٔЁݹȰɕ͔хɝа͍ѥѠЁЁɥɕɐ(((ѕ}耉}ɑ}ɵ}(耉 ȁɑȵɴ(ݹȈ聉}ѕlݹȉt(ͽɍ̈聉}ѕlͽɍ̉t(٥}聉}ѕl٥}t(ѥ}хє聉}ѕlѥ}хєt(ͽɍ}}х̈聉}ѕРͽɍ}}х̈ɕͽٕ(٥聉}ѕl٥t(ѥ耉 ЁȁɑȵɴI=$Օѥɔ嵕аЁ̸(}ɥѕɥ耉 ȵɑȁɴɽɕЁ́ɔхѼѡи(((ѕ}耉ѕ}ɕ}(耉Q䁍ɔ(ݹȈ耉фѥ́ݹȈ(ͽɍ̈lĽѥ}͹̽͡ѕЈ̽ѥ}t(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ䈁}̽ѥ}͔(٥耉ѥ͕́Ʌѕ́ɕ٥ɽɽ͕ɽՍѥɥ̸(ѥ耉 ɔɽՍѥɑѕݥѡЁ᥹ЁݥѠɽѽɥ̸(}ɥѕɥ耉Ёȁ٥ɽЁɕɑ́ѥѕ䰁ٕɥѥɅѕ̰Ё̸ٕ(((ѕ}耉х}}ɥѕɥ(耉хЁɥѕɥ(ݹȈ耉Qȁɕ٥ݕȈ(ͽɍ̈l(Ľɍ}х}̽ѕЈ(̽ɍ}х}(̽ɍ}}х}չ(t(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ(}̽ɍ}х}(}̽ɍ}}х}չ(͔(٥耉хȁչɕ٥܁ѕ̸(ѥ耉IոѡȁхЁѕȁ٥́х(}ɥѕɥ耉х́ɕє́݅ɹ́ɔѱ䁽ݹ(((ѕ}耉͕ɥ}}(耉Mɥ䁅(ݹȈ耉Mɥ䁅ɕ٥ݕȈ(ͽɍ̈lM UI%Qd̽ɍ}Ʌ}ɕ̹t(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ(}M UI%Qd}̽ɍ}Ʌ}ɕ̹(͔(٥耉Mɥ䁅ɅЁɕ́Ёɔمȁȁ(ѥ耉х͕ɥ䰁䁱ɅЁɕ́ɽ́Ѽȁ(}ɥѕɥ耉 ȁ͕ɥ佱ɕ٥ݕȁ́ѡЁȁ́ɕє̸(((ѕ}耉ɕ٥}ɽ}䈰(耉I٥܁ɽ́䈰(ݹȈ耉ݹȈ(ͽɍ̈l̽ɍ}ͅ}ͥ̽ɍ}ɑ}ɕ̹t(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ䈰(٥耉I٥܁䁥́Ёɑȁչ́ɕєɔ́ɽՍ(ѥ耉 ѥՔɑݽɬݡՕՕɕ٥́ɔ(}ɥѕɥ耉=䁍ɕє͕ɥ䰁A$ɅаյаȁɽՍЁ́ɽɕ̸(((ѕ}耉}ͥ(耉Aͥ(ݹȈ}ѕlݹȉt(ͽɍ̈}ѕlͽɍ̉t(٥}}ѕl٥}t(ѥ}хє}ѕlѥ}хєt(٥}ѕl٥t(ѥ耉-光ѕɥ͔ɽɽՍЁѡɽ՝ɑ(}ɥѕɥ耉ɅЁ䁅ѕȁ͕ɽՍаЁɕ͔ȁȁɽٕɥȁ̸((t(хѕ}չ̀ չѕȡѕlѥ}хєtȁѕɑ}ѕ̤(}չЀхѕ}չ̹Рɕѕ}̤(݅ɹ}չЀхѕ}չ̹Р݅ɹ(}չ(ɑ}х̀􀉍ɍ}ɑ}(݅ɹ}չ(ɑ}х̀􀉍ɍ}ɑ}ɕ}ݥѡ}݅ɹ̈(͔耀Ʌ聹ٕȀչɕݡѡ́ɕЁɥ́ѕɅȵ݅ɹ͕ѥ(ɑ}х̀􀉍ɍ}ɑ}ɕ䈀Ʌ聹ٕ((ɕɸ(ɑ}х̈聽ɑ}х̰(хɝ}Ʌ}مՕ}܈хɝ}Ʌ}مՕ}ܰ(хɝ}Ʌ}مՕ}聘-I\хɝ}Ʌ}مՕ}(ɕ}х̈耉}ɍ}ɑ}ɕ̈(ͽɍ}є耠( ɍɑɕٕ́́ɅЁɽɕЁ݅ɹ́Ѽ(ɑݹ̰ѥ̰Ёɥѕɥ쁥Ё́ЁمՅѥՅɅѕ(ɍ͔ѵаȁɽՍѥѥє((ɑ}յ(ѕ}չЈ聱ɑ}ѕ̤(ɕ}չЈхѕ}չ̹Рɕ䈰(݅ɹ}չЈ݅ɹ}չа(}չЈ聉}չа(}ͱ}ѥ}չЈ}ͱ}ѥ}չа(}}ѥ}չЈ聉}}ѥ}չа(ɕ٥}ɽ}}Ȉ聍Ʌlɕ٥}ɽ}ul}ȉt(ɕ͕}ѡɥ}}չЈ聱ɕ͕}ѡɥѥl̉t((ɑ}ѕ̈聽ɑ}ѕ̰(ɕѕ}̈聍ɕѕ}̰(ɕ͕}ѡɥѥɕ͕}ѡɥѥ(ɑ}х}ձ̈l((ɑ}х̈耉ɍ}ɑ}ɕ䈰(ձ耉анM1<ȁаѕ䰁х͕ɥ佱ɕ٥ܰѥ́ɔɕ䈰(((ɑ}х̈耉ɍ}ɑ}ɕ}ݥѡ}݅ɹ̈(ձ耉ɑ́ɕݡɽՍѥнM1<ȁȁɑȵɴѥ́ɕЁ݅ɹ̈(((ɑ}х̈耉ɍ}ɑ}(ձ耉ͥɑЁ٥ɕєɽՍЁаA$ɅЁɔյЁ͵э͕ɥ䁙ɔȁ Ё́ͅɑ((t(ɕ٥}ɽ}聍Ʌlɕ٥}ɽ}t(ɕѕ}չѥ}ɕ̈(ɍ}Ʌ}х̈聍ɅlɅ}х̉t(Ʌlɕѕ}չѥ}ɕ̉t((Ʌ}}ͥ聍ɅlɅ}}ͥt(՝}Ʌ聍Ʌl՝}Ʌt(ɑ}̈(}ͥ}耉輽ܹͥi5]!Ii9](}ɐ耉輽ܹɐ]5M!!MA4(չѥ}Ј耈Ľɍ}ɑ}ɕ̽ѕЈ(յхѥ耉̽ɍ}ɑ}ɕ̹((((ɍ}Ʌѥ}ɕ}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(ɕ͕}ѡɥ5mȰt99(mȰt(IɸɅѥ̵ɕ́єٕȁɑ٥(ɑ͕ɍ}ɑ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ(ɕ͕}ѡɥɕ͕}ѡɥ((ɽЀAѠ}}}|ɕͽٔɕlt((}ѠȤ(ɕɸɽЀѠ}((ɑ}}ѕlѕ}t聥ѕȁѕɑlɑ}ѕ̉u(}ѕ􁽹ɑ}}l}ͱ}t(ѕ}ѕ􁽹ɑ}}lѕ}ɕ}t(х}ѕ􁽹ɑ}}lх}}ɥѕɥt(͕ɥ}ѕ􁽹ɑ}}l͕ɥ}}t(}ѕ􁽹ɑ}}l}ͥt(ɕѕ}̀􁽹ɑlɕѕ}̉t(Ʌѥ}ѕ̀l((ѕ}耉嵕}չ(耉嵕Ёչ(ݹȈ耉AљɴɅѽȈ(ͽɍ̈l(I5(̽ɍ}Ʌѥ}ɕ̹(̽ɍ}ɑ}ɕ̹(̽ɕ}}ͥ(t(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ((}Ѡ(ȁѠ(I5(̽ɍ}Ʌѥ}ɕ̹(̽ɍ}ɑ}ɕ̹(̽ɕ}}ͥ(((͔(٥耉Iͥѽ䁽ٕ٥ܰIMPɅаɑɅѥ́ɔɕ͕и(ѥ耉U͔ѥё͕ٕȁյѕ́ȁȁɅѥ́(}ɥѕɥ耉 ȁɅѽȁхаѡѥєЁɕ̰́ոٕɥѥ̸(((ѕ}耉ѽɥ}ѕ}ɔ(耉5ѽɥѕ䁍ɔ(ݹȈѕ}ѕlݹȉt(ͽɍ̈ѕ}ѕlͽɍ̉t(٥}耉ɽ͕}չѥ}ɽՍѥ(ѥ}хє耉݅ɹ(ͽɍ}}х̈耉ɽՍѥ}}ɕեɕ(٥ѕ}ѕl٥t(ѥ耉 ɔѥѕ䰁ٕɥȁэ̰Ʌѕ̰Ёٕ̰嵕ЁѠѡȁ٥ɽи(}ɥѕɥ耉ЁɽՍѥѕ͹͡Ё́хݥѡЁ᥹ЁݥѠɽѽɥ̸(((ѕ}耉}ɽ}(耉%Ёɽ(ݹȈ耉=Ʌѥ́ЁݹȈ(ͽɍ̈l̽ɍ}ɑ}ɕ̹̽ɍ}}х}չt(٥}耉ɽ͕}չѥ}ɽՍѥ(ѥ}хє耉݅ɹ(ͽɍ}}х̈耉ɽՍѥ}}ɕեɕ(٥耉%Ёɥɽɽɕեɔȁ嵕Ёȁɑ٥ɽи(ѥ耉IոѡЁЁɥɽɍ͔ɥɑ(}ɥѕɥ耉%ЁݹȰ͍ѥѠɽѕ̰ɥɕɐɔх(((ѕ}耉}ɕٕ}(耉 ɕٕ䁕٥(ݹȈ耉=Ʌѥ́фݹȈ(ͽɍ̈l̽ɍ}ɑ}ɕ̹̽ɍ}}}йt(٥}耉ɽ͕}չѥ}ɽՍѥ(ѥ}хє耉݅ɹ(ͽɍ}}х̈耉ɽՍѥ}}ɕեɕ(٥耉 ɕٕ䁕٥́ѡȁ嵕Ёѽ䁅ͥѕ̸(ѥ耉͍ɕѕѥɕѽɔݹȰЁɕѽɔɽɥɑ(}ɥѕɥ耉 ȁ͍́ɕѽɔɽ́хȁѱٕ݅(((ѕ}耉}ͱ}ݹ͡(耉MЁɽфM1<ݹ͡(ݹȈ}ѕlݹȉt(ͽɍ̈}ѕlͽɍ̉t(٥}}ѕl٥}t(ѥ}хє}ѕlѥ}хєt(ͽɍ}}х̈}ѕРͽɍ}}х̈ɕͽٕ(٥}ѕl٥t(ѥ}ѕlѥt(}ɥѕɥ}ѕl}ɥѕɥt(((ѕ}耉х}(耉х(ݹȈ聅х}ѕlݹȉt(ͽɍ̈聅х}ѕlͽɍ̉t(٥}聅х}ѕl٥}t(ѥ}хє聅х}ѕlѥ}хєt(٥聅х}ѕl٥t(ѥ聅х}ѕlѥt(}ɥѕɥ聅х}ѕl}ɥѕɥt(((ѕ}耉͕ɥ}}(耉Mɥ䁅(ݹȈ͕ɥ}ѕlݹȉt(ͽɍ͕̈ɥ}ѕlͽɍ̉t(٥}͕ɥ}ѕl٥}t(ѥ}хє͕ɥ}ѕlѥ}хєt(٥͕ɥ}ѕl٥t(ѥ͕ɥ}ѕlѥt(}ɥѕɥ͕ɥ}ѕl}ɥѕɥt(((ѕ}耉ɕ٥}ɽ}䈰(耉I٥܁ɽ́䈰(ݹȈ耉ݹȈ(ͽɍ̈l̽ɍ}ͅ}ͥ̽ɍ}Ʌѥ}ɕ̹t(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ䈰(٥耉I٥܁䁥́ЁɅѥ́ȁչ́ɕєɔ́ɽՍ(ѥ耉 ѥՔɅѥ́ݽɬݡՕՕɕ٥́ɔ(}ɥѕɥ耉=䁍ɕє͕ɥ䰁A$ɅаյаȁɽՍЁ́ɽɕ̸(((ѕ}耉}ͥ(耉Aͥ(ݹȈ}ѕlݹȉt(ͽɍ̈}ѕlͽɍ̉t(٥}}ѕl٥}t(ѥ}хє}ѕlѥ}хєt(٥}ѕl٥t(ѥ}ѕlѥt(}ɥѕɥ}ѕl}ɥѕɥt((t(хѕ}չ̀ չѕȡѕlѥ}хєtȁѕɅѥ}ѕ̤(}չЀхѕ}չ̹Рɕѕ}̤(݅ɹ}չЀхѕ}չ̹Р݅ɹ(ɽՍѥ}٥}ѥ}չЀմ(āȁѕɅѥ}ѕ́ѕРͽɍ}}х̈ɽՍѥ}}ɕեɕ((}չ(Ʌѥ}х̀􀉍ɍ}Ʌѥ}(݅ɹ}չ(Ʌѥ}х̀􀉍ɍ}Ʌѥ}ɕ}ݥѡ}݅ɹ̈(͔耀Ʌ聹ٕȀչɕݡѡ́ɕЁɥ́ѕɅȵ݅ɹ͕ѥ(Ʌѥ}х̀􀉍ɍ}Ʌѥ}ɕ䈀Ʌ聹ٕ((ɕɸ(Ʌѥ}х̈聽Ʌѥ}х̰(хɝ}Ʌ}مՕ}܈хɝ}Ʌ}مՕ}ܰ(хɝ}Ʌ}مՕ}聘-I\хɝ}Ʌ}مՕ}(ɕ}х̈耉}ɍ}Ʌѥ}ɕ̈(ͽɍ}є耠( ɍɅѥ́ɕٕ́́ɑ٥ɽՍѥ(Ʌѥ́́Ѽݹ̰ѥ̰Ёɥѕɥ쁥Ё́ЁمՅѥ(ՅɅѕɍ͔ѵаȁɽՍѥѥє((Ʌѥ}յ(ѕ}չЈ聱Ʌѥ}ѕ̤(ɕ}չЈхѕ}չ̹Рɕ䈰(݅ɹ}չЈ݅ɹ}չа(}չЈ聉}չа(ɽՍѥ}٥}ѥ}չЈɽՍѥ}٥}ѥ}չа(ɕ٥}ɽ}}Ȉ聽ɑlɕ٥}ɽ}ul}ȉt((Ʌѥ}ѕ̈聽Ʌѥ}ѕ̰(ɕѕ}̈聍ɕѕ}̰(Ʌѥ}х}ձ̈l((Ʌѥ}х̈耉ɍ}Ʌѥ}ɕ䈰(ձ耉嵕аѽɥаах͕ɥ佱ɕ٥ܰ٥ɔɕ䈰(((Ʌѥ}х̈耉ɍ}Ʌѥ}ɕ}ݥѡ}݅ɹ̈(ձ耉Ʌѥ́́ɕݡɽՍѥѕ䰁аȁM1<٥ɕ́Ё݅ɹ̈(((Ʌѥ}х̈耉ɍ}Ʌѥ}(ձ耉ͥɅѥ́Ё٥ɕєɽՍЁаA$ɅЁɔյЁ͵э͕ɥ䁙ɔȁ Ё́ͅɅѥ́((t(ɕ٥}ɽ}聽ɑlɕ٥}ɽ}t(ɕѕ}չѥ}ɕ̈(ɍ}ɑ}х̈聽ɑlɑ}х̉t(ɑlɕѕ}չѥ}ɕ̉t((Ʌ}}ͥ聽ɑlɅ}}ͥt(՝}Ʌ聽ɑl՝}Ʌt(Ʌѥ}̈(}ͥ}耉輽ܹͥi5]!Ii9](}ɐ耉輽ܹɐ]5M!!MA4(չѥ}Ј耈Ľɍ}Ʌѥ}ɕ̽ѕЈ(յхѥ耉̽ɍ}Ʌѥ}ɕ̹((((ɍ}͕ɥ}ѕхѥ}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(ɕ͕}ѡɥ5mȰt99(mȰt(Iɸȁ͕ɥɕ٥܁ѕхѥєٕȁɅѥ́٥(Ʌѥ͕̀ɍ}Ʌѥ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ(ɕ͕}ѡɥɕ͕}ѡɥ((ɽЀAѠ}}}|ɕͽٔɕlt((}ѠȤ(ɕɸɽЀѠ}((Ʌѥ}}ѕlѕ}t聥ѕȁѕɅѥlɅѥ}ѕ̉u(չѥ}ɽ͕ɥ}ɽȁ(ɕѕ}̀Ʌѥlɕѕ}̉t(͕ɥ}ѕхѥ}ѕ̀l((ѕ}耉͕ɥ}䈰(耉Mɥ䈰(ݹȈ耉Mɥ䁽ݹȈ(ͽɍ̈lM UI%Qdt(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ䈁}M UI%Qd͔(٥耉Iͥѽ͕ɥ䁑͍ɔЁ䁥́ɕ͕и(ѥ耉хM UI%QdѼѡȁ͕ɥɕ٥܁и(}ɥѕɥ耉 ȁѥѡձɅɕѥѠѕ͍(((ѕ}耉}}}хф(耉䁱хф(ݹȈ耉I͔ݹȈ(ͽɍ̈lɕեɕ̹ɽйѽt(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ(}ɕեɕ̹}ɽйѽ(͔(٥耉A䁱Aѡхфɔɕ͕Ёȁ䵍ɕ٥ܸ(ѥ耉U͔ѡхф́ѡȁ䁉͕(}ɥѕɥ耉 ȁЁхфɕɽՍѡ䁥хѥѠ(((ѕ}耉͕ɥ}ݽɭ}хф(耉Mɥݽɭ܁хф(ݹȈ耉Mɥ䁽ݹȈ(ͽɍ̈l(ѡՈй嵰(ѡՈݽɭ͕̽ɥ嵰( ѕՅ]͑1ѡՈɅɕեɕ͕ɥݽɭ̈(t(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ((}Ѡ(ȁѠ(ѡՈй嵰(ѡՈݽɭ͕̽ɥ嵰(((͔(٥耉Ё́ E0ՑнM =4ݽɭ́ɔ쁑ɕ٥ܰQɥ䰁=MXMɕɐɔѕѼɅɕեɕݽɭ̸(ѥ耉хݽɭ܁ѥ́ѕЁͥո٥ݡѡȁɕ٥܁ɕՕ́ѕ $ɽ(}ɥѕɥ耉 ȁЁѡɕ͕ɥݽɭ܁ɽ́ѡȁѕЁոх͕́Ʌѕ丈(((ѕ}耉չѥ}}ɽ}ɽ(耉Iչѥ̵ɽɽ(ݹȈ耉AљɴɅѽȈ(ͽɍ̈lѕՅ}ɍɅѽȽ͕ٕȹ䈰Ľɍ}Ʌѥ}ɕ̽ѕЉt(٥}耉չѥ}Ʌѥ(ѥ}хє耉ɕ䈰(٥耠(Iչѥɽ͕́ѡ}չѥ}ɽРѡ}չݸ(}Չ}չѥ}ɽР}Չ}͔(͕}Ʌ}}ձչѥ}ɽР͕}Ʌ}}ձМ͔(Ʌѕ}}ɕՕչѥ}ɽРɅѕ}}ɕՕ̜չݸ(}ɕ}չչѥ}ɽР}ɕ}չ̜չݸ((ѥ耉U͔ѡ͕ɕеɕչѥɽ́ȵ٥̵ͥɽ٥(}ɥѕɥ耉 ȁٕɥ䁅ɕ͍̰ՉеɅɔձаɅєаɕ䁍ɽ̸(((ѕ}耉Ց}}٥(耉ՑЁ٥Ј(ݹȈ耉٥ݹȈ(ͽɍ̈l(̽ɍ}٥}й(̽ɍ}Ʌѥ}ɕ̹(Ľɍ}٥}̽ѕЈ(Ľɍ}Ʌѥ}ɕ̽ѕЈ(t(٥}耉ɕͥѽ}}չѥ}ѥЈ(ѥ}хє耉ɕ(}̽ɍ}٥}й(}̽ɍ}Ʌѥ}ɕ̹(͔(٥耉 ɍ٥ЁɅѥ́ɕ́յ́ɔɕ͕ЁȁȁՑЁɕ٥ܸ(ѥ耉Aչѥ٥ЁݥѠɅѥ́ɕ́ȁѡ͕ɥɕ٥܁фɽ(}ɥѕɥ耉 ȁɅ͕ɥ䁍́Ѽչѥ́5ɭݸѥ̸(((ѕ}耉ձɅ}͍}٥(耉YձɅ͍٥(ݹȈ耉Mɥ䁽ݹȈ(ͽɍ̈l(ѡՈݽɭ͕̽ɥ嵰( ѕՅ]͑1ѡՈɅɕեɕ͕ɥݽɭ̈(t(٥}耉ѕɹ}ѕхѥ}ɕեɕ(ѥ}хє耉݅ɹ(ͽɍ}}х̈耉ѕɹ}ѕхѥ}ɕեɕ(٥耉1䵍ݽɭ܁хфɅ͕ɥ͍ݽɭ܁хфаЁѡȁЁѥ́ѡѕЁѕ͍ɕձЁȁȵѕեمи(ѥ耉хѕЁ E0ՑаQɥ䰁M =4Mɕɐɕձ́ݡ $ѕ́ȁѡȁɕՕ́٥(}ɥѕɥ耉!ѕ͍́ɔхȁѡȁѱ䁅́ݽɭ܁ѥ́́ՙЁȁѡ́х(((ѕ}耉ѡɑ}}ѕхѥ}}ѕЈ(耉Qɐ䁅ѕхѥȁɅѥѕЈ(ݹȈ耉Mɥ䁽ݹȈ(ͽɍ̈lȁ͕ɥɕ٥܈ѕɹ͕ͽȉt(٥}耉ѕɹ}ѕхѥ}ɕեɕ(ѥ}хє耉݅ɹ(ͽɍ}}х̈耉ѕɹ}ѕхѥ}ɕեɕ(٥耉%ЁM= Ȱ%M<İɅѥѕаȁȁ͕ɥ䁅͕͵Ё٥́ͥѡɕɽѽ(ѥ耉Aɽ٥ѡȵɕՕѕѕхѥ͍ձ͕͵аȁյЁЁٕ݅ȸ(}ɥѕɥ耉 ȁ́ѡѡɐ͕ɥ䁕٥͍ձ͕͵аȁٕ݅ȸ(((ѕ}耉}ɥم}}Օѥɔ(耉 ȁɥم䰁AՕѥɔЈ(ݹȈ耉ݹȈ(ͽɍ̈lȁAȁɥمՕѥɔȁɑȁɴt(٥}耉}}ɕեɕ(ѥ}хє耉݅ɹ(ͽɍ}}х̈耉}}ɕեɕ(٥耉Aɥم䰁AՉɽͽ̰фɕͥ䰁Օѥɔݕ́ȵѕɵ̸(ѥ耉 ЁȁɥمՕѥɔAɕեɕ̰Չɽͽ̰фɕͥ䁍Ʌ̸(}ɥѕɥ耉 ȵɥم䁥́ɔѕȁѱٕ݅ѡи(((ѕ}耉ɕ٥}ɽ}䈰(耉I٥܁ɽ́䈰(ݹȈ耉ݹȈ(ͽɍ̈聽Ʌѥ}}lɕ٥}ɽ}ulͽɍ̉t(٥}聽Ʌѥ}}lɕ٥}ɽ}ul٥}t(ѥ}хє聽Ʌѥ}}lɕ٥}ɽ}ulѥ}хєt(٥聽Ʌѥ}}lɕ٥}ɽ}ul٥t(ѥ聽Ʌѥ}}lɕ٥}ɽ}ulѥt(}ɥѕɥ聽Ʌѥ}}lɕ٥}ɽ}ul}ɥѕɥt(((ѕ}耉}ͥ(耉Aͥ(ݹȈ聽Ʌѥ}}l}ͥulݹȉt(ͽɍ̈聽Ʌѥ}}l}ͥulͽɍ̉t(٥}聽Ʌѥ}}l}ͥul٥}t(ѥ}хє聽Ʌѥ}}l}ͥulѥ}хєt(٥聽Ʌѥ}}l}ͥul٥t(ѥ聽Ʌѥ}}l}ͥulѥt(}ɥѕɥ聽Ʌѥ}}l}ͥul}ɥѕɥt((t(хѕ}չ̀ չѕȡѕlѥ}хєtȁѕ͕ɥ}ѕхѥ}ѕ̤(}չЀхѕ}չ̹Рɕѕ}̤(݅ɹ}չЀхѕ}չ̹Р݅ɹ(ѕɹ}ѕхѥ}}չЀմ(āȁѕ͕ɥ}ѕхѥ}ѕ́ѕРͽɍ}}х̈􀉕ѕɹ}ѕхѥ}ɕեɕ((}ɥم}}չЀմ(āȁѕ͕ɥ}ѕхѥ}ѕ́ѕРͽɍ}}х̈􀉉}}ɕեɕ((}չ(͕ɥ}ѕхѥ}х̀􀉍ɍ}͕ɥ}ѕхѥ}(݅ɹ}չ(͕ɥ}ѕхѥ}х̀􀉍ɍ}͕ɥ}ѕхѥ}ɕ}ݥѡ}݅ɹ̈(͔耀Ʌ聹ٕȀչɕݡѡ́ɕЁɥ́ѕɅȵ݅ɹ͕ѥ(͕ɥ}ѕхѥ}х̀􀉍ɍ}͕ɥ}ѕхѥ}ɕ䈀Ʌ聹ٕ((ɕɸ(͕ɥ}ѕхѥ}х͕̈ɥ}ѕхѥ}х̰(хɝ}Ʌ}مՕ}܈хɝ}Ʌ}مՕ}ܰ(хɝ}Ʌ}مՕ}聘-I\хɝ}Ʌ}مՕ}(ɕ}х̈耉}ɍ}͕ɥ}ѕхѥ(ͽɍ}є耠( ɍ͕ɥ䁅ѕхѥ͕Ʌѕ́ɕ͕ɥ䁕٥ɽѕɹ(ѕхѥѕ͍ȁɥم䁥쁥Ё́ЁمՅѥՅɅѕ(ɍ͔ѵаɽՍѥѥєȁѡɐ͕ɥ䁅Ցи((͕ɥ}ѕхѥ}յ(ѕ}չЈ聱͕ɥ}ѕхѥ}ѕ̤(ɕ}չЈхѕ}չ̹Рɕ䈰(݅ɹ}չЈ݅ɹ}չа(}չЈ聉}չа(ѕɹ}ѕхѥ}}չЈ聕ѕɹ}ѕхѥ}}չа(}ɥم}}չЈ聉}ɥم}}չа(ɕ٥}ɽ}}Ȉ聽Ʌѥlɕ٥}ɽ}ul}ȉt((͕ɥ}ѕхѥ}ѕ͕̈ɥ}ѕхѥ}ѕ̰(ɕѕ}̈聍ɕѕ}̰(͕ɥ}ѕхѥ}х}ձ̈l((͕ɥ}ѕхѥ}х̈耉ɍ}͕ɥ}ѕхѥ}ɕ䈰(ձ耉͕ɥ䰁䁵хфݽɭ܁хф́ɽ̰ՑЁаѕɹѕхѥȁɥم䁥аɕ٥܁䰁٥ɔɕ䈰(((͕ɥ}ѕхѥ}х̈耉ɍ}͕ɥ}ѕхѥ}ɕ}ݥѡ}݅ɹ̈(ձ耉ɕ͕ɥЁ́ɕݡѕ͍٥ѡɐ䁅ѕхѥȁȁɥم䁥Ёɕ́Ё݅ɹ̈(((͕ɥ}ѕхѥ}х̈耉ɍ}͕ɥ}ѕхѥ}(ձ耉͕ͥɥЁ٥ɕєɽՍЁаA$ɅЁɔյЁ͵э͕ɥ䁙ɔȁ Ё͕́ͅɥ䁅ѕхѥ((t(ɕ٥}ɽ}聽Ʌѥlɕ٥}ɽ}t(ɕѕ}չѥ}ɕ̈(ɍ}Ʌѥ}х̈聽ɅѥlɅѥ}х̉t(Ʌѥlɕѕ}չѥ}ɕ̉t((Ʌ}}ͥ聽ɅѥlɅ}}ͥt(՝}Ʌ聽Ʌѥl՝}Ʌt(͕ɥ}ѕхѥ}̈(}ͥ}耉輽ܹͥi5]!Ii9](}ɐ耉輽ܹɐ]5M!!MA4(չѥ}Ј耈Ľɍ}͕ɥ}ѕхѥ̽ѕЈ(յхѥ耉̽ɍ}͕ɥ}ѕхѥ((((ɍ}مՕ}ɕ}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(ɕ͕}ѡɥ5mȰt99(mȰt(Iɸȁɕ٥܁єٕȁمՔI=$٥(ɍ͕ɍ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((Ѐ͕ɍ}٥}}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((͕ɥ͕ɍ}͕ɥ}ѕхѥ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ(ɕ͕}ѡɥɕ͕}ѡɥ((ѥ͕̀ѥ}͹͡С}չ}չ̤(ɽЀAѠ}}}|ɕͽٔɕlt((}ѠȤ(ɕɸɽЀѠ}((ɥѕɥ}}͕}ɥѕɥ}}ɍlɥѕɥt(مՕ}͔ɥѕɥ}}lɍ}مՕ}͔t(͕̀}ɥ}}ѥl̉t(ՅɑɅ͕̀}ɥ}}ѥlՅɑɅ̉t(͕ɥ}ѕ̀ѕlѕ}t聥ѕȁѕ͕ɥl͕ɥ}ѕхѥ}ѕ̉u(مՕ}ѕ̀l((ѕ}耉ɍ}مՕ}͕}ͥ̈(耉 ɍمՔ͔ͥ̈(ݹȈ耉ݹȈ(ͽɍ̈lĽɍ}ɕ̽ѕЈ̽ɍ}ɕ̹t(٥}耉}Օ}}͹͡Ј(ѥ}хє耉ɕ䈁مՕ}͕lх̉ẗ͔݅ɹ(٥مՕ}͕l٥t(ѥ耉U͔ɍɕ́́ѡمՔ͔͕ݥѡЁɕ͕ѥЁ́مՅѥՅɅѕ(}ɥѕɥ耉 ȁ͕́ѡ-I\хɝЁ́ɕ٥܁ȰЁ́ՅɅѕمՅѥ(((ѕ}耉}ѥ}٥(耉1ѥ́٥(ݹȈ耉AɽՍЁѥ́ݹȈ(ͽɍ̈lĽѥ}͹̽͡ѕЈ̽ѥ}t(٥}耉ɕ}(ѥ}хє耉ɕ䈰(٥耠(ѥ}}ѥlѥ}}ѥtРمՔ쀈(Ʌ}ѕ}ݽɭ}ɅєlɅ}ѕ}ݽɭ}ɅєtРمՕ}ɍМ쀈(}ͅ}ɽѥ}Ʌєl}ͅ}ɽѥ}ɅєtРمՕ}ɍМ쀈(ɽ٥}፱ͥ}}ɅєՅɑɅlɽ٥}፱ͥ}}ɅєtРمՔ((ѥ耉U͔ɕѥɅ䰁ɽ٥ȵͅ䁵ɥ́́٥䁙ȁѡ́ɽѽ(}ɥѕɥ耉 ȁչх́ѡ͔ɔɕ̰ͥЁɽՍѥɕٕՔȁѽȁ̸ͅ(((ѕ}耉}٥}Ј(耉 ȁ٥Ј(ݹȈ耉٥ݹȈ(ͽɍ̈l(Ľɍ}٥}̽ѕЈ(Ľɍ}͕ɥ}ѕхѥ̽ѕЈ(̽ɍ}٥}й(t(٥}耉ɕͥѽ}}չѥ}ѥЈ(ѥ}хє耉ɕ䈁}̽ɍ}٥}й͔(٥耠(ɍ}}хl}х̝u쀈(͕ɥ}ѕхѥ}х͕ɥl͕ɥ}ѕхѥ}х̝u((ѥ耉AمՔ٥ݥѠЁ͕ɥ䁅ѕхѥ́ѡȁфɽ(}ɥѕɥ耉 ȁɅ́Ѽչѥ́ɕѥ̸(((ѕ}耉ɥ}}Ʌѥ(耉AɥɅѥ(ݹȈ耉ݹȈ(ͽɍ̈l(̽ɍ}ɕ̹(̽ɍ}ͅ}ͥ(̽ɍ}ɽɕ}ɕ̹(̽ɍ}مՕ}ɕ̹(t(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ((}Ѡ(ȁѠ(̽ɍ}ɕ̹(̽ɍ}ͅ}ͥ(̽ɍ}ɽɕ}ɕ̹(((͔(٥耉 ɍɕ̰ͅ䰁ɽɕЁյ́ȁѡɅѥ(ѥ耉-ѡ-I\ɅѥѥѼA$ѥ䰁٥ɽɕ䰁Ցа͕ɥ䰁Ʌѥ́ɕ̸(}ɥѕɥ耉 ȁЁݡɽՍЁѥ́ЁѡɅѥ(((ѕ}耉ɽ}}̈(耉I=$̈(ݹȈ耉 ȁͽȁݹȈ(ͽɍ̈lȁI=$ѽȁ͍ٕ䈰ɽɕЁمՔ͔t(٥}耉}}ɕեɕ(ѥ}хє耉݅ɹ(ͽɍ}}х̈耉}}}ɕեɕ(٥耉 ȵ͕аݽɭ܁ٽյɽȽɕݽɬааѥͅ٥յѥ́ɔЁɕ̸(ѥ耉 Ёȁ͕ɥ́ѡѼA$ѥ䰁ɅՑаɕ䰁Ʌѥ́ͅ٥̸(}ɥѕɥ耉 ȁ́ѡI=$́ȁɭ́ѡٕ݅ȁѡɍɕ٥ܸ(((ѕ}耉ɕɕ}ѽ}}͕}Ց䈰(耉Iɕѽȁȁɽ(ݹȈ耉ݹȈ(ͽɍ̈lɕɕѽȈ͔Ց䈰ЁɕձЉt(٥}耉ѕɹ}مՕ}ɽ}ɕեɕ(ѥ}хє耉݅ɹ(ͽɍ}}х̈耉ѕɹ}مՕ}ɽ}ɕեɕ(٥耉IɕѽȰаȁɽՍѥɽ́ѕɹѼѡɕɽѽ(ѥ耉хɕɕЁɕձаȁЁȁٕ݅ȁɔɕѥѡمՔ͔́ѕɹɽٕ(}ɥѕɥ耉 ȁ́ѡɕɕɽЁɕձаȁٕ݅ȸ(((ѕ}耉ɽɕ}Ց}ݹȈ(耉AɽɕЁՑЁݹȈ(ݹȈ耉 ȁͽȁɽɕЁݹȈ(ͽɍ̈lȁɑȁɴɽɕЁɽ̈ՑЁɽمt(٥}耉}}ɕեɕ(ѥ}хє耉݅ɹ(ͽɍ}}х̈耉}}}ɕեɕ(٥耉 ՑЁݹȰɽمѠɑȵɴѡɥ䁅ɔȵ̸(ѥ耉%ѥͽȰՑЁݹȰɽɕЁѠɑȵɴѡɥ丈(}ɥѕɥ耉 ȁɵ́ѡՑЁݹȁɽمѠȁѡ-I\ɕ٥ܸ(((ѕ}耉хѥ}剅}յѥ(耉%хѥ剅յѥ(ݹȈ耉 ȁͽȁɑݹȈ(ͽɍ̈lȁɑхѥѥєɅѥ́t(٥}耉}}ɕեɕ(ѥ}хє耉݅ɹ(ͽɍ}}х̈耉}}}ɕեɕ(٥耉%хѥѥхչ䁍а剅ݥ܁ȁ嵕Ё͍(ѥ耉ѥєхѥЁ剅ݥ܁ɥɑȁȁ(}ɥѕɥ耉 ȁ́ѡ剅յѥ́ȁɭ́ѡЁ͍(((ѕ}耉ɕ٥}ɽ}䈰(耉I٥܁ɽ́䈰(ݹȈ耉ݹȈ(ͽɍ͕̈ɥ}ѕlɕ٥}ɽ}ulͽɍ̉t(٥}͕ɥ}ѕlɕ٥}ɽ}ul٥}t(ѥ}хє͕ɥ}ѕlɕ٥}ɽ}ulѥ}хєt(٥͕ɥ}ѕlɕ٥}ɽ}ul٥t(ѥ͕ɥ}ѕlɕ٥}ɽ}ulѥt(}ɥѕɥ͕ɥ}ѕlɕ٥}ɽ}ul}ɥѕɥt(((ѕ}耉}ͥ(耉Aͥ(ݹȈ͕ɥ}ѕl}ͥulݹȉt(ͽɍ͕̈ɥ}ѕl}ͥulͽɍ̉t(٥}͕ɥ}ѕl}ͥul٥}t(ѥ}хє͕ɥ}ѕl}ͥulѥ}хєt(٥͕ɥ}ѕl}ͥul٥t(ѥ͕ɥ}ѕl}ͥulѥt(}ɥѕɥ͕ɥ}ѕl}ͥul}ɥѕɥt((t(хѕ}չ̀ չѕȡѕlѥ}хєtȁѕمՕ}ѕ̤(ɕѕ}͕̀ɥlɕѕ}̉t(}չЀхѕ}չ̹Рɕѕ}̤(݅ɹ}չЀхѕ}չ̹Р݅ɹ(}}}չЀմ((ȁѕمՕ}ѕ(ѕРͽɍ}}х̈쉉}}}ɕեɕѕɹ}مՕ}ɽ}ɕեɕ((ѕɹ}مՕ}ɽ}}չЀմ(āȁѕمՕ}ѕ́ѕРͽɍ}}х̈􀉕ѕɹ}مՕ}ɽ}ɕեɕ((}չ(مՕ}х̀􀉍ɍ}مՕ}(݅ɹ}չ(مՕ}х̀􀉍ɍ}مՕ}ɕ}ݥѡ}݅ɹ̈(͔耀Ʌ聹ٕȀչɕݡѡ́ɕЁɥ́ѕɅȵ݅ɹ͕ѥ(مՕ}х̀􀉍ɍ}مՕ}ɕ䈀Ʌ聹ٕ((ɕɸ(مՕ}х̈مՕ}х̰(хɝ}Ʌ}مՕ}܈хɝ}Ʌ}مՕ}ܰ(хɝ}Ʌ}مՕ}聘-I\хɝ}Ʌ}مՕ}(ɕ}х̈耉}ɍ}مՕ}ɕ̈(ͽɍ}є耠( ɍمՔɕ͕́Ʌѕ́ɕɕ٥ɽȵ(I=$ɕɕՑа剅쁥Ё́ЁمՅѥՅɅѕɍ͔(ѵаɕٕՔɽȁ٥((مՕ}յ(ѕ}չЈ聱مՕ}ѕ̤(ɕ}չЈхѕ}չ̹Рɕ䈰(݅ɹ}չЈ݅ɹ}չа(}չЈ聉}չа(}}}չЈ聉}}}չа(ѕɹ}مՕ}ɽ}}չЈ聕ѕɹ}مՕ}ɽ}}չа(ɕ٥}ɽ}}Ȉ͕ɥlɕ٥}ɽ}ul}ȉt((مՕ}ѕ̈مՕ}ѕ̰(ɕѕ}̈聍ɕѕ}̰(مՕ}х}ձ̈l((مՕ}х̈耉ɍ}مՕ}ɕ䈰(ձ耉ɍمՔ͔ѥ̰٥аɥɅѥI=$̰ɕɕɽՑЁݹȰ剅յѥ̰ɕ٥܁䰁٥ɔɕ䈰(((مՕ}х̈耉ɍ}مՕ}ɕ}ݥѡ}݅ɹ̈(ձ耉ɕمՔ٥́ɕݡȁI=$̰ɕɕɽՑЁݹȰȁ剅յѥ́ɕЁ݅ɹ̈(((مՕ}х̈耉ɍ}مՕ}(ձ耉ͥمՔЁ٥ɕєɽՍЁаA$ɅЁɔյЁ͵э͕ɥ䁙ɔȁ Ё́ͅمՔɕ̈((t(ɕ٥}ɽ}͕ɥlɕ٥}ɽ}t(ɕѕ}չѥ}ɕ̈(ɍ}͕ɥ}ѕхѥ}х͕̈ɥl͕ɥ}ѕхѥ}х̉t(ɍ}}х̈聕l}х̉t(ɍ}х̈聍ɍlɍ}х̉t(͕ɥlɕѕ}չѥ}ɕ̉t((Ʌ}}͕ͥɥlɅ}}ͥt(՝}Ʌ͕ɥl՝}Ʌt(مՕ}̈(}ͥ}耉輽ܹͥi5]!Ii9](}ɐ耉輽ܹɐ]5M!!MA4(չѥ}Ј耈Ľɍ}مՕ}ɕ̽ѕЈ(յхѥ耉̽ɍ}مՕ}ɕ̹((((ɍ}͕}ɕ}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(ɕ͕}ѡɥ5mȰt99(mȰt(Iɸѡȵ͔єٕȁɍɕ́٥(مՔ͕ɍ}مՕ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ(ɕ͕}ѡɥɕ͕}ѡɥ((͕ɥ͕ɍ}͕ɥ}ѕхѥ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ(ɕ͕}ѡɥɕ͕}ѡɥ((ɅЀ͕ɍ}Ʌ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ(ɕ͕}ѡɥɕ͕}ѡɥ((ɑ͕ɍ}ɑ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ(ɕ͕}ѡɥɕ͕}ѡɥ((Ʌѥ͕̀ɍ}Ʌѥ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ(ɕ͕}ѡɥɕ͕}ѡɥ((Ѐ͕ɍ}٥}}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ɽЀAѠ}}}|ɕͽٔɕlt((}ѠȤ(ɕɸɽЀѠ}((ɕѕ}̀l(مՕlɕѕ}̉t(͕ɥlɕѕ}̉t(Ʌlɕѕ}̉t(ɑlɕѕ}̉t(Ʌѥlɕѕ}̉t(lɕѕ}̉t(t(ɕѕ}̀􁱥Сйɽ̡ɕѕ}̤(͕}ѕ̀l((ѕ}耉͕}ɽՍ}Ј(耉MɽՍЁЈ(ݹȈ耉ݹȈ(ͽɍ̈l(Ľɍ}مՕ}ɕ̽ѕЈ(Ľɍ}͕ɥ}ѕхѥ̽ѕЈ(Ľɍ}٥}̽ѕЈ(̽ɍ}مՕ}ɕ̹(̽ɍ}͕ɥ}ѕхѥ(̽ɍ}٥}й(t(٥}耉ɕͥѽ}}չѥ}ѥЈ(ѥ}хє耉ɕ(مՕlمՕ}х̉t􀉍ɍ}مՕ}(͕ɥl͕ɥ}ѕхѥ}х̉t􀉍ɍ}͕ɥ}ѕхѥ}(l}х̉t􀉍ɍ}}(}̽ɍ}مՕ}ɕ̹(}̽ɍ}͕ɥ}ѕхѥ(}̽ɍ}٥}й(͔(٥耠(مՕ}хمՕlمՕ}х̝u쀈(͕ɥ}ѕхѥ}х͕ɥl͕ɥ}ѕхѥ}х̝u쀈(ɍ}}хl}х̝u((ѥ耉хѡɕɽՍа͕ɥ䰁مՔ٥ЁЁѼȁ͔ɕ٥ܸ(}ɥѕɥ耉 ȁЁѡ͕ЁݥѡЁɕѥЁ́ɍ͔ѵЁȁمՅѥՅɅѕ(((ѕ}耉Ʌ}͕}Ј(耉 ɅЁ͔Ј(ݹȈ耉1ɽɕЁݹȈ(ͽɍ̈l(Ľɍ}Ʌ}ɕ̽ѕЈ(̽ɍ}Ʌ}ɕ̹(̽ɍ}ɽɕ}ɕ̹(t(٥}耉ɕͥѽ}}չѥ}ѥЈ(ѥ}хє耉ɕ(ɅlɅ}х̉t􀉍ɍ}Ʌ}(}̽ɍ}Ʌ}ɕ̹(͔(٥聘Ʌ}х퍽ɅlɅ}х̝u(ѥ耉U͔ɅЁɕ́́ѡɽɕЁЁɅͥɕ͕́Ʌѕ丈(}ɥѕɥ耉 ȁɽɕЁ͕́ɅЁ٥ѡɕͥɔ̸(((ѕ}耉ɑ}Ʌѥ}Ј(耉=ɑɅѥ́Ј(ݹȈ耉 ѽȁՍ́љɴݹȈ(ͽɍ̈l(Ľɍ}ɑ}ɕ̽ѕЈ(Ľɍ}Ʌѥ}ɕ̽ѕЈ(̽ɍ}ɑ}ɕ̹(̽ɍ}Ʌѥ}ɕ̹(t(٥}耉ɕͥѽ}}չѥ}ѥЈ(ѥ}хє耉ɕ(ɑlɑ}х̉t􀉍ɍ}ɑ}(ɅѥlɅѥ}х̉t􀉍ɍ}Ʌѥ}(}̽ɍ}ɑ}ɕ̹(}̽ɍ}Ʌѥ}ɕ̹(͔(٥耠(ɑ}хɑlɑ}х̝u쀈(Ʌѥ}хɅѥlɅѥ}х̝u((ѥ耉хɑɅѥ́ɕ́́ѡٔЁи(}ɥѕɥ耉 ȁѥ䁥хѥаɅѥ̰хݹ̸(((ѕ}耉}٥}}Ј(耉 ȁ٥ЁЈ(ݹȈ耉٥ݹȈ(ͽɍ̈l(Ľɍ}٥}̽ѕЈ(̽ɍ}٥}й(̽}ѥ̹(t(٥}耉ɕͥѽ}}չѥ}ѥЈ(ѥ}хє耉ɕ(l}х̉t􀉍ɍ}}(}̽ɍ}٥}й(}̽}ѥ̹(͔(٥聘ɍ}}хl}х̝u(ѥ耉U͔ѡхЁЁ́ѡȁфɽจ(}ɥѕɥ耉 ȁɅ͔٥Ѽչѥ̰̰)ѥ̸(((ѕ}耉ͥ}ɑ}ɵ}̈́(耉Mɑȁɴȁ5M(ݹȈ耉 ȁͽȰɽɕЁݹȰݹȈ(ͽɍ̈lȁɑȁɴ5MͥɔЉt(٥}耉}ͥɕ}ɕեɕ(ѥ}хє耉݅ɹ(ͽɍ}}х̈耉}ͥɕ}ɕեɕ(٥耉Mɑȁɴ5Mɍѕɵ̰ѡɥ䁍ɵѥɔȵ̸͔ͥ(ѥ耉 Ёͥɑȁɴȁ5MȁхЁȁٕ݅ȸ(}ɥѕɥ耉 ȁ͕ȁͥɔѡɥ䁅Ёѡɑȁɴȁ5M(((ѕ}耉}͕ɥ}х(耉A͕ɥ䁅х(ݹȈ耉 ȁ͕ɥ䰁ɥم䰁ݹȈ(ͽɍ̈lȁA͕ɥɕ٥܁хɥمՕѥɔt(٥}耉}ͥɕ}ɕեɕ(ѥ}хє耉݅ɹ(ͽɍ}}х̈耉}ͥɕ}ɕեɕ(٥耉A͕ɥ䁅хɥمՕѥɔѕхѥٕ݅́ɔȵ̸͔(ѥ耉 ЁA͕ɥ䁅хȁյѕٕ݅ȁɽȁ͕ɥ䁅ɕ٥ݕ̸(}ɥѕɥ耉 ȁͥ́ȁٕ݅́A͕ɥ䁅хɕեɕ̸(((ѕ}耉Ց}ɽم}ɍ͕}ɑȈ(耉 ՑЁɽمɍ͔ɑȈ(ݹȈ耉 ȁɽɕЁݹȈ(ͽɍ̈lՑЁɽمɍ͔ɑȈɽمt(٥}耉}ͥɕ}ɕեɕ(ѥ}хє耉݅ɹ(ͽɍ}}х̈耉}ͥɕ}ɕեɕ(٥耉 ՑЁɽمɍ͔ɑȰѡɥ䁅ɔѕɹȁɽɕЁ٥(ѥ耉 ЁȁՑЁɽمA<ȁхɽٕѕɹѥٔ嵕Ёѡɥ丈(}ɥѕɥ耉 ȁɽɕЁɵ́ՑЁѡɥ䁅嵕ЁѠȁ-I\(((ѕ}耉}ٕ}ѡɥѥ(耉ٔѡɥѥ(ݹȈ耉 ȁͥ́ͽȁхѥݹȈ(ͽɍ̈lٔɽمхѥѡɥѥхͥt(٥}耉}ͥɕ}ɕեɕ(ѥ}хє耉݅ɹ(ͽɍ}}х̈耉}ͥɕ}ɕեɕ(٥耉ٔѡɥѥхѥхɕեɔȁɽم(ѥ耉 ЁٔѡɥѥȁɬɽՍѥѥمѥЁ͍ȁѡͥ(}ɥѕɥ耉 ȁѡɥ́ٔɑȁ͍еͥɔхѥ(((ѕ}耉ɕ٥}ɽ}䈰(耉I٥܁ɽ́䈰(ݹȈ耉ݹȈ(ͽɍ̈l̽ɍ}ͅ}ͥ̽ɍ}͕}ɕ̹t(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ䈰(٥耉I٥܁ɽ́䁥́Ё͔ȁչ́ɕєɽՍа͕ɥ䰁A$ɅаȁյЁɔ́ɽՍ(ѥ耉-ɍ͔ݽɬ٥ݡՕՕɕ٥܁ɽ͕́ɔ(}ɥѕɥ耉=䁍ɕєɕ͔́ɕ̸(((ѕ}耉}ͥ(耉Aͥ(ݹȈ耉AɽɕЁ͕ɥɕ٥ݕȈ(ͽɍ̈l̽Ʌ}ɕ͕ɍ̽ɍ}՝}Ʌѥ}t(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ(مՕlɅ}}ͥulͥt􀉭}ͥ}ɽՍЈ(͔݅ɹ(٥مՕlɅ}}ͥulɕͽt(ѥ耉-光ѕɥ͔ɽɽՍЁչѥɅѥɥ́ɔɕ(}ɥѕɥ耉Ёɕє͕ɅєɅ䰁ЁՉձȁɅѕȁѡ͔́є((t(хѕ}չ̀ չѕȡѕlѥ}хєtȁѕ͕}ѕ̤(}չЀхѕ}չ̹Рɕѕ}̤(݅ɹ}չЀхѕ}չ̹Р݅ɹ(}ͥɕ}}չЀմ(āȁѕ͕}ѕ́ѕРͽɍ}}х̈􀉉}ͥɕ}ɕեɕ((}չ(͕}х̀􀉍ɍ}͕}(݅ɹ}չ(͕}х̀􀉍ɍ}͕}ɕ}ݥѡ}݅ɹ̈(͔耀Ʌ聹ٕȀչɕݡѡ́ɕЁɥ́ѕɅȵ݅ɹ͕ѥ(͕}х̀􀉍ɍ}͕}ɕ䈀Ʌ聹ٕ((ɕɸ(͕}х̈聍͕}х̰(хɝ}Ʌ}مՕ}܈хɝ}Ʌ}مՕ}ܰ(хɝ}Ʌ}مՕ}聘-I\хɝ}Ʌ}مՕ}(ɕ}х̈耉}ɍ}͕}ɕ̈(ͽɍ}є耠( ɍ͔ɕ͕́Ʌѕ́ɕ͕ɽՍЁ٥ɽȀ(ͥɔɽɕа͕ɥ䁅хٔѡɥѥ쀈(Ё́ЁمՅѥՅɅѕɍ͔ѵаͥɑȰ(ȁɽՍѥѥє((͕}յ(ѕ}չЈ聱͕}ѕ̤(ɕ}չЈхѕ}չ̹Рɕ䈰(݅ɹ}չЈ݅ɹ}չа(}չЈ聉}չа(}ͥɕ}}չЈ聉}ͥɕ}}չа(ɕ٥}ɽ}}ȈمՕlɕ٥}ɽ}ul}ȉt((͕}ѕ̈聍͕}ѕ̰(ɕѕ}̈聍ɕѕ}̰(͕}х}ձ̈l((͕}х̈耉ɍ}͕}ɕ䈰(ձ耉͕ɽՍЁаɅЁаɑɅѥ́а٥аͥɕ̰A͕ɥ䁅хՑнA<ٔѡɥѥɕ٥܁䰁٥ɔɕ䈰(((͕}х̈耉ɍ}͕}ɕ}ݥѡ}݅ɹ̈(ձ耉ɕ͔Ё́ɕݡȁͥɕ̰A͕ɥ䁅хՑнA<ȁٔѡɥѥɕЁ݅ɹ̈(((͕}х̈耉ɍ}͕}(ձ耉͔ͥ٥ɕєɽՍЁаA$ɅЁɔյЁ͵э͕ɥ䁙ɔȁ Ё͔́ͅɕ̈((t(ɕ٥}ɽ}مՕlɕ٥}ɽ}t(ɕѕ}չѥ}ɕ̈(ɍ}مՕ}х̈مՕlمՕ}х̉t(ɍ}͕ɥ}ѕхѥ}х͕̈ɥl͕ɥ}ѕхѥ}х̉t(ɍ}Ʌ}х̈聍ɅlɅ}х̉t(ɍ}ɑ}х̈聽ɑlɑ}х̉t(ɍ}Ʌѥ}х̈聽ɅѥlɅѥ}х̉t(ɍ}}х̈聕l}х̉t(مՕlɕѕ}չѥ}ɕ̉t((Ʌ}}ͥمՕlɅ}}ͥt(՝}ɅمՕl՝}Ʌt(͕}̈(}ͥ}耉輽ܹͥi5]!Ii9](}ɐ耉輽ܹɐ]5M!!MA4(չѥ}Ј耈Ľɍ}͕}ɕ̽ѕЈ(յхѥ耉̽ɍ}͕}ɕ̹((((ɍ}}ѽ}ɭ}ɕ}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(ɕ͕}ѡɥ5mȰt99(mȰt(IɸȵQ4ɕٕ́ȁɍ٥(͔͕ɍ}͕}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ(ɕ͕}ѡɥɕ͕}ѡɥ((مՔ͕ɍ}مՕ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ(ɕ͕}ѡɥɕ͕}ѡɥ((͕ɥ͕ɍ}͕ɥ}ѕхѥ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ(ɕ͕}ѡɥɕ͕}ѡɥ((Ѐ͕ɍ}٥}}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((͕ɍ}}չ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((͕ͅͅ}ͥ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ѥ͕̀ѥ}͹͡С}չ}չ̤(ɽЀAѠ}}}|ɕͽٔɕlt((}ѠȤ(ɕɸɽЀѠ}((ɕѕ}̀l(͕lɕѕ}̉t(مՕlɕѕ}̉t(͕ɥlɕѕ}̉t(lɕѕ}̉t(ͅlɕѕ}̉t(t(ɕѕ}̀􁱥Сйɽ̡ɕѕ}̤(ѵ}ѕ̀l((ѕ}耉ɍ}͕}Ј(耉 ɍ͔Ј(ݹȈ耉ݹȈ(ͽɍ̈lĽɍ}͕}ɕ̽ѕЈ̽ɍ}͕}ɕ̹t(٥}耉ɕͥѽ}}չѥ}ѥЈ(ѥ}хє耉ɕ(͕l͕}х̉t􀉍ɍ}͕}(}̽ɍ}͕}ɕ̹(͔(٥聘͕}х퍱͕l͕}х̝u(ѥ耉U͔͔ɕ́́ѡȵɕ́и(}ɥѕɥ耉 ȁ͕͔́Ёх́ɕȵͥͥɔ̸(((ѕ}耉}مՕ}Ј(耉مՔЈ(ݹȈ耉ݹȁѥ́ݹȈ(ͽɍ̈l(Ľɍ}مՕ}ɕ̽ѕЈ(Ľѥ}͹̽͡ѕЈ(̽ɍ}مՕ}ɕ̹(̽ѥ}(t(٥}耉ɕͥѽ}}չѥ}ѥЈ(ѥ}хє耉ɕ(مՕlمՕ}х̉t􀉍ɍ}مՕ}(}̽ɍ}مՕ}ɕ̹(}̽ѥ}(͔(٥耠(مՕ}хمՕlمՕ}х̝u쀈(}չѥl̝t쁝ՅɑɅ}չѥlՅɑɅ̝t((ѥ耉M܁مՔ٥ݥѠɕٕ́ȵɥ͕Ʌѥ(}ɥѕɥ耉 ȁЁمՔ́ݥѡЁɕѥѡ́ɕٕՔɽȁ٥(((ѕ}耉͕ɥ}}Ј(耉MɥЁЈ(ݹȈ耉Mɥ䁽ݹȈ(ͽɍ̈l(Ľɍ}͕ɥ}ѕхѥ̽ѕЈ(̽ɍ}͕ɥ}ѕхѥ(M UI%Qd(t(٥}耉ɕͥѽ}}չѥ}ѥЈ(ѥ}хє耉ɕ(͕ɥl͕ɥ}ѕхѥ}х̉t􀉍ɍ}͕ɥ}ѕхѥ}(}̽ɍ}͕ɥ}ѕхѥ(}M UI%Qd(͔(٥聘͕ɥ}ѕхѥ}х͕ɥl͕ɥ}ѕхѥ}х̝u(ѥ耉U͔͕ɥ䁅ѕхѥ́ѡȁЁЁѕɹѕхѥ͕́Ʌє(}ɥѕɥ耉 ȁЁ͕ɥ䁍ɽ́ѕɹѕхѥ̸(((ѕ}耉}٥}Ј(耉 ȁ٥Ј(ݹȈ耉٥ݹȈ(ͽɍ̈l(Ľɍ}٥}̽ѕЈ(Ľɍ}}չ̽ѕЈ(̽ɍ}٥}й(̽ɍ}}}չ(t(٥}耉ɕͥѽ}}չѥ}ѥЈ(ѥ}хє耉ɕ(l}х̉t􀉍ɍ}}(lչ}х̉t􀉉}}(}̽ɍ}٥}й(}̽ɍ}}}չ(͔(٥聘ɍ}}хl}х̝u쁉}}хlչ}х̝u(ѥ耉х٥Ёչ́ѡȁфɽจ(}ɥѕɥ耉 ȁɅQ4́Ѽչѥ̰̰ѕ̰ѥ̸(((ѕ}耉ͅ}ͥ}Ј(耉M䁑ͥЈ(ݹȈ耉ݹȈ(ͽɍ̈lĽͅ}ͥ̽ѕЈ̽ɍ}ͅ}ͥt(٥}耉ɕͥѽ}}չѥ}ѥЈ(ѥ}хє耉ɕ(ͅlͅ}х̉tͅ}(}̽ɍ}ͅ}ͥ(͔(٥聘ͅ}хͅlͅ}х̝u(ѥ耉U͔ͅ䁑ͥ́ѡQ4͕(}ɥѕɥ耉 ȁхȁɕ٥܁ѥե݅͠ɹ́ɽɕє̸(((ѕ}耉}Ʌѽ}٥(耉Ʌѽȁ٥(ݹȈ耉AɽՍЁͥݹȈ(ͽɍ̈lѕՅ}ɍɅѽȽ䈰͍̽ɕ}ͥt(٥}耉ɕͥѽ}}չѥ}ѥЈ(ѥ}хє耉ɕ(}ѕՅ}ɍɅѽȽ䈤}͍̽ɕ}ͥ(͔(٥耉ə͕́ɕ́х̰ͽɍѕ̰ɕЁх̰݅ɹȁյɥ̸(ѥ耉U͔ѡѥ͕مəѕɕѥ͕Ʌє́͡ͅɐ(}ɥѕɥ耉=ɅѽȁЁQ4ɕ́ɽѡɕЁə(((ѕ}耉ѥ}ѡձ}Ј(耉ѥ́ѡձ́Ј(ݹȈ耉фѥ́ݹȈ(ͽɍ̈l̽ѥ}Ľѥ}͹̽͡ѕЉt(٥}耉ɕͥѽ}}չѥ}ѥЈ(ѥ}хє耉ɕ䈁}̽ѥ}͔(٥耉ѥ͕́Ʌѕ́ɕ٥ɽɽ͕ɽՍѥȁȵ̸(ѥ耉-Q4ɥ́ɽɽՍѥɕٕՔͥȁɽȁչɕѕ丈(}ɥѕɥ耉Mх͕́ݡ-A$́ɔɕݡɔɽ̸͕(((ѕ}耉х}ѥ}Ј(耉Mхȁѥ́Ј(ݹȈ耉AɽՍЁͥݹȈ(ͽɍ̈l(̽}ѥ̹(輽ܹͥi5]!Ii9](輽ܹɐ]5M!!MA4(t(٥}耉}ѥЈ(ѥ}хє耉ɕ䈁}̽}ѥ̹͔(٥耉х)хȁѥ́ɔɕɑ Ё́፱Ց(ѥ耉U͔ххȁѥ́ȁQ4ɕ٥܁ѕ͍ɕ͡е䁕٥(}ɥѕɥ耉Mх́ѡͥ)ɐȁQ4ɕ٥ܸ(((ѕ}耉}ͥɕ}Ց}}(耉 ȁͥɔՑЁܵ(ݹȈ耉 ȁͽȰɽɕЁݹȰݹȈ(ͽɍ̈lȁɑȁɴ5MA͕ɥ䁅хɍ͔ɑȈٔɽمt(٥}耉}}ɕեɕ(ѥ}хє耉݅ɹ(ͽɍ}}х̈耉}ͥɕ}ɕեɕ(٥耠(}ͥɕ}}չ퍱͕l͕}յul}ͥɕ}}չНu쀈(ͥɑȽ5MA͕ɥ䁅хՑнA<ٔѡɥѥɔȁ̸((ѥ耉 Ёȁͥɕ̰ɽم̰ȁٕ݅́ɔɕɕ͕ѥѡЁ͕́ݽ(}ɥѕɥ耉 ȁ́ȁٕ݅́ͥɔՑа͕ɥ䁅х̸ٔ(((ѕ}耉ɽՍѥ}ѕɹ}ɽ}}(耉AɽՍѥѕɹɽܵ(ݹȈ耉Mɥ䰁Ʌѥ̰ݹȈ(ͽɍ̈lѕ͍Јѡɐ䁅ѕхѥɕɕɽɽՍѥѕt(٥}耉ѕɹ}}ɽՍѥ}}ɕեɕ(ѥ}хє耉݅ɹ(ͽɍ}}х̈耉ѕɹ}}ɽՍѥ}}ɕեɕ(٥耠(͕ɥ}݅ɹ}չ͕ɥl͕ɥ}ѕхѥ}յul݅ɹ}չНu쀈(مՕ}݅ɹ}չمՕlمՕ}յul݅ɹ}չНu쀈(}݅ɹ}չl}յul݅ɹ}չНu((ѥ耉хѕ͍ѡɐ䁅ѕхѥɕɕɽɽՍѥѕݡم(}ɥѕɥ耉 ȁ́ѕɹɽɽՍѥɽȁЁٕ݅ȸ(((ѕ}耉ɕ٥}ɽ}䈰(耉I٥܁ɽ́䈰(ݹȈ耉ݹȈ(ͽɍ̈l̽ɍ}}ѽ}ɭ}ɕ̹̽ɍ}ͅ}ͥt(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ䈰(٥耉I٥܁ɽ́䁥́ЁQ4ȁչ́ɕєɔ́ɽՍ(ѥ耉 ѥՔQ4ɕ́ݽɬݡՕՕɕ٥́ɔ(}ɥѕɥ耉=䁍ɕєɽՍа͕ɥ䰁A$ɅаȁյЁɕ́Q4ɕ̸(((ѕ}耉}ͥ(耉Aͥ(ݹȈ耉AɽɕЁ͕ɥɕ٥ݕȈ(ͽɍ̈l̽Ʌ}ɕ͕ɍ̽ɍ}՝}Ʌѥ}t(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ(͕lɅ}}ͥulͥt􀉭}ͥ}ɽՍЈ(͔݅ɹ(٥聍͕lɅ}}ͥulɕͽt(ѥ耉-光ѕɥ͔ɽɽՍЁչѥɅѥɥ́ɔɕ(}ɥѕɥ耉Ёɕє͕ɅєɅ䰁ЁՉձȁɅѕȁѡ́Q4є((t(хѕ}չ̀ չѕȡѕlѥ}хєtȁѕѵ}ѕ̤(}չЀхѕ}չ̹Рɕѕ}̤(݅ɹ}չЀхѕ}չ̹Р݅ɹ(}ͥɕ}}չЀ􁍱͕l͕}յul}ͥɕ}}չЉt(ѕɹ}}ɽՍѥ}}չЀ(͕ɥl͕ɥ}ѕхѥ}յulѕɹ}ѕхѥ}}չЉt(مՕlمՕ}յulѕɹ}مՕ}ɽ}}չЉt(l}յul݅ɹ}չЉt((}չ(ѵ}х̀􀉍ɍ}}ѽ}ɭ}(݅ɹ}չ(ѵ}х̀􀉍ɍ}}ѽ}ɭ}ɕ}ݥѡ}݅ɹ̈(͔耀Ʌ聹ٕȀչɕݡѡ́ɕЁɥ́ѕɅȵ݅ɹ͕ѥ(ѵ}х̀􀉍ɍ}}ѽ}ɭ}ɕ䈀Ʌ聹ٕ((ɕɸ(}ѽ}ɭ}х̈聝ѵ}х̰(хɝ}Ʌ}مՕ}܈хɝ}Ʌ}مՕ}ܰ(хɝ}Ʌ}مՕ}聘-I\хɝ}Ʌ}مՕ}(ɕ}х̈耉}ɍ}}ѽ}ɭ}ɕ̈(ͽɍ}є耠( ɍѼɭЁɕ́́ɕ͕ɽՍа٥(ѥ̰хȁѥ͕́Ʌѕ䁙ɽȁͥɕ̰(ѕɹɽɽՍѥѕ쁥Ё́ЁمՅѥՅɅѕɍ͔(ѵаͥɑȰɽՍѥѥєȁɕٕՔɽ((}ѽ}ɭ}յ(ѕ}չЈ聱ѵ}ѕ̤(ɕ}չЈхѕ}չ̹Рɕ䈰(݅ɹ}չЈ݅ɹ}չа(}չЈ聉}չа(}ͥɕ}}չЈ聉}ͥɕ}}չа(ѕɹ}}ɽՍѥ}}չЈ聕ѕɹ}}ɽՍѥ}}չа(ɕ٥}ɽ}}Ȉ聍͕lɕ٥}ɽ}ul}ȉt((}ѽ}ɭ}ѕ̈聝ѵ}ѕ̰(ɕѕ}̈聍ɕѕ}̰(}ѽ}ɭ}х}ձ̈l((}ѽ}ɭ}х̈耉ɍ}}ѽ}ɭ}ɕ䈰(ձ耉͔مՔ͕ɥ䰁٥ͅ䰁ѥ̰хȁѥ̰ȁ̰ѕɹɽɕ٥܁䰁٥ɔɕ䈰(((}ѽ}ɭ}х̈耉ɍ}}ѽ}ɭ}ɕ}ݥѡ}݅ɹ̈(ձ耉ɕQ4Ё́ɕݡȁͥɕ̰ՑнA<A͕ɥ䁅хɽՍѥѕ䰁ɕɕɽѕ͍ȁѡɐ䁅ѕхѥɕЁ݅ɹ̈(((}ѽ}ɭ}х̈耉ɍ}}ѽ}ɭ}(ձ耉ͥQ4Ё٥ɕєɽՍЁаA$ɅЁɔյЁ͵э͕ɥ䁙ɔȁ Ё́ͅQ4ɕ̈((t(ɕ٥}ɽ}聍͕lɕ٥}ɽ}t(ɕѕ}չѥ}ɕ̈(ɍ}͕}х̈聍͕l͕}х̉t(ɍ}مՕ}х̈مՕlمՕ}х̉t(ɍ}͕ɥ}ѕхѥ}х͕̈ɥl͕ɥ}ѕхѥ}х̉t(ɍ}}х̈聕l}х̉t(}}х̈聡lչ}х̉t(ͅ}х̈ͅlͅ}х̉t(͕lɕѕ}չѥ}ɕ̉t((Ʌ}}ͥ聍͕lɅ}}ͥt(՝}Ʌ聍͕l՝}Ʌt(}ѽ}ɭ}̈(}ͥ}耉輽ܹͥi5]!Ii9](}ɐ耉輽ܹɐ]5M!!MA4(չѥ}Ј耈Ľɍ}}ѽ}ɭ}ɕ̽ѕЈ(յхѥ耉̽ɍ}}ѽ}ɭ}ɕ̹((((ɍ}չ}ɕ}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(ɕ͕}ѡɥ5mȰt99(mȰt(Iɸѡȁչɥɕ́єٕȁɍ٥(Ѵ͕ɍ}}ѽ}ɭ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ(ɕ͕}ѡɥɕ͕}ѡɥ((Ʌѥ͕̀ɍ}Ʌѥ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ(ɕ͕}ѡɥɕ͕}ѡɥ((ɑ͕ɍ}ɑ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ(ɕ͕}ѡɥɕ͕}ѡɥ((х͕ɍ}х}}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ѥ͕̀ѥ}͹͡С}չ}չ̤(}хє͕}хє(ɽЀAѠ}}}|ɕͽٔɕlt((}ѠȤ(ɕɸɽЀѠ}((ɕѕ}̀l(ѵlɕѕ}̉t(Ʌѥlɕѕ}̉t(ɑlɕѕ}̉t(хlɕѕ}̉t(t(ɕѕ}̀􁱥Сйɽ̡ɕѕ}̤(չ}ѕ̀l((ѕ}耉}ѽ}ɭ}Ј(耉ѼɭЁЈ(ݹȈ耉ݹȈ(ͽɍ̈l(Ľɍ}}ѽ}ɭ}ɕ̽ѕЈ(̽ɍ}}ѽ}ɭ}ɕ̹(t(٥}耉ɕͥѽ}}չѥ}ѥЈ(ѥ}хє耉ɕ(ѵl}ѽ}ɭ}х̉t􀉍ɍ}}ѽ}ɭ}(}̽ɍ}}ѽ}ɭ}ɕ̹(͔(٥聘}ѽ}ɭ}хѵl}ѽ}ɭ}х̝u(ѥ耉U͔ѡQ4Ё́ѡչɥ䁕٥(}ɥѕɥ耉 ȁЁѡչЁݥѡЁɕѥЁ́ͥȁɽՍѥɽ(((ѕ}耉չѥ}չ}Ѡ(耉IչѥչѠ(ݹȈ耉AљɴɅѽȈ(ͽɍ̈l(I5(ѕՅ}ɍɅѽȽ͕ٕȹ䈰(ѕՅ}ɍɅѽȽ}Ʌй䈰(̽ɕ}}ͥ(Ľнѥ̈((t(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ((}Ѡ(ȁѠ(I5(ѕՅ}ɍɅѽȽ͕ٕȹ䈰(ѕՅ}ɍɅѽȽ}Ʌй䈰(̽ɕ}}ͥ(((͔(٥耉Mё͕ٕȰ=$ѥаͽIMPɅЁɔɕ͕и(ѥ耉Iոѡѥ͕ٕȁA$͵ѕ́ȁȁɥ͕(}ɥѕɥ耉 ȁхЁѡչѥѡѥє̰Ёչɕ́)M=8(((ѕ}耉х}ѕ}Ј(耉хѕЁЈ(ݹȈ耉Qɕ٥ݕȈ(ͽɍ̈l(Ľɍ}х}̽ѕЈ(ѕ̽ѕ}ɍ}х}䈰(ѕ̽ѕ}ɍ}}ѽ}ɭ}ɕ̹䈰(ѕ̽ѕ}ɍ}չ}ɕ̹䈰(ѕЀĈ(t(٥}耉ɕ}(ѥ}хє耉ɕ(хlх}х̉t􀉍ɍ}х}((}Ѡ(ȁѠ(ѕ̽ѕ}ɍ}х}䈰(ѕ̽ѕ}ɍ}}ѽ}ɭ}ɕ̹䈰(ѕ̽ѕ}ɍ}չ}ɕ̹䈰(((͔(٥聘х}х텍хlх}х̝u(ѥ耉U͔͕хչѕ́́ѡٕɥѥи(}ɥѕɥ耉͕չQ4хA$ѥЁѕ́́ɔȁ(((ѕ}耉Ʌѽ}չ}Ј(耉=ɅѽȁչЈ(ݹȈ耉 ѽȁՍ́љɴݹȈ(ͽɍ̈l(Ľɍ}Ʌѥ}ɕ̽ѕЈ(Ľɍ}ɑ}ɕ̽ѕЈ(̽ɍ}Ʌѥ}ɕ̹(̽ɍ}ɑ}ɕ̹(t(٥}耉ɕͥѽ}}չѥ}ѥЈ(ѥ}хє耉ɕ(ɅѥlɅѥ}х̉t􀉍ɍ}Ʌѥ}(ɑlɑ}х̉t􀉍ɍ}ɑ}(}̽ɍ}Ʌѥ}ɕ̹(}̽ɍ}ɑ}ɕ̹(͔(٥耠(Ʌѥ}хɅѥlɅѥ}х̝u쀈(ɑ}хɑlɑ}х̝u((ѥ耉хɑɅѥ́ɕ́́ѡչչ(}ɥѕɥ耉 ȁ͕́хѥаѕ䰁ахݹ̸(((ѕ}耉}͕م}Ј(耉͕مЈ(ݹȈ耉AɽՍЁͥݹȈ(ͽɍ̈lхєѕՅ}ɍɅѽȽ䈰͍̽ɕ}ͥt(٥}耉ɕͥѽ}}չѥ}ѥЈ(ѥ}хє耉ɕ(}хѕl̉t}ѕՅ}ɍɅѽȽ䈤}͍̽ɕ}ͥ(͔(٥耠(}չ}хѕl̝t쀈(ə͕́չͽɍɕа݅ɹյɥ̸((ѥ耉U͔ѡɕЁ͕مəɅѡȁѡ͕Ʌє́͡ͅɐ(}ɥѕɥ耉=Ʌѽȁɕ٥܁չɕ́ɽѡѥͽ(((ѕ}耉}٥ɽ}̈(耉 ȁ٥ɽЁ̈(ݹȈ耉 ȁхѥݹȁљɴɅѽȈ(ͽɍ̈lȁ٥ɽЁUI0嵕Ёѽ䈰ѽфɕѕѥͥt(٥}耉}٥ɽ}ɕեɕ(ѥ}хє耉݅ɹ(ͽɍ}}х̈耉}٥ɽ}ɕեɕ(٥耉 ȁ嵕ЁUI0ѽ䰁ɕѥ́ɕѕѥݽɬ䁅ɔЁɕ٥(ѥ耉 Ёȁ٥ɽЁх́ȁхЁɥ̸͍ٕ݅(}ɥѕɥ耉 ȁɽ٥́٥ɽЁ́ȁɕ́ѡչ́ѕѼɕᕍѥ(((ѕ}耉ɽՍѥ}ѕ}̈(耉AɽՍѥѕ䁥̈(ݹȈ耉=Ʌѥ́ѥ́ݹȈ(ͽɍ̈l(Ľɍ}Ʌѥ}ɕ̽ѕЈ(Ľѥ}͹̽͡ѕЈ(ɽՍѥɕՕЁ̈(Ёɥɕɐ(ɕѽɔɽ(t(٥}耉ɽ͕}չѥ}ɽՍѥ(ѥ}хє耉݅ɹ(ͽɍ}}х̈耉ɽՍѥ}}ɕեɕ(٥耠(Ʌѥ}ɽՍѥ}٥}ѥ}չ(ɅѥlɅѥ}յulɽՍѥ}٥}ѥ}չНu쀈(ѥ}ɕ}х텹ѥlɕ}х̝u((ѥ耉 ɔɽՍѥѕ䰁M1<٥Ёɥɕѽɔɽѡȁ٥ɽи(}ɥѕɥ耉ЁɽՍѥѕ͹͡ЁɅѥ́ɽɔхȁѱٕ݅(((ѕ}耉ɍ}ͥɕ}̈(耉 ɍͥɔ̈(ݹȈ耉 ȁͽȰɽɕЁݹȰݹȈ(ͽɍ̈lͥɑȽ5MA͕ɥ䁅хɍ͔ɑȈٔѡɥѥt(٥}耉}ͥɕ}ɕեɕ(ѥ}хє耉݅ɹ(ͽɍ}}х̈耉}ͥɕ}ɕեɕ(٥耠(}ͥɕ}}չѵl}ѽ}ɭ}յul}ͥɕ}}չНu쀈(ͥɑȰA͕ɥ䁅хՑнA<ٔѡɥѥɔȁ̸((ѥ耉 Ёͥɕ̰ɽم̰ȁٕ݅́ɔɕɕ͕ѥչɕ͕́́ݽ(}ɥѕɥ耉 ȁ́ͥɔA͕ɥ䰁Ցа̸ٔ(((ѕ}耉ɕ٥}ɽ}䈰(耉I٥܁ɽ́䈰(ݹȈ耉ݹȈ(ͽɍ̈l̽ɍ}չ}ɕ̹̽ɍ}}ѽ}ɭ}ɕ̹t(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ䈰(٥耉I٥܁ɽ́䁥́Ёչȁչ́ɕєɔ́ɽՍ(ѥ耉 ѥՔչɕ́ݽɬݡՕՕɕ٥܁ɽ͕́ɔ(}ɥѕɥ耉=䁍ɕєɽՍа͕ɥ䰁A$ɅаȁյЁɕ́չɕ̸(((ѕ}耉}ͥ(耉Aͥ(ݹȈ耉AɽɕЁ͕ɥɕ٥ݕȈ(ͽɍ̈l̽Ʌ}ɕ͕ɍ̽ɍ}՝}Ʌѥ}t(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ(ѵlɅ}}ͥulͥt􀉭}ͥ}ɽՍЈ(͔݅ɹ(٥聝ѵlɅ}}ͥulɕͽt(ѥ耉-光ѕɥ͔ɽɽՍЁչѥɅѥɥ́ɔɕ(}ɥѕɥ耉Ёɕє͕ɅєɅ䰁ЁՉձȁɅѕȁѡ́չє((t(хѕ}չ̀ չѕȡѕlѥ}хєtȁѕչ}ѕ̤(}չЀхѕ}չ̹Рɕѕ}̤(݅ɹ}չЀхѕ}չ̹Р݅ɹ(}٥ɽ}}չЀմ(āȁѕչ}ѕ́ѕРͽɍ}}х̈􀉉}٥ɽ}ɕեɕ((ɽՍѥ}ѕ}}չЀմ(āȁѕչ}ѕ́ѕРͽɍ}}х̈ɽՍѥ}}ɕեɕ((ɍ}ͥɕ}}չЀմ(āȁѕչ}ѕ́ѕРͽɍ}}х̈􀉉}ͥɕ}ɕեɕ((ѕɹ}}ɽ}չЀ(}٥ɽ}}չЀɽՍѥ}ѕ}}չЀɍ}ͥɕ}}չ((}չ(չ}х̀􀉍ɍ}չ}(݅ɹ}չ(չ}х̀􀉍ɍ}չ}ɕ}ݥѡ}݅ɹ̈(͔耀Ʌ聹ٕȀչɕݡѡ́ɕЁɥ́ѕɅȵ݅ɹ͕ѥ(չ}х̀􀉍ɍ}չ}ɕ䈀Ʌ聹ٕ((ɕɸ(չ}х̈聱չ}х̰(хɝ}Ʌ}مՕ}܈хɝ}Ʌ}مՕ}ܰ(хɝ}Ʌ}مՕ}聘-I\хɝ}Ʌ}مՕ}(ɕ}х̈耉}ɍ}չ}ɕ̈(ͽɍ}є耠( ɍչɕ́́ɕQ4չѥхɅѽȰ(ѥ̰ɕ٥ܵɽ̰٥͕Ʌѕ䁙ɽȁ٥ɽа(ɽՍѥѕ䰁ɍͥɔ쁥Ё́ЁمՅѥՅɅѕ(ɍ͔ѵаͥɑȰɽՍѥѥєȁɕٕՔɽ((չ}յ(ѕ}չЈ聱չ}ѕ̤(ɕ}չЈхѕ}չ̹Рɕ䈰(݅ɹ}չЈ݅ɹ}չа(}չЈ聉}չа(ѕɹ}}ɽ}չЈ聕ѕɹ}}ɽ}չа(}٥ɽ}}չЈ聉}٥ɽ}}չа(ɽՍѥ}ѕ}}չЈɽՍѥ}ѕ}}չа(ɍ}ͥɕ}}չЈ聍ɍ}ͥɕ}}չа(ɕ٥}ɽ}}Ȉ聝ѵlɕ٥}ɽ}ul}ȉt((չ}ѕ̈聱չ}ѕ̰(ɕѕ}̈聍ɕѕ}̰(չ}х}ձ̈l((չ}х̈耉ɍ}չ}ɕ䈰(ձ耉Q4չѥхɅѽȰȁ٥ɽаɽՍѥѕ䰁ɍͥɔɕ٥܁䰁٥ɔɕ䈰(((չ}х̈耉ɍ}չ}ɕ}ݥѡ}݅ɹ̈(ձ耉ɕչЁ́ɕݡȁ٥ɽаɽՍѥѕ䰁ȁɍͥɔ́ɕЁ݅ɹ̈(((չ}х̈耉ɍ}չ}(ձ耉ͥչЁ٥ɕєɽՍЁаA$ɅЁɔյЁ͵э͕ɥ䁙ɔȁ Ё́ͅչɕ̈((t(ɕ٥}ɽ}聝ѵlɕ٥}ɽ}t(ɕѕ}չѥ}ɕ̈(ɍ}}ѽ}ɭ}х̈聝ѵl}ѽ}ɭ}х̉t(ɍ}Ʌѥ}х̈聽ɅѥlɅѥ}х̉t(ɍ}ɑ}х̈聽ɑlɑ}х̉t(ɍ}х}х̈聅хlх}х̉t(ѥ}ɕ}х̈聅ѥlɕ}х̉t(ѵlɕѕ}չѥ}ɕ̉t((Ʌ}}ͥ聝ѵlɅ}}ͥt(՝}Ʌ聝ѵl՝}Ʌt(չ}̈(}ͥ}耉輽ܹͥi5]!Ii9](}ɐ耉輽ܹɐ]5M!!MA4(չѥ}Ј耈Ľɍ}չ}ɕ̽ѕЈ(յхѥ耉̽ɍ}չ}ɕ̹((((ɍ}ѥ}͍ɕɑ}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(ɕ͕}ѡɥ5mȰt99(mȰt(Iɸѡ-I\ɍѥ͍ɕɐ(ɍ͕ɍ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((Ѵ͕ɍ}}ѽ}ɭ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ(ɕ͕}ѡɥɕ͕}ѡɥ((չ͕ɍ}չ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ(ɕ͕}ѡɥɕ͕}ѡɥ((ѥ͕̀ѥ}͹͡С}չ}չ̤(}хє͕}хє(ɽЀAѠ}}}|ɕͽٔɕlt((}ѠȤ(ɕɸɽЀѠ}((ɕѕ}̀􁱥Сչlɕѕ}̉t(ɍlɍ}х̉t􀉹}ɍ}ɕ(ɕѕ}̹ɍ}ɕ}(չlչ}х̉t􀉍ɍ}չ}(ɕѕ}̹ɍ}չ}(ɕѕ}̀􁱥Сйɽ̡ɕѕ}̤(͍ɕɑ}ѕ̀l((ѕ}耉ɽՍ}ͥ}٥(耉AɽՍЁͥ٥(ݹȈ耉AɽՍЁͥݹȈ(ͽɍ̈l(̽՝}ɥٕ}ͥ}ɥ(̽ɍ}՝}Ʌѥ}(͍̽ɕ}ͥ((Ľɍ}ɕ̽ѕЈ(t(٥}耉ɕͥѽ}}չѥ}ѥЈ(ѥ}хє耉ɕ((}Ѡ(ȁѠ(̽՝}ɥٕ}ͥ}ɥ(̽ɍ}՝}Ʌѥ}(͍̽ɕ}ͥ(((}хѕl̉t(͔(٥耉 ȰɅѽȰ͕ɥ位ɽɕЁݽɭ́Ѽɕ́٥(ѥ耉-ȁ٥ѡ́٥ͥѡѥɽ(}ɥѕɥ耉ٕͽ́ɽՍнA$́٥Ѡ(((ѕ}耉}ѥ̈(耉ѥ̈(ݹȈ耉ݹȈ(ͽɍ̈l(̽}ѥ̹(輽ܹͥi5]!Ii9](輽ܹɐ]5M!!MA4(t(٥}耉}ѥЈ(ѥ}хє耉ɕ䈁}̽}ѥ̹͔(٥耉хͥ)Ʌ̰хȁѥЁɕɑ́ЁݥѡЁ и(ѥ耉U͔)ѥ́ȁхȁɕ٥܁ݥѡЁɅѥ Ёхф(}ɥѕɥ耉ѥ́ɔɕɑ Ёɕ́չ͕(((ѕ}耉ݕ}}٥(耉Mݕ́٥(ݹȈ耉%хѥݹȈ(ͽɍ̈l(̽ݕ̼̽شܴȵɍѥ͍ɕɐչѥ(̽ݕ̼̽شܴȵɍչɕ̹(ѕ̽ѕ}ɍ}ѥ}͍ɕɐ䈰(t(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ(}̽ݕ̼̽شܴȵɍѥ͍ɕɐչѥ(}ѕ̽ѕ}ɍ}ѥ}͍ɕɐ䈤(͔(٥耉ѕ͕́ѕ̰́ѕɕ̰хѥٕɥѥ̸(ѥ耉-Qٕ́ɥѥ́ѕݥѠѡ͍ɕɐ(}ɥѕɥ耉A͕ѕЁЁȁѡչѥ͍ɕɐ(((ѕ}耉х}}ͥ(耉Aхͥ(ݹȈ耉AɽɕЁ͕ɥɕ٥ݕȈ(ͽɍ̈l̽Ʌ}ɕ͕ɍ̽ɍ}՝}Ʌѥ}t(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ(չlɅ}}ͥulͥt􀉭}ͥ}ɽՍЈ(͔݅ɹ(٥聱չlɅ}}ͥulɕͽt(ѥ耉-ɕͥѽ䁅光ɽՍЁչѥɅѥɥ́ɔɕ(}ɥѕɥ耉9͕ɅєɅ䰁ЁՉձȁɅѕ́ɕѕȁѡ́ɕи(((ѕ}耉х}ѥ}ѡձ̈(耉фѥ́ѡձ̈(ݹȈ耉ѥ́ݹȈ(ͽɍ̈l(̽ѥ}(Ľѥ}͹̽͡ѕЈ(Ľɍ}չ}ɕ̽ѕЈ(t(٥}耉ɕ}(ѥ}хє耉ɕ(}̽ѥ}ѥlɕ}х̉t􀉱}չѥ}͹͡Ј(͔(٥耉5ɕ٥ɽ͕ɽՍѥȁȵ́ɔ͕Ʌѕ(ѥ耉Ёɕ͕Ёɽ͕ȁȁɽՍѥ́́ɕɽՍЁɕձ̸(}ɥѕɥ耉ٕ䁍ɍ-A$́٥ͽɍхѥ(((ѕ}耉չѥ}}(耉IչѥЁ(ݹȈ耉AљɴɅѽȈ(ͽɍ̈l(Ľɍ}ɕ̽ѕЈ(Ľɍ}}ѽ}ɭ}ɕ̽ѕЈ(Ľɍ}չ}ɕ̽ѕЈ(Ľɍ}ѥ}͍ɕɑ̽ѕЈ(t(٥}耉ɕͥѽ}}չѥ}ѥЈ(ѥ}хє耉ɕ(ɍlɍ}х̉t􀉹}ɍ}ɕ(ѵl}ѽ}ɭ}х̉t􀉍ɍ}}ѽ}ɭ}(չlչ}х̉t􀉍ɍ}չ}(͔(٥耠(ɍ}х퍽ɍlɍ}х̝u쀈(}ѽ}ɭ}хѵl}ѽ}ɭ}х̝u쀈(չ}хչlչ}х̝u((ѥ耉͔ѥх́ѡɽ՝ѡͅɽѕѕչѥA$(}ɥѕɥ耉Iչѥ́٥є(((ѕ}耉ٕɥѥ}Ј(耉YɥѥЈ(ݹȈ耉Qɕ٥ݕȈ(ͽɍ̈l(ѕ̽ѕ}ɍ}ѥ}͍ɕɐ䈰(ѕ̽ѕ}ɍ}չ}ɕ̹䈰(ѕ̽ѕ}՝}ɥٕ}ѥ̹䈰(ѕ̽ѕ}}Ʌй䈰(ѕЀĈ(t(٥}耉ɕ}(ѥ}хє耉ɕ((}Ѡ(ȁѠ(ѕ̽ѕ}ɍ}ѥ}͍ɕɐ䈰(ѕ̽ѕ}ɍ}չ}ɕ̹䈰(ѕ̽ѕ}՝}ɥٕ}ѥ̹䈰(ѕ̽ѕ}}Ʌй䈰(((͔(٥耉͕ѥչѥаA$ɅЁѕ́ɔɕ͕и(ѥ耉Iո͕ѕ́ձѕЁɔɕ͕ѥѥх̸(}ɥѕɥ耉͕ѕ̰ձѕа坥̸(((ѕ}耉ɕ٥}ɽ}䈰(耉I٥܁ɽ́䈰(ݹȈ耉ݹȈ(ͽɍ̈l̽ɍ}ѥ}͍ɕɐ̽ɍ}չ}ɕ̹t(٥}耉ɕͥѽ}ѥЈ(ѥ}хє耉ɕ䈰(٥耉I٥܁䰁ɕ٥܁䰁ՕՕɕ٥܁ѽѥɔЁɽՍЁ̸(ѥ耉 䁽ɕє͕ɥ䰁A$Ʌаյаȁչѥ̸(}ɥѕɥ耉I٥܁ɽ́ɕ́ݥѡЁɕєɔ٥(((ѕ}耉ɽՍѥ}}̈(耉AɽՍѥȁܵ̈(ݹȈ耉 ȁͽȰɅѥ́ݹȰݹȈ(ͽɍ̈l(Ľɍ}չ}ɕ̽ѕЈ(ȁ٥ɽЈ(ɽՍѥѕ䈰(ɍͥɕ̈(t(٥}耉ѕɹ}}ɕեɕ(ѥ}хє耉݅ɹ(ͽɍ}}х̈耉ѕɹ}}ɕեɕ(٥耠(ѕɹ}}ɽ}չչlչ}յulѕɹ}}ɽ}չНu쀈(}ͥɕ}}չѵl}ѽ}ɭ}յul}ͥɕ}}չНu((ѥ耉 Ёȁ٥ɽаɽՍѥѕ䰁ͥɔ́ȁЁ̸ٕ݅(}ɥѕɥ耉 ȁ́ȁٕ݅́ɕѕɹ̸((t(хѕ}չ̀ չѕȡѕlѥ}хєtȁѕ͍ɕɑ}ѕ̤(}չЀхѕ}չ̹Рɕѕ}̤(݅ɹ}չЀхѕ}չ̹Р݅ɹ(}չ(ѥ}х̀􀉍ɍ}ѥ}(݅ɹ}չ(ѥ}х̀􀉍ɍ}ѥ}ɕ}ݥѡ}݅ɹ̈(͔耀Ʌ聹ٕȀչɕݡѡ́ɕЁɥ́ѕɅȵ݅ɹ͕ѥ(ѥ}х̀􀉍ɍ}ѥ}ɕ䈀Ʌ聹ٕ((ɕɸ(ѥ}х̈聍ѥ}х̰(хɝ}Ʌ}مՕ}܈хɝ}Ʌ}مՕ}ܰ(хɝ}Ʌ}مՕ}聘-I\хɝ}Ʌ}مՕ}(ɕ}х̈耉}ɍ}ѥ}͍ɕɐ(ͽɍ}є耠( ɍѥ͍ɕɐɕѕ́ɕɽՍЁͥMݕ̰(Aхфѥ̰չѥٕɥѥɕ٥ܵɽ̰٥(͕Ʌѕ䁙ɽȁɽՍѥܵ쁥Ё́ЁمՅѥՅɅѕɍ͔(ѵаͥɑȰɽՍѥѥєȁɕٕՔɽ((ѥ}յ(ѕ}չЈ聱͍ɕɑ}ѕ̤(ɕ}չЈхѕ}չ̹Рɕ䈰(݅ɹ}չЈ݅ɹ}չа(}չЈ聉}չа(ѕɹ}}ɽ}չЈ聱չlչ}յulѕɹ}}ɽ}չЉt(ɕ٥}ɽ}}Ȉ聱չlɕ٥}ɽ}ul}ȉt(}}͕͔((ѥ}ѕ͍̈ɕɑ}ѕ̰(ɕѕ}̈聍ɕѕ}̰(ѥ}х}ձ̈l((ѥ}х̈耉ɍ}ѥ}ɕ䈰(ձ耉ɽՍЁͥMݕ̰Aхфѥ̰չѥٕɥѥɕ٥܁䰁ѕɹ́ɔɕ䈰(((ѥ}х̈耉ɍ}ѥ}ɕ}ݥѡ}݅ɹ̈(ձ耉ɕɽɅѥ٥́ɕݡȁ٥ɽаɽՍѥѕ䰁ɍͥɕ̰ȁѡȁѕɹ́ɕЁ݅ɹ̈(((ѥ}х̈耉ɍ}ѥ}(ձ耉͕ɥ䁙ɔA$ɅЁɕɕͥյЁ͵эɕɽՍɽՍЁаͥѥ٥ȁ Ё́ͅѥ((t(ɕ٥}ɽ}聱չlɕ٥}ɽ}t(ɕѕ}չѥ}ɕ̈(ɍ}ɕ}х̈聍ɍlɍ}х̉t(ɍ}}ѽ}ɭ}х̈聝ѵl}ѽ}ɭ}х̉t(ɍ}չ}х̈聱չlչ}х̉t(ѥ}ɕ}х̈聅ѥlɕ}х̉t((Ʌ}}ͥ聱չlɅ}}ͥt(՝}Ʌ聱չl՝}Ʌt(ѥ}̈(}ͥ}耉輽ܹͥi5]!Ii9](}ɐ耉輽ܹɐ]5M!!MA4(չѥ}Ј耈Ľɍ}ѥ}͍ɕɑ̽ѕЈ(յхѥ耉̽ɍ}ѥ}͍ɕɐ((((ɍ}}х}ݽɭ}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(mȰt(Iɸݹȵ͍ȁхݽɭ܁٥(х͕ɍ}х}}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ѥ͕ɍ}ѥ}͍ɕɑ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((͕ɍ}}չ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ѥ͕̀ѥ}͹͡С}չ}չ̤(ɽЀAѠ}}}|ɕͽٔɕlt((}ѠȤ(ɕɸɽЀѠ}((}̠ѡȤ(ɕɸ}ѠȁѠѡ̤((ѕ(ѕ}Ȱ(Ȱ(ݹȰ(ͽɍ聱mt(٥}Ȱ(ѥ}хєȰ(٥Ȱ(ͥ}ձȰ(}ѥȰ(mȰt(ɕեɕ}}ѕ}}х}ݽɭܹѕ}(ѥ}хєЁɕ䈰݅ɹ耀Ʌ聹ٕ(Ʌ͔YՕɽȠȁхݽɭ܁хєЁɕ䰁݅ɹȁ(ɕɸ(ѕ}ѕ}(聱(ݹȈ聽ݹȰ(ͽɍ̈ͽɍ̰(٥}聕٥}(ѥ}хє聍ѥ}хє(٥聕٥(ͥ}ձ聑ͥ}ձ(}ѥ聹}ѥ(((ɕѕ}̀􁱥Сйɽ̡хlɕѕ}̉tѥlɕѕ}̉t(х}􁅍хlх}х̉t􀉍ɍ}х}(ѥ}􁍽ѥlѥ}х̉t􀉍ɍ}ѥ}(}չѥ}хє􀉉х}ȁѥ}ȁɕѕ}͔́ɕ(ݽɭ}ѕ̀l(ѕ(ɵ}ɽՍ}͍( ɴɽՍЁ͍(AɽՍЁݹȈ(lI5̽ɽՍ}̽ɍ}ɕ̹t(ɕͥѽ}ѥЈ(ɕ䈁}̠I5̽ɽՍ}̽ɍ}ɕ̹͔(AɽՍЁɕ́ѕɥ͔ɍɅѥɽ(Aɽݡѡȁɕ٥́ѥA$́٥ə(IѽɔɽՍЁ͍́ɔȁх((ѕ(ɵ}ѕɅѥ}ə( ɴѕɅѥə(Aљɴɕ٥ݕȈ(lĽнѥ̈̽ɕ}}ͥѕ̽ѕ}}Ʌйt(ɕͥѽ}ѥЈ(ɕ䈁}̠̽ɕ}}ͥѕ̽ѕ}}Ʌй䈤͔(=$ѥA$A$ɅЁѕ́ɔɕ͕и(AɽݡA$ѥ䁕٥́ɕ͕Ёѕ̸́(IѽɔIMṔȁA$ɅЁѕ́ɔȁх((ѕ(ɵ}Ʌѽ}٥( ɴɅѽȁ٥(AљɴɅѽȈ(lхє͍̽ɕ}ͥѕՅ}ɍɅѽȽt(ɕͥѽ}ѥЈ(ɕ䈁}̠͍̽ɕ}ͥѕՅ}ɍɅѽȽ䈤͔(ͽ͕́Ʌѽȁ٥ȁ䰁Ʌ̰ɕ䰁ѥ̰ɕ̸(AɽݡɅѽȁхєɍɕ́ə́ɔ٥ͥ(Iѽɔ٥́ȁхѥɔȁх((ѕ(ɵ}ɕ}̈( ɴɕ́̈(AɽՍЁݹȈ(l(Ľͅ}ɕ̽ѕЈ(Ľɍ}ɕ̽ѕЈ(Ľɍ}х}̽ѕЈ(Ľɍ}ѥ}͍ɕɑ̽ѕЈ(t(ɕ}(}չѥ}хє((ɍ}х}х텍хlх}х̝u쀈(ɍ}ѥ}х퍽ѥlѥ}х̝u((Aɽݡչѥѕ́ٔɕє̸(Iͽٔɕ̰хȁѥѕ́ɔȁх((ѕ(ɵ}͕ɥ}ɔ( ɴ͕ɥɔ(Mɥɕ٥ݕȈ(lM UI%Qdѕ̽ѕ}͕ɥ}ɑ䈰ѡՈݽɭ͕̽ɥ嵰t(ɕͥѽ}ѥЈ(ɕ䈁}̠M UI%Qdѕ̽ѕ}͕ɥ}ɑ䈰ѡՈݽɭ͕̽ɥ嵰͔(Mɥ䰁ɑѕ̰ѕ͕ɥݽɭ܁хфɔɕ͕и(Aɽݡɕє͕ɥ䁙ɕ́ɔ͕и(ɕє͕ɥ䁙ɕՕՕ͕ɥ䁍́ɔЁ̸((ѕ(ɵ}ɥ}䈰( ɴɥ䈰(ѥ́ɕ٥ݕȈ(lĽѥ}͹̽͡ѕЈ̽ѥ}t(ɕ}(ɕ䈁}̽ѥ}ѥlɕ}х̉t􀉱}չѥ}͹͡Ј͔(ѥ́͹͡Ё͕Ʌєɕ٥ɽɽ͕ɽՍѥȁȁ̸(Aɽݡɕɽ͕́ɔЁᕐ(Iѽɔѥ́ͽɍ́ɔȁх((ѕ(ɵ}٥Յ}ɕ٥}Ѡ( ɴ٥Յɕ٥܁Ѡ(Mхȁɕ٥ݕȈ(l̽}ѥ̹ͥ)ɐḾt(}ѥЈ(ɕ䈁}̽}ѥ̹͔(хͥ)хȁѥ́ɔɕɑݥѡЁ и(Aɽݡ٥Յѥ́ɔمȁхȁɕ٥ܸ(Iɐѥ́ɔȁх((ѕ(ɵ}}ͥ( ɴͥ(AɽɕЁɕ٥ݕȈ(l̽Ʌ}ɕ͕ɍ̽ɍ}՝}Ʌѥ}t(ɕͥѽ}ѥЈ(ɕ䈁ѥlɅ}}ͥulͥt􀉭}ͥ}ɽՍЈ͔݅ɹ(ѥlɅ}}ͥulɕͽt(AɽݥѠɕͥѽ䁅光ɽՍи(ɅЁ䁅ѕȁ͕ɽՍаЁɕ͔ȁɽٕɥȁ̸((ѕ(ɵ}ɽՍѥ}̈( ɴɽՍѥ̈(=Ʌѥ́ݹȈ(lɽՍѥѕ䈰ЁM1<٥Ёɥt(ɽ͕}չѥ}ɽՍѥ(݅ɹ(AɽՍѥѕ䰁аM1<Ё٥ɕեɔ嵕Ёȁɑ٥ɽи(AɽݥѠ݅ɹݡɽՍѥ́ɔѱ䁍ٕѕ( ЁɽՍѥ٥ɥȁɑȁɬЁٕ݅ȸ((ѕ(ɵ}}}̈( ɴȵ̈( ȁչЁѕ(lI=$͕ɥՕѥɔɕ٥܈嵕ЁхɝЉt(ɽ͕}չѥ}}(݅ɹ(I=$ɽɕа嵕Ё́ɕեɔȸ(AɽݥѠ݅ɹݡȵ́ɔЁ̸ܵ( Ёȵ́ɥչЁ((t(хѕ}չ̀ չѕȡѕlѥ}хєtȁѕݽɭ}ѕ̤(}չЀхѕ}չ̹Рɕѕ}̤(݅ɹ}չЀхѕ}չ̹Р݅ɹ(}չ(ݽɭ}х̀􀉉}х}ݽɭ}(݅ɹ}չ(ݽɭ}х̀􀉉}х}ݽɭ}ɕ}ݥѡ}݅ɹ̈(͔耀Ʌ聹ٕȀչɕݡѡ́ɕЁɥ́ѕɅȵ݅ɹ͕ѥ(ݽɭ}х̀􀉉}х}ݽɭ}ɕ䈀Ʌ聹ٕ((ɕɸ(ݽɭ}х̈ݽɭ}х̰(хɝ}Ʌ}مՕ}܈хɝ}Ʌ}مՕ}ܰ(хɝ}Ʌ}مՕ}聘-I\хɝ}Ʌ}مՕ}(ɕ}х̈耉}}х}ݽɭ܈(ͽɍ}є耠( ɍȁхݽɭ܁́չݹ̰չѥ٥(ѥ̰ѥ́ѡձ̰ɕ٥ܵɽ́䰁(ͥѼ]ɹ9ѕ쁥Ё́ЁمՅѥՅɅѕ(ɍ͔ѵаͥɑȰɽՍѥѥє(ȁɕٕՔɽ((ݽɭ}յ(ѕ}չЈ聱ݽɭ}ѕ̤(ɕ}չЈхѕ}չ̹Рɕ䈰(݅ɹ}չЈ݅ɹ}չа(}չЈ聉}չа(ɽՍѥ}}}չЈմ(āȁѕݽɭ}ѕ́ѕl٥}tɽ͕}չѥ}ɽՍѥ((}}}}չЈմ(āȁѕݽɭ}ѕ́ѕl٥}tɽ͕}չѥ}}((ɕ٥}ɽ}}Ȉ聅хlɕ٥}ɽ}ul}ȉt(}}͕͔((х}ѕ̈ݽɭ}ѕ̰(ɕѕ}̈聍ɕѕ}̰(}݅ɹ}}}ձ̈l((ݽɭ}х̈耉}х}ݽɭ}ɕ䈰(ձ耉хݹ́ٔɕ䁕٥ѕɹɽՍѥȁȵ́ɕ(((ݽɭ}х̈耉}х}ݽɭ}ɕ}ݥѡ}݅ɹ̈(ձ耉ɕȁх٥́ɕݡɽՍѥȁȵ́ɕЁ݅ɹ̈(((ݽɭ}х̈耉}х}ݽɭ}(ձ耉͕ɥ䁙ɔA$ɅЁɕɕͥյЁ͵эɕɽՍɽՍЁаͥхѠȁ Ё́ͅх((t(ɕ٥}ɽ}聅хlɕ٥}ɽ}t(ɕѕ}չѥ}ɕ̈(ɍ}х}х̈聅хlх}х̉t(ɍ}ѥ}х̈聍ѥlѥ}х̉t(}}х̈聡lչ}х̉t(ѥ}ɕ}х̈聅ѥlɕ}х̉t((Ʌ}}ͥ聍ѥlɅ}}ͥt(՝}Ʌ聍ѥl՝}Ʌt(ݽɭ}̈(}ͥ}耉輽ܹͥi5]!Ii9](}ɐ耉輽ܹɐ]5M!!MA4(չѥ}Ј耈Ľɍ}}х}ݽɭ̽ѕЈ(յхѥ耉̽ɍ}}х}չ((((ɍ}}͍ɥ}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(mȰt(Iɸȵ͍ɥ́ȁѡ-I\ѥхɐ(ѥ͕ɍ}ѥ}͍ɕɑ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((}ݽɭ܀͕ɍ}}х}ݽɭ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ѥ͕̀ѥ}͹͡С}չ}չ̤(}хє͕}хє(ɽЀAѠ}}}|ɕͽٔɕlt((}ѠȤ(ɕɸɽЀѠ}((}̠ѡȤ(ɕɸ}ѠȁѠѡ̤((ѕ(ѕ}Ȱ(Ȱ(ͽȰ(ͽɍ聱mt(չѥ}聱mt(٥}Ȱ(ѥ}хєȰ(٥Ȱ(}ѥȰ(ѕ}٥Ȱ(mȰt(ɕեɕ}}ѕ}ɍ}ѕ}(ѥ}хєЁɕ䈰݅ɹ耀Ʌ聹ٕ(Ʌ͔YՕɽȠɍѕхєЁɕ䰁݅ɹȁ(ɕɸ(ѕ}ѕ}(聱(ͽͽ(ͽɍ̈ͽɍ̰(չѥ}̈չѥ}̰(٥}聕٥}(ѥ}хє聍ѥ}хє(٥聕٥(}ѥ聑}ѥ(ѕ}٥聕ѕ}٥(((ɕѕ}̀􁱥Р(йɽ̡ѥlɕѕ}̉t}ݽɭlɕѕ}̉t((}չѥ}хє((ѥlѥ}х̉t􀉍ɍ}ѥ}(ȁ}ݽɭlݽɭ}х̉t􀉉}х}ݽɭ}(ȁɕѕ}(͔ɕ((ٕ}չ̀􁅹ѥ̹Рٕ}չ̈(ɕ}չ̀􁅑}хєРɕ}ݽɭ}չ̈mt(}ѕ̀l(ѕ(ѥ}}͵( ѥA$͵(Ȉ(lI5̽ɕ}}ͥĽнѥ̉t(lĽнѥ̉t(ɕ}(ɕ(}̠I5̽ɕ}}ͥ(ٕ}չ̹Р}ѥ}ɕՕѕ(͔(Ս͙ձ}}ѥ}ٕٕ}չ̹Р}ѥ}ɕՕѕ(Iոѡ=$ѥЁѥ͕ѡȁѥ(Qȁ͕́ѥɕ͔ѡչѥɕɑ́ѥٕ́и((ѕ(Սѕ}ݽɭ}Ʌ( Սѕݽɭ܁Ʌ(AљɴɅѽȈ(lĽݽɭ}չ͍̈̽ɕ}ͥt(lĽݽɭ}չ̉t(ɕ}(ɕ䈁ɕ}չ́}͍̽ɕ}͔ͥ(ɕ}ݽɭ}չ}չɕ}չ̥(=ѡɅ٥܁ȁՍѕݽɭ܁ո(QɅѽȁЁ䁵͕ѕ̰ոɅ٥((ѕ(}}ѥ(̵Ёѥ( ɕ٥ݕȈ(l̽ɽՍ}Ľ}ɕ̽ݽɭ}չ}􈰀t(lĽ}ɕ̽ݽɭ}չ}􈰀t(ɕͥѽ}}չѥ}ѥЈ(ɕ䈁}̽ɽՍ}͔(́ɕ́ɔ͍Ѽݽɭ}չ}͕ѡɽ՝ѡə(=ѡ́ɕЁȁѡՍѕݽɭ܁ո(Qɕ٥ݕȁ͕́ݡ䁕Ё́Ѽѕаѽ̰Ʌ٥((ѕ(مՅѥ}ɕ䈰(مՅѥɕ䈰(EՅɕ٥ݕȈ(l͍̽ɕ}ͥĽمՅѥ}չ̈t(lĽمՅѥ}չ̈t(ɕ}(ɕ䈁ٕ}չ̹РمՅѥ}չ}ɕѕ͔(مՅѥ}չ}ɕѕ}ٕٕ}չ̹РمՅѥ}չ}ɕѕ(IѡȁɽЁѡɽ՝ѡمՅѥи(Qɕ٥ݕȁ͕́ɕх́Ʌٕɥѥ٥((ѕ(}ɕ}ͽ(ɕ́ͽ(Ȉ(l((Ľɍ}ѥ}͍ɕɑ̽ѕЈ(Ľɍ}}х}ݽɭ̽ѕЈ(Ľɍ}}͍ɥ̽ѕЈ(t(l((Ľɍ}ѥ}͍ɕɑ̽ѕЈ(Ľɍ}}х}ݽɭ̽ѕЈ(Ľɍ}}͍ɥ̽ѕЈ(t(ɕͥѽ}}չѥ}ѥЈ(}չѥ}хє((ɍ}ѥ}х퍽ѥlѥ}х̝u쀈(}х}ݽɭ}х}ݽɭlݽɭ}х̝u((M܁ѡɕ́ɐѡͽ(Qȁ͕́ѥȁхх́ݥѡЁ٥ɽ((ѕ(ɥ}ѡձ̈(5ɥѡձ̈( ɕ٥ݕȈ(l̽ѥ}Ľѥ}͹̽͡ѕЉt(lĽѥ}͹̽͡ѕЉt(ɕ}(ɕ(}̽ѥ}ѥlɕ}х̉t􀉱}չѥ}͹͡Ј(͔(ɕɥ́ɕ͕Ʌєɽɽ͕ɽՍѥȵɥ̈(I٥܁ѡѥ́ѥ́и(Qɕ٥ݕȁѥե͠ɕչѥфɽɽ͕-A$ѥ̸((ѕ(}х}ɕ٥܈(хȁɕ٥܈(Mхȁɕ٥ݕȈ(l(̽}ѥ̹(輽ܹͥi5]!Ii9](輽ܹɐ]5M!!MA4(t(mt(}ѥЈ(ɕ䈁}̽}ѥ̹͔(х)хȁѥ́ɔɕɑݥѡЁ Ј(]ѡɽ՝ѡͥ)Ʌи(Mх́ɕ٥܁ѡɽՍЁɅѥٔəչѥ܁́хѥ̸((ѕ(}х}ͥ( ȁхͥ(Ȉ(l(̽ɍ}}х}չ(Ľɍ}}х}ݽɭ̽ѕЈ(t(lĽɍ}}х}ݽɭ̽ѕЉt(ɕͥѽ}}չѥ}ѥЈ(}չѥ}хє(}х}ݽɭ}х}ݽɭlݽɭ}х̝u(U͔ѡȁхݽɭ܁́ѡ]ɹ9ͥɕɐ(Qȁͥɕ٥ݡѕɹܵ́х䁕и((ѕ(ɽՍѥ}}̈(AɽՍѥȁܵ̈(Ȉ(lɽՍѥѕ䈰I=$͕ɥՕѥɔЁt(mt(ɽ͕}չѥ}}(݅ɹ(AɽՍѥѕ䰁ȁI=$͕ɥՕѥɔЁɕեɔȁи( ɔȵɽՍѥI=$Ё́ѕȁѡ(ѕɹ́ɔɅ́݅ɹ̰Ё́ɕɽՍЁ٥((t(хѕ}չ̀ չѕȡѕlѥ}хєtȁѕ}ѕ̤(}չЀхѕ}չ̹Рɕѕ}̤(݅ɹ}չЀхѕ}չ̹Р݅ɹ(}չ(}х̀􀉍ɍ}}(݅ɹ}չ(}х̀􀉍ɍ}}ɕ}ݥѡ}݅ɹ̈(͔耀Ʌ聹ٕȀչɕݡѡ́ɕЁɥ́ѕɅȵ݅ɹ͕ѥ(}х̀􀉍ɍ}}ɕ䈀Ʌ聹ٕ(ɕեɕ}չѥ}̀􁱥Р(йɽ̠((ȁѕ}ѕ(ȁЁѕlչѥ}̉t(йхݥѠ((((ɕɸ(}х̈聑}х̰(хɝ}Ʌ}مՕ}܈хɝ}Ʌ}مՕ}ܰ(хɝ}Ʌ}مՕ}聘-I\хɝ}Ʌ}مՕ}(ɕ}х̈耉}ɍ}}͍ɥ̈(ͽɍ}є耠( ɍ͍ɥ́ɕչѥѥ̰(ȁхɕ٥ܵ䰁٥ȁ-I\Ȱ(ͅɕ٥쁥Ё́ЁمՅѥՅɅѕɍ͔ѵа(ͥɑȰɽՍѥѥєȁɕٕՔɽ((}Ʌѥٔ(ѥѱ耉-I\ɍɽȁ(ɽ͔耠(M܁ѕɥ͔ɍɅѥɽݥѠѥɕA$(ɅѽȽ٥Ʌ́٥ͥ䰁مՅѥɕ䰁ѡհɥ̸((Ցl(Ȉ(AљɴɅѽȈ( ɕ٥ݕȈ(EՅɕ٥ݕȈ(Mхȁɕ٥ݕȈ(t((}յ(ѕ}չЈ聱}ѕ̤(ɕ}չЈхѕ}չ̹Рɕ䈰(݅ɹ}չЈ݅ɹ}չа(}չЈ聉}չа(ͽ}չЈ聱ѕlͽtȁѕ}ѕ(}չЈ聱ɕեɕ}չѥ}̤(ɕ٥}ɽ}}Ȉ聍ѥlɕ٥}ɽ}ul}ȉt(}}͕͔((}ѕ̈聑}ѕ̰(ɕեɕ}չѥ}̈ɕեɕ}չѥ}̰(ɕѕ}̈聍ɕѕ}̰(}х}ձ̈l((}х̈耉ɍ}}ɕ䈰(ձ耉ѕ́ɔɕ䁅ɽՍѥȁȵܵ́ɕ(((}х̈耉ɍ}}ɕ}ݥѡ}݅ɹ̈(ձ耉ɕ٥́ɕݡɽՍѥI=$аȁȵ́ɕЁ݅ɹ̈(((}х̈耉ɍ}}(ձ耉͕ɥ䁙ɔA$ɅЁɕɕͥյЁ͵эչѥаͥ٥ȁ Ё́ͅѡ((t(ɕ٥}ɽ}聍ѥlɕ٥}ɽ}t(ɕѕ}չѥ}ɕ̈(ɍ}ѥ}х̈聍ѥlѥ}х̉t(}х}ݽɭ}х̈聉}ݽɭlݽɭ}х̉t(ѥ}ɕ}х̈聅ѥlɕ}х̉t((Ʌ}}ͥ聍ѥlɅ}}ͥt(՝}Ʌ聍ѥl՝}Ʌt(}̈(}ͥ}耉輽ܹͥi5]!Ii9](}ɐ耉輽ܹɐ]5M!!MA4(չѥ}Ј耈Ľɍ}}͍ɥ̽ѕЈ(յхѥ耉̽ɍ}}͍ɥ̹((((ɍ}ɽͅ}}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(mȰt(Iɸȁɽ͕ͅѥ́ȁѡ-I\ͅхɐ(ѥ͕ɍ}ѥ}͍ɕɑ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((͕ɍ}}͍ɥ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((}ݽɭ܀͕ɍ}}х}ݽɭ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((مՔ͕ɍ}مՕ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((͕ɥ͕ɍ}͕ɥ}ѕхѥ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ɅЀ͕ɍ}Ʌ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ɑ͕ɍ}ɑ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((Ʌѥ͕̀ɍ}Ʌѥ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ѥ͕̀ѥ}͹͡С}չ}չ̤(}хє͕}хє(ɽЀAѠ}}}|ɕͽٔɕlt((}ѠȤ(ɕɸɽЀѠ}((}̠ѡȤ(ɕɸ}ѠȁѠѡ̤((͕ѥ(͕ѥ}Ȱ(Ȱ(ݹȰ(ͽɍ聱mt(չѥ}聱mt(٥}Ȱ(ѥ}хєȰ(٥Ȱ(}ͅȰ(}ѥȰ(mȰt(ɕեɕ}}͕ѥ}ɍ}ɽ͕ͅѥ}(ѥ}хєЁɕ䈰݅ɹ耀Ʌ聹ٕ(Ʌ͔YՕɽȠɍɽ͕ͅѥхєЁɕ䰁݅ɹȁ(ɕɸ(͕ѥ}͕ѥ}(聱(ݹȈ聽ݹȰ(ͽɍ̈ͽɍ̰(չѥ}̈չѥ}̰(٥}聕٥}(ѥ}хє聍ѥ}хє(٥聕٥(}ͅ聉}ͅ(}ѥ聹}ѥ(((ɕѕ}̀􁱥Р(йɽ̠(ѥlɕѕ}̉t(lɕѕ}̉t(}ݽɭlɕѕ}̉t(((}չѥ}хє((ѥlѥ}х̉t􀉍ɍ}ѥ}(ȁl}х̉t􀉍ɍ}}(ȁ}ݽɭlݽɭ}х̉t􀉉}х}ݽɭ}(ȁɕѕ}(͔ɕ((ɽͅ}͕ѥ̀l(͕ѥ(ᕍѥٕ}յ䈰(ᕍѥٔյ䈰(ݹȈ(lI5̽ɍ}ѥ}͍ɕɐĽɍ}ѥ}͍ɕɑ̽ѕЉt(lĽɍ}ѥ}͍ɕɑ̽ѕЉt(ɕͥѽ}}չѥ}ѥЈ(}չѥ}хє}̠I5̽ɍ}ѥ}͍ɕɐ͔(ɍ}ѥ}х퍽ѥlѥ}х̝u(=ѕɥ͔ɍɅѥɽ́ɕ䁙ȁ-I\ȁɕ٥܁ݥѠЁ̸ٕ(U͔ѡѥ͍ɕɐ́ѡɽٕͅȁ٥((͕ѥ(ɽՍ}͍(AɽՍЁ͍(AɽՍЁݹȈ(l̽ɽՍ}̽ɍ}՝}Ʌѥ}̽Ʌ}ɕ͕ɍt(mt(ɕͥѽ}ѥЈ(ɕ(}̠̽ɽՍ}̽ɍ}՝}Ʌѥ}̽Ʌ}ɕ͕ɍ(ѥlɅ}}ͥulͥt􀉭}ͥ}ɽՍЈ(͔(ѥlɅ}}ͥulɕͽt(Qȁ́ѥA$́٥əЁЁɽՍЁեє(-ɽͅՅѕɕͥ光ɽ((͕ѥ(}مՕ}͔( ȁمՔ͔(Ȉ(l̽ɍ}مՕ}ɕ̹̽ѥ}Ľɍ}مՕ}ɕ̽ѕЉt(lĽɍ}مՕ}ɕ̽ѕЈĽѥ}͹̽͡ѕЉt(ɕͥѽ}}չѥ}ѥЈ(ɕ(مՕlمՕ}х̉t􀉍ɍ}مՕ}(}̽ɍ}مՕ}ɕ̹(ѥlɕ}х̉t􀉱}չѥ}͹͡Ј(͔(مՕ}хمՕlمՕ}х̝u쁅ѥ}ɕ}х텹ѥlɕ}х̝u(5ɕمՔ٥͕́ɅѕɽȵI=$̸(хȁI=$յѥ́䁅ѕȁȁ͍ٕمѕ́ѡ((͕ѥ(}}х}Ѡ(хѠ(AɽՍЁͥݹȈ(l(̽ɍ}}͍ɥ̹(̽ɍ}}х}չ(Ľɍ}}͍ɥ̽ѕЈ(Ľɍ}}х}ݽɭ̽ѕЈ(t(lĽɍ}}͍ɥ̽ѕЈĽɍ}}х}ݽɭ̽ѕЉt(ɕͥѽ}}չѥ}ѥЈ(}չѥ}хє(}̠̽ɍ}}͍ɥ̹̽ɍ}}х}չ(͔(ɍ}}х푕l}х̝u쁉}х}ݽɭ}х}ݽɭlݽɭ}х̝u( ȁɕ٥܁ٔɽ͍ɥЁѼ]ɹ9хݥѡЁ٥ѡɽ(IոѡЁɕɐѡхͥ((͕ѥ(ѕ}٥(Q٥(Aљɴɕ٥ݕȈ(l̽ɕ}}͍ͥ̽ɕ}ͥѕՅ}ɍɅѽȽ}Ʌй䈰t(lĽнѥ̈Ľݽɭ}չ̈Ľ}ɕ̽ݽɭ}չ}t(ɕͥѽ}}չѥ}ѥЈ(ɕ(}̠̽ɕ}}͍ͥ̽ɕ}ͥѕՅ}ɍɅѽȽ}Ʌй䈤(}хѕl̉t(͔(}չ}хѕl̝tɕ}ݽɭ}չ}չ}хѕlɕ}ݽɭ}չ̝t(QȁٕɥA$ѥ䰁Ʌ٥̵Ё٥(%ՑЁЁɕ٥܁͍ɕ́͡ȁٔ݅ѡɽ՝ѡɽͅ((͕ѥ(͕ɥ}}(Mɥ䁅(Mɥɕ٥ݕȈ(lM UI%Qd̽ɍ}͕ɥ}ѕхѥĽɍ}͕ɥ}ѕхѥ̽ѕЉt(lĽɍ}͕ɥ}ѕхѥ̽ѕЉt(ɕͥѽ}}չѥ}ѥЈ(ɕ(͕ɥl͕ɥ}ѕхѥ}х̉t􀉍ɍ}͕ɥ}ѕхѥ}(}̠M UI%Qd̽ɍ}͕ɥ}ѕхѥ(͔(͕ɥ}ѕхѥ}х͕ɥl͕ɥ}ѕхѥ}х̝u(I͕ɥ䁕٥́ɕ͕ЁݡѕɹѕхѥȁÁх䁕и(Ёѡɐ䁅ѕхѥչѥ((͕ѥ(хѥ}}Ʌѥ̈(%хѥɅѥ̈(=Ʌѥ́ݹȈ(l(̽ɍ}ɑ}ɕ̹(̽ɍ}Ʌѥ}ɕ̹(Ľɍ}ɑ}ɕ̽ѕЈ(Ľɍ}Ʌѥ}ɕ̽ѕЈ(t(lĽɍ}ɑ}ɕ̽ѕЈĽɍ}Ʌѥ}ɕ̽ѕЉt(ɕͥѽ}}չѥ}ѥЈ(ɕ(ɑlɑ}х̉t􀉍ɍ}ɑ}(ɅѥlɅѥ}х̉t􀉍ɍ}Ʌѥ}(}̠̽ɍ}ɑ}ɕ̹̽ɍ}Ʌѥ}ɕ̹(͔(ɑ}хɑlɑ}х̝u쁽Ʌѥ}хɅѥlɅѥ}х̝u(%хѥɅѥ́٥́ɽͅɕݥѠɽՍѥ٥ɽЁ͕ܵ́Ʌѕ( ٕЁȁ٥ɽЁх́ѼɑЁѕȁ͕ѥ((͕ѥ(ɽͅ}ɕ٥}Ј(Aɽͅɕ٥܁Ј(Mхȁɕ٥ݕȈ(l(̽ɍ}ɽͅ}й(̽}ѥ̹(̽ݕ̼̽شܴȵɍɽͅеչѥ(t(lĽɍ}ɽͅ}̽ѕЉt(ɕͥѽ}}չѥ}ѥЈ(ɕ(}̠(̽ɍ}ɽͅ}й(̽}ѥ̹(̽ݕ̼̽شܴȵɍɽͅеչѥ((͔(Aɽ̰ͅ)ѥЁɕɐхѥɔѕ́ɕѥ̸(Mх́ɕ٥܁ѡɽͅЁ̰́չѥ)M=8)ܸ(- ЁЁѡɽͅݽɭܸ((͕ѥ(ɍ}ѕɵ}̈( ɍѕɵ́ܵ̈(ݹȈ(l̽ɍ}Ʌ}ɕ̹ȁɑȁɴɕ٥܈ɥɽمt(lĽɍ}Ʌ}ɕ̽ѕЉt(ɽ͕}չѥ}}(݅ɹ(Ʌ}х퍽ɅlɅ}х̝u(=ɑȵɴɥɽمͥɔ́ȁɕ٥ܸ( Ёȵɍѕɵ́ȁɕɐЁٕ݅ȸ((͕ѥ(ɽՍѥ}}̈(AɽՍѥȁ̈( ȁͽȈ(lɽՍѥѕ䈰ȁI=$Ё͕ɥՕѥɔt(mt(ɽ͕}չѥ}}(݅ɹ(AɽՍѥѕ䰁ȁI=$Ё͕ɥՕѥɔɔѕɹ̸(Qɽ́ͅɕݡȵ́ɕٕѕ( Ёѕɹ٥ɥɽͅѥѥȁɑ((t(хѕ}չ̀ չѕȡѕlѥ}хєtȁѕɽͅ}͕ѥ̤(}չЀхѕ}չ̹Рɕѕ}̤(݅ɹ}չЀхѕ}չ̹Р݅ɹ(}չ(ɽͅ}х̀􀉍ɍ}ɽͅ}(݅ɹ}չ(ɽͅ}х̀􀉍ɍ}ɽͅ}ɕ}ݥѡ}݅ɹ̈(͔耀Ʌ聹ٕȀչɕݡѡ́ɕЁɥ́ѕɅȵ݅ɹ͕ѥ(ɽͅ}х̀􀉍ɍ}ɽͅ}ɕ䈀Ʌ聹ٕ(ɕեɕ}չѥ}̀􁱥Р(йɽ̠((ȁѕɽͅ}͕ѥ(ȁЁѕlչѥ}̉t(йхݥѠ((((ɕɸ(ɽͅ}х̈ɽͅ}х̰(хɝ}Ʌ}مՕ}܈хɝ}Ʌ}مՕ}ܰ(хɝ}Ʌ}مՕ}聘-I\хɝ}Ʌ}مՕ}(ɕ}х̈耉}ɍ}ɽͅ}Ј(ͽɍ}є耠( ɍɽͅЁ́ɕѥхمՔ(͕ɥ䰁ɅаɑɅѥ̰ѥ̰ɕ٥ܵ䰁(٥ȁ-I\Ȱȁɽͅɕ٥쁥Ё́ЁمՅѥՅɅѕ(ɍ͔ѵаͥɑȰɽՍѥѥєȁɕٕՔɽ((ɽͅ}Ʌѥٔ(ѥѱ耉-I\ɍȁɽͅЈ(ɽ͔耠(Aɕ͕Ёѕɥ͔ɍɅѥɽݥѠѥA$ѕɅѥ(Ʌѽȁ٥ȁѠхݽɭܰѡհɍ̸ٕ((Ցl(Ȉ(Aљɴɕ٥ݕȈ(Mɥɕ٥ݕȈ(=Ʌѥ́ݹȈ(Mхȁɕ٥ݕȈ(ݹȈ(t((ɽͅ}յ(͕ѥ}չЈ聱ɽͅ}͕ѥ̤(ɕ}չЈхѕ}չ̹Рɕ䈰(݅ɹ}չЈ݅ɹ}չа(}չЈ聉}չа(}չЈ聱ɕեɕ}չѥ}̤(ɕ٥}ɽ}}Ȉ聍ѥlɕ٥}ɽ}ul}ȉt(}}͕͔((ɽͅ}͕ѥ̈ɽͅ}͕ѥ̰(ɕեɕ}չѥ}̈ɕեɕ}չѥ}̰(ɕѕ}̈聍ɕѕ}̰(ɽͅ}х}ձ̈l((ɽͅ}х̈耉ɍ}ɽͅ}ɕ䈰(ձ耉ɽ͕ͅѥ́ɔɕ䁅ȵɍȁɽՍѥ́ɕ(((ɽͅ}х̈耉ɍ}ɽͅ}ɕ}ݥѡ}݅ɹ̈(ձ耉ɕɽͅ٥́ɕݡɥI=$ɽՍѥаȁͥɔ́ɕЁ݅ɹ̈(((ɽͅ}х̈耉ɍ}ɽͅ}(ձ耉͕ɥ䁙ɔA$ɅЁɕɕͥյЁ͵эչѥаͥɽͅ٥ȁ Ё́ͅѡɽͅ((t(ɕ٥}ɽ}聍ѥlɕ٥}ɽ}t(ɕѕ}չѥ}ɕ̈(ɍ}ѥ}х̈聍ѥlѥ}х̉t(ɍ}}х̈聑l}х̉t(}х}ݽɭ}х̈聉}ݽɭlݽɭ}х̉t(ɍ}مՕ}х̈مՕlمՕ}х̉t(ɍ}͕ɥ}ѕхѥ}х͕̈ɥl͕ɥ}ѕхѥ}х̉t(ɍ}Ʌ}х̈聍ɅlɅ}х̉t(ɍ}ɑ}х̈聽ɑlɑ}х̉t(ɍ}Ʌѥ}х̈聽ɅѥlɅѥ}х̉t(ѥ}ɕ}х̈聅ѥlɕ}х̉t((Ʌ}}ͥ聍ѥlɅ}}ͥt(՝}Ʌ聍ѥl՝}Ʌt(ɽͅ}̈(}ͥ}耉輽ܹͥi5]!Ii9](}ɐ耉輽ܹɐ]5M!!MA4(չѥ}Ј耈Ľɍ}ɽͅ}̽ѕЈ(յхѥ耉̽ɍ}ɽͅ}й((((ɍ}ɍ͕}ɽم}}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(mȰt(Iɸȵͥɍ͔ɽمѕ́ȁѡ-I\хɐ(ɽ͕ͅɍ}ɽͅ}}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((͔͕ɍ}͕}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ɽɕЀ͕ɍ}ɽɕ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ɅЀ͕ɍ}Ʌ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((مՔ͕ɍ}مՕ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((͕ɥ͕ɍ}͕ɥ}ѕхѥ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ɑ͕ɍ}ɑ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((Ʌѥ͕̀ɍ}Ʌѥ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ѥ͕̀ѥ}͹͡С}չ}չ̤(}хє͕}хє(ɽЀAѠ}}}|ɕͽٔɕlt((}ѠȤ(ɕɸɽЀѠ}((}̠ѡȤ(ɕɸ}ѠȁѠѡ̤((є(ѕ}Ȱ(Ȱ(ݹȰ(ͽɍ聱mt(չѥ}聱mt(٥}Ȱ(ѥ}хєȰ(٥Ȱ(ɽم}ՕѥȰ(}ѥȰ(mȰt(ɕեɕ}}ѕ}ɍ}ɍ͕}ɽمѕ}(ѥ}хєЁɕ䈰݅ɹ耀Ʌ聹ٕ(Ʌ͔YՕɽȠɍɍ͔ɽمєхєЁɕ䰁݅ɹȁ(ɕɸ(ѕ}聝ѕ}(聱(ݹȈ聽ݹȰ(ͽɍ̈ͽɍ̰(չѥ}̈չѥ}̰(٥}聕٥}(ѥ}хє聍ѥ}хє(٥聕٥(ɽم}Օѥ聅ɽم}Օѥ(}ѥ聹}ѥ(((ɕѕ}̀􁱥Сйɽ̡ɽͅlɕѕ}̉t͕lɕѕ}̉t(}չѥ}хє((ɽͅlɽͅ}х̉t􀉍ɍ}ɽͅ}(ȁ͕l͕}х̉t􀉍ɍ}͕}(ȁɕѕ}(͔ɕ((ɽم}ѕ̀l(є(ɽͅ}}ɕ䈰(AɽͅЁɕ䈰(ݹȈ(l̽ɍ}ɽͅ}йĽɍ}ɽͅ}̽ѕЉt(lĽɍ}ɽͅ}̽ѕЉt(ɕͥѽ}}չѥ}ѥЈ(}չѥ}хє}̽ɍ}ɽͅ}й͔(ɍ}ɽͅ}хɽͅlɽͅ}х̝u( ѡȁɕ٥܁ɕЁɽͅ(U͔ѡɽͅЁ́ѡɽمٕȁѥи((є(ɽɕ}ѡ}ɕ䈰(AɽɕЁѠɕ䈰(AɽɕЁݹȈ(l̽ɍ}ɽɕ}ɕ̹Ľɍ}ɽɕ}ɕ̽ѕЉt(lĽɍ}ɽɕ}ɕ̽ѕЉt(ɕͥѽ}}չѥ}ѥЈ(ɕ(ɽɕlɽɕ}х̉t􀉍ɍ}ɽɕ}(}̽ɍ}ɽɕ}ɕ̹(͔(ɍ}ɽɕ}хɽɕlɽɕ}х̝u( ɽɕЁمє͔ɥ̰ɥѥٕЁ٥(IєѡЁѼɽɕЁݥѠȵ́ѥɭ́݅ɹ̸((є(Ʌ}}}ɕ䈰( ɅЁЁɕ䈰(1ݹȈ(l̽ɍ}Ʌ}ɕ̹Ľɍ}Ʌ}ɕ̽ѕЉt(lĽɍ}Ʌ}ɕ̽ѕЉt(ɕͥѽ}}չѥ}ѥЈ(ɕ(ɅlɅ}х̉t􀉍ɍ}Ʌ}(}̽ɍ}Ʌ}ɕ̹(͔(ɍ}Ʌ}х퍽ɅlɅ}х̝u( ɕ٥܁аɥم䰁Ցа͔ɑȵɴѥ( Ё́ȁɑȵɴ́ͥѡչѥ((є(}مՕ}͕}ɕ䈰(مՔ͔ɕ䈰(Ȉ(l̽ɍ}مՕ}ɕ̹̽ѥ}Ľɍ}مՕ}ɕ̽ѕЉt(lĽɍ}مՕ}ɕ̽ѕЈĽѥ}͹̽͡ѕЉt(ɕͥѽ}}չѥ}ѥЈ(ɕ(مՕlمՕ}х̉t􀉍ɍ}مՕ}(}̠̽ɍ}مՕ}ɕ̹̽ѥ}(ѥlɕ}х̉t􀉱}չѥ}͹͡Ј(͔(ɍ}مՕ}хمՕlمՕ}х̝u쁅ѥ}ɕ}х텹ѥlɕ}х̝u( ͕Ʌєɕ٥ɽȁI=$յѥ(хȁI=$剅յѥ́䁅ѕȁȁ͍ٕ丈((є(͕ɥ}х}ɕ䈰(Mɥ䁅хɕ䈰(Mɥ䁽ݹȈ(lM UI%Qd̽ɍ}͕ɥ}ѕхѥĽɍ}͕ɥ}ѕхѥ̽ѕЉt(lĽɍ}͕ɥ}ѕхѥ̽ѕЉt(ɕͥѽ}}չѥ}ѥЈ(ɕ(͕ɥl͕ɥ}ѕхѥ}х̉t􀉍ɍ}͕ɥ}ѕхѥ}(}̠M UI%Qd̽ɍ}͕ɥ}ѕхѥ(͔(ɍ}͕ɥ}ѕхѥ}х͕ɥl͕ɥ}ѕхѥ}х̝u( ͕ɥ䁅ɽٔɕɽ́ݡѕɹѕхѥ́ɕٕѕ( ЁȁAɥم䰁ѡɐ䁅ѕхѥ٥͕Ʌѕ丈((є(хѥ}ɕ}ɕ䈰(%хѥɕ́ɕ䈰(%хѥݹȈ(l(̽ɍ}ɑ}ɕ̹(̽ɍ}Ʌѥ}ɕ̹(Ľɍ}ɑ}ɕ̽ѕЈ(Ľɍ}Ʌѥ}ɕ̽ѕЈ(t(lĽɍ}ɑ}ɕ̽ѕЈĽɍ}Ʌѥ}ɕ̽ѕЉt(ɕͥѽ}}չѥ}ѥЈ(ɕ(ɑlɑ}х̉t􀉍ɍ}ɑ}(ɅѥlɅѥ}х̉t􀉍ɍ}Ʌѥ}(}̠̽ɍ}ɑ}ɕ̹̽ɍ}Ʌѥ}ɕ̹(͔(ɍ}ɑ}хɑlɑ}х̝u쁍ɍ}Ʌѥ}хɅѥlɅѥ}х̝u( хѥݹ͕́ɑɅѥ́٥ɔɍ͔ɽم(Qɸȁ٥ɽЁх́Ѽѡɑ((є(͕}ɕ}ɕ䈰( ͔ɕ́ɕ䈰(ݹȈ(l̽ɍ}͕}ɕ̹Ľɍ}͕}ɕ̽ѕЉt(lĽɍ}͕}ɕ̽ѕЉt(ɕͥѽ}}չѥ}ѥЈ(ɕ(͕l͕}х̉t􀉍ɍ}͕}(}̽ɍ}͕}ɕ̹(͔(ɍ}͕}х퍱͕l͕}х̝u( ѡȁ͕ͥɔՑа͕ɥ䰁ٕٔ́ɔɽم(U͔͔ɕ́́ѡɥݕɽՍЁ٥ȁɽم̸((є(ɽم}չѥ}}ɕ䈰(ɽمչѥЁɕ䈰(Mхȁɕ٥ݕȈ(l(̽ɍ}ɍ͕}ɽم}й(̽}ѥ̹(̽ݕ̼̽شܴȵɍɍ͔ɽمеչѥ(t(lĽɍ}ɍ͕}ɽم}̽ѕЉt(ɕͥѽ}}չѥ}ѥЈ(ɕ(}̠(̽ɍ}ɍ͕}ɽم}й(̽}ѥ̹(̽ݕ̼̽شܴȵɍɍ͔ɽمеչѥ((}хѕl̉t(͔(Aɍ͔ɽم̰)ѥЁɕɐչѥɔɕ͕и( х́ɕ٥܁ѡɽمЁ̰́չѥ)M=8)(- ЁЁѡɽمݽɭܸ((є(}ͥɕ}ѡɥ䈰( ȁͥɔѡɥ䈰( ȁͽȁݹȈ(lͥɑȁɴ5MA͕ɥ䁅хt(mt(ɽ͕}չѥ}}(݅ɹ(Mɑȁɴ5MA͕ɥ䁅хɕեɔȁѡɥ丈(́ѡȁٔѥͥȁɽمѠ( Ёͥȁ͕ɥ䁅ɽم̸((є(}Ց}}ѡɥ䈰( ȁՑЁA<ѡɥ䈰(ɽɕЁݹȈ(lՑЁɽمɍ͔ɑȈѡɥ䈰ٔѡɥѥt(mt(ɽ͕}չѥ}}(݅ɹ( ՑЁɽمɍ͔ɑȰѡɥ䰁ٔѡɥѥɕեɔȁи( Քѡ-I\ɍ͔ɑȁɽٔٔ( ЁՑЁݹȰA<ѠٔѡɥѥȁЁٕ݅ȸ((t(хѕ}չ̀ չѕȡѕlѥ}хєtȁѕɽم}ѕ̤(}չЀхѕ}չ̹Рɕѕ}̤(݅ɹ}չЀхѕ}չ̹Р݅ɹ(}չ(ɍ͕}ɽم}х̀􀉍ɍ}ɍ͕}ɽم}(݅ɹ}չ(ɍ͕}ɽم}х̀􀉍ɍ}ɍ͕}ɽم}ɕ}ݥѡ}݅ɹ̈(͔耀Ʌ聹ٕȀչɕݡѡ́ɕЁɥ́ѕɅȵ݅ɹ͕ѥ(ɍ͕}ɽم}х̀􀉍ɍ}ɍ͕}ɽم}ɕ䈀Ʌ聹ٕ(ɕեɕ}չѥ}̀􁱥Р(йɽ̠((ȁѕɽم}ѕ(ȁЁѕlչѥ}̉t(йхݥѠ((((ɕɸ(ɍ͕}ɽم}х̈ɍ͕}ɽم}х̰(хɝ}Ʌ}مՕ}܈хɝ}Ʌ}مՕ}ܰ(хɝ}Ʌ}مՕ}聘-I\хɝ}Ʌ}مՕ}(ɕ}х̈耉}ɍ}ɍ͕}ɽم}Ј(ͽɍ}є耠( ɍɍ͔ɽمЁ́ɕɽ͔ͅɽɕа(ɅаمՔ͕ɥ䰁ɑɅѥ̰ѥ̰ɕ٥ܵ䰁(٥ȁ-I\Ȱȁɍ͔ɽم쁥Ё́ЁمՅѥ(ՅɅѕɍ͔ѵаͥɑȰɽՍѥ(ѥєȁɕٕՔɽ((ɽم}Ʌѥٔ(ѥѱ耉-I\ȁɍ͔ɽمЈ(ɽ͔耠(ٔɽɕа͕ɥ䰁хѥݹ́չѥ(ɽمЁѡЁ͕Ʌѕ́ɽՍЁ٥ɽȵѡɥ䁥̸((Ցl(Ȉ(ݹȈ(AɽɕЁݹȈ(1ݹȈ(Mɥ䁽ݹȈ(%хѥݹȈ(t((ɽم}յ(ѕ}չЈ聱ɽم}ѕ̤(ɕ}չЈхѕ}չ̹Рɕ䈰(݅ɹ}չЈ݅ɹ}չа(}չЈ聉}չа(}չЈ聱ɕեɕ}չѥ}̤(ɕ٥}ɽ}}Ȉɽͅlɕ٥}ɽ}ul}ȉt(}}͕͔((ɽم}ѕ̈聅ɽم}ѕ̰(ɕեɕ}չѥ}̈ɕեɕ}չѥ}̰(ɕѕ}̈聍ɕѕ}̰(ɍ͕}ɽم}х}ձ̈l((ɍ͕}ɽم}х̈耉ɍ}ɍ͕}ɽم}ɕ䈰(ձ耉ɽمѕ́ɔɕ䁅ȁͥɔՑаA<ȁٔ́ɕ(((ɍ͕}ɽم}х̈耉ɍ}ɍ͕}ɽم}ɕ}ݥѡ}݅ɹ̈(ձ耉ɕɍ͔ɽم٥́ɕݡȁͥɔѡɥ䰁ՑаA<ȁٔѡɥѥɕЁ݅ɹ̈(((ɍ͕}ɽم}х̈耉ɍ}ɍ͕}ɽم}(ձ耉͕ɥ䁙ɔA$ɅЁɕɕͥյЁ͵эչѥаͥɽم٥ȁ Ё́ͅɍ͔ɽم((t(ɕ٥}ɽ}ɽͅlɕ٥}ɽ}t(ɕѕ}չѥ}ɕ̈(ɍ}ɽͅ}х̈ɽͅlɽͅ}х̉t(ɍ}͕}х̈聍͕l͕}х̉t(ɍ}ɽɕ}х̈ɽɕlɽɕ}х̉t(ɍ}Ʌ}х̈聍ɅlɅ}х̉t(ɍ}مՕ}х̈مՕlمՕ}х̉t(ɍ}͕ɥ}ѕхѥ}х͕̈ɥl͕ɥ}ѕхѥ}х̉t(ɍ}ɑ}х̈聽ɑlɑ}х̉t(ɍ}Ʌѥ}х̈聽ɅѥlɅѥ}х̉t(ѥ}ɕ}х̈聅ѥlɕ}х̉t((Ʌ}}ͥɽͅlɅ}}ͥt(՝}Ʌɽͅl՝}Ʌt(ɽم}̈(}ͥ}耉輽ܹͥi5]!Ii9](}ɐ耉輽ܹɐ]5M!!MA4(չѥ}Ј耈Ľɍ}ɍ͕}ɽم}̽ѕЈ(յхѥ耉̽ɍ}ɍ͕}ɽم}й((((ɍ}Օ}}ɽ}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(mȰt(IɸȁՔɽ͕ѥ́ȁѡ-I\хɐ(ɍ͔͕ɍ}ɍ͕}ɽم}}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ɽ͕ͅɍ}ɽͅ}}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ѥ͕ɍ}ѥ}͍ɕɑ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((͕ɍ}}͍ɥ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((}ݽɭ܀͕ɍ}}х}ݽɭ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((͔͕ɍ}͕}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ɽɕЀ͕ɍ}ɽɕ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ɅЀ͕ɍ}Ʌ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((مՔ͕ɍ}مՕ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((͕ɥ͕ɍ}͕ɥ}ѕхѥ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ɑ͕ɍ}ɑ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((Ʌѥ͕̀ɍ}Ʌѥ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ѥ͕̀ѥ}͹͡С}չ}չ̤(}хє͕}хє(ɽЀAѠ}}}|ɕͽٔɕlt((}ѠȤ(ɕɸɽЀѠ}((}̠ѡȤ(ɕɸ}ѠȁѠѡ̤((͕ѥ(͕ѥ}Ȱ(Ȱ(ɕ٥ݕȰ(ͽɍ聱mt(չѥ}聱mt(٥}Ȱ(ѥ}хєȰ(٥Ȱ(}ՕѥȰ(}ѥȰ(mȰt(ɕեɕ}}͕ѥ}ɍ}Օ}͕ѥ}(ѥ}хєЁɕ䈰݅ɹ耀Ʌ聹ٕ(Ʌ͔YՕɽȠɍՔ͕ѥхєЁɕ䰁݅ɹȁ(ɕɸ(͕ѥ}͕ѥ}(聱(ɕ٥ݕȈɕ٥ݕȰ(ͽɍ̈ͽɍ̰(չѥ}̈չѥ}̰(٥}聕٥}(ѥ}хє聍ѥ}хє(٥聕٥(}Օѥ聑}Օѥ(}ѥ聹}ѥ(((ɕѕ}̀􁱥Р(йɽ̠(ɍ͕lɕѕ}̉t(ɽͅlɕѕ}̉t(ѥlɕѕ}̉t(lɕѕ}̉t(}ݽɭlɕѕ}̉t(((}չѥ}хє((ɍ͕lɍ͕}ɽم}х̉t􀉍ɍ}ɍ͕}ɽم}(ȁɽͅlɽͅ}х̉t􀉍ɍ}ɽͅ}(ȁѥlѥ}х̉t􀉍ɍ}ѥ}(ȁl}х̉t􀉍ɍ}}(ȁ}ݽɭlݽɭ}х̉t􀉉}х}ݽɭ}(ȁɕѕ}(͔ɕ((}͕ѥ̀l(͕ѥ(ɍ͕}ɽم}Ј(Aɍ͔ɽمЈ(Aɍ͔ѕ(l̽ɍ}ɍ͕}ɽم}йĽɍ}ɍ͕}ɽم}̽ѕЉt(lĽɍ}ɍ͕}ɽم}̽ѕЈĽɍ}ɽͅ}̽ѕЉt(ɕͥѽ}}չѥ}ѥЈ(}չѥ}хє}̽ɍ}ɍ͕}ɽم}й͔(ɍ}ɍ͕}ɽم}хɍ͕lɍ͕}ɽم}х̝u( ѡȁɕ٥܁ɽمЁɔͥ(U͔ѡɽمЁ́ѡɽٕȁจ((͕ѥ(չѥ}}٥(IչѥA$٥(Aљɴɕ٥ݕȈ(l(̽ɕ}}ͥ(ѕՅ}ɍɅѽȽ}Ʌй䈰(I5(Ľнѥ̈(t(l(Ľнѥ̈(Ľݽɭ}չ̈(Ľ}ɕ̽ݽɭ}չ}(Ľɍ}Օ}}ɽ̽ѕЈ(t(ɕͥѽ}}չѥ}ѥЈ(ɕ(}չѥ}хєɕ(}̠̽ɕ}}ͥѕՅ}ɍɅѽȽ}Ʌй䈰I5(}хѕl̉t(͔(}չ}хѕl̝t쁅}Ʌ}ɕ͕}ѕՅ}ɍɅѽȽ}Ʌй䜥( љɴɕ٥ݕٕ́ɥ䁍ѥA$٥(-A$ѥ䁅٥́ѡจ((͕ѥ(}Ʌ}٥(Ʌ٥(=Ʌѽȁɕ٥ݕȈ(l͍̽ɕ}ͥхєݽɭ܁Ʌ́ɕЉt(lхєĽݽɭ}չ̈Ľ}ɕ̽ݽɭ}չ}t(ɕͥѽ}}չѥ}ѥЈ(ɕ(}̠͍̽ɕ}ͥѕՅ}ɍɅѽȽ䈤(}хѕl̉t(}хѕlɕ}ݽɭ}չ̉t(͔(ɕ}ݽɭ}չ}չ}хѕlɕ}ݽɭ}չ̝t( ѡɅѽȁ͡܁Ʌ̵Ё٥ѡͽ(IոՍЁݽɭ܁ɔٔ݅ѡɽ՝((͕ѥ(͕ɥ}}(Mɥ䁅(Mɥɕ٥ݕȈ(lM UI%Qd̽ɍ}͕ɥ}ѕхѥĽɍ}͕ɥ}ѕхѥ̽ѕЉt(lĽɍ}͕ɥ}ѕхѥ̽ѕЉt(ɕͥѽ}}չѥ}ѥЈ(ɕ(͕ɥl͕ɥ}ѕхѥ}х̉t􀉍ɍ}͕ɥ}ѕхѥ}(}̠M UI%Qd̽ɍ}͕ɥ}ѕхѥ(͔(ɍ}͕ɥ}ѕхѥ}х͕ɥl͕ɥ}ѕхѥ}х̝u( ͕ɥ͕Ʌєɕɽ́ɽѕɹѕхѥ(Ёѡɐ䁍ѥѥչѥ((͕ѥ(ɍ}ѕɵ̈( ɍѕɵ̈(1ɽɕЁɕ٥ݕ̈(l(̽ɍ}Ʌ}ɕ̹(̽ɍ}ɽɕ}ɕ̹(̽ɍ}͕}ɕ̹(t(l(Ľɍ}Ʌ}ɕ̽ѕЈ(Ľɍ}ɽɕ}ɕ̽ѕЈ(Ľɍ}͕}ɕ̽ѕЈ(t(ɕͥѽ}}չѥ}ѥЈ(ɕ(ɅlɅ}х̉t􀉍ɍ}Ʌ}(ɽɕlɽɕ}х̉t􀉍ɍ}ɽɕ}(͕l͕}х̉t􀉍ɍ}͕}(}̠(̽ɍ}Ʌ}ɕ̹(̽ɍ}ɽɕ}ɕ̹(̽ɍ}͕}ɕ̹((͔((ɍ}Ʌ}х퍽ɅlɅ}х̝u쀈(ɍ}ɽɕ}хɽɕlɽɕ}х̝u쀈(ɍ}͕}х퍱͕l͕}х̝u(( ɽɕЁɕ٥܁ѕɵ̰ɥ̰͔ٕ́ѽѡ(хȵɑȵɴՅͥѡչѥ((͕ѥ(مՕ}}ѥ̈(YՔѥ̈(ɕ٥ݕȈ(l̽ɍ}مՕ}ɕ̹̽ѥ}Ľѥ}͹̽͡ѕЉt(lĽɍ}مՕ}ɕ̽ѕЈĽѥ}͹̽͡ѕЉt(ɕͥѽ}}չѥ}ѥЈ(ɕ(مՕlمՕ}х̉t􀉍ɍ}مՕ}(ѥlɕ}х̉t􀉱}չѥ}͹͡Ј(}̠̽ɍ}مՕ}ɕ̹̽ѥ}(͔(ɍ}مՕ}хمՕlمՕ}х̝u쁅ѥ}ɕ}х텹ѥlɕ}х̝u( ѕɕ٥ЁɽȁI=$յѥ(-ɽ͕-A$хɝ͕́Ʌєɽɕչѥф((͕ѥ(хѥ}ɕ̈(%хѥɕ̈(%хѥɅѥ́ɕ٥ݕ̈(l̽ɍ}ɑ}ɕ̹̽ɍ}Ʌѥ}ɕ̹t(lĽɍ}ɑ}ɕ̽ѕЈĽɍ}Ʌѥ}ɕ̽ѕЉt(ɕͥѽ}}չѥ}ѥЈ(ɕ(ɑlɑ}х̉t􀉍ɍ}ɑ}(ɅѥlɅѥ}х̉t􀉍ɍ}Ʌѥ}(}̠̽ɍ}ɑ}ɕ̹̽ɍ}Ʌѥ}ɕ̹(͔(ɍ}ɑ}хɑlɑ}х̝u쁍ɍ}Ʌѥ}хɅѥlɅѥ}х̝u( хѥݹ͕́ɑɅѥ̰а٥( ٕЁȁ٥ɽЁ́Ѽѡɑ((͕ѥ(}}ͥ}ɕ٥܈(ͥɕ٥܈(AɽՍЁͥɕ٥ݕȈ(l(̽ɍ}Օ}}ɽ(̽}ѥ̹(̽ݕ̼̽شܴȵɍՔɽչѥ(t(lĽɍ}Օ}}ɽ̽ѕЉt(ɕͥѽ}}չѥ}ѥЈ(ɕ(}̠(̽ɍ}Օ}}ɽ(̽}ѥ̹(̽ݕ̼̽شܴȵɍՔɽչѥ((͔(Ք)ѥЁɕɐхѥɔѕ( х́Ёѡɽ̰́չѥ)M=8)(U͔)쁑Ё͔ и((͕ѥ(}ѡɥ}յ̈( ȁѡɥ䁑յ̈( ȁͽȈ(lȁͥȈՑЁݹȁɍ͔ɑȈȁAȁɥم䁅хt(mt(ɽ͕}չѥ}}(݅ɹ(9ͥȰՑЁݹȰA<ȁɥم䁅хɕեɔȁѡɥ丈(́ѡȁٔѡɥ䁅ѥ́ɕ䁙ȁ( ЁͥȰA<Aɥم䁅хȁЁٕ݅ȸ((͕ѥ(ɽՍѥ}ѕɹ}ѕхѥ̈(AɽՍѥѕɹѕхѥ̈(AɽՍѥ͕ɥ䁽ݹ̈(lɽՍѥѕ䈰ѡɐ͕ɥ䁅ѕхѥѕ͍٥t(mt(ɽ͕}չѥ}}(݅ɹ(AɽՍѥѕ䁅ѡɐ䁅ѕхѥ́ɔѕɹ٥Ёɕɕ̸( ѡȁѥե͠ɕ́ɽɽՍѥѡɐ䁕٥( Ёѕѕ䁅ѕɹѕхѥѕȁ٥ɽЁ͕ѥ((t(хѕ}չ̀ չѕȡѕlѥ}хєtȁѕ}͕ѥ̤(}չЀхѕ}չ̹Рɕѕ}̤(݅ɹ}չЀхѕ}չ̹Р݅ɹ(}չ(Օ}}х̀􀉍ɍ}Օ}}(݅ɹ}չ(Օ}}х̀􀉍ɍ}Օ}}ɕ}ݥѡ}݅ɹ̈(͔耀Ʌ聹ٕȀչɕݡѡ́ɕЁɥ́ѕɅȵ݅ɹ͕ѥ(Օ}}х̀􀉍ɍ}Օ}}ɕ䈀Ʌ聹ٕ(ɕեɕ}չѥ}̀􁱥Р(йɽ̠((ȁѕ}͕ѥ(ȁЁѕlչѥ}̉t(йхݥѠ((((ɕɸ(Օ}}х̈聑Օ}}х̰(хɝ}Ʌ}مՕ}܈хɝ}Ʌ}مՕ}ܰ(хɝ}Ʌ}مՕ}聘-I\хɝ}Ʌ}مՕ}(ɕ}х̈耉}ɍ}Օ}}ɽ(ͽɍ}є耠( ɍՔɽ́ɕɍ͔ɽمɽͅչѥ(Ʌ͕ɥ䰁ɅаمՔɑɅѥ̰ѥ̰(ɕ٥ܵ䰁٥ȁ-I\Ȱȁ쁥Ё̀(ЁمՅѥՅɅѕɍ͔ѵаͥɑȰɽՍѥ(ѥєѡɐ䁅ѕхѥȁɕٕՔɽ((}Ʌѥٔ(ѥѱ耉-I\ɍՔɽ(ɽ͔耠(ٔɽɕа͕ɥ䰁ɽՍахѥɕ٥ݕ̀(٥ɽѡЁ͕Ʌѕ́ɕɽՍЁ٥ɽȵ(ѕɹɽՍѥѥ̸((Ցl(Ȉ(ݹȈ(AɽɕЁݹȈ(1ݹȈ(Mɥ䁽ݹȈ(Aљɴɕ٥ݕȈ(%хѥݹȈ(t((}յ(͕ѥ}չЈ聱}͕ѥ̤(ɕ}չЈхѕ}չ̹Рɕ䈰(݅ɹ}չЈ݅ɹ}չа(}չЈ聉}չа(}չЈ聱ɕեɕ}չѥ}̤(ɕ٥}ɽ}}Ȉɍ͕lɕ٥}ɽ}ul}ȉt(}}͕͔((}͕ѥ̈聑}͕ѥ̰(ɕեɕ}չѥ}̈ɕեɕ}չѥ}̰(}ͥ}ѥ̈l(ȁͥȈ(ՑЁݹȁɍ͔ɑȈ(ȁAȁɥم䁅х(ɽՍѥѕ䈰(ѡɐ͕ɥ䁅ѕхѥ(t(ɕѕ}̈聍ɕѕ}̰(Օ}}х}ձ̈l((Օ}}х̈耉ɍ}Օ}}ɕ䈰(ձ耉͕ѥ́ɔɕ䁅ȁѡɥ䰁ɽՍѥȁѡɐ䁕٥ɕ́(((Օ}}х̈耉ɍ}Օ}}ɕ}ݥѡ}݅ɹ̈(ձ耉ɕɽ٥́ɕݡȁѡɥ䰁ɽՍѥѕ䰁ȁѕɹѕхѥ́ɕЁ݅ɹ̈(((Օ}}х̈耉ɍ}Օ}}(ձ耉͕ɥ䁙ɔA$ɅЁɕɕͥյЁ͵эչѥаͥ٥ȁ Ё́ͅȁ((t(ɕ٥}ɽ}ɍ͕lɕ٥}ɽ}t(ɕѕ}չѥ}ɕ̈(ɍ}ɍ͕}ɽم}х̈ɍ͕lɍ͕}ɽم}х̉t(ɍ}ɽͅ}х̈ɽͅlɽͅ}х̉t(ɍ}ѥ}х̈聍ѥlѥ}х̉t(ɍ}}х̈聑l}х̉t(}х}ݽɭ}х̈聉}ݽɭlݽɭ}х̉t(ɍ}͕}х̈聍͕l͕}х̉t(ɍ}ɽɕ}х̈ɽɕlɽɕ}х̉t(ɍ}Ʌ}х̈聍ɅlɅ}х̉t(ɍ}مՕ}х̈مՕlمՕ}х̉t(ɍ}͕ɥ}ѕхѥ}х͕̈ɥl͕ɥ}ѕхѥ}х̉t(ɍ}ɑ}х̈聽ɑlɑ}х̉t(ɍ}Ʌѥ}х̈聽ɅѥlɅѥ}х̉t(ѥ}ɕ}х̈聅ѥlɕ}х̉t((Ʌ}}ͥɍ͕lɅ}}ͥt(՝}Ʌɍ͕l՝}Ʌt(Օ}}̈(}ͥ}耉輽ܹͥi5]!Ii9](}ɐ耉輽ܹɐ]5M!!MA4(չѥ}Ј耈Ľɍ}Օ}}ɽ̽ѕЈ(յхѥ耉̽ɍ}Օ}}ɽ((((ɍ}ٕѵ}ѕ}}ɕР(͕(хɝ}Ʌ}مՕ}聥ЀU1Q} =55I %1}QIQ}Y1U}-I\(}չ聑mȰmȰut99(͕ɥ}ɽ聑mȰt99(mȰt(IɸᕍѥٕٔѵЁѕ͕ѥ́ȁѡ-I\хɐ(Օ}͕ɍ}Օ}}ɽ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ɍ͔͕ɍ}ɍ͕}ɽم}}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ɽ͕ͅɍ}ɽͅ}}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ѥ͕ɍ}ѥ}͍ɕɑ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((͕ɍ}}͍ɥ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((}ݽɭ܀͕ɍ}}х}ݽɭ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((͔͕ɍ}͕}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ɽɕЀ͕ɍ}ɽɕ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ɅЀ͕ɍ}Ʌ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((مՔ͕ɍ}مՕ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((͕ɥ͕ɍ}͕ɥ}ѕхѥ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ɑ͕ɍ}ɑ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((Ʌѥ͕̀ɍ}Ʌѥ}ɕ}ɕР(хɝ}Ʌ}مՕ}хɝ}Ʌ}مՕ}ܰ(}չ}չ̰(͕ɥ}ɽ͕ɥ}ɽ((ѥ͕̀ѥ}͹͡С}չ}չ̤(}хє͕}хє(ɽЀAѠ}}}|ɕͽٔɕlt((}ѠȤ(ɕɸɽЀѠ}((}̠ѡȤ(ɕɸ}ѠȁѠѡ̤((͕ѥ(͕ѥ}Ȱ(Ȱ(ɕ٥ݕȰ(ͽɍ聱mt(չѥ}聱mt(٥}Ȱ(ѥ}хєȰ(٥Ȱ(ѕ}ՕѥȰ(}ѥȰ(mȰt(ɕեɕ}}͕ѥ}ɍ}ٕѵ}ѕ͕ѥ}(ѥ}хєЁɕ䈰݅ɹ耀Ʌ聹ٕ(Ʌ͔YՕɽȠɍٕѵЁѕ͕ѥхєЁɕ䰁݅ɹȁ(ɕɸ(͕ѥ}͕ѥ}(聱(ɕ٥ݕȈɕ٥ݕȰ(ͽɍ̈ͽɍ̰(չѥ}̈չѥ}̰(٥}聕٥}(ѥ}хє聍ѥ}хє(٥聕٥(ѕ}Օѥ聍ѕ}Օѥ(}ѥ聹}ѥ(((ɕѕ}̀􁱥Р(йɽ̠(Օ}lɕѕ}̉t(ɍ͕lɕѕ}̉t(ɽͅlɕѕ}̉t(ѥlɕѕ}̉t(lɕѕ}̉t(}ݽɭlɕѕ}̉t(((}չѥ}хє((Օ}lՕ}}х̉t􀉍ɍ}Օ}}(ȁɍ͕lɍ͕}ɽم}х̉t􀉍ɍ}ɍ͕}ɽم}(ȁɽͅlɽͅ}х̉t􀉍ɍ}ɽͅ}(ȁѥlѥ}х̉t􀉍ɍ}ѥ}(ȁl}х̉t􀉍ɍ}}(ȁ}ݽɭlݽɭ}х̉t􀉉}х}ݽɭ}(ȁɕѕ}(͔ɕ((}͕ѥ̀l(͕ѥ(ᕍѥٕ}ɕѥ(ᕍѥٔɕѥ(%ٕѵЁѕȈ(l(̽ɍ}ٕѵ}ѕ}(̽}ѥ̹(̽ݕ̼̽شܴȵɍٕѵеѕչѥ(t(lĽɍ}ٕѵ}ѕ}̽ѕЉt(ɕͥѽ}}չѥ}ѥЈ(}չѥ}хє(}̠(̽ɍ}ٕѵ}ѕ}(̽}ѥ̹(̽ݕ̼̽شܴȵɍٕѵеѕչѥ((͔(%ٕѵЁѕ)ѥЁɕɐхѥɔѕ( ѡѕɕѡ-I\ɍ͔ѠݥѠЁѥ(U͔ѡ́́ѡᕍѥٕٔͥȁѥи((͕ѥ(}ɽ}ɕ䈰(Քɽɕ䈰(ݹȈ(l̽ɍ}Օ}}ɽĽɍ}Օ}}ɽ̽ѕЉt(lĽɍ}Օ}}ɽ̽ѕЉt(ɕͥѽ}}չѥ}ѥЈ(}չѥ}хє}̽ɍ}Օ}}ɽ͔(ɍ}Օ}}хՕ}lՕ}}х̝u( ѡЁѼєɽ(IɕՔɽ͕ѥ́ѕѥ٥((͕ѥ(ɍ͕}ɽم}ɕ䈰(Aɍ͔ɽمɕ䈰(Aɍ͔ͽȈ(l̽ɍ}ɍ͕}ɽم}йĽɍ}ɍ͕}ɽم}̽ѕЉt(lĽɍ}ɍ͕}ɽم}̽ѕЉt(ɕͥѽ}}չѥ}ѥЈ(}չѥ}хє}̽ɍ}ɍ͕}ɽم}й͔(ɍ}ɍ͕}ɽم}хɍ͕lɍ͕}ɽم}х̝u( ѡѕ͕ɽɕа͕ɥ䰁хѥѕ(U͔ѡɍ͔ɽمЁ́ѕ((͕ѥ(}͔(͔(Ȉ(l̽ɍ}مՕ}ɕ̹̽ѥ}Ľѥ}͹̽͡ѕЉt(lĽɍ}مՕ}ɕ̽ѕЈĽѥ}͹̽͡ѕЉt(ɕͥѽ}}չѥ}ѥЈ(ɕ(مՕlمՕ}х̉t􀉍ɍ}مՕ}(ѥlɕ}х̉t􀉱}չѥ}͹͡Ј(}̠̽ɍ}مՕ}ɕ̹̽ѥ}(͔(ɍ}مՕ}хمՕlمՕ}х̝u쁅ѥ}ɕ}х텹ѥlɕ}х̝u(́ѡ͕Ʌєɕ٥ɽȁI=$յѥ(хȁI=$䁅ѕȁȁ͍ٕ́и((͕ѥ(ɥͭ}}͕ɥ}յ䈰(I͕ͬɥյ䈰(Mɥɕ٥ݕȈ(lM UI%Qd̽ɍ}͕ɥ}ѕхѥĽɍ}͕ɥ}ѕхѥ̽ѕЉt(lĽɍ}͕ɥ}ѕхѥ̽ѕЉt(ɕͥѽ}}չѥ}ѥЈ(ɕ(͕ɥl͕ɥ}ѕхѥ}х̉t􀉍ɍ}͕ɥ}ѕхѥ}(}̠M UI%Qd̽ɍ}͕ɥ}ѕхѥ(͔(ɍ}͕ɥ}ѕхѥ}х͕ɥl͕ɥ}ѕхѥ}х̝u(ɔ͕ɥɥͭ́ЁݥѡЁѕɹѥѥ(-ѡɐ䁅ѕхѥͥɕ٥((͕ѥ(ɍ}ѕɵ}յ䈰( ɍѕɵ́յ䈰(1ɽɕЁɕ٥ݕ̈(l(̽ɍ}Ʌ}ɕ̹(̽ɍ}ɽɕ}ɕ̹(̽ɍ}͕}ɕ̹(t(l(Ľɍ}Ʌ}ɕ̽ѕЈ(Ľɍ}ɽɕ}ɕ̽ѕЈ(Ľɍ}͕}ɕ̽ѕЈ(t(ɕͥѽ}}չѥ}ѥЈ(ɕ(ɅlɅ}х̉t􀉍ɍ}Ʌ}(ɽɕlɽɕ}х̉t􀉍ɍ}ɽɕ}(͕l͕}х̉t􀉍ɍ}͕}(}̠(̽ɍ}Ʌ}ɕ̹(̽ɍ}ɽɕ}ɕ̹(̽ɍ}͕}ɕ̹((͔((ɍ}Ʌ}х퍽ɅlɅ}х̝u쀈(ɍ}ɽɕ}хɽɕlɽɕ}х̝u쀈(ɍ}͕}х퍱͕l͕}х̝u(( ɽɕЁѥ́ɽٕȁɅ(хɑȵɴх́䁅ѕȁȁɕ٥ܸ((͕ѥ(хѥ}ɕ}յ䈰(%хѥɕ́յ䈰(%хѥݹȈ(l̽ɍ}ɑ}ɕ̹̽ɍ}Ʌѥ}ɕ̹t(lĽɍ}ɑ}ɕ̽ѕЈĽɍ}Ʌѥ}ɕ̽ѕЉt(ɕͥѽ}}չѥ}ѥЈ(ɕ(ɑlɑ}х̉t􀉍ɍ}ɑ}(ɅѥlɅѥ}х̉t􀉍ɍ}Ʌѥ}(}̠̽ɍ}ɑ}ɕ̹̽ɍ}Ʌѥ}ɕ̹(͔(ɍ}ɑ}хɑlɑ}х̝u쁍ɍ}Ʌѥ}хɅѥlɅѥ}х̝u( хѥхЁѕȁȁ٥ɽЁх́ɔ( ٕЁȁ٥ɽЁх́Ѽѡɑ((͕ѥ(ͥ}}}ɕ٥܈(ͥɕ٥܈(AɽՍЁͥɕ٥ݕȈ(l̽}ѥ̹̽ɍ}ٕѵ}ѕ}t(lĽɍ}ٕѵ}ѕ}̽ѕЉt(ɕͥѽ}}չѥ}ѥЈ(ɕ䈁}̠̽}ѥ̹̽ɍ}ٕѵ}ѕ}͔()܁AɽՍЁ͍ͥɔɕɑݥѡЁ и( х́Ёѡ܁)չѥ)M=8(- ЁЁѡѕݽɭܸ((͕ѥ(}}ѡɥ䈰( ȁѡɥ䈰( ȁͽȈ(lᕍѥٔͽȁɽمͥȈՑЁݹȈɍ͔ɑȉt(mt(ɽ͕}չѥ}}(݅ɹ(ᕍѥٔͽȁɽمͥȰՑЁݹȰɍ͔ɑȁɕեɔȁѡɥ丈( ѡȁɽٔѡ-I\ɍ͔ѡɥ( Ёȁѡɥ䁅ѥ́ȁЁٕ݅ȸ((͕ѥ(ɽՍѥ}ѕɹ}٥(AɽՍѥѕɹ٥(AɽՍѥ͕ɥ䁽ݹ̈(lɽՍѥѕ䈰ѡɐ͕ɥ䁅ѕхѥѕ͍٥t(mt(ɽ͕}չѥ}}(݅ɹ(AɽՍѥѕ䰁ѡɐ͕ɥ䁅ѕхѥѕ͍٥ɔѕɹ̸( ѡѕɽٔݥѠɽՍѥѕɹ٥ѥɅ́ѥ( Ёѕ٥ѕȁ٥ɽЁ͕ѥ((t(хѕ}չ̀ չѕȡѕlѥ}хєtȁѕ}͕ѥ̤(}չЀхѕ}չ̹Рɕѕ}̤(݅ɹ}չЀхѕ}չ̹Р݅ɹ(}չ(ٕѵ}ѕ}х̀􀉍ɍ}ٕѵ}ѕ}(ɕѥ}х̀􀉑}}ɕ}չѥ}}ɕ(݅ɹ}չ(ٕѵ}ѕ}х̀􀉍ɍ}ٕѵ}ѕ}ɕ}ݥѡ}݅ɹ̈(ɕѥ}х̀ɕ}ݥѡ}}ѥ̈(͔耀Ʌ聹ٕȀչɕݡѕɹ٥݅ɹ͕ѥ́ɕѕɅ(ٕѵ}ѕ}х̀􀉍ɍ}ٕѵ}ѕ}ɕ䈀Ʌ聹ٕ(ɕѥ}х̀ɕɅ聹ٕ(ɕեɕ}չѥ}̀􁱥Р(йɽ̠((ȁѕ}͕ѥ(ȁЁѕlչѥ}̉t(йхݥѠ((((ɕɸ(ٕѵ}ѕ}х̈聥ٕѵ}ѕ}х̰(хɝ}Ʌ}مՕ}܈хɝ}Ʌ}مՕ}ܰ(хɝ}Ʌ}مՕ}聘-I\хɝ}Ʌ}مՕ}(ɕ}х̈耉}ɍ}ٕѵ}ѕ}(ͽɍ}є耠( ɍٕѵЁѕ́ɕՔɍ͔ɽم(ɽͅչѥɅ͕ɥ䰁ɅаمՔɑɅѥ̰ѥ̰(ɕ٥ܵ䰁٥ȁ-I\Ȱᕍѥٔɕ٥쁥Ё̀(ЁمՅѥՅɅѕɍ͔ѵаͥɑȰɽՍѥ(ѥєѡɐ䁅ѕхѥȁɕٕՔɽ((ᕍѥٕ}ɕѥ(ѥѱ耉-I\ɍٕѵЁѕ(ɕѥ}х̈ɕѥ}х̰(ɕѥ耠(Iѕɕ٥܁ݥѠȁѡɥ䰁ɽՍѥѕ䰁ѕɹ(ѕхѥѥ́Ʌ͕Ʌѕ䁙ɽɕɽՍЁ٥(ɕѥ}х̀ɕ}ݥѡ}}ѥ̈(͔Ёɕչѥɕє́ɔɕ(ɕѥ}х̀􀉑}}ɕ}չѥ}}ɕ(͔IѕɽمݥѠȁȵѥ̸((Ցl(%ٕѵЁѕȈ(Ȉ(ݹȈ(AɽɕЁݹȈ(1ݹȈ(Mɥ䁽ݹȈ(%хѥݹȈ(t((}յ(͕ѥ}չЈ聱}͕ѥ̤(ɕ}չЈхѕ}չ̹Рɕ䈰(݅ɹ}չЈ݅ɹ}չа(}չЈ聉}չа(}չЈ聱ɕեɕ}չѥ}̤(ɕ٥}ɽ}}Ȉ聑Օ}lɕ٥}ɽ}ul}ȉt(}}͕͔((}͕ѥ̈聵}͕ѥ̰(ɕեɕ}չѥ}̈ɕեɕ}չѥ}̰(ѕ}ͥ}Օѥ̈l(%́ѡɽՍЁ٥ՙЁȁ-I\ȁɕ٥(ɔȁѡɥ䁑յ́Ʌ(ɔɽՍѥѡɐ䁕٥́Ё݅ɹ(%́䁍ɕєȁɕ͕(t(}ͥ}ѥ̈聑Օ}l}ͥ}ѥ̉t(lᕍѥٔͽȁɽمٕѵЁѕͥt(ɕѕ}̈聍ɕѕ}̰(ٕѵ}ѕ}х}ձ̈l((ٕѵ}ѕ}х̈耉ɍ}ٕѵ}ѕ}ɕ䈰(ձ耉͕ѥ́ɔɕ䁅ȁѡɥ䰁ɽՍѥȁѡɐ䁕٥ɕ́(((ٕѵ}ѕ}х̈耉ɍ}ٕѵ}ѕ}ɕ}ݥѡ}݅ɹ̈(ձ耉ɕѕ٥́ɕݡȁѡɥ䰁ɽՍѥѕ䰁ȁѕɹѕхѥ́ɕЁ݅ɹ̈(((ٕѵ}ѕ}х̈耉ɍ}ٕѵ}ѕ}(ձ耉͕ɥ䁙ɔA$ɅЁɕɕͥյЁ͵эչѥаͥ٥ȁ Ё́ͅѕɕѥ((t(ɕ٥}ɽ}聑Օ}lɕ٥}ɽ}t(ɕѕ}չѥ}ɕ̈(ɍ}Օ}}х̈聑Օ}lՕ}}х̉t(ɍ}ɍ͕}ɽم}х̈ɍ͕lɍ͕}ɽم}х̉t(ɍ}ɽͅ}х̈ɽͅlɽͅ}х̉t(ɍ}ѥ}х̈聍ѥlѥ}х̉t(ɍ}}х̈聑l}х̉t(}х}ݽɭ}х̈聉}ݽɭlݽɭ}х̉t(ɍ}͕}х̈聍͕l͕}х̉t(ɍ}ɽɕ}х̈ɽɕlɽɕ}х̉t(ɍ}Ʌ}х̈聍ɅlɅ}х̉t(ɍ}مՕ}х̈مՕlمՕ}х̉t(ɍ}͕ɥ}ѕхѥ}х͕̈ɥl͕ɥ}ѕхѥ}х̉t(ɍ}ɑ}х̈聽ɑlɑ}х̉t(ɍ}Ʌѥ}х̈聽ɅѥlɅѥ}х̉t(ѥ}ɕ}х̈聅ѥlɕ}х̉t(}}չЈ聱}хѕl̉t((Ʌ}}ͥ聑Օ}lɅ}}ͥt(՝}Ʌ聑Օ}l՝}Ʌt(ѕ}̈(}ͥ}耉輽ܹͥi5]!Ii9](}ɐ耉輽ܹɐ]5M!!MA4(չѥ}Ј耈Ľɍ}ٕѵ}ѕ}̽ѕЈ(յхѥ耉̽ɍ}ٕѵ}ѕ}((((}хє(͕(ݹ}ȁ99((ɽȁ99(͔ȁ99(mȰt( եѡͽхє屽ɽ̰䰁ՑЁф(}}ͥ销􁵅İ͕ѕ̤(ɕɸ(͕̈}̡}ͥ}}ͥ锤((͕久}Р(ɽ̈聱С͕I=1}QL((ɽѥ}٥(ɅЈ͕}ɽ}ɽѕȹ͹͡Р(Յ͕}Յ}ɽѕȹ͹͡Р((ɕ}ݽɭ}չ̈l(͕}͡ѕ}ոո(ȁո͕}ɕ}չ̠(}ͥİ͕}չ}ɑȤݹ}ݹ}((t(ɕ}Ց}ٕ͕̈}ɕ}Ց}̡ٕɽɽ͔͔(ɕ}ѡɥѥ}͕ͥ̈}ɕ}ѡɥѥ}̠ͥ(͕}ѥ̠(((}͡ѕ}ո͕ո聑mȰtmȰt耀Ʌ聹ٕ(ɕɸ(ݽɭ}չ}չlݽɭ}չ}t(չlt(}չl}t(ɕѕ}Јչlɕѕ}Љt(((}}Ʌ}є͕ո聑mȰt(ɅոРɅmt(ЁɅ(ɕɸ͔(ȁѕɅ(Ё䁥ѕȁ䁥ɽ}Չхͬ̈Ј(ɕɸ͔(Ёͥхѕl̉tФȁѕlЉt́9(ɕɸ͔(ٕɥѥոРٕɥѥȁ(ɕɸոРݕȈѕٕɥѥɕͽٕɥѥ((}}}ͅ}ո͕ո聑mȰt(չlt􀉍ՍЈչl}͹͡ЉtРٕɥ}ɕեɕЁոРٕɥѥ(ɕɸ͔(ɕɸ͕}ɽ٥}፱ͥ}}չСո((}ɽ٥}፱ͥ}}չС͕ո聑mȰt(͕̀(ȁѕոРɅmt((Ѐ͕}Сѕl}t(ፕЁ-ɽ(͕̀(ѥՔ(ѕlɽtйɽ٥}፱ͥ(͕̀(ɕɸ͕((}}}ɥ͕}չ聑mȰmȰutmȰt(͠􁱽}չ̹Р(ѡ}}̀ͽѕȁ}չ́􀉕(ѽȀ􁱕͠ѡ}}̤(ͥl(}(ȁ}ѡ}}(ȁ䁥ͽѕ͠(Ё}չm}tС(t(յɅѽȀ􁑕ѽȀͥ(ɕɸ(յɅѽȈ聹յɅѽȰ(ѽȈ聑ѽȰ(مՕ}ɍЈ͕}ɍСյɅѽȰѽȤ(ͥ}̈聵ͥ(((}ɍС͕յɅѽ聥аѽ聥ФЁ9(ѽȀ(ɕɸ9(ɕɸɽչյɅѽȀѽȤȤ((}ɥѕɥ(͕(ɥѕɥ}Ȱ(Ȱ(хȰ(٥Ȱ(ɕѥȰ(mȰt(ɕեɕ}}ɥѕɥ}ͅ}ɕ̹ɥѕɥ}(х́Ё̈݅ɸ耀Ʌ聹ٕ(Ʌ͔YՕɽȠ́ͅɕ́х́Ё̰݅ɸȁ(ɕɸ(ɥѕɥ}聍ɥѕɥ}(х̈х̰(聱(٥聕٥(ɕѥɕѥ(((}}٥}ѕ(͕(ѕ}Ȱ(Ȱ(ɕ٥ݕȰ(ͽɍ聱mt(٥}Ȱ(ѥ}хєȰ(٥Ȱ(}ѥȰ(mȰt(ɕեɕ}}ѕ}}٥}йѕ}(٥}Ё(ɕ}(ɕͥѽ}ѥЈ(}ѥЈ(ɽ͕}չѥ}ɽՍѥ(ɽ͕}չѥ}}(耀Ʌ聹ٕ(Ʌ͔YՕɽȠȁ٥́م(ѥ}хєЁɕ䈰݅ɹ耀Ʌ聹ٕ(Ʌ͔YՕɽȠȁ٥ѥхєЁɕ䰁݅ɹȁ(ɕɸ(ѕ}聥ѕ}(聱(ɕ٥ݕȈɕ٥ݕȰ(ͽɍ̈ͽɍ̰(٥}聕٥}(ѥ}хє聍ѥ}хє(٥聕٥(}ѥ聹}ѥ(((}}}յ͕ѕ聱mmȰutmȰt(ѥ}չ̀ չѕȡѕlѥ}хєtȁѕѕ̤(٥}չ̀ չѕȡѕl٥}tȁѕѕ̤(ɕɸ(ѽх}ѕ̈聱ѕ̤(}ѥ}хє(ɕ聍ѥ}չ̹Рɕ䈰(݅ɹ聍ѥ}չ̹Р݅ɹ(聍ѥ}չ̹Р((}٥}(ɕ}聕٥}չ̹Рɕ}(ɕͥѽ}ѥЈ聕٥}չ̹Рɕͥѽ}ѥЈ(}ѥЈ聕٥}չ̹Р}ѥЈ(ɽ͕}չѥ}ɽՍѥ聕٥}չ̹Рɽ͕}չѥ}ɽՍѥ(ɽ͕}չѥ}}聕٥}չ̹Рɽ͕}չѥ}}((((}͕ɥ}ɕ}ɥѕɥ͕͕ɥ}ɽ聑mȰtmȰt(ѡ}͕ɥ}ɽРѡ}}}Ѡ(Օ聱mtmt(݅ɹ聱mtmt(ѡ}ͥ}ѽ(݅ɹ̹ͥɕȁѽ͡ɕ䁅ɕ͍̈(ѡ}Ё}ѽѕɹ}ɕ}ٕɥȉ(Օ̹ɕȁѽɕͥ䁑ٕЈ(͕ɥ}ɽР}Չ}(Օ̹Չ́(͕ɥ}ɽР͕}Ʌ}}ձЈ(Օ̹Ʌɔ́䁑ձЈ(С͕ɥ}ɽРɅѕ}}ɕՕ̈Ȁ(Օ̹ɕՕЁɅєѥ́ͅ(С͕ɥ}ɽР}ɕ}չ̈Ȁ(Օ̹ոɕ䁱ѥ́ͅ((Օ(х̀􀉙(٥쀈Օ̤(ɕѥIեɔɕȁѠɥمєձ̰Ʌ̰Ʌє̰ո̸(݅ɹ(х̀݅ɸ(٥쀈݅ɹ̤(ɕѥȁѕɥ͔̰Ёɕѽ́ɔѽȁمՅѥ(͔(х̀̈(ѡ}٥(ѕɹɕȁٕɥȈ(ѡ}􀉕ѕɹ}ɕ}ٕɥȈ(͔Ёѽ̈((٥􁘉ѡ}٥ɥمєձаɅ̰Ʌє̰ո́ɔɕ(ɕѥ-ѡ͔ɽ́ȁѽȵ̸((ɕɸ͕}ɥѕɥ͕ɥ}ɔMɥɔх̰٥ɕѥ((}}ɕ}ɥѕɥ͕ѥ聑mȰtmȰt(}ɥ􁹕Р(ɥȁɥѥlՅɑɅ̉tɥlɥ}t􀉱}}ɥ((ͥ􁱽}ɥРͥ}̈mt(ɥ􁱽}ɥРمՕ}ɍЈ(ɥ(х̀̈(٥͠-ɕ́ɔ(ɕѥ-ɥѕ́ѕݡɅѽȁ丈(͔(х̀݅ɸ͔ͥ(٥􁘉ɥɥ쁵ͥ윰ͥȀչ͕́Н(ɕѥͥ-ɕ͠Ʌѽȁ́ɔѽȁɕ٥ܸ(ɕɸ͕}ɥѕɥ}ɕ̈1ɕ̈х̰٥ɕѥ((}ɽ٥}ɕ}ɥѕɥ͕mȰt(չͅmt(ɕєmt(ȁЁ͕(й͕}ɰхݥѠ輼(ѥՔ(}}}ɽ٥}ɰй͕}ɰ(ѥՔ(ɕєй(͕ɱ͔й͕}ɰ(͕͍􀉡̈ȁЁйɕѥ}(չͅй(չͅ(х̀􀉙(٥􁘉չͅɽ٥ȁɕ́ȁ윰ͽѕչͅ(ɕѥÚ͔ɽ٥ȁ́ݥѠ-Xɕѥɔɕєɕ̸(͔(х̀̈(٥(ɽ٥́(Ёɕє(͔ɕєɕєɽ٥͔́́-Xɕѥ((ɕѥ-ɽ٥ȁܵЁɍЁȁɽ٥̸(ɕɸ͕}ɥѕɥɽ٥}ɕ}ͅ䈰Aɽ٥ȁɕ́ͅ䈰х̰٥ɕѥ((}ɥѕɥ}}͕ɥѕɥ聱mmȰutmȰmȰut(ɕɸɽlɥѕɥ}tɽ܁ȁɽ܁ɥѕɥ((}ɥ}}͕ɥ聱mmȰutmȰmȰut(ɕɸɽlɥ}tɽ܁ȁɽ܁ɥ((}ɍ}յхѥ}ɽ͕mȰt(ɽЀAѠ}}}|ɕͽٔɕlt(ɕեɕ}յ̀l(I5(M UI%Qd(̽ɽՍ}(̽ɕ}}ͥ(̽ѥ}(̽ɍ}ɕ̹(t(ͥ}յ̀l(յ}Ѡ(ȁյ}Ѡɕեɕ}յ(ЀɽЀյ}Ѡ}(t(ɕɸ(ɕեɕ}յ̈ɕեɕ}յ̰(ͥ}յ̈聵ͥ}յ̰(ɕ͕}չЈ聱ɕեɕ}յ̤ͥ}յ̤(ɕեɕ}չЈ聱ɕեɕ}յ̤(}͕ɥ}耡ɽЀM UI%Qd}(ͽɍ耉ɕͥѽ䁑յхѥ̈(((}ɥѕɥ}յ͕ɥѕɥ聱mmȰutmȰt(չ̀ չѕȡɽlх̉tȁɽ܁ɥѕɥ(ɕɸ(̈聍չ̹Р̈(݅ɸ聍չ̹Р݅ɸ(聍չ̹Р((()ɕ}ѕСѕȤ(5ͬɕѥ̀͡A$̰ѽ̰ݽɑ̰ɕȁ̤ɽɅ̸((́ЁͬA%$ɕ͕̰̰ьȁٕɹɥͬ(A%$́ɽѕѕ͔ѕѡɥѥѥՑЁЁ(ɽ她Ёٕɕ͔ЁA%$ͭɔɽٕ䁑ݹɕ(յȁѡЁ́ѡɕѕЀЁɕɥՅɕ͕̤((ɕѕѕ(ȁѕɸM IQ}AQQI9L(ѕɸѕɸݕȠхݥѠ(ɕѕѕɸՈэ聘эɽĥэɽȥmI Qtɕѕ(͔(ɕѕѕɸՈэ聘эɽĥmI Qtɕѕ(ɕɸɕѕ(()ɕ}مՔمՔ䤀(IٕͥɕЁɥمՕ́ݡɕ͕٥ɕ͔͡(ͥхمՔȤ(ɕɸɕ}ѕСمՔ(ͥхمՔФ(ɕɸmɕ}مՔѕȁѕمՕt(ͥхمՔФ(ɕɸɕ}مՔѕȁ䰁ѕمՔѕ̠(ɕɸمՔ()}ɕ}ɕ}}مՔمՔ䤀(ͥхمՔФ(ɕɸ(ͽѕ(ȡ䤰}ɕ}ɕ}}مՔѕ(ȁ䰁ѕمՔѕ̠(((ͥхمՔа(ɕɸ}ɕ}ɕ}}مՔѕȁѕمՔ(ͥхمՔ͕Ф(ɕɸͽѕ}ɕ}ɕ}}مՔѕȁѕمՔ((͠مՔ(ፕЁQɽ(ɕɸɕȡمՔ(ɕɸمՔ(()}}ɍ}ɕСѡ䤀(Ʌ̡ѡ(Ʌȡ͕Qͭ=ɍɅѽȰɝ䰀݅ɝ䤀mȰt(} =55I %1}IA=IQ}  !Р(ѽ9(́9((ѽ} =55I %1}IA=IQ}  !͕С(((ѡ}}}|(}ɕ}ɕ}}مՔɝ̤(}ɕ}ɕ}}مՔ݅ɝ̤((䁹Ё(mt􁵕ѡ͕ɝ̰݅ɝ̤(ɕɸmt((ѽ́Ё9(} =55I %1}IA=IQ}  !ɕ͕Сѽ((ɕɸɅ(()ȁ}ɍ}ɕ}}ɍ}ɕ}ѡСQͭ=ɍɅѽȹ}}}|ѕ̠((}ɍ}ɕ}хݥѠɍ|(}ɍ}ɕ}ݥѠ}ɕЈ(}ɍ}ɕ}ѡ((͕хȠ(Qͭ=ɍɅѽȰ(}ɍ}ɕ}(}}ɍ}ɕС}ɍ}ɕ}ѡ((()}ɕѽ}ɽСɕձ聱mmȰutmmȰut( ́ЁѕՅЁݸ(ɕmɽ܁ȁɽ܁ɕձ́ɽܹР}͐́Ё9t(ɽ聱mmȰutmt(ȁɕ(ѕ􁅹(́Ё(lՅtlՅt(l}͐tl}͐t(lՅtlՅtȁl}͐tl}͐t(ȁɕ((Ёѕ(ɽй(ɕɸɽ(()}ɕ}ɕձ聱mmȰut}Ց}͐聙Ё9mȰt9(ɕmɽ܁ȁɽ܁ɕձ́ɽܹР}͐́Ё9t(Ёɕ(ɕɸ9(}Ց}͐́Ё9(ɑmȁȁȁɕl}͐t􁍽}Ց}͑t(ɑ(Ѐ􁵅ࡅɑ耡lՅtl}͐t(ɕͽ􀉡ЁՅݥѡЁՑЈ(͔(Ѐ􁵥ɕl}͐t(ɕͽ􀉹ݥѡՑ쁍Ёѕ(͔(5᥵锁əɵа锁Ё́ѡѥɕЁѡ(еՅ䁍̤PѡЁɕՅݡЈ(Ѐ􁵅ࡵɕ耡lՅtl}͐t(ɕͽ􀉡ЁՅ쁍ЁՅՅ䁍̈(ɕɸ쉹聉ltՅ聉lՅt}͐聉l}͐tɕͽɕͽ(()}͍ɕ}ɍɅѽ䰁хͭ聱mmȰutՅ}䰁Ȱ͕}э聉(5Յ䁽ٕȁѡх͕ͬɽє́䁕مՅє٥ э(͕}эɽє(ɕɑ̀ɍɅѽȹэ}ɽєmхͭlɽЉtȁхͬхͭt(͍ɕ̀mСՅ}хͬɕɑlݕȉtȀȁхͬɕɐх̰ͭɕɑ̥t(͔(͍ɕ̀l(СՅ}хͬɍɅѽȹոmɽ耉͕ȈѕЈхͭlɽЉutlݕȉt(ȁхͬхͭ(t(ɕɸմ͍ɕ̤͍ɕ̤͍ɕ͔́(()ѥ}ɍɅѥ(ѕ聱mmȰut(хͭ聱mmȰut(Յ}(}Ց}͐聙Ё99(͕}э聉͔(mȰt(MɍɍɅѥ́ȁ᥵մՅ䁅ЁմЀѡ՝ԁɅ((ѕ́聁m쉹ȰɍɅѽȈQͭ=ɍɅѽȰu(ɍɅѽȁ͡ձɕ͠ͼ́ɕ́ѡ͕́ɍ(хͭ́聁mɽЈȰuPѡم͕쁕хͬѡɽՍ(ݕȁ͕́ѼՅ}(Յ}хͬݕ}ѕФсltPѡȝ́ɕՅ(ͥݕ́ȁՑQ́չѥ́ЁɥєՅ(}Ց}͑聽ѥIѥ􁡥еՅ䁍ݥѡ(Ցа͔ѡݥѠՑаѡЁՅȵUM((Iɹ́ȵɕՅ䀬ɕаѡAɕѼɽаɕѥ((ɕձ聱mmȰutmt(ȁєѕ(ɍɅѽȀ􁍅ѕlɍɅѽȉt(􁍅єРѼ(Յ}͍ɕ}ɍɅѽȰх̰ͭՅ}͕}э(ЀɍɅѽȹ}ѥ̠lѽх̉ul}͐t(ɕձ̹(聍ѕlt(聵(ՅɽչՅ䰀Ф(}͐ɽչаؤЁ́Ё9͔9(Յ}}͐耠(ɽչՅ䀼аȤЁ́Ё9Ѐ͔9((хͭ}չЈ聱х̤ͭ(((ɕɸ(ѥٔ耉᥵锁Յ䰁锁Ј(}Ց}͐聍}Ց}͐(ɕձ̈ͽѕ(ɕձ̰(耠(lՅt(l}͐t́9(l}͐tl}͐t́Ё9͔Р(((ɕѽ}ɽЈmltȁȁ}ɕѽ}ɽСɕձ̥t(ɕ}ɕ}ɕձ̰}Ց}͐((()ٽٕ}ɍɅѥ(ե}ɍɅѽ(͕ɍ}聑mȰmut(хͭ聱mmȰut(Յ}(Ʌѥ聥Ѐа(ձѥ聥Ѐذ(}Ց}͐聙Ё99(͕聥Ѐܰ(͕}э聉͔(mȰt(ٽٔɍɅѥ́ѽ݅ɐՅ䁅ЁЀQI%9%Qd屔͕ɍ((ȁ͕ɍ́ѽɝѼյɅє聄͕хѥ͕ѥٕ(͕ɍ}ɅєمՕ̤ե}ɍɅѽȡɕɹ́(ɕ͠Qͭ=ɍɅѽȁȁѡȁݹ́ɽ٥ȁݥɥ쁕(مՅѕ=9 PɥѥݡمՅѥ́ɕA$((ѹ́᥵́ɕՅ䰁ѡ́ɕ쁍́ݡ͔(ፕ́}Ց}͑Ʌ܁ɑ̸EՅ䁍́ɽѡ(ȝ́Յ}хͬݕȤluPٕȁɥѕ((ɹɅI͕(Ʌ̀ͽѕ͕ɍ}((Ʌ}mȰt(ɕɸɹ͕ɍ}mtȁɅ((хє聑mȰtmȰt(􁑥С(ɹɅ̤(̀m؁ȁ؁͕ɍ}mt؀􁍽mutȁ͕ɍ}mt(mtɹ̤(ɕɸ((䡍聑mȰt(ɕɸͽյ̡聍mtȁɅͽ}QՔɕ}͍͔((مՅѕ聑mȰmȰut((مՅє聑mȰtmȰt(}􁭕䡍(}䁥مՅѕ(ɕɸمՅѕm}t(ɍɅѽȀե}ɍɅѽȡ(􁍽РѼ(Յ}͍ɕ}ɍɅѽȰх̰ͭՅ}͕}э(ЀɍɅѽȹ}ѥ̠lѽх̉ul}͐t(ɕձЀ(聍}(聑С(ՅɽչՅ䰀Ф(}͐ɽչаؤЁ́Ё9͔9(Յ}}͐耠(ɽչՅ䀼аȤЁ́Ё9Ѐ͔9((хͭ}չЈ聱х̤ͭ((مՅѕm}tɕձ(ɕɸɕձ((ѹ̡ɽ聑mȰtmааt(ɽl}͐t́9(ɕɸɽlՅtР(ɑā}Ց}͐́9ȁɽl}͐t􁍽}Ց}͔͐(ɕɸɑɽlՅtɽl}͐t((Mձѥ́ͼѥ͸Ё݅єمՅѥ̤(聱mmȰutmt(͕͕mt͕Р(ݡձѥ͕ձѥа}}ͥ锡͕ɍ}(Ʌ}(䡍Ё͕(͕䡍(((ѽ聱mmȰutmt(ȁɅѥɅɅѥ̤(ɽ̀mمՅєȁt(ɽ̹ͽСѹ̰ɕٕ͔QՔ(٥ٽ̀ɽl聵İɽ̤ȥt(ѽ久(Ʌѥ聝Ʌѥ(Ј쉍٥ٽlultՅ٥ٽlulՅt}͐٥ٽlul}͐u(مՅѕ}ѽх聱مՅѕ((mСɽltȁɽ܁٥ٽt(ݡձѥ(хєɹ٥ٽ̥lt((ɕձ̀ͽѕمՅѕمՕ̠ѹ̰ɕٕ͔QՔ(ɕɸ(ѥٔ耉᥵锁Յ䰁锁Ѐٽѥ͕ɍ(}Ց}͐聍}Ց}͐(Ʌѥ̈聝Ʌѥ̰(مՅѥ̈聱مՅѕ(}ͥ锈}}ͥ锡͕ɍ}(ɕձ̈ɕձ̰(ɕѽ}ɽЈmɽltȁɽ܁}ɕѽ}ɽСɕձ̥t(ɕ}ɕ}ɕձ̰}Ց}͐(ѽ聡ѽ((()}}ͥ锡͕ɍ}聑mȰmut(ͥ销(ȁمՕ͕́ɍ}مՕ̠(ͥ销􁵅İمՕ̤(ɕɸͥ(()}ѥ}ɕ͔(ɕձ聑mȰt(Ȁ􀉍ѕՅɍɅѽȈ(Ց}Ʌ聉͔(ͅ聑mȰt99(mȰt耀Ʌ聹ٕ(]ɅɍɅѥЁ=$ѥЁѥɕ͔((ͅɥ́ɕѽչ̸͕ɕ́Ёձ((ɍɅѥ(ݽɭ}չ}ɕձйРݽɭ}չ}(ɕձlt(ٕɥѥɕձйРٕɥѥ(ɕձйР(ɽѥ}ɕͽɕձйРɽѥ}ɕͽ(ͅ}ɕɑ}ɕձйРͅ}ɕɑ}(ЈɕձйРЈ((Ց}Ʌ(ɍɅѥlɅtɕ}مՔɕձlɅt(ͅ聑mȰtɽ耉ͥхЈѕЈɕձlݕȉu(ѽ}̀ɕձйРѽ}̈(ѽ}(ͅlѽ}̉tѽ}(ЁɕձйРݕȈ(ͅlѕЉt9(͡}ɕͽɕձйР͡}ɕͽȀѽ}̈ѽ}͔́ѽ(ɕɸ(}}}ѥ}(Ј耉йѥ(ɕѕ聥Сѥѥ(聵(̈l(((ͅ聵ͅ(͡}ɕͽ聙͡}ɕͽ((t(ͅͅ(ͅ}ɕ}х̈耉ɕ́ͅЁ9͔չم(ɍɅѥمՔȁ䰁مՔɍɅѥѕ̠مՔ́Ё9((()ѕ}ѥ}ɕ͔(ɕձ聑mȰt(Ȁ􀉍ѕՅɍɅѽȈ(ͅ聑mȰt99(mȰt耀Ʌ聹ٕ(]ɅɍɅѥЁ́=$䁁ѕ}ѥĽѥ́(ɕɸ(聘Сѥѥ(Ј耉ѕ}ѥ(ɕѕ聥Сѥѥ(聵(̈l(((ѕЈɕձlݕȉt(ɽ̈9(͡}ɕͽ耉ѽ((t(ͅͅ(ͅ}ɕ}х̈耉ɕ́ͅЁ9͔չم((()}MQI5} !U9-}M%i(()}ѥ}չ̠(ɕձ聑mȰt(Ȁ􀉍ѕՅɍɅѽȈ(Ց}Ʌ聉͔(Ց}ͅ聉͔(mmȰut(ɅɍɅѥɕձЁ́=$ѥЁѥչ̸((=ɽ٥ȵɕѕͅ䁉ѕѕ݅䁕ѥѕ́ɕѕɹ(͔ɕ͕ѥѥѕ́́ɽ٥ȁͅݽձ٥єѡݥɔɅи((ݕȀɕձйРݕȈ(ѥ}}}}ѥ}(ɕѕ􁥹Сѥѥ(͔(聍ѥ}(Ј耉йѥչ(ɕѕ聍ɕѕ(聵((Ց}ͅ(͕lͅt9((չ聱mmȰutl((͔(̈l(쉥фɽ耉ͥхЉ͡}ɕͽ9(t((t(ȁ͕ЁɅݕȤ}MQI5} !U9-}M%i(􁅹ݕm͕Ѐ聽͕Ѐ}MQI5} !U9-}M%it(չ̹((͔(̈l(쉥ф쉍ѕЈ͡}ɕͽ9(t(((ѽ}̀ɕձйРѽ}̈(ѽ}(չ̹((͔(̈l(((ф(ѽ}̈l(쉥聥ఀ(ȁఁյɅєѽ}̤(t((͡}ɕͽ9((t((((ɍɅѥ(ݽɭ}չ}ɕձйРݽɭ}չ}(ɕձйР(ٕɥѥɕձйРٕɥѥ((Ց}ɅɅɕձ(ɍɅѥlɅtɕ}مՔɕձlɅt((͡}ɕͽɕձйР͡}ɕͽȀ(ѽ}̈ѽ}͔́ѽ(((͔(̈m쉥ф͡}ɕͽ聙͡}ɕͽt(ɍɅѥ(مՔȁ䰁مՔɍɅѥѕ̠مՔ́Ё9(((չ̹((ͅɕձйРͅ(ЀɕձйРЈ(Ց}ͅ(ɕ(ͥхаФ(йРɕ}х̈􀉵ɕ(ͥхͅФ((չ̹((͔(̈mt(ͅͅɕ͔9(ͅ}ɕ}х̈耉ɕɕ͔չم(((ɕɸչ(()}}}ѥ}( ɕєͥɕͥхЁ=$ѥѥѥȸ(ɕɸэեեР(()͕}ɕ}䡍չ聱mmȰut(Mɥ锁Ёѥչ́́MٕȵMЁٕ́ѕɵѕ䁁m=9u(Ʌ̀mфͽյ̡չɕ}͍͔qqȁչչt(Ʌ̹фm=9uqq(ɕɸɅ̤ \ No newline at end of file + retry_attempt = 0 + while True: + try: + attempt_start = time.perf_counter() + effort_profile = self._role_effort_profile(role) + # This loop already decides retry-same-agent vs. failover + # per attempt below; single_attempt_transport() keeps + # ModelClient's own transient-retry-with-backoff from + # stacking underneath that decision and multiplying how + # many real attempts one already-failing agent consumes + # before failover ever runs (see its docstring). A plain + # duck-typed ``client`` (any object exposing just + # ``chat()``, e.g. test doubles) has no such method, so + # this degrades to a no-op scope exactly like the + # existing ``take_usage`` duck-typing below. + single_attempt = getattr(self.client, "single_attempt_transport", None) + transport_scope = single_attempt() if callable(single_attempt) else nullcontext() + tool_scope = ( + self.client.suppress_request_tools() + if role != "worker" + and hasattr(self.client, "suppress_request_tools") + else nullcontext() + ) + with transport_scope, tool_scope: + output = ( + self.client.chat(agent, messages, effort_profile=effort_profile) + if effort_profile is not None + else self.client.chat(agent, messages) + ) + except Exception as exc: + if _is_request_too_large_error(exc): + break + every_failure_was_request_too_large = False + if agent.group_name or allowed_agent_ids is not None: + self._group_router.observe_failure(agent.id) + if isinstance(exc, ToolFallbackStoppedError): + # Deliberately terminal, even inside a free/auto virtual + # pool with untried candidates remaining: every path that + # raises this (the provider's own explicit terminal + # tool-execution-state signal via + # _provider_tool_execution_stopped, or a FAIL_CLOSED + # verdict from classify_tool_failure below) resolves to + # ambiguous_outcome, permission_denied, policy_blocked, or + # invalid_arguments -- the exact ADR 0001 safety invariants + # ("permission and policy failures never fall through to + # another agent"; "non-idempotent timeout or transport + # uncertainty never replays automatically") that a + # different candidate cannot make safer: an ambiguous + # server-side outcome is ambiguous regardless of which + # agent asks next, and authorization/policy denial must + # not be worked around by trying a different one. Do not + # convert this to failover without an explicit product + # decision distinguishing which failure kinds that would + # actually be safe for. + raise + if isinstance(exc, ProviderUpstreamError): + last_upstream_error = exc + if ( + excluded_agent_ids is not None + and exc.error_code == "model_not_found" + ): + excluded_agent_ids.add(agent.id) + self._record_failure(agent.id) + break + # The primary chat call is a bounded, side-effect-free + # model request, not a tool invocation: classify from + # the provider's own already-computed retryability + # instead of classify_tool_failure's message-text + # heuristics, so free/auto virtual-model failover can + # never be accidentally downgraded to fail-closed by + # incidental wording in an upstream error body (e.g. a + # 400 that happens to mention "invalid arguments"). + decision = classify_provider_transport_failure(exc.retryable) + elif isinstance(exc, ProviderResponseError): + if allowed_agent_ids is None: + raise + bounded_provider_response_failures += 1 + last_provider_response_error = exc + decision = classify_tool_failure(exc) + self._record_tool_fallback(agent.id, decision, retry_attempt) + self._record_failure(agent.id) + break + else: + decision = classify_tool_failure(exc) + action = decision.action + # A failed attempt is one Bernoulli stability observation + # for measured group routing regardless of what happens next. + if ( + action is ToolFallbackAction.RETRY_SAME_AGENT + and retry_attempt < retry_limit + ): + retry_attempt += 1 + self._record_tool_fallback(agent.id, decision, retry_attempt) + if decision.circuit_failure: # pragma: no branch - retry-classified failures always trip the circuit + self._record_failure(agent.id) + if self.tool_retry_backoff_seconds: + retry_ceiling = min( + self.tool_retry_backoff_seconds + * (2.0 ** min(retry_attempt - 1, 16)), + 30.0, + ) + retry_delay = self._tool_retry_jitter(0.0, retry_ceiling) + self._tool_retry_sleep(retry_delay) + continue + if action is ToolFallbackAction.RETRY_SAME_AGENT: + decision = downgrade_to_failover(decision) + action = decision.action + self._record_tool_fallback(agent.id, decision, retry_attempt) + if decision.circuit_failure: + self._record_failure(agent.id) + if action is ToolFallbackAction.FAIL_CLOSED: + raise ToolFallbackStoppedError(agent.id, decision) from None + break + # Success: one Bernoulli observation plus measured latency, and + # provider-reported completion tokens when available feeding the + # tokens-per-second EWMA (Jacobson 1988 estimator). Token counts + # are never inferred from text length or chunk counts. + usage = self.client.take_usage() if hasattr(self.client, "take_usage") else None + extras = ( + self.client.take_assistant_message() + if hasattr(self.client, "take_assistant_message") + else None + ) + self._last_assistant_message = extras + output_tokens = self._usage_completion_tokens(usage) + total_tokens = self._usage_total_tokens(usage) + if agent.group_name or allowed_agent_ids is not None: + self._group_router.observe_success( + agent.id, + time.perf_counter() - attempt_start, + output_tokens=output_tokens, + total_tokens=total_tokens, + ) + self._record_success(agent.id) + return output, agent.id, agent.model, usage + if ( + last_provider_response_error is not None + and bounded_provider_response_failures == len(candidates) + ): + raise last_provider_response_error + if candidates and every_failure_was_request_too_large: + raise ProviderRequestTooLargeError( + "request body exceeds every eligible provider limit" + ) + if last_upstream_error is not None: + raise last_upstream_error + raise RuntimeError(f"all {len(candidates)} candidate agents failed for role={role}") from None + + def _record_tool_fallback( + self, + agent_id: str, + decision: ToolFailureDecision, + retry_attempt: int, + ) -> None: + """Record a secret-free audit event for one tool fallback decision.""" + event_detail = { + "agent_id": agent_id, + "action": decision.action.value, + "failure_kind": decision.kind.value, + "reason_code": decision.reason_code, + "retry_attempt": retry_attempt, + } + observed_kind = ( + decision.kind + if decision.observed_kind is None + else decision.observed_kind + ) + if observed_kind is not decision.kind: + event_detail["observed_failure_kind"] = observed_kind.value + self._append_audit_event("tool_fallback_decision", event_detail) + + def _failover_candidates( + self, + primary: ModelAgent, + text: str, + role: str, + *, + required_tags: tuple[str, ...] = (), + allowed_agent_ids: set[str] | None = None, + prompt_context: str | None = None, + effort_profile: ReasoningEffortProfile | None = None, + ) -> list[ModelAgent]: + try: + ranked = self._ranked_agents( + text, + role, + required_tags=required_tags, + prompt_context=prompt_context, + effort_profile=effort_profile, + ) + except RuntimeError: + if required_tags: + return [] + raise + if allowed_agent_ids is not None: + ranked = [agent for agent in ranked if agent.id in allowed_agent_ids] + if allowed_agent_ids is None: + ranked = [ + agent + for agent in ranked + if ( + canonical_group_name(agent.group_name) + == canonical_group_name(primary.group_name) + if primary.group_name and agent.group_name + else not primary.group_name and not agent.group_name + ) + ] + ordered = ( + [primary] + if allowed_agent_ids is None or primary.id in allowed_agent_ids + else [] + ) + [agent for agent in ranked if agent.id != primary.id] + ordered = [ + agent + for agent in ordered + if not agent.disabled + and self._zdr_agent_allowed(agent) + and _is_general_chat_agent(agent) + and all(tag in agent.tags for tag in required_tags) + ] + eligible = [agent for agent in ordered if not agent.disabled and role not in agent.provider_exclusions] + healthy = [agent for agent in eligible if not self._circuit_open(agent.id)] + # If every eligible agent is circuit-open, still probe them rather than fail with no attempt. + return healthy or eligible + + def _circuit_open(self, agent_id: str) -> bool: + with self._circuit_lock: + state = self._circuit.get(agent_id) + if not state or state["failures"] < self.circuit_failure_threshold: + return False + if time.monotonic() - state["opened_at"] >= self.circuit_reset_seconds: + state["failures"] = 0.0 + state["opened_at"] = 0.0 + reset_occurred = True + else: + reset_occurred = False + if reset_occurred: + if _LOGGER.isEnabledFor(logging.DEBUG): + _LOGGER.debug("circuit_reset agent_id=%s", agent_id) + return False + return True + + def _record_failure(self, agent_id: str) -> None: + opened = False + with self._circuit_lock: + state = self._circuit.setdefault(agent_id, {"failures": 0.0, "opened_at": 0.0}) + state["failures"] += 1.0 + failures = state["failures"] + if failures >= self.circuit_failure_threshold and not state["opened_at"]: + state["opened_at"] = time.monotonic() + opened = True + if _LOGGER.isEnabledFor(logging.DEBUG): + _LOGGER.debug( + "circuit_failure agent_id=%s failures=%s threshold=%s", + agent_id, + failures, + self.circuit_failure_threshold, + ) + if opened: + _LOGGER.warning( + "circuit_opened agent_id=%s failures=%s threshold=%s reset_seconds=%s", + agent_id, + failures, + self.circuit_failure_threshold, + self.circuit_reset_seconds, + ) + + def _record_success(self, agent_id: str) -> None: + with self._circuit_lock: + cleared = self._circuit.pop(agent_id, None) + if cleared is not None and _LOGGER.isEnabledFor(logging.DEBUG): + _LOGGER.debug("circuit_cleared agent_id=%s", agent_id) + + def _agent(self, agent_id: str) -> ModelAgent: + for agent in self.candidates: + if agent.id == agent_id and _agent_matches_request_endpoint(agent): + return agent + raise KeyError(agent_id) # pragma: no cover + + def _agent_in_pool(self, agent_pool_id: str, worker_agent_id: str) -> ModelAgent: + """Resolve an agent only through the pool boundary it can belong to. + + The current persistence model has one ``default`` pool and stores + agents by ID. Keeping the pool check beside the lookup prevents a + future multi-pool change from turning separately validated path + parameters into an object-authorization bypass. + """ + if agent_pool_id != "default": + raise KeyError(agent_pool_id) + return self._agent(worker_agent_id) + + def _needs_workflow(self, text: str) -> bool: + """Route-vs-conduct decision from a strict structured triage verdict. + + Keyword hint tables are intentionally absent: keyword matching cannot + handle negation, mixed language, or tasks that quote trigger words, and + hand-tuned thresholds are not evidence. The verdict comes from one + exact-schema model call (cached by content hash) and fails closed to + the orchestrated path on any uncertainty. + """ + return bool(self._triage_fn(text)) + + def _latest_user_text(self, messages: list[ChatMessage]) -> str: + for message in reversed(messages): + if message.get("role") != "user": + continue + text = _coerce_message_content_text(message.get("content", "")) + if text: + return text + return "" # pragma: no cover + + @staticmethod + def _prompt_interaction(messages: list[ChatMessage]) -> str: + """Canonical system/developer/user interaction used as an IRT item.""" + interaction = [ + {"role": message.get("role"), "content": message.get("content")} + for message in messages + if message.get("role") in {"system", "developer", "user"} + ] + try: + return json.dumps( + interaction, + sort_keys=True, + separators=(",", ":"), + ensure_ascii=False, + ) + except (TypeError, ValueError): + return "" + + @staticmethod + def _source_image_parts(messages: list[ChatMessage]) -> list[dict[str, Any]]: + """Copy validated image parts so evidence steps receive source pixels.""" + return [ + copy.deepcopy(part) + for message in messages + if isinstance(message.get("content"), list) + for part in message["content"] + if isinstance(part, dict) and part.get("type") == "image_url" + ] + + def _model_judge_verification( + self, + task: str, + fallback: dict[str, Any], + *, + free_only: bool = False, + allowed_agent_ids: set[str] | None = None, + excluded_agent_ids: set[str] | None = None, + ) -> dict[str, Any]: + """Ask a model for a strict structured verdict and fail closed on uncertainty.""" + verifier_output = fallback.get("verifier_output", "") + if not verifier_output: + return { + "accepted": False, + "reason": "model judge requires a non-empty verifier report", + "verifier_output": verifier_output, + "judge": "model", + } + try: + components = _resolve_fast_mlsirm_components() + except Exception: # noqa: BLE001 - a broken installed judge must not bypass the required path + return { + "accepted": False, + "reason": "fast-mlsirm judge could not be loaded; verification failed closed", + "verifier_output": verifier_output, + "judge": "model", + } + if components is None: + return { + "accepted": False, + "reason": "fast-mlsirm judge is unavailable; verification failed closed", + "verifier_output": verifier_output, + "judge": "model", + } + judge_adapter: _FastMLSIJudgeAdapter | None = None + try: + judge = next( + agent + for agent in self._ranked_agents(task, "verifier", free_only=free_only) + if allowed_agent_ids is None or agent.id in allowed_agent_ids + if excluded_agent_ids is None or agent.id not in excluded_agent_ids + ) + # The judge is one bounded provider call. Do not pass the + # planning strategy ("template"/"generated") as an + # orchestration mode or recursively conduct another workflow. + judge_adapter = _FastMLSIJudgeAdapter( + self, + task, + judge.id, + mode="route", + allowed_agent_ids=allowed_agent_ids, + excluded_agent_ids=excluded_agent_ids, + ) + fast_judge = components.judge_cls( + judge_adapter, + mode="route", + accept_threshold=0.7, + ) + result = fast_judge.judge( + task=task, + answer=verifier_output, + criteria=( + components.criterion_cls( + criterion_id="evidence_quality", + description="Does the verifier output identify concrete evidence and caveats with actionable impact?", + weight=1.0, + ), + components.criterion_cls( + criterion_id="risk_signal", + description="Does the verifier output mention substantive risks and constraints with support?", + weight=1.0, + ), + ), + ) + verification = { + "accepted": result.accepted, + "reason": result.rationale, + "verifier_output": verifier_output, + "judge": "model", + } + verification.update(self._judge_adapter_accounting_fields(judge_adapter)) + # The adapter's provider-boundary capture is authoritative for + # usage. fast-mlsirm aggregates a missing trace usage into a + # non-empty zero-token mapping, which must not turn an unmeasured + # call into provider-reported zero spend here. + result_usage_has_positive_evidence = isinstance(result.usage, Mapping) and any( + type(result.usage.get(key)) is int and result.usage[key] > 0 + for key in ("prompt_tokens", "completion_tokens", "total_tokens") + ) + if result.usage and ( + judge_adapter.served_usage is not None or result_usage_has_positive_evidence + ): + verification["judge_usage"] = result.usage + verification["judge_orchestration_mode"] = result.orchestration_mode + # The provider call has already completed by this point (result + # is a real response, with judge_agent_id/judge_model/judge_usage + # already captured above) -- an invalid IRT projection is a + # publication-safety failure, not evidence the call never + # happened. Every fail-closed verdict from here on must still + # carry this accounting subset, or _run_budget_output_by_model/ + # spend_analytics (which key off exactly these fields) silently + # lose an already-incurred, real judge spend the moment + # publication is rejected (Devin review on #961). + accounting_fields = { + key: verification[key] + for key in ( + "judge_agent_id", + "judge_model", + "judge_usage", + "judge_output_text", + ) + if key in verification + } + criterion_scores = getattr(result, "criterion_scores", None) + to_irt_row = getattr(result, "to_irt_row", None) + if isinstance(criterion_scores, Mapping) and callable(to_irt_row): + try: + irt_row = to_irt_row(item_type="dichotomous") + except Exception: # noqa: BLE001 - invalid IRT projection must not be published + return { + "accepted": False, + "reason": "model judge returned an invalid multi-item IRT projection; verification failed closed", + "verifier_output": verifier_output, + "judge": "model", + **accounting_fields, + } + if ( + len(criterion_scores) < 2 + or type(irt_row) not in (tuple, list) + or len(irt_row) != len(criterion_scores) + ): + return { + "accepted": False, + "reason": "model judge returned an invalid multi-item IRT projection; verification failed closed", + "verifier_output": verifier_output, + "judge": "model", + **accounting_fields, + } + verification["judge_criterion_scores"] = dict(criterion_scores) + verification["judge_irt_item_type"] = "dichotomous" + verification["judge_irt_row"] = list(irt_row) + return verification + except components.format_error: + return { + "accepted": False, + "reason": "model judge returned an invalid structured verdict; verification failed closed", + "verifier_output": verifier_output, + "judge": "model", + **self._judge_adapter_accounting_fields(judge_adapter), + } + except Exception: # noqa: BLE001 - judge failure must not break the request + return { + "accepted": False, + "reason": "model judge unavailable; verification failed closed", + "verifier_output": verifier_output, + "judge": "model", + **self._judge_adapter_accounting_fields(judge_adapter), + } + + @staticmethod + def _judge_adapter_accounting_fields( + judge_adapter: "_FastMLSIJudgeAdapter | None", + ) -> dict[str, Any]: + """Return whatever judge spend evidence a (possibly failed) call captured. + + A malformed structured verdict, or any other failure after the + provider call itself completed, must not erase that call's real + spend from budget/spend accounting (Devin review on #961): + ``_FastMLSIJudgeAdapter`` records ``served_agent_id``/``served_model``/ + ``served_usage`` as soon as its own ``complete()``/``complete_structured()`` + returns, independently of whether the caller (fast-mlsirm) later + raises while turning that response into a verdict. ``judge_adapter`` + itself can be ``None`` when the failure happened before one was even + constructed (e.g. no eligible judge agent), in which case there is + genuinely no call to account for. + """ + if judge_adapter is None: + return {} + fields: dict[str, Any] = {} + if judge_adapter.served_agent_id is not None: + fields["judge_agent_id"] = judge_adapter.served_agent_id + if judge_adapter.served_model is not None: + fields["judge_model"] = judge_adapter.served_model + if judge_adapter.served_usage: + # A falsy served_usage (missing/invalid response usage) is left + # genuinely absent rather than fabricated as reported-zero + # (Devin review on #961, on this same fix): judge_agent_id/ + # judge_model above already keep a completed-but-unmeasured call + # attributable, and downstream budget/spend consumers derive an + # honest estimated fallback from the judge's own served_output + # text instead of trusting a fabricated "reported" usage dict. + fields["judge_usage"] = judge_adapter.served_usage + if judge_adapter.served_output is not None: + # The judge's own generated text, not the verifier_output text + # it was judging (Devin review on #961, on this same fallback + # fix): estimating "judge output tokens" from the worker + # answer it evaluated -- rather than what the judge itself + # generated -- systematically mis-sizes the estimate whenever + # the two lengths differ. + fields["judge_output_text"] = judge_adapter.served_output + return fields + + def _judge_verifier_output(self, verifier_output: str, thinker_output: str, worker_output: str) -> dict[str, Any]: + """Prepare evidence for the model judge without making a heuristic decision.""" + del thinker_output, worker_output + return { + "accepted": False, + "reason": "model judgment required; keyword matching is disabled", + "verifier_output": verifier_output, + } + + def _protected_event_detail(self, detail: dict[str, Any], pii_fields: Iterable[str]) -> dict[str, Any]: + """Encrypt explicitly declared PII fields before an event enters memory or storage.""" + fields = tuple(pii_fields) + if not fields: + return detail + encryptor = self._pii_encryptors.get(self._pii_key_name) + if encryptor is None: + encryptor = load_pii_encryptor(self._pii_key_name) + self._pii_encryptors[self._pii_key_name] = encryptor + return encryptor.encrypt_fields(detail, fields) + + def _append_audit_event( + self, + event_type: str, + detail: dict[str, Any], + *, + pii_fields: Iterable[str] = (), + stream: str = "audit", + durable: bool = True, + ) -> None: + """Append a durable event to a bounded audit stream by default.""" + event = { + "created_at": int(time.time()), + "event_type": event_type, + "event_detail": self._protected_event_detail(detail, pii_fields), + } + events = self._authorization_events if stream == "authorization" else self._audit_events + events.append(event) + if self._store is not None: + self._store.save(stream, None, event, durable=durable) + + def record_authorization_decision( + self, + *, + scope: str, + purpose: str, + allowed: bool, + reason: str, + durable: bool = False, + ) -> None: + """Record a secret-free role/purpose authorization decision.""" + self._append_audit_event( + "authorization_decision", + { + "scope": scope, + "purpose": purpose, + "allowed": bool(allowed), + "reason": reason, + }, + stream="authorization", + durable=durable, + ) + + def _infer_provider_name(self, base_url: str) -> str: + if base_url.startswith("mock://"): + return f"mock-{base_url.removeprefix('mock://')}" + if "://" in base_url: + return base_url.split("//", 1)[-1].split("/", 1)[0] + return base_url # pragma: no cover + + def _agent_to_admin_payload(self, agent: ModelAgent) -> dict[str, Any]: + return { + "id": agent.id, + "model": agent.model, + "base_url": agent.base_url, + "provider_name": agent.provider_name or self._infer_provider_name(agent.base_url), + "priority": agent.priority, + "tags": list(agent.tags), + "status": "disabled" if agent.disabled else "active", + "provider_exclusions": list(agent.provider_exclusions), + "max_output_tokens": agent.max_output_tokens, + "context_window": agent.context_window, + "stream_usage_supported": agent.stream_usage_supported, + "group_name": agent.group_name, + "group_routing": self._group_router.member_report(agent.id) if agent.group_name else None, + } + + def list_agents(self, page_number: int = 1, page_size: int = 10) -> list[dict[str, Any]]: + """Return a paginated admin-safe view of configured agents.""" + if page_number < 1 or page_size < 1: # pragma: no cover + raise ValueError("page_number/page_size must be >= 1") + start = (page_number - 1) * page_size + end = start + page_size + return [self._agent_to_admin_payload(agent) for agent in self.candidates[start:end]] + + def list_openai_models(self) -> dict[str, Any]: + """Return an OpenAI-compatible ``/v1/models`` list from the agent pool. + + Buyers discover selectable model ids without admin-scope agent pool access. + Each enabled agent model appears once; gateway default + ``contextual-orchestrator`` is always first. Disabled models are omitted + deliberately (matching real OpenAI API behavior: you only see models you + can actually call) rather than listed with a "disabled" status -- showing + an inference-scope caller a model it cannot use is its own kind of + dishonesty. Operators get disabled-agent visibility through the + admin-scope ``list_agents``/``/admin`` surface instead. + """ + created = 1_700_000_000 # stable epoch so list responses are deterministic + data: list[dict[str, Any]] = [ + { + "id": self.GATEWAY_DEFAULT_MODEL, + "object": "model", + "created": created, + "owned_by": "contextual-orchestrator", + } + ] + data.append({ + "id": self.AUTO_MODEL, + "object": "model", + "created": created, + "owned_by": "contextual-orchestrator", + }) + if any(self._is_general_free_agent(agent) for agent in self.agents): + data.append({ + "id": self.FREE_MODEL, + "object": "model", + "created": created, + "owned_by": "contextual-orchestrator", + }) + seen: set[str] = {item["id"] for item in data} + # Model-group aliases are addressable model ids (a logical name routes + # to the best measured member), so advertise them like real models. + for group in self.list_model_groups(): + if not group.get("enabled_member_count"): + continue + group_alias = str(group["group_name"]) + if group_alias in seen: + continue + seen.add(group_alias) + data.append( + { + "id": group_alias, + "object": "model", + "created": created, + "owned_by": "model_group", + } + ) + # ``self.agents`` is the enabled-only projection of ``self.candidates`` + # (maintained at every pool mutation), so no disabled agent can appear + # in this loop. + for agent in self.agents: + model_id = str(agent.model).strip() + if not model_id or model_id in seen: + continue + seen.add(model_id) + data.append( + { + "id": model_id, + "object": "model", + "created": created, + "owned_by": agent.provider_name + or self._infer_provider_name(agent.base_url) + or "agent_pool", + } + ) + return {"object": "list", "data": data} + + def get_openai_model(self, model_id: str) -> dict[str, Any]: + """Return one OpenAI model object or raise ``KeyError`` when unknown.""" + wanted = (model_id or "").strip() + if not wanted: + raise KeyError(model_id) + for item in self.list_openai_models()["data"]: + if item["id"] == wanted: + return item + raise KeyError(model_id) + + def list_recent_runs( + self, + page_number: int = 1, + page_size: int = 10, + owner_id: str | None = None, + ) -> list[dict[str, Any]]: + """Return a paginated list of recent workflow run records.""" + if page_number < 1 or page_size < 1: # pragma: no cover + raise ValueError("page_number/page_size must be >= 1") + start = (page_number - 1) * page_size + end = start + page_size + run_ids = [ + run_id + for run_id in self._run_order + if owner_id is None or self._workflow_runs[run_id].get("owner_id") == owner_id + ][start:end] + return [self._workflow_runs[run_id] for run_id in run_ids] + + def _completed_workflow_runs(self) -> list[dict[str, Any]]: + """Return workflow runs visible to completed-run consumers. + + Excludes ``batch_route``'s not-yet-judged ``pending_verification`` + rows (Devin review on #961): those are kept in ``_workflow_runs`` so + their real, already-incurred spend is never lost, but a pending row + is not a finished result and must not inflate a completed-run count, + analytics KPI, or commercial-readiness metric -- the same reasoning + that already keeps them out of ``_run_order``/``list_recent_runs``. + Spend surfaces (``spend_analytics``) deliberately keep iterating + ``_workflow_runs`` directly instead of this helper, since a pending + row's spend is real and must stay counted there. + """ + return [ + run + for run in self._workflow_runs.values() + if not run.get("pending_verification") and not run.get("failure") + ] + + def count_workflow_runs(self, owner_id: str | None = None) -> int: + """Count only completed workflow runs visible to the requested owner.""" + return sum( + owner_id is None or record.get("owner_id") == owner_id + for record in self._completed_workflow_runs() + ) + + def list_recent_audit_events( + self, + page_number: int = 1, + page_size: int = 25, + *, + role: str | None = None, + purpose: str | None = None, + ) -> list[dict[str, Any]]: + """Return recent audit events, decrypting PII only for authorized replay.""" + + if page_number < 1 or page_size < 1: # pragma: no cover + raise ValueError("page_number/page_size must be >= 1") + events = list(self._audit_events) + start = (page_number - 1) * page_size + end = start + page_size + total = len(events) + left = max(0, total - end) + right = max(0, total - start) + selected = list(reversed(events[left:right])) + if role != "admin" or purpose != "audit_replay": + return selected + restored: list[dict[str, Any]] = [] + encryptors: dict[str, Any] = {} + for event in selected: + detail = event.get("event_detail") + if not is_encrypted_detail(detail): + restored.append(event) + continue + restored_event = dict(event) + try: + metadata = detail.get(ENCRYPTED_FIELDS_KEY) + key_name = metadata.get("key_name") if isinstance(metadata, dict) else self._pii_key_name + if not isinstance(key_name, str) or not key_name: + raise PiiProtectionError("encrypted field metadata has no valid key name") + encryptor = encryptors.get(key_name) + if encryptor is None: + encryptor = load_pii_encryptor(key_name) + encryptors[key_name] = encryptor + restored_event["event_detail"] = encryptor.decrypt_fields(detail) + except PiiProtectionError: + restored_event["event_detail"] = { + **detail, + "__pii_protection_error__": "unavailable", + } + restored.append(restored_event) + return restored + + def list_recent_authorization_decisions(self, page_number: int = 1, page_size: int = 25) -> list[dict[str, Any]]: + """Return recent secret-free authorization decisions in newest-first order.""" + if page_number < 1 or page_size < 1: # pragma: no cover + raise ValueError("page_number/page_size must be >= 1") + events = list(self._authorization_events) + start = (page_number - 1) * page_size + end = start + page_size + total = len(events) + left = max(0, total - end) + right = max(0, total - start) + return list(reversed(events[left:right])) + + def record_analytics_event( + self, + event_name: str, + detail: dict[str, Any], + *, + pii_fields: Iterable[str] = (), + ) -> None: + """Record a compact in-memory analytics event without prompt or output text.""" + require_object_name(event_name, "analytics.event_name") + event = { + "event_time": int(time.time()), + "event_name": event_name, + "event_detail": redact_value(self._protected_event_detail(detail, pii_fields)), + } + self._analytics_events.append(event) + if self._store is not None: + self._store.save("analytics", None, event) + + def _run_budget_output_by_model( + self, record: Mapping[str, Any] + ) -> tuple[dict[str, int], bool]: + """Return authoritative per-model output tokens and availability.""" + model_by_agent = {agent.id: agent.model for agent in self.candidates} + output_by_model: dict[str, int] = {} + for step in record.get("trace", []): + model = step.get("model_name") or model_by_agent.get( + step.get("served_agent_id") or step.get("agent_id"), "unknown" + ) + output_tokens, _source = _step_output_tokens( + step, self.token_counter, model + ) + if output_tokens is None: + return {}, False + output_by_model[model] = output_by_model.get(model, 0) + output_tokens + verification = record.get("verification") + if isinstance(verification, Mapping): + judge_agent_id = verification.get("judge_agent_id") + if judge_agent_id is not None: + # A completed judge call (judge_agent_id is only ever set + # once one has) whose response carried no valid usage must + # still count toward the budget meter, or a run of + # unmeasured judge calls could exceed a spend cap this + # conservative-by-design check exists to enforce. Fall back + # to the same estimate-from-real-text _step_output_tokens + # already applies to worker steps with no reported usage + # (Devin review on #961: an earlier revision of this fix + # fabricated a "reported" zero-token dict instead). Estimate + # from judge_output_text (the judge's own generated + # rationale), not verifier_output (the worker answer it was + # judging) -- a second Devin review on this same fallback + # caught estimating from the wrong side of the call. + judge_model = verification.get("judge_model") or model_by_agent.get( + judge_agent_id, "unknown" + ) + completion_tokens, _judge_reported = _step_output_tokens( + { + "usage": verification.get("judge_usage"), + "output": verification.get("judge_output_text", ""), + }, + self.token_counter, + judge_model, + ) + if completion_tokens is None: + return {}, False + output_by_model[judge_model] = ( + output_by_model.get(judge_model, 0) + completion_tokens + ) + return output_by_model, True + + def _replace_workflow_run(self, record: dict[str, Any]) -> None: + """Store one run and update its constant-time budget meter atomically.""" + model_by_agent = {agent.id: agent.model for agent in self.candidates} + for step in record.get("trace", []): + if not step.get("model_name"): + agent_id = step.get("served_agent_id") or step.get("agent_id") + step["model_name"] = model_by_agent.get(agent_id, "unknown") + run_id = record["workflow_run_id"] + with self._budget_spend_lock: + previous = self._workflow_runs.get(run_id) + for sign, run in ((-1, previous), (1, record)): + if run is None: + continue + run_id_for_meter = run["workflow_run_id"] + output_by_model, available = self._run_budget_output_by_model(run) + available_for_budget = available and ( + self.budget_max_cost_usd is None + or all(model in self.price_per_million for model in output_by_model) + ) + if sign < 0: + self._budget_unavailable_run_ids.discard(run_id_for_meter) + elif not available_for_budget: + self._budget_unavailable_run_ids.add(run_id_for_meter) + for model, output_tokens in output_by_model.items(): + before = self._budget_model_output_tokens.get(model, 0) + after = before + sign * output_tokens + price = self.price_per_million.get(model) + if price is not None: + self._budget_spent_cost_usd += _cost_usd_decimal( + after, price + ) - _cost_usd_decimal(before, price) + if after: + self._budget_model_output_tokens[model] = after + else: + self._budget_model_output_tokens.pop(model, None) + self._budget_spent_output_tokens += sign * output_tokens + self._workflow_runs[run_id] = record + + def _rebuild_budget_meter(self) -> None: + """Reconcile the meter after a rare agent-pool identity change.""" + with self._budget_spend_lock: + output_by_model: dict[str, int] = {} + unavailable_run_ids: set[str] = set() + for run in self._workflow_runs.values(): + run_output, available = self._run_budget_output_by_model(run) + available_for_budget = available and ( + self.budget_max_cost_usd is None + or all(model in self.price_per_million for model in run_output) + ) + if not available_for_budget: + unavailable_run_ids.add(run["workflow_run_id"]) + for model, output_tokens in run_output.items(): + output_by_model[model] = output_by_model.get(model, 0) + output_tokens + self._budget_model_output_tokens = output_by_model + self._budget_unavailable_run_ids = unavailable_run_ids + self._budget_spent_output_tokens = sum(output_by_model.values()) + self._budget_spent_cost_usd = sum( + ( + _cost_usd_decimal(output_tokens, self.price_per_million[model]) + for model, output_tokens in output_by_model.items() + if model in self.price_per_million + ), + start=Decimal(0), + ) + + def spend_analytics(self, price_per_million: dict[str, float] | None = None) -> dict[str, Any]: + """Return provider-reported or exact-tokenizer output usage and cost.""" + prices = {**self.price_per_million, **(price_per_million or {})} + model_by_agent = {agent.id: agent.model for agent in self.candidates} + by_model: dict[str, dict[str, Any]] = {} + total_output_tokens = 0 + reported_prompt_tokens = 0 + prompt_available = True + + for run in self._workflow_runs.values(): + for step in run["trace"]: + model = step.get("model_name") or model_by_agent.get( + step.get("served_agent_id") or step.get("agent_id"), "unknown" + ) + usage = step.get("usage") + reported_prompt = ( + usage.get("prompt_tokens", usage.get("input_tokens")) + if isinstance(usage, dict) + else None + ) + if type(reported_prompt) is int and reported_prompt >= 0: + reported_prompt_tokens += reported_prompt + else: + prompt_available = False + effective, source = _step_output_tokens(step, self.token_counter, model) + bucket = by_model.setdefault( + model, + { + "output_tokens": 0, + "step_count": 0, + "reported_steps": 0, + "tokenizer_steps": 0, + "unavailable_steps": 0, + }, + ) + bucket["step_count"] += 1 + bucket[f"{source}_steps"] += 1 + if effective is not None: + bucket["output_tokens"] += effective + total_output_tokens += effective + + verification = run.get("verification") + judge_agent_id = ( + verification.get("judge_agent_id") + if isinstance(verification, Mapping) + else None + ) + if judge_agent_id is not None: + # A completed judge call (judge_agent_id is only ever set + # once one has) must stay visible here even when its + # response carried no valid usage, or a real, incurred + # judge call is silently absent from buyer-facing spend + # analytics entirely. Mirror the worker-step loop above + # exactly: estimate from the real judged text, and let + # _step_output_tokens report the honest reported/estimated + # split instead of a fabricated "reported" dict. Estimate from + # judge_output_text (the judge's own generated rationale), + # not verifier_output (the worker answer it was judging). + judge_usage = verification.get("judge_usage") + judge_text = verification.get("judge_output_text", "") + judge_model = verification.get("judge_model") or model_by_agent.get( + judge_agent_id, "unknown" + ) + effective, source = _step_output_tokens( + {"usage": judge_usage, "output": judge_text}, + self.token_counter, + judge_model, + ) + reported_prompt = ( + judge_usage.get("prompt_tokens", judge_usage.get("input_tokens")) + if isinstance(judge_usage, dict) + else None + ) + if type(reported_prompt) is int and reported_prompt >= 0: + reported_prompt_tokens += reported_prompt + else: + prompt_available = False + bucket = by_model.setdefault( + judge_model, + { + "output_tokens": 0, + "step_count": 0, + "reported_steps": 0, + "tokenizer_steps": 0, + "unavailable_steps": 0, + }, + ) + bucket["step_count"] += 1 + bucket[f"{source}_steps"] += 1 + if effective is not None: + bucket["output_tokens"] += effective + total_output_tokens += effective + + rows: list[dict[str, Any]] = [] + unpriced: list[str] = [] + total_cost_usd = Decimal(0) + output_available = True + cost_available = True + for model, bucket in sorted(by_model.items()): + model_available = bucket["unavailable_steps"] == 0 + output_available = output_available and model_available + price = prices.get(model) + cost_decimal = ( + _cost_usd_decimal(bucket["output_tokens"], price) + if price is not None and model_available + else None + ) + cost = float(cost_decimal) if cost_decimal is not None else None + if price is None: + unpriced.append(model) + cost_available = False + elif not model_available: + cost_available = False + else: + total_cost_usd += cost_decimal + if not model_available: + usage_source = "unavailable" + elif bucket["reported_steps"] == bucket["step_count"]: + usage_source = "reported" + elif bucket["tokenizer_steps"] == bucket["step_count"]: + usage_source = "tokenizer" + else: + usage_source = "mixed" + rows.append({ + "model": model, + "output_tokens": bucket["output_tokens"] if model_available else None, + "usage_source": usage_source, + "step_count": bucket["step_count"], + "price_per_million_usd": price, + "cost_usd": cost, + }) + + measurement_status = ( + "unavailable" + if not output_available or not prompt_available + else "measured" + if all(row["usage_source"] == "reported" for row in rows) + else "exact_tokenizer" + ) + candidate_prices_available = ( + self.budget_max_cost_usd is None + or all( + agent.model in prices + for agent in self.agents + if _is_general_chat_agent(agent) + ) + ) + return { + "measurement_status": measurement_status, + "source_note": ( + "Provider usage is authoritative. Exact tokenizer counts apply only to " + "declared raw textual outputs; unreconstructible usage is unavailable." + ), + "pricing_configured": bool(prices), + "totals": { + "run_count": len(self._workflow_runs), + "output_tokens": total_output_tokens if output_available else None, + "prompt_tokens": reported_prompt_tokens if prompt_available else None, + "prompt_tokens_source": "reported" if prompt_available else "unavailable", + "cost_usd": ( + float(total_cost_usd) if prices and cost_available else None + ), + "currency": "USD", + }, + "by_model": rows, + "unpriced_models": unpriced, + "budget": self._budget_block( + total_output_tokens, + float(total_cost_usd) if prices and cost_available else None, + measurement_available=output_available and candidate_prices_available, + ), + } + + def _budget_block( + self, + spent_tokens: int, + spent_cost: float | None, + *, + measurement_available: bool = True, + ) -> dict[str, Any]: + token_limit = self.budget_max_output_tokens + cost_limit = self.budget_max_cost_usd + required_available = measurement_available and ( + cost_limit is None or spent_cost is not None + ) + exceeded = bool( + required_available + and ((token_limit is not None and spent_tokens >= token_limit) + or (cost_limit is not None and spent_cost is not None and spent_cost >= cost_limit) + ) + ) + enabled = token_limit is not None or cost_limit is not None + return { + "enabled": enabled, + "max_output_tokens": token_limit, + "max_cost_usd": cost_limit, + "spent_output_tokens": spent_tokens if measurement_available else None, + "spent_cost_usd": spent_cost if required_available else None, + "remaining_output_tokens": ( + max(0, token_limit - spent_tokens) + if token_limit is not None and measurement_available + else None + ), + "remaining_cost_usd": ( + round(max(0.0, cost_limit - spent_cost), 6) + if cost_limit is not None and spent_cost is not None and required_available + else None + ), + "exceeded": exceeded, + "measurement_status": "measured" if required_available else "unavailable", + "enforcement_status": ( + "blocked_unavailable" if enabled and not required_available + else "exceeded" if exceeded + else "within_budget" + ), + } + + def budget_status(self) -> dict[str, Any]: + """Current spend-budget state (limits, spent, remaining, exceeded).""" + with self._budget_spend_lock: + spent_tokens = self._budget_spent_output_tokens + spent_cost = float(self._budget_spent_cost_usd) + candidate_prices_available = ( + self.budget_max_cost_usd is None + or all( + agent.model in self.price_per_million + for agent in self.agents + if _is_general_chat_agent(agent) + ) + ) + measurement_available = ( + not self._budget_unavailable_run_ids and candidate_prices_available + ) + return self._budget_block( + spent_tokens, + spent_cost if self.price_per_million else None, + measurement_available=measurement_available, + ) + + def analytics_snapshot(self, locale_bundles: dict[str, dict[str, str]] | None = None) -> dict[str, Any]: + """Return source-backed local KPI definitions from in-memory runtime state.""" + runs = self._completed_workflow_runs() + conducted_runs = [run for run in runs if run["mode"] == "conduct"] + trace_complete_count = sum(1 for run in conducted_runs if self._is_trace_complete(run)) + policy_safe_count = sum(1 for run in runs if self._is_policy_safe_run(run)) + event_counts = Counter(event["event_name"] for event in self._analytics_events) + successful_chat_requests = sum( + 1 + for event in self._analytics_events + if event["event_name"] == "chat_completion_requested" + and event["event_detail"].get("status_code") == 200 + ) + route_count = sum(1 for run in runs if run["mode"] == "route") + conduct_count = sum(1 for run in runs if run["mode"] == "conduct") + step_count = sum(len(run["trace"]) for run in runs) + provider_exclusion_misses = sum(self._provider_exclusion_miss_count(run) for run in runs) + locale_parity = self._locale_key_parity(locale_bundles or {}) + + return { + "measurement_status": "local_runtime_snapshot", + "source_note": "Metrics are measured from this process in-memory runtime, not production telemetry.", + "event_counts": dict(sorted(event_counts.items())), + "kpis": [ + { + "metric_name": "compatible_api_adoption", + "label": "Compatible API adoption", + "value": successful_chat_requests, + "unit": "successful_requests", + "source": "chat_completion_requested events", + }, + { + "metric_name": "trace_complete_workflow_rate", + "label": "Trace-complete workflow rate", + "numerator": trace_complete_count, + "denominator": len(conducted_runs), + "value_percent": self._percent(trace_complete_count, len(conducted_runs)), + "source": "workflow_runs conduct traces", + }, + { + "metric_name": "policy_safe_routing_rate", + "label": "Policy-safe routing rate", + "numerator": policy_safe_count, + "denominator": len(runs), + "value_percent": self._percent(policy_safe_count, len(runs)), + "source": "workflow_runs policy snapshots", + }, + ], + "drivers": [ + { + "metric_name": "route_versus_conduct_mix", + "label": "Route-versus-conduct mix", + "counts": {"route": route_count, "conduct": conduct_count}, + "source": "workflow_runs mode", + }, + { + "metric_name": "evaluation_replay_usage", + "label": "Evaluation replay usage", + "value": event_counts.get("evaluation_run_created", 0), + "unit": "runs", + "source": "evaluation_run_created events", + }, + { + "metric_name": "agent_health_coverage", + "label": "Agent health coverage", + "numerator": len([agent for agent in self.agents if agent.id and agent.model and agent.base_url]), + "denominator": len(self.agents), + "value_percent": self._percent( + len([agent for agent in self.agents if agent.id and agent.model and agent.base_url]), + len(self.agents), + ), + "source": "agent pool configuration", + }, + ], + "guardrails": [ + { + "metric_name": "provider_exclusion_miss_rate", + "label": "Provider exclusion miss rate", + "value": provider_exclusion_misses, + "denominator": step_count, + "value_percent": self._percent(provider_exclusion_misses, step_count), + "source": "workflow trace agent selections", + }, + { + "metric_name": "locale_key_parity", + "label": "Locale key parity", + **locale_parity, + "source": "admin locale bundles", + }, + ], + } + + def sales_readiness_report( + self, + locale_bundles: dict[str, dict[str, str]] | None = None, + security_profile: dict[str, Any] | None = None, + ) -> dict[str, Any]: + """Return a local, evidence-backed sales-readiness gate for enterprise pilots.""" + analytics = self.analytics_snapshot(locale_bundles=locale_bundles) + admin_state = self.admin_state() + runs = self._completed_workflow_runs() + conducted_runs = [run for run in runs if run["mode"] == "conduct"] + trace_complete_count = sum(1 for run in conducted_runs if self._is_trace_complete(run)) + event_counts = analytics["event_counts"] + criteria = [ + self._criterion( + "api_compatibility", + "OpenAI-compatible API", + "pass" if event_counts.get("chat_completion_requested", 0) > 0 else "warn", + f"{event_counts.get('chat_completion_requested', 0)} compatible chat requests recorded", + "Run a /v1/chat/completions smoke test before an enterprise evaluation.", + ), + self._criterion( + "admin_evidence", + "Operator evidence surface", + "pass" if admin_state["agents"] and admin_state["policy"] else "fail", + f"{len(admin_state['agents'])} agents, {len(admin_state['recent_audit_events'])} audit events exposed", + "Expose agent pool, policy, and audit state before positioning the product as sellable.", + ), + self._criterion( + "trace_evidence", + "Workflow trace evidence", + "pass" if trace_complete_count > 0 else "warn", + f"{trace_complete_count} complete conducted traces across {len(conducted_runs)} conducted runs", + "Run a conduct-mode workflow so access-list and verifier evidence are visible.", + ), + self._criterion( + "evaluation_replay", + "Evaluation replay", + "pass" if event_counts.get("evaluation_run_created", 0) > 0 else "warn", + f"{event_counts.get('evaluation_run_created', 0)} evaluation replay runs recorded", + "Run at least one evaluation replay before customer-facing pilot review.", + ), + self._security_posture_criterion(security_profile or {}), + self._criterion( + "analytics_truthfulness", + "Analytics truthfulness", + "pass" if analytics["measurement_status"] == "local_runtime_snapshot" else "fail", + analytics["source_note"], + "Label metrics as proposed definitions unless backed by measured runtime telemetry.", + ), + self._locale_readiness_criterion(analytics), + self._provider_egress_criterion(), + ] + summary = self._criteria_summary(criteria) + readiness_summary = {"pass": summary["pass"], "warn": summary["warn"], "fail": summary["fail"]} + if summary["fail"]: + readiness_status = "not_ready" + elif summary["warn"]: + readiness_status = "pilot_ready_with_warnings" + else: + readiness_status = "sales_ready" + + return { + "readiness_status": readiness_status, + "measurement_status": "local_runtime_snapshot", + "source_note": ( + "Sales readiness is based on this process-local runtime, configuration, and " + "documentation evidence; it is not a production compliance certificate." + ), + "summary": readiness_summary, + "readiness_summary": readiness_summary, + "criteria": criteria, + } + + def commercial_readiness_report( + self, + target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, + locale_bundles: dict[str, dict[str, str]] | None = None, + security_profile: dict[str, Any] | None = None, + ) -> dict[str, Any]: + """Return a diligence-oriented readiness gate for high-value enterprise sales.""" + sales_readiness = self.sales_readiness_report( + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + analytics = self.analytics_snapshot(locale_bundles=locale_bundles) + sales_rows = self._criteria_by_name(sales_readiness["criteria"]) + analytics_guardrails = self._metrics_by_name(analytics["guardrails"]) + documentation = self._commercial_documentation_profile() + security_profile = security_profile or {} + policy_safe_metric = self._metrics_by_name(analytics["kpis"])["policy_safe_routing_rate"] + provider_metric = analytics_guardrails["provider_exclusion_miss_rate"] + locale_metric = analytics_guardrails["locale_key_parity"] + + criteria = [ + self._criterion( + "product_capability_evidence", + "Product capability evidence", + "pass" if sales_readiness["readiness_status"] == "sales_ready" else "warn", + ( + f"sales_readiness={sales_readiness['readiness_status']}; " + f"{sales_readiness['readiness_summary']['pass']} sales criteria passing" + ), + "Resolve all sales-readiness warnings before presenting the product for a high-value diligence review.", + ), + self._criterion( + "security_and_access_control", + "Security and access control", + "pass" + if sales_rows["security_posture"]["status"] == "pass" + and sales_rows["provider_egress_safety"]["status"] == "pass" + else "fail", + ( + f"{sales_rows['security_posture']['evidence']}; " + f"{sales_rows['provider_egress_safety']['evidence']}" + ), + "Keep split admin/inference tokens, private bind defaults, hidden traces, and safe provider egress.", + ), + self._criterion( + "operational_resilience", + "Operational resilience", + "pass" + if int(security_profile.get("rate_limit_requests") or 0) > 0 + and int(security_profile.get("max_concurrent_runs") or 0) > 0 + and policy_safe_metric.get("value_percent") == 100.0 + else "warn", + ( + f"rate_limit_requests={security_profile.get('rate_limit_requests')}; " + f"max_concurrent_runs={security_profile.get('max_concurrent_runs')}; " + f"policy_safe_routing_rate={policy_safe_metric.get('value_percent')}%" + ), + "Publish production SLOs, backup policy, and incident runbooks before a production sale.", + ), + self._criterion( + "audit_and_compliance_evidence", + "Audit and compliance evidence", + "pass" + if sales_rows["trace_evidence"]["status"] == "pass" + and provider_metric.get("value") == 0 + else "warn", + ( + f"{sales_rows['trace_evidence']['evidence']}; " + f"provider_exclusion_misses={provider_metric.get('value')}" + ), + "Capture customer-specific access reports and compliance exceptions during paid pilot onboarding.", + ), + self._criterion( + "buyer_due_diligence_packet", + "Buyer due-diligence packet", + "pass" if not documentation["missing_documents"] else "warn", + ( + f"{documentation['present_count']}/{documentation['required_count']} required documents present; " + f"missing={', '.join(documentation['missing_documents']) or 'none'}" + ), + "Complete README, security, API, analytics, product, and commercial readiness documents.", + ), + self._criterion( + "support_and_localization", + "Support and localization", + "pass" if locale_metric.get("value_percent") == 100.0 and documentation["has_security_policy"] else "warn", + ( + f"locale_key_parity={locale_metric.get('value_percent')}%; " + f"security_policy={documentation['has_security_policy']}" + ), + "Keep Korean and English operator copy aligned and publish support ownership for customer operations.", + ), + self._criterion( + "commercial_value_case", + "Commercial value case", + "pass" if target_contract_value_krw >= DEFAULT_COMMERCIAL_TARGET_VALUE_KRW else "warn", + ( + f"target_contract_value_krw={target_contract_value_krw:,}; " + "value case uses compatibility API, evidence control plane, replay, and audit controls" + ), + "Anchor high-value sales review at KRW 2,000,000,000 or higher with buyer-specific ROI evidence.", + ), + ] + summary = self._criteria_summary(criteria) + commercial_summary = {"pass": summary["pass"], "warn": summary["warn"], "fail": summary["fail"]} + if commercial_summary["fail"]: + commercial_status = "not_commercial_ready" + elif commercial_summary["warn"]: + commercial_status = "commercial_ready_with_warnings" + else: + commercial_status = "commercial_ready" + + return { + "commercial_status": commercial_status, + "target_contract_value_krw": target_contract_value_krw, + "target_contract_value_display": f"KRW {target_contract_value_krw:,}", + "measurement_status": "local_due_diligence_snapshot", + "source_note": ( + "Commercial readiness is based on process-local runtime, repository documentation, " + "security configuration, and analytics evidence; it is not a valuation guarantee, " + "purchase commitment, or production compliance certificate." + ), + "summary": commercial_summary, + "commercial_summary": commercial_summary, + "criteria": criteria, + "documentation": documentation, + "sales_readiness": sales_readiness, + } + + def commercial_evidence_manifest_report( + self, + target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, + locale_bundles: dict[str, dict[str, str]] | None = None, + security_profile: dict[str, Any] | None = None, + ) -> dict[str, Any]: + """Return the evidence index for commercial readiness review.""" + commercial = self.commercial_readiness_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + analytics = self.analytics_snapshot(locale_bundles=locale_bundles) + commercial_rows = self._criteria_by_name(commercial["criteria"]) + root = Path(__file__).resolve().parents[1] + + def has_file(path: str) -> bool: + return (root / path).is_file() + + items = [ + self._buyer_evidence_item( + "product_scope", + "Product scope", + "Economic buyer", + ["README.md", "docs/product_planning.md", "docs/commercial_readiness.md"], + "repository_artifact", + "ready" if all(has_file(path) for path in ("README.md", "docs/product_planning.md", "docs/commercial_readiness.md")) else "blocked", + "Single enterprise orchestration control plane is documented.", + "Keep product scope unified for buyer review.", + ), + self._buyer_evidence_item( + "compatible_inference_api", + "Compatible inference API", + "Platform reviewer", + ["/v1/chat/completions", "docs/rest_api_design.md", "tests/test_api_contract.py"], + "repository_artifact", + "ready" if has_file("docs/rest_api_design.md") and has_file("tests/test_api_contract.py") else "blocked", + "OpenAI-compatible endpoint and API contract tests are present.", + "Restore API contract docs and tests before buyer review.", + ), + self._buyer_evidence_item( + "admin_evidence_control_plane", + "Admin evidence control plane", + "Platform operator", + ["/admin", "/admin/state", "docs/screen_design.md"], + "repository_artifact", + "ready" if has_file("docs/screen_design.md") else "blocked", + "Admin screen design and runtime state endpoint are present.", + "Restore admin evidence design before buyer review.", + ), + self._buyer_evidence_item( + "sales_readiness", + "Sales readiness", + "Product owner", + ["/api/v1/sales_readiness/latest", "tests/test_sales_readiness.py"], + "measured_local", + "ready" if commercial["sales_readiness"]["readiness_summary"]["fail"] == 0 else "blocked", + f"sales_readiness={commercial['sales_readiness']['readiness_status']}", + "Resolve sales-readiness failures before commercial review.", + ), + self._buyer_evidence_item( + "commercial_readiness", + "Commercial readiness", + "Economic buyer", + ["/api/v1/commercial_readiness/latest", "tests/test_commercial_readiness.py"], + "measured_local", + "ready" if commercial["commercial_summary"]["fail"] == 0 else "blocked", + f"commercial_status={commercial['commercial_status']}", + "Resolve commercial-readiness failures before buyer review.", + ), + self._buyer_evidence_item( + "analytics_honesty", + "Analytics honesty", + "Analytics reviewer", + ["/api/v1/analytics_snapshots/latest", "docs/analytics_spec.md"], + "measured_local", + "ready" if analytics["measurement_status"] == "local_runtime_snapshot" else "blocked", + analytics["source_note"], + "Keep measured local evidence separate from production KPI proposals.", + ), + self._buyer_evidence_item( + "access_list_evidence", + "Access-list evidence", + "Security and compliance reviewer", + ["/api/v1/access_reports/{workflow_run_id}", "docs/product_planning.md"], + "repository_artifact", + "ready" if has_file("docs/product_planning.md") else "blocked", + "Workflow trace and access-report evidence are documented.", + "Restore access-list evidence docs before compliance review.", + ), + self._buyer_evidence_item( + "evaluation_replay", + "Evaluation replay", + "Quality reviewer", + ["/api/v1/evaluation_runs", "docs/screen_design.md"], + "repository_artifact", + "ready" if has_file("docs/screen_design.md") else "blocked", + "Evaluation replay surface is documented.", + "Restore evaluation replay docs before quality review.", + ), + self._buyer_evidence_item( + "security_posture", + "Security posture", + "Security reviewer", + ["SECURITY.md", "tests/test_security_hardening.py", "CodeQL", "Dependency review", "Trivy"], + "measured_local", + "ready" if commercial_rows["security_and_access_control"]["status"] == "pass" else "blocked", + commercial_rows["security_and_access_control"]["evidence"], + "Resolve concrete security failures before buyer review.", + ), + self._buyer_evidence_item( + "visual_stakeholder_evidence", + "Visual stakeholder evidence", + "Stakeholder reviewer", + ["docs/figma_artifacts.md", "Figma design file", "FigJam board", "Figma Slides deck"], + "figma_artifact", + "ready" if has_file("docs/figma_artifacts.md") else "blocked", + "Editable Figma, FigJam, and Slides artifacts are recorded.", + "Record editable Figma artifacts before stakeholder review.", + ), + self._buyer_evidence_item( + "buyer_diligence_packet", + "Buyer diligence packet", + "Procurement reviewer", + ["docs/commercial_buyer_diligence_packet.md"], + "repository_artifact", + "ready" if has_file("docs/commercial_buyer_diligence_packet.md") else "blocked", + "Buyer questions map to evidence paths and caveats.", + "Restore the buyer diligence packet before procurement review.", + ), + self._buyer_evidence_item( + "buyer_acceptance_runbook", + "Buyer acceptance runbook", + "Procurement reviewer", + ["docs/commercial_buyer_acceptance_runbook.md"], + "repository_artifact", + "ready" if has_file("docs/commercial_buyer_acceptance_runbook.md") else "blocked", + "Go, warning, and no-go rules are documented.", + "Restore acceptance runbook before procurement review.", + ), + self._buyer_evidence_item( + "buyer_evidence_manifest", + "Buyer evidence manifest", + "Deal owner", + ["docs/commercial_buyer_evidence_manifest.md", "/api/v1/commercial_evidence_manifests/latest"], + "measured_local", + "ready" if has_file("docs/commercial_buyer_evidence_manifest.md") else "blocked", + "Buyer evidence is indexed by owner, source, evidence type, and completion state.", + "Restore the manifest document and endpoint before buyer review.", + ), + self._buyer_evidence_item( + "packaging_decision", + "Packaging decision", + "Procurement and security reviewer", + ["docs/library_research.md", "docs/commercial_plugin_operating_model.md"], + "repository_artifact", + "ready" if has_file("docs/library_research.md") and has_file("docs/commercial_plugin_operating_model.md") else "blocked", + "Single repo and one deployable product remain the current decision.", + "Document extraction triggers before changing package boundaries.", + ), + self._buyer_evidence_item( + "production_slo_support", + "Production SLO and support proof", + "Customer operations reviewer", + ["production telemetry", "incident drill records", "support ownership"], + "proposed_until_production", + "warning", + "Production SLO, incident, and support evidence require a deployed customer environment.", + "Collect production telemetry during paid onboarding.", + ), + self._buyer_evidence_item( + "buyer_specific_roi_legal", + "Buyer-specific ROI and legal proof", + "Economic buyer and procurement", + ["ROI model", "legal questionnaire", "data-processing terms", "support plan"], + "proposed_until_buyer_specific", + "warning", + "ROI, legal, procurement, and deployment evidence require a named buyer.", + "Collect buyer-specific inputs during account diligence.", + ), + ] + summary = self._buyer_manifest_summary(items) + if summary["by_completion_state"].get("blocked", 0): + manifest_status = "buyer_review_blocked" + elif summary["by_completion_state"].get("warning", 0): + manifest_status = "buyer_review_ready_with_warnings" + else: # pragma: no cover - unreachable while this report carries literal buyer-specific warning sections + manifest_status = "buyer_review_ready" # pragma: no cover + + return { + "manifest_status": manifest_status, + "target_contract_value_krw": target_contract_value_krw, + "target_contract_value_display": f"KRW {target_contract_value_krw:,}", + "measurement_status": "local_buyer_evidence_manifest", + "source_note": ( + "Buyer evidence manifest combines process-local runtime reports, repository documents, " + "Figma artifact records, and explicit production or buyer-specific caveats; it is not a " + "valuation guarantee, purchase commitment, or production compliance certificate." + ), + "summary": summary, + "items": items, + "related_runtime_reports": { + "commercial_status": commercial["commercial_status"], + "sales_readiness_status": commercial["sales_readiness"]["readiness_status"], + "analytics_measurement_status": analytics["measurement_status"], + }, + } + + def commercial_handoff_bundle_report( + self, + target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, + locale_bundles: dict[str, dict[str, str]] | None = None, + security_profile: dict[str, Any] | None = None, + ) -> dict[str, Any]: + """Return the commercial handoff bundle for sale-readiness evidence.""" + manifest = self.commercial_evidence_manifest_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + manifest_summary = manifest["summary"]["by_completion_state"] + root = Path(__file__).resolve().parents[1] + + def has_file(path: str) -> bool: + return (root / path).is_file() + + runtime_state = "blocked" if manifest_summary.get("blocked", 0) else "ready" + included_artifacts = [ + self._buyer_evidence_item( + "runtime_reports", + "Runtime reports", + "Deal owner", + [ + "/api/v1/sales_readiness/latest", + "/api/v1/commercial_readiness/latest", + "/api/v1/commercial_evidence_manifests/latest", + "/api/v1/analytics_snapshots/latest", + ], + "measured_local", + runtime_state, + ( + f"buyer_manifest_status={manifest['manifest_status']}; " + f"commercial_status={manifest['related_runtime_reports']['commercial_status']}" + ), + "Resolve runtime report blockers before buyer handoff.", + ), + self._buyer_evidence_item( + "repository_packet", + "Repository packet", + "Procurement reviewer", + [ + "README.md", + "docs/commercial_buyer_diligence_packet.md", + "docs/commercial_buyer_acceptance_runbook.md", + "docs/commercial_buyer_evidence_manifest.md", + "docs/commercial_buyer_handoff_bundle.md", + ], + "repository_artifact", + "ready" + if all( + has_file(path) + for path in ( + "README.md", + "docs/commercial_buyer_diligence_packet.md", + "docs/commercial_buyer_acceptance_runbook.md", + "docs/commercial_buyer_evidence_manifest.md", + "docs/commercial_buyer_handoff_bundle.md", + ) + ) + else "blocked", + "Buyer-facing diligence, acceptance, manifest, and handoff documents are present.", + "Restore missing buyer packet documents before procurement review.", + ), + self._buyer_evidence_item( + "figma_stakeholder_artifacts", + "Figma stakeholder artifacts", + "Stakeholder reviewer", + ["docs/figma_artifacts.md", "Figma design file", "FigJam board", "Figma Slides deck"], + "figma_artifact", + "ready" if has_file("docs/figma_artifacts.md") else "blocked", + "Editable Figma, FigJam, and Slides artifacts are recorded without Code Connect.", + "Record editable stakeholder artifacts before buyer handoff.", + ), + self._buyer_evidence_item( + "verification_commands", + "Verification commands", + "Technical reviewer", + [ + "tests/test_buyer_handoff_bundle.py", + "tests/test_buyer_evidence_manifest.py", + "tests/test_plugin_driven_artifacts.py", + "tests/test_api_contract.py", + "pytest -q", + ], + "measured_local", + "ready" + if all( + has_file(path) + for path in ( + "tests/test_buyer_handoff_bundle.py", + "tests/test_buyer_evidence_manifest.py", + "tests/test_plugin_driven_artifacts.py", + "tests/test_api_contract.py", + ) + ) + else "blocked", + "Focused contract tests and full pytest verification are named for buyer review.", + "Restore focused tests before technical buyer handoff.", + ), + self._buyer_evidence_item( + "packaging_decision", + "Packaging decision", + "Procurement and security reviewer", + ["docs/library_research.md", "docs/commercial_plugin_operating_model.md"], + "repository_artifact", + "ready" if has_file("docs/library_research.md") and has_file("docs/commercial_plugin_operating_model.md") else "blocked", + "Single repository and one deployable product remain the current decision.", + "Only extract a library after a second product, independent release cadence, or provenance trigger exists.", + ), + ] + follow_up_items = [ + self._buyer_evidence_item( + "production_handoff_readiness", + "Production handoff readiness", + "Customer operations reviewer", + ["production SLO", "incident drill", "support rota", "deployment history"], + "proposed_until_production", + "warning", + "Production SLO, incident, deployment, and support evidence require a live customer environment.", + "Collect production telemetry and support evidence during paid onboarding.", + ), + self._buyer_evidence_item( + "buyer_specific_commercial_close", + "Buyer-specific commercial close", + "Economic buyer and legal reviewer", + ["ROI model", "legal questionnaire", "data-processing terms", "support plan"], + "proposed_until_buyer_specific", + "warning", + "ROI, legal, procurement, and deployment commitments require a named buyer.", + "Collect buyer-specific inputs during account diligence.", + ), + ] + all_items = included_artifacts + follow_up_items + summary = self._buyer_manifest_summary(all_items) + if summary["by_completion_state"].get("blocked", 0): + bundle_status = "buyer_handoff_blocked" + elif summary["by_completion_state"].get("warning", 0): + bundle_status = "buyer_handoff_ready_with_warnings" + else: # pragma: no cover - unreachable while this report carries literal buyer-specific warning sections + bundle_status = "buyer_handoff_ready" # pragma: no cover + + return { + "bundle_status": bundle_status, + "target_contract_value_krw": target_contract_value_krw, + "target_contract_value_display": f"KRW {target_contract_value_krw:,}", + "measurement_status": "local_buyer_handoff_bundle", + "source_note": ( + "Buyer handoff bundle packages local runtime reports, repository documents, " + "Figma artifact records, verification commands, and explicit production or " + "buyer-specific caveats; it is not a valuation guarantee, purchase commitment, " + "or production compliance certificate." + ), + "summary": summary, + "included_artifacts": included_artifacts, + "follow_up_items": follow_up_items, + "acceptance_gates": [ + { + "gate_name": "go", + "rule": "no blocked included artifacts and concrete security checks have no failure", + }, + { + "gate_name": "warning", + "rule": "production or buyer-specific evidence remains proposed and explicitly caveated", + }, + { + "gate_name": "blocked", + "rule": "security failure, API contract regression, document mismatch, product defect, or Code Connect usage", + }, + ], + "related_runtime_reports": { + "buyer_manifest_status": manifest["manifest_status"], + **manifest["related_runtime_reports"], + }, + "library_split_decision": { + "decision": "keep_single_product", + "reason": "No second product, independent release cadence, or security provenance trigger exists.", + "allowed_future_triggers": [ + "second product requires core only", + "independent release cadence is needed", + "buyer security provenance requires package extraction", + ], + }, + "plugin_traceability": { + "figma": "editable stakeholder artifacts and FigJam workflow", + "product_design": "buyer handoff surface and admin evidence workflow", + "superpowers": "implementation plan and verification checklist", + "ponytail": "single-product packaging and no new dependency", + "data_analytics": "measured versus proposed evidence separation", + }, + } + + def buyer_evidence_manifest_report( + self, + target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, + locale_bundles: dict[str, dict[str, str]] | None = None, + security_profile: dict[str, Any] | None = None, + ) -> dict[str, Any]: + """Return the deprecated manifest alias for existing Python consumers.""" + return self.commercial_evidence_manifest_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + + def buyer_handoff_bundle_report( + self, + target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, + locale_bundles: dict[str, dict[str, str]] | None = None, + security_profile: dict[str, Any] | None = None, + ) -> dict[str, Any]: + """Return the deprecated handoff alias for existing Python consumers.""" + return self.commercial_handoff_bundle_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + + def saleability_decision_report( + self, + target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, + locale_bundles: dict[str, dict[str, str]] | None = None, + security_profile: dict[str, Any] | None = None, + ) -> dict[str, Any]: + """Return the buyer-facing saleability decision for high-value review.""" + handoff = self.commercial_handoff_bundle_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + # Blockers must be hashable, operator-readable identifiers: downstream + # readiness reports deduplicate inherited blocker lists via + # ``dict.fromkeys``, which crashes on unhashable evidence-item dicts. + concrete_blockers = [ + item["item_name"] + for item in handoff["included_artifacts"] + if item["completion_state"] == "blocked" + ] + warning_conditions = [ + item + for item in handoff["follow_up_items"] + if item["completion_state"] == "warning" + ] + if concrete_blockers: + saleability_status = "saleability_blocked" + decision_label = "Blocked by concrete defect" + elif warning_conditions: + saleability_status = "saleability_ready_with_warnings" + decision_label = "Ready for buyer diligence with explicit warnings" + else: # pragma: no cover - unreachable while handoff follow-up warnings are literal report sections + saleability_status = "saleability_ready" # pragma: no cover + decision_label = "Ready for buyer diligence" # pragma: no cover + + return { + "saleability_status": saleability_status, + "decision_label": decision_label, + "target_contract_value_krw": target_contract_value_krw, + "target_contract_value_display": f"KRW {target_contract_value_krw:,}", + "measurement_status": "local_saleability_decision", + "source_note": ( + "Saleability decision is a local buyer due-diligence gate based on runtime " + "reports, repository documents, Figma artifacts, verification commands, and " + "explicit caveats; it is not a valuation guarantee, purchase commitment, " + "or production compliance certificate." + ), + "decision_summary": { + "included_artifact_count": len(handoff["included_artifacts"]), + "blocked_count": len(concrete_blockers), + "warning_count": len(warning_conditions), + "review_process_is_blocker": False, + }, + "decision_basis": [ + { + "basis_name": "buyer_handoff_bundle", + "status": handoff["bundle_status"], + "source": "/api/v1/commercial_handoff_bundles/latest", + }, + { + "basis_name": "buyer_evidence_manifest", + "status": handoff["related_runtime_reports"]["buyer_manifest_status"], + "source": "/api/v1/commercial_evidence_manifests/latest", + }, + { + "basis_name": "commercial_readiness", + "status": handoff["related_runtime_reports"]["commercial_status"], + "source": "/api/v1/commercial_readiness/latest", + }, + { + "basis_name": "sales_readiness", + "status": handoff["related_runtime_reports"]["sales_readiness_status"], + "source": "/api/v1/sales_readiness/latest", + }, + ], + "concrete_blockers": concrete_blockers, + "warning_conditions": warning_conditions, + "review_process_policy": { + "is_blocker": False, + "non_blocker_examples": [ + "reviewer delay", + "review bot delay", + "queued model review", + "pending check without concrete failure", + ], + "blocker_definition": "concrete security, API contract, document, or product defect", + }, + "related_runtime_reports": { + "buyer_handoff_status": handoff["bundle_status"], + **handoff["related_runtime_reports"], + }, + "library_split_decision": handoff["library_split_decision"], + "plugin_traceability": handoff["plugin_traceability"], + } + + def commercial_evidence_export_report( + self, + target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, + locale_bundles: dict[str, dict[str, str]] | None = None, + security_profile: dict[str, Any] | None = None, + ) -> dict[str, Any]: + """Return a portable buyer due-diligence export index for commercial review.""" + saleability = self.saleability_decision_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + root = Path(__file__).resolve().parents[1] + + def has_file(path: str) -> bool: + return (root / path).is_file() + + concrete_blockers = saleability["concrete_blockers"] + required_external_evidence = [ + { + "evidence_name": item["item_name"], + "label": item["label"], + "reviewer": item["reviewer"], + "sources": item["sources"], + "evidence_type": item["evidence_type"], + "evidence": item["evidence"], + "next_action": item["next_action"], + } + for item in saleability["warning_conditions"] + ] + saleability_state = "blocked" if saleability["saleability_status"] == "saleability_blocked" else "ready" + export_sections = [ + self._buyer_evidence_item( + "saleability_decision", + "Saleability decision", + "Deal owner", + ["/api/v1/saleability_decisions/latest", "docs/commercial_saleability_decision.md"], + "measured_local", + saleability_state, + f"saleability_status={saleability['saleability_status']}", + "Resolve concrete saleability blockers before exporting buyer evidence.", + ), + self._buyer_evidence_item( + "runtime_reports", + "Runtime reports", + "Technical reviewer", + [ + "/api/v1/sales_readiness/latest", + "/api/v1/commercial_readiness/latest", + "/api/v1/commercial_evidence_manifests/latest", + "/api/v1/commercial_handoff_bundles/latest", + "/api/v1/saleability_decisions/latest", + "/api/v1/analytics_snapshots/latest", + ], + "measured_local", + "blocked" if concrete_blockers else "ready", + ( + f"buyer_handoff_status={saleability['related_runtime_reports']['buyer_handoff_status']}; " + f"buyer_manifest_status={saleability['related_runtime_reports']['buyer_manifest_status']}" + ), + "Resolve blocked runtime reports before buyer export.", + ), + self._buyer_evidence_item( + "buyer_packet_documents", + "Buyer packet documents", + "Procurement reviewer", + [ + "docs/commercial_buyer_diligence_packet.md", + "docs/commercial_buyer_acceptance_runbook.md", + "docs/commercial_buyer_evidence_manifest.md", + "docs/commercial_buyer_handoff_bundle.md", + "docs/commercial_saleability_decision.md", + "docs/commercial_evidence_export.md", + ], + "repository_artifact", + "ready" + if all( + has_file(path) + for path in ( + "docs/commercial_buyer_diligence_packet.md", + "docs/commercial_buyer_acceptance_runbook.md", + "docs/commercial_buyer_evidence_manifest.md", + "docs/commercial_buyer_handoff_bundle.md", + "docs/commercial_saleability_decision.md", + "docs/commercial_evidence_export.md", + ) + ) + else "blocked", + "Buyer diligence, acceptance, manifest, handoff, decision, and export documents are present.", + "Restore missing buyer packet documents before export.", + ), + self._buyer_evidence_item( + "figma_stakeholder_artifacts", + "Figma stakeholder artifacts", + "Stakeholder reviewer", + ["docs/figma_artifacts.md", "Figma design file", "FigJam board", "Figma Slides deck"], + "figma_artifact", + "ready" if has_file("docs/figma_artifacts.md") else "blocked", + "Editable stakeholder artifacts are recorded and Code Connect is excluded.", + "Record Figma artifacts before exporting buyer evidence.", + ), + self._buyer_evidence_item( + "verification_commands", + "Verification commands", + "Technical reviewer", + [ + "tests/test_commercial_evidence_export.py", + "tests/test_saleability_decision.py", + "tests/test_plugin_driven_artifacts.py", + "tests/test_api_contract.py", + "pytest -q", + ], + "measured_local", + "ready" + if all( + has_file(path) + for path in ( + "tests/test_commercial_evidence_export.py", + "tests/test_saleability_decision.py", + "tests/test_plugin_driven_artifacts.py", + "tests/test_api_contract.py", + ) + ) + else "blocked", + "Focused commercial export, saleability, plugin artifact, and API contract tests are named.", + "Restore focused tests before buyer export.", + ), + self._buyer_evidence_item( + "review_process_policy", + "Review process policy", + "Deal owner", + ["docs/commercial_saleability_decision.md", "/api/v1/saleability_decisions/latest"], + "repository_artifact", + "ready", + "Reviewer delay, review bot delay, and queued model review are not concrete blockers.", + "Escalate only concrete security, API contract, document, or product defects.", + ), + self._buyer_evidence_item( + "packaging_decision", + "Packaging decision", + "Procurement and security reviewer", + ["docs/library_research.md", "docs/commercial_plugin_operating_model.md"], + "repository_artifact", + "ready" if has_file("docs/library_research.md") and has_file("docs/commercial_plugin_operating_model.md") else "blocked", + saleability["library_split_decision"]["reason"], + "Only extract a library after a second product, independent release cadence, or provenance trigger exists.", + ), + ] + export_section_summary = self._buyer_manifest_summary(export_sections) + blocked_count = export_section_summary["by_completion_state"]["blocked"] + len(concrete_blockers) + warning_count = len(required_external_evidence) + if blocked_count: + export_status = "commercial_export_blocked" + elif warning_count: + export_status = "commercial_export_ready_with_warnings" + else: # pragma: no cover - unreachable while this report carries literal buyer-specific warning sections + export_status = "commercial_export_ready" # pragma: no cover + + return { + "export_status": export_status, + "target_contract_value_krw": target_contract_value_krw, + "target_contract_value_display": f"KRW {target_contract_value_krw:,}", + "measurement_status": "local_commercial_evidence_export", + "source_note": ( + "Commercial evidence export packages local runtime decisions, repository documents, " + "Figma artifact records, verification commands, review-process policy, packaging decision, " + "and explicit production or buyer-specific evidence gaps; it is not a valuation guarantee, " + "purchase commitment, or production compliance certificate." + ), + "export_summary": { + "section_count": len(export_sections), + "blocked_count": blocked_count, + "warning_count": warning_count, + "review_process_is_blocker": saleability["review_process_policy"]["is_blocker"], + }, + "export_sections": export_sections, + "required_external_evidence": required_external_evidence, + "concrete_blockers": concrete_blockers, + "review_process_policy": saleability["review_process_policy"], + "related_runtime_reports": { + "saleability_status": saleability["saleability_status"], + **saleability["related_runtime_reports"], + }, + "library_split_decision": saleability["library_split_decision"], + "plugin_traceability": saleability["plugin_traceability"], + "export_links": { + "figma_design_file": "https://www.figma.com/design/vsZMd8WAv42HDRgcZuNcWk", + "figjam_board": "https://www.figma.com/board/Wr8iMlB9SHkerHSjv0Pe0M", + "runtime_endpoint": "/api/v1/commercial_evidence_exports/latest", + "documentation": "docs/commercial_evidence_export.md", + }, + } + + def commercial_acceptance_check_report( + self, + target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, + locale_bundles: dict[str, dict[str, str]] | None = None, + security_profile: dict[str, Any] | None = None, + ) -> dict[str, Any]: + """Return the buyer acceptance check over the commercial evidence export.""" + evidence_export = self.commercial_evidence_export_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + root = Path(__file__).resolve().parents[1] + + def has_file(path: str) -> bool: + return (root / path).is_file() + + concrete_blockers = evidence_export["concrete_blockers"] + export_blocked = evidence_export["export_status"] == "commercial_export_blocked" + runtime_state = "blocked" if export_blocked or concrete_blockers else "ready" + acceptance_items = [ + self._buyer_evidence_item( + "runtime_endpoint_chain", + "Runtime endpoint chain", + "Technical reviewer", + [ + "/api/v1/analytics_snapshots/latest", + "/api/v1/sales_readiness/latest", + "/api/v1/commercial_readiness/latest", + "/api/v1/commercial_evidence_manifests/latest", + "/api/v1/commercial_handoff_bundles/latest", + "/api/v1/saleability_decisions/latest", + "/api/v1/commercial_evidence_exports/latest", + ], + "measured_local", + runtime_state, + f"commercial_export_status={evidence_export['export_status']}", + "Resolve blocked runtime report chain before buyer acceptance.", + ), + self._buyer_evidence_item( + "buyer_packet_documents", + "Buyer packet documents", + "Procurement reviewer", + [ + "docs/commercial_buyer_diligence_packet.md", + "docs/commercial_buyer_acceptance_runbook.md", + "docs/commercial_buyer_evidence_manifest.md", + "docs/commercial_buyer_handoff_bundle.md", + "docs/commercial_saleability_decision.md", + "docs/commercial_evidence_export.md", + "docs/commercial_acceptance_check.md", + ], + "repository_artifact", + "ready" + if all( + has_file(path) + for path in ( + "docs/commercial_buyer_diligence_packet.md", + "docs/commercial_buyer_acceptance_runbook.md", + "docs/commercial_buyer_evidence_manifest.md", + "docs/commercial_buyer_handoff_bundle.md", + "docs/commercial_saleability_decision.md", + "docs/commercial_evidence_export.md", + "docs/commercial_acceptance_check.md", + ) + ) + else "blocked", + "Buyer packet documents cover diligence, acceptance, manifest, handoff, decision, export, and check.", + "Restore missing buyer packet documents before buyer acceptance.", + ), + self._buyer_evidence_item( + "admin_operator_surface", + "Admin operator surface", + "Platform operator", + ["/admin", "contextual_orchestrator/admin.py", "/api/v1/commercial_acceptance_checks/latest"], + "repository_artifact", + "ready" if has_file("contextual_orchestrator/admin.py") else "blocked", + "Admin observability surface exposes the commercial acceptance check status with bilingual labels.", + "Expose acceptance check status in admin observability before buyer acceptance.", + ), + self._buyer_evidence_item( + "verification_evidence", + "Verification evidence", + "Technical reviewer", + [ + "tests/test_commercial_acceptance_check.py", + "tests/test_commercial_evidence_export.py", + "tests/test_saleability_decision.py", + "tests/test_plugin_driven_artifacts.py", + "tests/test_api_contract.py", + "pytest -q", + ], + "measured_local", + "ready" + if all( + has_file(path) + for path in ( + "tests/test_commercial_acceptance_check.py", + "tests/test_commercial_evidence_export.py", + "tests/test_saleability_decision.py", + "tests/test_plugin_driven_artifacts.py", + "tests/test_api_contract.py", + ) + ) + else "blocked", + "Focused commercial acceptance, export, saleability, plugin artifact, and API contract tests are named.", + "Restore focused tests before buyer acceptance.", + ), + self._buyer_evidence_item( + "figma_stakeholder_artifacts", + "Figma stakeholder artifacts", + "Stakeholder reviewer", + ["docs/figma_artifacts.md", "Figma design file", "FigJam board", "Figma Slides deck"], + "figma_artifact", + "ready" if has_file("docs/figma_artifacts.md") else "blocked", + "Editable stakeholder artifacts are recorded and Code Connect is excluded.", + "Record editable Figma artifacts before buyer acceptance.", + ), + self._buyer_evidence_item( + "review_process_policy", + "Review process policy", + "Deal owner", + ["docs/commercial_saleability_decision.md", "/api/v1/saleability_decisions/latest"], + "repository_artifact", + "ready", + "Reviewer delay, review bot delay, queued model review, and pending checks without concrete failure are not blockers.", + "Block only on concrete security, API contract, document, or product defects.", + ), + self._buyer_evidence_item( + "packaging_decision", + "Packaging decision", + "Procurement and security reviewer", + ["docs/library_research.md", "docs/commercial_plugin_operating_model.md"], + "repository_artifact", + "ready" if has_file("docs/library_research.md") and has_file("docs/commercial_plugin_operating_model.md") else "blocked", + evidence_export["library_split_decision"]["reason"], + "Only extract a library after a second product, independent release cadence, or provenance trigger exists.", + ), + ] + follow_up_items = [ + self._buyer_evidence_item( + item["evidence_name"], + item["label"], + item["reviewer"], + item["sources"], + item["evidence_type"], + "warning", + item["evidence"], + item["next_action"], + ) + for item in evidence_export["required_external_evidence"] + ] + all_items = acceptance_items + follow_up_items + summary = self._buyer_manifest_summary(all_items) + blocked_count = summary["by_completion_state"]["blocked"] + len(concrete_blockers) + warning_count = summary["by_completion_state"]["warning"] + if blocked_count: + acceptance_status = "commercial_acceptance_blocked" + elif warning_count: + acceptance_status = "commercial_acceptance_ready_with_warnings" + else: # pragma: no cover - unreachable while this report carries literal buyer-specific warning sections + acceptance_status = "commercial_acceptance_ready" # pragma: no cover + + return { + "acceptance_status": acceptance_status, + "target_contract_value_krw": target_contract_value_krw, + "target_contract_value_display": f"KRW {target_contract_value_krw:,}", + "measurement_status": "local_commercial_acceptance_check", + "source_note": ( + "Commercial acceptance check evaluates local commercial evidence export, admin visibility, " + "repository packet, Figma artifacts, verification commands, review-process policy, packaging " + "decision, and explicit production or buyer-specific gaps; it is not a valuation guarantee, " + "purchase commitment, or production compliance certificate." + ), + "acceptance_summary": { + "item_count": len(all_items), + "blocked_count": blocked_count, + "warning_count": warning_count, + "review_process_is_blocker": evidence_export["review_process_policy"]["is_blocker"], + }, + "acceptance_items": acceptance_items, + "follow_up_items": follow_up_items, + "concrete_blockers": concrete_blockers, + "required_external_evidence": evidence_export["required_external_evidence"], + "acceptance_gates": [ + { + "gate_name": "go", + "rule": "no blocked acceptance items and no required external evidence gaps", + }, + { + "gate_name": "warning", + "rule": "only production or buyer-specific evidence remains explicitly caveated", + }, + { + "gate_name": "blocked", + "rule": "security failure, API contract regression, document mismatch, product defect, or Code Connect usage", + }, + ], + "review_process_policy": evidence_export["review_process_policy"], + "related_runtime_reports": { + "commercial_export_status": evidence_export["export_status"], + **evidence_export["related_runtime_reports"], + }, + "library_split_decision": evidence_export["library_split_decision"], + "plugin_traceability": evidence_export["plugin_traceability"], + "acceptance_links": { + "figma_design_file": "https://www.figma.com/design/vsZMd8WAv42HDRgcZuNcWk", + "figjam_board": "https://www.figma.com/board/Wr8iMlB9SHkerHSjv0Pe0M", + "runtime_endpoint": "/api/v1/commercial_acceptance_checks/latest", + "documentation": "docs/commercial_acceptance_check.md", + }, + } + + def commercial_release_candidate_report( + self, + target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, + locale_bundles: dict[str, dict[str, str]] | None = None, + security_profile: dict[str, Any] | None = None, + release_authority: Mapping[str, Any] | None = None, + ) -> dict[str, Any]: + """Return product evidence separately from protected release authority.""" + acceptance = self.commercial_acceptance_check_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + root = Path(__file__).resolve().parents[1] + + def has_file(path: str) -> bool: + return (root / path).is_file() + + concrete_blockers = acceptance["concrete_blockers"] + acceptance_blocked = acceptance["acceptance_status"] == "commercial_acceptance_blocked" + runtime_state = "blocked" if acceptance_blocked or concrete_blockers else "ready" + release_authorization = evaluate_release_authorization(release_authority) + release_artifacts = [ + self._buyer_evidence_item( + "commercial_acceptance_check", + "Commercial acceptance check", + "Deal owner", + ["/api/v1/commercial_acceptance_checks/latest", "docs/commercial_acceptance_check.md"], + "measured_local", + runtime_state, + f"acceptance_status={acceptance['acceptance_status']}", + "Resolve blocked acceptance checks before tagging a release candidate.", + ), + self._buyer_evidence_item( + "runtime_endpoint_chain", + "Runtime endpoint chain", + "Technical reviewer", + [ + "/api/v1/analytics_snapshots/latest", + "/api/v1/sales_readiness/latest", + "/api/v1/commercial_readiness/latest", + "/api/v1/commercial_evidence_manifests/latest", + "/api/v1/commercial_handoff_bundles/latest", + "/api/v1/saleability_decisions/latest", + "/api/v1/commercial_evidence_exports/latest", + "/api/v1/commercial_acceptance_checks/latest", + "/api/v1/commercial_release_candidates/latest", + ], + "measured_local", + runtime_state, + "Commercial release candidate endpoint is chained after acceptance, export, decision, handoff, manifest, readiness, and analytics reports.", + "Restore blocked runtime endpoint evidence before release-candidate handoff.", + ), + self._buyer_evidence_item( + "repository_distribution_packet", + "Repository distribution packet", + "Procurement reviewer", + [ + "README.md", + "docs/rest_api_design.md", + "docs/commercial_buyer_diligence_packet.md", + "docs/commercial_buyer_acceptance_runbook.md", + "docs/commercial_buyer_evidence_manifest.md", + "docs/commercial_buyer_handoff_bundle.md", + "docs/commercial_saleability_decision.md", + "docs/commercial_evidence_export.md", + "docs/commercial_acceptance_check.md", + "docs/commercial_release_candidate.md", + ], + "repository_artifact", + "ready" + if all( + has_file(path) + for path in ( + "README.md", + "docs/rest_api_design.md", + "docs/commercial_buyer_diligence_packet.md", + "docs/commercial_buyer_acceptance_runbook.md", + "docs/commercial_buyer_evidence_manifest.md", + "docs/commercial_buyer_handoff_bundle.md", + "docs/commercial_saleability_decision.md", + "docs/commercial_evidence_export.md", + "docs/commercial_acceptance_check.md", + "docs/commercial_release_candidate.md", + ) + ) + else "blocked", + "Repository packet contains the README, REST API contract notes, and commercial buyer documents.", + "Restore missing distribution documents before buyer release-candidate review.", + ), + self._buyer_evidence_item( + "security_package_metadata", + "Security and package metadata", + "Security reviewer", + [ + "LICENSE", + "SECURITY.md", + "pyproject.toml", + "requirements.lock", + ".github/workflows/security.yml", + ".github/dependabot.yml", + "ContextualWisdomLab/.github central required security workflows", + ], + "repository_artifact", + "ready" + if all( + has_file(path) + for path in ( + "LICENSE", + "SECURITY.md", + "pyproject.toml", + "requirements.lock", + ".github/workflows/security.yml", + ".github/dependabot.yml", + ) + ) + else "blocked", + "License, security policy, package metadata, locked requirements, local supply-chain workflow, Dependabot metadata, and central required security workflows are present.", + "Restore missing security or package metadata before release-candidate handoff.", + ), + self._buyer_evidence_item( + "admin_operator_surface", + "Admin operator surface", + "Platform operator", + ["/admin", "contextual_orchestrator/admin.py", "/api/v1/commercial_release_candidates/latest"], + "repository_artifact", + "ready" if has_file("contextual_orchestrator/admin.py") else "blocked", + "Admin observability surface exposes the release-candidate status with bilingual labels.", + "Expose release-candidate status in admin observability before buyer handoff.", + ), + self._buyer_evidence_item( + "verification_evidence", + "Verification evidence", + "Technical reviewer", + [ + "tests/test_commercial_release_candidate.py", + "tests/test_commercial_acceptance_check.py", + "tests/test_commercial_evidence_export.py", + "tests/test_saleability_decision.py", + "tests/test_plugin_driven_artifacts.py", + "tests/test_api_contract.py", + "pytest -q", + ], + "measured_local", + "ready" + if all( + has_file(path) + for path in ( + "tests/test_commercial_release_candidate.py", + "tests/test_commercial_acceptance_check.py", + "tests/test_commercial_evidence_export.py", + "tests/test_saleability_decision.py", + "tests/test_plugin_driven_artifacts.py", + "tests/test_api_contract.py", + ) + ) + else "blocked", + "Focused release-candidate, acceptance, export, saleability, plugin artifact, and API contract tests are named.", + "Restore focused verification before release-candidate handoff.", + ), + self._buyer_evidence_item( + "figma_stakeholder_artifacts", + "Figma stakeholder artifacts", + "Stakeholder reviewer", + ["docs/figma_artifacts.md", "Figma design file", "FigJam board", "Figma Slides deck"], + "figma_artifact", + "ready" if has_file("docs/figma_artifacts.md") else "blocked", + "Editable stakeholder artifacts are recorded and Code Connect is excluded.", + "Record editable Figma artifacts before buyer release-candidate review.", + ), + self._buyer_evidence_item( + "review_process_policy", + "Review process policy", + "Deal owner", + ["docs/commercial_saleability_decision.md", "docs/commercial_release_candidate.md"], + "repository_artifact", + "ready", + "Product evidence remains inspectable while protected release authority is evaluated separately.", + "Supply a fresh protected-main authority snapshot before authorizing release.", + ), + self._buyer_evidence_item( + "release_authority_collector", + "Protected-head authority collector", + "Release owner", + ["scripts/ci/release_authority_snapshot.py", "docs/doctoring/release-authorization.md"], + "repository_artifact", + "ready" if has_file("scripts/ci/release_authority_snapshot.py") else "blocked", + "Read-only gh API collector binds checks and reviews to the exact pull-request head without emitting secrets.", + "Run the collector with the exact candidate SHA and attach its JSON snapshot to release review.", + ), + self._buyer_evidence_item( + "packaging_decision", + "Packaging decision", + "Procurement and security reviewer", + ["docs/library_research.md", "docs/commercial_plugin_operating_model.md"], + "repository_artifact", + "ready" if has_file("docs/library_research.md") and has_file("docs/commercial_plugin_operating_model.md") else "blocked", + acceptance["library_split_decision"]["reason"], + "Only extract a library after a second product, independent release cadence, or provenance trigger exists.", + ), + ] + external_release_gaps = [ + self._buyer_evidence_item( + item["item_name"], + item["label"], + item["reviewer"], + item["sources"], + item["evidence_type"], + "warning", + item["evidence"], + item["next_action"], + ) + for item in acceptance["follow_up_items"] + ] + summary = self._buyer_manifest_summary(release_artifacts + external_release_gaps) + product_blocked_count = summary["by_completion_state"]["blocked"] + len(concrete_blockers) + warning_count = summary["by_completion_state"]["warning"] + product_evidence_status = ( + "commercial_release_blocked" + if product_blocked_count + else "commercial_release_ready_with_warnings" + if acceptance["follow_up_items"] + else "commercial_release_ready" + ) + release_blocked_count = product_blocked_count + len(release_authorization["blockers"]) + if release_blocked_count: + release_status = "commercial_release_blocked" + elif warning_count: + release_status = "commercial_release_ready_with_warnings" + else: # pragma: no cover - unreachable while this report carries literal buyer-specific warning sections + release_status = "commercial_release_ready" # pragma: no cover + + return { + "release_status": release_status, + "product_evidence_status": product_evidence_status, + "release_authorization": release_authorization, + "target_contract_value_krw": target_contract_value_krw, + "target_contract_value_display": f"KRW {target_contract_value_krw:,}", + "measurement_status": "local_commercial_release_candidate", + "source_note": ( + "Commercial release candidate packages local acceptance, runtime endpoints, repository " + "distribution documents, security metadata, admin visibility, verification commands, " + "Figma artifact records, review-process policy, packaging decision, and explicit external " + "release gaps; it is not a valuation guarantee, purchase commitment, or production " + "compliance certificate." + ), + "release_summary": { + "artifact_count": len(release_artifacts), + "blocked_count": release_blocked_count, + "product_blocked_count": product_blocked_count, + "warning_count": warning_count, + "release_authority_blocker_count": len(release_authorization["blockers"]), + }, + "release_artifacts": release_artifacts, + "external_release_gaps": external_release_gaps, + "concrete_blockers": concrete_blockers, + "release_gates": [ + { + "gate_name": "package", + "rule": "runtime endpoint chain, repository packet, security metadata, admin surface, tests, Figma artifacts, review policy, and packaging decision are present", + }, + { + "gate_name": "warning", + "rule": "only production or buyer-specific external evidence remains explicitly caveated", + }, + { + "gate_name": "blocked", + "rule": "security failure, API contract regression, missing distribution artifact, document mismatch, product defect, or Code Connect usage", + }, + ], + "review_process_policy": acceptance["review_process_policy"], + "related_runtime_reports": { + "commercial_acceptance_status": acceptance["acceptance_status"], + **acceptance["related_runtime_reports"], + }, + "library_split_decision": acceptance["library_split_decision"], + "plugin_traceability": acceptance["plugin_traceability"], + "release_links": { + "figma_design_file": "https://www.figma.com/design/vsZMd8WAv42HDRgcZuNcWk", + "figjam_board": "https://www.figma.com/board/Wr8iMlB9SHkerHSjv0Pe0M", + "runtime_endpoint": "/api/v1/commercial_release_candidates/latest", + "documentation": "docs/commercial_release_candidate.md", + }, + } + + def commercial_gap_register_report( + self, + target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, + locale_bundles: dict[str, dict[str, str]] | None = None, + security_profile: dict[str, Any] | None = None, + release_authority: Mapping[str, Any] | None = None, + ) -> dict[str, Any]: + """Return an owner/action register for commercial release-candidate gaps.""" + release = self.commercial_release_candidate_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + release_authority=release_authority, + ) + concrete_blockers = release["concrete_blockers"] + release_blocked = release["release_status"] == "commercial_release_blocked" + gap_items = [] + for item in release["external_release_gaps"]: + source_type = item["evidence_type"] + if source_type == "proposed_until_production": + gap_status = "production_input_required" + gap_type = "production_evidence_gap" + owner = "Operations and support owner" + else: + gap_status = "buyer_input_required" + gap_type = "buyer_specific_gap" + owner = "Buyer and deal owner" + gap_items.append({ + "gap_name": item["item_name"], + "label": item["label"], + "gap_type": gap_type, + "gap_status": gap_status, + "owner": owner, + "reviewer": item["reviewer"], + "sources": item["sources"], + "source_evidence_type": source_type, + "current_evidence": item["evidence"], + "required_input": item["next_action"], + "is_blocker": False, + }) + + release_authority_blockers = release["release_authorization"]["blockers"] + product_blocked_count = release["release_summary"]["product_blocked_count"] + blocked_count = ( + max(1, product_blocked_count + len(release_authority_blockers)) + if release_blocked + else len(concrete_blockers) + ) + if blocked_count: + gap_register_status = "commercial_gap_register_blocked" + elif gap_items: + gap_register_status = "commercial_gap_register_open" + else: # pragma: no cover - unreachable while this report carries literal buyer-specific warning sections + gap_register_status = "commercial_gap_register_clear" # pragma: no cover + + production_gap_count = sum(1 for item in gap_items if item["gap_type"] == "production_evidence_gap") + buyer_specific_gap_count = sum(1 for item in gap_items if item["gap_type"] == "buyer_specific_gap") + return { + "gap_register_status": gap_register_status, + "target_contract_value_krw": target_contract_value_krw, + "target_contract_value_display": f"KRW {target_contract_value_krw:,}", + "measurement_status": "local_commercial_gap_register", + "source_note": ( + "Commercial gap register converts local release-candidate warning gaps into owner, action, " + "source, and required-input rows for buyer due diligence; it is not a valuation guarantee, " + "purchase commitment, or production compliance certificate." + ), + "gap_summary": { + "total_gap_count": len(gap_items), + "production_gap_count": production_gap_count, + "buyer_specific_gap_count": buyer_specific_gap_count, + "blocked_count": blocked_count, + "release_authority_blocker_count": len(release_authority_blockers), + }, + "gap_items": gap_items, + "concrete_blockers": concrete_blockers, + "release_authorization": release["release_authorization"], + "gap_status_rules": [ + { + "gap_status": "production_input_required", + "rule": "production deployment, support, SLO, or operational evidence must be supplied before production claim", + }, + { + "gap_status": "buyer_input_required", + "rule": "buyer-specific legal, procurement, ROI, or deployment context must be supplied before buyer-specific claim", + }, + { + "gap_status": "blocked", + "rule": "concrete security, API contract, document, product defect, or Code Connect usage blocks commercial release", + }, + ], + "review_process_policy": release["review_process_policy"], + "related_runtime_reports": { + "commercial_release_status": release["release_status"], + "release_authorization_status": release["release_authorization"]["status"], + **release["related_runtime_reports"], + }, + "library_split_decision": release["library_split_decision"], + "plugin_traceability": release["plugin_traceability"], + "gap_register_links": { + "figma_design_file": "https://www.figma.com/design/vsZMd8WAv42HDRgcZuNcWk", + "figjam_board": "https://www.figma.com/board/Wr8iMlB9SHkerHSjv0Pe0M", + "runtime_endpoint": "/api/v1/commercial_gap_registers/latest", + "documentation": "docs/commercial_gap_register.md", + }, + } + + def commercial_procurement_readiness_report( + self, + target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, + locale_bundles: dict[str, dict[str, str]] | None = None, + security_profile: dict[str, Any] | None = None, + release_authority: Mapping[str, Any] | None = None, + ) -> dict[str, Any]: + """Return a procurement/legal readiness gate over commercial evidence.""" + gap_register = self.commercial_gap_register_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + release_authority=release_authority, + ) + root = Path(__file__).resolve().parents[1] + + def has_file(path: str) -> bool: + return (root / path).is_file() + + gap_by_status = {item["gap_status"]: item for item in gap_register["gap_items"]} + production_gap = gap_by_status.get("production_input_required") + buyer_gap = gap_by_status.get("buyer_input_required") + concrete_blockers = gap_register["concrete_blockers"] + release_authorization = gap_register["release_authorization"] + release_authority_blockers = release_authorization["blockers"] + procurement_items = [ + { + "item_name": "license_and_rights", + "label": "License and rights", + "owner": "Procurement reviewer", + "sources": ["LICENSE", "pyproject.toml"], + "evidence_type": "repository_artifact", + "completion_state": "ready" if has_file("LICENSE") and has_file("pyproject.toml") else "blocked", + "evidence": "MIT license and package metadata are present for buyer rights review.", + "required_input": "Restore license or package metadata before procurement review.", + }, + { + "item_name": "security_package_metadata", + "label": "Security package metadata", + "owner": "Security reviewer", + "sources": [ + "SECURITY.md", + "requirements.lock", + ".github/workflows/security.yml", + ".github/dependabot.yml", + "ContextualWisdomLab/.github central required security workflows", + ], + "evidence_type": "repository_artifact", + "completion_state": "ready" + if all( + has_file(path) + for path in ( + "SECURITY.md", + "requirements.lock", + ".github/workflows/security.yml", + ".github/dependabot.yml", + ) + ) + else "blocked", + "evidence": "Security policy, locked dependencies, local supply-chain workflow, Dependabot metadata, and central required security workflows are present.", + "required_input": "Restore missing security metadata before procurement review.", + }, + { + "item_name": "distribution_packet", + "label": "Distribution packet", + "owner": "Deal owner", + "sources": [ + "README.md", + "docs/rest_api_design.md", + "docs/commercial_release_candidate.md", + "docs/commercial_gap_register.md", + ], + "evidence_type": "repository_artifact", + "completion_state": "ready" + if all( + has_file(path) + for path in ( + "README.md", + "docs/rest_api_design.md", + "docs/commercial_release_candidate.md", + "docs/commercial_gap_register.md", + ) + ) + else "blocked", + "evidence": "Repository overview, REST contract, release candidate, and gap register documents are present.", + "required_input": "Restore missing distribution documents before procurement review.", + }, + { + "item_name": "admin_evidence_surface", + "label": "Admin evidence surface", + "owner": "Platform operator", + "sources": ["/admin", "contextual_orchestrator/admin.py", "/api/v1/commercial_procurement_readiness/latest"], + "evidence_type": "repository_artifact", + "completion_state": "ready" if has_file("contextual_orchestrator/admin.py") else "blocked", + "evidence": "Admin observability surface exposes procurement readiness with bilingual labels.", + "required_input": "Expose procurement readiness in admin observability before buyer review.", + }, + { + "item_name": "production_support_slo_input", + "label": "Production support and SLO input", + "owner": production_gap["owner"] if production_gap else "Operations and support owner", + "sources": production_gap["sources"] if production_gap else ["docs/commercial_gap_register.md"], + "evidence_type": "proposed_until_production", + "completion_state": "warning" if production_gap else "ready", + "source_gap_status": production_gap["gap_status"] if production_gap else "resolved", + "evidence": production_gap["current_evidence"] if production_gap else "No production evidence gap is open.", + "required_input": production_gap["required_input"] if production_gap else "No production input required.", + }, + { + "item_name": "buyer_legal_roi_procurement_input", + "label": "Buyer legal, ROI, and procurement input", + "owner": buyer_gap["owner"] if buyer_gap else "Buyer and deal owner", + "sources": buyer_gap["sources"] if buyer_gap else ["docs/commercial_gap_register.md"], + "evidence_type": "proposed_until_buyer_specific", + "completion_state": "warning" if buyer_gap else "ready", + "source_gap_status": buyer_gap["gap_status"] if buyer_gap else "resolved", + "evidence": buyer_gap["current_evidence"] if buyer_gap else "No buyer-specific evidence gap is open.", + "required_input": buyer_gap["required_input"] if buyer_gap else "No buyer input required.", + }, + { + "item_name": "review_process_policy", + "label": "Review process policy", + "owner": "Deal owner", + "sources": ["docs/commercial_saleability_decision.md", "docs/commercial_procurement_readiness.md"], + "evidence_type": "repository_artifact", + "completion_state": "ready", + "evidence": "Reviewer delay, review bot delay, queued model review, and pending checks without concrete failure are not blockers.", + "required_input": "Block only on concrete security, API contract, document, or product defects.", + }, + { + "item_name": "packaging_decision", + "label": "Packaging decision", + "owner": "Procurement and security reviewer", + "sources": ["docs/library_research.md", "docs/commercial_plugin_operating_model.md"], + "evidence_type": "repository_artifact", + "completion_state": "ready" if has_file("docs/library_research.md") and has_file("docs/commercial_plugin_operating_model.md") else "blocked", + "evidence": gap_register["library_split_decision"]["reason"], + "required_input": "Only extract a library after a second product, independent release cadence, or provenance trigger exists.", + }, + ] + state_counts = Counter(item["completion_state"] for item in procurement_items) + production_gap_count = 1 if production_gap else 0 + buyer_specific_gap_count = 1 if buyer_gap else 0 + blocked_count = state_counts.get("blocked", 0) + len(concrete_blockers) + warning_count = state_counts.get("warning", 0) + if blocked_count: + procurement_status = "commercial_procurement_blocked" + elif warning_count: + procurement_status = "commercial_procurement_ready_with_warnings" + else: # pragma: no cover - unreachable while this report carries literal buyer-specific warning sections + procurement_status = "commercial_procurement_ready" # pragma: no cover + + return { + "procurement_status": procurement_status, + "target_contract_value_krw": target_contract_value_krw, + "target_contract_value_display": f"KRW {target_contract_value_krw:,}", + "measurement_status": "local_commercial_procurement_readiness", + "source_note": ( + "Commercial procurement readiness packages local license, security, distribution, admin, " + "gap-register, review-process, and packaging evidence for buyer due diligence; it is not " + "a valuation guarantee, purchase commitment, or production compliance certificate." + ), + "procurement_summary": { + "item_count": len(procurement_items), + "ready_count": state_counts.get("ready", 0), + "warning_count": warning_count, + "blocked_count": blocked_count, + "production_gap_count": production_gap_count, + "buyer_specific_gap_count": buyer_specific_gap_count, + "review_process_is_blocker": gap_register["review_process_policy"]["is_blocker"], + "release_authority_blocker_count": len(release_authority_blockers), + }, + "procurement_items": procurement_items, + "concrete_blockers": concrete_blockers, + "release_authorization": release_authorization, + "procurement_status_rules": [ + { + "procurement_status": "commercial_procurement_ready", + "rule": "license, security, distribution, admin, support, legal, ROI, review, and packaging evidence are ready", + }, + { + "procurement_status": "commercial_procurement_ready_with_warnings", + "rule": "local packet is ready while production or buyer-specific inputs remain explicit warnings", + }, + { + "procurement_status": "commercial_procurement_blocked", + "rule": "missing packet evidence, concrete product defect, API contract failure, document mismatch, security failure, or Code Connect usage blocks procurement", + }, + ], + "review_process_policy": gap_register["review_process_policy"], + "related_runtime_reports": { + "commercial_gap_register_status": gap_register["gap_register_status"], + **gap_register["related_runtime_reports"], + }, + "library_split_decision": gap_register["library_split_decision"], + "plugin_traceability": gap_register["plugin_traceability"], + "procurement_links": { + "figma_design_file": "https://www.figma.com/design/vsZMd8WAv42HDRgcZuNcWk", + "figjam_board": "https://www.figma.com/board/Wr8iMlB9SHkerHSjv0Pe0M", + "runtime_endpoint": "/api/v1/commercial_procurement_readiness/latest", + "documentation": "docs/commercial_procurement_readiness.md", + }, + } + + def commercial_contract_readiness_report( + self, + target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, + locale_bundles: dict[str, dict[str, str]] | None = None, + security_profile: dict[str, Any] | None = None, + release_authority: Mapping[str, Any] | None = None, + ) -> dict[str, Any]: + """Return a contract-readiness gate over procurement evidence.""" + procurement = self.commercial_procurement_readiness_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + release_authority=release_authority, + ) + root = Path(__file__).resolve().parents[1] + + def has_file(path: str) -> bool: + return (root / path).is_file() + + procurement_by_name = {item["item_name"]: item for item in procurement["procurement_items"]} + license_item = procurement_by_name["license_and_rights"] + security_item = procurement_by_name["security_package_metadata"] + support_item = procurement_by_name["production_support_slo_input"] + buyer_item = procurement_by_name["buyer_legal_roi_procurement_input"] + packaging_item = procurement_by_name["packaging_decision"] + concrete_blockers = procurement["concrete_blockers"] + release_authorization = procurement["release_authorization"] + release_authority_blockers = release_authorization["blockers"] + support_slo_gap_count = 1 if support_item["completion_state"] == "warning" else 0 + buyer_order_form_gap_count = 1 if buyer_item["completion_state"] == "warning" else 0 + contract_items = [ + { + "item_name": "license_commercial_rights", + "label": "License and commercial rights terms", + "owner": "Legal reviewer", + "sources": license_item["sources"], + "evidence_type": license_item["evidence_type"], + "completion_state": license_item["completion_state"], + "evidence": license_item["evidence"], + "required_input": license_item["required_input"], + }, + { + "item_name": "security_privacy_terms", + "label": "Security and privacy terms", + "owner": "Security and legal reviewer", + "sources": [*security_item["sources"], "docs/commercial_procurement_readiness.md"], + "evidence_type": security_item["evidence_type"], + "completion_state": security_item["completion_state"], + "evidence": ( + f"{security_item['evidence']} Runtime readiness profile uses " + f"auth_mode={security_profile.get('auth_mode', 'unknown') if security_profile else 'unknown'}, " + f"public_bind={security_profile.get('allow_public_bind', 'unknown') if security_profile else 'unknown'}, " + "and trace exposure controls." + ), + "required_input": security_item["required_input"], + }, + { + "item_name": "audit_export_obligations", + "label": "Audit and export obligations", + "owner": "Compliance reviewer", + "sources": [ + "/api/v1/commercial_evidence_exports/latest", + "docs/commercial_evidence_export.md", + "docs/rest_api_design.md", + ], + "evidence_type": "repository_artifact", + "completion_state": "ready" + if all( + has_file(path) + for path in ( + "docs/commercial_evidence_export.md", + "docs/rest_api_design.md", + ) + ) + else "blocked", + "evidence": "Commercial evidence export and REST API contract describe buyer-readable audit evidence.", + "required_input": "Restore evidence export docs and REST contract before contract review.", + }, + { + "item_name": "contract_packet_docs", + "label": "Contract packet documents", + "owner": "Deal owner", + "sources": [ + "README.md", + "docs/commercial_contract_readiness.md", + "docs/commercial_procurement_readiness.md", + "docs/commercial_saleability_decision.md", + ], + "evidence_type": "repository_artifact", + "completion_state": "ready" + if all( + has_file(path) + for path in ( + "README.md", + "docs/commercial_contract_readiness.md", + "docs/commercial_procurement_readiness.md", + "docs/commercial_saleability_decision.md", + ) + ) + else "blocked", + "evidence": "Contract packet, procurement gate, and saleability blocker policy are documented.", + "required_input": "Restore buyer contract packet docs before legal review.", + }, + { + "item_name": "support_slo_terms", + "label": "Support and SLO terms", + "owner": support_item["owner"], + "sources": support_item["sources"], + "evidence_type": support_item["evidence_type"], + "completion_state": support_item["completion_state"], + "source_gap_status": support_item.get("source_gap_status", "resolved"), + "evidence": support_item["evidence"], + "required_input": support_item["required_input"], + }, + { + "item_name": "buyer_order_form_input", + "label": "Buyer order-form input", + "owner": buyer_item["owner"], + "sources": buyer_item["sources"], + "evidence_type": buyer_item["evidence_type"], + "completion_state": buyer_item["completion_state"], + "source_gap_status": buyer_item.get("source_gap_status", "resolved"), + "evidence": buyer_item["evidence"], + "required_input": buyer_item["required_input"], + }, + { + "item_name": "review_process_policy", + "label": "Review process policy", + "owner": "Deal owner", + "sources": ["docs/commercial_saleability_decision.md", "docs/commercial_contract_readiness.md"], + "evidence_type": "repository_artifact", + "completion_state": "ready", + "evidence": "Review process delay is not a contract blocker unless a concrete failure is produced.", + "required_input": "Block only on concrete security, API contract, document, or product defects.", + }, + { + "item_name": "packaging_decision", + "label": "Packaging decision", + "owner": packaging_item["owner"], + "sources": packaging_item["sources"], + "evidence_type": packaging_item["evidence_type"], + "completion_state": packaging_item["completion_state"], + "evidence": packaging_item["evidence"], + "required_input": packaging_item["required_input"], + }, + ] + state_counts = Counter(item["completion_state"] for item in contract_items) + blocked_count = state_counts.get("blocked", 0) + len(concrete_blockers) + warning_count = state_counts.get("warning", 0) + if blocked_count: + contract_status = "commercial_contract_blocked" + elif warning_count: + contract_status = "commercial_contract_ready_with_warnings" + else: # pragma: no cover - unreachable while this report carries literal buyer-specific warning sections + contract_status = "commercial_contract_ready" # pragma: no cover + + return { + "contract_status": contract_status, + "target_contract_value_krw": target_contract_value_krw, + "target_contract_value_display": f"KRW {target_contract_value_krw:,}", + "measurement_status": "local_commercial_contract_readiness", + "source_note": ( + "Commercial contract readiness packages local license, security/privacy, audit export, " + "support/SLO, buyer order-form, review-process, and packaging evidence for legal and " + "procurement due diligence; it is not a valuation guarantee, purchase commitment, or " + "production compliance certificate." + ), + "contract_summary": { + "item_count": len(contract_items), + "ready_count": state_counts.get("ready", 0), + "warning_count": warning_count, + "blocked_count": blocked_count, + "support_slo_gap_count": support_slo_gap_count, + "buyer_order_form_gap_count": buyer_order_form_gap_count, + "review_process_is_blocker": procurement["review_process_policy"]["is_blocker"], + "release_authority_blocker_count": len(release_authority_blockers), + }, + "contract_items": contract_items, + "concrete_blockers": concrete_blockers, + "release_authorization": release_authorization, + "contract_status_rules": [ + { + "contract_status": "commercial_contract_ready", + "rule": "license, security/privacy, audit/export, support/SLO, buyer order-form, review, and packaging terms are ready", + }, + { + "contract_status": "commercial_contract_ready_with_warnings", + "rule": "local contract packet is ready while production support/SLO or buyer order-form inputs remain explicit warnings", + }, + { + "contract_status": "commercial_contract_blocked", + "rule": "missing contract packet evidence, concrete product defect, API contract failure, document mismatch, security failure, or Code Connect usage blocks contract readiness", + }, + ], + "review_process_policy": procurement["review_process_policy"], + "related_runtime_reports": { + "commercial_procurement_status": procurement["procurement_status"], + **procurement["related_runtime_reports"], + }, + "library_split_decision": procurement["library_split_decision"], + "plugin_traceability": procurement["plugin_traceability"], + "contract_links": { + "figma_design_file": "https://www.figma.com/design/vsZMd8WAv42HDRgcZuNcWk", + "figjam_board": "https://www.figma.com/board/Wr8iMlB9SHkerHSjv0Pe0M", + "runtime_endpoint": "/api/v1/commercial_contract_readiness/latest", + "documentation": "docs/commercial_contract_readiness.md", + }, + } + + def commercial_onboarding_readiness_report( + self, + target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, + locale_bundles: dict[str, dict[str, str]] | None = None, + security_profile: dict[str, Any] | None = None, + release_authority: Mapping[str, Any] | None = None, + ) -> dict[str, Any]: + """Return a paid-onboarding readiness gate over contract evidence.""" + contract = self.commercial_contract_readiness_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + release_authority=release_authority, + ) + root = Path(__file__).resolve().parents[1] + + def has_file(path: str) -> bool: + return (root / path).is_file() + + contract_by_name = {item["item_name"]: item for item in contract["contract_items"]} + support_item = contract_by_name["support_slo_terms"] + buyer_item = contract_by_name["buyer_order_form_input"] + packaging_item = contract_by_name["packaging_decision"] + concrete_blockers = contract["concrete_blockers"] + release_authorization = contract["release_authorization"] + support_slo_action_count = 1 if support_item["completion_state"] == "warning" else 0 + buyer_input_action_count = 1 if buyer_item["completion_state"] == "warning" else 0 + onboarding_items = [ + { + "item_name": "buyer_kickoff_packet", + "label": "Buyer kickoff packet", + "owner": "Deal owner", + "sources": [ + "README.md", + "docs/commercial_onboarding_readiness.md", + "docs/commercial_contract_readiness.md", + ], + "evidence_type": "repository_artifact", + "completion_state": "ready" + if all( + has_file(path) + for path in ( + "README.md", + "docs/commercial_onboarding_readiness.md", + "docs/commercial_contract_readiness.md", + ) + ) + else "blocked", + "evidence": "Buyer kickoff packet connects product overview, contract readiness, and onboarding plan.", + "action": "Use the packet to start paid onboarding with named buyer stakeholders.", + "exit_criteria": "Buyer confirms kickoff owner, onboarding dates, and evidence review cadence.", + }, + { + "item_name": "support_slo_kickoff", + "label": "Support and SLO kickoff", + "owner": support_item["owner"], + "sources": support_item["sources"], + "evidence_type": support_item["evidence_type"], + "completion_state": support_item["completion_state"], + "source_gap_status": support_item.get("source_gap_status", "resolved"), + "evidence": support_item["evidence"], + "action": "Collect support rota, escalation path, SLO target, and incident drill evidence during paid onboarding.", + "exit_criteria": "Buyer and operator approve support owner, response target, escalation path, and first incident drill record.", + }, + { + "item_name": "buyer_order_form_kickoff", + "label": "Buyer order-form kickoff", + "owner": buyer_item["owner"], + "sources": buyer_item["sources"], + "evidence_type": buyer_item["evidence_type"], + "completion_state": buyer_item["completion_state"], + "source_gap_status": buyer_item.get("source_gap_status", "resolved"), + "evidence": buyer_item["evidence"], + "action": "Collect buyer order-form, ROI, legal questionnaire, deployment, and support inputs.", + "exit_criteria": "Buyer-specific order form and legal/procurement inputs are attached to the diligence packet.", + }, + { + "item_name": "telemetry_capture_plan", + "label": "Telemetry capture plan", + "owner": "Data analytics owner", + "sources": ["/api/v1/analytics_snapshots/latest", "docs/analytics_spec.md"], + "evidence_type": "repository_artifact", + "completion_state": "ready" if has_file("docs/analytics_spec.md") else "blocked", + "evidence": "Analytics spec separates measured local evidence from proposed production metrics.", + "action": "Capture production onboarding telemetry without mixing it with local prototype metrics.", + "exit_criteria": "First buyer environment records adoption, latency, verification, trace completeness, and support events.", + }, + { + "item_name": "acceptance_exit_criteria", + "label": "Acceptance exit criteria", + "owner": "Technical buyer reviewer", + "sources": [ + "/api/v1/commercial_acceptance_checks/latest", + "docs/commercial_acceptance_check.md", + "docs/commercial_buyer_acceptance_runbook.md", + ], + "evidence_type": "repository_artifact", + "completion_state": "ready" + if has_file("docs/commercial_acceptance_check.md") + and has_file("docs/commercial_buyer_acceptance_runbook.md") + else "blocked", + "evidence": "Acceptance check and buyer runbook define go/no-go review gates.", + "action": "Run the buyer acceptance checklist after kickoff evidence is attached.", + "exit_criteria": "Acceptance check has no concrete blockers and warnings are explicitly owned.", + }, + { + "item_name": "security_legal_handoff", + "label": "Security and legal handoff", + "owner": "Security and legal reviewer", + "sources": ["SECURITY.md", "docs/commercial_contract_readiness.md"], + "evidence_type": "repository_artifact", + "completion_state": "ready" + if has_file("SECURITY.md") and has_file("docs/commercial_contract_readiness.md") + else "blocked", + "evidence": "Security policy and contract readiness packet are available for buyer handoff.", + "action": "Attach security policy, dependency lock, and contract readiness rows to buyer diligence.", + "exit_criteria": "Buyer security/legal reviewer accepts the packet or opens concrete findings.", + }, + { + "item_name": "review_process_policy", + "label": "Review process policy", + "owner": "Deal owner", + "sources": ["docs/commercial_saleability_decision.md", "docs/commercial_onboarding_readiness.md"], + "evidence_type": "repository_artifact", + "completion_state": "ready", + "evidence": "Review delay is not an onboarding blocker unless a concrete failure is produced.", + "action": "Continue onboarding work while queued reviews are pending.", + "exit_criteria": "Only concrete security, API contract, document, or product defects block progress.", + }, + { + "item_name": "packaging_decision", + "label": "Packaging decision", + "owner": packaging_item["owner"], + "sources": packaging_item["sources"], + "evidence_type": packaging_item["evidence_type"], + "completion_state": packaging_item["completion_state"], + "evidence": packaging_item["evidence"], + "action": "Keep one deployable enterprise control-plane product through onboarding.", + "exit_criteria": "Extract only after a second product, independent release cadence, or buyer provenance trigger exists.", + }, + ] + state_counts = Counter(item["completion_state"] for item in onboarding_items) + blocked_count = state_counts.get("blocked", 0) + len(concrete_blockers) + warning_count = state_counts.get("warning", 0) + if blocked_count: + onboarding_status = "commercial_onboarding_blocked" + elif warning_count: + onboarding_status = "commercial_onboarding_ready_with_warnings" + else: # pragma: no cover - unreachable while this report carries literal buyer-specific warning sections + onboarding_status = "commercial_onboarding_ready" # pragma: no cover + + return { + "onboarding_status": onboarding_status, + "target_contract_value_krw": target_contract_value_krw, + "target_contract_value_display": f"KRW {target_contract_value_krw:,}", + "measurement_status": "local_commercial_onboarding_readiness", + "source_note": ( + "Commercial onboarding readiness converts local contract and procurement warnings into " + "paid-onboarding owners, actions, and exit criteria; it is not a valuation guarantee, " + "purchase commitment, or production compliance certificate." + ), + "onboarding_summary": { + "item_count": len(onboarding_items), + "ready_count": state_counts.get("ready", 0), + "warning_count": warning_count, + "blocked_count": blocked_count, + "support_slo_action_count": support_slo_action_count, + "buyer_input_action_count": buyer_input_action_count, + "review_process_is_blocker": contract["review_process_policy"]["is_blocker"], + "release_authority_blocker_count": len(release_authorization["blockers"]), + }, + "onboarding_items": onboarding_items, + "concrete_blockers": concrete_blockers, + "release_authorization": release_authorization, + "onboarding_status_rules": [ + { + "onboarding_status": "commercial_onboarding_ready", + "rule": "kickoff packet, support/SLO, buyer input, telemetry, acceptance, security/legal, review, and packaging actions are ready", + }, + { + "onboarding_status": "commercial_onboarding_ready_with_warnings", + "rule": "local onboarding plan is ready while production support/SLO or buyer order-form actions remain explicit warnings", + }, + { + "onboarding_status": "commercial_onboarding_blocked", + "rule": "missing onboarding packet evidence, concrete product defect, API contract failure, document mismatch, security failure, or Code Connect usage blocks onboarding", + }, + ], + "review_process_policy": contract["review_process_policy"], + "related_runtime_reports": { + "commercial_contract_status": contract["contract_status"], + **contract["related_runtime_reports"], + }, + "library_split_decision": contract["library_split_decision"], + "plugin_traceability": contract["plugin_traceability"], + "onboarding_links": { + "figma_design_file": "https://www.figma.com/design/vsZMd8WAv42HDRgcZuNcWk", + "figjam_board": "https://www.figma.com/board/Wr8iMlB9SHkerHSjv0Pe0M", + "runtime_endpoint": "/api/v1/commercial_onboarding_readiness/latest", + "documentation": "docs/commercial_onboarding_readiness.md", + }, + } + + def commercial_operations_readiness_report( + self, + target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, + locale_bundles: dict[str, dict[str, str]] | None = None, + security_profile: dict[str, Any] | None = None, + release_authority: Mapping[str, Any] | None = None, + ) -> dict[str, Any]: + """Return an operations-handoff readiness gate over onboarding evidence.""" + onboarding = self.commercial_onboarding_readiness_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + release_authority=release_authority, + ) + root = Path(__file__).resolve().parents[1] + + def has_file(path: str) -> bool: + return (root / path).is_file() + + onboarding_by_name = {item["item_name"]: item for item in onboarding["onboarding_items"]} + support_item = onboarding_by_name["support_slo_kickoff"] + telemetry_item = onboarding_by_name["telemetry_capture_plan"] + acceptance_item = onboarding_by_name["acceptance_exit_criteria"] + security_item = onboarding_by_name["security_legal_handoff"] + packaging_item = onboarding_by_name["packaging_decision"] + concrete_blockers = onboarding["concrete_blockers"] + operations_items = [ + { + "item_name": "deployment_runbook", + "label": "Deployment runbook", + "owner": "Platform operator", + "sources": [ + "README.md", + "docs/commercial_operations_readiness.md", + "docs/commercial_onboarding_readiness.md", + "docs/rest_api_design.md", + ], + "evidence_type": "repository_artifact", + "completion_state": "ready" + if all( + has_file(path) + for path in ( + "README.md", + "docs/commercial_operations_readiness.md", + "docs/commercial_onboarding_readiness.md", + "docs/rest_api_design.md", + ) + ) + else "blocked", + "evidence": "Repository overview, REST contract, onboarding plan, and operations handoff plan are present.", + "action": "Use existing stdlib server and documented endpoints for buyer operations handoff.", + "exit_criteria": "Buyer operator can start, authenticate, inspect readiness endpoints, and run verification commands.", + }, + { + "item_name": "monitoring_telemetry_capture", + "label": "Monitoring and telemetry capture", + "owner": telemetry_item["owner"], + "sources": telemetry_item["sources"], + "evidence_type": "proposed_until_production", + "completion_state": "warning", + "source_gap_status": "production_input_required", + "evidence": telemetry_item["evidence"], + "action": "Capture adoption, latency, verifier outcomes, trace completeness, support events, and deployment health in the buyer environment.", + "exit_criteria": "First production telemetry snapshot is attached without mixing it with local prototype metrics.", + }, + { + "item_name": "incident_rollback_plan", + "label": "Incident and rollback plan", + "owner": "Operations and support owner", + "sources": ["docs/commercial_onboarding_readiness.md", "docs/commercial_buyer_acceptance_runbook.md"], + "evidence_type": "proposed_until_production", + "completion_state": "warning", + "source_gap_status": "production_input_required", + "evidence": "Incident drill and rollback proof require a buyer deployment or paid onboarding environment.", + "action": "Run the first incident drill and rollback exercise during onboarding.", + "exit_criteria": "Incident owner, escalation path, rollback steps, and drill record are attached.", + }, + { + "item_name": "backup_recovery_plan", + "label": "Backup and recovery evidence", + "owner": "Operations and data owner", + "sources": ["docs/commercial_onboarding_readiness.md", "docs/commercial_buyer_diligence_packet.md"], + "evidence_type": "proposed_until_production", + "completion_state": "warning", + "source_gap_status": "production_input_required", + "evidence": "Backup and recovery evidence depends on the buyer deployment topology and persistence choices.", + "action": "Define backup scope, retention, restore owner, and first restore proof during onboarding.", + "exit_criteria": "Buyer accepts backup scope and a restore proof is attached or explicitly waived.", + }, + { + "item_name": "support_slo_ownership", + "label": "Support rota and SLO ownership", + "owner": support_item["owner"], + "sources": support_item["sources"], + "evidence_type": support_item["evidence_type"], + "completion_state": support_item["completion_state"], + "source_gap_status": support_item.get("source_gap_status", "resolved"), + "evidence": support_item["evidence"], + "action": support_item["action"], + "exit_criteria": support_item["exit_criteria"], + }, + { + "item_name": "acceptance_handoff", + "label": "Acceptance handoff", + "owner": acceptance_item["owner"], + "sources": acceptance_item["sources"], + "evidence_type": acceptance_item["evidence_type"], + "completion_state": acceptance_item["completion_state"], + "evidence": acceptance_item["evidence"], + "action": acceptance_item["action"], + "exit_criteria": acceptance_item["exit_criteria"], + }, + { + "item_name": "security_legal_handoff", + "label": "Security and legal handoff", + "owner": security_item["owner"], + "sources": security_item["sources"], + "evidence_type": security_item["evidence_type"], + "completion_state": security_item["completion_state"], + "evidence": security_item["evidence"], + "action": security_item["action"], + "exit_criteria": security_item["exit_criteria"], + }, + { + "item_name": "review_process_policy", + "label": "Review process policy", + "owner": "Deal owner", + "sources": ["docs/commercial_saleability_decision.md", "docs/commercial_operations_readiness.md"], + "evidence_type": "repository_artifact", + "completion_state": "ready", + "evidence": "Review delay is not an operations blocker unless a concrete failure is produced.", + "action": "Continue operations handoff work while queued reviews are pending.", + "exit_criteria": "Only concrete security, API contract, document, or product defects block progress.", + }, + { + "item_name": "packaging_decision", + "label": "Packaging decision", + "owner": packaging_item["owner"], + "sources": packaging_item["sources"], + "evidence_type": packaging_item["evidence_type"], + "completion_state": packaging_item["completion_state"], + "evidence": packaging_item["evidence"], + "action": packaging_item["action"], + "exit_criteria": packaging_item["exit_criteria"], + }, + ] + state_counts = Counter(item["completion_state"] for item in operations_items) + blocked_count = state_counts.get("blocked", 0) + len(concrete_blockers) + warning_count = state_counts.get("warning", 0) + production_evidence_action_count = sum( + 1 for item in operations_items if item.get("source_gap_status") == "production_input_required" + ) + if blocked_count: + operations_status = "commercial_operations_blocked" + elif warning_count: + operations_status = "commercial_operations_ready_with_warnings" + else: # pragma: no cover - unreachable while this report carries literal buyer-specific warning sections + operations_status = "commercial_operations_ready" # pragma: no cover + + return { + "operations_status": operations_status, + "target_contract_value_krw": target_contract_value_krw, + "target_contract_value_display": f"KRW {target_contract_value_krw:,}", + "measurement_status": "local_commercial_operations_readiness", + "source_note": ( + "Commercial operations readiness converts local onboarding evidence and production " + "operations gaps into handoff owners, actions, and exit criteria; it is not a valuation " + "guarantee, purchase commitment, or production compliance certificate." + ), + "operations_summary": { + "item_count": len(operations_items), + "ready_count": state_counts.get("ready", 0), + "warning_count": warning_count, + "blocked_count": blocked_count, + "production_evidence_action_count": production_evidence_action_count, + "review_process_is_blocker": onboarding["review_process_policy"]["is_blocker"], + }, + "operations_items": operations_items, + "concrete_blockers": concrete_blockers, + "operations_status_rules": [ + { + "operations_status": "commercial_operations_ready", + "rule": "deployment, monitoring, incident, backup, support, acceptance, security/legal, review, and packaging evidence are ready", + }, + { + "operations_status": "commercial_operations_ready_with_warnings", + "rule": "local operations plan is ready while production telemetry, incident, backup, or SLO evidence remains explicit warnings", + }, + { + "operations_status": "commercial_operations_blocked", + "rule": "missing operations packet evidence, concrete product defect, API contract failure, document mismatch, security failure, or Code Connect usage blocks operations handoff", + }, + ], + "review_process_policy": onboarding["review_process_policy"], + "related_runtime_reports": { + "commercial_onboarding_status": onboarding["onboarding_status"], + **onboarding["related_runtime_reports"], + }, + "library_split_decision": onboarding["library_split_decision"], + "plugin_traceability": onboarding["plugin_traceability"], + "operations_links": { + "figma_design_file": "https://www.figma.com/design/vsZMd8WAv42HDRgcZuNcWk", + "figjam_board": "https://www.figma.com/board/Wr8iMlB9SHkerHSjv0Pe0M", + "runtime_endpoint": "/api/v1/commercial_operations_readiness/latest", + "documentation": "docs/commercial_operations_readiness.md", + }, + } + + def commercial_security_attestation_report( + self, + target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, + locale_bundles: dict[str, dict[str, str]] | None = None, + security_profile: dict[str, Any] | None = None, + release_authority: Mapping[str, Any] | None = None, + ) -> dict[str, Any]: + """Return a buyer security-review attestation gate over operations evidence.""" + operations = self.commercial_operations_readiness_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + release_authority=release_authority, + ) + root = Path(__file__).resolve().parents[1] + + def has_file(path: str) -> bool: + return (root / path).is_file() + + operations_by_name = {item["item_name"]: item for item in operations["operations_items"]} + runtime_profile = security_profile or {} + concrete_blockers = operations["concrete_blockers"] + security_attestation_items = [ + { + "item_name": "security_policy", + "label": "Security policy", + "owner": "Security owner", + "sources": ["SECURITY.md"], + "evidence_type": "repository_artifact", + "completion_state": "ready" if has_file("SECURITY.md") else "blocked", + "evidence": "Repository security disclosure and support policy is present.", + "action": "Attach SECURITY.md to the buyer security review packet.", + "exit_criteria": "Buyer can identify the vulnerability reporting path and supported scope.", + }, + { + "item_name": "dependency_lock_package_metadata", + "label": "Dependency lock and package metadata", + "owner": "Release owner", + "sources": ["requirements.lock", "pyproject.toml"], + "evidence_type": "repository_artifact", + "completion_state": "ready" + if has_file("requirements.lock") and has_file("pyproject.toml") + else "blocked", + "evidence": "Pinned dependency lock and Python package metadata are present for supply-chain review.", + "action": "Use the pinned lockfile and package metadata as the buyer dependency baseline.", + "exit_criteria": "Buyer can inspect package metadata and reproduce the dependency installation path.", + }, + { + "item_name": "security_workflow_metadata", + "label": "Security workflow metadata", + "owner": "Security owner", + "sources": [ + ".github/dependabot.yml", + ".github/workflows/security.yml", + "ContextualWisdomLab/.github central required security workflows", + ], + "evidence_type": "repository_artifact", + "completion_state": "ready" + if all( + has_file(path) + for path in ( + ".github/dependabot.yml", + ".github/workflows/security.yml", + ) + ) + else "blocked", + "evidence": "Dependabot plus local CodeQL and pip-audit/SBOM workflows are defined; dependency review, Trivy, OSV, and Scorecard are delegated to central required workflows.", + "action": "Attach workflow definitions and latest passing run evidence when the buyer review requests hosted CI proof.", + "exit_criteria": "Buyer can inspect the configured security workflow controls and their latest run status separately.", + }, + { + "item_name": "runtime_access_control_profile", + "label": "Runtime access-control profile", + "owner": "Platform operator", + "sources": ["contextual_orchestrator/server.py", "/api/v1/commercial_operations_readiness/latest"], + "evidence_type": "runtime_configuration", + "completion_state": "ready", + "evidence": ( + f"Runtime profile uses auth_mode={runtime_profile.get('auth_mode', 'unknown')}, " + f"allow_public_bind={runtime_profile.get('allow_public_bind', False)}, " + f"expose_trace_by_default={runtime_profile.get('expose_trace_by_default', False)}, " + f"rate_limit_requests={runtime_profile.get('rate_limit_requests', 'unknown')}, " + f"max_concurrent_runs={runtime_profile.get('max_concurrent_runs', 'unknown')}." + ), + "action": "Use the secret-free runtime profile as buyer-visible access-control evidence.", + "exit_criteria": "Buyer can verify admin and inference scopes, public bind opt-in, trace exposure default, rate limit, and concurrency controls.", + }, + { + "item_name": "audit_export_evidence", + "label": "Audit and evidence export", + "owner": "Evidence owner", + "sources": [ + "docs/commercial_evidence_export.md", + "docs/commercial_operations_readiness.md", + "/api/v1/commercial_evidence_exports/latest", + "/api/v1/commercial_operations_readiness/latest", + ], + "evidence_type": "repository_and_runtime_artifact", + "completion_state": "ready" + if has_file("docs/commercial_evidence_export.md") + and has_file("docs/commercial_operations_readiness.md") + else "blocked", + "evidence": "Commercial evidence export and operations readiness documents are present for buyer audit review.", + "action": "Package runtime evidence export with operations readiness for the security review data room.", + "exit_criteria": "Buyer can trace security claims to runtime endpoints and Markdown artifacts.", + }, + { + "item_name": "vulnerability_scan_evidence", + "label": "Vulnerability scan evidence", + "owner": "Security owner", + "sources": [ + ".github/workflows/security.yml", + "ContextualWisdomLab/.github central required security workflows", + ], + "evidence_type": "external_attestation_required", + "completion_state": "warning", + "source_gap_status": "external_attestation_required", + "evidence": "Local supply-chain workflow metadata and central security scan workflow metadata exist, but the buyer packet still needs the latest hosted scan result or buyer-accepted equivalent.", + "action": "Attach latest CodeQL, pip-audit, Trivy, SBOM, and Scorecard results when CI completes or the buyer requests evidence.", + "exit_criteria": "Hosted scan outputs are attached, or the buyer explicitly accepts workflow definitions as sufficient for this stage.", + }, + { + "item_name": "third_party_attestation_pen_test", + "label": "Third-party attestation or penetration test", + "owner": "Security owner", + "sources": ["buyer security review", "external assessor"], + "evidence_type": "external_attestation_required", + "completion_state": "warning", + "source_gap_status": "external_attestation_required", + "evidence": "Independent SOC 2, ISO 27001, penetration-test, or buyer security assessment evidence is outside the repo-local prototype.", + "action": "Provide the buyer-requested attestation, schedule an assessment, or document an explicit waiver.", + "exit_criteria": "Buyer accepts the third-party security evidence, scheduled assessment, or waiver.", + }, + { + "item_name": "buyer_privacy_dpa_questionnaire", + "label": "Buyer privacy, DPA, and questionnaire input", + "owner": "Deal owner", + "sources": ["buyer DPA", "buyer privacy questionnaire", "buyer order form"], + "evidence_type": "buyer_input_required", + "completion_state": "warning", + "source_gap_status": "buyer_input_required", + "evidence": "Privacy, DPA, subprocessors, data residency, and questionnaire answers depend on buyer-specific terms.", + "action": "Collect buyer privacy questionnaire, DPA requirements, subprocessors, and data residency constraints.", + "exit_criteria": "Buyer-specific privacy inputs are completed or explicitly waived in the deal packet.", + }, + { + "item_name": "review_process_policy", + "label": "Review process policy", + "owner": "Deal owner", + "sources": operations_by_name["review_process_policy"]["sources"], + "evidence_type": operations_by_name["review_process_policy"]["evidence_type"], + "completion_state": operations_by_name["review_process_policy"]["completion_state"], + "evidence": operations_by_name["review_process_policy"]["evidence"], + "action": operations_by_name["review_process_policy"]["action"], + "exit_criteria": operations_by_name["review_process_policy"]["exit_criteria"], + }, + { + "item_name": "packaging_decision", + "label": "Packaging decision", + "owner": operations_by_name["packaging_decision"]["owner"], + "sources": operations_by_name["packaging_decision"]["sources"], + "evidence_type": operations_by_name["packaging_decision"]["evidence_type"], + "completion_state": operations_by_name["packaging_decision"]["completion_state"], + "evidence": operations_by_name["packaging_decision"]["evidence"], + "action": operations_by_name["packaging_decision"]["action"], + "exit_criteria": operations_by_name["packaging_decision"]["exit_criteria"], + }, + ] + state_counts = Counter(item["completion_state"] for item in security_attestation_items) + blocked_count = state_counts.get("blocked", 0) + len(concrete_blockers) + warning_count = state_counts.get("warning", 0) + external_attestation_gap_count = sum( + 1 for item in security_attestation_items if item.get("source_gap_status") == "external_attestation_required" + ) + buyer_privacy_gap_count = sum( + 1 for item in security_attestation_items if item.get("source_gap_status") == "buyer_input_required" + ) + if blocked_count: + security_attestation_status = "commercial_security_attestation_blocked" + elif warning_count: + security_attestation_status = "commercial_security_attestation_ready_with_warnings" + else: # pragma: no cover - unreachable while this report carries literal buyer-specific warning sections + security_attestation_status = "commercial_security_attestation_ready" # pragma: no cover + + return { + "security_attestation_status": security_attestation_status, + "target_contract_value_krw": target_contract_value_krw, + "target_contract_value_display": f"KRW {target_contract_value_krw:,}", + "measurement_status": "local_commercial_security_attestation", + "source_note": ( + "Commercial security attestation separates repo-local security evidence from external " + "attestation, hosted scan, and buyer privacy inputs; it is not a valuation guarantee, " + "purchase commitment, production compliance certificate, or third-party security audit." + ), + "security_attestation_summary": { + "item_count": len(security_attestation_items), + "ready_count": state_counts.get("ready", 0), + "warning_count": warning_count, + "blocked_count": blocked_count, + "external_attestation_gap_count": external_attestation_gap_count, + "buyer_privacy_gap_count": buyer_privacy_gap_count, + "review_process_is_blocker": operations["review_process_policy"]["is_blocker"], + }, + "security_attestation_items": security_attestation_items, + "concrete_blockers": concrete_blockers, + "security_attestation_status_rules": [ + { + "security_attestation_status": "commercial_security_attestation_ready", + "rule": "security policy, dependency metadata, workflow metadata, access controls, audit export, external attestation, buyer privacy input, review policy, and packaging evidence are ready", + }, + { + "security_attestation_status": "commercial_security_attestation_ready_with_warnings", + "rule": "repo-local security packet is ready while hosted scan evidence, third-party attestation, or buyer privacy input remains explicit warnings", + }, + { + "security_attestation_status": "commercial_security_attestation_blocked", + "rule": "missing local security packet evidence, concrete product defect, API contract failure, document mismatch, security failure, or Code Connect usage blocks security attestation", + }, + ], + "review_process_policy": operations["review_process_policy"], + "related_runtime_reports": { + "commercial_operations_status": operations["operations_status"], + **operations["related_runtime_reports"], + }, + "library_split_decision": operations["library_split_decision"], + "plugin_traceability": operations["plugin_traceability"], + "security_attestation_links": { + "figma_design_file": "https://www.figma.com/design/vsZMd8WAv42HDRgcZuNcWk", + "figjam_board": "https://www.figma.com/board/Wr8iMlB9SHkerHSjv0Pe0M", + "runtime_endpoint": "/api/v1/commercial_security_attestations/latest", + "documentation": "docs/commercial_security_attestation.md", + }, + } + + def commercial_value_readiness_report( + self, + target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, + locale_bundles: dict[str, dict[str, str]] | None = None, + security_profile: dict[str, Any] | None = None, + release_authority: Mapping[str, Any] | None = None, + ) -> dict[str, Any]: + """Return a buyer economic-review gate over value and ROI evidence.""" + commercial = self.commercial_readiness_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + export = self.commercial_evidence_export_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + security = self.commercial_security_attestation_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + release_authority=release_authority, + ) + analytics = self.analytics_snapshot(locale_bundles=locale_bundles) + root = Path(__file__).resolve().parents[1] + + def has_file(path: str) -> bool: + return (root / path).is_file() + + criteria_by_name = self._criteria_by_name(commercial["criteria"]) + value_case = criteria_by_name["commercial_value_case"] + kpis = self._metrics_by_name(analytics["kpis"]) + guardrails = self._metrics_by_name(analytics["guardrails"]) + security_items = {item["item_name"]: item for item in security["security_attestation_items"]} + value_items = [ + { + "item_name": "commercial_value_case_basis", + "label": "Commercial value-case basis", + "owner": "Deal owner", + "sources": ["/api/v1/commercial_readiness/latest", "docs/commercial_readiness.md"], + "evidence_type": "local_due_diligence_snapshot", + "completion_state": "ready" if value_case["status"] == "pass" else "warning", + "evidence": value_case["evidence"], + "action": "Use commercial readiness as the value-case baseline without presenting it as a valuation guarantee.", + "exit_criteria": "Buyer sees the KRW target as a review anchor, not as a guaranteed valuation.", + }, + { + "item_name": "local_analytics_evidence", + "label": "Local analytics evidence", + "owner": "Product analytics owner", + "sources": ["/api/v1/analytics_snapshots/latest", "docs/analytics_spec.md"], + "evidence_type": "measured_local", + "completion_state": "ready", + "evidence": ( + f"compatible_api_adoption={kpis['compatible_api_adoption'].get('value')}; " + f"trace_complete_workflow_rate={kpis['trace_complete_workflow_rate'].get('value_percent')}%; " + f"policy_safe_routing_rate={kpis['policy_safe_routing_rate'].get('value_percent')}%; " + f"provider_exclusion_miss_rate={guardrails['provider_exclusion_miss_rate'].get('value')}" + ), + "action": "Use local measured adoption, trace, policy, and provider-safety metrics as evidence only for this prototype.", + "exit_criteria": "Buyer understands these are local measured signals, not production revenue or customer usage claims.", + }, + { + "item_name": "buyer_evidence_export", + "label": "Buyer evidence export", + "owner": "Evidence owner", + "sources": [ + "/api/v1/commercial_evidence_exports/latest", + "/api/v1/commercial_security_attestations/latest", + "docs/commercial_evidence_export.md", + ], + "evidence_type": "repository_and_runtime_artifact", + "completion_state": "ready" if has_file("docs/commercial_evidence_export.md") else "blocked", + "evidence": ( + f"commercial_export_status={export['export_status']}; " + f"security_attestation_status={security['security_attestation_status']}" + ), + "action": "Package value evidence with export and security attestation outputs in the buyer data room.", + "exit_criteria": "Buyer can trace economic claims back to runtime endpoints and repo artifacts.", + }, + { + "item_name": "pricing_package_rationale", + "label": "Pricing and package rationale", + "owner": "Deal owner", + "sources": [ + "docs/commercial_readiness.md", + "docs/commercial_saleability_decision.md", + "docs/commercial_procurement_readiness.md", + "docs/commercial_value_readiness.md", + ], + "evidence_type": "repository_artifact", + "completion_state": "ready" + if all( + has_file(path) + for path in ( + "docs/commercial_readiness.md", + "docs/commercial_saleability_decision.md", + "docs/commercial_procurement_readiness.md", + ) + ) + else "blocked", + "evidence": "Commercial readiness, saleability, and procurement documents anchor the package rationale.", + "action": "Keep the KRW 2B package rationale tied to API compatibility, evidence control plane, replay, audit, security, and operations readiness.", + "exit_criteria": "Buyer can inspect which product capabilities support the package rationale.", + }, + { + "item_name": "roi_model_inputs", + "label": "ROI model inputs", + "owner": "Buyer sponsor and deal owner", + "sources": ["buyer ROI model", "customer discovery", "procurement value case"], + "evidence_type": "buyer_input_required", + "completion_state": "warning", + "source_gap_status": "buyer_financial_input_required", + "evidence": "Buyer-specific baseline cost, workflow volume, error/rework cost, compliance cost, and time-saving assumptions are not repo-local facts.", + "action": "Collect buyer baseline metrics and map them to API compatibility, trace audit, replay, and operations savings.", + "exit_criteria": "Buyer accepts the ROI model inputs or marks them waived for the commercial review.", + }, + { + "item_name": "reference_customer_or_case_study", + "label": "Reference customer or proof", + "owner": "Deal owner", + "sources": ["reference customer", "case study", "paid pilot result"], + "evidence_type": "external_value_proof_required", + "completion_state": "warning", + "source_gap_status": "external_value_proof_required", + "evidence": "Reference customer, paid pilot, or production proof is external to the repo-local prototype.", + "action": "Attach a reference, pilot result, or explicit buyer waiver before treating the value case as externally proven.", + "exit_criteria": "Buyer accepts the reference proof, pilot result, or waiver.", + }, + { + "item_name": "procurement_budget_owner", + "label": "Procurement budget owner", + "owner": "Buyer sponsor and procurement owner", + "sources": ["buyer order form", "procurement process", "budget approval"], + "evidence_type": "buyer_input_required", + "completion_state": "warning", + "source_gap_status": "buyer_financial_input_required", + "evidence": "Budget owner, approval path, and order-form authority are buyer-specific inputs.", + "action": "Identify sponsor, budget owner, procurement path, and order-form authority.", + "exit_criteria": "Buyer confirms the budget owner and approval path for the KRW 2B review.", + }, + { + "item_name": "implementation_payback_assumption", + "label": "Implementation payback assumption", + "owner": "Buyer sponsor and onboarding owner", + "sources": ["buyer onboarding plan", "implementation estimate", "operations handoff"], + "evidence_type": "buyer_input_required", + "completion_state": "warning", + "source_gap_status": "buyer_financial_input_required", + "evidence": "Implementation timeline, staffing, opportunity cost, and payback window depend on buyer deployment scope.", + "action": "Estimate implementation effort and payback window during paid onboarding or buyer diligence.", + "exit_criteria": "Buyer accepts the payback assumptions or marks them out of scope.", + }, + { + "item_name": "review_process_policy", + "label": "Review process policy", + "owner": "Deal owner", + "sources": security_items["review_process_policy"]["sources"], + "evidence_type": security_items["review_process_policy"]["evidence_type"], + "completion_state": security_items["review_process_policy"]["completion_state"], + "evidence": security_items["review_process_policy"]["evidence"], + "action": security_items["review_process_policy"]["action"], + "exit_criteria": security_items["review_process_policy"]["exit_criteria"], + }, + { + "item_name": "packaging_decision", + "label": "Packaging decision", + "owner": security_items["packaging_decision"]["owner"], + "sources": security_items["packaging_decision"]["sources"], + "evidence_type": security_items["packaging_decision"]["evidence_type"], + "completion_state": security_items["packaging_decision"]["completion_state"], + "evidence": security_items["packaging_decision"]["evidence"], + "action": security_items["packaging_decision"]["action"], + "exit_criteria": security_items["packaging_decision"]["exit_criteria"], + }, + ] + state_counts = Counter(item["completion_state"] for item in value_items) + concrete_blockers = security["concrete_blockers"] + blocked_count = state_counts.get("blocked", 0) + len(concrete_blockers) + warning_count = state_counts.get("warning", 0) + buyer_financial_gap_count = sum( + 1 + for item in value_items + if item.get("source_gap_status") in {"buyer_financial_input_required", "external_value_proof_required"} + ) + external_value_proof_gap_count = sum( + 1 for item in value_items if item.get("source_gap_status") == "external_value_proof_required" + ) + if blocked_count: + value_status = "commercial_value_blocked" + elif warning_count: + value_status = "commercial_value_ready_with_warnings" + else: # pragma: no cover - unreachable while this report carries literal buyer-specific warning sections + value_status = "commercial_value_ready" # pragma: no cover + + return { + "value_status": value_status, + "target_contract_value_krw": target_contract_value_krw, + "target_contract_value_display": f"KRW {target_contract_value_krw:,}", + "measurement_status": "local_commercial_value_readiness", + "source_note": ( + "Commercial value readiness separates repo-local measured evidence from buyer-specific " + "ROI, reference, budget, and payback inputs; it is not a valuation guarantee, purchase " + "commitment, revenue proof, or financial advice." + ), + "value_summary": { + "item_count": len(value_items), + "ready_count": state_counts.get("ready", 0), + "warning_count": warning_count, + "blocked_count": blocked_count, + "buyer_financial_gap_count": buyer_financial_gap_count, + "external_value_proof_gap_count": external_value_proof_gap_count, + "review_process_is_blocker": security["review_process_policy"]["is_blocker"], + }, + "value_items": value_items, + "concrete_blockers": concrete_blockers, + "value_status_rules": [ + { + "value_status": "commercial_value_ready", + "rule": "commercial value case, local analytics, evidence export, pricing rationale, ROI inputs, reference proof, budget owner, payback assumptions, review policy, and packaging evidence are ready", + }, + { + "value_status": "commercial_value_ready_with_warnings", + "rule": "repo-local value evidence is ready while buyer ROI inputs, reference proof, budget owner, or payback assumptions remain explicit warnings", + }, + { + "value_status": "commercial_value_blocked", + "rule": "missing local value packet evidence, concrete product defect, API contract failure, document mismatch, security failure, or Code Connect usage blocks value readiness", + }, + ], + "review_process_policy": security["review_process_policy"], + "related_runtime_reports": { + "commercial_security_attestation_status": security["security_attestation_status"], + "commercial_export_status": export["export_status"], + "commercial_status": commercial["commercial_status"], + **security["related_runtime_reports"], + }, + "library_split_decision": security["library_split_decision"], + "plugin_traceability": security["plugin_traceability"], + "value_links": { + "figma_design_file": "https://www.figma.com/design/vsZMd8WAv42HDRgcZuNcWk", + "figjam_board": "https://www.figma.com/board/Wr8iMlB9SHkerHSjv0Pe0M", + "runtime_endpoint": "/api/v1/commercial_value_readiness/latest", + "documentation": "docs/commercial_value_readiness.md", + }, + } + + def commercial_close_readiness_report( + self, + target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, + locale_bundles: dict[str, dict[str, str]] | None = None, + security_profile: dict[str, Any] | None = None, + release_authority: Mapping[str, Any] | None = None, + ) -> dict[str, Any]: + """Return the final buyer-close gate over commercial readiness evidence.""" + value = self.commercial_value_readiness_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + release_authority=release_authority, + ) + security = self.commercial_security_attestation_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + release_authority=release_authority, + ) + contract = self.commercial_contract_readiness_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + release_authority=release_authority, + ) + onboarding = self.commercial_onboarding_readiness_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + release_authority=release_authority, + ) + operations = self.commercial_operations_readiness_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + release_authority=release_authority, + ) + export = self.commercial_evidence_export_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + root = Path(__file__).resolve().parents[1] + + def has_file(path: str) -> bool: + return (root / path).is_file() + + concrete_blockers = [ + *value["concrete_blockers"], + *security["concrete_blockers"], + *contract["concrete_blockers"], + *onboarding["concrete_blockers"], + *operations["concrete_blockers"], + *export["concrete_blockers"], + ] + concrete_blockers = list(dict.fromkeys(concrete_blockers)) + close_items = [ + { + "item_name": "sellable_product_packet", + "label": "Sellable product packet", + "owner": "Deal owner", + "sources": [ + "/api/v1/commercial_value_readiness/latest", + "/api/v1/commercial_security_attestations/latest", + "/api/v1/commercial_evidence_exports/latest", + "docs/commercial_value_readiness.md", + "docs/commercial_security_attestation.md", + "docs/commercial_evidence_export.md", + ], + "evidence_type": "repository_and_runtime_artifact", + "completion_state": "ready" + if value["value_status"] != "commercial_value_blocked" + and security["security_attestation_status"] != "commercial_security_attestation_blocked" + and export["export_status"] != "commercial_export_blocked" + and has_file("docs/commercial_value_readiness.md") + and has_file("docs/commercial_security_attestation.md") + and has_file("docs/commercial_evidence_export.md") + else "blocked", + "evidence": ( + f"value_status={value['value_status']}; " + f"security_attestation_status={security['security_attestation_status']}; " + f"commercial_export_status={export['export_status']}" + ), + "action": "Attach the repo-local product, security, value, and evidence export packet to buyer close review.", + "exit_criteria": "Buyer can inspect the sellable packet without treating it as a purchase commitment or valuation guarantee.", + }, + { + "item_name": "contract_close_packet", + "label": "Contract close packet", + "owner": "Legal and procurement owner", + "sources": [ + "/api/v1/commercial_contract_readiness/latest", + "docs/commercial_contract_readiness.md", + "docs/commercial_procurement_readiness.md", + ], + "evidence_type": "repository_and_runtime_artifact", + "completion_state": "ready" + if contract["contract_status"] != "commercial_contract_blocked" + and has_file("docs/commercial_contract_readiness.md") + else "blocked", + "evidence": f"contract_status={contract['contract_status']}", + "action": "Use contract readiness as the local legal/procurement packet and track final signatures separately.", + "exit_criteria": "Buyer legal/procurement sees local contract evidence and the remaining signature inputs.", + }, + { + "item_name": "onboarding_operations_packet", + "label": "Onboarding and operations packet", + "owner": "Customer success and platform owner", + "sources": [ + "/api/v1/commercial_onboarding_readiness/latest", + "/api/v1/commercial_operations_readiness/latest", + "docs/commercial_onboarding_readiness.md", + "docs/commercial_operations_readiness.md", + ], + "evidence_type": "repository_and_runtime_artifact", + "completion_state": "ready" + if onboarding["onboarding_status"] != "commercial_onboarding_blocked" + and operations["operations_status"] != "commercial_operations_blocked" + and has_file("docs/commercial_onboarding_readiness.md") + and has_file("docs/commercial_operations_readiness.md") + else "blocked", + "evidence": ( + f"onboarding_status={onboarding['onboarding_status']}; " + f"operations_status={operations['operations_status']}" + ), + "action": "Attach onboarding and operations readiness as the go-live support packet.", + "exit_criteria": "Buyer can identify implementation, support, operations, and acceptance owners.", + }, + { + "item_name": "buyer_evidence_export_packet", + "label": "Buyer evidence export packet", + "owner": "Evidence owner", + "sources": [ + "/api/v1/commercial_evidence_exports/latest", + "docs/commercial_evidence_export.md", + "docs/figma_artifacts.md", + ], + "evidence_type": "repository_and_runtime_artifact", + "completion_state": "ready" + if export["export_status"] != "commercial_export_blocked" + and has_file("docs/commercial_evidence_export.md") + and has_file("docs/figma_artifacts.md") + else "blocked", + "evidence": f"commercial_export_status={export['export_status']}", + "action": "Use the portable export packet as the buyer data-room index.", + "exit_criteria": "Buyer can trace close evidence to runtime endpoints, docs, and Figma/FigJam artifacts.", + }, + { + "item_name": "signed_order_form_msa", + "label": "Signed order form or MSA", + "owner": "Buyer sponsor, procurement owner, and deal owner", + "sources": ["buyer order form", "MSA", "signature packet"], + "evidence_type": "buyer_signature_required", + "completion_state": "warning", + "source_gap_status": "buyer_signature_required", + "evidence": "Signed order form, MSA, commercial terms, and authority confirmation are buyer-side close inputs.", + "action": "Collect final signed order form or MSA, or attach an explicit buyer waiver.", + "exit_criteria": "Buyer and seller signature authority accept the order form or MSA.", + }, + { + "item_name": "dpa_security_acceptance", + "label": "DPA and security acceptance", + "owner": "Buyer security, privacy, and legal owner", + "sources": ["buyer DPA", "security review acceptance", "privacy questionnaire"], + "evidence_type": "buyer_signature_required", + "completion_state": "warning", + "source_gap_status": "buyer_signature_required", + "evidence": "DPA, security acceptance, privacy questionnaire, and attestation waivers are buyer-specific close inputs.", + "action": "Collect DPA/security acceptance or documented waiver from buyer security and legal reviewers.", + "exit_criteria": "Buyer signs or waives DPA/security acceptance requirements.", + }, + { + "item_name": "budget_approval_purchase_order", + "label": "Budget approval and purchase order", + "owner": "Buyer finance and procurement owner", + "sources": ["budget approval", "purchase order", "finance approval"], + "evidence_type": "buyer_signature_required", + "completion_state": "warning", + "source_gap_status": "buyer_signature_required", + "evidence": "Budget approval, purchase order, and finance authority are external buyer procurement evidence.", + "action": "Collect buyer budget approval and PO or attach approved alternative payment authority.", + "exit_criteria": "Buyer procurement confirms budget authority and payment path for KRW 2B.", + }, + { + "item_name": "go_live_authorization", + "label": "Go-live authorization", + "owner": "Buyer business sponsor and implementation owner", + "sources": ["go-live approval", "implementation authorization", "acceptance signoff"], + "evidence_type": "buyer_signature_required", + "completion_state": "warning", + "source_gap_status": "buyer_signature_required", + "evidence": "Go-live authorization and implementation acceptance require named buyer approval.", + "action": "Collect go-live authorization or mark production activation out of scope for the signed deal.", + "exit_criteria": "Buyer authorizes go-live, paid onboarding, or a scoped post-signature implementation plan.", + }, + { + "item_name": "review_process_policy", + "label": "Review process policy", + "owner": "Deal owner", + "sources": ["docs/commercial_saleability_decision.md", "docs/commercial_close_readiness.md"], + "evidence_type": "repository_artifact", + "completion_state": "ready", + "evidence": "Review process delay is not a close blocker unless a concrete product, security, API-contract, or document failure is produced.", + "action": "Keep commercial close work moving while queued review processes are pending.", + "exit_criteria": "Only concrete failures block close readiness.", + }, + { + "item_name": "packaging_decision", + "label": "Packaging decision", + "owner": "Procurement and security reviewer", + "sources": ["docs/library_research.md", "docs/commercial_plugin_operating_model.md"], + "evidence_type": "repository_artifact", + "completion_state": "ready" + if value["library_split_decision"]["decision"] == "keep_single_product" + else "warning", + "evidence": value["library_split_decision"]["reason"], + "action": "Keep one deployable enterprise control-plane product until extraction triggers are real.", + "exit_criteria": "Do not create a separate library, Git submodule, or extracted package for this close gate.", + }, + ] + state_counts = Counter(item["completion_state"] for item in close_items) + blocked_count = state_counts.get("blocked", 0) + len(concrete_blockers) + warning_count = state_counts.get("warning", 0) + buyer_signature_gap_count = sum( + 1 for item in close_items if item.get("source_gap_status") == "buyer_signature_required" + ) + if blocked_count: + close_status = "commercial_close_blocked" + elif warning_count: + close_status = "commercial_close_ready_with_warnings" + else: # pragma: no cover - unreachable while this report carries literal buyer-specific warning sections + close_status = "commercial_close_ready" # pragma: no cover + + return { + "close_status": close_status, + "target_contract_value_krw": target_contract_value_krw, + "target_contract_value_display": f"KRW {target_contract_value_krw:,}", + "measurement_status": "local_commercial_close_readiness", + "source_note": ( + "Commercial close readiness separates repo-local sellable product evidence from buyer " + "signature, legal, procurement, security acceptance, and go-live authorization inputs; " + "it is not a valuation guarantee, purchase commitment, signed order, legal opinion, " + "or production compliance certificate." + ), + "close_summary": { + "item_count": len(close_items), + "ready_count": state_counts.get("ready", 0), + "warning_count": warning_count, + "blocked_count": blocked_count, + "buyer_signature_gap_count": buyer_signature_gap_count, + "review_process_is_blocker": value["review_process_policy"]["is_blocker"], + }, + "close_items": close_items, + "concrete_blockers": concrete_blockers, + "close_status_rules": [ + { + "close_status": "commercial_close_ready", + "rule": "sellable product packet, contract packet, onboarding/operations packet, evidence export, signatures, DPA/security acceptance, budget/PO, go-live authorization, review policy, and packaging evidence are ready", + }, + { + "close_status": "commercial_close_ready_with_warnings", + "rule": "repo-local close packet is ready while buyer signatures, DPA/security acceptance, budget/PO, or go-live authorization remain explicit warnings", + }, + { + "close_status": "commercial_close_blocked", + "rule": "missing local close evidence, concrete product defect, API contract failure, document mismatch, security failure, or Code Connect usage blocks close readiness", + }, + ], + "review_process_policy": value["review_process_policy"], + "related_runtime_reports": { + "commercial_value_status": value["value_status"], + "commercial_security_attestation_status": security["security_attestation_status"], + "commercial_contract_status": contract["contract_status"], + "commercial_onboarding_status": onboarding["onboarding_status"], + "commercial_operations_status": operations["operations_status"], + "commercial_export_status": export["export_status"], + **value["related_runtime_reports"], + }, + "library_split_decision": value["library_split_decision"], + "plugin_traceability": value["plugin_traceability"], + "close_links": { + "figma_design_file": "https://www.figma.com/design/vsZMd8WAv42HDRgcZuNcWk", + "figjam_board": "https://www.figma.com/board/Wr8iMlB9SHkerHSjv0Pe0M", + "runtime_endpoint": "/api/v1/commercial_close_readiness/latest", + "documentation": "docs/commercial_close_readiness.md", + }, + } + + def commercial_go_to_market_readiness_report( + self, + target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, + locale_bundles: dict[str, dict[str, str]] | None = None, + security_profile: dict[str, Any] | None = None, + release_authority: Mapping[str, Any] | None = None, + ) -> dict[str, Any]: + """Return a buyer-facing GTM readiness index over commercial evidence.""" + close = self.commercial_close_readiness_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + release_authority=release_authority, + ) + value = self.commercial_value_readiness_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + release_authority=release_authority, + ) + security = self.commercial_security_attestation_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + release_authority=release_authority, + ) + export = self.commercial_evidence_export_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + handoff = self.commercial_handoff_bundle_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + saleability = self.saleability_decision_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + analytics = self.analytics_snapshot(locale_bundles=locale_bundles) + root = Path(__file__).resolve().parents[1] + + def has_file(path: str) -> bool: + return (root / path).is_file() + + concrete_blockers = [ + *close["concrete_blockers"], + *value["concrete_blockers"], + *security["concrete_blockers"], + *export["concrete_blockers"], + *saleability["concrete_blockers"], + ] + concrete_blockers = list(dict.fromkeys(concrete_blockers)) + gtm_items = [ + { + "item_name": "commercial_close_packet", + "label": "Commercial close packet", + "owner": "Deal owner", + "sources": ["/api/v1/commercial_close_readiness/latest", "docs/commercial_close_readiness.md"], + "evidence_type": "repository_and_runtime_artifact", + "completion_state": "ready" + if close["close_status"] != "commercial_close_blocked" + and has_file("docs/commercial_close_readiness.md") + else "blocked", + "evidence": f"close_status={close['close_status']}", + "action": "Use close readiness as the buyer-facing final readiness packet.", + "exit_criteria": "Buyer sees local close packet status and remaining buyer-side signature gaps.", + }, + { + "item_name": "economic_value_packet", + "label": "Economic value packet", + "owner": "Deal owner and analytics owner", + "sources": [ + "/api/v1/commercial_value_readiness/latest", + "/api/v1/analytics_snapshots/latest", + "docs/commercial_value_readiness.md", + "docs/analytics_spec.md", + ], + "evidence_type": "repository_and_runtime_artifact", + "completion_state": "ready" + if value["value_status"] != "commercial_value_blocked" + and has_file("docs/commercial_value_readiness.md") + and has_file("docs/analytics_spec.md") + else "blocked", + "evidence": ( + f"value_status={value['value_status']}; " + f"kpi_count={len(analytics['kpis'])}; guardrail_count={len(analytics['guardrails'])}" + ), + "action": "Show value evidence with measured-local versus buyer-specific metric separation.", + "exit_criteria": "Buyer can inspect value claims without treating them as revenue proof or financial advice.", + }, + { + "item_name": "security_trust_packet", + "label": "Security trust packet", + "owner": "Security owner", + "sources": [ + "/api/v1/commercial_security_attestations/latest", + "docs/commercial_security_attestation.md", + "SECURITY.md", + ], + "evidence_type": "repository_and_runtime_artifact", + "completion_state": "ready" + if security["security_attestation_status"] != "commercial_security_attestation_blocked" + and has_file("docs/commercial_security_attestation.md") + and has_file("SECURITY.md") + else "blocked", + "evidence": f"security_attestation_status={security['security_attestation_status']}", + "action": "Use security attestation as the buyer trust packet and keep external attestations separate.", + "exit_criteria": "Buyer can inspect local security controls and external attestation gaps.", + }, + { + "item_name": "buyer_evidence_packet", + "label": "Buyer evidence packet", + "owner": "Evidence owner", + "sources": [ + "/api/v1/commercial_evidence_exports/latest", + "/api/v1/commercial_handoff_bundles/latest", + "docs/commercial_evidence_export.md", + "docs/commercial_buyer_handoff_bundle.md", + ], + "evidence_type": "repository_and_runtime_artifact", + "completion_state": "ready" + if export["export_status"] != "commercial_export_blocked" + and handoff["bundle_status"] != "buyer_handoff_blocked" + and has_file("docs/commercial_evidence_export.md") + and has_file("docs/commercial_buyer_handoff_bundle.md") + else "blocked", + "evidence": f"commercial_export_status={export['export_status']}; buyer_handoff_status={handoff['bundle_status']}", + "action": "Attach evidence export and handoff bundle as the buyer data-room index.", + "exit_criteria": "Buyer can trace GTM claims to runtime endpoints, docs, tests, and Figma artifacts.", + }, + { + "item_name": "saleability_decision_packet", + "label": "Saleability decision packet", + "owner": "Deal owner", + "sources": ["/api/v1/saleability_decisions/latest", "docs/commercial_saleability_decision.md"], + "evidence_type": "repository_and_runtime_artifact", + "completion_state": "ready" + if saleability["saleability_status"] != "saleability_blocked" + and has_file("docs/commercial_saleability_decision.md") + else "blocked", + "evidence": f"saleability_status={saleability['saleability_status']}", + "action": "Use saleability decision as the GTM go/no-go baseline.", + "exit_criteria": "Buyer and stakeholder review can distinguish warnings from concrete blockers.", + }, + { + "item_name": "admin_operator_evidence", + "label": "Admin operator evidence", + "owner": "Product design owner", + "sources": ["/admin", "contextual_orchestrator/admin.py", "docs/screen_design.md"], + "evidence_type": "repository_and_runtime_artifact", + "completion_state": "ready" + if has_file("contextual_orchestrator/admin.py") and has_file("docs/screen_design.md") + else "blocked", + "evidence": "Admin surface exposes readiness status, source notes, measurement status, and warning/blocker summaries.", + "action": "Use the existing admin observability surface instead of creating a separate sales dashboard.", + "exit_criteria": "Operator can inspect GTM readiness from the current admin surface.", + }, + { + "item_name": "analytics_truthfulness_packet", + "label": "Analytics truthfulness packet", + "owner": "Data analytics owner", + "sources": ["docs/analytics_spec.md", "/api/v1/analytics_snapshots/latest"], + "evidence_type": "repository_and_runtime_artifact", + "completion_state": "ready" if has_file("docs/analytics_spec.md") else "blocked", + "evidence": "Analytics spec separates measured local evidence from proposed production or buyer-specific inputs.", + "action": "Keep GTM metrics from claiming production revenue, signed buyer proof, or unmeasured telemetry.", + "exit_criteria": "Stakeholders can see which KPI fields are measured and which are proposed inputs.", + }, + { + "item_name": "stakeholder_artifacts_packet", + "label": "Stakeholder artifacts packet", + "owner": "Figma and Product Design owner", + "sources": [ + "docs/figma_artifacts.md", + "https://www.figma.com/design/vsZMd8WAv42HDRgcZuNcWk", + "https://www.figma.com/board/Wr8iMlB9SHkerHSjv0Pe0M", + ], + "evidence_type": "figma_artifact", + "completion_state": "ready" if has_file("docs/figma_artifacts.md") else "blocked", + "evidence": "Editable Figma/FigJam stakeholder artifacts are recorded and Figma Code Connect is excluded.", + "action": "Use editable stakeholder artifacts for GTM review instead of screenshot-only evidence.", + "exit_criteria": "Stakeholders can open the design file and FigJam board for GTM review.", + }, + { + "item_name": "buyer_signature_budget_follow_up", + "label": "Buyer signature and budget follow-up", + "owner": "Buyer sponsor, procurement owner, and deal owner", + "sources": ["buyer order form", "MSA", "DPA", "security acceptance", "purchase order", "go-live approval"], + "evidence_type": "buyer_input_required", + "completion_state": "warning", + "source_gap_status": "buyer_signature_required", + "evidence": ( + f"buyer_signature_gap_count={close['close_summary']['buyer_signature_gap_count']}; " + "signed order/MSA, DPA/security acceptance, budget/PO, and go-live authorization are buyer inputs." + ), + "action": "Collect buyer signatures, approvals, or waivers before representing the packet as closed-won.", + "exit_criteria": "Buyer accepts or waives all signature, budget, security acceptance, and go-live inputs.", + }, + { + "item_name": "production_external_proof_follow_up", + "label": "Production and external proof follow-up", + "owner": "Security, operations, and deal owner", + "sources": ["hosted scan output", "third-party attestation", "reference proof", "production telemetry"], + "evidence_type": "external_or_production_input_required", + "completion_state": "warning", + "source_gap_status": "external_or_production_input_required", + "evidence": ( + f"security_warning_count={security['security_attestation_summary']['warning_count']}; " + f"value_warning_count={value['value_summary']['warning_count']}; " + f"export_warning_count={export['export_summary']['warning_count']}" + ), + "action": "Attach hosted scan, third-party attestation, reference proof, and production telemetry when available.", + "exit_criteria": "Buyer accepts external proof, production proof, or an explicit waiver.", + }, + { + "item_name": "review_process_policy", + "label": "Review process policy", + "owner": "Deal owner", + "sources": ["docs/commercial_go_to_market_readiness.md", "docs/commercial_saleability_decision.md"], + "evidence_type": "repository_artifact", + "completion_state": "ready", + "evidence": "Review process delay is not a GTM blocker unless a concrete failure is produced.", + "action": "Continue GTM readiness work while queued reviews are pending.", + "exit_criteria": "Only concrete product, security, API contract, or document failures block GTM readiness.", + }, + { + "item_name": "packaging_decision", + "label": "Packaging decision", + "owner": "Procurement and security reviewer", + "sources": ["docs/library_research.md", "docs/commercial_plugin_operating_model.md"], + "evidence_type": "repository_artifact", + "completion_state": "ready" + if close["library_split_decision"]["decision"] == "keep_single_product" + else "warning", + "evidence": close["library_split_decision"]["reason"], + "action": "Keep one deployable enterprise control-plane product until extraction triggers are real.", + "exit_criteria": "Do not create a separate library, Git submodule, or extracted package for this GTM gate.", + }, + ] + state_counts = Counter(item["completion_state"] for item in gtm_items) + blocked_count = state_counts.get("blocked", 0) + len(concrete_blockers) + warning_count = state_counts.get("warning", 0) + buyer_signature_gap_count = close["close_summary"]["buyer_signature_gap_count"] + external_or_production_gap_count = ( + security["security_attestation_summary"]["external_attestation_gap_count"] + + value["value_summary"]["external_value_proof_gap_count"] + + export["export_summary"]["warning_count"] + ) + if blocked_count: + gtm_status = "commercial_go_to_market_blocked" + elif warning_count: + gtm_status = "commercial_go_to_market_ready_with_warnings" + else: # pragma: no cover - unreachable while this report carries literal buyer-specific warning sections + gtm_status = "commercial_go_to_market_ready" # pragma: no cover + + return { + "go_to_market_status": gtm_status, + "target_contract_value_krw": target_contract_value_krw, + "target_contract_value_display": f"KRW {target_contract_value_krw:,}", + "measurement_status": "local_commercial_go_to_market_readiness", + "source_note": ( + "Commercial go-to-market readiness indexes repo-local sellable product, evidence, " + "admin, analytics, and stakeholder artifacts separately from buyer signatures, " + "external proof, and production telemetry; it is not a valuation guarantee, purchase " + "commitment, signed order, legal opinion, production compliance certificate, or revenue proof." + ), + "go_to_market_summary": { + "item_count": len(gtm_items), + "ready_count": state_counts.get("ready", 0), + "warning_count": warning_count, + "blocked_count": blocked_count, + "buyer_signature_gap_count": buyer_signature_gap_count, + "external_or_production_gap_count": external_or_production_gap_count, + "review_process_is_blocker": close["review_process_policy"]["is_blocker"], + }, + "go_to_market_items": gtm_items, + "concrete_blockers": concrete_blockers, + "go_to_market_status_rules": [ + { + "go_to_market_status": "commercial_go_to_market_ready", + "rule": "close, value, security, evidence, saleability, admin, analytics, stakeholder artifacts, buyer inputs, external proof, review policy, and packaging evidence are ready", + }, + { + "go_to_market_status": "commercial_go_to_market_ready_with_warnings", + "rule": "repo-local GTM packet is ready while buyer signatures, budget/PO, DPA/security acceptance, production telemetry, reference proof, hosted scan, or third-party attestation remain explicit warnings", + }, + { + "go_to_market_status": "commercial_go_to_market_blocked", + "rule": "missing local GTM packet evidence, concrete product defect, API contract failure, document mismatch, security failure, or Code Connect usage blocks GTM readiness", + }, + ], + "review_process_policy": close["review_process_policy"], + "related_runtime_reports": { + "commercial_close_status": close["close_status"], + "commercial_value_status": value["value_status"], + "commercial_security_attestation_status": security["security_attestation_status"], + "commercial_export_status": export["export_status"], + "buyer_handoff_status": handoff["bundle_status"], + "saleability_status": saleability["saleability_status"], + **close["related_runtime_reports"], + }, + "library_split_decision": close["library_split_decision"], + "plugin_traceability": close["plugin_traceability"], + "go_to_market_links": { + "figma_design_file": "https://www.figma.com/design/vsZMd8WAv42HDRgcZuNcWk", + "figjam_board": "https://www.figma.com/board/Wr8iMlB9SHkerHSjv0Pe0M", + "runtime_endpoint": "/api/v1/commercial_go_to_market_readiness/latest", + "documentation": "docs/commercial_go_to_market_readiness.md", + }, + } + + def commercial_launch_readiness_report( + self, + target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, + locale_bundles: dict[str, dict[str, str]] | None = None, + security_profile: dict[str, Any] | None = None, + release_authority: Mapping[str, Any] | None = None, + ) -> dict[str, Any]: + """Return the buyer launch/trial readiness gate over commercial evidence.""" + gtm = self.commercial_go_to_market_readiness_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + release_authority=release_authority, + ) + operations = self.commercial_operations_readiness_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + release_authority=release_authority, + ) + onboarding = self.commercial_onboarding_readiness_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + release_authority=release_authority, + ) + acceptance = self.commercial_acceptance_check_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + analytics = self.analytics_snapshot(locale_bundles=locale_bundles) + admin_state = self.admin_state() + root = Path(__file__).resolve().parents[1] + + def has_file(path: str) -> bool: + return (root / path).is_file() + + concrete_blockers = [ + *gtm["concrete_blockers"], + *operations["concrete_blockers"], + *onboarding["concrete_blockers"], + *acceptance["concrete_blockers"], + ] + concrete_blockers = list(dict.fromkeys(concrete_blockers)) + launch_items = [ + { + "item_name": "go_to_market_packet", + "label": "Go-to-market packet", + "owner": "Deal owner", + "sources": [ + "/api/v1/commercial_go_to_market_readiness/latest", + "docs/commercial_go_to_market_readiness.md", + ], + "evidence_type": "repository_and_runtime_artifact", + "completion_state": "ready" + if gtm["go_to_market_status"] != "commercial_go_to_market_blocked" + and has_file("docs/commercial_go_to_market_readiness.md") + else "blocked", + "evidence": f"go_to_market_status={gtm['go_to_market_status']}", + "action": "Use the GTM packet as the launch/trial entry evidence.", + "exit_criteria": "Buyer can inspect the launch packet without treating it as a signed deal or production proof.", + }, + { + "item_name": "runtime_launch_path", + "label": "Runtime launch path", + "owner": "Platform operator", + "sources": [ + "README.md", + "contextual_orchestrator/server.py", + "contextual_orchestrator/api_contract.py", + "docs/rest_api_design.md", + "/v1/chat/completions", + "/admin", + ], + "evidence_type": "repository_artifact", + "completion_state": "ready" + if all( + has_file(path) + for path in ( + "README.md", + "contextual_orchestrator/server.py", + "contextual_orchestrator/api_contract.py", + "docs/rest_api_design.md", + ) + ) + else "blocked", + "evidence": "Stdlib server, OpenAI-compatible endpoint, admin console, and REST contract are present.", + "action": "Run the existing server and admin/API smoke tests for buyer trial setup.", + "exit_criteria": "Buyer can start the runtime, authenticate admin calls, and inspect launch readiness JSON.", + }, + { + "item_name": "acceptance_test_packet", + "label": "Acceptance test packet", + "owner": "Technical reviewer", + "sources": [ + "/api/v1/commercial_acceptance_checks/latest", + "tests/test_commercial_acceptance_check.py", + "tests/test_commercial_go_to_market_readiness.py", + "tests/test_commercial_launch_readiness.py", + "pytest -q", + ], + "evidence_type": "measured_local", + "completion_state": "ready" + if acceptance["acceptance_status"] != "commercial_acceptance_blocked" + and all( + has_file(path) + for path in ( + "tests/test_commercial_acceptance_check.py", + "tests/test_commercial_go_to_market_readiness.py", + "tests/test_commercial_launch_readiness.py", + ) + ) + else "blocked", + "evidence": f"acceptance_status={acceptance['acceptance_status']}", + "action": "Use focused acceptance and launch tests as the local verification packet.", + "exit_criteria": "Focused launch, GTM, acceptance, API, and artifact tests pass before buyer handoff.", + }, + { + "item_name": "operator_runbook_packet", + "label": "Operator runbook packet", + "owner": "Customer success and platform owner", + "sources": [ + "/api/v1/commercial_operations_readiness/latest", + "/api/v1/commercial_onboarding_readiness/latest", + "docs/commercial_operations_readiness.md", + "docs/commercial_onboarding_readiness.md", + ], + "evidence_type": "repository_and_runtime_artifact", + "completion_state": "ready" + if operations["operations_status"] != "commercial_operations_blocked" + and onboarding["onboarding_status"] != "commercial_onboarding_blocked" + and has_file("docs/commercial_operations_readiness.md") + and has_file("docs/commercial_onboarding_readiness.md") + else "blocked", + "evidence": ( + f"operations_status={operations['operations_status']}; " + f"onboarding_status={onboarding['onboarding_status']}" + ), + "action": "Attach onboarding and operations readiness as the launch runbook.", + "exit_criteria": "Buyer sees implementation, support, telemetry, incident, backup, and acceptance owners.", + }, + { + "item_name": "admin_observability_packet", + "label": "Admin observability packet", + "owner": "Product design owner", + "sources": ["/admin", "/admin/state", "contextual_orchestrator/admin.py", "docs/screen_design.md"], + "evidence_type": "repository_and_runtime_artifact", + "completion_state": "ready" + if admin_state["agents"] and has_file("contextual_orchestrator/admin.py") and has_file("docs/screen_design.md") + else "blocked", + "evidence": ( + f"agent_count={len(admin_state['agents'])}; " + "admin surface exposes launch, source, measurement, and warning summaries." + ), + "action": "Use the current admin observability surface rather than a separate sales dashboard.", + "exit_criteria": "Operator can review launch readiness from the existing admin console.", + }, + { + "item_name": "buyer_environment_inputs", + "label": "Buyer environment inputs", + "owner": "Buyer implementation owner and platform operator", + "sources": ["buyer environment URL", "deployment topology", "admin token handoff", "data retention decision"], + "evidence_type": "buyer_environment_required", + "completion_state": "warning", + "source_gap_status": "buyer_environment_required", + "evidence": "Buyer deployment URL, topology, credentials handoff, retention, and network policy are not repo-local evidence.", + "action": "Collect buyer environment details or attach explicit trial-scope waivers.", + "exit_criteria": "Buyer provides environment inputs or agrees the launch is limited to repo-local/demo execution.", + }, + { + "item_name": "production_telemetry_inputs", + "label": "Production telemetry inputs", + "owner": "Operations and analytics owner", + "sources": [ + "/api/v1/commercial_operations_readiness/latest", + "/api/v1/analytics_snapshots/latest", + "production request logs", + "incident drill record", + "backup restore proof", + ], + "evidence_type": "proposed_until_production", + "completion_state": "warning", + "source_gap_status": "production_input_required", + "evidence": ( + f"operations_production_evidence_action_count=" + f"{operations['operations_summary']['production_evidence_action_count']}; " + f"analytics_measurement_status={analytics['measurement_status']}" + ), + "action": "Capture production telemetry, SLO evidence, incident drill, and restore proof in the buyer environment.", + "exit_criteria": "First production telemetry snapshot and operations proof are attached or explicitly waived.", + }, + { + "item_name": "commercial_signature_inputs", + "label": "Commercial signature inputs", + "owner": "Buyer sponsor, procurement owner, and deal owner", + "sources": ["signed order/MSA", "DPA/security acceptance", "purchase order", "go-live authorization"], + "evidence_type": "buyer_signature_required", + "completion_state": "warning", + "source_gap_status": "buyer_signature_required", + "evidence": ( + f"buyer_signature_gap_count={gtm['go_to_market_summary']['buyer_signature_gap_count']}; " + "signed order, DPA/security acceptance, budget/PO, and go-live authorization are buyer inputs." + ), + "action": "Collect signatures, approvals, or waivers before representing launch readiness as closed-won.", + "exit_criteria": "Buyer accepts all signature, DPA/security, budget, and go-live inputs.", + }, + { + "item_name": "review_process_policy", + "label": "Review process policy", + "owner": "Deal owner", + "sources": ["docs/commercial_launch_readiness.md", "docs/commercial_go_to_market_readiness.md"], + "evidence_type": "repository_artifact", + "completion_state": "ready", + "evidence": "Review process delay is not a launch blocker unless a concrete failure is produced.", + "action": "Continue launch readiness work while queued review processes are pending.", + "exit_criteria": "Only concrete product, security, API contract, or document failures block launch readiness.", + }, + { + "item_name": "packaging_decision", + "label": "Packaging decision", + "owner": "Procurement and security reviewer", + "sources": ["docs/library_research.md", "docs/commercial_plugin_operating_model.md"], + "evidence_type": "repository_artifact", + "completion_state": "ready" + if gtm["library_split_decision"]["decision"] == "keep_single_product" + else "warning", + "evidence": gtm["library_split_decision"]["reason"], + "action": "Keep one deployable enterprise control-plane product until extraction triggers are real.", + "exit_criteria": "Do not create a separate library, Git submodule, or extracted package for this launch gate.", + }, + ] + state_counts = Counter(item["completion_state"] for item in launch_items) + blocked_count = state_counts.get("blocked", 0) + len(concrete_blockers) + warning_count = state_counts.get("warning", 0) + buyer_environment_gap_count = sum( + 1 for item in launch_items if item.get("source_gap_status") == "buyer_environment_required" + ) + production_telemetry_gap_count = sum( + 1 for item in launch_items if item.get("source_gap_status") == "production_input_required" + ) + commercial_signature_gap_count = sum( + 1 for item in launch_items if item.get("source_gap_status") == "buyer_signature_required" + ) + external_input_group_count = ( + buyer_environment_gap_count + production_telemetry_gap_count + commercial_signature_gap_count + ) + if blocked_count: + launch_status = "commercial_launch_blocked" + elif warning_count: + launch_status = "commercial_launch_ready_with_warnings" + else: # pragma: no cover - unreachable while this report carries literal buyer-specific warning sections + launch_status = "commercial_launch_ready" # pragma: no cover + + return { + "launch_status": launch_status, + "target_contract_value_krw": target_contract_value_krw, + "target_contract_value_display": f"KRW {target_contract_value_krw:,}", + "measurement_status": "local_commercial_launch_readiness", + "source_note": ( + "Commercial launch readiness packages repo-local GTM, runtime, acceptance, operator, admin, " + "analytics, Figma, review-process, and packaging evidence separately from buyer environment, " + "production telemetry, and commercial signature inputs; it is not a valuation guarantee, " + "purchase commitment, signed order, legal opinion, production compliance certificate, or revenue proof." + ), + "launch_summary": { + "item_count": len(launch_items), + "ready_count": state_counts.get("ready", 0), + "warning_count": warning_count, + "blocked_count": blocked_count, + "external_input_group_count": external_input_group_count, + "buyer_environment_gap_count": buyer_environment_gap_count, + "production_telemetry_gap_count": production_telemetry_gap_count, + "commercial_signature_gap_count": commercial_signature_gap_count, + "review_process_is_blocker": gtm["review_process_policy"]["is_blocker"], + }, + "launch_items": launch_items, + "concrete_blockers": concrete_blockers, + "launch_status_rules": [ + { + "launch_status": "commercial_launch_ready", + "rule": "GTM, runtime, acceptance, operator, admin, buyer environment, production telemetry, commercial signature, review policy, and packaging evidence are ready", + }, + { + "launch_status": "commercial_launch_ready_with_warnings", + "rule": "repo-local launch packet is ready while buyer environment, production telemetry, or commercial signature inputs remain explicit warnings", + }, + { + "launch_status": "commercial_launch_blocked", + "rule": "missing local launch packet evidence, concrete product defect, API contract failure, document mismatch, security failure, or Code Connect usage blocks launch readiness", + }, + ], + "review_process_policy": gtm["review_process_policy"], + "related_runtime_reports": { + "commercial_go_to_market_status": gtm["go_to_market_status"], + "commercial_operations_status": operations["operations_status"], + "commercial_onboarding_status": onboarding["onboarding_status"], + "commercial_acceptance_status": acceptance["acceptance_status"], + "analytics_measurement_status": analytics["measurement_status"], + **gtm["related_runtime_reports"], + }, + "library_split_decision": gtm["library_split_decision"], + "plugin_traceability": gtm["plugin_traceability"], + "launch_links": { + "figma_design_file": "https://www.figma.com/design/vsZMd8WAv42HDRgcZuNcWk", + "figjam_board": "https://www.figma.com/board/Wr8iMlB9SHkerHSjv0Pe0M", + "runtime_endpoint": "/api/v1/commercial_launch_readiness/latest", + "documentation": "docs/commercial_launch_readiness.md", + }, + } + + def commercial_completion_scorecard_report( + self, + target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, + locale_bundles: dict[str, dict[str, str]] | None = None, + security_profile: dict[str, Any] | None = None, + release_authority: Mapping[str, Any] | None = None, + ) -> dict[str, Any]: + """Return the final KRW 2B commercial completion scorecard.""" + commercial = self.commercial_readiness_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + gtm = self.commercial_go_to_market_readiness_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + release_authority=release_authority, + ) + launch = self.commercial_launch_readiness_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + release_authority=release_authority, + ) + analytics = self.analytics_snapshot(locale_bundles=locale_bundles) + admin_state = self.admin_state() + root = Path(__file__).resolve().parents[1] + + def has_file(path: str) -> bool: + return (root / path).is_file() + + concrete_blockers = list(launch["concrete_blockers"]) + if commercial["commercial_status"] == "not_commercial_ready": + concrete_blockers.append("commercial_readiness_failed") + if launch["launch_status"] == "commercial_launch_blocked": + concrete_blockers.append("commercial_launch_blocked") + concrete_blockers = list(dict.fromkeys(concrete_blockers)) + scorecard_items = [ + { + "item_name": "product_design_evidence", + "label": "Product Design evidence", + "owner": "Product design owner", + "sources": [ + "docs/plugin_driven_design_brief.md", + "docs/commercial_plugin_operating_model.md", + "docs/screen_design.md", + "/admin", + "/api/v1/commercial_readiness/latest", + ], + "evidence_type": "repository_and_runtime_artifact", + "completion_state": "ready" + if all( + has_file(path) + for path in ( + "docs/plugin_driven_design_brief.md", + "docs/commercial_plugin_operating_model.md", + "docs/screen_design.md", + ) + ) + and admin_state["agents"] + else "blocked", + "evidence": "Buyer, operator, security/compliance, and procurement workflows map to admin and readiness evidence.", + "action": "Keep buyer evidence paths visible in the existing admin control plane.", + "exit_criteria": "Every persona has a product/API/docs evidence path.", + }, + { + "item_name": "figma_artifacts", + "label": "Figma artifacts", + "owner": "Figma owner", + "sources": [ + "docs/figma_artifacts.md", + "https://www.figma.com/design/vsZMd8WAv42HDRgcZuNcWk", + "https://www.figma.com/board/Wr8iMlB9SHkerHSjv0Pe0M", + ], + "evidence_type": "figma_artifact", + "completion_state": "ready" if has_file("docs/figma_artifacts.md") else "blocked", + "evidence": "Editable design, FigJam diagrams, and stakeholder artifact records exist without Code Connect.", + "action": "Use Figma/FigJam artifacts for stakeholder review without generating Code Connect metadata.", + "exit_criteria": "Figma artifacts are recorded and Code Connect remains unused.", + }, + { + "item_name": "superpowers_plan_evidence", + "label": "Superpowers plan evidence", + "owner": "Implementation owner", + "sources": [ + "docs/superpowers/plans/2026-07-02-commercial-completion-scorecard-runtime.md", + "docs/superpowers/plans/2026-07-02-commercial-launch-readiness.md", + "tests/test_commercial_completion_scorecard.py", + ], + "evidence_type": "repository_artifact", + "completion_state": "ready" + if has_file("docs/superpowers/plans/2026-07-02-commercial-completion-scorecard-runtime.md") + and has_file("tests/test_commercial_completion_scorecard.py") + else "blocked", + "evidence": "Dated plans and focused tests define files, expected failures, implementation, and verification commands.", + "action": "Keep TDD plans and verification commands committed with the scorecard.", + "exit_criteria": "Plan and focused test exist for the runtime scorecard.", + }, + { + "item_name": "ponytail_packaging_decision", + "label": "Ponytail packaging decision", + "owner": "Procurement and security reviewer", + "sources": ["docs/library_research.md", "docs/commercial_plugin_operating_model.md"], + "evidence_type": "repository_artifact", + "completion_state": "ready" + if launch["library_split_decision"]["decision"] == "keep_single_product" + else "warning", + "evidence": launch["library_split_decision"]["reason"], + "action": "Keep one repository and one deployable product until extraction triggers are real.", + "exit_criteria": "No separate library, Git submodule, or extracted package is created for this increment.", + }, + { + "item_name": "data_analytics_truthfulness", + "label": "Data Analytics truthfulness", + "owner": "Analytics owner", + "sources": [ + "docs/analytics_spec.md", + "/api/v1/analytics_snapshots/latest", + "/api/v1/commercial_launch_readiness/latest", + ], + "evidence_type": "measured_local", + "completion_state": "ready" + if has_file("docs/analytics_spec.md") and analytics["measurement_status"] == "local_runtime_snapshot" + else "blocked", + "evidence": "Measured local evidence and proposed production or buyer-specific inputs are separated.", + "action": "Do not present proposed buyer or production inputs as measured product results.", + "exit_criteria": "Every commercial KPI has an evidence type and source expectation.", + }, + { + "item_name": "runtime_endpoint_chain", + "label": "Runtime endpoint chain", + "owner": "Platform operator", + "sources": [ + "/api/v1/commercial_readiness/latest", + "/api/v1/commercial_go_to_market_readiness/latest", + "/api/v1/commercial_launch_readiness/latest", + "/api/v1/commercial_completion_scorecards/latest", + ], + "evidence_type": "repository_and_runtime_artifact", + "completion_state": "ready" + if commercial["commercial_status"] != "not_commercial_ready" + and gtm["go_to_market_status"] != "commercial_go_to_market_blocked" + and launch["launch_status"] != "commercial_launch_blocked" + else "blocked", + "evidence": ( + f"commercial_status={commercial['commercial_status']}; " + f"go_to_market_status={gtm['go_to_market_status']}; " + f"launch_status={launch['launch_status']}" + ), + "action": "Expose completion status through the same admin-protected runtime API chain.", + "exit_criteria": "Runtime chain has no blocked local evidence gate.", + }, + { + "item_name": "verification_packet", + "label": "Verification packet", + "owner": "Technical reviewer", + "sources": [ + "tests/test_commercial_completion_scorecard.py", + "tests/test_commercial_launch_readiness.py", + "tests/test_plugin_driven_artifacts.py", + "tests/test_api_contract.py", + "pytest -q", + ], + "evidence_type": "measured_local", + "completion_state": "ready" + if all( + has_file(path) + for path in ( + "tests/test_commercial_completion_scorecard.py", + "tests/test_commercial_launch_readiness.py", + "tests/test_plugin_driven_artifacts.py", + "tests/test_api_contract.py", + ) + ) + else "blocked", + "evidence": "Focused completion, launch, artifact, and API contract tests are present.", + "action": "Run focused tests and full pytest before presenting completion status.", + "exit_criteria": "Focused tests, compileall, full pytest, and diff hygiene pass.", + }, + { + "item_name": "review_process_policy", + "label": "Review process policy", + "owner": "Deal owner", + "sources": ["docs/commercial_completion_scorecard.md", "docs/commercial_launch_readiness.md"], + "evidence_type": "repository_artifact", + "completion_state": "ready", + "evidence": "Review delay, model-review delay, and queued review automation are not product blockers.", + "action": "Block only on concrete security, API contract, document, or functional defects.", + "exit_criteria": "Review process delay remains non-blocking without concrete failure evidence.", + }, + { + "item_name": "production_buyer_followups", + "label": "Production and buyer follow-ups", + "owner": "Buyer sponsor, operations owner, and deal owner", + "sources": [ + "/api/v1/commercial_launch_readiness/latest", + "buyer environment", + "production telemetry", + "commercial signatures", + ], + "evidence_type": "external_input_required", + "completion_state": "warning", + "source_gap_status": "external_input_required", + "evidence": ( + f"external_input_group_count={launch['launch_summary']['external_input_group_count']}; " + f"buyer_signature_gap_count={gtm['go_to_market_summary']['buyer_signature_gap_count']}" + ), + "action": "Collect buyer environment, production telemetry, and signature inputs or explicit waivers.", + "exit_criteria": "Buyer supplies or waives remaining external inputs.", + }, + ] + state_counts = Counter(item["completion_state"] for item in scorecard_items) + blocked_count = state_counts.get("blocked", 0) + len(concrete_blockers) + warning_count = state_counts.get("warning", 0) + if blocked_count: + completion_status = "commercial_completion_blocked" + elif warning_count: + completion_status = "commercial_completion_ready_with_warnings" + else: # pragma: no cover - unreachable while this report carries literal buyer-specific warning sections + completion_status = "commercial_completion_ready" # pragma: no cover + + return { + "completion_status": completion_status, + "target_contract_value_krw": target_contract_value_krw, + "target_contract_value_display": f"KRW {target_contract_value_krw:,}", + "measurement_status": "local_commercial_completion_scorecard", + "source_note": ( + "Commercial completion scorecard aggregates repo-local product design, Figma, Superpowers, " + "Ponytail, Data Analytics, runtime, verification, review-process, and packaging evidence " + "separately from buyer and production follow-ups; it is not a valuation guarantee, purchase " + "commitment, signed order, legal opinion, production compliance certificate, or revenue proof." + ), + "completion_summary": { + "item_count": len(scorecard_items), + "ready_count": state_counts.get("ready", 0), + "warning_count": warning_count, + "blocked_count": blocked_count, + "external_input_group_count": launch["launch_summary"]["external_input_group_count"], + "review_process_is_blocker": launch["review_process_policy"]["is_blocker"], + "code_connect_used": False, + }, + "completion_items": scorecard_items, + "concrete_blockers": concrete_blockers, + "completion_status_rules": [ + { + "completion_status": "commercial_completion_ready", + "rule": "product design, Figma, Superpowers, Ponytail, Data Analytics, runtime, verification, review policy, packaging, and external inputs are ready", + }, + { + "completion_status": "commercial_completion_ready_with_warnings", + "rule": "repo-local program completion evidence is ready while buyer environment, production telemetry, commercial signatures, or other external inputs remain explicit warnings", + }, + { + "completion_status": "commercial_completion_blocked", + "rule": "security failure, API contract regression, document mismatch, reproducible product defect, missing local completion evidence, or Code Connect usage blocks completion", + }, + ], + "review_process_policy": launch["review_process_policy"], + "related_runtime_reports": { + "commercial_readiness_status": commercial["commercial_status"], + "commercial_go_to_market_status": gtm["go_to_market_status"], + "commercial_launch_status": launch["launch_status"], + "analytics_measurement_status": analytics["measurement_status"], + }, + "library_split_decision": launch["library_split_decision"], + "plugin_traceability": launch["plugin_traceability"], + "completion_links": { + "figma_design_file": "https://www.figma.com/design/vsZMd8WAv42HDRgcZuNcWk", + "figjam_board": "https://www.figma.com/board/Wr8iMlB9SHkerHSjv0Pe0M", + "runtime_endpoint": "/api/v1/commercial_completion_scorecards/latest", + "documentation": "docs/commercial_completion_scorecard.md", + }, + } + + def commercial_buyer_acceptance_workflow_report( + self, + target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, + locale_bundles: dict[str, dict[str, str]] | None = None, + security_profile: dict[str, Any] | None = None, + ) -> dict[str, Any]: + """Return owner-scoped buyer acceptance workflow evidence.""" + acceptance = self.commercial_acceptance_check_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + completion = self.commercial_completion_scorecard_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + handoff = self.commercial_handoff_bundle_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + analytics = self.analytics_snapshot(locale_bundles=locale_bundles) + root = Path(__file__).resolve().parents[1] + + def has_file(path: str) -> bool: + return (root / path).is_file() + + def all_files(*paths: str) -> bool: + return all(has_file(path) for path in paths) + + def step( + step_name: str, + label: str, + owner: str, + sources: list[str], + evidence_type: str, + completion_state: str, + evidence: str, + decision_rule: str, + next_action: str, + ) -> dict[str, Any]: + require_object_name(step_name, "buyer_acceptance_workflow.step_name") + if completion_state not in {"ready", "warning", "blocked"}: # pragma: no cover + raise ValueError("buyer acceptance workflow state must be ready, warning, or blocked") + return { + "step_name": step_name, + "label": label, + "owner": owner, + "sources": sources, + "evidence_type": evidence_type, + "completion_state": completion_state, + "evidence": evidence, + "decision_rule": decision_rule, + "next_action": next_action, + } + + concrete_blockers = list(dict.fromkeys(acceptance["concrete_blockers"] + completion["concrete_blockers"])) + acceptance_blocked = acceptance["acceptance_status"] == "commercial_acceptance_blocked" + completion_blocked = completion["completion_status"] == "commercial_completion_blocked" + local_runtime_state = "blocked" if acceptance_blocked or completion_blocked or concrete_blockers else "ready" + workflow_steps = [ + step( + "confirm_product_scope", + "Confirm product scope", + "Product owner", + ["README.md", "docs/product_planning.md", "docs/commercial_readiness.md"], + "repository_artifact", + "ready" if all_files("README.md", "docs/product_planning.md", "docs/commercial_readiness.md") else "blocked", + "Product remains one enterprise orchestration control plane.", + "Proceed when the buyer reviews one compatible API plus one admin evidence surface.", + "Restore product scope docs before buyer acceptance.", + ), + step( + "confirm_integration_surface", + "Confirm integration surface", + "Platform reviewer", + ["/v1/chat/completions", "docs/rest_api_design.md", "tests/test_api_contract.py"], + "repository_artifact", + "ready" if all_files("docs/rest_api_design.md", "tests/test_api_contract.py") else "blocked", + "OpenAI-compatible API and API contract tests are present.", + "Proceed when API compatibility evidence is present and tests pass.", + "Restore REST docs or API contract tests before buyer acceptance.", + ), + step( + "confirm_operator_evidence", + "Confirm operator evidence", + "Platform operator", + ["/admin", "/admin/state", "docs/screen_design.md", "contextual_orchestrator/admin.py"], + "repository_artifact", + "ready" if all_files("docs/screen_design.md", "contextual_orchestrator/admin.py") else "blocked", + "Admin console exposes operator evidence for pool, policy, trace, access, replay, analytics, and readiness.", + "Proceed when operator state and commercial readiness surfaces are visible.", + "Restore admin evidence docs or implementation before buyer acceptance.", + ), + step( + "confirm_readiness_endpoints", + "Confirm readiness endpoints", + "Product owner", + [ + "/api/v1/sales_readiness/latest", + "/api/v1/commercial_readiness/latest", + "/api/v1/commercial_acceptance_checks/latest", + "/api/v1/commercial_completion_scorecards/latest", + ], + "measured_local", + local_runtime_state, + ( + f"commercial_acceptance_status={acceptance['acceptance_status']}; " + f"commercial_completion_status={completion['completion_status']}" + ), + "Proceed when local runtime gates have no concrete blockers.", + "Resolve blocked readiness, acceptance, or completion gates before buyer acceptance.", + ), + step( + "confirm_security_posture", + "Confirm security posture", + "Security reviewer", + ["SECURITY.md", "tests/test_security_hardening.py", ".github/workflows/security.yml"], + "repository_artifact", + "ready" if all_files("SECURITY.md", "tests/test_security_hardening.py", ".github/workflows/security.yml") else "blocked", + "Security policy, hardening tests, and hosted security workflow metadata are present.", + "Proceed when concrete security failures are absent.", + "Fix concrete security failures; queued security checks alone are not blockers.", + ), + step( + "confirm_metric_honesty", + "Confirm metric honesty", + "Analytics reviewer", + ["/api/v1/analytics_snapshots/latest", "docs/analytics_spec.md"], + "measured_local", + "ready" if has_file("docs/analytics_spec.md") and analytics["measurement_status"] == "local_runtime_snapshot" else "blocked", + "Analytics spec and local snapshot separate measured local evidence from proposed production or buyer inputs.", + "Proceed when measured and proposed claims are not mixed.", + "Restore analytics source labels before buyer acceptance.", + ), + step( + "confirm_visual_review_path", + "Confirm visual review path", + "Stakeholder reviewer", + ["docs/figma_artifacts.md", "Figma design file", "FigJam board", "Figma Slides deck"], + "figma_artifact", + "ready" if has_file("docs/figma_artifacts.md") else "blocked", + "Editable design, FigJam, and stakeholder artifacts are recorded without Code Connect.", + "Proceed when visual artifacts are available for stakeholder review.", + "Record Figma artifacts before buyer acceptance.", + ), + step( + "confirm_packaging_decision", + "Confirm packaging decision", + "Procurement reviewer", + ["docs/library_research.md", "docs/commercial_plugin_operating_model.md"], + "repository_artifact", + "ready" if completion["library_split_decision"]["decision"] == "keep_single_product" else "warning", + completion["library_split_decision"]["reason"], + "Proceed with one repository and one deployable product.", + "Extract only after a second product, independent release cadence, or provenance trigger exists.", + ), + step( + "confirm_production_inputs", + "Confirm production inputs", + "Operations owner", + ["production telemetry", "support plan", "SLO evidence", "incident drill"], + "proposed_until_production", + "warning", + "Production telemetry, support, SLO, and incident evidence require a deployment or paid onboarding environment.", + "Proceed with warning when production inputs are explicitly caveated.", + "Collect production evidence during buyer onboarding or mark an explicit waiver.", + ), + step( + "confirm_buyer_specific_inputs", + "Confirm buyer-specific inputs", + "Buyer and account team", + ["ROI model", "security questionnaire", "legal review", "deployment target"], + "proposed_until_buyer_specific", + "warning", + "ROI, legal, procurement, and deployment inputs require a named buyer.", + "Proceed with warning when buyer-specific inputs are explicit follow-ups.", + "Collect buyer-specific inputs during account diligence.", + ), + ] + state_counts = Counter(item["completion_state"] for item in workflow_steps) + blocked_count = state_counts.get("blocked", 0) + len(concrete_blockers) + warning_count = state_counts.get("warning", 0) + if blocked_count: + workflow_status = "buyer_acceptance_workflow_blocked" + elif warning_count: + workflow_status = "buyer_acceptance_workflow_ready_with_warnings" + else: # pragma: no cover - unreachable while this report carries literal buyer-specific warning sections + workflow_status = "buyer_acceptance_workflow_ready" # pragma: no cover + + return { + "workflow_status": workflow_status, + "target_contract_value_krw": target_contract_value_krw, + "target_contract_value_display": f"KRW {target_contract_value_krw:,}", + "measurement_status": "local_buyer_acceptance_workflow", + "source_note": ( + "Commercial buyer acceptance workflow maps runbook owners, runtime evidence, " + "Figma artifacts, analytics truthfulness, review-process policy, and packaging " + "decision into Go, Warning, and No-Go steps; it is not a valuation guarantee, " + "purchase commitment, signed order, legal opinion, production compliance certificate, " + "or revenue proof." + ), + "workflow_summary": { + "step_count": len(workflow_steps), + "ready_count": state_counts.get("ready", 0), + "warning_count": warning_count, + "blocked_count": blocked_count, + "production_follow_up_count": sum( + 1 for item in workflow_steps if item["evidence_type"] == "proposed_until_production" + ), + "buyer_specific_follow_up_count": sum( + 1 for item in workflow_steps if item["evidence_type"] == "proposed_until_buyer_specific" + ), + "review_process_is_blocker": acceptance["review_process_policy"]["is_blocker"], + "code_connect_used": False, + }, + "acceptance_steps": workflow_steps, + "concrete_blockers": concrete_blockers, + "go_warning_no_go_rules": [ + { + "workflow_status": "buyer_acceptance_workflow_ready", + "rule": "all acceptance owners have ready evidence and no external production or buyer-specific inputs remain open", + }, + { + "workflow_status": "buyer_acceptance_workflow_ready_with_warnings", + "rule": "repo-local buyer acceptance evidence is ready while production or buyer-specific inputs remain explicit warnings", + }, + { + "workflow_status": "buyer_acceptance_workflow_blocked", + "rule": "security failure, API contract regression, document mismatch, reproducible product defect, missing acceptance path, or Code Connect usage blocks acceptance", + }, + ], + "review_process_policy": acceptance["review_process_policy"], + "related_runtime_reports": { + "commercial_acceptance_status": acceptance["acceptance_status"], + "commercial_completion_status": completion["completion_status"], + "buyer_handoff_status": handoff["bundle_status"], + "analytics_measurement_status": analytics["measurement_status"], + }, + "library_split_decision": completion["library_split_decision"], + "plugin_traceability": completion["plugin_traceability"], + "workflow_links": { + "figma_design_file": "https://www.figma.com/design/vsZMd8WAv42HDRgcZuNcWk", + "figjam_board": "https://www.figma.com/board/Wr8iMlB9SHkerHSjv0Pe0M", + "runtime_endpoint": "/api/v1/commercial_buyer_acceptance_workflows/latest", + "documentation": "docs/commercial_buyer_acceptance_runbook.md", + }, + } + + def commercial_demo_scenario_report( + self, + target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, + locale_bundles: dict[str, dict[str, str]] | None = None, + security_profile: dict[str, Any] | None = None, + ) -> dict[str, Any]: + """Return buyer-demo scenarios for the KRW 2B completion standard.""" + completion = self.commercial_completion_scorecard_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + buyer_workflow = self.commercial_buyer_acceptance_workflow_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + analytics = self.analytics_snapshot(locale_bundles=locale_bundles) + admin_state = self.admin_state() + root = Path(__file__).resolve().parents[1] + + def has_file(path: str) -> bool: + return (root / path).is_file() + + def all_files(*paths: str) -> bool: + return all(has_file(path) for path in paths) + + def step( + step_name: str, + label: str, + persona: str, + sources: list[str], + runtime_endpoints: list[str], + evidence_type: str, + completion_state: str, + evidence: str, + demo_action: str, + expected_evidence: str, + ) -> dict[str, Any]: + require_object_name(step_name, "commercial_demo.step_name") + if completion_state not in {"ready", "warning", "blocked"}: # pragma: no cover + raise ValueError("commercial demo step state must be ready, warning, or blocked") + return { + "step_name": step_name, + "label": label, + "persona": persona, + "sources": sources, + "runtime_endpoints": runtime_endpoints, + "evidence_type": evidence_type, + "completion_state": completion_state, + "evidence": evidence, + "demo_action": demo_action, + "expected_evidence": expected_evidence, + } + + concrete_blockers = list( + dict.fromkeys(completion["concrete_blockers"] + buyer_workflow["concrete_blockers"]) + ) + local_runtime_state = ( + "blocked" + if completion["completion_status"] == "commercial_completion_blocked" + or buyer_workflow["workflow_status"] == "buyer_acceptance_workflow_blocked" + or concrete_blockers + else "ready" + ) + event_counts = analytics.get("event_counts", {}) + recent_runs = admin_state.get("recent_workflow_runs", []) + demo_steps = [ + step( + "compatible_api_smoke", + "Compatible API smoke", + "Economic buyer", + ["README.md", "docs/rest_api_design.md", "/v1/chat/completions"], + ["/v1/chat/completions"], + "measured_local", + "ready" + if all_files("README.md", "docs/rest_api_design.md") + and event_counts.get("chat_completion_requested", 0) > 0 + else "blocked", + f"successful_chat_completion_events={event_counts.get('chat_completion_requested', 0)}", + "Run the OpenAI-compatible chat completion call used by the buyer application.", + "The buyer sees a compatible response and the runtime records a local analytics event.", + ), + step( + "conducted_workflow_trace", + "Conducted workflow trace", + "Platform operator", + ["/admin", "/api/v1/workflow_runs", "docs/screen_design.md"], + ["/admin", "/api/v1/workflow_runs"], + "measured_local", + "ready" if recent_runs and has_file("docs/screen_design.md") else "blocked", + f"recent_workflow_run_count={len(recent_runs)}", + "Open the admin trace view for a conducted workflow run.", + "The operator can inspect mode, policy mode, selected agents, and run trace evidence.", + ), + step( + "access_list_inspection", + "Access-list inspection", + "Compliance reviewer", + ["docs/product_planning.md", "/api/v1/access_reports/{workflow_run_id}", "/admin"], + ["/api/v1/access_reports/{workflow_run_id}", "/admin"], + "repository_and_runtime_artifact", + "ready" if has_file("docs/product_planning.md") else "blocked", + "access reports are scoped to workflow_run_id and exposed through the admin surface", + "Open the access report for the conducted workflow run.", + "The reviewer sees why each agent had access to context, tools, and trace evidence.", + ), + step( + "evaluation_replay", + "Evaluation replay", + "Quality reviewer", + ["docs/screen_design.md", "/api/v1/evaluation_runs", "/admin"], + ["/api/v1/evaluation_runs", "/admin"], + "measured_local", + "ready" if event_counts.get("evaluation_run_created", 0) > 0 else "blocked", + f"evaluation_run_created_events={event_counts.get('evaluation_run_created', 0)}", + "Replay the buyer prompt through the evaluation endpoint.", + "The reviewer sees replay status and trace-backed verification evidence.", + ), + step( + "admin_readiness_console", + "Admin readiness console", + "Economic buyer", + [ + "/admin", + "/api/v1/commercial_completion_scorecards/latest", + "/api/v1/commercial_buyer_acceptance_workflows/latest", + "/api/v1/commercial_demo_scenarios/latest", + ], + [ + "/admin", + "/api/v1/commercial_completion_scorecards/latest", + "/api/v1/commercial_buyer_acceptance_workflows/latest", + "/api/v1/commercial_demo_scenarios/latest", + ], + "repository_and_runtime_artifact", + local_runtime_state, + ( + f"commercial_completion_status={completion['completion_status']}; " + f"buyer_acceptance_workflow_status={buyer_workflow['workflow_status']}" + ), + "Show the readiness card chain in the admin console.", + "The buyer sees completion, buyer acceptance, and demo status without leaving one control plane.", + ), + step( + "metric_truthfulness", + "Metric truthfulness", + "Compliance reviewer", + ["docs/analytics_spec.md", "/api/v1/analytics_snapshots/latest"], + ["/api/v1/analytics_snapshots/latest"], + "measured_local", + "ready" + if has_file("docs/analytics_spec.md") and analytics["measurement_status"] == "local_runtime_snapshot" + else "blocked", + "measured local metrics remain separate from proposed production and buyer-specific metrics", + "Review the analytics spec and local analytics endpoint.", + "The reviewer can distinguish measured runtime data from proposed KPI definitions.", + ), + step( + "figma_stakeholder_review", + "Figma stakeholder review", + "Stakeholder reviewer", + [ + "docs/figma_artifacts.md", + "https://www.figma.com/design/vsZMd8WAv42HDRgcZuNcWk", + "https://www.figma.com/board/Wr8iMlB9SHkerHSjv0Pe0M", + ], + [], + "figma_artifact", + "ready" if has_file("docs/figma_artifacts.md") else "blocked", + "editable Figma and FigJam stakeholder artifacts are recorded without Code Connect", + "Walk through the design file and FigJam diagram packet.", + "Stakeholders review the product narrative, admin surface, and runtime flow as editable artifacts.", + ), + step( + "buyer_acceptance_decision", + "Buyer acceptance decision", + "Economic buyer", + [ + "docs/commercial_buyer_acceptance_runbook.md", + "/api/v1/commercial_buyer_acceptance_workflows/latest", + ], + ["/api/v1/commercial_buyer_acceptance_workflows/latest"], + "repository_and_runtime_artifact", + local_runtime_state, + f"buyer_acceptance_workflow_status={buyer_workflow['workflow_status']}", + "Use the buyer acceptance workflow as the Go/Warning/No-Go decision record.", + "The buyer can sign off on repo-local evidence while external follow-ups stay explicit.", + ), + step( + "production_buyer_followups", + "Production and buyer follow-ups", + "Economic buyer", + ["production telemetry", "ROI model", "security questionnaire", "support plan"], + [], + "proposed_until_buyer_specific", + "warning", + "Production telemetry, named-buyer ROI, security questionnaire, and support plan require buyer input.", + "Capture buyer-specific production, ROI, legal, and support inputs after the local demo.", + "External inputs are tracked as warnings, not hidden as measured product evidence.", + ), + ] + state_counts = Counter(item["completion_state"] for item in demo_steps) + blocked_count = state_counts.get("blocked", 0) + len(concrete_blockers) + warning_count = state_counts.get("warning", 0) + if blocked_count: + demo_status = "commercial_demo_blocked" + elif warning_count: + demo_status = "commercial_demo_ready_with_warnings" + else: # pragma: no cover - unreachable while this report carries literal buyer-specific warning sections + demo_status = "commercial_demo_ready" # pragma: no cover + required_runtime_endpoints = list( + dict.fromkeys( + endpoint + for item in demo_steps + for endpoint in item["runtime_endpoints"] + if endpoint.startswith("/") + ) + ) + + return { + "demo_status": demo_status, + "target_contract_value_krw": target_contract_value_krw, + "target_contract_value_display": f"KRW {target_contract_value_krw:,}", + "measurement_status": "local_commercial_demo_scenarios", + "source_note": ( + "Commercial demo scenarios package repo-local runtime, admin, analytics, Figma, " + "buyer acceptance, review-policy, and packaging evidence for KRW 2,000,000,000 " + "saleability review; it is not a valuation guarantee, purchase commitment, " + "signed order, legal opinion, production compliance certificate, or revenue proof." + ), + "demo_narrative": { + "title": "KRW 2B commercial control-plane buyer demo", + "promise": ( + "Show one enterprise orchestration control plane with a compatible inference API, " + "operator/admin evidence, trace and access visibility, evaluation replay, and truthful metrics." + ), + "audience": [ + "Economic buyer", + "Platform operator", + "Compliance reviewer", + "Quality reviewer", + "Stakeholder reviewer", + ], + }, + "demo_summary": { + "step_count": len(demo_steps), + "ready_count": state_counts.get("ready", 0), + "warning_count": warning_count, + "blocked_count": blocked_count, + "persona_count": len({item["persona"] for item in demo_steps}), + "endpoint_count": len(required_runtime_endpoints), + "review_process_is_blocker": completion["review_process_policy"]["is_blocker"], + "code_connect_used": False, + }, + "demo_steps": demo_steps, + "required_runtime_endpoints": required_runtime_endpoints, + "concrete_blockers": concrete_blockers, + "demo_status_rules": [ + { + "demo_status": "commercial_demo_ready", + "rule": "all demo steps are ready and no production or buyer-specific follow-ups remain open", + }, + { + "demo_status": "commercial_demo_ready_with_warnings", + "rule": "repo-local demo evidence is ready while production, ROI, legal, support, or buyer-specific inputs remain explicit warnings", + }, + { + "demo_status": "commercial_demo_blocked", + "rule": "security failure, API contract regression, document mismatch, runtime defect, missing local demo evidence, or Code Connect usage blocks the demo", + }, + ], + "review_process_policy": completion["review_process_policy"], + "related_runtime_reports": { + "commercial_completion_status": completion["completion_status"], + "buyer_acceptance_workflow_status": buyer_workflow["workflow_status"], + "analytics_measurement_status": analytics["measurement_status"], + }, + "library_split_decision": completion["library_split_decision"], + "plugin_traceability": completion["plugin_traceability"], + "demo_links": { + "figma_design_file": "https://www.figma.com/design/vsZMd8WAv42HDRgcZuNcWk", + "figjam_board": "https://www.figma.com/board/Wr8iMlB9SHkerHSjv0Pe0M", + "runtime_endpoint": "/api/v1/commercial_demo_scenarios/latest", + "documentation": "docs/commercial_demo_scenarios.md", + }, + } + + def commercial_proposal_packet_report( + self, + target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, + locale_bundles: dict[str, dict[str, str]] | None = None, + security_profile: dict[str, Any] | None = None, + ) -> dict[str, Any]: + """Return buyer proposal sections for the KRW 2B saleability standard.""" + completion = self.commercial_completion_scorecard_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + demo = self.commercial_demo_scenario_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + buyer_workflow = self.commercial_buyer_acceptance_workflow_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + value = self.commercial_value_readiness_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + security = self.commercial_security_attestation_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + contract = self.commercial_contract_readiness_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + onboarding = self.commercial_onboarding_readiness_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + operations = self.commercial_operations_readiness_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + analytics = self.analytics_snapshot(locale_bundles=locale_bundles) + admin_state = self.admin_state() + root = Path(__file__).resolve().parents[1] + + def has_file(path: str) -> bool: + return (root / path).is_file() + + def all_files(*paths: str) -> bool: + return all(has_file(path) for path in paths) + + def section( + section_name: str, + label: str, + owner: str, + sources: list[str], + runtime_endpoints: list[str], + evidence_type: str, + completion_state: str, + evidence: str, + buyer_message: str, + next_action: str, + ) -> dict[str, Any]: + require_object_name(section_name, "commercial_proposal.section_name") + if completion_state not in {"ready", "warning", "blocked"}: # pragma: no cover + raise ValueError("commercial proposal section state must be ready, warning, or blocked") + return { + "section_name": section_name, + "label": label, + "owner": owner, + "sources": sources, + "runtime_endpoints": runtime_endpoints, + "evidence_type": evidence_type, + "completion_state": completion_state, + "evidence": evidence, + "buyer_message": buyer_message, + "next_action": next_action, + } + + concrete_blockers = list( + dict.fromkeys( + completion["concrete_blockers"] + + demo["concrete_blockers"] + + buyer_workflow["concrete_blockers"] + ) + ) + local_runtime_state = ( + "blocked" + if completion["completion_status"] == "commercial_completion_blocked" + or demo["demo_status"] == "commercial_demo_blocked" + or buyer_workflow["workflow_status"] == "buyer_acceptance_workflow_blocked" + or concrete_blockers + else "ready" + ) + proposal_sections = [ + section( + "executive_summary", + "Executive summary", + "Deal owner", + ["README.md", "docs/commercial_completion_scorecard.md", "/api/v1/commercial_completion_scorecards/latest"], + ["/api/v1/commercial_completion_scorecards/latest"], + "repository_and_runtime_artifact", + local_runtime_state if all_files("README.md", "docs/commercial_completion_scorecard.md") else "blocked", + f"commercial_completion_status={completion['completion_status']}", + "One enterprise orchestration control plane is ready for a KRW 2B buyer review with explicit caveats.", + "Use the completion scorecard as the proposal cover evidence.", + ), + section( + "product_scope", + "Product scope", + "Product owner", + ["docs/product_planning.md", "docs/commercial_plugin_operating_model.md", "docs/library_research.md"], + [], + "repository_artifact", + "ready" + if all_files("docs/product_planning.md", "docs/commercial_plugin_operating_model.md", "docs/library_research.md") + and completion["library_split_decision"]["decision"] == "keep_single_product" + else "blocked", + completion["library_split_decision"]["reason"], + "The offer is one compatible API plus one admin evidence surface, not a split product suite.", + "Keep proposal language centered on a single deployable control plane.", + ), + section( + "buyer_value_case", + "Buyer value case", + "Economic buyer", + ["docs/commercial_value_readiness.md", "docs/analytics_spec.md", "/api/v1/commercial_value_readiness/latest"], + ["/api/v1/commercial_value_readiness/latest", "/api/v1/analytics_snapshots/latest"], + "repository_and_runtime_artifact", + "ready" + if value["value_status"] != "commercial_value_blocked" + and has_file("docs/commercial_value_readiness.md") + and analytics["measurement_status"] == "local_runtime_snapshot" + else "blocked", + f"value_status={value['value_status']}; analytics_measurement_status={analytics['measurement_status']}", + "Measured local value evidence is separated from buyer-specific ROI inputs.", + "Attach buyer ROI assumptions only after buyer discovery validates them.", + ), + section( + "demo_and_acceptance_path", + "Demo and acceptance path", + "Product design owner", + [ + "docs/commercial_demo_scenarios.md", + "docs/commercial_buyer_acceptance_runbook.md", + "/api/v1/commercial_demo_scenarios/latest", + "/api/v1/commercial_buyer_acceptance_workflows/latest", + ], + ["/api/v1/commercial_demo_scenarios/latest", "/api/v1/commercial_buyer_acceptance_workflows/latest"], + "repository_and_runtime_artifact", + local_runtime_state + if all_files("docs/commercial_demo_scenarios.md", "docs/commercial_buyer_acceptance_runbook.md") + else "blocked", + f"commercial_demo_status={demo['demo_status']}; buyer_acceptance_workflow_status={buyer_workflow['workflow_status']}", + "Buyer review can move from demo script to Go/Warning/No-Go acceptance without leaving the control plane.", + "Run the demo packet and record the acceptance decision.", + ), + section( + "technical_evidence", + "Technical evidence", + "Platform reviewer", + ["docs/rest_api_design.md", "docs/screen_design.md", "contextual_orchestrator/api_contract.py", "/admin"], + ["/v1/chat/completions", "/admin", "/api/v1/workflow_runs", "/api/v1/access_reports/{workflow_run_id}"], + "repository_and_runtime_artifact", + "ready" + if all_files("docs/rest_api_design.md", "docs/screen_design.md", "contextual_orchestrator/api_contract.py") + and admin_state["agents"] + else "blocked", + f"agent_count={len(admin_state['agents'])}; recent_workflow_run_count={len(admin_state['recent_workflow_runs'])}", + "The buyer can verify API compatibility, trace evidence, and access-list evidence.", + "Include endpoint list and admin review screenshots or live walkthrough in the proposal.", + ), + section( + "security_and_compliance", + "Security and compliance", + "Security reviewer", + ["SECURITY.md", "docs/commercial_security_attestation.md", "/api/v1/commercial_security_attestations/latest"], + ["/api/v1/commercial_security_attestations/latest"], + "repository_and_runtime_artifact", + "ready" + if security["security_attestation_status"] != "commercial_security_attestation_blocked" + and all_files("SECURITY.md", "docs/commercial_security_attestation.md") + else "blocked", + f"security_attestation_status={security['security_attestation_status']}", + "Repo-local security evidence is present while external attestation and buyer DPA inputs stay explicit.", + "Do not claim third-party attestation until supplied.", + ), + section( + "implementation_and_operations", + "Implementation and operations", + "Operations owner", + [ + "docs/commercial_onboarding_readiness.md", + "docs/commercial_operations_readiness.md", + "/api/v1/commercial_onboarding_readiness/latest", + "/api/v1/commercial_operations_readiness/latest", + ], + ["/api/v1/commercial_onboarding_readiness/latest", "/api/v1/commercial_operations_readiness/latest"], + "repository_and_runtime_artifact", + "ready" + if onboarding["onboarding_status"] != "commercial_onboarding_blocked" + and operations["operations_status"] != "commercial_operations_blocked" + and all_files("docs/commercial_onboarding_readiness.md", "docs/commercial_operations_readiness.md") + else "blocked", + f"onboarding_status={onboarding['onboarding_status']}; operations_status={operations['operations_status']}", + "Implementation and operations evidence is proposal-ready with production environment follow-ups separated.", + "Convert buyer environment details into an onboarding checklist after selection.", + ), + section( + "proposal_review_packet", + "Proposal review packet", + "Stakeholder reviewer", + [ + "docs/commercial_proposal_packet.md", + "docs/figma_artifacts.md", + "docs/superpowers/plans/2026-07-02-commercial-proposal-packet-runtime.md", + ], + ["/api/v1/commercial_proposal_packets/latest"], + "repository_and_runtime_artifact", + "ready" + if all_files( + "docs/commercial_proposal_packet.md", + "docs/figma_artifacts.md", + "docs/superpowers/plans/2026-07-02-commercial-proposal-packet-runtime.md", + ) + else "blocked", + "Proposal docs, FigJam artifact record, and implementation plan are committed as repo artifacts.", + "Stakeholders can review the proposal packet as docs, runtime JSON, and FigJam flow.", + "Keep Figma Code Connect out of the proposal workflow.", + ), + section( + "commercial_terms_followups", + "Commercial terms follow-ups", + "Deal owner", + ["docs/commercial_contract_readiness.md", "buyer order form", "legal review", "pricing approval"], + ["/api/v1/commercial_contract_readiness/latest"], + "proposed_until_buyer_specific", + "warning", + f"contract_status={contract['contract_status']}", + "Order-form, legal, pricing approval, and signature inputs need named-buyer review.", + "Collect buyer-specific legal and commercial terms or record explicit waiver.", + ), + section( + "production_buyer_inputs", + "Production and buyer inputs", + "Buyer sponsor", + ["production telemetry", "buyer ROI model", "support plan", "security questionnaire"], + [], + "proposed_until_buyer_specific", + "warning", + "Production telemetry, buyer ROI model, support plan, and security questionnaire are external inputs.", + "The proposal is locally ready while buyer-specific inputs remain caveated.", + "Collect external evidence during proposal negotiation or paid onboarding.", + ), + ] + state_counts = Counter(item["completion_state"] for item in proposal_sections) + blocked_count = state_counts.get("blocked", 0) + len(concrete_blockers) + warning_count = state_counts.get("warning", 0) + if blocked_count: + proposal_status = "commercial_proposal_blocked" + elif warning_count: + proposal_status = "commercial_proposal_ready_with_warnings" + else: # pragma: no cover - unreachable while this report carries literal buyer-specific warning sections + proposal_status = "commercial_proposal_ready" # pragma: no cover + required_runtime_endpoints = list( + dict.fromkeys( + endpoint + for item in proposal_sections + for endpoint in item["runtime_endpoints"] + if endpoint.startswith("/") + ) + ) + + return { + "proposal_status": proposal_status, + "target_contract_value_krw": target_contract_value_krw, + "target_contract_value_display": f"KRW {target_contract_value_krw:,}", + "measurement_status": "local_commercial_proposal_packet", + "source_note": ( + "Commercial proposal packet packages repo-local completion, demo, acceptance, value, " + "security, contract, onboarding, operations, analytics, Figma, review-policy, and packaging " + "evidence for KRW 2,000,000,000 buyer proposal review; it is not a valuation guarantee, " + "purchase commitment, signed order, legal opinion, production compliance certificate, or revenue proof." + ), + "proposal_narrative": { + "title": "KRW 2B commercial buyer proposal packet", + "promise": ( + "Present one enterprise orchestration control plane with compatible API integration, " + "operator evidence, buyer demo path, acceptance workflow, and truthful commercial caveats." + ), + "audience": [ + "Economic buyer", + "Platform reviewer", + "Security reviewer", + "Operations owner", + "Stakeholder reviewer", + "Deal owner", + ], + }, + "proposal_summary": { + "section_count": len(proposal_sections), + "ready_count": state_counts.get("ready", 0), + "warning_count": warning_count, + "blocked_count": blocked_count, + "endpoint_count": len(required_runtime_endpoints), + "review_process_is_blocker": completion["review_process_policy"]["is_blocker"], + "code_connect_used": False, + }, + "proposal_sections": proposal_sections, + "required_runtime_endpoints": required_runtime_endpoints, + "concrete_blockers": concrete_blockers, + "proposal_status_rules": [ + { + "proposal_status": "commercial_proposal_ready", + "rule": "all proposal sections are ready and no buyer-specific commercial or production inputs remain open", + }, + { + "proposal_status": "commercial_proposal_ready_with_warnings", + "rule": "repo-local proposal evidence is ready while pricing, legal, ROI, production, support, or signature inputs remain explicit warnings", + }, + { + "proposal_status": "commercial_proposal_blocked", + "rule": "security failure, API contract regression, document mismatch, runtime defect, missing local proposal evidence, or Code Connect usage blocks the proposal", + }, + ], + "review_process_policy": completion["review_process_policy"], + "related_runtime_reports": { + "commercial_completion_status": completion["completion_status"], + "commercial_demo_status": demo["demo_status"], + "buyer_acceptance_workflow_status": buyer_workflow["workflow_status"], + "commercial_value_status": value["value_status"], + "commercial_security_attestation_status": security["security_attestation_status"], + "commercial_contract_status": contract["contract_status"], + "commercial_onboarding_status": onboarding["onboarding_status"], + "commercial_operations_status": operations["operations_status"], + "analytics_measurement_status": analytics["measurement_status"], + }, + "library_split_decision": completion["library_split_decision"], + "plugin_traceability": completion["plugin_traceability"], + "proposal_links": { + "figma_design_file": "https://www.figma.com/design/vsZMd8WAv42HDRgcZuNcWk", + "figjam_board": "https://www.figma.com/board/Wr8iMlB9SHkerHSjv0Pe0M", + "runtime_endpoint": "/api/v1/commercial_proposal_packets/latest", + "documentation": "docs/commercial_proposal_packet.md", + }, + } + + def commercial_purchase_approval_packet_report( + self, + target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, + locale_bundles: dict[str, dict[str, str]] | None = None, + security_profile: dict[str, Any] | None = None, + ) -> dict[str, Any]: + """Return buyer-side purchase approval gates for the KRW 2B standard.""" + proposal = self.commercial_proposal_packet_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + close = self.commercial_close_readiness_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + procurement = self.commercial_procurement_readiness_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + contract = self.commercial_contract_readiness_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + value = self.commercial_value_readiness_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + security = self.commercial_security_attestation_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + onboarding = self.commercial_onboarding_readiness_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + operations = self.commercial_operations_readiness_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + analytics = self.analytics_snapshot(locale_bundles=locale_bundles) + admin_state = self.admin_state() + root = Path(__file__).resolve().parents[1] + + def has_file(path: str) -> bool: + return (root / path).is_file() + + def all_files(*paths: str) -> bool: + return all(has_file(path) for path in paths) + + def gate( + gate_name: str, + label: str, + owner: str, + sources: list[str], + runtime_endpoints: list[str], + evidence_type: str, + completion_state: str, + evidence: str, + approval_question: str, + next_action: str, + ) -> dict[str, Any]: + require_object_name(gate_name, "commercial_purchase_approval.gate_name") + if completion_state not in {"ready", "warning", "blocked"}: # pragma: no cover + raise ValueError("commercial purchase approval gate state must be ready, warning, or blocked") + return { + "gate_name": gate_name, + "label": label, + "owner": owner, + "sources": sources, + "runtime_endpoints": runtime_endpoints, + "evidence_type": evidence_type, + "completion_state": completion_state, + "evidence": evidence, + "approval_question": approval_question, + "next_action": next_action, + } + + concrete_blockers = list(dict.fromkeys(proposal["concrete_blockers"] + close["concrete_blockers"])) + local_runtime_state = ( + "blocked" + if proposal["proposal_status"] == "commercial_proposal_blocked" + or close["close_status"] == "commercial_close_blocked" + or concrete_blockers + else "ready" + ) + approval_gates = [ + gate( + "proposal_packet_ready", + "Proposal packet ready", + "Deal owner", + ["docs/commercial_proposal_packet.md", "/api/v1/commercial_proposal_packets/latest"], + ["/api/v1/commercial_proposal_packets/latest"], + "repository_and_runtime_artifact", + local_runtime_state if has_file("docs/commercial_proposal_packet.md") else "blocked", + f"commercial_proposal_status={proposal['proposal_status']}", + "Can the buyer review one coherent proposal packet?", + "Use the proposal packet as the approval cover artifact.", + ), + gate( + "procurement_path_ready", + "Procurement path ready", + "Procurement owner", + ["docs/commercial_procurement_readiness.md", "/api/v1/commercial_procurement_readiness/latest"], + ["/api/v1/commercial_procurement_readiness/latest"], + "repository_and_runtime_artifact", + "ready" + if procurement["procurement_status"] != "commercial_procurement_blocked" + and has_file("docs/commercial_procurement_readiness.md") + else "blocked", + f"commercial_procurement_status={procurement['procurement_status']}", + "Can procurement validate license, rights, distribution, admin, and caveat evidence?", + "Route the packet to procurement with buyer-specific inputs still marked as warnings.", + ), + gate( + "contract_legal_packet_ready", + "Contract and legal packet ready", + "Legal owner", + ["docs/commercial_contract_readiness.md", "/api/v1/commercial_contract_readiness/latest"], + ["/api/v1/commercial_contract_readiness/latest"], + "repository_and_runtime_artifact", + "ready" + if contract["contract_status"] != "commercial_contract_blocked" + and has_file("docs/commercial_contract_readiness.md") + else "blocked", + f"commercial_contract_status={contract['contract_status']}", + "Can legal review support, privacy, audit, license, and order-form obligations?", + "Collect final legal edits and buyer order-form fields outside the local runtime claim.", + ), + gate( + "financial_value_case_ready", + "Financial value case ready", + "Economic buyer", + ["docs/commercial_value_readiness.md", "docs/analytics_spec.md", "/api/v1/commercial_value_readiness/latest"], + ["/api/v1/commercial_value_readiness/latest", "/api/v1/analytics_snapshots/latest"], + "repository_and_runtime_artifact", + "ready" + if value["value_status"] != "commercial_value_blocked" + and all_files("docs/commercial_value_readiness.md", "docs/analytics_spec.md") + and analytics["measurement_status"] == "local_runtime_snapshot" + else "blocked", + f"commercial_value_status={value['value_status']}; analytics_measurement_status={analytics['measurement_status']}", + "Can finance separate measured local evidence from buyer ROI assumptions?", + "Attach buyer ROI and payback assumptions only after buyer discovery.", + ), + gate( + "security_acceptance_ready", + "Security acceptance ready", + "Security owner", + ["SECURITY.md", "docs/commercial_security_attestation.md", "/api/v1/commercial_security_attestations/latest"], + ["/api/v1/commercial_security_attestations/latest"], + "repository_and_runtime_artifact", + "ready" + if security["security_attestation_status"] != "commercial_security_attestation_blocked" + and all_files("SECURITY.md", "docs/commercial_security_attestation.md") + else "blocked", + f"commercial_security_attestation_status={security['security_attestation_status']}", + "Can security approve repo-local controls while external attestations remain caveated?", + "Collect buyer DPA, privacy, and third-party attestation evidence separately.", + ), + gate( + "implementation_readiness_ready", + "Implementation readiness ready", + "Implementation owner", + [ + "docs/commercial_onboarding_readiness.md", + "docs/commercial_operations_readiness.md", + "/api/v1/commercial_onboarding_readiness/latest", + "/api/v1/commercial_operations_readiness/latest", + ], + ["/api/v1/commercial_onboarding_readiness/latest", "/api/v1/commercial_operations_readiness/latest"], + "repository_and_runtime_artifact", + "ready" + if onboarding["onboarding_status"] != "commercial_onboarding_blocked" + and operations["operations_status"] != "commercial_operations_blocked" + and all_files("docs/commercial_onboarding_readiness.md", "docs/commercial_operations_readiness.md") + else "blocked", + f"commercial_onboarding_status={onboarding['onboarding_status']}; commercial_operations_status={operations['operations_status']}", + "Can implementation owners see onboarding and operations evidence before purchase approval?", + "Turn buyer environment details into the paid onboarding plan.", + ), + gate( + "close_readiness_ready", + "Close readiness ready", + "Deal owner", + ["docs/commercial_close_readiness.md", "/api/v1/commercial_close_readiness/latest"], + ["/api/v1/commercial_close_readiness/latest"], + "repository_and_runtime_artifact", + "ready" + if close["close_status"] != "commercial_close_blocked" + and has_file("docs/commercial_close_readiness.md") + else "blocked", + f"commercial_close_status={close['close_status']}", + "Can the buyer see final signature, budget, security, and go-live caveats before approval?", + "Use close readiness as the bridge between local product evidence and buyer approvals.", + ), + gate( + "approval_runtime_packet_ready", + "Approval runtime packet ready", + "Stakeholder reviewer", + [ + "docs/commercial_purchase_approval_packet.md", + "docs/figma_artifacts.md", + "docs/superpowers/plans/2026-07-02-commercial-purchase-approval-packet-runtime.md", + ], + ["/api/v1/commercial_purchase_approval_packets/latest"], + "repository_and_runtime_artifact", + "ready" + if all_files( + "docs/commercial_purchase_approval_packet.md", + "docs/figma_artifacts.md", + "docs/superpowers/plans/2026-07-02-commercial-purchase-approval-packet-runtime.md", + ) + and admin_state["agents"] + else "blocked", + "Purchase approval docs, FigJam artifact record, plan, and admin runtime are present.", + "Can stakeholders review the approval packet as docs, runtime JSON, and FigJam flow?", + "Keep Figma Code Connect out of the approval workflow.", + ), + gate( + "buyer_signature_authority", + "Buyer signature authority", + "Buyer sponsor and legal owner", + ["signed order form", "MSA", "DPA", "security acceptance"], + [], + "proposed_until_buyer_specific", + "warning", + "Signed order form, MSA, DPA, and final security acceptance require buyer authority.", + "Does the buyer have an identified signer and legal approval path?", + "Collect named signer and final legal/security approvals.", + ), + gate( + "buyer_budget_po_authority", + "Buyer budget and PO authority", + "Finance and procurement owner", + ["budget approval", "purchase order", "finance authority", "go-live authorization"], + [], + "proposed_until_buyer_specific", + "warning", + "Budget approval, purchase order, finance authority, and go-live authorization require buyer input.", + "Can finance issue the KRW 2B purchase order and approve go-live?", + "Collect budget owner, PO path, and go-live authorization or explicit waiver.", + ), + ] + state_counts = Counter(item["completion_state"] for item in approval_gates) + blocked_count = state_counts.get("blocked", 0) + len(concrete_blockers) + warning_count = state_counts.get("warning", 0) + if blocked_count: + purchase_approval_status = "commercial_purchase_approval_blocked" + elif warning_count: + purchase_approval_status = "commercial_purchase_approval_ready_with_warnings" + else: # pragma: no cover - unreachable while this report carries literal buyer-specific warning sections + purchase_approval_status = "commercial_purchase_approval_ready" # pragma: no cover + required_runtime_endpoints = list( + dict.fromkeys( + endpoint + for item in approval_gates + for endpoint in item["runtime_endpoints"] + if endpoint.startswith("/") + ) + ) + + return { + "purchase_approval_status": purchase_approval_status, + "target_contract_value_krw": target_contract_value_krw, + "target_contract_value_display": f"KRW {target_contract_value_krw:,}", + "measurement_status": "local_commercial_purchase_approval_packet", + "source_note": ( + "Commercial purchase approval packet packages repo-local proposal, close, procurement, " + "contract, value, security, onboarding, operations, analytics, Figma, review-policy, and " + "packaging evidence for KRW 2,000,000,000 buyer purchase approval; it is not a valuation " + "guarantee, purchase commitment, signed order, legal opinion, production compliance " + "certificate, or revenue proof." + ), + "approval_narrative": { + "title": "KRW 2B buyer purchase approval packet", + "promise": ( + "Give finance, procurement, legal, security, and implementation owners one runtime " + "approval packet that separates local product evidence from buyer-specific authority inputs." + ), + "audience": [ + "Economic buyer", + "Finance owner", + "Procurement owner", + "Legal owner", + "Security owner", + "Implementation owner", + ], + }, + "approval_summary": { + "gate_count": len(approval_gates), + "ready_count": state_counts.get("ready", 0), + "warning_count": warning_count, + "blocked_count": blocked_count, + "endpoint_count": len(required_runtime_endpoints), + "review_process_is_blocker": proposal["review_process_policy"]["is_blocker"], + "code_connect_used": False, + }, + "approval_gates": approval_gates, + "required_runtime_endpoints": required_runtime_endpoints, + "concrete_blockers": concrete_blockers, + "purchase_approval_status_rules": [ + { + "purchase_approval_status": "commercial_purchase_approval_ready", + "rule": "all approval gates are ready and no buyer signature, budget, PO, or go-live inputs remain open", + }, + { + "purchase_approval_status": "commercial_purchase_approval_ready_with_warnings", + "rule": "repo-local purchase approval evidence is ready while buyer signature authority, budget, PO, or go-live authorization remain explicit warnings", + }, + { + "purchase_approval_status": "commercial_purchase_approval_blocked", + "rule": "security failure, API contract regression, document mismatch, runtime defect, missing local approval evidence, or Code Connect usage blocks purchase approval", + }, + ], + "review_process_policy": proposal["review_process_policy"], + "related_runtime_reports": { + "commercial_proposal_status": proposal["proposal_status"], + "commercial_close_status": close["close_status"], + "commercial_procurement_status": procurement["procurement_status"], + "commercial_contract_status": contract["contract_status"], + "commercial_value_status": value["value_status"], + "commercial_security_attestation_status": security["security_attestation_status"], + "commercial_onboarding_status": onboarding["onboarding_status"], + "commercial_operations_status": operations["operations_status"], + "analytics_measurement_status": analytics["measurement_status"], + }, + "library_split_decision": proposal["library_split_decision"], + "plugin_traceability": proposal["plugin_traceability"], + "approval_links": { + "figma_design_file": "https://www.figma.com/design/vsZMd8WAv42HDRgcZuNcWk", + "figjam_board": "https://www.figma.com/board/Wr8iMlB9SHkerHSjv0Pe0M", + "runtime_endpoint": "/api/v1/commercial_purchase_approval_packets/latest", + "documentation": "docs/commercial_purchase_approval_packet.md", + }, + } + + def commercial_due_diligence_room_report( + self, + target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, + locale_bundles: dict[str, dict[str, str]] | None = None, + security_profile: dict[str, Any] | None = None, + ) -> dict[str, Any]: + """Return buyer due diligence room sections for the KRW 2B standard.""" + purchase = self.commercial_purchase_approval_packet_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + proposal = self.commercial_proposal_packet_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + completion = self.commercial_completion_scorecard_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + demo = self.commercial_demo_scenario_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + buyer_workflow = self.commercial_buyer_acceptance_workflow_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + close = self.commercial_close_readiness_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + procurement = self.commercial_procurement_readiness_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + contract = self.commercial_contract_readiness_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + value = self.commercial_value_readiness_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + security = self.commercial_security_attestation_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + onboarding = self.commercial_onboarding_readiness_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + operations = self.commercial_operations_readiness_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + analytics = self.analytics_snapshot(locale_bundles=locale_bundles) + admin_state = self.admin_state() + root = Path(__file__).resolve().parents[1] + + def has_file(path: str) -> bool: + return (root / path).is_file() + + def all_files(*paths: str) -> bool: + return all(has_file(path) for path in paths) + + def section( + section_name: str, + label: str, + reviewer: str, + sources: list[str], + runtime_endpoints: list[str], + evidence_type: str, + completion_state: str, + evidence: str, + diligence_question: str, + next_action: str, + ) -> dict[str, Any]: + require_object_name(section_name, "commercial_due_diligence.section_name") + if completion_state not in {"ready", "warning", "blocked"}: # pragma: no cover + raise ValueError("commercial due diligence section state must be ready, warning, or blocked") + return { + "section_name": section_name, + "label": label, + "reviewer": reviewer, + "sources": sources, + "runtime_endpoints": runtime_endpoints, + "evidence_type": evidence_type, + "completion_state": completion_state, + "evidence": evidence, + "diligence_question": diligence_question, + "next_action": next_action, + } + + concrete_blockers = list( + dict.fromkeys( + purchase["concrete_blockers"] + + proposal["concrete_blockers"] + + completion["concrete_blockers"] + + demo["concrete_blockers"] + + buyer_workflow["concrete_blockers"] + ) + ) + local_runtime_state = ( + "blocked" + if purchase["purchase_approval_status"] == "commercial_purchase_approval_blocked" + or proposal["proposal_status"] == "commercial_proposal_blocked" + or completion["completion_status"] == "commercial_completion_blocked" + or demo["demo_status"] == "commercial_demo_blocked" + or buyer_workflow["workflow_status"] == "buyer_acceptance_workflow_blocked" + or concrete_blockers + else "ready" + ) + diligence_sections = [ + section( + "purchase_approval_packet", + "Purchase approval packet", + "Purchase committee", + ["docs/commercial_purchase_approval_packet.md", "/api/v1/commercial_purchase_approval_packets/latest"], + ["/api/v1/commercial_purchase_approval_packets/latest", "/api/v1/commercial_proposal_packets/latest"], + "repository_and_runtime_artifact", + local_runtime_state if has_file("docs/commercial_purchase_approval_packet.md") else "blocked", + f"commercial_purchase_approval_status={purchase['purchase_approval_status']}", + "Can the buyer review one approval packet before diligence sign-off?", + "Use the approval packet as the diligence room cover index.", + ), + section( + "runtime_api_evidence", + "Runtime API evidence", + "Platform reviewer", + [ + "docs/rest_api_design.md", + "contextual_orchestrator/api_contract.py", + "README.md", + "/v1/chat/completions", + ], + [ + "/v1/chat/completions", + "/api/v1/workflow_runs", + "/api/v1/access_reports/{workflow_run_id}", + "/api/v1/commercial_due_diligence_rooms/latest", + ], + "repository_and_runtime_artifact", + "ready" + if local_runtime_state == "ready" + and all_files("docs/rest_api_design.md", "contextual_orchestrator/api_contract.py", "README.md") + and admin_state["agents"] + else "blocked", + f"agent_count={len(admin_state['agents'])}; api_contract_present={has_file('contextual_orchestrator/api_contract.py')}", + "Can platform reviewers verify compatible API and evidence endpoints?", + "Keep API compatibility and evidence endpoints in the diligence index.", + ), + section( + "admin_trace_evidence", + "Admin trace evidence", + "Operator reviewer", + ["docs/screen_design.md", "/admin", "/admin/state", "workflow trace", "access report"], + ["/admin", "/admin/state", "/api/v1/workflow_runs", "/api/v1/access_reports/{workflow_run_id}"], + "repository_and_runtime_artifact", + "ready" + if all_files("docs/screen_design.md", "contextual_orchestrator/admin.py") + and admin_state["agents"] + and admin_state["recent_workflow_runs"] + else "blocked", + f"recent_workflow_run_count={len(admin_state['recent_workflow_runs'])}", + "Can the operator show trace and access-list evidence in the admin console?", + "Run one conduct workflow before a live diligence walkthrough.", + ), + section( + "security_and_compliance", + "Security and compliance", + "Security reviewer", + ["SECURITY.md", "docs/commercial_security_attestation.md", "/api/v1/commercial_security_attestations/latest"], + ["/api/v1/commercial_security_attestations/latest"], + "repository_and_runtime_artifact", + "ready" + if security["security_attestation_status"] != "commercial_security_attestation_blocked" + and all_files("SECURITY.md", "docs/commercial_security_attestation.md") + else "blocked", + f"commercial_security_attestation_status={security['security_attestation_status']}", + "Can security separate repo-local controls from external attestation gaps?", + "Do not claim third-party certification until supplied.", + ), + section( + "commercial_terms", + "Commercial terms", + "Legal and procurement reviewers", + [ + "docs/commercial_contract_readiness.md", + "docs/commercial_procurement_readiness.md", + "docs/commercial_close_readiness.md", + ], + [ + "/api/v1/commercial_contract_readiness/latest", + "/api/v1/commercial_procurement_readiness/latest", + "/api/v1/commercial_close_readiness/latest", + ], + "repository_and_runtime_artifact", + "ready" + if contract["contract_status"] != "commercial_contract_blocked" + and procurement["procurement_status"] != "commercial_procurement_blocked" + and close["close_status"] != "commercial_close_blocked" + and all_files( + "docs/commercial_contract_readiness.md", + "docs/commercial_procurement_readiness.md", + "docs/commercial_close_readiness.md", + ) + else "blocked", + ( + f"commercial_contract_status={contract['contract_status']}; " + f"commercial_procurement_status={procurement['procurement_status']}; " + f"commercial_close_status={close['close_status']}" + ), + "Can legal and procurement review terms, rights, and close caveats together?", + "Attach buyer-specific order-form language outside the local runtime claim.", + ), + section( + "value_and_analytics", + "Value and analytics", + "Economic reviewer", + ["docs/commercial_value_readiness.md", "docs/analytics_spec.md", "/api/v1/analytics_snapshots/latest"], + ["/api/v1/commercial_value_readiness/latest", "/api/v1/analytics_snapshots/latest"], + "repository_and_runtime_artifact", + "ready" + if value["value_status"] != "commercial_value_blocked" + and analytics["measurement_status"] == "local_runtime_snapshot" + and all_files("docs/commercial_value_readiness.md", "docs/analytics_spec.md") + else "blocked", + f"commercial_value_status={value['value_status']}; analytics_measurement_status={analytics['measurement_status']}", + "Can finance tell measured local evidence apart from buyer ROI assumptions?", + "Keep proposed KPI targets separate from measured local runtime data.", + ), + section( + "implementation_readiness", + "Implementation readiness", + "Implementation and operations reviewers", + ["docs/commercial_onboarding_readiness.md", "docs/commercial_operations_readiness.md"], + ["/api/v1/commercial_onboarding_readiness/latest", "/api/v1/commercial_operations_readiness/latest"], + "repository_and_runtime_artifact", + "ready" + if onboarding["onboarding_status"] != "commercial_onboarding_blocked" + and operations["operations_status"] != "commercial_operations_blocked" + and all_files("docs/commercial_onboarding_readiness.md", "docs/commercial_operations_readiness.md") + else "blocked", + f"commercial_onboarding_status={onboarding['onboarding_status']}; commercial_operations_status={operations['operations_status']}", + "Can implementation owners see onboarding, operations, incident, and handoff evidence?", + "Convert buyer environment specifics into the paid onboarding plan.", + ), + section( + "figma_and_design_review", + "Figma and design review", + "Product design reviewer", + [ + "docs/commercial_due_diligence_room.md", + "docs/figma_artifacts.md", + "docs/superpowers/plans/2026-07-02-commercial-due-diligence-room-runtime.md", + ], + ["/api/v1/commercial_due_diligence_rooms/latest"], + "repository_and_runtime_artifact", + "ready" + if all_files( + "docs/commercial_due_diligence_room.md", + "docs/figma_artifacts.md", + "docs/superpowers/plans/2026-07-02-commercial-due-diligence-room-runtime.md", + ) + else "blocked", + "Due diligence doc, FigJam artifact record, and implementation plan are committed.", + "Can stakeholders inspect the diligence room as docs, runtime JSON, and FigJam?", + "Use FigJam only; do not use Figma Code Connect.", + ), + section( + "buyer_authority_documents", + "Buyer authority documents", + "Buyer sponsor", + ["named buyer signer", "budget owner and purchase order", "buyer DPA or privacy acceptance"], + [], + "proposed_until_buyer_specific", + "warning", + "Named signer, budget owner, PO, and buyer privacy acceptance require buyer authority.", + "Does the buyer have authority artifacts ready for final diligence?", + "Collect signer, PO, DPA/privacy acceptance, or explicit waiver.", + ), + section( + "production_external_attestations", + "Production and external attestations", + "Production and security owners", + ["production telemetry", "third-party security attestation", "hosted scan evidence"], + [], + "proposed_until_buyer_specific", + "warning", + "Production telemetry and third-party attestations are external evidence, not local repo measurements.", + "Can the buyer distinguish local readiness from production and third-party evidence?", + "Collect hosted telemetry and external attestation after environment selection.", + ), + ] + state_counts = Counter(item["completion_state"] for item in diligence_sections) + blocked_count = state_counts.get("blocked", 0) + len(concrete_blockers) + warning_count = state_counts.get("warning", 0) + if blocked_count: + due_diligence_status = "commercial_due_diligence_blocked" + elif warning_count: + due_diligence_status = "commercial_due_diligence_ready_with_warnings" + else: # pragma: no cover - unreachable while this report carries literal buyer-specific warning sections + due_diligence_status = "commercial_due_diligence_ready" # pragma: no cover + required_runtime_endpoints = list( + dict.fromkeys( + endpoint + for item in diligence_sections + for endpoint in item["runtime_endpoints"] + if endpoint.startswith("/") + ) + ) + + return { + "due_diligence_status": due_diligence_status, + "target_contract_value_krw": target_contract_value_krw, + "target_contract_value_display": f"KRW {target_contract_value_krw:,}", + "measurement_status": "local_commercial_due_diligence_room", + "source_note": ( + "Commercial due diligence room packages repo-local purchase approval, proposal, runtime, " + "admin trace, security, contract, value, onboarding, operations, analytics, Figma, " + "review-policy, and packaging evidence for KRW 2,000,000,000 buyer diligence; it is " + "not a valuation guarantee, purchase commitment, signed order, legal opinion, production " + "compliance certificate, third-party attestation, or revenue proof." + ), + "diligence_narrative": { + "title": "KRW 2B commercial due diligence room", + "promise": ( + "Give finance, procurement, legal, security, product, and implementation reviewers " + "one evidence room that separates measured local product evidence from buyer-specific " + "and external production artifacts." + ), + "audience": [ + "Economic buyer", + "Finance owner", + "Procurement owner", + "Legal owner", + "Security owner", + "Platform reviewer", + "Implementation owner", + ], + }, + "diligence_summary": { + "section_count": len(diligence_sections), + "ready_count": state_counts.get("ready", 0), + "warning_count": warning_count, + "blocked_count": blocked_count, + "endpoint_count": len(required_runtime_endpoints), + "review_process_is_blocker": purchase["review_process_policy"]["is_blocker"], + "code_connect_used": False, + }, + "diligence_sections": diligence_sections, + "required_runtime_endpoints": required_runtime_endpoints, + "buyer_missing_artifacts": [ + "named buyer signer", + "budget owner and purchase order", + "buyer DPA or privacy acceptance", + "production telemetry", + "third-party security attestation", + ], + "concrete_blockers": concrete_blockers, + "due_diligence_status_rules": [ + { + "due_diligence_status": "commercial_due_diligence_ready", + "rule": "all diligence sections are ready and no buyer authority, production, or third-party evidence remains open", + }, + { + "due_diligence_status": "commercial_due_diligence_ready_with_warnings", + "rule": "repo-local diligence room evidence is ready while buyer authority, production telemetry, or external attestations remain explicit warnings", + }, + { + "due_diligence_status": "commercial_due_diligence_blocked", + "rule": "security failure, API contract regression, document mismatch, runtime defect, missing local diligence evidence, or Code Connect usage blocks buyer diligence", + }, + ], + "review_process_policy": purchase["review_process_policy"], + "related_runtime_reports": { + "commercial_purchase_approval_status": purchase["purchase_approval_status"], + "commercial_proposal_status": proposal["proposal_status"], + "commercial_completion_status": completion["completion_status"], + "commercial_demo_status": demo["demo_status"], + "buyer_acceptance_workflow_status": buyer_workflow["workflow_status"], + "commercial_close_status": close["close_status"], + "commercial_procurement_status": procurement["procurement_status"], + "commercial_contract_status": contract["contract_status"], + "commercial_value_status": value["value_status"], + "commercial_security_attestation_status": security["security_attestation_status"], + "commercial_onboarding_status": onboarding["onboarding_status"], + "commercial_operations_status": operations["operations_status"], + "analytics_measurement_status": analytics["measurement_status"], + }, + "library_split_decision": purchase["library_split_decision"], + "plugin_traceability": purchase["plugin_traceability"], + "due_diligence_links": { + "figma_design_file": "https://www.figma.com/design/vsZMd8WAv42HDRgcZuNcWk", + "figjam_board": "https://www.figma.com/board/Wr8iMlB9SHkerHSjv0Pe0M", + "runtime_endpoint": "/api/v1/commercial_due_diligence_rooms/latest", + "documentation": "docs/commercial_due_diligence_room.md", + }, + } + + def commercial_investment_committee_memo_report( + self, + target_contract_value_krw: int = DEFAULT_COMMERCIAL_TARGET_VALUE_KRW, + locale_bundles: dict[str, dict[str, str]] | None = None, + security_profile: dict[str, Any] | None = None, + ) -> dict[str, Any]: + """Return executive investment committee memo sections for the KRW 2B standard.""" + due_diligence = self.commercial_due_diligence_room_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + purchase = self.commercial_purchase_approval_packet_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + proposal = self.commercial_proposal_packet_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + completion = self.commercial_completion_scorecard_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + demo = self.commercial_demo_scenario_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + buyer_workflow = self.commercial_buyer_acceptance_workflow_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + close = self.commercial_close_readiness_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + procurement = self.commercial_procurement_readiness_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + contract = self.commercial_contract_readiness_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + value = self.commercial_value_readiness_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + security = self.commercial_security_attestation_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + onboarding = self.commercial_onboarding_readiness_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + operations = self.commercial_operations_readiness_report( + target_contract_value_krw=target_contract_value_krw, + locale_bundles=locale_bundles, + security_profile=security_profile, + ) + analytics = self.analytics_snapshot(locale_bundles=locale_bundles) + admin_state = self.admin_state() + root = Path(__file__).resolve().parents[1] + + def has_file(path: str) -> bool: + return (root / path).is_file() + + def all_files(*paths: str) -> bool: + return all(has_file(path) for path in paths) + + def section( + section_name: str, + label: str, + reviewer: str, + sources: list[str], + runtime_endpoints: list[str], + evidence_type: str, + completion_state: str, + evidence: str, + committee_question: str, + next_action: str, + ) -> dict[str, Any]: + require_object_name(section_name, "commercial_investment_committee.section_name") + if completion_state not in {"ready", "warning", "blocked"}: # pragma: no cover + raise ValueError("commercial investment committee section state must be ready, warning, or blocked") + return { + "section_name": section_name, + "label": label, + "reviewer": reviewer, + "sources": sources, + "runtime_endpoints": runtime_endpoints, + "evidence_type": evidence_type, + "completion_state": completion_state, + "evidence": evidence, + "committee_question": committee_question, + "next_action": next_action, + } + + concrete_blockers = list( + dict.fromkeys( + due_diligence["concrete_blockers"] + + purchase["concrete_blockers"] + + proposal["concrete_blockers"] + + completion["concrete_blockers"] + + demo["concrete_blockers"] + + buyer_workflow["concrete_blockers"] + ) + ) + local_runtime_state = ( + "blocked" + if due_diligence["due_diligence_status"] == "commercial_due_diligence_blocked" + or purchase["purchase_approval_status"] == "commercial_purchase_approval_blocked" + or proposal["proposal_status"] == "commercial_proposal_blocked" + or completion["completion_status"] == "commercial_completion_blocked" + or demo["demo_status"] == "commercial_demo_blocked" + or buyer_workflow["workflow_status"] == "buyer_acceptance_workflow_blocked" + or concrete_blockers + else "ready" + ) + memo_sections = [ + section( + "executive_recommendation", + "Executive recommendation", + "Investment committee chair", + [ + "docs/commercial_investment_committee_memo.md", + "docs/figma_artifacts.md", + "docs/superpowers/plans/2026-07-02-commercial-investment-committee-memo-runtime.md", + ], + ["/api/v1/commercial_investment_committee_memos/latest"], + "repository_and_runtime_artifact", + local_runtime_state + if all_files( + "docs/commercial_investment_committee_memo.md", + "docs/figma_artifacts.md", + "docs/superpowers/plans/2026-07-02-commercial-investment-committee-memo-runtime.md", + ) + else "blocked", + "Investment committee memo, FigJam artifact record, and implementation plan are committed.", + "Can the committee recommend the KRW 2B purchase path with explicit conditions?", + "Use this memo as the executive decision cover artifact.", + ), + section( + "diligence_room_ready", + "Due diligence room ready", + "Diligence owner", + ["docs/commercial_due_diligence_room.md", "/api/v1/commercial_due_diligence_rooms/latest"], + ["/api/v1/commercial_due_diligence_rooms/latest"], + "repository_and_runtime_artifact", + local_runtime_state if has_file("docs/commercial_due_diligence_room.md") else "blocked", + f"commercial_due_diligence_status={due_diligence['due_diligence_status']}", + "Can the memo point to a complete diligence room?", + "Reference due diligence room sections instead of duplicating evidence.", + ), + section( + "purchase_approval_ready", + "Purchase approval ready", + "Purchase sponsor", + ["docs/commercial_purchase_approval_packet.md", "/api/v1/commercial_purchase_approval_packets/latest"], + ["/api/v1/commercial_purchase_approval_packets/latest"], + "repository_and_runtime_artifact", + local_runtime_state if has_file("docs/commercial_purchase_approval_packet.md") else "blocked", + f"commercial_purchase_approval_status={purchase['purchase_approval_status']}", + "Can the committee see finance, procurement, legal, security, and implementation gates?", + "Use the purchase approval packet as committee appendix A.", + ), + section( + "financial_case", + "Financial case", + "Economic buyer", + ["docs/commercial_value_readiness.md", "docs/analytics_spec.md", "/api/v1/analytics_snapshots/latest"], + ["/api/v1/commercial_value_readiness/latest", "/api/v1/analytics_snapshots/latest"], + "repository_and_runtime_artifact", + "ready" + if value["value_status"] != "commercial_value_blocked" + and analytics["measurement_status"] == "local_runtime_snapshot" + and all_files("docs/commercial_value_readiness.md", "docs/analytics_spec.md") + else "blocked", + f"commercial_value_status={value['value_status']}; analytics_measurement_status={analytics['measurement_status']}", + "Does the memo separate measured local evidence from buyer ROI assumptions?", + "Attach buyer ROI model only after buyer discovery supplies it.", + ), + section( + "risk_and_security_summary", + "Risk and security summary", + "Security reviewer", + ["SECURITY.md", "docs/commercial_security_attestation.md", "/api/v1/commercial_security_attestations/latest"], + ["/api/v1/commercial_security_attestations/latest"], + "repository_and_runtime_artifact", + "ready" + if security["security_attestation_status"] != "commercial_security_attestation_blocked" + and all_files("SECURITY.md", "docs/commercial_security_attestation.md") + else "blocked", + f"commercial_security_attestation_status={security['security_attestation_status']}", + "Are security risks explicit without claiming external certification?", + "Keep third-party attestation outside measured local evidence.", + ), + section( + "commercial_terms_summary", + "Commercial terms summary", + "Legal and procurement reviewers", + [ + "docs/commercial_contract_readiness.md", + "docs/commercial_procurement_readiness.md", + "docs/commercial_close_readiness.md", + ], + [ + "/api/v1/commercial_contract_readiness/latest", + "/api/v1/commercial_procurement_readiness/latest", + "/api/v1/commercial_close_readiness/latest", + ], + "repository_and_runtime_artifact", + "ready" + if contract["contract_status"] != "commercial_contract_blocked" + and procurement["procurement_status"] != "commercial_procurement_blocked" + and close["close_status"] != "commercial_close_blocked" + and all_files( + "docs/commercial_contract_readiness.md", + "docs/commercial_procurement_readiness.md", + "docs/commercial_close_readiness.md", + ) + else "blocked", + ( + f"commercial_contract_status={contract['contract_status']}; " + f"commercial_procurement_status={procurement['procurement_status']}; " + f"commercial_close_status={close['close_status']}" + ), + "Can legal and procurement conditions be approved or tracked?", + "Attach order-form details only after buyer legal review.", + ), + section( + "implementation_readiness_summary", + "Implementation readiness summary", + "Implementation owner", + ["docs/commercial_onboarding_readiness.md", "docs/commercial_operations_readiness.md"], + ["/api/v1/commercial_onboarding_readiness/latest", "/api/v1/commercial_operations_readiness/latest"], + "repository_and_runtime_artifact", + "ready" + if onboarding["onboarding_status"] != "commercial_onboarding_blocked" + and operations["operations_status"] != "commercial_operations_blocked" + and all_files("docs/commercial_onboarding_readiness.md", "docs/commercial_operations_readiness.md") + else "blocked", + f"commercial_onboarding_status={onboarding['onboarding_status']}; commercial_operations_status={operations['operations_status']}", + "Can implementation start after buyer environment details are supplied?", + "Convert buyer environment details into the paid onboarding plan.", + ), + section( + "design_and_figma_review", + "Design and Figma review", + "Product design reviewer", + ["docs/figma_artifacts.md", "docs/commercial_investment_committee_memo.md"], + ["/api/v1/commercial_investment_committee_memos/latest"], + "repository_and_runtime_artifact", + "ready" if all_files("docs/figma_artifacts.md", "docs/commercial_investment_committee_memo.md") else "blocked", + "FigJam memo flow and Product Design scope are recorded without Code Connect.", + "Can stakeholders inspect the memo flow in FigJam and runtime JSON?", + "Keep Figma Code Connect out of the committee workflow.", + ), + section( + "buyer_final_authority", + "Buyer final authority", + "Buyer sponsor", + ["executive sponsor approval", "named signer", "budget owner", "purchase order"], + [], + "proposed_until_buyer_specific", + "warning", + "Executive sponsor approval, named signer, budget owner, and purchase order require buyer authority.", + "Can the buyer approve the final KRW 2B purchase authority?", + "Collect final buyer authority artifacts or explicit waiver.", + ), + section( + "production_external_evidence", + "Production and external evidence", + "Production and security owners", + ["production telemetry", "third-party security attestation", "hosted scan evidence"], + [], + "proposed_until_buyer_specific", + "warning", + "Production telemetry, third-party security attestation, and hosted scan evidence are external inputs.", + "Can the committee approve with production and external evidence still tracked as conditions?", + "Collect hosted evidence after environment selection.", + ), + ] + state_counts = Counter(item["completion_state"] for item in memo_sections) + blocked_count = state_counts.get("blocked", 0) + len(concrete_blockers) + warning_count = state_counts.get("warning", 0) + if blocked_count: + investment_committee_status = "commercial_investment_committee_blocked" + recommendation_status = "do_not_recommend_until_blockers_cleared" + elif warning_count: + investment_committee_status = "commercial_investment_committee_ready_with_warnings" + recommendation_status = "recommend_with_buyer_conditions" + else: # pragma: no cover - unreachable while external-evidence warning sections remain literal + investment_committee_status = "commercial_investment_committee_ready" # pragma: no cover + recommendation_status = "recommend" # pragma: no cover + required_runtime_endpoints = list( + dict.fromkeys( + endpoint + for item in memo_sections + for endpoint in item["runtime_endpoints"] + if endpoint.startswith("/") + ) + ) + + return { + "investment_committee_status": investment_committee_status, + "target_contract_value_krw": target_contract_value_krw, + "target_contract_value_display": f"KRW {target_contract_value_krw:,}", + "measurement_status": "local_commercial_investment_committee_memo", + "source_note": ( + "Commercial investment committee memo packages repo-local due diligence, purchase approval, " + "proposal, runtime, admin trace, security, contract, value, onboarding, operations, analytics, " + "Figma, review-policy, and packaging evidence for KRW 2,000,000,000 executive review; it is " + "not a valuation guarantee, purchase commitment, signed order, legal opinion, production " + "compliance certificate, third-party attestation, or revenue proof." + ), + "executive_recommendation": { + "title": "KRW 2B commercial investment committee memo", + "recommendation_status": recommendation_status, + "recommendation": ( + "Recommend committee review with buyer authority, production telemetry, and external " + "attestation conditions tracked separately from measured local product evidence." + if recommendation_status == "recommend_with_buyer_conditions" + else "Do not recommend until concrete blockers are cleared." + if recommendation_status == "do_not_recommend_until_blockers_cleared" + else "Recommend committee approval with no open local or buyer-specific conditions." + ), + "audience": [ + "Investment committee chair", + "Economic buyer", + "Finance owner", + "Procurement owner", + "Legal owner", + "Security owner", + "Implementation owner", + ], + }, + "memo_summary": { + "section_count": len(memo_sections), + "ready_count": state_counts.get("ready", 0), + "warning_count": warning_count, + "blocked_count": blocked_count, + "endpoint_count": len(required_runtime_endpoints), + "review_process_is_blocker": due_diligence["review_process_policy"]["is_blocker"], + "code_connect_used": False, + }, + "memo_sections": memo_sections, + "required_runtime_endpoints": required_runtime_endpoints, + "committee_decision_questions": [ + "Is the product evidence sufficient for KRW 2B buyer review?", + "Are buyer authority documents named and tracked?", + "Are production and third-party evidence gaps explicit warnings?", + "Is any concrete blocker present?", + ], + "buyer_missing_artifacts": due_diligence["buyer_missing_artifacts"] + + ["executive sponsor approval", "investment committee sign-off"], + "concrete_blockers": concrete_blockers, + "investment_committee_status_rules": [ + { + "investment_committee_status": "commercial_investment_committee_ready", + "rule": "all memo sections are ready and no buyer authority, production, or third-party evidence remains open", + }, + { + "investment_committee_status": "commercial_investment_committee_ready_with_warnings", + "rule": "repo-local committee memo evidence is ready while buyer authority, production telemetry, or external attestations remain explicit warnings", + }, + { + "investment_committee_status": "commercial_investment_committee_blocked", + "rule": "security failure, API contract regression, document mismatch, runtime defect, missing local memo evidence, or Code Connect usage blocks committee recommendation", + }, + ], + "review_process_policy": due_diligence["review_process_policy"], + "related_runtime_reports": { + "commercial_due_diligence_status": due_diligence["due_diligence_status"], + "commercial_purchase_approval_status": purchase["purchase_approval_status"], + "commercial_proposal_status": proposal["proposal_status"], + "commercial_completion_status": completion["completion_status"], + "commercial_demo_status": demo["demo_status"], + "buyer_acceptance_workflow_status": buyer_workflow["workflow_status"], + "commercial_close_status": close["close_status"], + "commercial_procurement_status": procurement["procurement_status"], + "commercial_contract_status": contract["contract_status"], + "commercial_value_status": value["value_status"], + "commercial_security_attestation_status": security["security_attestation_status"], + "commercial_onboarding_status": onboarding["onboarding_status"], + "commercial_operations_status": operations["operations_status"], + "analytics_measurement_status": analytics["measurement_status"], + "admin_agent_count": len(admin_state["agents"]), + }, + "library_split_decision": due_diligence["library_split_decision"], + "plugin_traceability": due_diligence["plugin_traceability"], + "committee_links": { + "figma_design_file": "https://www.figma.com/design/vsZMd8WAv42HDRgcZuNcWk", + "figjam_board": "https://www.figma.com/board/Wr8iMlB9SHkerHSjv0Pe0M", + "runtime_endpoint": "/api/v1/commercial_investment_committee_memos/latest", + "documentation": "docs/commercial_investment_committee_memo.md", + }, + } + + def admin_state( + self, + owner_id: str | None = None, + *, + role: str | None = None, + purpose: str | None = None, + ) -> dict[str, Any]: + """Build the admin console state payload from agents, policy, and audit data.""" + agent_page_size = max(1, len(self.candidates)) + return { + "agents": self.list_agents(page_size=agent_page_size), + "policy": { + **self.policy.as_dict(), + "roles": list(self.ROLE_TAGS), + }, + "routing_evidence": { + "transport": self._group_router.snapshot(), + "quality": self._quality_router.snapshot(), + }, + "recent_workflow_runs": [ + self._shorten_run(run) + for run in self.list_recent_runs( + page_size=max(1, len(self._run_order)), owner_id=owner_id + ) + ], + "recent_audit_events": self.list_recent_audit_events(role=role, purpose=purpose), + "recent_authorization_decisions": self.list_recent_authorization_decisions(), + "spend": self.spend_analytics(), + } + + def _shorten_run(self, run: dict[str, Any]) -> dict[str, Any]: # pragma: no cover + return { + "workflow_run_id": run["workflow_run_id"], + "mode": run["mode"], + "policy_mode": run["policy_mode"], + "created_at": run["created_at"], + } + + def _is_trace_complete(self, run: dict[str, Any]) -> bool: + trace = run.get("trace", []) + if not trace: + return False + for step in trace: + if not all(key in step for key in ("id", "role", "agent_id", "subtask", "access", "output")): + return False + if not isinstance(step["access"], list) or step["output"] is None: + return False + verification = run.get("verification") or {} + return bool(run.get("answer") and "accepted" in verification and "reason" in verification) + + def _is_policy_safe_run(self, run: dict[str, Any]) -> bool: + if run["mode"] == "conduct" and run["policy_snapshot"].get("verifier_required") and not run.get("verification"): + return False + return self._provider_exclusion_miss_count(run) == 0 + + def _provider_exclusion_miss_count(self, run: dict[str, Any]) -> int: + misses = 0 + for step in run.get("trace", []): + try: + agent = self._agent(step["agent_id"]) + except KeyError: + misses += 1 + continue + if step["role"] in agent.provider_exclusions: + misses += 1 + return misses + + def _locale_key_parity(self, locale_bundles: dict[str, dict[str, str]]) -> dict[str, Any]: + english = locale_bundles.get("en", {}) + other_locale_codes = sorted(code for code in locale_bundles if code != "en") + denominator = len(english) * len(other_locale_codes) + missing = [ + f"{locale_code}.{key}" + for locale_code in other_locale_codes + for key in sorted(english) + if not locale_bundles[locale_code].get(key) + ] + numerator = denominator - len(missing) + return { + "numerator": numerator, + "denominator": denominator, + "value_percent": self._percent(numerator, denominator), + "missing_keys": missing, + } + + def _percent(self, numerator: int, denominator: int) -> float | None: + if denominator == 0: + return None + return round((numerator / denominator) * 100, 2) + + def _criterion( + self, + criterion_name: str, + label: str, + status: str, + evidence: str, + remediation: str, + ) -> dict[str, str]: + require_object_name(criterion_name, "sales_readiness.criterion_name") + if status not in {"pass", "warn", "fail"}: # pragma: no cover + raise ValueError("sales readiness status must be pass, warn, or fail") + return { + "criterion_name": criterion_name, + "status": status, + "label": label, + "evidence": evidence, + "remediation": remediation, + } + + def _buyer_evidence_item( + self, + item_name: str, + label: str, + reviewer: str, + sources: list[str], + evidence_type: str, + completion_state: str, + evidence: str, + next_action: str, + ) -> dict[str, Any]: + require_object_name(item_name, "buyer_evidence_manifest.item_name") + if evidence_type not in { + "measured_local", + "repository_artifact", + "figma_artifact", + "proposed_until_production", + "proposed_until_buyer_specific", + }: # pragma: no cover + raise ValueError("buyer evidence type is invalid") + if completion_state not in {"ready", "warning", "blocked"}: # pragma: no cover + raise ValueError("buyer evidence completion state must be ready, warning, or blocked") + return { + "item_name": item_name, + "label": label, + "reviewer": reviewer, + "sources": sources, + "evidence_type": evidence_type, + "completion_state": completion_state, + "evidence": evidence, + "next_action": next_action, + } + + def _buyer_manifest_summary(self, items: list[dict[str, Any]]) -> dict[str, Any]: + completion_counts = Counter(item["completion_state"] for item in items) + evidence_counts = Counter(item["evidence_type"] for item in items) + return { + "total_items": len(items), + "by_completion_state": { + "ready": completion_counts.get("ready", 0), + "warning": completion_counts.get("warning", 0), + "blocked": completion_counts.get("blocked", 0), + }, + "by_evidence_type": { + "measured_local": evidence_counts.get("measured_local", 0), + "repository_artifact": evidence_counts.get("repository_artifact", 0), + "figma_artifact": evidence_counts.get("figma_artifact", 0), + "proposed_until_production": evidence_counts.get("proposed_until_production", 0), + "proposed_until_buyer_specific": evidence_counts.get("proposed_until_buyer_specific", 0), + }, + } + + def _security_posture_criterion(self, security_profile: dict[str, Any]) -> dict[str, str]: + auth_mode = security_profile.get("auth_mode", "loopback_no_auth") + issues: list[str] = [] + warnings: list[str] = [] + if auth_mode == "single_token": + warnings.append("single bearer token shared by admin and inference scopes") + elif auth_mode not in {"split_token", "external_bearer_verifier"}: + issues.append("no bearer token configured outside loopback-only development") + if security_profile.get("allow_public_bind"): + issues.append("public bind is enabled") + if security_profile.get("expose_trace_by_default"): + issues.append("trace exposure is enabled by default") + if int(security_profile.get("rate_limit_requests") or 0) <= 0: + issues.append("request rate limiting is disabled") + if int(security_profile.get("max_concurrent_runs") or 0) <= 0: + issues.append("run concurrency limiting is disabled") + + if issues: + status = "fail" + evidence = "; ".join(issues) + remediation = "Require bearer auth, private bind defaults, hidden traces, rate limits, and run limits." + elif warnings: + status = "warn" + evidence = "; ".join(warnings) + remediation = "For enterprise pilots, split admin and inference tokens before customer evaluation." + else: + status = "pass" + auth_evidence = ( + "external bearer verifier" + if auth_mode == "external_bearer_verifier" + else "split tokens" + ) + evidence = f"{auth_evidence}, private bind default, hidden traces, rate limits, and run limits are configured" + remediation = "Keep these controls enabled for customer-facing pilots." + + return self._criterion("security_posture", "Security posture", status, evidence, remediation) + + def _locale_readiness_criterion(self, analytics: dict[str, Any]) -> dict[str, str]: + locale_metric = next( + metric for metric in analytics["guardrails"] if metric["metric_name"] == "locale_key_parity" + ) + missing = locale_metric.get("missing_keys", []) + parity = locale_metric.get("value_percent") + if parity == 100.0: + status = "pass" + evidence = "English and Korean admin locale keys are aligned" + remediation = "Keep locale parity tests updated when adding operator copy." + else: + status = "warn" if missing else "fail" + evidence = f"{parity}% locale key parity; missing keys: {', '.join(missing) or 'locale bundles absent'}" + remediation = "Fill missing Korean and English operator labels before customer review." + return self._criterion("locale_readiness", "Locale readiness", status, evidence, remediation) + + def _provider_egress_criterion(self) -> dict[str, str]: + unsafe = [] + remote = [] + for agent in self.agents: + if agent.base_url.startswith("mock://"): + continue + if _is_local_provider_url(agent.base_url): + continue + remote.append(agent.id) + parsed = urlparse(agent.base_url) + if parsed.scheme != "https" or not agent.credential_name: + unsafe.append(agent.id) + if unsafe: + status = "fail" + evidence = f"unsafe provider egress config for agents: {', '.join(sorted(unsafe))}" + remediation = "Use https provider endpoints with a named KV credential before enabling remote egress." + else: + status = "pass" + evidence = ( + "mock providers only" + if not remote + else f"{len(remote)} remote providers use https and a named KV credential" + ) + remediation = "Keep provider allow-list enforcement enabled for non-mock providers." + return self._criterion("provider_egress_safety", "Provider egress safety", status, evidence, remediation) + + def _criteria_by_name(self, criteria: list[dict[str, str]]) -> dict[str, dict[str, str]]: + return {row["criterion_name"]: row for row in criteria} + + def _metrics_by_name(self, metrics: list[dict[str, Any]]) -> dict[str, dict[str, Any]]: + return {row["metric_name"]: row for row in metrics} + + def _commercial_documentation_profile(self) -> dict[str, Any]: + root = Path(__file__).resolve().parents[1] + required_documents = [ + "README.md", + "SECURITY.md", + "docs/product_planning.md", + "docs/rest_api_design.md", + "docs/analytics_spec.md", + "docs/commercial_readiness.md", + ] + missing_documents = [ + document_path + for document_path in required_documents + if not (root / document_path).is_file() + ] + return { + "required_documents": required_documents, + "missing_documents": missing_documents, + "present_count": len(required_documents) - len(missing_documents), + "required_count": len(required_documents), + "has_security_policy": (root / "SECURITY.md").is_file(), + "source": "repository documentation files", + } + + def _criteria_summary(self, criteria: list[dict[str, str]]) -> dict[str, int]: + counts = Counter(row["status"] for row in criteria) + return { + "pass": counts.get("pass", 0), + "warn": counts.get("warn", 0), + "fail": counts.get("fail", 0), + } + + +def redact_text(text: str) -> str: + """Mask credential shapes (API keys, tokens, passwords, bearer headers) from traces. + + Does not mask PII (email addresses, names, etc.): per governance-risk-compliance policy, + PII is protected by purpose-limited authorization, encryption, and audit logging, not by + destroying it in every response -- blanket PII masking here broke every downstream + consumer that needs the real content (e.g. an email client rendering actual addresses). + """ + redacted = text + for pattern in SECRET_PATTERNS: + if pattern.pattern.lower().startswith("(?i)(api"): + redacted = pattern.sub(lambda match: f"{match.group(1)}{match.group(2)}[REDACTED]", redacted) + else: + redacted = pattern.sub(lambda match: f"{match.group(1)}[REDACTED]", redacted) + return redacted + + +def redact_value(value: Any) -> Any: + """Recursively redact string values while preserving response shape.""" + if isinstance(value, str): + return redact_text(value) + if isinstance(value, list): + return [redact_value(item) for item in value] + if isinstance(value, dict): + return {key: redact_value(item) for key, item in value.items()} + return value + +def _freeze_report_cache_value(value: Any) -> Any: + if isinstance(value, dict): + return tuple( + sorted( + (str(key), _freeze_report_cache_value(item)) + for key, item in value.items() + ) + ) + if isinstance(value, (list, tuple)): + return tuple(_freeze_report_cache_value(item) for item in value) + if isinstance(value, set): + return tuple(sorted(_freeze_report_cache_value(item) for item in value)) + try: + hash(value) + except TypeError: + return repr(value) + return value + + +def _cached_commercial_report(method: Any) -> Any: + @wraps(method) + def wrapper(self: TaskOrchestrator, *args: Any, **kwargs: Any) -> dict[str, Any]: + cache = _COMMERCIAL_REPORT_CACHE.get() + token = None + if cache is None: + cache = {} + token = _COMMERCIAL_REPORT_CACHE.set(cache) + try: + key = ( + method.__name__, + _freeze_report_cache_value(args), + _freeze_report_cache_value(kwargs), + ) + if key not in cache: + cache[key] = method(self, *args, **kwargs) + return cache[key] + finally: + if token is not None: + _COMMERCIAL_REPORT_CACHE.reset(token) + + return wrapper + + +for _commercial_report_name, _commercial_report_method in list(TaskOrchestrator.__dict__.items()): + if ( + _commercial_report_name.startswith("commercial_") + and _commercial_report_name.endswith("_report") + and callable(_commercial_report_method) + ): + setattr( + TaskOrchestrator, + _commercial_report_name, + _cached_commercial_report(_commercial_report_method), + ) + + +def _pareto_front(results: list[dict[str, Any]]) -> list[dict[str, Any]]: + """Configs not dominated on (quality up, cost down).""" + measured = [row for row in results if row.get("cost_usd") is not None] + front: list[dict[str, Any]] = [] + for a in measured: + dominated = any( + b is not a + and b["quality"] >= a["quality"] + and b["cost_usd"] <= a["cost_usd"] + and (b["quality"] > a["quality"] or b["cost_usd"] < a["cost_usd"]) + for b in measured + ) + if not dominated: + front.append(a) + return front + + +def _recommend_config(results: list[dict[str, Any]], cost_budget_usd: float | None) -> dict[str, Any] | None: + measured = [row for row in results if row.get("cost_usd") is not None] + if not measured: + return None + if cost_budget_usd is not None: + affordable = [r for r in measured if r["cost_usd"] <= cost_budget_usd] + if affordable: + best = max(affordable, key=lambda r: (r["quality"], -r["cost_usd"])) + reason = "highest quality within cost budget" + else: + best = min(measured, key=lambda r: r["cost_usd"]) + reason = "no config within budget; cheapest instead" + else: + # Maximize performance first, minimize cost as the tie-break (cheapest among the + # best-quality configs) — the honest reading of "max quality while min cost". + best = max(measured, key=lambda r: (r["quality"], -r["cost_usd"])) + reason = "highest quality; cheapest among equal-quality configs" + return {"name": best["name"], "quality": best["quality"], "cost_usd": best["cost_usd"], "reason": reason} + + +def _score_config(orchestrator: Any, tasks: list[dict[str, Any]], quality_fn: Any, mode: str, use_batch: bool) -> float: + """Mean quality of one config over the task set; route configs may evaluate via Batch.""" + if use_batch and mode == "route": + records = orchestrator.batch_route([task["prompt"] for task in tasks]) + scores = [float(quality_fn(task, record["answer"] or "")) for task, record in zip(tasks, records)] + else: + scores = [ + float(quality_fn(task, orchestrator.run([{"role": "user", "content": task["prompt"]}], mode=mode)["answer"])) + for task in tasks + ] + return sum(scores) / len(scores) if scores else 0.0 + + +def optimize_orchestration( + candidates: list[dict[str, Any]], + tasks: list[dict[str, Any]], + quality_fn: Any, + cost_budget_usd: float | None = None, + use_batch: bool = False, +) -> dict[str, Any]: + """Search orchestration configs for maximum quality at minimum cost (the Fugu tradeoff). + + - ``candidates``: ``[{"name": str, "orchestrator": TaskOrchestrator, "mode": str}]``. + Each orchestrator should be fresh so its spend reflects only this search. + - ``tasks``: ``[{"prompt": str, ...}]`` — the eval set; each task + the produced + answer is passed to ``quality_fn``. + - ``quality_fn(task, answer_text) -> float`` in [0, 1] — the caller's real quality + signal (e.g. checkable answers or a judge). This function does not fabricate quality. + - ``cost_budget_usd``: optional cap. Recommendation = highest-quality config within + budget, else the cheapest; with no budget, the best quality-per-USD. + + Returns per-config measured quality + real cost, the Pareto front, and a recommendation. + """ + results: list[dict[str, Any]] = [] + for candidate in candidates: + orchestrator = candidate["orchestrator"] + mode = candidate.get("mode", "auto") + quality = _score_config(orchestrator, tasks, quality_fn, mode, use_batch) + cost = orchestrator.spend_analytics()["totals"]["cost_usd"] + results.append({ + "name": candidate["name"], + "mode": mode, + "quality": round(quality, 4), + "cost_usd": round(cost, 6) if cost is not None else None, + "quality_per_usd": ( + round(quality / cost, 2) if cost is not None and cost > 0 else None + ), + "task_count": len(tasks), + }) + + return { + "objective": "maximize quality, minimize cost", + "cost_budget_usd": cost_budget_usd, + "results": sorted( + results, + key=lambda r: ( + -r["quality"], + r["cost_usd"] is None, + r["cost_usd"] if r["cost_usd"] is not None else float("inf"), + ), + ), + "pareto_front": [r["name"] for r in _pareto_front(results)], + "recommended": _recommend_config(results, cost_budget_usd), + } + + +def evolve_orchestration( + build_orchestrator: Any, + search_space: dict[str, list[Any]], + tasks: list[dict[str, Any]], + quality_fn: Any, + generations: int = 4, + population: int = 6, + cost_budget_usd: float | None = None, + seed: int = 7, + use_batch: bool = False, +) -> dict[str, Any]: + """Evolve orchestration configs toward max quality at min cost (TRINITY-style search). + + For search spaces too large to enumerate: a seeded mutation+selection loop over + ``search_space`` (param -> candidate values). ``build_orchestrator(config)`` returns a + fresh TaskOrchestrator for a config (the caller owns provider wiring); each config is + evaluated ONCE and cached — critical when evaluation costs real API money. + + Fitness maximizes measured quality, then minimizes measured cost; configs whose cost + exceeds ``cost_budget_usd`` rank below all affordable ones. Quality comes from the + caller's ``quality_fn(task, answer) -> [0,1]`` — never fabricated. + """ + rng = random.Random(seed) + params = sorted(search_space) + + def random_config() -> dict[str, Any]: + return {p: rng.choice(search_space[p]) for p in params} + + def mutate(config: dict[str, Any]) -> dict[str, Any]: + child = dict(config) + gene = rng.choice(params) + choices = [v for v in search_space[gene] if v != config[gene]] or search_space[gene] + child[gene] = rng.choice(choices) + return child + + def key(config: dict[str, Any]) -> str: + return json.dumps({p: config[p] for p in params}, sort_keys=True, ensure_ascii=False) + + evaluated: dict[str, dict[str, Any]] = {} + + def evaluate(config: dict[str, Any]) -> dict[str, Any]: + config_key = key(config) + if config_key in evaluated: + return evaluated[config_key] + orchestrator = build_orchestrator(config) + mode = config.get("mode", "auto") + quality = _score_config(orchestrator, tasks, quality_fn, mode, use_batch) + cost = orchestrator.spend_analytics()["totals"]["cost_usd"] + result = { + "name": config_key, + "config": dict(config), + "quality": round(quality, 4), + "cost_usd": round(cost, 6) if cost is not None else None, + "quality_per_usd": ( + round(quality / cost, 2) if cost is not None and cost > 0 else None + ), + "task_count": len(tasks), + } + evaluated[config_key] = result + return result + + def fitness(row: dict[str, Any]) -> tuple[int, float, float]: + if row["cost_usd"] is None: + return (0, row["quality"], float("-inf")) + affordable = 1 if cost_budget_usd is None or row["cost_usd"] <= cost_budget_usd else 0 + return (affordable, row["quality"], -row["cost_usd"]) + + # Seed population (dedup keys so a tiny space doesn't waste evaluations). + pool: list[dict[str, Any]] = [] + seen: set[str] = set() + while len(pool) < population and len(seen) < min(population * 4, _space_size(search_space)): + config = random_config() + if key(config) not in seen: + seen.add(key(config)) + pool.append(config) + + history: list[dict[str, Any]] = [] + for generation in range(generations): + rows = [evaluate(config) for config in pool] + rows.sort(key=fitness, reverse=True) + survivors = rows[: max(1, len(rows) // 2)] + history.append({ + "generation": generation, + "best": {"config": survivors[0]["config"], "quality": survivors[0]["quality"], "cost_usd": survivors[0]["cost_usd"]}, + "evaluated_total": len(evaluated), + }) + pool = [dict(row["config"]) for row in survivors] + while len(pool) < population: + pool.append(mutate(rng.choice(survivors)["config"])) + + results = sorted(evaluated.values(), key=fitness, reverse=True) + return { + "objective": "maximize quality, minimize cost (evolutionary search)", + "cost_budget_usd": cost_budget_usd, + "generations": generations, + "evaluations": len(evaluated), + "space_size": _space_size(search_space), + "results": results, + "pareto_front": [row["name"] for row in _pareto_front(results)], + "recommended": _recommend_config(results, cost_budget_usd), + "history": history, + } + + +def _space_size(search_space: dict[str, list[Any]]) -> int: + size = 1 + for values in search_space.values(): + size *= max(1, len(values)) + return size + + +def chat_completion_response( + result: dict[str, Any], + model: str = "contextual-orchestrator", + include_trace: bool = False, + usage: dict[str, int] | None = None, +) -> dict[str, Any]: # pragma: no cover + """Wrap orchestration output in an OpenAI-compatible chat completion response. + + ``usage`` carries measured token counts. Absence remains explicit and null. + """ + orchestration = { + "workflow_run_id": result.get("workflow_run_id"), + "mode": result["mode"], + "verification": result.get("verification"), + "channel": result.get("channel"), + "routing_reason": result.get("routing_reason"), + "usage_record_id": result.get("usage_record_id"), + "cost": result.get("cost"), + } + if include_trace: + orchestration["trace"] = redact_value(result["trace"]) + message: dict[str, Any] = {"role": "assistant", "content": result["answer"]} + tool_calls = result.get("tool_calls") + if tool_calls: + message["tool_calls"] = tool_calls + if not result.get("answer"): + message["content"] = None + finish_reason = result.get("finish_reason") or ("tool_calls" if tool_calls else "stop") + return { + "id": _new_chat_completion_id(), + "object": "chat.completion", + "created": int(time.time()), + "model": model, + "choices": [ + { + "index": 0, + "message": message, + "finish_reason": finish_reason, + } + ], + "usage": usage, + "usage_measurement_status": "measured" if usage is not None else "unavailable", + "orchestration": {key: value for key, value in orchestration.items() if value is not None}, + } + + +def text_completion_response( + result: dict[str, Any], + model: str = "contextual-orchestrator", + usage: dict[str, int] | None = None, +) -> dict[str, Any]: # pragma: no cover + """Wrap orchestration output as OpenAI legacy ``text_completion`` (``/v1/completions``).""" + return { + "id": f"cmpl-{int(time.time() * 1000)}", + "object": "text_completion", + "created": int(time.time()), + "model": model, + "choices": [ + { + "index": 0, + "text": result["answer"], + "logprobs": None, + "finish_reason": "stop", + } + ], + "usage": usage, + "usage_measurement_status": "measured" if usage is not None else "unavailable", + } + + +_STREAM_CHUNK_SIZE = 32 + + +def chat_completion_chunks( + result: dict[str, Any], + model: str = "contextual-orchestrator", + include_trace: bool = False, + include_usage: bool = False, +) -> list[dict[str, Any]]: + """Frame an orchestration result as OpenAI-compatible chat completion chunks. + + Only provider-reported usage may be emitted. Gateway estimates remain internal + because presenting estimates as provider usage would violate the wire contract. + """ + answer = result.get("answer", "") + completion_id = _new_chat_completion_id() + created = int(time.time()) + base = { + "id": completion_id, + "object": "chat.completion.chunk", + "created": created, + "model": model, + } + if include_usage: + base["usage"] = None + + chunks: list[dict[str, Any]] = [ + { + **base, + "choices": [ + {"index": 0, "delta": {"role": "assistant"}, "finish_reason": None} + ], + } + ] + for offset in range(0, len(answer), _STREAM_CHUNK_SIZE): + piece = answer[offset : offset + _STREAM_CHUNK_SIZE] + chunks.append( + { + **base, + "choices": [ + {"index": 0, "delta": {"content": piece}, "finish_reason": None} + ], + } + ) + tool_calls = result.get("tool_calls") + if tool_calls: + chunks.append( + { + **base, + "choices": [ + { + "index": 0, + "delta": { + "tool_calls": [ + {"index": index, **call} + for index, call in enumerate(tool_calls) + ] + }, + "finish_reason": None, + } + ], + } + ) + + orchestration = { + "workflow_run_id": result.get("workflow_run_id"), + "mode": result.get("mode"), + "verification": result.get("verification"), + } + if include_trace and "trace" in result: + orchestration["trace"] = redact_value(result["trace"]) + + finish_reason = result.get("finish_reason") or ( + "tool_calls" if tool_calls else "stop" + ) + final = { + **base, + "choices": [{"index": 0, "delta": {}, "finish_reason": finish_reason}], + "orchestration": { + key: value for key, value in orchestration.items() if value is not None + }, + } + chunks.append(final) + + usage = result.get("usage") + cost = result.get("cost") + if include_usage: + measured = ( + isinstance(cost, dict) + and cost.get("measurement_status") == "measured" + and isinstance(usage, dict) + ) + chunks.append( + { + **base, + "choices": [], + "usage": usage if measured else None, + "usage_measurement_status": "measured" if measured else "unavailable", + } + ) + return chunks + + +def _new_chat_completion_id() -> str: + """Create a collision-resistant OpenAI-compatible completion identifier.""" + return f"chatcmpl-{uuid.uuid4().hex}" + + +def sse_stream_body(chunks: list[dict[str, Any]]) -> str: + """Serialize chat completion chunks as a Server-Sent Events body terminated by ``[DONE]``.""" + frames = [f"data: {json.dumps(chunk, ensure_ascii=False)}\n\n" for chunk in chunks] + frames.append("data: [DONE]\n\n") + return "".join(frames) From 316acdfafe55e4b3240a48bfcff703772fa50191 Mon Sep 17 00:00:00 2001 From: Seongho Bae Date: Sat, 12 Sep 2026 19:15:08 +0900 Subject: [PATCH 10/11] docs(effort): record exact-tree transport recovery --- docs/doctoring/effort_capability_evidence_20260912.md | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/docs/doctoring/effort_capability_evidence_20260912.md b/docs/doctoring/effort_capability_evidence_20260912.md index 8f815f020..cd4866045 100644 --- a/docs/doctoring/effort_capability_evidence_20260912.md +++ b/docs/doctoring/effort_capability_evidence_20260912.md @@ -66,9 +66,16 @@ failures: both numeric values reached request mutation without raising, and the hostile equality hook executed. Repair commit `0e514f316b63fdd2c43ae345bd9d70b10c0bb25a` replaces equality with an identity/type check at construction. The repaired production blob is -`fd9369d8309ac37624a79637fb8470af433cd30c`; malformed evidence is rejected +`441092b8889ab4328e95a93eee9093ad8a85d0c4`; malformed evidence is rejected before normalization, rendering, fallback selection, or payload mutation. +The first Git-data transfer created intermediate head `bd8ce72f69ca31d1b3a0e555632d0003466f81e1` +with a truncated source blob; exact-tree comparison rejected it before any +readiness or merge claim. Ordinary child +`5d4e8e30b66acf21e30aaecf94e10799f3cef288` restored the complete file from +predecessor `583ac7047df8129cabc3278eeb8d4ac96e43c348` and applied only the validated +line replacement. Its Git blob identity matches the locally verified source. + Fresh local verification with CPython 3.12 used disabled third-party pytest plugin autoload so an unrelated installed `pytest-asyncio` deprecation warning could not replace repository evidence. All effort-prefixed tests plus the From 64bcb8f0ef1b325e14a7b547529d90ff764d1e14 Mon Sep 17 00:00:00 2001 From: Seongho Bae Date: Sat, 12 Sep 2026 19:16:46 +0900 Subject: [PATCH 11/11] docs(effort): distinguish rejected transfer from valid repair --- .../effort_capability_evidence_20260912.md | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-) diff --git a/docs/doctoring/effort_capability_evidence_20260912.md b/docs/doctoring/effort_capability_evidence_20260912.md index cd4866045..4c058c4ca 100644 --- a/docs/doctoring/effort_capability_evidence_20260912.md +++ b/docs/doctoring/effort_capability_evidence_20260912.md @@ -63,16 +63,18 @@ request-profile boundary could apply its strict validation. RED commit `f0ad677ceb032ad90537df47571425604a22907a` exercises the real `ModelAgent` and `ModelClient` Responses path. It produced three intended failures: both numeric values reached request mutation without raising, and -the hostile equality hook executed. Repair commit -`0e514f316b63fdd2c43ae345bd9d70b10c0bb25a` replaces equality with an -identity/type check at construction. The repaired production blob is +the hostile equality hook executed. Valid repair commit +`5d4e8e30b66acf21e30aaecf94e10799f3cef288` replaces equality with an +identity/type check at construction and restores the complete source. The +repaired production blob is `441092b8889ab4328e95a93eee9093ad8a85d0c4`; malformed evidence is rejected before normalization, rendering, fallback selection, or payload mutation. -The first Git-data transfer created intermediate head `bd8ce72f69ca31d1b3a0e555632d0003466f81e1` -with a truncated source blob; exact-tree comparison rejected it before any -readiness or merge claim. Ordinary child -`5d4e8e30b66acf21e30aaecf94e10799f3cef288` restored the complete file from +The first Git-data transfer through implementation object +`0e514f316b63fdd2c43ae345bd9d70b10c0bb25a` and intermediate documentation +head `bd8ce72f69ca31d1b3a0e555632d0003466f81e1` contained a truncated source +blob; exact-tree comparison rejected that lineage before any readiness or +merge claim. The valid ordinary child restored the complete file from predecessor `583ac7047df8129cabc3278eeb8d4ac96e43c348` and applied only the validated line replacement. Its Git blob identity matches the locally verified source.