dsh-team-rooms 1.0.0

package/lib/types/audit.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Host-capability detection for the `ignorable` envelope-marker surface
+ * that every log-only plugin fact event depends on.
+ *
+ * `Session.append(type, data, { ignorable: true })` stamps the envelope
+ * marker on host builds that expose the surface (harness master
+ * `@deepseek-ai/dsh-session`); every released rc line through `0.1.0-rc.8`
+ * and the `0.1.1-rc` line silently drop the options bag, and the
+ * `0.1.2-alpha`/`0.1.2-rc` lines keep the envelope field for read
+ * compatibility but never accept an options bag either (the third append
+ * parameter is `SurfaceIntent` for surface event types only), so fact
+ * events land unmarked on all of them and stricter hosts refuse to resume
+ * those sessions (`SessionFormatUnsupportedError`).
+ * The fact appender detects the host before polluting a log: the installed
+ * peer version is checked against the known-unmarked lines first, and an
+ * unknown (unresolvable) version is verified by probing the FIRST
+ * appended event's returned envelope. The same discipline lives in
+ * `dsh-permission-rules` and `dsh-auto-review`.
+ * @module dsh-team-rooms/audit
+ */
+/** Host envelope capability: unknown until the first append (or the peer-version pre-check). */
+export type AuditSupport = 'unknown' | 'supported' | 'unsupported';
+/**
+ * Whether an `append` call actually honored the `ignorable` marker: the
+ * logged event returned by the host carries `ignorable === true` on
+ * marker-aware builds and nothing on pre-marker builds. `false` (or any
+ * non-event return) means the host dropped the marker and the event landed
+ * unmarked — the appender then degrades instead of polluting further logs.
+ * @param result - the return value of the fact append.
+ * @returns true only when the marker is present on the returned envelope.
+ */
+export declare function isMarkedAuditEvent(result: unknown): boolean;
+/**
+ * Whether a `@deepseek-ai/dsh-session` version line predates the
+ * `ignorable` envelope-marker surface: every released rc line through
+ * `0.1.0-rc.8` silently drops the marker from `Session.append` options
+ * (the stamping fix exists on harness master only — no release carries it
+ * yet), and the `0.1.1-rc` line regressed the same way (verified on
+ * `0.1.1-rc.2`), so fact events written by those builds land unmarked and
+ * break resume on stricter hosts. The `0.1.2` line keeps the `ignorable`
+ * field on the event envelope but has no append option that writes it
+ * (the third parameter is `SurfaceIntent` for surface event types only),
+ * so every `0.1.2-rc` build is known-unmarked too (verified on
+ * `0.1.2-rc.1`). The gate therefore treats
+ * `0.1.1-rc.1`–`rc.8` as known-unmarked as well; over-refusal is harmless
+ * because `allowUnmarkedFacts: true` opts back in. Extend the bound when a
+ * new rc line ships that still drops the marker. Non-matching (later rc,
+ * stable, or unresolvable) versions are treated as possibly-marker-aware
+ * and verified by the append probe.
+ * @param version - the installed peer version string.
+ * @returns true for the known-unmarked rc.1–rc.8 lines of `0.1.0` and
+ *   `0.1.1`, and every `0.1.2-rc` build.
+ */
+export declare function isUnmarkedHostVersion(version: string): boolean;
+/**
+ * The installed `@deepseek-ai/dsh-session` version, or `null` when
+ * unresolvable (falls back to the append probe).
+ * @returns the version string, or null when the peer cannot be resolved.
+ */
+export declare function peerSessionVersion(): string | null;
+/**
+ * Host policy for log-only fact events.
+ * `append` = the rc lines through `0.1.1-rc.2`: fact events may be
+ * appended when the `ignorable` marker is honored; `forbidden` = hosts at
+ * `0.1.2-alpha.1` and later (including every `0.1.2-rc` build), which fail
+ * closed on the session event
+ * vocabulary (`background-agents/fact` and `team-room/fact` are not in
+ * KNOWN_SESSION_EVENT_TYPES, so a written fact makes the session
+ * unreadable there) — never append fact events on those hosts.
+ */
+export type FactEventPolicy = 'append' | 'forbidden' | 'unknown';
+/**
+ * Classify an installed `@deepseek-ai/dsh-session` version for log-only
+ * fact events: `forbidden` at `0.1.2-alpha.1` and later, `append` on the
+ * earlier rc lines, `unknown` for unresolvable versions.
+ * @param version - the installed peer version string.
+ * @returns the fact-event policy for that host line.
+ */
+export declare function factEventPolicyForVersion(version: string): FactEventPolicy;
+//# sourceMappingURL=audit.d.ts.map

