@creatornader/agent-bridge 0.2.0

package/dist/sqlite.d.ts

@@ -0,0 +1,156 @@
+import { b as BridgeMessage, c as BridgePrincipal, B as BridgeDelivery, D as DeliveryState, R as RetryPolicy, A as AgentPresence, a as BridgeDeliveryEvent } from './bridge-domain-BcnBeHOn.js';
+import { b as MessageQuery, M as MessagePage, B as BridgeDiagnostics, I as InsertMessageResult, a as BridgeStore, C as ClaimOptions } from './bridge-store-BuGjxTn4.js';
+
+type PendingMessage = Omit<BridgeMessage, "sequence" | "createdAt">;
+interface EdgeScope {
+    endpoint: string;
+    principal: BridgePrincipal;
+}
+interface EdgeOutboxRecord {
+    position: number;
+    draft: PendingMessage;
+    payloadHash: string;
+    attempts: number;
+    leaseToken: string;
+    createdAt: string;
+}
+interface EdgeEnqueueResult {
+    draft: PendingMessage;
+    created: boolean;
+}
+interface EdgeStats {
+    pending: number;
+    blocked: number;
+    cached: number;
+    pullCursor?: string;
+    lastSyncAt?: string;
+    lastError?: string;
+}
+declare class EdgeConflictError extends Error {
+    readonly code = "edge_idempotency_conflict";
+}
+declare function edgeMessageFingerprint(message: PendingMessage | BridgeMessage): string;
+declare function stableIdempotency(message: PendingMessage): PendingMessage;
+declare function edgeScopeKey(scope: EdgeScope): string;
+declare class SQLiteEdgeStore {
+    private readonly path;
+    private readonly scope;
+    private readonly busyTimeoutMs;
+    private readonly db;
+    private readonly key;
+    private initialized;
+    constructor(path: string, scope: EdgeScope, busyTimeoutMs?: number);
+    private restrictFiles;
+    get scopeKey(): string;
+    initialize(): Promise<void>;
+    private ready;
+    enqueue(input: PendingMessage, now?: Date): Promise<EdgeEnqueueResult>;
+    claimNext(now?: Date, leaseMs?: number): Promise<EdgeOutboxRecord | undefined>;
+    retry(record: EdgeOutboxRecord, error: string, availableAt: Date): Promise<void>;
+    block(record: EdgeOutboxRecord, error: string): Promise<void>;
+    commit(record: EdgeOutboxRecord, message: BridgeMessage, cacheVisible: boolean, now?: Date): Promise<void>;
+    private cacheOne;
+    cachePage(messages: BridgeMessage[], cursor: string | undefined, now?: Date): Promise<void>;
+    cacheLatest(messages: BridgeMessage[], now?: Date): Promise<void>;
+    list(query?: MessageQuery): Promise<MessagePage>;
+    pullCursor(): Promise<string | undefined>;
+    noteError(error: string): Promise<void>;
+    stats(): Promise<EdgeStats>;
+    close(): Promise<void>;
+}
+
+interface SyncInsertResult extends InsertMessageResult {
+    disposition: "committed" | "queued";
+    authoritative: boolean;
+}
+interface CachedMessagePage extends MessagePage {
+    source: "remote" | "cache";
+    stale: boolean;
+    lastSyncedAt?: string;
+}
+interface SyncReport {
+    online: boolean;
+    pushed: number;
+    deduplicated: number;
+    pulled: number;
+    pending: number;
+    blocked: number;
+    cached: number;
+    cursor?: string;
+    lastSyncedAt?: string;
+    lastError?: string;
+    failureRetryable?: boolean;
+}
+interface SyncDiagnostics extends BridgeDiagnostics {
+    remoteReachable: boolean;
+    outboxPending: number;
+    outboxBlocked: number;
+    cachedMessages: number;
+    lastSyncAt?: string;
+    lastSyncError?: string;
+}
+interface SyncingBridgeStoreOptions {
+    now?: () => Date;
+    random?: () => number;
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+    leaseMs?: number;
+}
+declare function isRetryableSyncError(error: unknown): boolean;
+declare class SyncingBridgeStore implements BridgeStore {
+    private readonly edge;
+    private readonly remote;
+    private readonly principal;
+    private readonly now;
+    private readonly random;
+    private readonly baseDelayMs;
+    private readonly maxDelayMs;
+    private readonly leaseMs;
+    private remoteReady;
+    constructor(edge: SQLiteEdgeStore, remote: BridgeStore, principal: BridgePrincipal, options?: SyncingBridgeStoreOptions);
+    initialize(): Promise<void>;
+    verifyRemote(): Promise<void>;
+    private ensureRemote;
+    private assertPrincipal;
+    private delay;
+    private flushOne;
+    insertMessage(message: PendingMessage): Promise<SyncInsertResult>;
+    private pull;
+    sync(options?: {
+        maxPush?: number;
+        maxPages?: number;
+    }): Promise<SyncReport>;
+    listMessages(principal: BridgePrincipal, query?: MessageQuery): Promise<CachedMessagePage>;
+    recordReceipt(workspace: string, messageIds: string[], principal: string, readAt?: Date): Promise<number>;
+    claimDelivery(principal: BridgePrincipal, options: ClaimOptions): Promise<BridgeDelivery | null>;
+    renewDelivery(principal: BridgePrincipal, deliveryId: string, leaseToken: string, leaseMs: number): Promise<BridgeDelivery | null>;
+    settleDelivery(principal: BridgePrincipal, deliveryId: string, leaseToken: string, state: Extract<DeliveryState, "acked" | "retrying" | "dead">, error: string | undefined, retryPolicy: RetryPolicy): Promise<BridgeDelivery | null>;
+    diagnostics(principal: BridgePrincipal): Promise<SyncDiagnostics>;
+    heartbeat(principal: BridgePrincipal, leaseMs: number, runtimeType?: string, capabilities?: string[]): Promise<AgentPresence>;
+    listPresence(principal: BridgePrincipal): Promise<AgentPresence[]>;
+    close(): Promise<void>;
+}
+
+declare class SQLiteBridgeStore implements BridgeStore {
+    private readonly path;
+    private readonly busyTimeoutMs;
+    private readonly db;
+    private initialized;
+    constructor(path?: string, busyTimeoutMs?: number);
+    private restrictFiles;
+    initialize(): Promise<void>;
+    private ready;
+    insertMessage(input: Omit<BridgeMessage, "sequence" | "createdAt">): Promise<InsertMessageResult>;
+    listMessages(principal: BridgePrincipal, query?: MessageQuery): Promise<MessagePage>;
+    recordReceipt(workspace: string, messageIds: string[], principal: string, readAt?: Date): Promise<number>;
+    claimDelivery(principal: BridgePrincipal, options: ClaimOptions): Promise<BridgeDelivery | null>;
+    renewDelivery(principal: BridgePrincipal, id: string, token: string, leaseMs: number): Promise<BridgeDelivery | null>;
+    settleDelivery(principal: BridgePrincipal, id: string, token: string, state: "acked" | "retrying" | "dead", error: string | undefined, retryPolicy: RetryPolicy): Promise<BridgeDelivery | null>;
+    diagnostics(principal: BridgePrincipal): Promise<BridgeDiagnostics>;
+    heartbeat(principal: BridgePrincipal, leaseMs: number, runtimeType?: string, capabilities?: string[]): Promise<AgentPresence>;
+    listPresence(principal: BridgePrincipal): Promise<AgentPresence[]>;
+    listDeliveryEvents(deliveryId: string): Promise<BridgeDeliveryEvent[]>;
+    close(): Promise<void>;
+}
+
+export { type CachedMessagePage, EdgeConflictError, type EdgeEnqueueResult, type EdgeOutboxRecord, type EdgeScope, type EdgeStats, type PendingMessage, SQLiteBridgeStore, SQLiteEdgeStore, type SyncDiagnostics, type SyncInsertResult, type SyncReport, SyncingBridgeStore, type SyncingBridgeStoreOptions, edgeMessageFingerprint, edgeScopeKey, isRetryableSyncError, stableIdempotency };

