@krischoichoi/channel-harness 0.6.0

package/lib/outbox/tool-send.js

@@ -0,0 +1,77 @@
+/**
+ * send_channel_message — the M6 Harness tool.
+ *
+ * Lets the model send a proactive message back to the channel conversation the
+ * CURRENT session is durably bound to. Parameters are ONLY `{ text?,
+ * attachment_id? }` — there is NO `recipient` / `channel` / `account` /
+ * `conversation` / `user_id` / `openid` / `file_path` (those
+ * fields must NOT exist in the parameter schema nor in the request type). The
+ * durable binding resolves the target.
+ *
+ * Agent-scoped registration: installSendChannelMessageTool registers
+ * through the official @deepseek-ai/dsh-tools ctx.tools.register on the agent's
+ * own scope, mirroring installReadChannelAttachmentTool.
+ */
+import { defineTool, ToolArgsError } from '@deepseek-ai/dsh-tools';
+/**
+ * The tool definition, ready to register on an Agent scope. Parameters are
+ * type-level guaranteed to be only `{ text?, attachment_id? }`.
+ */
+export function registerSendChannelMessageTool(options) {
+    const outbox = options.outbox;
+    return defineTool({
+        name: 'send_channel_message',
+        description: 'Send a proactive message to the channel conversation bound to the current session. ' +
+            'Supply text and/or an attachment_id; the destination is derived from the session binding.',
+        parameters: {
+            text: { type: 'string', description: 'Plain text to send.' },
+            attachment_id: {
+                type: 'string',
+                description: 'A stored channel attachment id to send using its stored media kind.',
+            },
+        },
+        output: {
+            schema: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    delivered: { type: 'boolean' },
+                    messageId: { type: 'string' },
+                },
+            },
+            render: (args, value) => {
+                const delivered = Boolean(value.delivered);
+                const messageId = typeof value.messageId === 'string' ? value.messageId : undefined;
+                const text = delivered
+                    ? 'Message sent to the channel' + (messageId ? ' (message id ' + messageId + ')' : '') + '.'
+                    : 'Message could not be delivered.';
+                return [{ type: 'text', text }];
+            },
+        },
+        async execute(args, exec) {
+            const sessionId = exec.agent ? String(exec.agent.id) : undefined;
+            if (sessionId === undefined) {
+                throw new ToolArgsError(['send_channel_message requires a session (no agent context)']);
+            }
+            if (!args.text && !args.attachment_id) {
+                throw new ToolArgsError([
+                    'send_channel_message requires at least one of: text, attachment_id',
+                ]);
+            }
+            const result = await outbox.send(sessionId, { text: args.text, attachmentId: args.attachment_id }, { signal: exec.signal });
+            const canonical = {
+                delivered: result.delivered,
+                ...(result.messageId ? { messageId: result.messageId } : {}),
+            };
+            return canonical;
+        },
+    });
+}
+/** Install the tool on an Agent scoped context (Agent-scoped registration). */
+export async function installSendChannelMessageTool(agentCtx, options) {
+    const fiber = agentCtx.inject(['tools'], function* sendToolScope(ctx) {
+        yield ctx.tools.register(registerSendChannelMessageTool(options));
+    });
+    await fiber.await().then(() => undefined);
+}
+//# sourceMappingURL=tool-send.js.map

package/lib/outbox/tool-send.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-send.js","sourceRoot":"","sources":["../../src/outbox/tool-send.ts"],"names":[],"mappings":"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"}

