wtt-connect 0.2.29 → 0.2.31

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wtt-connect",
-  "version": "0.2.29",
+  "version": "0.2.31",
   "private": false,
   "description": "WTT-native connector daemon for Codex, Claude Code, Cursor, Gemini, ACP, and other coding agent surfaces.",
   "type": "module",

package/src/adapters/codex.js

@@ -3,7 +3,7 @@ import { execFile } from 'node:child_process';
 import readline from 'node:readline';
 import { promisify } from 'node:util';
 import { log } from '../logger.js';
-import { parseSlashCommand } from '../slash.js';
+import { CODEX_SLASH_COMMANDS, formatSlashCommandHelp, parseSlashCommand } from '../slash.js';
 
 const execFileAsync = promisify(execFile);
 
@@ -47,26 +47,21 @@ export class CodexAdapter {
 
     switch (parsed.command) {
       case '/help':
-        return [
-          'Codex slash commands supported by WTT:',
-          '- `/status`: show Codex runtime/session status.',
-          '- `/model`: show the model selected by WTT for this run. Use the WTT model picker to switch models.',
-          '- `/approvals`: show the current approval/sandbox mode.',
-          '- `/diff`: show current git diff summary and patch excerpt.',
-          '- `/review`: run Codex native code review for the current workspace.',
-          '- `/init`: ask Codex to inspect the workspace and create/update AGENTS.md guidance.',
-          '- `/clear`: clear the stored Codex resume thread for this WTT topic.',
-          '- `/compact`: non-interactive Codex cannot compact an existing TUI context; WTT clears the stored resume thread instead.',
-        ].join('\n');
+        return formatSlashCommandHelp(this.name);
       case '/status':
         return this.codexStatus(sessionKey, context);
       case '/model':
         return this.codexModel(context, parsed.args);
       case '/approvals':
+      case '/permissions':
         return this.codexApprovals();
       case '/diff':
         return this.gitDiff();
       case '/clear':
+      case '/new':
+      case '/reset':
+      case '/new-session':
+      case '/new-thread':
         return this.clearSession(sessionKey, 'clear');
       case '/compact':
         return this.clearSession(sessionKey, 'compact');
@@ -75,6 +70,7 @@ export class CodexAdapter {
       case '/init':
         return this.runInit(context, sessionKey);
       default:
+        if (CODEX_TUI_ONLY_COMMANDS.has(parsed.command)) return codexTuiOnlyMessage(parsed.command);
         return null;
     }
   }
@@ -180,6 +176,37 @@ export class CodexAdapter {
   }
 }
 
