@addozhang/dsh-discord 0.1.0

package/lib/features/session-resume.d.ts

@@ -0,0 +1,44 @@
+/**
+ * `/session resume` selector (design.md §13, task 9.1). Metadata only: the
+ * current workspace's sessions, filtered by id/title substring — never
+ * full-text content search (disabled by default in the Web profile).
+ * Untitled sessions fall back to their id; archived sessions carry an
+ * explicit mark so the user can tell before adopting.
+ */
+import { type SelectorOption } from '../discord/selector.js';
+export interface SessionCatalogPort {
+    listSessions(): Promise<{
+        outcome: 'completed';
+        sessions: ReadonlyArray<{
+            sessionId: string;
+            title: string | null;
+            archived: boolean;
+        }>;
+    } | {
+        outcome: 'failed';
+    } | {
+        outcome: 'unknown';
+    }>;
+}
+export interface ResumeSelectorRequest {
+    workspaceId: string;
+    selectionId: string;
+    query?: string | undefined;
+    page?: number | undefined;
+}
+export type ResumeSelectorView = {
+    outcome: 'ok';
+    items: SelectorOption[];
+    pageIndex: number;
+    pageCount: number;
+    hasPrev: boolean;
+    hasNext: boolean;
+    navValues: {
+        prev?: string;
+        next?: string;
+    };
+} | {
+    outcome: 'failed';
+    reason: 'session-catalog-unavailable' | 'session-catalog-unknown';
+};
+export declare function buildResumeSelector(port: SessionCatalogPort, request: ResumeSelectorRequest): Promise<ResumeSelectorView>;

package/lib/features/session-resume.js

@@ -0,0 +1,40 @@
+/**
+ * `/session resume` selector (design.md §13, task 9.1). Metadata only: the
+ * current workspace's sessions, filtered by id/title substring — never
+ * full-text content search (disabled by default in the Web profile).
+ * Untitled sessions fall back to their id; archived sessions carry an
+ * explicit mark so the user can tell before adopting.
+ */
+import { filterAutocomplete, paginateSelector } from '../discord/selector.js';
+import { safeTitle } from '../policy/disclosure.js';
+export async function buildResumeSelector(port, request) {
+    const catalog = await port.listSessions();
+    if (catalog.outcome === 'failed') {
+        return { outcome: 'failed', reason: 'session-catalog-unavailable' };
+    }
+    if (catalog.outcome === 'unknown') {
+        return { outcome: 'failed', reason: 'session-catalog-unknown' };
+    }
+    const selectable = catalog.sessions.map(session => ({
+        label: session.archived
+            ? `[archived] ${session.title === null ? session.sessionId : safeTitle(session.title)}`
+            : session.title === null
+                ? session.sessionId
+                : safeTitle(session.title),
+        value: `sess:${session.sessionId.replace('sess-', '')}`,
+    }));
+    const query = request.query ?? '';
+    const matches = query.trim() === ''
+        ? selectable
+        : filterAutocomplete(selectable, query.trim(), Number.POSITIVE_INFINITY);
+    const page = paginateSelector(matches, request.page ?? 0, `${request.selectionId}:page`);
+    return {
+        outcome: 'ok',
+        items: page.items,
+        pageIndex: page.pageIndex,
+        pageCount: page.pageCount,
+        hasPrev: page.hasPrev,
+        hasNext: page.hasNext,
+        navValues: page.navValues,
+    };
+}

package/lib/features/skill-run.d.ts

@@ -0,0 +1,48 @@
+/**
+ * `/skill run <skill> [input]` (design.md §13, task 10.4). Skill availability
+ * comes from the DSH catalog; operator-only skills refuse ordinary members.
+ * A passing check submits the CANONICAL slash invocation (`/<skill> <args>`)
+ * through the queued session prompt — skills ride the same at-most-once
+ * queue as ordinary thread messages, never a side channel.
+ */
+import type { AccessDecision } from '../policy/authorization.js';
+export interface DshSkillPort {
+    listSkills(): Promise<{
+        outcome: 'completed';
+        skills: ReadonlyArray<{
+            id: string;
+            name: string;
+            operatorOnly: boolean;
+        }>;
+    } | {
+        outcome: 'failed';
+    } | {
+        outcome: 'unknown';
+    }>;
+}
+export interface SkillPromptSubmit {
+    submit(request: {
+        sessionId: string;
+        requestId: string;
+        prompt: string;
+    }): Promise<{
+        outcome: 'queued';
+        position: number;
+    }>;
+}
+export type SkillRunResult = {
+    outcome: 'queued';
+} | {
+    outcome: 'failed';
+} | {
+    outcome: 'refused';
+    reason: 'skill-not-found' | 'operator-only-skill' | 'empty-skill';
+};
+export declare function runSkill(port: DshSkillPort, submit: SkillPromptSubmit, request: {
+    decision: AccessDecision;
+    sessionId: string;
+    requestId: string;
+    /** Canonical skill id the user typed after /skill run. */
+    skillInput: string;
+    args: readonly string[];
+}): Promise<SkillRunResult>;

