@kuralle-agents/engagement 0.3.0

package/dist/drip.d.ts

@@ -0,0 +1,26 @@
+import type { SessionStore } from '@kuralle-agents/core';
+import type { OutboundPipeline, OutboundTemplate, WindowStore } from '@kuralle-agents/messaging';
+import type { Scheduler, SendJob } from './scheduler.js';
+export declare const DRIP_WM_KEY = "__dripCampaign";
+export interface DripStep {
+    template: OutboundTemplate;
+    delayMs: number;
+}
+export interface DripCampaignState {
+    id: string;
+    step: number;
+    stoppedOnReply?: boolean;
+}
+export interface DripApi {
+    scheduleNext(threadId: string, step: DripStep): Promise<string | null>;
+    stopOnReply(threadId: string): Promise<void>;
+    /** Wire into `createInProcessScheduler({ run: drip.runJob })`. */
+    runJob(job: SendJob): Promise<void>;
+}
+export declare function createDrip(opts: {
+    scheduler: Scheduler;
+    pipeline: OutboundPipeline;
+    sessionStore: SessionStore;
+    platform: string;
+    windowStore?: WindowStore;
+}): DripApi;

package/dist/drip.js

@@ -0,0 +1,94 @@
+export const DRIP_WM_KEY = '__dripCampaign';
+function loadCampaign(session) {
+    const raw = session.workingMemory[DRIP_WM_KEY];
+    if (!raw || typeof raw !== 'object')
+        return undefined;
+    return raw;
+}
+async function loadOrCreateSession(sessionStore, threadId) {
+    const existing = await sessionStore.get(threadId);
+    if (existing)
+        return existing;
+    const now = new Date();
+    return {
+        id: threadId,
+        conversationId: threadId,
+        channelId: 'api',
+        createdAt: now,
+        updatedAt: now,
+        messages: [],
+        workingMemory: {},
+        currentAgent: 'main',
+        agentStates: {},
+        handoffHistory: [],
+        metadata: {
+            createdAt: now,
+            lastActiveAt: now,
+            totalTokens: 0,
+            totalSteps: 0,
+            handoffHistory: [],
+        },
+    };
+}
+export function createDrip(opts) {
+    async function runJob(job) {
+        if (job.kind !== 'drip-step')
+            return;
+        const threadId = job.payload.threadId;
+        const template = job.payload.template;
+        if (typeof threadId !== 'string' || !template || typeof template !== 'object')
+            return;
+        const session = await opts.sessionStore.get(threadId);
+        if (session) {
+            const campaign = loadCampaign(session);
+            if (campaign?.stoppedOnReply)
+                return;
+        }
+        const window = opts.windowStore
+            ? await opts.windowStore.get(threadId)
+            : { open: false, expiresAt: null };
+        await opts.pipeline.send({
+            threadId,
+            platform: opts.platform,
+            payload: { kind: 'template', template: template },
+            meta: {
+                window,
+                parts: [],
+                sessionId: threadId,
+                userId: typeof job.payload.userId === 'string' ? job.payload.userId : undefined,
+            },
+        });
+    }
+    return {
+        runJob,
+        async scheduleNext(threadId, step) {
+            const session = await loadOrCreateSession(opts.sessionStore, threadId);
+            const campaign = loadCampaign(session);
+            if (campaign?.stoppedOnReply)
+                return null;
+            const nextCampaign = {
+                id: campaign?.id ?? threadId,
+                step: (campaign?.step ?? 0) + 1,
+                stoppedOnReply: campaign?.stoppedOnReply,
+            };
+            session.workingMemory[DRIP_WM_KEY] = nextCampaign;
+            session.updatedAt = new Date();
+            await opts.sessionStore.save(session);
+            return opts.scheduler.enqueue({
+                kind: 'drip-step',
+                payload: {
+                    threadId,
+                    template: step.template,
+                    platform: opts.platform,
+                },
+            }, { delayMs: step.delayMs });
+        },
+        async stopOnReply(threadId) {
+            const session = await loadOrCreateSession(opts.sessionStore, threadId);
+            const campaign = loadCampaign(session) ?? { id: threadId, step: 0 };
+            session.workingMemory[DRIP_WM_KEY] = { ...campaign, stoppedOnReply: true };
+            session.updatedAt = new Date();
+            await opts.sessionStore.save(session);
+        },
+    };
+}

