auto-model-router 0.4.0 → 0.4.1

package/.omp-plugin/marketplace.json

@@ -7,14 +7,14 @@
   },
   "metadata": {
     "description": "auto-model-router: a local cost/complexity-aware model router for Oh My Pi, backed by OpenRouter",
-    "version": "0.4.0",
+    "version": "0.4.1",
     "pluginRoot": "."
   },
   "plugins": [
     {
       "name": "auto-model-router",
       "description": "Local cost/complexity-aware model router for Oh My Pi, backed by OpenRouter. Runs in-process, routes per turn by price and task complexity, with budget caps, mid-stream escalation, and cache-aware hysteresis.",
-      "version": "0.4.0",
+      "version": "0.4.1",
       "author": {
         "name": "drewappling",
         "email": "drewappling@gmail.com"

package/README.md

@@ -499,7 +499,7 @@ What it shows, for the window:
 
 | Block | Columns |
 | --- | --- |
-| totals | spend, dispatches, conversations, $/dispatch, prompt and completion tokens, cache hit rate, model switches, escalations, failovers, errors (aborted separately) |
+| totals | spend, dispatches, conversations, $/dispatch, prompt and completion tokens, cache hit rate, model switches, escalations, failovers, errors (aborted separately), subagent dispatches and their share of spend |
 | prompt anatomy | mean share of prompt bytes by role (tool results, assistant, user, system), tool schemas beside them, the older half of the conversation, and tool results older than the newest 20 messages — what compaction can reach. Recorded per turn from v0.3.5. |
 | providers | per upstream (`openrouter`, `ollama`): dispatches, spend, share, cache hit, mean TTFT, tokens/s, escalations, errors |
 | models | per served slug (top 12 by spend): the same plus user feedback (`+good/-bad` from `/router good\|bad`) and the tier mix it was routed for |
@@ -592,6 +592,7 @@ what each one does. All values are optional; omit a key to use its default.
 | `host` | `127.0.0.1` | Bind address. `0.0.0.0`/`::` listen on all interfaces (the provider still advertises loopback). |
 | `port` | `0` | Bind port. `0` = let the OS pick a free ephemeral port (the embedded router's default). |
 | `apiKey` | unset | Optional client bearer token. When set, every request must send `Authorization: Bearer <key>`. |
+| `subagentProfile` | `auto-sub` | Profile omp subagents are routed under when they ask for the default one. The embed extension marks sessions without a UI with `X-Omp-Subagent: 1`; delegated work (reads, searches, summaries) never needs the top tier. Empty disables the remap. |
 | `harnessId` | unset | Harness identity sent as `X-Omp-Harness`; scopes per-harness daily budgets and toasts. |
 
 ### `openrouter`
@@ -663,6 +664,7 @@ Each task (`coding`, `vision`, `documentation`, `data`, `chat`) is a
 | `deny` | `[]` | Glob denylist; matching slugs are excluded. |
 | `includeFree` | `false` | Include free models (rate-limited hard; usually excluded). |
 | `requireToolSupport` | `true` | Only models that support tool calls. |
+| `feedbackWeight` | `0` | How much a `/router good\|bad` verdict weighs in a model's trust rate: a bad verdict counts as this many failures, a good one as this many successes. `0` records verdicts without acting on them. |
 | `minTrust` | `0.7` | Minimum success rate; models below this (after `minTrustSamples`) are demoted. |
 | `minTrustSamples` | `12` | Attempts before trust is enforced. |
 | `trustScopedByHarness` | `false` | `true` = each harness reads only its own trust rows. |
@@ -688,6 +690,7 @@ Each task (`coding`, `vision`, `documentation`, `data`, `chat`) is a
 | `toolAxis` | `coding` | Quality axis for tool-heavy turns. |
 | `chatAxis` | `intelligence` | Quality axis for chat turns. |
 | `agenticLoopDepth` | `3` | Tool-loop depth at which a turn is treated as agentic. |
+| `readOnlyToolWeight` | `0` | Score subtracted when a tool-result continuation follows an assistant turn that used only read-only tools (read, grep, glob, ls, lsp…). Recorded as `features.readOnlyToolTail` either way; enable after `tools/replay.ts` prices it. |
 | `mechanicalRetryFactor` | `0.2` | Fraction of the failed-tool and circular-call weights kept on a tool-result continuation; `1` disables the damping. |
 
 ### `escalation` — mid-stream retry upward
@@ -767,7 +770,7 @@ Each profile is a complete entry (arrays replace wholesale):
 
 | Key | Default | Meaning |
 | --- | --- | --- |
-| `id` | `auto` / `auto-cheap` / `auto-max` | Model id omp selects. |
+| `id` | `auto` / `auto-cheap` / `auto-max` / `auto-sub` | Model id omp selects. `auto-sub` (trivial..moderate) is what subagents get via `server.subagentProfile`. |
 | `name` | `Auto (auto-model-router)` etc. | Display name. |
 | `minTier` / `maxTier` | `trivial`/`hard`, `trivial`/`simple`, `moderate`/`hard` | Tier envelope. |
 | `contextWindow` | `400000` | Advertised context window (drives omp's compaction). |

package/omp-extension/router-embed.ts

@@ -89,7 +89,7 @@ function trackProcessExit(): void {
  * Registers the auto-model-router provider (and its virtual models) into omp's model
  * registry at a specific bound port.
  */
-function registerRouterProvider(pi: ExtensionAPI, port: number, cfg: RouterConfig, sessionId: string): void {
+function registerRouterProvider(pi: ExtensionAPI, port: number, cfg: RouterConfig, sessionId: string, subagent: boolean): void {
 	// cwd is omp's workspace, which is what the agentdox scope is derived from
 	// when none is configured explicitly.
 	const providerConfig = buildProviderConfig(port, cfg, process.cwd());
@@ -100,6 +100,9 @@ function registerRouterProvider(pi: ExtensionAPI, port: number, cfg: RouterConfi
 	// Per-session scoping: lets the toast surface only this session's decisions
 	// even when several omp sessions share one embedded router's ledger.
 	if (sessionId !== "") headers["X-Omp-Session"] = sessionId;
+	// A session without a UI is a subagent (or a headless run): the router
+	// routes its turns under server.subagentProfile.
+	if (subagent) headers["X-Omp-Subagent"] = "1";
 	// Which agentdox project's shared context this workspace's turns draw on.
 	if (providerConfig.agentdoxScope !== undefined && providerConfig.agentdoxScope !== "") {
 		headers["X-Agentdox-Scope"] = providerConfig.agentdoxScope;
@@ -171,7 +174,7 @@ export default function (pi: ExtensionAPI): void {
 		// second bind would take a different port and orphan every model handle
 		// omp already resolved against the first one.
 		if (app !== null && boundPort !== null) {
-			registerRouterProvider(pi, boundPort, cfg, sessionId);
+			registerRouterProvider(pi, boundPort, cfg, sessionId, !ctx.hasUI);
 			return;
 		}
 
@@ -181,7 +184,7 @@ export default function (pi: ExtensionAPI): void {
 			// The main writes the port file before spawning subagents.
 			const shared = readEmbedPort(portFile);
 			if (shared !== null && (await probeEmbed(shared))) {
-				registerRouterProvider(pi, shared, cfg, sessionId);
+				registerRouterProvider(pi, shared, cfg, sessionId, !ctx.hasUI);
 				return;
 			}
 			// No live interactive session (headless batch runs, CI, the
@@ -193,7 +196,7 @@ export default function (pi: ExtensionAPI): void {
 			if (started.server.port === undefined) return;
 			app = started;
 			boundPort = started.server.port;
-			registerRouterProvider(pi, boundPort, cfg, sessionId);
+			registerRouterProvider(pi, boundPort, cfg, sessionId, !ctx.hasUI);
 			return;
 		}
 
@@ -207,7 +210,7 @@ export default function (pi: ExtensionAPI): void {
 		// default — never take this path, so sessions stay independent.
 		if (requestedPort !== 0 && (await probeEmbed(requestedPort))) {
 			writeEmbedPort(portFile, requestedPort);
-			registerRouterProvider(pi, requestedPort, cfg, sessionId);
+			registerRouterProvider(pi, requestedPort, cfg, sessionId, !ctx.hasUI);
 			pi.setLabel(`auto-model-router embed (shared :${requestedPort})`);
 			return;
 		}
@@ -266,7 +269,7 @@ export default function (pi: ExtensionAPI): void {
 
 		// Register BEFORE any await: everything omp resolves after this point
 		// picks up the live URL, so the registration must not sit behind I/O.
-		registerRouterProvider(pi, actualPort, cfg, sessionId);
+		registerRouterProvider(pi, actualPort, cfg, sessionId, !ctx.hasUI);
 		pi.setLabel(`auto-model-router embed :${actualPort}`);
 
 		// NO `session_shutdown` teardown. That event is emitted from session

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auto-model-router",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "private": false,
   "description": "Local cost/complexity-aware model router for Oh My Pi, backed by OpenRouter",
   "type": "module",

package/src/cli/config-wizard.ts

@@ -114,6 +114,7 @@ export const WIZARD_SECTIONS: readonly SectionSpec[] = [
 			{ path: "server.port", label: "Listen port", kind: "number", min: 1, max: 65535 },
 			{ path: "server.apiKey", label: "Client bearer token", kind: "string", optional: true, secret: true },
 			{ path: "server.harnessId", label: "Default harness id", kind: "string", optional: true },
+			{ path: "server.subagentProfile", label: "Subagent profile", kind: "string", optional: true, hint: "profile id for omp subagents; blank = none" },
 			{ path: "server.maxConcurrentTurns", label: "Max concurrent turns", kind: "number", min: 1, hint: "per process, all sessions" },
 		],
 	},
@@ -182,6 +183,7 @@ export const WIZARD_SECTIONS: readonly SectionSpec[] = [
 			{ path: "filters.includeFree", label: "Include free models", kind: "boolean" },
 			{ path: "filters.requireToolSupport", label: "Require tool support", kind: "boolean" },
 			{ path: "filters.minTrust", label: "Min trust", kind: "number", min: 0, max: 1 },
+			{ path: "filters.feedbackWeight", label: "Feedback weight in trust", kind: "number", min: 0, hint: "0=record only; a bad verdict = this many failures" },
 			{ path: "filters.minTrustSamples", label: "Min trust samples", kind: "number", min: 0 },
 			{ path: "filters.trustScopedByHarness", label: "Scope trust per harness", kind: "boolean" },
 			{ path: "filters.trustWindowDays", label: "Trust window", kind: "number", min: 0, hint: "days, 0=all time" },
@@ -210,6 +212,7 @@ export const WIZARD_SECTIONS: readonly SectionSpec[] = [
 			{ path: "classifier.chatAxis", label: "Chat axis", kind: "enum", options: AXES },
 			{ path: "classifier.agenticLoopDepth", label: "Agentic loop depth", kind: "number", min: 0, hint: "tool rounds before damping" },
 			{ path: "classifier.mechanicalRetryFactor", label: "Mechanical retry factor", kind: "number", min: 0, max: 1 },
+			{ path: "classifier.readOnlyToolWeight", label: "Read-only tool loop weight", kind: "number", min: 0, hint: "0=record only" },
 			{ path: "classifier.reasoningWeights.medium", label: "Reasoning weight: medium", kind: "number", min: 0 },
 			{ path: "classifier.reasoningWeights.high", label: "Reasoning weight: high", kind: "number", min: 0 },
 			{ path: "classifier.reasoningWeights.xhigh", label: "Reasoning weight: xhigh", kind: "number", min: 0 },

package/src/config/defaults.ts

@@ -15,6 +15,8 @@ export const DEFAULT_CONFIG: RouterConfig = {
 		// is deterministic, so peers reuse it), so this covers N sessions plus
 		// their subagents. Was effectively 8 per session when each bound its own.
 		maxConcurrentTurns: 24,
+		// omp subagents (no UI) route under this profile: delegated work, capped at moderate.
+		subagentProfile: "auto-sub",
 	},
 	openrouter: {
 		baseUrl: "https://openrouter.ai/api/v1",
@@ -99,6 +101,8 @@ export const DEFAULT_CONFIG: RouterConfig = {
 		includeFree: false,
 		requireToolSupport: true,
 		minTrust: 0.7,
+		// Verdicts are recorded and reported first; weigh them once there are some.
+		feedbackWeight: 0,
 		minTrustSamples: 12,
 		// Shared trust by default: more samples, demotion guard stays effective
 		// even with a tiny guardrail-narrowed catalog.
@@ -142,6 +146,8 @@ export const DEFAULT_CONFIG: RouterConfig = {
 		// A mechanical retry (failed tool call + tool-result continuation) keeps
 		// only a fifth of the +0.26; a user-visible failure keeps the full weight.
 		mechanicalRetryFactor: 0.2,
+		// Recorded, not acted on, until replay prices it. See ClassifierConfig.readOnlyToolWeight.
+		readOnlyToolWeight: 0,
 		// Shipped reasoning values, unchanged. See ClassifierConfig.reasoningWeights:
 		// a harness that pins the level for a whole session turns these into a
 		// constant tier offset, in which case `medium` belongs near 0.
@@ -298,6 +304,8 @@ export const DEFAULT_CONFIG: RouterConfig = {
 		{ id: "auto", name: "Auto (auto-model-router)", minTier: "trivial", maxTier: "hard", contextWindow: 400_000, maxTokens: 32_000 },
 		{ id: "auto-cheap", name: "Auto Cheap (auto-model-router)", minTier: "trivial", maxTier: "simple", contextWindow: 400_000, maxTokens: 32_000 },
 		{ id: "auto-max", name: "Auto Max (auto-model-router)", minTier: "moderate", maxTier: "hard", contextWindow: 400_000, maxTokens: 32_000 },
+		// Subagent envelope (server.subagentProfile): never the top tier for delegated work.
+		{ id: "auto-sub", name: "Auto Subagent (auto-model-router)", minTier: "trivial", maxTier: "moderate", contextWindow: 400_000, maxTokens: 32_000 },
 	],
 	ledger: {
 		// Resolved by loadConfig: empty ⇒ `$AUTO_MODEL_ROUTER_HOME/router.db`.

package/src/config/schema.ts

@@ -20,6 +20,7 @@ const server = z.strictObject({
 	port: z.number().int().min(0).max(65_535).optional(),
 	apiKey: z.string().optional(),
 	harnessId: z.string().optional(),
+	subagentProfile: z.string().optional(),
 	maxConcurrentTurns: z.number().int().positive().max(1_000).optional(),
 });
 
@@ -88,6 +89,7 @@ const filters = z.strictObject({
 	includeFree: z.boolean().optional(),
 	requireToolSupport: z.boolean().optional(),
 	minTrust: z.number().min(0).max(1).optional(),
+	feedbackWeight: z.number().nonnegative().optional(),
 	minTrustSamples: z.number().int().nonnegative().optional(),
 	trustScopedByHarness: z.boolean().optional(),
 	trustWindowDays: z.number().nonnegative().optional(),
@@ -114,6 +116,7 @@ const classifier = z.strictObject({
 	chatAxis: qualityAxis.optional(),
 	agenticLoopDepth: z.number().int().nonnegative().optional(),
 	mechanicalRetryFactor: z.number().min(0).max(1).optional(),
+	readOnlyToolWeight: z.number().nonnegative().optional(),
 	reasoningWeights: z
 		.strictObject({
 			medium: z.number().nonnegative().optional(),

package/src/config/types.ts

@@ -38,6 +38,14 @@ export interface ServerConfig {
 	 * ⇒ no header (single-harness default).
 	 */
 	harnessId?: string;
+	/**
+	 * Profile that requests from omp subagents (`X-Omp-Subagent: 1`, set by
+	 * the embed extension for sessions without a UI) are routed under when they
+	 * ask for the default profile. Subagents do delegated, bounded work — file
+	 * reads, searches, summaries — that rarely needs the top tier. Empty
+	 * disables the remap; a name with no matching profile is ignored.
+	 */
+	subagentProfile: string;
 	/**
 	 * Concurrent in-flight turns this router process will accept; excess gets a
 	 * 429 rather than being queued, so a local flood cannot pile up unbounded
@@ -215,6 +223,15 @@ export interface FilterConfig {
 	requireToolSupport: boolean;
 	/** Drop models whose ledger success rate is below this, once `minTrustSamples` is met. */
 	minTrust: number;
+	/**
+	 * How much a user verdict (/router good|bad) weighs in a model's trust
+	 * rate: each bad verdict counts as this many failures and each good one as
+	 * this many successes, beside escalations and errors. 0 (default) records
+	 * verdicts without acting on them. A person judging an answer wrong is a
+	 * stronger signal than a probe rejection, so values of 2-5 are sensible
+	 * once a week of verdicts is in the report.
+	 */
+	feedbackWeight: number;
 	/** Attempts required before `minTrust` is enforced against a model. */
 	minTrustSamples: number;
 	/**
@@ -347,6 +364,13 @@ export interface ClassifierConfig {
 	 * loops buy the hard tier. 1 preserves the shipped behaviour.
 	 */
 	mechanicalRetryFactor: number;
+	/**
+	 * Score subtracted when the newest assistant turn issued only read-only
+	 * tools (read, grep, glob, ls, lsp…) and this is the tool-result
+	 * continuation: the model is looking, not deciding. 0 (default) records
+	 * the feature without acting on it — enable after a replay prices it.
+	 */
+	readOnlyToolWeight: number;
 	/**
 	 * Score added when the CLIENT asks for a reasoning effort, per level. The
 	 * premise is that asking for reasoning states expected difficulty directly.

package/src/cost/ledger.ts

@@ -94,6 +94,15 @@ interface TrustRow {
 	mean_cost_error: number | null;
 }
 
+interface FeedbackRow {
+	good: number | null;
+	bad: number | null;
+}
+
+/** Verdict counts per served slug since a cutoff (optionally one harness). */
+const FEEDBACK_SELECT = `COALESCE(SUM(CASE WHEN f.verdict = 'good' THEN 1 ELSE 0 END), 0) AS good,
+		COALESCE(SUM(CASE WHEN f.verdict = 'bad' THEN 1 ELSE 0 END), 0) AS bad`;
+
 interface LatencyRow {
 	samples: number;
 	ttft_ms: number | null;
@@ -186,15 +195,23 @@ function errorKindOf(error: string | null): string | null {
 	return error.slice(0, sep);
 }
 
-function toTrust(slug: string, row: TrustRow): ModelTrust {
+function toTrust(slug: string, row: TrustRow, fb: FeedbackRow | null = null, feedbackWeight = 0): ModelTrust {
 	// Laplace smoothing: an untried model scores a neutral 1/2, and a failure
 	// is an attempt superseded by an escalation or ended in an upstream error.
+	// A user verdict counts as feedbackWeight extra attempts of that outcome.
+	const good = fb?.good ?? 0;
+	const bad = fb?.bad ?? 0;
+	const w = feedbackWeight > 0 ? feedbackWeight : 0;
+	const attempts = row.attempts + w * (good + bad);
+	const failures = row.failures + w * bad;
 	return {
 		slug,
 		attempts: row.attempts,
 		escalations: row.escalations,
 		errors: row.errors,
-		successRate: (row.attempts - row.failures + 1) / (row.attempts + 2),
+		feedbackGood: good,
+		feedbackBad: bad,
+		successRate: (attempts - failures + 1) / (attempts + 2),
 		meanCostError: row.mean_cost_error ?? 0,
 	};
 }
@@ -312,6 +329,17 @@ export function createLedger(db: Database, cfg: RouterConfig): Ledger {
 	const trustStmt = db.query(`SELECT ${TRUST_SELECT} FROM ledger WHERE slug = ? AND created_at_ms > ?`);
 	const trustHarnessStmt = db.query(`SELECT ${TRUST_SELECT} FROM ledger WHERE slug = ? AND harness_id = ? AND created_at_ms > ?`);
 	const allTrustStmt = db.query(`SELECT slug, ${TRUST_SELECT} FROM ledger WHERE created_at_ms > ? GROUP BY slug`);
+	const feedbackStmt = db.query(`SELECT ${FEEDBACK_SELECT} FROM feedback f WHERE f.slug = ? AND f.created_at_ms > ?`);
+	const feedbackHarnessStmt = db.query(
+		`SELECT ${FEEDBACK_SELECT} FROM feedback f JOIN ledger l ON l.id = f.ledger_id WHERE f.slug = ? AND l.harness_id = ? AND f.created_at_ms > ?`,
+	);
+	const allFeedbackStmt = db.query(`SELECT f.slug, ${FEEDBACK_SELECT} FROM feedback f WHERE f.created_at_ms > ? GROUP BY f.slug`);
+	const feedbackFor = (slug: string, harnessId: string | undefined, cutoff: number): FeedbackRow | null => {
+		if (cfg.filters.feedbackWeight <= 0) return null;
+		return harnessId !== undefined && harnessId !== ""
+			? (feedbackHarnessStmt.get(slug, harnessId, cutoff) as FeedbackRow | null)
+			: (feedbackStmt.get(slug, cutoff) as FeedbackRow | null);
+	};
 	const latencyStmt = db.query(
 		`SELECT ${LATENCY_SELECT} FROM (SELECT * FROM ledger WHERE slug = ? ORDER BY created_at_ms DESC LIMIT ${LATENCY_WINDOW_ROWS})`,
 	);
@@ -447,13 +475,17 @@ export function createLedger(db: Database, cfg: RouterConfig): Ledger {
 					? (trustHarnessStmt.get(slug, harnessId, cutoff) as TrustRow | null)
 					: (trustStmt.get(slug, cutoff) as TrustRow | null);
 			if (row === null || row.attempts === 0) return null;
-			return toTrust(slug, row);
+			return toTrust(slug, row, feedbackFor(slug, harnessId, cutoff), cfg.filters.feedbackWeight);
 		},
 
 		allTrust(): ModelTrust[] {
 			const cutoff = cfg.filters.trustWindowDays > 0 ? Date.now() - cfg.filters.trustWindowDays * DAY_MS : 0;
 			const rows = allTrustStmt.all(cutoff) as (TrustRow & { slug: string })[];
-			return rows.map((row) => toTrust(row.slug, row));
+			const fb = new Map<string, FeedbackRow>();
+			if (cfg.filters.feedbackWeight > 0) {
+				for (const r of allFeedbackStmt.all(cutoff) as (FeedbackRow & { slug: string })[]) fb.set(r.slug, r);
+			}
+			return rows.map((row) => toTrust(row.slug, row, fb.get(row.slug) ?? null, cfg.filters.feedbackWeight));
 		},
 
 		latency(slug: string, harnessId?: string): ModelLatency | null {
@@ -476,7 +508,7 @@ export function createLedger(db: Database, cfg: RouterConfig): Ledger {
 					? (latencyHarnessStmt.get(slug, harnessId) as LatencyRow | null)
 					: (latencyStmt.get(slug) as LatencyRow | null);
 				out.set(slug, {
-					trust: trustRow === null || trustRow.attempts === 0 ? null : toTrust(slug, trustRow),
+					trust: trustRow === null || trustRow.attempts === 0 ? null : toTrust(slug, trustRow, feedbackFor(slug, harnessId, cutoff), cfg.filters.feedbackWeight),
 					latency: latencyRow === null ? null : toLatency(slug, latencyRow),
 				});
 			}

package/src/cost/report.ts

@@ -27,6 +27,9 @@ export interface ReportTotals {
 	modelSwitches: number;
 	/** Any row in the window carries an estimated cache count. */
 	cacheEstimated: boolean;
+	/** Turns from omp subagents (`features.isSubagent`), and their spend. */
+	subagentDispatches: number;
+	subagentSpendUsd: number;
 }
 
 export interface ReportRow {
@@ -196,6 +199,8 @@ export function buildUsageReport(
 				COALESCE(SUM(${CT}), 0) AS cached_tokens,
 				COALESCE(SUM(${COMP}), 0) AS completion_tokens,
 				SUM(CASE WHEN ${EST} THEN 1 ELSE 0 END) AS estimated_rows,
+				SUM(CASE WHEN json_extract(features, '$.isSubagent') = 1 THEN 1 ELSE 0 END) AS subagent_rows,
+				COALESCE(SUM(CASE WHEN json_extract(features, '$.isSubagent') = 1 THEN ${USD} ELSE 0 END), 0) AS subagent_spend,
 				SUM(CASE WHEN escalation_signal IS NOT NULL THEN 1 ELSE 0 END) AS escalations,
 				SUM(CASE WHEN instr(reasons, 'failover:') > 0 THEN 1 ELSE 0 END) AS failovers,
 				SUM(CASE WHEN error IS NOT NULL THEN 1 ELSE 0 END) AS errors,
@@ -210,6 +215,8 @@ export function buildUsageReport(
 		cached_tokens: number;
 		completion_tokens: number;
 		estimated_rows: number | null;
+		subagent_rows: number | null;
+		subagent_spend: number;
 		escalations: number | null;
 		failovers: number | null;
 		errors: number | null;
@@ -327,6 +334,8 @@ export function buildUsageReport(
 			aborted: t.aborted ?? 0,
 			modelSwitches: switches,
 			cacheEstimated: (t.estimated_rows ?? 0) > 0,
+			subagentDispatches: t.subagent_rows ?? 0,
+			subagentSpendUsd: t.subagent_spend,
 		},
 		providers,
 		models,
@@ -391,6 +400,9 @@ export function reportView(r: UsageReport, opts: { maxModels?: number } = {}): R
 				.join(" · ")}`,
 		);
 	}
+	if (t.subagentDispatches > 0) {
+		summary.push(`subagents: ${num(t.subagentDispatches)} dispatches, ${usd(t.subagentSpendUsd)} (${pct(t.spendUsd > 0 ? t.subagentSpendUsd / t.spendUsd : 0)} of spend)`);
+	}
 	const a = r.anatomy;
 	if (a !== null) {
 		summary.push(

package/src/cost/types.ts

@@ -177,8 +177,11 @@ export interface ModelTrust {
 	escalations: number;
 	/** Attempts that ended in an upstream error. */
 	errors: number;
-	/** Laplace-smoothed success rate, 0-1. */
+	/** Laplace-smoothed success rate, 0-1; user verdicts weigh in at filters.feedbackWeight. */
 	successRate: number;
+	/** User verdicts in the window (/router good|bad). */
+	feedbackGood?: number;
+	feedbackBad?: number;
 	/** Mean absolute relative prediction error, for forecast calibration. */
 	meanCostError: number;
 }

package/src/router/classify.ts

@@ -166,6 +166,9 @@ export function scoreHeuristic(f: Features, cfg: RouterConfig): Classification {
 	// the served model must still accept image input — is enforced separately
 	// on `req.hasImages` in candidate selection, exactly as `classifyTask` does.
 	if (f.hasNewImage) add(W_IMAGES, "new image input");
+	if (f.readOnlyToolTail === true && cfg.classifier.readOnlyToolWeight > 0) {
+		add(-cfg.classifier.readOnlyToolWeight, "read-only tool loop (the model is looking, not deciding)");
+	}
 	if (f.toolCount > 0) add(W_TOOLS_OFFERED, `${f.toolCount} tools offered`);
 
 	score = Math.min(1, Math.max(0, score));

package/src/router/features.ts

@@ -242,6 +242,19 @@ export function extractFeatures(req: NormRequest, promptTokens: number): Feature
 		else anatomy.toolBytes += m.textBytes;
 	}
 
+	// Read-only tool loop: the assistant call behind a tool-result tail used
+	// only tools that look at things. Tool names are the harness's own; the
+	// set covers omp's built-ins and their common aliases.
+	let readOnlyToolTail = false;
+	if (isToolResultContinuation) {
+		for (let i = messages.length - 1; i >= 0; i--) {
+			const m = messages[i];
+			if (m === undefined || m.role !== "assistant") continue;
+			if (m.toolCalls.length > 0) readOnlyToolTail = m.toolCalls.every((tc) => READ_ONLY_TOOLS.has(tc.name.toLowerCase()));
+			break;
+		}
+	}
+
 	return {
 		promptTokens,
 		newContentTokens,
@@ -265,5 +278,31 @@ export function extractFeatures(req: NormRequest, promptTokens: number): Feature
 		questionCount,
 		isTerseInstruction,
 		anatomy,
+		isSubagent: req.isSubagent,
+		readOnlyToolTail,
 	};
 }
+
+/** Tools that read state without changing it, in omp, Claude Code and Hermes naming. */
+export const READ_ONLY_TOOLS: ReadonlySet<string> = new Set([
+	"read",
+	"read_file",
+	"grep",
+	"glob",
+	"ls",
+	"list",
+	"list_dir",
+	"find",
+	"lsp",
+	"ast_grep",
+	"search",
+	"web_search",
+	"web_fetch",
+	"webfetch",
+	"websearch",
+	"fetch",
+	"cat",
+	"view",
+	"inspect_image",
+	"todo",
+]);

package/src/router/index.ts

@@ -38,11 +38,18 @@ export interface RouterDeps {
  */
 const NEUTRAL_TOKENIZER = "gpt";
 
-function resolveProfile(cfg: RouterConfig, requestedModel: string): ProfileConfig {
-	const exact = cfg.profiles.find((p) => p.id === requestedModel);
-	if (exact !== undefined) return exact;
+export function resolveProfile(cfg: RouterConfig, requestedModel: string, isSubagent = false): ProfileConfig {
 	const fallback = cfg.profiles[0];
 	if (fallback === undefined) throw new Error("no router profiles configured");
+	// A subagent asking for the default profile is routed under the subagent
+	// profile when one is configured and exists; an explicit other profile
+	// (auto-max, auto-cheap) is honoured as asked.
+	const exact = cfg.profiles.find((p) => p.id === requestedModel);
+	if (isSubagent && cfg.server.subagentProfile !== "" && (exact === undefined || exact.id === fallback.id)) {
+		const sub = cfg.profiles.find((p) => p.id === cfg.server.subagentProfile);
+		if (sub !== undefined) return sub;
+	}
+	if (exact !== undefined) return exact;
 	return fallback;
 }
 
@@ -96,7 +103,7 @@ export function createRouter(deps: RouterDeps): Router {
 				req,
 				features,
 				classification,
-				profile: resolveProfile(config, req.requestedModel),
+				profile: resolveProfile(config, req.requestedModel, req.isSubagent),
 				state,
 				snapshot,
 				ledger,

package/src/router/types.ts

@@ -97,6 +97,14 @@ export interface Features {
 	 * recorded before it existed.
 	 */
 	anatomy?: PromptAnatomy;
+	/** The request came from an omp subagent (`X-Omp-Subagent`). */
+	isSubagent?: boolean;
+	/**
+	 * This is a tool-result continuation and the newest assistant turn issued
+	 * only read-only tools (read, grep, glob, ls, lsp…): the model is looking,
+	 * not deciding. Recorded for replay; scored at classifier.readOnlyToolWeight.
+	 */
+	readOnlyToolTail?: boolean;
 }
 
 /** Prompt bytes by message role and by age, plus the tool-schema bytes beside them. */

package/src/wire/openai/request.ts

@@ -292,6 +292,9 @@ export function parseChatRequest(body: unknown, headers: Headers): NormRequest {
 	// ⇒ the server falls back to its configured default scope.
 	const agentdoxScope = (headers.get("x-agentdox-scope") ?? "").trim();
 
+	// Subagent marker from the embed extension (sessions without a UI).
+	const isSubagent = (headers.get("x-omp-subagent") ?? "").trim() === "1";
+
 	if (typeof b.model !== "string" || b.model.length === 0) {
 		throw invalidRequest("model must be a non-empty string");
 	}
@@ -352,6 +355,7 @@ export function parseChatRequest(body: unknown, headers: Headers): NormRequest {
 		harnessId,
 		ompSessionId,
 		agentdoxScope,
+		isSubagent,
 		requestedModel,
 		messages,
 		tools,

package/src/wire/types.ts

@@ -82,6 +82,8 @@ export interface NormRequest {
 	 * and if that is empty too the bridge stays inert for this request.
 	 */
 	agentdoxScope: string;
+	/** `X-Omp-Subagent: 1`: the caller is an omp subagent (a session without a UI). */
+	isSubagent: boolean;
 	/** Virtual model the client selected, e.g. `auto`, `auto-cheap`, `auto-max`. */
 	requestedModel: string;
 	messages: NormMessage[];

package/test/classify.test.ts

@@ -458,3 +458,16 @@ describe("classifyTask", () => {
 		expect(classifyTask(featuresFor([SYSTEM, { role: "user", content: "explain the architecture of the system" }], []))).toBe("documentation");
 	});
 });
+
+describe("classifier.readOnlyToolWeight", () => {
+	test("subtracts only when enabled and the tail is a read-only loop", () => {
+		const base = { ...featuresFor([{ role: "user", content: "look" }]), isToolResultContinuation: true, readOnlyToolTail: true };
+		const off = scoreHeuristic(base, DEFAULT_CONFIG);
+		const cfg = structuredClone(DEFAULT_CONFIG);
+		cfg.classifier.readOnlyToolWeight = 0.1;
+		const on = scoreHeuristic(base, cfg);
+		expect(on.score).toBeCloseTo(Math.max(0, off.score - 0.1), 6);
+		expect(on.reasons.some((r) => r.includes("read-only tool loop"))).toBe(true);
+		expect(scoreHeuristic({ ...base, readOnlyToolTail: false }, cfg).score).toBeCloseTo(off.score, 6);
+	});
+});

package/test/config-wizard.test.ts

@@ -280,6 +280,7 @@ describe("runWizard", () => {
 			"", // keep apiKey
 			"", // keep harnessId
 			"", // keep maxConcurrentTurns
+			"", // keep subagentProfile
 			"s",
 		]);
 		expect(partial).toEqual({ server: { port: 9000 } });
@@ -358,7 +359,7 @@ describe("runWizard: profiles", () => {
 		const profiles = (partial ?? {})["profiles"];
 		expect(Array.isArray(profiles)).toBe(true);
 		if (!Array.isArray(profiles)) return;
-		expect(profiles).toHaveLength(3);
+		expect(profiles).toHaveLength(4);
 		expect(profiles[0]).toMatchObject({ id: "auto", contextWindow: 500000 });
 		expect(profiles[1]).toMatchObject({ id: "auto-cheap", contextWindow: 400000 });
 	});
@@ -379,8 +380,8 @@ describe("runWizard: profiles", () => {
 		const profiles = (partial ?? {})["profiles"];
 		expect(Array.isArray(profiles)).toBe(true);
 		if (!Array.isArray(profiles)) return;
-		expect(profiles).toHaveLength(4);
-		expect(profiles[3]).toEqual({
+		expect(profiles).toHaveLength(5);
+		expect(profiles[4]).toEqual({
 			id: "auto-fast",
 			name: "Auto Fast",
 			minTier: "trivial",
@@ -400,11 +401,11 @@ describe("runWizard: profiles", () => {
 		const profiles = (partial ?? {})["profiles"];
 		expect(Array.isArray(profiles)).toBe(true);
 		if (!Array.isArray(profiles)) return;
-		expect(profiles.map((p) => (p as Record<string, unknown>)["id"])).toEqual(["auto", "auto-max"]);
+		expect(profiles.map((p) => (p as Record<string, unknown>)["id"])).toEqual(["auto", "auto-max", "auto-sub"]);
 	});
 
 	test("refuses to delete the last remaining profile", async () => {
-		const { out } = await drive(["p", "x3", "x2", "x1", "b", "q"]);
+		const { out } = await drive(["p", "x4", "x3", "x2", "x1", "b", "q"]);
 		expect(out).toContain("cannot delete the last profile");
 	});
 

package/test/controls.test.ts

@@ -6,6 +6,7 @@ import { createFeedbackStore } from "../src/cost/feedback.ts";
 import { createLedger } from "../src/cost/ledger.ts";
 import { EMPTY_USAGE, type LedgerEntry } from "../src/cost/types.ts";
 import { startServer, type StartedServer } from "../src/server/http.ts";
+import { resolveProfile } from "../src/router/index.ts";
 import { ollamaRunway } from "../src/server/http.ts";
 import { createSessionOverrides, OVERRIDE_TTL_MS } from "../src/server/overrides.ts";
 import { openDb } from "../src/util/sqlite.ts";
@@ -121,7 +122,7 @@ describe("override and feedback endpoints", () => {
 	beforeAll(() => {
 		const cfg: RouterConfig = {
 			...structuredClone(DEFAULT_CONFIG),
-			server: { host: "127.0.0.1", port: 0, maxConcurrentTurns: 24 },
+			server: { host: "127.0.0.1", port: 0, maxConcurrentTurns: 24, subagentProfile: "auto-sub" },
 			ledger: { ...DEFAULT_CONFIG.ledger, path: ":memory:" },
 			logLevel: "silent",
 		};
@@ -221,3 +222,17 @@ describe("ollamaRunway", () => {
 		expect(ollamaRunway(null, 7, 1)).toBeNull();
 	});
 });
+
+describe("subagent profile", () => {
+	test("a subagent asking for the default profile is routed under server.subagentProfile; explicit profiles are honoured", () => {
+		const cfg = structuredClone(DEFAULT_CONFIG);
+		expect(resolveProfile(cfg, "auto", true).id).toBe("auto-sub");
+		expect(resolveProfile(cfg, "auto", false).id).toBe("auto");
+		expect(resolveProfile(cfg, "auto-max", true).id).toBe("auto-max");
+		expect(resolveProfile(cfg, "unknown", true).id).toBe("auto-sub"); // unknown ids fall back to the default, which a subagent remaps
+		cfg.server.subagentProfile = "";
+		expect(resolveProfile(cfg, "auto", true).id).toBe("auto");
+		cfg.server.subagentProfile = "nope";
+		expect(resolveProfile(cfg, "auto", true).id).toBe("auto");
+	});
+});

package/test/escalate.test.ts

@@ -24,6 +24,7 @@ function req(messages: NormMessage[] = [], over: Partial<NormRequest> = {}): Nor
 		harnessId: "",
 		ompSessionId: "",
 		agentdoxScope: "",
+		isSubagent: false,
 		requestedModel: "auto",
 		messages,
 		tools: [],

package/test/failover.test.ts

@@ -29,7 +29,7 @@ import type {
 
 function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 	return {
-		server: { host: "127.0.0.1", port: 8787, maxConcurrentTurns: 24 },
+		server: { host: "127.0.0.1", port: 8787, maxConcurrentTurns: 24, subagentProfile: "auto-sub" },
 		openrouter: { baseUrl: "https://openrouter.ai/api/v1", apiKey: "", title: "test", timeoutMs: 30_000, catalogTtlMs: 3_600_000, catalogRefreshMs: 0 },
 		ollama: { enabled: false, baseUrl: "http://127.0.0.1:11434/v1", apiKey: "", timeoutMs: 30_000, catalogTtlMs: 300_000, includeLocal: false, prices: {}, twins: {}, costBias: 1, biasUntilUsage: 0.9, usagePollMs: 0, quotaCooldownMs: 0, rateLimitCooldownMs: 0, planCreditsUsd: 0 },
 		benchmarks: { enabled: false, artificialAnalysisApiKey: "", benchlm: true, refreshMs: 86_400_000, timeoutMs: 30_000, useLocalScores: false },
@@ -46,7 +46,7 @@ function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 			data: { axis: "intelligence", minQuality: 0 },
 			chat: { axis: "intelligence", minQuality: 0 },
 		},
-		filters: { allow: [], deny: [], includeFree: false, requireToolSupport: true, minTrust: 0.6, minTrustSamples: 5, trustScopedByHarness: false, trustWindowDays: 0, contextHeadroom: 1.2, latencyWeight: 0, latencyReferenceMs: 5000, latencyReferenceTokensPerSec: 30, cacheReliabilityMinSamples: 10, latencyMinSamples: 20, escalationCostWeight: 0 },
+		filters: { allow: [], deny: [], includeFree: false, requireToolSupport: true, minTrust: 0.6, feedbackWeight: 0, minTrustSamples: 5, trustScopedByHarness: false, trustWindowDays: 0, contextHeadroom: 1.2, latencyWeight: 0, latencyReferenceMs: 5000, latencyReferenceTokensPerSec: 30, cacheReliabilityMinSamples: 10, latencyMinSamples: 20, escalationCostWeight: 0 },
 		classifier: {
 			ambiguityThreshold: 0,
 			model: "test/adjudicator", learnedModelPath: "",
@@ -57,7 +57,7 @@ function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 			toolAxis: "coding",
 			chatAxis: "intelligence",
 			agenticLoopDepth: 3,
-			mechanicalRetryFactor: 0.2,
+			mechanicalRetryFactor: 0.2, readOnlyToolWeight: 0,
 			reasoningWeights: { medium: 0.14, high: 0.24, xhigh: 0.3, max: 0.34 },
 		},
 		escalation: {
@@ -92,6 +92,7 @@ function mkReq(): NormRequest {
 		harnessId: "",
 		ompSessionId: "",
 		agentdoxScope: "",
+		isSubagent: false,
 		requestedModel: "auto",
 		messages: [{ role: "user", text: "hi", images: 0, textBytes: 2, toolCalls: [] }],
 		tools: [],

package/test/features.test.ts

@@ -337,3 +337,35 @@ describe("prompt anatomy", () => {
 		expect(a.olderHalfBytes).toBe(0);
 	});
 });
+
+describe("subagent and read-only tool loop signals", () => {
+	test("a tool-result tail behind read-only calls is flagged; a write call clears it", () => {
+		const reads = req([
+			SYSTEM,
+			{ role: "user", content: "find the retry helper" },
+			{ role: "assistant", content: null, tool_calls: [
+				{ id: "a", type: "function", function: { name: "grep", arguments: "{\"pattern\":\"retry\"}" } },
+				{ id: "b", type: "function", function: { name: "read", arguments: "{\"path\":\"x.ts\"}" } },
+			] },
+			{ role: "tool", tool_call_id: "a", content: "x.ts:12" },
+			{ role: "tool", tool_call_id: "b", content: "export function retry() {}" },
+		]);
+		expect(extractFeatures(reads, 1000).readOnlyToolTail).toBe(true);
+		const write = req([
+			SYSTEM,
+			{ role: "user", content: "fix it" },
+			toolCall("c", "edit", "{\"path\":\"x.ts\"}"),
+			{ role: "tool", tool_call_id: "c", content: "ok" },
+		]);
+		expect(extractFeatures(write, 1000).readOnlyToolTail).toBe(false);
+		// A fresh user turn is never a read-only tail, whatever came before.
+		expect(extractFeatures(req([SYSTEM, { role: "user", content: "now what?" }]), 100).readOnlyToolTail).toBe(false);
+	});
+
+	test("the subagent marker rides on the request", () => {
+		const r = parseChatRequest({ model: "auto", messages: [SYSTEM, { role: "user", content: "hi" }], tools: TOOLS }, new Headers({ "x-omp-subagent": "1" }));
+		expect(r.isSubagent).toBe(true);
+		expect(extractFeatures(r, 100).isSubagent).toBe(true);
+		expect(req([SYSTEM, { role: "user", content: "hi" }]).isSubagent).toBe(false);
+	});
+});

package/test/http-resilience.test.ts

@@ -10,7 +10,7 @@ describe("HTTP server resilience against dead streams", () => {
 	beforeAll(() => {
 		const cfg: RouterConfig = {
 			...DEFAULT_CONFIG,
-			server: { host: "127.0.0.1", port: 0, maxConcurrentTurns: 24 },
+			server: { host: "127.0.0.1", port: 0, maxConcurrentTurns: 24, subagentProfile: "auto-sub" },
 			ledger: { ...DEFAULT_CONFIG.ledger, path: ":memory:" },
 			context: { ...DEFAULT_CONFIG.context, enabled: false },
 			logLevel: "silent",

package/test/report-hub.test.ts

@@ -76,6 +76,8 @@ function report(over: Partial<UsageReport> = {}): UsageReport {
 			aborted: 0,
 			modelSwitches: 1,
 			cacheEstimated: false,
+			subagentDispatches: 0,
+			subagentSpendUsd: 0,
 		},
 		providers: [row("openrouter", 2), row("ollama", 1)],
 		models: [

package/test/report.test.ts

@@ -197,6 +197,18 @@ describe("buildUsageReport", () => {
 		db.close();
 	});
 
+	test("subagent turns are counted with their spend", () => {
+		const { db, ledger } = seeded();
+		ledger.record(entry({ reportedUsd: 0.01, features: { isSubagent: true } }));
+		ledger.record(entry({ reportedUsd: 0.03, features: { isSubagent: false } }));
+		ledger.record(entry({ reportedUsd: 0.06 }));
+		const r = buildUsageReport(db, { windowDays: 7, nowMs: NOW });
+		expect(r.totals.subagentDispatches).toBe(1);
+		expect(r.totals.subagentSpendUsd).toBeCloseTo(0.01, 6);
+		expect(renderUsageReport(r)).toContain("subagents: 1 dispatches, $0.0100 (10% of spend)");
+		db.close();
+	});
+
 	test("empty ledger yields zeroed totals and null speeds", () => {
 		const { db } = seeded();
 		const r = buildUsageReport(db, { windowDays: 7, nowMs: NOW });
@@ -213,6 +225,8 @@ describe("buildUsageReport", () => {
 			aborted: 0,
 			modelSwitches: 0,
 			cacheEstimated: false,
+			subagentDispatches: 0,
+			subagentSpendUsd: 0,
 		});
 		expect(r.providers).toEqual([]);
 		expect(r.models).toEqual([]);

package/test/trust-attribution.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, test } from "bun:test";
+import { createFeedbackStore } from "../src/cost/feedback.ts";
 
 import { loadConfig } from "../src/config/load.ts";
 import { createLedger, LATENCY_WINDOW_ROWS } from "../src/cost/ledger.ts";
@@ -410,3 +411,55 @@ describe("cache reliability signal", () => {
 		db.close();
 	});
 });
+
+describe("feedback in trust", () => {
+	// A user verdict counts as filters.feedbackWeight attempts of that outcome.
+	function trustWith(weight: number, verdicts: Array<"good" | "bad">): { rate: number; good: number; bad: number } {
+		const db = openDb(":memory:");
+		try {
+			const c = structuredClone(cfg);
+			c.filters.feedbackWeight = weight;
+			const ledger = createLedger(db, c);
+			const fb = createFeedbackStore(db);
+			let last = "";
+			for (let i = 0; i < 10; i++) {
+				const e = entry({ error: null });
+				last = e.id;
+				ledger.record(e);
+			}
+			for (const v of verdicts) fb.record({ ledgerId: last, ompSessionId: "s", slug: "vendor/model", tier: "simple", verdict: v, note: "" });
+			const t = ledger.trust("vendor/model")!;
+			return { rate: t.successRate, good: t.feedbackGood ?? -1, bad: t.feedbackBad ?? -1 };
+		} finally {
+			db.close();
+		}
+	}
+
+	test("weight 0 records verdicts without moving the rate", () => {
+		const base = trustWith(0, []);
+		expect(base.rate).toBeCloseTo(11 / 12, 6); // (10 - 0 + 1) / (10 + 2)
+		expect(trustWith(0, ["bad", "bad"]).rate).toBeCloseTo(base.rate, 6);
+	});
+
+	test("a bad verdict counts as `weight` failures, a good one as `weight` successes", () => {
+		// 10 clean attempts + one bad verdict at weight 3: attempts 13, failures 3.
+		const bad = trustWith(3, ["bad"]);
+		expect(bad.rate).toBeCloseTo((13 - 3 + 1) / (13 + 2), 6);
+		expect(bad.bad).toBe(1);
+		const good = trustWith(3, ["good"]);
+		expect(good.rate).toBeCloseTo((13 - 0 + 1) / (13 + 2), 6);
+		expect(good.good).toBe(1);
+		// allTrust and signals agree with trust().
+		const db = openDb(":memory:");
+		const c = structuredClone(cfg);
+		c.filters.feedbackWeight = 3;
+		const ledger = createLedger(db, c);
+		const fb = createFeedbackStore(db);
+		const e = entry({ error: null });
+		ledger.record(e);
+		fb.record({ ledgerId: e.id, ompSessionId: "s", slug: "vendor/model", tier: "simple", verdict: "bad", note: "" });
+		expect(ledger.allTrust()[0]?.successRate).toBeCloseTo(ledger.trust("vendor/model")!.successRate, 9);
+		expect(ledger.signals?.(["vendor/model"]).get("vendor/model")?.trust?.successRate).toBeCloseTo(ledger.trust("vendor/model")!.successRate, 9);
+		db.close();
+	});
+});

package/test/turn.test.ts

@@ -29,7 +29,7 @@ import type {
 
 function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 	return {
-		server: { host: "127.0.0.1", port: 8787, maxConcurrentTurns: 24 },
+		server: { host: "127.0.0.1", port: 8787, maxConcurrentTurns: 24, subagentProfile: "auto-sub" },
 		openrouter: { baseUrl: "https://openrouter.ai/api/v1", apiKey: "", title: "test", timeoutMs: 30_000, catalogTtlMs: 3_600_000, catalogRefreshMs: 0 },
 		ollama: { enabled: false, baseUrl: "http://127.0.0.1:11434/v1", apiKey: "", timeoutMs: 30_000, catalogTtlMs: 300_000, includeLocal: false, prices: {}, twins: {}, costBias: 1, biasUntilUsage: 0.9, usagePollMs: 0, quotaCooldownMs: 0, rateLimitCooldownMs: 0, planCreditsUsd: 0 },
 		benchmarks: { enabled: false, artificialAnalysisApiKey: "", benchlm: true, refreshMs: 86_400_000, timeoutMs: 30_000, useLocalScores: false },
@@ -46,7 +46,7 @@ function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 			data: { axis: "intelligence", minQuality: 0 },
 			chat: { axis: "intelligence", minQuality: 0 },
 		},
-		filters: { allow: [], deny: [], includeFree: false, requireToolSupport: true, minTrust: 0.6, minTrustSamples: 5, trustScopedByHarness: false, trustWindowDays: 0, contextHeadroom: 1.2, latencyWeight: 0, latencyReferenceMs: 5000, latencyReferenceTokensPerSec: 30, cacheReliabilityMinSamples: 10, latencyMinSamples: 20, escalationCostWeight: 0 },
+		filters: { allow: [], deny: [], includeFree: false, requireToolSupport: true, minTrust: 0.6, feedbackWeight: 0, minTrustSamples: 5, trustScopedByHarness: false, trustWindowDays: 0, contextHeadroom: 1.2, latencyWeight: 0, latencyReferenceMs: 5000, latencyReferenceTokensPerSec: 30, cacheReliabilityMinSamples: 10, latencyMinSamples: 20, escalationCostWeight: 0 },
 		classifier: {
 			ambiguityThreshold: 0,
 			model: "test/adjudicator", learnedModelPath: "",
@@ -57,7 +57,7 @@ function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 			toolAxis: "coding",
 			chatAxis: "intelligence",
 			agenticLoopDepth: 3,
-			mechanicalRetryFactor: 0.2,
+			mechanicalRetryFactor: 0.2, readOnlyToolWeight: 0,
 			reasoningWeights: { medium: 0.14, high: 0.24, xhigh: 0.3, max: 0.34 },
 		},
 		escalation: {
@@ -92,6 +92,7 @@ function mkReq(): NormRequest {
 		harnessId: "",
 		ompSessionId: "",
 		agentdoxScope: "",
+		isSubagent: false,
 		requestedModel: "auto",
 		messages: [{ role: "user", text: "hi", images: 0, textBytes: 2, toolCalls: [] }],
 		tools: [],

package/tools/replay.ts

@@ -197,6 +197,7 @@ function requestOf(row: Row, f: Features): NormRequest {
 		harnessId: row.harness_id,
 		ompSessionId: "",
 		agentdoxScope: "",
+		isSubagent: false,
 		requestedModel: row.requested_model,
 		messages,
 		tools,