@theowlops/boombot 0.0.0-stage → 1.1.0

package/dist/node_modules/@boombot/protocol/gateway-protocol/events.js

@@ -0,0 +1,395 @@
+import { z } from "zod";
+import { turnStatusSchema } from "./commands.js";
+import { ProtocolError } from "./errors.js";
+/**
+ * SSE / stream events emitted by the gateway while an agent turn runs.
+ *
+ * Transport: the client POSTs `agent.turn.submit`, then opens the turn's event
+ * stream (`GET /v1/turns/:turnId/events`, `text/event-stream`). Each SSE
+ * `data:` line is one JSON event below.
+ *
+ * Event names follow the same dotted convention as commands. New event types
+ * are added additively; existing fields are never removed or retyped within a
+ * wire version.
+ *
+ * Two families coexist: `agent.turn.*` (the original assistant-message
+ * oriented events) and `turn.*` (typed turn-lifecycle taxonomy with a
+ * per-turn `runId` for cross-event correlation).
+ */
+export const toolCallSchema = z.object({
+    id: z.string().min(1),
+    name: z.string().min(1),
+    arguments: z.record(z.string(), z.unknown()),
+    startedAt: z.string(),
+});
+const agentTurnToken = {
+    type: "agent.turn.token",
+    schema: z.object({
+        turnId: z.string().min(1),
+        /** Incremental text delta for the assistant message. */
+        delta: z.string(),
+    }),
+};
+const agentTurnToolCall = {
+    type: "agent.turn.tool_call",
+    schema: z.object({
+        turnId: z.string().min(1),
+        toolCall: toolCallSchema,
+    }),
+};
+const agentTurnDone = {
+    type: "agent.turn.done",
+    schema: z.object({
+        turnId: z.string().min(1),
+        status: turnStatusSchema,
+        /** Final assistant text when the turn completed. */
+        output: z.string().optional(),
+        usage: z.object({
+            inputTokens: z.number().int().nonnegative(),
+            outputTokens: z.number().int().nonnegative(),
+            totalTokens: z.number().int().nonnegative(),
+        }).optional(),
+    }),
+};
+const agentTurnError = {
+    type: "agent.turn.error",
+    schema: z.object({
+        turnId: z.string().min(1),
+        error: z.string(),
+        /** True when the client may retry with the same requestId. */
+        retryable: z.boolean().optional(),
+    }),
+};
+// ---------------------------------------------------------------------------
+// Turn lifecycle events (typed turn event taxonomy, additive in wire v1).
+//
+// A second, parallel event family alongside `agent.turn.*`, inspired by
+// LangChain `astream_events`. Every event of one turn carries the same
+// `runId` (a UUID generated by the gateway), so clients can correlate the
+// full lifecycle: start -> tool_start/tool_end -> done.
+// ---------------------------------------------------------------------------
+const turnStart = {
+    type: "turn.start",
+    schema: z.object({
+        turnId: z.string().min(1),
+        /** UUID generated per turn; traces every event of the turn. */
+        runId: z.string().min(1),
+    }),
+};
+const turnToolStart = {
+    type: "turn.tool_start",
+    schema: z.object({
+        turnId: z.string().min(1),
+        /** UUID generated per turn; traces every event of the turn. */
+        runId: z.string().min(1),
+        toolCallId: z.string().min(1),
+        toolName: z.string().min(1),
+    }),
+};
+const turnToolEnd = {
+    type: "turn.tool_end",
+    schema: z.object({
+        turnId: z.string().min(1),
+        /** UUID generated per turn; traces every event of the turn. */
+        runId: z.string().min(1),
+        toolCallId: z.string().min(1),
+        toolName: z.string().min(1),
+        durationMs: z.number().nonnegative(),
+        status: z.enum(["ok", "error"]),
+    }),
+};
+const turnApprovalRequired = {
+    type: "turn.approval_required",
+    schema: z.object({
+        turnId: z.string().min(1),
+        /** UUID generated per turn; traces every event of the turn. */
+        runId: z.string().min(1),
+        toolName: z.string().min(1),
+        args: z.record(z.string(), z.unknown()),
+        reason: z.string(),
+        /**
+         * P1-2: set on boot re-announcements of approvals that survived a
+         * gateway restart. No live turn waits behind such an event — answering
+         * records the decision and `turn.approve` reports `resumed: false`.
+         */
+        resumed: z.boolean().optional(),
+    }),
+};
+// ---------------------------------------------------------------------------
+// Harness guard events (wire v1 additive).
+//
+// `@boombot/security` blocks a tool call BEFORE its handler runs
+// (deterministic pre-execution gate: data boundary + tool gates +
+// dual-agent verification). The block is announced on the wire so the
+// client knows why the call never executed.
+// ---------------------------------------------------------------------------
+const guardBlocked = {
+    type: "guard.blocked",
+    schema: z.object({
+        turnId: z.string().min(1),
+        /** UUID generated per turn; traces every event of the turn. */
+        runId: z.string().min(1),
+        toolName: z.string().min(1),
+        /** Which guard layer denied the call: boundary | gates | verifier | sanitizer. */
+        layer: z.string().min(1),
+        reason: z.string(),
+    }),
+};
+// ---------------------------------------------------------------------------
+// Harness guard tagging events (wire v1 additive).
+//
+// `@boombot/security` output tagging: after a turn settles, the
+// gateway tags every tool output as trusted/untrusted (see
+// `agent-worker/src/guard/tagging.ts`) and announces each created tag on the
+// wire, so clients can observe the trust boundary in real time.
+// ---------------------------------------------------------------------------
+const guardTagged = {
+    type: "guard.tagged",
+    schema: z.object({
+        turnId: z.string().min(1),
+        /** UUID generated per turn; traces every event of the turn. */
+        runId: z.string().min(1),
+        /** Tool that produced the output; empty string when the name is unknown. */
+        toolName: z.string(),
+        /** The boundary classification assigned to this tool output. */
+        trust: z.enum(["trusted", "untrusted"]),
+        /** Tool-call id of the tagged output, when known. */
+        callId: z.string().optional(),
+        /** `detectInstructions` pattern ids found in the output (untrusted only). */
+        patterns: z.array(z.string()).optional(),
+    }),
+};
+// ---------------------------------------------------------------------------
+// Background task runner events (wire v1 additive).
+//
+// Lifecycle of tasks created with `task.create`. Clients correlate events by
+// `taskId`. Mirrors the task status machine: queued -> running ->
+// paused/awaiting_approval/completed/failed/cancelled/interrupted.
+// ---------------------------------------------------------------------------
+const taskCreated = {
+    type: "task.created",
+    schema: z.object({
+        taskId: z.string().min(1),
+    }),
+};
+const taskProgress = {
+    type: "task.progress",
+    schema: z.object({
+        taskId: z.string().min(1),
+        stepIndex: z.number().int().nonnegative(),
+        totalSteps: z.number().int().nonnegative(),
+        detail: z.string().optional(),
+    }),
+};
+const taskCheckpoint = {
+    type: "task.checkpoint",
+    schema: z.object({
+        taskId: z.string().min(1),
+        stepIndex: z.number().int().nonnegative(),
+    }),
+};
+const taskPaused = {
+    type: "task.paused",
+    schema: z.object({
+        taskId: z.string().min(1),
+    }),
+};
+const taskResumed = {
+    type: "task.resumed",
+    schema: z.object({
+        taskId: z.string().min(1),
+    }),
+};
+/**
+ * `task.awaiting_approval` — a task step requested a tool approval (HITL).
+ * The client answers with `task.resume` carrying `approved` / `editedArgs`.
+ */
+const taskAwaitingApproval = {
+    type: "task.awaiting_approval",
+    schema: z.object({
+        taskId: z.string().min(1),
+        runId: z.string().min(1),
+        toolName: z.string().min(1),
+        reason: z.string(),
+    }),
+};
+const taskCompleted = {
+    type: "task.completed",
+    schema: z.object({
+        taskId: z.string().min(1),
+    }),
+};
+const taskFailed = {
+    type: "task.failed",
+    schema: z.object({
+        taskId: z.string().min(1),
+        error: z.string(),
+    }),
+};
+const taskCancelled = {
+    type: "task.cancelled",
+    schema: z.object({
+        taskId: z.string().min(1),
+    }),
+};
+/**
+ * `task.interrupted` — the gateway marks tasks found in a non-terminal
+ * state at boot as interrupted (crash recovery). The task-runner bridge
+ * already publishes this event; the schema was missing, so clients calling
+ * `parseEvent` on it failed.
+ */
+const taskInterrupted = {
+    type: "task.interrupted",
+    schema: z.object({
+        taskId: z.string().min(1),
+    }),
+};
+// ---------------------------------------------------------------------------
+// Reasoning-guard verification events (wire v1 additive).
+//
+// `@boombot/security` verifies the final assistant message after the
+// turn finalizer and reports which claims are grounded in tool evidence.
+// The web ChatView renders the report as a verification badge
+// (`report.verdicts[]` + `report.ungroundedCount`).
+// ---------------------------------------------------------------------------
+const turnVerification = {
+    type: "turn.verification",
+    schema: z.object({
+        turnId: z.string().min(1),
+        /** UUID generated per turn; traces every event of the turn. */
+        runId: z.string().min(1),
+        report: z.object({
+            verdicts: z.array(z.object({
+                verdict: z.string().min(1),
+                claim: z.string().optional(),
+            })),
+            ungroundedCount: z.number().int().nonnegative(),
+        }),
+    }),
+};
+// ---------------------------------------------------------------------------
+// Adaptive-routing events (wire v1 additive).
+//
+// `@boombot/core`'s routing middleware (PR #14) classifies every
+// turn `fast`/`deep` at preflight (and can upgrade fast → deep mid-turn
+// when a model round's tool calls look risky). It escalates fast → deep at
+// most once per turn when the verification snapshot reports unsupported
+// claims. The gateway's `bridgeEvent` maps those internal `AgentEvent`s
+// onto these wire events so clients can observe the routing decision and
+// its single escalation.
+// ---------------------------------------------------------------------------
+const turnRouted = {
+    type: "turn.routed",
+    schema: z.object({
+        turnId: z.string().min(1),
+        /** UUID generated per turn; traces every event of the turn. */
+        runId: z.string().min(1),
+        /** Routing decision for the turn: `fast` (cheap) or `deep` (careful). */
+        route: z.enum(["fast", "deep"]),
+        /** Why the router decided this route (e.g. `default:fast`, `risk:destructive`). */
+        reason: z.string(),
+    }),
+};
+const turnEscalated = {
+    type: "turn.escalated",
+    schema: z.object({
+        turnId: z.string().min(1),
+        /** UUID generated per turn; traces every event of the turn. */
+        runId: z.string().min(1),
+        /** Escalation always runs fast → deep: the only direction the router escalates. */
+        from: z.enum(["fast", "deep"]),
+        to: z.enum(["fast", "deep"]),
+        /** What triggered the escalation (e.g. `guard:unsupported-claims`). */
+        trigger: z.string().min(1),
+    }),
+};
+// ---------------------------------------------------------------------------
+// Reasoning delta events (wire v1 additive).
+//
+// Providers that expose intermediate reasoning (DeepSeek `reasoning_content`,
+// OpenRouter `reasoning`, Anthropic `thinking`) stream it separately from the
+// final answer. The Python turn loop forwards those fragments as internal
+// `reasoning.delta` events, and `bridgeEvent` maps them here so the web UI
+// can render a collapsible "thinking" block instead of mixing reasoning
+// into the answer text.
+// ---------------------------------------------------------------------------
+const turnReasoningDelta = {
+    type: "turn.reasoning_delta",
+    schema: z.object({
+        turnId: z.string().min(1),
+        /** UUID generated per turn; traces every event of the turn. */
+        runId: z.string().min(1).optional(),
+        /** One reasoning fragment; concatenate across events for the full trace. */
+        delta: z.string(),
+    }),
+};
+const turnCompacted = {
+    type: "turn.compacted",
+    schema: z.object({
+        turnId: z.string().min(1),
+        prunedTurns: z.number().int().nonnegative(),
+        originalTokens: z.number().int().nonnegative(),
+        compactedTokens: z.number().int().nonnegative(),
+    }),
+};
+/** Every stream event type, mapped to its payload schema. */
+export const STREAM_EVENT_SCHEMAS = {
+    "agent.turn.token": agentTurnToken,
+    "agent.turn.tool_call": agentTurnToolCall,
+    "agent.turn.done": agentTurnDone,
+    "agent.turn.error": agentTurnError,
+    "turn.start": turnStart,
+    "turn.tool_start": turnToolStart,
+    "turn.tool_end": turnToolEnd,
+    "turn.approval_required": turnApprovalRequired,
+    "turn.verification": turnVerification,
+    "turn.routed": turnRouted,
+    "turn.escalated": turnEscalated,
+    "turn.reasoning_delta": turnReasoningDelta,
+    "turn.compacted": turnCompacted,
+    "guard.blocked": guardBlocked,
+    "guard.tagged": guardTagged,
+    "task.created": taskCreated,
+    "task.progress": taskProgress,
+    "task.checkpoint": taskCheckpoint,
+    "task.paused": taskPaused,
+    "task.resumed": taskResumed,
+    "task.awaiting_approval": taskAwaitingApproval,
+    "task.completed": taskCompleted,
+    "task.failed": taskFailed,
+    "task.cancelled": taskCancelled,
+    "task.interrupted": taskInterrupted,
+};
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+ * Validate a raw SSE `data:` value (parsed JSON object or JSON string).
+ * Returns the event with its `type` and validated `payload`.
+ * Throws {@link ProtocolError} with code INVALID_EVENT on any mismatch.
+ */
+export function parseEvent(raw) {
+    let value = raw;
+    if (typeof raw === "string") {
+        try {
+            value = JSON.parse(raw);
+        }
+        catch {
+            throw new ProtocolError("INVALID_EVENT", "Event is not valid JSON");
+        }
+    }
+    if (!isRecord(value) || typeof value.type !== "string") {
+        throw new ProtocolError("INVALID_EVENT", "Event must be an object with a string type");
+    }
+    const entry = STREAM_EVENT_SCHEMAS[value.type];
+    if (!entry) {
+        throw new ProtocolError("INVALID_EVENT", `Unknown event type: ${value.type}`, {
+            type: value.type,
+        });
+    }
+    const result = entry.schema.safeParse(value.payload);
+    if (!result.success) {
+        throw new ProtocolError("INVALID_EVENT", `Invalid payload for event ${value.type}: ${result.error.message}`, { type: value.type, issues: result.error.issues });
+    }
+    return { type: value.type, payload: result.data };
+}