package/dist/engagement.d.ts

@@ -0,0 +1,22 @@
+import type { ChannelPolicy } from './policy.js';
+import type { ConsentStore, OwnershipStore, WindowStore, InboundResolverPlugin, MessagingRouterConfig, OutboundPipeline } from '@kuralle-agents/messaging';
+import { type BroadcastApi } from './broadcast.js';
+import { type BroadcastLedger } from './broadcast-ledger.js';
+import type { AuditSink } from './strategist.js';
+import type { Scheduler } from './scheduler.js';
+export interface EngagementOptions {
+    policies: ChannelPolicy[];
+    consent?: ConsentStore;
+    ownership?: OwnershipStore;
+    audit?: AuditSink;
+    scheduler?: Scheduler;
+    windowStore?: WindowStore;
+    ledger?: BroadcastLedger;
+    broadcastPipeline?: OutboundPipeline;
+}
+export type EngagementBridge = Pick<MessagingRouterConfig, 'outbound' | 'inputResolver' | 'windowStore' | 'ownership' | 'consent' | 'onStatus'>;
+export declare function policyInboundResolver(policies: ChannelPolicy[]): InboundResolverPlugin;
+export declare function engagement(opts: EngagementOptions): {
+    bridge: EngagementBridge;
+    broadcasts: BroadcastApi;
+};

package/dist/engagement.js

@@ -0,0 +1,66 @@
+import { InMemoryWindowStore } from '@kuralle-agents/messaging';
+import { consentGate } from './consent.js';
+import { ownershipGate } from './ownership.js';
+import { closedWindowRecovery } from './closed-window-recovery.js';
+import { interactiveRenderer } from './interactive-renderer.js';
+import { createBroadcasts } from './broadcast.js';
+import { createInMemoryBroadcastLedger } from './broadcast-ledger.js';
+function alwaysOptedIn() {
+    return {
+        isOptedIn: async () => true,
+        optIn: async () => { },
+        optOut: async () => { },
+    };
+}
+export function policyInboundResolver(policies) {
+    return {
+        name: 'policy-inbound',
+        async tryResolve(m) {
+            const policy = policies.find((p) => p.channel === m.platform);
+            if (!policy)
+                return undefined;
+            return policy.resolveInbound(m);
+        },
+    };
+}
+function createBroadcastApi(opts) {
+    if (!opts.broadcastPipeline) {
+        return {
+            async send() {
+                throw new Error('no broadcast pipeline configured');
+            },
+        };
+    }
+    return createBroadcasts({
+        pipeline: opts.broadcastPipeline,
+        consent: opts.consent,
+        ledger: opts.ledger,
+        platform: opts.platform,
+    });
+}
+export function engagement(opts) {
+    const windowStore = opts.windowStore ?? new InMemoryWindowStore();
+    const outbound = [];
+    if (opts.consent)
+        outbound.push(consentGate(opts.consent));
+    if (opts.ownership)
+        outbound.push(ownershipGate(opts.ownership));
+    outbound.push(closedWindowRecovery(opts.policies));
+    outbound.push(interactiveRenderer(opts.policies));
+    const inputResolver = [policyInboundResolver(opts.policies)];
+    const bridge = {
+        outbound,
+        inputResolver,
+        windowStore,
+        ownership: opts.ownership,
+        consent: opts.consent,
+    };
+    const ledger = opts.ledger ?? createInMemoryBroadcastLedger();
+    const broadcasts = createBroadcastApi({
+        broadcastPipeline: opts.broadcastPipeline,
+        consent: opts.consent ?? alwaysOptedIn(),
+        ledger,
+        platform: opts.policies[0]?.channel ?? 'whatsapp',
+    });
+    return { bridge, broadcasts };
+}

