@openpond/evals 0.12.3 → 0.12.5

package/LEARNING.md

@@ -251,6 +251,27 @@ state is `dispatching`; only a provider observation establishes `training` or
 `evaluating`. A paused policy stops new submissions while existing executions
 continue to be observed.
 
+Executors can implement `admit` to defer an unstarted, persisted submission for
+calendar or capacity reasons. Return `{ status: "deferred", retryAt, reason }`
+with a future timestamp, or `{ status: "ready" }`. This check must not create an
+execution, launch compute or spend. A wait persists its reason and retry time,
+releases the worker lease and retains the same sealed batch and reservation
+without increasing failure retries. Restarted workers respect that timestamp;
+cancellation bypasses it and can settle an unstarted dispatch at zero spend.
+Once submission has started, retries reconcile its existing identity without
+repeating admission. The executor must still verify current authority atomically
+when creating an execution; a prior ready decision is not authorization to spend.
+
+If admission closes during transport, `submit` may return a `deferred` result
+with the exact scope, dispatch/hash, lease generation, retry time and immutable
+receipt. The owner must atomically prove no execution or charge was created and
+durably fence every late submission from that attempt before returning it. A
+timeout or a read that finds no Job cannot establish this. The shared worker
+retains the receipt, clears the started marker and releases/increments the
+lease generation without spending a failure retry. Owners sharing the learning
+repository use `deferLearningIterationSubmission` inside their native admission
+transaction; the older worker then observes the committed generation change.
+
 The executor must deduplicate `submit` by `dispatch.id`, verify observation
 identity and provider receipts, and use `reconcile` to recover an existing Job
 after a lost reply. An unreachable owner is an error, never proof of absence.
@@ -394,3 +415,25 @@ revision changes and budget reservations, resolve authoritative execution/gradin
 receipts, isolate holdouts from training, bind the exact candidate at runtime,
 verify cleanup, and enforce the verdict inside the candidate-decision transaction.
 No customer serving is activated by an acceptance group.
+
+### Bounded tool episodes
+
+The explicit `@openpond/evals/tool-learning` entry describes bounded attempt,
+observation, recovery-link, verification, installation, and recovery-consultation
+contracts. An event is sealed over validated sanitized bytes; the observation
+references the exact attempted action. Execution failure, validation failure,
+incomplete observation, uncertain effects, and verified outcome stay distinct.
+A producer-provided verifier reference is a claim that intake must resolve against
+its authentic execution owner.
+
+Collection acknowledgements explicitly have `learningEnrollment: false`. The
+capture policy requires separate review for model updates and disables synthetic
+variants. Retaining a successful command is not evidence of the requested outcome,
+a qualified training target, or permission to spend. Reuse the existing task
+review, immutable supervised batch, and publication owners for actual admission.
+
+Recovery consultation binds its action/context, active manifest, selected model,
+and usage receipt. Integration qualification advertises an existing-model route;
+learned qualification additionally requires retained training/evaluation/activation
+lineage. Neither installation nor receipt of evidence establishes learned efficacy.
+These protocols do not install client hooks or start background services.

package/dist/javascript-isolate-process-entry.js

@@ -5,4 +5,7 @@ const input = owner.__openpondIsolateInput;
 delete owner.__openpondIsolateInput;
 if (!input)
     throw new Error("JavaScript process requires its execution owner.");
-void executeJavaScriptIsolate(input).then((result) => process.stdout.write(JSON.stringify({ ok: true, result })), (error) => process.stdout.write(JSON.stringify({ ok: false, executionError: error instanceof JavaScriptIsolateExecutionError, error: (error instanceof Error ? error.message : "JavaScript execution failed.").slice(0, 8_192) })));
+void executeJavaScriptIsolate(input, input.errorPrefix === "verifier" ? {
+    onExecutionReady: () => { if (!process.send)
+        throw new Error("Verifier process requires its startup channel."); process.send({ type: "execution_ready" }); },
+} : undefined).then((result) => process.stdout.write(JSON.stringify({ ok: true, result })), (error) => process.stdout.write(JSON.stringify({ ok: false, executionError: error instanceof JavaScriptIsolateExecutionError, error: (error instanceof Error ? error.message : "JavaScript execution failed.").slice(0, 8_192) })));