auto-model-router 0.15.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.15.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.15.0",
+      "version": "0.16.0",
       "author": {
         "name": "drewappling",
         "email": "drewappling@gmail.com"

package/README.md

@@ -1519,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
@@ -1549,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.15.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/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/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/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,