package/dist/index.d.ts

@@ -0,0 +1,24 @@
+export * from './policy.js';
+export { engagement, policyInboundResolver, type EngagementOptions, type EngagementBridge, } from './engagement.js';
+export * from './strategist.js';
+export { strategistMiddleware } from './strategist-middleware.js';
+export { interactiveRenderer, renderChoices } from './interactive-renderer.js';
+export { closedWindowRecovery } from './closed-window-recovery.js';
+export { whatsappPolicy } from './policies/whatsapp.js';
+export { instagramPolicy } from './policies/instagram.js';
+export { resolveInboundWhatsApp } from './resolve-inbound-whatsapp.js';
+export { resolveInboundInstagram } from './resolve-inbound-instagram.js';
+export { renderInstagramInteractive, IG_TITLE_MAX, IG_BUTTON_COUNT_MAX, IG_CAROUSEL_COUNT_MAX, } from './render-instagram-interactive.js';
+export { withChoices } from './authoring.js';
+export { smartSend } from './nodes.js';
+export { whatsappTemplateCatalog, mapTemplateInfoToDescriptor, isApprovedNonPaused, type WhatsAppTemplateCatalogClient, } from './catalog.js';
+export { aiTemplateSelector } from './selector.js';
+export type { OutboundTemplateComponent } from '@kuralle-agents/messaging';
+export { webPolicy } from './policies/web.js';
+export { sessionOwnershipStore, ownershipGate, OWNERSHIP_WM_KEY, } from './ownership.js';
+export { sessionConsentStore, consentGate, CONSENT_WM_KEY } from './consent.js';
+export { createInProcessScheduler, type Scheduler, type SendJob, } from './scheduler.js';
+export { createInMemoryBroadcastLedger, createRedisBroadcastLedger, type BroadcastLedger, } from './broadcast-ledger.js';
+export { createBroadcasts, type Campaign, type BroadcastApi, } from './broadcast.js';
+export { createDrip, DRIP_WM_KEY, type DripStep, type DripCampaignState, type DripApi, } from './drip.js';
+export { createSimulator, type SimChannel, type SimSend, type SimSendKind, type SimInboundInput, type Simulator, type CreateSimulatorOptions, } from './simulator.js';

package/dist/index.js

@@ -0,0 +1,23 @@
+export * from './policy.js';
+export { engagement, policyInboundResolver, } from './engagement.js';
+export * from './strategist.js';
+export { strategistMiddleware } from './strategist-middleware.js';
+export { interactiveRenderer, renderChoices } from './interactive-renderer.js';
+export { closedWindowRecovery } from './closed-window-recovery.js';
+export { whatsappPolicy } from './policies/whatsapp.js';
+export { instagramPolicy } from './policies/instagram.js';
+export { resolveInboundWhatsApp } from './resolve-inbound-whatsapp.js';
+export { resolveInboundInstagram } from './resolve-inbound-instagram.js';
+export { renderInstagramInteractive, IG_TITLE_MAX, IG_BUTTON_COUNT_MAX, IG_CAROUSEL_COUNT_MAX, } from './render-instagram-interactive.js';
+export { withChoices } from './authoring.js';
+export { smartSend } from './nodes.js';
+export { whatsappTemplateCatalog, mapTemplateInfoToDescriptor, isApprovedNonPaused, } from './catalog.js';
+export { aiTemplateSelector } from './selector.js';
+export { webPolicy } from './policies/web.js';
+export { sessionOwnershipStore, ownershipGate, OWNERSHIP_WM_KEY, } from './ownership.js';
+export { sessionConsentStore, consentGate, CONSENT_WM_KEY } from './consent.js';
+export { createInProcessScheduler, } from './scheduler.js';
+export { createInMemoryBroadcastLedger, createRedisBroadcastLedger, } from './broadcast-ledger.js';
+export { createBroadcasts, } from './broadcast.js';
+export { createDrip, DRIP_WM_KEY, } from './drip.js';
+export { createSimulator, } from './simulator.js';