package/lib/types/client/TeamRoomsSection.d.ts

@@ -0,0 +1,33 @@
+import type { PropsLocale, PropsRuntime, InjectFace } from '@deepseek-ai/dsh-client-ui-slots';
+/** Minimal structural snapshot contract (the owner package no longer re-exports the generic). */
+interface ObservableSnapshot<T> {
+    getSnapshot(): T;
+    subscribe(listener: () => void): () => void;
+}
+import type { TeamRoomsState } from './room-presenter.js';
+import { ROOM_NS } from './room-locales.js';
+/** Business actions supplied by the slot registration (all via /room command execution). */
+export interface TeamRoomsInjected {
+    hooks: {
+        /** The live controller state: current session id + derived room panels. */
+        teamRooms: ObservableSnapshot<TeamRoomsState>;
+    };
+    /** The current session id (commands execute against it), or undefined. */
+    getSessionId(): string | undefined;
+    create(name: string): Promise<string | undefined>;
+    join(roomId: string): Promise<string | undefined>;
+    leave(roomId: string): Promise<string | undefined>;
+    post(roomId: string, text: string): Promise<string | undefined>;
+    addTask(roomId: string, title: string): Promise<string | undefined>;
+    claimTask(roomId: string, taskId: string): Promise<string | undefined>;
+    completeTask(roomId: string, taskId: string): Promise<string | undefined>;
+    assignTask(roomId: string, taskId: string, member: string): Promise<string | undefined>;
+}
+/** The action share one room card needs (everything except the bound hooks). */
+export type RoomActions = Omit<TeamRoomsInjected, 'hooks'>;
+/** Full component props: the settings-section owner share, locale, and the bound inject face. */
+export type TeamRoomsSectionProps = PropsRuntime<'settings.section'> & PropsLocale<typeof ROOM_NS> & InjectFace<TeamRoomsInjected>;
+/** The settings section: room management over the live session's projection. */
+export declare function TeamRoomsSection(props: TeamRoomsSectionProps): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=TeamRoomsSection.d.ts.map

package/lib/types/client/index.d.ts

@@ -0,0 +1,41 @@
+/**
+ * dsh-team-rooms, browser half: the Team Rooms `settings.section` page.
+ * Member status, the shared task board, and the timeline of every room the
+ * current session belongs to, read from the current session's `teamRoom`
+ * projection (live `faceOf` snapshots) and written back through the HOST
+ * `/room` command (`remote.commands.execute`) so every action keeps the
+ * durable command lifecycle. Zero custom RPC: the page rides the sanctioned
+ * plugin channels only.
+ *
+ * Extracted from the single client entry of `dsh-background-agents` 0.9.6,
+ * which served two slots from one bundle (`sidebar.footer.action`
+ * id `background-agents` for the background-agent panel, and this
+ * `settings.section` id `team-rooms`). Only the room half is shipped here;
+ * the slot id stays byte-identical so an installed settings page keeps
+ * resolving to this plugin.
+ *
+ * The client half reads no subagent surface at all: it needs `sessions`
+ * (list + bindings), `slots`, `locale`, and the remote command executor.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import { type TeamRoomsKey } from './room-locales.js';
+declare module '@deepseek-ai/dsh-client-ui-slots' {
+    interface LocaleNamespaceMap {
+        /** Team-room settings panel copy. */
+        teamRooms: TeamRoomsKey;
+    }
+}
+export type { TeamRoomsInjected, TeamRoomsSectionProps, } from './TeamRoomsSection.js';
+/**
+ * Required services: sessions (list + bindings), slots, locale, the wire
+ * client, and the remote command executor (`remote.commands`, which carries
+ * every `/room` line this page issues). `connection` is deliberately absent —
+ * the room page never calls a remote namespace directly.
+ */
+export declare const inject: string[];
+/**
+ * Register the Team Rooms settings page.
+ * @param ctx - client root context.
+ */
+export declare function apply(ctx: Context): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/client/room-locales.d.ts

