@smthrs/engine-store 0.0.0-stage → 1.0.0-rc.4

package/dist/cjs/PlanScheduler.js

@@ -0,0 +1,1090 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var PlanScheduler_exports = {};
+__export(PlanScheduler_exports, {
+  NodeExecutor: () => NodeExecutor,
+  PlanScheduler: () => PlanScheduler,
+  SchedulerError: () => SchedulerError,
+  layer: () => layer,
+  layerExecutor: () => layerExecutor,
+  make: () => make,
+  recertify: () => recertify
+});
+module.exports = __toCommonJS(PlanScheduler_exports);
+var import_crypto = require("@smthrs/crypto");
+var import_engine = require("@smthrs/engine");
+var import_journal = require("@smthrs/journal");
+var import_plan = require("@smthrs/plan");
+var import_plan_store = require("@smthrs/plan-store");
+var FileSet = __toESM(require("@smthrs/plan/FileSet"), 1);
+var import_run_store = require("@smthrs/run-store");
+var Cause = __toESM(require("effect/Cause"), 1);
+var Clock = __toESM(require("effect/Clock"), 1);
+var Context = __toESM(require("effect/Context"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Exit = __toESM(require("effect/Exit"), 1);
+var FileSystem = __toESM(require("effect/FileSystem"), 1);
+var Layer = __toESM(require("effect/Layer"), 1);
+var Metric = __toESM(require("effect/Metric"), 1);
+var Option = __toESM(require("effect/Option"), 1);
+var Queue = __toESM(require("effect/Queue"), 1);
+var Ref = __toESM(require("effect/Ref"), 1);
+var Result = __toESM(require("effect/Result"), 1);
+var Schema = __toESM(require("effect/Schema"), 1);
+var EngineStoreMetrics = __toESM(require("./EngineStoreMetrics.js"), 1);
+var ActionPersistence = __toESM(require("./internal/ActionPersistence.js"), 1);
+var AttemptAdmission = __toESM(require("./internal/AttemptAdmission.js"), 1);
+var CacheAgeVerdicts = __toESM(require("./internal/CacheAgeVerdicts.js"), 1);
+var FileEnumeration = __toESM(require("./internal/FileEnumeration.js"), 1);
+var JournalRecords = __toESM(require("./internal/JournalRecords.js"), 1);
+var import_Ordering = require("./internal/Ordering.js");
+var PlanInputs = __toESM(require("./internal/PlanInputs.js"), 1);
+var PlanMerges = __toESM(require("./internal/PlanMerges.js"), 1);
+var RuntimeGraph = __toESM(require("./internal/RuntimeGraph.js"), 1);
+var PlanInputStore = __toESM(require("./PlanInputStore.js"), 1);
+var PlanMergeStore = __toESM(require("./PlanMergeStore.js"), 1);
+var Reconciliation = __toESM(require("./Reconciliation.js"), 1);
+var ReplayOnly = __toESM(require("./ReplayOnly.js"), 1);
+var Selection = __toESM(require("./Selection.js"), 1);
+var StepBoundary = __toESM(require("./StepBoundary.js"), 1);
+var WorkspaceSandbox = __toESM(require("./WorkspaceSandbox.js"), 1);
+class NodeExecutor extends Context.Service()("@smthrs/engine-store/NodeExecutor") {
+}
+const layerExecutor = (executor) => Layer.succeed(NodeExecutor, executor);
+class SchedulerError extends Schema.TaggedError()("@smthrs/engine-store/SchedulerError", {
+  code: Schema.Literals([
+    "invalid_plan",
+    "boundary_unavailable",
+    "key_uncomputable",
+    "elaboration_failed",
+    "store_failed"
+  ]),
+  message: Schema.String,
+  cause: Schema.optional(Schema.Unknown),
+  /** Failures while settling siblings after the primary scheduler failure. */
+  cleanupErrors: Schema.optional(Schema.Array(Schema.Unknown))
+}) {
+}
+class PlanScheduler extends Context.Service()("@smthrs/engine-store/PlanScheduler") {
+}
+const actionOf = (node) => {
+  const body = node.material.body;
+  if (typeof body !== "object" || body === null) return void 0;
+  const fields = body;
+  const named = typeof fields["action"] === "string" ? fields["action"] : fields["flow"];
+  return typeof named === "string" && named !== "" ? named : void 0;
+};
+const nodeSummary = (node) => {
+  const action = actionOf(node);
+  return {
+    id: node.id,
+    kind: node.kind,
+    dependsOn: node.dependsOn,
+    tier: node.material.kind,
+    key: node.key,
+    generation: node.generation,
+    ...action === void 0 ? {} : { action }
+  };
+};
+const unmeasured = "unmeasured";
+const isConflict = (cause) => cause.reasons.some((reason) => Cause.isFailReason(reason) && WorkspaceSandbox.isMaterializationConflict(reason.error));
+const DeviationPayload = Schema.Struct({
+  stepKeyDigest: Schema.NonEmptyString,
+  attempt: Schema.Int,
+  paths: Schema.Array(Schema.String),
+  diffIdentity: Schema.String
+});
+const decodeDeviation = Schema.decodeUnknownOption(DeviationPayload);
+const digestOf = Schema.decodeUnknownEffect(import_crypto.Sha256);
+const storeFailure = (message) => (cause) => new SchedulerError({ code: "store_failed", message, cause });
+const nonNegativeSafeInteger = (name, value) => {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new RangeError(`${name} must be a non-negative safe integer`);
+  }
+  return value;
+};
+const make = (options) => {
+  const admission = AttemptAdmission.makeUnsafe();
+  const cacheAgeVerdict = CacheAgeVerdicts.make(options.runId);
+  const rebaseLimit = nonNegativeSafeInteger("rebaseLimit", options.rebaseLimit ?? 3);
+  const scheduling = import_plan.Scheduling.make(options.concurrency);
+  const capturedEnvironment = Result.try(
+    () => Schema.decodeUnknownSync(Schema.UndefinedOr(import_plan.StepKey.EnvironmentIdentity))(
+      options.environment,
+      { onExcessProperty: "error" }
+    )
+  );
+  const lineageId = import_engine.FlowEngine.Lineage.root(options.runId);
+  const source = (suffix) => ({ runId: options.runId, sourceId: `${options.sourceId}/${suffix}`, lineageId });
+  const emit = (record2) => Effect.flatMap(import_journal.Journal.Journal, (journal) => journal.emitDurable(record2, options.owner)).pipe(
+    Effect.catch(
+      (error) => error.code === "fence_lost" ? Effect.interrupt : Effect.fail(storeFailure("the scheduler could not journal a record")(error))
+    )
+  );
+  const atomically = (message, effect) => Effect.flatMap(import_journal.Journal.Journal, (journal) => journal.transact(effect)).pipe(
+    Effect.mapError((error) => error instanceof SchedulerError ? error : storeFailure(message)(error))
+  );
+  const verifyPlan = (candidate) => import_plan.Plan.verify(candidate).pipe(
+    Effect.mapError(
+      (cause) => new SchedulerError({ code: "invalid_plan", message: "the scheduler requires a verified plan", cause })
+    )
+  );
+  const record = Effect.fn("PlanScheduler.record")(
+    (candidate) => Effect.gen(function* () {
+      const plan = yield* verifyPlan(candidate);
+      yield* Effect.annotateCurrentSpan({
+        runId: options.runId,
+        planId: plan.planId,
+        digest: plan.digest,
+        generation: plan.generation
+      });
+      const store = yield* import_plan_store.PlanStore.PlanStore;
+      const now = yield* Clock.currentTimeMillis.pipe(Effect.map(Math.floor));
+      const outcome = yield* atomically(
+        "could not atomically record the plan",
+        Effect.gen(function* () {
+          const recorded = yield* store.record(plan, now).pipe(
+            Effect.mapError(storeFailure("could not record the plan"))
+          );
+          yield* emit(JournalRecords.planRecorded(source(`plan/${plan.planId}`), {
+            planId: plan.planId,
+            flow: plan.flow,
+            digest: plan.digest,
+            baseDigest: plan.baseDigest,
+            generation: plan.generation,
+            nodes: plan.nodes.length,
+            outcome: recorded._tag,
+            // The graph itself, beside the count it has always carried. A
+            // reader that only knows how MANY nodes ran cannot show which
+            // ones, and the count stays because the CLI's run progress reads
+            // it as a number.
+            graph: { nodes: plan.nodes.map(nodeSummary) }
+          }));
+          return recorded;
+        })
+      );
+      yield* Effect.annotateCurrentSpan({ outcome: outcome._tag });
+      return outcome;
+    })
+  );
+  const append = Effect.fn("PlanScheduler.append")(
+    (candidate) => Effect.gen(function* () {
+      const plan = yield* verifyPlan(candidate);
+      yield* Effect.annotateCurrentSpan({
+        runId: options.runId,
+        planId: plan.planId,
+        digest: plan.digest,
+        generation: plan.generation
+      });
+      const store = yield* import_plan_store.PlanStore.PlanStore;
+      yield* atomically(
+        "could not atomically append the subgraph",
+        Effect.gen(function* () {
+          yield* store.append(plan).pipe(Effect.mapError(storeFailure("could not append the subgraph")));
+          yield* emit(JournalRecords.subgraphAppended(source(`plan/${plan.planId}/${plan.generation}`), {
+            planId: plan.planId,
+            digest: plan.digest,
+            baseDigest: plan.baseDigest,
+            generation: plan.generation,
+            nodeIds: import_plan.Plan.generationNodes(plan).map((node) => node.id),
+            graph: { nodes: import_plan.Plan.generationNodes(plan).map(nodeSummary) }
+          }));
+        })
+      );
+      yield* Effect.annotateCurrentSpan({ outcome: "appended" });
+    })
+  );
+  const run = Effect.fn("PlanScheduler.run")(
+    (candidate) => Effect.gen(function* () {
+      if (Result.isFailure(capturedEnvironment)) {
+        return yield* Effect.fail(
+          new SchedulerError({
+            code: "key_uncomputable",
+            message: "the scheduler requires a valid execution environment identity"
+          })
+        );
+      }
+      const environment = capturedEnvironment.success;
+      const environmentDigest = yield* import_plan.StepKey.environmentIdentity(environment).pipe(Effect.mapError(
+        (cause) => new SchedulerError({ code: "key_uncomputable", message: "could not bind the execution environment", cause })
+      ));
+      const initial = yield* verifyPlan(candidate);
+      yield* Effect.annotateCurrentSpan({
+        runId: options.runId,
+        planId: initial.planId,
+        digest: initial.digest,
+        nodes: initial.nodes.length
+      });
+      const boundaries = yield* StepBoundary.StepBoundary;
+      const fileSystem = yield* Effect.serviceOption(FileSystem.FileSystem);
+      const executor = yield* NodeExecutor;
+      const journal = yield* import_journal.Journal.Journal;
+      const inputStore = yield* PlanInputStore.PlanInputStore;
+      const mergeStore = yield* PlanMergeStore.PlanMergeStore;
+      const mergeIdentity = {
+        runId: options.runId,
+        planId: initial.planId,
+        baseDigest: initial.baseDigest,
+        environmentDigest
+      };
+      const mergeFailure = (cause) => cause.code === "fence_lost" ? Effect.interrupt : Effect.fail(storeFailure("could not recover or persist the plan's merge decisions")(cause));
+      const recoveredMerges = yield* mergeStore.list(mergeIdentity, options.owner).pipe(Effect.catch(mergeFailure));
+      const reconciler = Option.getOrElse(
+        yield* Effect.serviceOption(Reconciliation.Reconciliation),
+        Reconciliation.makeDefault
+      );
+      const selector = Option.getOrElse(
+        yield* Effect.serviceOption(Selection.Selection),
+        Selection.makeNoop
+      );
+      const replayOnly = Option.getOrUndefined(yield* Effect.serviceOption(ReplayOnly.ReplayOnly));
+      yield* Effect.logDebug("scheduler run started", {
+        digest: initial.digest,
+        nodes: initial.nodes.length
+      });
+      let abortedForFailure = false;
+      const cleanupErrors = [];
+      let plan = yield* PlanMerges.recover(initial, recoveredMerges).pipe(Effect.catch(mergeFailure));
+      const graph = RuntimeGraph.make(plan.nodes);
+      const states = graph.states;
+      const results = /* @__PURE__ */ new Map();
+      const digestMemo = import_plan.StepKey.makeDigestMemo();
+      const verdicts = [];
+      const appended = [];
+      const digestToNode = /* @__PURE__ */ new Map();
+      const deviationSignatures = /* @__PURE__ */ new Map();
+      const writers = /* @__PURE__ */ new Map();
+      const writerEntries = [];
+      const nodesById = /* @__PURE__ */ new Map();
+      let cursor = void 0;
+      const events = yield* Queue.unbounded();
+      const stateOf = (node) => states.get(node.id);
+      const indexWriters = (nodes) => {
+        for (const node of nodes) {
+          nodesById.set(node.id, node);
+          for (const entry of [...FileSet.expand(node.effects.writes), ...node.effects.removes ?? []]) {
+            writerEntries.push({ entry, nodeId: node.id });
+            if (typeof entry === "string" && !writers.has(entry)) {
+              writers.set(entry, node.id);
+            }
+          }
+        }
+      };
+      indexWriters(plan.nodes);
+      const writerFor = (path) => writers.get(path) ?? writerEntries.find(({ entry }) => FileSet.overlaps(entry, path))?.nodeId;
+      const writerScopesBefore = (node) => {
+        const scopes = [];
+        graph.visitAncestors(node, (predecessor) => {
+          scopes.push(...FileSet.expand(predecessor.effects.writes), ...predecessor.effects.removes ?? []);
+        });
+        return scopes;
+      };
+      const expandReads = (entries, what) => Effect.gen(function* () {
+        const expanded = [];
+        for (const entry of entries) {
+          if (typeof entry === "string") {
+            expanded.push({ entry, paths: [entry] });
+            continue;
+          }
+          if (Option.isNone(fileSystem)) {
+            return yield* Effect.fail(
+              new SchedulerError({
+                code: "boundary_unavailable",
+                message: `the host cannot expand ${what} without a FileSystem`
+              })
+            );
+          }
+          const matches = yield* FileEnumeration.expandGlob(fileSystem.value, entry).pipe(
+            Effect.mapError(
+              (cause) => new SchedulerError({
+                code: "boundary_unavailable",
+                message: `the host could not expand ${what}`,
+                cause
+              })
+            )
+          );
+          expanded.push({ entry, paths: matches });
+        }
+        return expanded;
+      });
+      const prepare = (paths, what) => boundaries.prepare({
+        readSet: [...new Set(paths)].sort().map((path) => ({ path, digest: unmeasured })),
+        writeSet: [],
+        boundaryMode: "hard"
+      }).pipe(
+        Effect.mapError(
+          (cause) => new SchedulerError({
+            code: "boundary_unavailable",
+            message: `the host could not measure ${what}`,
+            cause
+          })
+        )
+      );
+      const expandProducedMatches = (glob, writerScopes, what) => Effect.gen(function* () {
+        const scopes = writerScopes.filter((entry) => FileSet.overlaps(glob, entry));
+        if (scopes.length === 0) return [];
+        if (Option.isNone(fileSystem)) {
+          return yield* Effect.fail(
+            new SchedulerError({
+              code: "boundary_unavailable",
+              message: `the host cannot expand ${what} without a FileSystem`
+            })
+          );
+        }
+        const paths = /* @__PURE__ */ new Set();
+        for (const entry of scopes) {
+          if (typeof entry === "string") {
+            const info = yield* fileSystem.value.stat(entry).pipe(
+              Effect.catchReason("PlatformError", "NotFound", () => Effect.succeed(void 0)),
+              Effect.mapError(
+                (cause) => new SchedulerError({
+                  code: "boundary_unavailable",
+                  message: `the host could not expand ${what}`,
+                  cause
+                })
+              )
+            );
+            if (info?.type === "File") paths.add(entry);
+            continue;
+          }
+          const matches = FileSet.isGlob(entry) ? yield* FileEnumeration.expandGlob(fileSystem.value, entry).pipe(
+            Effect.mapError(
+              (cause) => new SchedulerError({
+                code: "boundary_unavailable",
+                message: `the host could not expand ${what}`,
+                cause
+              })
+            )
+          ) : yield* FileEnumeration.filesUnder(fileSystem.value, entry.path).pipe(
+            Effect.mapError(
+              (cause) => new SchedulerError({
+                code: "boundary_unavailable",
+                message: `the host could not expand ${what}`,
+                cause
+              })
+            )
+          );
+          for (const path of matches) {
+            if (FileSet.matchesGlob(glob, path)) paths.add(path);
+          }
+        }
+        return [...paths].sort();
+      });
+      const pinned = /* @__PURE__ */ new Map();
+      const observedReads = /* @__PURE__ */ new Map();
+      const inputFailure = (cause) => cause.code === "fence_lost" ? Effect.interrupt : Effect.fail(storeFailure("could not recover or persist the plan's source observations")(cause));
+      const observeReads = (nodes, generation, what, commit) => Effect.gen(function* () {
+        const address = {
+          runId: options.runId,
+          planId: initial.planId,
+          baseDigest: initial.baseDigest,
+          environmentDigest,
+          generation
+        };
+        const stored = yield* inputStore.get(address, options.owner).pipe(Effect.catch(inputFailure));
+        let snapshot;
+        if (Option.isSome(stored)) {
+          snapshot = stored.value;
+        } else {
+          const unpinned = /* @__PURE__ */ new Set();
+          const observedNodes = [];
+          for (const node of nodes) {
+            const observed = [];
+            const reads = FileSet.expandReads(node.effects.reads);
+            const writerScopes = reads.length === 0 ? [] : writerScopesBefore(node);
+            for (const { entry, paths } of yield* expandReads(reads, what)) {
+              const sourcePaths = paths.filter((path) => !writerScopes.some((scope) => FileSet.overlaps(scope, path)));
+              for (const path of sourcePaths) {
+                if (!pinned.has(path)) unpinned.add(path);
+              }
+              observed.push({ entry, sourcePaths });
+            }
+            observedNodes.push({ id: node.id, key: node.key, reads: observed });
+          }
+          const pins = unpinned.size === 0 ? [] : (yield* prepare([...unpinned], what)).readSnapshot;
+          const measured = {
+            version: 1,
+            generation,
+            nodes: observedNodes,
+            pins
+          };
+          yield* PlanInputs.validate(measured, nodes, pinned, writerScopesBefore).pipe(Effect.catch(inputFailure));
+          snapshot = commit === void 0 ? yield* inputStore.record(address, measured, options.owner).pipe(Effect.catch(inputFailure)) : measured;
+        }
+        if (commit !== void 0) snapshot = yield* commit(snapshot);
+        const nextPins = yield* PlanInputs.validate(snapshot, nodes, pinned, writerScopesBefore).pipe(
+          Effect.catch(inputFailure)
+        );
+        for (const node of snapshot.nodes) observedReads.set(node.id, node.reads);
+        for (const [path, digest] of nextPins) pinned.set(path, digest);
+      });
+      for (let generation = 0; generation <= plan.generation; generation++) {
+        yield* observeReads(
+          plan.nodes.filter((node) => node.generation === generation),
+          generation,
+          "the plan's source inputs"
+        );
+      }
+      for (const { intent } of recoveredMerges) {
+        const state = stateOf(nodesById.get(intent.nodeId));
+        graph.stage(intent.nodeId, "skipped");
+        state.dispatchKey = intent.dispatchKey;
+        state.attempts = intent.attempts;
+        state.rebases = intent.rebases;
+      }
+      graph.reconcile();
+      const measure = (node) => Effect.gen(function* () {
+        const measured = /* @__PURE__ */ new Map();
+        const produced = /* @__PURE__ */ new Set();
+        const observed = observedReads.get(node.id);
+        const writerScopes = observed.length === 0 ? [] : writerScopesBefore(node);
+        for (const read of observed) {
+          if (typeof read.entry === "string") {
+            if (read.sourcePaths.length === 0) produced.add(read.entry);
+            else measured.set(read.entry, pinned.get(read.entry));
+            continue;
+          }
+          for (const path of read.sourcePaths) measured.set(path, pinned.get(path));
+          for (const path of yield* expandProducedMatches(read.entry, writerScopes, `the inputs of ${node.id}`)) {
+            produced.add(path);
+          }
+        }
+        if (produced.size > 0) {
+          const prepared = yield* prepare([...produced], `the inputs of ${node.id}`);
+          for (const entry of prepared.readSnapshot) measured.set(entry.path, entry.digest);
+        }
+        return {
+          readSet: [...measured].sort(([left], [right]) => (0, import_Ordering.compareText)(left, right)).map(([path, digest]) => ({
+            path,
+            digest
+          })),
+          writeSet: FileSet.expand(node.effects.writes),
+          // Declared removals travel with the boundary: they are what makes
+          // an absent declared output legitimate rather than a defect.
+          ...node.effects.removes === void 0 ? {} : { removes: node.effects.removes },
+          boundaryMode: node.effects.boundaryMode
+        };
+      });
+      const dispatchKeyFor = (node, boundary, settledResults) => (node.material.kind === "sealed" ? import_plan.StepKey.dispatchIdentity({
+        material: node.material,
+        results: Object.fromEntries(
+          node.material.inputs.flatMap(
+            (input) => input._tag === "Ref" ? [[input.from, settledResults.get(input.from)]] : []
+          )
+        ),
+        digestMemo,
+        environment,
+        hermetic: {
+          ...boundary,
+          readSet: StepBoundary.exactReads(boundary)
+        }
+      }) : import_plan.StepKey.ordinal({
+        runId: options.runId,
+        // Stable structural scope, never admission order. The declaration
+        // fingerprint prevents a changed plan from reusing an old attempt.
+        parentScope: JSON.stringify(["plan-node/v1", initial.planId, node.id, node.key]),
+        ordinal: 0,
+        tier: node.material.kind
+      })).pipe(
+        /* v8 ignore next 3 -- verified plans have serializable material, admission resolves every dependency, and successful upstream values already crossed durable serialization; key derivation still exposes its honest failure channel */
+        Effect.mapError(
+          (cause) => new SchedulerError({ code: "key_uncomputable", message: `could not key ${node.id}`, cause })
+        )
+      );
+      const runtimeStrategyOf = (node) => node.conflicts.some((conflict) => conflict.runtime === "stop-merge") ? "stop-merge" : node.runtime;
+      const markSettled = (node, outcome) => {
+        graph.stage(node.id, outcome);
+      };
+      const emitSettlement = (node, sourceSeq) => Effect.gen(function* () {
+        const state = stateOf(node);
+        const action = actionOf(node);
+        yield* emit(JournalRecords.nodeSettled({ ...source(`node/${node.id}/settled`), sourceSeq }, {
+          planId: plan.planId,
+          nodeId: node.id,
+          planKey: node.key,
+          dispatchKey: state.dispatchKey,
+          outcome: state.outcome,
+          attempts: state.attempts,
+          rebases: state.rebases,
+          ...action === void 0 ? {} : { action }
+        }));
+        yield* Metric.update(EngineStoreMetrics.node[state.outcome], 1);
+      });
+      const settle = (node, outcome) => {
+        markSettled(node, outcome);
+        graph.reconcile();
+        return emitSettlement(node);
+      };
+      const applyVerdict = (nodeId, verdict, trigger) => Effect.gen(function* () {
+        verdicts.push({ nodeId, verdict });
+        yield* emit(JournalRecords.nodeReconciled(source(`node/${nodeId}/reconciled/${verdicts.length}`), {
+          planId: plan.planId,
+          nodeId,
+          trigger,
+          verdict
+        }));
+        if (verdict._tag === "Fail") {
+          graph.stage(nodeId, "failed");
+          results.delete(nodeId);
+          return;
+        }
+        if (verdict._tag === "Reorder") {
+          graph.reorder(nodeId, verdict.dependsOn);
+        }
+      });
+      const dispatch = Effect.fn(
+        "PlanScheduler.dispatch"
+      )(function* (node, start) {
+        return yield* Effect.gen(function* () {
+          yield* Effect.annotateCurrentSpan({
+            runId: options.runId,
+            planId: plan.planId,
+            nodeId: node.id,
+            kind: node.kind,
+            planKey: node.key
+          });
+          let dispatchKey = start.dispatchKey;
+          let attempts = start.attempts;
+          let rebases = start.rebases;
+          while (true) {
+            const boundary = yield* measure(node);
+            const measuredKey = yield* dispatchKeyFor(node, boundary, start.results);
+            if (dispatchKey !== "" && dispatchKey !== measuredKey) {
+              yield* emit(JournalRecords.nodeInvalidated(source(`node/${node.id}/${attempts}/invalidated`), {
+                planId: plan.planId,
+                nodeId: node.id,
+                planKey: node.key,
+                from: dispatchKey,
+                to: measuredKey,
+                reason: "measured-inputs-changed"
+              }));
+            }
+            dispatchKey = measuredKey;
+            attempts = attempts + 1;
+            yield* Effect.annotateCurrentSpan({ dispatchKey, attempt: attempts });
+            const action = actionOf(node);
+            yield* emit(JournalRecords.nodeScheduled(source(`node/${node.id}/${attempts}`), {
+              planId: plan.planId,
+              nodeId: node.id,
+              kind: node.kind,
+              planKey: node.key,
+              dispatchKey,
+              attempt: attempts,
+              priority: node.priority,
+              waited: start.waited,
+              ...action === void 0 ? {} : { action }
+            }));
+            const dispatchDigest = yield* Effect.orDie(digestOf(dispatchKey));
+            yield* Queue.offer(events, { _tag: "AttemptKeyed", nodeId: node.id, digest: dispatchDigest });
+            const ran = yield* Ref.make(false);
+            const exit = yield* ActionPersistence.make({
+              runId: options.runId,
+              owner: options.owner,
+              admission,
+              cacheAgeVerdict,
+              replayOnly,
+              sourceId: `${options.sourceId}/node/${node.id}`,
+              execute: () => Ref.set(ran, true).pipe(
+                Effect.andThen(executor.execute({ node, attempt: attempts, boundary, inputs: start.inputs }))
+              )
+            })({
+              action: {},
+              attempt: attempts,
+              key: dispatchKey,
+              tier: node.material.kind,
+              nondeterministic: node.material.nondeterministic,
+              metadata: boundary
+            }).pipe(
+              Effect.onInterrupt(
+                () => abortedForFailure ? atomically(
+                  "could not settle a sibling aborted by scheduler failure",
+                  Effect.gen(function* () {
+                    const store = yield* import_run_store.AttemptStore.AttemptStore;
+                    const finishedAtMs = yield* Clock.currentTimeMillis.pipe(Effect.map(Math.floor));
+                    const identity = { runId: options.runId, stepKeyDigest: dispatchDigest, attempt: attempts };
+                    const finished = yield* store.finish({
+                      ...identity,
+                      state: "failed",
+                      finishedAtMs,
+                      error: { code: "scheduler_aborted", message: "A scheduler failure interrupted this attempt" }
+                    }, options.owner);
+                    if (finished._tag === "Finished") {
+                      yield* emit(JournalRecords.attemptFinished(source(`node/${node.id}/${attempts}/aborted`), {
+                        ...identity,
+                        state: "failed",
+                        reason: "scheduler_aborted"
+                      }));
+                    }
+                  })
+                ).pipe(Effect.catch(
+                  (cause) => Effect.sync(() => {
+                    cleanupErrors.push(cause);
+                  })
+                )) : Effect.void
+              ),
+              Effect.exit
+            );
+            if (Exit.isSuccess(exit)) {
+              return {
+                outcome: (yield* Ref.get(ran)) ? "built" : "clean",
+                result: exit.value,
+                dispatchKey,
+                attempts,
+                rebases
+              };
+            }
+            if (Cause.hasInterrupts(exit.cause)) return yield* Effect.interrupt;
+            if (!isConflict(exit.cause) || node.material.kind === "irreversible") {
+              return { outcome: "failed", dispatchKey, attempts, rebases };
+            }
+            const strategy = runtimeStrategyOf(node);
+            if (strategy === "delay-rebase" && rebases < rebaseLimit) {
+              rebases = rebases + 1;
+              continue;
+            }
+            return { outcome: "conflicted", strategy, dispatchKey, attempts, rebases };
+          }
+        }).pipe(
+          Effect.tap((result) => Effect.annotateCurrentSpan({ outcome: result.outcome }))
+        );
+      });
+      const appendMerge = (intent) => Effect.gen(function* () {
+        const node = yield* PlanMerges.validateIntent(plan, intent).pipe(Effect.catch(mergeFailure));
+        const winners = intent.peers.filter((id) => results.has(id));
+        const mergeId = PlanMerges.allocateId(plan, node.id);
+        const parentDigest = plan.digest;
+        const grown = yield* import_plan.Plan.append(plan, [PlanMerges.draft(node, mergeId, winners)]).pipe(
+          Effect.mapError(
+            (cause) => new SchedulerError({
+              code: "elaboration_failed",
+              message: `could not append the merge node for ${node.id}`,
+              cause
+            })
+          )
+        );
+        yield* observeReads(
+          import_plan.Plan.generationNodes(grown),
+          grown.generation,
+          `generation ${grown.generation}'s source inputs`,
+          (snapshot) => atomically(
+            "could not atomically commit the merge extension",
+            Effect.gen(function* () {
+              const recorded = yield* inputStore.record(
+                { ...mergeIdentity, generation: grown.generation },
+                snapshot,
+                options.owner
+              ).pipe(Effect.catch(inputFailure));
+              yield* append(grown);
+              yield* mergeStore.complete(mergeIdentity, intent.nodeId, {
+                version: 1,
+                generation: grown.generation,
+                parentDigest,
+                planDigest: grown.digest,
+                mergeId,
+                mergeKey: import_plan.Plan.generationNodes(grown)[0].key,
+                winners
+              }, options.owner).pipe(Effect.catch(mergeFailure));
+              return recorded;
+            })
+          )
+        );
+        const suffix = import_plan.Plan.generationNodes(grown);
+        graph.append(suffix);
+        plan = grown;
+        indexWriters(suffix);
+        appended.push(mergeId);
+      });
+      const pendingSettlements = [];
+      const registerAttempt = (event) => {
+        const dispatchedUnder = digestToNode.get(event.digest);
+        if (dispatchedUnder === void 0) {
+          digestToNode.set(event.digest, [event.nodeId]);
+        } else if (!dispatchedUnder.includes(event.nodeId)) {
+          digestToNode.set(event.digest, [...dispatchedUnder, event.nodeId]);
+        }
+      };
+      const drainReportedEvents = Effect.gen(function* () {
+        while (true) {
+          const next = yield* Queue.poll(events);
+          if (Option.isNone(next)) return;
+          if (next.value._tag === "AttemptKeyed") registerAttempt(next.value);
+          else pendingSettlements.push(next.value);
+        }
+      });
+      const nextSettlement = Effect.gen(function* () {
+        const pending = pendingSettlements.shift();
+        if (pending !== void 0) return pending;
+        while (true) {
+          const event = yield* Queue.take(events);
+          if (event._tag === "DispatchSettled") return event;
+          registerAttempt(event);
+        }
+      });
+      const pendingDeviations = [];
+      const drainDeviations = Effect.gen(function* () {
+        let hasMore = true;
+        while (hasMore) {
+          const page = yield* journal.entries({
+            runId: options.runId,
+            ...cursor === void 0 ? {} : { after: cursor },
+            limit: 512
+          }).pipe(Effect.mapError(storeFailure("could not read the run's journal")));
+          yield* drainReportedEvents;
+          const attributed = [];
+          for (const entry of page.entries) {
+            cursor = entry.seq;
+            if (entry.eventType !== "flows.engine.expected-set-deviation") continue;
+            const payload = decodeDeviation(entry.payload);
+            if (Option.isNone(payload)) continue;
+            const nodeIds = digestToNode.get(payload.value.stepKeyDigest);
+            if (nodeIds === void 0) continue;
+            const nodeId = nodeIds.find((candidate2) => states.get(candidate2).outcome === "built") ?? nodeIds[0];
+            const signature = JSON.stringify([
+              "expected-set-deviation/v1",
+              [...new Set(payload.value.paths)].sort(import_Ordering.compareText)
+            ]);
+            deviationSignatures.set(nodeId, signature);
+            attributed.push({ nodeId, signature, payload: payload.value });
+          }
+          pendingDeviations.push(...attributed);
+          for (let index = 0; index < pendingDeviations.length; ) {
+            const { nodeId, payload, signature } = pendingDeviations[index];
+            if (states.get(nodeId)?.status !== "settled") {
+              index = index + 1;
+              continue;
+            }
+            const alsoDeviatedBy = [...deviationSignatures.entries()].filter(([other, otherSignature]) => other !== nodeId && otherSignature === signature).map(([other]) => other);
+            const declaredBy = Object.assign(
+              /* @__PURE__ */ Object.create(null),
+              Object.fromEntries(
+                payload.paths.flatMap((path) => {
+                  const owner = writerFor(path);
+                  return owner === void 0 ? [] : [[path, owner]];
+                })
+              )
+            );
+            const verdict = yield* reconciler.onDeviation({
+              nodeId,
+              keyDigest: payload.stepKeyDigest,
+              attempt: payload.attempt,
+              paths: payload.paths,
+              diffIdentity: payload.diffIdentity,
+              declaredBy,
+              alsoDeviatedBy
+            });
+            yield* applyVerdict(nodeId, verdict, "deviation");
+            pendingDeviations.splice(index, 1);
+          }
+          hasMore = page.hasMore;
+        }
+      });
+      const deferrals = /* @__PURE__ */ new Map();
+      if (options.selection?.full === true) {
+        yield* emit(JournalRecords.selectionOverridden(source("selection/override"), {
+          planId: plan.planId,
+          mode: "full"
+        }));
+      } else {
+        const dependedOn = new Set(plan.nodes.flatMap((node) => node.dependsOn));
+        const sinks = plan.nodes.filter((node) => !dependedOn.has(node.id));
+        const present = /* @__PURE__ */ new Set([plan.flow, ...plan.nodes.map((node) => node.id)]);
+        const sinkIds = new Set(sinks.map((node) => node.id));
+        const selected = yield* selector.select({
+          changed: options.selection?.changed ?? [],
+          sinks: sinks.map((node) => ({ nodeId: node.id, planKey: node.key })),
+          present: [...present],
+          beliefs: options.selection?.beliefs ?? { pinnedAtMs: 0, edges: [] },
+          policy: options.selection?.policy ?? { deferBelow: 0 }
+        });
+        for (let index = 0; index < selected.length; index++) {
+          const { nodeId, verdict } = selected[index];
+          if (verdict._tag === "Admit") continue;
+          if (verdict._tag === "Defer" && sinkIds.has(nodeId)) {
+            deferrals.set(nodeId, { edge: verdict.edge, likelihood: verdict.likelihood });
+            continue;
+          }
+          if (verdict._tag === "Propose" && !present.has(nodeId)) {
+            yield* emit(JournalRecords.selectionProposed(source(`selection/proposed/${index}`), {
+              planId: plan.planId,
+              flow: verdict.flow,
+              edge: verdict.edge,
+              confidence: verdict.confidence
+            }));
+            continue;
+          }
+          yield* emit(JournalRecords.selectionInconsistent(source(`selection/inconsistent/${index}`), {
+            planId: plan.planId,
+            nodeId,
+            verdict: verdict._tag,
+            reason: verdict._tag === "Defer" ? "not-a-deferrable-sink" : "proposes-a-present-node"
+          }));
+        }
+      }
+      const passiveSettlements = Effect.gen(function* () {
+        while (true) {
+          const blocked = graph.blocked();
+          for (const node of blocked) yield* settle(node, "skipped");
+          if (blocked.length > 0) continue;
+          const ready = graph.ready();
+          const postponed = ready.filter((node) => deferrals.has(node.id));
+          for (const node of postponed) {
+            const debt = deferrals.get(node.id);
+            yield* emit(JournalRecords.selectionDeferred(source(`node/${node.id}/selection-deferred`), {
+              planId: plan.planId,
+              nodeId: node.id,
+              planKey: node.key,
+              edge: debt.edge,
+              likelihood: debt.likelihood
+            }));
+            yield* settle(node, "deferred");
+          }
+          if (postponed.length > 0) continue;
+          return ready;
+        }
+      });
+      const dispatchStart = (node) => {
+        const state = stateOf(node);
+        const settledResults = /* @__PURE__ */ new Map();
+        const inputs = [];
+        for (const input of node.material.inputs) {
+          if (input._tag !== "Ref") continue;
+          const value = results.get(input.from);
+          settledResults.set(input.from, value);
+          inputs.push({ from: input.from, path: input.path, value: import_plan.StepKey.project(value, input.path) });
+        }
+        return {
+          dispatchKey: state.dispatchKey,
+          attempts: state.attempts,
+          rebases: state.rebases,
+          waited: state.waited,
+          results: settledResults,
+          inputs
+        };
+      };
+      let admissions = 0;
+      yield* Effect.scoped(
+        Effect.gen(function* () {
+          let inFlightSteps = 0;
+          let inFlightAgents = 0;
+          const pendingMerges = recoveredMerges.filter((decision) => decision.completion === void 0).map((decision) => decision.intent);
+          const appendReadyMerges = Effect.gen(function* () {
+            for (let index = 0; index < pendingMerges.length; ) {
+              const pending = pendingMerges[index];
+              if (pending.peers.some((peer) => states.get(peer)?.status !== "settled")) {
+                index = index + 1;
+                continue;
+              }
+              yield* appendMerge(pending);
+              pendingMerges.splice(index, 1);
+            }
+          });
+          const advance = Effect.gen(function* () {
+            while (true) {
+              const ready = yield* passiveSettlements;
+              const before = plan.generation;
+              yield* appendReadyMerges;
+              if (plan.generation === before) return ready;
+            }
+          });
+          const admit = (ready) => Effect.gen(function* () {
+            const decision = scheduling.admit(
+              graph.candidates(ready),
+              { steps: inFlightSteps, agents: inFlightAgents }
+            );
+            const admitted = decision.admitted.map(({ node }) => node);
+            for (const { node, waited } of decision.deferred) {
+              stateOf(node).waited = waited;
+            }
+            if (admitted.length > 0) {
+              admissions = admissions + 1;
+              yield* Effect.annotateCurrentSpan({ admissions });
+              yield* Metric.update(EngineStoreMetrics.schedulerAdmissions, 1);
+              yield* Effect.logDebug("scheduler admission launched", {
+                admission: admissions,
+                ready: ready.length,
+                admitted: admitted.length,
+                agents: decision.agents,
+                inFlightSteps,
+                inFlightAgents
+              });
+            }
+            const launches = admitted.map((node) => {
+              const start = dispatchStart(node);
+              graph.start(node.id);
+              inFlightSteps = inFlightSteps + 1;
+              if (node.kind === "agent") inFlightAgents = inFlightAgents + 1;
+              return { node, start };
+            });
+            for (const { node, start } of launches) {
+              yield* dispatch(node, start).pipe(
+                Effect.trackDuration(EngineStoreMetrics.schedulerDispatchDuration),
+                Effect.exit,
+                Effect.flatMap((exit) => Queue.offer(events, { _tag: "DispatchSettled", node, exit })),
+                Effect.asVoid,
+                Effect.forkScoped({ startImmediately: true })
+              );
+            }
+          });
+          for (const { intent } of recoveredMerges) yield* emitSettlement(nodesById.get(intent.nodeId), 0);
+          yield* Effect.flatMap(advance, admit);
+          while (graph.remaining > 0) {
+            if (inFlightSteps === 0) {
+              return yield* Effect.die(
+                new Error(
+                  `PlanScheduler invariant broken: ${graph.remaining} nodes are pending and nothing is in flight`
+                )
+              );
+            }
+            const event = yield* nextSettlement;
+            if (Exit.isFailure(event.exit)) return yield* Effect.failCause(event.exit.cause);
+            const node = event.node;
+            const result = event.exit.value;
+            const state = stateOf(node);
+            inFlightSteps = inFlightSteps - 1;
+            if (node.kind === "agent") inFlightAgents = inFlightAgents - 1;
+            state.dispatchKey = result.dispatchKey;
+            state.attempts = result.attempts;
+            state.rebases = result.rebases;
+            switch (result.outcome) {
+              case "built":
+              case "clean":
+                results.set(node.id, result.result);
+                markSettled(node, result.outcome);
+                break;
+              case "failed":
+                markSettled(node, "failed");
+                break;
+              case "conflicted": {
+                if (result.strategy === "stop-merge") {
+                  const intent = yield* atomically(
+                    "could not persist the stopped-attempt decision",
+                    Effect.gen(function* () {
+                      const intent2 = yield* mergeStore.intend(mergeIdentity, {
+                        version: 1,
+                        nodeId: node.id,
+                        nodeKey: node.key,
+                        dispatchKey: state.dispatchKey,
+                        attempts: state.attempts,
+                        rebases: state.rebases,
+                        peers: node.conflicts.map((conflict) => conflict.with).filter((peer) => states.get(peer)?.status === "running" || results.has(peer))
+                      }, options.owner).pipe(Effect.catch(mergeFailure));
+                      yield* PlanMerges.validateIntent(plan, intent2).pipe(Effect.catch(mergeFailure));
+                      return intent2;
+                    })
+                  );
+                  markSettled(node, "skipped");
+                  state.dispatchKey = intent.dispatchKey;
+                  state.attempts = intent.attempts;
+                  state.rebases = intent.rebases;
+                  pendingMerges.push(intent);
+                  break;
+                }
+                const verdict = yield* reconciler.onConflict({
+                  nodeId: node.id,
+                  keyDigest: state.dispatchKey,
+                  attempt: state.attempts,
+                  rebases: state.rebases,
+                  strategy: result.strategy,
+                  conflictsWith: node.conflicts.map((conflict) => conflict.with)
+                });
+                markSettled(node, "failed");
+                yield* applyVerdict(node.id, verdict, "materialization-conflict");
+                break;
+              }
+            }
+            yield* appendReadyMerges;
+            yield* drainDeviations;
+            yield* emitSettlement(node);
+            graph.reconcile();
+            const ready = yield* advance;
+            if (pendingSettlements.length === 0) yield* admit(ready);
+          }
+        }).pipe(Effect.onError(
+          (cause) => Effect.sync(() => {
+            abortedForFailure = cause.reasons.some((reason) => reason._tag === "Fail");
+          })
+        ))
+      ).pipe(Effect.catch(
+        (error) => Effect.fail(
+          cleanupErrors.length === 0 ? error : new SchedulerError({
+            code: error.code,
+            message: error.message,
+            cause: error.cause,
+            cleanupErrors
+          })
+        )
+      ));
+      const settlements = plan.nodes.map((node) => {
+        const state = stateOf(node);
+        return {
+          nodeId: node.id,
+          planKey: node.key,
+          dispatchKey: state.dispatchKey,
+          outcome: state.outcome,
+          attempts: state.attempts,
+          rebases: state.rebases
+        };
+      });
+      yield* Effect.logDebug("scheduler run completed", {
+        admissions,
+        built: settlements.filter((settlement) => settlement.outcome === "built").length,
+        clean: settlements.filter((settlement) => settlement.outcome === "clean").length,
+        failed: settlements.filter((settlement) => settlement.outcome === "failed").length,
+        skipped: settlements.filter((settlement) => settlement.outcome === "skipped").length,
+        deferred: settlements.filter((settlement) => settlement.outcome === "deferred").length
+      });
+      return {
+        planId: plan.planId,
+        digest: plan.digest,
+        settlements,
+        results: Object.fromEntries(results),
+        verdicts,
+        appended
+      };
+    }).pipe(
+      Effect.annotateSpans({ runId: options.runId }),
+      Effect.annotateLogs({ runId: options.runId }),
+      Effect.onExit((exit) => Effect.annotateCurrentSpan({ outcome: EngineStoreMetrics.exitTag(exit).toLowerCase() }))
+    )
+  );
+  return { record, append, run };
+};
+const layer = (options) => Layer.succeed(PlanScheduler, make(options));
+const recertify = Effect.fn("PlanScheduler.recertify")(
+  (input) => Effect.gen(function* () {
+    const scheduler = make({
+      ...input.options,
+      selection: { ...input.options.selection, full: true }
+    });
+    const report = yield* scheduler.run(input.plan);
+    const remaining = yield* Selection.debt(input.deferringRunId, { repaidBy: [input.options.runId] });
+    return { runId: input.options.runId, report, remaining };
+  })
+);
+//# sourceMappingURL=PlanScheduler.js.map