package/lib/outbox/types.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Durable outbox types.
+ *
+ * A channel send request is deliberately MINIMAL: the model supplies only
+ * content (`text` and/or `attachment_id`). The durable binding resolves the
+ * recipient/target; the model NEVER names a `recipient` / `channel` /
+ * `account` / `conversation` / `user_id` / `openid` / `file_path`
+ * (those fields must not exist on the request type).
+ *
+ * An outbound attachment is referenced by its private-store `attachment_id`,
+ * never by a model-visible `file_path` (V1 model tools do not
+ * provide `file_path`; there is no path handling anywhere in this module).
+ */
+import { HarnessError } from '@deepseek-ai/dsh-llm';
+/**
+ * One outbound channel send request. At least one of `text` / `attachmentId`
+ * must be set; `text` and `attachmentId` may be combined in a single send.
+ */
+export interface ChannelOutboundRequest {
+    /** Plain text payload. */
+    text?: string;
+    /** Private-store attachment id whose bytes are sent using its stored media kind. */
+    attachmentId?: string;
+}
+/**
+ * Stable, machine-routable outbox failure codes. Tool results route on `code`, never on `message`.
+ */
+export type OutboxErrorCode = 'OUTBOX_NO_BINDING' | 'OUTBOX_AMBIGUOUS_BINDING' | 'OUTBOX_CAPABILITY_UNAVAILABLE' | 'ATTACHMENT_NOT_FOUND' | 'ATTACHMENT_ACCESS_DENIED' | 'ATTACHMENT_TOO_LARGE';
+/**
+ * Typed outbox failure carried as a `HarnessError` (mirrors the M4
+ * `AttachmentReadError` pattern in tool-read.ts) so the tool pipeline records
+ * a stable machine-routable `code`. Carries the session id it was raised for
+ * as an optional diagnostic.
+ */
+export declare class OutboxError extends HarnessError {
+    readonly sessionId?: string;
+    constructor(code: OutboxErrorCode, message: string, options?: {
+        sessionId?: string;
+        cause?: unknown;
+    });
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/outbox/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/outbox/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEpD;;;GAGG;AACH,MAAM,WAAW,sBAAsB;IACrC,0BAA0B;IAC1B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,oFAAoF;IACpF,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,MAAM,eAAe,GACvB,mBAAmB,GACnB,0BAA0B,GAC1B,+BAA+B,GAC/B,sBAAsB,GACtB,0BAA0B,GAC1B,sBAAsB,CAAC;AAE3B;;;;;GAKG;AACH,qBAAa,WAAY,SAAQ,YAAY;IAC3C,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;gBAChB,IAAI,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE;CAKtG"}

package/lib/outbox/types.js

@@ -0,0 +1,30 @@
+/**
+ * Durable outbox types.
+ *
+ * A channel send request is deliberately MINIMAL: the model supplies only
+ * content (`text` and/or `attachment_id`). The durable binding resolves the
+ * recipient/target; the model NEVER names a `recipient` / `channel` /
+ * `account` / `conversation` / `user_id` / `openid` / `file_path`
+ * (those fields must not exist on the request type).
+ *
+ * An outbound attachment is referenced by its private-store `attachment_id`,
+ * never by a model-visible `file_path` (V1 model tools do not
+ * provide `file_path`; there is no path handling anywhere in this module).
+ */
+import { HarnessError } from '@deepseek-ai/dsh-llm';
+/**
+ * Typed outbox failure carried as a `HarnessError` (mirrors the M4
+ * `AttachmentReadError` pattern in tool-read.ts) so the tool pipeline records
+ * a stable machine-routable `code`. Carries the session id it was raised for
+ * as an optional diagnostic.
+ */
+export class OutboxError extends HarnessError {
+    sessionId;
+    constructor(code, message, options) {
+        super(message, code, options?.cause !== undefined ? { cause: options.cause } : undefined);
+        this.name = 'OutboxError';
+        if (options?.sessionId !== undefined)
+            this.sessionId = options.sessionId;
+    }
+}
+//# sourceMappingURL=types.js.map

package/lib/outbox/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/outbox/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAwBpD;;;;;GAKG;AACH,MAAM,OAAO,WAAY,SAAQ,YAAY;IAClC,SAAS,CAAU;IAC5B,YAAY,IAAqB,EAAE,OAAe,EAAE,OAAiD;QACnG,KAAK,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;QAC1F,IAAI,CAAC,IAAI,GAAG,aAAa,CAAC;QAC1B,IAAI,OAAO,EAAE,SAAS,KAAK,SAAS;YAAE,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC,SAAS,CAAC;IAC3E,CAAC;CACF"}

package/lib/plugin.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Cordis plugin entry for the channel-harness bridge (doc §30 / H0.6).
+ *
+ * The plugin injects `channels` (ChannelService), `agents` (AgentRegistry),
+ * `agentDefaultModel`, `agentPresets`, `llm`, and `commands` (CommandRuntime).
+ * `sessionPersistence` and the question transports are
+ * NOT required: they are optional capabilities resolved LIVE at the use site
+ * (a resolver passed into the gateway), so probes reflect whether the service
+ * is present at probe time — including mounts/unmounts after startup.
+ * `commands` is a required capability (no optional fallback) so the bridge can
+ * install Agent-scoped channel commands.
+ *
+ * `userQuestions` is deliberately absent from the PLUGIN's own `inject`: the
+ * channel composes its answerer on the official `user-questions/request`
+ * waterfall and only probes the service for diagnostics (see
+ * `interactions/question-backend.ts`). Listener ORDER is a contract there, so
+ * the answerer is prepended rather than relying on fiber order.
+ *
+ * The whole bridge lifecycle is registered as one `ctx.effect` whose disposer
+ * is the teardown chain from `startBridge`.
+ */
+import { type Context } from '@deepseek-ai/cordis';
+import type { Config } from './config.js';
+export declare const name = "channel-harness";
+export declare const inject: string[];
+export declare function apply(ctx: Context, config: Config): void;
+//# sourceMappingURL=plugin.d.ts.map

package/lib/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAG1C,eAAO,MAAM,IAAI,oBAAoB,CAAC;AAMtC,eAAO,MAAM,MAAM,EAAE,MAAM,EAO1B,CAAC;AAEF,wBAAgB,KAAK,CAAC,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CASxD"}

package/lib/plugin.js

@@ -0,0 +1,47 @@
+/**
+ * Cordis plugin entry for the channel-harness bridge (doc §30 / H0.6).
+ *
+ * The plugin injects `channels` (ChannelService), `agents` (AgentRegistry),
+ * `agentDefaultModel`, `agentPresets`, `llm`, and `commands` (CommandRuntime).
+ * `sessionPersistence` and the question transports are
+ * NOT required: they are optional capabilities resolved LIVE at the use site
+ * (a resolver passed into the gateway), so probes reflect whether the service
+ * is present at probe time — including mounts/unmounts after startup.
+ * `commands` is a required capability (no optional fallback) so the bridge can
+ * install Agent-scoped channel commands.
+ *
+ * `userQuestions` is deliberately absent from the PLUGIN's own `inject`: the
+ * channel composes its answerer on the official `user-questions/request`
+ * waterfall and only probes the service for diagnostics (see
+ * `interactions/question-backend.ts`). Listener ORDER is a contract there, so
+ * the answerer is prepended rather than relying on fiber order.
+ *
+ * The whole bridge lifecycle is registered as one `ctx.effect` whose disposer
+ * is the teardown chain from `startBridge`.
+ */
+import {} from '@deepseek-ai/cordis';
+import { startBridge } from './lifecycle.js';
+export const name = 'channel-harness';
+// `agentDefaultModel` is the Harness default-model service: an agent created
+// without an explicit provider/model (the channel `agent.default` route) must
+// inherit the user's Harness-wide default model so the `{{model}}` persona
+// variable always resolves. See `resolveRoute` in agent-manager.ts.
+export const inject = [
+    'channels',
+    'agents',
+    'agentDefaultModel',
+    'agentPresets',
+    'llm',
+    'commands',
+];
+export function apply(ctx, config) {
+    ctx.effect(() => {
+        // Optional service resolved LIVE at the use site (never required): the
+        // resolver is re-queried on every probe, so a sessionPersistence mounted,
+        // unmounted, or replaced AFTER the bridge started is observed on the next
+        // `canResume()` / existence probe (no startup snapshot).
+        const lifecycle = startBridge(ctx, config, () => ctx.get('sessionPersistence'));
+        return () => lifecycle.dispose();
+    });
+}
+//# sourceMappingURL=plugin.js.map

package/lib/plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.js","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,EAAgB,MAAM,qBAAqB,CAAC;AAEnD,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAE7C,MAAM,CAAC,MAAM,IAAI,GAAG,iBAAiB,CAAC;AAEtC,6EAA6E;AAC7E,8EAA8E;AAC9E,2EAA2E;AAC3E,oEAAoE;AACpE,MAAM,CAAC,MAAM,MAAM,GAAa;IAC9B,UAAU;IACV,QAAQ;IACR,mBAAmB;IACnB,cAAc;IACd,KAAK;IACL,UAAU;CACX,CAAC;AAEF,MAAM,UAAU,KAAK,CAAC,GAAY,EAAE,MAAc;IAChD,GAAG,CAAC,MAAM,CAAC,GAAG,EAAE;QACd,uEAAuE;QACvE,0EAA0E;QAC1E,0EAA0E;QAC1E,yDAAyD;QACzD,MAAM,SAAS,GAAG,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,oBAAoB,CAAC,CAAC,CAAC;QAChF,OAAO,GAAG,EAAE,CAAC,SAAS,CAAC,OAAO,EAAE,CAAC;IACnC,CAAC,CAAC,CAAC;AACL,CAAC"}

package/lib/reply-context-store.d.ts

@@ -0,0 +1,69 @@
+/**
+ * `ReplyContextStore` — carries the transient per-turn reply context from an
+ * inbound message to the outbound reply target.
+ *
+ * The triggering message id (and the conversation kind it came from) belongs
+ * to one user-message ↔ one agent-turn pair, so it is *never* persisted on a
+ * `SessionBinding` (which models the durable conversation ↔ session relation).
+ * Instead the correlation is established with the Harness `MessageId`:
+ *
+ * 1. The bridge converts the inbound message to a Harness `UserMessage`
+ *    (`createUserMessage` assigns a fresh stable `MessageId`) and *registers*
+ *    a pending context keyed by that message id, strictly BEFORE `followup`.
+ * 2. Harness drives the message through the agent inbox; when the agent loop
+ *    actually picks it up, `agent/inbox/claimed { agent, message, turn }`
+ *    fires, and the store *claims* the pending context by `message.id`,
+ *    moving it to the active slot for `sessionId`+`turn`.
+ * 3. `agent/assistant-stream` / `assistant/message` (which only flow after the claim)
+ *    resolve the active context lazily via `getTurn`, so the reply target is
+ *    bound exactly once per message-id — never via a session FIFO guessed at
+ *    `turn/start`.
+ * 4. `turn/end` releases the active context; `agent/inbox/discarded` drops a
+ *    pending context that never became a turn (prevents leaks).
+ */
+export interface ChannelReplyContext {
+    conversationType: 'dm' | 'group';
+    /** Authorized sender that initiated this turn. */
+    senderId?: string;
+    replyToMessageId?: string;
+    raw?: unknown;
+    /**
+     * Turn-scoped correlation id. Mined once per inbound turn and shared by every
+     * outbound send scoped to that turn, so the platform (e.g. Weixin run_id)
+     * sees ONE stable correlation instead of a fresh UUID per sender call.
+     */
+    runId?: string;
+}
+export declare class ReplyContextStore {
+    /** MessageId → pending context waiting for its `agent/inbox/claimed`. */
+    private readonly pendingByMessageId;
+    /** `${sessionId}:${turn}` → active context for that turn. */
+    private readonly activeByTurn;
+    /** Register a context for one Harness UserMessage id (call BEFORE followup). */
+    register(messageId: string, pending: {
+        sessionId: string;
+        context: ChannelReplyContext;
+    }): void;
+    /** Move pendingByMessageId[messageId] → activeByTurn[sessionId:turn]; delete the pending entry. */
+    claim(input: {
+        sessionId: string;
+        messageId: string;
+        turn: number;
+    }): ChannelReplyContext | undefined;
+    /** Drop a pending context by message id (agent/inbox/discarded) — prevents leaks. */
+    discard(messageId: string): void;
+    /** Session id of a still-pending context, if any (used to cancel typing on discard). */
+    pendingSessionId(messageId: string): string | undefined;
+    /** Pending context before discard, used to stop target-bound indicators. */
+    pendingContext(messageId: string): ChannelReplyContext | undefined;
+    /** Active context for sessionId+turn, if any. */
+    getTurn(sessionId: string, turn: number): ChannelReplyContext | undefined;
+    /** Active context for a single-flight Agent session, including its turn. */
+    getActiveForSession(sessionId: string): {
+        turn: number;
+        context: ChannelReplyContext;
+    } | undefined;
+    /** Drop the active context for sessionId+turn (turn/end cleanup). */
+    releaseTurn(sessionId: string, turn: number): void;
+}
+//# sourceMappingURL=reply-context-store.d.ts.map

package/lib/reply-context-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reply-context-store.d.ts","sourceRoot":"","sources":["../src/reply-context-store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,MAAM,WAAW,mBAAmB;IAClC,gBAAgB,EAAE,IAAI,GAAG,OAAO,CAAC;IACjC,kDAAkD;IAClD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,GAAG,CAAC,EAAE,OAAO,CAAC;IACd;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,qBAAa,iBAAiB;IAC5B,yEAAyE;IACzE,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAG/B;IACJ,6DAA6D;IAC7D,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA0C;IAEvE,gFAAgF;IAChF,QAAQ,CACN,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,mBAAmB,CAAA;KAAE,GAC3D,IAAI;IAIP,mGAAmG;IACnG,KAAK,CAAC,KAAK,EAAE;QACX,SAAS,EAAE,MAAM,CAAC;QAClB,SAAS,EAAE,MAAM,CAAC;QAClB,IAAI,EAAE,MAAM,CAAC;KACd,GAAG,mBAAmB,GAAG,SAAS;IAQnC,qFAAqF;IACrF,OAAO,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAIhC,wFAAwF;IACxF,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAIvD,4EAA4E;IAC5E,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,mBAAmB,GAAG,SAAS;IAIlE,iDAAiD;IACjD,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,mBAAmB,GAAG,SAAS;IAIzE,4EAA4E;IAC5E,mBAAmB,CACjB,SAAS,EAAE,MAAM,GAChB;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,mBAAmB,CAAA;KAAE,GAAG,SAAS;IAU7D,qEAAqE;IACrE,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;CAGnD"}

package/lib/reply-context-store.js

@@ -0,0 +1,75 @@
+/**
+ * `ReplyContextStore` — carries the transient per-turn reply context from an
+ * inbound message to the outbound reply target.
+ *
+ * The triggering message id (and the conversation kind it came from) belongs
+ * to one user-message ↔ one agent-turn pair, so it is *never* persisted on a
+ * `SessionBinding` (which models the durable conversation ↔ session relation).
+ * Instead the correlation is established with the Harness `MessageId`:
+ *
+ * 1. The bridge converts the inbound message to a Harness `UserMessage`
+ *    (`createUserMessage` assigns a fresh stable `MessageId`) and *registers*
+ *    a pending context keyed by that message id, strictly BEFORE `followup`.
+ * 2. Harness drives the message through the agent inbox; when the agent loop
+ *    actually picks it up, `agent/inbox/claimed { agent, message, turn }`
+ *    fires, and the store *claims* the pending context by `message.id`,
+ *    moving it to the active slot for `sessionId`+`turn`.
+ * 3. `agent/assistant-stream` / `assistant/message` (which only flow after the claim)
+ *    resolve the active context lazily via `getTurn`, so the reply target is
+ *    bound exactly once per message-id — never via a session FIFO guessed at
+ *    `turn/start`.
+ * 4. `turn/end` releases the active context; `agent/inbox/discarded` drops a
+ *    pending context that never became a turn (prevents leaks).
+ */
+export class ReplyContextStore {
+    /** MessageId → pending context waiting for its `agent/inbox/claimed`. */
+    pendingByMessageId = new Map();
+    /** `${sessionId}:${turn}` → active context for that turn. */
+    activeByTurn = new Map();
+    /** Register a context for one Harness UserMessage id (call BEFORE followup). */
+    register(messageId, pending) {
+        this.pendingByMessageId.set(messageId, pending);
+    }
+    /** Move pendingByMessageId[messageId] → activeByTurn[sessionId:turn]; delete the pending entry. */
+    claim(input) {
+        const pending = this.pendingByMessageId.get(input.messageId);
+        if (!pending)
+            return undefined;
+        this.pendingByMessageId.delete(input.messageId);
+        this.activeByTurn.set(`${input.sessionId}:${input.turn}`, pending.context);
+        return pending.context;
+    }
+    /** Drop a pending context by message id (agent/inbox/discarded) — prevents leaks. */
+    discard(messageId) {
+        this.pendingByMessageId.delete(messageId);
+    }
+    /** Session id of a still-pending context, if any (used to cancel typing on discard). */
+    pendingSessionId(messageId) {
+        return this.pendingByMessageId.get(messageId)?.sessionId;
+    }
+    /** Pending context before discard, used to stop target-bound indicators. */
+    pendingContext(messageId) {
+        return this.pendingByMessageId.get(messageId)?.context;
+    }
+    /** Active context for sessionId+turn, if any. */
+    getTurn(sessionId, turn) {
+        return this.activeByTurn.get(`${sessionId}:${turn}`);
+    }
+    /** Active context for a single-flight Agent session, including its turn. */
+    getActiveForSession(sessionId) {
+        const prefix = `${sessionId}:`;
+        for (const [key, context] of this.activeByTurn) {
+            if (!key.startsWith(prefix))
+                continue;
+            const turn = Number(key.slice(prefix.length));
+            if (Number.isSafeInteger(turn))
+                return { turn, context };
+        }
+        return undefined;
+    }
+    /** Drop the active context for sessionId+turn (turn/end cleanup). */
+    releaseTurn(sessionId, turn) {
+        this.activeByTurn.delete(`${sessionId}:${turn}`);
+    }
+}
+//# sourceMappingURL=reply-context-store.js.map

package/lib/reply-context-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reply-context-store.js","sourceRoot":"","sources":["../src/reply-context-store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAgBH,MAAM,OAAO,iBAAiB;IAC5B,yEAAyE;IACxD,kBAAkB,GAAG,IAAI,GAAG,EAG1C,CAAC;IACJ,6DAA6D;IAC5C,YAAY,GAAG,IAAI,GAAG,EAA+B,CAAC;IAEvE,gFAAgF;IAChF,QAAQ,CACN,SAAiB,EACjB,OAA4D;QAE5D,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;IAClD,CAAC;IAED,mGAAmG;IACnG,KAAK,CAAC,KAIL;QACC,MAAM,OAAO,GAAG,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;QAC7D,IAAI,CAAC,OAAO;YAAE,OAAO,SAAS,CAAC;QAC/B,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;QAChD,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,SAAS,IAAI,KAAK,CAAC,IAAI,EAAE,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;QAC3E,OAAO,OAAO,CAAC,OAAO,CAAC;IACzB,CAAC;IAED,qFAAqF;IACrF,OAAO,CAAC,SAAiB;QACvB,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;IAC5C,CAAC;IAED,wFAAwF;IACxF,gBAAgB,CAAC,SAAiB;QAChC,OAAO,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,SAAS,CAAC;IAC3D,CAAC;IAED,4EAA4E;IAC5E,cAAc,CAAC,SAAiB;QAC9B,OAAO,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;IACzD,CAAC;IAED,iDAAiD;IACjD,OAAO,CAAC,SAAiB,EAAE,IAAY;QACrC,OAAO,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,GAAG,SAAS,IAAI,IAAI,EAAE,CAAC,CAAC;IACvD,CAAC;IAED,4EAA4E;IAC5E,mBAAmB,CACjB,SAAiB;QAEjB,MAAM,MAAM,GAAG,GAAG,SAAS,GAAG,CAAC;QAC/B,KAAK,MAAM,CAAC,GAAG,EAAE,OAAO,CAAC,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;YAC/C,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,MAAM,CAAC;gBAAE,SAAS;YACtC,MAAM,IAAI,GAAG,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;YAC9C,IAAI,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC;gBAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC;QAC3D,CAAC;QACD,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,qEAAqE;IACrE,WAAW,CAAC,SAAiB,EAAE,IAAY;QACzC,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,GAAG,SAAS,IAAI,IAAI,EAAE,CAAC,CAAC;IACnD,CAAC;CACF"}

package/lib/reply-router.d.ts

@@ -0,0 +1,138 @@
+/**
+ * ReplyRouter — the outbound reply pipeline (architecture §19).
+ *
+ * Consumes only official `session/event` records:
+ * - `assistant/message.stream` is the V3 durable stream source and feeds the
+ *   reply buffer;
+ * - `assistant/message` content provides the final fallback text;
+ * - `turn/end` flushes and finishes the reply, then cleans up.
+ *
+ * Strategy comes from the adapter's resolved streaming mode, which may be
+ * target-aware (via `adapter.resolveStreamingMode(target)` falling back to the
+ * static `adapter.capabilities.streaming`):
+ * - `native`  — `adapter.createReply` + `handle.append` (throttled previews);
+ * - `edit`    — `adapter.createReply` + `handle.replace` (throttled previews);
+ * - `buffered` — accumulate and send once via `adapter.send` at `turn/end`
+ *   (throttling is irrelevant for a send-once strategy).
+ * An adapter without `createReply` is always `buffered`.
+ *
+ * The reply target is resolved by reversing `sessionId -> SessionBinding`,
+ * never by inspecting the agent itself. Per-turn reply context (conversation
+ * type + triggering message id) comes from the shared `ReplyContextStore`.
+ *
+ * The two concepts are deliberately separated (core hardening):
+ * - `SessionBinding` answers "WHERE would a reply go" (the channel
+ *   conversation ↔ session relation). It does NOT authorize outbound.
+ * - `ReplyContext` answers "SHOULD this turn go back to the channel" — a turn
+ *   is only routed when the store has an active context for `sessionId:turn`,
+ *   which exists only because the turn was triggered by a channel inbound
+ *   message (`register` → `agent/inbox/claimed` → `getTurn`).
+ * Both are required: a turn driven by Web UI / CLI / steer / another plugin
+ * on a channel-bound session has no `ReplyContext`, so it is never delivered
+ * back to the channel.
+ *
+ * - `turn/start` only establishes turn existence (no active reply);
+ * - `assistant/message` requires an active `ReplyContext`
+ *   (authoritative by then because `agent/inbox/claimed` fired first) and
+ *   otherwise drop the output;
+ * - `turn/end` releases the active context via `releaseTurn`.
+ * The target passed to `createReply`/`send` carries the context so
+ * target-aware adapters (e.g. QQ C2C native streaming) behave correctly.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent, AssistantStreamFrame } from '@deepseek-ai/dsh-agent';
+import type { Session, SessionEvent } from '@deepseek-ai/dsh-session';
+import type { ChannelAdapter, ChannelLogger } from '@krischoichoi/channel-core';
+import type { ReplyConfig } from './config.js';
+import type { SessionBinding } from './session-router.js';
+import type { ReplyContextStore } from './reply-context-store.js';
+export interface ReplyRouterOptions {
+    config: ReplyConfig;
+    getAdapter(channelId: string): ChannelAdapter | undefined;
+    getBinding(sessionId: string): SessionBinding | undefined;
+    replyContexts: ReplyContextStore;
+    logger: ChannelLogger;
+}
+export declare class ReplyRouter {
+    private readonly options;
+    private readonly active;
+    private readonly streamTurns;
+    constructor(options: ReplyRouterOptions);
+    /** Register the `session/event` listener; returns a disposer. */
+    attach(ctx: Context): () => boolean;
+    /** Consume transient V3 stream frames for native/edit previews. */
+    onAssistantStream(agent: Agent, frame: AssistantStreamFrame): void;
+    /** Testable entry point; the registered listener delegates here. */
+    onSessionEvent(session: Session, event: SessionEvent): void;
+    /** Session ids with an in-flight reply (used by the lifecycle drain). */
+    activeSessions(): string[];
+    /**
+     * Finalize every reply still marked active, exactly like `turn/end` would.
+     * Turns still streaming at unload never deliver `turn/end`, so the lifecycle
+     * drain calls this after `whenIdle` to guarantee buffered/final text is
+     * delivered (or the reply handle fails) instead of being dropped.
+     */
+    flushAll(): Promise<void>;
+    /**
+     * Durable-log reconcile (doc §4.3 / §4.4): deliver the final assistant text
+     * for the last unfinished turn straight from the Session durable log, even
+     * when the `session/event` listener is no longer attached.
+     *
+     * Finds the last `turn/start` with no matching `turn/end`; if the
+     * ReplyRouter already holds an active reply for it, finalizes normally.
+     * Otherwise it rebuilds the assistant text from each V3
+     * `assistant/message.stream` (falling back to the message text) and delivers it via `adapter.send` (buffered
+     * strategy), then finishes/cleans up. The Session log is the ONLY source of
+     * transcript truth — reconcile never maintains a second copy.
+     */
+    reconcileSession(session: {
+        id: string;
+        events: readonly SessionEvent[];
+    }): Promise<void>;
+    /** Clear all timers and drop active replies. */
+    dispose(): void;
+    private ensureActive;
+    /**
+     * Mirror tracking for a non-channel turn (issue #5): only when the bound
+     * conversation opted in (`binding.mirror === true`) does the router attach
+     * a buffered-only reply that delivers the final assistant text to the bound
+     * conversation at `turn/end`. Everything else stays unrouted. The synthetic
+     * context carries NO platform state (no replyToMessageId / raw / runId) —
+     * the binding's stable identity is the sole delivery address.
+     */
+    private ensureMirrorActive;
+    private appendText;
+    /**
+     * Enqueue a preview flush. Deltas are drained through a single in-flight
+     * chain so concurrent deltas can never double-`createReply` on the same
+     * reply; the chain reads the current buffer at execution time, so a flush
+     * that started before the newest delta still covers it.
+     */
+    private flush;
+    /** Drain all pending deltas, flushing until the buffer is fully sent. */
+    private drain;
+    private doFlush;
+    private resolveTurnTarget;
+    private finishTurn;
+    /**
+     * Finalize one active reply: clear its timer, drain any in-flight preview
+     * chain, deliver the accumulated text (or fail the handle), and release the
+     * active reply context for its turn (v1.1 §20). Shared by `turn/end`
+     * handling and the lifecycle `flushAll()` so an unloaded turn is finalized
+     * exactly like a completed one.
+     */
+    private finalize;
+    private stopTypingIfSupported;
+    private deliver;
+}
+/**
+ * Split a long message into `maxLength`-bounded pieces, keeping fenced code
+ * blocks whole and preferring paragraph boundaries. `finalFlush: false`
+ * drops a trailing partial piece instead of delivering it.
+ */
+export declare function splitMessage(text: string, maxLength: number, config: {
+    splitParagraphs: boolean;
+    splitCodeBlocks: boolean;
+    finalFlush: boolean;
+}): string[];
+//# sourceMappingURL=reply-router.d.ts.map

