auto-model-router 0.15.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.15.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.15.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
 
@@ -1519,6 +1522,45 @@ 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.
+
+### 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
@@ -1549,7 +1591,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/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.15.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/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/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/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/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 : "";
+}