tmux-team 2.1.0 → 2.2.0

package/src/commands/talk.test.ts

@@ -63,6 +63,8 @@ function createDefaultConfig(): ResolvedConfig {
       timeout: 60,
       pollInterval: 0.1, // Fast polling for tests
       captureLines: 100,
+      preambleEvery: 3,
+      hideOrphanTasks: false,
     },
     agents: {},
     paneRegistry: {
@@ -85,7 +87,15 @@ function createContext(
   const exitError = new Error('exit called');
   (exitError as Error & { exitCode?: number }).exitCode = 0;
 
-  const config = { ...createDefaultConfig(), ...overrides.config };
+  const baseConfig = createDefaultConfig();
+  const config = {
+    ...baseConfig,
+    ...overrides.config,
+    defaults: {
+      ...baseConfig.defaults,
+      ...overrides.config?.defaults,
+    },
+  };
   const flags: Flags = { json: false, verbose: false, ...overrides.flags };
 
   return {
@@ -199,6 +209,91 @@ describe('buildMessage (via cmdTalk)', () => {
 
     expect(tmux.sends[0].message).toBe('[SYSTEM: Test preamble]\n\nTest message');
   });
+
+  it('injects preamble based on preambleEvery config (every N messages)', async () => {
+    const paths = createTestPaths(testDir);
+    fs.mkdirSync(paths.globalDir, { recursive: true });
+
+    const config = {
+      preambleMode: 'always' as const,
+      agents: { claude: { preamble: 'Be brief' } },
+      defaults: {
+        timeout: 60,
+        pollInterval: 0.1,
+        captureLines: 100,
+        preambleEvery: 3,
+        hideOrphanTasks: false,
+      },
+    };
+
+    // Message 1: should include preamble (first message)
+    const tmux1 = createMockTmux();
+    await cmdTalk(createContext({ tmux: tmux1, paths, config }), 'claude', 'Hello 1');
+    expect(tmux1.sends[0].message).toContain('[SYSTEM: Be brief]');
+
+    // Message 2: should NOT include preamble
+    const tmux2 = createMockTmux();
+    await cmdTalk(createContext({ tmux: tmux2, paths, config }), 'claude', 'Hello 2');
+    expect(tmux2.sends[0].message).toBe('Hello 2');
+
+    // Message 3: should NOT include preamble
+    const tmux3 = createMockTmux();
+    await cmdTalk(createContext({ tmux: tmux3, paths, config }), 'claude', 'Hello 3');
+    expect(tmux3.sends[0].message).toBe('Hello 3');
+
+    // Message 4: should include preamble (4 - 1 = 3, divisible by 3)
+    const tmux4 = createMockTmux();
+    await cmdTalk(createContext({ tmux: tmux4, paths, config }), 'claude', 'Hello 4');
+    expect(tmux4.sends[0].message).toContain('[SYSTEM: Be brief]');
+  });
+
+  it('injects preamble every time when preambleEvery is 1', async () => {
+    const paths = createTestPaths(testDir);
+    fs.mkdirSync(paths.globalDir, { recursive: true });
+
+    const config = {
+      preambleMode: 'always' as const,
+      agents: { claude: { preamble: 'Be brief' } },
+      defaults: {
+        timeout: 60,
+        pollInterval: 0.1,
+        captureLines: 100,
+        preambleEvery: 1,
+        hideOrphanTasks: false,
+      },
+    };
+
+    // All messages should include preamble
+    for (let i = 0; i < 3; i++) {
+      const tmux = createMockTmux();
+      await cmdTalk(createContext({ tmux, paths, config }), 'claude', `Hello ${i}`);
+      expect(tmux.sends[0].message).toContain('[SYSTEM: Be brief]');
+    }
+  });
+
+  it('never injects preamble when preambleEvery is 0', async () => {
+    const paths = createTestPaths(testDir);
+    fs.mkdirSync(paths.globalDir, { recursive: true });
+
+    const config = {
+      preambleMode: 'always' as const,
+      agents: { claude: { preamble: 'Be brief' } },
+      defaults: {
+        timeout: 60,
+        pollInterval: 0.1,
+        captureLines: 100,
+        preambleEvery: 0,
+        hideOrphanTasks: false,
+      },
+    };
+
+    // No messages should include preamble
+    for (let i = 0; i < 3; i++) {
+      const tmux = createMockTmux();
+      await cmdTalk(createContext({ tmux, paths, config }), 'claude', `Hello ${i}`);
+      expect(tmux.sends[0].message).toBe(`Hello ${i}`);
+    }
+  });
 });
 
 describe('cmdTalk - basic send', () => {
@@ -369,7 +464,15 @@ describe('cmdTalk - --wait mode', () => {
       tmux,
       paths: createTestPaths(testDir),
       flags: { wait: true, timeout: 5 },
-      config: { defaults: { timeout: 5, pollInterval: 0.01, captureLines: 100 } },
+      config: {
+        defaults: {
+          timeout: 5,
+          pollInterval: 0.01,
+          captureLines: 100,
+          preambleEvery: 3,
+          hideOrphanTasks: false,
+        },
+      },
     });
 
     await cmdTalk(ctx, 'claude', 'Hello');
@@ -404,7 +507,15 @@ describe('cmdTalk - --wait mode', () => {
       ui,
       paths: createTestPaths(testDir),
       flags: { wait: true, json: true, timeout: 5 },
-      config: { defaults: { timeout: 5, pollInterval: 0.01, captureLines: 100 } },
+      config: {
+        defaults: {
+          timeout: 5,
+          pollInterval: 0.01,
+          captureLines: 100,
+          preambleEvery: 3,
+          hideOrphanTasks: false,
+        },
+      },
     });
 
     await cmdTalk(ctx, 'claude', 'Hello');
@@ -412,7 +523,7 @@ describe('cmdTalk - --wait mode', () => {
     expect(ui.jsonOutput).toHaveLength(1);
     const output = ui.jsonOutput[0] as Record<string, unknown>;
     expect(output.status).toBe('completed');
-    expect(output.response).toBeDefined();
+    expect(output.response).toEqual(expect.stringContaining('Agent response here'));
   });
 
   it('returns timeout error with correct exit code', async () => {
@@ -427,7 +538,15 @@ describe('cmdTalk - --wait mode', () => {
       ui,
       paths: createTestPaths(testDir),
       flags: { wait: true, json: true, timeout: 0.1 },
-      config: { defaults: { timeout: 0.1, pollInterval: 0.02, captureLines: 100 } },
+      config: {
+        defaults: {
+          timeout: 0.1,
+          pollInterval: 0.02,
+          captureLines: 100,
+          preambleEvery: 3,
+          hideOrphanTasks: false,
+        },
+      },
     });
 
     try {
@@ -468,7 +587,15 @@ describe('cmdTalk - --wait mode', () => {
       ui,
       paths: createTestPaths(testDir),
       flags: { wait: true, json: true, timeout: 5 },
-      config: { defaults: { timeout: 5, pollInterval: 0.01, captureLines: 100 } },
+      config: {
+        defaults: {
+          timeout: 5,
+          pollInterval: 0.01,
+          captureLines: 100,
+          preambleEvery: 3,
+          hideOrphanTasks: false,
+        },
+      },
     });
 
     await cmdTalk(ctx, 'claude', 'Hello');
@@ -496,7 +623,15 @@ describe('cmdTalk - --wait mode', () => {
       tmux,
       paths,
       flags: { wait: true, timeout: 5 },
-      config: { defaults: { timeout: 5, pollInterval: 0.01, captureLines: 100 } },
+      config: {
+        defaults: {
+          timeout: 5,
+          pollInterval: 0.01,
+          captureLines: 100,
+          preambleEvery: 3,
+          hideOrphanTasks: false,
+        },
+      },
     });
 
     await cmdTalk(ctx, 'claude', 'Hello');
@@ -517,7 +652,15 @@ describe('cmdTalk - --wait mode', () => {
       tmux,
       paths,
       flags: { wait: true, timeout: 0.05 },
-      config: { defaults: { timeout: 0.05, pollInterval: 0.01, captureLines: 100 } },
+      config: {
+        defaults: {
+          timeout: 0.05,
+          pollInterval: 0.01,
+          captureLines: 100,
+          preambleEvery: 3,
+          hideOrphanTasks: false,
+        },
+      },
     });
 
     try {
@@ -565,7 +708,13 @@ describe('cmdTalk - --wait mode', () => {
       paths,
       flags: { wait: true, timeout: 5 },
       config: {
-        defaults: { timeout: 5, pollInterval: 0.05, captureLines: 100 },
+        defaults: {
+          timeout: 5,
+          pollInterval: 0.05,
+          captureLines: 100,
+          preambleEvery: 3,
+          hideOrphanTasks: false,
+        },
         paneRegistry: {
           codex: { pane: '10.1' },
           gemini: { pane: '10.2' },
@@ -606,7 +755,13 @@ describe('cmdTalk - --wait mode', () => {
       paths,
       flags: { wait: true, timeout: 0.1, json: true },
       config: {
-        defaults: { timeout: 0.1, pollInterval: 0.02, captureLines: 100 },
+        defaults: {
+          timeout: 0.1,
+          pollInterval: 0.02,
+          captureLines: 100,
+          preambleEvery: 3,
+          hideOrphanTasks: false,
+        },
         paneRegistry: {
           codex: { pane: '10.1' },
           gemini: { pane: '10.2' },
@@ -658,7 +813,13 @@ describe('cmdTalk - --wait mode', () => {
       paths,
       flags: { wait: true, timeout: 5 },
       config: {
-        defaults: { timeout: 5, pollInterval: 0.02, captureLines: 100 },
+        defaults: {
+          timeout: 5,
+          pollInterval: 0.02,
+          captureLines: 100,
+          preambleEvery: 3,
+          hideOrphanTasks: false,
+        },
         paneRegistry: {
           codex: { pane: '10.1' },
           gemini: { pane: '10.2' },
@@ -718,7 +879,15 @@ describe('cmdTalk - nonce collision handling', () => {
       ui,
       paths: createTestPaths(testDir),
       flags: { wait: true, json: true, timeout: 5 },
-      config: { defaults: { timeout: 5, pollInterval: 0.01, captureLines: 100 } },
+      config: {
+        defaults: {
+          timeout: 5,
+          pollInterval: 0.01,
+          captureLines: 100,
+          preambleEvery: 3,
+          hideOrphanTasks: false,
+        },
+      },
     });
 
     await cmdTalk(ctx, 'claude', 'Hello');
@@ -761,7 +930,15 @@ describe('cmdTalk - JSON output contract', () => {
       ui,
       paths: createTestPaths(testDir),
       flags: { wait: true, json: true, timeout: 5 },
-      config: { defaults: { timeout: 5, pollInterval: 0.01, captureLines: 100 } },
+      config: {
+        defaults: {
+          timeout: 5,
+          pollInterval: 0.01,
+          captureLines: 100,
+          preambleEvery: 3,
+          hideOrphanTasks: false,
+        },
+      },
     });
 
     await cmdTalk(ctx, 'claude', 'Hello');
@@ -786,7 +963,15 @@ describe('cmdTalk - JSON output contract', () => {
       ui,
       paths: createTestPaths(testDir),
       flags: { wait: true, json: true, timeout: 0.05 },
-      config: { defaults: { timeout: 0.05, pollInterval: 0.01, captureLines: 100 } },
+      config: {
+        defaults: {
+          timeout: 0.05,
+          pollInterval: 0.01,
+          captureLines: 100,
+          preambleEvery: 3,
+          hideOrphanTasks: false,
+        },
+      },
     });
 
     try {

package/src/commands/talk.ts

@@ -7,7 +7,12 @@ import type { WaitResult } from '../types.js';
 import { ExitCodes } from '../exits.js';
 import { colors } from '../ui.js';
 import crypto from 'crypto';
-import { cleanupState, clearActiveRequest, setActiveRequest } from '../state.js';
+import {
+  cleanupState,
+  clearActiveRequest,
+  setActiveRequest,
+  incrementPreambleCounter,
+} from '../state.js';
 import { resolveActor } from '../pm/permissions.js';
 
 function sleepMs(ms: number): Promise<void> {
@@ -62,9 +67,12 @@ interface BroadcastWaitResult {
 /**
  * Build the final message with optional preamble.
  * Format: [SYSTEM: <preamble>]\n\n<message>
+ *
+ * Preamble injection frequency is controlled by preambleEvery config.
+ * Default: inject every 3 messages per agent to save tokens.
  */
 function buildMessage(message: string, agentName: string, ctx: Context): string {
-  const { config, flags } = ctx;
+  const { config, flags, paths } = ctx;
 
   // Skip preamble if disabled or --no-preamble flag
   if (config.preambleMode === 'disabled' || flags.noPreamble) {
@@ -79,6 +87,22 @@ function buildMessage(message: string, agentName: string, ctx: Context): string
     return message;
   }
 
+  // Check preamble frequency (preambleEvery: 0 means never, 1 means always)
+  const preambleEvery = config.defaults.preambleEvery;
+  if (preambleEvery <= 0) {
+    // preambleEvery = 0 means never inject (equivalent to disabled for this agent)
+    return message;
+  }
+
+  // Increment counter and check if we should inject preamble
+  // Inject on message 1, 1+N, 1+2N, ... where N = preambleEvery
+  const count = incrementPreambleCounter(paths, agentName);
+  const shouldInject = (count - 1) % preambleEvery === 0;
+
+  if (!shouldInject) {
+    return message;
+  }
+
   return `[SYSTEM: ${preamble}]\n\n${message}`;
 }
 

package/src/commands/update.ts

@@ -2,9 +2,9 @@
 // update command - modify agent config
 // ─────────────────────────────────────────────────────────────
 
-import type { Context } from '../types.js';
+import type { Context, PaneEntry } from '../types.js';
 import { ExitCodes } from '../exits.js';
-import { saveLocalConfig } from '../config.js';
+import { loadLocalConfigFile, saveLocalConfigFile } from '../config.js';
 
 export function cmdUpdate(
   ctx: Context,
@@ -23,19 +23,30 @@ export function cmdUpdate(
     exit(ExitCodes.ERROR);
   }
 
+  // Load existing config to preserve all fields (preamble, deny, etc.)
+  const localConfig = loadLocalConfigFile(paths);
+
+  // Handle edge case where local config was modified externally
+  let entry = localConfig[name] as PaneEntry | undefined;
+  if (!entry) {
+    // Fall back to in-memory paneRegistry if entry is missing
+    entry = { ...config.paneRegistry[name] };
+    localConfig[name] = entry;
+  }
+
   const updates: string[] = [];
 
   if (options.pane) {
-    config.paneRegistry[name].pane = options.pane;
+    entry.pane = options.pane;
     updates.push(`pane → ${options.pane}`);
   }
 
   if (options.remark) {
-    config.paneRegistry[name].remark = options.remark;
+    entry.remark = options.remark;
     updates.push(`remark updated`);
   }
 
-  saveLocalConfig(paths, config.paneRegistry);
+  saveLocalConfigFile(paths, localConfig);
 
   if (flags.json) {
     ui.json({ updated: name, ...options });

package/src/config.test.ts

@@ -161,16 +161,16 @@ describe('loadConfig', () => {
     expect(config.defaults.timeout).toBe(180);
     expect(config.defaults.pollInterval).toBe(1);
     expect(config.defaults.captureLines).toBe(100);
+    expect(config.defaults.hideOrphanTasks).toBe(false);
     expect(config.agents).toEqual({});
     expect(config.paneRegistry).toEqual({});
   });
 
-  it('loads and merges global config', () => {
+  it('loads and merges global config (mode, preambleMode, defaults only)', () => {
     const globalConfig = {
       mode: 'wait',
       preambleMode: 'disabled',
       defaults: { timeout: 120 },
-      agents: { claude: { preamble: 'Be helpful' } },
     };
 
     vi.mocked(fs.existsSync).mockImplementation((p) => p === mockPaths.globalConfig);
@@ -182,7 +182,7 @@ describe('loadConfig', () => {
     expect(config.preambleMode).toBe('disabled');
     expect(config.defaults.timeout).toBe(120);
     expect(config.defaults.pollInterval).toBe(1); // Default preserved
-    expect(config.agents.claude?.preamble).toBe('Be helpful');
+    expect(config.agents).toEqual({}); // No agents from global config
   });
 
   it('loads local pane registry from tmux-team.json', () => {
@@ -201,12 +201,12 @@ describe('loadConfig', () => {
     expect(config.paneRegistry.codex?.pane).toBe('1.1');
   });
 
-  it('merges both global and local config', () => {
+  it('merges both global and local config (agents from local only)', () => {
     const globalConfig = {
-      agents: { claude: { preamble: 'Be brief' } },
+      mode: 'wait',
     };
     const localConfig = {
-      claude: { pane: '1.0' },
+      claude: { pane: '1.0', preamble: 'Be brief' },
     };
 
     vi.mocked(fs.existsSync).mockReturnValue(true);
@@ -218,8 +218,9 @@ describe('loadConfig', () => {
 
     const config = loadConfig(mockPaths);
 
-    expect(config.agents.claude?.preamble).toBe('Be brief');
-    expect(config.paneRegistry.claude?.pane).toBe('1.0');
+    expect(config.mode).toBe('wait'); // from global
+    expect(config.agents.claude?.preamble).toBe('Be brief'); // from local
+    expect(config.paneRegistry.claude?.pane).toBe('1.0'); // from local
   });
 
   it('throws ConfigParseError on invalid JSON in config file', () => {
@@ -240,7 +241,180 @@ describe('loadConfig', () => {
       expect(err).toBeInstanceOf(ConfigParseError);
       const parseError = err as ConfigParseError;
       expect(parseError.filePath).toBe(mockPaths.globalConfig);
-      expect(parseError.cause).toBeDefined();
+      expect(parseError.cause).toBeInstanceOf(SyntaxError);
     }
   });
+
+  it('loads local preamble into agents config', () => {
+    const localConfig = {
+      claude: { pane: '1.0', preamble: 'Be helpful and concise' },
+    };
+
+    vi.mocked(fs.existsSync).mockImplementation((p) => p === mockPaths.localConfig);
+    vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(localConfig));
+
+    const config = loadConfig(mockPaths);
+
+    expect(config.agents.claude?.preamble).toBe('Be helpful and concise');
+    expect(config.paneRegistry.claude?.pane).toBe('1.0');
+  });
+
+  it('loads local deny into agents config', () => {
+    const localConfig = {
+      claude: { pane: '1.0', deny: ['pm:task:update(status)'] },
+    };
+
+    vi.mocked(fs.existsSync).mockImplementation((p) => p === mockPaths.localConfig);
+    vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(localConfig));
+
+    const config = loadConfig(mockPaths);
+
+    expect(config.agents.claude?.deny).toEqual(['pm:task:update(status)']);
+  });
+
+  it('loads preamble from local config only', () => {
+    const localConfig = {
+      claude: { pane: '1.0', preamble: 'Local preamble' },
+    };
+
+    vi.mocked(fs.existsSync).mockImplementation((p) => p === mockPaths.localConfig);
+    vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(localConfig));
+
+    const config = loadConfig(mockPaths);
+
+    expect(config.agents.claude?.preamble).toBe('Local preamble');
+  });
+
+  it('loads deny from local config only', () => {
+    const localConfig = {
+      claude: { pane: '1.0', deny: ['pm:task:create'] },
+    };
+
+    vi.mocked(fs.existsSync).mockImplementation((p) => p === mockPaths.localConfig);
+    vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(localConfig));
+
+    const config = loadConfig(mockPaths);
+
+    expect(config.agents.claude?.deny).toEqual(['pm:task:create']);
+  });
+
+  it('handles local config with both preamble and deny', () => {
+    const localConfig = {
+      claude: { pane: '1.0', preamble: 'Be helpful', deny: ['pm:task:update(status)'] },
+    };
+
+    vi.mocked(fs.existsSync).mockImplementation((p) => p === mockPaths.localConfig);
+    vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(localConfig));
+
+    const config = loadConfig(mockPaths);
+
+    expect(config.agents.claude?.preamble).toBe('Be helpful');
+    expect(config.agents.claude?.deny).toEqual(['pm:task:update(status)']);
+  });
+
+  it('handles empty preamble in local config', () => {
+    const localConfig = {
+      claude: { pane: '1.0', preamble: '' },
+    };
+
+    vi.mocked(fs.existsSync).mockImplementation((p) => p === mockPaths.localConfig);
+    vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(localConfig));
+
+    const config = loadConfig(mockPaths);
+
+    expect(config.agents.claude?.preamble).toBe('');
+  });
+
+  it('handles empty deny array in local config', () => {
+    const localConfig = {
+      claude: { pane: '1.0', deny: [] },
+    };
+
+    vi.mocked(fs.existsSync).mockImplementation((p) => p === mockPaths.localConfig);
+    vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(localConfig));
+
+    const config = loadConfig(mockPaths);
+
+    expect(config.agents.claude?.deny).toEqual([]);
+  });
+
+  it('skips entries without pane field in paneRegistry', () => {
+    const localConfig = {
+      claude: { pane: '1.0' },
+      codex: { preamble: 'Preamble only, no pane' },
+    };
+
+    vi.mocked(fs.existsSync).mockImplementation((p) => p === mockPaths.localConfig);
+    vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(localConfig));
+
+    const config = loadConfig(mockPaths);
+
+    expect(config.paneRegistry.claude?.pane).toBe('1.0');
+    expect(config.paneRegistry.codex).toBeUndefined();
+    // But preamble should still be merged
+    expect(config.agents.codex?.preamble).toBe('Preamble only, no pane');
+  });
+
+  it('ignores agents field in global config (local config is SSOT)', () => {
+    // Even if global config has agents, they should be ignored
+    const globalConfig = {
+      mode: 'wait',
+      agents: {
+        // This should be ignored
+        claude: { preamble: 'Global preamble', deny: ['pm:task:delete'] },
+      },
+    };
+    const localConfig = {
+      claude: { pane: '1.0', preamble: 'Local preamble' },
+    };
+
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(fs.readFileSync).mockImplementation((p) => {
+      if (p === mockPaths.globalConfig) return JSON.stringify(globalConfig);
+      if (p === mockPaths.localConfig) return JSON.stringify(localConfig);
+      return '';
+    });
+
+    const config = loadConfig(mockPaths);
+
+    // Mode from global should work
+    expect(config.mode).toBe('wait');
+    // But agents come only from local config
+    expect(config.agents.claude?.preamble).toBe('Local preamble');
+    expect(config.agents.claude?.deny).toBeUndefined(); // Not from global
+  });
+
+  it('local config defines project-specific agent roles without global pollution', () => {
+    // No global config
+    const localConfig = {
+      claude: {
+        pane: '1.0',
+        remark: 'Main implementer',
+        preamble: 'You implement features. Ask Codex for review.',
+        deny: ['pm:task:update(status)', 'pm:milestone:update(status)'],
+      },
+      codex: {
+        pane: '1.1',
+        remark: 'Code quality guard',
+        preamble: 'You review code. You can update task status.',
+        // No deny - codex can do everything
+      },
+    };
+
+    vi.mocked(fs.existsSync).mockImplementation((p) => p === mockPaths.localConfig);
+    vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(localConfig));
+
+    const config = loadConfig(mockPaths);
+
+    // Claude has deny rules
+    expect(config.agents.claude?.deny).toEqual([
+      'pm:task:update(status)',
+      'pm:milestone:update(status)',
+    ]);
+    expect(config.agents.claude?.preamble).toBe('You implement features. Ask Codex for review.');
+
+    // Codex has no deny rules (full access)
+    expect(config.agents.codex?.deny).toBeUndefined();
+    expect(config.agents.codex?.preamble).toBe('You review code. You can update task status.');
+  });
 });