AbstractRuntime 0.8.1__tar.gz → 0.8.2__tar.gz

{abstractruntime-0.8.1 → abstractruntime-0.8.2}/CHANGELOG.md

@@ -7,6 +7,20 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.8.2] - 2026-10-01
+
+Pausing an automation also stops its retries. Requires AbstractCore 2.20.2 (unchanged).
+
+### Changed
+- `automation.pause` also stops retries: an occurrence waiting in retry backoff is cancelled
+  (quietly, like `stop_current`), and a scheduled attempt that fails while the automation is paused
+  completes `failed` without a retry. An attempt already running still finishes, and a manual run
+  (`run_now`, allowed while paused) keeps its retries.
+
+### Notes
+- A retry that is waiting in backoff when you pause an automation is cancelled instead of starting
+  after its backoff. Resume the automation, or use `run_now`, to run it again.
+
 ## [0.8.1] - 2026-09-30
 
 Email automations never trigger themselves, speech and images work without a buildable text model,

{abstractruntime-0.8.1 → abstractruntime-0.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: AbstractRuntime
-Version: 0.8.1
+Version: 0.8.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,7 +55,7 @@ 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.8.1 • **Python:** 3.10+
+**Version:** 0.8.2 • **Python:** 3.10+
 
 **Status:** pre-1.0 (API may evolve). For production use, pin versions and follow `CHANGELOG.md`.
 
@@ -147,7 +147,7 @@ state = rt.resume(
 assert state.status.value == "completed"
 ```
 
-## What’s included (v0.8.1)
+## What’s included (v0.8.2)
 
 Kernel (import-light):
 - workflow graphs: `WorkflowSpec` (`src/abstractruntime/core/spec.py`)

{abstractruntime-0.8.1 → abstractruntime-0.8.2}/README.md

@@ -4,7 +4,7 @@
 
 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.8.1 • **Python:** 3.10+
+**Version:** 0.8.2 • **Python:** 3.10+
 
 **Status:** pre-1.0 (API may evolve). For production use, pin versions and follow `CHANGELOG.md`.
 
@@ -96,7 +96,7 @@ state = rt.resume(
 assert state.status.value == "completed"
 ```
 
-## What’s included (v0.8.1)
+## What’s included (v0.8.2)
 
 Kernel (import-light):
 - workflow graphs: `WorkflowSpec` (`src/abstractruntime/core/spec.py`)

{abstractruntime-0.8.1 → abstractruntime-0.8.2}/docs/architecture.md

@@ -1,7 +1,7 @@
 # AbstractRuntime — Architecture
 
-> Updated: 2026-09-29
-> Version: 0.8.1
+> Updated: 2026-10-01
+> Version: 0.8.2
 > Scope: this describes **what is implemented in this repository**.
 
 AbstractRuntime is a **durable workflow runtime**: it executes workflow graphs as a persisted state machine with explicit waits (user, time, events, jobs, subworkflows). A run can pause for hours/days and resume **without** keeping Python stacks/coroutines alive.

{abstractruntime-0.8.1 → abstractruntime-0.8.2}/docs/automations.md

@@ -286,7 +286,7 @@ expected_revision=None, now=None)` is the only way to change an automation. It r
 
 | Type | Effect | Rejected with |
 |---|---|---|
-| `automation.pause` | Stops **scheduled** admissions. The current occurrence and its retries finish, and `run_now` still works. This is separate from the runtime's own pause. | `invalid_state` when archived or finished |
+| `automation.pause` | Stops **scheduled** admissions. An attempt already running finishes, but no retry follows: an occurrence waiting in retry backoff is cancelled (quietly), and a scheduled attempt that fails while paused completes `failed` without a retry. `run_now` still works (a manual run keeps its retries). This is separate from the runtime's own pause. | `invalid_state` when archived or finished |
 | `automation.resume` | Re-arms the schedule at the first tick after now. It never fires on resume and never catches up the paused time. Resuming an automation that is not paused is an applied no-op. | `invalid_state` when archived or finished |
 | `automation.run_now` | Runs one occurrence at the controller's next step, even while paused (the automation stays paused). There is no queue. | `automation_busy` while an occurrence or a manual run is pending; `invalid_state` when archived, finished or exhausted |
 | `automation.revise` | `payload.changes = {title?, target?, trigger?, context?, policy?}` (at least one). `title`, `target`, `trigger` and `context` are replaced whole; `policy` fields are merged, so a field you do not send keeps its value. The next revision applies from the controller's next step. A changed trigger gets a new binding and is re-armed after now, so no past tick fires; an unchanged trigger keeps its binding. | `invalid_state` when archived or finished; the definition's own reason codes for invalid changes |

{abstractruntime-0.8.1 → abstractruntime-0.8.2}/llms-full.txt

@@ -53,7 +53,7 @@ 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.8.1 • **Python:** 3.10+
+**Version:** 0.8.2 • **Python:** 3.10+
 
 **Status:** pre-1.0 (API may evolve). For production use, pin versions and follow `CHANGELOG.md`.
 
@@ -145,7 +145,7 @@ state = rt.resume(
 assert state.status.value == "completed"
 ```
 
-## What’s included (v0.8.1)
+## What’s included (v0.8.2)
 
 Kernel (import-light):
 - workflow graphs: `WorkflowSpec` (`src/abstractruntime/core/spec.py`)
@@ -431,8 +431,8 @@ rt = create_local_runtime(provider="ollama", model="qwen3:4b")
 
 # AbstractRuntime — Architecture
 
-> Updated: 2026-09-29
-> Version: 0.8.1
+> Updated: 2026-10-01
+> Version: 0.8.2
 > Scope: this describes **what is implemented in this repository**.
 
 AbstractRuntime is a **durable workflow runtime**: it executes workflow graphs as a persisted state machine with explicit waits (user, time, events, jobs, subworkflows). A run can pause for hours/days and resume **without** keeping Python stacks/coroutines alive.
@@ -3807,7 +3807,7 @@ expected_revision=None, now=None)` is the only way to change an automation. It r
 
 | Type | Effect | Rejected with |
 |---|---|---|
-| `automation.pause` | Stops **scheduled** admissions. The current occurrence and its retries finish, and `run_now` still works. This is separate from the runtime's own pause. | `invalid_state` when archived or finished |
+| `automation.pause` | Stops **scheduled** admissions. An attempt already running finishes, but no retry follows: an occurrence waiting in retry backoff is cancelled (quietly), and a scheduled attempt that fails while paused completes `failed` without a retry. `run_now` still works (a manual run keeps its retries). This is separate from the runtime's own pause. | `invalid_state` when archived or finished |
 | `automation.resume` | Re-arms the schedule at the first tick after now. It never fires on resume and never catches up the paused time. Resuming an automation that is not paused is an applied no-op. | `invalid_state` when archived or finished |
 | `automation.run_now` | Runs one occurrence at the controller's next step, even while paused (the automation stays paused). There is no queue. | `automation_busy` while an occurrence or a manual run is pending; `invalid_state` when archived, finished or exhausted |
 | `automation.revise` | `payload.changes = {title?, target?, trigger?, context?, policy?}` (at least one). `title`, `target`, `trigger` and `context` are replaced whole; `policy` fields are merged, so a field you do not send keeps its value. The next revision applies from the controller's next step. A changed trigger gets a new binding and is re-armed after now, so no past tick fires; an unchanged trigger keeps its binding. | `invalid_state` when archived or finished; the definition's own reason codes for invalid changes |

{abstractruntime-0.8.1 → abstractruntime-0.8.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.8.1
+- Version: 0.8.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.20.2 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.8.1 → abstractruntime-0.8.2}/pyproject.toml

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

abstractruntime-0.8.2/release-notes.md

@@ -0,0 +1,11 @@
+Pausing an automation also stops its retries. Requires AbstractCore 2.20.2 (unchanged).
+
+### Changed
+- `automation.pause` also stops retries: an occurrence waiting in retry backoff is cancelled
+  (quietly, like `stop_current`), and a scheduled attempt that fails while the automation is paused
+  completes `failed` without a retry. An attempt already running still finishes, and a manual run
+  (`run_now`, allowed while paused) keeps its retries.
+
+### Notes
+- A retry that is waiting in backoff when you pause an automation is cancelled instead of starting
+  after its backoff. Resume the automation, or use `run_now`, to run it again.

{abstractruntime-0.8.1 → abstractruntime-0.8.2}/src/abstractruntime/automations/commands.py

@@ -13,8 +13,11 @@ record, controller wake, child cancellation), so a crash after the decision
 never loses them. Domain rejections are returned, never raised.
 
 Semantics:
-- pause: gates SCHEDULED admission only (never the runtime pause gate); the
-  current occurrence, including its retries, finishes; run_now stays allowed.
+- pause: gates SCHEDULED admission (never the runtime pause gate); an attempt
+  already running finishes, but no retry follows while paused: an occurrence
+  waiting in retry backoff is cancelled (quiet), and a scheduled attempt that
+  fails while paused completes `failed` without a retry. run_now stays allowed
+  (a manual occurrence started while paused keeps its retries).
 - resume: re-arms the trigger at the first tick after now; never fires.
 - run_now: records `manual_pending` (admitted at the controller's next
   boundary); rejected `automation_busy` while an occurrence or a manual run is
@@ -91,7 +94,13 @@ def _decide(
     if command_type == "automation.pause":
         if archived or terminal:
             return _reject("invalid_state", "An archived or finished automation cannot be paused.")
-        return {"delta": {"state": {"paused": True}}}
+        pause_state: Dict[str, Any] = {"paused": True}
+        pending = state.get("pending_occurrence")
+        if not state.get("paused") and isinstance(pending, dict) and pending.get("phase") == "backoff":
+            # A retry only waiting for its backoff never starts after a pause (N3): the
+            # occurrence is cancelled at the controller's next boundary, like stop_current.
+            pause_state["pending_occurrence"] = {**pending, "stop_requested": True}
+        return {"delta": {"state": pause_state}}
 
     if command_type == "automation.resume":
         if archived or terminal:

{abstractruntime-0.8.1 → abstractruntime-0.8.2}/src/abstractruntime/automations/controller.py

@@ -856,7 +856,10 @@ def record_outcome(turn: Turn) -> str:
         return "next"
     retry = pending.get("retry") or {"max_attempts": 1}
     attempt = int(pending["attempt"])
-    if attempt < int(retry["max_attempts"]):
+    # Paused: a SCHEDULED occurrence gets no further attempt (N3); a manual one (run_now,
+    # allowed while paused, `command_id` set) keeps its retries.
+    retry_blocked = bool(state.get("paused")) and pending.get("command_id") is None
+    if attempt < int(retry["max_attempts"]) and not retry_blocked:
         retry_at = add_delay(turn.now, backoff_delay({"retry": retry}, attempt))
         turn.decide(
             "automation.retry_scheduled",

{abstractruntime-0.8.1 → abstractruntime-0.8.2}/tests/test_automation_commands.py

@@ -234,6 +234,72 @@ def test_stop_current_during_backoff_cancels_the_retry(env):
     assert [d["status"] for d in done] == ["cancelled"]
 
 
+@pytest.mark.parametrize("env", STORES, indirect=True)
+def test_pause_during_backoff_cancels_the_retry(env):
+    """N3: a pause lands while the occurrence only waits for its retry: no attempt 2."""
+    runtime, clock = env
+    aid = create(runtime, clock, workflow_id="flaky", input_data={"prompt": "p", "fail_until": 99}, trigger=HOURLY)
+    drive(runtime, aid)
+    assert automation_state(runtime, aid)["pending_occurrence"]["phase"] == "backoff"
+    clock.set("2026-01-01T00:00:05+00:00")
+    assert cmd(runtime, aid, "p", "pause", "2026-01-01T00:00:05+00:00")["status"] == "applied"
+    drive(runtime, aid)
+    at(runtime, clock, aid, "2026-01-01T00:00:31+00:00")  # past the retry time
+    assert len(children(runtime, aid)) == 1  # attempt 2 never started
+    done = [r["payload"] for r in automation_records(runtime.ledger_store, aid, "automation.completed")]
+    assert [(d["status"], d["attention"]) for d in done] == [("cancelled", None)]
+    st = automation_state(runtime, aid)
+    assert st["paused"] is True and st["pending_occurrence"] is None
+    assert get_automation(runtime.run_store, aid)["status"] == "paused"
+
+
+@pytest.mark.parametrize("env", STORES, indirect=True)
+def test_an_attempt_failing_while_paused_is_not_retried(env):
+    """N3: the attempt running when the pause lands finishes; its failure schedules no retry."""
+    from abstractruntime.automations.bundle import controller_workflow_spec
+
+    runtime, clock = env
+    aid = create(runtime, clock, workflow_id="ask", trigger=HOURLY)
+    drive(runtime, aid)
+    child = children(runtime, aid)[0]
+    assert child.status == RunStatus.WAITING
+    assert cmd(runtime, aid, "p", "pause", "2026-01-01T00:01:00+00:00")["status"] == "applied"
+    assert runtime.get_state(child.run_id).status == RunStatus.WAITING  # a running attempt is not stopped
+    failed = runtime.run_store.load(child.run_id)
+    failed.status = RunStatus.FAILED
+    failed.error = "boom while paused"
+    failed.waiting = None
+    runtime.run_store.save(failed)
+    ctl = runtime.get_state(aid)
+    runtime.resume(workflow=controller_workflow_spec(), run_id=aid, wait_key=ctl.waiting.wait_key,
+                   payload={"sub_run_id": child.run_id, "output": {"success": False, "error": "boom while paused"}}, max_steps=0)
+    drive(runtime, aid)
+    at(runtime, clock, aid, "2026-01-01T00:10:00+00:00")  # well past a 30 s backoff
+    assert len(children(runtime, aid)) == 1
+    assert list(automation_records(runtime.ledger_store, aid, "automation.retry_scheduled")) == []
+    done = [r["payload"] for r in automation_records(runtime.ledger_store, aid, "automation.completed")]
+    assert [(d["status"], d["attempts"]) for d in done] == [("failed", 1)]
+    assert automation_state(runtime, aid)["paused"] is True
+
+
+@pytest.mark.parametrize("env", STORES, indirect=True)
+def test_a_manual_run_while_paused_keeps_its_retries(env):
+    runtime, clock = env
+    aid = create(runtime, clock, workflow_id="flaky", input_data={"prompt": "p", "fail_until": 2}, trigger=HOURLY)
+    drive(runtime, aid)  # the 00:00 occurrence: attempt 1 fails, backoff
+    at(runtime, clock, aid, "2026-01-01T00:00:30+00:00")  # attempt 2 succeeds
+    cmd(runtime, aid, "p", "pause", "2026-01-01T00:05:00+00:00")
+    drive(runtime, aid)
+    clock.set("2026-01-01T00:06:00+00:00")
+    assert cmd(runtime, aid, "run-1", "run_now", "2026-01-01T00:06:00+00:00")["status"] == "applied"
+    drive(runtime, aid)
+    pending = automation_state(runtime, aid)["pending_occurrence"]
+    assert pending["phase"] == "backoff" and pending["attempt"] == 2 and pending["command_id"] == "run-1"
+    at(runtime, clock, aid, "2026-01-01T00:06:30+00:00")
+    done = [r["payload"] for r in automation_records(runtime.ledger_store, aid, "automation.completed")]
+    assert [(d["status"], d["attempts"]) for d in done] == [("completed", 2), ("completed", 2)]
+
+
 @pytest.mark.parametrize("env", STORES, indirect=True)
 def test_archive_lets_the_current_occurrence_finish_then_ends(env):
     runtime, clock = env

abstractruntime-0.8.1/release-notes.md

@@ -1,33 +0,0 @@
-Email automations never trigger themselves, speech and images work without a buildable text model,
-and a chat's mail to its owner runs without asking. Requires AbstractCore 2.20.2.
-
-### Added
-- Mail sent by an automation run (controller, occurrence, any run it starts, the send-email action)
-  is automatic mail: the run's `EmailContext` gets `automation_marker =
-  "automation:<automation id>/run:<run id>"`, so every send carries `Auto-Submitted` and
-  `X-AbstractFramework-Automation`. `automation_marker_for(vars, run_id)` is exported from
-  `abstractruntime.email.binding`. Chats and discussions send ordinary mail.
-- `email.received@1` config `auto_submitted`: `"skip"` (default) never admits a message whose
-  `Auto-Submitted` header is present and not `no`; `"admit"` lets it reach the filters. Stored
-  configs without the key behave like `"skip"`.
-- `EmailInboxFeeder(..., is_own_sent=callable)` and `PollReport.own_automatic`: the account's own
-  automatic mail (the framework marker from its own address, or a Message-ID the host recorded as
-  sent) never enters the event inbox.
-- `abstractruntime.integrations.abstractcore.run_facade.inline_run_active(run_id)`: true while the
-  run facade executes a child run in this process; host runners skip such runs.
-- `ToolApprovalPolicy.default_require_approval_tools`: the names on the require list only because
-  no list was given (the default caution list).
-
-### Changed
-- The pooled local client runs media-only requests (image, video, voice, music, transcription, no
-  tools) and streaming TTS on AbstractCore's capability host instead of building the default text
-  client: text-to-speech no longer fails when the text default cannot be built (for example an
-  MLX route on an install without MLX), and no text model is loaded for a media request.
-- Without a per-run tool policy, the `send_email_recipient@v2` refiner now also lowers a name that
-  is on the executor's default caution list (`send_email` under `ToolApprovalPolicy()`): a chat
-  run's send to its owner's own address runs without an approval wait. An explicitly passed
-  require list and a per-run policy's still win; email-triggered runs under `approval: "ask"` are
-  unchanged.
-
-### Dependencies
-- `abstractcore>=2.20.2` (also `[apple]` and `[gpu]`).