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

package/dist/cjs/PlanMergeStore.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/PlanMergeStore.ts"],
+  "sourcesContent": ["/**\n * Owner-fenced scheduler decisions, distinct from action failure evidence and\n * redacted journal projections. Intent survives before a merge is appended.\n * @since 1.0.0\n */\n\nimport { Sha256 } from \"@smthrs/crypto\"\nimport { DurableWriter } from \"@smthrs/database/DurableWriter\"\nimport { Plan } from \"@smthrs/plan\"\nimport { OwnerId } from \"@smthrs/run-store/Ownership\"\nimport { Context, Effect, Layer, Option, Schema } from \"effect\"\nimport type * as Crypto from \"effect/Crypto\"\nimport * as SqlClient from \"effect/unstable/sql/SqlClient\"\n\nconst Natural = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))\nconst Positive = Schema.Int.check(Schema.isGreaterThan(0))\nconst Names = Schema.Array(Schema.NonEmptyString).check(Schema.isMaxLength(Plan.maximumPlanNodes))\n\n/** Execution binding shared by every decision of one plan run.\n * @since 1.0.0\n * @category schemas\n */\nexport const Identity = Schema.Struct({\n  runId: Schema.NonEmptyString,\n  planId: Schema.NonEmptyString,\n  baseDigest: Schema.NonEmptyString,\n  environmentDigest: Schema.NonEmptyString\n})\n/** Execution binding.\n * @since 1.0.0\n * @category models\n */\nexport type Identity = typeof Identity.Type\n/** A stopped attempt and the exact cohort eligible to supply merge winners.\n * @since 1.0.0\n * @category schemas\n */\nexport const Intent = Schema.Struct({\n  version: Schema.Literal(1),\n  nodeId: Schema.NonEmptyString,\n  nodeKey: Schema.NonEmptyString,\n  dispatchKey: Schema.NonEmptyString,\n  attempts: Positive,\n  rebases: Natural,\n  peers: Names\n})\n/** Durable stopped-attempt decision.\n * @since 1.0.0\n * @category models\n */\nexport type Intent = typeof Intent.Type\n/** The plan extension committed for an intent.\n * @since 1.0.0\n * @category schemas\n */\nexport const Completion = Schema.Struct({\n  version: Schema.Literal(1),\n  generation: Positive,\n  parentDigest: Schema.NonEmptyString,\n  planDigest: Schema.NonEmptyString,\n  mergeId: Schema.NonEmptyString,\n  mergeKey: Schema.NonEmptyString,\n  winners: Names\n})\n/** Committed merge extension.\n * @since 1.0.0\n * @category models\n */\nexport type Completion = typeof Completion.Type\n/** Intent with its optional committed extension.\n * @since 1.0.0\n * @category models\n */\nexport interface Decision {\n  readonly intent: Intent\n  readonly completion?: Completion\n}\n/** Typed admission/storage refusal.\n * @since 1.0.0\n * @category errors\n */\nexport class PlanMergeError extends Schema.TaggedError<PlanMergeError>()(\"@smthrs/engine-store/PlanMergeError\", {\n  code: Schema.Literals([\n    \"invalid_input\",\n    \"corrupt_state\",\n    \"incompatible_state\",\n    \"fence_lost\",\n    \"transaction_open\",\n    \"transaction_required\",\n    \"persistence_failed\"\n  ]),\n  message: Schema.String,\n  cause: Schema.optional(Schema.Unknown)\n}) {}\n/** Store operations; writes may join the owning transaction, reads require committed state.\n * @since 1.0.0\n * @category models\n */\nexport interface Service {\n  readonly list: (identity: Identity, owner: OwnerId) => Effect.Effect<ReadonlyArray<Decision>, PlanMergeError>\n  readonly intend: (identity: Identity, intent: Intent, owner: OwnerId) => Effect.Effect<Intent, PlanMergeError>\n  readonly complete: (\n    identity: Identity,\n    nodeId: string,\n    completion: Completion,\n    owner: OwnerId\n  ) => Effect.Effect<Completion, PlanMergeError>\n}\n/** Durable merge decision service.\n * @since 1.0.0\n * @category services\n */\nexport class PlanMergeStore extends Context.Service<PlanMergeStore, Service>()(\"@smthrs/engine-store/PlanMergeStore\") {}\n/** Encoded decision limit, in JavaScript code units.\n * @since 1.0.0\n * @category constants\n */\nexport const maximumDecisionCharacters = 16 * 1024 * 1024\nconst error = (code: PlanMergeError[\"code\"], message: string, cause?: unknown) =>\n  new PlanMergeError({ code, message, ...(cause === undefined ? {} : { cause }) })\nconst storageError = (cause: unknown) =>\n  cause instanceof PlanMergeError ? cause : error(\"persistence_failed\", \"could not access plan merge decisions\", cause)\nconst decode = <S extends Schema.Top & { readonly DecodingServices: never }>(\n  schema: S,\n  value: unknown,\n  code: \"invalid_input\" | \"corrupt_state\"\n) =>\n  Effect.try({\n    try: () => Schema.decodeUnknownSync(schema)(value, { onExcessProperty: \"error\" }),\n    catch: (cause) => error(code, \"invalid plan merge decision\", cause)\n  })\nconst unique = (names: ReadonlyArray<string>, code: \"invalid_input\" | \"corrupt_state\") =>\n  new Set(names).size === names.length ? Effect.void : Effect.fail(error(code, \"duplicate merge peer identity\"))\n\n/** SQL constructor; all collaborating stores must use the same database/writer.\n * @since 1.0.0\n * @category constructors\n */\nexport const make: Effect.Effect<Service, never, SqlClient.SqlClient | DurableWriter | Crypto.Crypto> = Effect.gen(\n  function*() {\n    const sql = yield* SqlClient.SqlClient\n    const writer = yield* DurableWriter\n    const crypto = yield* Effect.context<Crypto.Crypto>()\n    const hash = (value: string) => Schema.decodeUnknownEffect(Sha256)(value).pipe(Effect.provide(crypto))\n    const fence = (identity: Identity, owner: OwnerId, requireHead: boolean) =>\n      Effect.gen(function*() {\n        const owned = yield* sql`SELECT run_id FROM flows_runs WHERE run_id = ${identity.runId}\n      AND status = 'running' AND cancel_requested_at_ms IS NULL\n      AND owner_host_id = ${owner.hostId} AND owner_pid = ${owner.pid} AND owner_nonce = ${owner.nonce}`\n        if (owned.length !== 1) {\n          return yield* Effect.fail(error(\"fence_lost\", \"merge decision owner no longer owns the run\"))\n        }\n        const heads = yield* sql<\n          { planId: string; baseDigest: string; environmentDigest: string | null; version: number | null }\n        >`SELECT\n      plan_id AS \"planId\", base_digest AS \"baseDigest\", environment_digest AS \"environmentDigest\", merge_state_version AS version\n      FROM flows_plan_input_heads WHERE run_id = ${identity.runId}`\n        const head = heads[0]\n        if (head === undefined) {\n          const orphan = yield* sql`SELECT 1 FROM flows_plan_merge_intents WHERE run_id = ${identity.runId} LIMIT 1`\n          if (requireHead || orphan.length > 0) {\n            return yield* Effect.fail(error(\"corrupt_state\", \"merge intent has no admitted input generation\"))\n          }\n          return\n        }\n        if (\n          head.version !== 1 || head.planId !== identity.planId || head.baseDigest !== identity.baseDigest ||\n          head.environmentDigest !== identity.environmentDigest\n        ) {\n          return yield* Effect.fail(\n            error(\n              \"incompatible_state\",\n              \"this run has different or unrecorded merge execution state; recover with its original runtime or reconcile before starting a new run\"\n            )\n          )\n        }\n      })\n    const encoded = <A>(value: A) =>\n      Effect.gen(function*() {\n        const json = JSON.stringify(value)\n        if (json.length > maximumDecisionCharacters) {\n          return yield* Effect.fail(error(\"invalid_input\", \"merge decision exceeds its durable size limit\"))\n        }\n        return { json, checksum: yield* hash(json) }\n      })\n    const stored = <S extends Schema.Top & { readonly DecodingServices: never }>(\n      schema: S,\n      row: { json: string; checksum: string }\n    ) =>\n      Effect.gen(function*() {\n        if (row.json.length > maximumDecisionCharacters || (yield* hash(row.json)) !== row.checksum) {\n          return yield* Effect.fail(error(\"corrupt_state\", \"merge decision failed its size or integrity check\"))\n        }\n        return yield* decode(Schema.fromJsonString(schema), row.json, \"corrupt_state\")\n      })\n    const load = (identity: Identity, nodeId?: string) =>\n      Effect.gen(function*() {\n        const rows = yield* sql<\n          {\n            nodeId: string\n            json: string\n            checksum: string\n            generation: number | null\n            mergeId: string | null\n            completionJson: string | null\n            completionChecksum: string | null\n          }\n        >`SELECT i.stopped_node_id AS \"nodeId\", i.intent_json AS json, i.checksum,\n        c.generation, c.merge_node_id AS \"mergeId\", c.completion_json AS \"completionJson\",\n        c.checksum AS \"completionChecksum\"\n      FROM flows_plan_merge_intents i LEFT JOIN flows_plan_merge_completions c\n        ON c.run_id = i.run_id AND c.stopped_node_id = i.stopped_node_id\n      WHERE i.run_id = ${identity.runId} ${nodeId === undefined ? sql`` : sql`AND i.stopped_node_id = ${nodeId}`}\n      ORDER BY i.stopped_node_id LIMIT ${Plan.maximumPlanNodes + 1}`\n        if (rows.length > Plan.maximumPlanNodes) {\n          return yield* Effect.fail(error(\"corrupt_state\", \"too many merge decisions for one plan\"))\n        }\n        return yield* Effect.forEach(rows, (row) =>\n          Effect.gen(function*() {\n            const intent = yield* stored(Intent, row)\n            yield* unique(intent.peers, \"corrupt_state\")\n            if (intent.nodeId !== row.nodeId || intent.peers.includes(intent.nodeId)) {\n              return yield* Effect.fail(error(\"corrupt_state\", \"merge intent identity is inconsistent\"))\n            }\n            if (row.completionJson === null) return { intent } satisfies Decision\n            const completion = yield* stored(Completion, {\n              json: row.completionJson,\n              checksum: row.completionChecksum!\n            })\n            yield* unique(completion.winners, \"corrupt_state\")\n            if (\n              completion.generation !== row.generation || completion.mergeId !== row.mergeId ||\n              completion.winners.some((id) => !intent.peers.includes(id))\n            ) {\n              return yield* Effect.fail(error(\"corrupt_state\", \"merge completion does not match its intent\"))\n            }\n            return { intent, completion } satisfies Decision\n          }))\n      })\n    const list: Service[\"list\"] = (input, ownerInput) =>\n      Effect.gen(function*() {\n        const identity = yield* decode(Identity, input, \"invalid_input\")\n        const owner = yield* decode(OwnerId, ownerInput, \"invalid_input\")\n        if (Option.isSome(yield* Effect.serviceOption(sql.transactionService))) {\n          return yield* Effect.fail(error(\"transaction_open\", \"merge recovery requires committed decisions\"))\n        }\n        return yield* writer.write(Effect.gen(function*() {\n          yield* fence(identity, owner, false)\n          return yield* load(identity)\n        }))\n      }).pipe(Effect.mapError(storageError))\n    const intend: Service[\"intend\"] = (input, value, ownerInput) =>\n      Effect.gen(function*() {\n        const identity = yield* decode(Identity, input, \"invalid_input\")\n        const owner = yield* decode(OwnerId, ownerInput, \"invalid_input\")\n        const intent = yield* decode(Intent, value, \"invalid_input\")\n        yield* unique(intent.peers, \"invalid_input\")\n        if (intent.peers.includes(intent.nodeId)) {\n          return yield* Effect.fail(error(\"invalid_input\", \"a merge cannot stop its own peer\"))\n        }\n        const data = yield* encoded(intent)\n        return yield* writer.write(Effect.gen(function*() {\n          yield* fence(identity, owner, true)\n          const [existing] = yield* load(identity, intent.nodeId)\n          if (existing !== undefined) return existing.intent\n          const [count] = yield* sql<{ count: number }>`SELECT count(*) AS count\n        FROM flows_plan_merge_intents WHERE run_id = ${identity.runId}`\n          if (count!.count >= Plan.maximumPlanNodes) {\n            return yield* Effect.fail(error(\"invalid_input\", \"too many merge intents for one plan\"))\n          }\n          yield* sql`INSERT INTO flows_plan_merge_intents (run_id, stopped_node_id, intent_json, checksum)\n        VALUES (${identity.runId}, ${intent.nodeId}, ${data.json}, ${data.checksum})`\n          return intent\n        }))\n      }).pipe(Effect.mapError(storageError))\n    const complete: Service[\"complete\"] = (input, nodeIdInput, value, ownerInput) =>\n      Effect.gen(function*() {\n        if (Option.isNone(yield* Effect.serviceOption(sql.transactionService))) {\n          return yield* Effect.fail(\n            error(\"transaction_required\", \"merge completion must join the plan/input append transaction\")\n          )\n        }\n        const identity = yield* decode(Identity, input, \"invalid_input\")\n        const owner = yield* decode(OwnerId, ownerInput, \"invalid_input\")\n        const nodeId = yield* decode(Schema.NonEmptyString, nodeIdInput, \"invalid_input\")\n        const completion = yield* decode(Completion, value, \"invalid_input\")\n        yield* unique(completion.winners, \"invalid_input\")\n        const data = yield* encoded(completion)\n        return yield* writer.write(Effect.gen(function*() {\n          yield* fence(identity, owner, true)\n          const [decision] = yield* load(identity, nodeId)\n          if (decision === undefined) {\n            return yield* Effect.fail(error(\"corrupt_state\", \"merge completion has no intent\"))\n          }\n          if (decision.completion !== undefined) {\n            if (JSON.stringify(decision.completion) !== JSON.stringify(completion)) {\n              return yield* Effect.fail(\n                error(\"incompatible_state\", \"a merge intent already committed a different extension\")\n              )\n            }\n            return decision.completion\n          }\n          if (completion.winners.some((id) => !decision.intent.peers.includes(id))) {\n            return yield* Effect.fail(error(\"invalid_input\", \"merge winner was not an admitted peer\"))\n          }\n          const appended =\n            yield* sql`SELECT p.plan_id FROM flows_plans p JOIN flows_plan_input_generations i ON i.plan_id = p.plan_id\n        JOIN flows_plan_nodes n ON n.plan_id = p.plan_id AND n.generation = p.generation\n        WHERE p.plan_id = ${identity.planId} AND p.digest = ${completion.planDigest} AND p.generation = ${completion.generation}\n        AND i.run_id = ${identity.runId} AND i.generation = ${completion.generation}\n        AND n.node_id = ${completion.mergeId} AND n.key_digest = ${completion.mergeKey} AND n.kind = 'merge'`\n          if (appended.length !== 1) {\n            return yield* Effect.fail(\n              error(\"corrupt_state\", \"merge completion requires its plan and input generation in the same transaction\")\n            )\n          }\n          yield* sql`INSERT INTO flows_plan_merge_completions (run_id, stopped_node_id, generation, merge_node_id, completion_json, checksum)\n        VALUES (${identity.runId}, ${nodeId}, ${completion.generation}, ${completion.mergeId}, ${data.json}, ${data.checksum})`\n          return completion\n        }))\n      }).pipe(Effect.mapError(storageError))\n    return { list, intend, complete }\n  }\n)\n/** SQL-backed merge decisions; migrations must run first.\n * @since 1.0.0\n * @category layers\n */\nexport const layer: Layer.Layer<PlanMergeStore, never, SqlClient.SqlClient | DurableWriter | Crypto.Crypto> = Layer\n  .effect(PlanMergeStore)(make)\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/PlanScheduler.d.ts

@@ -0,0 +1,363 @@
+/**
+ * Drives a persisted plan: the node scheduler.
+ *
+ * `@smthrs/plan` makes the plan a value; this makes it run. The scheduler
+ * walks the persisted graph, dispatches ready nodes through the same
+ * `internal/ActionPersistence` seam every action uses — so the shared step
+ * cache, the workspace sandbox's execute→materialize transaction, attempt
+ * rows, and the fenced journal all apply unchanged — and records an
+ * evaluation outcome per node.
+ *
+ * ## What it is, and what it is not
+ *
+ * Skyframe's `AbstractParallelEvaluator` is the prior art for the state
+ * machine (`CHECK_DEPENDENCIES → VERIFIED_CLEAN | NEEDS_REBUILDING →
+ * REBUILDING → DONE`) and `EvaluationProgressReceiver` for the outcome
+ * vocabulary. Two deliberate deviations:
+ *
+ * 1. **No cache-invalidating node visitor.** Content addressing governs
+ *    reuse. Private reverse indexes propagate settled outcomes and readiness,
+ *    never dirty bits. Dispatch-time content measurement still decides
+ *    whether a recorded result can serve the node.
+ * 2. **Completion-driven, without Skyframe restarts.** Skyframe atomically
+ *    signals reverse dependencies when one node settles. Our dependencies are
+ *    declared in the plan before anything runs, so one coordinator can make
+ *    the equivalent decision from the plan, settled state, and scheduling
+ *    permits: every completion is reconciled and immediately opens another
+ *    admission pass. Giving up the wavefront barrier also gives up its
+ *    trivially serialized reconciliation; draining and applying the durable
+ *    deviation journal after each settlement, before reevaluating downstream
+ *    readiness, restores that ordering without holding unrelated ready cones.
+ *    The coordinator is the sole writer of scheduling state, which keeps every
+ *    admission decision deterministic without the `DeterministicHelper` the
+ *    vault rejected.
+ *
+ * ## The three limits
+ *
+ * The same number must never
+ * stand in for graph width, scheduler admission, and provider capacity. This
+ * module owns the middle one only: `concurrency.steps` is the leaf-execution
+ * cap, and `concurrency.agents` is the subset cap an agent node consumes in
+ * addition. Structural width is whatever the plan says; seats belong to
+ * `Agent Adapters` and are not modelled here.
+ *
+ * Under contention, ready work is ordered by effective priority — declared
+ * `priority` plus one point per capacity-constrained admission pass. A ready
+ * node gains a point exactly when a pass considers it but cannot give it the
+ * required permits. Aging is what lets priority change latency without
+ * permitting starvation; equal effective priorities preserve deterministic
+ * plan order.
+ *
+ * ## Observing the world exactly once
+ *
+ * The torn-run rule: never re-observe the
+ * world mid-run. Reads with no preceding writer are **source** inputs; their
+ * digests and glob membership are durably recorded before dispatch and restored
+ * on reopening. Preceding producers' outputs are measured after settlement —
+ * observing our own output, not the world. Later and self-writes are not source
+ * producers. New generations retain prior pins and record new observations.
+ *
+ * @since 0.1.0
+ */
+import type { FileBoundary } from "@smthrs/flow/FileBoundary";
+import { Journal } from "@smthrs/journal";
+import type { Jj } from "@smthrs/kernel";
+import { Plan, Scheduling, StepKey } from "@smthrs/plan";
+import { PlanStore } from "@smthrs/plan-store";
+import { AttemptStore, type Ownership, type RunStore } from "@smthrs/run-store";
+import type { CacheStore } from "@smthrs/step-cache";
+import * as Cause from "effect/Cause";
+import * as Context from "effect/Context";
+import type * as Crypto from "effect/Crypto";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import * as PlanInputStore from "./PlanInputStore.ts";
+import * as PlanMergeStore from "./PlanMergeStore.ts";
+import * as Reconciliation from "./Reconciliation.ts";
+import * as Selection from "./Selection.ts";
+import * as StepBoundary from "./StepBoundary.ts";
+/**
+ * The evaluation outcomes: Skyframe's `EvaluationState` adapted to a
+ * content-addressed store, plus the selection debt.
+ *
+ * - `built` — the node executed (`SUCCESS_VERSION_CHANGED`).
+ * - `clean` — a recorded result served it and no executor ran. This includes
+ *   same-run durable attempt replay for every tier, and shared-cache hits for
+ *   eligible sealed work (`SUCCESS_VERSION_UNCHANGED`). It does not assert
+ *   cross-run cache eligibility.
+ * - `failed` — the node executed and failed, or reconciliation failed it.
+ * - `skipped` — its cone prevented dispatch, or `stop-merge` stopped a
+ *   conflicted attempt in favour of a merge node. The latter has nonzero
+ *   attempts; skipped does not imply that its executor never ran. Skyframe
+ *   splits failure by version instead; a content-addressed store never serves
+ *   a failure from cache, so that split has no meaning here and this one does.
+ * - `deferred`: a selection guess postponed this sink
+ *   (`docs/guides/defer-work-with-selection.md`). It never dispatched,
+ *   wrote no cache row, and is journaled as a debt for a later guess-free
+ *   pass. Distinct from `skipped` — the work was runnable, a guess postponed
+ *   it — and never reported as passed.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type Outcome = "built" | "clean" | "failed" | "skipped" | "deferred";
+/**
+ * One material `Ref` input, resolved: the settled output of `from` projected
+ * along `path` — for sealed work, the value whose digest the dispatch key folds.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface ResolvedInput {
+    readonly from: string;
+    readonly path: ReadonlyArray<string>;
+    readonly value: unknown;
+}
+/**
+ * What the scheduler hands a node's executor.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface NodeInput {
+    readonly node: Plan.PlanNode;
+    readonly attempt: number;
+    /** The measured boundary; folded into sealed keys, diagnostic context for other tiers. */
+    readonly boundary: FileBoundary;
+    /**
+     * The node's material `Ref` inputs, resolved through the same projection the
+     * dispatch key digests for sealed work. Ordering (`Pending`) dependencies
+     * and unprojected sibling fields are deliberately absent. This preserves
+     * the consumed-data contract for every tier and prevents a sealed cache hit
+     * from serving an execution that consumed different data.
+     */
+    readonly inputs: ReadonlyArray<ResolvedInput>;
+}
+/**
+ * The DI seam that turns a plan node into work.
+ *
+ * The scheduler owns identity, admission, caching, and journaling; it
+ * deliberately owns nothing about what a node *means*. A flow runtime, a test,
+ * or a remote host each supply their own executor.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface Executor {
+    readonly execute: (input: NodeInput) => Effect.Effect<unknown, unknown>;
+}
+declare const NodeExecutor_base: Context.ServiceClass<NodeExecutor, "@smthrs/engine-store/NodeExecutor", Executor>;
+/**
+ * Service tag for the node executor.
+ *
+ * @since 0.1.0
+ * @category services
+ */
+export declare class NodeExecutor extends NodeExecutor_base {
+}
+/**
+ * Provides a plain {@link Executor} value as the {@link NodeExecutor} service.
+ *
+ * This is the whole wiring story for the scheduler's one open seam: a flow
+ * runtime, a test double, or a remote dispatcher each become a layer by
+ * passing themselves here.
+ *
+ * @since 0.1.0
+ * @category layers
+ */
+export declare const layerExecutor: (executor: Executor) => Layer.Layer<NodeExecutor>;
+/**
+ * How one node ended.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface Settlement {
+    readonly nodeId: string;
+    /** The plan-time key: a pure function of declarations. */
+    readonly planKey: string;
+    /** The execution key: content-derived for sealed work; run/plan/node/declaration-scoped for other tiers. */
+    readonly dispatchKey: string;
+    readonly outcome: Outcome;
+    readonly attempts: number;
+    readonly rebases: number;
+}
+/**
+ * What a run of a plan produced.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface Report {
+    readonly planId: string;
+    readonly digest: string;
+    readonly settlements: ReadonlyArray<Settlement>;
+    readonly results: Readonly<Record<string, unknown>>;
+    readonly verdicts: ReadonlyArray<{
+        readonly nodeId: string;
+        readonly verdict: Reconciliation.Verdict;
+    }>;
+    /** Merge nodes a `stop-merge` conflict appended to the plan. */
+    readonly appended: ReadonlyArray<string>;
+}
+/**
+ * Scheduler construction options.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface Options {
+    readonly runId: string;
+    readonly owner: Ownership.OwnerId;
+    readonly sourceId: string;
+    /**
+     * Engine-resolved identity, copied at scheduler construction and durably
+     * bound before dispatch. A changed identity cannot resume the same run.
+     * Omitting it preserves existing action keys but is itself a distinct binding.
+     */
+    readonly environment?: StepKey.EnvironmentIdentity | undefined;
+    /**
+     * The admission caps. Both default to unbounded, because a cap the caller
+     * did not declare is not the scheduler's to invent — `aspects.ts` owns the
+     * policy and narrows it. Explicit caps must be positive safe integers;
+     * zero is refused rather than silently clamped or allowed to deadlock.
+     */
+    readonly concurrency?: Scheduling.Concurrency | undefined;
+    /**
+     * How many times a `delay-rebase` node may re-measure and re-key against a
+     * newly recorded base before reconciliation is asked. Bounded on purpose: an
+     * unbounded rebase loop is a livelock with good manners.
+     */
+    readonly rebaseLimit?: number | undefined;
+    /**
+     * Probabilistic selection input for this run (`Selection`). Every field is
+     * optional because every default is inert: no changed paths and no beliefs
+     * admit everything, so a caller that never opted in runs exactly as today.
+     * `full: true` is the run-level override — every verdict is treated as
+     * `Admit` and the override is journaled, the way `--fresh` ignores the
+     * cache.
+     */
+    readonly selection?: {
+        /** Changed paths the belief edges are matched against. */
+        readonly changed?: ReadonlyArray<string> | undefined;
+        /** The belief snapshot pinned before planning. */
+        readonly beliefs?: Selection.BeliefSnapshot | undefined;
+        /** Deferral policy; `deferBelow` defaults to zero, which defers nothing. */
+        readonly policy?: Selection.Policy | undefined;
+        /** Force full selection: treat every verdict as `Admit`, journaled. */
+        readonly full?: boolean | undefined;
+    } | undefined;
+}
+/**
+ * Everything driving a plan needs from the composition.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type Requirements = PlanMergeStore.PlanMergeStore | AttemptStore.AttemptStore | CacheStore.CacheStore | Crypto.Crypto | Jj.Jj | Journal.Journal | NodeExecutor | PlanStore.PlanStore | PlanInputStore.PlanInputStore | RunStore.RunStore | StepBoundary.Service;
+declare const SchedulerError_base: Schema.Class<SchedulerError, Schema.TaggedStruct<"@smthrs/engine-store/SchedulerError", {
+    readonly code: Schema.Literals<readonly ["invalid_plan", "boundary_unavailable", "key_uncomputable", "elaboration_failed", "store_failed"]>;
+    readonly message: Schema.String;
+    readonly cause: Schema.optional<Schema.Unknown>;
+    /** Failures while settling siblings after the primary scheduler failure. */
+    readonly cleanupErrors: Schema.optional<Schema.$Array<Schema.Unknown>>;
+}>, Cause.YieldableError>;
+/**
+ * A refusal the scheduler itself raises. A node's own failure is an outcome,
+ * not one of these — the run continues and the report says `failed`.
+ *
+ * @since 0.1.0
+ * @category errors
+ */
+export declare class SchedulerError extends SchedulerError_base {
+}
+/**
+ * Plan-driving operations.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface Service {
+    /** Persists generation 0 and journals `plan-recorded`. */
+    readonly record: (plan: Plan.Plan) => Effect.Effect<PlanStore.RecordResult, SchedulerError, PlanStore.PlanStore | Journal.Journal | Crypto.Crypto>;
+    /** Persists the newest generation and journals `subgraph-appended`. */
+    readonly append: (plan: Plan.Plan) => Effect.Effect<void, SchedulerError, PlanStore.PlanStore | Journal.Journal | Crypto.Crypto>;
+    /** Drives the plan to completion and reports every node's outcome. */
+    readonly run: (plan: Plan.Plan) => Effect.Effect<Report, SchedulerError, Requirements>;
+}
+declare const PlanScheduler_base: Context.ServiceClass<PlanScheduler, "@smthrs/engine-store/PlanScheduler", Service>;
+/**
+ * Service tag for the plan scheduler.
+ *
+ * @since 0.1.0
+ * @category services
+ */
+export declare class PlanScheduler extends PlanScheduler_base {
+}
+/**
+ * Constructs a scheduler bound to one run.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+export declare const make: (options: Options) => Service;
+/**
+ * Provides a scheduler bound to one run.
+ *
+ * @since 0.1.0
+ * @category layers
+ */
+export declare const layer: (options: Options) => Layer.Layer<PlanScheduler>;
+/**
+ * What {@link recertify} returns: the repaying run's id, its report, and the
+ * deferring run's remaining debt after the repayment is counted.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface RecertifyResult {
+    readonly runId: string;
+    readonly report: Report;
+    readonly remaining: ReadonlyArray<Selection.DebtEntry>;
+}
+/**
+ * The recertification driver: re-drives a compiled plan under a fresh,
+ * caller-supplied run with the `full` selection override — guess-free by
+ * construction — then reports the deferring run's remaining debt via
+ * `Selection.debt(deferringRunId, { repaidBy: [options.runId] })`.
+ *
+ * The design draft placed this beside the other Selection helpers; it lives
+ * here because it constructs a scheduler, and `Selection` must stay
+ * type-only toward this module to keep the dependency graph acyclic. The
+ * deferring run's journal is never written — repayment is a read-side join.
+ * Scheduling the cadence (nightly, per-merge) stays a product concern; this
+ * is only the primitive one pass runs.
+ *
+ * @since 0.1.0
+ * @category combinators
+ */
+export declare const recertify: (input: {
+    readonly plan: Plan.Plan;
+    readonly deferringRunId: string;
+    readonly options: Options;
+}) => Effect.Effect<{
+    runId: string;
+    report: Report;
+    remaining: readonly {
+        readonly planId: string;
+        readonly nodeId: string;
+        readonly planKey: string;
+        readonly edge: {
+            readonly scope: string;
+            readonly affects: string;
+            readonly confidence: number;
+            readonly validFromMs: number;
+            readonly evidence: readonly string[];
+        };
+        readonly likelihood: number;
+        readonly seq: number;
+    }[];
+}, Journal.JournalError | SchedulerError, Requirements>;
+export {};
+//# sourceMappingURL=PlanScheduler.d.ts.map

package/dist/cjs/PlanScheduler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PlanScheduler.d.ts","sourceRoot":"","sources":["../../src/PlanScheduler.ts"],"names":[],"mappings":"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"}