auto-model-router 0.14.0 → 0.16.0

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.14.0",
+    "version": "0.16.0",
     "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.14.0",
+      "version": "0.16.0",
       "author": {
         "name": "drewappling",
         "email": "drewappling@gmail.com"

package/README.md

@@ -710,8 +710,12 @@ escalation signal, error. Three views aggregate it, all from the same
   and model (dispatches, tokens, spend, escalations, errors) as CSV. Also
   `GET /v1/router/export?days=&harness=[&format=json]`; `GET /v1/router/spend?sinceMs=&harness=`
   gives spend over a harness set since an instant, and `GET /v1/router/feedback?days=&harness=`
-  lists verdicts by model and the recent ones with the harness that gave them. These are what
-  a front door such as the team edition reads instead of the ledger file.
+  lists verdicts by model and the recent ones with the harness that gave them, and
+  `GET /v1/router/decisions?harness=&days=|since=&slug=&tier=&limit=` is the decision trail
+  itself, newest first, each turn with its reasons, the classifier's view, forecast against
+  bill, escalation signal and verdicts (`?session=` narrows to one omp session, as `/router
+  why` does). These are what a front door such as the team edition reads instead of the
+  ledger file.
 - `GET /v1/router/report?days=7&harness=<id>` for dashboards (`harness` may be
   a comma-separated set of ids, for a group).
 - `GET /v1/router/summary?harness=<id>` — the daily summary as JSON (`auto=1`
@@ -1515,6 +1519,28 @@ them, injecting one project's context into another's work. A single configured t
 grants only the scopes it was minted for; for any other project the bridge degrades to inert
 rather than writing somewhere wrong.
 
+### Layers a team names around the project scope
+
+A front door such as the team edition can wrap the project scope in two more
+layers, named per request in headers next to `X-Agentdox-Scope`:
+
+| Header | What agentdox renders |
+| --- | --- |
+| `X-Agentdox-Group` | the group's context — its brief and top memory — **first**, as `# Group context: <group>` |
+| `X-Agentdox-Personal` | the member's own thread in the project — the entry tagged `handoff` whole, then the rest — **last**, as `# Your thread in <scope>` |
+
+Both go through the same slug rule as the scope (absent or invalid ⇒ empty ⇒ not
+sent). The member is the harness id (`X-Omp-Harness`, which the team sets from the
+authenticated key): when either layer is named it is sent as `user` too, and agentdox
+keeps the project layer's recent tail to that member's own turns. It is never sent on
+its own — a router without a team still has a harness id (Claude Code's is derived,
+omp's is configured) and must not have its tail filtered to one harness. Every
+recorded message carries a `user:<harness id>` ref alongside `model:` and `tier:`
+whenever there is a harness id, team or not; it is just another ref. A router without
+a team posts exactly what it always did, so its block is byte-identical; an older
+agentdox ignores the keys it does not know. `context.layers: false` is the kill
+switch — the headers are still parsed but nothing new goes to agentdox.
+
 ### It does not cost you a cache miss per turn
 
 The context block sits at the front of the prompt, so re-fetching it every turn
@@ -1545,7 +1571,8 @@ block lands inside the prefix `planCacheBreakpoints` already marks.
 ### Turns are recorded back, attributed to the model that served them
 
 With `context.recordTurns` (default on), each settled turn is written to an
-agentdox session tagged `model:<slug>` and `tier:<tier>` — a transcript that
+agentdox session tagged `model:<slug>` and `tier:<tier>` (plus `user:<harness id>`
+when the request carried one) — a transcript that
 shows which model produced which turn. Those messages feed back into the next
 `context_assemble`, so the model you switch *to* inherits what the model you
 switched *from* actually did.

package/package.json

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

package/src/cli/config-wizard.ts

@@ -300,6 +300,7 @@ export const WIZARD_SECTIONS: readonly SectionSpec[] = [
 			{ path: "context.docsLimit", label: "Doc items", kind: "number", min: 0 },
 			{ path: "context.sessionLimit", label: "Session items", kind: "number", min: 0 },
 			{ path: "context.briefChars", label: "Brief chars", kind: "number", min: 0 },
+			{ path: "context.layers", label: "Send team context layers", kind: "boolean" },
 			{ path: "context.recordTurns", label: "Record turns back", kind: "boolean" },
 			{ path: "context.injectWithoutTools", label: "Inject into tool-less calls", kind: "boolean" },
 			{ path: "context.maxQueue", label: "Write-back queue", kind: "number", min: 1 },

package/src/config/defaults.ts

@@ -265,6 +265,10 @@ export const DEFAULT_CONFIG: RouterConfig = {
 		// statics + all 14 decisions) inside a 24k block while leaving ~15k for
 		// the query-relevant memory/docs tail. 0 omits the brief.
 		briefChars: 12_000,
+		// Group / personal / user layers named by a team front door. On, because
+		// a router that is not behind one has no layer names to send and posts
+		// exactly what it did before; off only sends none when a team does.
+		layers: true,
 		recordTurns: true,
 		// A request with no tool schemas is a harness utility call — omp asks for
 		// a session title or a complexity rating through the same provider — and

package/src/config/schema.ts

@@ -228,6 +228,7 @@ const context = z.strictObject({
 	docsLimit: z.number().int().nonnegative().optional(),
 	sessionLimit: z.number().int().nonnegative().optional(),
 	briefChars: z.number().int().nonnegative().optional(),
+	layers: z.boolean().optional(),
 	recordTurns: z.boolean().optional(),
 	injectWithoutTools: z.boolean().optional(),
 	maxQueue: z.number().int().positive().optional(),

package/src/config/types.ts

@@ -767,6 +767,15 @@ export interface ContextConfig {
 	 * query-relevant tail always fits too.
 	 */
 	briefChars: number;
+	/**
+	 * Send the context layers a front door names on the request — the group
+	 * scope (`X-Agentdox-Group`, rendered first), the personal scope
+	 * (`X-Agentdox-Personal`, rendered last) and the member (the harness id,
+	 * which filters the project's recent tail and tags recorded turns). A
+	 * router without a team has none to send and its block is unchanged; this
+	 * is the kill switch for a team that wants single-scope blocks back.
+	 */
+	layers: boolean;
 	/** Write settled turns back to agentdox sessions, tagged with the served model. */
 	recordTurns: boolean;
 	/**

package/src/context/agentdox.ts

@@ -24,13 +24,29 @@ export interface AssembleLimits {
 	briefChars: number;
 }
 
+/**
+ * The layers around the project scope (project memory, phase one). Each is a
+ * name the team derives; empty means "not present" and is NOT sent, so a lone
+ * router's request body — and therefore its block — is byte-identical to
+ * before. An agentdox that predates layers ignores the keys it does not know.
+ */
+export interface AssembleLayers {
+	/** Scope whose brief and top memory render first, as group context. */
+	group: string;
+	/** Scope whose memory (handoff note first) renders last, as the member's own thread. */
+	personal: string;
+	/** The member: the project layer's recent tail is filtered to messages tagged `user:<user>`. */
+	user: string;
+}
+
 export interface AgentDoxClient {
 	/**
 	 * Assembles a context slice for `scope`, biased by `query`. Falls back to
 	 * the server's pre-assembled baseline when assembly is unavailable (older
-	 * server, or no query-relevant content).
+	 * server, or no query-relevant content). `layers` adds the group and
+	 * personal scopes around it; absent or all-empty sends nothing extra.
 	 */
-	assemble(scope: string, query: string, limits: AssembleLimits): Promise<string | null>;
+	assemble(scope: string, query: string, limits: AssembleLimits, layers?: AssembleLayers): Promise<string | null>;
 	createSession(scope: string, title: string): Promise<string | null>;
 	append(sessionId: string, role: "user" | "assistant", content: string, refs: string[]): Promise<boolean>;
 }
@@ -84,11 +100,13 @@ export function createAgentDoxClient(opts: AgentDoxClientOptions): AgentDoxClien
 	};
 
 	return {
-		async assemble(scope, query, limits) {
+		async assemble(scope, query, limits, layers) {
 			// camelCase: the REST endpoint ignores snake_case limit keys entirely,
 			// which silently reads as "unbounded". briefChars is sent even when 0:
 			// an older server ignores the unknown key, and 0 is the documented
-			// "no brief" value there.
+			// "no brief" value there. The layer keys are the opposite: only sent
+			// when non-empty, so a router without a team posts exactly what it
+			// always did.
 			const res = await request("POST", "/context/assemble", {
 				scope,
 				query,
@@ -96,6 +114,9 @@ export function createAgentDoxClient(opts: AgentDoxClientOptions): AgentDoxClien
 				docsLimit: limits.docsLimit,
 				sessionLimit: limits.sessionLimit,
 				briefChars: limits.briefChars,
+				...(layers === undefined || layers.group === "" ? {} : { group: layers.group }),
+				...(layers === undefined || layers.personal === "" ? {} : { personal: layers.personal }),
+				...(layers === undefined || layers.user === "" ? {} : { user: layers.user }),
 			});
 			if (res !== null && res.status === 200) {
 				const prompt = promptOf(res.json);

package/src/context/bridge.ts

@@ -40,6 +40,12 @@ export interface BridgeOptions {
 	sessionLimit: number;
 	/** Character budget for the project brief rendered first in the block; 0 omits it. */
 	briefChars: number;
+	/**
+	 * Send the group / personal / user layers a front door names (project
+	 * memory, phase one). False is the kill switch: none of the new assemble
+	 * fields go out, whatever the request headers say.
+	 */
+	layers: boolean;
 	/** Record settled turns back into agentdox sessions. */
 	recordTurns: boolean;
 	/** Bound on queued write-backs; excess is dropped rather than grown unbounded. */
@@ -83,7 +89,7 @@ function appendFragment(prior: string, next: string): string {
 }
 
 export function createContextBridge(opts: BridgeOptions): ContextBridge {
-	const { client, store, log, maxStalenessMs, maxBlockChars, memoryLimit, docsLimit, sessionLimit, briefChars, recordTurns, maxQueue } = opts;
+	const { client, store, log, maxStalenessMs, maxBlockChars, memoryLimit, docsLimit, sessionLimit, briefChars, layers, recordTurns, maxQueue } = opts;
 
 	// Serialized write-back queue. Session appends for one conversation must
 	// stay ordered, and agentdox is a local service — one worker is plenty.
@@ -124,12 +130,26 @@ export function createContextBridge(opts: BridgeOptions): ContextBridge {
 			// Recent sessions only on a conversation's first block: after that they
 			// are this conversation's own recorded turns, duplicating the prompt
 			// and changing on every refresh (measured 1.4-1.9k chars per block).
-			const raw = await client.assemble(input.scope, input.query, {
-				memoryLimit,
-				docsLimit,
-				sessionLimit: input.firstFetch ? sessionLimit : 0,
-				briefChars,
-			});
+			// The layers around the project scope ride along only while enabled.
+			// The block's version is a hash of its content, so a personal layer
+			// pins a different block per member and never shares one across them.
+			// `user` goes only behind a front door that named a layer: a router
+			// on its own still has a harness id (Claude Code's is derived, omp's
+			// is configured), and against a new agentdox that would filter the
+			// project's recent tail to that harness — a change the lone install
+			// never asked for.
+			const fronted = input.group !== "" || input.personal !== "";
+			const raw = await client.assemble(
+				input.scope,
+				input.query,
+				{
+					memoryLimit,
+					docsLimit,
+					sessionLimit: input.firstFetch ? sessionLimit : 0,
+					briefChars,
+				},
+				layers ? { group: input.group, personal: input.personal, user: fronted ? input.user : "" } : undefined,
+			);
 			if (raw === null) {
 				// agentdox unreachable or empty. Keep serving the pinned block if we
 				// have one: stale shared context beats none, and re-using it also
@@ -204,8 +224,13 @@ export function createContextBridge(opts: BridgeOptions): ContextBridge {
 					// Model attribution rides on refs, which agentdox already carries
 					// per message. This is what makes the transcript newly useful:
 					// every turn shows WHICH model produced it.
-					const refs = [`model:${rec.slug}`, `tier:${rec.tier}`];
-					if (rec.userText !== "") await client.append(sessionId, "user", rec.userText, []);
+					// The member rides on refs too, on BOTH messages: agentdox filters
+					// a project's recent tail to `user:<id>`, and a tail is user and
+					// assistant turns alike. A lone router has no harness id and
+					// adds nothing.
+					const who = rec.harnessId === "" ? [] : [`user:${rec.harnessId}`];
+					const refs = [`model:${rec.slug}`, `tier:${rec.tier}`, ...who];
+					if (rec.userText !== "") await client.append(sessionId, "user", rec.userText, who);
 					if (assistantText !== "") await client.append(sessionId, "assistant", assistantText, refs);
 				})
 				.catch((err: unknown) => {

package/src/context/index.ts

@@ -72,6 +72,7 @@ function buildBridge(cfg: RouterConfig, db: Database): ContextBridge {
 		docsLimit: c.docsLimit,
 		sessionLimit: c.sessionLimit,
 		briefChars: c.briefChars,
+		layers: c.layers,
 		recordTurns: c.recordTurns,
 		maxQueue: c.maxQueue,
 	});

package/src/context/types.ts

@@ -47,12 +47,32 @@ export interface ContextResolveInput {
 	 * the prompt already holds.
 	 */
 	firstFetch: boolean;
+	/**
+	 * Group-context scope (rendered first) from `X-Agentdox-Group`. Empty ⇒ no
+	 * group layer is requested and nothing new is sent.
+	 */
+	group: string;
+	/** Personal scope (rendered last) from `X-Agentdox-Personal`. Empty ⇒ no personal layer. */
+	personal: string;
+	/**
+	 * The member this turn belongs to — the harness id, which a team front door
+	 * sets per user. agentdox filters the project layer's recent tail to that
+	 * member's own turns. Sent only when `group` or `personal` is also named:
+	 * a lone router has a harness id too and must not filter its own tail.
+	 */
+	user: string;
 }
 
 /** One settled turn, recorded to agentdox with the model that served it. */
 export interface TurnRecord {
 	scope: string;
 	conversationKey: string;
+	/**
+	 * The harness id, which a team front door sets per user. Non-empty ⇒ every
+	 * recorded message also carries a `user:<harnessId>` ref, so the member's
+	 * own turns can be told apart in a shared project session.
+	 */
+	harnessId: string;
 	/** Title used if this is the first turn and a session must be created. */
 	title: string;
 	userText: string;

package/src/cost/ledger.ts

@@ -65,7 +65,7 @@ const CACHE_RELIABILITY_MEMO_MS = 60_000;
 const DAY_MS = 86_400_000;
 
 // Row shapes below are fixed by our own schema in util/sqlite.ts.
-interface LedgerRow {
+export interface LedgerRow {
 	id: string;
 	created_at_ms: number;
 	conversation_key: string;
@@ -240,7 +240,7 @@ function toLatency(slug: string, row: LatencyRow): ModelLatency | null {
 	return { slug, samples: row.samples, ttftMs: row.ttft_ms, tokensPerSec };
 }
 
-function toEntry(row: LedgerRow): LedgerEntry {
+export function toEntry(row: LedgerRow): LedgerEntry {
 	return {
 		id: row.id,
 		createdAtMs: row.created_at_ms,

package/src/cost/views.ts

@@ -10,7 +10,9 @@
 
 import { providerOfSlug } from "./report.ts";
 import type { Database } from "bun:sqlite";
+import { toEntry, type LedgerRow } from "./ledger.ts";
 import { harnessFilter } from "./report.ts";
+import type { LedgerEntry } from "./types.ts";
 
 /** `null` means every harness; an empty set matches nothing. */
 export type HarnessScope = readonly string[] | null;
@@ -61,6 +63,68 @@ function scope(harness: HarnessScope, column: string): { sql: string[]; bind: Re
 	return { sql: f.sql.map((s) => s.replace(/^harness_id/, column)), bind: f.bind };
 }
 
+/** A ledger entry as the decision explorer shows it: the entry itself plus the verdicts given on it. */
+export type DecisionEntry = LedgerEntry & { feedback: { verdict: "good" | "bad"; note: string; createdAtMs: number }[] };
+
+export interface DecisionFilter {
+	/** Entries at or after this instant; 0 for everything the ledger still holds. */
+	sinceMs: number;
+	/** The harness set; null for every harness, an empty list for none. */
+	harness: HarnessScope;
+	/** At most this many, newest first; 1..1000. */
+	limit?: number;
+	/** Only turns dispatched to (or served by) this slug. */
+	slug?: string;
+	/** Only turns classified at this tier. */
+	tier?: string;
+	/** Only one omp session (`/router why`). */
+	ompSessionId?: string;
+}
+
+/**
+ * Turns, newest first, over a harness set: what `GET /v1/router/decisions` serves and what a
+ * front door reads from the ledger file. Every field the decision trail needs is here — the
+ * reasons, the classifier's view, the cost forecast against the bill, the escalation signal —
+ * and the verdicts `/router good|bad` recorded against each turn ride along.
+ */
+export function decisionEntries(db: Database, filter: DecisionFilter): DecisionEntry[] {
+	const s = scope(filter.harness, "harness_id");
+	if (s === null) return [];
+	const where = ["created_at_ms >= $since", ...s.sql];
+	const bind: Record<string, string | number> = { $since: filter.sinceMs, ...s.bind };
+	if (filter.slug !== undefined && filter.slug !== "") {
+		where.push("(slug = $slug OR served_slug = $slug)");
+		bind.$slug = filter.slug;
+	}
+	if (filter.tier !== undefined && filter.tier !== "") {
+		where.push("tier = $tier");
+		bind.$tier = filter.tier;
+	}
+	if (filter.ompSessionId !== undefined && filter.ompSessionId !== "") {
+		where.push("omp_session_id = $session");
+		bind.$session = filter.ompSessionId;
+	}
+	const limit = Math.min(Math.max(filter.limit ?? 50, 1), 1_000);
+	const rows = db.query(`SELECT * FROM ledger WHERE ${where.join(" AND ")} ORDER BY created_at_ms DESC LIMIT ${limit}`).all(bind) as LedgerRow[];
+	const entries = rows.map(toEntry);
+	if (entries.length === 0) return [];
+	// Verdicts, when the feedback table exists (it does not on a ledger no one has judged).
+	const hasFeedback = (db.query("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'feedback'").get() as { name: string } | null) !== null;
+	const verdicts = new Map<string, DecisionEntry["feedback"]>();
+	if (hasFeedback) {
+		const ids = entries.map((e) => e.id);
+		const marks = ids.map((_, i) => `$f${i}`).join(", ");
+		const fb: Record<string, string> = {};
+		ids.forEach((id, i) => (fb[`$f${i}`] = id));
+		for (const r of db.query(`SELECT ledger_id, verdict, note, created_at_ms FROM feedback WHERE ledger_id IN (${marks}) ORDER BY created_at_ms ASC`).all(fb) as { ledger_id: string; verdict: string; note: string; created_at_ms: number }[]) {
+			const list = verdicts.get(r.ledger_id) ?? [];
+			list.push({ verdict: r.verdict === "good" ? "good" : "bad", note: r.note, createdAtMs: r.created_at_ms });
+			verdicts.set(r.ledger_id, list);
+		}
+	}
+	return entries.map((e) => ({ ...e, feedback: verdicts.get(e.id) ?? [] }));
+}
+
 /** Spend (reported where present, predicted otherwise) since `sinceMs`, digest calls included as the ledger counts them. */
 export function spendUsdSince(db: Database, sinceMs: number, harness: HarnessScope): number {
 	const s = scope(harness, "harness_id");

package/src/lib.ts

@@ -22,7 +22,7 @@ export type { DeepPartial } from "./config/load.ts";
 export { buildUsageReport, renderUsageReport, type UsageReport, type ReportTotals } from "./cost/report.ts";
 export { buildDailySummary, renderDailySummary, type DailySummary } from "./cost/summary.ts";
 export { openDb } from "./util/sqlite.ts";
-export { spendUsdSince, feedbackView, exportRows, exportCsv, harnessScopeParam, type HarnessScope, type ExportRow, type FeedbackRow, type FeedbackByModel, type FeedbackView } from "./cost/views.ts";
+export { spendUsdSince, feedbackView, exportRows, exportCsv, decisionEntries, harnessScopeParam, type HarnessScope, type ExportRow, type FeedbackRow, type FeedbackByModel, type FeedbackView, type DecisionEntry, type DecisionFilter } from "./cost/views.ts";
 export { createLedger } from "./cost/ledger.ts";
 export { createFeedbackStore, type FeedbackStore, type FeedbackRecord } from "./cost/feedback.ts";
 export { buildExecutable, collectPackageFiles, executableFileName, hostTarget, isExecutableTarget, EXECUTABLE_TARGETS, type ExecutableTarget, type BuildExecutableResult } from "./cli/build-executable.ts";

package/src/server/advise.ts

@@ -50,6 +50,8 @@ function requestOf(req: AdviseRequest): NormRequest {
 		harnessId: req.harnessId,
 		ompSessionId: req.ompSessionId,
 		agentdoxScope: "",
+		agentdoxGroup: "",
+		agentdoxPersonal: "",
 		isSubagent: false,
 		requestedModel: "auto",
 		messages: [

package/src/server/digest.ts

@@ -99,6 +99,8 @@ function syntheticRequest(req: DigestRequest, promptText: string): NormRequest {
 		harnessId: req.harnessId,
 		ompSessionId: req.ompSessionId,
 		agentdoxScope: "",
+		agentdoxGroup: "",
+		agentdoxPersonal: "",
 		isSubagent: true,
 		requestedModel: "digest",
 		messages: [

package/src/server/http.ts

@@ -10,7 +10,7 @@ import { createDigester } from "./digest.ts";
 import { advise } from "./advise.ts";
 import { TIER_ORDER, type Tier } from "../router/types.ts";
 import { baselinePrices, buildUsageReport, renderUsageReport } from "../cost/report.ts";
-import { exportCsv, exportRows, feedbackView, harnessScopeParam, spendUsdSince } from "../cost/views.ts";
+import { decisionEntries, exportCsv, exportRows, feedbackView, harnessScopeParam, spendUsdSince } from "../cost/views.ts";
 import { anthropicErrorResponse, countAnthropicTokens, createMessagesWire } from "../wire/anthropic/messages.ts";
 import { buildDailySummary, createKv, markSummaryShown, renderDailySummary, summaryDue, summaryHasNews, type SummaryOllama } from "../cost/summary.ts";
 import type { Ledger, ModelTrust } from "../cost/types.ts";
@@ -555,13 +555,24 @@ export function startServer(cfg: RouterConfig): StartedServer {
 					return json({ due: true, summary });
 				}
 				if (req.method === "GET" && url.pathname === "/v1/router/decisions") {
+					// The decision trail, newest first. ?session=<omp session id> narrows to one
+					// session (/router why); ?harness=a,b to a harness set (a team's user or group),
+					// ?since=<ms> or ?days=N to a window, ?slug= and ?tier= to a model or a tier.
 					const rawLimit = url.searchParams.get("limit");
 					const parsed = rawLimit === null ? 50 : Number.parseInt(rawLimit, 10);
 					const limit = Number.isInteger(parsed) ? Math.min(Math.max(parsed, 1), 1_000) : 50;
-					// ?session=<omp session id> narrows to one session (/router why).
-					const session = url.searchParams.get("session") ?? "";
-					const entries = session === "" ? ledger.recentEntries(limit) : (ledger.entriesForSession?.(session, limit) ?? []);
-					return json({ entries: entries.map((e) => ({ ...e, feedback: feedback.forLedgerId(e.id) })) });
+					const sinceRaw = Number.parseInt(url.searchParams.get("since") ?? "", 10);
+					const daysRaw = url.searchParams.get("days");
+					const sinceMs = Number.isFinite(sinceRaw) ? sinceRaw : daysRaw === null ? 0 : Date.now() - clampDays(daysRaw, 30) * 86_400_000;
+					const entries = decisionEntries(db, {
+						sinceMs,
+						harness: harnessScopeParam(url.searchParams.get("harness")),
+						limit,
+						slug: url.searchParams.get("slug") ?? "",
+						tier: url.searchParams.get("tier") ?? "",
+						ompSessionId: url.searchParams.get("session") ?? "",
+					});
+					return json({ entries });
 				}
 				if (url.pathname === "/v1/router/override") {
 					// Per-session pin / tier overrides from omp. GET shows, POST sets or clears.

package/src/server/turn.ts

@@ -225,6 +225,11 @@ export async function runTurn(
 				retrying: attempt > 0,
 				query: relevanceQuery(req),
 				firstFetch: state.contextVersion === null,
+				// Layer names come from the front door's headers; the member is the
+				// harness id it set. All empty on a router without a team.
+				group: req.agentdoxGroup,
+				personal: req.agentdoxPersonal,
+				user: req.harnessId,
 			});
 			if (pin !== null) {
 				contextBlock = pin.block;
@@ -673,6 +678,7 @@ export async function runTurn(
 			bridge.recordTurn({
 				scope: doxScope,
 				conversationKey: req.conversationKey,
+				harnessId: req.harnessId,
 				title: sessionTitle(req),
 				userText,
 				assistantText,

package/src/wire/openai/request.ts

@@ -335,6 +335,12 @@ export function parseChatRequest(body: unknown, headers: Headers): NormRequest {
 	// back to its configured default scope.
 	const agentdoxScope = acceptScope(headers.get("x-agentdox-scope"));
 
+	// Layered project memory (team edition): the group-context scope rendered
+	// first and the member's personal scope rendered last. A lone router never
+	// sees these headers; empty means "not sent", so the block is unchanged.
+	const agentdoxGroup = acceptScope(headers.get("x-agentdox-group"));
+	const agentdoxPersonal = acceptScope(headers.get("x-agentdox-personal"));
+
 	// Subagent marker from the embed extension (sessions without a UI).
 	const isSubagent = (headers.get("x-omp-subagent") ?? "").trim() === "1";
 
@@ -401,6 +407,8 @@ export function parseChatRequest(body: unknown, headers: Headers): NormRequest {
 		harnessId,
 		ompSessionId,
 		agentdoxScope,
+		agentdoxGroup,
+		agentdoxPersonal,
 		isSubagent,
 		...(policy === undefined ? {} : { policy }),
 		requestedModel,

package/src/wire/types.ts

@@ -96,6 +96,19 @@ export interface NormRequest {
 	 * and if that is empty too the bridge stays inert for this request.
 	 */
 	agentdoxScope: string;
+	/**
+	 * agentdox group-context scope from the `X-Agentdox-Group` request header,
+	 * set by a front door such as the team edition: the scope whose brief and
+	 * top memory render FIRST in the block. Empty when absent or not a slug,
+	 * which sends nothing, so a lone router's block is unchanged.
+	 */
+	agentdoxGroup: string;
+	/**
+	 * agentdox personal scope from the `X-Agentdox-Personal` request header:
+	 * one member's own thread in the project (their handoff note first), which
+	 * renders LAST. Empty when absent or not a slug ⇒ no personal layer.
+	 */
+	agentdoxPersonal: string;
 	/** `X-Omp-Subagent: 1`: the caller is an omp subagent (a session without a UI). */
 	isSubagent: boolean;
 	/**

package/test/anthropic-wire.test.ts

@@ -138,6 +138,22 @@ describe("parseMessagesRequest", () => {
 		expect(anthropicIdentityHeaders({}, new Headers({ "user-agent": "python-requests" })).get("x-omp-harness")).toBe("anthropic");
 	});
 
+	test("the agentdox scope and layer headers reach the request on the Anthropic path too", () => {
+		const plain = parseMessagesRequest(CLAUDE_CODE_BODY, new Headers({ "user-agent": "claude-cli/2.1.263" }));
+		expect(plain.agentdoxScope).toBe("");
+		expect(plain.agentdoxGroup).toBe("");
+		expect(plain.agentdoxPersonal).toBe("");
+		const team = parseMessagesRequest(
+			CLAUDE_CODE_BODY,
+			new Headers({ "user-agent": "claude-cli/2.1.263", "x-omp-harness": "u_ada", "x-agentdox-scope": "proj", "x-agentdox-group": "group.g1", "x-agentdox-personal": "proj.u.u_ada" }),
+		);
+		expect(team.harnessId).toBe("u_ada");
+		expect(team.agentdoxScope).toBe("proj");
+		expect(team.agentdoxGroup).toBe("group.g1");
+		expect(team.agentdoxPersonal).toBe("proj.u.u_ada");
+		expect(parseMessagesRequest(CLAUDE_CODE_BODY, new Headers({ "x-agentdox-group": "Not A Slug" })).agentdoxGroup).toBe("");
+	});
+
 	test("a request captured from Claude Code 2.1: system inside messages, JSON user_id, adaptive thinking with effort, 23 custom tools", () => {
 		const fixture = JSON.parse(readFileSync("test/fixtures/harness/claude-code.json", "utf8")) as { headers: Record<string, string>; body: Record<string, unknown> };
 		const norm = parseMessagesRequest(fixture.body, new Headers(fixture.headers));

package/test/context-bridge.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test";
 
-import type { AgentDoxClient, AssembleLimits } from "../src/context/agentdox.ts";
+import { type AgentDoxClient, type AssembleLayers, type AssembleLimits, createAgentDoxClient } from "../src/context/agentdox.ts";
 import { createContextBridge } from "../src/context/bridge.ts";
 import { createContextStore } from "../src/context/store.ts";
 import type { ContextResolveInput, TurnRecord } from "../src/context/types.ts";
@@ -16,19 +16,24 @@ interface FakeClient extends AgentDoxClient {
 	sessionsCreated: number;
 	prompt: string;
 	lastLimits: AssembleLimits | null;
+	/** The layers of the last assemble: undefined when the bridge sent none. */
+	lastLayers: AssembleLayers | undefined;
 }
 
 function mkClient(prompt = "MEMORY: player digs in 3/4 top-down"): FakeClient {
 	const c: FakeClient = {
 		assembleCalls: 0,
 		lastLimits: null,
+		lastLayers: undefined,
 		appended: [],
 		sessionsCreated: 0,
 		prompt,
-		async assemble(_scope, _query, limits) {
+		async assemble(scope, _query, limits, layers) {
 			c.assembleCalls++;
 			c.lastLimits = limits;
-			return c.prompt;
+			c.lastLayers = layers;
+			// Like the server: a personal layer renders last, so members differ.
+			return layers !== undefined && layers.personal !== "" ? `${c.prompt}\n\n# Your thread in ${scope}\n${layers.personal}` : c.prompt;
 		},
 		async createSession() {
 			c.sessionsCreated++;
@@ -56,6 +61,7 @@ function mkBridge(client: AgentDoxClient, over: Partial<BridgeOpts> = {}) {
 		docsLimit: 2,
 		sessionLimit: 6,
 		briefChars: 0,
+		layers: true,
 		recordTurns: true,
 		maxQueue: 64,
 		...over,
@@ -72,6 +78,9 @@ function input(over: Partial<ContextResolveInput> = {}): ContextResolveInput {
 		modelSwitching: false,
 		retrying: false,
 		query: "movement rules",
+		group: "",
+		personal: "",
+		user: "",
 		firstFetch: true,
 		...over,
 	};
@@ -258,6 +267,7 @@ describe("context bridge refresh policy", () => {
 				docsLimit: 2,
 				sessionLimit: 6,
 				briefChars: 0,
+				layers: true,
 				recordTurns: true,
 				maxQueue: 64,
 			};
@@ -282,6 +292,7 @@ describe("context bridge write-back", () => {
 			bridge.recordTurn({
 				scope: "ashlands",
 				conversationKey: "k1",
+				harnessId: "",
 				title: "movement fix",
 				userText: "fix movement",
 				assistantText: "done",
@@ -292,6 +303,7 @@ describe("context bridge write-back", () => {
 			bridge.recordTurn({
 				scope: "ashlands",
 				conversationKey: "k1",
+				harnessId: "",
 				title: "movement fix",
 				userText: "now the camera",
 				assistantText: "ok",
@@ -318,6 +330,7 @@ describe("context bridge write-back", () => {
 			bridge.recordTurn({
 				scope: "ashlands",
 				conversationKey: "k1",
+				harnessId: "",
 				title: "t",
 				userText: "u",
 				assistantText: "a",
@@ -337,6 +350,7 @@ describe("context bridge write-back", () => {
 		return {
 			scope: "ashlands",
 			conversationKey: "k1",
+			harnessId: "",
 			title: "movement fix",
 			userText: "fix movement",
 			assistantText: "",
@@ -423,6 +437,137 @@ describe("context bridge write-back", () => {
 	});
 });
 
+describe("context layers a team names (project memory, phase one)", () => {
+	// A router without a team has no group or personal scope and no harness id:
+	// the bridge must then send exactly what it did before, so a block on a
+	// lone install is byte-identical to 0.15. A team front door names the
+	// layers in headers and the member in the harness id.
+	test("resolve passes the group, personal and user layers to assemble; a lone router passes empties", async () => {
+		const client = mkClient();
+		const { bridge, db } = mkBridge(client);
+		try {
+			await bridge.resolve(input({ group: "group.g1", personal: "ashlands.u.u1", user: "u1" }));
+			expect(client.lastLayers).toEqual({ group: "group.g1", personal: "ashlands.u.u1", user: "u1" });
+			await bridge.resolve(input({ conversationKey: "k2" }));
+			expect(client.lastLayers).toEqual({ group: "", personal: "", user: "" });
+			// Either layer alone is a front door; the member goes with it.
+			await bridge.resolve(input({ conversationKey: "k3", group: "group.g1", user: "u1" }));
+			expect(client.lastLayers).toEqual({ group: "group.g1", personal: "", user: "u1" });
+		} finally {
+			db.close();
+		}
+	});
+
+	test("a router on its own sends no user, even though it has a harness id", async () => {
+		// Claude Code's wire path derives a harness id and omp sends one, so a
+		// lone router is NOT harness-less. Sending it as `user` would make a new
+		// agentdox filter the project's recent tail to that harness, dropping
+		// every pre-0.16 message and every other harness's turns.
+		const client = mkClient();
+		const { bridge, db } = mkBridge(client);
+		try {
+			await bridge.resolve(input({ user: "claude-code" }));
+			expect(client.lastLayers).toEqual({ group: "", personal: "", user: "" });
+		} finally {
+			db.close();
+		}
+	});
+
+	test("layers: false sends none, whatever the request names", async () => {
+		const client = mkClient();
+		const { bridge, db } = mkBridge(client, { layers: false });
+		try {
+			const pin = await bridge.resolve(input({ group: "group.g1", personal: "ashlands.u.u1", user: "u1" }));
+			expect(pin).not.toBeNull();
+			expect(client.assembleCalls).toBe(1);
+			expect(client.lastLayers).toBeUndefined();
+		} finally {
+			db.close();
+		}
+	});
+
+	test("a personal layer pins a different block per member, and the same block for the same member", async () => {
+		// The version is a hash of the block's content, so two members' blocks
+		// never share a version even in one scope; the shared store keys on it.
+		const client = mkClient();
+		const { bridge, db } = mkBridge(client);
+		try {
+			const ada = await bridge.resolve(input({ conversationKey: "ada", personal: "ashlands.u.ada", user: "ada" }));
+			const bob = await bridge.resolve(input({ conversationKey: "bob", personal: "ashlands.u.bob", user: "bob" }));
+			const adaAgain = await bridge.resolve(input({ conversationKey: "ada-2", personal: "ashlands.u.ada", user: "ada" }));
+			const nobody = await bridge.resolve(input({ conversationKey: "solo" }));
+			expect(ada?.block).toContain("ashlands.u.ada");
+			expect(bob?.block).toContain("ashlands.u.bob");
+			expect(ada?.version).not.toBe(bob?.version);
+			expect(adaAgain?.version).toBe(ada?.version ?? "");
+			expect(nobody?.version).not.toBe(ada?.version);
+			expect(nobody?.block).not.toContain("Your thread");
+		} finally {
+			db.close();
+		}
+	});
+
+	test("the recorded turn carries user:<harnessId> on both messages only when the harness is set", async () => {
+		const client = mkClient();
+		const { bridge, db } = mkBridge(client);
+		try {
+			const rec = {
+				scope: "ashlands",
+				title: "movement fix",
+				userText: "fix movement",
+				assistantText: "done",
+				slug: "anthropic/claude-haiku-4.5",
+				tier: "simple",
+				turnEnded: true,
+			};
+			bridge.recordTurn({ ...rec, conversationKey: "member", harnessId: "u_ada" });
+			bridge.recordTurn({ ...rec, conversationKey: "solo", harnessId: "" });
+			await bridge.flush();
+
+			const member = client.appended.filter((m) => m.sessionId === "ses_1");
+			expect(member.map((m) => m.role)).toEqual(["user", "assistant"]);
+			expect(member[0]?.refs).toEqual(["user:u_ada"]);
+			expect(member[1]?.refs).toEqual(["model:anthropic/claude-haiku-4.5", "tier:simple", "user:u_ada"]);
+
+			// No harness id: the refs are exactly what 0.15 wrote.
+			const solo = client.appended.filter((m) => m.sessionId === "ses_2");
+			expect(solo[0]?.refs).toEqual([]);
+			expect(solo[1]?.refs).toEqual(["model:anthropic/claude-haiku-4.5", "tier:simple"]);
+		} finally {
+			db.close();
+		}
+	});
+
+	test("the REST client posts the layer keys only when they are non-empty", async () => {
+		// An older agentdox ignores unknown keys, so sending them is harmless —
+		// but a lone router must post the same body as before, key for key, and
+		// a half-named layer set must not post empty strings the server would
+		// have to special-case.
+		const bodies: Record<string, unknown>[] = [];
+		const realFetch = globalThis.fetch;
+		globalThis.fetch = (async (_url: unknown, init?: RequestInit) => {
+			bodies.push(JSON.parse(String(init?.body)) as Record<string, unknown>);
+			return new Response(JSON.stringify({ prompt: "P" }), { status: 200, headers: { "content-type": "application/json" } });
+		}) as unknown as typeof fetch;
+		try {
+			const client = createAgentDoxClient({ baseUrl: "http://agentdox.test", token: "t", timeoutMs: 1000, log });
+			const limits = { memoryLimit: 8, docsLimit: 2, sessionLimit: 6, briefChars: 0 };
+			await client.assemble("ashlands", "q", limits);
+			await client.assemble("ashlands", "q", limits, { group: "", personal: "", user: "" });
+			await client.assemble("ashlands", "q", limits, { group: "group.g1", personal: "", user: "u1" });
+			await client.assemble("ashlands", "q", limits, { group: "group.g1", personal: "ashlands.u.u1", user: "u1" });
+
+			const before = { scope: "ashlands", query: "q", ...limits };
+			expect(bodies[0]).toEqual(before);
+			expect(bodies[1]).toEqual(before);
+			expect(bodies[2]).toEqual({ ...before, group: "group.g1", user: "u1" });
+			expect(bodies[3]).toEqual({ ...before, group: "group.g1", personal: "ashlands.u.u1", user: "u1" });
+		} finally {
+			globalThis.fetch = realFetch;
+		}
+	});
+});
+
 describe("context injection into the wire body", () => {
 	test("appends to the last system message, leaving breakpoint indices valid", () => {
 		const body = {

package/test/escalate.test.ts

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

package/test/failover.test.ts

@@ -74,7 +74,7 @@ function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 		hysteresis: { holdTurns: 2, holdTurnsAfterEscalation: 4, switchMargin: 1.5, cacheWarmTtlMs: 600_000, maxDowngradePerTurn: 1, breakHoldOnMechanical: false, switchHorizonTurns: 1, confirmUpgradesBelowConfidence: 0.6 },
 		exploration: { enabled: false, rates: {}, stickyPolicy: "never", holdTurns: { enabled: false, values: [2, 3, 4] } },
 		cache: { injectBreakpoints: true, maxBreakpoints: 4, minPromptTokens: 1024, milestoneTokens: 20_000 },
-		context: { enabled: false, baseUrl: "", token: "", defaultScope: "", timeoutMs: 3_000, maxStalenessMs: 900_000, maxBlockChars: 24_000, memoryLimit: 8, docsLimit: 2, sessionLimit: 6, briefChars: 0, recordTurns: false, injectWithoutTools: false, maxQueue: 64 },
+		context: { enabled: false, baseUrl: "", token: "", defaultScope: "", timeoutMs: 3_000, maxStalenessMs: 900_000, maxBlockChars: 24_000, memoryLimit: 8, docsLimit: 2, sessionLimit: 6, briefChars: 0, layers: true, recordTurns: false, injectWithoutTools: false, maxQueue: 64 },
 		compaction: { enabled: false, budgetTokens: 40_000, floorRatio: 1, fitToWindow: true, protectRecentTurns: 4, maxToolResultBytes: 4_096, keepHeadBytes: 512, keepTailBytes: 512, elideSupersededReads: true, collapseDuplicateResults: true, replanGrowthRatio: 1, digestToolResults: false, digestMaxPerTurn: 2 },
 		budget: { onExceeded: "downgrade" },
 		report: { baselines: [], dailySummary: false },
@@ -96,6 +96,8 @@ function mkReq(): NormRequest {
 		harnessId: "",
 		ompSessionId: "",
 		agentdoxScope: "",
+		agentdoxGroup: "",
+		agentdoxPersonal: "",
 		isSubagent: false,
 		requestedModel: "auto",
 		messages: [{ role: "user", text: "hi", images: 0, textBytes: 2, toolCalls: [] }],

package/test/scope.test.ts

@@ -28,4 +28,24 @@ describe("the scope a request may name", () => {
 		expect(parse("omp-router").agentdoxScope).toBe("omp-router");
 		expect(parse(SCOPE_ENV).agentdoxScope).toBe("");
 	});
+
+	test("the wire parser reads X-Agentdox-Group and X-Agentdox-Personal by the same rule", () => {
+		// A team front door names the group-context and personal scopes; a
+		// lone router never sees the headers and must end up with empties, so
+		// nothing new is sent to agentdox.
+		const body = { model: "auto", messages: [{ role: "user", content: "hi" }] };
+		const parse = (h: Record<string, string>) => parseChatRequest(body, new Headers(h));
+		const none = parse({ "x-agentdox-scope": "omp-router" });
+		expect(none.agentdoxGroup).toBe("");
+		expect(none.agentdoxPersonal).toBe("");
+		const both = parse({ "x-agentdox-scope": "omp-router", "x-agentdox-group": " group.g1 ", "x-agentdox-personal": "omp-router.u.u_ada" });
+		expect(both.agentdoxGroup).toBe("group.g1");
+		expect(both.agentdoxPersonal).toBe("omp-router.u.u_ada");
+		// Not slugs: dropped, never passed through.
+		const bad = parse({ "x-agentdox-group": "Has Spaces", "x-agentdox-personal": SCOPE_ENV });
+		expect(bad.agentdoxGroup).toBe("");
+		expect(bad.agentdoxPersonal).toBe("");
+		// Layers without a project scope are still parsed; the turn decides what to do.
+		expect(parse({ "x-agentdox-group": "group.g1" }).agentdoxGroup).toBe("group.g1");
+	});
 });

package/test/turn.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test";
 import { createDisabledBridge } from "../src/context/bridge.ts";
-import type { ContextBridge, TurnRecord } from "../src/context/types.ts";
+import type { ContextBridge, ContextResolveInput, TurnRecord } from "../src/context/types.ts";
 import type { CatalogModel, CatalogSource } from "../src/catalog/types.ts";
 import type { EscalationConfig, RouterConfig } from "../src/config/types.ts";
 import { EMPTY_USAGE, type Ledger, type LedgerEntry, type UsageCounts } from "../src/cost/types.ts";
@@ -74,7 +74,7 @@ function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 		hysteresis: { holdTurns: 2, holdTurnsAfterEscalation: 4, switchMargin: 1.5, cacheWarmTtlMs: 600_000, maxDowngradePerTurn: 1, breakHoldOnMechanical: false, switchHorizonTurns: 1, confirmUpgradesBelowConfidence: 0.6 },
 		exploration: { enabled: false, rates: {}, stickyPolicy: "never", holdTurns: { enabled: false, values: [2, 3, 4] } },
 		cache: { injectBreakpoints: true, maxBreakpoints: 4, minPromptTokens: 1024, milestoneTokens: 20_000 },
-		context: { enabled: false, baseUrl: "", token: "", defaultScope: "", timeoutMs: 3_000, maxStalenessMs: 900_000, maxBlockChars: 24_000, memoryLimit: 8, docsLimit: 2, sessionLimit: 6, briefChars: 0, recordTurns: false, injectWithoutTools: false, maxQueue: 64 },
+		context: { enabled: false, baseUrl: "", token: "", defaultScope: "", timeoutMs: 3_000, maxStalenessMs: 900_000, maxBlockChars: 24_000, memoryLimit: 8, docsLimit: 2, sessionLimit: 6, briefChars: 0, layers: true, recordTurns: false, injectWithoutTools: false, maxQueue: 64 },
 		compaction: { enabled: false, budgetTokens: 40_000, floorRatio: 1, fitToWindow: true, protectRecentTurns: 4, maxToolResultBytes: 4_096, keepHeadBytes: 512, keepTailBytes: 512, elideSupersededReads: true, collapseDuplicateResults: true, replanGrowthRatio: 1, digestToolResults: false, digestMaxPerTurn: 2 },
 		budget: { onExceeded: "downgrade" },
 		report: { baselines: [], dailySummary: false },
@@ -96,6 +96,8 @@ function mkReq(): NormRequest {
 		harnessId: "",
 		ompSessionId: "",
 		agentdoxScope: "",
+		agentdoxGroup: "",
+		agentdoxPersonal: "",
 		isSubagent: false,
 		requestedModel: "auto",
 		messages: [{ role: "user", text: "hi", images: 0, textBytes: 2, toolCalls: [] }],
@@ -722,6 +724,41 @@ describe("agentdox injection sees the shape of the turn", () => {
 		expect(store.load(req.conversationKey).contextVersion).toBe("v1");
 	});
 
+	test("the layer headers and the harness id reach resolve, and the harness id reaches the record", async () => {
+		// The team front door names the group and personal scopes in headers and
+		// the member in X-Omp-Harness; the turn carries all three through
+		// unchanged. A router without a team passes empties (see the other tests
+		// in this file, whose mkReq has none).
+		const { router, upstream, ledger, store, sink, errors } = oneDispatch();
+		const inputs: ContextResolveInput[] = [];
+		const records: TurnRecord[] = [];
+		const bridge: ContextBridge = {
+			enabled: true,
+			resolve: (input) => {
+				inputs.push(input);
+				return Promise.resolve(null);
+			},
+			recordTurn: (rec) => {
+				records.push(rec);
+			},
+			flush: () => Promise.resolve(),
+			pruneBlocks: () => 0,
+			close: () => {},
+		};
+		const req: NormRequest = { ...mkReq(), harnessId: "u_ada", agentdoxScope: "proj", agentdoxGroup: "group.g1", agentdoxPersonal: "proj.u.u_ada", tools: [AGENT_TOOL] };
+
+		await runTurn(req, sink, { config: mkConfig({ enabled: false }), router, upstream, ledger, conversations: store, catalog, context: bridge }, new AbortController().signal);
+
+		expect(errors).toHaveLength(0);
+		expect(inputs).toHaveLength(1);
+		expect(inputs[0]?.scope).toBe("proj");
+		expect(inputs[0]?.group).toBe("group.g1");
+		expect(inputs[0]?.personal).toBe("proj.u.u_ada");
+		expect(inputs[0]?.user).toBe("u_ada");
+		expect(records).toHaveLength(1);
+		expect(records[0]?.harnessId).toBe("u_ada");
+	});
+
 	test("context.injectWithoutTools restores injection into tool-less calls", async () => {
 		const { router, upstream, ledger, store, sink, errors } = oneDispatch();
 		const { bridge, resolves } = mkServingBridge();

package/test/views.test.ts

@@ -148,6 +148,12 @@ describe("view routes", () => {
 		expect((await fetch(`http://127.0.0.1:${handle.server.port}/v1/router/spend?sinceMs=0`)).status).toBe(401);
 		expect((await get("/v1/router/spend")).status).toBe(400);
 		expect(((await (await get(`/v1/router/spend?sinceMs=${Date.now() - DAY}&harness=u_x`)).json()) as { usd: number }).usd).toBeCloseTo(0.25, 6);
+		// The decision trail over a harness set: a team asks with its user or group ids and sees only theirs.
+		const mine = (await (await get("/v1/router/decisions?harness=u_x&days=1")).json()) as { entries: { id: string; feedback: unknown[] }[] };
+		expect(mine.entries.map((e) => e.id)).toEqual(["r1"]);
+		expect(mine.entries[0]?.feedback).toEqual([]);
+		expect((((await (await get("/v1/router/decisions?harness=u_other&days=1")).json()) as { entries: unknown[] }).entries)).toEqual([]);
+		expect((((await (await get("/v1/router/decisions?limit=1")).json()) as { entries: { id: string }[] }).entries.map((e) => e.id))).toEqual(["r1"]); // no filter: everything, as before
 		expect(((await (await get(`/v1/router/spend?sinceMs=${Date.now() - DAY}&harness=u_other`)).json()) as { usd: number }).usd).toBe(0);
 		const fb = (await (await get("/v1/router/feedback?days=7")).json()) as { days: number; byModel: unknown[]; recent: unknown[] };
 		expect(fb).toEqual({ days: 7, byModel: [], recent: [] });
@@ -159,3 +165,28 @@ describe("view routes", () => {
 		expect(js.rows[0]?.harnessId).toBe("u_x");
 	});
 });
+
+describe("decision entries", () => {
+	const db = seeded();
+	const since = NOW - DAY;
+
+	test("newest first over a harness set, with the verdicts given on each turn", () => {
+		const { decisionEntries } = require("../src/cost/views.ts") as typeof import("../src/cost/views.ts");
+		const ada = decisionEntries(db, { sinceMs: since, harness: ["u_ada"] });
+		expect(ada.map((e) => e.id)).toEqual(["l1", "l2"]); // same instant in the fixture; insertion order within it is stable
+		expect(ada.find((e) => e.id === "l1")?.feedback).toEqual([{ verdict: "good", note: "", createdAtMs: NOW - 1000 }]);
+		expect(ada.find((e) => e.id === "l2")?.escalationSignal).toBe("circular");
+		// Everyone, within the window: the 40-day-old row stays out; the digest row is a turn like any other.
+		expect(decisionEntries(db, { sinceMs: since, harness: null }).map((e) => e.id).sort()).toEqual(["l1", "l2", "l3", "l4"]);
+		expect(decisionEntries(db, { sinceMs: 0, harness: null }).length).toBe(5);
+		// A model, a tier, nobody, and a cap.
+		expect(decisionEntries(db, { sinceMs: since, harness: null, slug: "ollama/glm-5.3-flash" }).map((e) => e.id).sort()).toEqual(["l3", "l4"]);
+		expect(decisionEntries(db, { sinceMs: since, harness: null, tier: "hard" })).toEqual([]);
+		expect(decisionEntries(db, { sinceMs: since, harness: [] })).toEqual([]);
+		expect(decisionEntries(db, { sinceMs: since, harness: null, limit: 1 }).length).toBe(1);
+		// The error on l3 and its note ride along, so an explorer can show why a turn went wrong.
+		const bob = decisionEntries(db, { sinceMs: since, harness: ["u_bob"], slug: "ollama/glm-5.3-flash" });
+		expect(bob.find((e) => e.id === "l3")?.error).toBe("boom");
+		expect(bob.find((e) => e.id === "l3")?.feedback[0]?.note).toBe("looped");
+	});
+});

package/tools/agentdox-e2e.ts

@@ -44,6 +44,7 @@ const bridge = createContextBridge({
 	docsLimit: 0,
 	sessionLimit: 6,
 	briefChars: 12_000,
+	layers: true,
 	recordTurns: true,
 	maxQueue: 64,
 });
@@ -58,6 +59,9 @@ function input(over: Partial<ContextResolveInput> = {}): ContextResolveInput {
 		modelSwitching: false,
 		retrying: false,
 		query: "cache prompt context injection",
+		group: "",
+		personal: "",
+		user: "",
 		firstFetch: true,
 		...over,
 	};
@@ -93,6 +97,7 @@ check(
 bridge.recordTurn({
 	scope,
 	conversationKey,
+	harnessId: "",
 	title: `bridge e2e ${conversationKey}`,
 	userText: "does the bridge record which model served this turn?",
 	assistantText: "yes - refs carry model: and tier:.",
@@ -135,6 +140,7 @@ function loopDispatch(assistantText: string, turnEnded: boolean): void {
 	bridge.recordTurn({
 		scope,
 		conversationKey: loopKey,
+		harnessId: "",
 		title: loopTitle,
 		userText: "why did cache read fall?",
 		assistantText,

package/tools/replay.ts

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