package/lib/features/skill-run.js

@@ -0,0 +1,25 @@
+/**
+ * `/skill run <skill> [input]` (design.md §13, task 10.4). Skill availability
+ * comes from the DSH catalog; operator-only skills refuse ordinary members.
+ * A passing check submits the CANONICAL slash invocation (`/<skill> <args>`)
+ * through the queued session prompt — skills ride the same at-most-once
+ * queue as ordinary thread messages, never a side channel.
+ */
+export async function runSkill(port, submit, request) {
+    const skillId = request.skillInput.trim();
+    if (skillId === '')
+        return { outcome: 'refused', reason: 'empty-skill' };
+    const catalog = await port.listSkills();
+    if (catalog.outcome !== 'completed')
+        return { outcome: 'failed' };
+    const skill = catalog.skills.find(candidate => candidate.id === skillId);
+    if (skill === undefined)
+        return { outcome: 'refused', reason: 'skill-not-found' };
+    const isOperator = request.decision.allowed && request.decision.level === 'host-operator';
+    if (skill.operatorOnly && !isOperator) {
+        return { outcome: 'refused', reason: 'operator-only-skill' };
+    }
+    const canonical = `/${skillId}${request.args.length === 0 ? '' : ` ${request.args.join(' ')}`}`;
+    await submit.submit({ sessionId: request.sessionId, requestId: request.requestId, prompt: canonical });
+    return { outcome: 'queued' };
+}

package/lib/features/steer-control.d.ts

@@ -0,0 +1,37 @@
+/**
+ * `/steer <prompt>` (design.md §5, task 9.5). Steering submits
+ * `mode: 'steer'` against the calling thread's OWNED active turn — the
+ * ownership comes from the turn tracker's request-ID registration, never
+ * from a session's running status. Late steers and foreign threads are
+ * refused locally without a DSH call.
+ */
+import type { TurnTracker } from './turn-ownership.js';
+export interface DshSteerPort {
+    steer(request: {
+        sessionId: string;
+        requestId: string;
+        prompt: string;
+    }): Promise<{
+        outcome: 'accepted';
+    } | {
+        outcome: 'rejected';
+        reason: string;
+    } | {
+        outcome: 'unknown';
+    }>;
+}
+export type SteerResult = {
+    outcome: 'accepted';
+} | {
+    outcome: 'rejected';
+} | {
+    outcome: 'unknown';
+} | {
+    outcome: 'refused';
+    reason: 'no-active-turn' | 'not-authorized';
+};
+export declare function planSteer(port: DshSteerPort, tracker: TurnTracker, request: {
+    sessionId: string;
+    threadId: string;
+    prompt: string;
+}): Promise<SteerResult>;

package/lib/features/steer-control.js

@@ -0,0 +1,28 @@
+/**
+ * `/steer <prompt>` (design.md §5, task 9.5). Steering submits
+ * `mode: 'steer'` against the calling thread's OWNED active turn — the
+ * ownership comes from the turn tracker's request-ID registration, never
+ * from a session's running status. Late steers and foreign threads are
+ * refused locally without a DSH call.
+ */
+export async function planSteer(port, tracker, request) {
+    const control = tracker.authorizeControl({ sessionId: request.sessionId, threadId: request.threadId });
+    if (!control.allowed) {
+        // Map the tracker's ownership facts onto caller-facing refusals: a
+        // foreign-owned turn is simply not authorized for this thread.
+        return {
+            outcome: 'refused',
+            reason: control.reason === 'no-active-turn' ? 'no-active-turn' : 'not-authorized',
+        };
+    }
+    const steered = await port.steer({
+        sessionId: request.sessionId,
+        requestId: control.requestId,
+        prompt: request.prompt,
+    });
+    if (steered.outcome === 'accepted')
+        return { outcome: 'accepted' };
+    if (steered.outcome === 'unknown')
+        return { outcome: 'unknown' };
+    return { outcome: 'rejected' };
+}