package/dist/node_modules/@boombot/protocol/gateway-protocol/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Public API of `@boombot/protocol`.
+ *
+ * Only the modules below are public. There are no internals to hide — every
+ * file in `src/` is part of the contract surface.
+ */
+export { createEnvelope, parseEnvelope, WIRE_VERSION, } from "./envelope.js";
+export type { Envelope } from "./envelope.js";
+export { ProtocolError } from "./errors.js";
+export type { ProtocolErrorCode } from "./errors.js";
+export { COMMAND_SCHEMAS, parseCommand, parseCommandResponse, attachmentSchema, channelSchema, messageSchema, memoryHitSchema, providerInputSchema, providerKindSchema, providerSchema, reasoningProfileSchema, requestProfileSchema, scheduleSchema, sessionSchema, taskSchema, taskStatusSchema, taskStepSchema, turnStatusSchema, } from "./commands.js";
+export { pluginInfoSchema, marketplacePluginSchema, PLUGIN_COMMAND_DEFS, } from "./commands-plugins.js";
+export type { CommandDef, CommandPayload, CommandResponse, CommandType, ParsedCommand, Task, TaskStatus, TaskStep, } from "./commands.js";
+export { EXTRA_COMMAND_DEFS as SCHEDULER_EXTRA_COMMAND_DEFS } from "./commands-scheduler.js";
+export type { ExtraCommandType as SchedulerExtraCommandType } from "./commands-scheduler.js";
+export { EXTRA_COMMAND_DEFS as CHANNEL_EXTRA_COMMAND_DEFS } from "./commands-channels.js";
+export type { ExtraCommandType as ChannelExtraCommandType } from "./commands-channels.js";
+export { parseEvent, STREAM_EVENT_SCHEMAS, toolCallSchema } from "./events.js";
+export type { StreamEvent, StreamEventPayload, StreamEventType, } from "./events.js";
+export type { Attachment, ChannelInfo, ChannelStatus, MemoryHit, Message, ProviderInfo, ProviderKind, Schedule, SessionSummary, ToolCall, TurnResult, TurnStatus, } from "./types.js";

