@creatornader/agent-bridge 0.2.0 → 0.3.0

package/ROADMAP.md

@@ -0,0 +1,104 @@
+# Agent Bridge roadmap
+
+Agent Bridge is working toward one specific role: durable messaging and work delivery
+between agent runtimes that do not share a process, vendor, session, or machine.
+
+This roadmap separates released behavior from code that has not reached a public
+release. A merged implementation is not considered shipped until the package is
+published and the supported clients pass a fresh end-to-end check.
+
+## Status
+
+### Released in 0.2.0
+
+- Local SQLite and shared PostgreSQL storage behind provider-neutral interfaces.
+- An authenticated HTTPS gateway and a named legacy Supabase adapter.
+- Immutable messages, caller receipts, delivery leases, retries, dead letters, and
+  presence.
+- Durable SQLite edge outbox and inbox cache for gateway clients.
+- CLI, MCP, Codex, Claude Code, and Claude Desktop integration paths.
+
+### Implemented for the next release
+
+- Caller-bound inbox, sent, and combined history with scope-bound cursors.
+- Publisher-owned delivery policy, priority claims, cancel, requeue, and delivery event
+  inspection.
+- Canonical TypeBox operation definitions that generate JSON Schema, OpenAPI, MCP, and
+  capability artifacts.
+- Credential scopes, rate policy, transaction-bound PostgreSQL request authority, and
+  forced row isolation.
+- Offline owner commands for credential provisioning, inventory, rotation, and
+  revocation.
+- Claude Desktop registration with absolute launcher paths that do not depend on the
+  application's inherited shell `PATH`.
+- Portable workspace archives across canonical SQLite and PostgreSQL stores.
+- Native SQLite and PostgreSQL backup, verification, and restore.
+
+### Required before the next release is complete
+
+- Merge the development branch through the protected-main checks.
+- Publish the package through the configured npm OIDC workflow.
+- Prove Codex, Claude Code, and Claude Desktop startup, send, receive, receipt, claim,
+  settlement, offline replay, and restart behavior against the released package.
+- Move the project's own normal traffic to v2 while retaining a tested v1 rollback path.
+- Replace remaining direct legacy table pollers with the v2 cursor protocol.
+- Confirm the README, npm metadata, GitHub metadata, release notes, and package contents
+  match the released artifact.
+
+## Near-term work
+
+### Installation and operations
+
+- Add client repair, update, uninstall, and registration diagnostics.
+- Provide a Compose-based development deployment and a production deployment guide.
+- Add endpoint migration tooling that does not strand an existing SQLite outbox.
+- Publish a maintained client compatibility matrix.
+
+### Storage lifecycle and observability
+
+- Define retention separately from logical message immutability.
+- Add audited archive and purge operations for expired data.
+- Bound edge caches and resolve abandoned outbox state.
+- Add workspace quotas, principal limits, queue-depth diagnostics, and capacity alerts.
+- Maintain credential use and administrative audit records without logging secrets.
+
+### Presence and wakeups
+
+- Maintain heartbeat and expiry automatically for supported long-lived clients.
+- Add wake adapters only where they reduce latency. Lost wakeups must never lose data.
+- Keep cursored pull as the authoritative recovery path.
+
+### Failure and performance evidence
+
+- Measure install-to-first-message time and local and gateway latency.
+- Test concurrent claims, SQLite lock contention, queue growth, duplicate suppression,
+  lease expiry, and crash recovery.
+- Exercise gateway restarts, database outages, network partitions, clock skew, cache
+  corruption, and interrupted migrations.
+- Publish the test setup and results instead of making unsupported throughput claims.
+
+## Ecosystem work
+
+- Build an agmsg adapter for send, inbox, history, claim, and settlement operations.
+- Carry A2A envelopes without implementing a competing task state machine.
+- Publish conformance fixtures and an adapter template.
+- Add client libraries where real integrations need them.
+- Expand runtime installers after each host has a stable configuration contract.
+
+See [docs/ecosystem.md](docs/ecosystem.md) for the product boundary.
+
+## Project and community work
+
+- Add contribution and support policies, issue templates, and a reviewable governance
+  path.
+- Publish a local two-agent demo and a cross-machine recovery demo.
+- Track completed cross-runtime deliveries and successful second-principal activation.
+  Any product telemetry must be opt-in.
+- Review compatibility on every release and revisit interoperability choices each
+  quarter.
+
+## Deferred
+
+JetStream or another required broker, a large dashboard, Kubernetes packaging, and
+end-to-end payload encryption remain deferred until measurements or users justify the
+extra operational and security work.

