daggerml 0.1.4__tar.gz → 0.1.5__tar.gz

{daggerml-0.1.4 → daggerml-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: daggerml
-Version: 0.1.4
+Version: 0.1.5
 Summary: DaggerML
 Author-Email: DaggerML <engineering@daggerml.com>
 License: MIT

{daggerml-0.1.4 → daggerml-0.1.5}/openspec/specs/mutable-index-commit-model/spec.md

@@ -31,13 +31,22 @@ The system SHALL preserve the current external runtime and history behavior whil
 ### Requirement: Mutating index workflows SHALL check execution lifecycle before each write transaction
 Every mutating `IndexOps` workflow SHALL instantiate `ExecutionState`, use execution lifecycle state in S3 as the sole mutation authority, and call `ExecutionState.require_mutation(execution_id, db, mode=...)` before each LMDB write transaction that can change index or DAG state.
 
-Execution-aware `IndexOps.create(cache_key, execution_id)` SHALL use `mode = "activation"`.
+Execution-aware `IndexOps.create(cache_key, execution_id)` SHALL use `mode = "activation"` while holding the driver lock to claim a pending execution. After validating the cache key and required argv reference, it SHALL transition the execution to `running` and release the driver lock before materializing argv or creating local index state. It SHALL use `mode = "mutation"` after argv materialization and before the LMDB write transaction that creates local index state. A `running` execution denotes claimed, started work, including input materialization and index initialization; it does not require local index state to exist yet.
 
 `put_literal`, `put_import`, `set_node_name`, `start_fn`, and `commit` SHALL use `mode = "mutation"`.
 
 #### Scenario: Execution-aware create activates only from pending
 - **WHEN** `IndexOps.create(cache_key="ck1", execution_id="e1")` begins activation
-- **THEN** it SHALL call `ExecutionState.require_mutation("e1", db, mode="activation")` before creating local index state
+- **THEN** it SHALL call `ExecutionState.require_mutation("e1", db, mode="activation")` while holding the driver lock before claiming the execution as `running`
+
+#### Scenario: Input materialization does not hold the activation lock
+- **WHEN** execution-aware create begins materializing argv
+- **THEN** the execution SHALL already be `running` and its activation owner SHALL have released the driver lock
+- **AND** another worker SHALL not activate that running execution
+
+#### Scenario: Cancellation during input materialization blocks index creation
+- **WHEN** argv materialization completes after the execution has entered `cancel-pending` or `canceled`
+- **THEN** the `mode="mutation"` guard SHALL reject local index creation before its write transaction
 
 #### Scenario: Mutating index op writes only from running
 - **WHEN** `put_literal`, `put_import`, `set_node_name`, `start_fn`, or `commit` begins a write transaction for execution `e1`

{daggerml-0.1.4 → daggerml-0.1.5}/src/daggerml/__about__.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.1.4'
-__version_tuple__ = version_tuple = (0, 1, 4)
+__version__ = version = '0.1.5'
+__version_tuple__ = version_tuple = (0, 1, 5)
 
-__commit_id__ = commit_id = 'g8c222deae'
+__commit_id__ = commit_id = 'g2163d3564'

{daggerml-0.1.4 → daggerml-0.1.5}/src/daggerml/_core/index.py

@@ -104,13 +104,15 @@ class IndexOps:
         if execution_id is not None:
             record, owner = state.activate(exec_id, db)
             try:
+                state.require_mutation(exec_id, db, mode="activation")
                 metadata = record["metadata"]
                 if metadata["cache_key"] != cache_key or metadata["argv_ref"] is None:
                     raise DmlRepoError(f"Invalid execution payload for cache key: {cache_key}")
-                argv = self._remote.materialize_ref(Ref(metadata["argv_ref"]), db)
+                state.mark_running(exec_id, owner)
             except Exception:
                 state.unlock(exec_id, owner)
                 raise
+            argv = self._remote.materialize_ref(Ref(metadata["argv_ref"]), db)
         else:
             argv = None
             _, owner, _ = state.reserve_execution(None, execution_id=exec_id)
@@ -139,15 +141,8 @@ class IndexOps:
             )
 
         if execution_id is not None:
-            try:
-                index = db.write_with_growth(create_index)
-                state.mark_running(exec_id, owner)
-            except Exception:
-                state.unlock(exec_id, owner)
-                raise
-        else:
-            index = db.write_with_growth(create_index)
-        return index
+            state.require_mutation(exec_id, db, mode="mutation")
+        return db.write_with_growth(create_index)
 
     def freeze(self, index: Ref, message: str | None, *, db: DmlDB) -> Ref:
         """Replace a user runtime index with its frozen representation."""

{daggerml-0.1.4 → daggerml-0.1.5}/src/daggerml/dashboard/static/docs/fragments/extend/adapters.html

@@ -102,7 +102,7 @@
 </table>
 <p>Contrib plugin distributions are needed where delayed work is authored and lowered. The selected adapter executable must be available to the runtime process; a Lambda adapter additionally needs its target Lambda deployed.</p>
 <p>This minimal hook illustration constructs the <code>Runnable</code> directly; it is not a complete deployable backend.</p>
-<div id="54bbd7cf" class="cell" data-execution_count="2">
+<div id="893cf2c8" class="cell" data-execution_count="2">
 <div class="sourceCode cell-code" id="cb3"><pre class="sourceCode python code-with-copy"><code class="sourceCode python"><span id="cb3-1"><a href="#cb3-1" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> daggerml <span class="im">import</span> Runnable, Uri</span>
 <span id="cb3-2"><a href="#cb3-2" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> daggerml.contrib.adapters <span class="im">import</span> AdapterBase</span>
 <span id="cb3-3"><a href="#cb3-3" aria-hidden="true" tabindex="-1"></a></span>
@@ -134,7 +134,7 @@
 <span id="cb3-29"><a href="#cb3-29" aria-hidden="true" tabindex="-1"></a>)</span>
 <span id="cb3-30"><a href="#cb3-30" aria-hidden="true" tabindex="-1"></a><span class="cf">assert</span> response <span class="op">==</span> {<span class="st">"status"</span>: <span class="st">"retry"</span>, <span class="st">"adapter_state"</span>: {<span class="st">"job"</span>: <span class="st">"example"</span>}, <span class="st">"error"</span>: <span class="va">None</span>}</span></code><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></pre></div>
 </div>