package/dist/interactive-renderer.d.ts

@@ -0,0 +1,19 @@
+import type { ChoiceOption } from '@kuralle-agents/core';
+import type { InteractiveMessage, OutboundMiddleware } from '@kuralle-agents/messaging';
+import type { ChannelPolicy } from './policy.js';
+/** WhatsApp reply-button title limit (R-11). */
+export declare const BUTTON_TITLE_MAX = 20;
+/** WhatsApp list row title limit (R-11). */
+export declare const LIST_ROW_TITLE_MAX = 24;
+/** WhatsApp reply buttons per message. */
+export declare const BUTTON_COUNT_MAX = 3;
+/** WhatsApp list rows per message. */
+export declare const LIST_ROW_COUNT_MAX = 10;
+/**
+ * Renders author choices to a channel-neutral `InteractiveMessage`, enforcing
+ * WhatsApp limits (R-11). URL options map to a single-button reply shape because
+ * `InteractiveMessage` has no dedicated CTA variant — the sink must interpret
+ * `ChoiceOption.url` when sending platform CTA messages.
+ */
+export declare function renderChoices(options: ChoiceOption[], prompt: string): InteractiveMessage;
+export declare function interactiveRenderer(policies?: ChannelPolicy[]): OutboundMiddleware;

package/dist/interactive-renderer.js

@@ -0,0 +1,120 @@
+/** WhatsApp reply-button title limit (R-11). */
+export const BUTTON_TITLE_MAX = 20;
+/** WhatsApp list row title limit (R-11). */
+export const LIST_ROW_TITLE_MAX = 24;
+/** WhatsApp reply buttons per message. */
+export const BUTTON_COUNT_MAX = 3;
+/** WhatsApp list rows per message. */
+export const LIST_ROW_COUNT_MAX = 10;
+function assertButtonTitle(label, optionId) {
+    if (label.length > BUTTON_TITLE_MAX) {
+        throw new Error(`interactive: button title for "${optionId}" exceeds ${BUTTON_TITLE_MAX} characters (got ${label.length})`);
+    }
+}
+function assertListRowTitle(label, optionId) {
+    if (label.length > LIST_ROW_TITLE_MAX) {
+        throw new Error(`interactive: list row title for "${optionId}" exceeds ${LIST_ROW_TITLE_MAX} characters (got ${label.length})`);
+    }
+}
+/**
+ * Renders author choices to a channel-neutral `InteractiveMessage`, enforcing
+ * WhatsApp limits (R-11). URL options map to a single-button reply shape because
+ * `InteractiveMessage` has no dedicated CTA variant — the sink must interpret
+ * `ChoiceOption.url` when sending platform CTA messages.
+ */
+export function renderChoices(options, prompt) {
+    if (options.length === 0) {
+        throw new Error('interactive: at least one option is required');
+    }
+    const flowOption = options.find((o) => o.flow);
+    if (flowOption) {
+        if (options.length > 1) {
+            throw new Error('interactive: flow messages support exactly one option');
+        }
+        const { flowId } = flowOption.flow;
+        if (!flowOption.flow.cta) {
+            throw new Error('interactive: flow option requires flow.cta');
+        }
+        return {
+            type: 'flow',
+            body: prompt,
+            action: {
+                type: 'flow',
+                flowId,
+                flowToken: flowOption.id,
+            },
+        };
+    }
+    if (options.some((o) => o.url)) {
+        const urlOptions = options.filter((o) => o.url);
+        if (urlOptions.length > BUTTON_COUNT_MAX) {
+            throw new Error(`interactive: too many URL options (max ${BUTTON_COUNT_MAX} reply buttons)`);
+        }
+        for (const o of urlOptions) {
+            assertButtonTitle(o.label, o.id);
+        }
+        return {
+            type: 'buttons',
+            body: prompt,
+            action: {
+                type: 'buttons',
+                buttons: urlOptions.map((o) => ({ id: o.id, title: o.label })),
+            },
+        };
+    }
+    if (options.length > LIST_ROW_COUNT_MAX) {
+        throw new Error(`interactive: too many options (max ${LIST_ROW_COUNT_MAX} list rows)`);
+    }
+    if (options.length <= BUTTON_COUNT_MAX) {
+        for (const o of options) {
+            assertButtonTitle(o.label, o.id);
+        }
+        return {
+            type: 'buttons',
+            body: prompt,
+            action: {
+                type: 'buttons',
+                buttons: options.map((o) => ({ id: o.id, title: o.label })),
+            },
+        };
+    }
+    for (const o of options) {
+        assertListRowTitle(o.label, o.id);
+    }
+    return {
+        type: 'list',
+        body: prompt,
+        action: {
+            type: 'list',
+            button: 'Choose',
+            sections: [
+                {
+                    title: 'Options',
+                    rows: options.map((o) => ({
+                        id: o.id,
+                        title: o.label,
+                        description: o.description,
+                    })),
+                },
+            ],
+        },
+    };
+}
+function policyFor(policies, platform) {
+    return policies.find((p) => p.channel === platform);
+}
+export function interactiveRenderer(policies) {
+    return {
+        name: 'interactive-renderer',
+        async send(req, next) {
+            const part = req.meta.parts.find((p) => p.type === 'interactive');
+            if (!part)
+                return next(req);
+            const policy = policies ? policyFor(policies, req.platform) : undefined;
+            const interactive = policy
+                ? policy.renderInteractive(part.options, part.prompt)
+                : renderChoices(part.options, part.prompt);
+            return next({ ...req, payload: { kind: 'interactive', interactive } });
+        },
+    };
+}