package/dist/sqlite.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import {
+  EdgeConflictError,
+  SQLiteBridgeStore,
+  SQLiteEdgeStore,
+  SyncingBridgeStore,
+  edgeMessageFingerprint,
+  edgeScopeKey,
+  isRetryableSyncError,
+  stableIdempotency
+} from "./chunk-WEULPMUY.js";
+import "./chunk-YD6YJATN.js";
+import "./chunk-BV6W4AJK.js";
+export {
+  EdgeConflictError,
+  SQLiteBridgeStore,
+  SQLiteEdgeStore,
+  SyncingBridgeStore,
+  edgeMessageFingerprint,
+  edgeScopeKey,
+  isRetryableSyncError,
+  stableIdempotency
+};
+//# sourceMappingURL=sqlite.js.map

package/dist/sqlite.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/llms.txt

@@ -0,0 +1,39 @@
+# Agent Bridge
+
+Repository: https://github.com/creatornader/agent-bridge
+Package: @creatornader/agent-bridge
+
+Agent Bridge carries durable context and executable work between AI agents in different clients, processes, sessions, and machines.
+
+## Modes
+
+- local: SQLite WAL, no account or daemon
+- gateway: authenticated HTTPS, PostgreSQL authority, SQLite edge outbox and cache
+- legacy-supabase: compatibility with the v1 shared_context schema
+
+## Commands
+
+- agent-bridge init --provider local
+- agent-bridge demo
+- agent-bridge doctor
+- agent-bridge pending
+- agent-bridge send, inbox, history, acknowledge
+- agent-bridge claim, extend, ack, nack
+- agent-bridge sync, watch, join, presence
+- agent-bridge clients install <runtime> --identity <principal>
+
+## MCP tools
+
+Compatibility: post_context, get_context, ack_context.
+Reliable messaging: send, history, claim, extend, acknowledge, negative_acknowledge, heartbeat, presence.
+
+## Identity rule
+
+The active runtime supplies AGENT_BRIDGE_AGENT and AGENT_BRIDGE_INSTANCE. Do not hardcode another client name and do not store agent identity in the shared backend config. Gateway installations use a separate principal-bound token and owner-only backend file for each client.
+
+## References
+
+- README.md: setup, commands, security, and provider behavior
+- docs/architecture-v2.md: protocol, storage, identity, delivery, and acceptance decisions
+- clients/*.json: runtime adapter manifests
+- SKILL.md: concise agent operating instructions

package/package.json

@@ -0,0 +1,104 @@
+{
+  "name": "@creatornader/agent-bridge",
+  "version": "0.2.0",
+  "description": "Shared context MCP server for heterogeneous AI agent coordination",
+  "type": "module",
+  "license": "Apache-2.0",
+  "author": "Nader Helmy",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/creatornader/agent-bridge.git"
+  },
+  "homepage": "https://github.com/creatornader/agent-bridge#readme",
+  "bugs": {
+    "url": "https://github.com/creatornader/agent-bridge/issues"
+  },
+  "engines": {
+    "node": ">=22.23.1"
+  },
+  "main": "dist/bridge.js",
+  "bin": {
+    "agent-bridge": "bin/agent-bridge",
+    "agent-bridge-mcp": "dist/index.js",
+    "agent-bridge-gateway": "dist/gateway-main.js"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "clients",
+    "sql/migrations",
+    "sql/setup.sql",
+    "llms.txt",
+    "SKILL.md",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/bridge.d.ts",
+      "import": "./dist/bridge.js"
+    },
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "import": "./dist/server.js"
+    },
+    "./bridge": {
+      "types": "./dist/bridge.d.ts",
+      "import": "./dist/bridge.js"
+    },
+    "./gateway": {
+      "types": "./dist/gateway.d.ts",
+      "import": "./dist/gateway.js"
+    },
+    "./sqlite": {
+      "types": "./dist/sqlite.d.ts",
+      "import": "./dist/sqlite.js"
+    },
+    "./client": {
+      "types": "./dist/client-runtime.d.ts",
+      "import": "./dist/client-runtime.js"
+    },
+    "./config": {
+      "types": "./dist/client-config.d.ts",
+      "import": "./dist/client-config.js"
+    }
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "start": "node dist/index.js",
+    "start:gateway": "node dist/gateway-main.js",
+    "migrate": "node dist/gateway-main.js --migrate-only",
+    "prepack": "npm run build",
+    "pretest": "npm run build",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "check": "npm run typecheck && npm test"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    "pg": "^8.22.0"
+  },
+  "devDependencies": {
+    "@types/node": "^26.1.0",
+    "@types/pg": "^8.20.0",
+    "tsup": "^8.4.0",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.9"
+  },
+  "overrides": {
+    "esbuild": "0.28.1"
+  },
+  "directories": {
+    "doc": "docs",
+    "test": "test"
+  },
+  "keywords": [
+    "agents",
+    "mcp",
+    "messaging",
+    "coordination"
+  ],
+  "types": "./dist/bridge.d.ts"
+}

package/sql/migrations/001_schema_state.sql

@@ -0,0 +1,34 @@
+begin;
+
+select pg_advisory_xact_lock(1646705660);
+
+create schema if not exists agent_bridge;
+revoke all on schema agent_bridge from public;
+
+create table if not exists agent_bridge.schema_migrations (
+  version integer primary key,
+  name text not null unique,
+  checksum char(64) not null,
+  applied_at timestamptz not null default now(),
+  constraint schema_migrations_checksum check (checksum ~ '^[0-9a-f]{64}$')
+);
+
+insert into agent_bridge.schema_migrations (version, name, checksum)
+values (1, 'schema_state', '__AGENT_BRIDGE_MIGRATION_CHECKSUM__')
+on conflict (version) do update set applied_at=agent_bridge.schema_migrations.applied_at
+where agent_bridge.schema_migrations.name=excluded.name
+  and agent_bridge.schema_migrations.checksum=excluded.checksum;
+
+do $migration$
+begin
+  if not exists (
+    select 1 from agent_bridge.schema_migrations
+    where version=1 and name='schema_state'
+      and checksum='__AGENT_BRIDGE_MIGRATION_CHECKSUM__'
+  ) then
+    raise exception 'migration 1_schema_state conflicts with recorded schema state';
+  end if;
+end
+$migration$;
+
+commit;

package/sql/migrations/002_workspaces_agents_credentials.sql

@@ -0,0 +1,77 @@
+begin;
+
+select pg_advisory_xact_lock(1646705660);
+
+create table if not exists agent_bridge.workspaces (
+  id text primary key,
+  name text not null,
+  disabled_at timestamptz,
+  created_at timestamptz not null default now()
+);
+
+create table if not exists agent_bridge.agents (
+  id uuid primary key default gen_random_uuid(),
+  workspace_id text not null references agent_bridge.workspaces(id),
+  principal text not null,
+  display_name text,
+  runtime_type text,
+  disabled_at timestamptz,
+  created_at timestamptz not null default now(),
+  unique (workspace_id, principal),
+  unique (workspace_id, id)
+);
+
+create table if not exists agent_bridge.credentials (
+  id uuid primary key default gen_random_uuid(),
+  workspace_id text not null,
+  agent_id uuid not null,
+  token_hash char(64) not null unique,
+  label text,
+  expires_at timestamptz,
+  revoked_at timestamptz,
+  created_at timestamptz not null default now(),
+  last_used_at timestamptz,
+  foreign key (workspace_id, agent_id)
+    references agent_bridge.agents(workspace_id, id),
+  constraint credentials_hash check (token_hash ~ '^[0-9a-f]{64}$')
+);
+
+create index if not exists credentials_active_hash
+  on agent_bridge.credentials(token_hash)
+  where revoked_at is null;
+
+revoke all on all tables in schema agent_bridge from public;
+revoke all on all sequences in schema agent_bridge from public;
+
+do $roles$
+declare role_name text;
+begin
+  foreach role_name in array array['anon', 'authenticated'] loop
+    if exists (select 1 from pg_roles where rolname=role_name) then
+      execute format('revoke all on schema agent_bridge from %I', role_name);
+      execute format('revoke all on all tables in schema agent_bridge from %I', role_name);
+      execute format('revoke all on all sequences in schema agent_bridge from %I', role_name);
+    end if;
+  end loop;
+end
+$roles$;
+
+insert into agent_bridge.schema_migrations (version, name, checksum)
+values (2, 'workspaces_agents_credentials', '__AGENT_BRIDGE_MIGRATION_CHECKSUM__')
+on conflict (version) do update set applied_at=agent_bridge.schema_migrations.applied_at
+where agent_bridge.schema_migrations.name=excluded.name
+  and agent_bridge.schema_migrations.checksum=excluded.checksum;
+
+do $migration$
+begin
+  if not exists (
+    select 1 from agent_bridge.schema_migrations
+    where version=2 and name='workspaces_agents_credentials'
+      and checksum='__AGENT_BRIDGE_MIGRATION_CHECKSUM__'
+  ) then
+    raise exception 'migration 2_workspaces_agents_credentials conflicts with recorded schema state';
+  end if;
+end
+$migration$;
+
+commit;

package/sql/migrations/003_messages_receipts_deliveries.sql

@@ -0,0 +1,116 @@
+begin;
+
+select pg_advisory_xact_lock(1646705660);
+
+create table if not exists agent_bridge.messages (
+  sequence bigint generated always as identity primary key,
+  id uuid not null unique,
+  workspace text not null references agent_bridge.workspaces(id),
+  source text not null,
+  type text not null,
+  content text not null,
+  content_type text not null default 'text/plain',
+  data jsonb,
+  targets jsonb not null default '[]'::jsonb,
+  thread_id text,
+  reply_to_id text,
+  correlation_id text,
+  causation_id text,
+  priority text not null default 'info',
+  expires_at timestamptz,
+  idempotency_key text,
+  atrib_receipt_id text,
+  informed_by jsonb,
+  metadata jsonb,
+  created_at timestamptz not null default now(),
+  unique (workspace, id),
+  check (jsonb_typeof(targets)='array'),
+  check (priority in ('info','high','urgent'))
+);
+create unique index if not exists messages_idempotency
+  on agent_bridge.messages(workspace, source, idempotency_key)
+  where idempotency_key is not null;
+create index if not exists messages_cursor on agent_bridge.messages(workspace, sequence);
+create index if not exists messages_expiry on agent_bridge.messages(workspace, expires_at)
+  where expires_at is not null;
+
+create table if not exists agent_bridge.receipts (
+  workspace text not null,
+  message_id uuid not null,
+  principal text not null,
+  read_at timestamptz not null default now(),
+  primary key (workspace, message_id, principal),
+  foreign key (workspace, message_id)
+    references agent_bridge.messages(workspace, id) on delete cascade
+);
+
+create table if not exists agent_bridge.deliveries (
+  id uuid primary key,
+  message_id uuid not null,
+  workspace text not null,
+  recipient text not null,
+  state text not null,
+  attempt integer not null default 0,
+  available_at timestamptz not null default now(),
+  lease_token uuid,
+  lease_owner text,
+  lease_expires_at timestamptz,
+  last_error text,
+  unique (message_id, recipient),
+  foreign key (workspace, message_id)
+    references agent_bridge.messages(workspace, id) on delete cascade,
+  check (state in ('pending','claimed','acked','retrying','dead')),
+  check (attempt >= 0),
+  check ((state='claimed' and lease_token is not null and lease_expires_at is not null)
+    or (state<>'claimed' and lease_token is null and lease_owner is null and lease_expires_at is null))
+);
+create index if not exists deliveries_claim
+  on agent_bridge.deliveries(workspace, recipient, state, available_at);
+
+create or replace function agent_bridge.reject_message_mutation() returns trigger
+language plpgsql set search_path = '' as $$
+begin
+  raise exception 'bridge messages are immutable';
+end
+$$;
+drop trigger if exists messages_immutable on agent_bridge.messages;
+create trigger messages_immutable before update or delete on agent_bridge.messages
+for each row execute function agent_bridge.reject_message_mutation();
+
+revoke all on all tables in schema agent_bridge from public;
+revoke all on all sequences in schema agent_bridge from public;
+revoke all on all functions in schema agent_bridge from public;
+
+do $roles$
+declare role_name text;
+begin
+  foreach role_name in array array['anon', 'authenticated'] loop
+    if exists (select 1 from pg_roles where rolname=role_name) then
+      execute format('revoke all on schema agent_bridge from %I', role_name);
+      execute format('revoke all on all tables in schema agent_bridge from %I', role_name);
+      execute format('revoke all on all sequences in schema agent_bridge from %I', role_name);
+      execute format('revoke all on all functions in schema agent_bridge from %I', role_name);
+    end if;
+  end loop;
+end
+$roles$;
+
+insert into agent_bridge.schema_migrations (version, name, checksum)
+values (3, 'messages_receipts_deliveries', '__AGENT_BRIDGE_MIGRATION_CHECKSUM__')
+on conflict (version) do update set applied_at=agent_bridge.schema_migrations.applied_at
+where agent_bridge.schema_migrations.name=excluded.name
+  and agent_bridge.schema_migrations.checksum=excluded.checksum;
+
+do $migration$
+begin
+  if not exists (
+    select 1 from agent_bridge.schema_migrations
+    where version=3 and name='messages_receipts_deliveries'
+      and checksum='__AGENT_BRIDGE_MIGRATION_CHECKSUM__'
+  ) then
+    raise exception 'migration 3_messages_receipts_deliveries conflicts with recorded schema state';
+  end if;
+end
+$migration$;
+
+commit;

package/sql/migrations/004_message_query_indexes.sql

@@ -0,0 +1,31 @@
+begin;
+
+select pg_advisory_xact_lock(1646705660);
+
+create index if not exists messages_source
+  on agent_bridge.messages(workspace, source, sequence);
+create index if not exists messages_thread
+  on agent_bridge.messages(workspace, thread_id, sequence)
+  where thread_id is not null;
+create index if not exists messages_created
+  on agent_bridge.messages(workspace, created_at, sequence);
+
+insert into agent_bridge.schema_migrations (version, name, checksum)
+values (4, 'message_query_indexes', '__AGENT_BRIDGE_MIGRATION_CHECKSUM__')
+on conflict (version) do update set applied_at=agent_bridge.schema_migrations.applied_at
+where agent_bridge.schema_migrations.name=excluded.name
+  and agent_bridge.schema_migrations.checksum=excluded.checksum;
+
+do $migration$
+begin
+  if not exists (
+    select 1 from agent_bridge.schema_migrations
+    where version=4 and name='message_query_indexes'
+      and checksum='__AGENT_BRIDGE_MIGRATION_CHECKSUM__'
+  ) then
+    raise exception 'migration 4_message_query_indexes conflicts with recorded schema state';
+  end if;
+end
+$migration$;
+
+commit;

package/sql/migrations/005_delivery_events_presence.sql

@@ -0,0 +1,79 @@
+begin;
+
+select pg_advisory_xact_lock(1646705660);
+
+create table if not exists agent_bridge.delivery_events (
+  sequence bigint generated always as identity primary key,
+  delivery_id uuid not null,
+  message_id uuid not null,
+  workspace text not null,
+  recipient text not null,
+  from_state text,
+  to_state text not null,
+  attempt integer not null,
+  lease_owner text,
+  error text,
+  created_at timestamptz not null default now()
+);
+create index if not exists delivery_events_lookup
+  on agent_bridge.delivery_events(workspace, delivery_id, sequence);
+
+create or replace function agent_bridge.record_delivery_event() returns trigger
+language plpgsql set search_path = '' as $$
+begin
+  if tg_op = 'INSERT' or old.state is distinct from new.state or old.attempt is distinct from new.attempt then
+    insert into agent_bridge.delivery_events (
+      delivery_id, message_id, workspace, recipient, from_state, to_state,
+      attempt, lease_owner, error
+    ) values (
+      new.id, new.message_id, new.workspace, new.recipient,
+      case when tg_op = 'INSERT' then null else old.state end,
+      new.state, new.attempt, new.lease_owner, new.last_error
+    );
+  end if;
+  return new;
+end
+$$;
+drop trigger if exists deliveries_record_event on agent_bridge.deliveries;
+create trigger deliveries_record_event
+after insert or update on agent_bridge.deliveries
+for each row execute function agent_bridge.record_delivery_event();
+
+create table if not exists agent_bridge.agent_instances (
+  workspace text not null,
+  agent text not null,
+  instance text not null,
+  runtime_type text,
+  capabilities jsonb not null default '[]'::jsonb,
+  lease_expires_at timestamptz not null,
+  last_seen_at timestamptz not null default now(),
+  primary key (workspace, agent, instance),
+  foreign key (workspace) references agent_bridge.workspaces(id) on delete cascade,
+  check (jsonb_typeof(capabilities)='array')
+);
+create index if not exists agent_instances_active
+  on agent_bridge.agent_instances(workspace, lease_expires_at);
+
+revoke all on all tables in schema agent_bridge from public;
+revoke all on all sequences in schema agent_bridge from public;
+revoke all on all functions in schema agent_bridge from public;
+
+insert into agent_bridge.schema_migrations (version, name, checksum)
+values (5, 'delivery_events_presence', '__AGENT_BRIDGE_MIGRATION_CHECKSUM__')
+on conflict (version) do update set applied_at=agent_bridge.schema_migrations.applied_at
+where agent_bridge.schema_migrations.name=excluded.name
+  and agent_bridge.schema_migrations.checksum=excluded.checksum;
+
+do $migration$
+begin
+  if not exists (
+    select 1 from agent_bridge.schema_migrations
+    where version=5 and name='delivery_events_presence'
+      and checksum='__AGENT_BRIDGE_MIGRATION_CHECKSUM__'
+  ) then
+    raise exception 'migration 5_delivery_events_presence conflicts with recorded schema state';
+  end if;
+end
+$migration$;
+
+commit;