effect-agent 0.1.0-beta.85 → 0.1.0-beta.87

package/dist/durable/ThreadStoreConformance.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ThreadStoreConformance.mjs","names":[],"sources":["../../src/durable/ThreadStoreConformance.ts"],"sourcesContent":["import { Effect, DateTime, Option, Schema, Stream } from \"effect\";\n\nimport { ThreadId, RunId, SubmissionId } from \"../core/Identifiers.ts\";\nimport { EMPTY_TAIL_DIGEST } from \"./Digest.ts\";\nimport type { Digest } from \"./Records.ts\";\nimport {\n  BatchId,\n  CanonicalBatch,\n  CanonicalSequence,\n  DeploymentId,\n  ProducerEpoch,\n  ProducerId,\n  RecordEnvelope,\n  RecordId,\n  UserInputRecorded,\n} from \"./Records.ts\";\nimport {\n  type AppendResult,\n  AppendConflict,\n  CheckpointRejected,\n  ThreadCheckpoint,\n  ThreadExportRequest,\n  ThreadMaterialization,\n  ThreadNotMaterialized,\n  ThreadObservation,\n  ThreadRead,\n  ThreadStore,\n  ThreadTailRequest,\n  FencedAppendRequest,\n  FenceRejected,\n  LoadCheckpointRequest,\n  SaveCheckpointRequest,\n  type ThreadStoreFailure,\n} from \"./ThreadStore.ts\";\n\n/** A ThreadStore contract invariant that an adapter under test violated. */\nexport class ThreadStoreConformanceViolation extends Schema.TaggedError<ThreadStoreConformanceViolation>()(\n  \"ThreadStoreConformanceViolation\",\n  {\n    caseName: Schema.String,\n    message: Schema.String,\n  },\n) {}\n\nexport type ThreadStoreConformanceFailure =\n  | ThreadStoreFailure\n  | CheckpointRejected\n  | ThreadStoreConformanceViolation;\n\n/**\n * One adapter-neutral ThreadStore contract case. Each case owns disjoint\n * Thread identities, so a suite may run every case against one shared store\n * instance or against a fresh store per case.\n */\nexport interface ThreadStoreConformanceCase {\n  readonly name: string;\n  readonly run: Effect.Effect<void, ThreadStoreConformanceFailure, ThreadStore>;\n}\n\nconst decodeThreadId = Schema.decodeSync(ThreadId);\nconst decodeRecordId = Schema.decodeSync(RecordId);\nconst decodeBatchId = Schema.decodeSync(BatchId);\nconst decodeSequence = Schema.decodeSync(CanonicalSequence);\nconst decodeEpoch = Schema.decodeSync(ProducerEpoch);\n\nconst CONFORMANCE_DEPLOYMENT = Schema.decodeSync(DeploymentId)(\"deployment-conformance\");\nconst CONFORMANCE_PRODUCER = Schema.decodeSync(ProducerId)(\"producer-conformance\");\nconst CONFORMANCE_SUBMISSION = Schema.decodeSync(SubmissionId)(\"submission-conformance\");\nconst CONFORMANCE_RUN = Schema.decodeSync(RunId)(\"run-conformance\");\nconst CONFORMANCE_CREATED_AT = DateTime.toUtc(DateTime.makeUnsafe(1));\n\nconst ZERO_SEQUENCE = decodeSequence(0);\nconst EPOCH_ONE = decodeEpoch(1);\nconst EPOCH_TWO = decodeEpoch(2);\nconst EMPTY_TAIL = { lastSequence: ZERO_SEQUENCE, tailDigest: EMPTY_TAIL_DIGEST } as const;\nconst isAppendConflict = Schema.is(AppendConflict);\nconst isFenceRejected = Schema.is(FenceRejected);\nconst isCheckpointRejected = Schema.is(CheckpointRejected);\nconst isThreadNotMaterialized = Schema.is(ThreadNotMaterialized);\n\nconst record = (recordId: string, input: string): RecordEnvelope =>\n  RecordEnvelope.make({\n    recordId: decodeRecordId(recordId),\n    family: \"thread\",\n    schemaVersion: 1,\n    createdAt: CONFORMANCE_CREATED_AT,\n    deploymentId: CONFORMANCE_DEPLOYMENT,\n    payload: UserInputRecorded.make({\n      submissionId: CONFORMANCE_SUBMISSION,\n      kind: \"user\",\n      runId: CONFORMANCE_RUN,\n      input,\n    }),\n  });\n\nconst batch = (\n  batchId: string,\n  records: readonly [RecordEnvelope, ...Array<RecordEnvelope>],\n): CanonicalBatch =>\n  CanonicalBatch.make({\n    batchId: decodeBatchId(batchId),\n    producerId: CONFORMANCE_PRODUCER,\n    records,\n  });\n\nconst materialize = Effect.fn(\"ThreadStoreConformance.materialize\")(function* (\n  threadId: ThreadId,\n  producerEpoch: ProducerEpoch,\n) {\n  const store = yield* ThreadStore;\n\n  yield* store.materialize(ThreadMaterialization.make({ threadId, producerEpoch }));\n});\n\nconst append = Effect.fn(\"ThreadStoreConformance.append\")(function* (\n  threadId: ThreadId,\n  canonicalBatch: CanonicalBatch,\n  tail: Pick<AppendResult, \"lastSequence\" | \"tailDigest\"> = EMPTY_TAIL,\n  producerEpoch: ProducerEpoch = EPOCH_ONE,\n) {\n  const store = yield* ThreadStore;\n\n  return yield* store.append(\n    FencedAppendRequest.make({\n      threadId,\n      batch: canonicalBatch,\n      expectedTailSequence: tail.lastSequence,\n      expectedTailDigest: tail.tailDigest,\n      producerEpoch,\n    }),\n  );\n});\n\nconst readAll = Effect.fn(\"ThreadStoreConformance.readAll\")(function* (threadId: ThreadId) {\n  const store = yield* ThreadStore;\n\n  return yield* store.read(ThreadRead.make({ threadId, limit: 1_024 })).pipe(Stream.runCollect);\n});\n\nconst checkpointAt = (\n  threadId: ThreadId,\n  throughSequence: CanonicalSequence,\n  tailDigest: Digest,\n): ThreadCheckpoint =>\n  ThreadCheckpoint.make({\n    schemaVersion: 1,\n    threadId,\n    throughSequence,\n    tailDigest,\n    state: { conformance: true },\n    createdAt: CONFORMANCE_CREATED_AT,\n  });\n\nconst conformanceCase = (\n  name: string,\n  build: (assert: {\n    readonly ensure: (\n      condition: boolean,\n      message: string,\n    ) => Effect.Effect<void, ThreadStoreConformanceViolation>;\n    readonly expectFailure: <A, E, R>(\n      description: string,\n      effect: Effect.Effect<A, E, R>,\n    ) => Effect.Effect<E, ThreadStoreConformanceViolation, R>;\n  }) => Effect.Effect<void, ThreadStoreConformanceFailure, ThreadStore>,\n): ThreadStoreConformanceCase => ({\n  name,\n  run: build({\n    ensure: (condition, message) =>\n      condition\n        ? Effect.void\n        : Effect.fail(ThreadStoreConformanceViolation.make({ caseName: name, message })),\n    expectFailure: (description, effect) =>\n      Effect.flip(effect).pipe(\n        Effect.mapError(() =>\n          ThreadStoreConformanceViolation.make({\n            caseName: name,\n            message: `Expected failure but the operation succeeded: ${description}`,\n          }),\n        ),\n      ),\n  }).pipe(Effect.withSpan(`ThreadStoreConformance.${name}`)),\n});\n\nconst atomicBatchVisibility = conformanceCase(\n  \"commits batches atomically with no partial reader visibility\",\n  ({ ensure, expectFailure }) =>\n    Effect.gen(function* () {\n      const threadId = decodeThreadId(\"conformance-atomic\");\n      const store = yield* ThreadStore;\n\n      yield* materialize(threadId, EPOCH_ONE);\n\n      const committed = yield* append(\n        threadId,\n        batch(\"atomic-batch-1\", [\n          record(\"atomic-record-1\", \"first\"),\n          record(\"atomic-record-2\", \"second\"),\n          record(\"atomic-record-3\", \"third\"),\n        ]),\n      );\n\n      yield* ensure(\n        committed.firstSequence === 1 && committed.lastSequence === 3,\n        \"A three-record batch must commit sequences 1 through 3\",\n      );\n\n      const read = yield* readAll(threadId);\n\n      yield* ensure(read.length === 3, \"Readers must observe the full committed batch\");\n      yield* ensure(\n        read.every((envelope, index) => envelope.sequence === index + 1),\n        \"Committed records must be gap-free in declaration order\",\n      );\n\n      const observed = yield* store\n        .observe(ThreadObservation.make({ threadId }))\n        .pipe(Stream.take(3), Stream.runCollect);\n\n      yield* ensure(\n        observed.map((envelope) => envelope.record.recordId).join(\",\") ===\n          read.map((envelope) => envelope.record.recordId).join(\",\"),\n        \"Observers must see exactly the committed batch records in order\",\n      );\n\n      const duplicate = record(\"atomic-record-4\", \"duplicate\");\n\n      const intraBatch = yield* expectFailure(\n        \"a batch containing one record ID twice\",\n        append(threadId, batch(\"atomic-batch-2\", [duplicate, duplicate]), committed),\n      );\n\n      yield* ensure(\n        isAppendConflict(intraBatch) && intraBatch.reason === \"record-identity\",\n        \"A duplicated record ID inside one batch must conflict with reason record-identity\",\n      );\n\n      const crossBatch = yield* expectFailure(\n        \"a batch reusing an already-committed record ID\",\n        append(threadId, batch(\"atomic-batch-3\", [record(\"atomic-record-1\", \"reused\")]), committed),\n      );\n\n      yield* ensure(\n        isAppendConflict(crossBatch) && crossBatch.reason === \"record-identity\",\n        \"A record ID reused across batches must conflict with reason record-identity\",\n      );\n\n      const exported = yield* store.export(ThreadExportRequest.make({ threadId }));\n\n      yield* ensure(\n        exported.records.length === 3 &&\n          exported.tailSequence === committed.lastSequence &&\n          exported.tailDigest === committed.tailDigest,\n        \"A conflicting batch must leave no partial prefix behind\",\n      );\n    }),\n);\n\nconst idempotentReplay = conformanceCase(\n  \"replays an identical batch idempotently and rejects altered content\",\n  ({ ensure, expectFailure }) =>\n    Effect.gen(function* () {\n      const threadId = decodeThreadId(\"conformance-replay\");\n\n      yield* materialize(threadId, EPOCH_ONE);\n\n      const original = batch(\"replay-batch-1\", [\n        record(\"replay-record-1\", \"Lisbon\"),\n        record(\"replay-record-2\", \"Porto\"),\n      ]);\n\n      const first = yield* append(threadId, original);\n\n      yield* ensure(!first.replayed, \"The first append of a batch must not report replayed\");\n\n      const replayed = yield* append(threadId, original);\n\n      yield* ensure(\n        replayed.replayed &&\n          replayed.firstSequence === first.firstSequence &&\n          replayed.lastSequence === first.lastSequence &&\n          replayed.tailDigest === first.tailDigest,\n        \"Replaying an identical batch must return the original result with replayed set\",\n      );\n\n      const altered = yield* expectFailure(\n        \"replaying a batch ID with different canonical content\",\n        append(threadId, batch(\"replay-batch-1\", [record(\"replay-record-3\", \"Faro\")])),\n      );\n\n      yield* ensure(\n        isAppendConflict(altered) && altered.reason === \"batch-digest\",\n        \"A batch ID replayed with different content must conflict with reason batch-digest\",\n      );\n\n      const read = yield* readAll(threadId);\n\n      yield* ensure(read.length === 2, \"Replay and conflict must not duplicate committed records\");\n    }),\n);\n\nconst tailConflict = conformanceCase(\n  \"rejects stale expected tails and reports the actual tail\",\n  ({ ensure, expectFailure }) =>\n    Effect.gen(function* () {\n      const threadId = decodeThreadId(\"conformance-tail\");\n\n      yield* materialize(threadId, EPOCH_ONE);\n\n      const first = yield* append(\n        threadId,\n        batch(\"tail-batch-1\", [record(\"tail-record-1\", \"first\")]),\n      );\n\n      const staleSequence = yield* expectFailure(\n        \"an append declaring the pre-append tail sequence\",\n        append(threadId, batch(\"tail-batch-2\", [record(\"tail-record-2\", \"second\")])),\n      );\n\n      yield* ensure(\n        isAppendConflict(staleSequence) && staleSequence.reason === \"tail\",\n        \"A stale expected tail sequence must conflict with reason tail\",\n      );\n      yield* ensure(\n        isAppendConflict(staleSequence) &&\n          staleSequence.actualTailSequence === first.lastSequence &&\n          staleSequence.actualTailDigest === first.tailDigest,\n        \"A tail conflict must carry the actual committed tail as a resume hint\",\n      );\n\n      const staleDigest = yield* expectFailure(\n        \"an append declaring the right sequence with the wrong digest\",\n        append(threadId, batch(\"tail-batch-2\", [record(\"tail-record-2\", \"second\")]), {\n          lastSequence: first.lastSequence,\n          tailDigest: EMPTY_TAIL_DIGEST,\n        }),\n      );\n\n      yield* ensure(\n        isAppendConflict(staleDigest) && staleDigest.reason === \"tail\",\n        \"A stale expected tail digest must conflict with reason tail\",\n      );\n\n      const recovered = yield* append(\n        threadId,\n        batch(\"tail-batch-2\", [record(\"tail-record-2\", \"second\")]),\n        first,\n      );\n\n      yield* ensure(\n        recovered.firstSequence === first.lastSequence + 1,\n        \"An append declaring the true tail must commit after a tail conflict\",\n      );\n    }),\n);\n\nconst producerFencing = conformanceCase(\n  \"fences stale producer epochs while allowing epoch takeover\",\n  ({ ensure, expectFailure }) =>\n    Effect.gen(function* () {\n      const threadId = decodeThreadId(\"conformance-fencing\");\n\n      yield* materialize(threadId, EPOCH_ONE);\n\n      const first = yield* append(\n        threadId,\n        batch(\"fence-batch-1\", [record(\"fence-record-1\", \"first\")]),\n      );\n\n      yield* materialize(threadId, EPOCH_TWO);\n\n      const staleAppend = yield* expectFailure(\n        \"an append using the pre-takeover producer epoch\",\n        append(\n          threadId,\n          batch(\"fence-batch-2\", [record(\"fence-record-2\", \"second\")]),\n          first,\n          EPOCH_ONE,\n        ),\n      );\n\n      yield* ensure(\n        isFenceRejected(staleAppend) &&\n          staleAppend.actualEpoch === EPOCH_TWO &&\n          staleAppend.attemptedEpoch === EPOCH_ONE,\n        \"A stale producer epoch must be fenced with both epochs reported\",\n      );\n\n      const staleMaterialize = yield* expectFailure(\n        \"re-materializing with the pre-takeover producer epoch\",\n        materialize(threadId, EPOCH_ONE),\n      );\n\n      yield* ensure(\n        isFenceRejected(staleMaterialize),\n        \"A stale producer epoch must not re-register through materialization\",\n      );\n\n      const takeover = yield* append(\n        threadId,\n        batch(\"fence-batch-2\", [record(\"fence-record-2\", \"second\")]),\n        first,\n        EPOCH_TWO,\n      );\n\n      yield* ensure(\n        !takeover.replayed && takeover.firstSequence === first.lastSequence + 1,\n        \"The takeover epoch must append after the committed tail\",\n      );\n    }),\n);\n\nconst offsetResumability = conformanceCase(\n  \"resumes observation from a saved offset with exactly the suffix\",\n  ({ ensure }) =>\n    Effect.gen(function* () {\n      const threadId = decodeThreadId(\"conformance-offsets\");\n      const store = yield* ThreadStore;\n\n      yield* materialize(threadId, EPOCH_ONE);\n\n      const first = yield* append(\n        threadId,\n        batch(\"offset-batch-1\", [\n          record(\"offset-record-1\", \"first\"),\n          record(\"offset-record-2\", \"second\"),\n        ]),\n      );\n\n      const second = yield* append(\n        threadId,\n        batch(\"offset-batch-2\", [record(\"offset-record-3\", \"third\")]),\n        first,\n      );\n\n      yield* append(\n        threadId,\n        batch(\"offset-batch-3\", [record(\"offset-record-4\", \"fourth\")]),\n        second,\n      );\n\n      const committed = yield* readAll(threadId);\n\n      yield* ensure(committed.length === 4, \"All committed records must be readable\");\n      const savedOffset = committed[1]?.offset;\n\n      yield* ensure(savedOffset !== undefined, \"Committed records must carry observation offsets\");\n      if (savedOffset === undefined) return;\n\n      const resumed = yield* store\n        .observe(ThreadObservation.make({ threadId, afterOffset: savedOffset }))\n        .pipe(Stream.take(2), Stream.runCollect);\n\n      yield* ensure(\n        resumed.map((envelope) => envelope.record.recordId).join(\",\") ===\n          committed\n            .slice(2)\n            .map((envelope) => envelope.record.recordId)\n            .join(\",\"),\n        \"Observation from a saved offset must deliver exactly the suffix in order\",\n      );\n\n      const fromStart = yield* store\n        .observe(ThreadObservation.make({ threadId }))\n        .pipe(Stream.take(4), Stream.runCollect);\n\n      yield* ensure(\n        fromStart.map((envelope) => envelope.record.recordId).join(\",\") ===\n          committed.map((envelope) => envelope.record.recordId).join(\",\"),\n        \"Observation without an offset must deliver the full log in order\",\n      );\n    }),\n);\n\nconst checkpointBoundaries = conformanceCase(\n  \"enforces checkpoint save and load boundary rules\",\n  ({ ensure, expectFailure }) =>\n    Effect.gen(function* () {\n      const threadId = decodeThreadId(\"conformance-checkpoints\");\n      const store = yield* ThreadStore;\n      const checkpoints = store.checkpoints;\n\n      if (checkpoints === undefined) {\n        return yield* ThreadStoreConformanceViolation.make({\n          caseName: \"enforces checkpoint save and load boundary rules\",\n          message: \"The optional checkpoint suite requires checkpoint support\",\n        });\n      }\n\n      const missing = [\n        yield* expectFailure(\n          \"saving a checkpoint for an unmaterialized Thread\",\n          checkpoints.save(\n            SaveCheckpointRequest.make({\n              checkpoint: checkpointAt(threadId, ZERO_SEQUENCE, EMPTY_TAIL_DIGEST),\n            }),\n          ),\n        ),\n        yield* expectFailure(\n          \"loading a checkpoint for an unmaterialized Thread\",\n          checkpoints.load(LoadCheckpointRequest.make({ threadId })),\n        ),\n      ];\n\n      yield* ensure(\n        missing.every(isThreadNotMaterialized),\n        \"Checkpoints require a materialized Thread\",\n      );\n      yield* materialize(threadId, EPOCH_ONE);\n\n      const first = yield* append(\n        threadId,\n        batch(\"checkpoint-batch-1\", [record(\"checkpoint-record-1\", \"Kyoto\")]),\n      );\n\n      const aheadOfTail = yield* expectFailure(\n        \"a checkpoint claiming a sequence beyond the committed tail\",\n        checkpoints.save(\n          SaveCheckpointRequest.make({\n            checkpoint: checkpointAt(\n              threadId,\n              decodeSequence(first.lastSequence + 1),\n              first.tailDigest,\n            ),\n          }),\n        ),\n      );\n\n      yield* ensure(\n        isCheckpointRejected(aheadOfTail) && aheadOfTail.reason === \"ahead-of-tail\",\n        \"A checkpoint ahead of the tail must be rejected with reason ahead-of-tail\",\n      );\n\n      const digestMismatch = yield* expectFailure(\n        \"a checkpoint whose digest does not match the canonical chain\",\n        checkpoints.save(\n          SaveCheckpointRequest.make({\n            checkpoint: checkpointAt(threadId, first.lastSequence, EMPTY_TAIL_DIGEST),\n          }),\n        ),\n      );\n\n      yield* ensure(\n        isCheckpointRejected(digestMismatch) && digestMismatch.reason === \"digest-mismatch\",\n        \"A checkpoint with a mismatched digest must be rejected with reason digest-mismatch\",\n      );\n      yield* ensure(\n        Option.isNone(yield* checkpoints.load(LoadCheckpointRequest.make({ threadId }))),\n        \"Rejected checkpoints must not become loadable\",\n      );\n\n      const valid = checkpointAt(threadId, first.lastSequence, first.tailDigest);\n\n      yield* checkpoints.save(SaveCheckpointRequest.make({ checkpoint: valid }));\n      yield* checkpoints.save(SaveCheckpointRequest.make({ checkpoint: valid }));\n\n      const loaded = yield* checkpoints.load(LoadCheckpointRequest.make({ threadId }));\n\n      yield* ensure(\n        Option.isSome(loaded) &&\n          loaded.value.throughSequence === first.lastSequence &&\n          loaded.value.tailDigest === first.tailDigest,\n        \"A valid checkpoint must load bound to its canonical sequence and digest\",\n      );\n\n      const beforeCheckpoint = yield* checkpoints.load(\n        LoadCheckpointRequest.make({ threadId, atOrBeforeSequence: ZERO_SEQUENCE }),\n      );\n\n      yield* ensure(\n        Option.isNone(beforeCheckpoint),\n        \"Checkpoint lookup must respect the atOrBeforeSequence bound\",\n      );\n\n      yield* append(\n        threadId,\n        batch(\"checkpoint-batch-2\", [record(\"checkpoint-record-2\", \"Nara\")]),\n        first,\n      );\n      const afterAppend = yield* checkpoints.load(LoadCheckpointRequest.make({ threadId }));\n\n      yield* ensure(\n        Option.isSome(afterAppend) && afterAppend.value.throughSequence === first.lastSequence,\n        \"An older checkpoint must remain loadable after later appends\",\n      );\n    }),\n);\n\nconst tailInspection = conformanceCase(\n  \"inspects the canonical tail so a resuming producer can compose its next append\",\n  ({ ensure, expectFailure }) =>\n    Effect.gen(function* () {\n      const threadId = decodeThreadId(\"conformance-tail-inspection\");\n      const store = yield* ThreadStore;\n\n      const missing = yield* expectFailure(\n        \"inspecting the tail of an unmaterialized Thread\",\n        store.inspectTail(ThreadTailRequest.make({ threadId })),\n      );\n\n      yield* ensure(\n        isThreadNotMaterialized(missing) && missing.threadId === threadId,\n        \"Tail inspection of an unmaterialized Thread must fail as not materialized\",\n      );\n\n      yield* materialize(threadId, EPOCH_ONE);\n      const empty = yield* store.inspectTail(ThreadTailRequest.make({ threadId }));\n\n      yield* ensure(\n        empty.tailSequence === ZERO_SEQUENCE &&\n          empty.tailDigest === EMPTY_TAIL_DIGEST &&\n          empty.producerEpoch === EPOCH_ONE,\n        \"An empty Thread must report the zero tail and its registered epoch\",\n      );\n\n      const first = yield* append(\n        threadId,\n        batch(\"inspect-batch-1\", [record(\"inspect-record-1\", \"first\")]),\n      );\n\n      const afterAppend = yield* store.inspectTail(ThreadTailRequest.make({ threadId }));\n\n      yield* ensure(\n        afterAppend.tailSequence === first.lastSequence &&\n          afterAppend.tailDigest === first.tailDigest,\n        \"Tail inspection must match the latest AppendResult\",\n      );\n\n      const resumed = yield* append(\n        threadId,\n        batch(\"inspect-batch-2\", [record(\"inspect-record-2\", \"second\")]),\n        { lastSequence: afterAppend.tailSequence, tailDigest: afterAppend.tailDigest },\n        afterAppend.producerEpoch,\n      );\n\n      yield* ensure(\n        resumed.firstSequence === afterAppend.tailSequence + 1,\n        \"An append composed from the inspected tail must commit without exporting the log\",\n      );\n\n      yield* materialize(threadId, EPOCH_TWO);\n      const afterTakeover = yield* store.inspectTail(ThreadTailRequest.make({ threadId }));\n\n      yield* ensure(\n        afterTakeover.producerEpoch === EPOCH_TWO &&\n          afterTakeover.tailSequence === resumed.lastSequence,\n        \"Tail inspection must reflect epoch takeover without disturbing the tail\",\n      );\n    }),\n);\n\nconst notMaterializedOperations = conformanceCase(\n  \"fails every read and write against an unmaterialized Thread\",\n  ({ ensure, expectFailure }) =>\n    Effect.gen(function* () {\n      const threadId = decodeThreadId(\"conformance-not-materialized\");\n      const store = yield* ThreadStore;\n\n      const failures = [\n        yield* expectFailure(\n          \"appending to an unmaterialized Thread\",\n          append(threadId, batch(\"missing-batch-1\", [record(\"missing-record-1\", \"first\")])),\n        ),\n        yield* expectFailure(\"reading an unmaterialized Thread\", readAll(threadId)),\n        yield* expectFailure(\n          \"observing an unmaterialized Thread\",\n          store\n            .observe(ThreadObservation.make({ threadId }))\n            .pipe(Stream.take(1), Stream.runCollect),\n        ),\n        yield* expectFailure(\n          \"exporting an unmaterialized Thread\",\n          store.export(ThreadExportRequest.make({ threadId })),\n        ),\n        yield* expectFailure(\n          \"inspecting the tail of an unmaterialized Thread\",\n          store.inspectTail(ThreadTailRequest.make({ threadId })),\n        ),\n      ];\n\n      yield* Effect.forEach(\n        failures,\n        (failure) =>\n          ensure(\n            isThreadNotMaterialized(failure) && failure.threadId === threadId,\n            \"Operations against an unmaterialized Thread must fail as not materialized\",\n          ),\n        { discard: true },\n      );\n    }),\n);\n\n/**\n * The shared, adapter-parameterized ThreadStore contract suite (STORE-010). Every\n * durable adapter test suite must execute each case against its own store provisioning.\n */\nexport const threadStoreConformanceCases: ReadonlyArray<ThreadStoreConformanceCase> = [\n  atomicBatchVisibility,\n  idempotentReplay,\n  tailConflict,\n  producerFencing,\n  offsetResumability,\n  tailInspection,\n  notMaterializedOperations,\n];\n\n/** Additional contract cases only for adapters advertising `ThreadStore.checkpoints`. */\nexport const threadCheckpointConformanceCases: ReadonlyArray<ThreadStoreConformanceCase> = [\n  checkpointBoundaries,\n];\n"],"mappings":"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"}