package/lib/features/stop-control.d.ts

@@ -0,0 +1,38 @@
+/**
+ * `/stop` (design.md §5, task 9.6). Stopping cancels only the calling
+ * thread's OWNED active turn — the same request-ID ownership as steering.
+ * The cancel request carries no purge semantics: DSH preserves the session's
+ * pending inbox, so queued prompts survive a stop. After any cancel attempt
+ * the turn is terminal for the adapter (duplicates and late stops refuse
+ * locally), and DSH outcomes surface as plain values.
+ */
+import type { TurnTracker } from './turn-ownership.js';
+export interface DshCancelPort {
+    cancel(request: {
+        sessionId: string;
+        requestId: string;
+    }): Promise<{
+        outcome: 'accepted';
+        pendingPreserved: boolean;
+    } | {
+        outcome: 'rejected';
+        reason: string;
+    } | {
+        outcome: 'unknown';
+    }>;
+}
+export type StopResult = {
+    outcome: 'cancelled';
+    pendingPreserved: boolean;
+} | {
+    outcome: 'rejected';
+} | {
+    outcome: 'unknown';
+} | {
+    outcome: 'refused';
+    reason: 'no-active-turn' | 'not-authorized';
+};
+export declare function planStop(port: DshCancelPort, tracker: TurnTracker, request: {
+    sessionId: string;
+    threadId: string;
+}): Promise<StopResult>;

package/lib/features/stop-control.js

@@ -0,0 +1,31 @@
+/**
+ * `/stop` (design.md §5, task 9.6). Stopping cancels only the calling
+ * thread's OWNED active turn — the same request-ID ownership as steering.
+ * The cancel request carries no purge semantics: DSH preserves the session's
+ * pending inbox, so queued prompts survive a stop. After any cancel attempt
+ * the turn is terminal for the adapter (duplicates and late stops refuse
+ * locally), and DSH outcomes surface as plain values.
+ */
+export async function planStop(port, tracker, request) {
+    const control = tracker.authorizeControl({ sessionId: request.sessionId, threadId: request.threadId });
+    if (!control.allowed) {
+        return {
+            outcome: 'refused',
+            reason: control.reason === 'no-active-turn' ? 'no-active-turn' : 'not-authorized',
+        };
+    }
+    const cancelled = await port.cancel({
+        sessionId: request.sessionId,
+        requestId: control.requestId,
+    });
+    // The turn is terminal for this thread regardless of the wire outcome:
+    // after an accepted, rejected, or unknown cancel there is no controllable
+    // active turn left, so a duplicate or late stop refuses locally.
+    tracker.complete(control.requestId);
+    if (cancelled.outcome === 'accepted') {
+        return { outcome: 'cancelled', pendingPreserved: cancelled.pendingPreserved };
+    }
+    if (cancelled.outcome === 'unknown')
+        return { outcome: 'unknown' };
+    return { outcome: 'rejected' };
+}

package/lib/features/task-admission.d.ts

@@ -0,0 +1,29 @@
+/**
+ * New-task admission (design.md §4). In a bound project channel, a bot
+ * mention carrying non-empty text or a supported image is the canonical
+ * new-task interface: it admits one task against the channel's current
+ * workspace. Empty mentions answer ephemerally, silent messages are ignored,
+ * and unbound channels defer to the bind-affordance flow. Authorization is
+ * an input fact — the upstream guard already refused everyone else.
+ */
+import type { AccessDecision } from '../policy/authorization.js';
+export type NewTaskAdmission = {
+    outcome: 'admit-new-task';
+    workspaceId: string;
+    prompt: string;
+} | {
+    outcome: 'empty-mention';
+    response: 'ephemeral';
+} | {
+    outcome: 'defer-unbound';
+} | {
+    outcome: 'ignore';
+};
+export declare function admitNewTask(input: {
+    decision: AccessDecision;
+    isBound: boolean;
+    channelWorkspaceId: string | undefined;
+    mentionedBot: boolean;
+    content: string;
+    hasSupportedImage: boolean;
+}): NewTaskAdmission;

