@@ -28,6 +28,7 @@ import {
   oauth_client,
   oauth_session,
   plugin_storage,
+  subject,
   tool,
   tool_policy,
 } from "./executor-schema";
@@ -131,6 +132,13 @@ const seedTenant = async (db: DrizzleDb, tenant: string, tag: string) => {
     subject: "s",
   });
 
+  await db.insert(subject).values({
+    external_id: `acct-${tag}`,
+    created_at: now,
+    last_seen_at: BigInt(now.getTime()),
+    tenant,
+  });
+
   const orgNs = `o:${tenant}/plugin`;
   const userNs = `u:${tenant}:subject/plugin`;
   await db.insert(blob).values({
@@ -156,6 +164,7 @@ const TENANT_TABLES = [
   definition,
   tool_policy,
   plugin_storage,
+  subject,
 ] as const;
 
 const countTenantRows = async (db: DrizzleDb, tenant: string): Promise<number> => {
 
@@ -23,6 +23,7 @@ import {
   oauth_client,
   oauth_session,
   plugin_storage,
+  subject,
   tool,
   tool_policy,
 } from "./executor-schema";
@@ -48,6 +49,7 @@ export const purgeOrganizationData = (db: DrizzleDb, organizationId: string): Pr
     await tx.delete(oauth_session).where(eq(oauth_session.tenant, organizationId));
     await tx.delete(tool_policy).where(eq(tool_policy.tenant, organizationId));
     await tx.delete(plugin_storage).where(eq(plugin_storage.tenant, organizationId));
+    await tx.delete(subject).where(eq(subject.tenant, organizationId));
 
     // Secrets, OAuth tokens, and cached specs live in `blob`, namespaced by
     // owner: `o:<org>/<plugin>` (org scope) and `u:<org>:<subject>/<plugin>`
 
@@ -0,0 +1,82 @@
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { Effect, Layer } from "effect";
+import { afterAll, beforeAll, expect, test } from "@effect/vitest";
+import { withQueryContext } from "@executor-js/fumadb/query";
+
+import { makeScopedExecutor } from "@executor-js/api/server";
+
+import { createSelfHostDb, SelfHostDb } from "./db/self-host-db";
+import { SelfHostScopedExecutorSeams } from "./execution";
+import type { SelfHostPlugins } from "./plugins";
+
+// The `subject` table is populated at the request seam: `makeScopedExecutor` is
+// what every HTTP request and MCP session on every host passes through, so
+// building a scoped executor IS a sighting. Exercised here against a real host's
+// seams (long-lived SQLite DbProvider + real plugins) rather than a stub, since
+// the point is that the production wiring reaches the writer at all.
+
+const createScopedExecutor = (accountId: string, organizationId: string) =>
+  makeScopedExecutor<SelfHostPlugins>(accountId, organizationId, "Default").pipe(
+    Effect.provide(SelfHostScopedExecutorSeams),
+  );
+
+const dataDir = mkdtempSync(join(tmpdir(), "eh-subj-"));
+process.env.EXECUTOR_DATA_DIR = dataDir;
+
+let dbLayer!: Layer.Layer<SelfHostDb>;
+let dbHandle: Awaited<ReturnType<typeof createSelfHostDb>> | undefined;
+
+beforeAll(async () => {
+  dbHandle = await createSelfHostDb({
+    path: join(dataDir, "data.db"),
+    namespace: "executor_selfhost",
+    version: "1.0.0",
+  });
+  dbLayer = Layer.succeed(SelfHostDb)(dbHandle);
+});
+afterAll(async () => {
+  await dbHandle?.close();
+});
+
+const subjectsOf = async (tenant: string): Promise<readonly string[]> => {
+  const rows = await withQueryContext(dbHandle!.db, {
+    tenant,
+    subject: null,
+  }).findMany("subject", {
+    orderBy: ["external_id", "asc"],
+  });
+  return rows.map((row) => String(row.external_id));
+};
+
+test("building a scoped executor records the acting principal", async () => {
+  const before = Date.now();
+  await Effect.runPromise(
+    createScopedExecutor("alice", "sightings-org").pipe(Effect.provide(dbLayer), Effect.asVoid),
+  );
+
+  expect(await subjectsOf("sightings-org")).toEqual(["alice"]);
+
+  const [row] = await withQueryContext(dbHandle!.db, {
+    tenant: "sightings-org",
+    subject: null,
+  }).findMany("subject", {});
+  expect(Number(row?.last_seen_at)).toBeGreaterThanOrEqual(before);
+});
+
+test("repeat requests from several members converge on one row each", async () => {
+  const org = "sightings-org-2";
+  await Effect.runPromise(
+    Effect.forEach(
+      ["alice", "alice", "bob", "alice"],
+      (accountId) => createScopedExecutor(accountId, org).pipe(Effect.asVoid),
+      { discard: true },
+    ).pipe(Effect.provide(dbLayer)),
+  );
+
+  // Four requests, two principals, two rows: the sighting is an upsert, and
+  // the repeat sightings are absorbed by the throttle rather than duplicating.
+  expect(await subjectsOf(org)).toEqual(["alice", "bob"]);
+});
@@ -42,7 +42,11 @@ import {
   type Executor,
   type StorageFailure,
 } from "@executor-js/sdk";
-import { makeHostedFetch, makeHostedHttpClientLayer } from "@executor-js/sdk/host-internal";
+import {
+  makeHostedFetch,
+  makeHostedHttpClientLayer,
+  touchSubject,
+} from "@executor-js/sdk/host-internal";
 
 import { DbProvider } from "./executor-fuma-db";
 
@@ -281,6 +285,16 @@ export const makeScopedExecutor = <
         includeProviders: config.exposeCredentialProviders ?? true,
       },
     }).pipe(Effect.withSpan("executor.stack.create_executor"));