package/dist/durable/ToolReconciler.d.mts

@@ -0,0 +1,2 @@
+import { a as ReconciliationSafeToRetry, c as ToolReconcilerError, i as ReconciliationNeverStarted, n as ReconciliationCompleted, o as ReconciliationUncertain, r as ReconciliationDecision, s as ToolReconciler, t as PreparedToolCallEvidence } from "../ToolReconciler-DQVaJfpE.mjs";
+export { PreparedToolCallEvidence, ReconciliationCompleted, ReconciliationDecision, ReconciliationNeverStarted, ReconciliationSafeToRetry, ReconciliationUncertain, ToolReconciler, ToolReconcilerError };

package/dist/durable/ToolReconciler.mjs

@@ -0,0 +1,81 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
+import { RunId, SubmissionId, ThreadId, ToolCallId } from "../core/Identifiers.mjs";
+import { Digest, PersistedJson, ToolCallPrepared } from "./Records.mjs";
+import { Context, Effect, Layer, Schema } from "effect";
+//#region src/durable/ToolReconciler.ts
+var ToolReconciler_exports = /* @__PURE__ */ __exportAll({
+	PreparedToolCallEvidence: () => PreparedToolCallEvidence,
+	ReconciliationCompleted: () => ReconciliationCompleted,
+	ReconciliationDecision: () => ReconciliationDecision,
+	ReconciliationNeverStarted: () => ReconciliationNeverStarted,
+	ReconciliationSafeToRetry: () => ReconciliationSafeToRetry,
+	ReconciliationUncertain: () => ReconciliationUncertain,
+	ToolReconciler: () => ToolReconciler,
+	ToolReconcilerError: () => ToolReconcilerError
+});
+/**
+* Everything a reconciliation policy can consult about one prepared-but-unsettled ordinary Tool
+* Call (durability §10): deterministic identities for supplier-side lookup plus the exact
+* Schema-encoded parameters and their digest. Built from the canonical `ToolCallPrepared` record
+* and the owning Submission's identities — never from in-memory Attempt state.
+*/
+var PreparedToolCallEvidence = class extends Schema.Class("@effect-agent/thread/PreparedToolCallEvidence")({
+	threadId: ThreadId,
+	submissionId: SubmissionId,
+	runId: RunId,
+	turn: ToolCallPrepared.fields.turn,
+	toolCallId: ToolCallId,
+	toolName: ToolCallPrepared.fields.toolName,
+	parameters: PersistedJson,
+	parametersDigest: Digest
+}) {};
+/** Proof that the external execution never started: the call may re-execute on resume. */
+var ReconciliationNeverStarted = class extends Schema.TaggedClass("@effect-agent/thread/ReconciliationNeverStarted")("NeverStarted", {}) {};
+/**
+* Proof that the external execution completed: `result` is the recovered supplier truth, which
+* becomes canonical (`ToolCallSettled` + `ToolCallResolved`) WITHOUT executing anything.
+*/
+var ReconciliationCompleted = class extends Schema.TaggedClass("@effect-agent/thread/ReconciliationCompleted")("CompletedWithResult", {
+	result: PersistedJson,
+	isFailure: Schema.Boolean
+}) {};
+/** The call is safe to repeat under a stable external idempotency contract. */
+var ReconciliationSafeToRetry = class extends Schema.TaggedClass("@effect-agent/thread/ReconciliationSafeToRetry")("SafeToRetry", {}) {};
+/** No proof either way: the outcome is Unknown and requires authorized resolution (DUR-017). */
+var ReconciliationUncertain = class extends Schema.TaggedClass("@effect-agent/thread/ReconciliationUncertain")("Uncertain", { reason: Schema.String }) {};
+/**
+* What a reconciliation policy can prove about one prepared-but-unsettled ordinary Tool Call
+* (durability §10): execution never started, execution completed with a recoverable result,
+* execution is safe to repeat, or nothing — in which case the Run enters Unknown. The engine
+* never manufactures an error result and continues.
+*/
+const ReconciliationDecision = Schema.Union([
+	ReconciliationNeverStarted,
+	ReconciliationCompleted,
+	ReconciliationSafeToRetry,
+	ReconciliationUncertain
+]);
+/** The reconciliation policy itself failed (supplier unreachable, corrupt lookup, ...). The
+* caller treats this as no proof: the call stays open and the pass may retry. */
+var ToolReconcilerError = class extends Schema.TaggedError()("ToolReconcilerError", {
+	toolCallId: ToolCallId,
+	message: Schema.String,
+	cause: Schema.optionalKey(Schema.Defect())
+}) {};
+/**
+* Application-registered reconciliation policy consulted by recovery for every open ordinary
+* Tool Call before an Unknown Outcome is recorded (durability §10, DUR-009). A decision is a
+* claim about EXTERNAL truth — typically an idempotency-keyed supplier lookup — never a guess
+* from canonical state alone.
+*
+* `ToolReconciler.uncertain` is the fail-closed default (AGENTS rule 11): with no registered
+* policy, every open call stays Unknown and routes to the authorized DUR-017 resolution path.
+*/
+var ToolReconciler = class extends Context.Service()("@effect-agent/thread/ToolReconciler") {
+	/** Fail-closed default: no proof is ever asserted, every open call stays Unknown. */
+	static uncertain = Layer.succeed(this)({ reconcile: () => Effect.succeed(ReconciliationUncertain.make({ reason: "No reconciliation policy is registered; the outcome stays unknown" })) });
+};
+//#endregion
+export { PreparedToolCallEvidence, ReconciliationCompleted, ReconciliationDecision, ReconciliationNeverStarted, ReconciliationSafeToRetry, ReconciliationUncertain, ToolReconciler, ToolReconcilerError, ToolReconciler_exports as t };
+
+//# sourceMappingURL=ToolReconciler.mjs.map