package/dist/node_modules/@boombot/protocol/gateway-protocol/index.js

@@ -0,0 +1,13 @@
+/**
+ * Public API of `@boombot/protocol`.
+ *
+ * Only the modules below are public. There are no internals to hide — every
+ * file in `src/` is part of the contract surface.
+ */
+export { createEnvelope, parseEnvelope, WIRE_VERSION, } from "./envelope.js";
+export { ProtocolError } from "./errors.js";
+export { COMMAND_SCHEMAS, parseCommand, parseCommandResponse, attachmentSchema, channelSchema, messageSchema, memoryHitSchema, providerInputSchema, providerKindSchema, providerSchema, reasoningProfileSchema, requestProfileSchema, scheduleSchema, sessionSchema, taskSchema, taskStatusSchema, taskStepSchema, turnStatusSchema, } from "./commands.js";
+export { pluginInfoSchema, marketplacePluginSchema, PLUGIN_COMMAND_DEFS, } from "./commands-plugins.js";
+export { EXTRA_COMMAND_DEFS as SCHEDULER_EXTRA_COMMAND_DEFS } from "./commands-scheduler.js";
+export { EXTRA_COMMAND_DEFS as CHANNEL_EXTRA_COMMAND_DEFS } from "./commands-channels.js";
+export { parseEvent, STREAM_EVENT_SCHEMAS, toolCallSchema } from "./events.js";

