pi-continual-harness 0.10.0 → 0.12.0

package/README.md

@@ -63,6 +63,7 @@ Durable I/O (round-trip with pi-reflect):
 ```
 /harness status                  # counts + durable layer presence/mtime
 /harness export [path]           # layered export (or full snapshot to a path)
+/harness export-corpus [path]    # calibration corpus JSONL for pi-reflex (local-only; dedupe pairs + lifecycle)
 /harness import [--prune] [path] # layered import (or single file from a path)
 /harness prune [--decay <days>]  # drop items below the importance floor
 /harness keep <id>               # nudge importance up (+0.1)
@@ -144,8 +145,10 @@ Optional config at `~/.pi/agent/harness.json` (missing or malformed → defaults
   "dedupe": { "threshold": 0.6, "merge": true },
   "injection": { "enabled": true, "maxTokens": 1500, "maxPerKind": 10, "charsPerToken": 4 },
   "remindRefine": { "enabled": false, "everyTurns": 50 },
-  "autoRefine": { "enabled": false, "everyTurns": 100, "commit": false },
-  "outcomeImportance": { "enabled": false, "bump": 0.03 }
+  "autoRefine": { "enabled": false, "everyTurns": 100, "commit": false, "gate": false },
+  "outcomeImportance": { "enabled": false, "bump": 0.03 },
+  "classifier": { "model": "typesafe/jev-latest" },
+  "virtualBinding": "virtual"
 }
 ```
 
@@ -186,7 +189,29 @@ Optional config at `~/.pi/agent/harness.json` (missing or malformed → defaults
   (default 100). It is one of the package's opt-in autonomous paths: it reuses
   the exact `/refine` routine (audited `REFINE_ENTRY` tagged `source: "auto"`,
   branch-local, `/tree` rollback) and notifies before firing. `commit: true`
-  also flushes durable state on each run.
+  also flushes durable state on each run. `gate: true` (needs `classifier.model`)
+  asks the classifier first whether the recent trajectory contains a durable,
+  reusable correction and skips the refine when it does not — cadence becomes
+  signal, not just time (errors fall back to the plain cadence). The steering
+  prompt is delivered via the pi ≥ 0.87 actionable `turn_end` boundary (a
+  structural `harness.auto-refine-request` entry + `continue: true`), not a
+  synthetic user message.
+- **`classifier`** — opt-in classifier model (pi ≥ 0.99) for the cheap gated
+  paths: `"provider/id"` or a bare id of a **classifier** catalog entry, e.g.
+  `"typesafe/jev-latest"` or a local `llama-cpp` classifier (every chat model
+  listed for llama.cpp also appears as a classifier). When set and resolvable
+  it enables the classifier-confirmed dedupe (see `dedupe` above) and the
+  auto-refine `gate`. When unset or unresolvable, every classifier feature
+  degrades to its no-classifier behavior.
+- **`virtualBinding`** — how the per-model isolation key treats pi **virtual
+  models** (router extensions, pi ≥ 0.99). Default `"virtual"`: the key is
+  the selected model's own `provider/id` — a router starts a blank harness.
+  `"physical"`: when the selection is virtual, the key is the *physical*
+  model behind the latest successful response on the branch — notes
+  accumulated under that physical model keep injecting through the router, and
+  switching routed models re-scopes exactly like a manual model switch. Before
+  the first response the key is unknown: creates stay orphans and are adopted
+  on first contact.
 - **`outcomeImportance`** — opt-in autonomous **promotion** loop (**off by
   default**). When `enabled`, a `turn_end` hook bumps (+`bump`, default 0.03)
   the importance of any active item the agent cited by its `[h_xxxx]` tag in the
@@ -315,7 +340,7 @@ deltas directly). The propose stage is pluggable via a registry
 
 The dedupe planner's `similarity` seam (`DedupeOptions.similarity`, re-exported
 from the package entry) is how a companion package upgrades the comparison —
-e.g. embedding cosine similarity, or a local decision engine such as pi-jev
+e.g. embedding cosine similarity, or a local decision engine such as pi-reflex
 (a local-only project for now). A comparator may return
 `{ score, abstain }` instead of a plain number: **an abstaining pair is
 treated as not duplicates** — both items are kept — so an engine with