package/dist/durable/ToolReconciler.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ToolReconciler.mjs","names":[],"sources":["../../src/durable/ToolReconciler.ts"],"sourcesContent":["import { Context, Effect, Layer, Schema } from \"effect\";\n\nimport { ThreadId, RunId, SubmissionId, ToolCallId } from \"../core/Identifiers.ts\";\nimport { Digest, PersistedJson, ToolCallPrepared } from \"./Records.ts\";\n\n/**\n * Everything a reconciliation policy can consult about one prepared-but-unsettled ordinary Tool\n * Call (durability §10): deterministic identities for supplier-side lookup plus the exact\n * Schema-encoded parameters and their digest. Built from the canonical `ToolCallPrepared` record\n * and the owning Submission's identities — never from in-memory Attempt state.\n */\nexport class PreparedToolCallEvidence extends Schema.Class<PreparedToolCallEvidence>(\n  \"@effect-agent/thread/PreparedToolCallEvidence\",\n)({\n  threadId: ThreadId,\n  submissionId: SubmissionId,\n  runId: RunId,\n  turn: ToolCallPrepared.fields.turn,\n  toolCallId: ToolCallId,\n  toolName: ToolCallPrepared.fields.toolName,\n  parameters: PersistedJson,\n  parametersDigest: Digest,\n}) {}\n\n/** Proof that the external execution never started: the call may re-execute on resume. */\nexport class ReconciliationNeverStarted extends Schema.TaggedClass<ReconciliationNeverStarted>(\n  \"@effect-agent/thread/ReconciliationNeverStarted\",\n)(\"NeverStarted\", {}) {}\n\n/**\n * Proof that the external execution completed: `result` is the recovered supplier truth, which\n * becomes canonical (`ToolCallSettled` + `ToolCallResolved`) WITHOUT executing anything.\n */\nexport class ReconciliationCompleted extends Schema.TaggedClass<ReconciliationCompleted>(\n  \"@effect-agent/thread/ReconciliationCompleted\",\n)(\"CompletedWithResult\", {\n  result: PersistedJson,\n  isFailure: Schema.Boolean,\n}) {}\n\n/** The call is safe to repeat under a stable external idempotency contract. */\nexport class ReconciliationSafeToRetry extends Schema.TaggedClass<ReconciliationSafeToRetry>(\n  \"@effect-agent/thread/ReconciliationSafeToRetry\",\n)(\"SafeToRetry\", {}) {}\n\n/** No proof either way: the outcome is Unknown and requires authorized resolution (DUR-017). */\nexport class ReconciliationUncertain extends Schema.TaggedClass<ReconciliationUncertain>(\n  \"@effect-agent/thread/ReconciliationUncertain\",\n)(\"Uncertain\", {\n  reason: Schema.String,\n}) {}\n\n/**\n * What a reconciliation policy can prove about one prepared-but-unsettled ordinary Tool Call\n * (durability §10): execution never started, execution completed with a recoverable result,\n * execution is safe to repeat, or nothing — in which case the Run enters Unknown. The engine\n * never manufactures an error result and continues.\n */\nexport const ReconciliationDecision = Schema.Union([\n  ReconciliationNeverStarted,\n  ReconciliationCompleted,\n  ReconciliationSafeToRetry,\n  ReconciliationUncertain,\n]);\n\nexport type ReconciliationDecision = typeof ReconciliationDecision.Type;\n\n/** The reconciliation policy itself failed (supplier unreachable, corrupt lookup, ...). The\n * caller treats this as no proof: the call stays open and the pass may retry. */\nexport class ToolReconcilerError extends Schema.TaggedError<ToolReconcilerError>()(\n  \"ToolReconcilerError\",\n  {\n    toolCallId: ToolCallId,\n    message: Schema.String,\n    cause: Schema.optionalKey(Schema.Defect()),\n  },\n) {}\n\n/**\n * Application-registered reconciliation policy consulted by recovery for every open ordinary\n * Tool Call before an Unknown Outcome is recorded (durability §10, DUR-009). A decision is a\n * claim about EXTERNAL truth — typically an idempotency-keyed supplier lookup — never a guess\n * from canonical state alone.\n *\n * `ToolReconciler.uncertain` is the fail-closed default (AGENTS rule 11): with no registered\n * policy, every open call stays Unknown and routes to the authorized DUR-017 resolution path.\n */\nexport class ToolReconciler extends Context.Service<\n  ToolReconciler,\n  {\n    readonly reconcile: (\n      evidence: PreparedToolCallEvidence,\n    ) => Effect.Effect<ReconciliationDecision, ToolReconcilerError>;\n  }\n>()(\"@effect-agent/thread/ToolReconciler\") {\n  /** Fail-closed default: no proof is ever asserted, every open call stays Unknown. */\n  static readonly uncertain: Layer.Layer<ToolReconciler> = Layer.succeed(this)({\n    reconcile: () =>\n      Effect.succeed(\n        ReconciliationUncertain.make({\n          reason: \"No reconciliation policy is registered; the outcome stays unknown\",\n        }),\n      ),\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAWA,IAAa,2BAAb,cAA8C,OAAO,MACnD,+CACF,CAAC,CAAC;CACA,UAAU;CACV,cAAc;CACd,OAAO;CACP,MAAM,iBAAiB,OAAO;CAC9B,YAAY;CACZ,UAAU,iBAAiB,OAAO;CAClC,YAAY;CACZ,kBAAkB;AACpB,CAAC,CAAC,CAAC,CAAC;;AAGJ,IAAa,6BAAb,cAAgD,OAAO,YACrD,iDACF,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC;;;;;AAMvB,IAAa,0BAAb,cAA6C,OAAO,YAClD,8CACF,CAAC,CAAC,uBAAuB;CACvB,QAAQ;CACR,WAAW,OAAO;AACpB,CAAC,CAAC,CAAC,CAAC;;AAGJ,IAAa,4BAAb,cAA+C,OAAO,YACpD,gDACF,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC;;AAGtB,IAAa,0BAAb,cAA6C,OAAO,YAClD,8CACF,CAAC,CAAC,aAAa,EACb,QAAQ,OAAO,OACjB,CAAC,CAAC,CAAC,CAAC;;;;;;;AAQJ,MAAa,yBAAyB,OAAO,MAAM;CACjD;CACA;CACA;CACA;AACF,CAAC;;;AAMD,IAAa,sBAAb,cAAyC,OAAO,YAAiC,CAAC,CAChF,uBACA;CACE,YAAY;CACZ,SAAS,OAAO;CAChB,OAAO,OAAO,YAAY,OAAO,OAAO,CAAC;AAC3C,CACF,CAAC,CAAC,CAAC;;;;;;;;;;AAWH,IAAa,iBAAb,cAAoC,QAAQ,QAO1C,CAAC,CAAC,qCAAqC,CAAC,CAAC;;CAEzC,OAAgB,YAAyC,MAAM,QAAQ,IAAI,CAAC,CAAC,EAC3E,iBACE,OAAO,QACL,wBAAwB,KAAK,EAC3B,QAAQ,oEACV,CAAC,CACH,EACJ,CAAC;AACH"}

