discord-agent-bridge 0.1.0

package/dist/discord/interactionRouter.test.js

@@ -0,0 +1,1245 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { InteractionRouter, } from './interactionRouter.js';
+import { ConfigStore } from '../core/config.js';
+import { CONFIG_VERSION } from '../core/configSchema.js';
+import { StateStore } from '../core/state/store.js';
+import { ChannelRegistry } from '../core/channelRegistry.js';
+import { ConfigResolver } from '../core/configResolver.js';
+import { PermissionResolver } from '../core/permissionResolver.js';
+import { ModeRegistry } from '../core/modeRegistry.js';
+import { Authorizer } from '../core/auth.js';
+import { createLogger } from '../core/logger.js';
+const logger = createLogger('test', { level: 'error', sink: { write() { } } });
+const CLAUDE_CAPS = {
+    streaming: true,
+    thinking: true,
+    toolThreads: true,
+    permissionPrompts: true,
+    progress: false,
+    transcript: false,
+    sessionResume: true,
+    fileAttach: true,
+    fileDiff: true,
+    usagePanel: true,
+    permissionModes: ['default', 'acceptEdits', 'bypassPermissions', 'plan'],
+};
+// A no-op AgentMode used only for its name + capabilities in the router. `resumable`
+// scripts what listResumable returns (per-backend, for the resume-flow tests); when
+// undefined, listResumable is absent so the mode simply has no resumable list.
+class StubMode {
+    name;
+    capabilities;
+    resumable;
+    constructor(name, capabilities, resumable) {
+        this.name = name;
+        this.capabilities = capabilities;
+        this.resumable = resumable;
+        if (this.resumable !== undefined) {
+            this.listResumable = async (_ctx) => this.resumable;
+        }
+    }
+    listResumable;
+    async start(_ctx) {
+        return { sessionId: `${this.name}-sess`, async send() { }, async stop() { } };
+    }
+    async resume(_ctx, id) {
+        return { sessionId: id, async send() { }, async stop() { } };
+    }
+}
+const ADMIN_ROLE = 'role-admin';
+const EXEC_ROLE = 'role-exec';
+function writeConfig(dir) {
+    const config = {
+        version: CONFIG_VERSION,
+        discord: { token: 'x', clientId: 'cid' },
+        auth: {
+            adminRoleIds: [ADMIN_ROLE],
+            executeRoleIds: [EXEC_ROLE],
+            readOnlyRoleIds: [],
+            dmPolicy: 'deny',
+        },
+        defaults: {
+            mode: 'claude',
+            claudeModel: 'opus',
+            codexModel: '',
+            permissionMode: 'default',
+            permissionProfile: null,
+            codexHome: '~/.codex',
+            codexCliCommand: 'codex',
+            codexCliVersion: null,
+        },
+        limits: { maxSessionsPerUser: 0, permissionTimeoutSec: 60, codexTimeoutMs: 1_800_000 },
+        policy: { unknownCommand: 'confirm', allowExtraCommands: [] },
+        autoAllowClaudeTools: ['Read'],
+        profiles: {},
+        usage: { userAgent: 'claude-code', cacheSec: 180 },
+        audit: { channelId: null },
+        locale: 'ko',
+        logLevel: 'info',
+        favorites: [],
+    };
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, 'config.json'), JSON.stringify(config));
+}
+function binding(cwd, over = {}) {
+    return {
+        guildId: 'g1',
+        channelId: 'c1',
+        mode: 'claude',
+        sessionId: 's1',
+        cwd,
+        ownerId: 'owner',
+        permMode: 'default',
+        profile: null,
+        archived: false,
+        createdAt: 'now',
+        updatedAt: 'now',
+        ...over,
+    };
+}
+// A recording SessionWiring double.
+function fakeWiring() {
+    const calls = {
+        attach: vi.fn(async (_g, _c, _m) => { }),
+        detach: vi.fn((_g, _c) => { }),
+        resolvePermission: vi.fn(async (_g, _c, _id, _actor) => ({ behavior: 'allow' })),
+    };
+    return { wiring: calls, calls };
+}
+// A recording orchestrator double.
+function fakeOrchestrator() {
+    const calls = {
+        start: vi.fn(async () => ({ sessionId: 'new-sess', async send() { }, async stop() { } })),
+        resume: vi.fn(async (_p, sessionId) => ({ sessionId, async send() { }, async stop() { } })),
+        stop: vi.fn(async (_g, _c) => { }),
+        stopAll: vi.fn(async () => { }),
+        // A minimal read-only ModeContext for listResumable (cwd/config/logger only).
+        buildListContext: vi.fn((_mode, cwd) => ({
+            guildId: '',
+            channelId: '',
+            cwd,
+            ownerId: '',
+            permMode: 'default',
+            emit: () => { },
+            requestPermission: async () => ({ behavior: 'deny' }),
+            config: {},
+            logger,
+            audit: () => { },
+        })),
+    };
+    return { orchestrator: calls, calls };
+}
+function slash(over) {
+    const replies = [];
+    const acks = [];
+    let acked = false;
+    const roles = over.roles ?? [EXEC_ROLE];
+    const interaction = {
+        kind: 'slash',
+        guildId: over.guildId ?? 'g1',
+        channelId: over.channelId ?? 'c1',
+        user: over.user ?? { id: 'u1' },
+        member: { roles: { cache: { map: (fn) => roles.map((id) => fn({ id })) } } },
+        ...(over.hasAdminPermission !== undefined ? { hasAdminPermission: over.hasAdminPermission } : {}),
+        commandName: over.commandName ?? 'agent',
+        subcommand: over.subcommand ?? null,
+        getString: () => over.getStringValue ?? null,
+        reply: async (o) => {
+            acked = true;
+            acks.push({ kind: 'reply', payload: o });
+            replies.push(o);
+        },
+        deferReply: async (o) => {
+            acked = true;
+            acks.push({ kind: 'deferReply', payload: o });
+        },
+        editReply: async (o) => {
+            acked = true;
+            acks.push({ kind: 'editReply', payload: o });
+            replies.push(o);
+        },
+        followUp: async (o) => {
+            acked = true;
+            acks.push({ kind: 'followUp', payload: o });
+            replies.push(o);
+        },
+        get acknowledged() {
+            return acked;
+        },
+    };
+    return { interaction, replies, acks };
+}
+function component(over) {
+    const replies = [];
+    const acks = [];
+    let acked = false;
+    const roles = over.roles ?? [EXEC_ROLE];
+    const interaction = {
+        kind: 'component',
+        guildId: over.guildId ?? 'g1',
+        channelId: over.channelId ?? 'c1',
+        user: over.user ?? { id: 'u1' },
+        member: { roles: { cache: { map: (fn) => roles.map((id) => fn({ id })) } } },
+        ...(over.hasAdminPermission !== undefined ? { hasAdminPermission: over.hasAdminPermission } : {}),
+        customId: over.customId ?? 'x',
+        ...(over.value !== undefined ? { value: over.value } : {}),
+        ...(over.values !== undefined ? { values: over.values } : {}),
+        reply: async (o) => {
+            acked = true;
+            acks.push({ kind: 'reply', payload: o });
+            replies.push(o);
+        },
+        deferReply: async (o) => {
+            acked = true;
+            acks.push({ kind: 'deferReply', payload: o });
+        },
+        editReply: async (o) => {
+            acked = true;
+            acks.push({ kind: 'editReply', payload: o });
+            replies.push(o);
+        },
+        followUp: async (o) => {
+            acked = true;
+            acks.push({ kind: 'followUp', payload: o });
+            replies.push(o);
+        },
+        deferUpdate: async () => {
+            acked = true;
+            acks.push({ kind: 'deferUpdate' });
+        },
+        showModal: async (modal) => {
+            // showModal IS the ack — record it (and mark acknowledged) so a test can assert
+            // it fired without a preceding defer.
+            acked = true;
+            acks.push({ kind: 'showModal', modal });
+        },
+        get acknowledged() {
+            return acked;
+        },
+    };
+    return { interaction, replies, acks };
+}
+// A scripted ModalSubmit interaction: `fields` maps field custom id → submitted value.
+function modalSubmit(over) {
+    const replies = [];
+    const acks = [];
+    let acked = false;
+    const roles = over.roles ?? [EXEC_ROLE];
+    const fields = over.fields ?? {};
+    const interaction = {
+        kind: 'modalSubmit',
+        guildId: over.guildId ?? 'g1',
+        channelId: over.channelId ?? 'c1',
+        user: over.user ?? { id: 'u1' },
+        member: { roles: { cache: { map: (fn) => roles.map((id) => fn({ id })) } } },
+        ...(over.hasAdminPermission !== undefined ? { hasAdminPermission: over.hasAdminPermission } : {}),
+        customId: over.customId ?? 'config.codexHome.modal',
+        getField: (id) => fields[id] ?? '',
+        reply: async (o) => {
+            acked = true;
+            acks.push({ kind: 'reply', payload: o });
+            replies.push(o);
+        },
+        deferReply: async (o) => {
+            acked = true;
+            acks.push({ kind: 'deferReply', payload: o });
+        },
+        editReply: async (o) => {
+            acked = true;
+            acks.push({ kind: 'editReply', payload: o });
+            replies.push(o);
+        },
+        followUp: async (o) => {
+            acked = true;
+            acks.push({ kind: 'followUp', payload: o });
+            replies.push(o);
+        },
+        get acknowledged() {
+            return acked;
+        },
+    };
+    return { interaction, replies, acks };
+}
+let home;
+let store;
+let stateStore;
+let channelRegistry;
+let configResolver;
+let permissionResolver;
+let modeRegistry;
+let authorizer;
+function buildRouter(deps) {
+    return new InteractionRouter({
+        authorizer,
+        orchestrator: deps.orchestrator,
+        channelRegistry,
+        configStore: store,
+        configResolver,
+        permissionResolver,
+        modeRegistry,
+        wiring: deps.wiring,
+        logger: deps.logger ?? logger,
+        modelsFor: () => [
+            { value: 'opus', label: 'opus' },
+            { value: 'sonnet', label: 'sonnet' },
+        ],
+        ...(deps.browseRoots ? { browseRoots: deps.browseRoots } : {}),
+        ...(deps.resolveGuildProvisioner ? { resolveGuildProvisioner: deps.resolveGuildProvisioner } : {}),
+        ...(deps.resolveChannel ? { resolveChannel: deps.resolveChannel } : {}),
+    });
+}
+// A fake provisioner for /init + session-channel tests: records creates + deletes and
+// resolves reuse by an in-memory channel map (mirrors guildChannels.test.ts's fake).
+class FakeProvisioner {
+    guildId;
+    channels = new Map(); // id → name
+    createdNames = [];
+    deleted = [];
+    seq = 0;
+    manageChannels = true;
+    constructor(guildId = 'g1') {
+        this.guildId = guildId;
+    }
+    canManageChannels() {
+        return this.manageChannels;
+    }
+    channelExists(id) {
+        return this.channels.has(id);
+    }
+    nextId() {
+        this.seq += 1;
+        return `chan-${this.seq}`;
+    }
+    async ensureCategory(name, existingId) {
+        if (existingId && this.channels.has(existingId))
+            return { id: existingId, name: this.channels.get(existingId) };
+        const id = this.nextId();
+        this.channels.set(id, name);
+        this.createdNames.push(name);
+        return { id, name };
+    }
+    async ensureTextChannel(name, _parentId, existingId) {
+        if (existingId && this.channels.has(existingId))
+            return { id: existingId, name: this.channels.get(existingId) };
+        const id = this.nextId();
+        this.channels.set(id, name);
+        this.createdNames.push(name);
+        return { id, name };
+    }
+    async createTextChannel(name, _parentId) {
+        const id = this.nextId();
+        this.channels.set(id, name);
+        this.createdNames.push(name);
+        return { id, name };
+    }
+    async deleteChannel(id) {
+        this.channels.delete(id);
+        this.deleted.push(id);
+    }
+}
+// A fake MessageChannel that records every posted message (for the intro/status post).
+function fakeMessageChannel() {
+    const posts = [];
+    const channel = {
+        send: async (msg) => {
+            posts.push(msg);
+            return { id: 'posted-msg', async edit() { } };
+        },
+        startThread: async () => ({ id: 'thread', async send() { return { id: 'm', async edit() { } }; } }),
+    };
+    return { channel, posts };
+}
+beforeEach(() => {
+    home = fs.mkdtempSync(path.join(os.tmpdir(), 'dab-ir-'));
+    writeConfig(home);
+    store = new ConfigStore(home);
+    stateStore = new StateStore(home);
+    channelRegistry = new ChannelRegistry(stateStore);
+    configResolver = new ConfigResolver(store, channelRegistry);
+    permissionResolver = new PermissionResolver(store, configResolver);
+    modeRegistry = new ModeRegistry();
+    modeRegistry.register(new StubMode('claude', CLAUDE_CAPS));
+    modeRegistry.register(new StubMode('codex', { ...CLAUDE_CAPS, usagePanel: false }));
+    authorizer = new Authorizer(store, channelRegistry);
+});
+afterEach(() => {
+    fs.rmSync(home, { recursive: true, force: true });
+});
+describe('InteractionRouter slash commands', () => {
+    it('/stop-all by a non-admin (execute) is denied — stopAll not called', async () => {
+        const { orchestrator, calls } = fakeOrchestrator();
+        const { wiring } = fakeWiring();
+        const router = buildRouter({ orchestrator, wiring });
+        const { interaction, replies, acks } = slash({ commandName: 'stop-all', roles: [EXEC_ROLE] });
+        await router.handle(interaction);
+        expect(calls.stopAll).not.toHaveBeenCalled();
+        // Deferred ephemerally FIRST, then the denial edits that ephemeral reply.
+        expect(acks[0].kind).toBe('deferReply');
+        expect(acks[0].payload?.ephemeral).toBe(true);
+        expect(replies[0].content).toContain('권한이 없습니다');
+    });
+    it('/stop-all by an admin stops all sessions', async () => {
+        const { orchestrator, calls } = fakeOrchestrator();
+        const { wiring } = fakeWiring();
+        const router = buildRouter({ orchestrator, wiring });
+        const { interaction } = slash({ commandName: 'stop-all', roles: [ADMIN_ROLE] });
+        await router.handle(interaction);
+        expect(calls.stopAll).toHaveBeenCalledOnce();
+    });
+    it('/agent start launches the wizard WITH the folder-picker components (not just text)', async () => {
+        const { orchestrator } = fakeOrchestrator();
+        const { wiring } = fakeWiring();
+        const router = buildRouter({ orchestrator, wiring });
+        const { interaction, replies } = slash({ commandName: 'agent', subcommand: 'start' });
+        await router.handle(interaction);
+        // The launched reply carries the step embed AND the folder-picker component rows —
+        // this is the LIVE bug: it used to send only the "마법사 열었어요" text with no
+        // components, so the user had nothing to click.
+        expect(replies[0].content).toContain('마법사');
+        expect(replies[0].embeds && replies[0].embeds.length).toBeGreaterThan(0);
+        const rows = (replies[0].components ?? []);
+        expect(rows.length).toBeGreaterThan(0);
+        const flat = rows.flatMap((r) => r.components);
+        // The folder select (dir:into) + ⬆ up / ✅ start buttons are all present.
+        expect(flat.some((c) => c.type === 'select' && c.customId === 'dir:into')).toBe(true);
+        expect(flat.some((c) => c.type === 'button' && c.customId === 'dir:up')).toBe(true);
+        expect(flat.some((c) => c.type === 'button' && c.customId === 'dir:here')).toBe(true);
+    });
+    it('/agent start: a folder-select advances the wizard and re-renders the NEXT step with components', async () => {
+        const { orchestrator } = fakeOrchestrator();
+        const { wiring } = fakeWiring();
+        const router = buildRouter({ orchestrator, wiring });
+        const { interaction: start } = slash({ commandName: 'agent', subcommand: 'start', user: { id: 'u1' } });
+        await router.handle(start);
+        // Selecting the current folder (✅ 이 폴더로 시작) advances folder → backend; the
+        // component is deferUpdate'd and the router edits the message with the backend step,
+        // which again carries components (the backend select + cancel button).
+        const { interaction: pick, replies } = component({ customId: 'dir:here', user: { id: 'u1' } });
+        await router.handle(pick);
+        const edited = replies.find((r) => r.components && r.components.length > 0);
+        expect(edited).toBeTruthy();
+        const rows = (edited.components ?? []);
+        const flat = rows.flatMap((r) => r.components);
+        expect(flat.some((c) => c.type === 'select' && c.customId === 'backend')).toBe(true);
+    });
+    it('/agent start: EVERY step advances via its BUTTON and re-renders the next step with components', async () => {
+        const { orchestrator } = fakeOrchestrator();
+        const { wiring } = fakeWiring();
+        const router = buildRouter({ orchestrator, wiring });
+        const { interaction: start } = slash({ commandName: 'agent', subcommand: 'start', user: { id: 'u1' } });
+        await router.handle(start);
+        // The choice steps advance on their confirm BUTTON (backend.next / model.next /
+        // effort.next), not the select's change. Each transition re-renders the next step
+        // with its select/buttons on the edited message. The final perm step carries the
+        // ✅ 시작 (perm.start) button.
+        const steps = [
+            { customId: 'dir:here', expectId: 'backend', expectType: 'select' },
+            { customId: 'backend.next', expectId: 'model', expectType: 'select' },
+            { customId: 'model.next', expectId: 'effort', expectType: 'select' },
+            { customId: 'effort.next', expectId: 'perm.start', expectType: 'button' },
+        ];
+        for (const step of steps) {
+            const { interaction, replies } = component({ customId: step.customId, user: { id: 'u1' } });
+            await router.handle(interaction);
+            const edited = replies.find((r) => r.components && r.components.length > 0);
+            expect(edited, `step after ${step.customId} must carry components`).toBeTruthy();
+            const flat = (edited.components ?? [])
+                .flatMap((r) => r.components);
+            expect(flat.some((c) => c.type === step.expectType && c.customId === step.expectId)).toBe(true);
+        }
+    });
+    it('/agent start: a select-change updates pending state + re-renders WITHOUT advancing', async () => {
+        const { orchestrator, calls } = fakeOrchestrator();
+        const { wiring } = fakeWiring();
+        const router = buildRouter({ orchestrator, wiring });
+        const { interaction: start } = slash({ commandName: 'agent', subcommand: 'start', user: { id: 'u1' } });
+        await router.handle(start);
+        await router.handle(component({ customId: 'dir:here', user: { id: 'u1' } }).interaction);
+        // Changing the backend select (to codex) must NOT advance to the model step — it
+        // re-renders the backend step with codex pre-selected; the session is not started.
+        const { interaction: change, replies } = component({ customId: 'backend', value: 'codex', user: { id: 'u1' } });
+        await router.handle(change);
+        const edited = replies.find((r) => r.components && r.components.length > 0);
+        const flat = (edited?.components ?? []).flatMap((r) => r.components);
+        // Still on the backend step (backend select + backend.next button), NOT the model step.
+        expect(flat.some((c) => c.customId === 'backend.next')).toBe(true);
+        expect(flat.some((c) => c.customId === 'model')).toBe(false);
+        const backendSelect = flat.find((c) => c.customId === 'backend');
+        expect(backendSelect?.options?.find((o) => o.value === 'codex')?.default).toBe(true);
+        expect(calls.start).not.toHaveBeenCalled();
+    });
+    it('/mode backend switches backend with the fresh-context warning', async () => {
+        channelRegistry.set(binding(home));
+        const { orchestrator, calls } = fakeOrchestrator();
+        const { wiring, calls: wcalls } = fakeWiring();
+        const router = buildRouter({ orchestrator, wiring });
+        const { interaction, acks } = slash({
+            commandName: 'mode',
+            subcommand: 'backend',
+            getStringValue: 'codex',
+        });
+        await router.handle(interaction);
+        expect(calls.stop).toHaveBeenCalledWith('g1', 'c1');
+        expect(wcalls.detach).toHaveBeenCalledWith('g1', 'c1');
+        expect(calls.start).toHaveBeenCalledOnce();
+        expect(wcalls.attach).toHaveBeenCalledWith('g1', 'c1', 'codex');
+        // The public fresh-context warning is a NON-ephemeral followUp (deferred reply is
+        // ephemeral); the confirmation edits the deferred reply.
+        const freshFollowUp = acks.find((a) => a.kind === 'followUp');
+        expect(freshFollowUp?.payload?.content).toContain('새 대화로 시작');
+        expect(freshFollowUp?.payload?.ephemeral).toBe(false);
+    });
+    it('/mode backend to an UNREGISTERED backend: ephemeral notice, session NOT stopped', async () => {
+        channelRegistry.set(binding(home));
+        const { orchestrator, calls } = fakeOrchestrator();
+        const { wiring, calls: wcalls } = fakeWiring();
+        const router = buildRouter({ orchestrator, wiring });
+        // 'gemini' is not registered (only claude + codex are), so it must be rejected
+        // WITHOUT tearing down the running session.
+        const { interaction, replies, acks } = slash({
+            commandName: 'mode',
+            subcommand: 'backend',
+            getStringValue: 'gemini',
+        });
+        await router.handle(interaction);
+        expect(calls.stop).not.toHaveBeenCalled();
+        expect(wcalls.detach).not.toHaveBeenCalled();
+        expect(calls.start).not.toHaveBeenCalled();
+        // Deferred ephemerally first; the notice edits that ephemeral reply.
+        expect(acks[0].kind).toBe('deferReply');
+        expect(acks[0].payload?.ephemeral).toBe(true);
+        expect(replies[0].content).toContain('gemini');
+    });
+    it('/mode backend with NO binding is rejected instead of falling back to cwd', async () => {
+        // No channelRegistry.set → no binding.
+        const { orchestrator, calls } = fakeOrchestrator();
+        const { wiring, calls: wcalls } = fakeWiring();
+        const router = buildRouter({ orchestrator, wiring });
+        const { interaction, acks } = slash({
+            commandName: 'mode',
+            subcommand: 'backend',
+            getStringValue: 'codex', // registered, but there is no session to switch
+        });
+        await router.handle(interaction);
+        expect(calls.stop).not.toHaveBeenCalled();
+        expect(wcalls.detach).not.toHaveBeenCalled();
+        expect(calls.start).not.toHaveBeenCalled();
+        // Deferred ephemerally first; the no-session notice edits that ephemeral reply.
+        expect(acks[0].kind).toBe('deferReply');
+        expect(acks[0].payload?.ephemeral).toBe(true);
+    });
+    it('/stop stops the channel session and detaches renderers', async () => {
+        const { orchestrator, calls } = fakeOrchestrator();
+        const { wiring, calls: wcalls } = fakeWiring();
+        const router = buildRouter({ orchestrator, wiring });
+        const { interaction } = slash({ commandName: 'stop' });
+        await router.handle(interaction);
+        expect(calls.stop).toHaveBeenCalledWith('g1', 'c1');
+        expect(wcalls.detach).toHaveBeenCalledWith('g1', 'c1');
+    });
+});
+describe('InteractionRouter component interactions', () => {
+    it('perm:<id>:allow button routes to wiring.resolvePermission with the acting user id', async () => {
+        const { orchestrator } = fakeOrchestrator();
+        const { wiring, calls } = fakeWiring();
+        const router = buildRouter({ orchestrator, wiring });
+        const { interaction } = component({ customId: 'perm:req-1:allow', user: { id: 'u1' } });
+        await router.handle(interaction);
+        // The acting user id is threaded so the handler can enforce the approver binding.
+        expect(calls.resolvePermission).toHaveBeenCalledWith('g1', 'c1', 'perm:req-1:allow', 'u1');
+    });
+    it('a foreign (non-perm, no-wizard) component is safely ignored (deferUpdate, no resolve)', async () => {
+        const { orchestrator } = fakeOrchestrator();
+        const { wiring, calls } = fakeWiring();
+        const router = buildRouter({ orchestrator, wiring });
+        const { interaction } = component({ customId: 'dir:up' });
+        await router.handle(interaction);
+        expect(calls.resolvePermission).not.toHaveBeenCalled();
+    });
+    it('a denied user clicking a perm button does NOT resolve it', async () => {
+        const { orchestrator } = fakeOrchestrator();
+        const { wiring, calls } = fakeWiring();
+        const router = buildRouter({ orchestrator, wiring });
+        const { interaction, replies } = component({ customId: 'perm:req-1:allow', roles: ['role-nobody'] });
+        await router.handle(interaction);
+        expect(calls.resolvePermission).not.toHaveBeenCalled();
+        expect(replies[0].content).toContain('권한이 없습니다');
+    });
+    it('a wizard component from a NON-owner is ignored; the owner advances it', async () => {
+        const { orchestrator, calls } = fakeOrchestrator();
+        const { wiring } = fakeWiring();
+        const router = buildRouter({ orchestrator, wiring });
+        // Owner 'u1' opens the wizard (browseRoots defaults to []; the browser starts at
+        // a resolvable root — 'dir:here' selects the current folder).
+        const { interaction: start } = slash({ commandName: 'agent', subcommand: 'start', user: { id: 'u1' } });
+        await router.handle(start);
+        const flow = [
+            { customId: 'dir:here' },
+            { customId: 'backend.next' },
+            { customId: 'model.next' },
+            { customId: 'effort.next' },
+            { customId: 'perm.start' },
+        ];
+        // A bystander 'u2' (also execute tier) runs the WHOLE flow → every input is
+        // ignored, so the session is never started.
+        for (const step of flow) {
+            const { interaction } = component({ ...step, user: { id: 'u2' } });
+            await router.handle(interaction);
+        }
+        expect(calls.start).not.toHaveBeenCalled();
+        // The owner 'u1' now advances the SAME wizard to completion → start is called.
+        for (const step of flow) {
+            const { interaction } = component({ ...step, user: { id: 'u1' } });
+            await router.handle(interaction);
+        }
+        expect(calls.start).toHaveBeenCalledOnce();
+    });
+});
+describe('InteractionRouter /config command', () => {
+    it('opens the panel for a Discord Administrator (empty allowlist bootstrap)', async () => {
+        const { orchestrator } = fakeOrchestrator();
+        const { wiring } = fakeWiring();
+        const router = buildRouter({ orchestrator, wiring });
+        // A user with NO allowlisted role but the Discord Administrator permission.
+        const { interaction, replies, acks } = slash({
+            commandName: 'config',
+            roles: ['role-nobody'],
+            hasAdminPermission: true,
+        });
+        await router.handle(interaction);
+        // Deferred ephemerally first (so the 3s window is never missed), then the panel is
+        // delivered as an editReply (role tiers + Save) plus a followUp (defaults). Both
+        // together stay within Discord's 5-action-row-per-message limit.
+        expect(acks[0].kind).toBe('deferReply');
+        expect(acks[0].payload?.ephemeral).toBe(true);
+        const edit = replies[0];
+        const follow = replies[1];
+        expect(edit.components && edit.components.length).toBeGreaterThan(0);
+        expect(edit.components.length).toBeLessThanOrEqual(5);
+        expect(follow.ephemeral).toBe(true);
+        expect(follow.components.length).toBeLessThanOrEqual(5);
+    });
+    it('opens the panel for an admin-tier user (configured allowlist)', async () => {
+        const { orchestrator } = fakeOrchestrator();
+        const { wiring } = fakeWiring();
+        const router = buildRouter({ orchestrator, wiring });
+        const { interaction, replies } = slash({
+            commandName: 'config',
+            roles: [ADMIN_ROLE],
+            hasAdminPermission: false,
+        });
+        await router.handle(interaction);
+        // The panel (role tiers + Save) is edited into the deferred ephemeral reply.
+        expect(replies[0].components && replies[0].components.length).toBeGreaterThan(0);
+    });
+    it('denies a non-admin, non-allowlisted user; panel not opened', async () => {
+        const { orchestrator } = fakeOrchestrator();
+        const { wiring } = fakeWiring();
+        const router = buildRouter({ orchestrator, wiring });
+        const { interaction, replies, acks } = slash({
+            commandName: 'config',
+            roles: [EXEC_ROLE], // execute tier is NOT admin
+            hasAdminPermission: false,
+        });
+        await router.handle(interaction);
+        // Deferred ephemerally first, then the denial edits that ephemeral reply.
+        expect(acks[0].kind).toBe('deferReply');
+        expect(acks[0].payload?.ephemeral).toBe(true);
+        expect(replies).toHaveLength(1);
+        // No panel components were sent.
+        expect(replies[0].components).toBeUndefined();
+        expect(replies[0].content).toContain('admin');
+    });
+    it('a role-select component routes to the panel and persists on Save', async () => {
+        const { orchestrator } = fakeOrchestrator();
+        const { wiring } = fakeWiring();
+        const router = buildRouter({ orchestrator, wiring });
+        // Admin opens the panel.
+        const { interaction: open } = slash({
+            commandName: 'config',
+            user: { id: 'admin-user' },
+            hasAdminPermission: true,
+        });
+        await router.handle(open);
+        // The admin picks execute roles via the role-select, then Saves.
+        const { interaction: pick } = component({
+            customId: 'config.role.execute',
+            values: ['picked-exec'],
+            user: { id: 'admin-user' },
+            hasAdminPermission: true,
+        });
+        await router.handle(pick);
+        const { interaction: save, replies } = component({
+            customId: 'config.save',
+            user: { id: 'admin-user' },
+            hasAdminPermission: true,
+        });
+        await router.handle(save);
+        // The picked role landed in this guild's server config auth.
+        const saved = store.loadServerConfig('g1');
+        expect(saved?.auth?.executeRoleIds).toEqual(['picked-exec']);
+        // A confirmation summary was sent.
+        expect(replies[0].content).toContain('picked-exec');
+    });
+    it('a role-select from a NON-owner is ignored (does not persist)', async () => {
+        const { orchestrator } = fakeOrchestrator();
+        const { wiring } = fakeWiring();
+        const router = buildRouter({ orchestrator, wiring });
+        const { interaction: open } = slash({
+            commandName: 'config',
+            user: { id: 'admin-user' },
+            hasAdminPermission: true,
+        });
+        await router.handle(open);
+        // A different admin (u2) tries to Save without any pick — the panel is owned by
+        // 'admin-user', so u2's interaction is acknowledged but ignored (no save).
+        const { interaction: hijack } = component({
+            customId: 'config.save',
+            user: { id: 'u2' },
+            hasAdminPermission: true,
+        });
+        await router.handle(hijack);
+        expect(store.loadServerConfig('g1')).toBeNull();
+    });
+    it('a defaults select auto-saves that one field immediately (no Save button)', async () => {
+        const { orchestrator } = fakeOrchestrator();
+        const { wiring } = fakeWiring();
+        const router = buildRouter({ orchestrator, wiring });
+        const { interaction: open } = slash({ commandName: 'config', user: { id: 'admin-user' }, hasAdminPermission: true });
+        await router.handle(open);
+        // The owner changes the default backend → it persists at once (no Save).
+        const { interaction: pick, replies } = component({
+            customId: 'config.default.backend',
+            value: 'codex',
+            user: { id: 'admin-user' },
+            hasAdminPermission: true,
+        });
+        await router.handle(pick);
+        expect(store.loadServerConfig('g1')?.defaults?.mode).toBe('codex');
+        // A short ephemeral confirmation for just that field was sent.
+        expect(replies[0].ephemeral).toBe(true);
+        expect(replies[0].content).toContain('codex');
+    });
+    it('a locale select auto-saves the per-guild locale immediately', async () => {
+        const { orchestrator } = fakeOrchestrator();
+        const { wiring } = fakeWiring();
+        const router = buildRouter({ orchestrator, wiring });
+        const { interaction: open } = slash({ commandName: 'config', user: { id: 'admin-user' }, hasAdminPermission: true });
+        await router.handle(open);
+        const { interaction: pick } = component({
+            customId: 'config.default.locale',
+            value: 'en',
+            user: { id: 'admin-user' },
+            hasAdminPermission: true,
+        });
+        await router.handle(pick);
+        expect(store.loadServerConfig('g1')?.locale).toBe('en');
+    });
+    it('the /config panel renders NO Codex-path button (codexHome auto-resolves)', async () => {
+        const { orchestrator } = fakeOrchestrator();
+        const { wiring } = fakeWiring();
+        const router = buildRouter({ orchestrator, wiring });
+        const { interaction, replies } = slash({ commandName: 'config', user: { id: 'admin-user' }, hasAdminPermission: true });
+        await router.handle(interaction);
+        // The whole panel (primary role reply + defaults follow-up) carries no codexHome
+        // button, and no showModal ack ever fires from opening /config.
+        const rows = replies.flatMap((r) => (r.components ?? []));
+        const allComponents = rows.flatMap((row) => row.components);
+        expect(allComponents.some((c) => c.customId === 'config.codexHome.open')).toBe(false);
+    });
+    it('a stray modal submit is acknowledged generically and persists nothing', async () => {
+        const { orchestrator } = fakeOrchestrator();
+        const { wiring } = fakeWiring();
+        const router = buildRouter({ orchestrator, wiring });
+        // The bot no longer opens any modal; a replayed/stray submit must still be acked
+        // (never "did not respond") without writing config.
+        const { interaction: submit, replies } = modalSubmit({
+            customId: 'config.codexHome.modal',
+            user: { id: 'admin-user' },
+            hasAdminPermission: true,
+            fields: { 'config.codexHome.value': '/srv/codex' },
+        });
+        await router.handle(submit);
+        expect(replies).toHaveLength(1);
+        expect(replies[0].ephemeral).toBe(true);
+        // Nothing was persisted for this guild.
+        expect(store.loadServerConfig('g1')).toBeNull();
+    });
+});
+describe('InteractionRouter /init command', () => {
+    it('creates the category + control channel + sessions category and persists the ids', async () => {
+        const { orchestrator } = fakeOrchestrator();
+        const { wiring } = fakeWiring();
+        const prov = new FakeProvisioner('g1');
+        const router = buildRouter({ orchestrator, wiring, resolveGuildProvisioner: async () => prov });
+        const { interaction, replies } = slash({ commandName: 'init', hasAdminPermission: true, roles: ['role-nobody'] });
+        await router.handle(interaction);
+        // Three channels created; ids persisted to servers/g1.json.
+        expect(prov.createdNames).toHaveLength(3);
+        const saved = store.loadServerConfig('g1');
+        expect(saved?.channels?.controlChannelId).toBeTruthy();
+        expect(saved?.channels?.sessionsCategoryId).toBeTruthy();
+        // The reply links the control channel.
+        expect(replies[0].content).toContain(`<#${saved.channels.controlChannelId}>`);
+    });
+    it('is idempotent: a second /init reuses the stored channels (no duplicates)', async () => {
+        const { orchestrator } = fakeOrchestrator();
+        const { wiring } = fakeWiring();
+        const prov = new FakeProvisioner('g1');
+        const router = buildRouter({ orchestrator, wiring, resolveGuildProvisioner: async () => prov });
+        const { interaction: first } = slash({ commandName: 'init', hasAdminPermission: true });
+        await router.handle(first);
+        const afterFirst = store.loadServerConfig('g1')?.channels;
+        expect(prov.createdNames).toHaveLength(3);
+        const { interaction: second } = slash({ commandName: 'init', hasAdminPermission: true });
+        await router.handle(second);
+        // No new creates; the stored ids are unchanged.
+        expect(prov.createdNames).toHaveLength(3);
+        expect(store.loadServerConfig('g1')?.channels).toEqual(afterFirst);
+    });
+    it('denies /init for a non-admin, non-allowlisted user (no channels created)', async () => {
+        const { orchestrator } = fakeOrchestrator();
+        const { wiring } = fakeWiring();
+        const prov = new FakeProvisioner('g1');
+        const router = buildRouter({ orchestrator, wiring, resolveGuildProvisioner: async () => prov });
+        const { interaction, replies } = slash({ commandName: 'init', roles: [EXEC_ROLE], hasAdminPermission: false });
+        await router.handle(interaction);
+        expect(prov.createdNames).toHaveLength(0);
+        expect(store.loadServerConfig('g1')?.channels).toBeUndefined();
+        expect(replies[0].content).toContain('admin');
+    });
+    it('reports a graceful notice when no provisioner is available', async () => {
+        const { orchestrator } = fakeOrchestrator();
+        const { wiring } = fakeWiring();
+        const router = buildRouter({ orchestrator, wiring, resolveGuildProvisioner: async () => null });
+        const { interaction, replies } = slash({ commandName: 'init', hasAdminPermission: true });
+        await router.handle(interaction);
+        expect(replies[0].content).toContain('채널 관리');
+    });
+});
+describe('InteractionRouter /agent start creates a dedicated session channel', () => {
+    // Drive the wizard to confirm and return the recorded orchestrator/wiring calls +
+    // the new channel's posted messages.
+    async function runStartFlow(prov, sessionsCategoryId) {
+        const { orchestrator, calls } = fakeOrchestrator();
+        const { wiring, calls: wcalls } = fakeWiring();
+        const { channel, posts } = fakeMessageChannel();
+        const router = buildRouter({
+            orchestrator,
+            wiring,
+            resolveGuildProvisioner: async () => prov,
+            resolveChannel: async () => channel,
+        });
+        if (sessionsCategoryId) {
+            // Seed a persisted /init structure so the session channel is placed under it.
+            store.saveServerConfig({
+                version: 1,
+                guildId: 'g1',
+                channels: {
+                    categoryId: 'cat',
+                    controlChannelId: 'ctrl',
+                    sessionsCategoryId,
+                    statusChannelId: null,
+                },
+            });
+        }
+        const { interaction: start } = slash({ commandName: 'agent', subcommand: 'start', user: { id: 'u1' } });
+        await router.handle(start);
+        // Owner drives the whole wizard to start via the confirm buttons.
+        const flow = [
+            { customId: 'dir:here' },
+            { customId: 'backend.next' },
+            { customId: 'model.next' },
+            { customId: 'effort.next' },
+            { customId: 'perm.start' },
+        ];
+        const compReplies = [];
+        for (const step of flow) {
+            const { interaction, replies } = component({ ...step, user: { id: 'u1' } });
+            await router.handle(interaction);
+            compReplies.push(...replies);
+        }
+        return { calls, wcalls, posts, compReplies };
+    }
+    it('creates a NEW channel, binds the session + wires renderers to the new channel id', async () => {
+        const prov = new FakeProvisioner('g1');
+        const { calls, wcalls, posts, compReplies } = await runStartFlow(prov);
+        // A dedicated session channel was created (proj-*).
+        expect(prov.createdNames).toHaveLength(1);
+        expect(prov.createdNames[0]).toMatch(/^proj-/);
+        const newChannelId = [...prov.channels.keys()][0];
+        // The session started bound to the NEW channel (not the command channel 'c1').
+        expect(calls.start).toHaveBeenCalledOnce();
+        expect(calls.start).toHaveBeenCalledWith(expect.objectContaining({ channelId: newChannelId }));
+        expect(calls.start).not.toHaveBeenCalledWith(expect.objectContaining({ channelId: 'c1' }));
+        // Renderers/eventBus subscription keys off the NEW channel id (wiring.attach).
+        expect(wcalls.attach).toHaveBeenCalledWith('g1', newChannelId, 'claude');
+        // The status embed + intro were posted INTO the new channel.
+        expect(posts.length).toBeGreaterThanOrEqual(1);
+        expect(posts[0].embeds && posts[0].embeds.length).toBeGreaterThan(0);
+        // The driver was told where the session channel is.
+        expect(compReplies.some((r) => r.content?.includes(`<#${newChannelId}>`))).toBe(true);
+    });
+    it('places the new session channel under the /init sessions category when present', async () => {
+        const prov = new FakeProvisioner('g1');
+        // Seed the sessions category id into the fake so createTextChannel records its parent.
+        prov.channels.set('sessions-cat', 'Agent - Sessions');
+        const { calls } = await runStartFlow(prov, 'sessions-cat');
+        // start was called (session bound to the created channel).
+        expect(calls.start).toHaveBeenCalledOnce();
+        // The created project channel exists in the provisioner.
+        const created = prov.createdNames.find((n) => n.startsWith('proj-'));
+        expect(created).toBeTruthy();
+    });
+});
+describe('InteractionRouter /agent close deletes the session channel', () => {
+    it('deletes the closed channel via the provisioner (A4D behavior)', async () => {
+        channelRegistry.set(binding(home, { channelId: 'sess-1' }));
+        const { orchestrator, calls } = fakeOrchestrator();
+        const { wiring, calls: wcalls } = fakeWiring();
+        const prov = new FakeProvisioner('g1');
+        prov.channels.set('sess-1', 'proj-thing');
+        const router = buildRouter({ orchestrator, wiring, resolveGuildProvisioner: async () => prov });
+        const { interaction } = slash({ commandName: 'agent', subcommand: 'close', channelId: 'sess-1' });
+        await router.handle(interaction);
+        expect(calls.stop).toHaveBeenCalledWith('g1', 'sess-1');
+        expect(wcalls.detach).toHaveBeenCalledWith('g1', 'sess-1');
+        expect(prov.deleted).toContain('sess-1');
+    });
+    it('never deletes the control channel on close', async () => {
+        // Persist an /init structure whose control channel is 'ctrl'.
+        store.saveServerConfig({
+            version: 1,
+            guildId: 'g1',
+            channels: { categoryId: 'cat', controlChannelId: 'ctrl', sessionsCategoryId: 'sess-cat', statusChannelId: null },
+        });
+        channelRegistry.set(binding(home, { channelId: 'ctrl' }));
+        const { orchestrator } = fakeOrchestrator();
+        const { wiring } = fakeWiring();
+        const prov = new FakeProvisioner('g1');
+        prov.channels.set('ctrl', 'agent-start');
+        const router = buildRouter({ orchestrator, wiring, resolveGuildProvisioner: async () => prov });
+        const { interaction } = slash({ commandName: 'agent', subcommand: 'close', channelId: 'ctrl' });
+        await router.handle(interaction);
+        expect(prov.deleted).not.toContain('ctrl');
+    });
+});
+// A logger whose calls are recorded, for the interaction-receipt + error-logging tests.
+function fakeLogger() {
+    const info = vi.fn();
+    const error = vi.fn();
+    const logger = { debug: vi.fn(), info, warn: vi.fn(), error };
+    return { logger, info, error };
+}
+// These tests assert the ACK-ORDERING CONTRACT — the fix for Discord's 3-second
+// deadline ("application did not respond"). Because CI cannot reach the real gateway,
+// they verify that the router acknowledges (defers) BEFORE the slow handler work and
+// that no path (including a thrown handler) leaves the interaction unacknowledged. The
+// real fix is validated by a live retest against Discord.
+describe('InteractionRouter acknowledgment contract (3s window fix)', () => {
+    it('/stop DEFERS before doing the slow orchestrator/wiring work', async () => {
+        channelRegistry.set(binding(home));
+        const order = [];
+        const { wiring } = fakeWiring();
+        const orchestrator = {
+            start: vi.fn(),
+            stop: vi.fn(async () => {
+                order.push('stop');
+            }),
+            stopAll: vi.fn(),
+        };
+        const router = buildRouter({ orchestrator, wiring });
+        const { interaction, acks } = slash({ commandName: 'stop' });
+        // Record the defer relative to the orchestrator work.
+        const origDefer = interaction.deferReply;
+        interaction.deferReply = async (o) => {
+            order.push('defer');
+            return origDefer(o);
+        };
+        await router.handle(interaction);
+        // The ack (defer) fired FIRST, before orchestrator.stop.
+        expect(order).toEqual(['defer', 'stop']);
+        expect(acks[0].kind).toBe('deferReply');
+    });
+    it('a slash handler that THROWS still produces a user-visible ack (no unhandled rejection)', async () => {
+        channelRegistry.set(binding(home));
+        const { wiring } = fakeWiring();
+        // orchestrator.stop throws → the /stop handler body throws after the defer.
+        const orchestrator = {
+            start: vi.fn(),
+            stop: vi.fn(async () => {
+                throw new Error('boom');
+            }),
+            stopAll: vi.fn(),
+        };
+        const { logger, error } = fakeLogger();
+        const router = buildRouter({ orchestrator, wiring, logger });
+        const { interaction, replies, acks } = slash({ commandName: 'stop' });
+        // Must not reject.
+        await expect(router.handle(interaction)).resolves.toBeUndefined();
+        // Deferred first, then the error was edited into the deferred reply.
+        expect(acks[0].kind).toBe('deferReply');
+        const errorReply = replies.find((r) => r.content && r.content.includes('처리하지 못했'));
+        expect(errorReply).toBeTruthy();
+        // The error was logged WITH its stack to the operator terminal.
+        expect(error).toHaveBeenCalled();
+        const errMeta = error.mock.calls.find((c) => typeof c[1] === 'object');
+        expect(errMeta && errMeta[1].stack).toContain('boom');
+    });
+    it('logs a receipt line for EVERY received interaction (slash + component)', async () => {
+        const { orchestrator } = fakeOrchestrator();
+        const { wiring } = fakeWiring();
+        const { logger, info } = fakeLogger();
+        const router = buildRouter({ orchestrator, wiring, logger });
+        const { interaction: s } = slash({ commandName: 'stop' });
+        await router.handle(s);
+        const slashReceipt = info.mock.calls.find((c) => c[0] === 'interaction received' && c[1]?.type === 'slash');
+        expect(slashReceipt).toBeTruthy();
+        expect((slashReceipt?.[1]).command).toBe('stop');
+        expect((slashReceipt?.[1]).userId).toBe('u1');
+        const { interaction: c } = component({ customId: 'perm:req-1:allow' });
+        await router.handle(c);
+        const compReceipt = info.mock.calls.find((call) => call[0] === 'interaction received' && call[1]?.type === 'component');
+        expect(compReceipt).toBeTruthy();
+        expect((compReceipt?.[1]).customId).toBe('perm:req-1:allow');
+    });
+    it('a perm button DEFERS (deferUpdate) before resolving the permission', async () => {
+        const order = [];
+        const orchestrator = fakeOrchestrator().orchestrator;
+        const wiring = {
+            attach: vi.fn(),
+            detach: vi.fn(),
+            resolvePermission: vi.fn(async () => {
+                order.push('resolve');
+                return { behavior: 'allow' };
+            }),
+        };
+        const router = buildRouter({ orchestrator, wiring });
+        const { interaction } = component({ customId: 'perm:req-1:allow' });
+        const origDefer = interaction.deferUpdate;
+        interaction.deferUpdate = async () => {
+            order.push('defer');
+            return origDefer();
+        };
+        await router.handle(interaction);
+        // deferUpdate fired BEFORE resolvePermission (never miss the 3s window).
+        expect(order).toEqual(['defer', 'resolve']);
+    });
+});
+// ---------------------------------------------------------------------------
+// 📁 Create folder (folder-step modal)
+// ---------------------------------------------------------------------------
+describe('InteractionRouter 📁 Create folder', () => {
+    // Open a wizard rooted at `root` and return the router (so the folder step is live
+    // with a browser whose cwd === root, the current browsed directory).
+    async function openWizard(root) {
+        const { orchestrator } = fakeOrchestrator();
+        const { wiring } = fakeWiring();
+        const router = buildRouter({ orchestrator, wiring, browseRoots: [root] });
+        const { interaction } = slash({ commandName: 'agent', subcommand: 'start', user: { id: 'u1' } });
+        await router.handle(interaction);
+        return router;
+    }
+    it('the Create button opens a modal WITHOUT a preceding defer (showModal is the ack)', async () => {
+        const root = fs.mkdtempSync(path.join(os.tmpdir(), 'dab-create-'));
+        try {
+            const router = await openWizard(root);
+            const { interaction, acks } = component({ customId: 'dir:create', user: { id: 'u1' } });
+            await router.handle(interaction);
+            // showModal fired; no deferUpdate before it (a deferred component cannot show a modal).
+            expect(acks.map((a) => a.kind)).toEqual(['showModal']);
+            expect(acks[0].modal?.customId).toBe('dir:create');
+            expect(acks[0].modal?.fields[0]?.customId).toBe('name');
+        }
+        finally {
+            fs.rmSync(root, { recursive: true, force: true });
+        }
+    });
+    it('the modal submit mkdir\'s the folder in the CURRENT browsed dir and re-renders', async () => {
+        const root = fs.mkdtempSync(path.join(os.tmpdir(), 'dab-create-'));
+        try {
+            const router = await openWizard(root);
+            // Open the modal (records the current path implicitly via the live wizard).
+            await router.handle(component({ customId: 'dir:create', user: { id: 'u1' } }).interaction);
+            // Submit the modal with a valid name.
+            const { interaction, replies } = modalSubmit({ customId: 'dir:create', user: { id: 'u1' }, fields: { name: 'new-folder' } });
+            await router.handle(interaction);
+            // The directory was created as a direct child of the browsed dir.
+            expect(fs.existsSync(path.join(root, 'new-folder'))).toBe(true);
+            // The reply re-rendered the folder step (component rows present) + a confirmation.
+            const reply = replies.find((r) => r.content?.includes('new-folder'));
+            expect(reply).toBeDefined();
+            expect(reply?.components && reply.components.length).toBeGreaterThan(0);
+        }
+        finally {
+            fs.rmSync(root, { recursive: true, force: true });
+        }
+    });
+    it('rejects a traversal / separator / absolute name — no mkdir, ephemeral notice', async () => {
+        const root = fs.mkdtempSync(path.join(os.tmpdir(), 'dab-create-'));
+        try {
+            for (const bad of ['..', 'a/b', '/etc/evil', '.', 'x\\y']) {
+                const router = await openWizard(root);
+                await router.handle(component({ customId: 'dir:create', user: { id: 'u1' } }).interaction);
+                const { interaction, replies } = modalSubmit({ customId: 'dir:create', user: { id: 'u1' }, fields: { name: bad } });
+                await router.handle(interaction);
+                // Nothing escaped: the only entry under root is never a traversal target.
+                expect(fs.existsSync(path.join(root, '..', 'evil'))).toBe(false);
+                // An invalid-name notice was returned (ephemeral).
+                expect(replies.some((r) => r.ephemeral && (r.content ?? '').length > 0)).toBe(true);
+            }
+            // No folder named after any bad input was created directly either.
+            expect(fs.readdirSync(root)).toHaveLength(0);
+        }
+        finally {
+            fs.rmSync(root, { recursive: true, force: true });
+        }
+    });
+    it('a Create from a NON-owner is ignored (deferUpdate, no modal)', async () => {
+        const root = fs.mkdtempSync(path.join(os.tmpdir(), 'dab-create-'));
+        try {
+            const router = await openWizard(root); // owner u1
+            const { interaction, acks } = component({ customId: 'dir:create', user: { id: 'intruder' } });
+            await router.handle(interaction);
+            // The stray click is acknowledged (deferUpdate) but shows NO modal.
+            expect(acks.map((a) => a.kind)).toEqual(['deferUpdate']);
+        }
+        finally {
+            fs.rmSync(root, { recursive: true, force: true });
+        }
+    });
+});
+// ---------------------------------------------------------------------------
+// Resume Session flow (both backends)
+// ---------------------------------------------------------------------------
+describe('InteractionRouter Resume Session flow', () => {
+    // Re-register the modes with scripted resumable lists for this suite.
+    function registerResumable(claude, codex) {
+        modeRegistry = new ModeRegistry();
+        modeRegistry.register(new StubMode('claude', CLAUDE_CAPS, claude));
+        modeRegistry.register(new StubMode('codex', { ...CLAUDE_CAPS, usagePanel: false }, codex));
+    }
+    async function openResumeFlow(root, opts = {}) {
+        registerResumable(opts.claude ?? [], opts.codex ?? []);
+        const { orchestrator, calls } = fakeOrchestrator();
+        const { wiring, calls: wcalls } = fakeWiring();
+        const { channel, posts } = fakeMessageChannel();
+        const prov = new FakeProvisioner('g1');
+        const router = buildRouter({
+            orchestrator,
+            wiring,
+            browseRoots: [root],
+            resolveGuildProvisioner: async () => prov,
+            resolveChannel: async () => channel,
+        });
+        // Open the wizard (folder step) then press Resume Session.
+        await router.handle(slash({ commandName: 'agent', subcommand: 'start', user: { id: 'u1' } }).interaction);
+        const { interaction: resumeBtn, replies: r0 } = component({ customId: 'dir:resume', user: { id: 'u1' } });
+        await router.handle(resumeBtn);
+        return { router, calls, wcalls, posts, prov, firstRender: r0 };
+    }
+    it('picking a backend lists THAT backend\'s sessions (Claude)', async () => {
+        const root = fs.mkdtempSync(path.join(os.tmpdir(), 'dab-resume-'));
+        try {
+            const { router } = await openResumeFlow(root, {
+                claude: [{ sessionId: 'cl-1', cwd: root, label: 'Claude work' }],
+                codex: [{ sessionId: 'cx-1', cwd: root, label: 'Codex work' }],
+            });
+            // Default backend is claude (config). Confirm the backend → list claude sessions.
+            const { interaction, replies } = component({ customId: 'resume.backend.next', user: { id: 'u1' } });
+            await router.handle(interaction);
+            // The session-pick select is rendered with the claude session's label.
+            const rows = (replies[replies.length - 1].components ?? []);
+            const pick = rows.flatMap((r) => r.components).find((c) => c.customId === 'resume.pick');
+            expect(pick).toBeDefined();
+            expect(pick?.options?.map((o) => o.value)).toEqual(['cl-1']);
+        }
+        finally {
+            fs.rmSync(root, { recursive: true, force: true });
+        }
+    });
+    it('selecting a session RESUMES it: orchestrator.resume + wiring.attach on a fresh channel (Claude)', async () => {
+        const root = fs.mkdtempSync(path.join(os.tmpdir(), 'dab-resume-'));
+        try {
+            const { router, calls, wcalls, posts, prov } = await openResumeFlow(root, {
+                claude: [{ sessionId: 'cl-42', cwd: root, label: 'Resume me' }],
+            });
+            await router.handle(component({ customId: 'resume.backend.next', user: { id: 'u1' } }).interaction);
+            const { interaction, replies } = component({ customId: 'resume.pick', value: 'cl-42', user: { id: 'u1' } });
+            await router.handle(interaction);
+            // A dedicated session channel was created (proj-*).
+            expect(prov.createdNames.some((n) => n.startsWith('proj-'))).toBe(true);
+            const newChannelId = [...prov.channels.keys()].find((id) => prov.channels.get(id)?.startsWith('proj-'));
+            // orchestrator.resume was called with the chosen session id, bound to the NEW channel.
+            expect(calls.resume).toHaveBeenCalledOnce();
+            expect(calls.resume.mock.calls[0][0]).toMatchObject({ channelId: newChannelId, mode: 'claude', cwd: root });
+            expect(calls.resume.mock.calls[0][1]).toBe('cl-42');
+            // Renderers were wired to the new channel; a resumed-status embed was posted.
+            expect(wcalls.attach).toHaveBeenCalledWith('g1', newChannelId, 'claude');
+            expect(posts.some((p) => (p.embeds ?? []).length > 0)).toBe(true);
+            // The driver was told where the resumed session lives.
+            expect(replies.some((r) => r.content?.includes(`<#${newChannelId}>`))).toBe(true);
+        }
+        finally {
+            fs.rmSync(root, { recursive: true, force: true });
+        }
+    });
+    it('works for Codex too: picking codex lists + resumes a codex session', async () => {
+        const root = fs.mkdtempSync(path.join(os.tmpdir(), 'dab-resume-'));
+        try {
+            const { router, calls } = await openResumeFlow(root, {
+                claude: [],
+                codex: [{ sessionId: 'cx-7', cwd: root, label: 'Codex thread' }],
+            });
+            // Switch the backend select to codex, then confirm.
+            await router.handle(component({ customId: 'resume.backend', value: 'codex', user: { id: 'u1' } }).interaction);
+            const { interaction, replies } = component({ customId: 'resume.backend.next', user: { id: 'u1' } });
+            await router.handle(interaction);
+            const rows = (replies[replies.length - 1].components ?? []);
+            const pick = rows.flatMap((r) => r.components).find((c) => c.customId === 'resume.pick');
+            expect(pick?.options?.map((o) => o.value)).toEqual(['cx-7']);
+            // Pick it → resume with the codex backend.
+            await router.handle(component({ customId: 'resume.pick', value: 'cx-7', user: { id: 'u1' } }).interaction);
+            expect(calls.resume).toHaveBeenCalledOnce();
+            expect(calls.resume.mock.calls[0][0]).toMatchObject({ mode: 'codex' });
+            expect(calls.resume.mock.calls[0][1]).toBe('cx-7');
+        }
+        finally {
+            fs.rmSync(root, { recursive: true, force: true });
+        }
+    });
+    it('an empty list → ephemeral "재개할 세션이 없습니다" notice, resume NOT called', async () => {
+        const root = fs.mkdtempSync(path.join(os.tmpdir(), 'dab-resume-'));
+        try {
+            const { router, calls } = await openResumeFlow(root, { claude: [], codex: [] });
+            const { interaction, replies } = component({ customId: 'resume.backend.next', user: { id: 'u1' } });
+            await router.handle(interaction);
+            expect(replies.some((r) => (r.content ?? '').includes('재개할 세션이 없습니다'))).toBe(true);
+            expect(calls.resume).not.toHaveBeenCalled();
+        }
+        finally {
+            fs.rmSync(root, { recursive: true, force: true });
+        }
+    });
+    it('a Resume Session from a NON-owner is ignored (no resume flow started)', async () => {
+        const root = fs.mkdtempSync(path.join(os.tmpdir(), 'dab-resume-'));
+        try {
+            registerResumable([{ sessionId: 'cl-1', cwd: root }], []);
+            const { orchestrator, calls } = fakeOrchestrator();
+            const { wiring } = fakeWiring();
+            const router = buildRouter({ orchestrator, wiring, browseRoots: [root], resolveGuildProvisioner: async () => new FakeProvisioner('g1') });
+            await router.handle(slash({ commandName: 'agent', subcommand: 'start', user: { id: 'u1' } }).interaction);
+            // Intruder presses Resume → ignored; a later backend.next has no flow to advance.
+            await router.handle(component({ customId: 'dir:resume', user: { id: 'intruder' } }).interaction);
+            await router.handle(component({ customId: 'resume.backend.next', user: { id: 'intruder' } }).interaction);
+            expect(calls.resume).not.toHaveBeenCalled();
+        }
+        finally {
+            fs.rmSync(root, { recursive: true, force: true });
+        }
+    });
+});
+//# sourceMappingURL=interactionRouter.test.js.map