@@ -0,0 +1,61 @@
+/** `teamRooms` namespace dictionaries (the settings page panel copy). */
+/** Dictionary namespace owned by the room panel. */
+export declare const ROOM_NS = "teamRooms";
+/** Simplified Chinese dictionary (the key-set source of truth). */
+export declare const zh: {
+    readonly nav: "团队房间";
+    readonly title: "团队房间";
+    readonly intro: "跨会话的持久多 agent 协作：成员注册、消息总线、共享任务板与时间线。状态存在本地存储层（SQLite/JSONL），DSH 重启后自动恢复。";
+    readonly noSession: "暂无活动会话。打开一个会话后再管理团队房间。";
+    readonly empty: "本会话尚未加入任何团队房间。创建一个房间，或粘贴其它会话分享的房间 id 加入。";
+    readonly create: "创建房间";
+    readonly createPlaceholder: "房间名称…";
+    readonly createAction: "创建";
+    readonly join: "加入房间";
+    readonly joinPlaceholder: "房间 id…";
+    readonly joinAction: "加入";
+    readonly roomId: "房间 id";
+    readonly copy: "复制";
+    readonly copied: "已复制";
+    readonly members: "成员";
+    readonly owner: "房主";
+    readonly member: "成员";
+    readonly live: "在线";
+    readonly offline: "离线";
+    readonly tasks: "任务板";
+    readonly tasksEmpty: "暂无任务 —— 用 /room task add 或 room_create_task 添加。";
+    readonly taskAddPlaceholder: "新任务标题…";
+    readonly taskAdd: "添加";
+    readonly claim: "认领";
+    readonly assign: "交接";
+    readonly assignTo: "成员 id 或 me";
+    readonly assignAction: "确定";
+    readonly done: "完成";
+    readonly unassigned: "未分配";
+    readonly statusTodo: "待办";
+    readonly statusInProgress: "进行中";
+    readonly statusDone: "完成";
+    readonly timeline: "时间线";
+    readonly timelineEmpty: "暂无事件。";
+    readonly timelineMessage: "{sender} 广播：{text}";
+    readonly timelineDirected: "{sender} → {to}：{text}";
+    readonly timelineMemberJoined: "{member} 加入了房间";
+    readonly timelineMemberLeft: "{member} 离开了房间";
+    readonly timelineTaskCreated: "创建任务「{title}」";
+    readonly timelineTaskClaimed: "{member} 认领了任务";
+    readonly timelineTaskAssigned: "任务交接给 {member}";
+    readonly timelineTaskCompleted: "任务完成";
+    readonly timelineRoomCreated: "{member} 创建了房间";
+    readonly timelineUnknown: "事件 #{seq}";
+    readonly message: "发消息";
+    readonly messagePlaceholder: "广播给所有成员…";
+    readonly send: "发送";
+    readonly error: "操作失败";
+    readonly busy: "处理中…";
+    readonly leave: "离开房间";
+};
+/** English dictionary, key-identical to the Chinese source of truth. */
+export declare const en: Record<TeamRoomsKey, string>;
+/** The `teamRooms` namespace key union. */
+export type TeamRoomsKey = keyof typeof zh;
+//# sourceMappingURL=room-locales.d.ts.map