package/dist/nodes.d.ts

@@ -0,0 +1,10 @@
+import type { ActionNode, FlowState, Transition } from '@kuralle-agents/core';
+import type { WindowState } from '@kuralle-agents/messaging';
+import type { SendDecision, SmartSendStrategist } from './strategist.js';
+export declare function smartSend(strategist: SmartSendStrategist, node: {
+    id: string;
+    message: (s: FlowState) => string;
+    intent?: string;
+    window?: (s: FlowState) => WindowState;
+    next?: (d: SendDecision, s: FlowState) => Transition;
+}): ActionNode;

package/dist/nodes.js

@@ -0,0 +1,15 @@
+import { action } from '@kuralle-agents/core';
+export function smartSend(strategist, node) {
+    return action({
+        id: node.id,
+        run: async (state) => {
+            const text = node.message(state);
+            const window = node.window?.(state) ?? {
+                open: true,
+                expiresAt: new Date(),
+            };
+            const decision = await strategist.decide({ text, window, intent: node.intent });
+            return node.next ? node.next(decision, state) : 'stay';
+        },
+    });
+}

package/dist/ownership.d.ts

@@ -0,0 +1,5 @@
+import type { SessionStore } from '@kuralle-agents/core';
+import type { OwnershipStore, OutboundMiddleware } from '@kuralle-agents/messaging';
+export declare const OWNERSHIP_WM_KEY = "__ownership";
+export declare function sessionOwnershipStore(sessionStore: SessionStore): OwnershipStore;
+export declare function ownershipGate(ownership: OwnershipStore): OutboundMiddleware;

package/dist/ownership.js

