runbios-sdk 0.2.17-rc.269 → 0.2.18-dev.271

package/dist/resources/loop.js

@@ -1,10 +1,16 @@
 /**
- * The Conscious Loop -- capture what your model was asked and answered, record
- * whether it was right, and turn those judgements into training data.
+ * The Conscious Loop -- pipelines that keep improving a model from the
+ * conversations you send them.
  *
- * Nothing is captured until you turn it on for a source, and you can turn it
- * off again at any time. Anything that looks like a credential or a personal
- * detail is removed before the record is written, never afterwards.
+ * A pipeline is one use case: a model, the tags whose samples train it, when
+ * to train, and how a new version is promoted. Every time it trains it makes
+ * an attempt; an attempt that beats the live model becomes the next version.
+ *
+ * Nothing is captured until a source is switched on, and you can switch it
+ * off again at any time. Creating a pipeline switches on the source named by
+ * its own tag (`own_tag`), stamping that tag, and deleting it switches that
+ * source off again. Anything that looks like a credential or a personal detail
+ * is removed before the record is written, never afterwards.
  *
  * Requires an API key carrying `loop:read` and/or `loop:write`. Those scopes are
  * deliberately absent from the Read Only preset, because what they return is
@@ -17,28 +23,30 @@
  *
  * @example
  * ```ts
- * // 1. Decide that this source is recorded.
- * await client.loop.setConfig('my-agent', { enabled: true, retention_days: 30 });
+ * // 1. A pipeline: a model it can train, and its own tag.
+ * const { models } = await client.loop.listModels();
+ * const { pipeline } = await client.loop.createPipeline({
+ *   name: 'Support replies',
+ *   model: { id: models[0].id },
+ * });
  *
- * // 2. Send what your model was asked and what it answered. Works whoever
- * //    served it -- us, another provider, or your own servers.
- * const { trace_id } = await client.loop.capture({
- *   deployment_id: 'my-agent',
+ * // 2. Send samples from your app to the pipeline's own source: its create
+ * //    switched that source on, and it tags everything it records.
+ * const sent = await client.loop.capture({
+ *   deployment_id: pipeline.own_tag!,
  *   model: 'gpt-4o',
  *   messages: [{ role: 'user', content: 'what is our refund window' }],
  *   completion: 'thirty days',
  * });
  *
- * // 3. Say whether it was right. A rewrite is the most valuable answer here:
- * //    the model learns your version AND learns to avoid its own.
- * await client.loop.signal(trace_id, {
- *   verdict: 'edited',
- *   correction: 'Thirty days from delivery, no questions asked.',
- * });
+ * // 3. Say whether it was right, on the trace_id the capture answered with.
+ * //    A correction is the most valuable answer.
+ * if (sent.trace_id) {
+ *   await client.loop.correct(sent.trace_id, 'Thirty days from delivery, no questions asked.');
+ * }
  *
- * // 4. Turn the judgements into a training set and take the file.
- * const ds = await client.loop.createDataset({ name: 'support', method: 'sft' });
- * const jsonl = await client.loop.downloadDataset(ds.id);
+ * // 4. Once it has its minimum, it trains; versions appear on the pipeline.
+ * const p = await client.loop.getPipeline(pipeline.rule_id);
  * ```
  */
 export class Loop {
@@ -58,11 +66,17 @@ export class Loop {
      *
      * The returned `trace_id` is OURS. If you pass your own `request_id` it is
      * kept as an idempotency handle: sending the same one again returns the same
-     * trace rather than storing a second copy, so a retry is safe.
+     * trace rather than storing a second copy, so a retry is safe. Send feedback
+     * on that `trace_id`.
+     *
+     * `deployment_id` is the source. A pipeline's `own_tag` is a source its
+     * create switched on, and it stamps that tag on everything it records;
+     * `labels` add tags of your own, so the same conversation can feed other
+     * pipelines too.
      *
-     * When the source is not enabled this resolves with `captured: false` and a
-     * reason instead of throwing -- capture must never be the thing that breaks
-     * your application.
+     * When the source is not switched on this resolves with `captured: false`
+     * and a reason instead of throwing -- capture must never be the thing that
+     * breaks your application.
      */
     async capture(params) {
         return this._http.fetchPost('/api/loop/traces', params);
@@ -70,9 +84,9 @@ export class Loop {
     /**
      * Bring data you already have into the loop.
      *
-     * This does NOT create a training set. It creates conversations, in the same
-     * place captured ones live and subject to the same review, rules, judges and
-     * labels. A row becomes trainable when something says it is good, never
+     * This does NOT create a training set. It creates conversations (samples),
+     * in the same place captured ones live and subject to the same feedback and
+     * tags. A row becomes trainable when something says it is good, never
      * because it arrived in a file -- which is the one guarantee that separates
      * a corpus from a pile.
      *
@@ -155,6 +169,12 @@ export class Loop {
             q.set('origin', params.origin);
         if (params.unlabelled)
             q.set('unlabelled', 'true');
+        if (params.pipeline)
+            q.set('pipeline', params.pipeline);
+        if (params.signal)
+            q.set('signal', params.signal);
+        if (params.unsignalled)
+            q.set('unsignalled', 'true');
         if (params.limit != null)
             q.set('limit', String(params.limit));
         if (params.offset != null)
@@ -244,43 +264,17 @@ export class Loop {
         const res = await this._http.fetchGet(`/api/loop/traces/${encodeURIComponent(traceId)}/signals`);
         return res.signals;
     }
-    // ── alternative answers ───────────────────────────────────────────────
     /**
-     * Submit an alternative answer to a prompt already captured.
+     * The pipelines one conversation feeds: every live pipeline whose tags
+     * select it, and whether each is switched on.
      *
-     * This is what makes preference learning scale. A human rewrite is the best
-     * signal there is and the least available -- somebody has to sit down and
-     * write it. Sample the model several times for the same prompt, score the
-     * samples, and a DPO pair falls out automatically: best becomes chosen,
-     * worst becomes rejected. Point a stronger model at the prompt instead and
-     * the same machinery does distillation.
-     *
-     * Score them, or they cannot pair: an unscored alternative says nothing about
-     * which answer anybody prefers. `score_source` is required alongside a score,
-     * because precedence between a verifier, a judge and a person is the whole
-     * reason we record who judged.
-     *
-     * A human correction always outranks any score.
-     *
-     * @example
-     * ```ts
-     * for (const sample of await sampleMyModel(prompt, 4)) {
-     *   await client.loop.addCandidate(traceId, {
-     *     completion: sample.text,
-     *     score: await myVerifier(sample.text),
-     *     score_source: 'verifier',
-     *   });
-     * }
-     * ```
+     * Being listed means the pipeline would select it, not that it will be
+     * trained on -- a set still drops answers it cannot use and duplicates, and
+     * holds some back to judge by; `note` says so. An empty list is a real
+     * answer: the conversation trains nothing until it carries a pipeline's tag.
      */
-    async addCandidate(traceId, params) {
-        const res = await this._http.fetchPost(`/api/loop/traces/${encodeURIComponent(traceId)}/candidates`, params);
-        return res.candidate;
-    }
-    /** Every alternative answer recorded for one prompt, oldest first. */
-    async listCandidates(traceId) {
-        const res = await this._http.fetchGet(`/api/loop/traces/${encodeURIComponent(traceId)}/candidates`);
-        return res.candidates;
+    async getTracePipelines(traceId) {
+        return this._http.fetchGet(`/api/loop/traces/${encodeURIComponent(traceId)}/pipelines`);
     }
     // ── labels ────────────────────────────────────────────────────────────
     /**
@@ -344,180 +338,6 @@ export class Loop {
         const res = await this._http.fetchGet('/api/loop/labels');
         return res.labels;
     }
-    // ── training sets ─────────────────────────────────────────────────────
-    /**
-     * Build a training set from the feedback recorded so far.
-     *
-     * The three methods need genuinely different things, so one set cannot be
-     * reshaped into another afterwards:
-     *
-     * - `sft` -- answers you marked right, and answers you rewrote.
-     * - `dpo` -- answers you REWROTE, so a better and a worse version of the same
-     *   reply exist. Nothing else produces a pair.
-     * - `grpo` -- answers with a value or fact they can be checked against, or
-     *   a judge rubric, which scores answers the run has not written yet.
-     * - `kto` -- anything carrying a yes or a no, INCLUDING a thumbs-down with
-     *   nothing written. That row trains nothing under the other three methods,
-     *   which is why this one exists: it is the feedback people actually give.
-     *
-     * `holdout_percent` holds back your most recent work rather than a random
-     * slice, so the evaluation measures whether the model generalised instead of
-     * memorised the same week.
-     *
-     * The result always reports `rejected_counts`: why rows were left out. A
-     * small set with a reason is useful; a small set without one is just alarming.
-     */
-    async createDataset(params) {
-        const res = await this._http.fetchPost('/api/loop/datasets', params);
-        return res.dataset;
-    }
-    /** List training sets, newest first. */
-    // ── build rules ───────────────────────────────────────────────────────
-    /**
-     * Stand up a rule that builds a set whenever enough new work exists.
-     *
-     * The manual path asks somebody to notice that enough conversations have
-     * been reviewed, remember which filters describe the slice they want, and
-     * press build — every time. A rule is that instruction, stored.
-     *
-     * `spec` is the same selection `createDataset` takes and is replayed
-     * verbatim, so an automatic set is identical to a hand-made one.
-     *
-     * `min_new_rows` counts only work reviewed SINCE THE LAST BUILD. Counting
-     * the whole corpus would fire the rule every interval forever, because a
-     * total that has crossed a threshold stays across it. It is at least 100,
-     * and 100 when absent: a set built from fewer is too small to learn from.
-     */
-    async createBuildRule(params) {
-        const res = await this._http.fetchPost('/api/loop/build-rules', params);
-        return res.rule;
-    }
-    /**
-     * Every build rule, with what each one last did and why.
-     *
-     * `last_reason` is the field worth reading: a rule quiet because it is
-     * waiting looks exactly like one quiet because it is broken.
-     */
-    async listBuildRules() {
-        const res = await this._http.fetchGet('/api/loop/build-rules');
-        return res.rules ?? [];
-    }
-    /** Stop a standing build rule. Sets it already produced are untouched. */
-    async deleteBuildRule(id) {
-        return this._http.fetchDelete(`/api/loop/build-rules/${encodeURIComponent(id)}`);
-    }
-    async listDatasets(params = {}) {
-        const q = new URLSearchParams();
-        if (params.method)
-            q.set('method', params.method);
-        if (params.limit != null)
-            q.set('limit', String(params.limit));
-        if (params.offset != null)
-            q.set('offset', String(params.offset));
-        const qs = q.toString();
-        const res = await this._http.fetchGet(`/api/loop/datasets${qs ? `?${qs}` : ''}`);
-        return res.datasets;
-    }
-    /** Read one training set and its curation report. */
-    async getDataset(id) {
-        const res = await this._http.fetchGet(`/api/loop/datasets/${encodeURIComponent(id)}`);
-        return res.dataset;
-    }
-    /**
-     * Page through the rows a training set actually contains.
-     *
-     * Worth reading before you spend money on a run: each row carries the address
-     * of the conversation it was built from.
-     */
-    async listDatasetItems(id, params = {}) {
-        const q = new URLSearchParams();
-        if (params.limit != null)
-            q.set('limit', String(params.limit));
-        if (params.offset != null)
-            q.set('offset', String(params.offset));
-        const qs = q.toString();
-        const res = await this._http.fetchGet(`/api/loop/datasets/${encodeURIComponent(id)}/items${qs ? `?${qs}` : ''}`);
-        return res.items;
-    }
-    /**
-     * Download a training set as JSONL -- one training row per line, the format
-     * every trainer in this space reads.
-     *
-     * `split` defaults to the training rows; pass `holdout` for the slice held
-     * back, or `all` for both.
-     */
-    async downloadDataset(id, split) {
-        const qs = split ? `?split=${split}` : '';
-        return this._http.fetchGet(`/api/loop/datasets/${encodeURIComponent(id)}/download${qs}`);
-    }
-    /**
-     * Delete a training set.
-     *
-     * The conversations it was built from are untouched -- a set is a selection,
-     * and discarding the selection must not discard the evidence. A set a
-     * training run was trained on is refused `409 DATASET_IN_USE` and kept, as
-     * the record of what that run learned from. See
-     * `LoopDatasetDeleteRefusalCode`.
-     */
-    async deleteDataset(id) {
-        return this._http.fetchDelete(`/api/loop/datasets/${encodeURIComponent(id)}`);
-    }
-    // ── graders ───────────────────────────────────────────────────────────
-    /**
-     * Write a rule that scores answers without a person.
-     *
-     * Human review is the most trustworthy feedback and the least available. A
-     * grader is written once and applied to every answer afterwards: did it
-     * contain the required phrase, did it parse as the schema you asked for, is
-     * the number within tolerance of the known answer, did it call the function
-     * it should have.
-     *
-     * Every kind here is DETERMINISTIC -- no model call, no network. That is why
-     * a verifier outranks a judge when they disagree: it cannot be flattered and
-     * it cannot drift between runs.
-     *
-     * `weight` is the multiplier: a criterion that matters twice as much gets
-     * twice the weight, and the combined score is the weighted mean over the
-     * rules that actually applied.
-     *
-     * `matches_gold` needs no `expected`: it compares each answer to the gold
-     * answer recorded on that same conversation, or the human correction when
-     * there is no gold, and scores sampled alternatives against the same gold.
-     * A conversation with neither is skipped, not failed, so one rule checks
-     * every labelled question without punishing the unlabelled ones. An
-     * optional `tolerance` widens the match when both sides are bare numbers.
-     *
-     * A caution worth knowing before you write a set: a rule made only of
-     * `forbidden` phrases is satisfied VACUOUSLY by an answer that says nothing.
-     * Pair it with a `required` phrase, or you are rewarding silence.
-     */
-    async createGrader(params) {
-        const res = await this._http.fetchPost('/api/loop/graders', params);
-        return res.grader;
-    }
-    /** Every rule this workspace has written. */
-    async listGraders() {
-        const res = await this._http.fetchGet('/api/loop/graders');
-        return res.graders;
-    }
-    async deleteGrader(id) {
-        return this._http.fetchDelete(`/api/loop/graders/${encodeURIComponent(id)}`);
-    }
-    /**
-     * Apply this workspace's rules to one captured answer AND to every
-     * alternative sampled for it.
-     *
-     * Grading both in one pass is the point: scoring only the original gives a
-     * verdict, while scoring the samples as well gives the preference pair. Sample
-     * your model, call this, and you have DPO data with nobody reading anything.
-     *
-     * A run where no rule could apply writes NOTHING -- no verdict, no scores.
-     * Recording a zero that no rule produced would poison curation with a
-     * judgement nobody reached, so `applied: 0` is reported instead.
-     */
-    async grade(traceId) {
-        return this._http.fetchPost(`/api/loop/traces/${encodeURIComponent(traceId)}/grade`);
-    }
     // ── capture settings ──────────────────────────────────────────────────
     /** Every source this workspace has configured. */
     async listConfigs() {
@@ -547,425 +367,40 @@ export class Loop {
         return res.config;
     }
     /**
-     * How much there is, and how much of it each method could actually use.
+     * How much there is, and how many samples a pipeline could train on now
+     * (`ready.sft`: the ones marked good or corrected).
      *
-     * The `ready` numbers are upper bounds: duplicate questions are folded into
-     * one row while a set is built, so the finished count can be lower.
+     * `ready.sft` is an upper bound: duplicates, the held-back set and
+     * conversations too long to train on come out of it when an attempt trains.
      */
     async stats() {
         const res = await this._http.fetchGet('/api/loop/stats');
         return res.stats;
     }
-    // ── judges ────────────────────────────────────────────────────────────
-    //
-    // A grader is a rule: deterministic, cheap, and blind to anything it was not
-    // told to look for. A judge is a rubric handed to a model, which is the only
-    // thing that can answer "was this answer actually helpful".
-    //
-    // YOU run the model. This service stores raw prompts and completions and
-    // holds them with no outbound credentials at all, which is most of the reason
-    // it is safe to store them there -- so it hands the work out instead. Open a
-    // run, take the batch, send each `prompt` to whatever model you like, and
-    // post the scores back.
-    /** Write a rubric: what makes an answer good here, and what to score. */
-    async createJudge(params) {
-        const res = await this._http.fetchPost('/api/loop/judges', params);
-        return res.judge;
-    }
-    async listJudges() {
-        const res = await this._http.fetchGet('/api/loop/judges');
-        return res.judges;
-    }
-    /**
-     * Rewrite a rubric. Runs already recorded keep the instructions they used:
-     * a verdict has to keep meaning what it meant when it was given.
-     */
-    async updateJudge(judgeId, params) {
-        const res = await this._http.fetchPut(`/api/loop/judges/${encodeURIComponent(judgeId)}`, params);
-        return res.judge;
-    }
-    /**
-     * Retire a rubric. Its runs go with it; the verdicts they wrote stay. A score
-     * is evidence about an answer, and it does not stop being true because the
-     * rubric was retired.
-     */
-    async deleteJudge(judgeId) {
-        await this._http.fetchDelete(`/api/loop/judges/${encodeURIComponent(judgeId)}`);
-    }
-    /**
-     * Open a run: select the conversations now, and freeze the rubric onto them.
-     *
-     * The selection is fixed at this moment on purpose. A run whose selection is
-     * a live query silently grows as conversations arrive, so "we scored the
-     * refunds slice" becomes a claim about a set that no longer exists.
-     */
-    async startRun(judgeId, limit) {
-        const res = await this._http.fetchPost(`/api/loop/judges/${encodeURIComponent(judgeId)}/runs`, limit ? { limit } : {});
-        return res.run;
-    }
-    async listRuns(judgeId) {
-        const path = judgeId
-            ? `/api/loop/judges/${encodeURIComponent(judgeId)}/runs`
-            : '/api/loop/runs';
-        const res = await this._http.fetchGet(path);
-        return res.runs;
-    }
-    async getRun(runId) {
-        const res = await this._http.fetchGet(`/api/loop/runs/${encodeURIComponent(runId)}`);
-        return res.run;
-    }
-    /**
-     * Take the next conversations to score, each rendered into a ready-to-send
-     * prompt. Nothing is marked taken, so a caller that dies half way loses
-     * nothing: ask again and the same items come back.
-     */
-    async takeWork(runId, limit = 20) {
-        return this._http.fetchGet(`/api/loop/runs/${encodeURIComponent(runId)}/work?limit=${limit}`);
-    }
-    /**
-     * What happened to each conversation in a run, and why.
-     *
-     * `takeWork` hands out what is still PENDING, so a finished run answers it
-     * with an empty list. This answers with every item and the outcome on it:
-     * `status`, `scored_at`, and `error` — the reason the caller gave for an
-     * item it could not score, which is where a wrong model slug or a refused
-     * key actually shows up. A run that ends "scored 0, failed 3" is otherwise a
-     * number with no detail behind it.
-     *
-     * Pass `status: 'failed'` for the usual question. At most 500 items come
-     * back at a time; when `has_more` is true, call again with the `next_offset`
-     * from the reply.
-     */
-    async listRunItems(runId, opts = {}) {
-        const qs = new URLSearchParams();
-        if (opts.status)
-            qs.set('status', opts.status);
-        if (opts.limit != null)
-            qs.set('limit', String(opts.limit));
-        if (opts.offset)
-            qs.set('offset', String(opts.offset));
-        const suffix = qs.toString() ? `?${qs.toString()}` : '';
-        return this._http.fetchGet(`/api/loop/runs/${encodeURIComponent(runId)}/items${suffix}`);
-    }
-    /**
-     * Hand the scores back. A verdict for a conversation outside this run, or
-     * scoring something the rubric never asked for, is refused and reported in
-     * `rejected` rather than silently dropped.
-     *
-     * Pass `finish` to close the run in the same call once you have nothing left
-     * to send. To close a run WITHOUT scores, call `stopRun`: an empty verdict
-     * list with `finish` does the same thing and reads like a mistake.
-     */
-    async postVerdicts(runId, verdicts, finish = false) {
-        return this._http.fetchPost(`/api/loop/runs/${encodeURIComponent(runId)}/verdicts`, { verdicts, finish });
-    }
-    /**
-     * Close a run that has not finished.
-     *
-     * A judge may have one open run of its own at a time, so an open run BLOCKS
-     * the next one, and the runs that most need closing are the ones nobody can
-     * wait out: a run the agent has parked on an empty balance or a refused key
-     * stays open until the reason is fixed or somebody stops it.
-     *
-     * Nothing is deleted. Every verdict already recorded stays recorded, the
-     * counters keep saying how much of the selection was covered, and the
-     * conversations the run was holding are free for the next one. The run ends
-     * as `stopped` rather than `done`, so an interrupted pass and a completed
-     * one do not read alike.
-     *
-     * A run that finished on its own is not rewritten: stopping one answers 409.
-     *
-     * Returns the stopped run itself, like `startRun` and `getRun`, not the
-     * `{run}` envelope the service sends. Every other single-run method in this
-     * class unwraps, and `Loop.stop_run` in the Python SDK does too, so a
-     * caller who wrote `(await loop.stopRun(id)).status` against one of its
-     * siblings is right here as well.
-     */
-    async stopRun(runId) {
-        const res = await this._http.fetchPost(`/api/loop/runs/${encodeURIComponent(runId)}/stop`, {});
-        return res.run;
-    }
-    // ── the agent ─────────────────────────────────────────────────────────
-    //
-    // The worker that calls a model on the workspace's behalf: it applies
-    // automatic judges and writes sample answers. It spends through a managed
-    // serverless key OF THIS WORKSPACE, so every call is billed exactly like
-    // one of your own, and turning it off revokes that key.
-    /**
-     * Can an agent run here, is one running, and is it on for this workspace.
-     * `available` is about the environment; `online` about the worker;
-     * `credential` about this workspace.
-     */
-    async agentStatus() {
-        return this._http.fetchGet('/api/loop/agent');
-    }
-    /**
-     * Turn the agent on: mints the workspace's managed serverless key and
-     * resumes the automatic judges a previous turn-off paused. After this,
-     * automatic judges and sample runs make model calls billed to the
-     * workspace. Idempotent.
-     *
-     * A judge whose model the serving gateway will not route is NOT resumed:
-     * making it automatic would buy a run that fails every conversation. It
-     * stays paused, `judges_still_paused` counts those, and each one carries
-     * `auto_pause_reason` saying so. Point it at a model that is served and
-     * turn the agent on again.
-     *
-     * `monthly_spend_cap_cents` caps what that key may spend on model calls in
-     * a calendar month. Omitted = no cap on a fresh key, and an existing cap is
-     * left as it is; sent while the agent is already on, it moves the cap on
-     * the existing key without minting a new one. When the cap is reached the
-     * agent's model calls are refused until next month and its runs pause with
-     * that reason.
-     */
-    async enableAgent(opts = {}) {
-        const body = {};
-        if (opts.monthly_spend_cap_cents != null)
-            body.monthly_spend_cap_cents = opts.monthly_spend_cap_cents;
-        const res = await this._http.fetchPost('/api/loop/agent', body);
-        return res.credential;
-    }
-    /**
-     * Turn the agent off: revokes its key and pauses every automatic judge in
-     * the workspace (`judges_paused`; each judge shows `auto_paused`). Turning
-     * it back on resumes exactly those judges. Open runs stop where they are
-     * and continue if it is turned back on. Nothing already scored or written
-     * is removed.
-     */
-    async disableAgent() {
-        return this._http.fetchDelete('/api/loop/agent');
-    }
     /**
-     * Ask the agent to write `n` alternative answers to each conversation in a
-     * slice with `model`, score each with `judge_id`, and store them as
-     * candidates. This is how preference pairs are made without a person
-     * writing each one: the curation pass pairs the best sample against the
-     * worst wherever the gap is real.
-     *
-     * Cost: up to `n` calls to write plus `n` to judge, per conversation, at the
-     * workspace's serverless rate; `selection.sample` caps the conversations
-     * (max 200) and `n` is capped at 8. Opening a run turns the agent on if it
-     * is off.
+     * How the loop moved over time: every attempt as a point, oldest first --
+     * its attempt number, the version it became (null when it did not), its
+     * base model, its win rate, what it cost -- and each day's feedback counted
+     * by verdict. `rule_id` narrows the attempts to one pipeline; the feedback
+     * counts are the workspace's. `truncated` says older attempts exist beyond
+     * `limit`.
      */
-    async createSampleRun(params) {
-        const res = await this._http.fetchPost('/api/loop/sample-runs', params);
-        return res.run;
-    }
-    async listSampleRuns() {
-        const res = await this._http.fetchGet('/api/loop/sample-runs');
-        return res.runs;
-    }
-    async getSampleRun(runId) {
-        const res = await this._http.fetchGet(`/api/loop/sample-runs/${encodeURIComponent(runId)}`);
-        return res.run;
-    }
-    // ── automatic training ────────────────────────────────────────────────
-    //
-    // A training rule is a STANDING INSTRUCTION, not a job. Once it is accepted
-    // the platform builds a set, trains a model, books a candidate, compares it
-    // against what serves your traffic today and -- if you asked for that --
-    // re-points the alias at the winner, on its own schedule, with nobody
-    // watching. Every one of those steps spends money from the authorising
-    // member's wallet.
-    //
-    // So the order is always the same: preflight for the estimate and the exact
-    // words of the terms, show them to the person whose wallet pays, and only
-    // then create with `accept_terms` carrying the `terms_version` they read.
-    // Money-bearing edits bump `revision`, clear the consent and stop the rule
-    // firing until someone accepts the new amounts.
-    //
-    // Requires `loop:write` for every mutation, including `preflightTrainingRule`:
-    // it is the estimate step of a create, and a key that may not create a rule
-    // has no reason to price one.
-    /**
-     * Price a training rule before anyone agrees to it. Writes nothing.
-     *
-     * Takes the create body without `accept_terms` and answers with the estimate
-     * a member has to see first: the pinned model revision, the worst hourly
-     * price each GPU ladder can reach, how many hours each ceiling buys, any
-     * refusals that would stop a create, the API keys that cannot follow a
-     * cutover because they lack `deployments:read`, and `terms_text` -- the
-     * exact sentence to show, with real figures in it.
-     *
-     * Send the `terms_version` it returns back in `createTrainingRule`. Read the
-     * figures out of this response rather than inventing ceilings of your own.
-     *
-     * `valid: false` with an EMPTY `refusals` list is not nothing: check
-     * `unreachable`, which names every peer the platform could not reach. The
-     * rule is savable in that state and would be paused, but the estimate around
-     * it is not trustworthy -- both `worst_hourly_*` are `0`, and so are both
-     * `max_*_hours` beside them -- so do not quote those figures to anyone.
-     * `model_revision` is empty unless training-service actually pinned a
-     * commit; test `unreachable.length > 0` to tell a degraded pass from a
-     * refusal.
-     *
-     * A `TRAINING_NOT_ENABLED` refusal is neither: training is in beta and this
-     * organisation does not hold the grant. It is in `refusals`, never in
-     * `unreachable`, and nothing in the request can lift it.
-     */
-    async preflightTrainingRule(params) {
-        return this._http.fetchPost('/api/loop/training-rules/preflight', params);
-    }
-    /**
-     * Create a training rule and record the consent that pays for it.
-     *
-     * ACCEPTING THE TERMS AUTHORISES SPENDING FROM YOUR WALLET WHILE YOU ARE NOT
-     * PRESENT. From here on the platform may, on its own schedule and without
-     * asking again, build a training set, run a training job on rented GPUs,
-     * book a second deployment to compare against the one serving your traffic,
-     * and pay for the model calls that judge the two. Those charges come out of
-     * the wallet of the member whose credentials make this call, up to the
-     * ceilings in `money`, and they keep recurring for as long as the rule is
-     * enabled. If `promotion.auto_promote` is set, the platform will also
-     * re-point your public handle at the new model with nobody reviewing it.
-     *
-     * `accept_terms` is therefore required, and this method refuses to send the
-     * request without it rather than letting the server decide. Call
-     * {@link preflightTrainingRule} first, show the person whose wallet pays the
-     * `terms_text` and the figures it returns, get an explicit yes, and send the
-     * `terms_version` they were shown. Do not invent ceilings or price caps on
-     * their behalf.
-     *
-     * Refused `409 TRAINING_NOT_ENABLED`, with nothing saved, while training is
-     * in beta and this organisation does not hold the grant: do not retry, ask
-     * the platform team to enable it. See `TrainingRuleSaveRefusalCode`.
-     *
-     * @example
-     * ```ts
-     * const estimate = await client.loop.preflightTrainingRule(draft);
-     * // show estimate.terms_text and the ceilings to the member, get a yes
-     * const rule = await client.loop.createTrainingRule({
-     *   ...draft,
-     *   accept_terms: { terms_version: estimate.terms_version },
-     * });
-     * ```
-     */
-    async createTrainingRule(params) {
-        // Refused here rather than on the wire: a create without a recorded
-        // acceptance is a request to spend somebody's money with no record that
-        // they agreed, and the SDK should never be the thing that sends it.
-        if (!params.accept_terms || !params.accept_terms.terms_version) {
-            throw new Error('RunBiOS: createTrainingRule requires accept_terms.terms_version. '
-                + 'Call preflightTrainingRule, show the member terms_text and the ceilings, '
-                + 'and send back the terms_version they accepted -- this rule spends from their wallet.');
-        }
-        const res = await this._http.fetchPost('/api/loop/training-rules', params);
-        return res.rule;
-    }
-    /**
-     * Every training rule in the workspace, with what each one last did and why.
-     *
-     * `last_reason` and `paused_reason` are the fields worth reading: a rule
-     * quiet because it is waiting looks exactly like one quiet because its
-     * consent went stale.
-     */
-    async listTrainingRules(params = {}) {
+    async getMetricsHistory(params = {}) {
         const q = new URLSearchParams();
-        if (params.enabled != null)
-            q.set('enabled', String(params.enabled));
+        if (params.rule_id)
+            q.set('rule_id', params.rule_id);
         if (params.limit != null)
             q.set('limit', String(params.limit));
-        if (params.offset != null)
-            q.set('offset', String(params.offset));
+        if (params.days != null)
+            q.set('days', String(params.days));
         const qs = q.toString();
-        return this._http.fetchGet(`/api/loop/training-rules${qs ? `?${qs}` : ''}`);
-    }
-    /**
-     * Read one rule with its recent runs, what its runs this month have cost at
-     * most, and how far its judge agrees with your own reviewers.
-     *
-     * Returned whole rather than unwrapped to the rule: `month_spent_cents` is
-     * the number that says whether the monthly ceiling is about to stop it. It
-     * is an upper bound, not an exact spend: see `Pipeline.month_spent_cents`.
-     */
-    async getTrainingRule(id) {
-        return this._http.fetchGet(`/api/loop/training-rules/${encodeURIComponent(id)}`);
-    }
-    /**
-     * Edit or pause a rule. Absent means unchanged; a null clears the fields
-     * that can be cleared.
-     *
-     * A money-bearing change -- a ceiling, a model, a GPU ladder, the promotion
-     * policy, or changing `explore_recipes` in EITHER direction -- bumps
-     * `revision`, clears the recorded consent and STOPS the rule firing until
-     * someone accepts the new amounts. Turning recipe variants OFF does this
-     * too: the pipeline then makes no version at all, variant or not, until the
-     * terms are accepted again. The reply says so in
-     * `consent_required`, and carries a fresh `preflight` with the new figures.
-     * Pass `expected_revision` to be refused with `REVISION_MISMATCH` rather
-     * than overwrite an edit somebody else made in the meantime.
-     *
-     * Switching a rule on, switching it into preference training or carrying
-     * `accept_terms` re-runs the preflight, and can be refused
-     * `409 TRAINING_NOT_ENABLED` like a create. A rule paused
-     * `training_not_enabled` is started again by a save of it once the
-     * organisation has been enabled.
-     */
-    async updateTrainingRule(id, params) {
-        return this._http.fetchPut(`/api/loop/training-rules/${encodeURIComponent(id)}`, params);
-    }
-    /**
-     * Accept the rule's current terms, so it may fire again.
-     *
-     * ACCEPTING THE TERMS AUTHORISES SPENDING FROM YOUR WALLET WHILE YOU ARE NOT
-     * PRESENT, on the amounts as they stand right now. This is the same
-     * authorisation {@link createTrainingRule} records, given again because a
-     * money-bearing edit cleared the old one: training, a candidate deployment
-     * and the judge's model calls are charged to the wallet of the member making
-     * this call, up to the rule's ceilings, every time it fires.
-     *
-     * Show the member the current `terms_text` from a fresh
-     * {@link preflightTrainingRule} or from the `preflight` on the update reply,
-     * and send the `revision` those figures belong to. A stale revision is
-     * refused with `409`, which is the point: it means the amounts moved again
-     * after they were read. `409 TRAINING_NOT_ENABLED` means training is in beta
-     * and this organisation does not hold the grant.
-     */
-    async consentTrainingRule(id, params) {
-        const res = await this._http.fetchPost(`/api/loop/training-rules/${encodeURIComponent(id)}/consent`, params);
-        return res.rule;
-    }
-    /**
-     * Fire a rule now, without waiting for its cadence.
-     *
-     * Bypasses the schedule and `min_new_rows` only. The row floors, the money
-     * ceilings, the consent, the version limit and the monthly limit all still
-     * apply, so this can answer `409 CONSENT_REQUIRED`, `409 RULE_PAUSED`,
-     * `409 RUN_ACTIVE`, `409 VERSION_LIMIT_REACHED` (the pipeline has made
-     * `max_versions` versions), `409 MONTHLY_LIMIT_REACHED` (the most this
-     * month's runs can have cost plus the most one run may cost would pass the
-     * monthly limit; the error
-     * body carries `month_spent_cents`, `monthly_ceiling_cents`, `run_max_cents`
-     * and `resumes_at`), `409 AGENT_OFF` (the workspace's Conscious Loop agent
-     * is not turned on, so a trained model could not be compared) or
-     * `422 NOT_ENOUGH_ROWS` with the counts it needed. See
-     * `TrainingRuleRunRefusalCode`.
-     */
-    async runTrainingRule(id) {
-        const res = await this._http.fetchPost(`/api/loop/training-rules/${encodeURIComponent(id)}/run`, {});
-        return res.run;
-    }
-    /**
-     * Delete a rule. An active run is cancelled; runs that already finished, and
-     * anything already promoted, are kept.
-     */
-    async deleteTrainingRule(id) {
-        return this._http.fetchDelete(`/api/loop/training-rules/${encodeURIComponent(id)}`);
+        return this._http.fetchGet(`/api/loop/metrics/history${qs ? `?${qs}` : ''}`);
     }
-    /**
-     * Edit or pause a build rule -- the standing instruction that assembles the
-     * training set a training rule then trains on.
-     *
-     * Changing `spec.deployment_id` while an enabled training rule owns this
-     * build rule is refused with `409`: it would silently retrain the next model
-     * on a different source's conversations.
-     */
-    async updateBuildRule(id, params) {
-        const res = await this._http.fetchPut(`/api/loop/build-rules/${encodeURIComponent(id)}`, params);
-        return res.rule;
-    }
-    // ── training runs ─────────────────────────────────────────────────────
-    /** Firings, newest first. Filter by rule or by the state they are sitting in. */
+    // ── attempts ──────────────────────────────────────────────────────────
+    //
+    // Every time a pipeline trains it makes an attempt (a training run). The
+    // attempts that beat the live model became its versions.
+    /** Attempts, newest first. Filter by pipeline (`rule_id`) or by the state they are sitting in. */
     async listTrainingRuns(params = {}) {
         const q = new URLSearchParams();
         if (params.rule_id)
@@ -1027,23 +462,22 @@ export class Loop {
     }
     // ── pipelines ─────────────────────────────────────────────────────────
     /**
-     * Every training rule in the workspace, seen as the series of versions it
-     * produced: which exist, which one serves (`champion_version`), how each did
-     * against the champion of its day and on the standing benchmark, the run in
-     * flight and which version it will be, and what the pipeline is waiting for.
-     *
-     * Read-only. Every decision stays on the route that owns it -- promote,
-     * reject and roll back on the run, the version limit and `explore_recipes`
-     * on the rule.
+     * Every pipeline in the workspace: its versions (the attempts that became
+     * the live model), every attempt, which version is live, the attempt in
+     * flight, and what the pipeline is waiting for.
      *
      * RETURNED WITH ITS ENVELOPE, because the list is not always all of them:
-     * the service returns the newest 100, `total` is every pipeline in the
-     * workspace and `truncated` is true when more exist than were returned. A
-     * caller that shows `pipelines` alone presents a short list as the whole of
-     * it. The rest are reached through `listTrainingRules`, which pages.
+     * the service returns a page of 100, newest first, `total` is every
+     * pipeline in the workspace and `truncated` is true when more exist after
+     * this page. A caller that shows `pipelines` alone presents a short list as
+     * the whole of it; the next page is `{ offset: offset + pipelines.length }`.
      */
-    async listPipelines() {
-        const res = await this._http.fetchGet('/api/loop/pipelines');
+    async listPipelines(params = {}) {
+        const q = new URLSearchParams();
+        if (params.offset)
+            q.set('offset', String(params.offset));
+        const qs = q.toString();
+        const res = await this._http.fetchGet(`/api/loop/pipelines${qs ? `?${qs}` : ''}`);
         const pipelines = res.pipelines || [];
         return {
             pipelines,
@@ -1053,7 +487,7 @@ export class Loop {
         };
     }
     /**
-     * One pipeline, by its training rule's id.
+     * One pipeline, by its id.
      *
      * `status` says whether it is the platform working (`running`), the member
      * who has to act (`needs_review`, `needs_funds`), or nothing at all until
@@ -1066,10 +500,108 @@ export class Loop {
         const res = await this._http.fetchGet(`/api/loop/pipelines/${encodeURIComponent(id)}`);
         return res.pipeline;
     }
+    // ── creating and changing pipelines ───────────────────────────────────
+    //
+    // One body -- a name, a model, tags, when to train, how to promote -- and
+    // the platform decides the rest: the machines and the limits on each
+    // attempt. Saving a pipeline IS the authorization to spend; you pay the GPU
+    // time its attempts actually use.
+    /**
+     * The base models a pipeline can train: only those the engine trains with
+     * LoRA SFT and the platform can serve for the comparison, recommended first.
+     * The one list {@link createPipeline} accepts a `model.id` from, with the
+     * `floors` a new pipeline is held to: the samples its first attempt needs and
+     * the smallest `train_when.min_samples`.
+     */
+    async listModels() {
+        const res = await this._http.fetchGet('/api/loop/models');
+        return { ...res, models: res.models || [] };
+    }
+    /**
+     * Create a pipeline -- one use case.
+     *
+     * SAVING IT AUTHORISES SPENDING FROM YOUR WALLET WHILE YOU ARE NOT PRESENT:
+     * whenever its data has grown enough (and at its schedule, when it has one),
+     * the platform trains a new version on GPUs it chooses, compares it with what
+     * serves your traffic, and promotes it by the pipeline's promotion policy.
+     * What is charged is the GPU time the runs actually use; the platform's own
+     * per-run and monthly limits stop a run that goes wrong.
+     */
+    async createPipeline(params) {
+        return this._http.fetchPost('/api/loop/pipelines', params);
+    }
+    /**
+     * Edit a pipeline. Only the fields sent change; `max_versions: null` removes
+     * the limit and `challenger_model: null` removes the challenger. `promotion`
+     * is how the promotion policy is set. Saving is the authorization, as on a
+     * create.
+     */
+    async updatePipeline(id, params) {
+        return this._http.fetchPut(`/api/loop/pipelines/${encodeURIComponent(id)}`, params);
+    }
+    /**
+     * Delete a pipeline: an attempt still running is cancelled; the versions it
+     * made, what serves your app, and its samples and tags are kept. Recording
+     * to its own tag stops.
+     */
+    async deletePipeline(id) {
+        return this._http.fetchDelete(`/api/loop/pipelines/${encodeURIComponent(id)}`);
+    }
+    /**
+     * Train now: skips the schedule, never the minimum. A pipeline short of its
+     * samples is refused 422 `NOT_ENOUGH_SAMPLES` with `have` and `need` -- the
+     * numbers `minimums` shows. 503 `AGENT_COULD_NOT_START` means the key the
+     * attempt would be scored with could not be renewed just then: nothing was
+     * started, so press train now again in a minute. Every refusal is a
+     * `TrainingRuleRunRefusalCode`.
+     */
+    async runPipeline(id) {
+        return this._http.fetchPost(`/api/loop/pipelines/${encodeURIComponent(id)}/run`, {});
+    }
+    /**
+     * {@link importRows}, with every row given the pipeline's own tag. `source`
+     * defaults to that tag; the rows, the answer and the retry rules are the
+     * import door's own. `default_feedback: 'good'` records every answered row
+     * that brought no verdict of its own as a good example to learn from.
+     */
+    async importIntoPipeline(id, params) {
+        return this._http.fetchPost(`/api/loop/pipelines/${encodeURIComponent(id)}/import`, params);
+    }
+    // ── a pipeline's benchmarks, and its versions side by side ─────────────
+    /** The pipeline's benchmarks in priority order (1 is the primary), the ones it stopped using, and its promotion policy. */
+    async listPipelineBenchmarks(id) {
+        return this._http.fetchGet(`/api/loop/pipelines/${encodeURIComponent(id)}/benchmarks`);
+    }
+    /** Add a benchmark to a pipeline, last unless `priority` says where. Every version from now on is replayed on it. */
+    async attachPipelineBenchmark(id, params) {
+        return this._http.fetchPost(`/api/loop/pipelines/${encodeURIComponent(id)}/benchmarks`, params);
+    }
+    /** Move a benchmark on a pipeline's list; priority 1 makes it the primary. */
+    async movePipelineBenchmark(id, benchmarkId, params) {
+        return this._http.fetchPut(`/api/loop/pipelines/${encodeURIComponent(id)}/benchmarks/${encodeURIComponent(benchmarkId)}`, params);
+    }
+    /** Stop using a benchmark. Every score it produced is kept. */
+    async removePipelineBenchmark(id, benchmarkId) {
+        return this._http.fetchDelete(`/api/loop/pipelines/${encodeURIComponent(id)}/benchmarks/${encodeURIComponent(benchmarkId)}`);
+    }
+    /**
+     * Every version's scores side by side: its head-to-head and every benchmark,
+     * `not_measured` where a benchmark was added after it. `a` and `b` are
+     * VERSION numbers; with both, `differences` says b minus a per benchmark.
+     */
+    async compareVersions(id, params = {}) {
+        const q = new URLSearchParams();
+        if (params.a != null)
+            q.set('a', String(params.a));
+        if (params.b != null)
+            q.set('b', String(params.b));
+        const qs = q.toString();
+        return this._http.fetchGet(`/api/loop/pipelines/${encodeURIComponent(id)}/versions/compare${qs ? `?${qs}` : ''}`);
+    }
     // ── the comparison report ─────────────────────────────────────────────
     /**
      * The comparison behind a verdict: both models on the same held-out rows,
-     * with identical decoding, judge and grader names resolved.
+     * with identical decoding, scored by the same judge.
      *
      * Read `warnings` before you read `win_rate`. A win rate over a holdout too
      * small to mean anything, or one measured by a judge that disagrees with
@@ -1085,8 +617,10 @@ export class Loop {
      * The paired conversations behind the numbers: one prompt, both answers, the
      * scores each earned, and which won.
      *
-     * Filter by `winner` to read the losses first, which is where a verdict is
-     * actually checked. `limit` is capped at 100 by the service.
+     * Filter by `winner` -- `candidate` (the attempt won), `serving` (the version
+     * serving today won; the item itself says `incumbent`) or `tie` -- and read
+     * `serving` first: the pairs the attempt lost are where a verdict is actually
+     * checked. `limit` is 50 when absent and at most 200.
      */
     async listEvaluationItems(id, params = {}) {
         const q = new URLSearchParams();
@@ -1099,24 +633,6 @@ export class Loop {
         const qs = q.toString();
         return this._http.fetchGet(`/api/loop/evaluations/${encodeURIComponent(id)}/items${qs ? `?${qs}` : ''}`);
     }
-    /**
-     * How far a judge agrees with your own reviewers, over the conversations
-     * both have scored.
-     *
-     * This is a gate, not a badge: a rule's `min_judge_agreement` refuses to
-     * promote on the word of a judge that does not agree with the people whose
-     * product it is. `enough_pairs` is the field to read first -- "not enough
-     * reviewer overlap yet" is an answer, and 100% of two pairs is not.
-     */
-    async getJudgeAgreement(judgeId, params = {}) {
-        const q = new URLSearchParams();
-        if (params.from)
-            q.set('from', params.from);
-        if (params.to)
-            q.set('to', params.to);
-        const qs = q.toString();
-        return this._http.fetchGet(`/api/loop/judges/${encodeURIComponent(judgeId)}/agreement${qs ? `?${qs}` : ''}`);
-    }
     // ── the standing benchmark ────────────────────────────────────────────
     /**
      * Pin a fixed set of conversations, with a judge frozen beside them, and
@@ -1133,9 +649,10 @@ export class Loop {
      * is refused rather than skipped, because pinning 47 of the 50 you chose is
      * the set being wrong from the first day and you would never find out.
      *
-     * It raises no amount you have already agreed to. The replay's calls come
-     * out of the rule's existing `eval_ceiling_cents`, and
-     * `per_run_ceiling_cents` can only lower what is spent inside that.
+     * The platform freezes the judge and the model it scores on (the ones every
+     * pipeline comparison uses), gives both models the comparison's own answer
+     * length, and sets what one replay may spend, inside the attempt's own
+     * scoring limit; none of that is sent.
      */
     async createBenchmark(params) {
         const res = await this._http.fetchPost('/api/loop/benchmarks', params);
@@ -1166,7 +683,7 @@ export class Loop {
         return res.benchmark;
     }
     /**
-     * The pinned conversations, paged. `limit` is capped at 100 by the service.
+     * The pinned conversations, paged. `limit` is 50 when absent and at most 200.
      *
      * `source_trace_id` and `source_trace_url` come back null once the
      * conversation a row was copied from has been deleted. The row itself stays
@@ -1201,7 +718,7 @@ export class Loop {
         return this._http.fetchGet(`/api/loop/benchmarks/${encodeURIComponent(id)}/history${qs ? `?${qs}` : ''}`);
     }
     /**
-     * Stop replaying a benchmark, and detach it from every rule that names it.
+     * Stop replaying a benchmark, and detach it from every pipeline using it.
      *
      * Nothing measured is removed. There is no delete and no update on purpose:
      * the series of numbers measured against a set is what a benchmark is for,
@@ -1231,45 +748,4 @@ export class Loop {
         const res = await this._http.fetchGet(`/api/loop/benchmark-runs/${encodeURIComponent(id)}`);
         return res.benchmark_run;
     }
-    /**
-     * Attach a benchmark to a rule, or send `{ benchmark_id: null }` to detach
-     * it.
-     *
-     * Its own route rather than a field on the rule body, because it is a
-     * decision to replay a fixed set on every future run of this rule for as
-     * long as it stands, and its refusals -- retired, or belonging to another
-     * workspace -- are about the benchmark rather than about the rule.
-     *
-     * It does not invalidate consent and the reply says so: attaching raises
-     * neither the amount set aside for judge calls nor the amount set aside for
-     * keeping the new model available, so nobody is asked to read the same
-     * sentence again. A retired benchmark is refused with `BENCHMARK_RETIRED`,
-     * because a rule pointed at one would report no number on every run and say
-     * nothing about why.
-     */
-    async setTrainingRuleBenchmark(id, params) {
-        return this._http.fetchPut(`/api/loop/training-rules/${encodeURIComponent(id)}/benchmark`, params);
-    }
-    // ── agent settings ────────────────────────────────────────────────────
-    /**
-     * The workspace's agent options: which model it defaults to, the system
-     * prompts it judges and samples with, and the monthly cap on what its model
-     * calls may spend.
-     */
-    async getAgentSettings() {
-        const res = await this._http.fetchGet('/api/loop/agent/settings');
-        return res.settings;
-    }
-    /**
-     * Change them. An absent key leaves that setting exactly where it is; a
-     * present null returns it to the platform default. Those are three
-     * instructions, not two, so `{}` changes nothing.
-     *
-     * `eval_monthly_cap_cents` is pushed to the workspace's managed key, so it
-     * caps what the agent can spend even if a rule's own ceilings are higher.
-     */
-    async updateAgentSettings(params) {
-        const res = await this._http.fetchPut('/api/loop/agent/settings', params);
-        return res.settings;
-    }
 }