AbstractRuntime 0.15.0__tar.gz → 0.15.2__tar.gz

{abstractruntime-0.15.0 → abstractruntime-0.15.2}/CHANGELOG.md

@@ -7,6 +7,26 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.15.2] - 2026-10-28
+
+### Fixed
+
+- **An index build no longer loses a run another store object creates during it** (`JsonFileRunStore`, backlog 0863).
+  A new run's `+` journal line is written before its file is published; a session/children/active index build that
+  marked the journal between the two and scanned the folder before the file landed missed the run: the listing until
+  the next reconciliation, the session and children indexes for the life of the store object (the reconciliation
+  repaired only the listing). Seen as a gateway that answered 404 `session_not_found` when archiving a session written
+  while it booted (AbstractGateway backlog 0963); a split-mode runner creating a run during the API process's boot
+  hit the same window. The first sync after a build now re-applies the journal's last 16 KiB before the build's mark
+  (`JOURNAL_REPLAY_TAIL_BYTES`; idempotent, once per build), and the reconciliation re-files a run it repairs into
+  the session and children indexes too (and drops a vanished one from them).
+
+## [0.15.1] - 2026-10-28
+
+### Changed
+
+- **Is Empty (`is_empty_string`) accepts lists.** Nothing (unset / `None`), an empty text, and a list, tuple, set or object with no elements are empty; whitespace, `0`, `False` and a list with any element are not. Before, a list was turned into text (`"[]"`) and was never empty, so a flow checking a list variable needed Array Length + Compare (operator QA 2026-10-28, the email-triage flow). Backlog 0862 (numbered 0857 in the 0.15.1 package). AbstractFlow lets the node take a list once this is released.
+
 ## [0.15.0] - 2026-10-28
 
 Requires AbstractMemory 0.4.0 or newer (`abstractmemory.graph`). ADR 0011, backlog 0856.