@@ -0,0 +1,62 @@
+export const OWNERSHIP_WM_KEY = '__ownership';
+function loadOrCreate(sessionStore, threadId) {
+    return sessionStore.get(threadId).then((session) => {
+        if (session)
+            return session;
+        const now = new Date();
+        return {
+            id: threadId,
+            conversationId: threadId,
+            channelId: 'api',
+            createdAt: now,
+            updatedAt: now,
+            messages: [],
+            workingMemory: {},
+            currentAgent: 'main',
+            agentStates: {},
+            handoffHistory: [],
+            metadata: {
+                createdAt: now,
+                lastActiveAt: now,
+                totalTokens: 0,
+                totalSteps: 0,
+                handoffHistory: [],
+            },
+        };
+    });
+}
+export function sessionOwnershipStore(sessionStore) {
+    return {
+        async owner(threadId) {
+            const session = await sessionStore.get(threadId);
+            if (!session)
+                return 'bot';
+            return session.workingMemory[OWNERSHIP_WM_KEY] === 'human' ? 'human' : 'bot';
+        },
+        async claim(threadId, by) {
+            const session = await loadOrCreate(sessionStore, threadId);
+            session.workingMemory[OWNERSHIP_WM_KEY] = by;
+            session.updatedAt = new Date();
+            await sessionStore.save(session);
+        },
+        async release(threadId) {
+            const session = await sessionStore.get(threadId);
+            if (!session)
+                return;
+            delete session.workingMemory[OWNERSHIP_WM_KEY];
+            session.updatedAt = new Date();
+            await sessionStore.save(session);
+        },
+    };
+}
+export function ownershipGate(ownership) {
+    return {
+        name: 'ownership-gate',
+        async send(req, next) {
+            if ((await ownership.owner(req.threadId)) === 'human') {
+                return { kind: 'suppressed', reason: 'human-owned' };
+            }
+            return next(req);
+        },
+    };
+}

package/dist/policies/instagram.d.ts

@@ -0,0 +1,7 @@
+import type { WindowStore } from '@kuralle-agents/messaging';
+import type { InstagramClient } from '@kuralle-agents/messaging-meta/instagram';
+import type { ChannelPolicy } from '../policy.js';
+export declare function instagramPolicy(opts: {
+    client: InstagramClient;
+    windowStore: WindowStore;
+}): ChannelPolicy;

package/dist/policies/instagram.js

@@ -0,0 +1,15 @@
+import { renderInstagramInteractive } from '../render-instagram-interactive.js';
+import { resolveInboundInstagram } from '../resolve-inbound-instagram.js';
+export function instagramPolicy(opts) {
+    return {
+        channel: 'instagram',
+        hasWindow: true,
+        async isWindowOpen(threadId) {
+            return (await opts.windowStore.get(threadId)).open;
+        },
+        closedWindow: { kind: 'message-tag', tag: 'HUMAN_AGENT' },
+        consentRequired: true,
+        renderInteractive: (options, prompt) => renderInstagramInteractive(options, prompt),
+        resolveInbound: (m) => resolveInboundInstagram(m),
+    };
+}

package/dist/policies/web.d.ts

@@ -0,0 +1,3 @@
+import type { ChannelPolicy } from '../policy.js';
+/** Web/SSE null policy — no window, no consent (RFC §4.12). Proves the abstraction. */
+export declare function webPolicy(): ChannelPolicy;

package/dist/policies/web.js

@@ -0,0 +1,22 @@
+/** Web/SSE null policy — no window, no consent (RFC §4.12). Proves the abstraction. */
+export function webPolicy() {
+    return {
+        channel: 'web',
+        hasWindow: false,
+        async isWindowOpen() {
+            return true;
+        },
+        closedWindow: { kind: 'none' },
+        consentRequired: false,
+        renderInteractive(options, prompt) {
+            return {
+                type: 'buttons',
+                body: prompt,
+                action: { type: 'buttons', buttons: options.map((o) => ({ id: o.id, title: o.label })) },
+            };
+        },
+        resolveInbound(m) {
+            return { input: m.text ?? '' };
+        },
+    };
+}