package/dist/durable/WakeScheduler.d.mts

@@ -0,0 +1,2 @@
+import { i as makeWakeSubscriptionHub, r as WakeSubscriptionHub, t as WakeScheduler } from "../WakeScheduler-EjUF-GhC.mjs";
+export { WakeScheduler, WakeSubscriptionHub, makeWakeSubscriptionHub };

package/dist/durable/WakeScheduler.mjs

@@ -0,0 +1,85 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
+import { Context, Deferred, Effect, Layer, Ref, Stream } from "effect";
+//#region src/durable/WakeScheduler.ts
+var WakeScheduler_exports = /* @__PURE__ */ __exportAll({
+	WakeScheduler: () => WakeScheduler,
+	makeWakeSubscriptionHub: () => makeWakeSubscriptionHub
+});
+/**
+* Build the shared per-incarnation registration primitive used by host WakeSchedulers. The hub
+* contains hints only: eviction may discard it, while a reconnecting caller re-subscribes and
+* rechecks canonical storage. Scope finalizers remove cancelled waiters, and notify broadcasts
+* instead of consuming a signal that belongs to another waiter.
+*/
+const makeWakeSubscriptionHub = Effect.gen(function* () {
+	const registrations = yield* Ref.make(/* @__PURE__ */ new Map());
+	const nextId = yield* Ref.make(0);
+	const remove = (threadId, id) => Ref.update(registrations, (current) => {
+		const existing = current.get(threadId);
+		if (existing === void 0 || !existing.has(id)) return current;
+		const next = new Map(current);
+		const thread = new Map(existing);
+		thread.delete(id);
+		if (thread.size === 0) next.delete(threadId);
+		else next.set(threadId, thread);
+		return next;
+	});
+	return {
+		subscribe: Effect.fn("WakeSubscriptionHub.subscribe")((threadId) => Effect.gen(function* () {
+			const deferred = yield* Deferred.make();
+			const registration = {
+				id: yield* Ref.getAndUpdate(nextId, (current) => current + 1),
+				deferred
+			};
+			yield* Effect.addFinalizer(() => remove(threadId, registration.id));
+			yield* Ref.update(registrations, (current) => {
+				const next = new Map(current);
+				const thread = new Map(current.get(threadId) ?? []);
+				thread.set(registration.id, registration.deferred);
+				next.set(threadId, thread);
+				return next;
+			});
+			return registration.deferred;
+		}).pipe(Effect.map((deferred) => Deferred.await(deferred)))),
+		notify: Effect.fn("WakeSubscriptionHub.notify")(function* (threadId) {
+			const waiters = yield* Ref.modify(registrations, (current) => {
+				const thread = current.get(threadId);
+				if (thread === void 0) return [[], current];
+				const next = new Map(current);
+				next.delete(threadId);
+				return [[...thread.values()], next];
+			});
+			yield* Effect.forEach(waiters, (waiter) => Deferred.succeed(waiter, void 0), { discard: true });
+		})
+	};
+});
+/**
+* Liveness hint channel for durable schedulers. `notify` announces that a Thread lane may
+* have claimable, canonical, or settled work; `wakes` is the all-lanes subscription surface for
+* workers, while `subscribe` installs an efficient one-Thread wait registration.
+*
+* Correctness must NEVER depend on delivery: notifications may be dropped, coalesced, duplicated,
+* or observed by no subscriber (a notify before any subscription is simply lost). Every consumer
+* must pair a wake with durable authority: workers use periodic SubmissionLedger scans, while a
+* public progress waiter subscribes before its canonical read and reconnects/rechecks after an
+* incarnation loss (persistence §14).
+*
+* Each run of `wakes` creates its own subscription whose resources live in that run's Scope and
+* are released when the consuming stream ends or is interrupted. Implementations must not spawn
+* daemon fibers.
+*/
+var WakeScheduler = class WakeScheduler extends Context.Service()("@effect-agent/thread/WakeScheduler") {
+	/**
+	* Discards every notification and never wakes anyone. Valid because WakeScheduler is only a
+	* liveness hint: consumers relying on ledger scans stay correct, merely slower.
+	*/
+	static layerNoop = Layer.succeed(WakeScheduler, {
+		notify: () => Effect.void,
+		subscribe: () => Effect.succeed(Effect.never),
+		wakes: Stream.never
+	});
+};
+//#endregion
+export { WakeScheduler, makeWakeSubscriptionHub, WakeScheduler_exports as t };
+
+//# sourceMappingURL=WakeScheduler.mjs.map

