auto-model-router 0.16.0 → 0.17.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.16.0",
+    "version": "0.17.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.16.0",
+      "version": "0.17.0",
       "author": {
         "name": "drewappling",
         "email": "drewappling@gmail.com"

package/README.md

@@ -1343,6 +1343,9 @@ the embed extension sets it from the workspace as it loads. If the variable is u
 sends the name itself, which the router does not accept as a scope (a scope is a
 lowercase slug) and falls back to its default. `--scope <slug>` pins one project for the
 whole machine instead; a refresh keeps a pin, and `connect --scope ""` removes it.
+`X-Agentdox-Origin` rides the same way under `AUTO_MODEL_ROUTER_ORIGIN`, set from the
+workspace's git remote; a pinned scope does not pin it, because the repository a turn
+came from is still the workspace's. See [the origin fingerprint](#the-origin-fingerprint).
 
 ### One file to install
 
@@ -1541,6 +1544,23 @@ a team posts exactly what it always did, so its block is byte-identical; an olde
 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.
 
+### The origin fingerprint
+
+The scope is the folder's name, and folder names collide: two unrelated repositories
+checked out as `api` would share one project, and one repository cloned into `~/work/api`
+and `~/src/backend-api` would split into two. So the embed extension also sends
+`X-Agentdox-Origin`: the workspace's git remote `origin`, normalised to `<host>/<path>` —
+lowercase, no scheme, credentials, port, `.git` or trailing slash — so
+`https://github.com/DrewAppling/omp-router.git` and `git@github.com:drewappling/omp-router.git`
+are both `github.com/drewappling/omp-router`. It is read from `.git/config` (or through a
+worktree's `.git` file) with the filesystem alone, never by running git, and a workspace
+outside a repository or with a local-path remote sends none. Like the scope it reaches the
+main model through an environment variable, `AUTO_MODEL_ROUTER_ORIGIN`, that the managed
+`models.yml` entry names and the extension sets. A team edition uses it to find the
+project a workspace belongs to whatever the folder is called; a router on its own has no
+project registry and ignores it — the header is parsed and validated (a raw URL or the
+variable's name is dropped) and nothing else changes.
+
 ### 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

package/docs/AGENTDOX-BRIDGE.md

@@ -32,7 +32,8 @@ unchanged re-assembly keeps the same bytes and the cache survives.
 | `src/context/store.ts` | `context_blocks` (content-addressed) + `agentdox_sessions` |
 | `src/context/index.ts` | `createBridgeFromConfig` — returns an inert bridge when unconfigured |
 | `src/server/turn.ts` | Resolve → inject → pin → record. Two `log.debug("agentdox …")` lines |
-| `src/wire/openai/request.ts` | `injectContextBlock` + `x-agentdox-scope` header parsing |
+| `src/wire/openai/request.ts` | `injectContextBlock` + the `x-agentdox-*` header parsing (the Anthropic path delegates to it) |
+| `src/context/scope.ts` | The slug and origin rules, and the env-var names the managed provider entries carry |
 | `src/util/sqlite.ts` | `USER_VERSION` 11, `MIGRATE_V11` |
 | `test/context-bridge.test.ts` | 14 tests: every refresh trigger, restart survival, degradation |
 | `tools/agentdox-e2e.ts` | Live check against a running agentdox server |
@@ -41,6 +42,22 @@ Injection appends to the **last system message** rather than inserting one — i
 shift every `cacheBreakpointMessageIndices` entry the core computed, and appending lands the
 block inside the prefix `planCacheBreakpoints` already marks.
 
+### The request headers
+
+Every one is optional; absent or invalid ⇒ empty, and an empty value sends nothing new to
+agentdox, so a router without a front door behaves as it always did.
+
+| Header | Since | Value | Who sends it | What the router does |
+| --- | --- | --- | --- | --- |
+| `X-Agentdox-Scope` | 0.2 | a project slug (`isScopeSlug`) | the embed extension, from the workspace folder; the managed `models.yml` entry names `AUTO_MODEL_ROUTER_SCOPE` and the extension sets it | selects the project whose context is injected and whose sessions the turn is recorded into; empty ⇒ `context.defaultScope` |
+| `X-Agentdox-Group` | 0.16.0 | a slug | a front door (the team edition), per request | the group's brief and top memory render **first**; sent to `assemble` as `group` |
+| `X-Agentdox-Personal` | 0.16.0 | a slug | a front door, per request | the member's own thread renders **last**; sent as `personal`. When either layer is named the harness id goes as `user` too |
+| `X-Agentdox-Origin` | 0.17.0 | `<host>/<path>` of the git remote (`isOrigin`) | the embed extension, from `.git/config`; `models.yml` names `AUTO_MODEL_ROUTER_ORIGIN` | parsed and validated only (`NormRequest.agentdoxOrigin`); the bridge never reads it — a front door with a project registry resolves the project from it |
+
+omp resolves a header value that names an environment variable per request, and sends the
+literal name when the variable is unset. Both names are uppercase and neither rule accepts
+uppercase, so a sentinel can never become a project or a fingerprint.
+
 ## 3. Running it
 
 ```bash

package/omp-extension/embed-logic.ts

@@ -13,7 +13,9 @@
  */
 
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { dirname, join, resolve } from "node:path";
+
+import { normalizeOrigin } from "../src/context/scope.ts";
 
 /**
  * The provider id registered into omp. Kept stable so a `models.yml` that
@@ -58,6 +60,13 @@ export interface EmbedConfig {
 	 * models never loses the project's memory/docs/brief.
 	 */
 	agentdoxScope?: string;
+	/**
+	 * The workspace's repository fingerprint (its git remote `origin`,
+	 * normalised) sent as `X-Agentdox-Origin`. A front door with a project
+	 * registry uses it to find the project whatever the folder is called; a
+	 * router alone ignores it.
+	 */
+	agentdoxOrigin?: string;
 }
 
 /**
@@ -79,6 +88,81 @@ export function deriveAgentdoxScope(cwd: string): string {
 		.replace(/^-+|-+$/g, "");
 }
 
+/** The first `url` under `[remote "origin"]` in a git config, or "" when there is none. */
+function originUrlOf(config: string): string {
+	let inOrigin = false;
+	for (const line of config.split(/\r?\n/)) {
+		const t = line.trim();
+		if (t.startsWith("[")) {
+			inOrigin = /^\[remote\s+"origin"\]$/i.test(t);
+			continue;
+		}
+		if (!inOrigin) continue;
+		const m = /^url\s*=\s*(.+)$/i.exec(t);
+		if (m !== null) return m[1]!.trim().replace(/^"(.*)"$/, "$1");
+	}
+	return "";
+}
+
+/**
+ * Derives the workspace's repository fingerprint: the git remote `origin` of
+ * the repository holding `cwd`, normalised by `normalizeOrigin`.
+ *
+ * The scope (`deriveAgentdoxScope`) is the FOLDER's name, which two unrelated
+ * repositories can share and one repository cloned twice does not. The origin
+ * is what a project registry needs to tell them apart, so it travels beside
+ * the scope; the scope itself is untouched by this.
+ *
+ * Walks up from `cwd` to the filesystem root looking for `.git`. A directory
+ * holds `config` directly; a file (a worktree or a submodule) names the real
+ * git dir with `gitdir: <path>`, relative to the folder holding the file, and
+ * a worktree's own dir keeps the shared config one hop further in `commondir`.
+ * Read with the filesystem only — never git itself, which may be absent, slow,
+ * or prompt — and total: any failure, including no repository at all, is "".
+ * `readFile` is injectable so the walk can be tested on hand-built files.
+ */
+export function deriveWorkspaceOrigin(cwd: string, readFile: (path: string) => string = (p) => readFileSync(p, "utf8")): string {
+	const read = (path: string): string | null => {
+		try {
+			return readFile(path);
+		} catch {
+			return null;
+		}
+	};
+	try {
+		if (cwd.trim() === "") return "";
+		let dir = resolve(cwd);
+		for (;;) {
+			const dotGit = join(dir, ".git");
+			// A directory: the config sits inside it. (Reading a directory throws.)
+			let config = read(join(dotGit, "config"));
+			if (config === null) {
+				// A file: `gitdir: <path>`; that dir has its own config (a
+				// submodule) or points at the shared one through `commondir`.
+				const pointer = read(dotGit);
+				const m = pointer === null ? null : /^gitdir:\s*(.+?)\s*$/m.exec(pointer);
+				if (m !== null) {
+					const gitDir = resolve(dir, m[1]!);
+					config = read(join(gitDir, "config"));
+					if (config === null) {
+						const common = read(join(gitDir, "commondir"));
+						if (common !== null) config = read(join(resolve(gitDir, common.trim()), "config"));
+					}
+					// A `.git` file that leads nowhere is still the repository's
+					// boundary: nothing above it is this workspace's origin.
+					return config === null ? "" : normalizeOrigin(originUrlOf(config));
+				}
+			}
+			if (config !== null) return normalizeOrigin(originUrlOf(config));
+			const parent = dirname(dir);
+			if (parent === dir) return "";
+			dir = parent;
+		}
+	} catch {
+		return "";
+	}
+}
+
 /**
  * Resolves the desired bind port: an explicit `AUTO_MODEL_ROUTER_PORT` when set
  * and valid, else 0 so the OS assigns a free ephemeral port.
@@ -189,6 +273,8 @@ export function buildProviderConfig(
 	},
 	/** omp's workspace directory, used to derive a scope when none is configured. */
 	cwd?: string,
+	/** The workspace's repository fingerprint (`deriveWorkspaceOrigin`); "" or absent sends none. */
+	origin?: string,
 ): EmbedConfig {
 	const host = cfg.server.host === "0.0.0.0" || cfg.server.host === "::" ? "127.0.0.1" : cfg.server.host;
 	const round = (v: number): number => Math.round(v * 1e4) / 1e4;
@@ -224,6 +310,10 @@ export function buildProviderConfig(
 		const derived = deriveAgentdoxScope(cwd ?? "");
 		const scope = derived !== "" ? derived : cfg.context.defaultScope;
 		if (scope !== "") out.agentdoxScope = scope;
+		// The repository beside the folder: one value for every clone of it,
+		// whatever each is called. Only a registry can use it, so it is sent
+		// only where the scope is.
+		if (origin !== undefined && origin !== "") out.agentdoxOrigin = origin;
 	}
 	return out;
 }

package/omp-extension/remote-logic.ts

@@ -112,7 +112,7 @@ export const REMOTE_MODELS: readonly { id: string; name: string }[] = [
  * the session and subagent tags, and the virtual models. Costs are USD per
  * million tokens, like the embedded config.
  */
-export function remoteProviderRegistration(remote: RemoteRouter, sessionId: string, subagent: boolean, blend: { inputPerMtok: number; outputPerMtok: number }, agentdoxScope = ""): {
+export function remoteProviderRegistration(remote: RemoteRouter, sessionId: string, subagent: boolean, blend: { inputPerMtok: number; outputPerMtok: number }, agentdoxScope = "", agentdoxOrigin = ""): {
 	baseUrl: string;
 	api: string;
 	apiKey: string;
@@ -126,6 +126,9 @@ export function remoteProviderRegistration(remote: RemoteRouter, sessionId: stri
 	// router, so this is sent whatever the local config says; the remote decides what to do with
 	// it (a team that pins a scope for the group overrides it, and one that pins none follows it).
 	if (agentdoxScope !== "") headers["X-Agentdox-Scope"] = agentdoxScope;
+	// The repository behind that folder: the same value from every clone, so a remote with a
+	// project registry finds the project when two folders share a name or one repo has two.
+	if (agentdoxOrigin !== "") headers["X-Agentdox-Origin"] = agentdoxOrigin;
 	const round = (v: number): number => Math.round(v * 1e4) / 1e4;
 	return {
 		baseUrl: `${remote.url}/v1`,

package/omp-extension/router-embed.ts

@@ -33,8 +33,8 @@ import type { RouterConfig } from "../src/config/types.ts";
 
 import type { ExtensionAPI } from "@oh-my-pi/pi-coding-agent";
 
-import { EMBED_DUMMY_API_KEY, EMBED_PROVIDER_ID, buildProviderConfig, deriveAgentdoxScope, embedPortPath, modelsYmlPort, probeEmbed, readEmbedPort, resolveEmbedPort, writeEmbedPort } from "./embed-logic.ts";
-import { SCOPE_ENV } from "../src/context/scope.ts";
+import { EMBED_DUMMY_API_KEY, EMBED_PROVIDER_ID, buildProviderConfig, deriveAgentdoxScope, deriveWorkspaceOrigin, embedPortPath, modelsYmlPort, probeEmbed, readEmbedPort, resolveEmbedPort, writeEmbedPort } from "./embed-logic.ts";
+import { ORIGIN_ENV, SCOPE_ENV } from "../src/context/scope.ts";
 
 // The workspace's scope for the MAIN model. omp builds that handle from
 // models.yml before this file loads, so its X-Agentdox-Scope cannot come from
@@ -43,9 +43,17 @@ import { SCOPE_ENV } from "../src/context/scope.ts";
 // and this module runs inside omp's process — so setting it here reaches
 // every turn of this session, main and side roles alike. A workspace that
 // derives no scope (no folder name) leaves whatever the shell set.
+//
+// The workspace's ORIGIN (its git remote, normalised) rides the same way under
+// ORIGIN_ENV: the folder name is the scope, the repository is the fingerprint
+// a team uses to find the project when folder names collide. Read once — the
+// remote does not change during a session — and shared with the providers
+// registered below. A workspace outside a repository sets nothing.
+const workspaceOrigin = deriveWorkspaceOrigin(process.cwd());
 {
 	const workspaceScope = deriveAgentdoxScope(process.cwd());
 	if (workspaceScope !== "") process.env[SCOPE_ENV] = workspaceScope;
+	if (workspaceOrigin !== "") process.env[ORIGIN_ENV] = workspaceOrigin;
 }
 
 /** omp's models.yml as text, or "" when it does not exist / cannot be read. */
@@ -97,7 +105,7 @@ function trackProcessExit(): void {
 function registerRouterProvider(pi: ExtensionAPI, port: number, cfg: RouterConfig, sessionId: string, subagent: boolean): void {
 	// cwd is omp's workspace, which is what the agentdox scope is derived from
 	// when none is configured explicitly.
-	const providerConfig = buildProviderConfig(port, cfg, process.cwd());
+	const providerConfig = buildProviderConfig(port, cfg, process.cwd(), workspaceOrigin);
 	const headers: Record<string, string> = {};
 	if (providerConfig.harnessId !== undefined && providerConfig.harnessId !== "") {
 		headers["X-Omp-Harness"] = providerConfig.harnessId;
@@ -112,6 +120,10 @@ function registerRouterProvider(pi: ExtensionAPI, port: number, cfg: RouterConfi
 	if (providerConfig.agentdoxScope !== undefined && providerConfig.agentdoxScope !== "") {
 		headers["X-Agentdox-Scope"] = providerConfig.agentdoxScope;
 	}
+	// The repository behind that folder, for a front door that keeps a registry.
+	if (providerConfig.agentdoxOrigin !== undefined && providerConfig.agentdoxOrigin !== "") {
+		headers["X-Agentdox-Origin"] = providerConfig.agentdoxOrigin;
+	}
 	pi.registerProvider(EMBED_PROVIDER_ID, {
 		baseUrl: providerConfig.baseUrl,
 		api: "openai-completions",
@@ -190,7 +202,7 @@ export default function (pi: ExtensionAPI): void {
 					writeEmbedLog(`remote credential refresh failed: ${err instanceof Error ? err.message : String(err)}`);
 				}
 			}
-			pi.registerProvider(EMBED_PROVIDER_ID, remoteProviderRegistration(remote, sessionId, !ctx.hasUI, cfg.ledger.fallbackBlend, deriveAgentdoxScope(process.cwd())));
+			pi.registerProvider(EMBED_PROVIDER_ID, remoteProviderRegistration(remote, sessionId, !ctx.hasUI, cfg.ledger.fallbackBlend, deriveAgentdoxScope(process.cwd()), workspaceOrigin));
 			pi.setLabel(`auto-model-router remote (${remote.url.replace(/^https?:\/\//, "")})`);
 			writeEmbedLog(`remote mode url=${remote.url} user=${remote.userId} session=${sessionId}`);
 			return;

package/package.json

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

package/src/cli/config-cmd.ts

@@ -15,7 +15,7 @@
  * keys survive.
  */
 
-import { SCOPE_ENV } from "../context/scope.ts";
+import { ORIGIN_ENV, SCOPE_ENV } from "../context/scope.ts";
 import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
@@ -65,7 +65,9 @@ export interface SpliceResult {
  * the embed extension sets from the workspace folder, so the MAIN model's turns
  * carry the repository's own scope rather than one for the whole machine. When
  * the variable is unset the router ignores the literal and falls back to its
- * own `context.defaultScope`.
+ * own `context.defaultScope`. The origin (`ORIGIN_ENV`, set by the extension
+ * from the workspace's git remote) rides the same way; a router on its own
+ * ignores it, a front door with a project registry does not.
  */
 function providerHeaders(cfg: RouterConfig): Record<string, string> {
 	const headers: Record<string, string> = {};
@@ -74,6 +76,7 @@ function providerHeaders(cfg: RouterConfig): Record<string, string> {
 	}
 	if (cfg.context.enabled) {
 		headers["X-Agentdox-Scope"] = SCOPE_ENV;
+		headers["X-Agentdox-Origin"] = ORIGIN_ENV;
 	}
 	return headers;
 }

package/src/cli/connect.ts

@@ -29,7 +29,7 @@ import { homedir, hostname } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { refreshAccountOf, remoteFilePath } from "../../omp-extension/remote-logic.ts";
-import { SCOPE_ENV } from "../context/scope.ts";
+import { ORIGIN_ENV, SCOPE_ENV } from "../context/scope.ts";
 import { executablePath, materializePackage, readEmbeddedPackage } from "./embedded.ts";
 import { fetchSkills, installSkills, type SkillsBundle, type SkillsInstallReport, type SkillsTarget } from "./skills.ts";
 import { pickStore, saveRefreshToken, type StoreDeps, type StoreKind } from "./credential-store.ts";
@@ -200,6 +200,10 @@ const MODELS_YML_END = "  # END auto-model-router (remote)";
  * `SCOPE_ENV`, which omp resolves from its environment per request, and the
  * embed extension sets that variable from the workspace folder as it loads.
  * `scope` pins a literal slug instead, for a single-project machine.
+ *
+ * `X-Agentdox-Origin` always names `ORIGIN_ENV`, which the extension sets from
+ * the workspace's git remote: a pinned scope says which project's context to
+ * draw on, and the origin still says which repository the turn came from.
  */
 export function renderRemoteModelsYml(url: string, key: string, blend: { inputPerMtok: number; outputPerMtok: number }, scope = ""): string {
 	const round = (v: number): number => Math.round(v * 1e4) / 1e4;
@@ -217,7 +221,7 @@ export function renderRemoteModelsYml(url: string, key: string, blend: { inputPe
 		"    api: openai-completions",
 		`    apiKey: ${key}`,
 	];
-	lines.push("    headers:", `      X-Agentdox-Scope: ${scope !== "" ? scope : SCOPE_ENV}`);
+	lines.push("    headers:", `      X-Agentdox-Scope: ${scope !== "" ? scope : SCOPE_ENV}`, `      X-Agentdox-Origin: ${ORIGIN_ENV}`);
 	lines.push("    models:");
 	for (const m of REMOTE_MODEL_ROWS) {
 		lines.push(

package/src/context/scope.ts

@@ -27,3 +27,66 @@ export function acceptScope(raw: string | null | undefined): string {
 	const s = (raw ?? "").trim();
 	return isScopeSlug(s) ? s : "";
 }
+
+/**
+ * The workspace's ORIGIN travels the same road as the scope: `connect` and
+ * `config --write` put this NAME in the managed provider entry, the embed
+ * extension sets the variable from the workspace's git remote as it loads, and
+ * omp resolves it per request. Where the scope names a FOLDER, the origin
+ * names the REPOSITORY, so a front door with a project registry (the team
+ * edition) can tell two unrelated `api` folders apart and recognise one repo
+ * cloned into two differently named folders. A router on its own has no such
+ * registry and ignores it.
+ */
+export const ORIGIN_ENV = "AUTO_MODEL_ROUTER_ORIGIN";
+
+/**
+ * A repository fingerprint: `<host>/<path>` — lowercase, no scheme, no
+ * credentials, no port, no trailing `.git`, no trailing slash — so the same
+ * repository cloned over https and over ssh yields one value. Uppercase never
+ * passes, so `ORIGIN_ENV` itself, which omp sends verbatim when the variable is
+ * unset, can never become a fingerprint.
+ */
+export function isOrigin(value: string): boolean {
+	return /^[a-z0-9][a-z0-9.-]{0,127}(\/[a-z0-9._~-]{1,64}){1,8}$/.test(value);
+}
+
+/**
+ * Reduces a git remote URL to its fingerprint, or "" when it names no host —
+ * a local path (`/srv/repo`, `C:\repo`) or `file://` — or does not reduce to a
+ * valid origin. Every form git accepts for `origin` is covered: `scheme://`
+ * with optional credentials and port, and the scp-like `[user@]host:path`.
+ */
+export function normalizeOrigin(url: string): string {
+	const raw = url.trim();
+	let host: string;
+	let path: string;
+	const scheme = /^([a-z][a-z0-9+.-]*):\/\//i.exec(raw);
+	if (scheme !== null) {
+		if (scheme[1]!.toLowerCase() === "file") return "";
+		const rest = raw.slice(scheme[0].length);
+		const slash = rest.search(/[/\\]/);
+		host = slash < 0 ? rest : rest.slice(0, slash);
+		path = slash < 0 ? "" : rest.slice(slash + 1);
+	} else {
+		// scp-like `[user@]host:path`. A Windows drive (`C:\repo`, `C:/repo`)
+		// has the same shape with a one-letter "host" and is a local path.
+		const scp = /^(?:[^@/\\:]+@)?([^/\\:]+):(.*)$/.exec(raw);
+		if (scp === null || /^[a-z]$/i.test(scp[1]!)) return "";
+		host = scp[1]!;
+		path = scp[2]!;
+	}
+	// Credentials first (a password may contain digits and a colon), then the port.
+	host = host.slice(host.lastIndexOf("@") + 1).replace(/:\d+$/, "");
+	const segments = path.split(/[/\\]/).filter((s) => s !== "");
+	const last = segments.length - 1;
+	if (last >= 0) segments[last] = segments[last]!.replace(/\.git$/i, "");
+	const value = [host, ...segments.filter((s) => s !== "")].join("/").toLowerCase();
+	return isOrigin(value) ? value : "";
+}
+
+/** The origin to trust from a request header: a fingerprint, or "" for anything else. */
+export function acceptOrigin(raw: string | null | undefined): string {
+	const s = (raw ?? "").trim();
+	return isOrigin(s) ? s : "";
+}

package/src/server/advise.ts

@@ -52,6 +52,7 @@ function requestOf(req: AdviseRequest): NormRequest {
 		agentdoxScope: "",
 		agentdoxGroup: "",
 		agentdoxPersonal: "",
+		agentdoxOrigin: "",
 		isSubagent: false,
 		requestedModel: "auto",
 		messages: [

package/src/server/digest.ts

@@ -101,6 +101,7 @@ function syntheticRequest(req: DigestRequest, promptText: string): NormRequest {
 		agentdoxScope: "",
 		agentdoxGroup: "",
 		agentdoxPersonal: "",
+		agentdoxOrigin: "",
 		isSubagent: true,
 		requestedModel: "digest",
 		messages: [

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,
@@ -341,6 +341,11 @@ export function parseChatRequest(body: unknown, headers: Headers): NormRequest {
 	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";
 
@@ -409,6 +414,7 @@ export function parseChatRequest(body: unknown, headers: Headers): NormRequest {
 		agentdoxScope,
 		agentdoxGroup,
 		agentdoxPersonal,
+		agentdoxOrigin,
 		isSubagent,
 		...(policy === undefined ? {} : { policy }),
 		requestedModel,

package/src/wire/types.ts

@@ -109,6 +109,15 @@ export interface NormRequest {
 	 * 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

@@ -154,6 +154,12 @@ describe("parseMessagesRequest", () => {
 		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/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

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

package/test/failover.test.ts

@@ -98,6 +98,7 @@ function mkReq(): NormRequest {
 		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", () => {

package/test/scope.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { SCOPE_ENV, acceptScope, isScopeSlug } from "../src/context/scope.ts";
+import { ORIGIN_ENV, SCOPE_ENV, acceptOrigin, acceptScope, isOrigin, isScopeSlug, normalizeOrigin } from "../src/context/scope.ts";
 import { parseChatRequest } from "../src/wire/openai/request.ts";
 
 describe("the scope a request may name", () => {
@@ -49,3 +49,56 @@ describe("the scope a request may name", () => {
 		expect(parse({ "x-agentdox-group": "group.g1" }).agentdoxGroup).toBe("group.g1");
 	});
 });
+
+describe("the origin a request may name", () => {
+	test("normalizeOrigin reduces every remote form to host/path, and a local path to nothing", () => {
+		// The same repository over https and ssh is one fingerprint.
+		expect(normalizeOrigin("https://github.com/DrewAppling/omp-router.git")).toBe("github.com/drewappling/omp-router");
+		expect(normalizeOrigin("git@github.com:drewappling/omp-router.git")).toBe("github.com/drewappling/omp-router");
+		expect(normalizeOrigin("ssh://git@gitlab.example.com:2222/team/api/")).toBe("gitlab.example.com/team/api");
+		// Credentials and the port never reach the value.
+		expect(normalizeOrigin("https://user:p4ss@host.example:8443/a/b.git")).toBe("host.example/a/b");
+		expect(normalizeOrigin("host.example:repo")).toBe("host.example/repo");
+		expect(normalizeOrigin(" https://github.com/a/b/.git ")).toBe("github.com/a/b");
+		// No host, no fingerprint: a local clone says nothing about the project.
+		expect(normalizeOrigin("file:///e/projects/x")).toBe("");
+		expect(normalizeOrigin("/local/path")).toBe("");
+		expect(normalizeOrigin("C:\\path")).toBe("");
+		expect(normalizeOrigin("C:\\Users\\drew\\repo")).toBe("");
+		expect(normalizeOrigin("C:/path")).toBe("");
+		expect(normalizeOrigin("https://github.com/")).toBe("");
+		expect(normalizeOrigin("")).toBe("");
+	});
+
+	test("isOrigin: host/path only; the env-var sentinel never passes", () => {
+		expect(isOrigin("github.com/drewappling/omp-router")).toBe(true);
+		expect(isOrigin("gitlab.example.com/team/sub/api")).toBe(true);
+		// omp sends the header's literal value when the variable it names is
+		// unset: the NAME must never become a fingerprint.
+		expect(isOrigin(ORIGIN_ENV)).toBe(false);
+		expect(isOrigin("github.com")).toBe(false);
+		expect(isOrigin("GitHub.com/a/b")).toBe(false);
+		expect(isOrigin("https://github.com/a/b")).toBe(false);
+		expect(isOrigin("github.com/a/b/")).toBe(false);
+		expect(isOrigin("")).toBe(false);
+	});
+
+	test("acceptOrigin trims and rejects", () => {
+		expect(acceptOrigin(" github.com/a/b ")).toBe("github.com/a/b");
+		expect(acceptOrigin(ORIGIN_ENV)).toBe("");
+		expect(acceptOrigin("https://github.com/a/b")).toBe("");
+		expect(acceptOrigin(null)).toBe("");
+	});
+
+	test("the wire parser reads X-Agentdox-Origin by that rule and nothing else changes", () => {
+		const body = { model: "auto", messages: [{ role: "user", content: "hi" }] };
+		const parse = (h: Record<string, string>) => parseChatRequest(body, new Headers(h));
+		expect(parse({ "x-agentdox-scope": "omp-router" }).agentdoxOrigin).toBe("");
+		const both = parse({ "x-agentdox-scope": "omp-router", "x-agentdox-origin": "github.com/drewappling/omp-router" });
+		expect(both.agentdoxScope).toBe("omp-router");
+		expect(both.agentdoxOrigin).toBe("github.com/drewappling/omp-router");
+		// The sentinel and a raw URL are dropped, never passed through.
+		expect(parse({ "x-agentdox-origin": ORIGIN_ENV }).agentdoxOrigin).toBe("");
+		expect(parse({ "x-agentdox-origin": "https://github.com/a/b" }).agentdoxOrigin).toBe("");
+	});
+});

package/test/turn.test.ts

@@ -98,6 +98,7 @@ function mkReq(): NormRequest {
 		agentdoxScope: "",
 		agentdoxGroup: "",
 		agentdoxPersonal: "",
+		agentdoxOrigin: "",
 		isSubagent: false,
 		requestedModel: "auto",
 		messages: [{ role: "user", text: "hi", images: 0, textBytes: 2, toolCalls: [] }],

package/tools/replay.ts

@@ -199,6 +199,7 @@ function requestOf(row: Row, f: Features): NormRequest {
 		agentdoxScope: "",
 		agentdoxGroup: "",
 		agentdoxPersonal: "",
+		agentdoxOrigin: "",
 		isSubagent: false,
 		requestedModel: row.requested_model,
 		messages,