dirigent-core 0.17.2__tar.gz → 0.18.0__tar.gz

{dirigent_core-0.17.2 → dirigent_core-0.18.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dirigent-core
-Version: 0.17.2
+Version: 0.18.0
 Summary: Dirigent engine core: schema, configuration, and plugin host.
 License-Expression: LicenseRef-Proprietary
 License-File: LICENSE
@@ -12,9 +12,9 @@ Requires-Dist: argon2-cffi>=25.1.0
 Requires-Dist: asyncpg>=0.31.0
 Requires-Dist: cronsim>=2.7
 Requires-Dist: cryptography>=46.0.5
-Requires-Dist: dirigent-client==0.17.2
-Requires-Dist: dirigent-common==0.17.2
-Requires-Dist: dirigent-plugin==0.17.2
+Requires-Dist: dirigent-client==0.18.0
+Requires-Dist: dirigent-common==0.18.0
+Requires-Dist: dirigent-plugin==0.18.0
 Requires-Dist: jsonschema>=4.26.0
 Requires-Dist: opentelemetry-api>=1.44.0
 Requires-Dist: pydantic-settings>=2.15.0

{dirigent_core-0.17.2 → dirigent_core-0.18.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dirigent-core"
-version = "0.17.2"
+version = "0.18.0"
 description = "Dirigent engine core: schema, configuration, and plugin host."
 readme = "README.md"
 requires-python = ">=3.13"
@@ -17,9 +17,9 @@ dependencies = [
     "asyncpg>=0.31.0",
     "cronsim>=2.7",
     "cryptography>=46.0.5",
-    "dirigent-client==0.17.2",
-    "dirigent-common==0.17.2",
-    "dirigent-plugin==0.17.2",
+    "dirigent-client==0.18.0",
+    "dirigent-common==0.18.0",
+    "dirigent-plugin==0.18.0",
     "jsonschema>=4.26.0",
     "opentelemetry-api>=1.44.0",
     "pydantic-settings>=2.15.0",

{dirigent_core-0.17.2 → dirigent_core-0.18.0}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "dirigent-core"
-version = "0.17.2"
+version = "0.18.0"
 description = "Dirigent engine core: schema, configuration, and plugin host."
 readme = "README.md"
 requires-python = ">=3.13"
@@ -17,9 +17,9 @@ dependencies = [
     "asyncpg>=0.31.0",
     "cronsim>=2.7",
     "cryptography>=46.0.5",
-    "dirigent-client==0.17.2",
-    "dirigent-common==0.17.2",
-    "dirigent-plugin==0.17.2",
+    "dirigent-client==0.18.0",
+    "dirigent-common==0.18.0",
+    "dirigent-plugin==0.18.0",
     "jsonschema>=4.26.0",
     "opentelemetry-api>=1.44.0",
     "pydantic-settings>=2.15.0",

{dirigent_core-0.17.2 → dirigent_core-0.18.0}/src/dirigent_core/alembic/versions/0001_baseline_schema.py

@@ -808,6 +808,9 @@ def upgrade() -> None:
         sa.Column(
             "remote_handle", sa.JSON().with_variant(postgresql.JSONB(astext_type=Text()), "postgresql"), nullable=True
         ),
+        sa.Column(
+            "fetched_output", sa.JSON().with_variant(postgresql.JSONB(astext_type=Text()), "postgresql"), nullable=True
+        ),
         sa.Column(
             "poke_cursor", sa.JSON().with_variant(postgresql.JSONB(astext_type=Text()), "postgresql"), nullable=True
         ),

{dirigent_core-0.17.2 → dirigent_core-0.18.0}/src/dirigent_core/artifacts.py

@@ -2,6 +2,7 @@
 
 import hashlib
 import json
+from collections.abc import AsyncGenerator
 from contextlib import suppress
 from typing import Final
 from uuid import UUID
@@ -9,6 +10,8 @@ from uuid import UUID
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from dirigent_common import JsonMap
+from dirigent_core.errors import DomainError
+from dirigent_core.messages import OBJECT_MISSING
 from dirigent_core.models import ArtifactRef, StepAttempt
 from dirigent_core.storage import Storage, StorageError, join_uri, parse_uri
 
@@ -19,6 +22,24 @@ MARKDOWN_CONTENT_TYPE: Final = "text/markdown"
 #: The key a text document inlines under, so an inline row is still a JSON document.
 TEXT_KEY: Final = "text"
 
+#: What an artifact row belonging to the run rather than to a step attempt names as its attempt.
+NO_ATTEMPT: Final = "-"
+
+
+class ObjectMissing(DomainError):
+    """The object this row names is not in storage."""
+
+    status = 404
+    message = OBJECT_MISSING
+
+    def __init__(self, reference: ArtifactRef) -> None:
+        """Name the object that is gone, and the run and attempt whose row still names it."""
+        super().__init__(
+            uri=reference.uri or "",
+            run=str(reference.run_id),
+            attempt=str(reference.step_attempt_id) if reference.step_attempt_id else NO_ATTEMPT,
+        )
+
 
 def canonical_json(value: object) -> bytes:
     """Serialize a value the one way the engine hashes and stores it."""
@@ -108,6 +129,24 @@ async def persist_document(
     return reference
 
 
+async def _present_uri(storage: Storage, reference: ArtifactRef) -> str:
+    """Return the URI a row names once storage confirms the object is there, or refuse.
+
+    A database restored without the artifact root it was taken beside still holds every row,
+    so the object is stat-ed before it is opened: a read that refuses here names what is gone,
+    where one that opened the stream first would break mid-body with the status already sent.
+    """
+    uri = reference.uri or ""
+    if await storage.stat(uri) is None:
+        raise ObjectMissing(reference)
+    return uri
+
+
+async def open_artifact(storage: Storage, reference: ArtifactRef) -> AsyncGenerator[bytes]:
+    """Open the stored object a row names for streaming, refusing before the first byte."""
+    return storage.open_read(await _present_uri(storage, reference))
+
+
 async def load_document(storage: Storage, reference: ArtifactRef) -> str:
     """Read a text document back, from the row when it inlined and from storage when it did not."""
     if reference.inline_value is not None:
@@ -115,7 +154,7 @@ async def load_document(storage: Storage, reference: ArtifactRef) -> str:
         return inlined if isinstance(inlined, str) else ""
     if reference.uri is None:
         return ""
-    return (await storage.read_bytes(reference.uri)).decode()
+    return (await storage.read_bytes(await _present_uri(storage, reference))).decode()
 
 
 async def load_artifact(session: AsyncSession, storage: Storage, artifact_id: UUID) -> JsonMap | None:
@@ -127,6 +166,6 @@ async def load_artifact(session: AsyncSession, storage: Storage, artifact_id: UU
         return reference.inline_value
     if reference.uri is None:
         return None
-    payload = await storage.read_bytes(reference.uri)
+    payload = await storage.read_bytes(await _present_uri(storage, reference))
     loaded: JsonMap = json.loads(payload)
     return loaded

{dirigent_core-0.17.2 → dirigent_core-0.18.0}/src/dirigent_core/config.py

@@ -161,10 +161,12 @@ class Settings(BaseSettings):
     """How loud the process log is. This is the process log; a run's own telemetry is the
     ``log_entries`` table, and a CLI ``-v`` or ``--debug`` flag wins over this."""
 
-    log_format: Literal["console", "json"] = "console"
-    """How a command spells a log line: ``console`` for a person, ``json`` for a collector.
+    log_format: Literal["console", "json"] | None = None
+    """How a command spells its output and its logs: ``console`` renders, ``json`` writes records.
 
-    The four process commands write NDJSON whatever this says.
+    Unset, the terminal decides: a terminal gets the rendering, and a pipe, a container's log,
+    an agent's shell and CI get NDJSON, ``dg dev`` and ``dg server`` included. A command's
+    ``--json`` or ``-o console`` wins over it.
     """
 
     artifact_root: str = f"file://./{STATE_DIR}/artifacts"
@@ -248,7 +250,7 @@ class Settings(BaseSettings):
     """A running run with no attempt progress for this long is flagged as stuck."""
 
     stale_worker: Duration = Field(default=timedelta(minutes=15), gt=timedelta(0))
-    """A worker whose registry row is older than this has that row reaped by the sweeper."""
+    """A worker whose last heartbeat is older than this has its registry row reaped by the sweeper."""
 
     docker_reap_interval: Duration = timedelta(minutes=5)
     """How often a docker-capable worker looks for compose stacks whose run has ended.

{dirigent_core-0.17.2 → dirigent_core-0.18.0}/src/dirigent_core/database.py

@@ -6,6 +6,7 @@ from collections.abc import AsyncGenerator, Awaitable, Callable
 from contextlib import asynccontextmanager, suppress
 from typing import Any, Final
 
+import aiosqlite
 import sqlalchemy as sa
 import structlog
 from sqlalchemy import event
@@ -78,11 +79,34 @@ def _configure_sqlite(engine: AsyncEngine) -> None:
         connection.exec_driver_sql("BEGIN IMMEDIATE")
 
 
+async def open_sqlite(*args: Any, **kwargs: Any) -> aiosqlite.Connection:
+    """Open one SQLite connection, waiting for its thread when the file will not open.
+
+    aiosqlite drives every connection from a worker thread that hands results back through
+    ``call_soon_threadsafe``. A connection that fails to open queues that thread's stop and
+    raises without waiting for it, so the thread can call into an event loop that has closed
+    in the meantime and die with ``RuntimeError: Event loop is closed``.
+    """
+    connection = aiosqlite.connect(*args, **kwargs)
+    worker = connection._thread  # pyright: ignore[reportPrivateUsage] - the driver's own thread
+    worker.daemon = True
+    try:
+        return await connection
+    except BaseException:
+        await asyncio.to_thread(worker.join)
+        raise
+
+
 def create_engine(settings: Settings) -> AsyncEngine:
     """Build the async engine for the configured database."""
     if settings.is_sqlite:
         ensure_sqlite_directory(settings)
-        engine = create_async_engine(settings.database_url, echo=settings.database_echo, future=True)
+        engine = create_async_engine(
+            settings.database_url,
+            echo=settings.database_echo,
+            future=True,
+            connect_args={"async_creator_fn": open_sqlite},
+        )
         _configure_sqlite(engine)
         return engine
     return create_async_engine(

{dirigent_core-0.17.2 → dirigent_core-0.18.0}/src/dirigent_core/documents.py

@@ -44,6 +44,7 @@ from dirigent_core.messages import (
     NOT_YAML,
     PARAMS_SCHEMA_INVALID,
     REFERENCE_GRID_IN_CONFIG,
+    REFERENCE_MALFORMED_ARTIFACTS,
     REFERENCE_MALFORMED_ITEM,
     REFERENCE_MALFORMED_RUN,
     REFERENCE_MALFORMED_STEP,
@@ -892,6 +893,10 @@ def _reference_problem(
             return None
         case ["run", *_]:
             return Issue.of(REFERENCE_MALFORMED_RUN, reference=reference)
+        case ["artifacts"]:
+            return None
+        case ["artifacts", *_]:
+            return Issue.of(REFERENCE_MALFORMED_ARTIFACTS, reference=reference)
         case [namespace, *_]:
             return Issue.of(REFERENCE_UNKNOWN_NAMESPACE, reference=reference, namespace=repr(namespace))
         case _:  # pragma: no cover - every shape above is total over a list of strings

{dirigent_core-0.17.2 → dirigent_core-0.18.0}/src/dirigent_core/engine/claim.py

@@ -60,6 +60,9 @@ class ClaimedUnit(BaseModel):
     """The run's trace context, so an attempt's span joins the trace the run started in."""
 
     remote_handle: RemoteHandle | None = None
+    fetched_output: JsonMap | None = None
+    """The result a previous call already fetched and committed, which settles this claim."""
+
     poke_cursor: JsonMap | None = None
     """The cursor the last committed poke returned, handed to the next one."""
 

{dirigent_core-0.17.2 → dirigent_core-0.18.0}/src/dirigent_core/engine/context.py

@@ -6,7 +6,8 @@ long step is visible working and its last lines still land with the outcome.
 """
 
 import asyncio
-from collections.abc import Mapping
+from collections.abc import AsyncGenerator, Mapping
+from contextlib import AbstractAsyncContextManager, asynccontextmanager
 from datetime import UTC, datetime, timedelta
 from fnmatch import fnmatch
 from pathlib import Path
@@ -26,7 +27,7 @@ from dirigent_core.messages import RUN_UNKNOWN_CONNECTION, RUN_UNKNOWN_SCHEMA, U
 from dirigent_core.models import Connection, Schema
 from dirigent_core.secrets import SecretBox
 from dirigent_core.storage import AttemptStorage, Storage, connection_binder, work_dir
-from dirigent_plugin import BlockFailure, ConnectionRef, ErrorClass, Logger, Runs
+from dirigent_plugin import BlockFailure, ByteSink, Capture, ConnectionRef, ErrorClass, Logger, Runs
 
 #: What an HTTP connection is assumed to call its fields, so core can build a client for
 #: any connection kind without importing the package that contributed it.
@@ -230,6 +231,19 @@ class BufferedLogger(BaseModel):
             self.full.set()
 
 
+class CapturedStream:
+    """A sink that carries the URI the engine opened it under, for a block to put in its output."""
+
+    def __init__(self, uri: str, sink: ByteSink) -> None:
+        """Bind the storage sink to the URI naming it."""
+        self.uri = uri
+        self._sink = sink
+
+    async def write(self, data: bytes) -> int:
+        """Append bytes to the stream and return how many were accepted."""
+        return await self._sink.write(data)
+
+
 class EngineStepContext:
     """The concrete StepContext the engine hands a block for exactly one call."""
 
@@ -297,6 +311,26 @@ class EngineStepContext:
         """Return the run-scoped URI prefix for intermediate artifacts."""
         return self._scratch
 
+    def capture(self, name: str, *, content_type: str = "text/plain") -> AbstractAsyncContextManager[Capture]:
+        """Open the storage object a block's named stream is written to, under the run's scratch."""
+        uri = f"{self._scratch.rstrip('/')}/{self._segment()}-{name}"
+
+        @asynccontextmanager
+        async def opened() -> AsyncGenerator[Capture]:
+            async with self.storage.open_write(uri, content_type=content_type) as sink:
+                yield CapturedStream(uri, sink)
+
+        return opened()
+
+    def _segment(self) -> str:
+        """The path this attempt's captures sit under: the step, the fan-out item, and the attempt.
+
+        ``{step}[/{item}]/attempt-{n}``. The step key is unique within the run and the item id
+        within a fan-out, so no two attempts of one run write over each other's streams.
+        """
+        item = f"/{self.run_item_id}" if self.run_item_id is not None else ""
+        return f"{self.step}{item}/attempt-{self.attempt}"
+
     @property
     def work(self) -> Path:
         """Return the run's directory on this worker's own filesystem, made on first read.

{dirigent_core-0.17.2 → dirigent_core-0.18.0}/src/dirigent_core/engine/executor.py

@@ -1,9 +1,10 @@
 """The engine proper: claim, call one block, record the outcome, ready the dependents.
 
 Two invariants carry everything here. One transaction per state transition, so there is no
-window in which a step is finished but its dependents have not been told. And a remote
-handle is committed on its own the moment ``execute`` returns it, so submit-then-crash
-recovers into polling rather than into a duplicate job.
+window in which a step is finished but its dependents have not been told. And what a remote
+call hands back is committed on its own the moment it arrives -- the handle ``execute``
+returns, and the result ``fetch`` returns -- so a crash recovers into polling or settling
+rather than into a duplicate job or a second fetch.
 """
 
 import asyncio
@@ -97,6 +98,8 @@ class Produced(BaseModel):
     model_config = ConfigDict(frozen=True)
 
     output: JsonMap
+    fetched: bool = False
+    """True when a fetch returned this output and nothing has committed it yet."""
 
 
 class Submitted(BaseModel):
@@ -252,6 +255,7 @@ class Engine:
             item_outputs=item_outputs,
             paired=frozenset(family),
             scratch=scratch,
+            artifacts=self.services.storage.artifact_root,
             run_id=run.id,
             window_start=run.window_start,
             window_end=run.window_end,
@@ -320,6 +324,7 @@ class Engine:
             schemas=await load_schemas(session),
             traceparent=run.traceparent,
             remote_handle=RemoteHandle.model_validate(attempt.remote_handle) if attempt.remote_handle else None,
+            fetched_output=attempt.fetched_output,
             poke_cursor=attempt.poke_cursor,
             deadline_at=attempt.deadline_at,
             gone_probes=attempt.gone_probes,
@@ -376,6 +381,8 @@ class Engine:
                 telemetry.record_failure(span, result.failure.message)
             if isinstance(result, Submitted):
                 await self.record_handle(unit, result.handle)
+            if isinstance(result, Produced) and result.fetched:
+                await self._record_fetched(unit, result.output)
             await self._record(
                 unit,
                 result,
@@ -440,6 +447,8 @@ class Engine:
         unit: ClaimedUnit,
     ) -> CallResult:
         """Drive an operator's half of the contract: execute once, then probe and fetch."""
+        if unit.fetched_output is not None:
+            return Produced(output=unit.fetched_output)
         if not unit.is_probe or unit.remote_handle is None:
             with self._timed(unit.block_id, "execute"):
                 produced = await operator.execute(config, context)
@@ -460,8 +469,8 @@ class Engine:
                 )
             case ProbeStatus.SUCCEEDED:
                 with self._timed(unit.block_id, "fetch"):
-                    fetched = await operator.fetch(handle, config, context)
-                return Produced(output=fetched.model_dump(mode="json"))
+                    retrieved = await operator.fetch(handle, config, context)
+                return Produced(output=retrieved.model_dump(mode="json"), fetched=True)
             case ProbeStatus.FAILED:
                 failed = (
                     Failure.unknown(REMOTE_JOB_SAID, detail=probe.message)
@@ -532,6 +541,24 @@ class Engine:
                 return
             attempt.remote_handle = handle.model_dump(mode="json")
 
+    async def _record_fetched(self, unit: ClaimedUnit, output: JsonMap) -> None:
+        """Commit a fetched result on its own, before the outcome that settles it."""
+        await with_deadlock_retry(lambda: self._record_fetched_once(unit, output))
+
+    async def _record_fetched_once(self, unit: ClaimedUnit, output: JsonMap) -> None:
+        """Run that transaction once; the caller runs it again after a deadlock.
+
+        It locks the run and then writes the attempt, the order every outcome uses and the
+        opposite of the claim's. Nothing of it survives a rollback, so it is safe to repeat.
+        """
+        async with session_scope(self.sessions) as session:
+            await lock_run(session, unit.run_id)
+            attempt = await session.get(StepAttempt, unit.attempt_id)
+            if attempt is None or not self._holds_lease(unit, attempt):
+                self._log_lost_lease(unit, attempt, "fetched result")
+                return
+            attempt.fetched_output = output
+
     async def _cancel_what_was_just_submitted(
         self,
         session: AsyncSession,
@@ -746,6 +773,7 @@ class Engine:
         )
         attempt.status = AttemptStatus.SUCCEEDED
         attempt.finished_at = now
+        attempt.fetched_output = None
         attempt.error = None
         attempt.error_code = None
         attempt.error_params = None

{dirigent_core-0.17.2 → dirigent_core-0.18.0}/src/dirigent_core/engine/references.py

@@ -1,8 +1,12 @@
 """``${...}`` reference resolution: the whole reference language, and nothing more.
 
-There are no expressions, loops, or conditionals, and four namespaces: ``params.*``,
-``steps.*``, ``item``, and ``run.scratch`` / ``run.id`` / ``run.window.start`` /
-``run.window.end``.
+There are no expressions, loops, or conditionals, and five namespaces: ``params.*``,
+``steps.*``, ``item``, ``run.scratch`` / ``run.id`` / ``run.window.start`` /
+``run.window.end``, and ``artifacts``.
+
+``run.scratch`` is the run's own prefix, which retention sweeps with the run; ``artifacts`` is
+the instance's storage root, which nothing sweeps, so ``${artifacts}/kept/x.json`` is how a
+document names an object meant to outlive the run that wrote it.
 
 ``steps`` has three forms: ``steps.<name>.output.*`` is a step's stored output,
 ``steps.<name>.items`` is the list a fan-out maps over and only ``for_each`` reads it, and
@@ -29,6 +33,7 @@ from dirigent_common import JsonMap, Message
 from dirigent_core.errors import DomainError
 from dirigent_core.messages import (
     ITEM_FAILED,
+    MALFORMED_ARTIFACTS,
     MALFORMED_RUN,
     MALFORMED_STEP,
     NAMES_NOTHING,
@@ -93,6 +98,9 @@ class ReferenceScope(BaseModel):
     """The steps whose grid this one shares, and whose matching item it may therefore read."""
 
     scratch: str = ""
+    artifacts: str = ""
+    """The instance's storage root, which outlives every run written under it."""
+
     run_id: UUID | None = None
 
     window_start: datetime | None = None
@@ -287,6 +295,10 @@ def lookup(reference: str, scope: ReferenceScope) -> JsonValue:
             return _step_output(reference, parts, scope)
         case "run":
             return _run_value(reference, parts, scope)
+        case "artifacts":
+            if parts[1:]:
+                raise UnknownReference(MALFORMED_ARTIFACTS, reference=reference)
+            return scope.artifacts
         case unknown:
             raise UnknownReference(UNKNOWN_NAMESPACE, reference=reference, namespace=repr(unknown))
 

{dirigent_core-0.17.2 → dirigent_core-0.18.0}/src/dirigent_core/engine/runs.py

@@ -247,6 +247,7 @@ async def create_run(
         scope = ReferenceScope(
             params=resolved_params,
             scratch=scratch_prefix(services.settings.artifact_root, run_id),
+            artifacts=services.storage.artifact_root,
             run_id=run_id,
             window_start=window.start if window is not None else None,
             window_end=window.end if window is not None else None,

{dirigent_core-0.17.2 → dirigent_core-0.18.0}/src/dirigent_core/logging.py

@@ -21,9 +21,6 @@ if TYPE_CHECKING:
 
 PACKAGE_LOGGER = "dirigent"
 
-#: Where a container names the spelling once, for a process and for a command alike.
-LOG_FORMAT_ENV = "DIRIGENT_LOG_FORMAT"
-
 #: Third-party loggers that ship their own handlers and must be pointed at ours instead.
 BRIDGED_LOGGERS = (
     "uvicorn",

{dirigent_core-0.17.2 → dirigent_core-0.18.0}/src/dirigent_core/messages.py

@@ -64,13 +64,24 @@ UNKNOWN_SCHEME = ARTIFACTS.define(
     "no storage backend registered for scheme {scheme}; registered schemes: {registered}",
 )
 
-OUTSIDE_ROOT = ARTIFACTS.define("outside_root", "{uri} resolves outside the artifact root {root}")
+OUTSIDE_ROOT = ARTIFACTS.define(
+    "outside_root",
+    "{uri} resolves outside the artifact root {root}; write ${{artifacts}}/<path> for an object "
+    "kept under this instance's root, or ${{run.scratch}}/<path> for one swept with the run",
+)
 
 UNKNOWN_STORAGE_CONNECTION = ARTIFACTS.define(
     "unknown_connection",
     "no connection coded {ref} to configure the {scheme} scheme from ({available})",
 )
 
+OBJECT_MISSING = ARTIFACTS.define(
+    "object_missing",
+    "there is nothing at {uri}: run {run} (attempt {attempt}) has an artifact row and storage "
+    "has no object; restore the artifact root from the backup that matches this database, "
+    "or prune the run",
+)
+
 
 HOST = Catalogue("host")
 
@@ -317,9 +328,15 @@ REFERENCE_MALFORMED_RUN = DOCUMENT.define(
     "${{{reference}}} is malformed: run exposes only run.scratch, run.id, run.window.start and run.window.end",
 )
 
+REFERENCE_MALFORMED_ARTIFACTS = DOCUMENT.define(
+    "reference_malformed_artifacts",
+    "${{{reference}}} is malformed: artifacts is the storage root itself and has no fields; "
+    "write ${{artifacts}}/<path>",
+)
+
 REFERENCE_UNKNOWN_NAMESPACE = DOCUMENT.define(
     "reference_unknown_namespace",
-    "${{{reference}}} names {namespace}, which is not one of params, steps, item, run",
+    "${{{reference}}} names {namespace}, which is not one of params, steps, item, run, artifacts",
 )
 
 FOR_EACH_READS_OUTPUT = DOCUMENT.define(
@@ -509,7 +526,7 @@ NO_ITEM = _unresolved("no_item", "this step does not fan out, so there is no ite
 
 UNKNOWN_NAMESPACE = _unresolved(
     "unknown_namespace",
-    "{namespace} is not a namespace; the reference language has params, steps, item, and run",
+    "{namespace} is not a namespace; the reference language has params, steps, item, run, and artifacts",
 )
 
 NO_OUTPUT = _unresolved("no_output", "step {step} has no stored output ({available})")
@@ -536,6 +553,11 @@ MALFORMED_RUN = _unresolved(
     "run exposes only run.scratch, run.id, run.window.start and run.window.end",
 )
 
+MALFORMED_ARTIFACTS = _unresolved(
+    "malformed_artifacts",
+    "artifacts is the storage root itself and has no fields; write ${{artifacts}}/<path>",
+)
+
 NO_WINDOW = _unresolved(
     "no_window",
     "this run carries no window; a schedule-fired or backfilled run has one, "

{dirigent_core-0.17.2 → dirigent_core-0.18.0}/src/dirigent_core/models.py

@@ -288,6 +288,10 @@ class StepAttempt(Entity):
 
     remote_handle: Mapped[JsonMap | None] = mapped_column(JsonDocument)
 
+    fetched_output: Mapped[JsonMap | None] = mapped_column(JsonDocument)
+    """The result a fetch returned, committed before the outcome so a worker that dies
+    between the two settles from it rather than fetching again."""
+
     poke_cursor: Mapped[JsonMap | None] = mapped_column(JsonDocument)
     """How far a sensor's poke has read, handed to the next poke as ``ctx.cursor``."""