package/SECURITY.md

@@ -0,0 +1,73 @@
+# Security policy
+
+## Supported versions
+
+| Version | Security updates |
+| --- | --- |
+| 0.2.x | Supported until its successor is released |
+| 0.1.x | Not supported |
+| Unreleased development code | No public support guarantee |
+
+Upgrade to the latest published package before reporting a defect that may already be
+fixed. The npm package and GitHub release page are the public version authorities.
+
+## Report a vulnerability
+
+Use [GitHub private vulnerability reporting](https://github.com/creatornader/agent-bridge/security/advisories/new).
+Do not open a public issue for a suspected vulnerability.
+
+Include the affected version, provider mode, operating system, reproduction steps, and
+the security boundary that failed. Remove bearer tokens, raw credential files, database
+URLs, message content, archive data, and disaster-recovery bundles. The maintainer will
+coordinate disclosure and remediation through the private advisory.
+
+## Security boundaries
+
+### Local mode
+
+Local mode relies on operating-system account isolation and private file permissions.
+Anyone who can act as the same operating-system user can generally read or replace that
+user's Agent Bridge state. Local mode is not a hostile multi-user boundary.
+
+### Gateway mode
+
+Gateway credentials bind one workspace and principal. The gateway derives remote
+identity from the credential, applies operation scopes and rate policy, and uses
+transaction-bound PostgreSQL request authority. Production runtime roles must not be
+superusers or hold `BYPASSRLS`. Put every non-loopback gateway behind TLS.
+
+Keep the schema-owner, runtime, operator, archive, backup, and restore database
+authorities separate. Do not copy one client's token or backend file into another
+client's configuration.
+
+### Legacy Supabase mode
+
+The legacy adapter keeps existing v1 deployments working, but its publishable key can
+call the underlying PostgREST table and receipt RPC directly. Adapter checks therefore
+provide cooperative behavior, not the same workspace and principal isolation as the
+authenticated gateway. Do not use legacy mode as a hostile multi-tenant boundary.
+
+### Archives and disaster recovery
+
+Portable archives and native DR bundles may contain message content, routing metadata,
+credentials, or database state. Their hashes detect changed bytes. They do not encrypt
+the files or authenticate their source. Store them as private data and transfer them
+through a separately trusted channel.
+
+PostgreSQL restore executes SQL from the source dump. Use
+`--accept-source-sql-risk` only for a bundle from a trusted source. Never activate the
+source and restored target as authorities at the same time.
+
+### Optional integrations
+
+Agent Bridge does not require atrib or another provenance system. A signed wrapper is a
+separate security and availability boundary. Keep a direct Agent Bridge path available
+when wrapper health is uncertain.
+
+## Secret handling
+
+- Pass gateway tokens through private enrollment or backend files, not shell arguments.
+- Keep database URLs in the documented environment variables. Do not put them in CLI
+  arguments, logs, issues, or examples.
+- Treat client backend files, enrollment files, archives, and DR bundles as secrets.
+- Sanitize `doctor` output and logs before sharing them publicly.

package/SKILL.md

@@ -5,10 +5,23 @@ description: Share context and reliable work between agents across runtimes and
 
 # Agent Bridge
 
+Discover the active v2 operation contract with MCP `capabilities`, CLI `agent-bridge capabilities`, or authenticated `GET /v2/capabilities`. Released 2.0 clients continue to work after the gateway is upgraded. A new 2.1 client must receive complete, consistent negotiation headers that select and advertise 2.1 before it mutates remote state. If the probe is headerless, selects 2.0, or returns partial or contradictory headers, do not mutate. Upgrade the gateway first instead of downgrading the client.
+
 Use the Agent Bridge MCP tools for normal traffic. Let the active runtime supply its own identity. Do not pass a literal source unless a standalone CLI process has no configured identity.
 
+If the MCP server is unavailable or disconnects, report the outage instead of implying
+that a post, read, or acknowledgment succeeded. Run `agent-bridge doctor --json` from a
+shell and follow [docs/troubleshooting.md](docs/troubleshooting.md). Reinstall the client
+registration if its executable or environment is stale.
+
+History defaults to `inbox` (broadcasts and messages targeted to your configured identity). Use `sent` for messages you published or `mailbox: all` for the union. Receipt state is caller-relative; use `unread` or `read` only with inbox. Deprecated `unacked_by` and `--unacked-by` values must equal your configured identity.
+
 At session start, call `get_context` with a small limit. Summarize relevant unacknowledged entries, then call `ack_context` with the IDs you handled.
 
+In gateway mode, long-lived MCP clients sync automatically. Call the MCP `sync` tool to trigger bounded outbox replay and inbox cache refresh manually.
+
+Use `agent-bridge status` for a passive operational snapshot. Do not use it as a connectivity probe. Unprobed remote reachability is unknown, not healthy. Use `agent-bridge doctor` for active checks. Doctor exits 0 when ok, 2 when degraded, and 1 when checks fail. Treat blocked outbox rows as intervention-required even if a later send or pull succeeded. Distinguish due, scheduled, and leased work.
+
 Post context as events happen when another agent would need the information later:
 
 - `goal-update`: material progress, decisions, or completed research
@@ -17,8 +30,61 @@ Post context as events happen when another agent would need the information late
 - `operational`: runtime and repository handoffs
 - `bridge-meta`: limitations or proposed improvements to Agent Bridge
 
-Use v2 delivery tools for executable work. A read receipt does not claim work. Claim a delivery before acting, renew long leases, acknowledge success, and negatively acknowledge retryable or dead work with a bounded error.
+Use v2 delivery tools for executable work. MCP `ack_context` and CLI `acknowledge` write read receipts. MCP `acknowledge` and CLI `ack` settle claimed deliveries. A read receipt does not claim or settle work, and delivery settlement does not create a receipt.
+
+Publish executable work with `deliveryPolicy`; consumers never select retry limits or backoff. Leased policy accepts `maxAttempts`, `retryBaseDelayMs`, `retryMaxDelayMs`, `retryJitterRatio`, and optional `notBefore`. Untargeted messages default to mailbox mode and targeted messages to leased mode. Only publishers cancel or requeue. Publishers and recipients can inspect delivery history. Requeue starts a new cycle without resetting lifetime attempts. Consumer `maxAttempts` on claim and `retryPolicy` on nack are validated but ignored for one compatibility release. External task completion stays outside Agent Bridge.
 
-Use `agent-bridge pending` as a cheap process gate before starting an agent. Exit 0 means unread context or due delivery work exists. Exit 1 means neither exists. Treat network errors as unknown state, not as an empty queue.
+Claim a delivery before acting. Renew a long lease only to retain ownership. A lease extension does not report progress or success. Record external task completion through the application or A2A protocol, then settle the Agent Bridge delivery separately.
+
+Use `agent-bridge pending` as a cheap process gate before starting an agent. Exit 0 means unread candidates or due delivery work are visible. Exit 1 means the authoritative state is empty. Exit 2 means the remote state is unknown. During a gateway outage, cached unacknowledged results are degraded candidates with unknown acknowledgement state.
 
 Keep side effects idempotent. Agent Bridge provides at-least-once delivery and idempotent message insertion, not exactly-once execution.
+
+Owner administration is an offline operator task. Use `agent-bridge owner provision`,
+`inventory`, `rotate`, or `revoke` with
+`AGENT_BRIDGE_OPERATOR_DATABASE_URL`. Do not route these commands through MCP or
+HTTP. Provision and rotation produce a private enrollment file. Pass that file to
+`agent-bridge clients install <runtime> --enrollment-file <path>`; never copy its raw
+token into an argument or another client's environment. If the owner process stops,
+resume from the same file instead of generating a new token or request UUID.
+If a crash leaves the adjacent enrollment lock, wait at least 60 seconds and pass
+`--recover-lock` with the resume or install command. Recovery must prove that the
+same-host process recorded in the lock has stopped. Never remove the lock manually.
+
+Portable archive work is an offline operator task, not normal MCP traffic. Use
+`agent-bridge archive export --provider local|postgres --workspace <workspace>
+--output <file>` to create an archive, then run `agent-bridge archive verify --file
+<file>` before moving or importing it. Archive files and their directories must satisfy
+the current user's private-path policy. Import replays three bounded passes through one
+open descriptor. It is a dry run unless `--apply` is explicit; `--dry-run` and
+`--apply` cannot be combined. Provide `--workspace` on import when the destination must
+match an expected tenant. PostgreSQL archive commands accept only
+`AGENT_BRIDGE_ARCHIVE_DATABASE_URL`.
+Portable v1 requires current-domain records, lowercase UUIDs, and six-digit UTC
+timestamps. It does not repair legacy or direct database rows. Use native database
+recovery for rows that fail export validation.
+Set and retain `--request-id` for export. The archive header records it as
+`exportRequestId`; verification and import return that provenance. An import
+`--request-id` identifies the destination operation and is independent. Retry an
+export ID only with the same private output file. The CLI verifies completed exports
+and reconciles matching started exports without streaming a new snapshot. Temporary
+and backup files have deterministic adjacent names derived from the export ID. Follow
+returned recovery paths and audit status exactly when replacement, cleanup, or audit
+completion is uncertain.
+Do not treat the archive digest as encryption or authentication. Archives contain
+messages and read receipts but exclude deliveries, events, presence, credentials,
+control records, and security state.
+
+Native DR is also an offline operator task. Use `agent-bridge dr backup|verify|restore`
+for one complete SQLite or PostgreSQL authority. Local DR accepts the SQLite authority,
+not the gateway edge store. PostgreSQL backup and restore authority come only from
+`AGENT_BRIDGE_DR_SOURCE_DATABASE_URL` and
+`AGENT_BRIDGE_DR_TARGET_DATABASE_URL`. PostgreSQL restore needs a fresh same-name,
+same-major database, a superuser, an explicit request ID, and
+`--accept-source-sql-risk`. Never activate the source and restored target together.
+Treat the bundle as private database material; its hashes do not encrypt or authenticate
+the source.
+
+Use `project` only as an optional message label. Workspace remains the tenant and credential boundary. Omit a project filter to read labeled and unlabeled messages, or provide one for an exact match. Reusing a workspace/source idempotency key with a different project is a conflict.
+
+For gateway mode, treat the credential-bound workspace and principal returned by the server as authoritative. Instance identifies one runtime of that same principal; it cannot select a workspace, agent, or scopes. A production gateway reports row isolation only when transaction-bound request authority and every database readiness check pass. RLS isolates workspace and principal rows. The service still enforces lease transitions and target-to-delivery membership.

package/bin/agent-bridge

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
-import { runCli } from "../dist/cli.js";
+import { formatCliError, runCli } from "../dist/cli.js";
 
 runCli().catch((error) => {
-  process.stderr.write(`Error: ${error instanceof Error ? error.message : String(error)}\n`);
+  process.stderr.write(formatCliError(error));
   process.exitCode = 1;
 });

package/clients/claude-desktop.json

@@ -2,7 +2,8 @@
   "schema": "agent-bridge.runtime-manifest.v1",
   "runtime": "claude-desktop",
   "transport": "stdio",
-  "command": "agent-bridge-mcp",
+  "command": "{{absoluteNodeExecutable}}",
+  "args": ["{{absoluteServerEntry}}"],
   "identity": { "source": "env", "variable": "AGENT_BRIDGE_AGENT", "required": true },
   "instance": { "source": "env", "variable": "AGENT_BRIDGE_INSTANCE", "required": true },
   "backendConfig": { "source": "env", "variable": "AGENT_BRIDGE_CONFIG", "perClient": true },
@@ -13,6 +14,7 @@
     "identityValue": "operator-selected",
     "instanceValue": "installer-generated",
     "backendConfigValue": "installer-generated",
+    "launchValue": "installer-resolved-absolute",
     "restartRequired": true
   },
   "wakeModes": ["poll"],