package/dist/durable/WakeScheduler.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"WakeScheduler.mjs","names":[],"sources":["../../src/durable/WakeScheduler.ts"],"sourcesContent":["import type { Scope } from \"effect\";\nimport { Context, Deferred, Effect, Layer, Ref, Stream } from \"effect\";\n\nimport { type ThreadId } from \"../core/Identifiers.ts\";\n\n/**\n * Incarnation-local, thread-keyed wake registrations. A registration is installed before\n * its returned Effect can be awaited, which lets a caller subscribe, check durable authority,\n * and then park without a lost-wakeup window.\n */\nexport interface WakeSubscriptionHub {\n  /** Register one Scope-owned waiter and return its one-shot wake Effect. */\n  readonly subscribe: (\n    threadId: ThreadId,\n  ) => Effect.Effect<Effect.Effect<void>, never, Scope.Scope>;\n  /** Wake every currently registered waiter for exactly this Thread. */\n  readonly notify: (threadId: ThreadId) => Effect.Effect<void>;\n}\n\ninterface WakeRegistration {\n  readonly id: number;\n  readonly deferred: Deferred.Deferred<void>;\n}\n\ntype WakeRegistrations = ReadonlyMap<ThreadId, ReadonlyMap<number, Deferred.Deferred<void>>>;\n\n/**\n * Build the shared per-incarnation registration primitive used by host WakeSchedulers. The hub\n * contains hints only: eviction may discard it, while a reconnecting caller re-subscribes and\n * rechecks canonical storage. Scope finalizers remove cancelled waiters, and notify broadcasts\n * instead of consuming a signal that belongs to another waiter.\n */\nexport const makeWakeSubscriptionHub: Effect.Effect<WakeSubscriptionHub> = Effect.gen(function* () {\n  const registrations = yield* Ref.make<WakeRegistrations>(new Map());\n  const nextId = yield* Ref.make(0);\n\n  const remove = (threadId: ThreadId, id: number) =>\n    Ref.update(registrations, (current) => {\n      const existing = current.get(threadId);\n\n      if (existing === undefined || !existing.has(id)) return current;\n      const next = new Map(current);\n      const thread = new Map(existing);\n\n      thread.delete(id);\n      if (thread.size === 0) {\n        next.delete(threadId);\n      } else {\n        next.set(threadId, thread);\n      }\n\n      return next;\n    });\n\n  const subscribe = Effect.fn(\"WakeSubscriptionHub.subscribe\")(\n    (threadId: ThreadId): Effect.Effect<Effect.Effect<void>, never, Scope.Scope> =>\n      Effect.gen(function* () {\n        const deferred = yield* Deferred.make<void>();\n        const id = yield* Ref.getAndUpdate(nextId, (current) => current + 1);\n        const registration: WakeRegistration = { id, deferred };\n\n        yield* Effect.addFinalizer(() => remove(threadId, registration.id));\n        yield* Ref.update(registrations, (current) => {\n          const next = new Map(current);\n          const thread = new Map(current.get(threadId) ?? []);\n\n          thread.set(registration.id, registration.deferred);\n          next.set(threadId, thread);\n\n          return next;\n        });\n\n        return registration.deferred;\n      }).pipe(Effect.map((deferred) => Deferred.await(deferred))),\n  );\n\n  const notify = Effect.fn(\"WakeSubscriptionHub.notify\")(function* (threadId: ThreadId) {\n    const waiters = yield* Ref.modify(registrations, (current) => {\n      const thread = current.get(threadId);\n\n      if (thread === undefined) return [[], current] as const;\n      const next = new Map(current);\n\n      next.delete(threadId);\n\n      return [[...thread.values()], next] as const;\n    });\n\n    yield* Effect.forEach(waiters, (waiter) => Deferred.succeed(waiter, undefined), {\n      discard: true,\n    });\n  });\n\n  return { subscribe, notify };\n});\n\n/**\n * Liveness hint channel for durable schedulers. `notify` announces that a Thread lane may\n * have claimable, canonical, or settled work; `wakes` is the all-lanes subscription surface for\n * workers, while `subscribe` installs an efficient one-Thread wait registration.\n *\n * Correctness must NEVER depend on delivery: notifications may be dropped, coalesced, duplicated,\n * or observed by no subscriber (a notify before any subscription is simply lost). Every consumer\n * must pair a wake with durable authority: workers use periodic SubmissionLedger scans, while a\n * public progress waiter subscribes before its canonical read and reconnects/rechecks after an\n * incarnation loss (persistence §14).\n *\n * Each run of `wakes` creates its own subscription whose resources live in that run's Scope and\n * are released when the consuming stream ends or is interrupted. Implementations must not spawn\n * daemon fibers.\n */\nexport class WakeScheduler extends Context.Service<\n  WakeScheduler,\n  {\n    /** Best-effort hint that `threadId` may have claimable or settled work. Never fails. */\n    readonly notify: (threadId: ThreadId) => Effect.Effect<void>;\n    /** Scope-owned one-shot registration for exactly one Thread. */\n    readonly subscribe: (\n      threadId: ThreadId,\n    ) => Effect.Effect<Effect.Effect<void>, never, Scope.Scope>;\n    /** Scope-owned subscription to wake hints, starting at subscription time. */\n    readonly wakes: Stream.Stream<ThreadId>;\n  }\n>()(\"@effect-agent/thread/WakeScheduler\") {\n  /**\n   * Discards every notification and never wakes anyone. Valid because WakeScheduler is only a\n   * liveness hint: consumers relying on ledger scans stay correct, merely slower.\n   */\n  static readonly layerNoop: Layer.Layer<WakeScheduler> = Layer.succeed(WakeScheduler, {\n    notify: () => Effect.void,\n    subscribe: () => Effect.succeed(Effect.never),\n    wakes: Stream.never,\n  });\n}\n"],"mappings":";;;;;;;;;;;;;AAgCA,MAAa,0BAA8D,OAAO,IAAI,aAAa;CACjG,MAAM,gBAAgB,OAAO,IAAI,qBAAwB,IAAI,IAAI,CAAC;CAClE,MAAM,SAAS,OAAO,IAAI,KAAK,CAAC;CAEhC,MAAM,UAAU,UAAoB,OAClC,IAAI,OAAO,gBAAgB,YAAY;EACrC,MAAM,WAAW,QAAQ,IAAI,QAAQ;EAErC,IAAI,aAAa,KAAA,KAAa,CAAC,SAAS,IAAI,EAAE,GAAG,OAAO;EACxD,MAAM,OAAO,IAAI,IAAI,OAAO;EAC5B,MAAM,SAAS,IAAI,IAAI,QAAQ;EAE/B,OAAO,OAAO,EAAE;EAChB,IAAI,OAAO,SAAS,GAClB,KAAK,OAAO,QAAQ;OAEpB,KAAK,IAAI,UAAU,MAAM;EAG3B,OAAO;CACT,CAAC;CAyCH,OAAO;EAAE,WAvCS,OAAO,GAAG,+BAA+B,CAAC,EACzD,aACC,OAAO,IAAI,aAAa;GACtB,MAAM,WAAW,OAAO,SAAS,KAAW;GAE5C,MAAM,eAAiC;IAAE,IAAA,OADvB,IAAI,aAAa,SAAS,YAAY,UAAU,CAAC;IACtB;GAAS;GAEtD,OAAO,OAAO,mBAAmB,OAAO,UAAU,aAAa,EAAE,CAAC;GAClE,OAAO,IAAI,OAAO,gBAAgB,YAAY;IAC5C,MAAM,OAAO,IAAI,IAAI,OAAO;IAC5B,MAAM,SAAS,IAAI,IAAI,QAAQ,IAAI,QAAQ,KAAK,CAAC,CAAC;IAElD,OAAO,IAAI,aAAa,IAAI,aAAa,QAAQ;IACjD,KAAK,IAAI,UAAU,MAAM;IAEzB,OAAO;GACT,CAAC;GAED,OAAO,aAAa;EACtB,CAAC,CAAC,CAAC,KAAK,OAAO,KAAK,aAAa,SAAS,MAAM,QAAQ,CAAC,CAAC,CAoB7C;EAAG,QAjBL,OAAO,GAAG,4BAA4B,CAAC,CAAC,WAAW,UAAoB;GACpF,MAAM,UAAU,OAAO,IAAI,OAAO,gBAAgB,YAAY;IAC5D,MAAM,SAAS,QAAQ,IAAI,QAAQ;IAEnC,IAAI,WAAW,KAAA,GAAW,OAAO,CAAC,CAAC,GAAG,OAAO;IAC7C,MAAM,OAAO,IAAI,IAAI,OAAO;IAE5B,KAAK,OAAO,QAAQ;IAEpB,OAAO,CAAC,CAAC,GAAG,OAAO,OAAO,CAAC,GAAG,IAAI;GACpC,CAAC;GAED,OAAO,OAAO,QAAQ,UAAU,WAAW,SAAS,QAAQ,QAAQ,KAAA,CAAS,GAAG,EAC9E,SAAS,KACX,CAAC;EACH,CAEyB;CAAE;AAC7B,CAAC;;;;;;;;;;;;;;;;AAiBD,IAAa,gBAAb,MAAa,sBAAsB,QAAQ,QAYzC,CAAC,CAAC,oCAAoC,CAAC,CAAC;;;;;CAKxC,OAAgB,YAAwC,MAAM,QAAQ,eAAe;EACnF,cAAc,OAAO;EACrB,iBAAiB,OAAO,QAAQ,OAAO,KAAK;EAC5C,OAAO,OAAO;CAChB,CAAC;AACH"}

