auto-model-router 0.15.0 → 0.17.0

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,9 @@ function requestOf(req: AdviseRequest): NormRequest {
 		harnessId: req.harnessId,
 		ompSessionId: req.ompSessionId,
 		agentdoxScope: "",
+		agentdoxGroup: "",
+		agentdoxPersonal: "",
+		agentdoxOrigin: "",
 		isSubagent: false,
 		requestedModel: "auto",
 		messages: [

package/src/server/digest.ts

@@ -99,6 +99,9 @@ function syntheticRequest(req: DigestRequest, promptText: string): NormRequest {
 		harnessId: req.harnessId,
 		ompSessionId: req.ompSessionId,
 		agentdoxScope: "",
+		agentdoxGroup: "",
+		agentdoxPersonal: "",
+		agentdoxOrigin: "",
 		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

@@ -1,4 +1,4 @@
-import { acceptScope } from "../../context/scope.ts";
+import { acceptOrigin, acceptScope } from "../../context/scope.ts";
 import type {
 	RequestPolicy,
 	CompactionEdit,
@@ -335,6 +335,17 @@ 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"));
+
+	// The workspace's repository fingerprint, for a front door that keeps a
+	// project registry. Same sentinel rule as the scope: omp sends the env-var
+	// NAME when the variable is unset, and a name is never a fingerprint.
+	const agentdoxOrigin = acceptOrigin(headers.get("x-agentdox-origin"));
+
 	// Subagent marker from the embed extension (sessions without a UI).
 	const isSubagent = (headers.get("x-omp-subagent") ?? "").trim() === "1";
 
@@ -401,6 +412,9 @@ export function parseChatRequest(body: unknown, headers: Headers): NormRequest {
 		harnessId,
 		ompSessionId,
 		agentdoxScope,
+		agentdoxGroup,
+		agentdoxPersonal,
+		agentdoxOrigin,
 		isSubagent,
 		...(policy === undefined ? {} : { policy }),
 		requestedModel,

package/src/wire/types.ts

@@ -96,6 +96,28 @@ 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;
+	/**
+	 * The workspace's repository fingerprint from the `X-Agentdox-Origin`
+	 * request header (`<host>/<path>` of its git remote `origin`, see
+	 * `src/context/scope.ts`). Validated here, in one place, for a front door
+	 * with a project registry — the team edition — which uses it to find the
+	 * project two same-named folders are really about. The router's own bridge
+	 * has no registry and never reads it. Empty when absent or not a fingerprint.
+	 */
+	agentdoxOrigin: 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,28 @@ 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("the origin fingerprint reaches the request on the Anthropic path too", () => {
+		expect(parseMessagesRequest(CLAUDE_CODE_BODY, new Headers({ "user-agent": "claude-cli/2.1.263" })).agentdoxOrigin).toBe("");
+		expect(parseMessagesRequest(CLAUDE_CODE_BODY, new Headers({ "x-agentdox-origin": "github.com/drewappling/omp-router" })).agentdoxOrigin).toBe("github.com/drewappling/omp-router");
+		expect(parseMessagesRequest(CLAUDE_CODE_BODY, new Headers({ "x-agentdox-origin": "https://github.com/a/b" })).agentdoxOrigin).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/embed-logic.test.ts

@@ -1,11 +1,12 @@
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
-import { mkdtempSync, rmSync } from "node:fs";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
 import {
 	buildProviderConfig,
 	deriveAgentdoxScope,
+	deriveWorkspaceOrigin,
 	EMBED_PORT_FILE,
 	EMBED_PROVIDER_ID,
 	embedPortPath,
@@ -207,3 +208,87 @@ describe("agentdox scope", () => {
 		expect(buildProviderConfig(1234, cfg, "/x/ashlands").agentdoxScope).toBeUndefined();
 	});
 });
+
+describe("workspace origin", () => {
+	const CONFIG = ['[core]', '\trepositoryformatversion = 0', '[remote "origin"]', '\turl = https://github.com/DrewAppling/omp-router.git', '\tfetch = +refs/heads/*:refs/remotes/origin/*', '[branch "main"]', '\tremote = origin', ''].join("\n");
+	let root: string;
+	beforeAll(() => {
+		root = mkdtempSync(join(tmpdir(), "amr-origin-"));
+	});
+	afterAll(() => {
+		rmSync(root, { recursive: true, force: true });
+	});
+
+	test("a plain repository: the remote from .git/config, also from a subdirectory", () => {
+		const repo = join(root, "repo");
+		mkdirSync(join(repo, ".git"), { recursive: true });
+		writeFileSync(join(repo, ".git", "config"), CONFIG);
+		mkdirSync(join(repo, "src", "deep"), { recursive: true });
+		expect(deriveWorkspaceOrigin(repo)).toBe("github.com/drewappling/omp-router");
+		expect(deriveWorkspaceOrigin(join(repo, "src", "deep"))).toBe("github.com/drewappling/omp-router");
+		// The scope is still the folder, untouched by any of this.
+		expect(deriveAgentdoxScope(repo)).toBe("repo");
+	});
+
+	test("a worktree: .git is a file naming the git dir, whose shared config is one hop further", () => {
+		// The main checkout holds the config; the worktree's own dir only points at it.
+		const main = join(root, "main");
+		mkdirSync(join(main, ".git", "worktrees", "wt"), { recursive: true });
+		writeFileSync(join(main, ".git", "config"), CONFIG.replace("github.com/DrewAppling/omp-router.git", "gitlab.example.com:2222/team/api/").replace("https://", "ssh://git@"));
+		writeFileSync(join(main, ".git", "worktrees", "wt", "commondir"), "../..\n");
+		const wt = join(root, "wt");
+		mkdirSync(wt, { recursive: true });
+		writeFileSync(join(wt, ".git"), `gitdir: ${join(main, ".git", "worktrees", "wt")}\n`);
+		expect(deriveWorkspaceOrigin(wt)).toBe("gitlab.example.com/team/api");
+		// A submodule-style pointer: the named dir has its own config, relative to the .git file.
+		const sub = join(root, "sub");
+		mkdirSync(join(sub, "modules", "lib"), { recursive: true });
+		mkdirSync(join(sub, "lib"), { recursive: true });
+		writeFileSync(join(sub, "modules", "lib", "config"), CONFIG.replace("DrewAppling/omp-router", "org/lib"));
+		writeFileSync(join(sub, "lib", ".git"), "gitdir: ../modules/lib\n");
+		expect(deriveWorkspaceOrigin(join(sub, "lib"))).toBe("github.com/org/lib");
+	});
+
+	test("no remote, a local remote, no repository, or nothing at all: no fingerprint, never a throw", () => {
+		const bare = join(root, "bare");
+		mkdirSync(join(bare, ".git"), { recursive: true });
+		writeFileSync(join(bare, ".git", "config"), "[core]\n\tbare = false\n");
+		expect(deriveWorkspaceOrigin(bare)).toBe("");
+		const local = join(root, "local");
+		mkdirSync(join(local, ".git"), { recursive: true });
+		writeFileSync(join(local, ".git", "config"), '[remote "origin"]\n\turl = /srv/git/local.git\n');
+		expect(deriveWorkspaceOrigin(local)).toBe("");
+		// A `.git` file that leads nowhere is the boundary: the walk stops there.
+		const dangling = join(root, "repo", "dangling");
+		mkdirSync(dangling, { recursive: true });
+		writeFileSync(join(dangling, ".git"), "gitdir: /nowhere/at/all\n");
+		expect(deriveWorkspaceOrigin(dangling)).toBe("");
+		expect(deriveWorkspaceOrigin(join(root, "not-a-repo", "missing"))).toBe("");
+		expect(deriveWorkspaceOrigin("")).toBe("");
+		expect(
+			deriveWorkspaceOrigin("/anywhere", () => {
+				throw new Error("disk on fire");
+			}),
+		).toBe("");
+	});
+
+	test("the first url under [remote \"origin\"] wins; other remotes do not count", () => {
+		const read = () => '[remote "upstream"]\n\turl = https://github.com/other/thing.git\n[remote "origin"]\n\turl = git@github.com:me/thing.git\n\turl = https://github.com/me/second.git\n';
+		expect(deriveWorkspaceOrigin("/x/repo", read)).toBe("github.com/me/thing");
+		expect(deriveWorkspaceOrigin("/x/repo", () => '[remote "upstream"]\n\turl = https://github.com/other/thing.git\n')).toBe("");
+	});
+
+	test("buildProviderConfig carries the origin beside the scope, only where the scope goes", () => {
+		const base = {
+			server: { host: "127.0.0.1" },
+			profiles: [],
+			ledger: { fallbackBlend: { inputPerMtok: 1, outputPerMtok: 1 } },
+		};
+		const on = buildProviderConfig(1234, { ...base, context: { enabled: true, defaultScope: "" } }, "/x/ashlands", "github.com/me/ashlands");
+		expect(on.agentdoxScope).toBe("ashlands");
+		expect(on.agentdoxOrigin).toBe("github.com/me/ashlands");
+		expect(buildProviderConfig(1234, { ...base, context: { enabled: true, defaultScope: "" } }, "/x/ashlands", "").agentdoxOrigin).toBeUndefined();
+		expect(buildProviderConfig(1234, { ...base, context: { enabled: true, defaultScope: "" } }, "/x/ashlands").agentdoxOrigin).toBeUndefined();
+		expect(buildProviderConfig(1234, { ...base, context: { enabled: false, defaultScope: "" } }, "/x/ashlands", "github.com/me/ashlands").agentdoxOrigin).toBeUndefined();
+	});
+});

package/test/escalate.test.ts

@@ -24,6 +24,9 @@ function req(messages: NormMessage[] = [], over: Partial<NormRequest> = {}): Nor
 		harnessId: "",
 		ompSessionId: "",
 		agentdoxScope: "",
+		agentdoxGroup: "",
+		agentdoxPersonal: "",
+		agentdoxOrigin: "",
 		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,9 @@ function mkReq(): NormRequest {
 		harnessId: "",
 		ompSessionId: "",
 		agentdoxScope: "",
+		agentdoxGroup: "",
+		agentdoxPersonal: "",
+		agentdoxOrigin: "",
 		isSubagent: false,
 		requestedModel: "auto",
 		messages: [{ role: "user", text: "hi", images: 0, textBytes: 2, toolCalls: [] }],

package/test/models-yml.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, test } from "bun:test";
 import { parse as parseYaml } from "yaml";
 
 import { loadConfig } from "../src/config/load.ts";
+import { ORIGIN_ENV, SCOPE_ENV } from "../src/context/scope.ts";
 import {
 	BEGIN_GUARD,
 	END_GUARD,
@@ -68,6 +69,15 @@ describe("renderProviderBlock", () => {
 		expect(BLOCK).toContain("auth: none");
 		expect(BLOCK).toContain("/v1");
 	});
+
+	test("with the bridge on, the scope and origin headers name the variables the extension sets", () => {
+		// The file is machine-wide, so neither can be a literal: omp resolves a
+		// header value that names an env var per request (src/context/scope.ts).
+		const bridged = renderProviderBlock(loadConfig({ overrides: { context: { enabled: true, baseUrl: "http://agentdox:3003", token: "t" } } }), null);
+		expect(bridged).toContain(`X-Agentdox-Scope: ${SCOPE_ENV}`);
+		expect(bridged).toContain(`X-Agentdox-Origin: ${ORIGIN_ENV}`);
+		expect(BLOCK).not.toContain("X-Agentdox-");
+	});
 });
 
 describe("spliceProviderBlock", () => {

package/test/remote.test.ts

@@ -6,7 +6,7 @@ import { join } from "node:path";
 import { addExtensions, codexBlock, connectRemote, setDotenv, type ConnectOptions } from "../src/cli/connect.ts";
 import { parseRemoteRouter, readRemoteRouter, remoteProviderRegistration } from "../omp-extension/remote-logic.ts";
 import { existingBlockScope, hasForeignRouterProvider, mergeModelsYml, renderRemoteModelsYml } from "../src/cli/connect.ts";
-import { SCOPE_ENV } from "../src/context/scope.ts";
+import { ORIGIN_ENV, SCOPE_ENV } from "../src/context/scope.ts";
 import { refreshAndRewrite, refreshCredential, RefreshError, resolveRefreshToken, shouldRefresh } from "../src/cli/refresh.ts";
 import { loadRefreshToken, pickStore, removeRefreshToken, saveRefreshToken } from "../src/cli/credential-store.ts";
 import { hasRefresh, refreshAccountOf } from "../omp-extension/remote-logic.ts";
@@ -31,6 +31,9 @@ describe("remote-logic", () => {
 		// the machine with the right context; the remote may still override it.
 		expect(reg.headers["X-Agentdox-Scope"]).toBeUndefined();
 		expect(remoteProviderRegistration(t, "", false, { inputPerMtok: 1, outputPerMtok: 4 }, "omp-router").headers).toEqual({ "X-Agentdox-Scope": "omp-router" });
+		// The repository fingerprint rides beside the scope, and only when there is one.
+		expect(remoteProviderRegistration(t, "", false, { inputPerMtok: 1, outputPerMtok: 4 }, "omp-router", "github.com/drewappling/omp-router").headers).toEqual({ "X-Agentdox-Scope": "omp-router", "X-Agentdox-Origin": "github.com/drewappling/omp-router" });
+		expect(remoteProviderRegistration(t, "", false, { inputPerMtok: 1, outputPerMtok: 4 }, "", "github.com/drewappling/omp-router").headers).toEqual({ "X-Agentdox-Origin": "github.com/drewappling/omp-router" });
 		const dir = mkdtempSync(join(tmpdir(), "amr-remote-"));
 		expect(readRemoteRouter(dir)).toBeNull();
 		writeFileSync(join(dir, "remote.json"), JSON.stringify({ url: "https://t", key: "k" }));
@@ -126,12 +129,16 @@ describe("omp models.yml for a remote router", () => {
 		// Machine-wide file: the header names the env var the extension sets per
 		// workspace, so the MAIN model's turns carry each repo's own scope.
 		expect(block).toContain(`X-Agentdox-Scope: ${SCOPE_ENV}`);
+		// The origin names its own variable the same way, on every block.
+		expect(block).toContain(`X-Agentdox-Origin: ${ORIGIN_ENV}`);
 		expect(existingBlockScope(mergeModelsYml("", block))).toBe("");
 		// --scope pins one slug for the whole machine.
 		const pinned = renderRemoteModelsYml("https://team.example", "k", BLEND, "omp-router");
 		expect(pinned).toContain("X-Agentdox-Scope: omp-router");
 		expect(pinned).not.toContain(SCOPE_ENV);
 		expect(existingBlockScope(mergeModelsYml("", pinned))).toBe("omp-router");
+		// A pinned scope does not pin an origin: the repository is still the workspace's.
+		expect(pinned).toContain(`X-Agentdox-Origin: ${ORIGIN_ENV}`);
 	});
 
 	test("merging keeps other providers, replaces our own block, and is idempotent", () => {