tmux-team 2.0.0-alpha.1 → 2.0.0-alpha.4

package/package.json

@@ -1,13 +1,15 @@
 {
   "name": "tmux-team",
-  "version": "2.0.0-alpha.1",
+  "version": "2.0.0-alpha.4",
   "description": "CLI tool for AI agent collaboration in tmux - manage cross-pane communication",
   "type": "module",
   "bin": {
-    "tmux-team": "./bin/tmux-team"
+    "tmux-team": "./bin/tmux-team",
+    "tmt": "./bin/tmux-team"
   },
   "scripts": {
     "dev": "tsx src/cli.ts",
+    "tmt": "./bin/tmux-team",
     "test": "vitest",
     "test:run": "vitest run",
     "lint": "oxlint src/",

package/src/cli.ts

@@ -7,7 +7,8 @@ import { createContext, ExitCodes } from './context.js';
 import type { Flags } from './types.js';
 
 // Commands
-import { cmdHelp } from './commands/help.js';
+import { cmdHelp, HelpConfig } from './commands/help.js';
+import { loadConfig, resolvePaths } from './config.js';
 import { cmdInit } from './commands/init.js';
 import { cmdList } from './commands/list.js';
 import { cmdAdd } from './commands/add.js';
@@ -17,6 +18,8 @@ import { cmdTalk } from './commands/talk.js';
 import { cmdCheck } from './commands/check.js';
 import { cmdCompletion } from './commands/completion.js';
 import { cmdPm } from './pm/commands.js';
+import { cmdConfig } from './commands/config.js';
+import { cmdPreamble } from './commands/preamble.js';
 
 // ─────────────────────────────────────────────────────────────
 // Argument parsing
@@ -101,9 +104,20 @@ function main(): void {
   const argv = process.argv.slice(2);
   const { command, args, flags } = parseArgs(argv);
 
-  // Help doesn't need context
+  // Help - load config to show current mode/timeout
   if (!command || command === 'help' || command === '--help' || command === '-h') {
-    cmdHelp();
+    try {
+      const paths = resolvePaths();
+      const config = loadConfig(paths);
+      const helpConfig: HelpConfig = {
+        mode: config.mode,
+        timeout: config.defaults.timeout,
+      };
+      cmdHelp(helpConfig);
+    } catch {
+      // Fallback if config can't be loaded
+      cmdHelp();
+    }
     process.exit(ExitCodes.SUCCESS);
   }
 
@@ -193,6 +207,14 @@ function main(): void {
         await cmdPm(ctx, args);
         break;
 
+      case 'config':
+        cmdConfig(ctx, args);
+        break;
+
+      case 'preamble':
+        cmdPreamble(ctx, args);
+        break;
+
       default:
         ctx.ui.error(`Unknown command: ${command}. Run 'tmux-team help' for usage.`);
         ctx.exit(ExitCodes.ERROR);

package/src/commands/config.ts

@@ -0,0 +1,186 @@
+// ─────────────────────────────────────────────────────────────
+// Config command - view and modify settings
+// ─────────────────────────────────────────────────────────────
+
+import type { Context } from '../types.js';
+import { ExitCodes } from '../context.js';
+import {
+  loadGlobalConfig,
+  saveGlobalConfig,
+  loadLocalConfigFile,
+  saveLocalConfigFile,
+  updateLocalSettings,
+  clearLocalSettings,
+} from '../config.js';
+
+type ConfigKey = 'mode' | 'preambleMode';
+
+const VALID_KEYS: ConfigKey[] = ['mode', 'preambleMode'];
+
+const VALID_VALUES: Record<ConfigKey, string[]> = {
+  mode: ['polling', 'wait'],
+  preambleMode: ['always', 'disabled'],
+};
+
+function isValidKey(key: string): key is ConfigKey {
+  return VALID_KEYS.includes(key as ConfigKey);
+}
+
+function isValidValue(key: ConfigKey, value: string): boolean {
+  return VALID_VALUES[key].includes(value);
+}
+
+/**
+ * Show resolved config with source indicators.
+ */
+function showConfig(ctx: Context): void {
+  const globalConfig = loadGlobalConfig(ctx.paths);
+  const localConfigFile = loadLocalConfigFile(ctx.paths);
+  const localSettings = localConfigFile.$config;
+
+  if (ctx.flags.json) {
+    ctx.ui.json({
+      resolved: {
+        mode: ctx.config.mode,
+        preambleMode: ctx.config.preambleMode,
+        defaults: ctx.config.defaults,
+      },
+      sources: {
+        mode: localSettings?.mode ? 'local' : globalConfig.mode ? 'global' : 'default',
+        preambleMode: localSettings?.preambleMode
+          ? 'local'
+          : globalConfig.preambleMode
+            ? 'global'
+            : 'default',
+      },
+      paths: {
+        global: ctx.paths.globalConfig,
+        local: ctx.paths.localConfig,
+      },
+    });
+    return;
+  }
+
+  // Determine sources
+  const modeSource = localSettings?.mode ? '(local)' : globalConfig.mode ? '(global)' : '(default)';
+  const preambleSource = localSettings?.preambleMode
+    ? '(local)'
+    : globalConfig.preambleMode
+      ? '(global)'
+      : '(default)';
+
+  ctx.ui.info('Current configuration:\n');
+  ctx.ui.table(
+    ['Key', 'Value', 'Source'],
+    [
+      ['mode', ctx.config.mode, modeSource],
+      ['preambleMode', ctx.config.preambleMode, preambleSource],
+      ['defaults.timeout', String(ctx.config.defaults.timeout), '(global)'],
+      ['defaults.pollInterval', String(ctx.config.defaults.pollInterval), '(global)'],
+      ['defaults.captureLines', String(ctx.config.defaults.captureLines), '(global)'],
+    ]
+  );
+
+  ctx.ui.info(`\nPaths:`);
+  ctx.ui.info(`  Global: ${ctx.paths.globalConfig}`);
+  ctx.ui.info(`  Local:  ${ctx.paths.localConfig}`);
+}
+
+/**
+ * Set a config value.
+ */
+function setConfig(ctx: Context, key: string, value: string, global: boolean): void {
+  if (!isValidKey(key)) {
+    ctx.ui.error(`Invalid key: ${key}. Valid keys: ${VALID_KEYS.join(', ')}`);
+    ctx.exit(ExitCodes.ERROR);
+  }
+
+  if (!isValidValue(key, value)) {
+    ctx.ui.error(
+      `Invalid value for ${key}: ${value}. Valid values: ${VALID_VALUES[key].join(', ')}`
+    );
+    ctx.exit(ExitCodes.ERROR);
+  }
+
+  if (global) {
+    // Set in global config
+    const globalConfig = loadGlobalConfig(ctx.paths);
+    if (key === 'mode') {
+      globalConfig.mode = value as 'polling' | 'wait';
+    } else if (key === 'preambleMode') {
+      globalConfig.preambleMode = value as 'always' | 'disabled';
+    }
+    saveGlobalConfig(ctx.paths, globalConfig);
+    ctx.ui.success(`Set ${key}=${value} in global config`);
+  } else {
+    // Set in local config
+    if (key === 'mode') {
+      updateLocalSettings(ctx.paths, { mode: value as 'polling' | 'wait' });
+    } else if (key === 'preambleMode') {
+      updateLocalSettings(ctx.paths, { preambleMode: value as 'always' | 'disabled' });
+    }
+    ctx.ui.success(`Set ${key}=${value} in local config (repo override)`);
+  }
+}
+
+/**
+ * Clear local config override.
+ */
+function clearConfig(ctx: Context, key?: string): void {
+  if (key) {
+    if (!isValidKey(key)) {
+      ctx.ui.error(`Invalid key: ${key}. Valid keys: ${VALID_KEYS.join(', ')}`);
+      ctx.exit(ExitCodes.ERROR);
+    }
+
+    // Clear specific key from local settings
+    const localConfigFile = loadLocalConfigFile(ctx.paths);
+    if (localConfigFile.$config) {
+      delete localConfigFile.$config[key];
+      // Remove $config if empty
+      if (Object.keys(localConfigFile.$config).length === 0) {
+        delete localConfigFile.$config;
+      }
+      saveLocalConfigFile(ctx.paths, localConfigFile);
+    }
+    ctx.ui.success(`Cleared local override for ${key}`);
+  } else {
+    // Clear all local settings
+    clearLocalSettings(ctx.paths);
+    ctx.ui.success('Cleared all local config overrides');
+  }
+}
+
+/**
+ * Config command entry point.
+ */
+export function cmdConfig(ctx: Context, args: string[]): void {
+  // Parse --global flag first, then determine subcommand
+  const globalFlag = args.includes('--global') || args.includes('-g');
+  const filteredArgs = args.filter((a) => a !== '--global' && a !== '-g');
+  const subcommand = filteredArgs[0];
+
+  switch (subcommand) {
+    case undefined:
+    case 'show':
+      showConfig(ctx);
+      break;
+
+    case 'set':
+      if (filteredArgs.length < 3) {
+        ctx.ui.error('Usage: tmux-team config set <key> <value> [--global]');
+        ctx.exit(ExitCodes.ERROR);
+      }
+      setConfig(ctx, filteredArgs[1], filteredArgs[2], globalFlag);
+      break;
+
+    case 'clear':
+      clearConfig(ctx, filteredArgs[1]);
+      break;
+
+    default:
+      ctx.ui.error(`Unknown config subcommand: ${subcommand}`);
+      ctx.ui.error('Usage: tmux-team config [show|set|clear]');
+      ctx.exit(ExitCodes.ERROR);
+  }
+}

package/src/commands/help.ts

@@ -5,10 +5,30 @@
 import { colors } from '../ui.js';
 import { VERSION } from '../version.js';
 
-export function cmdHelp(): void {
+export interface HelpConfig {
+  mode?: 'polling' | 'wait';
+  timeout?: number;
+}
+
+export function cmdHelp(config?: HelpConfig): void {
+  const mode = config?.mode ?? 'polling';
+  const timeout = config?.timeout ?? 180;
+  const isWaitMode = mode === 'wait';
+
+  // Mode indicator with clear explanation
+  const modeInfo = isWaitMode
+    ? `${colors.yellow('CURRENT MODE')}: ${colors.green('wait')} (timeout: ${timeout}s)
+  ${colors.dim('→ talk commands will BLOCK until agent responds or timeout')}
+  ${colors.dim('→ Response is returned directly, no need to use check command')}`
+    : `${colors.yellow('CURRENT MODE')}: ${colors.cyan('polling')}
+  ${colors.dim('→ talk commands send and return immediately')}
+  ${colors.dim('→ Use check command to read agent response')}`;
+
   console.log(`
 ${colors.cyan('tmux-team')} v${VERSION} - AI agent collaboration in tmux
 
+${modeInfo}
+
 ${colors.yellow('USAGE')}
   tmux-team <command> [arguments]
 
@@ -20,6 +40,8 @@ ${colors.yellow('COMMANDS')}
   ${colors.green('update')} <name> [options]     Update an agent's config
   ${colors.green('remove')} <name>               Remove an agent
   ${colors.green('init')}                        Create empty tmux-team.json
+  ${colors.green('config')} [show|set|clear]     View/modify settings
+  ${colors.green('preamble')} [show|set|clear]   Manage agent preambles
   ${colors.green('pm')} <subcommand>             Project management (run 'pm help')
   ${colors.green('completion')}                  Output shell completion script
   ${colors.green('help')}                        Show this help message
@@ -29,23 +51,33 @@ ${colors.yellow('OPTIONS')}
   ${colors.green('--verbose')}                   Show detailed output
   ${colors.green('--force')}                     Skip warnings
 
-${colors.yellow('TALK OPTIONS')} ${colors.dim('(v2)')}
-  ${colors.green('--delay')} <seconds>           Wait before sending (default: seconds)
-  ${colors.green('--wait')}                      Wait for agent response (nonce-based)
-  ${colors.green('--timeout')} <seconds>         Max wait time (default: 60)
+${colors.yellow('TALK OPTIONS')}
+  ${colors.green('--delay')} <seconds>           Wait before sending
+  ${colors.green('--wait')}                      Force wait mode (block until response)
+  ${colors.green('--timeout')} <seconds>         Max wait time (current: ${timeout}s)
   ${colors.green('--no-preamble')}               Skip agent preamble for this message
 
-${colors.yellow('EXAMPLES')}
-  tmux-team talk codex "Please review the PR"
-  tmux-team talk all "Sync meeting in 5 minutes"
-  tmux-team check gemini 50
+${colors.yellow('EXAMPLES')}${
+    isWaitMode
+      ? `
+  ${colors.dim('# Wait mode: commands block until response')}
+  tmux-team talk codex "Review this PR"     ${colors.dim('← blocks, returns response')}
+  tmux-team talk all "Status update"        ${colors.dim('← waits for all agents')}`
+      : `
+  ${colors.dim('# Polling mode: send then check')}
+  tmux-team talk codex "Review this PR"     ${colors.dim('← sends immediately')}
+  tmux-team check codex                     ${colors.dim('← read response later')}`
+  }
   tmux-team list --json
   tmux-team add codex 10.1 "Code review specialist"
-  tmux-team update codex --pane 10.2
-  tmux-team remove codex
 
 ${colors.yellow('CONFIG')}
-  Local:  ./tmux-team.json (pane registry)
+  Local:  ./tmux-team.json (pane registry + $config override)
   Global: ~/.config/tmux-team/config.json (settings)
+
+${colors.yellow('CHANGE MODE')}
+  tmux-team config set mode wait            ${colors.dim('Enable wait mode (local)')}
+  tmux-team config set mode polling         ${colors.dim('Enable polling mode (local)')}
+  tmux-team config set timeout 120          ${colors.dim('Set timeout to 120s')}
 `);
 }

package/src/commands/preamble.ts

@@ -0,0 +1,153 @@
+// ─────────────────────────────────────────────────────────────
+// Preamble command - manage agent preambles
+// ─────────────────────────────────────────────────────────────
+
+import type { Context } from '../types.js';
+import { ExitCodes } from '../context.js';
+import { loadGlobalConfig, saveGlobalConfig } from '../config.js';
+
+/**
+ * Show preamble(s) for agent(s).
+ */
+function showPreamble(ctx: Context, agentName?: string): void {
+  const { ui, config, flags } = ctx;
+
+  if (agentName) {
+    // Show specific agent's preamble
+    const agentConfig = config.agents[agentName];
+    const preamble = agentConfig?.preamble;
+
+    if (flags.json) {
+      ui.json({ agent: agentName, preamble: preamble ?? null });
+      return;
+    }
+
+    if (preamble) {
+      ui.info(`Preamble for ${agentName}:`);
+      console.log(preamble);
+    } else {
+      ui.info(`No preamble set for ${agentName}`);
+    }
+  } else {
+    // Show all preambles
+    const preambles: { agent: string; preamble: string }[] = [];
+
+    for (const [name, agentConfig] of Object.entries(config.agents)) {
+      if (agentConfig.preamble) {
+        preambles.push({ agent: name, preamble: agentConfig.preamble });
+      }
+    }
+
+    if (flags.json) {
+      ui.json({ preambles });
+      return;
+    }
+
+    if (preambles.length === 0) {
+      ui.info('No preambles configured');
+      return;
+    }
+
+    for (const { agent, preamble } of preambles) {
+      console.log(`─── ${agent} ───`);
+      console.log(preamble);
+      console.log();
+    }
+  }
+}
+
+/**
+ * Set preamble for an agent.
+ */
+function setPreamble(ctx: Context, agentName: string, preamble: string): void {
+  const { ui, paths, flags } = ctx;
+
+  const globalConfig = loadGlobalConfig(paths);
+
+  // Ensure agents object exists
+  if (!globalConfig.agents) {
+    globalConfig.agents = {};
+  }
+
+  // Ensure agent config exists
+  if (!globalConfig.agents[agentName]) {
+    globalConfig.agents[agentName] = {};
+  }
+
+  globalConfig.agents[agentName].preamble = preamble;
+  saveGlobalConfig(paths, globalConfig);
+
+  if (flags.json) {
+    ui.json({ agent: agentName, preamble, status: 'set' });
+  } else {
+    ui.success(`Set preamble for ${agentName}`);
+  }
+}
+
+/**
+ * Clear preamble for an agent.
+ */
+function clearPreamble(ctx: Context, agentName: string): void {
+  const { ui, paths, flags } = ctx;
+
+  const globalConfig = loadGlobalConfig(paths);
+
+  if (globalConfig.agents?.[agentName]?.preamble) {
+    delete globalConfig.agents[agentName].preamble;
+
+    // Clean up empty agent config
+    if (Object.keys(globalConfig.agents[agentName]).length === 0) {
+      delete globalConfig.agents[agentName];
+    }
+
+    saveGlobalConfig(paths, globalConfig);
+
+    if (flags.json) {
+      ui.json({ agent: agentName, status: 'cleared' });
+    } else {
+      ui.success(`Cleared preamble for ${agentName}`);
+    }
+  } else {
+    if (flags.json) {
+      ui.json({ agent: agentName, status: 'not_set' });
+    } else {
+      ui.info(`No preamble was set for ${agentName}`);
+    }
+  }
+}
+
+/**
+ * Preamble command entry point.
+ */
+export function cmdPreamble(ctx: Context, args: string[]): void {
+  const subcommand = args[0];
+
+  switch (subcommand) {
+    case undefined:
+    case 'show':
+      showPreamble(ctx, args[1]);
+      break;
+
+    case 'set':
+      if (args.length < 3) {
+        ctx.ui.error('Usage: tmux-team preamble set <agent> <preamble>');
+        ctx.exit(ExitCodes.ERROR);
+      }
+      // Join remaining args as preamble (allows spaces without quotes)
+      setPreamble(ctx, args[1], args.slice(2).join(' '));
+      break;
+
+    case 'clear':
+      if (args.length < 2) {
+        ctx.ui.error('Usage: tmux-team preamble clear <agent>');
+        ctx.exit(ExitCodes.ERROR);
+      }
+      clearPreamble(ctx, args[1]);
+      break;
+
+    default:
+      ctx.ui.error(`Unknown preamble subcommand: ${subcommand}`);
+      ctx.ui.error('Usage: tmux-team preamble [show|set|clear]');
+      ctx.exit(ExitCodes.ERROR);
+  }
+}

package/src/commands/talk.test.ts

@@ -203,12 +203,18 @@ describe('buildMessage (via cmdTalk)', () => {
 
 describe('cmdTalk - basic send', () => {
   let testDir: string;
+  const originalEnv = { ...process.env };
 
   beforeEach(() => {
+    // Disable pane detection in tests
+    delete process.env.TMUX;
+    delete process.env.TMT_AGENT_NAME;
+    delete process.env.TMUX_TEAM_ACTOR;
     testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'talk-test-'));
   });
 
   afterEach(() => {
+    process.env = { ...originalEnv };
     if (fs.existsSync(testDir)) {
       fs.rmSync(testDir, { recursive: true, force: true });
     }
@@ -235,6 +241,27 @@ describe('cmdTalk - basic send', () => {
     expect(tmux.sends.map((s) => s.pane).sort()).toEqual(['1.0', '1.1', '1.2']);
   });
 
+  it('skips self when sending to all (via env var)', async () => {
+    // Simulate being an agent via env var (when not in tmux)
+    const originalEnv = { ...process.env };
+    delete process.env.TMUX; // Ensure pane detection is disabled
+    process.env.TMT_AGENT_NAME = 'claude';
+
+    try {
+      const tmux = createMockTmux();
+      const ui = createMockUI();
+      const ctx = createContext({ tmux, ui, paths: createTestPaths(testDir) });
+
+      await cmdTalk(ctx, 'all', 'Hello team');
+
+      // Should skip claude (self) and only send to codex and gemini
+      expect(tmux.sends).toHaveLength(2);
+      expect(tmux.sends.map((s) => s.pane).sort()).toEqual(['1.1', '1.2']);
+    } finally {
+      process.env = originalEnv;
+    }
+  });
+
   it('removes exclamation marks for gemini agent', async () => {
     const tmux = createMockTmux();
     const ctx = createContext({ tmux, paths: createTestPaths(testDir) });
@@ -506,16 +533,144 @@ describe('cmdTalk - --wait mode', () => {
     }
   });
 
-  it('errors when using --wait with all target', async () => {
+  it('supports wait mode with all target (parallel polling)', async () => {
+    // Create mock tmux that returns markers for each agent after a delay
+    const tmux = createMockTmux();
+    let captureCount = 0;
+    const markersByPane: Record<string, string> = {};
+
+    // Mock send to capture the marker for each pane
+    tmux.send = (pane: string, msg: string) => {
+      const match = msg.match(/\{tmux-team-end:([a-f0-9]+)\}/);
+      if (match) {
+        markersByPane[pane] = match[0];
+      }
+    };
+
+    // Mock capture to return the marker after first poll
+    tmux.capture = (pane: string) => {
+      captureCount++;
+      // Return marker on second capture for each pane
+      if (captureCount > 3 && markersByPane[pane]) {
+        return `Response from agent\n${markersByPane[pane]}`;
+      }
+      return 'working...';
+    };
+
     const ui = createMockUI();
+    const paths = createTestPaths(testDir);
     const ctx = createContext({
       ui,
-      paths: createTestPaths(testDir),
-      flags: { wait: true },
+      tmux,
+      paths,
+      flags: { wait: true, timeout: 5 },
+      config: {
+        defaults: { timeout: 5, pollInterval: 0.05, captureLines: 100 },
+        paneRegistry: {
+          codex: { pane: '10.1' },
+          gemini: { pane: '10.2' },
+        },
+      },
     });
 
-    await expect(cmdTalk(ctx, 'all', 'Hello')).rejects.toThrow('exit(1)');
-    expect(ui.errors[0]).toContain('Wait mode is not supported');
+    await cmdTalk(ctx, 'all', 'Hello');
+
+    // Should have captured both panes
+    expect(captureCount).toBeGreaterThan(2);
+  });
+
+  it('handles partial timeout in wait mode with all target', async () => {
+    const tmux = createMockTmux();
+    const markersByPane: Record<string, string> = {};
+
+    tmux.send = (pane: string, msg: string) => {
+      const match = msg.match(/\{tmux-team-end:([a-f0-9]+)\}/);
+      if (match) {
+        markersByPane[pane] = match[0];
+      }
+    };
+
+    // Only pane 10.1 responds, 10.2 times out
+    tmux.capture = (pane: string) => {
+      if (pane === '10.1' && markersByPane[pane]) {
+        return `Response from codex\n${markersByPane[pane]}`;
+      }
+      return 'still working...';
+    };
+
+    const ui = createMockUI();
+    const paths = createTestPaths(testDir);
+    const ctx = createContext({
+      ui,
+      tmux,
+      paths,
+      flags: { wait: true, timeout: 0.1, json: true },
+      config: {
+        defaults: { timeout: 0.1, pollInterval: 0.02, captureLines: 100 },
+        paneRegistry: {
+          codex: { pane: '10.1' },
+          gemini: { pane: '10.2' },
+        },
+      },
+    });
+
+    try {
+      await cmdTalk(ctx, 'all', 'Hello');
+    } catch {
+      // Expected timeout exit
+    }
+
+    // Should have JSON output with both results
+    expect(ui.jsonOutput.length).toBe(1);
+    const result = ui.jsonOutput[0] as {
+      summary: { completed: number; timeout: number };
+      results: Array<{ agent: string; status: string }>;
+    };
+    expect(result.summary.completed).toBe(1);
+    expect(result.summary.timeout).toBe(1);
+    expect(result.results.find((r) => r.agent === 'codex')?.status).toBe('completed');
+    expect(result.results.find((r) => r.agent === 'gemini')?.status).toBe('timeout');
+  });
+
+  it('uses unique nonces per agent in broadcast', async () => {
+    const tmux = createMockTmux();
+    const nonces: string[] = [];
+
+    tmux.send = (_pane: string, msg: string) => {
+      const match = msg.match(/\{tmux-team-end:([a-f0-9]+)\}/);
+      if (match) {
+        nonces.push(match[1]);
+      }
+    };
+
+    // Return markers immediately
+    tmux.capture = (pane: string) => {
+      const idx = pane === '10.1' ? 0 : 1;
+      if (nonces[idx]) {
+        return `Response\n{tmux-team-end:${nonces[idx]}}`;
+      }
+      return '';
+    };
+
+    const paths = createTestPaths(testDir);
+    const ctx = createContext({
+      tmux,
+      paths,
+      flags: { wait: true, timeout: 5 },
+      config: {
+        defaults: { timeout: 5, pollInterval: 0.02, captureLines: 100 },
+        paneRegistry: {
+          codex: { pane: '10.1' },
+          gemini: { pane: '10.2' },
+        },
+      },
+    });
+
+    await cmdTalk(ctx, 'all', 'Hello');
+
+    // Each agent should have a unique nonce
+    expect(nonces.length).toBe(2);
+    expect(nonces[0]).not.toBe(nonces[1]);
   });
 });