package/dist/durable/WorkerHost.d.mts

@@ -0,0 +1,129 @@
+import { l as SubmissionId, u as ThreadId } from "../Identifiers-CN2s30fF.mjs";
+import { i as SubagentBudgetReservation } from "../SubagentContract-DdT7Cqe6.mjs";
+import { r as Principal } from "../Receipt-BAHyigAF.mjs";
+import { t as AgentPolicy } from "../AgentPolicy-CetmQrf3.mjs";
+import { r as AnyDefinition } from "../Agent-CN0EWRsR.mjs";
+import { a as WorkerError, c as WorkerRef, u as WorkerSource } from "../Worker-CaPYykpe.mjs";
+import { O as PersistedJson, _ as Digest, h as DefinitionDigests, qa as SubmissionSnapshot, st as WorkerOrigin } from "../Records-BAGkekt8.mjs";
+import { Context, Effect, Option, Schema } from "effect";
+declare namespace WorkerHost_d_exports {
+  export { WorkerBudgetAuthorizer, WorkerConcurrencyLimit, WorkerConcurrencyResolver, WorkerHostAuthorizationRequest, WorkerHostAuthorizer, WorkerHostConfig, WorkerHostLimits, WorkerPolicyResolver, WorkerPolicySource, WorkerPolicyTarget };
+}
+/** Host-verified source input; absence never means the latest input in the Thread. */
+interface WorkerPolicySource {
+  readonly threadId: ThreadId;
+  readonly definition: AnyDefinition;
+  readonly definitions: DefinitionDigests;
+  readonly submission?: SubmissionSnapshot;
+}
+/** Initial input is validated again at destination admission, including idempotent replay. */
+type WorkerPolicyTarget = {
+  readonly definition: AnyDefinition;
+  readonly definitions: DefinitionDigests;
+  readonly source: WorkerSource;
+} & ({
+  readonly _tag: "InitialInput";
+  readonly sourceSubmission?: SubmissionSnapshot;
+  readonly input: PersistedJson;
+  readonly inputDigest: Digest;
+} | {
+  readonly _tag: "RetainedWorker";
+  /** Verified against canonical source history before this request reaches the resolver. */
+  readonly origin: WorkerOrigin;
+});
+/**
+ * Opt-in host authority for policies captured in immutable application input. None preserves
+ * the registered Definition's existing policy/override semantics. Some is a complete policy,
+ * never merged with static overrides. Decode and authorize the exact captured revision; do not
+ * read mutable settings or substitute a current capture for missing historical authority.
+ * RetainedWorker may affirm only origin.policy, never replace a continuing worker's allowance.
+ * Return WorkerError(unavailable) for temporarily unavailable authority so delivery can retry.
+ * Implementations are acquired through Effect Layers; capture their dependencies in Layer R.
+ */
+declare const WorkerPolicyResolver: Context.Reference<{
+  readonly resolveSource: (request: WorkerPolicySource) => Effect.Effect<Option.Option<AgentPolicy>, WorkerError>;
+  readonly resolveTarget: (request: WorkerPolicyTarget) => Effect.Effect<Option.Option<AgentPolicy>, WorkerError>;
+}>;
+/** A host-authorized ceiling on active background workers, not retained workers or Run usage. */
+declare const WorkerConcurrencyLimit: Schema.Struct<{
+  readonly maxActiveWorkersPerSource: Schema.Int;
+}>;
+type WorkerConcurrencyLimit = typeof WorkerConcurrencyLimit.Type;
+/**
+ * Optional source-aware operational authority. Resolution occurs inside every new source
+ * reservation attempt, against the same canonical history used for the append CAS. None
+ * preserves WorkerHostConfig; Some can only narrow it. The selected submission is exact,
+ * never the latest input. Implementations must authorize that immutable capture and retain
+ * construction dependencies in Layer R. Unavailable authority must return WorkerError(unavailable).
+ *
+ * One worker occupies a slot while any of its inputs remain unacknowledged. Steering an active
+ * worker does not acquire another slot. Decreases (including zero) do not cancel incumbents;
+ * an idle worker needs a slot again. Idempotent retained reservations do not reacquire slots.
+ */
+declare const WorkerConcurrencyResolver: Context.Reference<{
+  readonly resolve: (request: {
+    readonly source: WorkerSource;
+    readonly sourceSubmission?: SubmissionSnapshot;
+    readonly worker: WorkerRef;
+    readonly principal: Principal;
+  }) => Effect.Effect<Option.Option<WorkerConcurrencyLimit>, WorkerError>;
+}>;
+/** Host ceilings apply across all declarations owned by one source Thread. */
+declare const WorkerHostLimits: Schema.Struct<{
+  readonly maxWorkersPerSource: Schema.Int;
+  /** Active background workers across declarations; omission retains source Tool concurrency. */
+  readonly maxActiveWorkersPerSource: Schema.optionalKey<Schema.Int>;
+  readonly maxInputsPerWorker: Schema.Int;
+  readonly maxPendingInputsPerWorker: Schema.Int;
+  readonly maxUpdateInputsPerWorker: Schema.optionalKey<Schema.Int>;
+  readonly maxPendingUpdateInputsPerWorker: Schema.optionalKey<Schema.Int>;
+  readonly lifetimeMillis: Schema.Int;
+  /** Preparation may repeat after loss before its decision commits; keep callbacks side-effect free. */
+  readonly reportPreparationTimeoutMillis: Schema.optionalKey<Schema.Int>;
+}>;
+type WorkerHostLimits = typeof WorkerHostLimits.Type;
+declare const WorkerHostConfig: Context.Reference<{
+  readonly maxWorkersPerSource: number;
+  readonly maxActiveWorkersPerSource?: number | undefined;
+  readonly maxInputsPerWorker: number;
+  readonly maxPendingInputsPerWorker: number;
+  readonly maxUpdateInputsPerWorker?: number | undefined;
+  readonly maxPendingUpdateInputsPerWorker?: number | undefined;
+  readonly lifetimeMillis: number;
+  readonly reportPreparationTimeoutMillis?: number | undefined;
+}>;
+/**
+ * Authenticate every acquisition/operation and authorize its exact source Thread. A returned
+ * Principal is host-owned admission identity. Context access authenticates source metadata;
+ * read, send and control remain separate grants. WorkerRefs and caller-supplied Thread
+ * identifiers alone never confer any of them.
+ */
+interface WorkerHostAuthorizationRequest {
+  readonly sourceThreadId: ThreadId;
+  /** An explicitly selected owner input; authorize this locator as well as the Thread. */
+  readonly sourceSubmissionId?: SubmissionId;
+  readonly principal: Principal;
+  readonly operation: WorkerError["operation"];
+  readonly access: "context" | "read" | "send" | "control";
+  readonly worker?: WorkerRef;
+}
+declare const WorkerHostAuthorizer: Context.Reference<{
+  readonly authorize: (request: WorkerHostAuthorizationRequest) => Effect.Effect<Principal, WorkerError>;
+}>;
+/**
+ * Deployment-owned permission to fund a root's background worker independently. The decision
+ * covers the exact immutable origin and is checked again before each input admission. It never
+ * changes delegation depth or Tool authority. Omission denies independent funding.
+ */
+declare const WorkerBudgetAuthorizer: Context.Reference<{
+  readonly authorize: (request: {
+    readonly source: WorkerSource;
+    readonly principal: Principal;
+    readonly worker: WorkerRef;
+    readonly policy: AgentPolicy;
+    readonly budget: SubagentBudgetReservation;
+  }) => Effect.Effect<void, WorkerError>;
+}>;
+//#endregion
+export { WorkerBudgetAuthorizer, WorkerConcurrencyLimit, WorkerConcurrencyResolver, WorkerHostAuthorizationRequest, WorkerHostAuthorizer, WorkerHostConfig, WorkerHostLimits, WorkerPolicyResolver, WorkerPolicySource, WorkerPolicyTarget, WorkerHost_d_exports as t };
+//# sourceMappingURL=WorkerHost.d.mts.map

package/dist/durable/WorkerHost.mjs