-<div id="e5d80163" class="cell" data-execution_count="3">
+<div id="e0df54ad" class="cell" data-execution_count="3">
 <div class="sourceCode cell-code" id="cb4"><pre class="sourceCode python code-with-copy"><code class="sourceCode python"><span id="cb4-1"><a href="#cb4-1" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> daggerml.contrib.adapters <span class="im">import</span> list_adapters</span>
 <span id="cb4-2"><a href="#cb4-2" aria-hidden="true" tabindex="-1"></a></span>
 <span id="cb4-3"><a href="#cb4-3" aria-hidden="true" tabindex="-1"></a></span>

{daggerml-0.1.4 → daggerml-0.1.5}/src/daggerml/dashboard/static/docs/fragments/extend/codecs.html

@@ -24,7 +24,7 @@
 <h2 class="anchored" data-anchor-id="contract-and-normalization">Contract and normalization</h2>
 <p>The public <code>LiteralCodec</code> contract has <code>can_encode(value)</code> and <code>encode(value, dag)</code>. Selection stops at the first matching codec. <code>encode()</code> must return a value that is not an instance of its input type so normalization makes progress; otherwise DaggerML raises <code>CodecError</code>. Codec exceptions are wrapped as <code>CodecError</code>, except <code>DmlRepoError</code>, which remains meaningful to callers.</p>
 <p><code>apply_codecs()</code> repeats codec application until it reaches a DaggerML scalar, collection, or <code>Ref</code>. It then recursively normalizes list and dict values, URI text, and a runnable’s target, nested runnable, and kwargs. A codec may therefore return a <code>Uri</code>, <code>Runnable</code>, collection, reference, or another encodable intermediate value, but the chain must terminate.</p>
-<div id="ef29ad81" class="cell" data-execution_count="2">
+<div id="73a8a82c" class="cell" data-execution_count="2">
 <div class="sourceCode cell-code" id="cb1"><pre class="sourceCode python code-with-copy"><code class="sourceCode python"><span id="cb1-1"><a href="#cb1-1" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> decimal <span class="im">import</span> Decimal</span>
 <span id="cb1-2"><a href="#cb1-2" aria-hidden="true" tabindex="-1"></a></span>
 <span id="cb1-3"><a href="#cb1-3" aria-hidden="true" tabindex="-1"></a></span>
@@ -61,7 +61,7 @@
 <div class="sourceCode" id="cb3"><pre class="sourceCode toml code-with-copy"><code class="sourceCode toml"><span id="cb3-1"><a href="#cb3-1" aria-hidden="true" tabindex="-1"></a><span class="kw">[project.entry-points."</span><span class="dt">daggerml.codecs"</span><span class="kw">]</span></span>
 <span id="cb3-2"><a href="#cb3-2" aria-hidden="true" tabindex="-1"></a><span class="dt">my_package</span> <span class="op">=</span> <span class="st">"my_package.codecs:literal_codecs"</span></span></code><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></pre></div>
 <p>Install that distribution wherever values are authored and normalized. Use the public diagnostics helper to inspect discovered codecs and loading errors rather than relying on registry internals.</p>
-<div id="86070c95" class="cell" data-execution_count="3">
+<div id="dca738e3" class="cell" data-execution_count="3">
 <div class="sourceCode cell-code" id="cb4"><pre class="sourceCode python code-with-copy"><code class="sourceCode python"><span id="cb4-1"><a href="#cb4-1" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> daggerml.contrib.status <span class="im">import</span> status</span>
 <span id="cb4-2"><a href="#cb4-2" aria-hidden="true" tabindex="-1"></a></span>
 <span id="cb4-3"><a href="#cb4-3" aria-hidden="true" tabindex="-1"></a></span>

{daggerml-0.1.4 → daggerml-0.1.5}/src/daggerml/dashboard/static/docs/fragments/extend/executors.html

@@ -28,7 +28,7 @@
 <!-- docs:pseudocode: This metadata belongs in an installable executor distribution. -->
 <div class="sourceCode" id="cb1"><pre class="sourceCode toml code-with-copy"><code class="sourceCode toml"><span id="cb1-1"><a href="#cb1-1" aria-hidden="true" tabindex="-1"></a><span class="kw">[project.entry-points."</span><span class="dt">daggerml.contrib.executors"</span><span class="kw">]</span></span>
 <span id="cb1-2"><a href="#cb1-2" aria-hidden="true" tabindex="-1"></a><span class="dt">example_backend</span> <span class="op">=</span> <span class="st">"my_package.executor:ExampleExecutor"</span></span></code><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></pre></div>
-<div id="b6eeb78d" class="cell" data-execution_count="2">
+<div id="00916f40" class="cell" data-execution_count="2">
 <div class="sourceCode cell-code" id="cb2"><pre class="sourceCode python code-with-copy"><code class="sourceCode python"><span id="cb2-1"><a href="#cb2-1" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> daggerml.contrib.status <span class="im">import</span> status</span>
 <span id="cb2-2"><a href="#cb2-2" aria-hidden="true" tabindex="-1"></a></span>
 <span id="cb2-3"><a href="#cb2-3" aria-hidden="true" tabindex="-1"></a></span>
@@ -39,7 +39,7 @@
 <section id="dispatch-and-lifecycle" class="level2">
 <h2 class="anchored" data-anchor-id="dispatch-and-lifecycle">Dispatch and lifecycle</h2>
 <p><code>ExecutorBase</code> creates a fresh instance for every <code>handle()</code> call. <code>handle()</code> accepts only invoke, cleanup, and cancel, validates the adapter request and response schemas, and dispatches invoke without <code>adapter_state</code> to <code>start</code> or invoke with saved object state to <code>poll</code>. Cleanup calls <code>cleanup</code>; cancel calls <code>cancel</code>, regardless of state. Repeated <code>operation="invoke"</code> performs polling; there is no wire <code>poll</code> operation.</p>