@@ -369,7 +394,7 @@ Then `"my-proposer"` is selectable via `/refine --proposer my-proposer` or
 
 ## Status
 
-0.9.x. Implemented:
+0.12.x. Requires **pi ≥ 0.99.0**. Implemented:
 
 - Unified harness-state store with branch-local snapshots (`/tree` rollback).
 - Online `/refine` + `harness_mutate` / `harness_list` tools.
@@ -394,11 +419,28 @@ Then `"my-proposer"` is selectable via `/refine --proposer my-proposer` or
 - **Per-model isolation**: every item is bound to a `provider/id` and injected
   only for that model; new items are stamped automatically and orphans adopted
   on first contact. A new model id starts from a blank harness, and the durable
-  round-trip preserves the owner tag.
+  round-trip preserves the owner tag. With pi virtual models (routers), the
+  `"virtualBinding": "physical"` policy keys items by the routed physical
+  model instead of the router id, so a router selection does not silently
+  reset the harness.
 - **Bounded injection (on by default)**: the supplemental block is
   importance-ordered and capped per kind + by a total token budget, so a growing
   harness never balloons the system prompt. Tunable / opt-out via the `injection`
-  config key; the store is never changed by selection.
+  config key; the store is never changed by selection. Rendered on **every
+  provider request** (`context_with_system`), so a mid-run `harness_mutate`
+  shows up on the very next request.
+- **Classifier features (pi ≥ 0.99, opt-in)**: `"classifier": { "model": … }`
+  enables (1) classifier-confirmed dedupe — candidate merge pairs confirmed by
+  one batched yes/no call (errors fall back to the rule-based plan) — and (2)
+  the auto-refine gate `"autoRefine": { "gate": true }`, which skips a cadenced
+  refine when the trajectory holds no durable correction.
+- **Structured tool results**: `harness_list` / `harness_mutate` return
+  `structuredContent` (with `outputSchema`), so codemode scripts and
+  `ctx.executeTool()` callers can consume harness state programmatically.
+- **Boundary delivery for auto-refine**: the steering prompt is persisted as a
+  structural entry with `{ entries, continue: true }` at `turn_end` (no
+  synthetic user message, no follow-up-scheduling side effects); manual
+  `/refine` still steers via a user message.
 
 Open extension points (see `docs/ROADMAP.md`):
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-continual-harness",
-  "version": "0.10.0",
+  "version": "0.12.0",
   "description": "Online self-improvement layer for pi. A unified, in-trajectory harness-state store (prompt notes, memory, skill descriptions, sub-agent specs) with a manual /refine that proposes evidence-backed structured CRUD deltas. Composes with pi-reflect (offline) and pi-mem (storage); owns only the online optimizer layer. Inspired by Continual Harness (arXiv 2605.09998) and ACE (arXiv 2510.04618).",
   "keywords": [
     "pi-package",
@@ -35,13 +35,13 @@
     "node": ">=20.0.0"
   },
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": ">=0.74.0",
-    "@earendil-works/pi-ai": ">=0.74.0",
+    "@earendil-works/pi-coding-agent": ">=0.99.0",
+    "@earendil-works/pi-ai": ">=0.99.0",
     "typebox": ">=1.0.0"
   },
   "devDependencies": {
-    "@earendil-works/pi-coding-agent": ">=0.74.0",
-    "@earendil-works/pi-ai": ">=0.74.0",
+    "@earendil-works/pi-coding-agent": ">=0.99.0",
+    "@earendil-works/pi-ai": ">=0.99.0",
     "typebox": ">=1.0.0",
     "@types/node": "^22.0.0",
     "typescript": "^5.6.0",

package/src/auto-refine.ts

@@ -9,13 +9,30 @@
 // properties: structured evidence-backed deltas, an audited REFINE_ENTRY
 // (tagged source: "auto"), branch-local snapshots, and /tree rollback.
 //
-// It is also visible: it notifies before firing and the steering message
-// appears in the transcript. The decision logic is factored into
+// Two pi ≥ 0.87/0.99 upgrades (0.12.0):
+//
+//  - Classifier gate (opt-in via autoRefine.gate + classifier.model): before
+//    spending a refine, ask ONE cheap yes/no classifier question over the
+//    recent trajectory. "No durable correction" skips the refine entirely —
+//    cadence becomes signal, not just time. Soft-fails to the plain cadence on
+//    any classifier error (the gate can skip work, never block it).
+//
+//  - Boundary delivery: the steering message is no longer sent as a synthetic
+//    user message; runRefine returns it undelivered and this handler persists
+//    it as a structural custom-message entry with `{ entries, continue: true }`
+//    — the actionable turn_end boundary. One guaranteed next provider request,
+//    no steering queue and no follow-up scheduling side effects. Falls back to
+//    sendUserMessage when the boundary cannot continue (event.context.
+//    canContinue false, e.g. after an error turn).
+//
+// It stays visible: it notifies before firing, and the boundary draft (and the
+// gate decision) appear in the transcript. The decision logic is factored into
 // evaluateAutoRefine() so it is unit-testable without a live pi runtime.
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { DEFAULT_AUTO_EVERY_TURNS, type HarnessConfig, loadConfig } from "./config.js";
-import { runRefine } from "./refine.js";
+import { runRefine, gatherEvidence, DEFAULT_LOOKBACK_TURNS } from "./refine.js";
+import { buildClassify, buildGateRequest, gateDecision } from "./classify.js";
 
 // turnIndex of the last auto-refine (or the seeded baseline). -1 = unseen.
 let lastTurn = -1;
@@ -45,20 +62,64 @@ export function evaluateAutoRefine(config: HarnessConfig, turnIndex: number): bo
   return false;
 }
 
