tmux-team 2.1.0 → 3.0.0-alpha.1

package/src/commands/talk.ts

@@ -7,8 +7,13 @@ 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 { resolveActor } from '../pm/permissions.js';
+import {
+  cleanupState,
+  clearActiveRequest,
+  setActiveRequest,
+  incrementPreambleCounter,
+} from '../state.js';
+import { resolveActor } from '../identity.js';
 
 function sleepMs(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -36,8 +41,8 @@ interface AgentWaitState {
   pane: string;
   requestId: string;
   nonce: string;
-  marker: string;
-  baseline: string;
+  startMarker: string;
+  endMarker: string;
   status: 'pending' | 'completed' | 'timeout' | 'error';
   response?: string;
   error?: string;
@@ -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}`;
 }
 
@@ -188,11 +212,12 @@ export async function cmdTalk(ctx: Context, target: string, message: string): Pr
 
   const requestId = makeRequestId();
   const nonce = makeNonce();
-  const marker = `{tmux-team-end:${nonce}}`;
+  const startMarker = `{tmux-team-start:${nonce}}`;
+  const endMarker = `{tmux-team-end:${nonce}}`;
 
-  // Build message with preamble, then append nonce instruction
+  // Build message with preamble, then wrap with start/end markers
   const messageWithPreamble = buildMessage(message, target, ctx);
-  const fullMessage = `${messageWithPreamble}\n\n[IMPORTANT: When your response is complete, print exactly: ${marker}]`;
+  const fullMessage = `${startMarker}\n${messageWithPreamble}\n\n[IMPORTANT: When your response is complete, print exactly: ${endMarker}]`;
 
   // Best-effort cleanup and soft-lock warning
   const state = cleanupState(ctx.paths, 60 * 60); // 1 hour TTL
@@ -203,14 +228,6 @@ export async function cmdTalk(ctx: Context, target: string, message: string): Pr
     );
   }
 
-  let baseline = '';
-  try {
-    baseline = tmux.capture(pane, captureLines);
-  } catch {
-    ui.error(`Failed to capture pane ${pane}. Is tmux running?`);
-    exit(ExitCodes.ERROR);
-  }
-
   setActiveRequest(ctx.paths, target, { id: requestId, nonce, pane, startedAtMs: Date.now() });
 
   const startedAt = Date.now();
@@ -243,7 +260,8 @@ export async function cmdTalk(ctx: Context, target: string, message: string): Pr
             error: `Timed out waiting for ${target} after ${Math.floor(timeoutSeconds)}s`,
             requestId,
             nonce,
-            marker,
+            startMarker,
+            endMarker,
           });
           exit(ExitCodes.TIMEOUT);
         }
@@ -279,16 +297,32 @@ export async function cmdTalk(ctx: Context, target: string, message: string): Pr
         exit(ExitCodes.ERROR);
       }
 
-      const markerIndex = output.indexOf(marker);
-      if (markerIndex === -1) continue;
-
-      let startIndex = 0;
-      const baselineIndex = baseline ? output.lastIndexOf(baseline) : -1;
-      if (baselineIndex !== -1) {
-        startIndex = baselineIndex + baseline.length;
+      // Find end marker (use lastIndexOf because the marker appears in the instruction AND agent's response)
+      const endMarkerIndex = output.lastIndexOf(endMarker);
+      if (endMarkerIndex === -1) continue;
+
+      // Find the end of our instruction by looking for `}]` pattern (the instruction ends with `{end}]`)
+      // This is more reliable than looking for newline after start marker because
+      // the message may be word-wrapped across multiple visual lines
+      let responseStart = 0;
+      const instructionEndPattern = '}]';
+      const instructionEndIndex = output.lastIndexOf(instructionEndPattern, endMarkerIndex);
+      if (instructionEndIndex !== -1) {
+        // Find the first newline after the instruction's closing `}]`
+        responseStart = output.indexOf('\n', instructionEndIndex + 2);
+        if (responseStart !== -1) responseStart += 1;
+        else responseStart = instructionEndIndex + 2;
+      } else {
+        // Fallback: if no `}]` found, try to find newline after start marker
+        const startMarkerIndex = output.lastIndexOf(startMarker);
+        if (startMarkerIndex !== -1) {
+          responseStart = output.indexOf('\n', startMarkerIndex);
+          if (responseStart !== -1) responseStart += 1;
+          else responseStart = startMarkerIndex + startMarker.length;
+        }
       }
 
-      const response = output.slice(startIndex, markerIndex).trim();
+      const response = output.slice(responseStart, endMarkerIndex).trim();
 
       if (!flags.json && isTTY) {
         process.stdout.write('\r' + ' '.repeat(80) + '\r');
@@ -299,7 +333,7 @@ export async function cmdTalk(ctx: Context, target: string, message: string): Pr
 
       clearActiveRequest(ctx.paths, target, requestId);
 
-      const result: WaitResult = { requestId, nonce, marker, response };
+      const result: WaitResult = { requestId, nonce, startMarker, endMarker, response };
       if (flags.json) {
         ui.json({ target, pane, status: 'completed', ...result });
       } else {
@@ -343,35 +377,16 @@ async function cmdTalkAllWait(
     );
   }
 
-  // Phase 1: Send messages to all agents and capture baselines
+  // Phase 1: Send messages to all agents with start/end markers
   for (const [name, data] of targetAgents) {
     const requestId = makeRequestId();
     const nonce = makeNonce(); // Unique nonce per agent (#19)
-    const marker = `{tmux-team-end:${nonce}}`;
-
-    let baseline = '';
-    try {
-      baseline = tmux.capture(data.pane, captureLines);
-    } catch {
-      agentStates.push({
-        agent: name,
-        pane: data.pane,
-        requestId,
-        nonce,
-        marker,
-        baseline: '',
-        status: 'error',
-        error: `Failed to capture pane ${data.pane}`,
-      });
-      if (!flags.json) {
-        ui.warn(`Failed to capture ${name} (${data.pane})`);
-      }
-      continue;
-    }
+    const startMarker = `{tmux-team-start:${nonce}}`;
+    const endMarker = `{tmux-team-end:${nonce}}`;
 
-    // Build and send message
+    // Build and send message with start/end markers
     const messageWithPreamble = buildMessage(message, name, ctx);
-    const fullMessage = `${messageWithPreamble}\n\n[IMPORTANT: When your response is complete, print exactly: ${marker}]`;
+    const fullMessage = `${startMarker}\n${messageWithPreamble}\n\n[IMPORTANT: When your response is complete, print exactly: ${endMarker}]`;
     const msg = name === 'gemini' ? fullMessage.replace(/!/g, '') : fullMessage;
 
     try {
@@ -387,8 +402,8 @@ async function cmdTalkAllWait(
         pane: data.pane,
         requestId,
         nonce,
-        marker,
-        baseline,
+        startMarker,
+        endMarker,
         status: 'pending',
       });
       if (!flags.json) {
@@ -400,8 +415,8 @@ async function cmdTalkAllWait(
         pane: data.pane,
         requestId,
         nonce,
-        marker,
-        baseline,
+        startMarker,
+        endMarker,
         status: 'error',
         error: `Failed to send to pane ${data.pane}`,
       });
@@ -496,17 +511,32 @@ async function cmdTalkAllWait(
           continue;
         }
 
-        const markerIndex = output.indexOf(state.marker);
-        if (markerIndex === -1) continue;
-
-        // Found marker - extract response
-        let startIndex = 0;
-        const baselineIndex = state.baseline ? output.lastIndexOf(state.baseline) : -1;
-        if (baselineIndex !== -1) {
-          startIndex = baselineIndex + state.baseline.length;
+        // Find end marker (use lastIndexOf because the marker appears in the instruction AND agent's response)
+        const endMarkerIndex = output.lastIndexOf(state.endMarker);
+        if (endMarkerIndex === -1) continue;
+
+        // Find the end of our instruction by looking for `}]` pattern (the instruction ends with `{end}]`)
+        // This is more reliable than looking for newline after start marker because
+        // the message may be word-wrapped across multiple visual lines
+        let responseStart = 0;
+        const instructionEndPattern = '}]';
+        const instructionEndIndex = output.lastIndexOf(instructionEndPattern, endMarkerIndex);
+        if (instructionEndIndex !== -1) {
+          // Find the first newline after the instruction's closing `}]`
+          responseStart = output.indexOf('\n', instructionEndIndex + 2);
+          if (responseStart !== -1) responseStart += 1;
+          else responseStart = instructionEndIndex + 2;
+        } else {
+          // Fallback: if no `}]` found, try to find newline after start marker
+          const startMarkerIndex = output.lastIndexOf(state.startMarker);
+          if (startMarkerIndex !== -1) {
+            responseStart = output.indexOf('\n', startMarkerIndex);
+            if (responseStart !== -1) responseStart += 1;
+            else responseStart = startMarkerIndex + state.startMarker.length;
+          }
         }
 
-        state.response = output.slice(startIndex, markerIndex).trim();
+        state.response = output.slice(responseStart, endMarkerIndex).trim();
         state.status = 'completed';
         state.elapsedMs = Date.now() - startedAt;
         clearActiveRequest(paths, state.agent, state.requestId);
@@ -568,8 +598,8 @@ function outputBroadcastResults(
         pane: s.pane,
         requestId: s.requestId,
         nonce: s.nonce,
-        marker: s.marker,
-        baseline: '', // Don't include baseline in output
+        startMarker: s.startMarker,
+        endMarker: s.endMarker,
         status: s.status,
         response: s.response,
         error: s.error,

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

@@ -165,12 +165,11 @@ describe('loadConfig', () => {
     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 +181,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 +200,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 +217,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 +240,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.');
+  });
 });

package/src/config.ts

@@ -19,15 +19,15 @@ const LOCAL_CONFIG_FILENAME = 'tmux-team.json';
 const STATE_FILENAME = 'state.json';
 
 // Default configuration values
-const DEFAULT_CONFIG: Omit<GlobalConfig, 'agents'> & { agents: Record<string, never> } = {
+const DEFAULT_CONFIG: GlobalConfig = {
   mode: 'polling',
   preambleMode: 'always',
   defaults: {
     timeout: 180,
     pollInterval: 1,
     captureLines: 100,
+    preambleEvery: 3, // inject preamble every 3 messages
   },
-  agents: {},
 };
 
 /**
@@ -130,7 +130,7 @@ export function loadConfig(paths: Paths): ResolvedConfig {
     paneRegistry: {},
   };
 
-  // Merge global config
+  // Merge global config (mode, preambleMode, defaults only)
   const globalConfig = loadJsonFile<Partial<GlobalConfig>>(paths.globalConfig);
   if (globalConfig) {
     if (globalConfig.mode) config.mode = globalConfig.mode;
@@ -138,12 +138,10 @@ export function loadConfig(paths: Paths): ResolvedConfig {
     if (globalConfig.defaults) {
       config.defaults = { ...config.defaults, ...globalConfig.defaults };
     }
-    if (globalConfig.agents) {
-      config.agents = { ...config.agents, ...globalConfig.agents };
-    }
   }
 
-  // Load local config (pane registry + optional settings)
+  // Load local config (pane registry + optional settings + agent config)
+  // Local config is the SSOT for agent configuration (preamble, deny)
   const localConfigFile = loadJsonFile<LocalConfigFile>(paths.localConfig);
   if (localConfigFile) {
     // Extract local settings if present
@@ -153,22 +151,36 @@ export function loadConfig(paths: Paths): ResolvedConfig {
     if (localSettings) {
       if (localSettings.mode) config.mode = localSettings.mode;
       if (localSettings.preambleMode) config.preambleMode = localSettings.preambleMode;
+      if (localSettings.preambleEvery !== undefined) {
+        config.defaults.preambleEvery = localSettings.preambleEvery;
+      }
     }
 
-    // Set pane registry (filter out $config)
-    config.paneRegistry = paneEntries as LocalConfig;
+    // Build pane registry and agents config from local entries
+    for (const [agentName, entry] of Object.entries(paneEntries)) {
+      const paneEntry = entry as LocalConfig[string];
+
+      // Add to pane registry if has valid pane field
+      if (paneEntry.pane) {
+        config.paneRegistry[agentName] = paneEntry;
+      }
+
+      // Build agents config from preamble/deny fields
+      const hasPreamble = Object.prototype.hasOwnProperty.call(paneEntry, 'preamble');
+      const hasDeny = Object.prototype.hasOwnProperty.call(paneEntry, 'deny');
+
+      if (hasPreamble || hasDeny) {
+        config.agents[agentName] = {
+          ...(hasPreamble && { preamble: paneEntry.preamble }),
+          ...(hasDeny && { deny: paneEntry.deny }),
+        };
+      }
+    }
   }
 
   return config;
 }
 
-export function saveLocalConfig(
-  paths: Paths,
-  paneRegistry: Record<string, { pane: string; remark?: string }>
-): void {
-  fs.writeFileSync(paths.localConfig, JSON.stringify(paneRegistry, null, 2) + '\n');
-}
-
 export function ensureGlobalDir(paths: Paths): void {
   if (!fs.existsSync(paths.globalDir)) {
     fs.mkdirSync(paths.globalDir, { recursive: true });