package/lib/types/client/room-presenter.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Pure presentation of the team-room settings panel: derives the display
+ * state from the `teamRoom` projection value plus the session-list snapshot
+ * (the live overlay for member status). No I/O, clock, or randomness — the
+ * component stays a thin binder and the rows stay testable.
+ *
+ * @module dsh-team-rooms/room-presenter
+ */
+import { type TimelineEvent } from '../room/schema.js';
+/** The session-list face the presenter reads (host-sampled `running` per session). */
+export interface SessionListLike {
+    byId: Record<string, {
+        id: string;
+        running?: boolean;
+        displayTitle?: string;
+    }>;
+}
+/** One member row with the live overlay applied. */
+export interface RoomMemberRow {
+    readonly sessionId: string;
+    readonly role: 'owner' | 'member';
+    readonly joinedAt: number;
+    /** Live bit from the session list (this browser's own view of the process). */
+    readonly live: boolean;
+    readonly title?: string;
+}
+/** One task-board row. */
+export interface RoomTaskRow {
+    readonly taskId: string;
+    readonly title: string;
+    readonly description: string;
+    readonly status: 'todo' | 'in-progress' | 'done';
+    readonly assigneeSessionId: string | null;
+    readonly createdBy: string;
+}
+/** One rendered timeline entry (the raw event plus its localized label inputs). */
+export interface RoomTimelineRow {
+    readonly seq: number;
+    readonly kind: TimelineEvent['kind'];
+    readonly data: TimelineEvent['data'];
+}
+/** One rendered room panel. */
+export interface RoomPanel {
+    readonly roomId: string;
+    readonly name: string;
+    readonly createdAt: number;
+    readonly members: RoomMemberRow[];
+    readonly tasks: RoomTaskRow[];
+    readonly timeline: RoomTimelineRow[];
+}
+/** The controller state the section component selects from. */
+export interface TeamRoomsState {
+    readonly status: 'ready' | 'unavailable';
+    /** The current session id, when a conversation is open. */
+    readonly sessionId?: string;
+    readonly rooms: RoomPanel[];
+}
+/** Empty ready state (no session open). */
+export declare function emptyTeamRoomsState(): TeamRoomsState;
+/**
+ * Derive the room panels from one projection value and the session list.
+ * @param value - the opaque `teamRoom` projection cell.
+ * @param list - the session-list snapshot (live overlay source).
+ * @returns the panels, or undefined when the cell is absent or invalid.
+ */
+export declare function buildRoomPanels(value: unknown, list: SessionListLike): RoomPanel[] | undefined;
+//# sourceMappingURL=room-presenter.d.ts.map

package/lib/types/facts.d.ts

@@ -0,0 +1,66 @@
+/**
+ * The single append seam for the log-only `team-room/fact` event that carries
+ * the shared room timeline into every member session.
+ *
+ * Two host lines gate the appender:
+ * - rc lines through `0.1.1-rc.2`: `Session.append` predates the
+ *   `ignorable` envelope marker, so a fact event lands unmarked and
+ *   stricter harness builds refuse to resume the session. The appender
+ *   detects such hosts before the first append and disables fact appends
+ *   with a one-time warning.
+ * - `0.1.2-alpha.1` and later: the host fails closed on the session event
+ *   vocabulary - `team-room/fact` is not in KNOWN_SESSION_EVENT_TYPES, so
+ *   writing one makes the session unreadable there. On those hosts fact
+ *   events are never appended; each fact is routed to the injected fallback
+ *   sink (logger/panel channel) instead.
+ * `allowUnmarkedFacts: true` opts back into unmarked appends - deliberately
+ * dangerous - and already-polluted logs can be repaired with
+ * `scripts/repair-session-logs.mjs` from `dsh-permission-rules`.
+ *
+ * Copied from `dsh-background-agents` 0.9.6 with exactly two changes: the
+ * header docstring names only the room fact channel, and {@link FactEventType}
+ * is narrowed to `'team-room/fact'`. The host gating itself is unchanged, so a
+ * profile holding `team_rooms` facts written by 0.9.6 replays them here
+ * identically. (The source carried five mojibake sequences - U+9205 where an
+ * em dash was intended - which are written as plain hyphens here.)
+ * @module dsh-team-rooms/facts
+ */
+import type { Session } from '@deepseek-ai/dsh-session';
+/** The log-only fact event type this appender owns. */
+export type FactEventType = 'team-room/fact';
+/**
+ * Host-gated fact appender. One instance per plugin mount, shared by the
+ * room hub and the room tools.
+ */
+export declare class FactAppender {
+    private readonly allowUnmarked;
+    private readonly warn;
+    private readonly fallback?;
+    private support;
+    private policy;
+    private warned;
+    private warnedForbidden;
+    constructor(allowUnmarked: boolean, warn: (message: string) => void, fallback?: ((type: FactEventType, data: unknown) => void) | undefined);
+    /**
+     * Append one log-only fact, requesting the envelope's `ignorable: true`
+     * marker. On hosts whose event vocabulary forbids the fact events
+     * (`0.1.2-alpha.1+`) the record is routed to the fallback sink instead
+     * of the session log; on pre-marker rc hosts (and after a failed probe)
+     * the append is skipped so the session log stays loadable everywhere. On 0.1.2-alpha.3 the envelope field is retained for stored-log read compatibility only - its Session.append still cannot stamp the marker, so the gate behavior is unchanged.
+     * Append failures are contained: a fact hiccup never disturbs the
+     * caller's operation.
+     * @param session - the session whose log carries the fact.
+     * @param type - the fact event type.
+     * @param data - the fact payload.
+     */
+    append(session: Session, type: FactEventType, data: unknown): void;
+    /** Whether the host's event vocabulary still accepts the log-only fact events; the pre-check runs once. */
+    private factEventsAllowed;
+    /** Whether the host stamps the marker (or the dangerous opt-in is set); the pre-check runs once. */
+    private mayAppend;
+    /** After the first append on an unversioned host, probe the returned envelope for the marker. */
+    private probe;
+    /** One-time warning that fact appends were disabled to keep session logs loadable. */
+    private warnOnce;
+}
+//# sourceMappingURL=facts.d.ts.map