+/** The boundary draft custom type for auto-refine steering messages. */
+export const AUTO_REFINE_ENTRY = "harness.auto-refine-request";
+
+/** Build the boundary draft carrying a steering message. Pure — testable. */
+export function buildRefineDraft(steeringMessage: string): {
+  type: "custom_message";
+  customType: string;
+  content: string;
+  display: boolean;
+} {
+  return { type: "custom_message", customType: AUTO_REFINE_ENTRY, content: steeringMessage, display: true };
+}
+
 /** Subscribe to turn_end and run /refine on the configured cadence. */
 export function registerAutoRefine(pi: ExtensionAPI): void {
   pi.on("turn_end", async (event, ctx) => {
     const config = await loadConfig();
     if (!evaluateAutoRefine(config, event.turnIndex)) return;
     const every = config.autoRefine?.everyTurns ?? DEFAULT_AUTO_EVERY_TURNS;
+
+    // Opt-in classifier gate: cheap yes/no before spending the refine.
+    if (config.autoRefine?.gate) {
+      const classify = buildClassify(ctx, config.classifier?.model);
+      if (classify) {
+        const evidence = gatherEvidence(ctx, DEFAULT_LOOKBACK_TURNS);
+        const res = await classify(buildGateRequest(evidence));
+        const decision = gateDecision(res);
+        if (!decision.proceed) {
+          ctx.ui.notify(`Auto-refine: skipped — ${decision.because}.`, "info");
+          return;
+        }
+        ctx.ui.notify(`Auto-refine: gate passed (${decision.because}).`, "info");
+      }
+      // No resolvable classifier → plain cadence behavior (documented soft-fail).
+    }
+
     ctx.ui.notify(`Auto-refine: running /refine (every ${every} turns, opt-in).`, "info");
     try {
-      await runRefine(
+      const result = await runRefine(
         pi,
         ctx,
-        { commit: config.autoRefine?.commit ?? false, ...(config.proposer ? { proposer: config.proposer } : {}) },
+        {
+          commit: config.autoRefine?.commit ?? false,
+          ...(config.proposer ? { proposer: config.proposer } : {}),
+          delivery: "boundary",
+        },
         "auto",
       );
+      // Boundary delivery: persist the steering message as a structural entry
+      // and guarantee one next provider request. Only when the boundary CAN
+      // continue — otherwise fall back to the legacy steering send.
+      if (result.steeringMessage) {
+        if (event.context?.canContinue === false) {
+          pi.sendUserMessage(result.steeringMessage);
+          return;
+        }
+        return { entries: [...event.entries, buildRefineDraft(result.steeringMessage)], continue: true };
+      }
     } catch (err) {
       ctx.ui.notify(`Auto-refine failed: ${(err as Error).message}`, "error");
     }

package/src/classify.ts

@@ -0,0 +1,220 @@
+// Classifier adapter (pi ≥ 0.99). Wraps ctx.modelRegistry.classify() — cheap
+// typed yes/no or score questions answered from next-token label probabilities
+// (local llama.cpp) or a hosted Jev model — behind two package seams:
+//
+//  1. autoRefine gate (auto-refine.ts): when the cadence elapses, ask ONE bool
+//     question over the recent trajectory ("did it contain a durable, reusable
+//     correction?") and skip the refine when the answer is no. Soft-fails to the
+//     old cadence behavior on any classifier error, so a flaky classifier never
+//     blocks refinement.
+//  2. dedupe confirmation (proposer.ts): a precision filter on candidate merge
+//     pairs — see classifyConfirmPairs().
+//
+// The pi-ai classifier shapes (ClassifierContext/ClassifierQuestion/…) are kept
+// OUT of the public proposer interface: ClassifyFn below is a minimal structural
+// contract so proposers stay testable without pi runtime types.
+
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+/** One yes/no question in a ClassifyFn request. */
+export interface ClassifyBoolQuestion {
+  instructions: string;
+  /** Criteria text for the yes answer. */
+  trueCriteria: string;
+  /** Criteria text for the no answer. */
+  falseCriteria: string;
+}
+
+/** A parsed answer per question key. */
+export interface ClassifyBoolAnswer {
+  /** The classifier's decision. */
+  value: boolean;
+  /** [0,1] confidence when the engine reports one. */
+  confidence?: number;
+}
+
+/** Result of a ClassifyFn call: one answer per question key, or an error. */
+export interface ClassifyBoolResult {
+  ok: boolean;
+  answers: Record<string, ClassifyBoolAnswer>;
+  /** Resolved classifier label ("provider/id") for telemetry. */
+  model?: string;
+  /** Token usage when the engine reports it (for the audit trail). */
+  usage?: { input: number; output: number };
+  error?: string;
+}
+
+/**
+ * Batched yes/no classification seam injected into ProposeInput when a
+ * classifier model is configured AND resolvable. Structural on purpose —
+ * the adapter below is the only place that knows pi-ai's shapes.
+ */
+export type ClassifyFn = (input: {
+  state: Record<string, unknown>;
+  questions: Record<string, ClassifyBoolQuestion>;
+}) => Promise<ClassifyBoolResult>;
+
+/** Structural slice of ctx.modelRegistry used here. */
+interface RegistryLike {
+  classify?: (model: unknown, context: unknown, options?: unknown) => Promise<ClassifyRawResult>;
+  findOfType?: (type: "classifier", provider: string, id: string) => unknown | undefined;
+  getModelsOfType?: (type: "classifier") => readonly unknown[];
+}
+
+/** Raw pi-ai ClassifierResult slice (never rejects, but stopReason may be error). */
+interface ClassifyRawResult {
+  answers?: Record<string, { type?: string; choice?: unknown; score?: number; probability?: number; confidence?: number }>;
+  stopReason?: string;
+  errorMessage?: string;
+}
+
+/** Raw classifier-model slice (Model<ClassifierApi>). */
+interface ClassifierModelLike {
+  provider?: string;
+  id?: string;
+}
+
+/**
+ * Resolve a classifier model from a configured id ("provider/id" or bare id).
+ * Returns undefined when unconfigured or unresolvable — every feature keyed on
+ * it then degrades to its no-classifier behavior.
+ */
+export function resolveClassifierModel(
+  registry: RegistryLike | undefined,
+  configured?: string,
+): ClassifierModelLike | undefined {
+  if (!configured || !registry) return undefined;
+  const slash = configured.indexOf("/");
+  if (slash > 0 && typeof registry.findOfType === "function") {
+    const byPair = registry.findOfType("classifier", configured.slice(0, slash), configured.slice(slash + 1));
+    if (byPair) return byPair as ClassifierModelLike;
+  }
+  const all =
+    typeof registry.getModelsOfType === "function"
+      ? [...registry.getModelsOfType("classifier")]
+      : [];
+  return (all.find((m) => {
+    const cm = m as ClassifierModelLike;
+    return cm.id === configured || `${cm.provider}/${cm.id}` === configured;
+  }) ?? undefined) as ClassifierModelLike | undefined;
+}
+
+/** Build the ClassifyFn adapter over a resolved classifier model. */
+export function makeClassifyFn(
+  registry: RegistryLike,
+  model: ClassifierModelLike,
+  signal?: AbortSignal,
+): ClassifyFn {
+  const label = `${model.provider}/${model.id}`;
+  return async ({ state, questions }) => {
+    if (typeof registry.classify !== "function") {
+      return { ok: false, answers: {}, model: label, error: "modelRegistry.classify unavailable" };
+    }
+    // Map our minimal bool contract onto pi-ai's ClassifierBoolQuestion.
+    const piQuestions: Record<string, unknown> = {};
+    for (const [key, q] of Object.entries(questions)) {
+      piQuestions[key] = {
+        type: "bool",
+        instructions: q.instructions,
+        criteria: { true: q.trueCriteria, false: q.falseCriteria },
+      };
+    }
+    let raw: ClassifyRawResult;
+    try {
+      raw = (await registry.classify(model, { state, questions: piQuestions }, signal ? { signal } : undefined)) as ClassifyRawResult;
+    } catch (err) {
+      // classify "never rejects", but stay defensive around transport edges.
+      return { ok: false, answers: {}, model: label, error: (err as Error).message };
+    }
+    const usage =
+      typeof (raw as { usage?: { input?: number; output?: number } }).usage?.input === "number" &&
+      typeof (raw as { usage?: { input?: number; output?: number } }).usage?.output === "number"
+        ? {
+            input: (raw as { usage?: { input: number; output: number } }).usage!.input,
+            output: (raw as { usage?: { input: number; output: number } }).usage!.output,
+          }
+        : undefined;
+    if (raw.stopReason && raw.stopReason !== "stop") {
+      return {
+        ok: false,
+        answers: {},
+        model: label,
+        ...(usage ? { usage } : {}),
+        error: raw.errorMessage ?? `stopReason ${raw.stopReason}`,
+      };
+    }
+    const answers: Record<string, ClassifyBoolAnswer> = {};
+    for (const [key, a] of Object.entries(raw.answers ?? {})) {
+      let value: boolean | undefined;
+      let confidence: number | undefined;
+      if (a?.type === "bool") {
+        // Bool answers carry the probability of TRUE.
+        value = (a.probability ?? 0) >= 0.5;
+        confidence = a.probability;
+      } else if (a?.type === "choice") {
+        value = a.choice === true || a.choice === "true";
+        confidence = a.confidence;
+      } else if (a?.type === "score") {
+        value = (a.score ?? 0) >= 0.5;
+        confidence = a.confidence;
+      }
+      if (value !== undefined) {
+        answers[key] = { value, ...(typeof confidence === "number" ? { confidence } : {}) };
+      }
+    }
+    return { ok: true, answers, model: label, ...(usage ? { usage } : {}) };
+  };
+}
+
+/**
+ * Resolve the ClassifyFn for a session from config + ctx, or undefined.
+ * The single construction point shared by refine (ProposeInput.classify) and
+ * the auto-refine gate.
+ */
+export function buildClassify(
+  ctx: ExtensionContext,
+  configuredModel?: string,
+): ClassifyFn | undefined {
+  const registry = ctx.modelRegistry as RegistryLike | undefined;
+  const model = resolveClassifierModel(registry, configuredModel);
+  if (!registry || !model) return undefined;
+  return makeClassifyFn(registry, model, ctx.signal);
+}
+
+/**
+ * The auto-refine gate question: did the recent trajectory contain a durable,
+ * reusable correction worth a /refine pass? Pure builder — unit-testable.
+ * Keeps the state payload bounded (the caller already bounds evidence bytes).
+ */
+export function buildGateRequest(evidence: string): {
+  state: Record<string, unknown>;
+  questions: Record<string, ClassifyBoolQuestion>;
+} {
+  return {
+    state: { trajectory: evidence },
+    questions: {
+      gate: {
+        instructions:
+          "You are gating an online self-improvement pass for a coding agent. Does the recent trajectory below contain a durable, reusable correction — a mistake fixed, a preference learned, a convention discovered, or a fact worth remembering across sessions — that is NOT already routine work?",
+        trueCriteria:
+          "The trajectory contains at least one durable, reusable lesson or correction worth persisting into the agent's harness state.",
+        falseCriteria:
+          "The trajectory is routine work (ordinary edits, reads, test runs) with no reusable correction worth persisting.",
+      },
+    },
+  };
+}
+
+/**
+ * Gate decision from a classify result. Errors and missing answers fall back to
+ * `true` (proceed) so a flaky classifier never disables refinement — the gate
+ * can only SKIP work, never block it.
+ */
+export function gateDecision(result: ClassifyBoolResult): { proceed: boolean; because: string } {
+  if (!result.ok) return { proceed: true, because: `classifier error (${result.error ?? "unknown"}); falling back to cadence` };
+  const a = result.answers.gate;
+  if (!a) return { proceed: true, because: "no gate answer; falling back to cadence" };
+  return a.value
+    ? { proceed: true, because: `classifier: yes (confidence ${a.confidence ?? "?"})` }
+    : { proceed: false, because: `classifier: no durable correction (confidence ${a.confidence ?? "?"})` };
+}

package/src/config.ts

@@ -27,6 +27,12 @@ export const DEFAULT_AUTO_EVERY_TURNS = 100;
 /** Default per-reference importance bump for the opt-in outcome loop. */
 export const DEFAULT_REF_BUMP = 0.03;
 
+/** How the binding key treats virtual (router) models. "virtual" (default):
+ * key = the selected model's own provider/id. "physical": when the selection
+ * is virtual, key = the physical model behind the latest successful response
+ * on the branch (see src/vmodel.ts). */
+export type VirtualBinding = "virtual" | "physical";
+
 /** Resolved dedupe policy (merge-capable, 0.10.0). Populated by loadConfig. */
 export interface NormalizedDedupe {
   /** Token-overlap threshold in (0,1]; pairs at/above it merge. Default 0.6. */
@@ -51,7 +57,21 @@ export interface HarnessConfig {
     enabled?: boolean;
     everyTurns?: number;
     commit?: boolean;
+    /** Opt-in classifier gate (pi ≥ 0.99, needs `classifier.model`): when the
+     *  cadence elapses, ask a cheap yes/no classifier whether the recent
+     *  trajectory contains a durable correction; skip the refine when it says
+     *  no. Soft-fails to the plain cadence on classifier errors. Default false. */
+    gate?: boolean;
+  };
+  /** Classifier model for the cheap gated paths (pi ≥ 0.99): "provider/id" or
+   *  a bare id of a classifier catalog entry (e.g. "typesafe/jev-latest" or a
+   *  local llama.cpp classifier). When unset or unresolvable, every classifier
+   *  feature degrades to its no-classifier behavior. */
+  classifier?: {
+    model?: string | undefined;
   };
+  /** Virtual-model binding policy (pi ≥ 0.99). Default "virtual". */
+  virtualBinding?: VirtualBinding;
   /** Delta proposer name (see proposer.ts registry). Defaults to "steering". */
   proposer?: string;
   /** Opt-in turn_end outcome loop: promote importance of items the agent
@@ -72,7 +92,9 @@ export const DEFAULT_CONFIG: HarnessConfig = {
   durableScope: "global",
   autoImport: false,
   remindRefine: { enabled: false, everyTurns: DEFAULT_EVERY_TURNS },
-  autoRefine: { enabled: false, everyTurns: DEFAULT_AUTO_EVERY_TURNS, commit: false },
+  autoRefine: { enabled: false, everyTurns: DEFAULT_AUTO_EVERY_TURNS, commit: false, gate: false },
+  classifier: { model: undefined },
+  virtualBinding: "virtual",
   proposer: "steering",
   outcomeImportance: { enabled: false, bump: DEFAULT_REF_BUMP },
   // Dedupe (merge-capable): merge ON at the historical 0.6 threshold — a
@@ -102,7 +124,12 @@ function mergeConfig(over: Partial<HarnessConfig>): HarnessConfig {
       enabled: over.autoRefine?.enabled ?? false,
       everyTurns: over.autoRefine?.everyTurns ?? DEFAULT_AUTO_EVERY_TURNS,
       commit: over.autoRefine?.commit ?? false,
+      gate: over.autoRefine?.gate === true,
+    },
+    classifier: {
+      model: typeof over.classifier?.model === "string" && over.classifier.model ? over.classifier.model : undefined,
     },
+    virtualBinding: over.virtualBinding === "physical" ? "physical" : "virtual",
     proposer: over.proposer ?? "steering",
     outcomeImportance: {
       enabled: over.outcomeImportance?.enabled ?? false,