-<div id="95677530" class="cell" data-execution_count="3">
+<div id="03855cda" class="cell" data-execution_count="3">
 <div class="sourceCode cell-code" id="cb3"><pre class="sourceCode python code-with-copy"><code class="sourceCode python"><span id="cb3-1"><a href="#cb3-1" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> daggerml <span class="im">import</span> Runnable, Uri</span>
 <span id="cb3-2"><a href="#cb3-2" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> daggerml.contrib.executors <span class="im">import</span> ExecutorBase</span>
 <span id="cb3-3"><a href="#cb3-3" aria-hidden="true" tabindex="-1"></a></span>

{daggerml-0.1.4 → daggerml-0.1.5}/src/daggerml/dashboard/static/docs/fragments/start-here/dagclasses.html

@@ -23,13 +23,13 @@
 <p>Every Python block on this page runs in order during the docs build.</p>
 <section id="start-with-constructor-values-and-an-entrypoint" class="level2">
 <h2 class="anchored" data-anchor-id="start-with-constructor-values-and-an-entrypoint">Start with constructor values and an entrypoint</h2>
-<div id="48cc53ed" class="cell" data-execution_count="2">
+<div id="07898877" class="cell" data-execution_count="2">
 <div class="sourceCode cell-code" id="cb1"><pre class="sourceCode python code-with-copy"><code class="sourceCode python"><span id="cb1-1"><a href="#cb1-1" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> daggerml <span class="im">as</span> dml</span>
 <span id="cb1-2"><a href="#cb1-2" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> daggerml.api <span class="im">import</span> DmlRepoError</span>
 <span id="cb1-3"><a href="#cb1-3" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> daggerml.contrib <span class="im">import</span> api</span></code><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></pre></div>
 </div>
 <p>Decorating a class with <code>@api.dagclass</code> also makes it a dataclass. Annotated fields become constructor arguments. Inside a method, their values are nodes, so read them with <code>.value()</code> when ordinary Python needs the stored value.</p>
-<div id="2a93c417" class="cell" data-execution_count="3">
+<div id="49cee468" class="cell" data-execution_count="3">
 <div class="sourceCode cell-code" id="cb2"><pre class="sourceCode python code-with-copy"><code class="sourceCode python"><span id="cb2-1"><a href="#cb2-1" aria-hidden="true" tabindex="-1"></a><span class="at">@api.dagclass</span></span>
 <span id="cb2-2"><a href="#cb2-2" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> ScaledTotal:</span>
 <span id="cb2-3"><a href="#cb2-3" aria-hidden="true" tabindex="-1"></a>    scale: <span class="bu">int</span></span>
@@ -57,7 +57,7 @@
 <section id="compose-methods-and-name-intermediate-nodes" class="level2">
 <h2 class="anchored" data-anchor-id="compose-methods-and-name-intermediate-nodes">Compose methods and name intermediate nodes</h2>
 <p>Direct <code>self.member</code> reads tell the compiler which members a method needs. That lets <code>main</code> call <code>clean</code>, then <code>total</code>, without manually passing either funk through the constructor.</p>
-<div id="047369b4" class="cell" data-execution_count="4">
+<div id="78d3866c" class="cell" data-execution_count="4">
 <div class="sourceCode cell-code" id="cb4"><pre class="sourceCode python code-with-copy"><code class="sourceCode python"><span id="cb4-1"><a href="#cb4-1" aria-hidden="true" tabindex="-1"></a><span class="at">@api.dagclass</span></span>
 <span id="cb4-2"><a href="#cb4-2" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> NumberPipeline:</span>
 <span id="cb4-3"><a href="#cb4-3" aria-hidden="true" tabindex="-1"></a>    scale: <span class="bu">int</span></span>
@@ -90,7 +90,7 @@
 <section id="reuse-a-compiled-entrypoint-in-another-dag" class="level2">
 <h2 class="anchored" data-anchor-id="reuse-a-compiled-entrypoint-in-another-dag">Reuse a compiled entrypoint in another DAG</h2>
 <p>A compiled instance holds runnable methods. Stage its entrypoint and call it like any other funk.</p>
-<div id="23026c7f" class="cell" data-execution_count="5">
+<div id="5c4f8fcf" class="cell" data-execution_count="5">
 <div class="sourceCode cell-code" id="cb6"><pre class="sourceCode python code-with-copy"><code class="sourceCode python"><span id="cb6-1"><a href="#cb6-1" aria-hidden="true" tabindex="-1"></a>compiled_pipeline <span class="op">=</span> NumberPipeline(scale<span class="op">=</span><span class="dv">3</span>)</span>
 <span id="cb6-2"><a href="#cb6-2" aria-hidden="true" tabindex="-1"></a></span>
 <span id="cb6-3"><a href="#cb6-3" aria-hidden="true" tabindex="-1"></a>dag <span class="op">=</span> dml.new(<span class="st">"reuse-dagclass"</span>, message<span class="op">=</span><span class="st">"reuse a compiled dagclass"</span>)</span>
@@ -109,7 +109,7 @@
 <section id="nest-dagclasses-and-use-comprehensions" class="level2">
 <h2 class="anchored" data-anchor-id="nest-dagclasses-and-use-comprehensions">Nest dagclasses and use comprehensions</h2>
 <p>A dagclass can be a member of another dagclass. Dependency discovery also sees direct member reads inside comprehensions.</p>
-<div id="e591950c" class="cell" data-execution_count="6">
+<div id="0be0fbc0" class="cell" data-execution_count="6">
 <div class="sourceCode cell-code" id="cb8"><pre class="sourceCode python code-with-copy"><code class="sourceCode python"><span id="cb8-1"><a href="#cb8-1" aria-hidden="true" tabindex="-1"></a><span class="at">@api.dagclass</span></span>
 <span id="cb8-2"><a href="#cb8-2" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> MultiPipeline:</span>
 <span id="cb8-3"><a href="#cb8-3" aria-hidden="true" tabindex="-1"></a>    pipeline <span class="op">=</span> NumberPipeline(scale<span class="op">=</span><span class="dv">1</span>)</span>