package/dist/archive.d.ts

@@ -0,0 +1,163 @@
+import { J as JsonValue, i as MessagePriority, f as DeliveryPolicy } from './bridge-domain-CBX3IVqC.js';
+import { P as PgQueryable } from './postgres-bridge-store-Bfd3hRId.js';
+import './bridge-store-DPVSCwfs.js';
+
+interface PortableArchiveMessage {
+    id: string;
+    project: string | null;
+    source: string;
+    type: string;
+    content: string;
+    contentType: string;
+    data: JsonValue | null;
+    targets: string[];
+    threadId: string | null;
+    replyToId: string | null;
+    correlationId: string | null;
+    causationId: string | null;
+    priority: MessagePriority;
+    expiresAt: string | null;
+    idempotencyKey: string | null;
+    atribReceiptId: string | null;
+    informedBy: string[];
+    metadata: JsonValue | null;
+    deliveryPolicy: DeliveryPolicy;
+    createdAt: string;
+}
+interface PortableArchiveReceipt {
+    messageId: string;
+    principal: string;
+    readAt: string;
+}
+/** In-memory helper used by format tests and small programmatic archives. Stores do not use it. */
+interface PortableArchiveContents {
+    exportRequestId: string;
+    workspace: string;
+    messages: PortableArchiveMessage[];
+    receipts: PortableArchiveReceipt[];
+    digest?: string;
+}
+interface PortableArchiveMetadata {
+    exportRequestId: string;
+    workspace: string;
+    digest: string;
+    messageCount: number;
+    receiptCount: number;
+}
+type PortableArchiveAbandonCode = "stream_failed" | "snapshot_failed" | "publication_failed" | "audit_failed" | "not_published";
+interface PortableArchiveExportSession {
+    messages(): AsyncIterable<PortableArchiveMessage>;
+    receipts(): AsyncIterable<PortableArchiveReceipt>;
+    complete(result: PortableArchiveMetadata & {
+        publishedAt: string;
+    }): Promise<void>;
+    reconcile(result: PortableArchiveMetadata & {
+        publishedAt: string;
+    }): Promise<void>;
+    abandon(reason: PortableArchiveAbandonCode): Promise<void>;
+    close(): Promise<void> | void;
+}
+type PortableArchiveExportStart = {
+    status: "active";
+    session: PortableArchiveExportSession;
+    replayed: boolean;
+} | {
+    status: "completed";
+    metadata: PortableArchiveMetadata & {
+        publishedAt: string;
+    };
+};
+interface PortableArchiveImportPasses {
+    messageBatches(): AsyncIterable<readonly PortableArchiveMessage[]>;
+    receiptBatches(): AsyncIterable<readonly PortableArchiveReceipt[]>;
+}
+interface PortableArchiveResult {
+    requestId: string;
+    workspace: string;
+    digest: string;
+    apply: boolean;
+    messages: {
+        created: number;
+        replayed: number;
+    };
+    receipts: {
+        created: number;
+        replayed: number;
+    };
+}
+interface PortableArchiveStore {
+    beginExport(requestId: string, workspace: string): Promise<PortableArchiveExportStart>;
+    importWorkspace(requestId: string, metadata: PortableArchiveMetadata, passes: PortableArchiveImportPasses, options: {
+        apply: boolean;
+    }): Promise<PortableArchiveResult>;
+    close?(): Promise<void> | void;
+}
+
+declare const PORTABLE_ARCHIVE_FORMAT = "agent-bridge.portable-archive";
+declare const PORTABLE_ARCHIVE_VERSION = 1;
+declare const PORTABLE_ARCHIVE_MAX_LINE_BYTES: number;
+declare const PORTABLE_ARCHIVE_MAX_BYTES: number;
+declare const PORTABLE_ARCHIVE_BATCH_BYTES: number;
+declare const PORTABLE_ARCHIVE_BATCH_ROWS = 1000;
+declare class PortableArchiveError extends Error {
+    readonly code = "invalid_portable_archive";
+    constructor(message: string);
+}
+declare function canonicalJson(value: unknown): string;
+declare function normalizeArchiveTimestamp(value: unknown, field: string): string;
+declare function validateArchiveWorkspace(value: unknown): string;
+declare function validatePortableArchiveRequestId(value: unknown): string;
+declare function parsePortableArchiveMessage(value: unknown): PortableArchiveMessage;
+declare function parsePortableArchiveReceipt(value: unknown): PortableArchiveReceipt;
+declare function encodePortableArchive(contents: PortableArchiveContents): Buffer;
+declare function decodePortableArchive(input: Uint8Array): PortableArchiveContents & {
+    digest: string;
+};
+
+declare class PortableArchiveFile implements PortableArchiveImportPasses {
+    readonly path: string;
+    private readonly descriptor;
+    private readonly identity;
+    private closed;
+    private verified?;
+    constructor(path: string);
+    private assertIdentity;
+    private lines;
+    private validatedRecords;
+    verify(): PortableArchiveMetadata;
+    proveDurable(): void;
+    messageBatches(): AsyncIterable<readonly PortableArchiveMessage[]>;
+    receiptBatches(): AsyncIterable<readonly PortableArchiveReceipt[]>;
+    close(): void;
+}
+
+declare function streamPortableArchive(session: PortableArchiveExportSession, workspaceValue: string, exportRequestIdValue: string, write: (bytes: Buffer) => void | Promise<void>): Promise<PortableArchiveMetadata>;
+/** Small in-memory compatibility helper. It abandons the durable export audit. */
+declare function exportPortableArchive(store: PortableArchiveStore, workspace: string, exportRequestIdValue: string): Promise<Buffer>;
+/** Small in-memory compatibility helper. CLI imports use PortableArchiveFile instead. */
+declare function importPortableArchive(store: PortableArchiveStore, bytes: Uint8Array, options: {
+    requestId: string;
+    apply?: boolean;
+}): Promise<PortableArchiveResult>;
+
+declare class SQLitePortableArchiveStore implements PortableArchiveStore {
+    private readonly path;
+    private readonly db;
+    constructor(path: string);
+    beginExport(requestIdValue: string, workspaceValue: string): Promise<PortableArchiveExportStart>;
+    importWorkspace(requestId: string, archive: PortableArchiveMetadata, passes: PortableArchiveImportPasses, options: {
+        apply: boolean;
+    }): Promise<PortableArchiveResult>;
+    close(): void;
+}
+
+declare class PostgresPortableArchiveStore implements PortableArchiveStore {
+    private readonly db;
+    constructor(db: PgQueryable);
+    beginExport(requestId: string, workspace: string): Promise<PortableArchiveExportStart>;
+    importWorkspace(requestId: string, metadata: PortableArchiveMetadata, passes: PortableArchiveImportPasses, options: {
+        apply: boolean;
+    }): Promise<PortableArchiveResult>;
+}
+
+export { PORTABLE_ARCHIVE_BATCH_BYTES, PORTABLE_ARCHIVE_BATCH_ROWS, PORTABLE_ARCHIVE_FORMAT, PORTABLE_ARCHIVE_MAX_BYTES, PORTABLE_ARCHIVE_MAX_LINE_BYTES, PORTABLE_ARCHIVE_VERSION, type PortableArchiveAbandonCode, type PortableArchiveContents, PortableArchiveError, type PortableArchiveExportSession, type PortableArchiveExportStart, PortableArchiveFile, type PortableArchiveImportPasses, type PortableArchiveMessage, type PortableArchiveMetadata, type PortableArchiveReceipt, type PortableArchiveResult, type PortableArchiveStore, PostgresPortableArchiveStore, SQLitePortableArchiveStore, canonicalJson, decodePortableArchive, encodePortableArchive, exportPortableArchive, importPortableArchive, normalizeArchiveTimestamp, parsePortableArchiveMessage, parsePortableArchiveReceipt, streamPortableArchive, validateArchiveWorkspace, validatePortableArchiveRequestId };

