shikiru-cli 0.2.0__py3-none-any.whl

shikiru/engine/acceptance.py

@@ -0,0 +1,90 @@
+"""Acceptance of a completed turn's report: a dirty worktree cannot end a task's work."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from shikiru.domain.reports import (
+    DECISION_ACCEPT,
+    DECISION_CHANGES_REQUESTED,
+    DECISION_SUPERSEDE,
+    REPORT_JSON_INDENT,
+    SEVERITY_BLOCKER,
+    FeedbackVerdict,
+    Issue,
+    Verdict,
+)
+from shikiru.engine.events import emit_turn_completed, emit_verdict
+from shikiru.engine.history import ENGINE_VERDICT_FILENAME
+from shikiru.engine.task_facts import require_repo
+from shikiru.private import write_private_text
+from shikiru.workspace.facts import describe_off_branch
+
+if TYPE_CHECKING:
+    from shikiru.domain.steps import Outcome
+    from shikiru.domain.tasks import Task
+    from shikiru.engine.task_facts import TaskFacts
+    from shikiru.engine.turn_execution import TurnExecution
+    from shikiru.store.events import EventLog
+    from shikiru.workspace.facts import WorkspaceFacts
+
+_WORK_ENDING_DECISIONS = frozenset({DECISION_ACCEPT, DECISION_SUPERSEDE})
+REJECTION_SUMMARY = "The workspace cannot be integrated as it is."
+UNCOMMITTED_ISSUE = (
+    "Uncommitted changes in the workspace: {paths}. "
+    "Commit what belongs to this task and discard the rest."
+)
+
+
+def _blocker(task: Task, facts: WorkspaceFacts) -> str | None:
+    branch = require_repo(task).branch
+    if facts.head_branch != branch:
+        return describe_off_branch(branch, facts.head_branch, facts.commits)
+    if facts.status:
+        paths = ", ".join(line.strip() for line in facts.status)
+        return UNCOMMITTED_ISSUE.format(paths=paths)
+    return None
+
+
+class AcceptanceGuard:
+    """Records a completed turn and rejects an accepting verdict over a dirty worktree."""
+
+    def __init__(self, *, events: EventLog, facts: TaskFacts) -> None:
+        """Record through `events` and inspect the worktree through `facts`."""
+        self._events = events
+        self._facts = facts
+
+    async def settle[R: Outcome](
+        self, task: Task, report: R, execution: TurnExecution
+    ) -> R | Verdict:
+        """Record the completed turn; return `report`, or the engine's rejection of a dirty accept.
+
+        An `accept` or `supersede` verdict ends the task's work, so uncommitted changes in its
+        worktree replace it with a `changes_requested` verdict written beside the turn's report.
+        """
+        emit_turn_completed(self._events, task, report, execution)
+        if not isinstance(report, Verdict) or report.decision not in _WORK_ENDING_DECISIONS:
+            return report
+        facts = await self._facts.collect(task)
+        description = _blocker(task, facts)
+        if description is None:
+            return report
+        rejection_type = FeedbackVerdict if isinstance(report, FeedbackVerdict) else Verdict
+        rejection = rejection_type(
+            decision=DECISION_CHANGES_REQUESTED,
+            summary=REJECTION_SUMMARY,
+            issues=[Issue(severity=SEVERITY_BLOCKER, description=description)],
+        )
+        write_private_text(
+            execution.turn_dir / ENGINE_VERDICT_FILENAME,
+            rejection.model_dump_json(indent=REPORT_JSON_INDENT),
+        )
+        emit_verdict(
+            self._events,
+            task,
+            rejection,
+            rejection.summary,
+            turn=execution.turn_dir.name,
+            role=execution.role,
+        )
+        return rejection

shikiru/engine/agents.py

@@ -0,0 +1,61 @@
+"""`AgentPool`: builds and caches one headless `Agent` per name.
+
+Builds through an injected `create` callable rather than an `AgentRegistry` directly, keeping
+the engine on the shared `agents.contracts` boundary: callers pass `AgentRegistry.create` bound,
+but the engine itself never imports `agents.registry`.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from shikiru.agents.contracts import AgentContext, BillingDeclaration, billing_declaration_for
+from shikiru.errors import ConfigError
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from shikiru.agents.contracts import Agent
+    from shikiru.clock import Clock
+    from shikiru.config.settings import Settings
+    from shikiru.process import SubprocessRunner
+
+
+class AgentPool:
+    """Resolves a rung's agent name to its `Agent`, built once and cached."""
+
+    def __init__(
+        self,
+        create: Callable[[str, AgentContext], Agent],
+        runner: SubprocessRunner,
+        settings: Settings,
+        clock: Clock,
+    ) -> None:
+        """Build agents by calling `create(name, context)`, timed by `clock`."""
+        self._create = create
+        self._runner = runner
+        self._settings = settings
+        self._clock = clock
+        self._agents: dict[str, Agent] = {}
+
+    def get(self, name: str) -> Agent:
+        """Return `name`'s headless `Agent`, building and caching it on first use.
+
+        Raises `ConfigError` if `name` has no `[agents.<name>]` table: a rung naming an agent
+        the project never configured is a configuration mistake, not a default to paper over.
+        """
+        cached = self._agents.get(name)
+        if cached is not None:
+            return cached
+        config = self._settings.agents.get(name)
+        if config is None:
+            message = f"agent {name!r} is used by a rung but has no [agents.{name}] table"
+            raise ConfigError(message)
+        context = AgentContext(options=config.options, runner=self._runner, clock=self._clock)
+        agent = self._create(name, context)
+        self._agents[name] = agent
+        return agent
+
+    def billing_declaration(self, name: str) -> BillingDeclaration:
+        """Return the configured plugin's optional declaration through the contract boundary."""
+        return billing_declaration_for(self.get(name))