@@ -0,0 +1,77 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
+import { WorkerError } from "../core/Worker.mjs";
+import { Context, Effect, Option, Schema } from "effect";
+//#region src/durable/WorkerHost.ts
+var WorkerHost_exports = /* @__PURE__ */ __exportAll({
+	WorkerBudgetAuthorizer: () => WorkerBudgetAuthorizer,
+	WorkerConcurrencyLimit: () => WorkerConcurrencyLimit,
+	WorkerConcurrencyResolver: () => WorkerConcurrencyResolver,
+	WorkerHostAuthorizer: () => WorkerHostAuthorizer,
+	WorkerHostConfig: () => WorkerHostConfig,
+	WorkerHostLimits: () => WorkerHostLimits,
+	WorkerPolicyResolver: () => WorkerPolicyResolver
+});
+/**
+* Opt-in host authority for policies captured in immutable application input. None preserves
+* the registered Definition's existing policy/override semantics. Some is a complete policy,
+* never merged with static overrides. Decode and authorize the exact captured revision; do not
+* read mutable settings or substitute a current capture for missing historical authority.
+* RetainedWorker may affirm only origin.policy, never replace a continuing worker's allowance.
+* Return WorkerError(unavailable) for temporarily unavailable authority so delivery can retry.
+* Implementations are acquired through Effect Layers; capture their dependencies in Layer R.
+*/
+const WorkerPolicyResolver = Context.Reference("@effect-agent/thread/WorkerPolicyResolver", { defaultValue: () => ({
+	resolveSource: () => Effect.succeed(Option.none()),
+	resolveTarget: () => Effect.succeed(Option.none())
+}) });
+const Positive = Schema.Int.check(Schema.isGreaterThan(0));
+/** A host-authorized ceiling on active background workers, not retained workers or Run usage. */
+const WorkerConcurrencyLimit = Schema.Struct({ maxActiveWorkersPerSource: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)) });
+/**
+* Optional source-aware operational authority. Resolution occurs inside every new source
+* reservation attempt, against the same canonical history used for the append CAS. None
+* preserves WorkerHostConfig; Some can only narrow it. The selected submission is exact,
+* never the latest input. Implementations must authorize that immutable capture and retain
+* construction dependencies in Layer R. Unavailable authority must return WorkerError(unavailable).
+*
+* One worker occupies a slot while any of its inputs remain unacknowledged. Steering an active
+* worker does not acquire another slot. Decreases (including zero) do not cancel incumbents;
+* an idle worker needs a slot again. Idempotent retained reservations do not reacquire slots.
+*/
+const WorkerConcurrencyResolver = Context.Reference("@effect-agent/thread/WorkerConcurrencyResolver", { defaultValue: () => ({ resolve: () => Effect.succeed(Option.none()) }) });
+/** Host ceilings apply across all declarations owned by one source Thread. */
+const WorkerHostLimits = Schema.Struct({
+	maxWorkersPerSource: Positive.check(Schema.isLessThanOrEqualTo(100)),
+	/** Active background workers across declarations; omission retains source Tool concurrency. */
+	maxActiveWorkersPerSource: Schema.optionalKey(Positive.check(Schema.isLessThanOrEqualTo(100))),
+	maxInputsPerWorker: Positive.check(Schema.isLessThanOrEqualTo(1e3)),
+	maxPendingInputsPerWorker: Positive.check(Schema.isLessThanOrEqualTo(100)),
+	maxUpdateInputsPerWorker: Schema.optionalKey(Positive.check(Schema.isLessThanOrEqualTo(1e3))),
+	maxPendingUpdateInputsPerWorker: Schema.optionalKey(Positive.check(Schema.isLessThanOrEqualTo(100))),
+	lifetimeMillis: Positive.check(Schema.isLessThanOrEqualTo(6048e5)),
+	/** Preparation may repeat after loss before its decision commits; keep callbacks side-effect free. */
+	reportPreparationTimeoutMillis: Schema.optionalKey(Positive.check(Schema.isLessThanOrEqualTo(3e4)))
+});
+const WorkerHostConfig = Context.Reference("@effect-agent/thread/WorkerHostConfig", { defaultValue: () => ({
+	maxWorkersPerSource: 32,
+	maxInputsPerWorker: 64,
+	maxPendingInputsPerWorker: 8,
+	lifetimeMillis: 864e5
+}) });
+const WorkerHostAuthorizer = Context.Reference("@effect-agent/thread/WorkerHostAuthorizer", { defaultValue: () => ({ authorize: (request) => WorkerError.make({
+	operation: request.operation,
+	reason: "denied"
+}) }) });
+/**
+* Deployment-owned permission to fund a root's background worker independently. The decision
+* covers the exact immutable origin and is checked again before each input admission. It never
+* changes delegation depth or Tool authority. Omission denies independent funding.
+*/
+const WorkerBudgetAuthorizer = Context.Reference("@effect-agent/thread/WorkerBudgetAuthorizer", { defaultValue: () => ({ authorize: () => WorkerError.make({
+	operation: "start",
+	reason: "denied"
+}) }) });
+//#endregion
+export { WorkerBudgetAuthorizer, WorkerConcurrencyLimit, WorkerConcurrencyResolver, WorkerHostAuthorizer, WorkerHostConfig, WorkerHostLimits, WorkerPolicyResolver, WorkerHost_exports as t };
+
+//# sourceMappingURL=WorkerHost.mjs.map

package/dist/durable/WorkerHost.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"WorkerHost.mjs","names":[],"sources":["../../src/durable/WorkerHost.ts"],"sourcesContent":["import { Context, Effect, Option, Schema } from \"effect\";\n\nimport type * as Agent from \"../core/Agent.ts\";\nimport type { AgentPolicy } from \"../core/AgentPolicy.ts\";\nimport type { SubmissionId, ThreadId } from \"../core/Identifiers.ts\";\nimport type { SubagentBudgetReservation } from \"../core/SubagentContract.ts\";\nimport { WorkerError, type WorkerRef, type WorkerSource } from \"../core/Worker.ts\";\nimport type { DefinitionDigests, Digest, PersistedJson, WorkerOrigin } from \"./Records.ts\";\nimport type { Principal, SubmissionSnapshot } from \"./SubmissionLedger.ts\";\n\n/** Host-verified source input; absence never means the latest input in the Thread. */\nexport interface WorkerPolicySource {\n  readonly threadId: ThreadId;\n  readonly definition: Agent.AnyDefinition;\n  readonly definitions: DefinitionDigests;\n  readonly submission?: SubmissionSnapshot;\n}\n\n/** Initial input is validated again at destination admission, including idempotent replay. */\nexport type WorkerPolicyTarget = {\n  readonly definition: Agent.AnyDefinition;\n  readonly definitions: DefinitionDigests;\n  readonly source: WorkerSource;\n} & (\n  | {\n      readonly _tag: \"InitialInput\";\n      readonly sourceSubmission?: SubmissionSnapshot;\n      readonly input: PersistedJson;\n      readonly inputDigest: Digest;\n    }\n  | {\n      readonly _tag: \"RetainedWorker\";\n      /** Verified against canonical source history before this request reaches the resolver. */\n      readonly origin: WorkerOrigin;\n    }\n);\n\n/**\n * Opt-in host authority for policies captured in immutable application input. None preserves\n * the registered Definition's existing policy/override semantics. Some is a complete policy,\n * never merged with static overrides. Decode and authorize the exact captured revision; do not\n * read mutable settings or substitute a current capture for missing historical authority.\n * RetainedWorker may affirm only origin.policy, never replace a continuing worker's allowance.\n * Return WorkerError(unavailable) for temporarily unavailable authority so delivery can retry.\n * Implementations are acquired through Effect Layers; capture their dependencies in Layer R.\n */\nexport const WorkerPolicyResolver = Context.Reference<{\n  readonly resolveSource: (\n    request: WorkerPolicySource,\n  ) => Effect.Effect<Option.Option<AgentPolicy>, WorkerError>;\n  readonly resolveTarget: (\n    request: WorkerPolicyTarget,\n  ) => Effect.Effect<Option.Option<AgentPolicy>, WorkerError>;\n}>(\"@effect-agent/thread/WorkerPolicyResolver\", {\n  defaultValue: () => ({\n    resolveSource: () => Effect.succeed(Option.none()),\n    resolveTarget: () => Effect.succeed(Option.none()),\n  }),\n});\n\nconst Positive = Schema.Int.check(Schema.isGreaterThan(0));\n\n/** A host-authorized ceiling on active background workers, not retained workers or Run usage. */\nexport const WorkerConcurrencyLimit = Schema.Struct({\n  maxActiveWorkersPerSource: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),\n});\n\nexport type WorkerConcurrencyLimit = typeof WorkerConcurrencyLimit.Type;\n\n/**\n * Optional source-aware operational authority. Resolution occurs inside every new source\n * reservation attempt, against the same canonical history used for the append CAS. None\n * preserves WorkerHostConfig; Some can only narrow it. The selected submission is exact,\n * never the latest input. Implementations must authorize that immutable capture and retain\n * construction dependencies in Layer R. Unavailable authority must return WorkerError(unavailable).\n *\n * One worker occupies a slot while any of its inputs remain unacknowledged. Steering an active\n * worker does not acquire another slot. Decreases (including zero) do not cancel incumbents;\n * an idle worker needs a slot again. Idempotent retained reservations do not reacquire slots.\n */\nexport const WorkerConcurrencyResolver = Context.Reference<{\n  readonly resolve: (request: {\n    readonly source: WorkerSource;\n    readonly sourceSubmission?: SubmissionSnapshot;\n    readonly worker: WorkerRef;\n    readonly principal: Principal;\n  }) => Effect.Effect<Option.Option<WorkerConcurrencyLimit>, WorkerError>;\n}>(\"@effect-agent/thread/WorkerConcurrencyResolver\", {\n  defaultValue: () => ({ resolve: () => Effect.succeed(Option.none()) }),\n});\n\n/** Host ceilings apply across all declarations owned by one source Thread. */\nexport const WorkerHostLimits = Schema.Struct({\n  maxWorkersPerSource: Positive.check(Schema.isLessThanOrEqualTo(100)),\n  /** Active background workers across declarations; omission retains source Tool concurrency. */\n  maxActiveWorkersPerSource: Schema.optionalKey(Positive.check(Schema.isLessThanOrEqualTo(100))),\n  maxInputsPerWorker: Positive.check(Schema.isLessThanOrEqualTo(1_000)),\n  maxPendingInputsPerWorker: Positive.check(Schema.isLessThanOrEqualTo(100)),\n  maxUpdateInputsPerWorker: Schema.optionalKey(Positive.check(Schema.isLessThanOrEqualTo(1_000))),\n  maxPendingUpdateInputsPerWorker: Schema.optionalKey(\n    Positive.check(Schema.isLessThanOrEqualTo(100)),\n  ),\n  lifetimeMillis: Positive.check(Schema.isLessThanOrEqualTo(604_800_000)),\n  /** Preparation may repeat after loss before its decision commits; keep callbacks side-effect free. */\n  reportPreparationTimeoutMillis: Schema.optionalKey(\n    Positive.check(Schema.isLessThanOrEqualTo(30_000)),\n  ),\n});\n\nexport type WorkerHostLimits = typeof WorkerHostLimits.Type;\n\nexport const WorkerHostConfig = Context.Reference<WorkerHostLimits>(\n  \"@effect-agent/thread/WorkerHostConfig\",\n  {\n    defaultValue: () => ({\n      maxWorkersPerSource: 32,\n      maxInputsPerWorker: 64,\n      maxPendingInputsPerWorker: 8,\n      lifetimeMillis: 86_400_000,\n    }),\n  },\n);\n\n/**\n * Authenticate every acquisition/operation and authorize its exact source Thread. A returned\n * Principal is host-owned admission identity. Context access authenticates source metadata;\n * read, send and control remain separate grants. WorkerRefs and caller-supplied Thread\n * identifiers alone never confer any of them.\n */\nexport interface WorkerHostAuthorizationRequest {\n  readonly sourceThreadId: ThreadId;\n  /** An explicitly selected owner input; authorize this locator as well as the Thread. */\n  readonly sourceSubmissionId?: SubmissionId;\n  readonly principal: Principal;\n  readonly operation: WorkerError[\"operation\"];\n  readonly access: \"context\" | \"read\" | \"send\" | \"control\";\n  readonly worker?: WorkerRef;\n}\n\nexport const WorkerHostAuthorizer = Context.Reference<{\n  readonly authorize: (\n    request: WorkerHostAuthorizationRequest,\n  ) => Effect.Effect<Principal, WorkerError>;\n}>(\"@effect-agent/thread/WorkerHostAuthorizer\", {\n  defaultValue: () => ({\n    authorize: (request) =>\n      WorkerError.make({\n        operation: request.operation,\n        reason: \"denied\",\n      }),\n  }),\n});\n\n/**\n * Deployment-owned permission to fund a root's background worker independently. The decision\n * covers the exact immutable origin and is checked again before each input admission. It never\n * changes delegation depth or Tool authority. Omission denies independent funding.\n */\nexport const WorkerBudgetAuthorizer = Context.Reference<{\n  readonly authorize: (request: {\n    readonly source: WorkerSource;\n    readonly principal: Principal;\n    readonly worker: WorkerRef;\n    readonly policy: AgentPolicy;\n    readonly budget: SubagentBudgetReservation;\n  }) => Effect.Effect<void, WorkerError>;\n}>(\"@effect-agent/thread/WorkerBudgetAuthorizer\", {\n  defaultValue: () => ({\n    authorize: () => WorkerError.make({ operation: \"start\", reason: \"denied\" }),\n  }),\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AA8CA,MAAa,uBAAuB,QAAQ,UAOzC,6CAA6C,EAC9C,qBAAqB;CACnB,qBAAqB,OAAO,QAAQ,OAAO,KAAK,CAAC;CACjD,qBAAqB,OAAO,QAAQ,OAAO,KAAK,CAAC;AACnD,GACF,CAAC;AAED,MAAM,WAAW,OAAO,IAAI,MAAM,OAAO,cAAc,CAAC,CAAC;;AAGzD,MAAa,yBAAyB,OAAO,OAAO,EAClD,2BAA2B,OAAO,IAAI,MAAM,OAAO,uBAAuB,CAAC,CAAC,EAC9E,CAAC;;;;;;;;;;;;AAeD,MAAa,4BAA4B,QAAQ,UAO9C,kDAAkD,EACnD,qBAAqB,EAAE,eAAe,OAAO,QAAQ,OAAO,KAAK,CAAC,EAAE,GACtE,CAAC;;AAGD,MAAa,mBAAmB,OAAO,OAAO;CAC5C,qBAAqB,SAAS,MAAM,OAAO,oBAAoB,GAAG,CAAC;;CAEnE,2BAA2B,OAAO,YAAY,SAAS,MAAM,OAAO,oBAAoB,GAAG,CAAC,CAAC;CAC7F,oBAAoB,SAAS,MAAM,OAAO,oBAAoB,GAAK,CAAC;CACpE,2BAA2B,SAAS,MAAM,OAAO,oBAAoB,GAAG,CAAC;CACzE,0BAA0B,OAAO,YAAY,SAAS,MAAM,OAAO,oBAAoB,GAAK,CAAC,CAAC;CAC9F,iCAAiC,OAAO,YACtC,SAAS,MAAM,OAAO,oBAAoB,GAAG,CAAC,CAChD;CACA,gBAAgB,SAAS,MAAM,OAAO,oBAAoB,MAAW,CAAC;;CAEtE,gCAAgC,OAAO,YACrC,SAAS,MAAM,OAAO,oBAAoB,GAAM,CAAC,CACnD;AACF,CAAC;AAID,MAAa,mBAAmB,QAAQ,UACtC,yCACA,EACE,qBAAqB;CACnB,qBAAqB;CACrB,oBAAoB;CACpB,2BAA2B;CAC3B,gBAAgB;AAClB,GACF,CACF;AAkBA,MAAa,uBAAuB,QAAQ,UAIzC,6CAA6C,EAC9C,qBAAqB,EACnB,YAAY,YACV,YAAY,KAAK;CACf,WAAW,QAAQ;CACnB,QAAQ;AACV,CAAC,EACL,GACF,CAAC;;;;;;AAOD,MAAa,yBAAyB,QAAQ,UAQ3C,+CAA+C,EAChD,qBAAqB,EACnB,iBAAiB,YAAY,KAAK;CAAE,WAAW;CAAS,QAAQ;AAAS,CAAC,EAC5E,GACF,CAAC"}