@@ -137,7 +137,7 @@
 <section id="choose-a-different-entrypoint" class="level2">
 <h2 class="anchored" data-anchor-id="choose-a-different-entrypoint">Choose a different entrypoint</h2>
 <p>Use <code>entrypoint=</code> when <code>main</code> is not the clearest public name.</p>
-<div id="3713e304" class="cell" data-execution_count="7">
+<div id="8a57d954" class="cell" data-execution_count="7">
 <div class="sourceCode cell-code" id="cb10"><pre class="sourceCode python code-with-copy"><code class="sourceCode python"><span id="cb10-1"><a href="#cb10-1" aria-hidden="true" tabindex="-1"></a><span class="at">@api.dagclass</span>(entrypoint<span class="op">=</span><span class="st">"calculate"</span>)</span>
 <span id="cb10-2"><a href="#cb10-2" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> CustomEntrypoint:</span>
 <span id="cb10-3"><a href="#cb10-3" aria-hidden="true" tabindex="-1"></a>    offset: <span class="bu">int</span></span>
@@ -157,7 +157,7 @@
 <section id="import-a-committed-result-lazily" class="level2">
 <h2 class="anchored" data-anchor-id="import-a-committed-result-lazily">Import a committed result lazily</h2>
 <p><code>api.load()</code> is a delayed class member. It becomes a <code>dag.require()</code> node only when the dagclass is staged, so the new DAG records exactly which prior commit it consumed.</p>
-<div id="b66133d3" class="cell" data-execution_count="8">
+<div id="8abdeabd" class="cell" data-execution_count="8">
 <div class="sourceCode cell-code" id="cb12"><pre class="sourceCode python code-with-copy"><code class="sourceCode python"><span id="cb12-1"><a href="#cb12-1" aria-hidden="true" tabindex="-1"></a><span class="at">@api.dagclass</span></span>
 <span id="cb12-2"><a href="#cb12-2" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> PreviousResult:</span>
 <span id="cb12-3"><a href="#cb12-3" aria-hidden="true" tabindex="-1"></a>    previous <span class="op">=</span> api.load(<span class="st">"number-pipeline"</span>)</span>
@@ -177,7 +177,7 @@
 <section id="bind-an-existing-funk-into-the-class-namespace" class="level2">
 <h2 class="anchored" data-anchor-id="bind-an-existing-funk-into-the-class-namespace">Bind an existing funk into the class namespace</h2>
 <p>Class members do not have to be methods. An externally defined funk can use <code>api.ref()</code> to request configuration from whichever dagclass contains it.</p>
-<div id="f50d2a85" class="cell" data-execution_count="9">
+<div id="2c9c2745" class="cell" data-execution_count="9">
 <div class="sourceCode cell-code" id="cb14"><pre class="sourceCode python code-with-copy"><code class="sourceCode python"><span id="cb14-1"><a href="#cb14-1" aria-hidden="true" tabindex="-1"></a><span class="at">@api.funkify</span>(prepop<span class="op">=</span>{<span class="st">"offset"</span>: api.ref(<span class="st">"offset"</span>)})</span>
 <span id="cb14-2"><a href="#cb14-2" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> add_offset(dag, value):</span>
 <span id="cb14-3"><a href="#cb14-3" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> dag.offset.value() <span class="op">+</span> value.value()</span>
@@ -203,7 +203,7 @@
 <section id="decorate-a-method-for-another-executor" class="level2">
 <h2 class="anchored" data-anchor-id="decorate-a-method-for-another-executor">Decorate a method for another executor</h2>
 <p>Dagclass methods accept the same <code>@api.funkify</code> options as standalone funks. This one runs in the tiny image built on the <a href="/docs/start-here/dags">DAGs</a> page and reuses the Docker flags committed on the <a href="/docs/start-here/funks">Funks</a> page.</p>
-<div id="24635bf0" class="cell" data-execution_count="10">
+<div id="1c0a1fcc" class="cell" data-execution_count="10">
 <div class="sourceCode cell-code" id="cb16"><pre class="sourceCode python code-with-copy"><code class="sourceCode python"><span id="cb16-1"><a href="#cb16-1" aria-hidden="true" tabindex="-1"></a><span class="at">@api.dagclass</span></span>
 <span id="cb16-2"><a href="#cb16-2" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> ContainerTotal:</span>
 <span id="cb16-3"><a href="#cb16-3" aria-hidden="true" tabindex="-1"></a>    image: <span class="bu">object</span></span>
@@ -238,7 +238,7 @@
 <section id="catch-dependency-mistakes-during-compilation" class="level2">
 <h2 class="anchored" data-anchor-id="catch-dependency-mistakes-during-compilation">Catch dependency mistakes during compilation</h2>
 <p>Because direct <code>self.member</code> reads define the dependency graph, the compiler can reject missing members and cycles immediately.</p>
-<div id="10fcc3a7" class="cell" data-execution_count="11">
+<div id="5b4a1830" class="cell" data-execution_count="11">
 <div class="sourceCode cell-code" id="cb18"><pre class="sourceCode python code-with-copy"><code class="sourceCode python"><span id="cb18-1"><a href="#cb18-1" aria-hidden="true" tabindex="-1"></a><span class="at">@api.dagclass</span></span>
 <span id="cb18-2"><a href="#cb18-2" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> UnknownMember:</span>
 <span id="cb18-3"><a href="#cb18-3" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> main(<span class="va">self</span>, value):</span>
@@ -288,7 +288,7 @@ Cannot assign to reserved dagclass names: put</code></pre>
 <section id="keep-dependency-syntax-direct" class="level2">
 <h2 class="anchored" data-anchor-id="keep-dependency-syntax-direct">Keep dependency syntax direct</h2>
 <p>Dependency inference is deliberately syntactic. Any direct assignment to <code>self.output</code> makes <code>output</code> local to the invocation for the whole method, regardless of control flow. Dynamic item access is invisible to the compiler.</p>
-<div id="8bf5b1f5" class="cell" data-execution_count="12">
+<div id="2071cde7" class="cell" data-execution_count="12">
 <div class="sourceCode cell-code" id="cb20"><pre class="sourceCode python code-with-copy"><code class="sourceCode python"><span id="cb20-1"><a href="#cb20-1" aria-hidden="true" tabindex="-1"></a><span class="at">@api.dagclass</span></span>
 <span id="cb20-2"><a href="#cb20-2" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> ConditionalOutput:</span>
 <span id="cb20-3"><a href="#cb20-3" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> main(<span class="va">self</span>, value, ready):</span>