package/dist/node_modules/@boombot/protocol/gateway-protocol/types.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Shared domain types used by command payloads, responses and stream events.
+ *
+ * These are plain TypeScript types (compile-time only). The runtime shapes are
+ * enforced by the zod schemas in `commands.ts` and `events.ts`.
+ */
+/** Summary of an agent conversation session, as listed by `session.list`. */
+export interface SessionSummary {
+    id: string;
+    title: string;
+    createdAt: string;
+    updatedAt: string;
+    messageCount: number;
+}
+/** A chat message inside a session. */
+export interface Message {
+    id: string;
+    role: "user" | "assistant" | "system" | "tool";
+    content: string;
+    createdAt: string;
+    toolCallId?: string;
+    toolName?: string;
+}
+/** A tool invocation made by the agent during a turn. */
+export interface ToolCall {
+    id: string;
+    name: string;
+    arguments: Record<string, unknown>;
+    startedAt: string;
+}
+/** Supported model-provider kinds for `provider.*` commands. */
+export type ProviderKind = "openai" | "anthropic" | "google" | "mistral" | "xai" | "deepseek" | "openai-compatible" | "local";
+/** Provider record as returned by `provider.list` / `provider.save`. */
+export interface ProviderInfo {
+    id: string;
+    name: string;
+    kind: ProviderKind;
+    /** Custom endpoint; defaults are implied when omitted (except `local`). */
+    baseUrl?: string;
+    /** True when a secret key is stored server-side. The key value itself is never sent. */
+    hasKey: boolean;
+    active: boolean;
+    /**
+     * Default chat model for turns, as set via `provider.save`. Unlike `models`
+     * (probe-discovered catalogue) this is explicit and never overwritten by
+     * `provider.test`. Turns fail when neither is set.
+     */
+    model?: string;
+    models?: string[];
+}
+/** A scheduled job, as used by `schedule.*` commands. */
+export interface Schedule {
+    id: string;
+    name: string;
+    cron: string;
+    prompt: string;
+    enabled: boolean;
+    nextRunAt?: string;
+}
+/** One memory recall hit returned by `memory.search`. */
+export interface MemoryHit {
+    id: string;
+    excerpt: string;
+    score: number;
+}
+/** Channel connection status as returned by `channel.list`. */
+export type ChannelStatus = "connected" | "disconnected" | "error" | "pending";
+export interface ChannelInfo {
+    id: string;
+    kind: string;
+    status: ChannelStatus;
+    displayName: string;
+}
+/** Attachment reference submitted with an agent turn. */
+export interface Attachment {
+    id: string;
+    name: string;
+    mimeType: string;
+    sizeBytes: number;
+    /** Where the gateway can fetch the bytes (opaque to the client). */
+    ref: string;
+}
+/** Terminal status of an agent turn. */
+export type TurnStatus = "queued" | "running" | "completed" | "cancelled" | "failed";
+/** Result summary carried by the `agent.turn.done` stream event. */
+export interface TurnResult {
+    turnId: string;
+    status: TurnStatus;
+    output?: string;
+    error?: string;
+}