{abstractruntime-0.15.0 → abstractruntime-0.15.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: AbstractRuntime
-Version: 0.15.0
+Version: 0.15.2
 Summary: AbstractRuntime: a durable graph runner designed to pair with AbstractCore.
 Project-URL: AbstractCore (website), https://www.abstractcore.ai/
 Project-URL: AbstractRuntime (GitHub), https://github.com/lpalbou/abstractruntime
@@ -55,10 +55,21 @@ Description-Content-Type: text/markdown
 
 It is designed for long-running workflows that must survive restarts and explicitly model blocking (human input, timers, external events, subworkflows) without keeping Python stacks alive.
 
-**Version:** 0.15.0 • **Python:** 3.10+
+**Version:** 0.15.2 • **Python:** 3.10+
 
 **Status:** pre-1.0 (API may evolve). For production use, pin versions and follow `CHANGELOG.md`.
 
+## What's new in 0.15.2
+
+- **Run index builds never lose a run created during them**: a run another process (or store object) wrote while
+  this store built its indexes is in the session and children indexes and the listing at once (before, the session
+  index could miss it for the life of the store object; backlog 0863).
+
+## What's new in 0.15.1
+
+- **Is Empty accepts lists**: nothing, an empty text, or a list or object with no elements is empty (visual-flow
+  node `is_empty_string`; backlog 0862).
+
 ## What's new in 0.15.0
 
 - **Memory facade** (`abstractruntime.integrations.abstractmemory.memory_facade.MemoryFacade`): the one

{abstractruntime-0.15.0 → abstractruntime-0.15.2}/README.md

@@ -4,10 +4,21 @@
 
 It is designed for long-running workflows that must survive restarts and explicitly model blocking (human input, timers, external events, subworkflows) without keeping Python stacks alive.
 
-**Version:** 0.15.0 • **Python:** 3.10+
+**Version:** 0.15.2 • **Python:** 3.10+
 
 **Status:** pre-1.0 (API may evolve). For production use, pin versions and follow `CHANGELOG.md`.
 
+## What's new in 0.15.2
+
+- **Run index builds never lose a run created during them**: a run another process (or store object) wrote while
+  this store built its indexes is in the session and children indexes and the listing at once (before, the session
+  index could miss it for the life of the store object; backlog 0863).
+
+## What's new in 0.15.1
+
+- **Is Empty accepts lists**: nothing, an empty text, or a list or object with no elements is empty (visual-flow
+  node `is_empty_string`; backlog 0862).
+
 ## What's new in 0.15.0
 
 - **Memory facade** (`abstractruntime.integrations.abstractmemory.memory_facade.MemoryFacade`): the one

{abstractruntime-0.15.0 → abstractruntime-0.15.2}/docs/backlog/README.md

@@ -12,10 +12,16 @@ If you are new to the project, start with `../README.md` and `../architecture.md
 
 ## Counts
 
-- Planned: 32
-- Proposed: 14
+2026-10-28: +1 proposed, 0862 (a message's artifacts list the run's offloaded bookkeeping; one listed ref is missing from `view.artifacts`), found by the desktop Assistant QA (AbstractAssistant 1067).
+
+2026-10-28: +2 proposed, 0860 (the view does not say how a run was stopped; the gateway does not advertise the view) and 0861 (tool sandbox and per-call model timings missing from view activities), found by AbstractUIC 0040 (panel-chat renders the replay view).
+
+2026-10-28: recounted from disk (deprecated was 13 in this block, 14 on disk); +1 planned for 0858 (root 1063, typed runs); +1 planned for 0859 (ephemeral live-text deltas on the view stream, gateway 0954).
+
+- Planned: 34
+- Proposed: 17
 - Completed: 39
-- Deprecated: 13
+- Deprecated: 14
 - Recurrent: 0
 
 2026-09-20: counts reconciled to disk (28 planned and 12 proposed before this
@@ -93,6 +99,8 @@ mtime). The anticipated ADR ("an automation is its controller root run") is not
 
 | ID | Item |
 |----|------|
+| 0863 | [An index build never loses a run created during it](completed/0863_index_build_never_loses_a_run_created_during_it.md): completed 2026-10-28, released in abstractruntime 0.15.2; the first sync after an index build re-applies the journal's last 16 KiB (gateway backlog 0963, the flaky archive test). |
+| 0862 | [Is Empty accepts lists](completed/0862_is_empty_accepts_lists.md): completed 2026-10-28, released in abstractruntime 0.15.1 (PR #15); `is_empty_string` treats nothing, "" and a list/tuple/set/object with no elements as empty (operator QA 2026-10-28, AbstractFlow backlog 0160). |
 | 0856 | [Memory facade and ledger provenance](completed/0856_memory_facade_and_ledger_provenance.md): completed 2026-10-27, released in abstractruntime 0.15.0 (2026-10-28, PR #6 merge `88a584b`; floor AbstractMemory>=0.4.0); ADR 0011: `MemoryFacade` (open a mind, stamp, reconstruct a source), `LedgerStore.get_record(run_id, seq)` (JSON-file line-offset index), the step context, a `step` ref on every memory write the runtime performs, `MEMORY_REVISE` / node `memory_revise`. Follow-up 0857. |
 | 0851 | [Per-account voice stores](completed/0851_per_account_voice_stores.md): completed 2026-10-27 (0.13.0); the runtime's voice catalog and voice library use its `voice_store_dir` / `voice_library_dirs`; real-weights E2E 9/9. |
 | 0852 | [Capability refusals are not retried](completed/0852_capability_refusals_are_not_retried.md): completed 2026-10-27 (0.13.0); one engine call for a refused request. |
@@ -149,6 +157,8 @@ mtime). The anticipated ADR ("an automation is its controller root run") is not
 | 0853 | `planned/0853_session_tool_policy_before_the_approval_wait.md` (P1; abstractruntime 0.14.0: a conversation's approve/deny stored per session and applied before any approval wait, with an `abstract.tool_policy_decision` ledger record; gateway routes and client wiring remain) |
 | 0854 | `planned/0854_replay_view.md` (P0; abstractruntime 0.14.0 carries the reducer, the durable per-run `seq` cursor and the conformance cases; gateway routes and client migration remain; ADR 0010) |
 | 0857 | `planned/0857_entity_direct_memory_writes_provenance.md` (P2; entity memory written outside any effect: world models, tending, night passes; follows 0856) |
+| 0858 | `planned/0858_typed_runs_run_type_stamped_at_start.md` (P1; one `run_type` + `origin.surface` stamped at start, indexed, in `replay_view_v1`; root 1063, gateway 0951) |
+| 0859 | `planned/0859_replay_view_ephemeral_text_deltas.md` (P1; live token text on `/view/stream` as ephemeral `text` deltas the reducer ignores; gateway 0954; regression found by the Assistant desktop migration) |
 | 0044 | `planned/runtime_systemic_reliability/0044_meta_analysis_record.md` (track source record) |
 | 0045 | `planned/runtime_systemic_reliability/0045_crash_replay_harness_and_ordering_invariant.md` |
 | 0046 | `planned/runtime_systemic_reliability/0046_per_run_driver_exclusion.md` |

abstractruntime-0.15.2/docs/backlog/completed/0862_is_empty_accepts_lists.md

@@ -0,0 +1,29 @@
+# 0862 — Is Empty accepts lists (nothing or no elements = empty)
+
+**Status**: completed 2026-10-28, released in abstractruntime 0.15.1 (PR #15; released on the release lead's decision;
+the gateway floor stays >=0.15.0, the root pins 0.15.1) · **Priority**: P2 · **Created**: 2026-10-28 · Numbered 0857 at release (a clash with planned 0857, renumbered 2026-10-28)
+**Cross-package**: AbstractFlow backlog 0160 (operator QA 2026-10-28 item (e)); the Flow editor lets Is Empty take a
+list only after this is released (branch `fix/is-empty-lists` there).
+
+## Why
+Operator QA 2026-10-28 (e): "Is Empty must also accept arrays (undefined or 0 elements = empty)". The email-triage
+flow checked its `triage` list variable with Array Length + Compare, and a Compare left on its default `==` inverted
+the check. One node that says "the list is empty" is the readable way.
+
+## Current code reality (before)
+`visualflow_compiler/visual/builtins.py` `string_is_empty`: `"" if text is None else str(text)` then `== ""`, so
+`[]` became `"[]"` and was never empty.
+
+## Change
+`string_is_empty`: `None` → true; `list`, `tuple`, `set`, `frozenset`, `dict` → `len == 0`; anything else → `str(value)
+== ""` (unchanged for text; whitespace, `0`, `False` stay not empty). The node type and pin id (`text`) are unchanged,
+so every saved flow compiles as before and a text input behaves as before.
+
+## Evidence
+- `tests/test_visualflow_string_contains_replace.py::test_is_empty_accepts_lists_and_objects` and `::test_is_empty_on_a_list_variable_in_a_compiled_flow` (Get Variable → Is Empty → If; RED before: `[]`
+  returned False).
+- The operator's email-triage flow with Array Length + Compare replaced by Is Empty(Get triage) → If false → Notify
+  me, run through the executor with 5 emails / 2 important: reaches Notify me and publishes the alert
+  (`untracked/release-closing/w6-flow/repro_email_triage.py` at the workspace root).
+- Full suite: 3863 passed; the only failures are environment ones present on `main` (a real abstractvision plugin
+  test, three modules importing the old Python `abstractflow.FlowRunner`).

abstractruntime-0.15.2/docs/backlog/completed/0863_index_build_never_loses_a_run_created_during_it.md

@@ -0,0 +1,48 @@
+# 0863 — An index build never loses a run another store object creates during it
+
+**Status**: completed 2026-10-28, released in abstractruntime 0.15.2 · **Priority**: P1 · **Created**: 2026-10-28
+**Cross-package**: AbstractGateway backlog 0963 (the flaky `test_runs_reads_archive_and_kinds_once_and_sees_its_own_writes`,
+404 `session_not_found` on one CI job per run; it blocked the gateway 0.17.2 PR and release runs).
+
+## Why
+`JsonFileRunStore._save` appends a new run's `+id` journal line BEFORE it publishes the run file (J53-1: a crash after
+publication can never hide a run). An index build (`_ensure_session_index`, `_ensure_children_index`, the active
+index; `warm_session_index` at a host's boot) marks the journal offset (`_mark_journal_start`) and then scans the
+folder. A run created by ANOTHER store object (another process: a split-mode runner during the API process's boot;
+or another object in the same process) whose `+` line landed before the mark and whose file landed after the scan
+was in neither: the trusted listing memo missed it until the next reconciliation, and the session and children
+indexes for the life of the store object (the reconciliation repaired only the memo and the active set). In the gateway, `POST /sessions/{id}/archive` answered 404
+`session_not_found` for a session just written (`session_exists` -> `list_run_index(session_id=...)`).
+
+## Change
+`_mark_journal_start` sets the first sync's offset to `_journal_replay_start(size)`: the first record boundary within
+`JOURNAL_REPLAY_TAIL_BYTES` (16 KiB, ~400 records) before the journal's size at the mark, instead of the size itself.
+The build syncs right after its scan, so those records are re-applied at once; applying is idempotent (a `+` whose
+file exists is filed again; one whose file is still absent stays pending, as for any `+`, until the file appears).
+The reconciliation (`_scan_active_ids`) now re-files every run it repairs into the session and children indexes
+and drops a vanished run from them (review finding: it repaired only the memo and the active set).
+
+Chosen over "a `+` whose file was absent at scan time stays pending": that needs the build to know which `+` lines
+precede the mark, i.e. to read the journal before the mark anyway; the tail replay reuses the existing, tested
+pending path unchanged. Cost: one read of at most 16 KiB and one stat per record in it, once per index build (a
+build happens at boot or after a journal rewrite). Failure mode: a run whose `+` is more than ~400 records before
+the mark and still unpublished after the scan (a publication takes milliseconds) is caught by the periodic
+reconciliation, which logs what it repairs and now re-files it in every index; an unreadable tail logs a warning and replays nothing (the previous
+behaviour).
+
+## Evidence
+- `tests/test_json_file_run_store_index_build_race.py`: another store object's new run, with this store's index
+  build run between its `+` line and its publication, is listed by `list_run_index(session_id=...)` and by the
+  root listing; with a 50 KB journal the replay is bounded to the tail and starts on a record boundary. These 2:
+  2 failed with the previous `json_files.py`. The file (3 tests): 20/20 plain runs and 20/20 beside 12 CPU-busy processes passed.
+- `test_the_reconciliation_refiles_a_run_the_session_and_children_indexes_missed`: a miss beyond the tail is
+  repaired by `rescan_active_index()` into the session index; red with the re-file removed.
+- Adversarial review (Opus, read-only): all index kinds covered (session, children, active, the memo; event-wait
+  and mailbox indexes refresh from the active set); record boundaries never parse a bogus record; the rewind
+  happens once per store object; re-application of `-`, `~`, `=` and this store's own records is safe. Fixed: the
+  claim that the reconciliation caught a miss (it did not repair the session/children indexes; now it does).
+  Recorded: a build's replay bumps the change counter once for the replayed runs (one incremental pass of the
+  gateway's notifications collector over ~400 runs per build).
+- The gateway's previous test order (runs written while the boot warm-up builds the index), with the window between
+  `+` and publication widened to 0.3 s: 3/3 failed with AbstractRuntime 0.15.1 (the CI's exact 404), 5/5 passed with
+  this change.

abstractruntime-0.15.2/docs/backlog/planned/0858_typed_runs_run_type_stamped_at_start.md

@@ -0,0 +1,41 @@
+# 0858 — Typed runs: one `run_type` stamped at start, indexed, carried in the replay view
+
+**Status**: planned · **Priority**: P1 (high) · **Created**: 2026-10-28
+**Package**: abstractruntime (enum, stamp, index column, replay view field, backfill helper) · **Slices**: abstractgateway 0951 (start paths, `/runs` filters, migration), clients (framework root 1065)
+**Master item**: framework root backlog 1063, `abstractframework/docs/backlog/planned/1063_typed_runs_and_sessions.md`; links root 0993, 1059
+
+## Summary
+
+The runtime owns the vocabulary of what a run is. Today it has two partial ones: `core/run_attribution.py`
+derives `session_kind` (`chat|automation|occurrence|discussion`) and `role` at index time from automation
+metadata, so every non-automation run is `chat`; `core/run_origin.py` stamps `_meta.origin`
+(`person|trigger|agent|system`, `actor`, `client`, `ref`) once at start but nothing indexes it and the
+replay view does not carry it. Add one `_meta.run_type` (enum in root 1063: `conversation`, `docs`,
+`automation_controller`, `occurrence`, `discussion`, `scheduled`, `entity_visit`, `entity_life`, `import`,
+`correction`, `bridge`, `flow`, `subrun`) and `origin.surface` (`desktop|iphone|watch|web|terminal|console|api|none`),
+written once like `stamp_origin`, indexed as columns, and exposed in `replay_view_v1` as `run.type` and `run.origin`.
+
+## Current code reality (origin/main, abstractruntime 0.15.0)
+
+- `core/run_attribution.py`: `SESSION_KINDS`, `ROLES`, `INDEX_FIELD_NAMES`, `automation_index_fields(vars)`; first-match derivation from `_meta.automation` / `_meta.occurrence` / `_meta.discussion` / `_meta.schedule`; columns in `storage/sqlite.py` and `storage/json_files.py`.
+- `core/run_origin.py`: `ORIGIN_KINDS`, `origin_for`, `origin_of`, `stamp_origin` (written once; an existing origin is kept); the automation controller stamps occurrences (`automations/controller.py`).
+- `replay/view.py`: no type or origin on the view.
+- Entity homes (`identity/chat.py`, life loop) write runs under synthetic ids for the in-process chat path (memory report decision 3), so `entity_visit`/`entity_life` need the gateway hosts and decision 3 to stamp them.
+
+## Chosen route
+
+1. `core/run_type.py`: `RUN_TYPES`, `stamp_run_type(vars, type)` (once; refuses an unknown value), `run_type_of(vars)` with the backfill derivation for runs that predate the stamp (returns `(type, "stamped"|"derived")`).
+2. `Runtime.start` refuses a root run with no `run_type` after one release of warnings (descendants default to `subrun`).
+3. Index columns `run_type`, `origin_kind`, `origin_surface` (SQLite migration + JSON index); `list_runs(run_types=..., surfaces=...)`.
+4. `run_attribution` derives `session_kind`/`role` from `run_type` for one release (compatibility), then is reduced to the automation fields.
+5. `replay_view_v1`: `run.type`, `run.origin` (additive); conformance fixture updated.
+
+## Open decisions
+
+See root 1063 (enum names, `surface` placement, retirement of `session_kind`, interaction with root 1024).
+
+## Acceptance criteria
+
+- [ ] Every start path in the runtime stamps `run_type`; tests per path red when the stamp is removed.
+- [ ] Index columns filled for new runs; the backfill helper derives the same type the old fields implied on a fixture of legacy runs.
+- [ ] View fixture carries `run.type` and `run.origin`.

abstractruntime-0.15.2/docs/backlog/planned/0859_replay_view_ephemeral_text_deltas.md

@@ -0,0 +1,27 @@
+# 0859 — Replay view: ephemeral live-text deltas, ignored by the reducer
+
+**Status**: planned · **Priority**: P1 (high) · **Created**: 2026-10-28
+**Package**: abstractruntime (`replay/view.py` `apply`, conformance fixtures, ADR 0010 note) · **Slices**: abstractgateway 0954 (`/view/stream` `text` frames)
+**Master item**: framework root backlog 0993; follows 0854 (its "Out" list put live token text on the ledger stream)
+
+## Summary
+
+Finding from the AbstractAssistant desktop migration (draft PR #11, `feat/replay-view-desktop`, its backlog 1063): the `/view/stream` deltas carry committed ledger records only, so a client that renders from the view loses the live token text while an answer is being generated, a regression against the old path (`GET /runs/{id}/ledger/stream`), which interleaves `llm.delta` frames from `LiveDeltaHub` (`live_deltas.py`) and shows tokens as they arrive. Runtime 0854 put live token text out of scope ("`llm.delta` frames stay on the ledger stream"); the migration shows the view stream needs it.
+
+## Chosen route
+
+- The view model stays a fold of committed ledger records only. Live text travels as an ephemeral `text` delta kind
+  (`{run_id, node_id, call_id, channel, seq, text}` appended, `text_end`) produced by the gateway from
+  `abstractruntime.core.live_deltas` sinks (gateway 0954), never persisted, superseded by the committed message record.
+- `ReplayView.apply` / `apply(view, new_records)` ignore ephemeral deltas explicitly (a record of kind `llm.delta`,
+  `llm.delta_end`, `text` or `text_end` leaves the view and `last_delta` unchanged), so a client that feeds the whole
+  stream into a port of the reducer cannot corrupt its view; ADR 0010 states the rule (the cursor is `seq`; ephemeral
+  frames carry none).
+- Conformance fixture: a stream with interleaved ephemeral frames folds to the same view as without them; a fixture of
+  the client rule "drop a call's live text when its committed message arrives".
+- Interim (option B in gateway 0954): clients keep `/ledger/stream` open for live deltas alongside `/view/stream`.
+
+## Acceptance criteria
+
+- [ ] `apply` ignores ephemeral kinds; a test red when the guard is removed.
+- [ ] Conformance fixtures shipped as package data; ADR 0010 amended.

abstractruntime-0.15.2/docs/backlog/proposed/0860_replay_view_stop_wording_from_the_ledger.md

@@ -0,0 +1,34 @@
+# 0860 — Replay view: a forced stop reads "Stopped" (the stop's wording is not in the view)
+
+**Status**: proposed · **Priority**: P2 · **Created**: 2026-10-28
+**Package**: abstractruntime (`replay/view.py`) · **Slice**: abstractgateway (`discovery/capabilities`)
+**Parent**: 0854 (replay view), framework root backlog 0993 · **Found by**: AbstractUIC backlog 0040 (panel-chat 0.6.0 renders the view)
+
+## Problem
+
+A client that renders the replay view cannot tell a Stop the person asked for from one the gateway
+forced. The ledger knows: the gateway's kill switch writes an `abstract.status` record with
+`killed_by: "kill_switch"` and its text ("Stop forced at 10 s: inference killed", conformance case
+`d_cancellation`). The reducer keeps only the text, as `display_status` of the run
+(`view.py` `_fold_event`, the `abstract.status` branch), and drops `killed_by`. panel-chat's ledger
+fold showed "Stop forced: inference killed" from that record; in view mode it can only say
+"Stopped", and a client that clears `display_status` on a terminal status (panel-chat does, as its
+ledger fold did) loses the text too.
+
+A second, related gap: AbstractGateway 0.17.0 does not list the view in `GET discovery/capabilities`,
+so every client must probe `GET /view` once and treat FastAPI's route-missing 404 as "no view".
+
+## Proposal
+
+- The view carries how the run was stopped: on the root (and each `runs[]` row) a `stop` object
+  `{by: "person"|"kill_switch"|"timeout"|…, text, seq}` folded from the attribution record
+  (`killed_by`, `cancelled_by` on the cancelled `llm_call`), and a `stop` change in `changes`.
+- The gateway advertises `capabilities.replay_view: {supported: true, version: "replay_view_v1",
+  endpoints: {view, stream}}`.
+
+## Acceptance
+
+- `d_cancellation`'s expected view names the kill switch and its text; a person's cancel
+  (`cancelled_by`) reads as such; a new conformance case for a person's Stop.
+- `GET discovery/capabilities` lists `replay_view`; panel-chat passes it as `advertised` and stops
+  probing.

abstractruntime-0.15.2/docs/backlog/proposed/0861_replay_view_activity_tool_sandbox_and_call_timings.md

@@ -0,0 +1,34 @@
+# 0861 — Replay view activities: the tool sandbox and per-call model timings
+
+**Status**: proposed · **Priority**: P2 · **Created**: 2026-10-28
+**Package**: abstractruntime (`replay/view.py` `_fill_activity`)
+**Parent**: 0854 (replay view), framework root backlog 0993 · **Found by**: AbstractUIC backlog 0040 (panel-chat 0.6.0 renders the view)
+
+## Problem
+
+Two things clients showed from raw records are not in `replay_view_v1.activities[]`:
+
+1. **The command sandbox of a tool call.** A process-spawning tool's result carries
+   `output.sandbox` (macOS sandbox-exec, Linux bubblewrap/Landlock, "none — refused", the enforced
+   workspaces). panel-chat's `ToolSandboxLine` renders it from the ledger; a view tool call has
+   `output` only when the output is the tool's value, and the sandbox block is not kept as a field.
+2. **Per-call model timings.** An `llm` activity carries `usage` (tokens) but not the call's
+   `gen_time`, the provider's prompt rate (prefill time), cache reuse or the model load. panel-chat's
+   turn statistics (`genTimeMs`, `prefillMs`, `decodeMs`, `timedCalls`, the slowest tool batch)
+   came from these record fields; in view mode only tokens, call counts, changed files and the
+   turn's span remain.
+
+## Proposal
+
+- `tool_calls[].sandbox`: the call's sandbox block as the tool reported it (`label`, `enforced`,
+  `workspaces`, `refused`), absent when the tool spawned nothing.
+- `activities[kind=llm].timing`: `{gen_time_ms, prompt_tokens_per_s, completion_tokens_per_s,
+  cached_tokens, load_ms}` exactly as the record reported them (a field absent when not reported:
+  zero is a claim).
+- `usage` on the view keeps its meaning (sums); timings are not summed by the reducer.
+
+## Acceptance
+
+- A conformance case with a sandboxed `execute_command` and an MLX call that reports
+  `gen_time` / rates; expected views carry both.
+- panel-chat's `replayStatistics` and tool rows read them (AbstractUIC follow-up of 0040).

abstractruntime-0.15.2/docs/backlog/proposed/0862_replay_view_message_artifacts_exclude_bookkeeping.md

@@ -0,0 +1,48 @@
+# 0862 — Replay view: a message's artifacts are what the run produced, not its offloaded bookkeeping
+
+**Status**: proposed · **Priority**: P2 · **Created**: 2026-10-28
+**Package**: abstractruntime (`replay/view.py` `_final_message` / `_note_artifacts` / `_artifact_refs`; the run-output and node-trace offload)
+**Parent**: 0854 (replay view) · **Found by**: operator QA 2026-10-28 (b) on the desktop Assistant (AbstractAssistant backlog 1067)
+
+## Problem
+
+An automation answer in the desktop Assistant showed two chips named by raw ids (`7c8efef…`, `f738932…`); opening
+one failed with "artifact not found". Evidence (operator data dir, run `68c30dd3…`, session
+`automation:7f7613b4…`, AbstractRuntime 0.15.0, AbstractGateway 0.17.0):
+
+1. **The final message lists bookkeeping as its artifacts.** `_final_message(..., refs=_artifact_refs(output))`
+   takes EVERY `$artifact` under the completion output. An agent's output carries `scratchpad`; the runtime
+   offloads its large values into the artifact store, so the message's `artifact_ids` were the agent's system
+   prompt (`text/plain`, 4,340 B, tag `source=node_trace_offload`, path
+   `output.scratchpad.node_traces.reason.steps[0].result.metadata._provider_request.payload.messages[0].content`)
+   and its step list (`application/json`, 145,460 B, `source=run_output_offload`, path `output.scratchpad.steps`).
+   Neither is something the person asked for.
+2. **`view.artifacts` misses a ref the message lists.** `_note_artifacts` walks the completion RESULT, one level
+   above the output `_final_message` walks; the system-prompt ref sits at depth 12 from the result, and
+   `_artifact_refs` stops at `_MAX_WALK_DEPTH = 12`. The message names an artifact the view does not describe
+   (no path, no owning run): a client cannot label it or know which run serves it.
+3. **The offload belongs to a child run.** The system-prompt artifact's `run_id` is the agent's child run
+   (`d072afe8…`, parent chain under the root), with no `session_id` tag; the gateway's content route serves an
+   artifact only through its own run or the session's memory run (`_assert_artifact_visible_to_run`), so a client
+   asking through the root run gets 404 "artifact not found" although the blob exists.
+
+4. **The snapshot-built final has the same problem, unlisted.** When no completion record was folded,
+   `_finalize` builds `:final` from `snapshot.output_artifacts` (every ref under the output, bookkeeping included)
+   and lists none of them in `view.artifacts`, so a client cannot tell an image from a scratchpad offload.
+
+## Proposal
+
+- A message's `artifact_ids` exclude refs under the run's bookkeeping (`scratchpad`, node traces, `_`-prefixed
+  metadata such as `_provider_request`, `_runtime_observability`), or carry a `role` per artifact
+  (`output` / `bookkeeping`) so every client applies one rule. Conformance case: an agent completion whose output
+  holds offloaded scratchpad values and one real `image_artifact`.
+- `_note_artifacts` and the message walk use the same root and depth bound, so every id a message lists is in
+  `view.artifacts` (invariant: `message.artifact_ids ⊆ {a.id for a in view.artifacts}`).
+- Offloads made for a run in a session carry the session (tag or descriptor), so the gateway can serve a child
+  run's artifact through the root run of the same session; or the view's artifact entry names its owning run (it
+  does: `run_id`) and clients are told to use it (AbstractAssistant 0.16.3 does).
+
+## Client status
+
+AbstractAssistant 0.16.3 drops listed bookkeeping refs, and unlisted refs of a ledger-folded final, on its side (a snapshot-built final keeps its unlisted refs) and opens each artifact through its
+owning run; AbstractUIC panel-chat and the iPhone/watch clients should apply the same rule until this lands.

{abstractruntime-0.15.0 → abstractruntime-0.15.2}/llms-full.txt

@@ -55,10 +55,21 @@ See llms.txt for the linked index.
 
 It is designed for long-running workflows that must survive restarts and explicitly model blocking (human input, timers, external events, subworkflows) without keeping Python stacks alive.
 
-**Version:** 0.15.0 • **Python:** 3.10+
+**Version:** 0.15.2 • **Python:** 3.10+
 
 **Status:** pre-1.0 (API may evolve). For production use, pin versions and follow `CHANGELOG.md`.
 
+## What's new in 0.15.2
+
+- **Run index builds never lose a run created during them**: a run another process (or store object) wrote while
+  this store built its indexes is in the session and children indexes and the listing at once (before, the session
+  index could miss it for the life of the store object; backlog 0863).
+
+## What's new in 0.15.1
+
+- **Is Empty accepts lists**: nothing, an empty text, or a list or object with no elements is empty (visual-flow
+  node `is_empty_string`; backlog 0862).
+
 ## What's new in 0.15.0
 
 - **Memory facade** (`abstractruntime.integrations.abstractmemory.memory_facade.MemoryFacade`): the one

{abstractruntime-0.15.0 → abstractruntime-0.15.2}/llms.txt

@@ -3,7 +3,7 @@
 > Durable workflow runtime (interrupt → checkpoint → resume) with an append-only execution ledger.
 
 - Python: 3.10+ (see `pyproject.toml`)
-- Version: 0.15.0
+- Version: 0.15.2
 - Ecosystem: [AbstractFramework](https://github.com/lpalbou/AbstractFramework) umbrella, integrates with [AbstractCore](https://github.com/lpalbou/abstractcore)
 - Hard invariant: `RunState.vars` must be JSON-serializable (`src/abstractruntime/core/models.py`)
 - Current AbstractCore baseline: base `abstractruntime` requires AbstractCore 2.30.0 or newer with its light install (remote providers, tools and the MCP worker, media routing); `abstractruntime[apple]` and `abstractruntime[gpu]` require AbstractCore's `apple` and `gpu` settings (`pyproject.toml`)

{abstractruntime-0.15.0 → abstractruntime-0.15.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "AbstractRuntime"
-version = "0.15.0"
+version = "0.15.2"
 description = "AbstractRuntime: a durable graph runner designed to pair with AbstractCore."
 readme = "README.md"
 requires-python = ">=3.10"

abstractruntime-0.15.2/release-notes.md

@@ -0,0 +1,11 @@
+### Fixed
+
+- **An index build no longer loses a run another store object creates during it** (`JsonFileRunStore`, backlog 0863).
+  A new run's `+` journal line is written before its file is published; a session/children/active index build that
+  marked the journal between the two and scanned the folder before the file landed missed the run: the listing until
+  the next reconciliation, the session and children indexes for the life of the store object (the reconciliation
+  repaired only the listing). Seen as a gateway that answered 404 `session_not_found` when archiving a session written
+  while it booted (AbstractGateway backlog 0963); a split-mode runner creating a run during the API process's boot
+  hit the same window. The first sync after a build now re-applies the journal's last 16 KiB before the build's mark
+  (`JOURNAL_REPLAY_TAIL_BYTES`; idempotent, once per build), and the reconciliation re-files a run it repairs into
+  the session and children indexes too (and drops a vanished one from them).

{abstractruntime-0.15.0 → abstractruntime-0.15.2}/src/abstractruntime/storage/json_files.py

@@ -130,6 +130,10 @@ class JsonFileRunStore(RunStore):
     # A run temp file older than this is an orphan of a crashed writer (a
     # save()/create_if_absent() publishes its temp within milliseconds).
     STALE_TEMP_AGE_S = 600.0
+    # An index build re-applies the journal records written in this many bytes BEFORE its mark
+    # (`_mark_journal_start`; ~400 records): a run whose `+` line landed before the mark while its
+    # file was published after the folder scan is otherwise in neither (gateway backlog 0963).
+    JOURNAL_REPLAY_TAIL_BYTES = 16 * 1024
     # Background reconciliation of the active index (foreign writers that bypass the journal).
     ACTIVE_INDEX_RESCAN_S = 60.0
     # Trusted run index: with the folder and the creation log unchanged since the last
@@ -701,6 +705,7 @@ class JsonFileRunStore(RunStore):
             self._children_index = children
             self._run_parent_index = run_parent
         self._maybe_persist_scan_memo()
+        self._sync_indexes()  # the journal tail before the mark (`_journal_replay_start`), at once
 
     # --- creation journal ------------------------------------------------
 
@@ -745,7 +750,32 @@ class JsonFileRunStore(RunStore):
         with self._journal_lock:
             if self._journal_offset is None:
                 size = self._journal_size()
-                self._journal_offset = size if size is not None else 0
+                self._journal_offset = self._journal_replay_start(size) if size is not None else 0
+
+    def _journal_replay_start(self, size: int) -> int:
+        """Where the first sync after an index build starts reading: the first record boundary
+        within JOURNAL_REPLAY_TAIL_BYTES before `size` (the journal's size at the mark).
+
+        `_save` appends a new run's `+id` BEFORE publishing its file (J53-1). A build that marks
+        the journal at `size` and then scans the folder misses a run whose line is before the
+        mark and whose file lands after the scan; re-applying the tail (idempotent: a `+` whose
+        file exists is filed, one whose file is still absent stays pending until it appears)
+        closes that window. Cost: one read of at most JOURNAL_REPLAY_TAIL_BYTES and one stat per
+        record in it, once per build. A record older than the tail is still caught by the
+        periodic reconciliation, which re-files what it repairs in every index and logs it."""
+        start = max(0, int(size) - int(self.JOURNAL_REPLAY_TAIL_BYTES))
+        if start == 0:
+            return 0
+        try:
+            with open(self._journal_path, "rb") as f:
+                f.seek(start)
+                chunk = f.read(int(size) - start)
+        except OSError:
+            logger.warning("JsonFileRunStore: creation journal tail unreadable; index build replays nothing before its mark",
+                           exc_info=True)
+            return int(size)
+        boundary = chunk.find(b"\n")  # records are framed `\n<op><run_id>\n`: start after a newline
+        return start + boundary + 1 if boundary >= 0 else int(size)
 
     def _sync_indexes(self) -> None:
         """Apply journal lines appended since the last sync (one stat when
@@ -880,6 +910,7 @@ class JsonFileRunStore(RunStore):
             self._session_index = index
             self._run_session = by_run
         self._maybe_persist_scan_memo()
+        self._sync_indexes()  # the journal tail before the mark (`_journal_replay_start`), at once
 
     def _update_session_index_on_save(self, run: RunState) -> None:
         rid = str(run.run_id)
@@ -1324,6 +1355,7 @@ class JsonFileRunStore(RunStore):
         t0 = time.monotonic()
         settled_ns = time.time_ns() - int(float(self.RUN_INDEX_IN_FLIGHT_S) * 1e9)
         repaired: List[str] = []
+        refile: Dict[str, Dict[str, Any]] = {}
         found: set[str] = set()
         seen: set[str] = set()
         for p in self._base.glob("run_*.json"):
@@ -1341,6 +1373,8 @@ class JsonFileRunStore(RunStore):
                 cur_tok = tuple(cur[0]) if cur is not None else None
                 if cur_tok is not None and cur_tok != prev_tok and cur_tok[0] < settled_ns:
                     repaired.append(rid)
+                    if fields is not None and rid:
+                        refile[rid] = fields
             if fields is None:
                 continue
             if self._is_active_status(fields.get("status")):
@@ -1349,6 +1383,13 @@ class JsonFileRunStore(RunStore):
         self._sync_indexes()
         dropped = self._scan_memo_prune(seen)
         if complete:
+            # A run the session/children indexes missed (gateway backlog 0963) is re-filed there
+            # too, not only in the memo and the active set; a vanished one leaves them.
+            for rid, fields in refile.items():
+                self._index_fields_into_indexes(rid, fields)
+            for rid in dropped:
+                self._drop_from_children_index(rid)
+                self._drop_from_session_index(rid)
             repaired.extend(dropped)
             self._note_reconcile(repaired, files=len(seen), seconds=time.monotonic() - t0)
         return found

{abstractruntime-0.15.0 → abstractruntime-0.15.2}/src/abstractruntime/visualflow_compiler/visual/builtins.py

@@ -283,10 +283,15 @@ def string_length(inputs: Dict[str, Any]) -> int:
 
 
 def string_is_empty(inputs: Dict[str, Any]) -> bool:
-    """Return True if `text` is exactly empty."""
-    text_raw = inputs.get("text")
-    text = "" if text_raw is None else str(text_raw)
-    return text == ""
+    """Is Empty: True when `text` is nothing (unset / None), an empty string, or a list,
+    tuple, set or object with no elements (operator QA 2026-10-28: a list variable filled
+    by a loop is checked with one node). Whitespace is not empty; any other value is not."""
+    value = inputs.get("text")
+    if value is None:
+        return True
+    if isinstance(value, (list, tuple, set, frozenset, dict)):
+        return len(value) == 0
+    return str(value) == ""
 
 
 def string_contains(inputs: Dict[str, Any]) -> bool: