@addozhang/dsh-discord 0.2.3 → 0.4.0

package/lib/features/interaction-router.js

@@ -52,19 +52,41 @@ export function createInteractionRouter(deps) {
         });
     }
     async function routeAutocomplete(event, interactionToken) {
-        if (event.commandName !== 'project')
+        if (event.commandName !== 'project' && event.commandName !== 'session')
             return;
         // Autocomplete has no deferred-ack form: whatever happens below, Discord
         // must receive exactly one type-8 answer, even if only empty choices.
         try {
             const decision = authorize(event);
             const choices = [];
-            if (decision.allowed) {
+            const wireOptions = event.data['options'];
+            const sub = Array.isArray(wireOptions) ? wireOptions[0] : undefined;
+            const focused = Array.isArray(sub?.options) ? sub.options.find(option => option.focused === true) : undefined;
+            const query = typeof focused?.value === 'string' ? focused.value : '';
+            if (decision.allowed && event.commandName === 'session') {
+                // /session resume: live candidates scoped to the bound workspace.
+                try {
+                    const binding = deps.channelBinding(event.guildId, event.channelId);
+                    const catalog = await deps.catalogPort.listWorkspaces();
+                    const workspacePath = binding !== undefined && catalog.outcome === 'completed'
+                        ? catalog.workspaces.find(workspace => workspace.id === binding.workspaceId)?.path
+                        : undefined;
+                    const archivedSessionIds = catalog.outcome === 'completed'
+                        ? new Set(catalog.archivedSessionIds)
+                        : undefined;
+                    const outcome = await deps.resumeCandidates(query, workspacePath, archivedSessionIds);
+                    if (outcome.outcome === 'ok') {
+                        choices.push(...outcome.options.slice(0, 25).map(option => (option.description === undefined
+                            ? { name: option.label, value: option.value }
+                            : { name: option.label, value: option.value, description: option.description })));
+                    }
+                }
+                catch (cause) {
+                    deps.warn('discord_autocomplete_sessions_failed', String(cause));
+                }
+            }
+            else if (decision.allowed && event.commandName === 'project') {
                 try {
-                    const wireOptions = event.data['options'];
-                    const sub = Array.isArray(wireOptions) ? wireOptions[0] : undefined;
-                    const focused = Array.isArray(sub?.options) ? sub.options.find(option => option.focused === true) : undefined;
-                    const query = typeof focused?.value === 'string' ? focused.value : '';
                     const catalog = await deps.catalogPort.listWorkspaces();
                     if (catalog.outcome === 'completed') {
                         choices.push(...workspaceAutocompleteChoices(catalog.workspaces, query).slice(0, 25));
@@ -483,6 +505,57 @@ export function createInteractionRouter(deps) {
                 await followUp(content);
                 return;
             }
+            if (event.commandName === 'session') {
+                // /session resume: cold-adopt an existing DSH session into a new
+                // thread of the bound project channel (16.44). /session new is
+                // deliberately absent — the @mention is the new-session path.
+                const options = event.data['options'];
+                const subcommand = Array.isArray(options) ? options[0] : undefined;
+                if (subcommand?.name !== 'resume') {
+                    await followUp(deps.copy.unknownSubcommand);
+                    return;
+                }
+                const binding = deps.channelBinding(event.guildId, event.channelId);
+                if (binding === undefined) {
+                    await followUp(deps.copy.sessionResumeNeedsBoundChannel);
+                    return;
+                }
+                const wireOptions = Array.isArray(subcommand.options) ? subcommand.options : [];
+                const sessionId = wireOptions.find(option => option.name === 'session')?.value;
+                if (typeof sessionId !== 'string' || sessionId === '') {
+                    await followUp(deps.copy.sessionResumeFailed);
+                    return;
+                }
+                const outcome = await deps.resumeSession({
+                    sessionId,
+                    workspaceId: binding.workspaceId,
+                    guildId: event.guildId,
+                    parentChannelId: event.channelId,
+                    actorId: event.actorId,
+                });
+                if (outcome.outcome === 'refused-control-channel') {
+                    await followUp(deps.copy.sessionResumeControlChannel);
+                    return;
+                }
+                if (outcome.outcome === 'refused-subagent') {
+                    await followUp(deps.copy.sessionResumeSubagent);
+                    return;
+                }
+                if (outcome.outcome === 'refused-archived') {
+                    await followUp(deps.copy.sessionResumeArchived);
+                    return;
+                }
+                if (outcome.outcome === 'already-bound') {
+                    await followUp(deps.copy.sessionResumeAlreadyBound(outcome.threadId));
+                    return;
+                }
+                if (outcome.outcome === 'started') {
+                    await followUp(deps.copy.sessionResumeStarted(outcome.threadId));
+                    return;
+                }
+                await followUp(deps.copy.sessionResumeFailed);
+                return;
+            }
             // Terminal guard: a recognized interaction type with an unhandled
             // command name must still answer, never strand on the deferred ack.
             await followUp(deps.copy.unknownSubcommand);

package/lib/features/project-list.d.ts

@@ -22,6 +22,7 @@ export interface ProjectListPort {
             title: string;
             path?: string | undefined;
         }>;
+        archivedSessionIds: ReadonlyArray<string>;
     } | {
         outcome: 'failed';
     } | {

package/lib/features/prompt-submission.d.ts

@@ -15,6 +15,8 @@ export interface DshPromptPort {
         sessionId: string;
         prompt: string;
         mode: 'queue';
+        /** Collected images (16.50); omitted for text-only prompts so legacy shapes are untouched. */
+        images?: ReadonlyArray<PromptRequestImage>;
     }): Promise<{
         outcome: 'accepted';
     } | {
@@ -24,6 +26,11 @@ export interface DshPromptPort {
         outcome: 'unknown';
     }>;
 }
+/** One collected image, ready for the prompt parts encoding. */
+export interface PromptRequestImage {
+    mediaType: string;
+    base64: string;
+}
 export interface PromptSubmissionDeps {
     prompts: DshPromptPort;
     intents: IntentStore;
@@ -44,6 +51,8 @@ export interface PromptRequest {
     requestId: string;
     sessionId: string;
     prompt: string;
+    /** Collected images (16.50); omitted for text-only prompts. */
+    images?: ReadonlyArray<PromptRequestImage>;
 }
 export declare function createPromptSubmissionFlow(deps: PromptSubmissionDeps): {
     submitOnce(request: PromptRequest): Promise<PromptSubmissionResult>;

package/lib/features/prompt-submission.js

@@ -10,7 +10,12 @@
 import { hashPayload } from '../state/intents.js';
 export function createPromptSubmissionFlow(deps) {
     async function submit(requestId, request) {
-        const contentHash = await hashPayload({ sessionId: request.sessionId, prompt: request.prompt });
+        const images = request.images ?? [];
+        const contentHash = await hashPayload({
+            sessionId: request.sessionId,
+            prompt: request.prompt,
+            ...(images.length > 0 ? { images } : {}),
+        });
         const claim = await deps.intents.claim({
             messageId: requestId,
             contentHash,
@@ -26,6 +31,7 @@ export function createPromptSubmissionFlow(deps) {
             sessionId: request.sessionId,
             prompt: request.prompt,
             mode: 'queue',
+            ...(images.length > 0 ? { images } : {}),
         });
         if (submitted.outcome === 'accepted') {
             await deps.intents.resolve(requestId, 'succeeded', deps.nowMs());

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

@@ -9,13 +9,44 @@
  */
 import type { createThreadCreationFlow } from './thread-creation.js';
 import type { createSessionCreationFlow } from './session-creation.js';
-import type { createPromptSubmissionFlow } from './prompt-submission.js';
+import type { createPromptSubmissionFlow, PromptRequestImage } from './prompt-submission.js';
 import type { TurnTracker } from './turn-ownership.js';
+/** Declared image metadata as carried on the normalized wire message. */
+export interface MainlineWireImage {
+    url: string;
+    filename: string;
+    declaredSize: number;
+    contentType: string;
+}
+/** One collected image, ready for submission. */
+export type MainlineImage = PromptRequestImage;
+/**
+ * The bounded collection boundary (design.md §12, 16.50): declared wire
+ * metadata goes in, base64-encoded images come out. The composition root
+ * implements it over the safe-download boundary — this layer never touches
+ * the network itself.
+ */
+export interface MainlineImageCollector {
+    collect(request: {
+        attachments: ReadonlyArray<{
+            url: string;
+            declaredSize: number;
+            contentType: string;
+        }>;
+    }): Promise<{
+        outcome: 'collected';
+        images: ReadonlyArray<MainlineImage>;
+    } | {
+        outcome: 'failed';
+        reason: string;
+    }>;
+}
 export interface SessionMainlineDeps {
     threads: ReturnType<typeof createThreadCreationFlow>;
     sessions: ReturnType<typeof createSessionCreationFlow>;
     prompts: ReturnType<typeof createPromptSubmissionFlow>;
     turns: TurnTracker;
+    images: MainlineImageCollector;
 }
 export type MentionMainlineResult = {
     outcome: 'admitted';
@@ -33,6 +64,9 @@ export type MentionMainlineResult = {
     outcome: 'prompt-rejected';
 } | {
     outcome: 'prompt-unknown';
+} | {
+    outcome: 'image-failed';
+    reason: string;
 };
 export interface MentionMainlineRequest {
     applicationId: string;
@@ -43,6 +77,8 @@ export interface MentionMainlineRequest {
     authorId: string;
     workspaceId: string;
     prompt: string;
+    /** Declared image attachments (16.50); omitted for text-only mentions. */
+    images?: ReadonlyArray<MainlineWireImage>;
 }
 export type ContinuationMainlineResult = {
     outcome: 'queued';
@@ -54,6 +90,9 @@ export type ContinuationMainlineResult = {
     outcome: 'rejected';
 } | {
     outcome: 'unknown';
+} | {
+    outcome: 'image-failed';
+    reason: string;
 };
 export interface ContinuationMainlineRequest {
     applicationId: string;
@@ -62,6 +101,8 @@ export interface ContinuationMainlineRequest {
     sessionId: string;
     messageId: string;
     prompt: string;
+    /** Declared image attachments (16.50); omitted for text-only messages. */
+    images?: ReadonlyArray<MainlineWireImage>;
 }
 /**
  * The stable, adapter-owned request id for a submitted prompt: derived from

package/lib/features/session-mainline.js

@@ -30,17 +30,38 @@ function mapSubmission(result) {
         return { outcome: 'conflict' };
     return result.outcome === 'rejected' ? { outcome: 'rejected' } : { outcome: 'unknown' };
 }
+/**
+ * Collect the request's declared images through the bounded boundary. A
+ * text-only request never touches the collector; a failed collection is a
+ * first-class outcome so no degraded text-only submission is sent silently.
+ */
+async function collectRequestImages(deps, images) {
+    if (images.length === 0)
+        return { outcome: 'collected', images: [] };
+    const collected = await deps.images.collect({
+        attachments: images.map(({ url, declaredSize, contentType }) => ({ url, declaredSize, contentType })),
+    });
+    if (collected.outcome !== 'collected')
+        return { outcome: 'image-failed', reason: collected.reason };
+    return collected;
+}
 export function createSessionMainline(deps) {
     return {
         async admitMention(request) {
+            const declaredImages = request.images ?? [];
+            const images = await collectRequestImages(deps, declaredImages);
+            if (images.outcome !== 'collected')
+                return images;
             // The source message id is the durable intent: one thread per message,
-            // deterministic recovery on redelivery (design.md §4, §10).
+            // deterministic recovery on redelivery (design.md §4, §10). An
+            // image-only mention names the thread after its first image's filename.
+            const title = request.prompt !== '' ? request.prompt : (declaredImages[0]?.filename ?? '');
             const thread = await deps.threads.ensureThread({
                 sourceMessageId: request.messageId,
-                contentHash: await hashPayload({ prompt: request.prompt }),
+                contentHash: await hashPayload({ prompt: request.prompt, images: declaredImages }),
                 guildId: request.guildId,
                 parentChannelId: request.channelId,
-                threadName: safeTitle(request.prompt),
+                threadName: safeTitle(title),
                 creatorUserId: request.authorId,
             });
             if (thread.outcome === 'conflict')
@@ -66,6 +87,7 @@ export function createSessionMainline(deps) {
                 requestId,
                 sessionId,
                 prompt: request.prompt,
+                ...(images.images.length > 0 ? { images: images.images } : {}),
             });
             if (submitted.outcome === 'accepted') {
                 ownTurn(deps, { sessionId, requestId, threadId });
@@ -81,11 +103,15 @@ export function createSessionMainline(deps) {
             return submitted.outcome === 'rejected' ? { outcome: 'prompt-rejected' } : { outcome: 'prompt-unknown' };
         },
         async continueInThread(request) {
+            const images = await collectRequestImages(deps, request.images ?? []);
+            if (images.outcome !== 'collected')
+                return images;
             const requestId = requestIdFor(request.messageId);
             const submitted = await deps.prompts.submitOnce({
                 requestId,
                 sessionId: request.sessionId,
                 prompt: request.prompt,
+                ...(images.images.length > 0 ? { images: images.images } : {}),
             });
             if (submitted.outcome === 'accepted') {
                 ownTurn(deps, { sessionId: request.sessionId, requestId, threadId: request.threadId });

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

@@ -1,44 +1,78 @@
 /**
- * `/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.
+ * `/session resume` candidate building (design.md §13, tasks 9.1 + 16.44).
+ * The Host's `sessions.list` returns rich rows (updatedAt desc, running,
+ * blank, cwd, title via projection values). Candidates exclude blank
+ * sessions and sessions this adapter already owns a thread for, filter by
+ * title/id substring, and sort newest-first — Discord autocomplete caps at
+ * 25 choices, the caller slices.
  */
+import type { SessionResumeRow } from '../dsh/api-proxy-face.js';
+export type { SessionResumeRow };
+import type { CopyTable } from '../i18n.js';
 import { type SelectorOption } from '../discord/selector.js';
 export interface SessionCatalogPort {
     listSessions(): Promise<{
         outcome: 'completed';
-        sessions: ReadonlyArray<{
-            sessionId: string;
-            title: string | null;
-            archived: boolean;
-        }>;
+        sessions: ReadonlyArray<SessionResumeRow>;
     } | {
         outcome: 'failed';
     } | {
         outcome: 'unknown';
     }>;
 }
-export interface ResumeSelectorRequest {
-    workspaceId: string;
-    selectionId: string;
-    query?: string | undefined;
-    page?: number | undefined;
-}
-export type ResumeSelectorView = {
+export type ResumeCandidatesPort = (query: string, 
+/**
+ * The bound Workspace's REGISTERED PATH, resolved by the router from the
+ * channel binding through the workspace catalog. Not a workspace id: the
+ * port must never re-resolve it through the catalog (an id/path swap here
+ * once answered `unavailable` in every channel — 16.45). `undefined`
+ * (unbound channel / catalog miss) is fail-closed.
+ */
+workspacePath?: string, 
+/** The registry's archived set (16.49): archived sessions never resume. */
+archivedSessionIds?: ReadonlySet<string>) => Promise<{
     outcome: 'ok';
-    items: SelectorOption[];
-    pageIndex: number;
-    pageCount: number;
-    hasPrev: boolean;
-    hasNext: boolean;
-    navValues: {
-        prev?: string;
-        next?: string;
-    };
+    options: SelectorOption[];
 } | {
-    outcome: 'failed';
-    reason: 'session-catalog-unavailable' | 'session-catalog-unknown';
-};
-export declare function buildResumeSelector(port: SessionCatalogPort, request: ResumeSelectorRequest): Promise<ResumeSelectorView>;
+    outcome: 'unavailable';
+}>;
+/**
+ * Relative-time rendering for a candidate's label. Discord autocomplete
+ * choices carry no description field on the wire (name/value only), so the
+ * age rides the label — bilingual via the copy table (16.47).
+ */
+export declare function relativeTime(copy: CopyTable, fromMs: number, nowMs: number): string;
+/**
+ * Build the /session resume autocomplete candidates from one Host listing:
+ * blank sessions are hidden (nothing to resume), already-bound sessions are
+ * excluded (their thread is the live surface), the query filters over
+ * title/id case-insensitively, and rows sort newest-first. Uncapped here —
+ * the caller applies Discord's 25-choice ceiling. Same-titled candidates
+ * get a short-id suffix: choices have no description on the wire, so
+ * identical labels would be indistinguishable (16.47).
+ */
+export declare function buildResumeCandidates(sessions: ReadonlyArray<SessionResumeRow>, options: {
+    /** Registered path of the bound Workspace; only its sessions are offered. */
+    workspacePath: string | undefined;
+    boundSessionIds?: ReadonlySet<string>;
+    /** Registry's archived set: archived sessions never resume (16.49). */
+    archivedSessionIds?: ReadonlySet<string>;
+    query?: string | undefined;
+    nowMs?: number;
+    copy: CopyTable;
+}): SelectorOption[];
+/** Discard candidates: prefix matches first, then substring, capped. */
+export declare function filterResumeCandidates(candidates: ReadonlyArray<SelectorOption>, query: string, limit?: number): SelectorOption[];
+/**
+ * The composition-root wiring for the router's `resumeCandidates` dep
+ * (16.44): one Host listing per call, filtered by the handed-in workspace
+ * path against the live thread-ownership set. Listing failure is logged at
+ * the face (`…failed`/`…timeout`) and degrades to `unavailable` — Discord
+ * autocomplete then answers empty choices, never an unanswered interaction.
+ */
+export declare function createResumeCandidatesPort(deps: {
+    listSessions: SessionCatalogPort['listSessions'];
+    /** Sessions this adapter already owns a thread for, re-read per call. */
+    boundSessionIds: () => ReadonlySet<string>;
+    copy: CopyTable;
+}): ResumeCandidatesPort;

package/lib/features/session-resume.js

@@ -1,40 +1,113 @@
 /**
- * `/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.
+ * `/session resume` candidate building (design.md §13, tasks 9.1 + 16.44).
+ * The Host's `sessions.list` returns rich rows (updatedAt desc, running,
+ * blank, cwd, title via projection values). Candidates exclude blank
+ * sessions and sessions this adapter already owns a thread for, filter by
+ * title/id substring, and sort newest-first — Discord autocomplete caps at
+ * 25 choices, the caller slices.
  */
-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-', '')}`,
+import { filterAutocomplete } from '../discord/selector.js';
+/**
+ * Relative-time rendering for a candidate's label. Discord autocomplete
+ * choices carry no description field on the wire (name/value only), so the
+ * age rides the label — bilingual via the copy table (16.47).
+ */
+export function relativeTime(copy, fromMs, nowMs) {
+    const delta = Math.max(0, nowMs - fromMs);
+    const minutes = Math.floor(delta / 60_000);
+    if (minutes < 1)
+        return copy.sessionCandidateJustNow;
+    if (minutes < 60)
+        return copy.sessionCandidateMinutesAgo(minutes);
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return copy.sessionCandidateHoursAgo(hours);
+    const days = Math.floor(hours / 24);
+    return copy.sessionCandidateDaysAgo(days);
+}
+/** Short display form of a session id (first 8 chars). */
+function shortId(sessionId) {
+    return sessionId.slice(0, 8);
+}
+/** Discord rejects the whole autocomplete answer when a choice name exceeds 100. */
+const DISCORD_CHOICE_NAME_MAX = 100;
+function candidateLabel(copy, session, nowMs) {
+    const parts = [session.title ?? shortId(session.sessionId), relativeTime(copy, session.updatedAt, nowMs)];
+    if (session.running)
+        parts.push(copy.sessionCandidateRunning);
+    const label = parts.join(' · ');
+    return label.length <= DISCORD_CHOICE_NAME_MAX ? label : label.slice(0, DISCORD_CHOICE_NAME_MAX);
+}
+/**
+ * Build the /session resume autocomplete candidates from one Host listing:
+ * blank sessions are hidden (nothing to resume), already-bound sessions are
+ * excluded (their thread is the live surface), the query filters over
+ * title/id case-insensitively, and rows sort newest-first. Uncapped here —
+ * the caller applies Discord's 25-choice ceiling. Same-titled candidates
+ * get a short-id suffix: choices have no description on the wire, so
+ * identical labels would be indistinguishable (16.47).
+ */
+export function buildResumeCandidates(sessions, options) {
+    const query = (options.query ?? '').trim().toLowerCase();
+    const nowMs = options.nowMs ?? Date.now();
+    const bound = options.boundSessionIds ?? new Set();
+    const archived = options.archivedSessionIds ?? new Set();
+    const copy = options.copy;
+    const rows = sessions
+        .filter(session => !session.blank && !bound.has(session.sessionId))
+        // Subagent sessions are never resumable as top-level threads (the spec's
+        // "Subagent Session selected" refusal) — offering them only produces
+        // selections that must fail (16.48).
+        .filter(session => session.origin !== 'subagent')
+        // Archived sessions adopt fine but never run a turn — the user waits in
+        // a dead thread. `workspace.list` carries the registry's archived set;
+        // sessions.list rows have no archived marker (16.49).
+        .filter(session => !archived.has(session.sessionId))
+        // Workspace scoping (16.44): a session belongs to the channel's Workspace
+        // only when its recorded cwd is that Workspace's registered path.
+        // Sessions with no recorded cwd cannot be attributed and are never
+        // offered.
+        .filter(session => options.workspacePath === undefined || session.cwd === options.workspacePath)
+        .sort((a, b) => b.updatedAt - a.updatedAt);
+    const options_ = rows.map(session => ({
+        label: candidateLabel(copy, session, nowMs),
+        value: session.sessionId,
     }));
-    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,
+    const counts = new Map();
+    for (const option of options_)
+        counts.set(option.label, (counts.get(option.label) ?? 0) + 1);
+    const disambiguated = options_.map(option => (counts.get(option.label) ?? 0) > 1
+        ? { label: `${option.label} · ${shortId(option.value)}`.slice(0, DISCORD_CHOICE_NAME_MAX), value: option.value }
+        : option);
+    if (query === '')
+        return disambiguated;
+    return disambiguated.filter(option => option.label.toLowerCase().includes(query) || option.value.toLowerCase().includes(query));
+}
+/** Discard candidates: prefix matches first, then substring, capped. */
+export function filterResumeCandidates(candidates, query, limit = 25) {
+    return filterAutocomplete(candidates, query, limit);
+}
+/**
+ * The composition-root wiring for the router's `resumeCandidates` dep
+ * (16.44): one Host listing per call, filtered by the handed-in workspace
+ * path against the live thread-ownership set. Listing failure is logged at
+ * the face (`…failed`/`…timeout`) and degrades to `unavailable` — Discord
+ * autocomplete then answers empty choices, never an unanswered interaction.
+ */
+export function createResumeCandidatesPort(deps) {
+    return async (query, workspacePath, archivedSessionIds) => {
+        if (workspacePath === undefined)
+            return { outcome: 'unavailable' };
+        const summaries = await deps.listSessions();
+        if (summaries.outcome !== 'completed')
+            return { outcome: 'unavailable' };
+        const candidates = buildResumeCandidates(summaries.sessions, {
+            workspacePath,
+            boundSessionIds: deps.boundSessionIds(),
+            ...(archivedSessionIds === undefined ? {} : { archivedSessionIds }),
+            query,
+            copy: deps.copy,
+        });
+        return { outcome: 'ok', options: filterResumeCandidates(candidates, query, 25) };
     };
 }

package/lib/gateway/inbound.d.ts

@@ -40,6 +40,20 @@ export interface NormalizedMessage {
     mentionedBot: boolean;
     /** The snowflake of the message this one replies to, when present and valid. */
     repliedToId: DiscordSnowflake | undefined;
+    /**
+     * DECLARED image-attachment metadata (16.50): supported types only,
+     * malformed entries skipped, capped at Discord's per-message limit. No
+     * bytes cross this boundary — download happens later, behind the
+     * allowlisted fetch boundary.
+     */
+    images: DiscordImageAttachment[];
+}
+/** One supported image attachment, as declared by the wire. */
+export interface DiscordImageAttachment {
+    url: string;
+    filename: string;
+    declaredSize: number;
+    contentType: string;
 }
 /** A validated guild interaction with its actor identity. */
 export interface NormalizedInteraction {

package/lib/gateway/inbound.js

@@ -40,6 +40,46 @@ function extractRoleIds(payload) {
 function asSnowflake(value) {
     return isDiscordSnowflake(value) ? value : undefined;
 }
+/** Image content types the adapter carries (design.md §12). */
+const SUPPORTED_IMAGE_TYPES = new Set([
+    'image/jpeg',
+    'image/png',
+    'image/webp',
+    'image/gif',
+]);
+/** Discord's per-message attachment cap; a defensive bound on untrusted input. */
+const MAX_MESSAGE_IMAGES = 10;
+/**
+ * Narrow untrusted `attachments` onto declared image metadata. Entries that
+ * are not records, lack any required field, or declare an unsupported media
+ * type are skipped — a malformed attachment never rejects the message.
+ */
+function extractImages(payload) {
+    const raw = payload['attachments'];
+    if (!Array.isArray(raw))
+        return [];
+    const images = [];
+    for (const entry of raw) {
+        if (images.length >= MAX_MESSAGE_IMAGES)
+            break;
+        if (!isRecord(entry))
+            continue;
+        const url = entry['url'];
+        const filename = entry['filename'];
+        const size = entry['size'];
+        const contentType = entry['content_type'];
+        if (typeof url !== 'string' || url === '')
+            continue;
+        if (typeof filename !== 'string' || filename === '')
+            continue;
+        if (typeof size !== 'number' || !Number.isFinite(size) || size < 0)
+            continue;
+        if (typeof contentType !== 'string' || !SUPPORTED_IMAGE_TYPES.has(contentType))
+            continue;
+        images.push({ url, filename, declaredSize: size, contentType });
+    }
+    return images;
+}
 function parseMessage(payload, selfUserId) {
     // Webhook-authored messages are app-driven surfaces, not member input:
     // their author object need not carry `bot: true`, and anyone with
@@ -93,6 +133,7 @@ function parseMessage(payload, selfUserId) {
             content: stripped.text,
             mentionedBot: stripped.mentioned,
             repliedToId,
+            images: extractImages(payload),
         },
     };
 }