package/dist/node_modules/@boombot/protocol/gateway-protocol/types.js

@@ -0,0 +1,7 @@
+/**
+ * Shared domain types used by command payloads, responses and stream events.
+ *
+ * These are plain TypeScript types (compile-time only). The runtime shapes are
+ * enforced by the zod schemas in `commands.ts` and `events.ts`.
+ */
+export {};

package/dist/node_modules/@boombot/protocol/index.d.ts

@@ -0,0 +1,4 @@
+export * from './gateway-protocol/index.js';
+export * from './plugin-sdk/index.js';
+export * from './providers/index.js';
+export type { ProviderKind } from './gateway-protocol/index.js';

package/dist/node_modules/@boombot/protocol/index.js

@@ -0,0 +1,3 @@
+export * from './gateway-protocol/index.js';
+export * from './plugin-sdk/index.js';
+export * from './providers/index.js';

package/dist/node_modules/@boombot/protocol/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "@boombot/protocol",
+  "version": "2.0.0",
+  "type": "module",
+  "main": "./index.js",
+  "exports": {
+    ".": "./index.js"
+  }
+}

package/dist/node_modules/@boombot/protocol/plugin-sdk/channel.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Channel contracts for `@boombot/protocol`.
+ *
+ * Extensions implement `ChannelAdapter` for their platform (Telegram,
+ * WhatsApp, Discord, Slack, …). The gateway (phase 2) loads adapters
+ * through the plugin manifest and never touches platform SDKs directly.
+ */
+/** Messaging platforms with a first-class adapter contract. */
+export type ChannelKind = 'telegram' | 'whatsapp' | 'discord' | 'slack' | 'zalo' | 'messenger' | 'tiktok';
+/** All known channel kinds — used by manifest validation. */
+export declare const CHANNEL_KINDS: readonly ChannelKind[];
+export interface InboundMessage {
+    readonly channel: ChannelKind;
+    readonly chatId: string;
+    readonly senderId: string;
+    readonly messageId: string;
+    readonly text: string;
+    /** Unix epoch milliseconds. */
+    readonly timestamp: number;
+}
+export interface SendOptions {
+    readonly replyToMessageId?: string;
+    readonly silent?: boolean;
+}
+export interface SendResult {
+    readonly delivered: boolean;
+    readonly messageId?: string;
+    readonly error?: string;
+}
+export type MessageHandler = (msg: InboundMessage) => void | Promise<void>;
+/**
+ * Platform adapter implemented by extensions.
+ * Lifecycle: `connect` once at gateway boot, `disconnect` on shutdown.
+ */
+export interface ChannelAdapter {
+    readonly kind: ChannelKind;
+    connect(config: Readonly<Record<string, unknown>>): Promise<void>;
+    disconnect(): Promise<void>;
+    sendMessage(target: string, text: string, opts?: SendOptions): Promise<SendResult>;
+    onMessage(handler: MessageHandler): void;
+}