{daggerml-0.1.4 → daggerml-0.1.5}/src/daggerml/dashboard/static/docs/fragments/start-here/funks.html

@@ -24,7 +24,7 @@
 <section id="package-a-python-function" class="level2">
 <h2 class="anchored" data-anchor-id="package-a-python-function">Package a Python function</h2>
 <p>The authoring helpers live in <code>daggerml.contrib.api</code>:</p>
-<div id="bb91d981" class="cell" data-execution_count="2">
+<div id="8ab631cd" class="cell" data-execution_count="2">
 <div class="sourceCode cell-code" id="cb1"><pre class="sourceCode python code-with-copy"><code class="sourceCode python"><span id="cb1-1"><a href="#cb1-1" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> os</span>
 <span id="cb1-2"><a href="#cb1-2" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> urllib.parse <span class="im">import</span> urlparse</span>
 <span id="cb1-3"><a href="#cb1-3" aria-hidden="true" tabindex="-1"></a></span>
@@ -39,7 +39,7 @@
 <section id="make-source-dependencies-explicit" class="level2">
 <h2 class="anchored" data-anchor-id="make-source-dependencies-explicit">Make source dependencies explicit</h2>
 <p>The worker receives the funk’s source, not the imports and globals surrounding it in the authoring process. Import dependencies inside the function when possible. For a source-defined helper, use <code>extra_objs</code>; use <code>post_lines</code> for a small explicit definition that must appear in the generated worker module.</p>
-<div id="bd1fe739" class="cell" data-execution_count="3">
+<div id="d8602aee" class="cell" data-execution_count="3">
 <div class="sourceCode cell-code" id="cb2"><pre class="sourceCode python code-with-copy"><code class="sourceCode python"><span id="cb2-1"><a href="#cb2-1" aria-hidden="true" tabindex="-1"></a>SCALE <span class="op">=</span> <span class="dv">100</span></span>
 <span id="cb2-2"><a href="#cb2-2" aria-hidden="true" tabindex="-1"></a></span>
 <span id="cb2-3"><a href="#cb2-3" aria-hidden="true" tabindex="-1"></a></span>
@@ -55,7 +55,7 @@
 <section id="how-funkify-serializes" class="level3">
 <h3 class="anchored" data-anchor-id="how-funkify-serializes">How <code>funkify</code> serializes</h3>
 <p>When <code>funkify</code> decorates the function, the script executor normalizes the function and its explicit source dependencies into the Python string it will persist. Capturing source eagerly is what makes this work in a notebook. Comments are removed during normalization.</p>
-<div id="92f3b870" class="cell" data-execution_count="4">
+<div id="2018ccde" class="cell" data-execution_count="4">
 <div class="sourceCode cell-code" id="cb3"><pre class="sourceCode python code-with-copy"><code class="sourceCode python"><span id="cb3-1"><a href="#cb3-1" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(normalize.kwargs[<span class="st">"script"</span>])</span></code><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></pre></div>
 <div class="cell-output cell-output-stdout">
 <pre><code>def clamp(value):
@@ -72,7 +72,7 @@ SCALE = 100</code></pre>
 <section id="compose-funks-with-prepop" class="level2">
 <h2 class="anchored" data-anchor-id="compose-funks-with-prepop">Compose funks with <code>prepop</code></h2>
 <p>A funk can call another funk. <code>prepop</code> stages values under names in the worker DAG before the function body runs, so the outer function does not need to receive every helper as an argument.</p>
-<div id="fd000a3a" class="cell" data-execution_count="5">
+<div id="28c7b05d" class="cell" data-execution_count="5">
 <div class="sourceCode cell-code" id="cb5"><pre class="sourceCode python code-with-copy"><code class="sourceCode python"><span id="cb5-1"><a href="#cb5-1" aria-hidden="true" tabindex="-1"></a><span class="at">@api.funkify</span></span>
 <span id="cb5-2"><a href="#cb5-2" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> total(dag, values):</span>
 <span id="cb5-3"><a href="#cb5-3" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="bu">sum</span>(values.value())</span>
@@ -96,7 +96,7 @@ SCALE = 100</code></pre>
 <section id="choose-and-stack-executors" class="level2">
 <h2 class="anchored" data-anchor-id="choose-and-stack-executors">Choose and stack executors</h2>
 <p>Each <code>funkify</code> layer is one runnable. The inner <code>summarize</code> layer renders and runs Python; this outer layer runs that script runnable inside Docker.</p>