package/dist/archive.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+import {
+  PORTABLE_ARCHIVE_BATCH_BYTES,
+  PORTABLE_ARCHIVE_BATCH_ROWS,
+  PORTABLE_ARCHIVE_FORMAT,
+  PORTABLE_ARCHIVE_MAX_BYTES,
+  PORTABLE_ARCHIVE_MAX_LINE_BYTES,
+  PORTABLE_ARCHIVE_VERSION,
+  PortableArchiveError,
+  PortableArchiveFile,
+  PostgresPortableArchiveStore,
+  SQLitePortableArchiveStore,
+  canonicalJson,
+  decodePortableArchive,
+  encodePortableArchive,
+  exportPortableArchive,
+  importPortableArchive,
+  normalizeArchiveTimestamp,
+  parsePortableArchiveMessage,
+  parsePortableArchiveReceipt,
+  streamPortableArchive,
+  validateArchiveWorkspace,
+  validatePortableArchiveRequestId
+} from "./chunk-A6W4QALF.js";
+import "./chunk-NCO7RLBM.js";
+import "./chunk-BZLMF5O5.js";
+export {
+  PORTABLE_ARCHIVE_BATCH_BYTES,
+  PORTABLE_ARCHIVE_BATCH_ROWS,
+  PORTABLE_ARCHIVE_FORMAT,
+  PORTABLE_ARCHIVE_MAX_BYTES,
+  PORTABLE_ARCHIVE_MAX_LINE_BYTES,
+  PORTABLE_ARCHIVE_VERSION,
+  PortableArchiveError,
+  PortableArchiveFile,
+  PostgresPortableArchiveStore,
+  SQLitePortableArchiveStore,
+  canonicalJson,
+  decodePortableArchive,
+  encodePortableArchive,
+  exportPortableArchive,
+  importPortableArchive,
+  normalizeArchiveTimestamp,
+  parsePortableArchiveMessage,
+  parsePortableArchiveReceipt,
+  streamPortableArchive,
+  validateArchiveWorkspace,
+  validatePortableArchiveRequestId
+};
+//# sourceMappingURL=archive.js.map

