@haywoodmarx/agent-pager 0.1.0

package/dist/src/implementations/claude/socket-delivery.d.ts

@@ -0,0 +1,52 @@
+import { type DeliveryAddress, type DeliveryReach } from "../../messaging/delivery.js";
+import type { HostWake, KnownValue } from "../model.js";
+/** Names this integration as the sender Claude Code shows on every delivered message. */
+export declare const CLAUDE_INBOX_SENDER = "pager";
+/**
+ * Bounds one connection to the inbox socket. Claude Code closes a connection that has not sent a
+ * complete line within its own deadline, so a connection that cannot finish well inside that is
+ * reported as undelivered rather than left to be dropped silently.
+ */
+export declare const CLAUDE_INBOX_WRITE_TIMEOUT_MS = 10000;
+/**
+ * Writes complete lines to one inbox socket and resolves once the host has taken them.
+ *
+ * Injected so the provider's own test observes the exact lines written, and the real connection is
+ * tested on its own against a listening Unix socket.
+ */
+export type ClaudeInboxWriter = (socketPath: string, lines: readonly string[]) => Promise<void>;
+/**
+ * Read the inbox address Claude Code exported to this process, for the gateway to register.
+ * @param environment - Environment Claude Code exported to its stdio child.
+ * @returns - Opaque address text for the broker to hold, or not known when either part is absent.
+ */
+export declare function claudeDeliveryAddress(environment: Readonly<NodeJS.ProcessEnv>): KnownValue<string>;
+/**
+ * Accept an address a Claude session registered, refusing anything not shaped like an inbox socket.
+ *
+ * The socket path must be absolute and end in `.sock`, which is the only shape Claude Code binds,
+ * so a value that is not one cannot be an inbox and is not worth connecting to.
+ * @param raw - Untrusted address text exactly as the session supplied it.
+ * @returns - The branded address when it is well formed, otherwise not known.
+ */
+export declare function parseClaudeDeliveryAddress(raw: string): KnownValue<DeliveryAddress>;
+/**
+ * Write one wake into a Claude session's inbox and report how far it reached.
+ *
+ * The first line authenticates as the session's own child, which is what lets a session that
+ * bypasses permission prompts deliver the message without holding it for approval. The second
+ * carries the wake as a user message.
+ * @param write - Connection to the inbox socket.
+ * @param address - Address this provider accepted for the recipient's session.
+ * @param wake - Claims to hand over, or a body-free operator ping.
+ * @returns - Claimed for a claim-carrying wake, notified for a ping, or undelivered with the cause.
+ */
+export declare function deliverToClaudeInbox(write: ClaudeInboxWriter, address: DeliveryAddress, wake: HostWake): Promise<DeliveryReach>;
+/**
+ * Connect to an inbox socket, write every line, then end the connection.
+ * @param socketPath - Unix domain socket bound by the Claude session.
+ * @param lines - Complete lines to write, without trailing newlines.
+ * @returns - Resolves once the final write has flushed; rejects on a socket error or when the socket
+ * sits idle past `CLAUDE_INBOX_WRITE_TIMEOUT_MS`.
+ */
+export declare function writeClaudeInboxLines(socketPath: string, lines: readonly string[]): Promise<void>;

package/dist/src/implementations/claude/socket-delivery.js

