@holon-run/agentinbox 0.6.0 → 1.0.0-beta.0

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/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),
@@ -101,6 +122,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 +145,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 +182,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.6.0",
+  "version": "1.0.0-beta.0",
   "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": {

package/scripts/iterm2_cursor_probe.py

@@ -8,6 +8,11 @@ import sys
 import json
 import asyncio
 
+# Keep this value in sync with the TypeScript probe normalization constant
+# `NORMALIZED_BUFFER_TAIL_LINES`, since both are intended to mirror the same
+# CLI/probe tail window.
+CAPTURE_TAIL_LINES = 20
+
 
 def probe_session(connection, session_id):
     """Probe iTerm2 session state and return cursor position with buffer contents."""
@@ -25,9 +30,9 @@ def probe_session(connection, session_id):
                 screen = await session.async_get_screen_contents()
                 cursor = screen.cursor_coord
 
-                # Get the last few lines of content
+                # Capture a tail comparable to the CLI probe window.
                 lines = []
-                start_line = max(0, screen.number_of_lines - 5)
+                start_line = max(0, screen.number_of_lines - CAPTURE_TAIL_LINES)
                 for i in range(start_line, screen.number_of_lines):
                     try:
                         line = screen.line(i)
@@ -83,4 +88,4 @@ def main():
 
 
 if __name__ == "__main__":
-    main()
+    main()

package/scripts/release_smoke.sh

@@ -0,0 +1,123 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+if [ "$#" -ne 1 ]; then
+  echo "usage: scripts/release_smoke.sh <packed-tarball>" >&2
+  exit 1
+fi
+
+PACK_FILE="$(cd "$(dirname "$1")" && pwd)/$(basename "$1")"
+if [ ! -f "$PACK_FILE" ]; then
+  echo "packed tarball not found: $PACK_FILE" >&2
+  exit 1
+fi
+
+TMP_BASE="${TMPDIR:-/tmp}"
+TMP_ROOT="$(mktemp -d "$TMP_BASE/aixsmk.XXXXXX")"
+cleanup() {
+  rm -rf "$TMP_ROOT" >/dev/null 2>&1 || true
+}
+trap cleanup EXIT
+
+PKG_ROOT="$TMP_ROOT/pkg"
+HOME_DIR="$TMP_ROOT/home"
+mkdir -p "$PKG_ROOT" "$HOME_DIR"
+
+cd "$PKG_ROOT"
+npm init -y >/dev/null 2>&1
+npm install "$PACK_FILE" >/dev/null 2>&1
+
+export HOME="$HOME_DIR"
+unset AGENTINBOX_SOCKET
+unset AGENTINBOX_URL
+FRESH_HOME="$TMP_ROOT/f1"
+LEGACY_HOME="$TMP_ROOT/f2"
+CLI_HOME="$TMP_ROOT/f3"
+
+echo "[smoke] fresh install"
+export AGENTINBOX_HOME="$FRESH_HOME"
+DB_PATH="$AGENTINBOX_HOME/agentinbox.sqlite"
+npx agentinbox --version >/dev/null
+npx agentinbox daemon start >/dev/null
+npx agentinbox host list >/dev/null
+[ -f "$DB_PATH" ]
+
+echo "[smoke] archive pre-v1 database and start fresh"
+export AGENTINBOX_HOME="$LEGACY_HOME"
+DB_PATH="$AGENTINBOX_HOME/agentinbox.sqlite"
+rm -rf "$AGENTINBOX_HOME"
+mkdir -p "$AGENTINBOX_HOME"
+python3 - "$DB_PATH" <<'PY'
+import sqlite3
+import sys
+
+db_path = sys.argv[1]
+conn = sqlite3.connect(db_path)
+conn.execute("create table sources (source_id text primary key, source_type text, source_key text)")
+conn.commit()
+conn.close()
+PY
+npx agentinbox daemon start >/dev/null
+npx agentinbox host list >/dev/null
+[ -f "$DB_PATH" ]
+find "$AGENTINBOX_HOME" -maxdepth 1 -name 'agentinbox.sqlite.pre-v1.*.bak*' | grep -q .
+
+echo "[smoke] canonical v1 CLI and HTTP surfaces"
+export AGENTINBOX_HOME="$CLI_HOME"
+DB_PATH="$AGENTINBOX_HOME/agentinbox.sqlite"
+npx agentinbox daemon start >/dev/null
+HOST_JSON="$(npx agentinbox host add local_event smoke-local)"
+HOST_ID="$(printf '%s' "$HOST_JSON" | node -e 'let input=""; process.stdin.on("data", (chunk) => input += chunk); process.stdin.on("end", () => process.stdout.write(JSON.parse(input).hostId));')"
+SOURCE_JSON="$(npx agentinbox source add "$HOST_ID" events smoke-local)"
+SOURCE_ID="$(printf '%s' "$SOURCE_JSON" | node -e 'let input=""; process.stdin.on("data", (chunk) => input += chunk); process.stdin.on("end", () => process.stdout.write(JSON.parse(input).sourceId));')"
+npx agentinbox source schema "$SOURCE_ID" >/dev/null
+
+node - "$AGENTINBOX_HOME/agentinbox.sock" <<'PY'
+const http = require("http");
+
+const socketPath = process.argv[2];
+
+function request(pathname) {
+  return new Promise((resolve, reject) => {
+    const req = http.request({
+      agent: false,
+      socketPath,
+      path: pathname,
+      method: "GET",
+    }, (res) => {
+      let body = "";
+      res.setEncoding("utf8");
+      res.on("data", (chunk) => {
+        body += chunk;
+      });
+      res.on("end", () => resolve({ statusCode: res.statusCode ?? 0, body }));
+    });
+    req.on("error", reject);
+    req.end();
+  });
+}
+
+(async () => {
+  const health = await request("/healthz");
+  if (health.statusCode !== 200) {
+    throw new Error(`healthz failed: ${health.statusCode}`);
+  }
+  const openapi = await request("/openapi.json");
+  if (openapi.statusCode !== 200) {
+    throw new Error(`openapi failed: ${openapi.statusCode}`);
+  }
+  const schema = JSON.parse(openapi.body);
+  const raw = JSON.stringify(schema);
+  if (raw.includes("/agents/{agentId}/inbox/raw-items")) {
+    throw new Error("legacy raw-items endpoint still exposed");
+  }
+  if (raw.includes("throughItemId") || raw.includes("afterItemId")) {
+    throw new Error("legacy inbox paging fields still exposed");
+  }
+})().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});
+PY
+
+echo "[smoke] ok"