+const CODEX_HEADLESS_COMPAT_COMMANDS = new Set([
+  '/help',
+  '/status',
+  '/model',
+  '/approvals',
+  '/permissions',
+  '/diff',
+  '/clear',
+  '/new',
+  '/reset',
+  '/new-session',
+  '/new-thread',
+  '/compact',
+  '/review',
+  '/init',
+]);
+
+const CODEX_TUI_ONLY_COMMANDS = new Set(
+  CODEX_SLASH_COMMANDS.map(([cmd]) => cmd).filter((cmd) => !CODEX_HEADLESS_COMPAT_COMMANDS.has(cmd)),
+);
+
+function codexTuiOnlyMessage(command) {
+  return [
+    `Codex ${command} is a native interactive TUI slash command.`,
+    '',
+    'WTT runs Codex through `codex exec` for chat/agent automation. In Codex CLI 0.133.0, `codex exec` treats slash text from stdin as a normal prompt instead of dispatching the TUI slash command.',
+    '',
+    'Open the Agent Terminal to run this command in native Codex TUI, or use WTT-compatible commands such as `/status`, `/model`, `/permissions`, `/diff`, `/review`, `/init`, `/new`, `/clear`, and `/compact` from chat.',
+  ].join('\n');
+}
+
 async function commandOutput(bin, args, cwd, timeoutMs = 30000, maxChars = 8000) {
   try {
     const { stdout, stderr } = await execFileAsync(bin, args, { cwd, timeout: timeoutMs, maxBuffer: Math.max(maxChars * 4, 1024 * 1024) });

package/src/config.js

@@ -55,6 +55,8 @@ export function loadConfig(argv = {}) {
       providerMap: fileConfig.modelSwitch?.providerMap || parseJsonEnv(process.env.WTT_CONNECT_MODEL_PROVIDER_MAP, {}),
     },
     workDir,
+    cloudSandbox: parseBool(process.env.WTT_CONNECT_CLOUD_SANDBOX, fileConfig.cloudSandbox ?? false),
+    persistentOutputDir: process.env.WTT_CONNECT_PERSISTENT_OUTPUT_DIR || process.env.WTT_CONNECT_R2_OUTPUT_DIR || fileConfig.persistentOutputDir || '',
     model: process.env.WTT_CONNECT_MODEL || fileConfig.model || '',
     mode,
     allowYolo: parseBool(process.env.WTT_CONNECT_ALLOW_YOLO, fileConfig.allowYolo ?? mode === 'yolo'),

package/src/main.js

@@ -186,7 +186,7 @@ function packageUploadFiles(files, config, argv) {
   return { path: zipPath, originalFiles: files };
 }
 
-function resolveUploadFilePath(filePath, config) {
+export function resolveUploadFilePath(filePath, config) {
   const raw = String(filePath || '').trim();
   if (!raw) throw new Error('empty file path');
   const expanded = raw.startsWith('~/') ? path.join(process.env.HOME || '', raw.slice(2)) : raw;
@@ -197,9 +197,10 @@ function resolveUploadFilePath(filePath, config) {
     config.artifactDir,
     config.storeFile ? path.dirname(config.storeFile) : '',
     config.inboxDir,
+    config.persistentOutputDir,
   ].filter(Boolean).map((root) => path.resolve(root));
   if (!roots.some((root) => isPathInside(resolved, root))) {
-    throw new Error(`upload-file refused path outside WTT workspace/state roots: ${resolved}`);
+    throw new Error(`upload-file refused path outside WTT workspace/state/persistent roots: ${resolved}`);
   }
   return resolved;
 }

package/src/runner.js

@@ -20,7 +20,7 @@ import { buildRuntimeInfo } from './runtime-info.js';
 import { runShellCommand } from './shell-runner.js';
 import { TerminalSessionManager } from './terminal-session.js';
 import { isModelSwitcherEnabled, switchModelProvider } from './model-switcher.js';
-import { isAgentSlashCommand, parseSlashCommand } from './slash.js';
+import { formatSlashCommandHelp, isAgentSlashCommand, parseSlashCommand, slashCommandsForAdapter } from './slash.js';
 
 const TERMINAL_STATUSES = new Set(['review', 'done', 'approved', 'cancelled']);
 const GENERATED_FILE_EXTENSIONS = new Set([
@@ -182,9 +182,10 @@ export class Runner {
       const discussionRouting = renderDiscussionRoutingInstruction(m, this.config);
       const currentDisplayName = effectiveAgentDisplayName(this.config, agentProfile);
       const isSlashPassthrough = isAgentSlashCommand(m, content);
+      const sessionKey = `wtt:topic:${topicId}:${adapter.name}:${sessionModelKey(modelConfig)}`;
       if (isSlashPassthrough) {
         const localSlash = await this.handleLocalSlashCommand(content, adapter, {
-          sessionKey: `wtt:topic:${topicId}:${adapter.name}:${sessionModelKey(modelConfig)}`,
+          sessionKey,
           topicId,
           modelConfig,
           files: staged.files,
@@ -198,6 +199,7 @@ export class Runner {
           return;
         }
       }
+      const compactSummary = this.store.getSession(sessionKey).compactSummary || '';
       const prompt = isSlashPassthrough ? content : [
         'You are replying to a WTT Web conversation. Do not mention implementation internals unless asked.',
         `WTT topic_id: ${topicId}`,
@@ -212,16 +214,19 @@ export class Runner {
         discussionRouting ? '' : null,
         agentSoul,
         agentSoul ? '' : null,
+        renderCompactSummaryBlock(compactSummary),
+        compactSummary ? '' : null,
         'User message:',
         content,
         '',
         staged.promptBlock,
         renderTranscriptBlock(transcripts),
+        renderCloudSandboxStorageInstruction(this.config),
         renderGeneratedFileArtifactInstruction(this.config, topicId),
         'Reply naturally and concisely unless the user asks for detail.',
       ].filter(Boolean).join('\n');
       const output = await this.runAdapter(adapter, prompt, {
-        sessionKey: `wtt:topic:${topicId}:${adapter.name}:${sessionModelKey(modelConfig)}`,
+        sessionKey,
         topicId,
         modelConfig,
         files: staged.files,
@@ -336,9 +341,18 @@ export class Runner {
     if (parsed.command === '/upgrade') {
       return this.handleUpgradeCommand(parsed.args);
     }
+    if (parsed.command === '/help' || parsed.command === '/?') {
+      return formatSlashCommandHelp(adapter.name);
+    }
     if (parsed.command === '/status') {
       return this.runtimeStatusText(adapter, context);
     }
+    if (parsed.command === '/model' || parsed.command === '/models') {
+      return this.runtimeModelText(adapter, context, parsed.args);
+    }
+    if (['/compact', '/compress'].includes(parsed.command)) {
+      return this.compactAdapterSession(adapter, context, parsed.command, parsed.args);
+    }
     if (['/clear', '/new', '/reset', '/new-session', '/new-thread'].includes(parsed.command)) {
       return this.clearAdapterSession(adapter, context.sessionKey || 'default', parsed.command);
     }
@@ -346,6 +360,9 @@ export class Runner {
       const handled = await adapter.handleSlashCommand(content, context);
       if (handled !== null && handled !== undefined) return handled;
     }
+    if (isKnownAdapterSlashCommand(adapter.name, parsed.command)) {
+      return headlessSlashUnsupportedMessage(adapter.name, parsed.command);
+    }
     return null;
   }
 
@@ -356,6 +373,72 @@ export class Runner {
     return `${adapterDisplayName(adapter.name)} session cleared for this WTT topic. The next turn starts a fresh agent thread/session.`;
   }
 
+  async compactAdapterSession(adapter, context = {}, command = '/compact', args = '') {
+    const sessionKey = context.sessionKey || 'default';
+    const topicId = String(context.topicId || '').trim();
+    if (!topicId) return this.clearAdapterSession(adapter, sessionKey, command);
+    const messages = await this.api.getTopicMessages(topicId, { limit: 160, includeHistory: true });
+    const transcript = formatTopicMessagesForCompaction(messages, {
+      currentAgentId: this.config.agentId,
+      excludeSlashCommands: new Set(['/compact', '/compress']),
+    });
+    if (!transcript) {
+      return `${adapterDisplayName(adapter.name)} compact skipped: no topic history was available.`;
+    }
+    const focus = String(args || '').trim();
+    const prompt = [
+      'You are compacting a WTT agent conversation for continuation in a fresh headless CLI session.',
+      'Create a durable context summary that will be injected before the next user message.',
+      '',
+      'Requirements:',
+      '- Preserve user goals, constraints, decisions, unresolved questions, file paths, commands, errors, and current next steps.',
+      '- Preserve any model/tool/API/deployment details that matter for future turns.',
+      '- Drop greetings, duplicate status noise, progress chatter, and irrelevant old details.',
+      '- Do not invent facts. If uncertain, say so briefly.',
+      '- Keep it concise but complete enough to continue work without the previous CLI session.',
+      focus ? `- User focus for this compaction: ${focus}` : null,
+      '',
+      'Return Markdown with these sections:',
+      '1. Current Goal',
+      '2. Key Facts And Decisions',
+      '3. Files/Commands/Environment',
+      '4. Open Issues',
+      '5. Next Steps',
+      '',
+      'Conversation transcript:',
+      transcript,
+    ].filter(Boolean).join('\n');
+    await this.wtt.typing(topicId, 'start', {
+      statusText: `${adapterDisplayName(adapter.name)} 正在压缩当前上下文`,
+      statusKind: 'compact',
+      adapter: adapter.name,
+      model: context.modelConfig?.model || undefined,
+      ttlMs: 120000,
+    });
+    const compactSessionKey = `${sessionKey}:compact:${Date.now()}`;
+    const summary = stripHiddenContextLeak(await this.runAdapter(adapter, prompt, {
+      ...context,
+      sessionKey: compactSessionKey,
+      files: [],
+      images: [],
+    }) || '').trim();
+    if (!summary) return `${adapterDisplayName(adapter.name)} compact failed: summary was empty.`;
+    this.store.clearSession(sessionKey, {
+      adapter: adapter.name,
+      clearedBy: command,
+      compactSummary: truncate(summary, 30000),
+      compactedAt: new Date().toISOString(),
+      compactedMessageCount: messages.length,
+    });
+    if (adapter.threadBySession?.delete) adapter.threadBySession.delete(sessionKey);
+    if (adapter.sessionByKey?.delete) adapter.sessionByKey.delete(sessionKey);
+    return [
+      `${adapterDisplayName(adapter.name)} context compacted for this WTT topic. The next turn starts a fresh headless CLI session with this summary injected.`,
+      '',
+      summary,
+    ].join('\n');
+  }
+
   runtimeStatusText(adapter, context = {}) {
     const runtime = this.runtimeInfo();
     const modelConfig = context.modelConfig || {};
@@ -371,6 +454,22 @@ export class Runner {
       `- wtt-connect: ${runtime.wtt_connect || runtime.wttConnect || '(unknown)'}`,
       `- claude: ${runtime.claude_code || runtime.claude || '(unknown)'}`,
       `- codex: ${runtime.codex || '(unknown)'}`,
+      `- gemini: ${runtime.gemini || '(unknown)'}`,
+    ].join('\n');
+  }
+
+  runtimeModelText(adapter, context = {}, args = '') {
+    const runtime = this.runtimeInfo();
+    const modelConfig = context.modelConfig || {};
+    const model = modelConfig.model || runtime.current_model || runtime.model || this.config.model || '(config/default)';
+    const reasoning = modelConfig.reasoning_effort || modelConfig.reasoningEffort || runtime.reasoning_effort || runtime.thinking_mode || '(default)';
+    return [
+      `${adapterDisplayName(adapter.name)} model`,
+      `- current model: ${model}`,
+      `- reasoning/thinking: ${reasoning}`,
+      args?.trim()
+        ? '- note: WTT Web model picker controls the next headless run. Native interactive /model switching requires Agent Terminal.'
+        : '- use the WTT Web model picker to switch the next headless run.',
     ].join('\n');
   }
 
@@ -521,9 +620,27 @@ export class Runner {
 function adapterDisplayName(name) {
   if (name === 'claude-code') return 'Claude Code';
   if (name === 'codex') return 'Codex';
+  if (name === 'gemini') return 'Gemini';
   return name || 'Agent';
 }
 
+function isKnownAdapterSlashCommand(adapterName, command) {
+  const normalized = String(command || '').trim().toLowerCase();
+  if (!normalized) return false;
+  return slashCommandsForAdapter(adapterName).some(([cmd]) => cmd === normalized);
+}
+
+function headlessSlashUnsupportedMessage(adapterName, command) {
+  const display = adapterDisplayName(adapterName);
+  return [
+    `${display} ${command} is a native interactive slash command.`,
+    '',
+    `WTT currently runs ${display} through its non-interactive/headless executable mode for chat automation. In this mode, the CLI does not reliably dispatch interactive slash commands; it may treat them as normal prompts instead.`,
+    '',
+    'Use Agent Terminal for the native TUI command, or use WTT-compatible chat commands such as `/help`, `/status`, `/model`, `/new`, `/clear`, and `/compact`.',
+  ].join('\n');
+}
+
 function wttSlashHelp() {
   return [
     'WTT slash commands:',
@@ -787,10 +904,11 @@ function truncate(text, maxChars) {
 
 function renderGeneratedFileArtifactInstruction(config, topicId = '') {
   const workDir = config.workDir || process.cwd();
+  const outputDir = config.cloudSandbox && config.persistentOutputDir ? config.persistentOutputDir : workDir;
   const uploadCommand = `wtt-connect upload-file --topic-id ${topicId || '<topic_id>'} --title "optional display name" <file-or-files>`;
   return [
     'Generated file artifact rule, for internal execution only:',
-    `- If you create a user-facing file (.docx, .pptx, .xlsx, .pdf, .csv, .md, .zip, images, or video), save it under your current WTT agent workspace: ${workDir}.`,
+    `- If you create a user-facing file (.docx, .pptx, .xlsx, .pdf, .csv, .md, .zip, images, or video), save it under: ${outputDir}.`,
     `- After creating the file, immediately publish it to this WTT conversation by running: ${uploadCommand}`,
     '- For multiple related files, pass all file paths to one upload-file command; wtt-connect will package them into one zip before publishing.',
     '- If upload-file is unavailable, include one marker line per generated file in your final response, exactly like: [WTT_ARTIFACT_FILE path="relative/or/absolute/file.docx" title="optional display name"].',
@@ -799,6 +917,34 @@ function renderGeneratedFileArtifactInstruction(config, topicId = '') {
   ].join('\n');
 }
 
+function renderCloudSandboxStorageInstruction(config) {
+  if (!config.cloudSandbox) return '';
+  const workDir = config.workDir || process.cwd();
+  const persistentDir = String(config.persistentOutputDir || '').trim();
+  const lines = [
+    'Cloud Sandbox storage policy, for internal execution only:',
+    `- This agent is running inside WTT Cloud Sandbox. Keep the active workspace small: ${workDir}.`,
+  ];
+  if (persistentDir) {
+    lines.push(
+      `- Put durable outputs, datasets, downloads, archives, generated reports, build products, and any file expected to survive cleanup under: ${persistentDir}.`,
+      `- Create that directory before use: mkdir -p ${shellishQuote(persistentDir)}.`,
+    );
+  } else {
+    lines.push('- Put durable large outputs under the mounted R2 storage area when available, not in the active workspace.');
+  }
+  lines.push(
+    '- Do not install large dependencies, clone large repositories, download datasets, or write bulky generated files into the workspace unless the user explicitly asks for local temporary storage.',
+    '- Keep only source edits, small manifests, notes, and temporary scratch files in the workspace.',
+    '- If a generated user-facing file is stored in R2/persistent output storage and should appear in WTT chat, still publish it with `wtt-connect upload-file` or a WTT artifact marker.',
+  );
+  return lines.join('\n');
+}
+
+function shellishQuote(value) {
+  return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
+
 async function packageGeneratedFilesIfNeeded(files, config, context = {}) {
   if (!files.length) return [];
   if (files.length === 1) return files;
@@ -1235,6 +1381,7 @@ function buildTaskPrompt(task, config, staged = { promptBlock: '' }, transcripts
     renderTranscriptBlock(transcripts),
     '',
     config.requireCommitPush ? 'For code changes, commit and push before final response, and include commit id.' : '',
+    renderCloudSandboxStorageInstruction(config),
     renderGeneratedFileArtifactInstruction(config, task.topic_id || task.topicId || ''),
     'Return a concise final summary with evidence, changed files, tests, artifacts, and blockers.',
   ].filter(Boolean).join('\n');
@@ -1256,3 +1403,41 @@ function renderTranscriptBlock(transcripts = []) {
   if (!transcripts.length) return '';
   return ['Audio transcripts:', ...transcripts.map((t) => `- ${t.file.name || t.file.path}: ${t.text}`)].join('\n');
 }
+
+function renderCompactSummaryBlock(summary) {
+  const value = String(summary || '').trim();
+  if (!value) return '';
+  return [
+    'Compacted prior WTT conversation context:',
+    '```markdown',
+    value,
+    '```',
+    'Use this summary as the durable context from previous turns. Do not mention that compaction happened unless relevant.',
+  ].join('\n');
+}
+
+function formatTopicMessagesForCompaction(messages = [], options = {}) {
+  const exclude = options.excludeSlashCommands || new Set();
+  const currentAgentId = String(options.currentAgentId || '');
+  const lines = [];
+  for (const message of messages || []) {
+    const content = String(message?.content || '').trim();
+    if (!content) continue;
+    const command = content.startsWith('/') ? content.split(/\s+/, 1)[0].toLowerCase() : '';
+    if (command && exclude.has(command)) continue;
+    const senderId = String(message?.sender_id || '');
+    const senderType = String(message?.sender_type || '').toLowerCase();
+    const role = senderId === currentAgentId || senderType === 'agent' ? 'assistant' : 'user';
+    const name = String(message?.sender_display_name || senderId || role).slice(0, 80);
+    const semantic = String(message?.semantic_type || '').toLowerCase();
+    const text = truncateForTranscript(content, 5000);
+    lines.push(`[${role}${name ? `:${name}` : ''}${semantic ? ` ${semantic}` : ''}] ${text}`);
+  }
+  return truncateForTranscript(lines.join('\n\n'), 90000);
+}
+
+function truncateForTranscript(text, maxChars) {
+  const value = String(text || '');
+  if (value.length <= maxChars) return value;
+  return `${value.slice(0, maxChars)}\n...[truncated ${value.length - maxChars} chars]`;
+}

package/src/slash.js

@@ -20,3 +20,237 @@ export function isAgentSlashCommand(message = {}, content = '') {
   if (slashType === 'agent_passthrough') return true;
   return String(content || message?.content || '').trim().startsWith('/');
 }
+
+export const CODEX_SLASH_COMMANDS = [
+  ['/agent', 'Configure or switch Codex agent settings.'],
+  ['/apps', 'Browse available Codex apps/connectors.'],
+  ['/plugins', 'Browse and manage Codex plugins.'],
+  ['/hooks', 'View and manage lifecycle hooks.'],
+  ['/clear', 'Clear the current terminal view and start fresh.'],
+  ['/compact', 'Summarize earlier context to free tokens.'],
+  ['/copy', 'Copy the latest response.'],
+  ['/diff', 'Show the current git diff, including untracked files.'],
+  ['/exit', 'Exit Codex. Alias: /quit.'],
+  ['/quit', 'Exit Codex. Alias: /exit.'],
+  ['/experimental', 'Toggle experimental Codex features.'],
+  ['/approve', 'Approve one retry after an auto-review denial.'],
+  ['/memories', 'Configure Codex memory use and generation.'],
+  ['/skills', 'Browse and use skills.'],
+  ['/feedback', 'Send diagnostics or feedback to Codex maintainers.'],
+  ['/init', 'Generate or update AGENTS.md guidance.'],
+  ['/logout', 'Sign out of Codex.'],
+  ['/mcp', 'List configured MCP tools; use verbose for diagnostics.'],
+  ['/mention', 'Attach a file or folder to the conversation.'],
+  ['/model', 'Choose the active model and reasoning effort.'],
+  ['/fast', 'Toggle or inspect Fast service tier when available.'],
+  ['/plan', 'Switch to plan mode, optionally with a prompt.'],
+  ['/goal', 'Set, view, pause, resume, or clear a task goal.'],
+  ['/personality', 'Choose response style.'],
+  ['/ps', 'Show background terminals and recent output.'],
+  ['/stop', 'Stop background terminals.'],
+  ['/clean', 'Alias for /stop.'],
+  ['/fork', 'Fork the current conversation into a new thread.'],
+  ['/side', 'Start an ephemeral side conversation.'],
+  ['/raw', 'Toggle raw scrollback mode.'],
+  ['/resume', 'Resume a saved conversation.'],
+  ['/new', 'Start a new conversation in the same workspace.'],
+  ['/review', 'Review the working tree.'],
+  ['/status', 'Show session configuration, token usage, and runtime status.'],
+  ['/debug-config', 'Print configuration diagnostics.'],
+  ['/statusline', 'Configure TUI status-line fields.'],
+  ['/title', 'Configure terminal title fields.'],
+  ['/theme', 'Choose syntax-highlighting theme.'],
+  ['/permissions', 'Adjust approval and sandbox permissions.'],
+  ['/ide', 'Configure IDE integration.'],
+  ['/keymap', 'Configure keyboard shortcuts.'],
+  ['/vim', 'Toggle Vim editing mode.'],
+  ['/sandbox-add-read-dir', 'Add an extra read-only sandbox directory.'],
+];
+
+export const CLAUDE_CODE_SLASH_COMMANDS = [
+  ['/add-dir', 'Add a working directory for file access.'],
+  ['/agents', 'Manage agent/subagent configurations.'],
+  ['/autofix-pr', 'Spawn Claude Code on the web to fix PR/CI feedback.'],
+  ['/background', 'Detach the current session to run as a background agent. Alias: /bg.'],
+  ['/bg', 'Alias for /background.'],
+  ['/batch', 'Decompose large work across parallel worktrees/subagents.'],
+  ['/branch', 'Branch the current conversation. Alias: /fork.'],
+  ['/fork', 'Alias for /branch in Claude Code.'],
+  ['/btw', 'Ask a side question without bloating history.'],
+  ['/chrome', 'Configure Claude in Chrome settings.'],
+  ['/claude-api', 'Load Claude API reference or migration workflows.'],
+  ['/clear', 'Start a new conversation with empty context. Aliases: /reset, /new.'],
+  ['/reset', 'Alias for /clear.'],
+  ['/new', 'Alias for /clear.'],
+  ['/code-review', 'Review current diff and optionally apply fixes.'],
+  ['/color', 'Set prompt bar color.'],
+  ['/compact', 'Summarize conversation to free context.'],
+  ['/config', 'Open settings. Alias: /settings.'],
+  ['/settings', 'Alias for /config.'],
+  ['/context', 'Visualize context usage.'],
+  ['/copy', 'Copy a recent assistant response.'],
+  ['/cost', 'Alias for /usage.'],
+  ['/debug', 'Enable debug logging and troubleshoot.'],
+  ['/deep-research', 'Run a deep-research workflow.'],
+  ['/desktop', 'Continue in Claude Code Desktop. Alias: /app.'],
+  ['/app', 'Alias for /desktop.'],
+  ['/diff', 'Open an interactive diff viewer.'],
+  ['/doctor', 'Diagnose installation and settings.'],
+  ['/effort', 'Set reasoning effort level.'],
+  ['/exit', 'Exit or detach from a background session. Alias: /quit.'],
+  ['/quit', 'Alias for /exit.'],
+  ['/export', 'Export the current conversation.'],
+  ['/fast', 'Toggle fast mode.'],
+  ['/feedback', 'Submit feedback or a bug report. Aliases: /bug, /share.'],
+  ['/bug', 'Alias for /feedback.'],
+  ['/share', 'Alias for /feedback.'],
+  ['/fewer-permission-prompts', 'Generate an allowlist to reduce prompts.'],
+  ['/focus', 'Toggle focus view.'],
+  ['/goal', 'Set, view, or clear a persistent goal.'],
+  ['/heapdump', 'Write a heap snapshot for diagnostics.'],
+  ['/help', 'Show Claude Code help and commands.'],
+  ['/hooks', 'View hook configuration.'],
+  ['/ide', 'Manage IDE integrations.'],
+  ['/init', 'Initialize CLAUDE.md project guidance.'],
+  ['/insights', 'Analyze Claude Code sessions.'],
+  ['/install-github-app', 'Install Claude GitHub Actions app.'],
+  ['/install-slack-app', 'Install Claude Slack app.'],
+  ['/keybindings', 'Open keybindings configuration.'],
+  ['/login', 'Sign in to Anthropic.'],
+  ['/logout', 'Sign out from Anthropic.'],
+  ['/loop', 'Run a prompt repeatedly. Alias: /proactive.'],
+  ['/proactive', 'Alias for /loop.'],
+  ['/mcp', 'Manage MCP server connections and OAuth.'],
+  ['/memory', 'Edit memory files and auto-memory entries.'],
+  ['/mobile', 'Show mobile app QR code. Aliases: /ios, /android.'],
+  ['/ios', 'Alias for /mobile.'],
+  ['/android', 'Alias for /mobile.'],
+  ['/model', 'Switch model and save defaults.'],
+  ['/passes', 'Share Claude Code passes when eligible.'],
+  ['/permissions', 'Manage tool permissions. Alias: /allowed-tools.'],
+  ['/allowed-tools', 'Alias for /permissions.'],
+  ['/plan', 'Enter plan mode, optionally with a task.'],
+  ['/plugin', 'Manage Claude Code plugins.'],
+  ['/powerup', 'Discover Claude Code features.'],
+  ['/pr-comments', 'Legacy PR comments helper.'],
+  ['/privacy-settings', 'View/update privacy settings.'],
+  ['/radio', 'Open Claude FM radio.'],
+  ['/recap', 'Generate a one-line session recap.'],
+  ['/release-notes', 'View changelog.'],
+  ['/reload-plugins', 'Reload active plugins.'],
+  ['/reload-skills', 'Reload skills and command directories.'],
+  ['/remote-control', 'Enable remote control from claude.ai. Alias: /rc.'],
+  ['/rc', 'Alias for /remote-control.'],
+  ['/remote-env', 'Configure default remote environment.'],
+  ['/rename', 'Rename current session.'],
+  ['/resume', 'Resume a previous conversation. Alias: /continue.'],
+  ['/continue', 'Alias for /resume.'],
+  ['/review', 'Review a PR locally.'],
+  ['/rewind', 'Rewind conversation/code to a checkpoint. Aliases: /checkpoint, /undo.'],
+  ['/checkpoint', 'Alias for /rewind.'],
+  ['/undo', 'Alias for /rewind.'],
+  ['/run', 'Launch and verify the project app.'],
+  ['/run-skill-generator', 'Generate project run/verify skills.'],
+  ['/sandbox', 'Toggle sandbox mode where supported.'],
+  ['/schedule', 'Create or manage routines. Alias: /routines.'],
+  ['/routines', 'Alias for /schedule.'],
+  ['/scroll-speed', 'Adjust mouse wheel scroll speed.'],
+  ['/security-review', 'Analyze pending changes for security risks.'],
+  ['/setup-bedrock', 'Configure Amazon Bedrock.'],
+  ['/setup-vertex', 'Configure Google Vertex AI.'],
+  ['/simplify', 'Review changes for cleanup opportunities.'],
+  ['/skills', 'List and manage skills.'],
+  ['/stats', 'Alias for /usage.'],
+  ['/status', 'Open status/settings view.'],
+  ['/statusline', 'Configure status line.'],
+  ['/stickers', 'Order stickers.'],
+  ['/stop', 'Stop an attached background session.'],
+  ['/tasks', 'List and manage background tasks. Alias: /bashes.'],
+  ['/bashes', 'Alias for /tasks.'],
+  ['/team-onboarding', 'Generate team onboarding guide.'],
+  ['/teleport', 'Pull a web session into terminal. Alias: /tp.'],
+  ['/tp', 'Alias for /teleport.'],
+  ['/terminal-setup', 'Configure terminal keybindings.'],
+  ['/theme', 'Change color theme.'],
+  ['/tui', 'Set terminal UI renderer.'],
+  ['/ultraplan', 'Draft a plan in an ultraplan session.'],
+  ['/ultrareview', 'Run deep multi-agent code review.'],
+  ['/upgrade', 'Open plan upgrade page.'],
+  ['/usage', 'Show cost, usage limits, and activity stats.'],
+  ['/usage-credits', 'Configure usage credits.'],
+  ['/verify', 'Verify a code change by running the app.'],
+  ['/vim', 'Legacy Vim-mode command.'],
+  ['/voice', 'Toggle voice dictation.'],
+  ['/web-setup', 'Connect GitHub for Claude Code on the web.'],
+  ['/workflows', 'Watch and manage workflows.'],
+];
+
+export const GEMINI_SLASH_COMMANDS = [
+  ['/about', 'Show version information.'],
+  ['/agents', 'Manage local and remote subagents.'],
+  ['/auth', 'Change authentication method.'],
+  ['/bug', 'File an issue or bug report.'],
+  ['/chat', 'Alias for /resume and checkpoint management.'],
+  ['/clear', 'Clear visible terminal/session history.'],
+  ['/commands', 'List or reload custom slash commands.'],
+  ['/compress', 'Compress chat context into a summary.'],
+  ['/copy', 'Copy the last output.'],
+  ['/directory', 'Manage workspace directories. Alias: /dir.'],
+  ['/dir', 'Alias for /directory.'],
+  ['/docs', 'Open Gemini CLI documentation.'],
+  ['/editor', 'Select editor integration.'],
+  ['/extensions', 'Manage Gemini CLI extensions.'],
+  ['/help', 'Show Gemini CLI help. Alias: /?.'],
+  ['/?', 'Alias for /help.'],
+  ['/hooks', 'Manage lifecycle hooks.'],
+  ['/ide', 'Manage IDE integration.'],
+  ['/init', 'Generate or update GEMINI.md.'],
+  ['/mcp', 'Manage MCP servers.'],
+  ['/memory', 'Inspect or refresh GEMINI.md memory.'],
+  ['/model', 'Manage model configuration.'],
+  ['/permissions', 'Manage folder trust and permissions.'],
+  ['/plan', 'Switch to plan mode.'],
+  ['/policies', 'List active policies.'],
+  ['/privacy', 'Display privacy notice and consent options.'],
+  ['/quit', 'Exit Gemini CLI. Alias: /exit.'],
+  ['/exit', 'Alias for /quit.'],
+  ['/restore', 'Restore files to a checkpoint.'],
+  ['/rewind', 'Navigate backward through conversation history.'],
+  ['/resume', 'Browse, resume, save, delete, or share sessions.'],
+  ['/settings', 'Open settings editor.'],
+  ['/shells', 'Toggle background shells view. Alias: /bashes.'],
+  ['/bashes', 'Alias for /shells.'],
+  ['/setup-github', 'Set up GitHub Actions integration.'],
+  ['/skills', 'Manage Agent Skills.'],
+  ['/stats', 'Show Gemini CLI session statistics.'],
+  ['/terminal-setup', 'Configure multiline keybindings.'],
+  ['/theme', 'Change visual theme.'],
+  ['/tools', 'Show available tools.'],
+  ['/upgrade', 'Open Gemini Code Assist upgrade page.'],
+  ['/vim', 'Toggle Vim mode.'],
+];
+
+export function slashCommandsForAdapter(adapterName) {
+  const name = String(adapterName || '').trim().toLowerCase();
+  if (name === 'codex' || name.includes('codex')) return CODEX_SLASH_COMMANDS;
+  if (name === 'claude-code' || name === 'claude' || name.includes('claude')) return CLAUDE_CODE_SLASH_COMMANDS;
+  if (name === 'gemini' || name.includes('gemini')) return GEMINI_SLASH_COMMANDS;
+  return [
+    ['/help', 'Show help.'],
+    ['/status', 'Show WTT runtime status.'],
+    ['/model', 'Show or switch model when supported.'],
+    ['/clear', 'Clear the WTT topic session.'],
+    ['/new', 'Start a fresh WTT topic session.'],
+    ['/compact', 'Compact context when supported.'],
+  ];
+}
+
+export function formatSlashCommandHelp(adapterName) {
+  const title = adapterName ? `${adapterName} slash commands` : 'Agent slash commands';
+  return [
+    `${title}:`,
+    ...slashCommandsForAdapter(adapterName).map(([cmd, desc]) => `- \`${cmd}\`: ${desc}`),
+    '',
+    'Note: WTT handles deterministic commands such as /status, /new, /clear, /compact, /diff, /review, and /init where possible. Other commands are passed through to the underlying CLI; interactive TUI-only commands may require opening the agent terminal.',
+  ].join('\n');
+}

package/src/wtt-api.js

@@ -76,6 +76,22 @@ export class WTTApi {
     return this.request('POST', '/tasks', { json: payload });
   }
 
+  async getTopicMessages(topicId, { limit = 120, includeHistory = true } = {}) {
+    if (!topicId) return [];
+    const params = new URLSearchParams({
+      limit: String(limit),
+      agent_id: this.config.agentId || '',
+      include_history: includeHistory ? 'true' : 'false',
+    });
+    try {
+      const rows = await this.request('GET', `/topics/${encodeURIComponent(topicId)}/messages?${params.toString()}`);
+      return Array.isArray(rows) ? rows : [];
+    } catch (err) {
+      log('warn', 'get_topic_messages failed', { topicId, error: err.message });
+      return [];
+    }
+  }
+
   async runTask(taskId, payload = {}) {
     return this.request('POST', `/tasks/${taskId}/run`, { json: payload });
   }