package/dist/node_modules/@boombot/protocol/plugin-sdk/channel.js

@@ -0,0 +1,17 @@
+/**
+ * Channel contracts for `@boombot/protocol`.
+ *
+ * Extensions implement `ChannelAdapter` for their platform (Telegram,
+ * WhatsApp, Discord, Slack, …). The gateway (phase 2) loads adapters
+ * through the plugin manifest and never touches platform SDKs directly.
+ */
+/** All known channel kinds — used by manifest validation. */
+export const CHANNEL_KINDS = [
+    'telegram',
+    'whatsapp',
+    'discord',
+    'slack',
+    'zalo',
+    'messenger',
+    'tiktok',
+];

package/dist/node_modules/@boombot/protocol/plugin-sdk/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * `@boombot/protocol` — the ONLY public barrel extensions may import.
+ *
+ * Boundary rule (enforced by lint from day one): extensions import from
+ * `@boombot/protocol` and nothing else under `@boombot/*`. Core internals
+ * are never reachable from extension code.
+ */
+export * from './manifest.js';
+export * from './channel.js';
+export * from './plugin.js';

package/dist/node_modules/@boombot/protocol/plugin-sdk/index.js

@@ -0,0 +1,10 @@
+/**
+ * `@boombot/protocol` — the ONLY public barrel extensions may import.
+ *
+ * Boundary rule (enforced by lint from day one): extensions import from
+ * `@boombot/protocol` and nothing else under `@boombot/*`. Core internals
+ * are never reachable from extension code.
+ */
+export * from './manifest.js';
+export * from './channel.js';
+export * from './plugin.js';