@addozhang/dsh-discord 0.2.3 → 0.3.0

package/README.md

@@ -109,6 +109,7 @@ The settings card exposes the three high-frequency fields (guild allowlist, auto
 | `/queue list`, `/queue remove` | session thread | inspect and trim the pending queue |
 | `/steer`, `/stop` | session thread | steer or cancel the running turn (owner only) |
 | `/model show` / `select` | session thread | show the live model directory; `select` without arguments walks the interactive provider → model → reasoning cascade (any authorized member by default) |
+| `/session resume` | project channel | pick one of this workspace's past sessions (autocomplete: title and age, newest first) and resume it into a new thread of this channel; blank, already-bound, subagent, and archived sessions are never offered |
 | `/guild forget` | any channel | operator-only removal of adapter records |
 
 ## Design notes
@@ -122,7 +123,6 @@ The settings card exposes the three high-frequency fields (guild allowlist, auto
 
 ## Known Limitations and Deferred Work
 
-- **`/session new|resume` is not registered** — the selector and cold-adoption modules are implemented and unit-tested, but the Host RPC face cannot back them yet (`sessions.list` v1 returns bare ids; no `session.inspect`). They return with the next milestone.
 - **`/preset`, `/skill`, and `/host` stay deregistered** — their control modules are implemented and unit-tested and return when the router wires them (the `/preset` thread-context guard rides along).
 - **Verbosity is a single global setting** (the DSH ecosystem has per-channel precedent).
 - **Deferred after a Kimaki parity pass**: reconcile-interactions wiring, typing pause during ask waits, fail-closed binding/session-owner store wiring, and credential-rotation watching.

package/README.zh.md

@@ -109,6 +109,7 @@ dsh-discord:
 | `/queue list`, `/queue remove` | 会话线程 | 查看与移除待处理队列 |
 | `/steer`, `/stop` | 会话线程 | 插话或取消运行中的 Turn（仅属主） |
 | `/model show` / `select` | 会话线程 | 查看实时模型目录；`select` 不带参数时走交互式 provider → 模型 → 推理强度级联（默认对所有授权成员开放） |
+| `/session resume` | 项目频道 | 自动补全选择本工作区的历史会话（显示标题与时间，最新优先），恢复为当前频道的新线程；空白、已挂线程、subagent、已归档的会话不会出现 |
 | `/guild forget` | 任意频道 | 仅操作员：移除适配器记录 |
 
 
@@ -123,7 +124,6 @@ dsh-discord:
 
 ## 已知限制与推迟项
 
-- **`/session new|resume` 未注册** — 选择器与冷收养模块已实现并通过单元测试，但 Host RPC 面尚不支持（`sessions.list` v1 只返回裸 id；缺少 `session.inspect`）。将在下个里程碑回归。
 - **`/preset`、`/skill`、`/host` 保持注销状态** — 控制模块已实现并通过单元测试，待路由接线时回归（`/preset` 的会话线程守卫一并处理）。
 - **verbosity 为全局设置**（DSH 生态有按频道设置的先例）。
 - **经 Kimaki 对齐后有意推迟**：reconcile-interactions 接线、ask 等待期暂停 typing、fail-closed 绑定/会话属主 store 接线、凭据轮换监听。

package/lib/discord/commands.js

@@ -35,6 +35,12 @@ export const MILESTONE_ONE_COMMANDS = [
         // → reasoning cascade (16.35); typing `provider/model` applies directly.
         { name: 'select', options: [{ name: 'model', required: false }, { name: 'reasoning', required: false }] },
     ]),
+    grouped('session', 'Resume a DSH session into a new thread', [
+        // Typing filters live candidates by session title (autocomplete);
+        // /session new is deliberately absent — the @mention IS the new-session
+        // path (design.md §13).
+        { name: 'resume', options: [{ name: 'session', required: true, autocomplete: true }] },
+    ]),
     grouped('guild', 'Guild-scoped adapter operations', [
         { name: 'forget' },
     ]),

package/lib/dsh/api-proxy-face.d.ts

@@ -62,9 +62,7 @@ export interface DshApiProxyFace {
         list(request: RpcRequestShape<{
             cursor?: string;
         }>): Promise<RpcResponseShape<{
-            items: Array<{
-                sessionId: string;
-            }>;
+            items: SessionSummaryShape[];
         }>>;
         models(request: RpcRequestShape<{
             sessionId: string;
@@ -79,6 +77,29 @@ export interface DshApiProxyFace {
         }>>;
     };
 }
+/** Defensive read of the title projection in a list row's values. */
+export interface SessionProjectionsShape {
+    values?: {
+        title?: unknown;
+    };
+}
+/** The per-session summary `sessions.list` returns (rc.2 rich rows). */
+export interface SessionSummaryShape {
+    sessionId: string;
+    updatedAt: number;
+    running: boolean;
+    blank: boolean;
+    cwd?: string;
+    agentPreset?: string;
+    origin?: 'subagent';
+    projections?: SessionProjectionsShape;
+}
+/** The complete provider/model/reasoning selection (dsh-agent ModelSelection). */
+export interface ModelSelectionShape {
+    provider: string;
+    model: string;
+    reasoningEffort?: string;
+}
 /** One reasoning effort a model's adapter advertises (sessions.d.ts). */
 import type { DshModelPort } from '../features/model-control.js';
 export interface ModelReasoningEffortShape {
@@ -115,12 +136,6 @@ export interface SessionModelsShape {
         message: string;
     }>;
 }
-/** The complete provider/model/reasoning selection (dsh-agent ModelSelection). */
-export interface ModelSelectionShape {
-    provider: string;
-    model: string;
-    reasoningEffort?: string;
-}
 /** Signature-layer narrow request form (RpcId brand erased at this seam). */
 export interface RpcRequestShape<P> {
     rpcId: string;
@@ -246,6 +261,31 @@ export type SessionIdListOutcome = {
 };
 /** List durable Session ids (`session.list`, v1 returns everything). */
 export declare function listSessionIds(dsh: DshApiProxyFace, options?: ApiProxyFaceOptions): Promise<SessionIdListOutcome>;
+/** A list row narrowed to what the /session resume surface renders. */
+export interface SessionResumeRow {
+    sessionId: string;
+    title: string | undefined;
+    updatedAt: number;
+    running: boolean;
+    blank: boolean;
+    cwd: string | undefined;
+    origin: 'subagent' | undefined;
+}
+export type SessionSummariesOutcome = {
+    outcome: 'completed';
+    sessions: SessionResumeRow[];
+} | {
+    outcome: 'failed';
+} | {
+    outcome: 'unknown';
+};
+/**
+ * The rich `sessions.list` for the /session resume surface: titles ride each
+ * row's projection values (absence = the session has no title yet), blank
+ * sessions are flagged, and rows arrive updatedAt-descending. Defensive
+ * narrowing: the wire is untrusted, extra/missing fields never throw.
+ */
+export declare function listSessionSummaries(dsh: DshApiProxyFace, options?: ApiProxyFaceOptions): Promise<SessionSummariesOutcome>;
 export type CancelOutcome = {
     outcome: 'accepted';
 } | {

package/lib/dsh/api-proxy-face.js

@@ -101,7 +101,19 @@ export function createWorkspaceCatalogPort(dsh, options = {}) {
                     workspaces: items.map(workspace => ({
                         id: workspace.workspaceId,
                         title: workspace.title,
+                        // The registered path rides every workspace.* row (Host
+                        // WorkspaceView); /session resume scopes candidates by it and
+                        // /project autocomplete abbreviates it — dropping it here once
+                        // silently emptied the resume list everywhere (16.46).
+                        ...(typeof workspace.path === 'string' ? { path: workspace.path } : {}),
                     })),
+                    // The registry's archived set rides the workspace.list value
+                    // (sessions.list rows carry NO archived marker): /session resume
+                    // subtracts it — resuming an archived session dead-ends in a
+                    // thread whose turns never run (16.49).
+                    archivedSessionIds: Array.isArray(result.value.archivedSessionIds)
+                        ? result.value.archivedSessionIds.filter((id) => typeof id === 'string')
+                        : [],
                 };
             }
             log?.('discord_workspace_list_rejected', {
@@ -271,6 +283,55 @@ export async function listSessionIds(dsh, options = {}) {
     log?.('discord_session_list_rejected', { code: result.error.code });
     return { outcome: 'failed' };
 }
+/**
+ * The rich `sessions.list` for the /session resume surface: titles ride each
+ * row's projection values (absence = the session has no title yet), blank
+ * sessions are flagged, and rows arrive updatedAt-descending. Defensive
+ * narrowing: the wire is untrusted, extra/missing fields never throw.
+ */
+export async function listSessionSummaries(dsh, options = {}) {
+    const timeoutMs = options.timeoutMs ?? CATALOG_TIMEOUT_MS;
+    const log = options.log;
+    let response;
+    try {
+        response = await withRpcTimeout(dsh.sessions.list(mintRequest({})), timeoutMs);
+    }
+    catch (cause) {
+        if (cause instanceof RpcTimeoutError) {
+            log?.('discord_session_summaries_timeout', { timeoutMs });
+            return { outcome: 'unknown' };
+        }
+        log?.('discord_session_summaries_threw', { cause: String(cause) });
+        return { outcome: 'unknown' };
+    }
+    const result = response?.result;
+    if (result === undefined || !result.ok || !Array.isArray(result.value.items)) {
+        log?.('discord_session_summaries_malformed');
+        return { outcome: 'failed' };
+    }
+    const sessions = [];
+    // The wire is untrusted: narrow every row defensively before use.
+    const items = Array.isArray(result.value.items) ? result.value.items : [];
+    for (const item of items) {
+        if (typeof item !== 'object' || item === null)
+            continue;
+        const row = item;
+        if (typeof row.sessionId !== 'string' || row.sessionId === '')
+            continue;
+        const values = row.projections?.values;
+        const title = typeof values?.title === 'string' && values.title !== '' ? values.title : undefined;
+        sessions.push({
+            sessionId: row.sessionId,
+            title,
+            updatedAt: typeof row.updatedAt === 'number' ? row.updatedAt : 0,
+            running: row.running ?? false,
+            blank: row.blank === true,
+            cwd: typeof row.cwd === 'string' ? row.cwd : undefined,
+            origin: row.origin === 'subagent' ? 'subagent' : undefined,
+        });
+    }
+    return { outcome: 'completed', sessions };
+}
 /** Cancel the session's active turn (`session.cancel`); DSH preserves the pending inbox. */
 export async function cancelSessionViaProxy(dsh, request, options = {}) {
     const timeoutMs = options.timeoutMs ?? CATALOG_TIMEOUT_MS;

package/lib/features/interaction-router.d.ts

@@ -85,6 +85,48 @@ export interface InteractionRouterDeps {
     purgeChannelBinding: (guildId: string, channelId: string) => Promise<void>;
     /** The session's live model directory + selection mutation (/model surface). */
     model: DshModelPort;
+    /**
+     * /session resume autocomplete candidates: rich Host rows filtered to
+     * non-blank, unbound sessions, title-filtered, newest-first, capped at 25
+     * (16.44).
+     */
+    resumeCandidates: (query: string, workspacePath?: string, archivedSessionIds?: ReadonlySet<string>) => Promise<{
+        outcome: 'ok';
+        options: Array<{
+            label: string;
+            value: string;
+            description?: string;
+        }>;
+    } | {
+        outcome: 'unavailable';
+    }>;
+    /**
+     * Cold-adopt a session into a NEW thread of the bound project channel:
+     * anchor post → message-anchored thread creation → durable thread→session
+     * binding. Already-bound sessions resolve to their existing thread
+     * (16.44).
+     */
+    resumeSession: (input: {
+        sessionId: string;
+        workspaceId: string;
+        guildId: string;
+        parentChannelId: string;
+        actorId: string;
+    }) => Promise<{
+        outcome: 'started';
+        threadId: string;
+    } | {
+        outcome: 'already-bound';
+        threadId: string;
+    } | {
+        outcome: 'refused-control-channel';
+    } | {
+        outcome: 'refused-subagent';
+    } | {
+        outcome: 'refused-archived';
+    } | {
+        outcome: 'failed';
+    }>;
     /**
      * Whether /model select stays Host-operator-only (default). Single-user
      * deployments flip this so any authorized member can switch (16.42).

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/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/i18n.d.ts

@@ -109,6 +109,19 @@ declare const zh: {
     modelNotInCatalog: string;
     modelInvalidReasoning: string;
     modelTypedParseFailed: string;
+    sessionResumeNeedsBoundChannel: string;
+    sessionResumeStarted: (threadId: string) => string;
+    sessionResumeAlreadyBound: (threadId: string) => string;
+    sessionResumeFailed: string;
+    sessionResumeAnchor: (title: string) => string;
+    sessionResumeControlChannel: string;
+    sessionResumeSubagent: string;
+    sessionResumeArchived: string;
+    sessionCandidateJustNow: string;
+    sessionCandidateMinutesAgo: (minutes: number) => string;
+    sessionCandidateHoursAgo: (hours: number) => string;
+    sessionCandidateDaysAgo: (days: number) => string;
+    sessionCandidateRunning: string;
     approvalRequired: (label: string) => string;
 };
 export type CopyTable = typeof zh;

package/lib/i18n.js

@@ -118,6 +118,22 @@ const zh = {
     modelNotInCatalog: '⚠️ 该 provider/模型不在当前会话的目录中。',
     modelInvalidReasoning: '⚠️ 该推理强度对此模型无效。',
     modelTypedParseFailed: '⚠️ 模型需按 `provider/model` 格式填写，或留空进入交互式选择。',
+    // ── /session resume ──────────────────────────────────────────────────
+    sessionResumeNeedsBoundChannel: '⚠️ /session resume 需要在已绑定工作区的项目频道中使用。',
+    sessionResumeStarted: (threadId) => `✅ 会话已恢复到 <#${threadId}>——历史在 Web 界面查看，线程内直接续聊。`,
+    sessionResumeAlreadyBound: (threadId) => `该会话已在 <#${threadId}> 中。`,
+    sessionResumeFailed: '⚠️ 会话恢复失败，请稍后重试。',
+    sessionResumeAnchor: (title) => `📌 恢复会话：${title}`,
+    sessionResumeControlChannel: 'general 是控制频道，不承载会话——请到工作区频道使用 /session resume。',
+    sessionResumeSubagent: '⚠️ 这是 subagent 会话，不能恢复为顶层线程——可在 Web 界面查看。',
+    sessionResumeArchived: '⚠️ 该会话已归档，恢复后不会有任何运行——请在 Web 界面先取消归档。',
+    // Discord autocomplete choices carry no description field, so the age and
+    // running marker ride the candidate label (16.47).
+    sessionCandidateJustNow: '刚刚',
+    sessionCandidateMinutesAgo: (minutes) => `${String(minutes)} 分钟前`,
+    sessionCandidateHoursAgo: (hours) => `${String(hours)} 小时前`,
+    sessionCandidateDaysAgo: (days) => `${String(days)} 天前`,
+    sessionCandidateRunning: '运行中',
     // ── approval / question cards ────────────────────────────────────────
     approvalRequired: (label) => `Approval required — ${label}`,
 };
@@ -223,6 +239,20 @@ const en = {
     modelNotInCatalog: "⚠️ That provider/model is not in this session's catalog.",
     modelInvalidReasoning: '⚠️ That reasoning effort is not valid for this model.',
     modelTypedParseFailed: '⚠️ The model must be `provider/model`, or left empty for the interactive cascade.',
+    // ── /session resume ──────────────────────────────────────────────────
+    sessionResumeNeedsBoundChannel: '⚠️ /session resume must run in a bound project channel.',
+    sessionResumeStarted: threadId => `✅ Session resumed into <#${threadId}> — full history lives in the web UI; continue in the thread.`,
+    sessionResumeAlreadyBound: threadId => `This session already lives in <#${threadId}>.`,
+    sessionResumeFailed: '⚠️ Resuming the session failed; try again later.',
+    sessionResumeAnchor: title => `📌 Resumed session: ${title}`,
+    sessionResumeControlChannel: 'general is the control channel and carries no sessions — use /session resume in a workspace channel.',
+    sessionResumeSubagent: '⚠️ That is a subagent session — it cannot be resumed as a top-level thread; view it in the web UI.',
+    sessionResumeArchived: '⚠️ That session is archived — a resumed one never runs; unarchive it in the web UI first.',
+    sessionCandidateJustNow: 'just now',
+    sessionCandidateMinutesAgo: minutes => `${String(minutes)}m ago`,
+    sessionCandidateHoursAgo: hours => `${String(hours)}h ago`,
+    sessionCandidateDaysAgo: days => `${String(days)}d ago`,
+    sessionCandidateRunning: 'running',
     // ── approval / question cards ────────────────────────────────────────
     approvalRequired: label => `Approval required — ${label}`,
 };

package/lib/index.js

@@ -1,7 +1,7 @@
 import { DEFAULT_DISCORD_SETTINGS, DiscordSettingsSchema, installDiscordSettings, normalizeDiscordSettings, } from './settings.js';
 import { settingsNamespace } from '@deepseek-ai/dsh-settings';
 import { installCancellationRoot } from './lifecycle.js';
-import { ALLOWED_MENTIONS_NONE, DISCORD_SUPPRESS_NOTIFICATIONS_FLAG, OUTBOUND_EPHEMERAL_FLAGS } from './policy/disclosure.js';
+import { ALLOWED_MENTIONS_NONE, DISCORD_SUPPRESS_NOTIFICATIONS_FLAG, OUTBOUND_EPHEMERAL_FLAGS, safeTitle } from './policy/disclosure.js';
 import { validateHostCapabilities } from './startup.js';
 import { createAdapterStatusTracker, installAdapterStatusRpc, } from './features/adapter-status.js';
 import { DISCORD_BOT_TOKEN_REF, describeDiscordCredential, resolveDiscordBotToken } from './credential.js';
@@ -22,12 +22,13 @@ import { createInteractionRouter } from './features/interaction-router.js';
 import { channelBindingKey, parseChannelBindingKey, threadBindingKey, parseThreadBindingKey, discordDomainSpec, CHANNEL_BINDINGS_TABLE, THREAD_BINDINGS_TABLE, INTENTS_TABLE } from './state/domain.js';
 import { planBindingReconciliation } from './features/reconcile-bindings.js';
 import { guildKeysToForget, sweepExpired } from './state/retention.js';
-import { listSessionIds, createClientRespondPort } from './dsh/api-proxy-face.js';
+import { listSessionIds, listSessionSummaries, createClientRespondPort } from './dsh/api-proxy-face.js';
 import { createBindingStore } from './state/bindings.js';
 import { createIntentStore } from './state/intents.js';
 import { createTurnTracker } from './features/turn-ownership.js';
 import { createThreadCreationFlow } from './features/thread-creation.js';
 import { createSessionCreationFlow } from './features/session-creation.js';
+import { createResumeCandidatesPort } from './features/session-resume.js';
 import { createPromptSubmissionFlow } from './features/prompt-submission.js';
 import { createSessionMainline, requestIdFor } from './features/session-mainline.js';
 import { startLiveRender } from './stream/live.js';
@@ -702,6 +703,91 @@ export function apply(ctx, config = DEFAULT_DISCORD_SETTINGS) {
             },
             model: createModelPort(apiProxy, { log: rpcLog }),
             modelSelectOperatorOnly: () => current.modelSelectOperatorOnly,
+            resumeCandidates: createResumeCandidatesPort({
+                listSessions: () => listSessionSummaries(apiProxy, { log: rpcLog }),
+                boundSessionIds: () => {
+                    const bound = new Set();
+                    for (const [, record] of threadTable.entries())
+                        bound.add(record.sessionId);
+                    return bound;
+                },
+                copy,
+            }),
+            resumeSession: async ({ sessionId, workspaceId, guildId, parentChannelId, actorId }) => {
+                const rest = await sharedRest();
+                if (rest === undefined)
+                    return { outcome: 'failed' };
+                // threadBindings is the Discord-ownership record: a session with a
+                // binding already lives in a thread (16.44; the owners-store wiring
+                // stays deferred per 16.28).
+                const existingThread = threadForSession(sessionId);
+                if (existingThread !== undefined)
+                    return { outcome: 'already-bound', threadId: existingThread };
+                // The control channel never carries sessions: refuse explicitly so
+                // the user is pointed at the workspace channel (16.44 rev).
+                const listedChannels = await rest.request('GET', `/guilds/${guildId}/channels`);
+                if (listedChannels.outcome === 'completed') {
+                    const category = listedChannels.body.find(channel => channel.type === 4 && channel.name.toLowerCase() === CATEGORY_NAME.toLowerCase());
+                    const control = category !== undefined
+                        ? listedChannels.body.find(channel => channel.type === 0 && channel.parent_id === category.id && channel.name.toLowerCase() === 'general')
+                        : undefined;
+                    if (control !== undefined && control.id === parentChannelId) {
+                        return { outcome: 'refused-control-channel' };
+                    }
+                }
+                const summaries = await listSessionSummaries(apiProxy, { log: rpcLog });
+                if (summaries.outcome !== 'completed')
+                    return { outcome: 'failed' };
+                const summary = summaries.sessions.find(candidate => candidate.sessionId === sessionId);
+                if (summary === undefined || summary.blank)
+                    return { outcome: 'failed' };
+                // Spec scenario "Subagent Session selected": a subagent spawn is
+                // never a top-level writable thread, even if handed in directly
+                // (the candidates already hide it — 16.48).
+                if (summary.origin === 'subagent')
+                    return { outcome: 'refused-subagent' };
+                // Same defense for archived sessions (16.49): adoption would
+                // succeed and the thread would never see a turn.
+                const catalog = await catalogPort.listWorkspaces();
+                if (catalog.outcome === 'completed'
+                    && catalog.archivedSessionIds.includes(sessionId)) {
+                    return { outcome: 'refused-archived' };
+                }
+                const title = summary.title ?? `Resume ${sessionId.slice(0, 8)}`;
+                // Anchor post: a durable marker the resume thread hangs off.
+                const anchor = await rest.request('POST', `/channels/${parentChannelId}/messages`, {
+                    content: copy.sessionResumeAnchor(safeTitle(title)),
+                    flags: DISCORD_SUPPRESS_NOTIFICATIONS_FLAG,
+                    allowed_mentions: ALLOWED_MENTIONS_NONE,
+                });
+                if (anchor.outcome === 'rejected') {
+                    rpcLog('discord_session_resume_anchor_failed', { sessionId, status: `HTTP ${String(anchor.status)}` });
+                    return { outcome: 'failed' };
+                }
+                if (anchor.outcome === 'unknown' || typeof anchor.body.id !== 'string') {
+                    rpcLog('discord_session_resume_anchor_unknown', { sessionId });
+                    return { outcome: 'failed' };
+                }
+                const thread = await rest.request('POST', `/channels/${parentChannelId}/messages/${anchor.body.id}/threads`, {
+                    name: safeTitle(title),
+                });
+                if (thread.outcome === 'rejected') {
+                    rpcLog('discord_session_resume_thread_failed', { sessionId, status: `HTTP ${String(thread.status)}` });
+                    return { outcome: 'failed' };
+                }
+                if (thread.outcome === 'unknown' || typeof thread.body.id !== 'string') {
+                    rpcLog('discord_session_resume_thread_unknown', { sessionId });
+                    return { outcome: 'failed' };
+                }
+                await threadBindingStore.bind(threadBindingKey({ applicationId: applicationIdRef.current, guildId, threadId: thread.body.id }), {
+                    sessionId,
+                    workspaceId,
+                    createdBy: actorId,
+                    createdAtMs: Date.now(),
+                });
+                rpcLog('discord_session_resumed', { sessionId, threadId: thread.body.id, title });
+                return { outcome: 'started', threadId: thread.body.id };
+            },
             log: rpcLog,
             warn: (event, detail) => {
                 emitLog(ctx, 'warn', { event, detail: typeof detail === 'string' ? detail : JSON.stringify(detail ?? null) });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@addozhang/dsh-discord",
-  "version": "0.2.3",
+  "version": "0.3.0",
   "description": "Discord-first adapter for DeepSeek Harness",
   "license": "MIT",
   "type": "module",
@@ -91,5 +91,16 @@
   "bugs": {
     "url": "https://github.com/addozhang/dsh-discord/issues"
   },
-  "homepage": "https://github.com/addozhang/dsh-discord#readme"
+  "homepage": "https://github.com/addozhang/dsh-discord#readme",
+  "keywords": [
+    "discord",
+    "deepseek",
+    "deepseek-harness",
+    "dsh",
+    "dsh-plugin",
+    "bot",
+    "ai-agent",
+    "claude-code",
+    "coding-agent"
+  ]
 }