@holon-run/agentinbox 0.7.0 → 1.0.0-beta.1

package/dist/src/terminal.js

@@ -16,6 +16,28 @@ const node_fs_1 = __importDefault(require("node:fs"));
 const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
 const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+const AGENT_ADJECTIVES = [
+    "amber", "ancient", "autumn", "brisk", "bright", "bronze", "calm", "cedar",
+    "cinder", "clear", "cobalt", "cool", "copper", "crisp", "dawn", "deep",
+    "drift", "ember", "falling", "fern", "frost", "gentle", "glint", "golden",
+    "granite", "harbor", "hazel", "hidden", "hollow", "ice", "indigo", "iron",
+    "ivory", "jade", "juniper", "kind", "lake", "lively", "lunar", "maple",
+    "meadow", "misty", "moss", "night", "north", "oak", "olive", "opal",
+    "orchid", "pale", "pine", "plum", "quiet", "rapid", "river", "rose",
+    "royal", "rust", "sage", "silver", "soft", "solar", "spring", "stone",
+    "summer", "swift", "timber", "velvet", "warm", "west", "whisper", "winter",
+];
+const AGENT_ANIMALS = [
+    "antelope", "badger", "beaver", "bison", "bittern", "boar", "bobcat", "buffalo",
+    "canary", "cougar", "crane", "crow", "deer", "dingo", "dolphin", "dragonfly",
+    "eagle", "falcon", "finch", "firefly", "fox", "frog", "gazelle", "gecko",
+    "gull", "hare", "hawk", "heron", "ibis", "jaguar", "jay", "kingfisher",
+    "koala", "koi", "lemur", "leopard", "lizard", "lynx", "magpie", "martin",
+    "mink", "mole", "narwhal", "newt", "ocelot", "orca", "otter", "owl",
+    "panther", "parrot", "pebble", "pelican", "pika", "puma", "quail", "raven",
+    "robin", "seal", "sparrow", "stoat", "stork", "swift", "tern", "tiger",
+    "toad", "toucan", "trout", "viper", "weasel", "wren", "yak", "zebra",
+];
 function detectTerminalContext(env = process.env) {
     const tmuxPaneId = normalizeOptionalString(env.TMUX_PANE);
     const termProgram = normalizeOptionalString(env.TERM_PROGRAM);
@@ -48,7 +70,7 @@ function detectTerminalContext(env = process.env) {
     throw new Error("unable to detect a supported terminal context");
 }
 function renderAgentPrompt(input) {
-    const totalUnackedCount = input.totalUnackedCount ?? input.newItemCount ?? 0;
+    const totalUnackedCount = input.totalUnackedCount;
     const itemWord = totalUnackedCount === 1 ? "item" : "items";
     const base = `AgentInbox: ${totalUnackedCount} unacked ${itemWord} in inbox ${input.inboxId}.`;
     if (totalUnackedCount === 1 && input.preview) {
@@ -89,7 +111,7 @@ function deriveInlineItemPreview(item, summary) {
 function normalizeInlinePreviewText(candidate) {
     return normalizeInlinePreview(candidate);
 }
-function assignedAgentIdFromContext(input) {
+function assignedAgentIdFromContext(input, attempt = 0) {
     const primary = normalizeOptionalString(input.runtimeSessionId)
         ?? normalizeOptionalString(input.tmuxPaneId)
         ?? normalizeOptionalString(input.itermSessionId)
@@ -97,12 +119,16 @@ function assignedAgentIdFromContext(input) {
     if (!primary) {
         throw new Error("unable to derive agentId from terminal context");
     }
-    const normalized = primary.replace(/[^a-zA-Z0-9]+/g, "").toLowerCase();
-    if (normalized.length > 0) {
-        return `agent_${input.runtimeKind ?? "unknown"}_${normalized.slice(0, 40)}`;
+    const digest = node_crypto_1.default.createHash("sha256")
+        .update(`${input.runtimeKind ?? "unknown"}:${input.backend}:${primary}:${attempt}`)
+        .digest();
+    const adjective = AGENT_ADJECTIVES[digest[0] % AGENT_ADJECTIVES.length];
+    const animal = AGENT_ANIMALS[digest[1] % AGENT_ANIMALS.length];
+    if (attempt < 16) {
+        return `agt_${adjective}-${animal}`;
     }
-    const digest = node_crypto_1.default.createHash("sha256").update(primary).digest("hex").slice(0, 16);
-    return `agent_${input.runtimeKind ?? "unknown"}_${digest}`;
+    const suffix = digest.toString("hex").slice(0, 3);
+    return `agt_${adjective}-${animal}-${suffix}`;
 }
 class TerminalDispatcher {
     execAsync;

package/dist/src/util.js

@@ -4,16 +4,41 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.nowIso = nowIso;
+exports.generateCanonicalId = generateCanonicalId;
 exports.generateId = generateId;
+exports.generateShortToken = generateShortToken;
 exports.parseJsonArg = parseJsonArg;
 exports.asObject = asObject;
 exports.jsonResponse = jsonResponse;
+exports.formatEntryRef = formatEntryRef;
+exports.parseEntryRef = parseEntryRef;
+exports.formatThreadRef = formatThreadRef;
+exports.parseThreadRef = parseThreadRef;
 const node_crypto_1 = __importDefault(require("node:crypto"));
+const CANONICAL_ID_ALPHABET = "23456789abcdefghjkmnpqrstvwxyz";
+const CANONICAL_ID_TOKEN_LENGTH = 12;
+const ENTRY_THREAD_ID_PATTERN = new RegExp(`^(ent|thr)_[${CANONICAL_ID_ALPHABET}]{${CANONICAL_ID_TOKEN_LENGTH}}$`);
 function nowIso() {
     return new Date().toISOString();
 }
+function generateCanonicalId(prefix, length = CANONICAL_ID_TOKEN_LENGTH) {
+    return `${prefix}_${generateShortToken(length)}`;
+}
 function generateId(prefix) {
-    return `${prefix}_${node_crypto_1.default.randomUUID()}`;
+    return generateCanonicalId(prefix);
+}
+function generateShortToken(length = CANONICAL_ID_TOKEN_LENGTH) {
+    let token = "";
+    while (token.length < length) {
+        const bytes = node_crypto_1.default.randomBytes(length - token.length);
+        for (const byte of bytes) {
+            token += CANONICAL_ID_ALPHABET[byte % CANONICAL_ID_ALPHABET.length];
+            if (token.length >= length) {
+                break;
+            }
+        }
+    }
+    return token;
 }
 function parseJsonArg(raw, source = "JSON argument", options) {
     if (!raw) {
@@ -50,3 +75,23 @@ function asObject(value) {
 function jsonResponse(data) {
     return JSON.stringify(data, null, 2);
 }
+function formatEntryRef(entryId) {
+    return parseEntryRef(entryId);
+}
+function parseEntryRef(ref) {
+    const value = ref.trim();
+    if (!ENTRY_THREAD_ID_PATTERN.test(value) || !value.startsWith("ent_")) {
+        throw new Error(`invalid inbox entry id: ${ref}`);
+    }
+    return value;
+}
+function formatThreadRef(threadId) {
+    return parseThreadRef(threadId);
+}
+function parseThreadRef(ref) {
+    const value = ref.trim();
+    if (!ENTRY_THREAD_ID_PATTERN.test(value) || !value.startsWith("thr_")) {
+        throw new Error(`invalid digest thread id: ${ref}`);
+    }
+    return value;
+}

package/drizzle/migrations/{0000_initial.sql → 0000_v1_initial.sql}

@@ -1,5 +1,8 @@
 create table if not exists sources (
   source_id text primary key,
+  host_id text not null,
+  stream_kind text not null,
+  stream_key text not null,
   source_type text not null,
   source_key text not null,
   config_ref text,
@@ -7,8 +10,7 @@ create table if not exists sources (
   status text not null,
   checkpoint text,
   created_at text not null,
-  updated_at text not null,
-  unique(source_type, source_key)
+  updated_at text not null
 );
 
 create table if not exists agents (
@@ -25,7 +27,11 @@ create table if not exists agents (
 create table if not exists inboxes (
   inbox_id text primary key,
   owner_agent_id text not null unique,
-  created_at text not null
+  created_at text not null,
+  aggregation_enabled integer not null default 0,
+  aggregation_window_ms integer,
+  aggregation_max_items integer,
+  aggregation_max_thread_age_ms integer
 );
 
 create table if not exists subscriptions (
@@ -33,8 +39,8 @@ create table if not exists subscriptions (
   agent_id text not null,
   source_id text not null,
   filter_json text not null,
-  lifecycle_mode text not null,
-  expires_at text,
+  tracked_resource_ref text,
+  cleanup_policy_json text not null,
   start_policy text not null,
   start_offset integer,
   start_time text,
@@ -62,7 +68,9 @@ create table if not exists activation_targets (
   iterm_session_id text,
   created_at text not null,
   updated_at text not null,
-  last_seen_at text not null
+  last_seen_at text not null,
+  runtime_pid integer,
+  min_unacked_items integer
 );
 
 create table if not exists activation_dispatch_states (
@@ -75,6 +83,12 @@ create table if not exists activation_dispatch_states (
   pending_subscription_ids_json text not null,
   pending_source_ids_json text not null,
   updated_at text not null,
+  last_notified_fingerprint text,
+  defer_reason text,
+  defer_attempts integer not null default 0,
+  first_deferred_at text,
+  last_deferred_at text,
+  pending_fingerprint text,
   primary key (agent_id, target_id)
 );
 
@@ -89,6 +103,7 @@ create table if not exists inbox_items (
   raw_payload_json text not null,
   delivery_handle_json text,
   acked_at text,
+  inbox_sequence integer,
   unique(source_id, source_native_id, event_variant, inbox_id)
 );
 
@@ -165,6 +180,107 @@ create table if not exists consumer_commits (
   committed_at text not null
 );
 
+create table if not exists subscription_lifecycle_retirements (
+  subscription_id text primary key,
+  source_id text not null,
+  tracked_resource_ref text not null,
+  retire_at text not null,
+  terminal_state text,
+  terminal_result text,
+  terminal_occurred_at text,
+  created_at text not null,
+  updated_at text not null
+);
+
+create table if not exists source_idle_states (
+  source_id text primary key not null,
+  idle_since text not null,
+  auto_pause_at text not null,
+  auto_paused_at text,
+  updated_at text not null
+);
+
+create table if not exists timers (
+  schedule_id text primary key not null,
+  agent_id text not null,
+  status text not null,
+  mode text not null,
+  at text,
+  interval_ms integer,
+  cron_expr text,
+  timezone text not null,
+  message text not null,
+  sender text,
+  next_fire_at text,
+  last_fired_at text,
+  created_at text not null,
+  updated_at text not null
+);
+
+create table if not exists source_hosts (
+  host_id text primary key,
+  host_type text not null,
+  host_key text not null,
+  config_ref text,
+  config_json text not null,
+  status text not null,
+  created_at text not null,
+  updated_at text not null
+);
+
+create table if not exists digest_threads (
+  thread_id text primary key,
+  inbox_id text not null,
+  source_id text not null,
+  group_key text not null,
+  resource_ref text,
+  event_family text,
+  latest_revision integer not null,
+  latest_entry_id text,
+  status text not null,
+  summary text not null,
+  first_item_at text not null,
+  last_item_at text not null,
+  flush_after_at text,
+  created_at text not null,
+  updated_at text not null
+);
+
+create table if not exists inbox_entries (
+  entry_id text primary key,
+  inbox_id text not null,
+  kind text not null,
+  sequence integer not null unique,
+  thread_id text,
+  revision integer,
+  group_key text,
+  resource_ref text,
+  event_family text,
+  item_json text,
+  count integer not null,
+  summary text not null,
+  first_item_at text not null,
+  last_item_at text not null,
+  source_ids_json text not null,
+  subscription_ids_json text not null,
+  delivery_handle_json text,
+  acked_at text,
+  superseded_at text,
+  created_at text not null
+);
+
+create table if not exists inbox_entry_items (
+  entry_id text not null,
+  item_id text not null,
+  primary key (entry_id, item_id)
+);
+
+create table if not exists digest_thread_items (
+  thread_id text not null,
+  item_id text not null,
+  primary key (thread_id, item_id)
+);
+
 create unique index if not exists idx_activation_targets_terminal_tmux
   on activation_targets(tmux_pane_id)
   where kind = 'terminal' and tmux_pane_id is not null;
@@ -204,3 +320,63 @@ create index if not exists idx_consumers_stream
 create index if not exists idx_consumer_commits_consumer
   on consumer_commits(consumer_id, committed_offset);
 
+create index if not exists idx_subscription_lifecycle_retirements_retire_at
+  on subscription_lifecycle_retirements(retire_at);
+
+create index if not exists idx_source_idle_states_auto_pause_at
+  on source_idle_states(auto_pause_at);
+
+create index if not exists idx_timers_agent_next_fire_at
+  on timers(agent_id, next_fire_at);
+
+create index if not exists idx_timers_next_fire_at
+  on timers(next_fire_at);
+
+create unique index if not exists idx_source_hosts_type_key
+  on source_hosts(host_type, host_key);
+
+create unique index if not exists idx_sources_host_stream_key
+  on sources(host_id, stream_kind, stream_key);
+
+create index if not exists idx_sources_type_key
+  on sources(source_type, source_key);
+
+create unique index if not exists idx_inbox_items_inbox_sequence
+  on inbox_items(inbox_sequence);
+
+create index if not exists idx_inbox_items_inbox_sequence_order
+  on inbox_items(inbox_id, inbox_sequence);
+
+create index if not exists idx_inbox_items_source_occurred_at
+  on inbox_items(source_id, occurred_at);
+
+create index if not exists idx_digest_threads_inbox_status
+  on digest_threads(inbox_id, status);
+
+create index if not exists idx_digest_threads_group_status
+  on digest_threads(inbox_id, group_key, status);
+
+create index if not exists idx_digest_threads_flush_after
+  on digest_threads(status, flush_after_at);
+
+create index if not exists idx_inbox_entries_inbox_visible
+  on inbox_entries(inbox_id, acked_at, superseded_at, sequence);
+
+create index if not exists idx_inbox_entries_thread_revision
+  on inbox_entries(thread_id, revision);
+
+create index if not exists idx_inbox_entry_items_item
+  on inbox_entry_items(item_id);
+
+create index if not exists idx_digest_thread_items_item
+  on digest_thread_items(item_id);
+
+create trigger if not exists trg_inbox_items_set_sequence_after_insert
+after insert on inbox_items
+for each row
+when new.inbox_sequence is null
+begin
+  update inbox_items
+  set inbox_sequence = new.rowid
+  where rowid = new.rowid;
+end;

package/drizzle/migrations/0002_host_scoped_lifecycle_retirements.sql

@@ -0,0 +1,42 @@
+pragma foreign_keys=off;
+
+create table if not exists subscription_lifecycle_retirements__new (
+  subscription_id text primary key,
+  host_id text not null,
+  tracked_resource_ref text not null,
+  retire_at text not null,
+  terminal_state text,
+  terminal_result text,
+  terminal_occurred_at text not null,
+  created_at text not null,
+  updated_at text not null
+);
+
+insert into subscription_lifecycle_retirements__new (
+  subscription_id,
+  host_id,
+  tracked_resource_ref,
+  retire_at,
+  terminal_state,
+  terminal_result,
+  terminal_occurred_at,
+  created_at,
+  updated_at
+)
+select
+  retirement.subscription_id,
+  coalesce(source.host_id, retirement.source_id),
+  retirement.tracked_resource_ref,
+  retirement.retire_at,
+  retirement.terminal_state,
+  retirement.terminal_result,
+  retirement.terminal_occurred_at,
+  retirement.created_at,
+  retirement.updated_at
+from subscription_lifecycle_retirements as retirement
+left join sources as source on source.source_id = retirement.source_id;
+
+drop table subscription_lifecycle_retirements;
+alter table subscription_lifecycle_retirements__new rename to subscription_lifecycle_retirements;
+
+pragma foreign_keys=on;

package/drizzle/migrations/0003_subscription_tracked_resource_indexes.sql

@@ -0,0 +1,5 @@
+create index if not exists idx_subscriptions_tracked_resource_ref
+  on subscriptions(tracked_resource_ref);
+
+create index if not exists idx_subscriptions_tracked_resource_source
+  on subscriptions(tracked_resource_ref, source_id);

package/drizzle/schema.ts

@@ -1,7 +1,23 @@
 import { index, integer, primaryKey, sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core";
 
+export const sourceHosts = sqliteTable("source_hosts", {
+  hostId: text("host_id").primaryKey(),
+  hostType: text("host_type").notNull(),
+  hostKey: text("host_key").notNull(),
+  configRef: text("config_ref"),
+  configJson: text("config_json").notNull(),
+  status: text("status").notNull(),
+  createdAt: text("created_at").notNull(),
+  updatedAt: text("updated_at").notNull(),
+}, (table) => ({
+  hostTypeKey: uniqueIndex("idx_source_hosts_type_key").on(table.hostType, table.hostKey),
+}));
+
 export const sources = sqliteTable("sources", {
   sourceId: text("source_id").primaryKey(),
+  hostId: text("host_id").notNull(),
+  streamKind: text("stream_kind").notNull(),
+  streamKey: text("stream_key").notNull(),
   sourceType: text("source_type").notNull(),
   sourceKey: text("source_key").notNull(),
   configRef: text("config_ref"),
@@ -11,7 +27,8 @@ export const sources = sqliteTable("sources", {
   createdAt: text("created_at").notNull(),
   updatedAt: text("updated_at").notNull(),
 }, (table) => ({
-  sourceTypeKey: uniqueIndex("idx_sources_type_key").on(table.sourceType, table.sourceKey),
+  sourceTypeKey: index("idx_sources_type_key").on(table.sourceType, table.sourceKey),
+  hostStreamKey: uniqueIndex("idx_sources_host_stream_key").on(table.hostId, table.streamKind, table.streamKey),
 }));
 
 export const sourceIdleStates = sqliteTable("source_idle_states", {
@@ -60,6 +77,10 @@ export const agents = sqliteTable("agents", {
 export const inboxes = sqliteTable("inboxes", {
   inboxId: text("inbox_id").primaryKey(),
   ownerAgentId: text("owner_agent_id").notNull(),
+  aggregationEnabled: integer("aggregation_enabled").notNull().default(0),
+  aggregationWindowMs: integer("aggregation_window_ms"),
+  aggregationMaxItems: integer("aggregation_max_items"),
+  aggregationMaxThreadAgeMs: integer("aggregation_max_thread_age_ms"),
   createdAt: text("created_at").notNull(),
 }, (table) => ({
   ownerAgentIdUnique: uniqueIndex("idx_inboxes_owner_agent_id").on(table.ownerAgentId),
@@ -76,11 +97,14 @@ export const subscriptions = sqliteTable("subscriptions", {
   startOffset: integer("start_offset"),
   startTime: text("start_time"),
   createdAt: text("created_at").notNull(),
-});
+}, (table) => ({
+  trackedResourceRefIdx: index("idx_subscriptions_tracked_resource_ref").on(table.trackedResourceRef),
+  trackedResourceRefSourceIdx: index("idx_subscriptions_tracked_resource_source").on(table.trackedResourceRef, table.sourceId),
+}));
 
 export const subscriptionLifecycleRetirements = sqliteTable("subscription_lifecycle_retirements", {
   subscriptionId: text("subscription_id").primaryKey(),
-  sourceId: text("source_id").notNull(),
+  hostId: text("host_id").notNull(),
   trackedResourceRef: text("tracked_resource_ref").notNull(),
   retireAt: text("retire_at").notNull(),
   terminalState: text("terminal_state"),
@@ -101,6 +125,7 @@ export const activationTargets = sqliteTable("activation_targets", {
   lastError: text("last_error"),
   mode: text("mode").notNull(),
   notifyLeaseMs: integer("notify_lease_ms").notNull(),
+  minUnackedItems: integer("min_unacked_items"),
   url: text("url"),
   runtimeKind: text("runtime_kind"),
   runtimeSessionId: text("runtime_session_id"),
@@ -123,6 +148,11 @@ export const activationDispatchStates = sqliteTable("activation_dispatch_states"
   status: text("status").notNull(),
   leaseExpiresAt: text("lease_expires_at"),
   lastNotifiedFingerprint: text("last_notified_fingerprint"),
+  deferReason: text("defer_reason"),
+  deferAttempts: integer("defer_attempts").notNull().default(0),
+  firstDeferredAt: text("first_deferred_at"),
+  lastDeferredAt: text("last_deferred_at"),
+  pendingFingerprint: text("pending_fingerprint"),
   pendingNewItemCount: integer("pending_new_item_count").notNull(),
   pendingSummary: text("pending_summary"),
   pendingSubscriptionIdsJson: text("pending_subscription_ids_json").notNull(),
@@ -155,6 +185,71 @@ export const inboxItems = sqliteTable("inbox_items", {
   sourceOccurredAtIdx: index("idx_inbox_items_source_occurred_at").on(table.sourceId, table.occurredAt),
 }));
 
+export const digestThreads = sqliteTable("digest_threads", {
+  threadId: text("thread_id").primaryKey(),
+  inboxId: text("inbox_id").notNull(),
+  sourceId: text("source_id").notNull(),
+  groupKey: text("group_key").notNull(),
+  resourceRef: text("resource_ref"),
+  eventFamily: text("event_family"),
+  latestRevision: integer("latest_revision").notNull(),
+  latestEntryId: text("latest_entry_id"),
+  status: text("status").notNull(),
+  summary: text("summary").notNull(),
+  firstItemAt: text("first_item_at").notNull(),
+  lastItemAt: text("last_item_at").notNull(),
+  flushAfterAt: text("flush_after_at"),
+  createdAt: text("created_at").notNull(),
+  updatedAt: text("updated_at").notNull(),
+}, (table) => ({
+  inboxStatusIdx: index("idx_digest_threads_inbox_status").on(table.inboxId, table.status),
+  groupStatusIdx: index("idx_digest_threads_group_status").on(table.inboxId, table.groupKey, table.status),
+  flushIdx: index("idx_digest_threads_flush_after").on(table.status, table.flushAfterAt),
+}));
+
+export const inboxEntries = sqliteTable("inbox_entries", {
+  entryId: text("entry_id").primaryKey(),
+  inboxId: text("inbox_id").notNull(),
+  kind: text("kind").notNull(),
+  sequence: integer("sequence").notNull(),
+  threadId: text("thread_id"),
+  revision: integer("revision"),
+  groupKey: text("group_key"),
+  resourceRef: text("resource_ref"),
+  eventFamily: text("event_family"),
+  itemJson: text("item_json"),
+  count: integer("count").notNull(),
+  summary: text("summary").notNull(),
+  firstItemAt: text("first_item_at").notNull(),
+  lastItemAt: text("last_item_at").notNull(),
+  sourceIdsJson: text("source_ids_json").notNull(),
+  subscriptionIdsJson: text("subscription_ids_json").notNull(),
+  deliveryHandleJson: text("delivery_handle_json"),
+  ackedAt: text("acked_at"),
+  supersededAt: text("superseded_at"),
+  createdAt: text("created_at").notNull(),
+}, (table) => ({
+  sequenceUnique: uniqueIndex("idx_inbox_entries_sequence").on(table.sequence),
+  inboxVisibleIdx: index("idx_inbox_entries_inbox_visible").on(table.inboxId, table.ackedAt, table.supersededAt, table.sequence),
+  threadRevisionIdx: index("idx_inbox_entries_thread_revision").on(table.threadId, table.revision),
+}));
+
+export const inboxEntryItems = sqliteTable("inbox_entry_items", {
+  entryId: text("entry_id").notNull(),
+  itemId: text("item_id").notNull(),
+}, (table) => ({
+  pk: primaryKey({ columns: [table.entryId, table.itemId] }),
+  itemIdx: index("idx_inbox_entry_items_item").on(table.itemId),
+}));
+
+export const digestThreadItems = sqliteTable("digest_thread_items", {
+  threadId: text("thread_id").notNull(),
+  itemId: text("item_id").notNull(),
+}, (table) => ({
+  pk: primaryKey({ columns: [table.threadId, table.itemId] }),
+  itemIdx: index("idx_digest_thread_items_item").on(table.itemId),
+}));
+
 export const activations = sqliteTable("activations", {
   activationId: text("activation_id").primaryKey(),
   kind: text("kind").notNull(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@holon-run/agentinbox",
-  "version": "0.7.0",
+  "version": "1.0.0-beta.1",
   "description": "Local event subscription and delivery service for agents.",
   "license": "Apache-2.0",
   "repository": {
@@ -38,6 +38,7 @@
     "docs:deploy": "npm run docs:index && npm run docs:build && npx wrangler@4 deploy --config wrangler.jsonc",
     "db:migrations:generate": "drizzle-kit generate --config drizzle.config.ts",
     "prepack": "npm run build",
+    "smoke:release": "bash scripts/release_smoke.sh",
     "test": "node --require ts-node/register --test --test-force-exit test/*.test.ts"
   },
   "dependencies": {