shikiru/engine/cosmetic_decorator.py

@@ -0,0 +1,99 @@
+"""Decorations that never fail the engine path that sets them."""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from shikiru.errors import PROCESS_FAILURES
+from shikiru.tmux.decorator import PaneDecorator
+
+if TYPE_CHECKING:
+    from collections.abc import Awaitable, Mapping
+
+    from shikiru.tmux.client import Tmux
+
+COSMETIC_LOGGER_NAME = __name__
+_LOGGER = logging.getLogger(COSMETIC_LOGGER_NAME)
+
+
+class CosmeticDecorator(PaneDecorator):
+    """A `PaneDecorator` whose failing tmux calls, timeouts included, are logged instead of raised.
+
+    A streak of failures of one operation is logged once, at its first failure, and ends with
+    that operation's next success.
+
+    A lost pane or server is repaired by the layout guard and must not end a task's flow or a
+    command.
+
+    A title template that cannot be rendered still raises `ConfigError`.
+    """
+
+    def __init__(self, tmux: Tmux) -> None:
+        """Decorate through `tmux`."""
+        super().__init__(tmux)
+        self._failing: set[str] = set()
+
+    async def _cosmetic(self, name: str, operation: Awaitable[None]) -> None:
+        try:
+            await operation
+        except PROCESS_FAILURES:
+            if name not in self._failing:
+                _LOGGER.exception("tmux %s failed", name)
+            self._failing.add(name)
+        else:
+            self._failing.discard(name)
+
+    async def configure_formats(self, window_target: str) -> None:
+        """Set the window formats, logging a tmux failure."""
+        await self._cosmetic("configure_formats", super().configure_formats(window_target))
+
+    async def set_pane_state(self, pane_target: str, *, color: str, glyph: str) -> None:
+        """Set the pane state, logging a tmux failure."""
+        await self._cosmetic(
+            "set_pane_state", super().set_pane_state(pane_target, color=color, glyph=glyph)
+        )
+
+    async def refresh_window(
+        self,
+        window_target: str,
+        template: str,
+        fields: Mapping[str, object],
+        *,
+        color: str,
+        glyph: str,
+    ) -> None:
+        """Set the window state and title, logging a tmux failure."""
+        await self._cosmetic(
+            "refresh_window",
+            super().refresh_window(window_target, template, fields, color=color, glyph=glyph),
+        )
+
+    async def set_pane_title(
+        self, pane_target: str, template: str, fields: Mapping[str, object]
+    ) -> None:
+        """Set the pane title, logging a tmux failure."""
+        await self._cosmetic(
+            "set_pane_title", super().set_pane_title(pane_target, template, fields)
+        )
+
+    async def set_pane_title_styling(
+        self,
+        pane_target: str,
+        template: str,
+        fields: Mapping[str, object],
+        *,
+        field_colors: Mapping[str, str],
+        field_segments: Mapping[str, tuple[tuple[str, str], ...]],
+    ) -> None:
+        """Set pane-title component colors, logging a tmux failure."""
+        await self._cosmetic(
+            "set_pane_title_styling",
+            super().set_pane_title_styling(
+                pane_target,
+                template,
+                fields,
+                field_colors=field_colors,
+                field_segments=field_segments,
+            ),
+        )