+    // Record the sighting. THIS is the seam every HTTP request and MCP session
+    // on every host passes through, so it is where the `subject` table gets
+    // populated: a principal earns a row the first time it authenticates,
+    // whether or not it ever connects anything. Throttled (`touchSubject` only
+    // rewrites `last_seen_at` past a coarse interval) and non-fatal by
+    // construction — it returns `Effect<void>`, so a lost sighting logs and the
+    // request proceeds. `accountId` is passed verbatim, sentinels ("local")
+    // included.
+    yield* touchSubject(db, { tenant: organizationId, externalId: accountId });
+
     // The seam erases the plugin tuple type; the caller re-narrows via the
     // `TPlugins` phantom. Runtime shape is identical to a typed
     // `createExecutor({ plugins })` call.
 
@@ -107,6 +107,7 @@ import {
   type UpdateToolPolicyInput,
 } from "./policies";
 import type { CredentialProvider, ProviderEntry } from "./provider";
+import { touchSubject } from "./subject-registry";
 import type {
   AnyPlugin,
   Elicit,
@@ -2428,6 +2429,16 @@ export const createExecutor = <const TPlugins extends readonly AnyPlugin[] = rea
           }),
         );
 
+        // Record the sighting. The request seam (`makeScopedExecutor`) already
+        // does this for every hosted call, so this is the belt for direct
+        // SDK/CLI callers that never pass through it — a connecting principal
+        // must always have a subject row. Outside
+        // the transaction above: bookkeeping must not roll back the
+        // connection, and `touchSubject` cannot fail. No-ops on a pure-org
+        // executor (no principal to record), including for `owner: "org"`
+        // connections created by a bound member.
+        yield* touchSubject(rootDbUntyped, { tenant, externalId: subject });
+
         const ref: ConnectionRef = {
           owner: input.owner,
           integration: input.integration,
 
@@ -20,6 +20,9 @@
 //     endpoint SSRF guard + default fetch timeout. The SDK's own OAuth flow uses
 //     them; the host's connection-identity handler reuses the same guard/timeout
 //     when fetching OIDC userinfo, so they surface here (not the plugin barrel).
+//   - `touchSubject`: the sole writer of the `subject` table. The SDK writes a
+//     sighting at connection-create; the host layer writes one per request in
+//     `makeScopedExecutor`. Not a plugin-author concern.
 // ---------------------------------------------------------------------------
 
 export {
@@ -31,6 +34,12 @@ export {
 
 export { OAUTH2_DEFAULT_TIMEOUT_MS, assertSupportedOAuthEndpointUrl } from "./oauth-helpers";
 
+export {
+  DEFAULT_SUBJECT_LAST_SEEN_THROTTLE_MS,
+  touchSubject,
+  type TouchSubjectInput,
+} from "./subject-registry";
+
 export {
   createExecutorFumaDb,
   type CreateExecutorFumaDbOptions,