From 94a81112c231155319fc554e3937a66c866cf560 Mon Sep 17 00:00:00 2001 From: Pearce Kieser <5055971+Pearcekieser@users.noreply.github.com> Date: Sun, 27 Sep 2026 08:46:33 +0000 Subject: [PATCH] fix(dashboard): persist a turn-in-flight marker so a restart mid-turn shows Resume MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A gateway force exit during a turn runs no finally, so the transcript ends in user -> assistant(partial) -> tool rows with no error row. That tail is shape-identical to a finished answer, and the restore heuristic (is_turn_interrupted / selectTurnInterrupted) reads it as finished: the session comes back with no "Turn interrupted · Resume" treatment and the user has to notice and type "continue". _run_chat now writes the turn's generation to the slot-owned metadata key turn_in_flight_generation before provider dispatch and omits it at teardown. Absence is the clear. Admission is a metadata-only merge (the rows stay with the periodic flush, so what the prompt builder reads off disk is unchanged); only a transcript that does not exist yet takes the full forced save that creates it. Both are best-effort, like the queued-prompt copy: a failing disk never refuses the turn. The generation is bound before the save is awaited so a cancellation inside it still reaches the finally with something to retire. A landed turn retires the marker before its existing end-of-turn save, so the normal path pays no extra write; other exits pay one forced save. The marker is preserved when the process is shutting down and the turn has not landed, which covers both the hard CancelledError and the provider-side cancel a graceful shutdown produces. The marker also carries a copy of the row that opened the turn (turn_in_flight_prompt: role, content, cls, ts, and a meta reduced to mid, files, dirs, injectKind), the same way queued_prompts carries the queue. The row itself waits for the periodic flush, so a death inside that window loses it and a restore judging the tail would see the previous turn's ending instead. Every restore path appends the copy first when no row with its identity is in the window; the unanswered opener is then the interruption evidence and Resume replays the right prompt. The copy is validated field by field on the way back in and cleared with the generation. Nothing is written for a restricted session (memory_mode other than persistent): the transcript save honours that retention mode, so a marker there could never be cleared and the prompt copy would outlive the session. Admission skips the marker in memory and on disk, and such a session restores exactly as before. Every restore path reconciles a leftover marker after the window is built: startup rehydration, recent-session restore, the shared resume/import materialiser, and channel surfacing. If the transcript already proves the interruption nothing is added; a deliberate trailing Stop card wins; otherwise one error row (meta.kind=gateway_restart_interruption) is appended past the window boundary so the classifier, composer and sidebar agree. Malformed values (booleans, strings, non-positive) are ignored, and the decision is idempotent across repeated restarts. The resume materialiser now carries a row's persisted cls like the startup restores do, so a resumed Stop card keeps its discriminator. Backend and frontend classifiers both treat an inject row stamped with a dispatching meta.injectKind (cron, recovery, user_replay, synthesis) as a turn opener, so an older Stop cannot mask a newer interrupted queued/recovery/synthesis turn; untagged inject rows (notes, Stop-hook halt cards, refusal notices) dispatched nothing and are looked through. --- src/kiro_crew/dashboard/channel_slots.py | 12 + src/kiro_crew/dashboard/chat_handlers.py | 26 +- src/kiro_crew/dashboard/chat_persistence.py | 258 ++- src/kiro_crew/dashboard/chat_runner.py | 264 +++- src/kiro_crew/dashboard/state.py | 67 +- src/kiro_crew/history.py | 11 + .../restart-interruption-inject-turn.png | Bin 0 -> 93762 bytes .../restart-interruption-row.png | Bin 0 -> 96607 bytes .../restart-lost-opener-restored.png | Bin 0 -> 91650 bytes test/test_channel_slots.py | 24 + test/test_dashboard_chat.py | 126 +- test/test_is_interrupted.py | 74 + test/test_local_turn_restart_marker.py | 1404 +++++++++++++++++ test/test_to_dict_board_fields.py | 23 + website/src/store/chatSlice.ts | 45 +- website/src/test/ChatSliceCoverage.test.tsx | 35 + .../src/test/chatSlice.continuable.test.ts | 36 +- 17 files changed, 2387 insertions(+), 18 deletions(-) create mode 100644 temp-screenshots/restart-interruption/restart-interruption-inject-turn.png create mode 100644 temp-screenshots/restart-interruption/restart-interruption-row.png create mode 100644 temp-screenshots/restart-interruption/restart-lost-opener-restored.png create mode 100644 test/test_local_turn_restart_marker.py diff --git a/src/kiro_crew/dashboard/channel_slots.py b/src/kiro_crew/dashboard/channel_slots.py index 3178d8276dbc..926d18beddaf 100644 --- a/src/kiro_crew/dashboard/channel_slots.py +++ b/src/kiro_crew/dashboard/channel_slots.py @@ -670,6 +670,18 @@ def surface_channel_session( # the frozen prefix a save never rewrites, and redact assistant content at # the read boundary. _rebuild_window(slot, messages) + # Channel transcripts bypass both dashboard restore drivers, so the local-turn + # marker a dashboard turn on this slot left behind is reconciled here, once + # the whole window exists. Local import: chat_persistence imports this module. + from kiro_crew.dashboard.chat_persistence import ( + _local_turn_generation, + _local_turn_prompt, + _reconcile_local_turn_marker, + ) + + _reconcile_local_turn_marker( + slot, _local_turn_generation(meta), _local_turn_prompt(meta), persisted=messages + ) # The window corresponds to the file as of this listing, so the refresh pass # has nothing to do until the channel writes again. slot._channel_window_mtime = float(session_info.get("modified", 0) or 0) diff --git a/src/kiro_crew/dashboard/chat_handlers.py b/src/kiro_crew/dashboard/chat_handlers.py index 5f6c9309cd0f..689db226a111 100644 --- a/src/kiro_crew/dashboard/chat_handlers.py +++ b/src/kiro_crew/dashboard/chat_handlers.py @@ -72,6 +72,9 @@ _TRANSIENT_ROLES, COLOR_HEX_RE, _attach_variants, + _local_turn_generation, + _local_turn_prompt, + _reconcile_local_turn_marker, _rehydrate_slot_title, _remember_reasoning_effort_for_restore, _restored_agent_name, @@ -11873,7 +11876,12 @@ def _hydrate_slot_from_history( # by variant count). for m in messages: role = m.get("role", "assistant") - cls = "msg msg-u" if role == "user" else "msg msg-a" + # Carry the persisted ``cls`` like the startup restore paths do: a Stop + # card's discriminator lives only in that JSON string (see + # ``is_stop_event_row``), so a resumed session dropping it reads the + # user's deliberate Stop as an interrupted turn. Import rows carry none + # and fall through to the role default as before. + cls = m.get("cls") or ("msg msg-u" if role == "user" else "msg msg-a") content = m.get("content", "") slot.append( role, @@ -11896,6 +11904,12 @@ def _hydrate_slot_from_history( # _disk_older_count above) are the frozen prefix saves never rewrite, # so older on-disk turns are preserved. slot._disk_window_len = len(slot.messages) + # After the window boundary, like the startup restore: a local turn the + # previous process admitted and never tore down becomes the interruption + # row here, so a session pulled up off disk and one restored at boot agree. + _reconcile_local_turn_marker( + slot, _local_turn_generation(meta), _local_turn_prompt(meta), persisted=all_messages + ) async def api_chat_slot_resume(request: web.Request) -> web.Response: @@ -12297,7 +12311,10 @@ async def api_chat_slot_resume(request: web.Request) -> web.Response: # Restore the protected choice read before construction, not the # editable transcript's provisional agent name. slot.agent = restored_agent - total = len(all_messages) + # Hydrated length, not the raw disk count: materialisation may append one + # unsaved interruption row, and the paging cursor below has to account for + # it or the next older page repeats a row. + total = slot._disk_older_count + len(slot.messages) recent = slot.messages[-200:] if len(slot.messages) > 200 else slot.messages # The slot was registered throughout hydration (so a concurrent same-key # resume resolved it and hit the idempotency guard) but hidden from the @@ -12311,8 +12328,9 @@ async def api_chat_slot_resume(request: web.Request) -> web.Response: { "ok": True, "key": slot.key, - # `total` is the full on-disk length here, so this already is the - # raw index the next older page starts from. + # `total` is the effective hydrated length (durable rows plus a + # recovered interruption row when one was appended), so this is + # the raw index the next older page starts from. "next_before": total - len(recent), "messages": _prepare_messages( recent, diff --git a/src/kiro_crew/dashboard/chat_persistence.py b/src/kiro_crew/dashboard/chat_persistence.py index ed6c99f8af5f..80415d73e8e2 100644 --- a/src/kiro_crew/dashboard/chat_persistence.py +++ b/src/kiro_crew/dashboard/chat_persistence.py @@ -34,6 +34,7 @@ config_dir, ) from kiro_crew.dashboard.channel_slots import slot_closed_since +from kiro_crew.dashboard.chat_delivery import ATTACHMENT_LIST_MAX_ITEMS, ATTACHMENT_PATH_MAX_LEN from kiro_crew.dashboard.chat_utils import ( _normalize_model, _redact_meta_for_role, @@ -65,6 +66,8 @@ _normalize_slot_key, _note_authorized_elsewhere, durable_row_count, + is_stop_event_row, + is_turn_interrupted, row_mid, ) from kiro_crew.effort import EFFORT_LEVELS, EFFORT_VALUES @@ -123,6 +126,232 @@ # the persistence module's load path). _TITLE_ORIGINS = ("auto", "user") +_RESTART_INTERRUPTION_KIND = "gateway_restart_interruption" +# "app", not "gateway": the sibling relay-interruption row in +# ``_rehydrate_slot_from_history`` names the same event the same way, and the +# process name means nothing to the person reading the transcript. +_RESTART_INTERRUPTION_MSG = ( + "This turn was interrupted when the app restarted. " + "Review the partial output above, then resume to continue." +) + + +def _local_turn_generation(meta: Mapping[str, object]) -> int: + """The persisted local-turn generation, or zero when none is recorded. + + ``bool`` is an ``int`` subclass, so it is refused explicitly: the metadata + line is an ordinary writable file, and a malformed or hand-edited value + must never manufacture an interruption row. + """ + stored = meta.get("turn_in_flight_generation") + return stored if type(stored) is int and stored > 0 else 0 + + +_LOCAL_TURN_PROMPT_ROLES = frozenset({"user", "nudge", "inject"}) +_LOCAL_TURN_PROMPT_META_KEYS = ("mid", "files", "dirs", "injectKind") +#: Bounds on the opening-row copy the marker retains. The attachment bounds are +#: the send path's own (``chat_delivery.ATTACHMENT_LIST_MAX_ITEMS`` entries of +#: ``ATTACHMENT_PATH_MAX_LEN`` chars), so every row the send path accepts fits +#: the copy and a narrower local bound cannot drop an accepted opener. The +#: total is sized for ``MAX_PROMPT_BYTES`` (100 KB) plus two full attachment +#: lists plus the identity fields, so it only rejects a line that no writer of +#: this gateway produced. An out-of-bounds copy is dropped whole, never +#: truncated: the restore re-appends it as the user's own transcript row, and a +#: shortened row would misstate what they sent. A dropped copy leaves the +#: generation alone to flag the turn. +_LOCAL_TURN_PROMPT_MAX_ATTACHMENTS = ATTACHMENT_LIST_MAX_ITEMS +_LOCAL_TURN_PROMPT_MAX_FIELD_CHARS = ATTACHMENT_PATH_MAX_LEN +_LOCAL_TURN_PROMPT_MAX_BYTES = 128 * 1024 + 2 * ATTACHMENT_LIST_MAX_ITEMS * ( + ATTACHMENT_PATH_MAX_LEN + 4 +) + + +def local_turn_prompt_within_bounds(prompt: Mapping[str, object]) -> bool: + """Whether an opening-row copy fits the bounds the marker retains. + + Checked at retention (``_local_turn_opening_row``) so an oversize copy is + never written, and again at restore (:func:`_local_turn_prompt`) because + the metadata line is a writable file. ``content`` is bounded only through + the serialized total; ``ts``, ``mid``, ``injectKind`` and each + attachment path are bounded per field, and the attachment lists per count. + """ + ts = prompt.get("ts") + if isinstance(ts, str) and len(ts) > _LOCAL_TURN_PROMPT_MAX_FIELD_CHARS: + return False + meta = prompt.get("meta") + if isinstance(meta, Mapping): + for key in ("mid", "injectKind"): + value = meta.get(key) + if isinstance(value, str) and len(value) > _LOCAL_TURN_PROMPT_MAX_FIELD_CHARS: + return False + for key in ("files", "dirs"): + value = meta.get(key) + if isinstance(value, list): + if len(value) > _LOCAL_TURN_PROMPT_MAX_ATTACHMENTS: + return False + if any( + isinstance(item, str) and len(item) > _LOCAL_TURN_PROMPT_MAX_FIELD_CHARS + for item in value + ): + return False + try: + size = len(json.dumps(prompt, ensure_ascii=False, separators=(",", ":"))) + except (TypeError, ValueError): + return False + return size <= _LOCAL_TURN_PROMPT_MAX_BYTES + + +def _local_turn_prompt(meta: Mapping[str, object]) -> dict | None: + """The persisted copy of the in-flight turn's opening row, validated. + + Same trust boundary as :func:`_local_turn_generation`: the line is an + ordinary writable file, so every field is re-checked rather than trusted. + A copy that is not a dict, names a role that never opens a turn, or has + no content is dropped. ``meta`` is reduced to the row's identity, its + attachment lists and the inject kind; a restored row must not arrive + wearing a flag that changes what a later reader does with it. + """ + stored = meta.get("turn_in_flight_prompt") + if not isinstance(stored, dict) or not local_turn_prompt_within_bounds(stored): + return None + role = stored.get("role") + content = stored.get("content") + if role not in _LOCAL_TURN_PROMPT_ROLES or not isinstance(content, str) or not content: + return None + raw_meta = stored.get("meta") + kept_meta: dict = {} + if isinstance(raw_meta, dict): + mid = raw_meta.get("mid") + if isinstance(mid, str) and mid: + kept_meta["mid"] = mid + for key in ("files", "dirs"): + value = raw_meta.get(key) + if isinstance(value, list) and all(isinstance(item, str) for item in value): + kept_meta[key] = list(value) + kind = raw_meta.get("injectKind") + if isinstance(kind, str) and kind: + kept_meta["injectKind"] = kind + ts = stored.get("ts") + # No ``cls`` is read: the transcript never persists one for these roles, + # and a JSON ``cls`` on the re-appended row would be parsed into ``meta`` + # on emit, over the identity this copy exists to carry. + return { + "role": role, + "content": content, + "ts": ts if isinstance(ts, str) else "", + "meta": kept_meta, + } + + +def _window_holds_row( + messages: Iterable[Mapping[str, object]], prompt: Mapping[str, object] +) -> bool: + """Whether *messages* (a window or the whole on-disk list) holds the marker's opening row. + + Matched by ``mid`` when the copy has one, which is the identity every + other dual-writer uses; a copy without an id falls back to the row's + ordering ``ts`` plus role, the pair ``_ChatSlot.append`` makes unique + within one transcript. + """ + meta = prompt.get("meta") + mid = meta.get("mid") if isinstance(meta, dict) else None + ts = prompt.get("ts") + for row in messages: + row_meta = row.get("meta") + if mid and isinstance(row_meta, dict) and row_meta.get("mid") == mid: + return True + if not mid and ts and row.get("ts") == ts and row.get("role") == prompt.get("role"): + return True + return False + + +def _latest_turn_was_deliberately_stopped(messages: list[dict]) -> bool: + """Whether the newest turn ends in the user's own Stop card. + + Same tail walk as :func:`state.is_turn_interrupted`: tool, notice and + status rows are looked through, and the newest stop or conversational row + decides. Read only when a local-turn marker outlived its process. The stop + handler cancels the runner, and a shutdown landing in that same instant can + leave the marker on disk, so the Stop card -- the user's recorded intent -- + must win over a restart-interruption row. + """ + for message in reversed(messages): + if is_stop_event_row(message): + return True + if message.get("role") in ("user", "assistant") and message.get("content"): + return False + return False + + +def _reconcile_local_turn_marker( + slot: _ChatSlot, + generation: int, + prompt: Mapping[str, object] | None = None, + *, + persisted: Iterable[Mapping[str, object]] | None = None, +) -> bool: + """Turn a local-turn marker that outlived its process into the interruption row. + + Returns whether a marker was present, so the startup restore can avoid + layering the remote-relay notice on top of metadata that claims both kinds + of execution. Call it only after the whole window is loaded and + ``_disk_window_len`` is set: rows are appended past that boundary so the + next save writes them rather than counting them as already on disk. + + The marker says a turn was admitted and never reached teardown, which the + transcript alone cannot show -- partial assistant prose followed by + finished tool rows is shape-identical to a clean answer. Rows ride the + periodic flush, so the opening row itself may be missing: when the marker + carries a copy (*prompt*) and no row with its identity is on disk, the + copy is appended first. *persisted* is EVERY on-disk row of the session, + not the loaded window: a long turn can push its own opener past the + window bound into the frozen prefix, and a check against the window alone + would append a duplicate that the next save then writes for good. Callers + that hold only the window pass nothing and the window is searched. Only + then is the tail judged: when the transcript already proves the + interruption (an unanswered user row, a trailing error) no second row is + needed; when the newest turn ends in the user's own Stop card, that intent + wins. Otherwise one ``error`` row lands at the tail so the classifier, + composer and sidebar agree. + + Every window save rewrites the window from its first row, so a lost + opener implies every row after it is lost too and the tail is where it + belongs. The runtime marker starts clear and the slot is marked dirty even + when no row was appended, so the next save omits the slot-owned keys. A + second restart before that save re-runs this decision from the same bytes + and cannot accumulate rows. + """ + if generation <= 0: + return False + if prompt is not None and not _window_holds_row( + slot.messages if persisted is None else persisted, prompt + ): + prompt_meta = prompt.get("meta") + role = str(prompt["role"]) + slot.append( + role, + str(prompt["content"]), + # The loader's own default for a row whose ``cls`` is not on disk. + "msg msg-u" if role == "user" else "msg msg-a", + str(prompt.get("ts") or ""), + broadcast=False, + meta=dict(prompt_meta) if isinstance(prompt_meta, dict) and prompt_meta else None, + ) + if not is_turn_interrupted(slot.messages) and not _latest_turn_was_deliberately_stopped( + slot.messages + ): + slot.append( + "error", + _RESTART_INTERRUPTION_MSG, + "msg msg-err", + broadcast=False, + meta={"kind": _RESTART_INTERRUPTION_KIND}, + ) + slot._turn_in_flight_generation = 0 + slot._turn_in_flight_prompt = None + slot._dirty = True + return True + def _rehydrate_title_origin(titled: bool, stored: object) -> str: """Resolve a rehydrated slot's title origin from persisted metadata. @@ -1713,6 +1942,8 @@ def _rehydrate_slot_from_history( # not slot.is_remote`` -> 409 ``remote_binding_incomplete``) plus the # ``_run_chat`` chokepoint (keyed on ``executor``, not ``is_remote``) refuse # the send with a message the user can act on, rather than run local. + _local_turn_was_in_flight = _local_turn_generation(meta) + _local_turn_prompt_copy = _local_turn_prompt(meta) _relay_was_in_flight = False _executor_meta = meta.get("executor") _instance_meta = meta.get("instance_id") @@ -1977,7 +2208,14 @@ def _rehydrate_slot_from_history( # turns counted above) is never rewritten. slot._disk_window_len = len(slot.messages) slot._dirty = False - if _relay_was_in_flight: + # A local turn admitted by the previous process and never torn down. + # Placed with the relay notice below for the same window-boundary + # reasons; when both markers are present the metadata is inconsistent + # (a slot runs locally OR on a peer), and one row is enough. + _had_local_turn_marker = _reconcile_local_turn_marker( + slot, _local_turn_was_in_flight, _local_turn_prompt_copy, persisted=messages + ) + if _relay_was_in_flight and not _had_local_turn_marker: # The gateway crashed while this slot's turn was executing on the peer # (flagged in the binding block above). The relay reader died with it # and the turn's tail was never mirrored here, so the loaded window @@ -2513,6 +2751,9 @@ def _apply_recent_session( # _disk_older_count above) are the frozen prefix saves never rewrite. slot._disk_window_len = len(slot.messages) slot._dirty = False + _reconcile_local_turn_marker( + slot, _local_turn_generation(meta), _local_turn_prompt(meta), persisted=messages + ) logger.info("Restored session %s (%s)", slot_name, slot.title) @@ -4056,6 +4297,14 @@ def _fresh_fields(meta: dict) -> dict: fields["channel_origin"] = True if slot.forked_from is not None: fields["forked_from"] = slot.forked_from + # CLEARABLE: the merge cannot delete a key and rehydrate reads + # zero as "no local turn outstanding", so the current value is + # written either way -- a forced save after a turn's teardown + # must not leave the admitted generation on disk. + fields["turn_in_flight_generation"] = slot._turn_in_flight_generation + # Same rule for the opening-row copy: None is the cleared value + # (rehydrate reads anything but a dict as "no copy"). + fields["turn_in_flight_prompt"] = slot._turn_in_flight_prompt if slot.executor == "remote" and slot.instance_id and slot.remote_slot: # All three or none, exactly like the full save: a newborn # bound to a peer has an EMPTY window until the first relayed @@ -4506,6 +4755,13 @@ def _refresh_under_lock(meta: dict) -> bool: # in-flight, so a True read back on reload is the crash signal # that triggers the interrupted-turn row. meta_line["relay_in_flight"] = True + if slot._turn_in_flight_generation > 0: + # Written while a local turn is between admission and teardown + # and omitted otherwise; ``SLOT_OWNED_META_KEYS`` makes that + # omission the durable clear. + meta_line["turn_in_flight_generation"] = slot._turn_in_flight_generation + if slot._turn_in_flight_prompt is not None: + meta_line["turn_in_flight_prompt"] = slot._turn_in_flight_prompt if slot.folder_id: meta_line["folder_id"] = slot.folder_id if slot._channel_folder_filed or existing_meta.get("channel_folder_filed"): diff --git a/src/kiro_crew/dashboard/chat_runner.py b/src/kiro_crew/dashboard/chat_runner.py index 2c8df57fc079..69540716115e 100644 --- a/src/kiro_crew/dashboard/chat_runner.py +++ b/src/kiro_crew/dashboard/chat_runner.py @@ -3,6 +3,7 @@ from __future__ import annotations import asyncio +import functools import hashlib import inspect import json @@ -21,6 +22,7 @@ model_registry, resource_status, session_directive, + shutdown_event, ) from kiro_crew.acp.client import ( AcpAuthRequired, @@ -111,7 +113,11 @@ _resolve_folder_steering_dirs, slot_steering_principal, ) -from kiro_crew.dashboard.chat_persistence import save_slot_off_loop +from kiro_crew.dashboard.chat_persistence import ( + local_turn_prompt_within_bounds, + register_guarded_history_write, + save_slot_off_loop, +) from kiro_crew.dashboard.chat_summary import generate_session_summary from kiro_crew.dashboard.chat_tag_grants import refresh_cache as refresh_tag_grants_cache from kiro_crew.dashboard.chat_tags import resolve_board_tags @@ -155,6 +161,7 @@ parse_workflow_command, remember_slack_options, restore_replacement_if_handover_did_not_land, + run_to_completion, slack_mirror_is_paused, slot_history_key, tighten_live_slot_memory_mode, @@ -209,6 +216,7 @@ CrewLogPrevious, DashboardState, _ChatSlot, + _is_turn_inject, _mark_permission_resolved, append_and_surface, build_infra_retry_prompt, @@ -9287,6 +9295,226 @@ class _AppAgentNotLoaded(Exception): """ +def _local_turn_generation_for(slot: _ChatSlot) -> int: + """The generation the marker for this dispatch is written under. + + ``slot.task`` is installed before ``_run_chat`` gets its first loop step, so + ``_turn_generation`` already names this exact dispatch. Read into a local + BEFORE the marker save is awaited: a cancellation landing inside that await + (a tab close) must still leave the finally a generation it can retire, or + the save commits after the cancel and nothing ever clears it. + """ + return max(1, slot._turn_generation) + + +# Keys of the opening row copied into the marker: the row's identity, its +# attachment lists and, for an inject, the kind that makes the classifier +# count it as a turn opener. Everything else about the row is recomputed by +# ``_ChatSlot.append`` or belongs to the process that wrote it. +_LOCAL_TURN_PROMPT_META_KEYS = ("mid", "files", "dirs", "injectKind") +#: Roles whose row opens a turn by itself. ``inject`` opens one only with a +#: dispatching ``injectKind`` (``_is_turn_inject``). Mirrors +#: ``_LOCAL_TURN_PROMPT_ROLES`` in ``chat_persistence.py`` minus ``inject``. +_LOCAL_TURN_OPENER_ROLES = frozenset({"user", "nudge"}) + + +def _local_turn_opening_row(slot: _ChatSlot) -> "dict[str, Any] | None": + """A durable copy of the row that opened the turn being admitted. + + Walks back from the window tail to the newest row that opens a turn: a + ``user`` row, a ``nudge`` row (a monitor loop's cycle, which always + dispatches) or a dispatching ``inject`` (``_is_turn_inject``). Stops at + the first conversational assistant row, since a turn whose opener already + has an answer is not the one being admitted. Returns ``None`` when the + window holds no such row (a slot whose opener was consumed by an earlier + save-and-trim, or a test stub with an empty window). + + The copy carries what ``_ChatSlot.append`` needs to re-create the row as + the loader would: role, content, the ordering ``ts`` and the identity + ``mid`` plus the attachment lists. It does NOT carry the + generation, the turn actor or any directive flag -- the restored row is a + transcript row again, not an admission. A copy outside + ``local_turn_prompt_within_bounds`` (serialized size, attachment count, + per-field length) is not carried at all. + """ + for row in reversed(slot.messages): + role = row.get("role") + if role == "assistant" and row.get("content"): + return None + meta = row.get("meta") + if role in _LOCAL_TURN_OPENER_ROLES or (role == "inject" and _is_turn_inject(meta)): + kept_meta = { + key: meta[key] + for key in _LOCAL_TURN_PROMPT_META_KEYS + if isinstance(meta, dict) and key in meta + } + # No ``cls``: the transcript never persists one for a ``user`` or + # ``inject`` row, and a cron inject's in-memory ``cls`` is JSON that + # the emit path would parse into ``meta`` over the row's real + # ``mid`` / ``injectKind``. The restore assigns the loader's default. + copy = { + "role": role, + "content": str(row.get("content") or ""), + "ts": str(row.get("ts") or ""), + "meta": kept_meta, + } + # Bounded as a whole, never truncated: a shortened copy would come + # back as the user's own transcript row. Over the bound, the + # generation alone marks the turn. + return copy if local_turn_prompt_within_bounds(copy) else None + return None + + +async def _begin_local_turn_marker(state: DashboardState, slot: _ChatSlot, generation: int) -> None: + """Persist this turn's generation on the slot's metadata line before dispatch. + + The transcript cannot record a process death: a turn cut by a force exit + leaves partial assistant prose and finished tool rows, the same shape as a + clean answer, and the restore heuristic reads it as finished. Writing the + generation BEFORE any provider work begins means no output can outrun it, + and every restore path turns a leftover value into the interruption row. + + A metadata-only merge, not a window save: the rows stay with the periodic + flush, so admitting a turn changes nothing about what the prompt builder + reads off disk. Only a transcript that does not exist yet (a newborn slot's + first turn) takes the full forced save, which is the one writer that can + create it. Both writes are awaited to completion under cancellation, however + many times it is delivered (``run_to_completion``: a graceful shutdown + escalating after its timeout cancels the runner more than once), so the + teardown clear that follows a cancelled turn is always ordered after them. + Best-effort like the queue's own durable copy: a + failure leaves the value in memory for the next save and never refuses the + turn -- the marker is a recovery hint, not the user's words. + + Both writes are fenced to THIS slot incarnation. A tab closed mid-turn and + reopened under the same key (``close_slot`` pops the slot, then waits up to + 2 s for the cancelled runner) resumes the same transcript, so the routing + pin alone cannot tell the two apart; the merge's guard and the forced + save's ``expected_slot_name`` recheck ``state._slots`` under the owner lock + and refuse once the map holds a different object, so a cancelled runner + that outlives its replacement never writes over the replacement's line or + rebuilds the window over its rows. + A restricted session (``memory_mode`` other than ``persistent``) gets the + marker like any other: the transcript save writes every mode's rows and + records the strictest ``memory_mode`` it can see, so the teardown clear + lands and the restart reads the marker. The prompt copy on the metadata + line adds no exposure the transcript rows do not already have -- every + reader that learns gates on the line's ``memory_mode``. + """ + slot._turn_in_flight_generation = generation + # The opening row travels with the generation. The row itself waits for the + # periodic flush (an immediate window save would put it on disk before the + # prompt build, where the builder's recent-context projection would read + # the current prompt as history), so a death inside that window loses it + # and the restore would judge the previous turn's tail instead. With the + # copy on the metadata line the restore puts the row back first. + slot._turn_in_flight_prompt = _local_turn_opening_row(slot) + log = state.conversation_log + if log is None: + return + history_key = slot_history_key(slot) + slot_name = slot.key + # Both keys every time. The merge cannot delete a key, so a copy the + # previous turn's clear failed to remove would otherwise stay paired with + # this generation and come back as this turn's opener; ``None`` is the + # cleared value the restore reads as "no copy" (same rule as the merge + # save in ``_save_slot_to_history``). + marker_fields: dict[str, Any] = { + "turn_in_flight_generation": generation, + "turn_in_flight_prompt": slot._turn_in_flight_prompt, + } + + def _still_this_incarnation(_meta: dict) -> bool: + return state._slots.get(slot_name) is slot + + # Same fence and same registry as every truncating save. A close raises + # ``is_closing``, waits for the futures in ``_guarded_history_writes``, and + # only then pops the name; a write dispatched after the fence has nothing + # left to order against it, and a write not registered is invisible to the + # wait, so a close-and-same-key-reopen could land this line onto the + # replacement's transcript. Read the fence here with no suspension before + # the registration so the two interleavings are the only ones: fence first + # and this refuses, or registration first and the retraction waits. + if getattr(slot, "is_closing", False): + slot._dirty = True + return + merge = asyncio.get_running_loop().run_in_executor( + None, + functools.partial( + log.update_metadata_if, + history_key, + marker_fields, + _still_this_incarnation, + require_existing=True, + ), + ) + register_guarded_history_write(slot, merge) + try: + merged = await run_to_completion(merge) + except asyncio.CancelledError: + raise + except Exception: + logger.warning("Could not persist the turn marker for slot %s", slot.key, exc_info=True) + slot._dirty = True + return + if not merged and state._slots.get(slot_name) is slot: + await run_to_completion( + save_slot_off_loop( + state, + slot, + force=True, + expected_history_key=history_key, + expected_slot_name=slot_name, + ) + ) + + +def _retire_local_turn_marker(slot: _ChatSlot, generation: int) -> bool: + """Clear the in-memory marker for one turn without touching a successor's. + + Returns whether this call cleared it. A successor can be admitted in the + same slot before this turn's teardown finishes (the queue drain installs a + new task with its own generation), so only the generation that wrote the + marker may retire it. + """ + if generation <= 0 or slot._turn_in_flight_generation != generation: + return False + slot._turn_in_flight_generation = 0 + slot._turn_in_flight_prompt = None + return True + + +async def _clear_local_turn_marker(state: DashboardState, slot: _ChatSlot, generation: int) -> None: + """Durably clear one turn's marker on an exit that wrote no other save. + + The landed path retires the marker in memory right before its own transcript + save, so the omission rides that write. Every other exit -- an error card, + a Stop, a recovery re-queue -- reaches here and pays one forced save, since + a restart before the periodic flush would otherwise read the stale value + and flag a turn that ended in plain sight as interrupted. + """ + if not _retire_local_turn_marker(slot, generation): + return + # ``best_effort`` re-arms ``_dirty`` on failure so the flush retries the + # omission; until then a stale on-disk value fails safe to one extra + # recovery prompt rather than a missed interruption. The identity pins + # refuse the write when a same-key replacement now owns the transcript + # (see ``_begin_local_turn_marker``): the replacement's own saves carry + # its marker state, and the live window is the replacement's, not this one. + await save_slot_off_loop( + state, + slot, + force=True, + expected_history_key=slot_history_key(slot), + expected_slot_name=slot.key, + ) + + +def _gateway_shutdown_requested() -> bool: + """Whether the process is shutting down, read without retaining the event.""" + return shutdown_event.is_set() + + async def _run_chat( state: DashboardState, slot: _ChatSlot, @@ -10769,6 +10997,9 @@ def _wt_note_approved(event) -> None: # noqa: ANN001 -- ACP event union _mirror_thread: str | None = "" _mirror_task_counter = 0 _memory_preparation_admitted = False + # Zero until the marker below is written, so a cancellation that lands during + # startup admission has nothing to clear. + _local_turn_marker_generation = 0 # Bound before the try because cancellation may land while this turn waits # for shared memory preparation, before any provider is allocated. client: Any = None @@ -10807,6 +11038,15 @@ def _wt_note_approved(event) -> None: # noqa: ANN001 -- ACP event union if _prompt_depth == 0: await expire_slack_options(state, session_key) + # Durable "turn in flight" marker, written at the same boundary as the + # active-turn identity: every local command has returned, no provider + # work has begun. Not gated on ``_prompt_depth``: the expanded re-entry + # is the only call that reaches here for a /prompts mention. The + # generation is bound before the save is awaited so a cancellation + # inside it still reaches the finally with something to retire. + _local_turn_marker_generation = _local_turn_generation_for(slot) + await _begin_local_turn_marker(state, slot, _local_turn_marker_generation) + # Resolve agent bindings early so we pass the correct kiro-cli # agent name (e.g. "kirocrew") instead of the KiroCrew slot name # (e.g. "default") which has no matching ~/.kiro/agents/ config. @@ -17552,6 +17792,14 @@ def _emit_error(msg: str, *, will_retry: bool = False) -> None: ) # Attach accumulated file changes to last assistant message before persist _flush_file_changes(slot) + # The reply is in the window, so this save is the durable clear of + # the in-flight marker: retire it first and the omission rides the + # same write instead of costing a second one in the finally. Not + # for a provider-side cancel: a shutdown cancels the provider the + # same way, persists the partial reply as an ordinary row, and the + # finally's shutdown check must still see the marker to preserve it. + if _stop_reason != STOP_REASON_CANCELLED: + _retire_local_turn_marker(slot, _local_turn_marker_generation) # Save to history and trigger memory consolidation await save_slot_off_loop(state, slot) # Reset ALL retry budgets once the cycle completes (success OR the @@ -19589,6 +19837,20 @@ def _emit_error(msg: str, *, will_retry: bool = False) -> None: _unclaimed_markers, _identity_markers, ) + # Retire the in-flight marker once every transcript mutation is complete + # and the session permit above is released (an await here cannot skip + # that release), and only while the process is going to live on: during + # a shutdown the cancellation that ended this turn came from the process + # dying, which is exactly the interruption the marker exists to record -- + # the graceful save writes it and the next start converts it. A turn + # that landed inside the shutdown grace keeps its clear. Before the queue + # drain below, so the successor's own marker is never overtaken by this + # omission. Guarded so a failing save cannot skip the steer requeue. + if not (_gateway_shutdown_requested() and not _turn_landed): + try: + await _clear_local_turn_marker(state, slot, _local_turn_marker_generation) + except Exception: + logger.debug("_clear_local_turn_marker failed", exc_info=True) # End-of-turn fallback: catches set_project and reset_conversation calls # that fired mid-turn, after the start-of-turn consume already ran. This # is the ONLY caller that may consume a queued conversation discard — diff --git a/src/kiro_crew/dashboard/state.py b/src/kiro_crew/dashboard/state.py index fc280d84a539..2b6f2b5e1af4 100644 --- a/src/kiro_crew/dashboard/state.py +++ b/src/kiro_crew/dashboard/state.py @@ -994,13 +994,42 @@ def is_stop_event_row(m: dict) -> bool: return bool(parsed and parsed.get("kind") == "stop_event") +#: ``meta.injectKind`` values stamped on an ``inject`` row that DISPATCHED a +#: turn (the queue drain, the cron injectors, the synthesis kick-off, an app +#: message's delivery). Every other inject row -- a ``/note`` breadcrumb, a +#: Stop-hook halt card, a policy refusal notice -- is appended without one and +#: opens nothing. Mirrors ``TURN_INJECT_KINDS`` in +#: ``website/src/store/chatSlice.ts``, which is keyed by the ``InjectKind`` +#: type so a new kind cannot be stamped without being classified there. +#: Wider than ``_TURN_OPENING_INJECT_KINDS`` in ``chat_handlers.py`` on +#: purpose: that set counts turns for the session-start failure streak and +#: walks past ``recovery`` / ``user_replay`` because they resume the SAME +#: turn; here the question is whether a dispatch happened that got no reply, +#: and a recovery or replay dispatch that died is exactly such a turn. +_TURN_INJECT_KINDS: frozenset[str] = frozenset( + {"cron", "mcp_app", "recovery", "user_replay", "synthesis"} +) + + +def _is_turn_inject(meta: object) -> bool: + """Whether an ``inject`` row's meta says it dispatched a turn.""" + return isinstance(meta, dict) and meta.get("injectKind") in _TURN_INJECT_KINDS + + def is_turn_interrupted(messages: list[dict]) -> bool: """True when the transcript shows a turn that ended without a reply. - Two shapes qualify: the last conversational row is the USER's (nothing came - back at all — a gateway restart mid-turn leaves exactly this), or it is the + Two shapes qualify: the last turn-opening row is the USER's, a monitor + loop's NUDGE, or a runner-authored INJECT's (nothing came back at all — a gateway restart + mid-turn leaves exactly this), or the last conversational row is the ASSISTANT's but an error row follows it (the turn streamed partway then died, - which is otherwise shape-identical to a clean completion). + which is otherwise shape-identical to a clean completion). An inject counts + as an opener only when it carries a dispatching ``meta.injectKind`` (see + ``_TURN_INJECT_KINDS``): a queued continuation, a recovery or a synthesis + turn IS a turn, and without it the scan walks past an interrupted one and + can reach the previous turn's Stop card, which then hides the newer + interruption. An untagged inject -- a ``/note`` breadcrumb, a Stop-hook halt + card, a refusal notice -- dispatched nothing and is looked through. Two shapes are explicitly excluded. A trailing ``stop_event``: the user pressing Stop is a deliberate ending, not an interruption, and stopping @@ -1042,7 +1071,8 @@ def is_turn_interrupted(messages: list[dict]) -> bool: # "the gateway died before anything came back". See ``is_stop_event_row`` # for why the discriminator has to be resolved from three carriers. # Only the NEWEST turn's terminator reaches here -- an older stop card - # is never scanned, because a later user/assistant row returns first. + # is never scanned, because a later user/inject/assistant row returns + # first. if is_stop_event_row(m): return False if is_system_notice(role, meta): @@ -1061,6 +1091,12 @@ def is_turn_interrupted(messages: list[dict]) -> bool: ): saw_compaction_result = True continue + if role == "inject" and m.get("content") and _is_turn_inject(meta): + return True + # A monitor loop's cycle row always dispatches a turn; unanswered, it + # is the same shape as an unanswered user row. + if role == "nudge" and m.get("content"): + return True if role in ("user", "assistant") and m.get("content"): if role != "user": return saw_trailing_error @@ -1079,7 +1115,12 @@ def is_turn_interrupted(messages: list[dict]) -> bool: return True if role == "error": saw_trailing_error = True - return False + # The walk ran off the start of the window without meeting a conversational + # row: a long turn can push its own opener and reply into the frozen prefix, + # leaving only tool rows here. A trailing error row is still the evidence + # the assistant branch above honors -- the turn ended in it and nothing + # newer proves completion -- so it decides the same way. + return saw_trailing_error def _mark_permission_resolved( @@ -2651,6 +2692,8 @@ class _ChatSlot: "instance_id", "remote_slot", "_relay_in_flight", + "_turn_in_flight_generation", + "_turn_in_flight_prompt", "_active_turn_session_key", "_side", "_acp_client", @@ -2801,6 +2844,20 @@ def __init__( # and rehydration appends an "interrupted" row rather than leaving the # transcript silently stopped. Set/cleared in ``remote_relay.relay_remote_turn``. self._relay_in_flight: bool = False + # Generation of the LOCAL turn ``chat_runner._run_chat`` durably admitted; + # zero when no local turn is outstanding. Persisted on the metadata line + # before provider dispatch and omitted after teardown, so a process that + # dies mid-turn leaves it on disk and every restore path converts it into + # the interruption row the transcript shape alone cannot prove -- partial + # assistant text followed by completed tool rows and no error row looks + # exactly like a finished answer once the process is gone. + self._turn_in_flight_generation: int = 0 + # The row that opened the in-flight turn, persisted beside the + # generation. The row itself rides the periodic flush, so a process + # death inside that window loses it; the copy here lets the restore + # put it back before the interruption is judged. None when no turn is + # in flight. + self._turn_in_flight_prompt: dict[str, Any] | None = None self.created_at: str = datetime.now(timezone.utc).isoformat() self.messages: list[dict[str, Any]] = [] self._buffers = SlotBufferCoordinator() diff --git a/src/kiro_crew/history.py b/src/kiro_crew/history.py index 40c5d36860cf..35ecf32ba890 100644 --- a/src/kiro_crew/history.py +++ b/src/kiro_crew/history.py @@ -212,6 +212,17 @@ # written at relay start is carried forward past a clean completion, so # every later restart would append a false "interrupted" row. "relay_in_flight", + # Local-turn crash marker: the generation of the turn ``_run_chat`` + # admitted, written before provider dispatch and omitted once the turn + # reaches teardown. Owned for the same reason as ``relay_in_flight``: + # absence IS the clear, so a carried-forward value would flag every + # later restart as interrupted after one clean completion. + "turn_in_flight_generation", + # The row that opened that turn (role, content, cls, ts, meta), carried + # with the generation so a restart inside the periodic flush window + # can put the prompt back before flagging the interruption. Cleared by + # omission alongside the generation. + "turn_in_flight_prompt", "folder_id", "app", "artifact", diff --git a/temp-screenshots/restart-interruption/restart-interruption-inject-turn.png b/temp-screenshots/restart-interruption/restart-interruption-inject-turn.png new file mode 100644 index 0000000000000000000000000000000000000000..491e6f60bf5385f2ef74a17d0513ee277d3edbac GIT binary patch literal 93762 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

k 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 literal 0 HcmV?d00001 diff --git a/temp-screenshots/restart-interruption/restart-interruption-row.png b/temp-screenshots/restart-interruption/restart-interruption-row.png new file mode 100644 index 0000000000000000000000000000000000000000..9ca59905f026619356ca9543be562db1e390e29c GIT binary patch literal 96607 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 literal 0 HcmV?d00001 diff --git a/test/test_channel_slots.py b/test/test_channel_slots.py index c7424ef65033..b8d4cb7a41fa 100644 --- a/test/test_channel_slots.py +++ b/test/test_channel_slots.py @@ -398,6 +398,30 @@ def test_a_slot_without_channel_provenance_is_never_rebound(self, dashboard_stat impostor.linked_session_key == "" ), "a slot with no channel provenance was bound to a channel conversation" + def test_reconciles_an_interrupted_local_turn_marker(self, dashboard_state: Any) -> None: + """A dashboard turn on a channel-surfaced slot leaves its in-flight marker + on the channel transcript's metadata line; surfacing is that slot's only + restore path, so it converts a leftover marker like the dashboard ones.""" + slot = channel_slots.surface_channel_session( + dashboard_state, + _session("slack:1.1", title="Interrupted channel turn"), + {"turn_in_flight_generation": 17}, + [ + {"role": "user", "content": "inspect it"}, + {"role": "assistant", "content": "partial result"}, + {"role": "tool", "content": "read complete", "meta": {"done": True}}, + ], + session_key="slack:1.1", + ) + + assert slot is not None + assert slot.to_dict()["interrupted"] is True + assert slot.messages[-1]["meta"]["kind"] == "gateway_restart_interruption" + assert slot._turn_in_flight_generation == 0 + assert slot._dirty is True + # Past the window boundary, so the next save writes the row. + assert slot._disk_window_len == len(slot.messages) - 1 + def test_an_unresolvable_session_key_surfaces_the_slot_unbound( self, dashboard_state: Any ) -> None: diff --git a/test/test_dashboard_chat.py b/test/test_dashboard_chat.py index dca305561496..9dfc02e0af39 100644 --- a/test/test_dashboard_chat.py +++ b/test/test_dashboard_chat.py @@ -20184,8 +20184,20 @@ def spy(self_slot, *a, **kw): notice_msgs = [m for m in slot.messages if m.get("role") == "notice"] assert not any("returned nothing this turn" in m.get("content", "") for m in notice_msgs) # Re-queue path must NOT persist/consolidate the spurious empty turn or - # record success (item 3 of the CR). - mock_save.assert_not_called() + # record success (item 3 of the CR). The only saves are the in-flight + # marker's: this slot has no transcript yet, so admission falls back to + # the forced save that creates it, and the finally clears the marker + # with a second one before the queued retry receives its own generation. + assert mock_save.await_count == 2 + for marker_save in mock_save.await_args_list: + assert marker_save.args == (state, slot) + # Both marker saves are pinned to this slot incarnation so a + # cancelled runner outliving a same-key replacement writes nothing. + assert marker_save.kwargs == { + "force": True, + "expected_history_key": "dashboard:empty-resp-slot", + "expected_slot_name": "empty-resp-slot", + } mock_consolidate.assert_not_called() state.sessions.record_success.assert_not_called() # _flush_file_changes is intentionally NOT skipped: the try-body call (inside @@ -25535,3 +25547,113 @@ def test_trailing_owed_rows_survive_the_idless_tail_filter(self): "stopped", "partial an", ], f"the owed chunk must keep its trailing window position; got {bodies}" + + +class TestHistoryResumeInterruptedTurnMarker: + """The History resume endpoint shares the startup restore's marker handling.""" + + @staticmethod + def _saved_state(tmp_path, monkeypatch, name: str, rows: list[tuple], generation: int): + from kiro_crew.dashboard.chat_persistence import _save_slot_to_history + + monkeypatch.setattr("kiro_crew.dashboard.state.config_dir", lambda: tmp_path) + state = _make_state(tmp_path) + slot = state.get_or_create_slot(name) + for row in rows: + slot.append(*row[:3], meta=row[3] if len(row) > 3 else None) + slot._turn_in_flight_generation = generation + assert _save_slot_to_history(state, slot, force=True) + del state._slots[slot.key] + return state + + @pytest.mark.asyncio + async def test_resume_reconciles_partial_assistant_and_tool_tail(self, tmp_path, monkeypatch): + state = self._saved_state( + tmp_path, + monkeypatch, + "resume-interrupted", + [ + ("user", "inspect it", "msg msg-u"), + ("assistant", "partial result", "msg msg-a"), + ("tool", "read complete", "tool", {"done": True}), + ], + generation=18, + ) + + async with TestClient(TestServer(_make_app(state))) as client: + response = await client.post( + "/api/chat/slots/resume-interrupted/resume", + json={"key": "dashboard:resume-interrupted"}, + ) + payload = await response.json() + + assert response.status == 200 + restored = state.get_slot("resume-interrupted") + assert restored is not None + assert restored.to_dict()["interrupted"] is True + assert restored.messages[-1]["meta"]["kind"] == "gateway_restart_interruption" + # The paging cursor counts the recovered row, so the next older page + # starts where this response's rows end. + assert payload["total"] == 4 + assert payload["messages"][-1]["role"] == "error" + assert payload["next_before"] == 0 + assert payload["has_more"] is False + + @pytest.mark.asyncio + async def test_resume_preserves_a_deliberate_stop(self, tmp_path, monkeypatch): + state = self._saved_state( + tmp_path, + monkeypatch, + "resume-stopped", + [ + ("user", "inspect it", "msg msg-u"), + ("system", "Stopped", json.dumps({"kind": "stop_event"})), + ], + generation=19, + ) + + async with TestClient(TestServer(_make_app(state))) as client: + response = await client.post( + "/api/chat/slots/resume-stopped/resume", + json={"key": "dashboard:resume-stopped"}, + ) + payload = await response.json() + + assert response.status == 200 + restored = state.get_slot("resume-stopped") + assert restored is not None + assert restored.to_dict()["interrupted"] is False + assert all( + (m.get("meta") or {}).get("kind") != "gateway_restart_interruption" + for m in restored.messages + ) + assert payload["total"] == 2 + + @pytest.mark.asyncio + async def test_resume_ignores_a_malformed_boolean_marker(self, tmp_path, monkeypatch): + state = self._saved_state( + tmp_path, + monkeypatch, + "resume-malformed", + [("user", "hi", "msg msg-u"), ("assistant", "complete", "msg msg-a")], + generation=0, + ) + assert state.conversation_log is not None + state.conversation_log.update_metadata( + "dashboard:resume-malformed", {"turn_in_flight_generation": True} + ) + + async with TestClient(TestServer(_make_app(state))) as client: + response = await client.post( + "/api/chat/slots/resume-malformed/resume", + json={"key": "dashboard:resume-malformed"}, + ) + + assert response.status == 200 + restored = state.get_slot("resume-malformed") + assert restored is not None + assert restored.to_dict()["interrupted"] is False + assert all( + (m.get("meta") or {}).get("kind") != "gateway_restart_interruption" + for m in restored.messages + ) diff --git a/test/test_is_interrupted.py b/test/test_is_interrupted.py index ca80320a68ea..96fc45584893 100644 --- a/test/test_is_interrupted.py +++ b/test/test_is_interrupted.py @@ -89,6 +89,13 @@ def test_superseded_error_is_not_interrupted(self): def test_empty_transcript_is_not_interrupted(self): assert _is_interrupted(slot()) is False + def test_window_of_only_tool_rows_reads_its_trailing_error(self): + # A long turn pushed its opener and reply into the frozen prefix; the + # loaded window is tool rows plus the restart's error row. + tool = {"role": "tool", "content": "read page", "meta": {"done": True}} + assert _is_interrupted(slot(tool, tool, error())) is True + assert _is_interrupted(slot(tool, tool)) is False + class TestDeliberateStop: """A user-initiated Stop is an ENDING, not an interruption.""" @@ -264,3 +271,70 @@ def test_borrowed_tag_notices_do_not_complete_a_compact(self): "meta": {"kind": "compaction", "notice": notice_kind}, } assert _is_interrupted(slot(user("/compact"), row)) is True + + +class TestInjectRowsOpenTurns: + """An ``inject`` row stamped with a dispatching ``meta.injectKind`` (the queue + drain's cron/recovery/user_replay, the synthesis kick-off) is a turn like a + user row. An untagged inject -- a ``/note`` breadcrumb, a Stop-hook halt card, + a policy refusal notice -- dispatched nothing and is looked through. + + Mirrors ``selectTurnInterrupted`` in ``chatSlice.ts``, which decides inject + rows before its CONTINUE_SCAN_SKIP set. + """ + + @staticmethod + def inject(kind: str | None = "user_replay", content: str = "go on", **meta) -> dict: + row = {"role": "inject", "content": content} + if kind is not None or meta: + row["meta"] = ({"injectKind": kind} if kind is not None else {}) | meta + return row + + def test_nudge_row_is_an_opener(self): + # A monitor loop's cycle dispatches a turn; unanswered it is interrupted, + # and an older Stop card behind it must not mask that. + nudge = {"role": "nudge", "content": "[auto-nudge cycle 3] check", "meta": {"nudge": {}}} + assert _is_interrupted(slot(user(), assistant(), nudge)) is True + assert _is_interrupted(slot(user(), stop_event(), nudge)) is True + assert _is_interrupted(slot(user(), assistant(), nudge, assistant())) is False + + def test_every_dispatching_kind_is_an_opener(self): + for kind in ("cron", "mcp_app", "recovery", "user_replay", "synthesis"): + assert _is_interrupted(slot(user(), assistant(), self.inject(kind))) is True + + def test_inject_followed_by_tool_rows_is_interrupted(self): + rows = ( + user(), + self.inject("recovery", "continue queued work"), + {"role": "tool", "content": "read complete", "meta": {"done": True}}, + ) + assert _is_interrupted(slot(*rows)) is True + + def test_answered_inject_is_finished(self): + assert _is_interrupted(slot(user(), self.inject(), assistant())) is False + + def test_older_stop_does_not_mask_a_newer_inject_turn(self): + rows = ( + user("first"), + stop_event(), + self.inject("synthesis", "continue queued work"), + {"role": "tool", "content": "read complete"}, + ) + assert _is_interrupted(slot(*rows)) is True + + def test_untagged_injects_are_looked_through(self): + # A halt card, a note (rehydrated and live shapes), an unknown or + # non-string kind: none dispatched a turn, so none is unanswered. + for row in ( + self.inject(None, "Stop hook halted #3"), + self.inject(None, "noted", noteSession="dashboard:s"), + {"role": "inject", "content": "noted", "cls": "reconcile-note"}, + self.inject("unknown"), + {"role": "inject", "content": "x", "meta": {"injectKind": 7}}, + {"role": "inject", "content": "x", "meta": "cron"}, + ): + assert _is_interrupted(slot(user(), assistant(), row)) is False + assert _is_interrupted(slot(user(), row)) is True + + def test_empty_inject_is_not_an_opener(self): + assert _is_interrupted(slot(user(), assistant(), self.inject("cron", ""))) is False diff --git a/test/test_local_turn_restart_marker.py b/test/test_local_turn_restart_marker.py new file mode 100644 index 000000000000..b307f5e1da6f --- /dev/null +++ b/test/test_local_turn_restart_marker.py @@ -0,0 +1,1404 @@ +"""The durable "turn in flight" marker that survives a gateway force exit. + +A turn cut by process death leaves ``user -> assistant(partial) -> tool rows`` +and no error row, which the transcript heuristic (``is_turn_interrupted``) +reads as a finished answer. ``_run_chat`` writes the turn's generation to the +slot-owned ``turn_in_flight_generation`` metadata key before provider dispatch +and omits it at teardown; every restore path converts a leftover value into the +existing interruption row. +""" + +from __future__ import annotations + +import asyncio +import json +from unittest.mock import AsyncMock, MagicMock + +import pytest +from chat_test_helpers import _make_state + +from kiro_crew.dashboard.chat_persistence import ( + _LOCAL_TURN_PROMPT_MAX_ATTACHMENTS, + _LOCAL_TURN_PROMPT_MAX_BYTES, + _LOCAL_TURN_PROMPT_MAX_FIELD_CHARS, + _local_turn_prompt, + _rehydrate_slot_from_history, + _save_slot_to_history, + restore_recent_sessions, +) +from kiro_crew.dashboard.chat_runner import ( + _begin_local_turn_marker, + _clear_local_turn_marker, + _local_turn_generation_for, + _local_turn_opening_row, + _retire_local_turn_marker, +) +from kiro_crew.history import SLOT_OWNED_META_KEYS + +_RESTART_KIND = "gateway_restart_interruption" + + +def _restart_rows(messages: list[dict]) -> list[dict]: + return [m for m in messages if (m.get("meta") or {}).get("kind") == _RESTART_KIND] + + +def _provider_mock() -> AsyncMock: + # Same shape as test_dashboard_chat._provider_mock: the telemetry accessors + # the runner reads after a turn are SYNCHRONOUS on the real provider, so they + # are pinned as MagicMock or each call hands back a never-awaited coroutine. + client = AsyncMock() + client.context_usage_pct = MagicMock(return_value=10.0) + client.context_window_tokens = MagicMock(return_value=0) + client.context_used_tokens = MagicMock(return_value=0) + client.mcp_session_report = MagicMock(return_value=None) + client.available_models = MagicMock(return_value=[]) + client.client.pop_pending_oauth_requests = MagicMock(return_value=[]) + return client + + +def _client_streaming(events: list) -> AsyncMock: + client = _provider_mock() + + async def _stream(msg): + for ev in events: + yield ev + + client.stream = _stream + client.stream_command = _stream + return client + + +def _state_for_run_chat(tmp_path, monkeypatch): + monkeypatch.setattr("kiro_crew.dashboard.state.config_dir", lambda: tmp_path) + state = _make_state(tmp_path) + state.broadcast_ws = MagicMock() + state.push_slots_update = MagicMock() + state.context_builder = None + state.consolidator = MagicMock() + state._hook_store = None + state._yolo = False + return state + + +# ── marker lifecycle ─────────────────────────────────────────────────────── + + +@pytest.mark.asyncio +async def test_marker_is_durable_before_dispatch_and_omitted_after_clear(tmp_path): + state = _make_state(tmp_path) + slot = state.get_or_create_slot("chat-1") + slot.append("user", "do something long", "msg msg-u") + slot._turn_generation = 7 + + generation = _local_turn_generation_for(slot) + await _begin_local_turn_marker(state, slot, generation) + + assert generation == 7 + assert slot._turn_in_flight_generation == 7 + assert state.conversation_log is not None + assert state.conversation_log.get_metadata("dashboard:chat-1")["turn_in_flight_generation"] == 7 + + slot.append("assistant", "done", "msg msg-a") + await _clear_local_turn_marker(state, slot, generation) + + assert slot._turn_in_flight_generation == 0 + assert "turn_in_flight_generation" not in state.conversation_log.get_metadata( + "dashboard:chat-1" + ) + + +def test_marker_key_is_slot_owned(): + # Omission on the teardown save IS the durable clear. An unowned key would be + # carried forward by carry_unowned_metadata and flag every later restart. + assert "turn_in_flight_generation" in SLOT_OWNED_META_KEYS + + +def test_retire_is_generation_checked_so_a_successor_keeps_its_marker(): + from kiro_crew.dashboard.state import _ChatSlot + + slot = _ChatSlot("chat-1") + slot._turn_in_flight_generation = 9 + # A stale predecessor's clear must not erase the generation a successor wrote. + assert _retire_local_turn_marker(slot, 8) is False + assert slot._turn_in_flight_generation == 9 + assert _retire_local_turn_marker(slot, 0) is False + assert _retire_local_turn_marker(slot, 9) is True + assert slot._turn_in_flight_generation == 0 + assert _retire_local_turn_marker(slot, 9) is False + + +@pytest.mark.asyncio +async def test_admission_writes_only_metadata_when_the_transcript_exists(tmp_path): + state = _make_state(tmp_path) + slot = state.get_or_create_slot("chat-1") + slot.append("user", "first", "msg msg-u") + slot.append("assistant", "answered", "msg msg-a") + assert _save_slot_to_history(state, slot, force=True) + slot.append("user", "second", "msg msg-u") + assert state.conversation_log is not None + before = state.conversation_log.read_messages("dashboard:chat-1") + + await _begin_local_turn_marker(state, slot, 4) + + # The unflushed user row stays with the periodic flush: admitting a turn + # must not change what the prompt builder reads off disk. + assert state.conversation_log.read_messages("dashboard:chat-1") == before + assert state.conversation_log.get_metadata("dashboard:chat-1")["turn_in_flight_generation"] == 4 + + +@pytest.mark.asyncio +async def test_admission_creates_the_transcript_for_a_newborn_slot(tmp_path): + state = _make_state(tmp_path) + slot = state.get_or_create_slot("chat-1") + slot.append("user", "first ever", "msg msg-u") + assert state.conversation_log is not None + assert state.conversation_log.get_metadata("dashboard:chat-1") == {} + + await _begin_local_turn_marker(state, slot, 1) + + # No line to merge into, so the full save is the one writer that can make + # the marker durable; it carries the user row along. + assert state.conversation_log.get_metadata("dashboard:chat-1")["turn_in_flight_generation"] == 1 + assert [m["role"] for m in state.conversation_log.read_messages("dashboard:chat-1")] == ["user"] + + +def _replace_slot_under_same_key(state, old_slot): + """Mimic a tab close + same-key reopen that resumes the same transcript.""" + from kiro_crew.dashboard.state import _ChatSlot + + replacement = _ChatSlot(old_slot.key) + replacement._tab_id = old_slot._tab_id + state._slots[old_slot.key] = replacement + return replacement + + +@pytest.mark.asyncio +async def test_admission_merge_refuses_once_a_replacement_owns_the_key(tmp_path): + state = _make_state(tmp_path) + slot = state.get_or_create_slot("chat-1") + slot.append("user", "first", "msg msg-u") + slot.append("assistant", "answered", "msg msg-a") + assert _save_slot_to_history(state, slot, force=True) + replacement = _replace_slot_under_same_key(state, slot) + replacement.append("user", "the replacement's turn", "msg msg-u") + assert _save_slot_to_history(state, replacement, force=True) + assert state.conversation_log is not None + before = state.conversation_log.read_messages("dashboard:chat-1") + + # The cancelled predecessor's admission lands after the replacement took the key. + await _begin_local_turn_marker(state, slot, 3) + + meta = state.conversation_log.get_metadata("dashboard:chat-1") + assert "turn_in_flight_generation" not in meta + assert state.conversation_log.read_messages("dashboard:chat-1") == before + # In memory the stale object still carries its value; nothing reads it again. + assert slot._turn_in_flight_generation == 3 + + +@pytest.mark.asyncio +async def test_admission_merge_refuses_once_the_slot_is_closing(tmp_path): + # The close raises its fence before it waits on the guarded writes; a merge + # dispatched after the fence has nothing left to order against it. + state = _make_state(tmp_path) + slot = state.get_or_create_slot("chat-1") + slot.append("user", "first", "msg msg-u") + slot.append("assistant", "answered", "msg msg-a") + assert _save_slot_to_history(state, slot, force=True) + assert state.conversation_log is not None + before = dict(state.conversation_log.get_metadata("dashboard:chat-1")) + slot.append("user", "second", "msg msg-u") + slot.begin_close() + + await _begin_local_turn_marker(state, slot, 3) + + assert state.conversation_log.get_metadata("dashboard:chat-1") == before + assert slot._dirty is True + + +@pytest.mark.asyncio +async def test_admission_merge_is_a_guarded_history_write(tmp_path): + # The merge's future is in the registry a close waits on while the worker + # runs, and leaves it when the worker returns; the retraction therefore + # orders itself after the write instead of racing it. + import threading + + from kiro_crew.dashboard.chat_handlers import _pending_guarded_history_writes + + state = _make_state(tmp_path) + slot = state.get_or_create_slot("chat-1") + slot.append("user", "first", "msg msg-u") + slot.append("assistant", "answered", "msg msg-a") + assert _save_slot_to_history(state, slot, force=True) + slot.append("user", "second", "msg msg-u") + assert state.conversation_log is not None + log = state.conversation_log + entered = threading.Event() + release = threading.Event() + real = log.update_metadata_if + seen: list[set] = [] + + def slow_merge(*args, **kwargs): + entered.set() + release.wait(5) + return real(*args, **kwargs) + + log.update_metadata_if = slow_merge # type: ignore[method-assign] + task = asyncio.ensure_future(_begin_local_turn_marker(state, slot, 3)) + await asyncio.get_running_loop().run_in_executor(None, entered.wait, 5) + seen.append(_pending_guarded_history_writes(slot)) + release.set() + await task + + assert len(seen[0]) == 1 + assert _pending_guarded_history_writes(slot) == set() + assert log.get_metadata("dashboard:chat-1")["turn_in_flight_generation"] == 3 + + +@pytest.mark.asyncio +async def test_newborn_forced_save_refuses_once_a_replacement_owns_the_key(tmp_path): + state = _make_state(tmp_path) + slot = state.get_or_create_slot("chat-1") + slot.append("user", "predecessor's first row", "msg msg-u") + replacement = _replace_slot_under_same_key(state, slot) + replacement.append("user", "the replacement's turn", "msg msg-u") + assert _save_slot_to_history(state, replacement, force=True) + assert state.conversation_log is not None + + # ``require_existing`` is satisfied by the replacement's file, so the merge + # path is taken and the guard refuses; the newborn fallback must not then + # rebuild the window from the stale object's rows either. + await _begin_local_turn_marker(state, slot, 2) + + rows = state.conversation_log.read_messages("dashboard:chat-1") + assert [m["content"] for m in rows] == ["the replacement's turn"] + assert "turn_in_flight_generation" not in state.conversation_log.get_metadata( + "dashboard:chat-1" + ) + + +@pytest.mark.asyncio +async def test_teardown_clear_refuses_to_overwrite_a_replacement_slot(tmp_path): + state = _make_state(tmp_path) + slot = state.get_or_create_slot("chat-1") + slot.append("user", "first", "msg msg-u") + await _begin_local_turn_marker(state, slot, 5) + replacement = _replace_slot_under_same_key(state, slot) + replacement.append("user", "first", "msg msg-u") + replacement.append("assistant", "partial from the replacement", "msg msg-a") + replacement.append("tool", "tool output", "msg msg-tool") + await _begin_local_turn_marker(state, replacement, 1) + assert state.conversation_log is not None + before = state.conversation_log.read_messages("dashboard:chat-1") + assert state.conversation_log.get_metadata("dashboard:chat-1")["turn_in_flight_generation"] == 1 + + # The old runner's finally fires after close_slot's 2 s grace has admitted a + # same-key replacement whose own turn is in flight. An unfenced forced save + # from the stale object would republish ITS slot-owned metadata (no marker) + # over the replacement's line and erase the replacement's in-flight marker. + await _clear_local_turn_marker(state, slot, 5) + + assert state.conversation_log.get_metadata("dashboard:chat-1")["turn_in_flight_generation"] == 1 + assert state.conversation_log.read_messages("dashboard:chat-1") == before + assert slot._turn_in_flight_generation == 0 + + +@pytest.mark.asyncio +async def test_a_cancelled_admission_write_lands_before_the_cancel_propagates( + tmp_path, monkeypatch +): + """A tab close while the metadata merge is on its thread must not let that + write land AFTER the teardown clear: the admission waits for the job.""" + import asyncio + import threading + + state = _make_state(tmp_path) + slot = state.get_or_create_slot("chat-1") + slot.append("user", "first", "msg msg-u") + assert _save_slot_to_history(state, slot, force=True) + assert state.conversation_log is not None + log = state.conversation_log + real_merge = log.update_metadata_if + entered = threading.Event() + release = threading.Event() + + def slow_merge(*args, **kwargs): + entered.set() + assert release.wait(10) + return real_merge(*args, **kwargs) + + monkeypatch.setattr(log, "update_metadata_if", slow_merge) + task = asyncio.ensure_future(_begin_local_turn_marker(state, slot, 6)) + await asyncio.to_thread(entered.wait, 10) + task.cancel() + # The cancellation is delivered only once the write has landed. + await asyncio.sleep(0) + assert not task.done() + release.set() + with pytest.raises(asyncio.CancelledError): + await asyncio.wait_for(task, 10) + assert log.get_metadata("dashboard:chat-1")["turn_in_flight_generation"] == 6 + # And a clear issued afterwards is ordered after it, so nothing resurrects it. + await _clear_local_turn_marker(state, slot, 6) + assert "turn_in_flight_generation" not in log.get_metadata("dashboard:chat-1") + + +@pytest.mark.asyncio +async def test_repeated_cancellation_still_waits_for_the_admission_write(tmp_path, monkeypatch): + """A graceful shutdown escalating after its timeout cancels the runner more + than once. The second cancel must not abandon the thread job either: a write + left running would land after the teardown clear and restore a stale marker.""" + import asyncio + import threading + + state = _make_state(tmp_path) + slot = state.get_or_create_slot("chat-1") + slot.append("user", "first", "msg msg-u") + assert _save_slot_to_history(state, slot, force=True) + assert state.conversation_log is not None + log = state.conversation_log + real_merge = log.update_metadata_if + entered = threading.Event() + release = threading.Event() + + def slow_merge(*args, **kwargs): + entered.set() + assert release.wait(10) + return real_merge(*args, **kwargs) + + monkeypatch.setattr(log, "update_metadata_if", slow_merge) + task = asyncio.ensure_future(_begin_local_turn_marker(state, slot, 7)) + await asyncio.to_thread(entered.wait, 10) + for _ in range(3): + task.cancel() + await asyncio.sleep(0) + assert not task.done(), "a cancel delivered mid-write must not end the admission" + release.set() + with pytest.raises(asyncio.CancelledError): + await asyncio.wait_for(task, 10) + assert log.get_metadata("dashboard:chat-1")["turn_in_flight_generation"] == 7 + await _clear_local_turn_marker(state, slot, 7) + assert "turn_in_flight_generation" not in log.get_metadata("dashboard:chat-1") + + +@pytest.mark.asyncio +async def test_a_failed_metadata_merge_never_refuses_the_turn(tmp_path, monkeypatch): + state = _make_state(tmp_path) + slot = state.get_or_create_slot("chat-1") + slot.append("user", "first", "msg msg-u") + assert _save_slot_to_history(state, slot, force=True) + slot._dirty = False + assert state.conversation_log is not None + monkeypatch.setattr( + state.conversation_log, + "update_metadata_if", + MagicMock(side_effect=OSError("disk unavailable")), + ) + + await _begin_local_turn_marker(state, slot, 5) + + assert slot._turn_in_flight_generation == 5 + assert slot._dirty is True + + +@pytest.mark.asyncio +async def test_a_failed_marker_save_never_refuses_the_turn(tmp_path, monkeypatch): + state = _make_state(tmp_path) + slot = state.get_or_create_slot("chat-1") + slot.append("user", "do something", "msg msg-u") + slot._turn_generation = 3 + slot._dirty = False + monkeypatch.setattr( + "kiro_crew.dashboard.chat_persistence._save_slot_to_history", + MagicMock(side_effect=OSError("disk unavailable")), + ) + + generation = _local_turn_generation_for(slot) + await _begin_local_turn_marker(state, slot, generation) + + # The marker is a recovery hint, not the user's words: it stays in memory + # for the periodic flush and the turn goes ahead. + assert generation == 3 + assert slot._turn_in_flight_generation == 3 + assert slot._dirty is True + + +def test_generation_is_bound_before_the_marker_save_is_awaited(): + from kiro_crew.dashboard.state import _ChatSlot + + # A cancellation inside the admission save must still leave the finally a + # generation to retire, so the generation is a plain read, not the save's + # return value. + slot = _ChatSlot("chat-1") + slot._turn_generation = 0 + assert _local_turn_generation_for(slot) == 1 + slot._turn_generation = 12 + assert _local_turn_generation_for(slot) == 12 + + +@pytest.mark.asyncio +async def test_a_cancel_inside_the_admission_save_still_clears_the_marker(tmp_path, monkeypatch): + """Tab close while the marker save is in flight: the save commits after the + cancel, and teardown must still retire the marker it wrote.""" + import asyncio + + from kiro_crew.dashboard.chat import _run_chat + + state = _state_for_run_chat(tmp_path, monkeypatch) + slot = state.get_or_create_slot("cancel-in-admission") + slot.append("user", "hello", "msg msg-u") + real_begin = __import__( + "kiro_crew.dashboard.chat_runner", fromlist=["x"] + )._begin_local_turn_marker + + async def cancelling_begin(st, sl, generation): + await real_begin(st, sl, generation) + raise asyncio.CancelledError() + + monkeypatch.setattr( + "kiro_crew.dashboard.chat_runner._begin_local_turn_marker", cancelling_begin + ) + + # _run_chat absorbs the cancellation (its except arm persists the partial + # reply) and reaches its finally, which owns the clear. + await _run_chat(state, slot, "hello") + + assert slot._turn_in_flight_generation == 0 + assert state.conversation_log is not None + assert "turn_in_flight_generation" not in state.conversation_log.get_metadata( + "dashboard:cancel-in-admission" + ) + + +@pytest.mark.asyncio +async def test_clear_for_another_generation_writes_nothing(tmp_path, monkeypatch): + state = _make_state(tmp_path) + slot = state.get_or_create_slot("chat-1") + slot._turn_in_flight_generation = 5 + save = AsyncMock(return_value=True) + monkeypatch.setattr("kiro_crew.dashboard.chat_runner.save_slot_off_loop", save) + + await _clear_local_turn_marker(state, slot, 4) + + save.assert_not_awaited() + assert slot._turn_in_flight_generation == 5 + + +def test_empty_window_forced_save_writes_the_marker_as_a_clearable_field(tmp_path): + state = _make_state(tmp_path) + slot = state.get_or_create_slot("chat-1") + slot.append("user", "hello", "msg msg-u") + assert _save_slot_to_history(state, slot, force=True) + assert state.conversation_log is not None + + # The merge writer cannot delete a key, so it writes the current value + # either way: the admitted generation while a turn runs, zero afterwards. + slot.messages.clear() + slot._turn_in_flight_generation = 6 + assert _save_slot_to_history(state, slot, force=True) + assert state.conversation_log.get_metadata("dashboard:chat-1")["turn_in_flight_generation"] == 6 + slot._turn_in_flight_generation = 0 + assert _save_slot_to_history(state, slot, force=True) + assert state.conversation_log.get_metadata("dashboard:chat-1")["turn_in_flight_generation"] == 0 + + +# ── restore reconciliation ───────────────────────────────────────────────── + + +def test_partial_assistant_and_finished_tools_are_flagged_after_restart(tmp_path): + state = _make_state(tmp_path) + slot = state.get_or_create_slot("chat-1") + slot.append("user", "inspect the page", "msg msg-u") + slot.append("assistant", "I am inspecting it now", "msg msg-a") + slot.append("tool", "read complete", "tool", meta={"done": True}) + slot._turn_in_flight_generation = 11 + assert _save_slot_to_history(state, slot, force=True) + # RED on main: this tail reads as a finished answer. + del state._slots["chat-1"] + + restored = _rehydrate_slot_from_history(state, "chat-1") + + assert restored is not None + assert restored.to_dict()["interrupted"] is True + assert restored.messages[-1]["role"] == "error" + assert restored.messages[-1]["meta"]["kind"] == _RESTART_KIND + assert restored._turn_in_flight_generation == 0 + assert restored._dirty is True + # Appended past the window boundary, so the next save writes it rather than + # counting it as already on disk. + assert restored._disk_window_len == len(restored.messages) - 1 + + +def test_reconciliation_is_idempotent_once_the_row_is_saved(tmp_path): + state = _make_state(tmp_path) + slot = state.get_or_create_slot("chat-1") + slot.append("user", "inspect the page", "msg msg-u") + slot.append("assistant", "partial result", "msg msg-a") + slot._turn_in_flight_generation = 12 + assert _save_slot_to_history(state, slot, force=True) + + del state._slots["chat-1"] + restored = _rehydrate_slot_from_history(state, "chat-1") + assert restored is not None + assert _save_slot_to_history(state, restored, force=True) + assert state.conversation_log is not None + assert "turn_in_flight_generation" not in state.conversation_log.get_metadata( + "dashboard:chat-1" + ) + + del state._slots["chat-1"] + restored_again = _rehydrate_slot_from_history(state, "chat-1") + assert restored_again is not None + assert len(_restart_rows(restored_again.messages)) == 1 + assert restored_again._turn_in_flight_generation == 0 + + +def test_a_second_restart_before_the_save_does_not_duplicate_the_row(tmp_path): + state = _make_state(tmp_path) + slot = state.get_or_create_slot("chat-1") + slot.append("user", "inspect the page", "msg msg-u") + slot.append("assistant", "partial result", "msg msg-a") + slot._turn_in_flight_generation = 12 + assert _save_slot_to_history(state, slot, force=True) + + # Two restores from the same unchanged bytes: the decision re-runs and the + # row is appended once per process, never accumulated on disk. + for _ in range(2): + del state._slots["chat-1"] + restored = _rehydrate_slot_from_history(state, "chat-1") + assert restored is not None + assert len(_restart_rows(restored.messages)) == 1 + + +def test_existing_interruption_evidence_does_not_gain_a_duplicate_error(tmp_path): + state = _make_state(tmp_path) + slot = state.get_or_create_slot("chat-1") + slot.append("user", "inspect the page", "msg msg-u") + slot.append("assistant", "partial result", "msg msg-a") + slot.append("error", "backend stopped", "msg msg-err") + slot._turn_in_flight_generation = 13 + assert _save_slot_to_history(state, slot, force=True) + + del state._slots["chat-1"] + restored = _rehydrate_slot_from_history(state, "chat-1") + + assert restored is not None + assert restored.to_dict()["interrupted"] is True + assert [m["role"] for m in restored.messages].count("error") == 1 + assert restored._turn_in_flight_generation == 0 + assert restored._dirty is True + + +def test_deliberate_stop_clears_a_stale_marker_without_flagging_interruption(tmp_path): + state = _make_state(tmp_path) + slot = state.get_or_create_slot("chat-1") + slot.append("user", "inspect the page", "msg msg-u") + slot.append("system", "Stopped", json.dumps({"kind": "stop_event"})) + slot._turn_in_flight_generation = 14 + assert _save_slot_to_history(state, slot, force=True) + + del state._slots["chat-1"] + restored = _rehydrate_slot_from_history(state, "chat-1") + + assert restored is not None + assert restored.to_dict()["interrupted"] is False + assert _restart_rows(restored.messages) == [] + assert restored._turn_in_flight_generation == 0 + assert restored._dirty is True + + +def test_a_stop_card_behind_tool_rows_still_counts_as_deliberate(tmp_path): + state = _make_state(tmp_path) + slot = state.get_or_create_slot("chat-1") + slot.append("user", "inspect the page", "msg msg-u") + slot.append("assistant", "working", "msg msg-a") + slot.append("system", "Stopped", json.dumps({"kind": "stop_event"})) + slot.append("tool", "late tool row", "tool", meta={"done": True}) + slot._turn_in_flight_generation = 14 + assert _save_slot_to_history(state, slot, force=True) + + del state._slots["chat-1"] + restored = _rehydrate_slot_from_history(state, "chat-1") + + assert restored is not None + assert _restart_rows(restored.messages) == [] + assert restored.to_dict()["interrupted"] is False + + +@pytest.mark.parametrize("malformed", [True, "11", -3, 0, 2.5, None]) +def test_malformed_marker_values_are_ignored(tmp_path, malformed): + state = _make_state(tmp_path) + slot = state.get_or_create_slot("chat-1") + slot.append("user", "hello", "msg msg-u") + slot.append("assistant", "complete", "msg msg-a") + assert _save_slot_to_history(state, slot, force=True) + assert state.conversation_log is not None + state.conversation_log.update_metadata( + "dashboard:chat-1", {"turn_in_flight_generation": malformed} + ) + + del state._slots["chat-1"] + restored = _rehydrate_slot_from_history(state, "chat-1") + + assert restored is not None + assert restored.to_dict()["interrupted"] is False + assert _restart_rows(restored.messages) == [] + # No marker means nothing to clear: the window is not dirtied for nothing. + assert restored._dirty is False + + +def test_recent_session_restore_also_reconciles_the_marker(tmp_path): + state = _make_state(tmp_path) + slot = state.get_or_create_slot("chat-1") + slot.append("user", "inspect the page", "msg msg-u") + slot.append("assistant", "partial result", "msg msg-a") + slot._turn_in_flight_generation = 15 + assert _save_slot_to_history(state, slot, force=True) + del state._slots["chat-1"] + + assert restore_recent_sessions(state, window_minutes=30) == 1 + + restored = state.get_slot("chat-1") + assert restored is not None + assert restored.to_dict()["interrupted"] is True + assert restored.messages[-1]["meta"]["kind"] == _RESTART_KIND + assert restored._turn_in_flight_generation == 0 + + +def test_local_marker_and_relay_marker_together_append_one_row(tmp_path): + state = _make_state(tmp_path) + slot = state.get_or_create_slot("chat-1") + slot.append("user", "inspect the page", "msg msg-u") + slot.append("assistant", "partial result", "msg msg-a") + assert _save_slot_to_history(state, slot, force=True) + assert state.conversation_log is not None + # Inconsistent metadata claiming both kinds of execution: one row, not two. + state.conversation_log.update_metadata( + "dashboard:chat-1", + { + "turn_in_flight_generation": 4, + "executor": "remote", + "instance_id": "peer-1", + "remote_slot": "chat-9", + "relay_in_flight": True, + }, + ) + + del state._slots["chat-1"] + restored = _rehydrate_slot_from_history(state, "chat-1") + + assert restored is not None + assert [m["role"] for m in restored.messages].count("error") == 1 + assert restored.messages[-1]["meta"]["kind"] == _RESTART_KIND + + +# ── _run_chat wiring ─────────────────────────────────────────────────────── + + +@pytest.mark.asyncio +async def test_a_landed_turn_leaves_no_marker_on_disk(tmp_path, monkeypatch): + from kiro_crew.acp.types import STOP_REASON_END_TURN + from kiro_crew.dashboard.chat import _run_chat + from kiro_crew.providers.base import EVENT_COMPLETE, EVENT_TEXT_CHUNK, LLMEvent + + state = _state_for_run_chat(tmp_path, monkeypatch) + slot = state.get_or_create_slot("landed") + # The send handler appends the user row before dispatch; mirror it so the + # slot has a window (an empty newborn has no metadata line to carry a key). + slot.append("user", "hello", "msg msg-u") + client = _client_streaming( + [ + LLMEvent(kind=EVENT_TEXT_CHUNK, text="the answer"), + LLMEvent(kind=EVENT_COMPLETE, stop_reason=STOP_REASON_END_TURN), + ] + ) + state.sessions.get_or_create = AsyncMock(return_value=(client, True, False)) + + await _run_chat(state, slot, "hello") + + assert slot._turn_in_flight_generation == 0 + assert state.conversation_log is not None + assert "turn_in_flight_generation" not in state.conversation_log.get_metadata( + "dashboard:landed" + ) + # And a restart afterwards reads a finished answer, not an interruption. + del state._slots["landed"] + restored = _rehydrate_slot_from_history(state, "landed") + assert restored is not None + assert restored.to_dict()["interrupted"] is False + + +@pytest.mark.asyncio +async def test_a_cancelled_turn_clears_its_marker_while_the_process_lives(tmp_path, monkeypatch): + from kiro_crew.acp.types import STOP_REASON_CANCELLED + from kiro_crew.dashboard.chat import _run_chat + from kiro_crew.providers.base import EVENT_COMPLETE, EVENT_TEXT_CHUNK, LLMEvent + + state = _state_for_run_chat(tmp_path, monkeypatch) + slot = state.get_or_create_slot("cancelled") + # The send handler appends the user row before dispatch; mirror it so the + # slot has a window (an empty newborn has no metadata line to carry a key). + slot.append("user", "hello", "msg msg-u") + client = _client_streaming( + [ + LLMEvent(kind=EVENT_TEXT_CHUNK, text="partial"), + LLMEvent(kind=EVENT_COMPLETE, stop_reason=STOP_REASON_CANCELLED), + ] + ) + state.sessions.get_or_create = AsyncMock(return_value=(client, True, False)) + + await _run_chat(state, slot, "hello") + + # The process did not die, so whatever ended the turn is already in the + # transcript; the marker must not flag a later clean restart. + assert slot._turn_in_flight_generation == 0 + assert state.conversation_log is not None + assert "turn_in_flight_generation" not in state.conversation_log.get_metadata( + "dashboard:cancelled" + ) + + +@pytest.mark.asyncio +async def test_shutdown_preserves_the_marker_of_an_unlanded_turn(tmp_path, monkeypatch): + from kiro_crew import shutdown_event + from kiro_crew.acp.types import STOP_REASON_CANCELLED + from kiro_crew.dashboard.chat import _run_chat + from kiro_crew.providers.base import EVENT_COMPLETE, EVENT_TEXT_CHUNK, LLMEvent + + state = _state_for_run_chat(tmp_path, monkeypatch) + slot = state.get_or_create_slot("shutdown-cancelled") + # The send handler appends the user row before dispatch; mirror it so the + # slot has a window (an empty newborn has no metadata line to carry a key). + slot.append("user", "hello", "msg msg-u") + client = _client_streaming( + [ + LLMEvent(kind=EVENT_TEXT_CHUNK, text="partial"), + LLMEvent(kind=EVENT_COMPLETE, stop_reason=STOP_REASON_CANCELLED), + ] + ) + state.sessions.get_or_create = AsyncMock(return_value=(client, True, False)) + shutdown_event.set() + try: + await _run_chat(state, slot, "hello") + finally: + shutdown_event.clear() + + assert slot._turn_in_flight_generation > 0 + assert state.conversation_log is not None + meta = state.conversation_log.get_metadata("dashboard:shutdown-cancelled") + assert meta["turn_in_flight_generation"] == slot._turn_in_flight_generation + # The next process converts it into the interruption row. + del state._slots["shutdown-cancelled"] + restored = _rehydrate_slot_from_history(state, "shutdown-cancelled") + assert restored is not None + assert restored.to_dict()["interrupted"] is True + + +@pytest.mark.asyncio +async def test_a_turn_that_lands_during_shutdown_still_clears(tmp_path, monkeypatch): + from kiro_crew import shutdown_event + from kiro_crew.acp.types import STOP_REASON_END_TURN + from kiro_crew.dashboard.chat import _run_chat + from kiro_crew.providers.base import EVENT_COMPLETE, EVENT_TEXT_CHUNK, LLMEvent + + state = _state_for_run_chat(tmp_path, monkeypatch) + slot = state.get_or_create_slot("shutdown-landed") + # The send handler appends the user row before dispatch; mirror it so the + # slot has a window (an empty newborn has no metadata line to carry a key). + slot.append("user", "hello", "msg msg-u") + client = _client_streaming( + [ + LLMEvent(kind=EVENT_TEXT_CHUNK, text="the answer"), + LLMEvent(kind=EVENT_COMPLETE, stop_reason=STOP_REASON_END_TURN), + ] + ) + state.sessions.get_or_create = AsyncMock(return_value=(client, True, False)) + shutdown_event.set() + try: + await _run_chat(state, slot, "hello") + finally: + shutdown_event.clear() + + assert slot._turn_in_flight_generation == 0 + assert state.conversation_log is not None + assert "turn_in_flight_generation" not in state.conversation_log.get_metadata( + "dashboard:shutdown-landed" + ) + + +@pytest.mark.asyncio +async def test_the_marker_is_on_disk_before_the_provider_streams(tmp_path, monkeypatch): + from kiro_crew.acp.types import STOP_REASON_END_TURN + from kiro_crew.dashboard.chat import _run_chat + from kiro_crew.providers.base import EVENT_COMPLETE, EVENT_TEXT_CHUNK, LLMEvent + + state = _state_for_run_chat(tmp_path, monkeypatch) + slot = state.get_or_create_slot("ordered") + # The send handler appends the user row before dispatch; mirror it so the + # slot has a window (an empty newborn has no metadata line to carry a key). + slot.append("user", "hello", "msg msg-u") + seen: list[object] = [] + client = _provider_mock() + + async def _stream(msg): + assert state.conversation_log is not None + seen.append( + state.conversation_log.get_metadata("dashboard:ordered").get( + "turn_in_flight_generation" + ) + ) + yield LLMEvent(kind=EVENT_TEXT_CHUNK, text="partial") + yield LLMEvent(kind=EVENT_COMPLETE, stop_reason=STOP_REASON_END_TURN) + + client.stream = _stream + client.stream_command = _stream + state.sessions.get_or_create = AsyncMock(return_value=(client, True, False)) + + await _run_chat(state, slot, "hello") + + # A force exit at any point of the stream would have left this value behind. + assert seen and type(seen[0]) is int and seen[0] > 0 + + +# ── the opening row travels with the marker ───────────────────────────────── +# +# Rows ride the periodic flush; the marker is a metadata merge written before +# dispatch. A force exit inside that window loses the opening row, and a restore +# that judges the tail without it reads the PREVIOUS turn's ending (a Stop card, +# a finished answer) instead of the lost prompt. The marker therefore carries a +# copy of the row, and every restore path puts it back before deciding. + + +@pytest.mark.asyncio +async def test_admission_carries_the_opening_row_and_the_clear_drops_it(tmp_path): + state = _make_state(tmp_path) + slot = state.get_or_create_slot("chat-1") + slot.append("assistant", "earlier answer", "msg msg-a") + assert _save_slot_to_history(state, slot, force=True) + user_row = slot.append("user", "the prompt that opens this turn", "msg msg-u") + slot._turn_generation = 3 + + await _begin_local_turn_marker(state, slot, _local_turn_generation_for(slot)) + + assert state.conversation_log is not None + stored = state.conversation_log.get_metadata("dashboard:chat-1")["turn_in_flight_prompt"] + assert stored["role"] == "user" + assert stored["content"] == "the prompt that opens this turn" + assert "cls" not in stored + assert stored["ts"] == user_row["ts"] + assert stored["meta"] == {"mid": user_row["meta"]["mid"]} + assert slot._turn_in_flight_prompt == stored + + slot.append("assistant", "done", "msg msg-a") + await _clear_local_turn_marker(state, slot, 3) + + assert slot._turn_in_flight_prompt is None + assert "turn_in_flight_prompt" not in state.conversation_log.get_metadata("dashboard:chat-1") + + +def test_prompt_copy_key_is_slot_owned(): + assert "turn_in_flight_prompt" in SLOT_OWNED_META_KEYS + + +def test_retire_clears_the_prompt_copy_with_the_generation(): + from kiro_crew.dashboard.state import _ChatSlot + + slot = _ChatSlot("chat-1") + slot._turn_in_flight_generation = 9 + slot._turn_in_flight_prompt = {"role": "user", "content": "x"} + assert _retire_local_turn_marker(slot, 8) is False + assert slot._turn_in_flight_prompt is not None + assert _retire_local_turn_marker(slot, 9) is True + assert slot._turn_in_flight_prompt is None + + +def test_opening_row_copy_picks_the_newest_unanswered_opener(): + from kiro_crew.dashboard.state import _ChatSlot + + slot = _ChatSlot("chat-1") + slot.append("user", "first", "msg msg-u") + slot.append("assistant", "answered", "msg msg-a") + # An answered opener is not the turn being admitted. + assert _local_turn_opening_row(slot) is None + + slot.append( + "user", + "second", + "msg msg-u", + meta={"files": ["f1"], "dirs": [], "sendId": "s-1", "_directive_user_origin": True}, + ) + slot.append("tool", "late tool row", "tool", meta={"done": True}) + copy = _local_turn_opening_row(slot) + assert copy is not None + assert copy["content"] == "second" + # Identity and attachments only: no send id, no directive flag. + assert set(copy["meta"]) == {"mid", "files", "dirs"} + + slot.append("inject", "[Cron notification] tick", "msg msg-u", meta={"injectKind": "cron"}) + copy = _local_turn_opening_row(slot) + assert copy is not None + assert copy["role"] == "inject" and copy["meta"]["injectKind"] == "cron" + + # An app message's delivery dispatches a whole new turn too; its opener is + # copied like the cron one so a restart mid app turn restores the request. + slot.append( + "inject", "app request", "msg msg-inject", meta={"injectKind": "mcp_app", "appLabel": "x"} + ) + copy = _local_turn_opening_row(slot) + assert copy is not None + assert copy["role"] == "inject" and copy["meta"]["injectKind"] == "mcp_app" + + # An untagged inject dispatches nothing and is looked through. + slot.append("inject", "hook halted", "msg msg-u") + copy = _local_turn_opening_row(slot) + assert copy is not None and copy["content"] == "app request" + + # A monitor loop's cycle row opens a turn like a user row. + slot.append( + "nudge", "[auto-nudge cycle 4] check the PR", "msg msg-nudge", meta={"nudge": {"cycle": 4}} + ) + copy = _local_turn_opening_row(slot) + assert copy is not None and copy["role"] == "nudge" + assert set(copy["meta"]) == {"mid"} + + +def test_a_lost_nudge_opener_behind_a_stop_card_is_restored(tmp_path): + # An armed loop survives a Stop; its next cycle's row rides the periodic + # flush. A force exit inside that window leaves the Stop card as the + # newest row on disk, and without the copy the restore would read that + # Stop as intent and offer nothing. + state = _make_state(tmp_path) + slot = state.get_or_create_slot("chat-1") + slot.append("user", "watch the PR", "msg msg-u") + slot.append("assistant", "watching", "msg msg-a") + slot.append("system", "Stopped", json.dumps({"kind": "stop_event"})) + assert _save_slot_to_history(state, slot, force=True) + nudge = slot.append( + "nudge", "[auto-nudge cycle 2] check the PR", "msg msg-nudge", meta={"nudge": {"cycle": 2}} + ) + copy = _local_turn_opening_row(slot) + assert copy is not None and copy["role"] == "nudge" + assert state.conversation_log is not None + state.conversation_log.update_metadata( + "dashboard:chat-1", {"turn_in_flight_generation": 7, "turn_in_flight_prompt": copy} + ) + + del state._slots["chat-1"] + restored = _rehydrate_slot_from_history(state, "chat-1") + + assert restored is not None + tail = restored.messages[-1] + assert tail["role"] == "nudge" and tail["content"] == nudge["content"] + assert tail["meta"]["mid"] == nudge["meta"]["mid"] + assert restored.to_dict()["interrupted"] is True + + +def _prompt_copy(row: dict) -> dict: + return { + "role": row["role"], + "content": row["content"], + "ts": row["ts"], + "meta": {"mid": row["meta"]["mid"]}, + } + + +def test_a_lost_opening_row_is_restored_before_the_tail_is_judged(tmp_path): + # The chat-434 shape with the previous turn ended by Stop and the new prompt + # still in the flush window when the process died: on disk the tail is the + # Stop card, the marker names a row the window does not hold. + state = _make_state(tmp_path) + slot = state.get_or_create_slot("chat-1") + slot.append("user", "first", "msg msg-u") + slot.append("assistant", "working", "msg msg-a") + slot.append("system", "Stopped", json.dumps({"kind": "stop_event"})) + assert _save_slot_to_history(state, slot, force=True) + lost = slot.append("user", "second prompt, never flushed", "msg msg-u") + assert state.conversation_log is not None + state.conversation_log.update_metadata( + "dashboard:chat-1", + {"turn_in_flight_generation": 15, "turn_in_flight_prompt": _prompt_copy(lost)}, + ) + + del state._slots["chat-1"] + restored = _rehydrate_slot_from_history(state, "chat-1") + + assert restored is not None + # RED before the copy: the Stop tail read as deliberate, no row, no flag. + tail = restored.messages[-1] + assert tail["role"] == "user" + assert tail["content"] == "second prompt, never flushed" + assert tail["ts"] == lost["ts"] + assert tail["meta"]["mid"] == lost["meta"]["mid"] + assert restored.to_dict()["interrupted"] is True + # The unanswered prompt is the interruption evidence; no second row. + assert _restart_rows(restored.messages) == [] + assert restored._turn_in_flight_generation == 0 + assert restored._turn_in_flight_prompt is None + assert restored._dirty is True + assert restored._disk_window_len == len(restored.messages) - 1 + + # The restored row is written by the next save and survives another restart. + assert _save_slot_to_history(state, restored, force=True) + del state._slots["chat-1"] + again = _rehydrate_slot_from_history(state, "chat-1") + assert again is not None + assert [m["content"] for m in again.messages if m["role"] == "user"] == [ + "first", + "second prompt, never flushed", + ] + assert "turn_in_flight_prompt" not in state.conversation_log.get_metadata("dashboard:chat-1") + + +def test_an_opening_row_already_on_disk_is_not_restored_twice(tmp_path): + state = _make_state(tmp_path) + slot = state.get_or_create_slot("chat-1") + opener = slot.append("user", "inspect the page", "msg msg-u") + slot.append("assistant", "I am inspecting it now", "msg msg-a") + slot.append("tool", "read complete", "tool", meta={"done": True}) + slot._turn_in_flight_generation = 11 + slot._turn_in_flight_prompt = _prompt_copy(opener) + assert _save_slot_to_history(state, slot, force=True) + + del state._slots["chat-1"] + restored = _rehydrate_slot_from_history(state, "chat-1") + + assert restored is not None + assert [m["content"] for m in restored.messages if m["role"] == "user"] == ["inspect the page"] + assert restored.messages[-1]["meta"]["kind"] == _RESTART_KIND + assert restored.to_dict()["interrupted"] is True + + +def test_an_opening_row_in_the_frozen_prefix_is_not_restored_twice(tmp_path): + # A long turn pushes its own opener past the 500-row window into the + # frozen prefix. The opener is on disk, just not in the loaded window; the + # restore must find it there rather than append the copy behind 500 rows + # of the turn's own output. + state = _make_state(tmp_path) + slot = state.get_or_create_slot("chat-1") + opener = slot.append("user", "inspect every page", "msg msg-u") + slot.append("assistant", "starting", "msg msg-a") + for i in range(520): + slot.append("tool", f"read page {i}", "tool", meta={"done": True}) + slot._turn_in_flight_generation = 12 + slot._turn_in_flight_prompt = _prompt_copy(opener) + assert _save_slot_to_history(state, slot, force=True) + + del state._slots["chat-1"] + restored = _rehydrate_slot_from_history(state, "chat-1") + + assert restored is not None + assert restored._disk_older_count > 0 + assert [m for m in restored.messages if m["role"] == "user"] == [] + assert restored.messages[-1]["meta"]["kind"] == _RESTART_KIND + assert restored.to_dict()["interrupted"] is True + # The next save writes the window; a second restart from those bytes still + # holds exactly one opener across the whole file. + assert _save_slot_to_history(state, restored, force=True) + del state._slots["chat-1"] + again = _rehydrate_slot_from_history(state, "chat-1") + assert again is not None + assert state.conversation_log is not None + on_disk = list(state.conversation_log.read_messages("dashboard:chat-1")) + assert [m["content"] for m in on_disk if m.get("role") == "user"] == ["inspect every page"] + assert sum(1 for m in on_disk if (m.get("meta") or {}).get("kind") == _RESTART_KIND) == 1 + + +def test_a_copy_without_an_id_matches_on_ts_and_role(tmp_path): + state = _make_state(tmp_path) + slot = state.get_or_create_slot("chat-1") + opener = slot.append("user", "inspect the page", "msg msg-u") + slot.append("assistant", "partial", "msg msg-a") + assert _save_slot_to_history(state, slot, force=True) + assert state.conversation_log is not None + copy = _prompt_copy(opener) + copy["meta"] = {} + state.conversation_log.update_metadata( + "dashboard:chat-1", {"turn_in_flight_generation": 16, "turn_in_flight_prompt": copy} + ) + + del state._slots["chat-1"] + restored = _rehydrate_slot_from_history(state, "chat-1") + + assert restored is not None + assert [m["content"] for m in restored.messages if m["role"] == "user"] == ["inspect the page"] + assert len(_restart_rows(restored.messages)) == 1 + + +@pytest.mark.parametrize( + "malformed", + [ + "a string", + ["user", "content"], + {"role": "assistant", "content": "an answer is not an opener"}, + {"role": "system", "content": "Stopped"}, + {"role": "user", "content": ""}, + {"role": "user"}, + {"content": "no role"}, + ], +) +def test_malformed_prompt_copies_are_ignored(tmp_path, malformed): + state = _make_state(tmp_path) + slot = state.get_or_create_slot("chat-1") + slot.append("user", "inspect the page", "msg msg-u") + slot.append("assistant", "partial", "msg msg-a") + assert _save_slot_to_history(state, slot, force=True) + assert state.conversation_log is not None + state.conversation_log.update_metadata( + "dashboard:chat-1", + {"turn_in_flight_generation": 17, "turn_in_flight_prompt": malformed}, + ) + + del state._slots["chat-1"] + restored = _rehydrate_slot_from_history(state, "chat-1") + + assert restored is not None + # The generation still counts; only the copy is dropped. + assert [m["role"] for m in restored.messages] == ["user", "assistant", "error"] + assert restored.to_dict()["interrupted"] is True + + +def test_a_restored_copy_carries_only_identity_and_attachments(tmp_path): + # The metadata line is a writable file: a flag planted on the copy must not + # come back as a row property another reader acts on. + state = _make_state(tmp_path) + slot = state.get_or_create_slot("chat-1") + slot.append("user", "first", "msg msg-u") + slot.append("assistant", "answered", "msg msg-a") + assert _save_slot_to_history(state, slot, force=True) + assert state.conversation_log is not None + state.conversation_log.update_metadata( + "dashboard:chat-1", + { + "turn_in_flight_generation": 18, + "turn_in_flight_prompt": { + "role": "user", + "content": "lost prompt", + "cls": 12, + "ts": None, + "meta": { + "mid": "m-lost", + "files": ["a.txt", 7], + "dirs": ["src"], + "_directive_user_origin": True, + "sendId": "s-9", + "injectKind": "cron", + }, + }, + }, + ) + + del state._slots["chat-1"] + restored = _rehydrate_slot_from_history(state, "chat-1") + + assert restored is not None + tail = restored.messages[-1] + assert tail["role"] == "user" and tail["content"] == "lost prompt" + # A planted ``cls`` is not read; the loader's default is assigned. + assert tail["cls"] == "msg msg-u" + # A mixed-type list is dropped whole; the clean one survives. + assert tail["meta"] == {"mid": "m-lost", "dirs": ["src"], "injectKind": "cron"} + assert restored.to_dict()["interrupted"] is True + + +def test_an_oversize_opener_is_not_copied_and_never_truncated(): + from kiro_crew.dashboard.state import _ChatSlot + + # The copy is bounded as a whole. Over the bound nothing is carried: a + # truncated copy would come back as the user's own words, shortened. + slot = _ChatSlot("chat-1") + slot.append("user", "x" * (_LOCAL_TURN_PROMPT_MAX_BYTES + 1), "msg msg-u") + assert _local_turn_opening_row(slot) is None + + slot = _ChatSlot("chat-1") + slot.append( + "user", + "many files", + "msg msg-u", + meta={ + "files": [f"f{i}" for i in range(_LOCAL_TURN_PROMPT_MAX_ATTACHMENTS + 1)], + "dirs": [], + }, + ) + assert _local_turn_opening_row(slot) is None + + slot = _ChatSlot("chat-1") + slot.append( + "user", + "long path", + "msg msg-u", + meta={"files": ["p" * (_LOCAL_TURN_PROMPT_MAX_FIELD_CHARS + 1)], "dirs": []}, + ) + assert _local_turn_opening_row(slot) is None + + # At the bound the copy is carried whole. + slot = _ChatSlot("chat-1") + slot.append( + "user", + "fits", + "msg msg-u", + meta={"files": [f"f{i}" for i in range(_LOCAL_TURN_PROMPT_MAX_ATTACHMENTS)], "dirs": []}, + ) + copy = _local_turn_opening_row(slot) + assert copy is not None and copy["content"] == "fits" + assert len(copy["meta"]["files"]) == _LOCAL_TURN_PROMPT_MAX_ATTACHMENTS + + +def test_an_oversize_stored_copy_is_dropped_at_restore(): + # The metadata line is a writable file, so the same bounds apply on read. + base = {"role": "user", "content": "lost prompt", "cls": "", "ts": "", "meta": {"mid": "m-1"}} + assert _local_turn_prompt({"turn_in_flight_prompt": base}) is not None + big = dict(base, content="x" * (_LOCAL_TURN_PROMPT_MAX_BYTES + 1)) + assert _local_turn_prompt({"turn_in_flight_prompt": big}) is None + crowded = dict( + base, + meta={ + "mid": "m-1", + "dirs": [f"d{i}" for i in range(_LOCAL_TURN_PROMPT_MAX_ATTACHMENTS + 1)], + }, + ) + assert _local_turn_prompt({"turn_in_flight_prompt": crowded}) is None + long_id = dict(base, meta={"mid": "m" * (_LOCAL_TURN_PROMPT_MAX_FIELD_CHARS + 1)}) + assert _local_turn_prompt({"turn_in_flight_prompt": long_id}) is None + long_ts = dict(base, ts="t" * (_LOCAL_TURN_PROMPT_MAX_FIELD_CHARS + 1)) + assert _local_turn_prompt({"turn_in_flight_prompt": long_ts}) is None + + +def test_a_cron_openers_json_cls_does_not_round_trip(tmp_path): + # A cron inject carries a JSON ``cls`` in memory that the transcript never + # persists. Had the copy carried it, the re-appended row would reach the + # emit path with that JSON, be parsed into ``meta`` over ``mid`` and + # ``injectKind``, and the frontend would stop reading the turn as + # interrupted. The copy carries no ``cls`` and the restore assigns the + # loader's default, so the emitted row keeps its identity. + from kiro_crew.dashboard.chat_utils import parse_cls_meta + + state = _make_state(tmp_path) + slot = state.get_or_create_slot("chat-1") + slot.append("user", "first", "msg msg-u") + slot.append("assistant", "answered", "msg msg-a") + assert _save_slot_to_history(state, slot, force=True) + opener = slot.append( + "inject", + "[Cron notification] tick", + json.dumps({"cronLabel": "nightly"}), + meta={"injectKind": "cron"}, + ) + copy = _local_turn_opening_row(slot) + assert copy is not None and "cls" not in copy + slot._turn_in_flight_generation = 9 + slot._turn_in_flight_prompt = copy + assert state.conversation_log is not None + state.conversation_log.update_metadata( + "dashboard:chat-1", {"turn_in_flight_generation": 9, "turn_in_flight_prompt": copy} + ) + # The window save has not run: the opener is not on disk. + state.conversation_log.update_metadata("dashboard:chat-1", {}) + del state._slots["chat-1"] + restored = _rehydrate_slot_from_history(state, "chat-1") + + assert restored is not None + row = next(m for m in restored.messages if m.get("role") == "inject") + assert row["meta"]["mid"] == opener["meta"]["mid"] + assert row["meta"]["injectKind"] == "cron" + assert parse_cls_meta(row["cls"]) is None + assert restored.to_dict()["interrupted"] is True + + +@pytest.mark.asyncio +async def test_admission_without_a_copy_clears_a_stale_copy_on_disk(tmp_path): + # The merge cannot delete a key. A previous turn whose clear failed left its + # copy on the line; the next admission carries no copy (oversize opener), so + # it must write None or a restart would restore the previous prompt as this + # turn's opener. + state = _make_state(tmp_path) + slot = state.get_or_create_slot("chat-1") + slot.append("user", "first", "msg msg-u") + slot.append("assistant", "answered", "msg msg-a") + assert _save_slot_to_history(state, slot, force=True) + assert state.conversation_log is not None + state.conversation_log.update_metadata( + "dashboard:chat-1", + { + "turn_in_flight_generation": 2, + "turn_in_flight_prompt": { + "role": "user", + "content": "stale prompt", + "cls": "", + "ts": "", + "meta": {"mid": "m-stale"}, + }, + }, + ) + slot.append("user", "x" * (_LOCAL_TURN_PROMPT_MAX_BYTES + 1), "msg msg-u") + slot._turn_generation = 3 + + await _begin_local_turn_marker(state, slot, _local_turn_generation_for(slot)) + + meta = state.conversation_log.get_metadata("dashboard:chat-1") + assert meta["turn_in_flight_generation"] == 3 + assert meta["turn_in_flight_prompt"] is None + del state._slots["chat-1"] + restored = _rehydrate_slot_from_history(state, "chat-1") + assert restored is not None + assert all(m["content"] != "stale prompt" for m in restored.messages) + assert restored.messages[-1]["meta"]["kind"] == _RESTART_KIND + + +@pytest.mark.asyncio +@pytest.mark.parametrize("mode", ["incognito", "temporary"]) +async def test_a_restricted_session_gets_and_clears_the_marker(tmp_path, mode): + # The transcript save writes every retention mode's rows, so a restricted + # session is restart-durable like any other: the admission writes the + # marker, the teardown clear lands, and neither state outlives the turn. + # The recorded memory_mode is what keeps the learning readers out, not the + # absence of the line. + state = _make_state(tmp_path) + slot = state.get_or_create_slot("chat-1") + slot.memory_mode = mode + slot.append("user", "earlier, while restricted", "msg msg-u") + slot.append("assistant", "answered", "msg msg-a") + assert _save_slot_to_history(state, slot, force=True) + assert state.conversation_log is not None + slot.append("user", "a private prompt", "msg msg-u") + slot._turn_generation = 4 + + await _begin_local_turn_marker(state, slot, _local_turn_generation_for(slot)) + during = state.conversation_log.get_metadata("dashboard:chat-1") + assert during["turn_in_flight_generation"] == _local_turn_generation_for(slot) + assert during["turn_in_flight_prompt"]["content"] == "a private prompt" + assert during["memory_mode"] == mode + + await _clear_local_turn_marker(state, slot, 4) + after = state.conversation_log.get_metadata("dashboard:chat-1") + assert "turn_in_flight_generation" not in after + assert "turn_in_flight_prompt" not in after + assert after["memory_mode"] == mode + assert slot._turn_in_flight_generation == 0 + assert slot._turn_in_flight_prompt is None + + +@pytest.mark.asyncio +@pytest.mark.parametrize("mode", ["incognito", "temporary"]) +async def test_a_restricted_session_killed_mid_turn_restores_resume(tmp_path, mode): + # A restricted turn admitted, the prompt row still in the unflushed window, + # then a force exit. The marker copy puts the row back and the restart + # offers Resume, mode preserved. + state = _make_state(tmp_path) + slot = state.get_or_create_slot("chat-1") + slot.memory_mode = mode + slot.append("user", "earlier, while restricted", "msg msg-u") + slot.append("assistant", "answered", "msg msg-a") + assert _save_slot_to_history(state, slot, force=True) + slot.append("user", "a private prompt", "msg msg-u") + slot._turn_generation = 5 + + await _begin_local_turn_marker(state, slot, _local_turn_generation_for(slot)) + + del state._slots["chat-1"] + restored = _rehydrate_slot_from_history(state, "chat-1") + + assert restored is not None + assert restored.memory_mode == mode + # The restored opener is itself the unanswered tail, so no extra error row. + assert [m["role"] for m in restored.messages] == ["user", "assistant", "user"] + assert restored.messages[-1]["content"] == "a private prompt" + assert restored.to_dict()["interrupted"] is True diff --git a/test/test_to_dict_board_fields.py b/test/test_to_dict_board_fields.py index 717f35e8ea9e..06dd162f28e0 100644 --- a/test/test_to_dict_board_fields.py +++ b/test/test_to_dict_board_fields.py @@ -280,6 +280,29 @@ def test_not_interrupted_while_running(): assert d["interrupted"] is False +def test_interrupted_inject_successor_outranks_older_stop(): + s = _slot( + {"role": "user", "content": "first", "ts": "t1"}, + {"role": "system", "content": "stopped", "cls": json.dumps({"kind": "stop_event"}), "ts": "t2"}, + {"role": "inject", "content": "continue queued work", "ts": "t3", "meta": {"injectKind": "recovery"}}, + {"role": "tool", "content": "read complete", "ts": "t4"}, + ) + + assert s.to_dict()["interrupted"] is True + + +def test_halted_hook_inject_is_not_interrupted(): + # A Stop-hook halt card is appended as ``inject`` but dispatched nothing, so + # the deliberately halted run must not read as interrupted. + s = _slot( + {"role": "user", "content": "first", "ts": "t1"}, + {"role": "assistant", "content": "done", "ts": "t2"}, + {"role": "inject", "content": "Stop hook halted #3", "ts": "t3"}, + ) + + assert s.to_dict()["interrupted"] is False + + def test_interrupted_scan_tolerates_non_string_cls(): # A row whose persisted `cls` is object-valued (foreign writer / corrupted # transcript) must not crash the summary scan — `to_dict()` runs on every diff --git a/website/src/store/chatSlice.ts b/website/src/store/chatSlice.ts index 1bc4a9b92299..8d01e2bc1c0c 100644 --- a/website/src/store/chatSlice.ts +++ b/website/src/store/chatSlice.ts @@ -22,6 +22,7 @@ import { safeSetItem } from '../utils/safeStorage' import { errMessage, isMissingSlotError, type StatusRejection } from '../utils/thunkError' import { jsonEqual } from '../utils/structuralEqual' import type { McpAppRenderPayload } from '../lib/mcpAppSrcdoc' +import type { InjectKind } from '../pages/chat/RecoveryCard' import { i18nT } from '../i18n/t' import { secureRandomId } from '../utils/secureId' import { mergeIntoDraft } from '../utils/chatDrafts' @@ -4278,6 +4279,25 @@ export const selectComposerBusy = (state: RootState, slot: string | null): boole * `user` / `assistant` / `error` rows. Keep them in sync — these predicates * decide whether to OFFER Continue and what to call it, those decide whether to * authorize it and what to tell the model. */ +/** `meta.injectKind` values the gateway stamps on an `inject` row that dispatched a + * turn. Every other inject row opens nothing. Mirrors `_TURN_INJECT_KINDS` in + * `dashboard/state.py`. Keyed by `InjectKind` (see `pages/chat/RecoveryCard.tsx`) + * so a new kind does not compile until it is classified here, the same guard + * `INJECT_KIND_OPENS_TURN` carries. Wider than that record on purpose: it + * answers "does this row start a turn the failure streak should count", and + * walks past `recovery` / `user_replay` because they resume the same turn; + * this one answers "did a dispatch happen that got no reply", and a recovery + * or replay dispatch that died is exactly such a turn. */ +const TURN_INJECT_DISPATCHED: Readonly> = { + cron: true, + mcp_app: true, + recovery: true, + synthesis: true, + user_replay: true, +} +const TURN_INJECT_KINDS: ReadonlySet = new Set( + (Object.keys(TURN_INJECT_DISPATCHED) as InjectKind[]).filter((k) => TURN_INJECT_DISPATCHED[k]), +) const CONTINUE_SCAN_SKIP = new Set(['queued', 'tool_call', 'tool_result', 'inject', 'subagent', 'permission', 'nudge']) /** @@ -4404,10 +4424,25 @@ export const selectTurnInterrupted = (state: RootState): boolean => { // segment had flushed first, i.e. on invisible timing the user cannot // predict. The user chose to stop; the floor is theirs, so the composer // shows Send. Reached only for the NEWEST turn's terminator — an older stop - // card deeper in history is never scanned, because a later user/assistant - // row returns first. + // card deeper in history is never scanned, because a later user/inject/ + // assistant row returns first. if (isStopEvent(m)) return false if (m.role === 'error') { sawTrailingError = true; continue } + // An inject row that DISPATCHED a turn (a queued continuation, a recovery, + // a synthesis, a cron prompt) opens it exactly as a user row does, so one + // with no reply after it is an interruption -- and an OLDER Stop card + // behind it must not be reached and mask it. Only the structurally tagged + // kinds qualify: a `/note` breadcrumb, a Stop-hook halt card or a refusal + // notice is appended as `inject` too but ran nothing, and offering Resume + // on a deliberately halted run would be wrong. Decided before + // CONTINUE_SCAN_SKIP, where `inject` stays for the selectors that look + // through continuations to the prior user floor. Mirrors + // `is_turn_interrupted` in `dashboard/state.py`. + if (m.role === 'inject' && m.content && TURN_INJECT_KINDS.has((m.meta as { injectKind?: unknown } | undefined)?.injectKind)) return true + // A monitor loop's cycle row always dispatches a turn; unanswered, it is + // the same shape as an unanswered user row. Decided before the skip set, + // where `nudge` stays for the selectors that look through it. + if (m.role === 'nudge' && m.content) return true if (CONTINUE_SCAN_SKIP.has(m.role)) continue if ((m.role === 'user' || m.role === 'assistant') && m.content) { const meta = m.meta as { kind?: string; notice?: string } | undefined @@ -4431,7 +4466,11 @@ export const selectTurnInterrupted = (state: RootState): boolean => { return true } } - return false + // Ran off the start of the loaded window with no conversational row: a long + // turn can push its opener and reply into the frozen prefix, leaving only + // tool rows here. A trailing error row is still the evidence the assistant + // branch honors, so it decides the same way. + return sawTrailingError } /** Monotonic tick, so an observation can be ordered against a request already in flight. diff --git a/website/src/test/ChatSliceCoverage.test.tsx b/website/src/test/ChatSliceCoverage.test.tsx index a9bca73286ce..83f39876a2ed 100644 --- a/website/src/test/ChatSliceCoverage.test.tsx +++ b/website/src/test/ChatSliceCoverage.test.tsx @@ -945,6 +945,16 @@ describe('chatSlice selectors', () => { expect(selectTurnInterrupted(root(store))).toBe(false) }) + it('treats a trailing dispatching inject as a new, unanswered turn floor', () => { + for (const injectKind of ['cron', 'mcp_app', 'recovery', 'user_replay', 'synthesis']) { + const store = makeStore() + store.dispatch(setActiveSlot('front')) + store.dispatch(appendMessage({ role: 'assistant', content: 'answered' } as ChatMessage)) + store.dispatch(appendMessage({ role: 'inject', content: 'dispatched prompt', meta: { injectKind } } as ChatMessage)) + expect(selectTurnInterrupted(root(store)), injectKind).toBe(true) + } + }) + it('reads an interruption from a trailing user row or an error after the answer', () => { const store = makeStore() store.dispatch(setActiveSlot('front')) @@ -959,6 +969,31 @@ describe('chatSlice selectors', () => { expect(selectTurnInterrupted(root(store))).toBe(true) }) + it('treats a trailing nudge row as a new, unanswered turn floor', () => { + const store = makeStore() + store.dispatch(setActiveSlot('front')) + store.dispatch(appendMessage({ role: 'user', content: 'watch it' } as ChatMessage)) + store.dispatch(appendMessage({ role: 'assistant', content: 'watching' } as ChatMessage)) + store.dispatch(appendMessage({ role: 'inject', content: 'stopped', meta: { kind: 'stop_event' } } as ChatMessage)) + expect(selectTurnInterrupted(root(store))).toBe(false) + store.dispatch(appendMessage({ role: 'nudge', content: '[auto-nudge cycle 2] check', meta: { nudge: { cycle: 2 } } } as ChatMessage)) + expect(selectTurnInterrupted(root(store))).toBe(true) + store.dispatch(appendMessage({ role: 'assistant', content: 'checked' } as ChatMessage)) + expect(selectTurnInterrupted(root(store))).toBe(false) + }) + + it('reads a trailing error when the loaded window holds only tool rows', () => { + // A long turn pushed its opener and reply past the window into the frozen + // prefix; only its tool rows and the restart's error row were loaded. + const store = makeStore() + store.dispatch(setActiveSlot('front')) + store.dispatch(appendMessage({ role: 'tool_result', content: 'read page 1' } as ChatMessage)) + store.dispatch(appendMessage({ role: 'tool_result', content: 'read page 2' } as ChatMessage)) + expect(selectTurnInterrupted(root(store))).toBe(false) + store.dispatch(appendMessage({ role: 'error', content: 'gateway died' } as ChatMessage)) + expect(selectTurnInterrupted(root(store))).toBe(true) + }) + it('treats a deliberate stop as the end of a turn, not an interruption', () => { const store = makeStore() store.dispatch(setActiveSlot('front')) diff --git a/website/src/test/chatSlice.continuable.test.ts b/website/src/test/chatSlice.continuable.test.ts index 6bf5c50880ee..d1bc2b900a42 100644 --- a/website/src/test/chatSlice.continuable.test.ts +++ b/website/src/test/chatSlice.continuable.test.ts @@ -363,11 +363,43 @@ describe('selectTurnInterrupted', () => { } }) - it('reads past an injected recovery row to the real floor beneath it', () => { + it('reads an injected recovery row as a turn opener', () => { expect(selectTurnInterrupted(state({ - messages: [msg('user'), msg('inject', '[Continue — requested by the user]\nresume')], + messages: [msg('user'), msg('inject', '[Continue — requested by the user]\nresume', { injectKind: 'recovery' })], }))).toBe(true) }) + + it('does not let an older Stop mask a newer interrupted inject turn', () => { + for (const injectKind of ['cron', 'recovery', 'user_replay', 'synthesis']) { + expect(selectTurnInterrupted(state({ + messages: [ + msg('user', 'first'), + msg('system', 'Stopped', { kind: 'stop_event' }), + msg('inject', 'continue queued work', { injectKind }), + msg('tool', 'read complete'), + ], + }))).toBe(true) + } + }) + + it('treats an answered dispatching inject as finished', () => { + expect(selectTurnInterrupted(state({ + messages: [msg('user'), msg('inject', 'go on', { injectKind: 'user_replay' }), msg('assistant', 'done')], + }))).toBe(false) + }) + + it('looks through an untagged inject (note, hook halt, refusal notice) to the real floor', () => { + // These rows dispatch nothing, so a trailing one is not an unanswered turn + // and a deliberately halted run must not offer Resume. + for (const meta of [undefined, { noteSession: 'dashboard:front' }, { injectKind: 'unknown' }, { injectKind: 7 }]) { + expect(selectTurnInterrupted(state({ + messages: [msg('user', 'first'), msg('assistant', 'answered'), msg('inject', 'halted', meta)], + }))).toBe(false) + expect(selectTurnInterrupted(state({ + messages: [msg('user', 'first'), msg('inject', 'halted', meta)], + }))).toBe(true) + } + }) }) /**

A0Fm#=~ia6TNQJX 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�h=+0aZ^|rl@K?Ji1l%iK6j0q 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 Tehc8vP*CXU7;9rR;o<)W%B+GL literal 0 HcmV?d00001 diff --git a/temp-screenshots/restart-interruption/restart-lost-opener-restored.png b/temp-screenshots/restart-interruption/restart-lost-opener-restored.png new file mode 100644 index 0000000000000000000000000000000000000000..fd25ffb42def0bc79207a26f2f62bfce71d7d59e GIT binary patch literal 91650 zcmb4qbwCtR`|b*Yii98`AfSYFNl7D0cXvy7cPWB`fJ!V#EVXoZFC9yFcP}itfGjL~ z*YEq?d;h(6{@9(JnVoay%sFp7&+~p)SCu2cqrw9K00av1A2k609Lz3u#A7VXm%Hy% zZ2;gIK;h$iZNK!R6&!QYx!FgjEty9y%PX(+!`6=pWen5tNLifCOtQEt?k{JIV6xfc zG+0>X|2??>>>1#{S4u^N0bcy~pvc3A9RL9Qd3=Au&=I30 z`!9LMXX_Q>%l`aSb(&yJ7WN^i;)^NX{h#}4sZt#U56Jd8L1VV#rgn9PRIqQlB@+(& zXagl4Cq67%&{!^g+g~xC?+%KN~{zbY48YMHe zo}GYW{@OJ*QoI|naATV^vlJ~IozAT8tQETlW-M7-zTZqm@Ci^cV2ue$!{yGnzDZX; ztZemYgwbZnY7)YaAK0xUjFoi5L*uC1<4e;+7k zfp7Ne*+dmldq?f0zRQs4?08Tj`D`II#d}I=v*4qc=MNVjBS~f)lJd(UJF%!!Ik5p@ zSD!r~nnkTIC%9|5*^)k=cO)8RWw7DGse0S!iDlk?hGhYlLU&VJ-!02O?1mGn#gAoB zu5>6o3<_6gltnE0>_en8J5I^!d--yzvH^fvI)qwWZW~{YnH>-cjmdavOj+wldL7+s ziPXwp^AsfT^>3xFfKj283LHPCJoLrGvzDRft+23tdr?@WKipq*?u;+ffjj}LWX8qe z^8lo7UjvtlW)x#(M*xcqWx5O`3Wqgyz0+V2s~QYueimv2L{cFCM+z z4{VKX69vz1g35ID#t2UR#H!>!?>9KV-9E=b_@>qI4*VNJI+Cg+^6Qq*S22RFivyIk za)|?N#HhDc(Cf8t4ZA~mnK}iZDQmeS#VRY~T$5$LU)l~aAe~$Gm$KKqjc)zv0k{A= z$sYPD!&n4&tx>K2lvmGkvUTkbPx zu&PxUkF>Bam2#WPn9OpX4E;V5NS+(J+&49)#MNNI`A{wLA?DWmYcIsk9xw7Pwo!hf;9bD(9cU+H=6Go>+=uiW72raUGu9(r#q<4^fTP>O{_+w6L1!<|_j=7sbF z+EVSniu*mwyx*LprCFa}U1eJs8nU&}$i}_Q)+|v2iH!VFVI=jx@nd3oQL7bVc3^JSIGr?oLUu!)?G0*3!XKdCsL( zSyz`Pd_hY`XLjuD-~g305==@?s@}C%1O#2cTm9+<1)0D?D{f!=sZci#%k;yuef4>@ z(}+Cu8^jaLQXG4(CdP>rdZe$Z`TO_ppwkWsm8F)R{rVIk*9~wC#pb3JCC_Yy8Txod zn!Y@;NJqf+WrkUbnX&F9UtWW5iFnA-<1b6G9v|N{1n;KGLi!qh*uE&);x)O9+lqaW z!Y)W81NriZ2;7y*SK#7~FJ^a|<+~buyFXz?%3K;?v7^M@{*sJRCwHU|BDA=)4o3M*~bjt8F? zs9W@WBfegN>~E08|52T6Gm39R%R&gR2onlaJ>7j!sB3|nn;T>6vCOt8Lh9@ZJLr(2 z@A0y!rlxX|nk4GZ78LyPYe!aA_J_y{qlQR<7Y)wS?Qw~3yIXOWuY_N**v$?vR81f+ z{pU>h8k|s~yb`OLRAXapRJI zkGNh#n+F9Q-3PZ^JUvfOHn{!>6w|b@85ybT-*W56DJYw&-aE?YwV}q*xK%aLT=o55e5Q_!x`eh$S+ZZnL@tD zzZm2=bQHmpJM78gx5J+9RqpYUH-Ce#S8g|=&^7#K;bEa`Ik(j{p2Km$=7ZR4A*fjU zSRjyspr)oKWn+&ow6pE@>V#4_D6cA9o{>tx0YMj9IyN*!BOb7v)%oG-WXWo=`!t(@ zh(@A=YS2xHLj?|vR1UlzUH}E1TU@4PEM@xp%oOxB?Aq{~cVu1cjcG3QF8Ggs8BzmD zxZh05_&Ap7pY8tu z>skeIH8yqu0Oh5&f~W?4Mnx4R`vq)#!wf-A&ffl|xv42p20j8`0gMZ)@$mH2Oh|wq zA)Y*wltgcDGnQxiIIOIQO-^36RMu*xrT*I3+}u3e17fzH>KF5pC{OZd&*T+;wBEID zZ}%)xXaxHEPfeI2fn4I^8TStaXN?RDv;@BpF81~J>gwuvB=NW8zcEcxPsq`-kC8D? z&&Nj)?x4B)d*uy-TwK;NHyM&>-;uM<^mb|SuJw*d33!LRs1PtzP3L#-ia6tjAQW|U zlE8|O9z}I^(MN|A1tF)4aGsJ+^E#q}lW{&{x?^c&nG{JEGf_B^8yyqFZQAG`;ps8pa`**h}zi%fRhvI!Usxz#e6m=#R5-Eqc2cX33SPOv z5KkxSfkNuI`0VVEEi9zg*ZYWn2$(VzmN^jgNRtS@MV}855!jpi_;UnD6EnzO9)&tc{NAB zO+9$us;TJ}At85bEi4xuY;3CQQm+Z2O5x(+IW0f%%@A|XIWGLru?0EpViU=qb(KQ< zt_Iw0eucSRXOj^TQ1c#5#Y+k}E4QG+?;psioHxkSRh$dF{O;!A0h?jx7ZmLCI_{2) z-G8}k9hyNwWYopy3$hKt#$rPnUf`XpI6|RAy_QcLU&!br85+@i@e929K`E43&l|4p zw{h20qSu|eF}^*|yT$5VFkzRIQ@*q$`cfiDo#U7CpLhPZS7pl)i76vPBPz;@JWC(! zKp`2T-uY!h%lapT_U3(S) z=Q@vGI{Lo#nm?uDt3wbUr;0aJSF<&Go>n-9aB#5+E>_EpkE60l5={R1;IoFZ&*&yjV_ zOM81ev|^3%l&Y!ij*DJX0R1dTZ=v~CpJZXT<6L>U{#oIdFIJrpQDu^PDg zx9@VNQptDh&xZ$<`W&=EE|VvRA)IVnIRVs0OT9!Ku`%&FY>2S}ai1f3OG`2MjW`m- zZ0{O>g;jJuAxGz1>C3{wR@(AjLE$@irwGMr$BXeu_wDx$Slu(e9;rbG)nxcCZ;}S> z8$(bkb1&QP&Z&{eJ26~m?D#R4X6)HmVkGmOZh%4B?7`Z3^ot6dD}2`K;^NZZ^1~lL zda*=%Bq8`dm32cE&ktQ8?bpY*{c$v*@YuQ43A0-NKldDs%}vekgi%+Ai;D?&cNg3c zRQ*-moLSpmW+01(u^d>6CF_$%+fb!df1G&BwI<-MWAjm8Jhd%;ScP%ZWUkzG`AT!7 z$rC=o5!=*kd`aC)u8`q=XK`!nk z*^Bvu>A~m2Zi45#BWVulu^hkj2`I(9F4m|o&M)@uy0YGXxjtEQTnxMCO_K~I)*Bs$ zz6&|hhYL@>{=JwnomsRHFNG5d33E1TI9h1?Pyi8IyA!FZwWPkSWHS;Kt@@Y_)VjF4 zTW&QLiLh{VR6-k9=Q}6@jy8`RoH?zLQ{|r>;zyuR7EWhGThq1&wHgsOAA^?&@=1$G zi_P9AK8z>B`&eOI$})$x;z$@|R!;G|I`ntCtm;>Er}gmb0(@Q@CF^ zsFgoxjl3g)(`snjzdYRER_-5Y+6QibvJJgnabSBVER6AX9upPqMj{cWnn$orXvQKC zSRsjuzapAuV}cuaI43HC)fqRT-u#7D{tlsdhWLg=eKc{^=WmaPKLG5${rqVv=&>|a zpz3km{#GU`Sy55RkQ>RghB{qg=Wc_7Gt7c_>QIla-Gw?~3nhEdJ-rz_j)q^iNTeym zC*%ABkjvzFk!fC&$ye6TN%;ufh7Ls`uggTs+Fal##;^JKYP1Td126Z+GW1wTE84H1 zyAYw0#2MfdjP2f<+(D}1&K`^zVxo|R8ed?1e8s_XLPCNz+YI8MraZ!A+RkOAC_|2r zj!N7{%$Me%vFbVD%fdapPtk{sY2kdR8GbDA26;ecW+qnnD;}P2rph2n-M^a9Y3QGO zDlLSPK$1?<-e~6WjOesxgH7PKZ;!b-*#7Xidl)+%Rawa$n)2YOpcntzs+$*ZnY1hn zIPZ5j#^M^5_4z3($;f6mQVy%wyah#G{@c)dem-9 zLjcpyTm*GhzW7WPgGtAwL^!ve4x0=(HtyAU2Y}B=?WA1^gg)<9?XIw0!e-o*n4Kr% zTuN3Wz2_?}C`Qe)9?s>W{Sh^45~6{-N0>OZssB~m88WSIX=!1x?fO12zSJ+`s_nxq zLRCSvO4~qRe}CPa?!}9gpFep%4g6eAr*0YVjv}Iyv{>$^3$`5AMy*BBwO+0@K!@0o z5s@}FHmRe$VjSrr=>m?keGoy|p0(@V{(j0c3cc&S9I zAkbWiFR0H{$5Fy~R)FP6dO}*l&u4PHIM#DkTbAdCF|5iJdEiik=7+wqvERw@WT3@t zTQfu2EG!&uK3=*kWPMNA(XnA(Lbjp@Ja4A@Cv5`8VP1hga5vBE$9Q;D0v^)`d76F4tI8Zh*gi9&2i9wTiW6WS9(R;;hv6 zztYjwO_@~>gKzD=?*}zHhMm1&1ON&@Xjr@lx~$N5T{0hGUQ9{2maxb>Z5 zC?lioK*sT=$v-iS03Vk4tYQs*IKjY}C&!H!cH!Z9uoe=E4$I5?h>B#7B(nd zfSG1e+424jdatg&=hyw(A8PonrIDwR($@s>jW~B?_5*dcbu(xk&+oZDbD0?Gw zERI64@aus}CBn)((j;Unb&Asqhnva6ZZA#5v2AJNE$X0d5((WW@MnIzWUFMjDzicr`CF~ z(e?2%X5{g*yzsI+wJ0&Qz+tL%@Lbrz`R#>N-XdV$x30=OM@6>j<6 zcuh@Bzci2$o_nL6mt3t2!m}&i-ScfEr9U8Ty~|Z*&A;FhuySy`3%N^KsA7(zfs>Mo z`3;Qc$`RGPvER(LM2+z9X^M-t2Db*WdM<5Vcjj2lPxCqFH$LSD0Qh@07^3>()81vF zvnD5h_eA&+5sgJEC#5Iye;TM{Qc9i}wbQYlxw)_{P;GMD%9m_Piy2>CJr)<0jeW`Y z=~SJovn3QwTOP8OY0@1PpBI{UP^QngSYvA&lRj;0?>{U!%iY($QoHp2)~D95x3_mt zXbo2MB~8#ez{Bvou7ns^VSIje#z!L~U|^8?T0HQ^{}#U7meJ{4&~nrIIFq+@CZ1T= z&RCUPr$E~4Xl=g%X>$1?-01O6L@bf4Wtk1S9o2GuYW$waC~b@MP75&vtcWCuD1D%gNcP2}d-@4ZY$!mMs-||AYC>8+}-~sTa@Y{p~;3 zd;91i?YqkOG?Vx5JD2^RYW+@#dnx|O7ujbd+e=Mr}O)RkKaFPW{m8dHNK87xV<(VH)f(Zr#ilJQbzx21!u=3$UVQu4G6q- z13mx=dlnC>0rEL(G-~Q=YL-s-keHZBiE%SiJn(*RqCe63l9}V#V{tJtm$RB*DjI_A zJ`z9r_mrr7ByIJC8ae3_*c8Hcsdy}6P&D()R44Tm97F;u_gW9{5Y#U z(yagOe)7{NoB5^1I;S{Y+jj|N@({`JWp2!xkycgJ@^NWo#+~b&42M@&zn#T{nPgI( zy9rr&;+j`Ap z8zPirrn{0k_v7!b4~}0HA&sSafk?yB!4{cFvh7?MK$hNQHSaH7#p4>&qy4@c!T5j)>8DNMwvdx zEOU4hPqOWAyds(fSaAhFkn_S%KD}1ROF!>8bmF6>`-k5hZqyn`J+OoB;%sN=DRYT6jf5~NciKu-+n&!EuHK(zfLZ2xY* zKlBV$uVz@LTUO5OS*XkEPtPtvw-!PTo`Gq@c4-s2IXGCHve}b`37Y+>0Dxs;#i8h( z>OS!~+I2#D;9_!8-6>~(7JU4mma0yX4hmD2HV&}&o)K79Dk&+qoe}sJvP74mTA*8U z*yfhlCnVYaSy$Q&biZUDNQ5AsH`jXt$fD6G((x#Y)ttfd{SL6xVnK3pah3`(JoM#X zw90R#TMJ9w4IAMX__2M4>8fNcL7}!ojhf`!525Q3^^_0lBLrnYw>qqgyIW4g|Db#J z$kQ<9gavxs$g3V%8$DA~U2viK_$sBPISmCib&gTD=TGIUoDz0oWW848zTQG%i!kg( zZwHmj7mIP+7wsQq((pqr|I4GW)oGSYi3m4N5I&3_6M7litF^N}+P!s#VIo z@t&c47$c|5E}4Z6t*EYC^C{lD-sVrhrWJJ()a>(}BPs7^x@A46Cyt{O)fSRLyI)$Q zFkLkAXv+BLr1Bs_D$IzsD?=`K;sl>PDGA(o+<={Hjse(T}ZhoVwX zkPjT6%q;x~8_SUB=;o|8d>-t-EP$kn-B4H!BYwPUm$5$kH5kcYKu3$q$N=ndZeWjyKJ=c=Ai@MIW zKk8>-1WA$a{2v^XB0h|xr6Oh^#Ea$ZY*0g(&_9xK{DA;JVAm3N@rkF8mlg||PP7N^ z_+)8WUSh$>$k?QvKxt9S-x&k5_VK}q*mD~l9Wwl1ShYkVHrCdh*=zFeeLO=L{yjQP zatCJ8xH53%RQ_5Lo)-q{kd|oU;f~`?JCIr1(a;#%^_$wy5BsTz$e3|8c-DGyRj_Cl zC4LLZMy>PKMTRgs$OYO4%+;H{+Y(Uak_XNmA8yFCAM8KhMWuI9vB?s zKUx*?LbnGPd7n=^=#VA7Q+Tk*=g5w7Wo*cDhY(}_9!6N6iO)l!(I^sFoT#G{jfd-| zR5-0j8}G{CTUf|pO)%t+qDBRH8h%O}6wMUxL}K$_uGT~ScKK93Yaz0~U<^eql?ry~e;&UBMi_RP>yOnmjcY5> z?fjlPGj=(ye@`fn*SSPc(2}qT;OE=o1m0s5k5Zh`d0?HcnqtKlsRD^Yil;QW^Znz*ROU=Od+| zX#1L4uk75iWz({JXPxdW-qNy9^e8?XnV|5j)jq>mS+K@0HW^CC(~-KB(m>w^5d75> zk3_F(auFW8N=0vraQbp7Vmbqaua9*K*oLZXLx{eizf%#@$*_P_$Wwlx@~PJ~JKJcP z)na*^C$4`v=_!Fm?ZUvv{sC2<^$r?>R zu?ydp8Hc*e@^%>}f4@zQZiOD*x2euD{@-OwbR4w_ZYU?Ab5YQsaAOChK_BbjIl~M8 z%}y@0OLtS~-VB||2bx-u5pXMLbT=s9I+;-J9Aj_ZR%^L&VLS&wYK3DJ$MDrNXr70X z?^Ip&?^U6LZj0B~21}=uW+kPQ?hB@-vCkq3YCNrSkIDEn{QdkI)mah;KN;gQJbT<1 zM?F<%1k8v;?aMkmd?azrK@*yy!TlTDa`o_ZeRtpaNWObp>-0hj zR{p*5Fn=2?^JDk7iLXe$_ay%oyC5I-zx)yyOrjf|GYiB>0>NU~LxK0EdE*$Kb>6(ghm|r2k9(}OdV|mNwZo%`U`oBDB)+=zDZ2n!43(|KINmwyimKsKK~sdvsVof3D4m^EY29Dyzq2-!UKQr>NK|B|qiqpo{41bhE7u zGY0MbEQ>-gE2c-!)Sro&+4f?0L{(K)XiT2p;>ZNQy!`aL$UES*Q zbCOwUD7#V_)8yi%3H)StYj{sr%CW9si@qjzAMjKDQ}4f_$x==B(e$<)df%H;mFu7v z&DiSlp|sQ~$uL6}^j>gTR;gqvY1@&NdjpfH?CuI;Kn?H1*^xg2Ltb6m1J%Fh0l4Or z&e65+4V&9FIDYGk=wl0f`$}J?J7oAxHSbsH3|B@-(=J0^|74Nml zzox@jv%$nz;XkqTYjOiFVS^a-cp@Sy%5|+h`2Oyuv$KkBtjn^io-9viuXXHu_m>)oqZyH&rdzi&gzrx21I*^CWu3&e#}Mr-PSb5YCM(N9 z!FLYnz20}+nRU%RPo97BHP(dx9 z##cs7dvixe58GpV(gfnQ-)NO+6F|~x%VNuvxwu(a)LE#!;8n)^E}UL$nvBI>WcbIQ zP>=9mN;on0HYC@RSLurd{TnjGn7h}Ho^E>xgO`S&LogRvlhoj_%8z#4 zS>Ez8qnNA+kTvpC5j=JBhl&5?w}$%U-Mu}Rn?2WAvHOq*nWn2);i)xA0#wej0fw3$ z^p3^(w)iX=w>{6*l>hLvGBD&~QgcB;LGV}DoiZLKSA+(be3kf?VW`vfPMJg3QLOq~SC#ff9{k^movE?Av`fh7Nk@4f8tdy2E`>48?$RrHFdt%b;cCZHuwJ4KiA;nO>bZkLqz03{kn=ltEgY9hGx>|3mU>n#| ze}$t(iQWC7096~k`kGDU+0UN{OVP$Y-rPfKHsi(n=2LrSK`uchg~ieF@#xDr0WcWs zt$f)FG>eG(iu${ycBDGqqUTzsN=-bm4B6Aw{r!lXn^w@PFrmiNPya6{^p298*2X?A z{%(($Eioy%+_)(kIj4HEb7x3Vb;T4GV97Va?byTGrc^a60S{52F1UF&ll?(X9g&upI3NQ_{$y*5VGY&o;3p?^ z%V5X%7M(>}%!MJa+Jm^bxIOOlq0v!11kuqdLtb&t`FeKnZr}uObci#f#0Cz8Lc7vT_aV5z1ps(N}-+pP1zkji1{>;5Wkj2uT-%u9c>j`W!$8n+C`?AgjD&+b)E&7 z*F8#7_ZVNZ$;;3O;R2(L?e%jMt>8luPZBh>w1{Y1t1{(&yyPT~X|f`3AhEt@MNzNQ z*@+bx7O9g{P^8umLPwA1Twggd{?bQ;qOZeyps=o+iybnu4^f1uF)Or!l9FWTv6$oQ zW7=brX0KoJrG^54_N3*O>Opn`3*4dTVo25SugkWyq}}SQP9$J{R0S<~to`&+hi*O6 zWs07P6tLu9S;SpwC0UIq!KaFei;9duuyAo@OA;dLjjmlVyus50%Jb7`Iao?@V7v>? z&CL09cVZza=2mA9PWy)0qo5H%!tn>5 ztv{5C&hXJ&Rp(gmdn|OOQ`xGt3v?aX75SAJNX~o3+Cv_AUE*MrSqfPGp8WglRCMoGPPQ(P&^1c-HMMk+vjn4|Q&UZzi3vuZ{v89(BYV zw+X#^wSKdww;GBL_9_JaTjhnXKScTv61GzjckYPTS7Z(Rl*M~;;5}DMx#WAdwZA_- z4AAFD{uYsQcPCb3g#n@hBN5T@vDt!&&mGohN(K0t09>rdWHWCKh&{rPwsyRQw%Tu?UU&xZD{LtYDQ&Ttl4=VcF+S!bVMBI-uwW~*XZrnml=_4Zt06^s%N1+us>t%|NJSNo88TS zI9txn+V1|A8J;3>iAa!WmmvAh$iQGV!VSp~^ZyN#i>37*I|{_Yy3^9q97`9jxoYq> z4y?JP3%;8;NGMqK-!qy0L*++s>imngGeFHM{ELBmUo7&Y(UqmOv>puu-McnS@-J8ms<7ro>6$J$TuA%SyV=?KQVbl3d zm{e%@0+YX7{7ckTnrqQL1Rd;o)L3Plw#6JL)8E5k*1SB~I?R=#;jVFpyrjN5k?d$2 z85}GsEv&9CznNyo`$54SvOZsBWjmG*2BiF(<@}0FrfpR34a}w#tq_6m#TkokS$^1R zZG(&!*18&P-1Bc<2+a~Nwy&zWq=h99gWe>_f6PECM6Pfa?CY`Yo;^ga$i*7!85FmL zG~XRvRp&SbzffktXEn=+6L5hyHtwqtNqFr`85p2$cStQKV%W`|v;GeuKpV%8{Z7^KPvt@oHi$X7d*v)BBb*f6@+yb!)mE&8B<6cqvs`=p?`}5|7 z7*vsZsUoLte!x%^j2&lmAqftHtx^4$a5WC%a5S5ooFt+Z<9At}H=DbYo^bW@8g6g9 zCAnAmbarz$x8^r9xZsbGE!_CyTo1S3eg*1snzWWSHvVne1F5L0BJZZgZV~WXj4)wy zi$pa;L?)_kc(!KNH>To&3rB3Ubw3X%QwYl(_)75p3AtywGm87rmx%g;W$4?dulCBX zEIn*@w}*1#D$8?I+bC+ht$PiGnmrKKTDnz-kLJIdAvE^)$vBu*>DGRSy+1-2zNwz< zZxer0-I!2%_`=7AMyV-B(l&4a+i9reX!wNVo}ctOiOHm#5x| zc@mo23RTvB!7K;r+0~Z)@WA8D8vmg;#o5wQQtKy&p^i2PM^{%NyUP358n4Br^OaMB z&boT1r}>d>t*9#_E-o%3^unJsprq?+x}I6!3Vl)hmA4vw6{cMwIgZVGy2le-F1c|a&*DNn7G^}X?!*K zjap{CQBz;W`k*pL-(g^h>Nfz1*B*8T7Q9nXa=ulo+qiJVO?WHX zInZ<^9;xITltvwBTBPyxvOwX2D%j~2E9(SCuNB9R@gviXb~S>>ROW0Cad9v45Bx73 z{8WAFXWd@c9Rxcz-MZQf?E0?rD~GOeJZPDa=&{JwEon6k+8VX#D+y||{_q)Y(?bd$ z&|96SP~{Z$FSBFN%g5)@%To3z5>a~NRrUOKa*1BXqlht9vy*W1RaHl%==)}q^UI69 zIK|-<>KC!6pQBH#)Cp#-A%6Y^Uk%J(das>y~Ts8olK|9vg z&3$w^4q2n!3nmrI+BHXW)H~wn5_G11ViG~>0R0u!>VAqIQQsDyjPRkb4Cp(!TJNzE z|8m#xYJxDba>yvvmBsTgFW%!K!3D83rG)N3{Hs<9{aG+)@A3n@e_fm%8XahYb;-KZ z2HL-9E6+&z2<_2C6%MoHPp_TE?eyr4mD}453bl9ahUSe4pCF|qy{>FSB`U@Y8(33Q zQ%R3C@x^X4n-H^Wl3}ZwOpcit?k5DH;VoF#*tp$L=SYzBy1l(U@uJo3jJ^%rEjyIV zNzLaoY!>RwpE_=t=DQj)H!+djm>1zukZNEM(vG}vd?HBrt0Ll!GT7 z2Yz-M#$KgWTvANv|Cz%GmL0hD;ba0(?y3Cr`$yMHLY6+ z!Z76I=9cAW5u7Q#giO;5S+nH^&pp^u1Glv+OG8a4=sr4#h$vo7;@0n=8f*-3I@#_( zFpI=x1Kmji10Q{rJ{#-@mHU0_4LpG;MI~{Wv?5TxYs`#{hQ+pJYPqv_$isN5vN*g_ zvYt$HYCRn~u>_Gyd+zECy1PKi%5sqhj@4Bi^N8gX? z7qji|m&J#(N^#21$R!DmB8`t@@9}BQ@7p@t6|*IG<`qL*0J;X6CJGBGc)wfXFh&|y zz&U6U^xE-`Z1Yk*@ql5~pRU^0r>6B|u))L|G(5}A7Zq9elww)UnvGu)X^mtsBX-2E zN-v8Y(NdFagMCeUy36V1xJ(NUYuNRM+Z9!AC3#jSvfgXl$CSV zB>4LOxp)1bWfi^mk{3sO*UO&13JR<;GZ+Jr-QyiQiV3$=V)oYePxnJS%oB(7c4`8gk1<&ZMU$} z?4!j_Hdw?e9*C%}X&`Fx=$*_grZI*MyO*eQi{=T_wu^A3}vc;@P1wm!tz<1yR zuJ_BOrNi(gAD$0|KNB*x_D;rPIoYN`HK!PHD!OWe$fnV{R+){Rjg91qjA7aCV1H(w z_`&$NI?UqiH_l-U(zdf~(VHl5c8AF^yK5mFi9& zp099w%^!Mfs%xN8%Gg4jz-%^Y8_*W03sGsyfgI4{fGO^6GFKMH9~G<7=D(P)sK`d! zp*S-#un`566e%zL6rN1=H*C?)fdZEu*{JJ2(_mWu6WEB4vqY*&hk6f6B6#W4c&(#{ zvh)P1H{u@DG}>>J3bSmY9LcCJ9*f>NQ^$q~Q&Lh&qDm#VZLiv&sHkge2VD&tl#BTu z8*>G4a7_E&uQaSx7!^PeCLH8S*3~&(X}fksBZvcE4MYnD@Kd2i>z2$wP*?18nIT#T zwLS)R+H8=+nnW-KmtmvR!a3v~S%Pui!?Z*>ARdC?pc2IF&d&*$UH)d`Epq+pEX%&0Abob!K+L-7u);OpZd#YX zOm11Fve7_R*0cZ-aI%`MRj^VQe5*SvFY4=*Cg%O;3~ytN|~CMZGnn+qzkE zxw;-#>h~i43Q1eVYBnX^oQz@DDxZG=02cFo4SEtA%{>9KRrqe1R6jY=3=ByuUa<)i zz9l-+a^&Z;Sw)S_jx_8@=#$pic^lqCzDvgH8s$C!^*eU$+!m;1gltd9C5tuojEso$ z^15S8{z{v$w;*EX>HSC~+nVPxC%g|5O*5VgOQws|V*PP8D zf$vf*jp%kJj2ymUEyTt-K{YhVb^X$G+^Wea($DtwcgYVntA)<5N5+ZoDdwlInuHvd9i zS>_6}a>84Av^MlPveG-g$|k3A&X3Z~XjU`Zm8Pq^OG{IeRzC>Rma)>S1bm~G%I~o~ zfOA3dCzIN#h(M^mSQC_&A?#=)W&WynzAf-_cAwuBf|~t$K_P+M-&$$$#Y~E@I9`EI zvfhmzH;U3hT}KPodEopVitTu6q1oQvn|K1D@>SiUnR2f3?nr`>f#GU?ZVEl%;!_(D z;J8FKf=`bvDF!HJUYb{KcYG*xrS0&xqY&VEWQ?g!KpH1wQj@sC)2Hy9&um3ObBFcEzcU6&7Kn%I2oPOqHCJt0e-x_5F(1P4a@?$ky1rW( z#M_T>=VnSccts7o1*9S>)Decg1S#CT^DYbMH*m8XOimSAz7l{Pivn)fg)(DVSv%#{3aUdg_ktr=fZ{x zZ0&R-4ch4XI=xb)Rlve5XbmN$prD8~4E*G|J3Es~A71BPJW{0+9PxPhiHI*@{yRSQ zk^?<_5z*#?y#5QnyG6DA%d69d+Okd{zST2bT z4SI%u?v>?bIgQZ5zMRl#YcTH8*#?yxcu0)t9_GJRIins6eH#MGw zP7FX{BXZRbg4Ecw+#U;Ohmno5iy;Ei)6;d!4C`#iGU-D8TI>#|ChA7Vv)m)TJJPqO zixSi+n$$AeQ({+^g0akP{61rJk`?lH_o_~8No>NxtU}l1D;_uG7;ynB$Dm`;Ud_au zh3lcVzVU@c-Oy(>1q`X9T&oQ*&W7Hy+7vEmz~5rZO#xx`-7~$;V@!dJ}srC)-|#`15vFGVH_`2F8`rgaB1db|g*R{dref;i z@|TO*TQ;kc?GfA=hBo~a-$#rG4mUO|TwPBvY0Kdud%_^5mRe;XOVDzG#66m5xV5-_ff znHe*S(Wk9+fi0!x%FHzs-+F8&2QZVfs37xgd)v@@pB-&)he(<3$kqkJc}NZ+C14q^ zb@H5^I@QG9pVyH#nAuvUF4s&mPf-GRd!yd4M_F6QCk!Gh(fm(^I={|ykZ!t02wUz^ z`hX#G4cR#kL16N)Cs6#78RP}12Fm?Or*^z3954=0Op?wn{5^D}&o@5+XN^@hF>r8W zJ?T$}9^xCSx>$em>oolLVgMuKJ%E&mo#5ws_3s_}hx5Z=`7`@a#i3k0bmQ-90qig% zr6OJRBbeO@Mi(a|?T#JVB}Qw;m?+Pv$^1y@>*t)c=HooD)ne@T3$E>uiWz}3++g#M zho_duM4?Qh;5z8PMzSa|iZ=wrYfkH$+rZs_cZDyKfNrwHms?IQDxiS%pT+|c@VDcP zvp`UfP3eUrIQ8rQ)&&5T2^Fn%!mFW%^kjw#GFZfB>gbFreyUi*TzZ>|+cK3Bt<2FI zmTa$3q1%PH->>8pm>n%pq4XVvnkM>L-`KT#%(#)FEpLDP6Q4-c2zr|&+=aX-VPYanmTw9 z-#^7mqlU({PSlX4+#yt-J*X5^mtF8k)w6OfVtv3PO$rDT+|L((jnCWj?8Cp0ZbHe@ zHb~DuYhU+NrncSm{bR3eI7XDOrVzh(_P4IV%9SY8sRV$aRv1#AS#{c*H3D5tW|3md3i5rDjcO4gU17h9h zRVXJ8(}+j2SKwgALaOC`=yeGinfv1{lqGlB0;-SAl4~s2^u`z)-#3!H z33uL*{`nIb>FjUZ&v?S>RZ1obF%_Q}1qX}m4?WjFWNe0m886}R5e{#>qw2x}4FzEtA{>(h+M#jts zNwZ?fTSWhPE6P^q(%)ZpR%B@j;Iwf!_V+4ot34wIvS2Q60o6}p0e}ueCb|xziRP7coQab7 z^}BQ%s%UV_zcG|nUwEbw@ABZeu&ya<#REJsf@D`yDxjWuP7K(>re#N2U#Y~NlYC@R zAxPHlH|N%8WmZ;ExA=S!R8*rlk^+_$SQ?X#LL*q~in=C3c_{%DdaMDYz{26}yOdZS zmXSeI){l^TSfT=NsY*U5tkCJe=QLs{MgOiy36Jx_cFH$G>l@ic835N*c=W40g43H! zjEWR7)7-Z-kN*$cmRU!Fa60J;5tu0*|Ym*?=%P_}7xIgsf~AR)tOcUGJy&W>w9xWKCYb%;6$&1RnyQ zbWXHuzZe3GcviPvHlDZ>4_xrZy?yJ+Owxx#9i#1i)6>FSPoD}4^Kgh1O-nKvu|;;4 z@>?2-W%Qzo@Mp=+kG1G%!a_Y%=}zBMTrZrer%}Z?U@yB@p)pFz^Mt|;Yee!lv$3z7 z481KaEEr^B6C>f;T1ru|v3e#Z0*0$EeBZe)?!L{CGBaZV%myIQ&g}%o6;Go-Fd4J6 zTNSLZ5k7qJ;`v3OQi@^4j}On*hq+$y2xq20>E^7%Bf*dMCl_xPIsXbtWexrGzxMw78)+h0G7fF3*o+ z;qMz)ln7?miYWe_H5dY6LV0QTtr@U$X@j_v4^s*W+gvZer(s%6pF_ZGKj_aS~oSqV(asFl8zl)?U0%`;=F z(ZV6qvYa(DAZQz=i>tPCNIxZ8T*>1e4ufQ7000@*X^2LnhZ<~~p0g1xt}MZO^R70} z7`UichSnOeFK0ZiW3*9}z!qZ*k+MWWVD4ZLC$x}( z+61e@CoIg`ST%E8k&ka2;FHGKdU&c`U98p4L>(XG)5aq7TMt%x?a~tA+Ba|B3<|`% zb@PT%Kw8?9punK)dSwL@RtW2QPwVjT525<^Fzp(Lk1QXDM0Ip%kJgr!w&vy(RaD-K ze6+Sk{QmZ>_Cl*rQls6RG~akd6BV7w z3;8|N|Ni*jf6B^Ku`HfCY6%{}QO%_hfz^XF+o3n4Gi%S6<+(a@10OcBne6CUGYh6^ zu`UU+$+`foIJt=$hqZN8cjnK^A5Z3hYM|a5$lFNBoP4Ek2?+2hd&_=iGqHrqYhRr84Gu3iog&3)f zrY3D!Y&|J*>4JhHUBax_wUycZ9UXBSJ)04+mKNoMAKqx+np%~59{vrzt*r2)XxMZW za4p4v_-O6x@D!EJyYs^|%VcqSOJX&4UBe!|*DLKmaCtCO693CiwyW|R!SlYHdS`m# zwLv~Sxu4b^dJ0A7^WNFCSP_B_+0*vE)ekRCes*bivWy%p{}ruAAKgoF`A+Msm20$| zb5#$hv<#K1#ue?VWUZ1;sqP27*FWPBU<}d$+{dP-Vj#u&{5j^g{+-rpp!zPfYG3)J zxq-0AH>gI{*2=*Jq~Ghiv69^Rr+FQrBW85O*QNwvUeW++)~J{mKzzWo*^#NyJyv3h zA};>z@R?~@Qc7lXpd?GYfQ_9U$bx6xxUTm>Lcy!lJ20t?J$LKNC#oMi41Wzq5SQSq zI$JjuM|_}EA7?sa)u{x+&i`Z_*Kw8xQ?7&64e5rbo(g)_5z@x*6~jKbEuWz`zy6+v zxA)LqYFR0oYn{=LSnw#V^!FO1tMc6T7Dz^+sKF8qis>EA&bkd-FVYTsApk2V2+7KF ze*gX<64x^@KVODijW@2_@1|IphR2acPfmV*{^jK*=ychC0vO(TT=3AxD+Gqo4N270 zGYtP#kJ?eqL!wM|H~h6!v|=L@3?zb#Ad|pX1oX#NZDPjhIVXYeGrr)$x#?j>kt}p} z@7Cr_u`zjm=(M-}ayRn`US+|pzqynsL4sgT#Jb4a&=F@WMg@rVmS*Uy$e4=4Spg)iSS8(k0THU%VqahLP0@GF!%L&JZbjN)v>_@DJ+7rz5Jy&@`g?<>kj@K{=b- z+f6G6IdLUHtk~BD;ajGAQoo7M+BF`L;GNv8rv)drqeH*%-O_#r2`XAk&(b@CnSV5p za9i@#L8(i#=z6QEUY*H8F2n9nEe&hx4gDPf2`s${stz;zA8i^eNyt-HbzwZ zxN3Bg{&m(1`X_U%O+gU0kHUfr$P&;*5;@|A(O96ed5KmYL5gd$pEC+#Zi`K!f~Q?g z`_}R_g%WRG3c0Zie~dA>Yawz<%G+sC(T`@%C86TI_Pj}{FlNfoGSH#o69dhsJvWuPzWS3*F*9h7C_!n^?}a0P|xRx6n=zde0= z6iH4_dU|r==ZF57r@~UkFCnJ(i(z($XqLG>8}_Ir_Pqxw~743g5hyeR}H@ z(0rIlK9;_qH=@VulGd*;e)qW?cj0Smd+W*BsVl@ic5Z#Xa_nKJ8n3x)en9~?Hg;s> zDP;)5qenmU^M_idkOLi@MUwJ0mUQ6kf*#>z9CaKL!3Tjh+Cs388VhSSI>l@7*1JnD zciLv{%1cvgEv9sDb--peYbfR}?-Y23Rrp7Q7IXabM~#o*`7>j&Z|$_gsDRE~`_y(_wjOev~5GTJg14<7)(#MJ2$nM=rqa~- zIZ+2hz=P|9DAK z5!k6;+#gS|4|R0LcV@!#*!b>wU1M)+0fEd`nrsx0N=7d8>0{~bV63r$HhYU1=+j6! zMq@wZfH=(l>`ltT@k@>O&5DJnt6S{<#R7`q-5HgFqvGp}hC4@1JNN~y z`(LJZD953gp~qpH{0AOeogzea)`|B=6W}P=(tFio2Is=;+Pz?XcyD))MNe;6spfSl z>Rm4SocQUPufR>q?9!@oJp%WH3Me_$nlf5t$iCS|W#0@YWxMlj6zWWgY&FrlDpYp6 z6%r^lplcHwP9Bp)#cS5DB!xfOk+?%~+TC@0wPd=`w6e!Yq#>NSQ%AyvsH-nf`ouyK z*rOWX``t~tBeWVi#5Hy4r{wQU=usN9)5tYiFO7D|WZg}P05R3*38TeUMxzn?Xfxkbhn6O15PXlP?^yS*sO9Fei|w4R z{3b_@l|glNUvDq*#;hUc^N?$Ib+j}U;w6_Hp);}E`*9sU(TY{SayS2E5JpiHYJW1& zfgIPD>!DbsGwUU|QgLuO^0{@eEF?v%eJ9`LH8@ij8F5fyRcgBkURst?0O;i4wy$%y zr8m~=(gE`*wi5Ec_=I8x5_#r!Yl+k_4&F9C03Xf*I|Y}a0Tw~CX1Z{CJP^i0(rTRW zQ59yq*j|E@_I;wKNranGNpnNRFs=+9V{ha1+0J%61UGN@VP989Nq46(8*grHZhB}Z zWqzw2qd?Ii>fv^dG~vJxs}vna3rFU)y|ea`(Q2yd3jcY= zB9^cRxX`D6Zf;UG(FE{J@z7wkXKG*AA=AW+##@(M31)e6l%n{?YgSlUDH`GO>?J*{ zf9A{Dp3VVfrorq+Uq(yAQyYm?*%%(Zg7T_Sp7QxqqG+WutcrU@0RCVvVP)k2OXB53 zu(Wj0&rzUn>uFkfe2MS;V#2#Dze-XMbwxPA2a`%sQ0d5UBA5*|dRn5)#0oRN1&)1F z9H|sefLjDvG|F~hLAWV}*=fC1lP%!_sN5kusRX`>nrK+ex&vjIxbOKp(Mbufd0&95 zHO5F=N=xJ0a`1w$5Ehnu_Eq51^;ZB)ld|mLjTfa~$*Kyco@YoYDnuEu6_W*~Kk-ob zLilikKSbQ?r+9|ae6=q4P0o|!f3{64IIvU$;=bJ|eKk?44#`zfd3np~`z_~(?}7P8 zzmg5!E7X97A-0tiIk4&KX*ef)L#RHAW*c+>1gkDJk(4?}=FpQA~qr*^e-Ni@FI|NEJpm{FC~RJBRoJO5PGJeF|GU&vYd z$?< zHSf~!8v+=$NL&m5_HDfi$p;AR?uETTsePjnAkv~Jl=oTgUvq$cTv~z|js3WOrV~-Y zhXihBWz`#_MF=5#tC{Ib0q5-t2oiB+F>QxI`T8A;QZ$1OUyJ`;E>nZ}t6>)?G>lTn z?(jROudmo4dPmj^7YC<1$=-QOxRrP>uc+bIS>7;-UCCrtz>ODNsIPgczhqMKe?@$_ zb@PkDqs0ST6Kzwb0@bw4t5@qRV)TUf&#!fwr5?7$dn5$M+fxaEn<;$G#KU7XwwscZ zv&K>2mSa+s)K}zQuDsGqO1gB8-n?2|kmsiCNedHtM+nYIrhbizxr*N>zk|DFa`$YG zlNWJ^4bx2u-7vQduC&f443_Lpfn0*$X18&0@K*!oWTTzVbACcu=4dr7EchXJbL;Ra zD(*nU{a92+#v;V1usHEZPCw_%IMIir2aK}n4m-`jy(u#@-D7F(pkPHbO43&UR_|T~>wTkqi*h zan{Z>dXg~l^Yf#)Jtk`T4i*-OV;`qd@jLuU?|2a6s`7NfZbU$mhVZ$^n~Zm#6m{g7 z`vEVG4Qj(DmIB_lPz`zrqvhm;Mw-a!y3a%avOO|;W+eY;cenDm9$NLL)Q^ApBeY2! zz78*18`aiq@Vso3r{=Yt|EA0+?{VC7%-vSMH^b|BG1tDhXy{b)_&>Memr9~*VL`2y zY1*$&hoXNg=`5eA6+TIlkH80a($6L~>@$~4Q{nDNIKVPM#`Pk2t zqN`)aI2otIKOoRVkA~XqKxcJA#1A(5AnH{AwLqr)7V)hKD3>Iql~X+4t#HI%U2ydQ z8Pu0|aFZmDY7kQMm$JFnCt$u}VkGBvmHSJjrLPLxT3Up-xbi|h*WtgFu%+qxhlk7L zXN3DiY9cy;y{enlusx6DeoLMKd(O$D{tu3H0^ON zWc(>@8DePg^lEp3=xWD@sN&LK?^GQQLe>32q0Mz8q?FtF+|}jIaoNUr!SL_)M}JR@ zH|?J-EoB4h`|3|#3$c0ZBzbVRDWSvsMvEkrY(Bi*2eFrlB`=M)K(4*w;-4SY?UY98 zCR(q(=E`_=9BqDPRfzf#U`)=V0j-SNgjo7|ZIo#o9dgM}b9+$20OcRLHb@_!KKShx zm)P7!RmqAjbb&OGZOyV`TN@~qD(u^>N;dxGwQ;RLRKsY695gJqR%1p6O?2Ju`ZjBF zF4`d0=(}qM?j8q66;UEt%>`ke6gTy*7dh4o$aXDXROW*qv6-ursSd7oUDvIpp{UY! z%t57GR^GsV_ZruLqN3MTiS3l%O#S&>0>bm6N*>Wq=Xo}*)c5)G9G7uVa<5vUTYa&C zY~AUZ7d`P_VVyw5*2LKs(Tv6TFPQ$2v7CPSmkc6x1%;F5+!$Kue6cpv$>QR?&rCTB zbJ~uO)qJ6R<*~q)qf!l>+4d^Gyle@Zv7RY6K(@(7kA#i8e$x24+&%gnk~7pc;z!nY zSavp9ghFYz2h(u59Wsry?Fwpnn5(QEUN@{h1Z|EKU;i zr5ay?{sBbx688`^8~5A;aA9PL)-*T-n~20HeZiD!F%{-q^@B%PegfDx z^}MUEH=ws$nG+U4|3o|;)&hh2-=~h%|9F;C@A|*qci(0qU;djh{io^2k3)l9=~MO_ zC-`4yg=EqGC*b?y&~kUYT?La0LV#;*NC;uk4PaaN_bZ~mDksl{I<+U>6tWoWzlBd8 zH}YJo(zHMMEx23oV?|m}_({I(MrGZr39>P7%{})1^78V9wy@*9y}5&<&uCRs3dYKc%7Y(fh-V>-YfnUv1q(P3*-!q zP1ug|zwCx{yJ9%##u^aZ!@ngX-40jxK-eCd+B}7^Ui%p)QrvjsuWzvRGQGUc2 z@@ISP);XI?OGYL;Hg&yhWL5%ap8kY%bEZ2knN{!b@^J=GA&G2?8h;Lph-iTFB3smR(!(NY&3xTNvZHe$o<>@e7M;H z_qA&%UHcVn!+Q5hAsM>(=RPu?(t2YFcq7fv?@z{a1811j3ShQ;HX}h7Lc@!uY`#-j zMh#EI$2;K3*KMclXlV)h%KA^EB{j{@u9;{N%k{%H@djX{2~b7Afh~VxC&S$2djz#@7eoz_pvMOOH~fLH2APLL2reGnp(@b zIe1O8n2stJu=>5)-j0dQR|VRWacD??xhisLkRbT{3`#Y zQSa_*iV&tO1AG-ODxUn6bs<5anCCk4YfH?<5ej5yh@LC0T9+^Db#-;*96Iw08wN&3 zj$0FDwJ5CxEl=%|<(&pz%b9XG^t@F~7cOLfcI?&O3M0b{`FG!qAaz49`_yjGK$4={%Z&aGmt1QUY5_}Z!41$Ypj1@g)#(Kv)ELu-7q~bE%hlhD^__6+C#1M833a(=}jz5>zREl zsv*?Cw4dtAv81{WnuxjI|hu3R@oLhptGhe!73ER+Jqn}PmnwUsPM z%lkl-#sB)XLJ}VvH~p(pBH8INDu++&ac?I_>Y(5K{a1i@HQ)io3wtoM3ch^{$G+(^ zVtpd}Jfa&eeZz7dXbf&|Avr4TUyxc@ZUssQ9&b(!SK06W2~Qg-l+91GH=hBv@10oI z)3xDEG|kh!>NG~zlh6Eh!P(|GSD47&KevieDxW`p7P&fkK-!xq ze7U5i>$o=Idvn&?8;i~wfqi}~Atr{*rV((?S1;CYY`no)%o%kl&`*pCIR{I@G7Cd%FgSkpWuMY)Eib$8!*3gzqGWpd_@TypXOLfUJfz?K0da) zm|YdhLTzbj3GkKXlkgE@09*gYmcX232y(3hLR1OYlINO&t;A0d>U{#o|&94o9 z$)^(Cb>yr=Bl7uXT`(JSipkT8f&o&oo#>l-H)gu&@TG;gOb>t|I5Aj7-%^XiE!SV?$P?cx)t6w^|!t z+Ynhsisz+#V}Y1eJi*F*6O*cIeA}Zc{;1(oYl#9&JArBl&Xky06)q;gn-&qL!^PH=a+^C z5f}|MO)wjcY$ppW9`oixbB8IigKC<~hlhio;g@n&Zx@|gWv)~c4R1g|03N|+sl%FR zRA<`mm`kS+BOjmHMCsbW3P)-&aj^@SKL7+1GLmv`i{b6|2X@j@<~mE#;|su!Tj=ue z0O5hY?^C|gxzyz>i&$D(TUuYP2Tq2@m5)baITzsYL>d~ngUn=!$qrB<_&JbLxH&I~=-Z5=EXALGJhW)WHw@0&4sZOu&!}M^rNf zX+BKJO;4b)K;Wx+9}D=M9<5Ct{|Rr=u5rw$Pz+ZDjL~}cH9K2LQR`bIv}A=UEOc%s zbD%me0bcS0O)1t5m>7;VYqm(RD(}%X=ruJ*4Mhz`MA$Ac20!F`@^W8;rjDMTJ|i=| zJCTozfko;O$+Y9>A^6_9!+HF(vuhUnl*DIy2bINi$;fl`mPswnYhht45L?5;!vTxA zE1CnM(#OYF1-5O7Mv3Jl8PM&V#gUS!(v^%=8RV%jq!Es};BCOV$k)VtzkNI5hIoQR zDK_cPPlFX6agGNlt{;_Xgy)$Ej^#(7EId1E0IroQD=W6R0;|$9<&In#UL`WULDO}4 zXFM+C?1_0(0mXKsg)~YKNYWbx9aUo|r>V=+ z-l|CAeZqva`a{+Y zr^c;;{&dhyP8Qt;Pxx1-z|ty7Pt007W0ITsFg{0r?;fatw6#!_!(6EQf#y?%`Kh&u zI>uDW@uN1F8>MuaqgatI19iK))FV|?R7WNm*sl1|;BJ!HlD$G-;kYMZ(EY&}d9N)p zBj3Fpl2Y~p)hwa}CXJzWCc+M(y{wPNVJ@_V!rZwIZW_8p$+cgfj}SyHJK8(Xlus3_U8D7wG+1i(Ar7C;GK+^V2hqxd(`$C`DjG2(6dTNQwy4BxHg@FtrDiLa$) z&$i8%FJJVFD~pv~-GHh4urfpBUv8XtIpK{L-qTORgn#Wc>VzwJ^_7oKyKEr}5{~Im zqZQV=ZlM09W`Vl6smH6bz^qQ}FY{|miYE<$9u3sjR(b}2-+lI4npUg3&I4$(*S5a; z;-4LDoKF$W2v_X$jp)^T*3Woc^~9GocwVfvds&~J11EgWzr_U)0r=ZG#>Na`?FV~D znZGJxRtBE7M@hjD4IFij2R2!D#^MZ+JmbE&DS=X6NbM348y&CJX6Tl{)!43tl$5!; z`Ux1tLM40}#8J1pIln){I~^|oolcs9F83e=whGPuKA7Z!X6{BTH*l)Ia&SKW@ZrND zdT**>=aKL4`g%{5we|UkgoGCEg@aQdqBtPhEy~XR4t@ecbEbxWJodTi^Oeas69)tn z-eFvvoU-_DC*J_MMmglebB$ky9pgw7YB;=BPzcOE&{j}*ZGOlk^`4H;4wy+4P4k5! zUI;&W^ybm5|KX^_U5&HcuHw-t+s^n>5+u zb1nWf)YL#d6d4JZMJi#{+6;X4!M%Ikn!PS+y_J)10Fj+NlgY;VywshKZV8D|VBE|4 zQkuxqiSbrG&mLVO>4h-nQUuKU5YY9eJnjGG zFN|4z5LoTQe`{Ev9bhVJIgCk4IYS`P&S(b44jV}^_vx*fi7~*68${_6)@PiLZJTO+ zIr7~Gl>AAuxmu95A(0Bzld*d|aIgSANXhA+QJK2_gL5l0E6d;4_x$|))2C00-tg%7 zw(EC~rEvoQ66Qb_Txi7(wj>M&k+SYVx?fJIJf*ElK1tE3G8#frqEdk!1ZFi12! zO{Af^G=1nN!P$ozkh1v^vr5+4=ND|dQh+voyznyEsZ6l=2I#?(bj-oQ!N#gWfvR%d z8>Sa>FYT9u<4TN2Vo`$<$xJb!uPdvnl!*oC`M5bBceJFOUw;ye&?odPWoOMv#jd$+cnJl-2t^k3c z#||6@EYwCd9%_5g7@MriYh>;ob?0z(+Z6135TWQ?FVDVQp35>8Ej;bNkIT!e=H+#T zzrxYK@8aTi;$Fp9UtzRWNiTp?Sps==JI^t1-F=&?=I{o zYg8|dpo@a14lSZxw_M+KlwDf}db@#G=i|q+)oEXBoVyQSTKutRMQFP0Jc<97U^5?r|?0e_tSBq(b9I=aT z-8H-X-PYEV!0U`Uv3<3{h;VBL_R~P1NO*NSO3m5P@n~-^voJOFa77LnLR11yb8UX& zU&yocrlI$ZTq8qcK0bkgjpMEcq$b{^-N8P{tuqEpD@`6L>Y;~Y^2ph>cEKqyFj-mY z(zzXv2HMNRaYh7Nwe!HWT-mxvH|*l1B`jM(UEx~k)T{e*cB^70wF2ayGhSDsuCBf^ z34ut{y;QE4fN@z`0NO?(eKX1&+j;GzI;PprQA3ypV*{%V_8~-O6!EA}< zA5aKQO~G%J3cajy$6ScDjV8YprF@-I20H>4RG`!BPD~rNv%NjAd)9`Yp$54EfP z&gr`^K|!pLU_beHil}dU52$oz#xMz@>=k#mhgt{6s$+J^vY~t3)!Z9@@6{?z(*e)n zjb7u)-U4ur>RH%hkd4>+nDaqO$`H#kKqE&+PVQwvxP~UK$X zOql)=rlFz|up9a?;^HoRl>rciqq0$2ulc=dO&pwmfJzrxxNZ<8BJ8xOzA#2B^e#!a zD&mZS&zuB8jKri&&EDkM7E1_u|2#>^q~5!I)cn=KG6yhCayT(YZ&rbz517m;DIUOU zzD3sbX-pUmSAA-3s`HMp%8RX%xyYd;cu7zYm>8q}4A7Qs9c*5pKc&^9zsVr3qGaPg zNW`;%f(gt+;~<%SJp^oQ;hYECpGEy+U@;W!gLb{}n#ReltlE5w%~)G7eZz)rr5jE+ zQ4{95_e>Rkc_vRa$1GyJWW^TP7AEL9sr1n24>x9`n|X8hLKLIP!_I4g^L}O@L~GJ- z$0(_$25KfLdG*D|xHr+r!~}9yFswu6_}p*&qj`D6bwFygbPRI(^W@1Bzq?dq4<2+a zlz`(2@!Iw)w+<*#svXwsz!8qQ#OGIRlAWB9Ein8$AUJnbKlh${K@qRb+8sCrg1U6)BCRK_6UXvS_Ap zW3*5y?nz_8B#-i27TBGW+RnhhKYt*c4BDI?fgcqNR6^+U4JIZK)jxk`&xIh7NH#Xn z5PDRVLCx9(dT)=7nN7$>j}DfWmPYHMXBJ}JvpMmz^dSnbs91{YT4V|xq5oP>2_zf5*?z~%vv z?GCa6q`)cX$6MBaR7!&`Ml`KSNl@P%eV=?bHXZ@?P90b>Dp4_Ue(|Ala?Y~w@c8Id z6&A21m?y%e0PBw)r4G~uC%bP8Wnd(WFGNj$Ke#P(9@Sw)n3#^)u}Pi3azc$6Cw5g9S#vTy{NNVGz3hhc*FUy5K52FCuRZ(?+2AcA|o=0l-R#FCv7Hf!UdcXg*~dpiL|ar ze#pnY9PaDmVCCAF&j^|!QUlHM$L}fpKW}=#`ZCdg~d@!WO4ASvPa4zI3X>5 zjxu!P8k_0Y`&>IRCUQ;Q-6pl$P}M2=&7;jBzLVV)?99j^TIt76!rB++y#$~Fbk+^= z_IGaY?;obB@YHQrnG_}@K+QhoWGI5+5{~i^3kB#L)o|tGAQLA`6XSH{?B`@b%-_o@ zoI&e)&2Jc_qK^3?enmD1F!WttG2bCeN!x($p=|+&oFdmHvA1Sw*-bri6Y@aMJ}{GE zeJBTTA!M&DK!w=&H4vKs=!f*_)S)-0X-G-A-A{J+9xy0;NCZBg<9~YD*|)8%&X2b< zz??QUvlW=qD-Fw|DL+2~O1sle*e>g5fLQPWqid9_eYV|#ZUV3$lo1#&Ghhsi z*Y5xb2XJd*zjqrT;KdR1^T*R3eN#P-$YzrQ}p^SYRolghWXFG_9xTD-upxV#)2TIaHN(d>IX zz%hVC+E1dr%%AJHiEAK)JxqFQvnsQ{x4Tri@~NthM2iDMs1nd_UJs$VGIcS~5Hl~U z-frc}OE3L4KPiU4lb4^%!ptTsU9-lc1`Z3ye8LjeS~Lr+W2ualSucqjf?h8Yt^qy^ zjG=V)j`kH56;~TYgnzSKt2;^ldGaAF@T8GZR;HpyLENy&NaQ7vpbZ9f3K$OxzXi