package/lib/types/inbound.d.ts

@@ -0,0 +1,282 @@
+/**
+ * Cross-ecosystem inbound (P2): a minimal newline-delimited JSON-RPC 2.0
+ * bridge over stdio that lets external agent runtimes — OpenAI Agents SDK,
+ * CrewAI, and similar — publish into a team room.
+ *
+ * This is a JSON-RPC direct-connect minimal set, not the official ACP wire
+ * protocol: full ACP compatibility waits for the upstream seam. The bridge
+ * exposes one seam ({@link InboundCoordinator.registerInboundAdapter}) that
+ * returns a disposer, and one concrete adapter ({@link StdioJsonRpcInbound})
+ * that spawns a runtime command and listens on its stdout.
+ *
+ * Wire shape (one JSON notification per line on the child's stdout):
+ *
+ * - `jsonrpc` is always `"2.0"`; `method` is the event name
+ *   (`agent_started` | `agent_message` | `agent_finished`).
+ * - `params` carries the payload: `name` (the external agent's display
+ *   name), `room` (the team-room id), `traceId` (the correlation id),
+ *   `status` (`ok` | `error`, only meaningful on `agent_finished`),
+ *   `message` (the text), and optional `usage` token accounting.
+ *
+ * Mapping onto the team room's existing surfaces (see {@link deliveriesFor}):
+ * `agent_started` opens a task-board card, `agent_message` posts to the
+ * message bus, and `agent_finished` closes the card and posts the outcome.
+ * Every invalid message fails closed: it is dropped and a JSON-RPC error
+ * response is written back to the child's stdin. The owning fiber disposes
+ * the adapter (kills the child, removes listeners) through the returned
+ * disposer; an unspawnable command degrades to a logged warning and a
+ * dormant bridge.
+ *
+ * @module dsh-team-rooms/inbound
+ */
+import { type ChildProcess, type SpawnOptions } from 'node:child_process';
+import { z } from 'zod';
+/** A JSON-RPC 2.0 id: a string, a number, or null (notifications carry none). */
+export type JsonRpcId = string | number | null;
+/** The three recognized inbound event names (the JSON-RPC `method`). */
+export declare const INBOUND_METHODS: readonly ["agent_started", "agent_message", "agent_finished"];
+/** One recognized inbound event name. */
+export type InboundMethod = (typeof INBOUND_METHODS)[number];
+/** Optional token accounting the runtime may report on `agent_finished`. */
+export declare const inboundUsageSchema: z.ZodObject<{
+    /** Un-cached input tokens of the finished run. */
+    inputTokens: z.ZodNumber;
+    /** Output tokens of the finished run. */
+    outputTokens: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    inputTokens: number;
+    outputTokens: number;
+}, {
+    inputTokens: number;
+    outputTokens: number;
+}>;
+/** Token accounting the runtime may report on `agent_finished`. */
+export type InboundUsage = z.infer<typeof inboundUsageSchema>;
+/**
+ * The `params` payload every inbound notification carries. `name` is the
+ * external agent's display name; `room` the team-room id; `traceId` the
+ * correlation id; `status` the ok/error outcome (only `agent_finished`);
+ * `message` the text (required for `agent_message`); `usage` optional token
+ * accounting. `.strict()` rejects unknown fields — fail-closed by default.
+ */
+export declare const inboundParamsSchema: z.ZodObject<{
+    name: z.ZodString;
+    room: z.ZodString;
+    traceId: z.ZodString;
+    status: z.ZodOptional<z.ZodEnum<["ok", "error"]>>;
+    message: z.ZodOptional<z.ZodString>;
+    usage: z.ZodOptional<z.ZodObject<{
+        /** Un-cached input tokens of the finished run. */
+        inputTokens: z.ZodNumber;
+        /** Output tokens of the finished run. */
+        outputTokens: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        inputTokens: number;
+        outputTokens: number;
+    }, {
+        inputTokens: number;
+        outputTokens: number;
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    name: string;
+    room: string;
+    traceId: string;
+    message?: string | undefined;
+    status?: "ok" | "error" | undefined;
+    usage?: {
+        inputTokens: number;
+        outputTokens: number;
+    } | undefined;
+}, {
+    name: string;
+    room: string;
+    traceId: string;
+    message?: string | undefined;
+    status?: "ok" | "error" | undefined;
+    usage?: {
+        inputTokens: number;
+        outputTokens: number;
+    } | undefined;
+}>;
+/** One decoded JSON-RPC request line (params left unknown until mapped). */
+export interface InboundRequest {
+    /** The JSON-RPC `method`, expected to be one of {@link INBOUND_METHODS}. */
+    readonly method: string;
+    /** The raw `params` value; validated by {@link mapInboundEvent}. */
+    readonly params: unknown;
+    /** The request id, or null when the line was a notification (no id). */
+    readonly id: JsonRpcId;
+}
+/** A parsed stdin line: either a valid request or a protocol error to report back. */
+export type InboundParse = {
+    readonly ok: true;
+    readonly request: InboundRequest;
+} | {
+    readonly ok: false;
+    readonly id: JsonRpcId;
+    readonly code: number;
+    readonly message: string;
+};
+/** A mapped event: either a normalized event or an invalid-params error. */
+export type InboundDecode = {
+    readonly ok: true;
+    readonly event: InboundEvent;
+} | {
+    readonly ok: false;
+    readonly code: number;
+    readonly message: string;
+};
+/**
+ * One normalized inbound event, discriminated on the JSON-RPC `method`.
+ * `name` is the external agent's display name; `roomId`/`traceId` come from
+ * `params.room`/`params.traceId`.
+ */
+export type InboundEvent = {
+    readonly method: 'agent_started';
+    readonly name: string;
+    readonly roomId: string;
+    readonly traceId: string;
+    readonly message?: string;
+} | {
+    readonly method: 'agent_message';
+    readonly name: string;
+    readonly roomId: string;
+    readonly traceId: string;
+    readonly message: string;
+} | {
+    readonly method: 'agent_finished';
+    readonly name: string;
+    readonly roomId: string;
+    readonly traceId: string;
+    readonly status: 'ok' | 'error';
+    readonly message?: string;
+    readonly usage?: InboundUsage;
+};
+/**
+ * One room write the bridge performs for a normalized event: a task-board
+ * card open/close or a message-bus post. `traceId` correlates the card with
+ * the external run so `agent_finished` can close the card `agent_started`
+ * opened.
+ */
+export type InboundDelivery = {
+    readonly kind: 'task-open';
+    readonly roomId: string;
+    readonly traceId: string;
+    readonly title: string;
+} | {
+    readonly kind: 'bus-post';
+    readonly roomId: string;
+    readonly traceId: string;
+    readonly text: string;
+} | {
+    readonly kind: 'task-close';
+    readonly roomId: string;
+    readonly traceId: string;
+    readonly status: 'ok' | 'error';
+};
+/** The host-side delivery target: receives normalized events, returns nothing (or a promise). */
+export type InboundSink = (event: InboundEvent) => Promise<void> | void;
+/** A minimal logger face; `console` and the Cordis logger both satisfy it. */
+export interface InboundLogger {
+    info(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+    debug?(message: string): void;
+}
+/** An adapter that listens for external events and forwards them to a sink. */
+export interface InboundAdapter {
+    /**
+     * Begin listening; every mapped event goes to `sink`. Returns a disposer
+     * that stops the adapter and releases every side effect it owns.
+     * @param sink - the delivery target for normalized events.
+     * @returns the stop disposer.
+     */
+    start(sink: InboundSink): () => void;
+}
+/** Spawn signature the stdio adapter uses; injectable for protocol tests. */
+export type SpawnFn = (command: string, options: SpawnOptions) => ChildProcess;
+/**
+ * Parse one newline-delimited stdin line as a JSON-RPC 2.0 request or
+ * notification. Malformed JSON and non-conforming envelopes fail closed with
+ * a stable JSON-RPC error code; the caller reports the error back.
+ * @param line - one raw line (whitespace tolerated).
+ * @returns the parsed request, or a protocol error with its response id.
+ */
+export declare function parseInboundLine(line: string): InboundParse;
+/**
+ * Validate a parsed request's method and params and map them to a normalized
+ * {@link InboundEvent}. Unknown methods and invalid params fail closed with a
+ * stable JSON-RPC error code.
+ * @param request - the parsed request from {@link parseInboundLine}.
+ * @returns the normalized event, or an error to report back.
+ */
+export declare function mapInboundEvent(request: InboundRequest): InboundDecode;
+/**
+ * Map one normalized event to the team room's existing surfaces. The result
+ * is a list of room writes the host executes in order against the `RoomHub`.
+ * @param event - the normalized inbound event.
+ * @returns the ordered room deliveries for the event.
+ */
+export declare function deliveriesFor(event: InboundEvent): InboundDelivery[];
+/**
+ * Serialize one JSON-RPC 2.0 error response. `id` is echoed when the request
+ * carried one; null otherwise (best-effort observability for a notification,
+ * which the JSON-RPC spec would normally not answer).
+ * @param id - the request id to echo (or null).
+ * @param code - the JSON-RPC error code.
+ * @param message - the human-readable error text.
+ * @returns one serialized error response line (no trailing newline).
+ */
+export declare function jsonRpcErrorResponse(id: JsonRpcId, code: number, message: string): string;
+/**
+ * The stdio JSON-RPC inbound adapter: spawns a runtime command and listens
+ * for newline-delimited JSON-RPC notifications on its stdout. Invalid lines
+ * are dropped (fail-closed) and answered with a JSON-RPC error on the child's
+ * stdin. Start/stop are owned entirely by the returned disposer.
+ */
+export declare class StdioJsonRpcInbound implements InboundAdapter {
+    private readonly command;
+    private readonly logger;
+    private readonly spawnFn;
+    private child;
+    private attempted;
+    private disposed;
+    /**
+     * @param command - the runtime launch command (spawned with a shell).
+     * @param logger - where lifecycle and rejection lines are logged.
+     * @param spawnFn - injectable spawn for tests; defaults to `node:child_process` spawn.
+     */
+    constructor(command: string, logger?: InboundLogger, spawnFn?: SpawnFn);
+    /**
+     * Spawn the runtime and begin listening. A spawn failure degrades to a
+     * logged warning and a no-op disposer (the bridge stays dormant).
+     * @param sink - the delivery target for mapped events.
+     * @returns the stop disposer (kills the child; further output is ignored).
+     */
+    start(sink: InboundSink): () => void;
+    /** Stop the adapter: kill the child if still running; further output is ignored. Idempotent. */
+    stop(): void;
+    /** Decode one line, emit a mapped event, or report the failure back (fail-closed). */
+    private handleLine;
+    /** Best-effort write of one JSON-RPC error response to the child's stdin. */
+    private writeResponse;
+}
+/**
+ * The inbound adapter provider seam: registers adapters and owns their
+ * disposers. Every registration returns a disposer that stops and unregisters
+ * exactly that adapter; {@link stopAll} stops every registered adapter.
+ */
+export declare class InboundCoordinator {
+    private readonly stops;
+    /**
+     * Register one adapter for a sink and start it. Returns a disposer that
+     * stops the adapter and drops it from the registry (idempotent).
+     * @param adapter - the adapter to start.
+     * @param sink - the delivery target the adapter emits into.
+     * @returns the stop-and-unregister disposer.
+     */
+    registerInboundAdapter(adapter: InboundAdapter, sink: InboundSink): () => void;
+    /** Stop every registered adapter (idempotent). */
+    stopAll(): void;
+}
+//# sourceMappingURL=inbound.d.ts.map