@@ -0,0 +1,159 @@
+import { connect } from "node:net";
+import { isAbsolute } from "node:path";
+import { publicEpoch } from "../../broker/snapshot.js";
+import { claimsWakeContent, } from "../../messaging/delivery.js";
+import { wakeLine } from "../../messaging/wake.js";
+import { CLAUDE_INBOX_SOCKET_ENVIRONMENT, CLAUDE_INBOX_TOKEN_ENVIRONMENT } from "./environment.js";
+/** Names this integration as the sender Claude Code shows on every delivered message. */
+export const CLAUDE_INBOX_SENDER = "pager";
+/**
+ * Bounds one connection to the inbox socket. Claude Code closes a connection that has not sent a
+ * complete line within its own deadline, so a connection that cannot finish well inside that is
+ * reported as undelivered rather than left to be dropped silently.
+ */
+export const CLAUDE_INBOX_WRITE_TIMEOUT_MS = 10_000;
+/** Names the envelope element Claude Code parses as a message from another session. */
+const CROSS_SESSION_MESSAGE_TAG = "cross-session-message";
+/**
+ * Accepts a peer address the envelope can carry verbatim.
+ *
+ * Narrower than what the host tolerates: it strips some characters and truncates a long name, and
+ * an attribute altered that way fails the host's own round-trip check and renders the delivery in
+ * full instead.
+ */
+const NAMEABLE_PEER = /^[A-Za-z0-9._:@/-]{1,64}$/u;
+/**
+ * Read the inbox address Claude Code exported to this process, for the gateway to register.
+ * @param environment - Environment Claude Code exported to its stdio child.
+ * @returns - Opaque address text for the broker to hold, or not known when either part is absent.
+ */
+export function claudeDeliveryAddress(environment) {
+    const socketPath = environment[CLAUDE_INBOX_SOCKET_ENVIRONMENT];
+    const token = environment[CLAUDE_INBOX_TOKEN_ENVIRONMENT];
+    if (!socketPath || !token)
+        return { known: false };
+    const address = { socketPath, token };
+    return { known: true, value: JSON.stringify(address) };
+}
+/**
+ * Accept an address a Claude session registered, refusing anything not shaped like an inbox socket.
+ *
+ * The socket path must be absolute and end in `.sock`, which is the only shape Claude Code binds,
+ * so a value that is not one cannot be an inbox and is not worth connecting to.
+ * @param raw - Untrusted address text exactly as the session supplied it.
+ * @returns - The branded address when it is well formed, otherwise not known.
+ */
+export function parseClaudeDeliveryAddress(raw) {
+    const address = decodeAddress(raw);
+    if (!address)
+        return { known: false };
+    return { known: true, value: raw };
+}
+/**
+ * Write one wake into a Claude session's inbox and report how far it reached.
+ *
+ * The first line authenticates as the session's own child, which is what lets a session that
+ * bypasses permission prompts deliver the message without holding it for approval. The second
+ * carries the wake as a user message.
+ * @param write - Connection to the inbox socket.
+ * @param address - Address this provider accepted for the recipient's session.
+ * @param wake - Claims to hand over, or a body-free operator ping.
+ * @returns - Claimed for a claim-carrying wake, notified for a ping, or undelivered with the cause.
+ */
+export async function deliverToClaudeInbox(write, address, wake) {
+    const decoded = decodeAddress(address);
+    if (!decoded)
+        return { reach: "undelivered", cause: "delivery address is malformed" };
+    const content = wake.type === "claims_delivered"
+        ? crossSessionMessage(claimsWakeContent(wake), peerName(wake.claims))
+        : wakeLine(wake, publicEpoch(wake.epoch));
+    const lines = [
+        JSON.stringify({ type: "auth", token: decoded.token }),
+        JSON.stringify({
+            type: "user",
+            message: { role: "user", content },
+            from: CLAUDE_INBOX_SENDER,
+        }),
+    ];
+    try {
+        await write(decoded.socketPath, lines);
+    }
+    catch (error) {
+        return { reach: "undelivered", cause: error instanceof Error ? error.message : String(error) };
+    }
+    return wake.type === "claims_delivered" ? { reach: "claimed" } : { reach: "notified" };
+}
+/**
+ * Connect to an inbox socket, write every line, then end the connection.
+ * @param socketPath - Unix domain socket bound by the Claude session.
+ * @param lines - Complete lines to write, without trailing newlines.
+ * @returns - Resolves once the final write has flushed; rejects on a socket error or when the socket
+ * sits idle past `CLAUDE_INBOX_WRITE_TIMEOUT_MS`.
+ */
+export function writeClaudeInboxLines(socketPath, lines) {
+    return new Promise((resolve, reject) => {
+        const socket = connect({ path: socketPath });
+        let settled = false;
+        const settle = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            socket.destroy();
+            if (error)
+                reject(error);
+            else
+                resolve();
+        };
+        socket.setTimeout(CLAUDE_INBOX_WRITE_TIMEOUT_MS, () => {
+            settle(new Error(`inbox socket write timed out after ${String(CLAUDE_INBOX_WRITE_TIMEOUT_MS)} ms`));
+        });
+        socket.once("error", (error) => {
+            settle(error);
+        });
+        socket.once("connect", () => {
+            socket.end(`${lines.join("\n")}\n`, () => {
+                settle();
+            });
+        });
+    });
+}
+/**
+ * Wrap delivered text in the envelope Claude Code recognises as a message from another session.
+ *
+ * A session collapses a recognised envelope to a single line the reader can expand, which is the
+ * only reason to emit one; unrecognised text renders in full. The host re-serialises what it parses
+ * and rejects anything that does not match byte for byte, so the attribute is emitted only when it
+ * survives that comparison unchanged, and the body must sit on its own lines.
+ * @param body - Text to carry, rendered by the shared claim renderer.
+ * @param name - Sender to label the collapsed line with, or nothing when no single sender owns it.
+ * @returns - Envelope text for the host, wrapping the body unaltered.
+ */
+function crossSessionMessage(body, name) {
+    const attribute = name === undefined ? "" : ` from-name="${name}"`;
+    return `<${CROSS_SESSION_MESSAGE_TAG}${attribute}>\n${body}\n</${CROSS_SESSION_MESSAGE_TAG}>`;
+}
+function peerName(claims) {
+    const [first] = claims;
+    if (!first || claims.some((claim) => claim.fromAddress !== first.fromAddress))
+        return undefined;
+    return NAMEABLE_PEER.test(first.fromAddress) ? first.fromAddress : undefined;
+}
+function decodeAddress(raw) {
+    let decoded;
+    try {
+        decoded = JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+    if (typeof decoded !== "object" || decoded === null || Array.isArray(decoded))
+        return undefined;
+    const { socketPath, token } = decoded;
+    if (typeof socketPath !== "string" || !isAbsolute(socketPath) || !socketPath.endsWith(".sock"))
+        return undefined;
+    if (typeof token !== "string" || token.length === 0)
+        return undefined;
+    if (Object.keys(decoded).length !== 2)
+        return undefined;
+    return { socketPath, token };
+}

package/dist/src/implementations/model.d.ts

@@ -0,0 +1,162 @@
+import type { AgentId } from "../broker/protocol.js";
+import type { ClaimsDelivered, DeliveryAddress, DeliveryReach } from "../messaging/delivery.js";
+import type { OperatorPingChanged } from "../messaging/notifications.js";
+/** Brands an open implementation identifier after boundary validation. */
+declare const implementationIdBrand: unique symbol;
+/** Identifies an agent implementation without enumerating installed providers. */
+export type ImplementationId = string & {
+    readonly [implementationIdBrand]: true;
+};
+/** Reports whether a value is known at the current boundary. */
+export type KnownValue<T> = {
+    known: true; /** Supplies the value. */
+    value: T;
+} | {
+    known: false;
+};
+/** Names a capability an implementation may advertise. */
+export type ImplementationCapabilityName = "launch" | "notification" | "session-identity" | "host-registration";
+/** Describes public implementation metadata and declared capabilities. */
+export type ImplementationDescriptor = {
+    /** Identifies the implementation with an open validated value. */
+    id: ImplementationId;
+    /** Supplies a human-readable label owned by the implementation. */
+    displayName: string;
+    /** Reports the installed implementation version when known. */
+    version: KnownValue<string>;
+    /** Lists the capabilities implemented by this provider. */
+    capabilities: readonly ImplementationCapabilityName[];
+};
+/** Supplies neutral values from which an implementation builds a launch plan. */
+export type ImplementationLaunchRequest = {
+    /** Identifies the reserved broker agent. */
+    agentId: AgentId;
+    /** Supplies the shared broker endpoint. */
+    brokerUrl: string;
+    /** Supplies the launch attachment reservation environment value. */
+    reservation: string;
+    /** Supplies the delivery attachment reservation environment value. */
+    deliveryReservation: string;
+    /** Supplies caller arguments forwarded to the implementation. */
+    passthroughArgs: readonly string[];
+    /** Supplies the workspace in which the process starts. */
+    workspacePath: string;
+};
+/** Describes an implementation-owned process invocation consumed by terminal providers. */
+export type ImplementationLaunchPlan = {
+    /** Names the executable to start. */
+    command: string;
+    /** Supplies ordered executable arguments. */
+    args: readonly string[];
+    /** Supplies non-sensitive implementation-owned environment additions. */
+    environment: Readonly<Record<string, string>>;
+    /** Supplies process-binding environment values that terminal providers must not expose. */
+    sensitiveEnvironment: Readonly<Record<string, string>>;
+    /** Supplies the process working directory. */
+    workspacePath: string;
+    /** Supplies a terminal title. */
+    title: string;
+};
+/** Represents a capability the implementation does not provide. */
+export type UnsupportedImplementationCapability = {
+    /** Reports that the capability is unavailable. */ supported: false;
+};
+/** Builds implementation-owned launch plans. */
+export type LaunchImplementationCapability = UnsupportedImplementationCapability | {
+    /** Reports that process launch is available. */
+    supported: true;
+    /** Builds one process plan from neutral launch inputs. */
+    buildPlan(request: ImplementationLaunchRequest): Promise<ImplementationLaunchPlan>;
+};
+/** A wake the broker pushes to a host: claims for its messages, or a body-free operator ping. */
+export type HostWake = ClaimsDelivered | OperatorPingChanged;
+/**
+ * Describes how an implementation's sessions learn their inbox changed.
+ *
+ * A supported implementation receives its claims inside the wake: the broker claims on the
+ * session's behalf when it writes to the address the session registered.
+ */
+export type NotificationImplementationCapability = UnsupportedImplementationCapability | HostPushNotificationCapability;
+/** Notification capability of an implementation whose sessions accept claims the broker pushes. */
+export type HostPushNotificationCapability = {
+    /** Reports that the broker delivers wakes to an address the session registers. */
+    supported: true;
+    /** Reports that the implementation accepts claims pushed into its host session. */
+    mode: "host-push";
+    /**
+     * Accept or reject an address a session registered, before the broker holds it.
+     * @param raw - Untrusted address text exactly as the session supplied it.
+     * @returns - The branded address when it is well formed, otherwise not known.
+     */
+    parseAddress(raw: string): KnownValue<DeliveryAddress>;
+    /**
+     * Write one wake to a host address and report how far it reached. Never rejects: a transport
+     * failure is the undelivered reach, so the caller can release what it claimed.
+     * @param address - Address this implementation accepted for the recipient's session.
+     * @param wake - Claims to hand over, or a body-free operator ping.
+     * @returns - Highest rung of delivery the transport can vouch for.
+     */
+    deliver(address: DeliveryAddress, wake: HostWake): Promise<DeliveryReach>;
+};
+/** Reads the value an implementation uses to recognise one of its own conversations. */
+export type SessionIdentityInput = {
+    /** Supplies the process environment visible to the implementation's in-process code. */
+    environment: Readonly<NodeJS.ProcessEnv>;
+    /** Supplies the conversation identity the implementation's own host API reported, when it has one. */
+    hostSessionId?: string;
+};
+/** Recognises the harness conversation a process belongs to, across restarts of that process. */
+export type SessionIdentityImplementationCapability = UnsupportedImplementationCapability | {
+    /** Reports that resumable session identity is available. */
+    supported: true;
+    /**
+     * Resolve the key that stays the same when this conversation is resumed in a new process, and
+     * that differs between two conversations of the same implementation in one workspace. Returning
+     * nothing means this process cannot prove which conversation it is, so it must register anew.
+     */
+    sessionKey(input: SessionIdentityInput): string | undefined;
+};
+/** Names the child process that registers an implementation with its host. */
+export type HostRegistrationCommand = {
+    /** Executable to run. */
+    command: string;
+    /** Arguments passed to the executable. */
+    args: readonly string[];
+    /**
+     * The same command as an operator would type it.
+     *
+     * Shown before the child runs, and copied on request. A command needing a shell to sequence its
+     * steps is spawned through one, and this is the script that shell is given, without the wrapper.
+     */
+    display: string;
+};
+/** Declares whether an implementation can register itself with its host for every session. */
+export type HostRegistrationImplementationCapability = {
+    /** Reports that this implementation registers nothing with its host. */
+    supported: false;
+} | {
+    /** Reports that this implementation can register itself with its host. */
+    supported: true;
+    /**
+     * Name the command that registers this implementation, so sessions nobody launched connect.
+     *
+     * The command is handed back rather than run, because the host owns its own installation: it
+     * decides what to write and where, and it may ask the operator before doing either.
+     * @returns - Command to run in a terminal the operator can answer prompts in.
+     */
+    registrationCommand(): HostRegistrationCommand;
+};
+/** Defines one implementation behind capability-specific neutral ports. */
+export interface ImplementationProvider {
+    /** Describes this implementation without exposing its concrete type. */
+    readonly descriptor: ImplementationDescriptor;
+    /** Builds process launch plans when supported. */
+    readonly launch: LaunchImplementationCapability;
+    /** Describes how its sessions learn their inbox changed, when supported. */
+    readonly notification: NotificationImplementationCapability;
+    /** Recognises its own resumed conversations when supported. */
+    readonly sessionIdentity: SessionIdentityImplementationCapability;
+    /** Names the command that registers it with its host, when supported. */
+    readonly hostRegistration: HostRegistrationImplementationCapability;
+}
+export {};

package/dist/src/implementations/model.js

@@ -0,0 +1 @@
+export {};

package/dist/src/implementations/opencode/adapter.d.ts

@@ -0,0 +1,71 @@
+/** Name OpenCode gives the acknowledgement tool of the MCP server the plugin registers as `pager`. */
+export declare const OPENCODE_ACK_TOOL = "pager_ack_agent_messages";
+/** Sends one delivery into an OpenCode session as a prompt carrying a system addition. */
+export type OpenCodePrompt = (sessionId: string, system: string, text: string) => Promise<void>;
+/** Describes the session fields needed to select a top-level OpenCode target. */
+export type OpenCodeSessionInfo = {
+    /** Identifies the OpenCode session. */
+    id: string;
+    /** Identifies the parent session when this session is a child. */
+    parentID?: string;
+    /** Reports the session status when supplied by OpenCode. */
+    status?: string;
+};
+/** Resolves an OpenCode session by its identifier. */
+export type OpenCodeSessionResolver = (sessionId: string) => Promise<OpenCodeSessionInfo | undefined>;
+/** Defines collaborators and recovery state used by an OpenCode adapter. */
+export type OpenCodeAdapterOptions = {
+    /** Sends deliveries to the selected OpenCode session. */
+    prompt: OpenCodePrompt;
+    /** Resolves sessions to determine whether they are top-level targets. */
+    resolveSession: OpenCodeSessionResolver;
+};
+/**
+ * Track only top-level OpenCode sessions, selecting the first whose resolution completed.
+ * @param resolveSession - Lookup used to distinguish top-level from child sessions.
+ * @returns - Session tracking controls whose selection is the first tracked top-level session still present;
+ * concurrent `track` calls are ordered by when `resolveSession` settles, not by call order.
+ */
+export declare function createBrokeredOpenCodeTargets(resolveSession: OpenCodeSessionResolver): {
+    current: () => string | undefined;
+    remove: (sessionId: string) => void;
+    track: (sessionId: string) => Promise<void>;
+};
+/**
+ * Build the system addition every pushed delivery carries, so the session learns how to settle it.
+ * @returns - Standing Pager guidance naming the acknowledgement tool as OpenCode exposes it.
+ */
+export declare function opencodeDeliverySystem(): string;
+/** Injects deliveries the broker pushed to the plugin's inbox into the selected OpenCode session. */
+export declare class OpenCodeInboundAdapter {
+    #private;
+    /**
+     * Constructs an OpenCode adapter over its prompt sender and session resolver.
+     * @param options - Prompt sender and session resolver; both required.
+     */
+    constructor(options: OpenCodeAdapterOptions);
+    /**
+     * Track an OpenCode session if it is a top-level delivery target.
+     * @param sessionId - OpenCode session id to evaluate and, if top-level, track.
+     */
+    trackSession(sessionId: string): Promise<void>;
+    /**
+     * Remove a deleted OpenCode session from delivery target selection.
+     * @param sessionId - OpenCode session id to drop from tracking.
+     */
+    removeSession(sessionId: string): void;
+    /**
+     * Return the selected top-level OpenCode session id.
+     * @returns - First tracked top-level session still present, ordered by when its resolution settled, when one is available.
+     */
+    currentSession(): string | undefined;
+    /** Refuse every later delivery, so the broker releases what it pushed and offers it again. */
+    stop(): void;
+    /**
+     * Inject one pushed delivery through OpenCode promptAsync, serialized to avoid OpenCode concurrent FIFO loss.
+     * @param content - Rendered delivery text, carrying claims or an operator ping.
+     * @returns - Resolves once OpenCode accepted the prompt; rejects when no session can take it, which
+     * the inbox reports to the broker as a refused delivery.
+     */
+    deliver(content: string): Promise<void>;
+}

package/dist/src/implementations/opencode/adapter.js

@@ -0,0 +1,94 @@
+import { ProtocolError } from "../../broker/protocol.js";
+import { pagerInboxGuidance } from "../../messaging/inbox-socket.js";
+/** Name OpenCode gives the acknowledgement tool of the MCP server the plugin registers as `pager`. */
+export const OPENCODE_ACK_TOOL = "pager_ack_agent_messages";
+/**
+ * Track only top-level OpenCode sessions, selecting the first whose resolution completed.
+ * @param resolveSession - Lookup used to distinguish top-level from child sessions.
+ * @returns - Session tracking controls whose selection is the first tracked top-level session still present;
+ * concurrent `track` calls are ordered by when `resolveSession` settles, not by call order.
+ */
+export function createBrokeredOpenCodeTargets(resolveSession) {
+    const sessionIds = [];
+    return {
+        current: () => sessionIds[0],
+        remove: (sessionId) => {
+            const index = sessionIds.indexOf(sessionId);
+            if (index !== -1)
+                sessionIds.splice(index, 1);
+        },
+        track: async (sessionId) => {
+            if (sessionIds.includes(sessionId))
+                return;
+            const session = await resolveSession(sessionId);
+            if (session && !session.parentID)
+                sessionIds.push(sessionId);
+        },
+    };
+}
+/**
+ * Build the system addition every pushed delivery carries, so the session learns how to settle it.
+ * @returns - Standing Pager guidance naming the acknowledgement tool as OpenCode exposes it.
+ */
+export function opencodeDeliverySystem() {
+    return ["Pager is active in this session.", ...pagerInboxGuidance(OPENCODE_ACK_TOOL)].join("\n");
+}
+/** Injects deliveries the broker pushed to the plugin's inbox into the selected OpenCode session. */
+export class OpenCodeInboundAdapter {
+    #prompt;
+    #targets;
+    #deliveryChain = Promise.resolve();
+    #draining = false;
+    /**
+     * Constructs an OpenCode adapter over its prompt sender and session resolver.
+     * @param options - Prompt sender and session resolver; both required.
+     */
+    constructor(options) {
+        this.#prompt = options.prompt;
+        this.#targets = createBrokeredOpenCodeTargets(options.resolveSession);
+    }
+    /**
+     * Track an OpenCode session if it is a top-level delivery target.
+     * @param sessionId - OpenCode session id to evaluate and, if top-level, track.
+     */
+    async trackSession(sessionId) {
+        await this.#targets.track(sessionId);
+    }
+    /**
+     * Remove a deleted OpenCode session from delivery target selection.
+     * @param sessionId - OpenCode session id to drop from tracking.
+     */
+    removeSession(sessionId) {
+        this.#targets.remove(sessionId);
+    }
+    /**
+     * Return the selected top-level OpenCode session id.
+     * @returns - First tracked top-level session still present, ordered by when its resolution settled, when one is available.
+     */
+    currentSession() {
+        return this.#targets.current();
+    }
+    /** Refuse every later delivery, so the broker releases what it pushed and offers it again. */
+    stop() {
+        this.#draining = true;
+    }
+    /**
+     * Inject one pushed delivery through OpenCode promptAsync, serialized to avoid OpenCode concurrent FIFO loss.
+     * @param content - Rendered delivery text, carrying claims or an operator ping.
+     * @returns - Resolves once OpenCode accepted the prompt; rejects when no session can take it, which
+     * the inbox reports to the broker as a refused delivery.
+     */
+    async deliver(content) {
+        const run = this.#deliveryChain.then(() => this.#deliverNow(content));
+        this.#deliveryChain = run.catch(() => { });
+        await run;
+    }
+    async #deliverNow(content) {
+        if (this.#draining)
+            throw new ProtocolError("conflict", "The OpenCode adapter has stopped");
+        const sessionId = this.#targets.current();
+        if (!sessionId)
+            throw new ProtocolError("conflict", "No top-level OpenCode session is available");
+        await this.#prompt(sessionId, opencodeDeliverySystem(), content);
+    }
+}

package/dist/src/implementations/opencode/environment.d.ts

@@ -0,0 +1,8 @@
+/** Names the broker endpoint supplied to the launched OpenCode process. */
+export declare const OPENCODE_BROKER_URL_ENVIRONMENT = "PAGER_MCP_URL";
+/** Names the reserved broker identity supplied to the launched OpenCode process. */
+export declare const OPENCODE_AGENT_ID_ENVIRONMENT = "PAGER_AGENT_ID";
+/** Names the single-use messaging attachment consumed by the MCP config's attach header. */
+export declare const OPENCODE_MESSAGING_RESERVATION_ENVIRONMENT = "PAGER_ATTACH_RESERVATION";
+/** Names the single-use delivery attachment supplied to the OpenCode plugin. */
+export declare const OPENCODE_DELIVERY_RESERVATION_ENVIRONMENT = "PAGER_PLUGIN_ATTACH_RESERVATION";

package/dist/src/implementations/opencode/environment.js

@@ -0,0 +1,9 @@
+import { PAGER_AGENT_ID_ENVIRONMENT, PAGER_ATTACH_RESERVATION_ENVIRONMENT, PAGER_MCP_URL_ENVIRONMENT, } from "../../launch/environment.js";
+/** Names the broker endpoint supplied to the launched OpenCode process. */
+export const OPENCODE_BROKER_URL_ENVIRONMENT = PAGER_MCP_URL_ENVIRONMENT;
+/** Names the reserved broker identity supplied to the launched OpenCode process. */
+export const OPENCODE_AGENT_ID_ENVIRONMENT = PAGER_AGENT_ID_ENVIRONMENT;
+/** Names the single-use messaging attachment consumed by the MCP config's attach header. */
+export const OPENCODE_MESSAGING_RESERVATION_ENVIRONMENT = PAGER_ATTACH_RESERVATION_ENVIRONMENT;
+/** Names the single-use delivery attachment supplied to the OpenCode plugin. */
+export const OPENCODE_DELIVERY_RESERVATION_ENVIRONMENT = "PAGER_PLUGIN_ATTACH_RESERVATION";

package/dist/src/implementations/opencode/manifest.d.ts

@@ -0,0 +1,30 @@
+import { type PagerInboxWriter } from "../../messaging/inbox-socket.js";
+import type { ImplementationProvider } from "../model.js";
+/** Resolves and writes what one OpenCode launch needs beyond its plan. */
+export type OpenCodeLaunchFilesPort = {
+    /** Names the Bun executable the launched session pins into its environment. */
+    runtimePath(): string;
+    /**
+     * Write one launch's MCP configuration where the launched process can read it.
+     * @param content - Serialised configuration document.
+     * @returns - Path of the written file, handed to OpenCode as `OPENCODE_CONFIG`.
+     */
+    writeLaunchConfig(content: string): string;
+};
+/** Ports {@link createOpenCodeImplementationProvider} composes its provider from. */
+export type OpenCodeImplementationProviderPorts = {
+    /** Injected installed-version reader. */
+    readVersion: () => string | null;
+    /** Runtime resolution and configuration file each launch plan depends on. */
+    launchFiles: OpenCodeLaunchFilesPort;
+    /** Connection that writes one delivery into a session's inbox. */
+    writeInbox: PagerInboxWriter;
+};
+/**
+ * Construct the built-in OpenCode implementation provider.
+ * @param ports - Version reader, launch-file, and inbox ports.
+ * @returns - Provider owning OpenCode integration behavior.
+ */
+export declare function createOpenCodeImplementationProvider({ readVersion, launchFiles, writeInbox, }: OpenCodeImplementationProviderPorts): ImplementationProvider;
+declare const _default: ImplementationProvider;
+export default _default;