package/lib/reply-router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reply-router.d.ts","sourceRoot":"","sources":["../src/reply-router.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,KAAK,EAAE,KAAK,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC1E,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAiB,MAAM,0BAA0B,CAAC;AAErF,OAAO,KAAK,EACV,cAAc,EACd,aAAa,EAGd,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,KAAK,EAAuB,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAkCvF,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,WAAW,CAAC;IACpB,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS,CAAC;IAC1D,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS,CAAC;IAC1D,aAAa,EAAE,iBAAiB,CAAC;IACjC,MAAM,EAAE,aAAa,CAAC;CACvB;AAED,qBAAa,WAAW;IAIV,OAAO,CAAC,QAAQ,CAAC,OAAO;IAHpC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAkC;IACzD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA6B;gBAE5B,OAAO,EAAE,kBAAkB;IAExD,iEAAiE;IACjE,MAAM,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,OAAO;IAUnC,mEAAmE;IACnE,iBAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,oBAAoB,GAAG,IAAI;IAiBlE,oEAAoE;IACpE,cAAc,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,YAAY,GAAG,IAAI;IA8B3D,yEAAyE;IACzE,cAAc,IAAI,MAAM,EAAE;IAI1B;;;;;OAKG;IACG,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAO/B;;;;;;;;;;;OAWG;IACG,gBAAgB,CAAC,OAAO,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,SAAS,YAAY,EAAE,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAiE/F,gDAAgD;IAChD,OAAO,IAAI,IAAI;IASf,OAAO,CAAC,YAAY;IA6DpB;;;;;;;OAOG;IACH,OAAO,CAAC,kBAAkB;IAoC1B,OAAO,CAAC,UAAU;IAqBlB;;;;;OAKG;IACH,OAAO,CAAC,KAAK;IASb,yEAAyE;YAC3D,KAAK;YASL,OAAO;IA+BrB,OAAO,CAAC,iBAAiB;YA4BX,UAAU;IAiExB;;;;;;OAMG;YACW,QAAQ;IAsDtB,OAAO,CAAC,qBAAqB;YASf,OAAO;CAgBtB;AAgFD;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE;IAAE,eAAe,EAAE,OAAO,CAAC;IAAC,eAAe,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,OAAO,CAAA;CAAE,GAClF,MAAM,EAAE,CAqBV"}