AbstractRuntime 0.15.0__tar.gz → 0.15.1__tar.gz

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

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [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 0857. 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.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: AbstractRuntime
-Version: 0.15.0
+Version: 0.15.1
 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,15 @@ 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.1 • **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.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 0857).
+
 ## What's new in 0.15.0
 
 - **Memory facade** (`abstractruntime.integrations.abstractmemory.memory_facade.MemoryFacade`): the one

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

@@ -4,10 +4,15 @@
 
 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.1 • **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.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 0857).
+
 ## What's new in 0.15.0
 
 - **Memory facade** (`abstractruntime.integrations.abstractmemory.memory_facade.MemoryFacade`): the one

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

@@ -12,10 +12,14 @@ If you are new to the project, start with `../README.md` and `../architecture.md
 
 ## Counts
 
-- Planned: 32
-- Proposed: 14
+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: 16
 - Completed: 39
-- Deprecated: 13
+- Deprecated: 14
 - Recurrent: 0
 
 2026-09-20: counts reconciled to disk (28 planned and 12 proposed before this
@@ -93,6 +97,7 @@ mtime). The anticipated ADR ("an automation is its controller root run") is not
 
 | ID | Item |
 |----|------|
+| 0857 | [Is Empty accepts lists](completed/0857_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 +154,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.1/docs/backlog/completed/0857_is_empty_accepts_lists.md

@@ -0,0 +1,29 @@
+# 0857 — 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
+**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.1/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.1/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.1/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.1/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.0 → abstractruntime-0.15.1}/llms-full.txt

@@ -55,10 +55,15 @@ 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.1 • **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.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 0857).
+
 ## What's new in 0.15.0
 
 - **Memory facade** (`abstractruntime.integrations.abstractmemory.memory_facade.MemoryFacade`): the one

{abstractruntime-0.15.0 → abstractruntime-0.15.1}/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.1
 - 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.1}/pyproject.toml

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

abstractruntime-0.15.1/release-notes.md

@@ -0,0 +1,3 @@
+### 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 0857. AbstractFlow lets the node take a list once this is released.

{abstractruntime-0.15.0 → abstractruntime-0.15.1}/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:

abstractruntime-0.15.1/tests/test_visualflow_string_contains_replace.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+from abstractruntime.visualflow_compiler.visual.builtins import get_builtin_handler
+
+
+def test_string_is_empty_builtin() -> None:
+    is_empty = get_builtin_handler("is_empty_string")
+    assert is_empty is not None
+
+    assert is_empty({"text": ""}) is True
+    assert is_empty({}) is True
+    assert is_empty({"text": None}) is True
+    assert is_empty({"text": " "}) is False
+    assert is_empty({"text": "hello"}) is False
+
+
+def test_is_empty_accepts_lists_and_objects() -> None:
+    """Operator QA 2026-10-28: Is Empty also takes a list (no elements = empty), so a list
+    variable filled by a ForEach is checked with one node instead of Array Length + Compare."""
+    is_empty = get_builtin_handler("is_empty_string")
+    assert is_empty({"text": []}) is True
+    assert is_empty({"text": ()}) is True
+    assert is_empty({"text": {}}) is True
+    assert is_empty({"text": ["a"]}) is False
+    assert is_empty({"text": [None]}) is False
+    assert is_empty({"text": [[]]}) is False
+    assert is_empty({"text": {"k": 1}}) is False
+    assert is_empty({"text": 0}) is False
+    assert is_empty({"text": False}) is False
+
+
+def test_string_contains_builtin() -> None:
+    contains = get_builtin_handler("contains")
+    assert contains is not None
+
+    assert contains({"text": "hello world", "pattern": "world"}) is True
+    assert contains({"text": "hello world", "pattern": "WORLD"}) is False
+
+    # Safer than Python's default behavior where "" is contained in every string.
+    assert contains({"text": "hello", "pattern": ""}) is False
+    assert contains({"text": "hello", "pattern": None}) is False
+    assert contains({"text": None, "pattern": "x"}) is False
+
+
+def test_string_replace_builtin_modes() -> None:
+    replace = get_builtin_handler("replace")
+    assert replace is not None
+
+    assert replace({"text": "a-b-c", "pattern": "-", "replacement": "_", "mode": "all"}) == "a_b_c"
+    assert replace({"text": "a-b-c", "pattern": "-", "replacement": "_", "mode": "first"}) == "a_b-c"
+    assert replace({"text": "a-b-c", "pattern": "-", "replacement": "_", "mode": None}) == "a_b_c"
+
+    # Empty/missing pattern is a no-op.
+    assert replace({"text": "a-b-c", "pattern": "", "replacement": "_", "mode": "all"}) == "a-b-c"
+    assert replace({"text": "a-b-c", "pattern": None, "replacement": "_", "mode": "all"}) == "a-b-c"
+
+    # Numeric best-effort support: replace first N occurrences.
+    assert replace({"text": "a-b-c-d", "pattern": "-", "replacement": "_", "mode": "2"}) == "a_b_c-d"
+
+
+def test_is_empty_on_a_list_variable_in_a_compiled_flow() -> None:
+    """A list variable filled earlier, read by Get Variable into Is Empty, decides an If (the email-triage shape)."""
+    from abstractruntime.core.runtime import Runtime
+    from abstractruntime.storage.in_memory import InMemoryLedgerStore, InMemoryRunStore
+    from abstractruntime.visualflow_compiler.compiler import compile_flow
+    from abstractruntime.visualflow_compiler.visual.executor import visual_to_flow
+    from abstractruntime.visualflow_compiler.visual.models import load_visualflow_json
+
+    x, o = {"id": "exec-in", "type": "execution"}, {"id": "exec-out", "type": "execution"}
+
+    def node(nid, ntype, inputs=(), outputs=(), **data):
+        return {"id": nid, "type": ntype, "data": {"nodeType": ntype, "inputs": list(inputs), "outputs": list(outputs), **data}}
+
+    def edge(s, sh, t, th):
+        return {"source": s, "sourceHandle": sh, "target": t, "targetHandle": th}
+
+    def run(items):
+        nodes = [
+            node("start", "on_flow_start", outputs=[o]),
+            node("get", "get_var", [{"id": "name", "type": "string"}], [{"id": "value", "type": "array"}], pinDefaults={"name": "triage"}),
+            node("empty", "is_empty_string", [{"id": "text", "type": "any"}], [{"id": "result", "type": "boolean"}]),
+            node("if", "if", [x, {"id": "condition", "type": "boolean"}], [{"id": "true", "type": "execution"}, {"id": "false", "type": "execution"}]),
+            node("none", "on_flow_end", [x, {"id": "response", "type": "string"}], pinDefaults={"response": "none"}),
+            node("some", "on_flow_end", [x, {"id": "response", "type": "string"}], pinDefaults={"response": "some"}),
+        ]
+        edges = [
+            edge("start", "exec-out", "if", "exec-in"),
+            edge("get", "value", "empty", "text"),
+            edge("empty", "result", "if", "condition"),
+            edge("if", "true", "none", "exec-in"),
+            edge("if", "false", "some", "exec-in"),
+        ]
+        vf = load_visualflow_json({"id": "t", "name": "t", "entryNode": "start", "nodes": nodes, "edges": edges})
+        rt = Runtime(run_store=InMemoryRunStore(), ledger_store=InMemoryLedgerStore())
+        wf = compile_flow(visual_to_flow(vf))
+        rid = rt.start(workflow=wf, vars={"triage": items})
+        state = rt.tick(workflow=wf, run_id=rid, max_steps=50)
+        assert state.status.value == "completed", state.error
+        return state.output["response"]
+
+    assert run([]) == "none"
+    assert run([{"id": "m1"}, {"id": "m2"}]) == "some"

abstractruntime-0.15.0/release-notes.md

@@ -1,54 +0,0 @@
-Requires AbstractMemory 0.4.0 or newer (`abstractmemory.graph`). ADR 0011, backlog 0856.
-
-### Upgrade notes (one-way)
-
-- AbstractMemory 0.4.0 rewrites a SQLite home's JSON-text vectors as float32 BLOBs on first write; a 0.3.x reader then
-  finds no vectors (zero semantic hits, no error). Every process sharing a home or a plane moves to AbstractMemory 0.4.0
-  (and so AbstractRuntime 0.15.0) together. See the AbstractMemory 0.4.0 changelog.
-- The JSON-file ledger writes a `ledger_<run_id>.idx` row index beside each ledger; older readers ignore it, and a
-  missing or stale index is rebuilt from the ledger.
-
-### Added
-
-- **Ledger row address** (on 0.14.0's per-run `seq`, ADR 0010): `LedgerStore.get_record(run_id, seq)` returns one
-  record ready to read (a terminal row's `$slim` markers resolved against its STARTED row, offloaded leaves
-  rehydrated); `find_started_record(run_id, step_id, before_seq=)`. SQLite reads by primary key; the JSON-file backend
-  keeps a per-run line-offset index and checks the seq persisted on the line, so a point read is a seek and one line
-  parse (0.05 ms at 10,000 rows instead of a 58 ms full parse), and a rewritten file is read by persisted seq, never
-  by position.
-- **Step context**: an effect handler reads its own step with
-  `abstractruntime.core.step_context.current_step_context(run.run_id)`: `run_id`, `step_id`, `seq` of the attempt's
-  STARTED row, `node_id`, `attempt`, `effect_type`. Out of band like the progress callback; `None` outside a runtime
-  step; a nested runtime shadows it.
-- **Memory facade** (`abstractruntime.integrations.abstractmemory.memory_facade`): `MemoryFacade` (`open_mind`, `stamp`,
-  `stamp_current_step`, `reconstruct_source`, `history`, `sources_of`, `derived_from_source`, `apply_revision`),
-  `is_real_run`, and the AbstractMemory names hosts use re-exported unchanged (`GATEWAY_NAMES`). Hosts no longer import
-  `abstractmemory`. `reconstruct_source` answers `ok`, `source_gone` or `unsupported`, never raises for a missing
-  source. See [AbstractMemory integration](docs/integrations/abstractmemory.md).
-- **Provenance stamping**: `MEMORY_FORM`, `MEMORY_KG_ASSERT` and the `DIARY_WRITE` graph projection add a `sources`
-  list to the provenance they write: the `step` ref `(run_id, seq, step_id)` of the writing effect, an `artifact` ref
-  for the verbatim / `span_id`, a `diary_entry` ref for a projection. The legacy flat keys stay. A synthetic run id
-  (`chat-<session_id>`, `diary:<entity_id>`, ...) is never a `run`/`step` ref: the home-direct chat path carries
-  artifact or diary-entry refs only.
-- **`MEMORY_REVISE`** (`EffectType.MEMORY_REVISE`, VisualFlow node `memory_revise`): one revision of a mind (assert /
-  close / narrow ops) applied atomically through `MemoryGraph.apply_revision` as a workflow step, its provenance
-  stamped with the step that applied it. Handler from `build_memory_kg_effect_handlers` (new optional `journal=`); a
-  store that is not a graph home answers a failed outcome naming AbstractMemory backlog 0057; an ungrounded revision
-  fails with `ProvenanceRequired`.
-
-- **Source integrity** (architect pass): every ref the runtime stamps carries a `digest` (step: sha256 of the STARTED
-  record as written, also on the step context; artifact: the sha256 of its bytes; diary entry: the chain
-  `record_hash`), and `reconstruct_source` verifies it: new statuses `mismatch` (the bytes changed since the memory
-  named them) and `partial` (a `$slim` marker or an `{"$artifact": id}` leaf whose artifact is gone or uncheckable;
-  never `ok` with a hole). A step ref resolves only to its STARTED row (a rewritten JSON-file ledger answers
-  `source_gone`, never another row).
-- **Owner partitions**: `MEMORY_REVISE` and `MEMORY_KG_ASSERT` write only the run's own owners (its run, its session,
-  the global owner); `MEMORY_REVISE` refuses `recorded_at` (record time is the store's); a replayed revision reports
-  the memory's sources, not the retry's step.
-- **Persisted JSON-file row index** (`ledger_<run_id>.idx` beside the ledger): a fresh process reads a 100,000-row
-  ledger's row in 39 ms instead of 320 ms.
-
-### Changed
-
-- `AbstractMemory>=0.4.0` (was `>=0.3.2`).
-- SQLite `find_started_record` reads newest-first with `LIMIT 1` (0.01 ms at 10,000 rows instead of 3.5 ms).

abstractruntime-0.15.0/tests/test_visualflow_string_contains_replace.py

@@ -1,43 +0,0 @@
-from __future__ import annotations
-
-from abstractruntime.visualflow_compiler.visual.builtins import get_builtin_handler
-
-
-def test_string_is_empty_builtin() -> None:
-    is_empty = get_builtin_handler("is_empty_string")
-    assert is_empty is not None
-
-    assert is_empty({"text": ""}) is True
-    assert is_empty({}) is True
-    assert is_empty({"text": None}) is True
-    assert is_empty({"text": " "}) is False
-    assert is_empty({"text": "hello"}) is False
-
-
-def test_string_contains_builtin() -> None:
-    contains = get_builtin_handler("contains")
-    assert contains is not None
-
-    assert contains({"text": "hello world", "pattern": "world"}) is True
-    assert contains({"text": "hello world", "pattern": "WORLD"}) is False
-
-    # Safer than Python's default behavior where "" is contained in every string.
-    assert contains({"text": "hello", "pattern": ""}) is False
-    assert contains({"text": "hello", "pattern": None}) is False
-    assert contains({"text": None, "pattern": "x"}) is False
-
-
-def test_string_replace_builtin_modes() -> None:
-    replace = get_builtin_handler("replace")
-    assert replace is not None
-
-    assert replace({"text": "a-b-c", "pattern": "-", "replacement": "_", "mode": "all"}) == "a_b_c"
-    assert replace({"text": "a-b-c", "pattern": "-", "replacement": "_", "mode": "first"}) == "a_b-c"
-    assert replace({"text": "a-b-c", "pattern": "-", "replacement": "_", "mode": None}) == "a_b_c"
-
-    # Empty/missing pattern is a no-op.
-    assert replace({"text": "a-b-c", "pattern": "", "replacement": "_", "mode": "all"}) == "a-b-c"
-    assert replace({"text": "a-b-c", "pattern": None, "replacement": "_", "mode": "all"}) == "a-b-c"
-
-    # Numeric best-effort support: replace first N occurrences.
-    assert replace({"text": "a-b-c-d", "pattern": "-", "replacement": "_", "mode": "2"}) == "a_b_c-d"