package/lib/features/task-admission.js

@@ -0,0 +1,21 @@
+/**
+ * New-task admission (design.md §4). In a bound project channel, a bot
+ * mention carrying non-empty text or a supported image is the canonical
+ * new-task interface: it admits one task against the channel's current
+ * workspace. Empty mentions answer ephemerally, silent messages are ignored,
+ * and unbound channels defer to the bind-affordance flow. Authorization is
+ * an input fact — the upstream guard already refused everyone else.
+ */
+export function admitNewTask(input) {
+    if (!input.decision.allowed)
+        return { outcome: 'ignore' };
+    if (!input.isBound || input.channelWorkspaceId === undefined)
+        return { outcome: 'defer-unbound' };
+    if (!input.mentionedBot)
+        return { outcome: 'ignore' };
+    const prompt = input.content.trim();
+    if (prompt === '' && !input.hasSupportedImage) {
+        return { outcome: 'empty-mention', response: 'ephemeral' };
+    }
+    return { outcome: 'admit-new-task', workspaceId: input.channelWorkspaceId, prompt };
+}

package/lib/features/thread-continuation.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Ordinary thread continuation (design.md §5, task 8.5). Every normal message
+ * in an adapter-owned thread submits through `session.prompt` with
+ * `mode: 'queue'` — the queue is what makes idle and busy sessions equally
+ * safe, and ordinary messages never improvise steer or stop semantics
+ * (those are the explicit `/steer` and `/stop` commands).
+ */
+export interface DshPromptPort {
+    submit(request: {
+        requestId: string;
+        sessionId: string;
+        prompt: string;
+        mode: 'queue';
+    }): Promise<{
+        outcome: 'queued';
+        position: number;
+    } | {
+        outcome: 'rejected';
+        reason: string;
+    } | {
+        outcome: 'unknown';
+    }>;
+}
+export type ContinuationResult = {
+    outcome: 'queued';
+    position: number;
+} | {
+    outcome: 'rejected';
+} | {
+    outcome: 'unknown';
+};
+export declare function continueThread(prompts: DshPromptPort, request: {
+    sessionId: string;
+    messageId: string;
+    content: string;
+}): Promise<ContinuationResult>;

package/lib/features/thread-continuation.js

@@ -0,0 +1,18 @@
+/**
+ * Ordinary thread continuation (design.md §5, task 8.5). Every normal message
+ * in an adapter-owned thread submits through `session.prompt` with
+ * `mode: 'queue'` — the queue is what makes idle and busy sessions equally
+ * safe, and ordinary messages never improvise steer or stop semantics
+ * (those are the explicit `/steer` and `/stop` commands).
+ */
+export async function continueThread(prompts, request) {
+    const submitted = await prompts.submit({
+        requestId: request.messageId,
+        sessionId: request.sessionId,
+        prompt: request.content,
+        mode: 'queue',
+    });
+    if (submitted.outcome === 'queued')
+        return { outcome: 'queued', position: submitted.position };
+    return submitted.outcome === 'rejected' ? { outcome: 'rejected' } : { outcome: 'unknown' };
+}