package/dist/engine/AgentRuntime.d.mts

@@ -0,0 +1,2 @@
+import { A as start, C as decodeFinalOutput, D as renderInputPrompt, E as projectCompletionOutput, F as withTerminalDefectEvent, M as stream, N as streamUnknown, O as run, P as streamWithUsageAccountingUnknown, S as ToolCallWaiting, T as projectCompletionFromToolOutput, _ as SubagentDurability, a as AgentResultSchema, b as SubagentDurabilityError, c as AgentSpawner, d as DetachedRun, f as EngineProvidedToolServices, g as SpawnedChildRun, h as SpawnRunOptions, i as AgentResult, j as startUnknown, k as runUnknown, l as AgentSpawnerParent, m as SpawnDelegation, n as AgentChildPending, o as AgentRuntimeFailure, p as RuntimeBinding, r as AgentCompletionProjectionRequirements, s as AgentRuntimeRequirements, u as AgentSpawnerService, v as SubagentDurabilityDurable, w as encodeRunDisposition, x as SubagentDurabilityService, y as SubagentDurabilityEphemeral } from "../AgentRuntime-uxR_a4VM.mjs";
+export { AgentChildPending, type AgentCompletionProjectionRequirements, type AgentResult, AgentResultSchema, type AgentRuntimeFailure, type AgentRuntimeRequirements, AgentSpawner, type AgentSpawnerParent, type AgentSpawnerService, type DetachedRun, type EngineProvidedToolServices, type RuntimeBinding, type SpawnDelegation, type SpawnRunOptions, type SpawnedChildRun, SubagentDurability, type SubagentDurabilityDurable, type SubagentDurabilityEphemeral, SubagentDurabilityError, type SubagentDurabilityService, ToolCallWaiting, decodeFinalOutput, encodeRunDisposition, projectCompletionFromToolOutput, projectCompletionOutput, renderInputPrompt, run, runUnknown, start, startUnknown, stream, streamUnknown, streamWithUsageAccountingUnknown, withTerminalDefectEvent };

package/dist/engine/AgentRuntime.mjs

@@ -0,0 +1,2 @@
+import { _ as stream, a as SubagentDurability, b as withTerminalDefectEvent, c as decodeFinalOutput, d as projectCompletionOutput, f as renderInputPrompt, g as startUnknown, h as start, i as AgentSpawner, l as encodeRunDisposition, m as runUnknown, n as AgentChildPending, o as SubagentDurabilityError, p as run, r as AgentResultSchema, s as ToolCallWaiting, u as projectCompletionFromToolOutput, v as streamUnknown, y as streamWithUsageAccountingUnknown } from "../AgentRuntime-BLyETCPo.mjs";
+export { AgentChildPending, AgentResultSchema, AgentSpawner, SubagentDurability, SubagentDurabilityError, ToolCallWaiting, decodeFinalOutput, encodeRunDisposition, projectCompletionFromToolOutput, projectCompletionOutput, renderInputPrompt, run, runUnknown, start, startUnknown, stream, streamUnknown, streamWithUsageAccountingUnknown, withTerminalDefectEvent };

package/dist/engine/Compaction.d.mts

@@ -0,0 +1,7 @@
+import { d as CONTEXT_ROLLOVER_PREFIX, f as ContextCompactionState, g as estimatePromptTokens, h as estimateMessageTokens, l as CLEARED_TOOL_RESULT, m as contextWindowMessage, p as contextWindowId, u as COMPACTION_SUMMARY_PREFIX } from "../ContextCompactor-Dxu5zhOL.mjs";
+declare namespace Compaction_d_exports {
+  export { CLEARED_TOOL_RESULT, COMPACTION_SUMMARY_PREFIX, CONTEXT_ROLLOVER_PREFIX, ContextCompactionState, contextWindowId, contextWindowMessage, estimateMessageTokens, estimatePromptTokens };
+}
+//#endregion
+export { CLEARED_TOOL_RESULT, COMPACTION_SUMMARY_PREFIX, CONTEXT_ROLLOVER_PREFIX, type ContextCompactionState, contextWindowId, contextWindowMessage, estimateMessageTokens, estimatePromptTokens, Compaction_d_exports as t };
+//# sourceMappingURL=Compaction.d.mts.map

package/dist/engine/Compaction.mjs

@@ -0,0 +1,16 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
+import { f as contextWindowId, h as estimatePromptTokens, m as estimateMessageTokens, n as COMPACTION_SUMMARY_PREFIX, p as contextWindowMessage, r as CONTEXT_ROLLOVER_PREFIX, t as CLEARED_TOOL_RESULT } from "../compaction-C2OTceKw.mjs";
+//#region src/engine/Compaction.ts
+var Compaction_exports = /* @__PURE__ */ __exportAll({
+	CLEARED_TOOL_RESULT: () => CLEARED_TOOL_RESULT,
+	COMPACTION_SUMMARY_PREFIX: () => COMPACTION_SUMMARY_PREFIX,
+	CONTEXT_ROLLOVER_PREFIX: () => CONTEXT_ROLLOVER_PREFIX,
+	contextWindowId: () => contextWindowId,
+	contextWindowMessage: () => contextWindowMessage,
+	estimateMessageTokens: () => estimateMessageTokens,
+	estimatePromptTokens: () => estimatePromptTokens
+});
+//#endregion
+export { CLEARED_TOOL_RESULT, COMPACTION_SUMMARY_PREFIX, CONTEXT_ROLLOVER_PREFIX, contextWindowId, contextWindowMessage, estimateMessageTokens, estimatePromptTokens, Compaction_exports as t };
+
+//# sourceMappingURL=Compaction.mjs.map

package/dist/engine/Compaction.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Compaction.mjs","names":[],"sources":["../../src/engine/Compaction.ts"],"sourcesContent":["/** Public Compaction API. Implementation helpers remain private. */\nexport {\n  CLEARED_TOOL_RESULT,\n  COMPACTION_SUMMARY_PREFIX,\n  CONTEXT_ROLLOVER_PREFIX,\n  contextWindowId,\n  contextWindowMessage,\n  estimateMessageTokens,\n  estimatePromptTokens,\n  type ContextCompactionState,\n} from \"./internal/compaction.ts\";\n"],"mappings":""}

package/dist/engine/ContextCompactor.d.mts

@@ -0,0 +1,2 @@
+import { a as ContextCompaction, c as ContextMessageTokenEstimator, i as CompactionRequest, n as CompactionError, o as ContextCompactor, r as CompactionModelLayer, t as CompactionDecision } from "../ContextCompactor-Dxu5zhOL.mjs";
+export { CompactionDecision, CompactionError, CompactionModelLayer, CompactionRequest, ContextCompaction, ContextCompactor, ContextMessageTokenEstimator };