package/dist/archive.js.map

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

package/dist/bridge-domain-CBX3IVqC.d.ts

@@ -0,0 +1,153 @@
+type JsonValue = null | boolean | number | string | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+type DeliveryState = "pending" | "claimed" | "acked" | "retrying" | "dead" | "cancelled";
+type MessagePriority = "info" | "high" | "urgent";
+interface LeasedDeliveryPolicy {
+    mode: "leased";
+    maxAttempts: number;
+    retryBaseDelayMs: number;
+    retryMaxDelayMs: number;
+    retryJitterRatio: number;
+    notBefore?: string;
+}
+type DeliveryPolicy = {
+    mode: "mailbox";
+} | LeasedDeliveryPolicy;
+/** @deprecated Consumer retry policy is validated and ignored for one compatibility release. */
+interface RetryPolicy {
+    maxAttempts: number;
+    baseDelayMs: number;
+    maxDelayMs: number;
+    jitterRatio: number;
+}
+type DeliveryAction = "created" | "claim" | "ack" | "nack_retry" | "nack_dead" | "lease_expired" | "attempts_exhausted" | "message_expired" | "cancel" | "requeue";
+interface BridgePrincipal {
+    workspace: string;
+    agent: string;
+    instance?: string;
+}
+interface MessageDraft {
+    id?: string;
+    project?: string;
+    type: string;
+    content: string;
+    contentType?: string;
+    data?: JsonValue;
+    targets?: string[];
+    threadId?: string;
+    replyToId?: string;
+    correlationId?: string;
+    causationId?: string;
+    priority?: MessagePriority;
+    expiresAt?: string;
+    idempotencyKey?: string;
+    atribReceiptId?: string;
+    informedBy?: string[];
+    metadata?: JsonValue;
+    deliveryPolicy?: DeliveryPolicy | Record<string, unknown>;
+}
+interface BridgeMessage extends Required<Pick<MessageDraft, "id" | "type" | "content" | "contentType" | "targets" | "priority">> {
+    workspace: string;
+    project?: string;
+    source: string;
+    sequence: string;
+    createdAt: string;
+    data?: JsonValue;
+    threadId?: string;
+    replyToId?: string;
+    correlationId?: string;
+    causationId?: string;
+    expiresAt?: string;
+    idempotencyKey?: string;
+    atribReceiptId?: string;
+    informedBy?: string[];
+    metadata?: JsonValue;
+    deliveryPolicy: DeliveryPolicy;
+}
+interface BridgeDelivery {
+    id: string;
+    messageId: string;
+    workspace: string;
+    recipient: string;
+    state: DeliveryState;
+    attempt: number;
+    cycleAttempt: number;
+    requeueCount: number;
+    createdAt: string;
+    priorityRank: number;
+    availableAt: string;
+    leaseToken?: string;
+    leaseOwner?: string;
+    leaseExpiresAt?: string;
+    lastError?: string;
+    lastActor?: string;
+    lastAction: DeliveryAction;
+}
+interface BridgeDeliveryEvent {
+    sequence: string;
+    deliveryId: string;
+    messageId: string;
+    workspace: string;
+    recipient: string;
+    fromState?: DeliveryState;
+    toState: DeliveryState;
+    attempt: number;
+    cycleAttempt: number;
+    requeueCount: number;
+    leaseOwner?: string;
+    error?: string;
+    actor: string;
+    action: DeliveryAction;
+    createdAt: string;
+}
+interface AgentPresence {
+    workspace: string;
+    agent: string;
+    instance: string;
+    runtimeType?: string;
+    capabilities: string[];
+    leaseExpiresAt: string;
+    lastSeenAt: string;
+}
+declare class BridgeValidationError extends Error {
+    readonly code = "invalid_input";
+}
+declare class BridgePrincipalMismatchError extends Error {
+    readonly code = "principal_mismatch";
+    readonly status = 403;
+}
+declare class DeliveryStateConflictError extends Error {
+    readonly code = "delivery_state_conflict";
+    readonly status = 409;
+}
+declare function validateProject(value: unknown): string | undefined;
+declare function uuidv7(now?: number): string;
+declare function validatePrincipal(value: BridgePrincipal): BridgePrincipal;
+declare function validateUuid(value: unknown, field: string): string;
+declare function validateLeasedDeliveryPolicy(input?: Record<string, unknown>): LeasedDeliveryPolicy;
+declare function validateDeliveryPolicy(input: Record<string, unknown> | null | undefined, targeted: boolean): DeliveryPolicy;
+declare function validateMessageDraft(input: MessageDraft): Omit<BridgeMessage, "workspace" | "source" | "sequence" | "createdAt">;
+interface CursorScopeQuery {
+    mailbox?: "inbox" | "sent" | "all";
+    receiptState?: "any" | "unread" | "read";
+    project?: string;
+    types?: string[];
+    includeExpired?: boolean;
+    source?: string;
+    since?: string;
+    threadId?: string;
+}
+declare function cursorScope(principal: BridgePrincipal, query: CursorScopeQuery): string;
+declare function encodeCursor(sequence: string, scope?: string): string;
+declare function decodeCursor(cursor: string | undefined, scope?: string): string | undefined;
+declare function scopedCursorScope(kind: string, principal: BridgePrincipal, filters: JsonValue): string;
+declare function encodeScopedCursor(scope: string, position: JsonValue): string;
+declare function decodeScopedCursor(cursor: string | undefined, scope: string): JsonValue | undefined;
+declare function validateDeliveryCursorPosition(position: JsonValue | undefined): {
+    createdAt: string;
+    id: string;
+} | undefined;
+declare function validateEventCursorPosition(position: JsonValue | undefined): string | undefined;
+
+export { type AgentPresence as A, type BridgeDelivery as B, type DeliveryAction as D, type JsonValue as J, type LeasedDeliveryPolicy as L, type MessageDraft as M, type RetryPolicy as R, type BridgeDeliveryEvent as a, type BridgeMessage as b, type BridgePrincipal as c, BridgePrincipalMismatchError as d, BridgeValidationError as e, type DeliveryPolicy as f, type DeliveryState as g, DeliveryStateConflictError as h, type MessagePriority as i, cursorScope as j, decodeCursor as k, decodeScopedCursor as l, encodeCursor as m, encodeScopedCursor as n, validateDeliveryPolicy as o, validateEventCursorPosition as p, validateLeasedDeliveryPolicy as q, validateMessageDraft as r, scopedCursorScope as s, validatePrincipal as t, uuidv7 as u, validateDeliveryCursorPosition as v, validateProject as w, validateUuid as x };