package/dist/policies/whatsapp.d.ts

@@ -0,0 +1,11 @@
+import type { WindowStore } from '@kuralle-agents/messaging';
+import type { WhatsAppClient } from '@kuralle-agents/messaging-meta/whatsapp';
+import type { ChannelPolicy } from '../policy.js';
+import { type AuditSink, type TemplateSelector } from '../strategist.js';
+export declare function whatsappPolicy(opts: {
+    client: WhatsAppClient;
+    selector: TemplateSelector;
+    windowStore: WindowStore;
+    wabaId: string;
+    audit?: AuditSink;
+}): ChannelPolicy;

package/dist/policies/whatsapp.js

@@ -0,0 +1,23 @@
+import { whatsappTemplateCatalog } from '../catalog.js';
+import { renderChoices } from '../interactive-renderer.js';
+import { resolveInboundWhatsApp } from '../resolve-inbound-whatsapp.js';
+import { createSmartSendStrategist } from '../strategist.js';
+export function whatsappPolicy(opts) {
+    const catalog = whatsappTemplateCatalog({ client: opts.client, wabaId: opts.wabaId });
+    const strategist = createSmartSendStrategist({
+        catalog,
+        selector: opts.selector,
+        audit: opts.audit ?? { record() { } },
+    });
+    return {
+        channel: 'whatsapp',
+        hasWindow: true,
+        async isWindowOpen(threadId) {
+            return (await opts.windowStore.get(threadId)).open;
+        },
+        closedWindow: { kind: 'template', strategist },
+        consentRequired: true,
+        renderInteractive: (options, prompt) => renderChoices(options, prompt),
+        resolveInbound: (m) => resolveInboundWhatsApp(m),
+    };
+}

package/dist/policy.d.ts

@@ -0,0 +1,27 @@
+import type { InboundMessage, InteractiveMessage } from '@kuralle-agents/messaging';
+import type { ChoiceOption, ResolvedSelection } from '@kuralle-agents/core';
+import type { SmartSendStrategist } from './strategist.js';
+export type { SmartSendStrategist } from './strategist.js';
+export type { ChoiceOption } from '@kuralle-agents/core';
+export type ClosedWindowStrategy = {
+    kind: 'template';
+    strategist: SmartSendStrategist;
+} | {
+    kind: 'message-tag';
+    tag: string;
+} | {
+    kind: 'none';
+};
+/** The only channel-specific code (RFC §4.12 / REQ-22). */
+export interface ChannelPolicy {
+    readonly channel: string;
+    readonly hasWindow: boolean;
+    isWindowOpen(threadId: string): Promise<boolean>;
+    readonly closedWindow: ClosedWindowStrategy;
+    readonly consentRequired: boolean;
+    renderInteractive(options: ChoiceOption[], prompt: string): InteractiveMessage;
+    resolveInbound(m: InboundMessage): {
+        input: string;
+        selection?: ResolvedSelection;
+    };
+}

package/dist/policy.js

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

package/dist/render-instagram-interactive.d.ts

@@ -0,0 +1,14 @@
+import type { ChoiceOption } from '@kuralle-agents/core';
+import type { InteractiveMessage } from '@kuralle-agents/messaging';
+/** Instagram button-template title limit (R-11 / Meta quick-reply parity). */
+export declare const IG_TITLE_MAX = 20;
+/** Instagram button template — max buttons per message. */
+export declare const IG_BUTTON_COUNT_MAX = 3;
+/** Instagram generic-template carousel — max elements. */
+export declare const IG_CAROUSEL_COUNT_MAX = 10;
+/**
+ * Renders author choices to a channel-neutral `InteractiveMessage` for Instagram:
+ * ≤3 → button template; 4–10 → generic-template carousel via list shape.
+ * Quick-replies (≤13) are a future enhancement — not used in this cut.
+ */
+export declare function renderInstagramInteractive(options: ChoiceOption[], prompt: string): InteractiveMessage;