shikiru/engine/daemon.py

@@ -0,0 +1,409 @@
+"""The asyncio engine daemon: liveness, command dispatch and task supervision."""
+
+from __future__ import annotations
+
+import fcntl
+import math
+import os
+from datetime import timedelta
+from typing import TYPE_CHECKING, Self
+
+import psutil
+
+from shikiru.domain.commands import COMMAND_POLL_SECONDS, Stop
+from shikiru.domain.engine_uptime import (
+    ENGINE_PID_FIELD,
+    ENGINE_PROCESS_STARTED_AT_FIELD,
+)
+from shikiru.domain.events import STOP_REASON_KEY, EventKind
+from shikiru.errors import ShikiruError
+from shikiru.private import create_private_file, make_private_dir
+from shikiru.process import ProcessIdentity, identify_pid
+from shikiru.store.database import OperationalDatabaseError
+
+if TYPE_CHECKING:
+    from collections.abc import Awaitable, Callable
+    from logging import FileHandler, Logger
+    from pathlib import Path
+    from typing import TextIO
+
+    from shikiru.clock import Clock
+    from shikiru.config.settings import Settings
+    from shikiru.domain.events import Event
+    from shikiru.engine.handlers import HandlerRegistry
+    from shikiru.engine.layout_guard import LayoutGuard
+    from shikiru.engine.notification_delivery import NotificationDelivery
+    from shikiru.engine.notification_feed import NotificationFeed
+    from shikiru.engine.pull_request_closing import PullRequestClosing
+    from shikiru.engine.push_service import PushService
+    from shikiru.engine.reconcile import Reconciler
+    from shikiru.engine.retention import Retention
+    from shikiru.engine.scheduler import Scheduler
+    from shikiru.engine.session_guard import SessionGuard
+    from shikiru.engine.supervisor import TaskSupervisor
+    from shikiru.engine.tick_guard import TickGuard
+    from shikiru.store.commands import CommandQueue
+    from shikiru.store.events import EventLog
+    from shikiru.store.tasks import TaskStore
+
+ENGINE_LOGGER_NAME = "shikiru"
+_ENGINE_LOCK_METADATA_PARTS = 2
+ENGINE_LOCK_PROBE_GRACE_SECONDS = 1.0
+ENGINE_LOCK_RETRY_SECONDS = 0.02
+
+
+class EngineAlreadyRunningError(ShikiruError):
+    """The project already has an engine holding its exclusive lock."""
+
+
+class EngineLock:
+    """An exclusive process lock held for exactly one engine lifetime."""
+
+    def __init__(self, path: Path) -> None:
+        self._path = path
+        self._file: TextIO | None = None
+        self._identity: ProcessIdentity | None = None
+
+    def acquire(self) -> None:
+        """Acquire the lock without blocking, or raise `EngineAlreadyRunningError`."""
+        make_private_dir(self._path.parent)
+        create_private_file(self._path)
+        self._file = self._path.open("a+")
+        try:
+            fcntl.flock(self._file.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+        except BlockingIOError:
+            self._file.close()
+            self._file = None
+            message = f"engine lock is held: {self._path}"
+            raise EngineAlreadyRunningError(message) from None
+        self._file.seek(0)
+        self._file.truncate()
+        identity = ProcessIdentity(os.getpid(), psutil.Process(os.getpid()).create_time())
+        self._identity = identity
+        self._file.write(f"{identity.pid} {identity.started_at!r}")
+        self._file.flush()
+
+    @property
+    def identity(self) -> ProcessIdentity:
+        """Return this lock holder's recorded process identity."""
+        identity = self._identity
+        if identity is None:
+            message = "engine lock identity is unavailable before acquisition"
+            raise RuntimeError(message)
+        return identity
+
+    @staticmethod
+    def identity_if_running(path: Path) -> ProcessIdentity | None:
+        """Return the verified identity written by the process currently holding `path`."""
+        try:
+            lock_file = path.open()
+        except FileNotFoundError:
+            return None
+        with lock_file:
+            try:
+                fcntl.flock(lock_file.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+            except BlockingIOError:
+                lock_file.seek(0)
+                contents = lock_file.read().split()
+                if len(contents) != _ENGINE_LOCK_METADATA_PARTS:
+                    return None
+                try:
+                    pid = int(contents[0])
+                    process_started_at = float(contents[1])
+                except ValueError:
+                    return None
+                if pid < 1 or not math.isfinite(process_started_at):
+                    return None
+                identity = ProcessIdentity(pid, process_started_at)
+                return identity if identity.matches(identify_pid(identity.pid)) else None
+            fcntl.flock(lock_file.fileno(), fcntl.LOCK_UN)
+        return None
+
+    @staticmethod
+    def pid_if_running(path: Path) -> int | None:
+        """Return the verified PID written by the process that currently holds `path`."""
+        identity = EngineLock.identity_if_running(path)
+        return identity.pid if identity is not None else None
+
+    def release(self) -> None:
+        """Release the lock and close its file descriptor."""
+        if self._file is None:
+            return
+        fcntl.flock(self._file.fileno(), fcntl.LOCK_UN)
+        self._file.close()
+        self._file = None
+        self._identity = None
+
+    def __enter__(self) -> Self:
+        self.acquire()
+        return self
+
+    def __exit__(self, _type: object, _value: object, _traceback: object) -> None:
+        self.release()
+
+
+def engine_is_running(lock_path: Path) -> bool:
+    """Return whether another process currently holds `lock_path`."""
+    try:
+        lock_file = lock_path.open("r")
+    except FileNotFoundError:
+        return False
+    try:
+        fcntl.flock(lock_file.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+    except BlockingIOError:
+        return True
+    else:
+        fcntl.flock(lock_file.fileno(), fcntl.LOCK_UN)
+        return False
+    finally:
+        lock_file.close()
+
+
+class Engine:
+    """Poll commands, run the scheduler and supervise one coroutine per active task."""
+
+    def __init__(
+        self,
+        *,
+        lock_path: Path,
+        command_queue: CommandQueue,
+        tasks: TaskStore,
+        events: EventLog,
+        scheduler: Scheduler,
+        task_supervisor: TaskSupervisor,
+        handlers: HandlerRegistry,
+        layout: LayoutGuard,
+        session_guard: SessionGuard,
+        tick_guard: TickGuard,
+        command_guard: TickGuard,
+        loop_guard: TickGuard,
+        reconciler: Reconciler,
+        notifications: NotificationDelivery,
+        notification_feed: NotificationFeed,
+        retention: Retention,
+        retention_guard: TickGuard,
+        pull_request_closing: PullRequestClosing,
+        push_service: PushService | None,
+        settings: Settings,
+        clock: Clock,
+        close_state: Callable[[], None],
+        logger: Logger,
+        log_handler: FileHandler,
+    ) -> None:
+        """Wire the daemon loop to its stores and bootstrap-built command registry."""
+        self._lock = EngineLock(lock_path)
+        self._commands = command_queue
+        self._tasks = tasks
+        self._events = events
+        self._scheduler = scheduler
+        self._task_supervisor = task_supervisor
+        self._handlers = handlers
+        self._layout = layout
+        self._session_guard = session_guard
+        self._tick_guard = tick_guard
+        self._command_guard = command_guard
+        self._loop_guard = loop_guard
+        self._reconciled = False
+        self._stop_reason: str | None = None
+        self._stopped_event: Event | None = None
+        self._reconciler = reconciler
+        self._notifications = notifications
+        self._notification_feed = notification_feed
+        self._retention = retention
+        self._retention_guard = retention_guard
+        self._pull_request_closing = pull_request_closing
+        self._push_service = push_service
+        self._settings = settings
+        self._clock = clock
+        self._close_state = close_state
+        self._last_scheduled_event = 0
+        self._logger = logger
+        self._log_handler = log_handler
+
+    async def _acquire_lock(self) -> None:
+        deadline = self._clock.now() + timedelta(seconds=ENGINE_LOCK_PROBE_GRACE_SECONDS)
+        while True:
+            try:
+                self._lock.acquire()
+            except EngineAlreadyRunningError:
+                if self._clock.now() >= deadline:
+                    raise
+                await self._clock.sleep(ENGINE_LOCK_RETRY_SECONDS)
+            else:
+                return
+
+    async def run(self) -> None:
+        """Hold liveness, process commands and schedule tasks until `Stop` or cancellation."""
+        try:
+            await self._acquire_lock()
+        except BaseException:
+            self._close_logging()
+            self._close_state()
+            raise
+        try:
+            await self._until_done(self._restore_notifications)
+            self._notifications.start()
+            self._pull_request_closing.start()
+            await self._until_done(self._record_start)
+            next_tick = self._clock.now()
+            while not self._task_supervisor.stop_requested:
+                await self._task_supervisor.supervise(self._logger)
+                self._notifications.supervise(self._logger)
+                self._pull_request_closing.supervise(self._logger)
+                if not self._reconciled:
+                    await self._tick_guard.attempt(self._prepare)
+                commands_changed = bool(await self._command_guard.attempt(self._process_commands))
+                if self._task_supervisor.stop_requested:
+                    break
+                now = self._clock.now()
+                events_changed = await self._loop_guard.attempt(self._new_events) or []
+                if events_changed:
+                    self._last_scheduled_event = max(event.id for event in events_changed)
+                if commands_changed or events_changed or now >= next_tick:
+                    await self._tick_guard.attempt(self._tick)
+                    next_tick = now + timedelta(seconds=self._settings.orchestration.poll_seconds)
+                if self._reconciled and self._push_service is not None:
+                    self._push_service.poll(self._logger)
+                if self._reconciled:
+                    await self._retention_guard.attempt(self._retention.run_if_due)
+                await self._loop_guard.attempt(self._scan_notifications)
+                await self._clock.sleep(COMMAND_POLL_SECONDS)
+            await self._task_supervisor.supervise(self._logger)
+        except Exception as error:
+            self._stop_reason = f"{type(error).__name__}: {error}"
+            self._logger.exception("engine stopping on an unrecoverable fault")
+            raise
+        finally:
+            await self._shutdown()
+
+    def request_stop(self) -> None:
+        """Ask the command loop to stop after acknowledging the current command."""
+        self._task_supervisor.request_stop()
+
+    async def _until_done(self, step: Callable[[], Awaitable[bool]]) -> None:
+        while await self._loop_guard.attempt(step) is None:
+            if self._task_supervisor.stop_requested:
+                return
+            await self._clock.sleep(COMMAND_POLL_SECONDS)
+
+    async def _restore_notifications(self) -> bool:
+        self._notification_feed.restore()
+        return True
+
+    async def _record_start(self) -> bool:
+        self._events.append(
+            EventKind.ENGINE_STARTED,
+            message="engine started",
+            data=_engine_identity_data(self._lock.identity),
+        )
+        return True
+
+    async def _new_events(self) -> list[Event]:
+        return self._events.since(self._last_scheduled_event)
+
+    async def _scan_notifications(self) -> None:
+        self._notification_feed.scan()
+
+    async def _prepare(self) -> None:
+        await self._session_guard.ensure()
+        if not self._reconciled:
+            await self._reconciler.reconcile()
+            self._reconciled = True
+
+    async def _tick(self) -> None:
+        await self._prepare()
+        await self._layout.restore(self._tasks.list_active())
+        schedule = await self._scheduler.run_once()
+        for dispatch in schedule.dispatches:
+            await self._task_supervisor.start_task(dispatch.task_id)
+        await self._task_supervisor.ensure_flows()
+        await self._reconciler.restore_escalations()
+        scheduled_events = self._events.since(self._last_scheduled_event)
+        if scheduled_events:
+            self._last_scheduled_event = max(event.id for event in scheduled_events)
+
+    async def _process_commands(self) -> bool:
+        changed = False
+        for queued in self._commands.pending():
+            if not self._reconciled and not isinstance(queued.command, Stop):
+                continue
+            try:
+                result = await self._handlers.handle(queued.command)
+            except ShikiruError as error:
+                self._commands.mark_rejected(queued.id, {"error": str(error)})
+                continue
+            except OperationalDatabaseError:
+                raise
+            except Exception as error:
+                self._commands.mark_rejected(queued.id, {"error": str(error)})
+                raise
+            self._commands.mark_done(queued.id, result)
+            changed = True
+        return changed
+
+    async def _shutdown(self) -> None:
+        self._stopped_event = None
+        failures: list[Exception] = []
+        try:
+            for step in (
+                self._record_stop,
+                self._notifications.shutdown,
+                self._persist_notification_cursor,
+                self._pull_request_closing.shutdown,
+                self._shutdown_pushes,
+                self._deliver_stop,
+                self._scheduler.shutdown,
+                self._task_supervisor.shutdown,
+            ):
+                try:
+                    await step()
+                except Exception as error:
+                    self._logger.exception("engine shutdown step failed")
+                    failures.append(error)
+        finally:
+            try:
+                self._lock.release()
+            finally:
+                self._close_logging()
+                self._close_state()
+        if failures:
+            raise failures[0]
+
+    async def _record_stop(self) -> None:
+        reason = self._stop_reason
+        self._stopped_event = self._events.append(
+            EventKind.ENGINE_STOPPED,
+            message="engine stopped" if reason is None else f"engine stopped: {reason}",
+            data={
+                **_engine_identity_data(self._lock.identity),
+                **({} if reason is None else {STOP_REASON_KEY: reason}),
+            },
+        )
+
+    async def _persist_notification_cursor(self) -> None:
+        self._notification_feed.persist()
+
+    async def _shutdown_pushes(self) -> None:
+        if self._push_service is not None:
+            await self._push_service.shutdown()
+
+    async def _deliver_stop(self) -> None:
+        if self._stop_reason is not None and self._stopped_event is not None:
+            await self._notifications.deliver_final(
+                self._stopped_event, self._settings.orchestration.faults.stop_notify_seconds
+            )
+
+    def _close_logging(self) -> None:
+        handler = self._log_handler
+        self._logger.removeHandler(handler)
+        handler.close()
+
+
+def _engine_identity_data(identity: ProcessIdentity) -> dict[str, int | float]:
+    if identity.started_at is None:
+        message = "engine process start time is unavailable"
+        raise RuntimeError(message)
+    return {
+        ENGINE_PID_FIELD: identity.pid,
+        ENGINE_PROCESS_STARTED_AT_FIELD: identity.started_at,
+    }

shikiru/engine/dependency.py

@@ -0,0 +1,37 @@
+"""Dependency-cancellation escalation orchestration."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from shikiru.domain.steps import Transition
+from shikiru.domain.tasks import EscalationReason
+
+if TYPE_CHECKING:
+    from shikiru.domain.tasks import Task
+    from shikiru.engine.escalations import EscalationRaiser
+    from shikiru.engine.transitions import TransitionWriter
+
+
+class DependencyEscalator:
+    """Apply and packet a dependency-cancelled escalation through one boundary."""
+
+    def __init__(self, writer: TransitionWriter, raiser: EscalationRaiser) -> None:
+        """Use `writer` for the state transition and `raiser` for the operator packet."""
+        self._writer = writer
+        self._raiser = raiser
+
+    async def __call__(self, task: Task) -> None:
+        """Escalate `task` after the scheduler finds a cancelled dependency."""
+        transition = Transition.escalate_current(task, EscalationReason.DEPENDENCY_CANCELLED)
+        await self._raiser.raise_escalation(
+            task,
+            step=transition.step,
+            reason=EscalationReason.DEPENDENCY_CANCELLED,
+            question="A dependency was cancelled; choose whether to drop it or cancel this task.",
+            attempted="The scheduler found a cancelled dependency before dispatch.",
+            reports=(),
+            facts="",
+            view_tail="",
+            apply_state=lambda: self._writer.persist(task, transition, None),
+        )