-<div id="3326975d" class="cell" data-execution_count="6">
+<div id="585f5599" class="cell" data-execution_count="6">
 <div class="sourceCode cell-code" id="cb6"><pre class="sourceCode python code-with-copy"><code class="sourceCode python"><span id="cb6-1"><a href="#cb6-1" aria-hidden="true" tabindex="-1"></a>containerized_summarize <span class="op">=</span> api.funkify(</span>
 <span id="cb6-2"><a href="#cb6-2" aria-hidden="true" tabindex="-1"></a>    summarize,</span>
 <span id="cb6-3"><a href="#cb6-3" aria-hidden="true" tabindex="-1"></a>    uri<span class="op">=</span><span class="st">"docker"</span>,</span>
@@ -110,7 +110,7 @@ SCALE = 100</code></pre>
 <section id="put-and-call-funks" class="level2">
 <h2 class="anchored" data-anchor-id="put-and-call-funks">Put and call funks</h2>
 <p><code>api.load()</code> is the delayed counterpart to <code>dml.load()</code>: when staged, it imports a committed DAG result into the current DAG. Here it imports the small image built on the previous page. The docs harness supplies portable Docker flags behind the scenes for local and CI execution.</p>
-<div id="ec8a1560" class="cell" data-execution_count="8">
+<div id="b5485a45" class="cell" data-execution_count="8">
 <div class="sourceCode cell-code" id="cb7"><pre class="sourceCode python code-with-copy"><code class="sourceCode python"><span id="cb7-1"><a href="#cb7-1" aria-hidden="true" tabindex="-1"></a>dag <span class="op">=</span> dml.new(<span class="st">"funks"</span>, message<span class="op">=</span><span class="st">"run and reuse funks"</span>)</span>
 <span id="cb7-2"><a href="#cb7-2" aria-hidden="true" tabindex="-1"></a></span>
 <span id="cb7-3"><a href="#cb7-3" aria-hidden="true" tabindex="-1"></a>image <span class="op">=</span> dag.put(api.load(<span class="st">"docs-image"</span>), name<span class="op">=</span><span class="st">"image"</span>)</span>
@@ -128,7 +128,7 @@ SCALE = 100</code></pre>
 <section id="errors-remain-inspectable" class="level2">
 <h2 class="anchored" data-anchor-id="errors-remain-inspectable">Errors remain inspectable</h2>
 <p>A failed funk call raises an error to the author while retaining its named call node and failed execution DAG. Catching it allows this authoring DAG to continue and commit other useful results.</p>
-<div id="d732d1bf" class="cell" data-execution_count="9">
+<div id="8f3ff7be" class="cell" data-execution_count="9">
 <div class="sourceCode cell-code" id="cb8"><pre class="sourceCode python code-with-copy"><code class="sourceCode python"><span id="cb8-1"><a href="#cb8-1" aria-hidden="true" tabindex="-1"></a><span class="at">@api.funkify</span></span>
 <span id="cb8-2"><a href="#cb8-2" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> divide(dag, numerator, denominator):</span>
 <span id="cb8-3"><a href="#cb8-3" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> numerator.value() <span class="op">/</span> denominator.value()</span>
@@ -136,7 +136,7 @@ SCALE = 100</code></pre>
 <span id="cb8-5"><a href="#cb8-5" aria-hidden="true" tabindex="-1"></a></span>
 <span id="cb8-6"><a href="#cb8-6" aria-hidden="true" tabindex="-1"></a>divide_node <span class="op">=</span> dag.put(divide, name<span class="op">=</span><span class="st">"divide"</span>)</span></code><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></pre></div>
 </div>
-<div id="9a9cad51" class="cell" data-execution_count="10">
+<div id="52e521a4" class="cell" data-execution_count="10">
 <div class="sourceCode cell-code" id="cb9"><pre class="sourceCode python code-with-copy"><code class="sourceCode python"><span id="cb9-1"><a href="#cb9-1" aria-hidden="true" tabindex="-1"></a><span class="cf">try</span>:</span>
 <span id="cb9-2"><a href="#cb9-2" aria-hidden="true" tabindex="-1"></a>    divide_node(<span class="dv">1</span>, <span class="dv">0</span>, name<span class="op">=</span><span class="st">"failed"</span>)</span>
 <span id="cb9-3"><a href="#cb9-3" aria-hidden="true" tabindex="-1"></a><span class="cf">except</span> dml.Error <span class="im">as</span> error:</span>
@@ -150,7 +150,7 @@ SCALE = 100</code></pre>
 <section id="commit-the-useful-results" class="level2">
 <h2 class="anchored" data-anchor-id="commit-the-useful-results">Commit the useful results</h2>
 <p>The failed call is already retained by name. We commit the successful nodes as the result of the outer DAG.</p>
-<div id="1da6e998" class="cell" data-execution_count="11">
+<div id="5d7d1d4e" class="cell" data-execution_count="11">
 <div class="sourceCode cell-code" id="cb11"><pre class="sourceCode python code-with-copy"><code class="sourceCode python"><span id="cb11-1"><a href="#cb11-1" aria-hidden="true" tabindex="-1"></a>dag.commit(</span>
 <span id="cb11-2"><a href="#cb11-2" aria-hidden="true" tabindex="-1"></a>    {</span>
 <span id="cb11-3"><a href="#cb11-3" aria-hidden="true" tabindex="-1"></a>        <span class="st">"normalized"</span>: normalized,</span>
@@ -163,14 +163,14 @@ SCALE = 100</code></pre>
 <section id="test-function-logic-without-a-runtime" class="level2">
 <h2 class="anchored" data-anchor-id="test-function-logic-without-a-runtime">Test function logic without a runtime</h2>
 <p><code>defunkify()</code> unwraps the innermost script function and supplies lightweight node-like arguments. It is useful for fast unit tests of ordinary function logic; it does not exercise an executor, remote storage, or caching.</p>
-<div id="1dd68fe1" class="cell" data-execution_count="12">
+<div id="ed56382e" class="cell" data-execution_count="12">
 <div class="sourceCode cell-code" id="cb12"><pre class="sourceCode python code-with-copy"><code class="sourceCode python"><span id="cb12-1"><a href="#cb12-1" aria-hidden="true" tabindex="-1"></a><span class="cf">assert</span> defunkify(normalize)(<span class="va">None</span>, <span class="dv">125</span>) <span class="op">==</span> <span class="dv">1</span></span></code><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></pre></div>
 </div>
 </section>
 <section id="inspect-caching-and-execution-dags" class="level2">
 <h2 class="anchored" data-anchor-id="inspect-caching-and-execution-dags">Inspect caching and execution DAGs</h2>
 <p>The runnable plus normalized DaggerML arguments form the cache identity. The two identical calls above are distinct nodes in <code>funks</code>, but both resolve to the same completed execution DAG.</p>
-<div id="9fe93bb3" class="cell" data-execution_count="13">
+<div id="7aad0bce" class="cell" data-execution_count="13">
 <div class="sourceCode cell-code" id="cb13"><pre class="sourceCode python code-with-copy"><code class="sourceCode python"><span id="cb13-1"><a href="#cb13-1" aria-hidden="true" tabindex="-1"></a>recorded <span class="op">=</span> dml.load(<span class="st">"funks"</span>)</span>
 <span id="cb13-2"><a href="#cb13-2" aria-hidden="true" tabindex="-1"></a>first_execution <span class="op">=</span> recorded[<span class="st">"first"</span>].context(root<span class="op">=</span><span class="va">False</span>)</span>
 <span id="cb13-3"><a href="#cb13-3" aria-hidden="true" tabindex="-1"></a>cached_execution <span class="op">=</span> recorded[<span class="st">"cached"</span>].context(root<span class="op">=</span><span class="va">False</span>)</span>

{daggerml-0.1.4 → daggerml-0.1.5}/src/daggerml/dashboard/static/docs/fragments/use/execution.html

@@ -23,7 +23,7 @@
 <section id="run-self-contained-script-work" class="level2">
 <h2 class="anchored" data-anchor-id="run-self-contained-script-work">Run self-contained script work</h2>
 <p>A script worker receives persisted source, not the authoring interpreter’s imports or globals. Import dependencies inside the function, or explicitly inject source with <code>extra_objs</code> or <code>post_lines</code>.</p>
-<div id="f61758a9" class="cell" data-execution_count="2">
+<div id="7ff9dfa9" class="cell" data-execution_count="2">
 <div class="sourceCode cell-code" id="cb1"><pre class="sourceCode python code-with-copy"><code class="sourceCode python"><span id="cb1-1"><a href="#cb1-1" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> os</span>
 <span id="cb1-2"><a href="#cb1-2" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> urllib.parse <span class="im">import</span> urlparse</span>
 <span id="cb1-3"><a href="#cb1-3" aria-hidden="true" tabindex="-1"></a></span>
@@ -57,7 +57,7 @@
 <section id="compose-docker-work" class="level2">
 <h2 class="anchored" data-anchor-id="compose-docker-work">Compose Docker work</h2>
 <p>Docker is an outer runnable wrapper around the inner script. Its image and flags are staged data, so they also participate in the execution boundary and identity.</p>
-<div id="3475e9c7" class="cell" data-execution_count="3">
+<div id="d83ca30c" class="cell" data-execution_count="3">
 <div class="sourceCode cell-code" id="cb2"><pre class="sourceCode python code-with-copy"><code class="sourceCode python"><span id="cb2-1"><a href="#cb2-1" aria-hidden="true" tabindex="-1"></a>docker_summarize <span class="op">=</span> api.funkify(</span>
 <span id="cb2-2"><a href="#cb2-2" aria-hidden="true" tabindex="-1"></a>    summarize_artifact,</span>
 <span id="cb2-3"><a href="#cb2-3" aria-hidden="true" tabindex="-1"></a>    uri<span class="op">=</span><span class="st">"docker"</span>,</span>

{daggerml-0.1.4 → daggerml-0.1.5}/src/daggerml/dashboard/static/docs/fragments/use/runtimes.html

@@ -37,16 +37,16 @@
 <div class="cell-output cell-output-stdout">
 <pre><code>{
   "author": "runner@runnervmtr4k5",
-  "created": "2026-09-25T15:34:19.280900+00:00",
+  "created": "2026-10-01T03:30:31.955215+00:00",
   "dag": "dag:fddaecd49ea1cbf67fd367bdb95372f57c42aaed9439a5b009d28c598331470e",
   "frozen_message": "Review staged input",
-  "id": "frozenindex:01a0d93401457fb6ada9b22214fd12af",
+  "id": "frozenindex:01a0f58383457da583e956bff43f2b0b",
   "message": "",
   "parents": [
-    "commit:bef1a8005251fb87c5cdca2c69d3449f4c2d0f37ed626c848888943d5056ad3b"
+    "commit:2c9c10cd940f3f60e9c60dd9d8e22fdf3efcd628c1aaadff9d705ccaa4fcc843"
   ],
   "state": "frozen",
-  "tree": "tree:883256f41d7280460ecd42370eebf8946abf42ec27e772677029a54d3096e8b5"
+  "tree": "tree:28a527e37db3d08bc70414f1609f040d79c42f5e6f44832c2801f7635f6383ae"
 }
 true
 true</code></pre>
@@ -70,7 +70,7 @@ true</code></pre>
 <span id="cb3-10"><a href="#cb3-10" aria-hidden="true" tabindex="-1"></a><span class="ex">dml</span> cache invalidate <span class="st">"</span><span class="va">$execution_ref</span><span class="st">"</span></span></code><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></pre></div>
 <div class="cell-output cell-output-stdout">
 <pre><code>true
-{"invalidations":[{"cache_key":"fe612bf7a9a547ba609acb7d75c197744abb456e6b0d46725e8d8c4aeec2ad8e","execution_id":"01a0d933c26e7ba7b0a7735f8456be7d","requested_at":1790350464,"requested_by":"runner@runnervmtr4k5"}],"total_time":0.13678956031799316}</code></pre>
+{"invalidations":[{"cache_key":"fe612bf7a9a547ba609acb7d75c197744abb456e6b0d46725e8d8c4aeec2ad8e","execution_id":"01a0f5833fa477c18aa31882962a062d","requested_at":1790825437,"requested_by":"runner@runnervmtr4k5"}],"total_time":0.1427314281463623}</code></pre>
 </div>
 </div>
 <p>Rerunning the same stored runnable and argument produces a new execution for the same normalized cache key:</p>

{daggerml-0.1.4 → daggerml-0.1.5}/src/daggerml/dashboard/static/docs/fragments/use/sharing.html

@@ -35,12 +35,12 @@
 <pre><code>true
 true
 {
-  "commit": "commit:547a03f91c35a9cfc8091153e9d78bd0c179f5fba073e872890fba1f2e349ce5",
+  "commit": "commit:5d3f6e67b20331021b2488d99314f424b36144e07824b828669c14cb9adb685d",
   "name": "course-v1"
 }
 true
 {
-  "commit": "commit:547a03f91c35a9cfc8091153e9d78bd0c179f5fba073e872890fba1f2e349ce5",
+  "commit": "commit:5d3f6e67b20331021b2488d99314f424b36144e07824b828669c14cb9adb685d",
   "name": "main"
 }</code></pre>
 </div>
@@ -82,14 +82,14 @@ true
 <span id="cb3-29"><a href="#cb3-29" aria-hidden="true" tabindex="-1"></a><span class="kw">)</span></span></code><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></pre></div>
 <div class="cell-output cell-output-stdout">
 <pre><code>{"ahead":null,"behind":null,"branch":"main","branches":[],"commit":null,"mode":"attached","num_indexes":0,"upstream":null}
-commit:14eb937646e6097954ab97a2d9a4d677183513d2950a6cb7ee90af449438f049
-"dag:7d550507343c610d7cef5592abeb09f3925ec114e171562bc776fde78f0ed17e"
+commit:bdfa5c62e73555fdb577607efabcfece0bd106769d727075eb1fef640dc1b0a4
+"dag:4fa042bdd06e6011a85d2288d088b3eef0d6a9ee614fb77d62603ed1885912da"
 {"ahead":null,"behind":null,"branch":"main","branches":[],"commit":null,"mode":"attached","num_indexes":0,"upstream":null}
 tutorial
-commit:a8770e8f7767a0320630389de807b50a2eabafdd615b75a29f103c8d3fb7ba47
+commit:37fc5ca7e36981aa111999fd62d27d2a2b9d9f8084afba89d8b7129185ac3d97
 "dag:bd8e5e5b71213031bbd1f7017bbc10f8fe90706d29ccd2a1a5f4dc8cd76d65ce"
-{"ahead":0,"behind":0,"branch":"main","branches":["main"],"commit":"commit:547a03f91c35a9cfc8091153e9d78bd0c179f5fba073e872890fba1f2e349ce5","mode":"attached","num_indexes":0,"upstream":"main"}
-"dag:7d550507343c610d7cef5592abeb09f3925ec114e171562bc776fde78f0ed17e"</code></pre>
+{"ahead":0,"behind":0,"branch":"main","branches":["main"],"commit":"commit:5d3f6e67b20331021b2488d99314f424b36144e07824b828669c14cb9adb685d","mode":"attached","num_indexes":0,"upstream":"main"}
+"dag:4fa042bdd06e6011a85d2288d088b3eef0d6a9ee614fb77d62603ed1885912da"</code></pre>
 </div>
 </div>
 <p><code>dml.load("name")</code> reads a committed DAG and <code>dag.require("name")</code> imports one into new work. A shallow clone contains the selected commit’s complete tree, DAGs, nodes, data, and imports; only older parents may be unavailable. Use a larger <code>fetch --depth N</code> to deepen history or <code>fetch --unshallow</code> to retrieve it all. Dependencies are import-only endpoints, not the project’s cache or execution remote. A normal push can advance an observed shallow branch; creating a remote branch or forcing publication requires complete ancestry.</p>

{daggerml-0.1.4 → daggerml-0.1.5}/tests/_core/contracts/test_runtime_cancel_gates.py

@@ -95,13 +95,24 @@ def test_put_literal_rejects_non_running_execution_states(tmp_path, lifecycle: s
         ops.put_literal(index, 42, db=db)
 
 
-def test_execution_aware_create_activates_pending_execution(tmp_path) -> None:
+def test_execution_aware_create_activates_pending_execution(tmp_path, monkeypatch) -> None:
     db = make_db(tmp_path)
     state = NoopExecutionState()
     ops = local_index_ops(state)
     argv_ref = _put_argv_node(db)
     _put_reserved_execution(state, "exec", lifecycle="pending", argv_ref=argv_ref)
-    ops._remote.materialized_ref = argv_ref
+    unlocks = []
+    monkeypatch.setattr(state, "unlock", lambda execution_id, owner: unlocks.append((execution_id, owner)) or True)
+
+    def materialize(ref, db):
+        assert ref == argv_ref
+        assert state.read_execution_record("exec")["state"]["lifecycle"] == "running"
+        assert unlocks == [("exec", "owner")]
+        with pytest.raises(BadExecutionStatusError):
+            state.activate("exec", db)
+        return argv_ref
+
+    monkeypatch.setattr(ops._remote, "materialize_ref", materialize)
 
     index = ops.create("user", commit=db.init(), cache_key="ck1", execution_id="exec", db=db)
 
@@ -109,6 +120,32 @@ def test_execution_aware_create_activates_pending_execution(tmp_path) -> None:
     assert state.read_execution_record("exec")["state"]["lifecycle"] == "running"
 
 
+@pytest.mark.parametrize("lifecycle", ["cancel-pending", "canceled"])
+def test_execution_aware_create_blocks_local_index_after_cancellation_during_pull(
+    tmp_path, monkeypatch, lifecycle: str
+) -> None:
+    db = make_db(tmp_path)
+    state = NoopExecutionState()
+    ops = local_index_ops(state)
+    argv_ref = _put_argv_node(db)
+    commit = db.init()
+    _put_reserved_execution(state, "exec", lifecycle="pending", argv_ref=argv_ref)
+
+    def materialize(ref, db):
+        record = state.read_execution_record("exec")
+        record["state"]["lifecycle"] = lifecycle
+        state.update_execution_record(record)
+        return argv_ref
+
+    monkeypatch.setattr(ops._remote, "materialize_ref", materialize)
+    with pytest.raises(CanceledExecutionError):
+        ops.create("user", commit=commit, cache_key="ck1", execution_id="exec", db=db)
+
+    with db.tx(readonly=True) as txn:
+        with pytest.raises(DmlRepoError, match="Object not found"):
+            txn.get(Ref("index:exec"))
+
+
 @pytest.mark.parametrize("lifecycle", ["running", "succeeded", "failed"])
 def test_execution_aware_create_rejects_non_pending_activation_states(tmp_path, lifecycle: str) -> None:
     db = make_db(tmp_path)
@@ -179,3 +216,4 @@ def test_execution_aware_create_unlocks_activation_owner_after_setup_failure(
         ops.create("user", commit=commit, cache_key="ck1", execution_id="exec", db=db)
 
     assert unlocks == [("exec", "owner")]
+    assert state.read_execution_record("exec")["state"]["lifecycle"] == "running"

{daggerml-0.1.4 → daggerml-0.1.5}/tests/_core/helpers.py

@@ -160,6 +160,7 @@ class NoopExecutionState:
         record = self.read_execution_record(execution_id)
         record["state"]["lifecycle"] = "running"
         self.update_execution_record(record)
+        self.unlock(execution_id, owner)
 
     def unlock(self, execution_id, owner):
         return True