package/lib/features/thread-creation.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Thread creation over the source-message intent (design.md §4, §10, anchored-thread
+ * thread model). The source Discord message id is the stable claim: the
+ * first creator creates a thread ANCHORED to that message (Discord moves it
+ * into the thread as its first post — the user's task text opens the
+ * thread) and records it on the intent; any redelivery of the same message
+ * recovers that thread (from the record, or — across a crash window where
+ * the intent exists but carries no thread id — from Discord's deterministic
+ * source-message lookup). The author is joined to the thread so it appears
+ * in their sidebar (live-tested: "add user to thread so it appears in their
+ * sidebar"). Different content under the same message id conflicts, and
+ * creation failures surface as values.
+ */
+import type { IntentStore } from '../state/intents.js';
+/** The Discord thread surface the flow needs (REST in production, fakes here). */
+export interface DiscordThreadPort {
+    createThread(request: {
+        parentChannelId: string;
+        name: string;
+        /** The source message anchors the thread (its durable first message). */
+        sourceMessageId: string;
+    }): Promise<{
+        outcome: 'completed';
+        threadId: string;
+    } | {
+        outcome: 'failed';
+    } | {
+        outcome: 'unknown';
+    }>;
+    /** Deterministic recovery: find the thread created for this source message. */
+    findThreadBySource(request: {
+        guildId: string;
+        sourceMessageId: string;
+    }): Promise<{
+        outcome: 'found';
+        threadId: string;
+    } | {
+        outcome: 'not-found';
+    }>;
+    /**
+     * Join the task author to the thread: Discord sidebars list only threads
+     * the user has joined, so the anchored task thread stays invisible to its
+     * author until this runs. Best-effort by contract; never fails the task.
+     */
+    joinThread(request: {
+        threadId: string;
+        userId: string;
+    }): Promise<{
+        outcome: 'completed';
+    } | {
+        outcome: 'failed';
+    }>;
+}
+export interface ThreadCreationDeps {
+    intents: IntentStore;
+    discord: DiscordThreadPort;
+    nowMs: () => number;
+}
+export type ThreadCreationResult = {
+    outcome: 'created';
+    threadId: string;
+} | {
+    outcome: 'recovered';
+    threadId: string;
+} | {
+    outcome: 'conflict';
+} | {
+    outcome: 'failed';
+};
+export interface EnsureThreadRequest {
+    sourceMessageId: string;
+    contentHash: string;
+    guildId: string;
+    parentChannelId: string;
+    threadName: string;
+    /** The task author to join into the thread (sidebar visibility). */
+    creatorUserId?: string | undefined;
+}
+export declare function createThreadCreationFlow(deps: ThreadCreationDeps): {
+    ensureThread(request: EnsureThreadRequest): Promise<ThreadCreationResult>;
+};

package/lib/features/thread-creation.js

@@ -0,0 +1,81 @@
+/**
+ * Thread creation over the source-message intent (design.md §4, §10, anchored-thread
+ * thread model). The source Discord message id is the stable claim: the
+ * first creator creates a thread ANCHORED to that message (Discord moves it
+ * into the thread as its first post — the user's task text opens the
+ * thread) and records it on the intent; any redelivery of the same message
+ * recovers that thread (from the record, or — across a crash window where
+ * the intent exists but carries no thread id — from Discord's deterministic
+ * source-message lookup). The author is joined to the thread so it appears
+ * in their sidebar (live-tested: "add user to thread so it appears in their
+ * sidebar"). Different content under the same message id conflicts, and
+ * creation failures surface as values.
+ */
+export function createThreadCreationFlow(deps) {
+    /**
+     * Best-effort author join on every path that yields a live thread. A join
+     * failure never fails the task: the thread exists and reconciliation, not
+     * this call, owns Discord-side recovery.
+     */
+    async function joinAuthor(request, threadId) {
+        if (request.creatorUserId === undefined || request.creatorUserId === '')
+            return;
+        try {
+            await deps.discord.joinThread({ threadId, userId: request.creatorUserId });
+        }
+        catch {
+            return;
+        }
+    }
+    return {
+        async ensureThread(request) {
+            const claim = await deps.intents.claim({
+                messageId: request.sourceMessageId,
+                contentHash: request.contentHash,
+                claimedAtMs: deps.nowMs(),
+            });
+            if (claim.outcome === 'conflict')
+                return { outcome: 'conflict' };
+            if (claim.outcome === 'duplicate') {
+                const existing = claim.record.threadId;
+                if (existing !== undefined && existing !== '') {
+                    await joinAuthor(request, existing);
+                    return { outcome: 'recovered', threadId: existing };
+                }
+                // Intent exists without a thread id: a previous attempt crashed
+                // mid-flow. Recover deterministically from Discord.
+                const found = await deps.discord.findThreadBySource({
+                    guildId: request.guildId,
+                    sourceMessageId: request.sourceMessageId,
+                });
+                if (found.outcome === 'found') {
+                    await deps.intents.resolve(request.sourceMessageId, 'succeeded', deps.nowMs());
+                    // Persist the recovered id like the fresh-create path does, or
+                    // every redelivery re-enters the crash window and rescans.
+                    await deps.intents.annotate(request.sourceMessageId, { threadId: found.threadId });
+                    await joinAuthor(request, found.threadId);
+                    return { outcome: 'recovered', threadId: found.threadId };
+                }
+                return { outcome: 'failed' };
+            }
+            // Fresh claim: create the anchored thread and record it on the intent.
+            const created = await deps.discord.createThread({
+                parentChannelId: request.parentChannelId,
+                name: request.threadName,
+                sourceMessageId: request.sourceMessageId,
+            });
+            if (created.outcome !== 'completed') {
+                await deps.intents.resolve(request.sourceMessageId, 'failed', deps.nowMs());
+                return { outcome: 'failed' };
+            }
+            await joinAuthor(request, created.threadId);
+            const stored = deps.intents.get(request.sourceMessageId);
+            if (stored !== undefined) {
+                await deps.intents.resolve(request.sourceMessageId, 'succeeded', deps.nowMs());
+                // Persist the thread id on the intent record for later replays.
+                await deps.intents.annotate(request.sourceMessageId, { threadId: created.threadId });
+            }
+            return { outcome: 'created', threadId: created.threadId };
+        },
+    };
+}

package/lib/features/thread-routing.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Thread routing (design.md §4). A thread bound to a Session always routes to
+ * that Session and its immutable cwd workspace — channel rebinds cannot move
+ * it. Routing prefers the thread binding, falls back to the channel's current
+ * workspace for NEW threads, and reports unbound when neither exists. New
+ * thread bindings go through the same revision-fenced store so a duplicate
+ * Thread-create race cannot rebind an existing thread to a different session.
+ */
+import type { ThreadBinding } from '../state/records.js';
+import { type ThreadBindingScope } from '../state/domain.js';
+import type { BindingStore } from '../state/bindings.js';
+export interface ThreadRoutingDeps {
+    threadBindings: BindingStore<ThreadBinding>;
+    applicationId: string;
+}
+export type ThreadRoute = {
+    route: 'existing-session';
+    sessionId: string;
+    workspaceId: string;
+} | {
+    route: 'new-session';
+    workspaceId: string;
+} | {
+    route: 'unbound';
+};
+export interface ThreadRoutingService {
+    bindThread(request: {
+        scope: ThreadBindingScope;
+        request: {
+            sessionId: string;
+            workspaceId: string;
+            createdBy: string;
+            nowMs: number;
+        };
+    }): Promise<{
+        ok: true;
+        binding: ThreadBinding;
+    } | {
+        ok: false;
+        error: 'already-bound' | 'stale-revision' | 'not-bound';
+    }>;
+    route(input: {
+        guildId: string;
+        threadId: string;
+        /** The channel's current binding; undefined when the channel is unbound. */
+        channelWorkspaceId: string | undefined;
+    }): ThreadRoute;
+}
+export declare function createThreadRoutingService(deps: ThreadRoutingDeps): ThreadRoutingService;

package/lib/features/thread-routing.js

@@ -0,0 +1,34 @@
+/**
+ * Thread routing (design.md §4). A thread bound to a Session always routes to
+ * that Session and its immutable cwd workspace — channel rebinds cannot move
+ * it. Routing prefers the thread binding, falls back to the channel's current
+ * workspace for NEW threads, and reports unbound when neither exists. New
+ * thread bindings go through the same revision-fenced store so a duplicate
+ * Thread-create race cannot rebind an existing thread to a different session.
+ */
+import { threadBindingKey } from '../state/domain.js';
+export function createThreadRoutingService(deps) {
+    return {
+        async bindThread({ scope, request }) {
+            const result = await deps.threadBindings.bind(threadBindingKey(scope), {
+                sessionId: request.sessionId,
+                workspaceId: request.workspaceId,
+                createdBy: request.createdBy,
+                createdAtMs: request.nowMs,
+            });
+            if (result.ok)
+                return { ok: true, binding: result.binding };
+            return { ok: false, error: result.error };
+        },
+        route({ guildId, threadId, channelWorkspaceId }) {
+            const binding = deps.threadBindings.get(threadBindingKey({ applicationId: deps.applicationId, guildId, threadId }));
+            if (binding !== undefined) {
+                return { route: 'existing-session', sessionId: binding.sessionId, workspaceId: binding.workspaceId };
+            }
+            if (channelWorkspaceId !== undefined) {
+                return { route: 'new-session', workspaceId: channelWorkspaceId };
+            }
+            return { route: 'unbound' };
+        },
+    };
+}