tmux-team 2.1.0 → 2.2.0

package/src/pm/storage/fs.test.ts

@@ -40,7 +40,7 @@ describe('FSAdapter', () => {
       expect(team.name).toBe('My Project');
       expect(team.windowId).toBe('window-1');
       expect(team.id).toBe(path.basename(testDir));
-      expect(team.createdAt).toBeDefined();
+      expect(team.createdAt).toMatch(/^\d{4}-\d{2}-\d{2}T/);
 
       // Verify file contents
       const teamFile = path.join(testDir, 'team.json');
@@ -162,6 +162,80 @@ describe('FSAdapter', () => {
       const milestone = await adapter.getMilestone('1');
       expect(milestone).toBeNull();
     });
+
+    it('creates markdown doc file for milestone', async () => {
+      const milestone = await adapter.createMilestone({ name: 'Phase 1' });
+      const docPath = path.join(testDir, 'milestones', `${milestone.id}.md`);
+
+      expect(fs.existsSync(docPath)).toBe(true);
+      const content = fs.readFileSync(docPath, 'utf-8');
+      expect(content).toContain('# Phase 1');
+    });
+
+    it('creates milestone with description in doc file', async () => {
+      const milestone = await adapter.createMilestone({
+        name: 'Phase 1',
+        description: 'Initial development phase',
+      });
+      const docPath = path.join(testDir, 'milestones', `${milestone.id}.md`);
+
+      const content = fs.readFileSync(docPath, 'utf-8');
+      expect(content).toContain('# Phase 1');
+      expect(content).toContain('Initial development phase');
+    });
+
+    it('deletes both json and md files on milestone delete', async () => {
+      const milestone = await adapter.createMilestone({ name: 'Cleanup' });
+      const jsonPath = path.join(testDir, 'milestones', `${milestone.id}.json`);
+      const mdPath = path.join(testDir, 'milestones', `${milestone.id}.md`);
+
+      expect(fs.existsSync(jsonPath)).toBe(true);
+      expect(fs.existsSync(mdPath)).toBe(true);
+
+      await adapter.deleteMilestone(milestone.id);
+
+      expect(fs.existsSync(jsonPath)).toBe(false);
+      expect(fs.existsSync(mdPath)).toBe(false);
+    });
+  });
+
+  describe('Milestone Documentation', () => {
+    beforeEach(async () => {
+      await adapter.initTeam('Test Project');
+    });
+
+    it('gets milestone documentation', async () => {
+      await adapter.createMilestone({ name: 'Phase 1', description: 'Intro' });
+      const doc = await adapter.getMilestoneDoc('1');
+
+      expect(doc).toContain('# Phase 1');
+      expect(doc).toContain('Intro');
+    });
+
+    it('sets milestone documentation', async () => {
+      await adapter.createMilestone({ name: 'Test' });
+      await adapter.setMilestoneDoc('1', '# Updated\n\nNew content');
+
+      const doc = await adapter.getMilestoneDoc('1');
+      expect(doc).toBe('# Updated\n\nNew content');
+    });
+
+    it('creates milestones dir when setting doc if missing', async () => {
+      await adapter.createMilestone({ name: 'Test' });
+      // Remove the milestones dir
+      fs.rmSync(path.join(testDir, 'milestones'), { recursive: true, force: true });
+
+      await adapter.setMilestoneDoc('1', '# Updated\n\nBody');
+
+      expect(fs.existsSync(path.join(testDir, 'milestones', '1.md'))).toBe(true);
+      const doc = await adapter.getMilestoneDoc('1');
+      expect(doc).toBe('# Updated\n\nBody');
+    });
+
+    it('returns null for non-existent doc', async () => {
+      const doc = await adapter.getMilestoneDoc('999');
+      expect(doc).toBeNull();
+    });
   });
 
   describe('Task Operations', () => {
@@ -254,6 +328,60 @@ describe('FSAdapter', () => {
       expect(tasks[0].assignee).toBe('claude');
     });
 
+    it('excludes tasks in completed milestones by default', async () => {
+      // Create milestones
+      const m1 = await adapter.createMilestone({ name: 'Done Milestone' });
+      const m2 = await adapter.createMilestone({ name: 'Open Milestone' });
+      await adapter.updateMilestone(m1.id, { status: 'done' });
+
+      // Create tasks in both milestones
+      await adapter.createTask({ title: 'Task in done milestone', milestone: m1.id });
+      await adapter.createTask({ title: 'Task in open milestone', milestone: m2.id });
+      await adapter.createTask({ title: 'Task without milestone' });
+
+      // Default: excludeCompletedMilestones = true
+      const tasks = await adapter.listTasks();
+      expect(tasks).toHaveLength(2);
+      expect(tasks.map((t) => t.title)).not.toContain('Task in done milestone');
+    });
+
+    it('includes tasks in completed milestones when excludeCompletedMilestones is false', async () => {
+      // Create milestones
+      const m1 = await adapter.createMilestone({ name: 'Done Milestone' });
+      await adapter.updateMilestone(m1.id, { status: 'done' });
+
+      // Create task in done milestone
+      await adapter.createTask({ title: 'Task in done milestone', milestone: m1.id });
+      await adapter.createTask({ title: 'Task without milestone' });
+
+      // Include all tasks
+      const tasks = await adapter.listTasks({ excludeCompletedMilestones: false });
+      expect(tasks).toHaveLength(2);
+      expect(tasks.map((t) => t.title)).toContain('Task in done milestone');
+    });
+
+    it('hides tasks without milestones when hideOrphanTasks is true', async () => {
+      const milestone = await adapter.createMilestone({ name: 'Has Tasks' });
+
+      await adapter.createTask({ title: 'With milestone', milestone: milestone.id });
+      await adapter.createTask({ title: 'Without milestone' });
+
+      const tasks = await adapter.listTasks({ hideOrphanTasks: true });
+      expect(tasks).toHaveLength(1);
+      expect(tasks[0].title).toBe('With milestone');
+    });
+
+    it('includes tasks without milestones when hideOrphanTasks is false', async () => {
+      const milestone = await adapter.createMilestone({ name: 'Has Tasks' });
+
+      await adapter.createTask({ title: 'With milestone', milestone: milestone.id });
+      await adapter.createTask({ title: 'Without milestone' });
+
+      const tasks = await adapter.listTasks({ hideOrphanTasks: false });
+      expect(tasks).toHaveLength(2);
+      expect(tasks.map((t) => t.title)).toContain('Without milestone');
+    });
+
     it('returns task by ID', async () => {
       await adapter.createTask({ title: 'Test Task' });
       const task = await adapter.getTask('1');

package/src/pm/storage/fs.ts

@@ -106,10 +106,17 @@ export class FSAdapter implements StorageAdapter {
       id,
       name: input.name,
       status: 'pending',
+      description: input.description,
+      docPath: `milestones/${id}.md`,
       createdAt: this.now(),
       updatedAt: this.now(),
     };
     this.writeJson(path.join(this.milestonesDir, `${id}.json`), milestone);
+    // Create doc file with name and optional description
+    const docContent = input.description
+      ? `# ${input.name}\n\n${input.description}\n`
+      : `# ${input.name}\n\n`;
+    fs.writeFileSync(path.join(this.milestonesDir, `${id}.md`), docContent);
     return milestone;
   }
 
@@ -141,10 +148,10 @@ export class FSAdapter implements StorageAdapter {
   }
 
   async deleteMilestone(id: string): Promise<void> {
-    const filePath = path.join(this.milestonesDir, `${id}.json`);
-    if (fs.existsSync(filePath)) {
-      fs.unlinkSync(filePath);
-    }
+    const jsonPath = path.join(this.milestonesDir, `${id}.json`);
+    const mdPath = path.join(this.milestonesDir, `${id}.md`);
+    if (fs.existsSync(jsonPath)) fs.unlinkSync(jsonPath);
+    if (fs.existsSync(mdPath)) fs.unlinkSync(mdPath);
   }
 
   // Task operations
@@ -191,6 +198,21 @@ export class FSAdapter implements StorageAdapter {
       tasks = tasks.filter((t) => t.assignee === filter.assignee);
     }
 
+    // Exclude tasks in completed milestones (default: true)
+    const excludeCompleted = filter?.excludeCompletedMilestones ?? true;
+    if (excludeCompleted) {
+      const milestones = await this.listMilestones();
+      const completedMilestoneIds = new Set(
+        milestones.filter((m) => m.status === 'done').map((m) => m.id)
+      );
+      tasks = tasks.filter((t) => !t.milestone || !completedMilestoneIds.has(t.milestone));
+    }
+
+    // Hide tasks without milestone if configured
+    if (filter?.hideOrphanTasks) {
+      tasks = tasks.filter((t) => t.milestone);
+    }
+
     return tasks.sort((a, b) => parseInt(a.id) - parseInt(b.id));
   }
 
@@ -225,6 +247,18 @@ export class FSAdapter implements StorageAdapter {
     fs.writeFileSync(docPath, content);
   }
 
+  async getMilestoneDoc(id: string): Promise<string | null> {
+    const docPath = path.join(this.milestonesDir, `${id}.md`);
+    if (!fs.existsSync(docPath)) return null;
+    return fs.readFileSync(docPath, 'utf-8');
+  }
+
+  async setMilestoneDoc(id: string, content: string): Promise<void> {
+    this.ensureDir(this.milestonesDir);
+    const docPath = path.join(this.milestonesDir, `${id}.md`);
+    fs.writeFileSync(docPath, content);
+  }
+
   // Audit log
   async appendEvent(event: AuditEvent): Promise<void> {
     this.ensureDir(this.teamDir);

package/src/pm/storage/github.ts

@@ -53,6 +53,7 @@ interface GHIssue {
 interface GHMilestone {
   number: number;
   title: string;
+  description: string | null;
   state: 'open' | 'closed'; // REST API uses lowercase (unlike GraphQL)
   createdAt: string;
 }
@@ -61,13 +62,13 @@ interface GHMilestone {
 // Local cache for ID mapping (task ID -> issue number)
 // ─────────────────────────────────────────────────────────────
 
-const CACHE_VERSION = 2;
+const CACHE_VERSION = 3; // Bumped: milestone state now cached
 
 interface IdCache {
   version: number; // Cache format version for migrations
   repo: string; // Associated repo to detect cross-repo drift
   tasks: Record<string, number>; // task ID -> issue number
-  milestones: Record<string, { number: number; name: string }>; // milestone ID -> {number, name}
+  milestones: Record<string, { number: number; name: string; state?: 'open' | 'closed' }>; // milestone ID -> {number, name, state}
   nextTaskId: number;
   nextMilestoneId: number;
 }
@@ -89,7 +90,7 @@ export class GitHubAdapter implements StorageAdapter {
   // Helper: Execute gh CLI command safely (no shell injection)
   // ─────────────────────────────────────────────────────────────
 
-  private gh(args: string[], options?: { skipRepo?: boolean }): string {
+  private gh(args: string[], options?: { skipRepo?: boolean; input?: string }): string {
     const fullArgs = [...args];
     // gh api doesn't accept --repo flag (repo is in the endpoint path)
     // Other commands like 'gh issue' do accept --repo
@@ -101,6 +102,7 @@ export class GitHubAdapter implements StorageAdapter {
     const result = spawnSync('gh', fullArgs, {
       encoding: 'utf-8',
       stdio: ['pipe', 'pipe', 'pipe'],
+      input: options?.input,
     });
 
     if (result.error) {
@@ -137,9 +139,17 @@ export class GitHubAdapter implements StorageAdapter {
       try {
         const data = JSON.parse(fs.readFileSync(this.cacheFile, 'utf-8')) as IdCache;
 
+        // Migrate from version 2 to 3: add milestone state field
+        if (data.version === 2) {
+          // Preserve all existing data, just update version
+          // Milestone states will be populated on next listMilestones() call
+          data.version = 3;
+          this.saveCache(data);
+        }
+
         // Validate cache integrity
         if (data.version !== CACHE_VERSION) {
-          // Version mismatch - reset cache (future: migration logic)
+          // Unknown version - reset cache
           console.error(`[tmux-team] Cache version mismatch, resetting cache`);
           return this.createEmptyCache();
         }
@@ -254,6 +264,8 @@ export class GitHubAdapter implements StorageAdapter {
       id,
       name: ghMilestone.title,
       status: ghMilestone.state === 'closed' ? 'done' : 'pending',
+      description: ghMilestone.description || undefined,
+      docPath: `github:milestone/${ghMilestone.number}`,
       createdAt: ghMilestone.createdAt,
       updatedAt: ghMilestone.createdAt, // GH milestones don't have updatedAt
     };
@@ -348,7 +360,7 @@ export class GitHubAdapter implements StorageAdapter {
 
   async createMilestone(input: CreateMilestoneInput): Promise<Milestone> {
     // Create milestone in GitHub
-    const result = this.gh([
+    const args = [
       'api',
       `repos/${this.repo}/milestones`,
       '-X',
@@ -357,19 +369,30 @@ export class GitHubAdapter implements StorageAdapter {
       `title=${input.name}`,
       '-f',
       'state=open',
-    ]);
-    const ghMilestone = JSON.parse(result) as { number: number; title: string; created_at: string };
+    ];
+    if (input.description) {
+      args.push('-f', `description=${input.description}`);
+    }
+    const result = this.gh(args);
+    const ghMilestone = JSON.parse(result) as {
+      number: number;
+      title: string;
+      description: string | null;
+      created_at: string;
+    };
 
-    // Cache the ID mapping (store both number and name)
+    // Cache the ID mapping (store number, name, and state)
     const cache = this.loadCache();
     const id = String(cache.nextMilestoneId++);
-    cache.milestones[id] = { number: ghMilestone.number, name: ghMilestone.title };
+    cache.milestones[id] = { number: ghMilestone.number, name: ghMilestone.title, state: 'open' };
     this.saveCache(cache);
 
     return {
       id,
       name: ghMilestone.title,
       status: 'pending',
+      description: ghMilestone.description || undefined,
+      docPath: `github:milestone/${ghMilestone.number}`,
       createdAt: ghMilestone.created_at,
       updatedAt: ghMilestone.created_at,
     };
@@ -416,8 +439,9 @@ export class GitHubAdapter implements StorageAdapter {
         if (!id) {
           // New milestone from GitHub, assign ID
           id = String(cache.nextMilestoneId++);
-          cache.milestones[id] = { number: ghm.number, name: ghm.title };
         }
+        // Always update cache with current state
+        cache.milestones[id] = { number: ghm.number, name: ghm.title, state: ghm.state };
         milestones.push(this.milestoneToMilestone(ghm, id));
       }
 
@@ -443,9 +467,24 @@ export class GitHubAdapter implements StorageAdapter {
     if (input.status) {
       args.push('-f', `state=${input.status === 'done' ? 'closed' : 'open'}`);
     }
+    if (input.description !== undefined) {
+      args.push('-f', `description=${input.description}`);
+    }
 
     const result = this.gh(args);
     const ghMilestone = JSON.parse(result) as GHMilestone;
+
+    // Update cache with new name/state
+    const cache = this.loadCache();
+    if (cache.milestones[id]) {
+      cache.milestones[id] = {
+        ...cache.milestones[id],
+        name: ghMilestone.title,
+        state: ghMilestone.state,
+      };
+      this.saveCache(cache);
+    }
+
     return this.milestoneToMilestone(ghMilestone, id);
   }
 
@@ -453,13 +492,12 @@ export class GitHubAdapter implements StorageAdapter {
     const number = this.getMilestoneNumber(id);
     if (!number) return;
 
-    try {
-      this.gh(['api', `repos/${this.repo}/milestones/${number}`, '-X', 'DELETE']);
-    } catch {
-      // Already deleted or not found
-    }
+    // Note: We intentionally don't delete the milestone from GitHub.
+    // GitHub milestones may be used by other tools, and deletion is destructive.
+    // Instead, we only remove it from the local cache (soft delete).
+    // To permanently delete, use the GitHub web UI or `gh api` directly.
 
-    // Remove from cache
+    // Remove from cache only
     const cache = this.loadCache();
     delete cache.milestones[id];
     this.saveCache(cache);
@@ -580,7 +618,7 @@ export class GitHubAdapter implements StorageAdapter {
 
     try {
       const issues = this.ghJson<GHIssue[]>(args);
-      const tasks: Task[] = [];
+      let tasks: Task[] = [];
 
       for (const issue of issues) {
         // Find or create ID mapping
@@ -593,6 +631,23 @@ export class GitHubAdapter implements StorageAdapter {
         tasks.push(this.issueToTask(issue, id, cache));
       }
 
+      // Exclude tasks in completed milestones (default: true)
+      const excludeCompleted = filter?.excludeCompletedMilestones ?? true;
+      if (excludeCompleted) {
+        // Build set of closed milestone IDs from cache
+        const closedMilestoneIds = new Set(
+          Object.entries(cache.milestones)
+            .filter(([, m]) => m.state === 'closed')
+            .map(([id]) => id)
+        );
+        tasks = tasks.filter((t) => !t.milestone || !closedMilestoneIds.has(t.milestone));
+      }
+
+      // Hide tasks without milestone if configured
+      if (filter?.hideOrphanTasks) {
+        tasks = tasks.filter((t) => t.milestone);
+      }
+
       this.saveCache(cache);
       return tasks.sort((a, b) => parseInt(a.id) - parseInt(b.id));
     } catch (error) {
@@ -705,6 +760,30 @@ export class GitHubAdapter implements StorageAdapter {
     this.gh(['issue', 'edit', String(number), '--body', content]);
   }
 
+  async getMilestoneDoc(id: string): Promise<string | null> {
+    const number = this.getMilestoneNumber(id);
+    if (!number) return null;
+
+    try {
+      const result = this.gh(['api', `repos/${this.repo}/milestones/${number}`]);
+      const ghMilestone = JSON.parse(result) as GHMilestone;
+      return ghMilestone.description || null;
+    } catch {
+      return null;
+    }
+  }
+
+  async setMilestoneDoc(id: string, content: string): Promise<void> {
+    const number = this.getMilestoneNumber(id);
+    if (!number) throw new Error(`Milestone ${id} not found`);
+
+    // Use -F with @- to read from stdin (handles multiline content properly)
+    this.gh(
+      ['api', `repos/${this.repo}/milestones/${number}`, '-X', 'PATCH', '-F', 'description=@-'],
+      { input: content }
+    );
+  }
+
   // ─────────────────────────────────────────────────────────────
   // Audit log (Issue Comments)
   // ─────────────────────────────────────────────────────────────

package/src/pm/types.ts

@@ -16,6 +16,8 @@ export interface Milestone {
   id: string;
   name: string;
   status: MilestoneStatus;
+  description?: string;
+  docPath?: string;
   createdAt: string;
   updatedAt: string;
 }
@@ -55,17 +57,21 @@ export interface UpdateTaskInput {
 
 export interface CreateMilestoneInput {
   name: string;
+  description?: string;
 }
 
 export interface UpdateMilestoneInput {
   name?: string;
   status?: MilestoneStatus;
+  description?: string;
 }
 
 export interface ListTasksFilter {
   milestone?: string;
   status?: TaskStatus;
   assignee?: string;
+  excludeCompletedMilestones?: boolean; // Hide tasks in completed milestones (default: true)
+  hideOrphanTasks?: boolean; // Hide tasks without milestone (default: false)
 }
 
 // ─────────────────────────────────────────────────────────────

package/src/state.test.ts

@@ -51,8 +51,11 @@ describe('State Management', () => {
       fs.writeFileSync(paths.stateFile, JSON.stringify(existingState));
 
       const state = loadState(paths);
-      expect(state.requests.claude).toBeDefined();
-      expect(state.requests.claude?.nonce).toBe('abc123');
+      expect(state.requests.claude).toMatchObject({
+        id: 'req-1',
+        nonce: 'abc123',
+        pane: '1.0',
+      });
     });
 
     it('returns empty state when state.json is corrupted', () => {
@@ -123,7 +126,11 @@ describe('State Management', () => {
 
       const cleaned = cleanupState(paths, 60); // 60 second TTL
 
-      expect(cleaned.requests.recentAgent).toBeDefined();
+      expect(cleaned.requests.recentAgent).toMatchObject({
+        id: 'new',
+        nonce: 'new',
+        pane: '1.0',
+      });
     });
 
     it('requires ttlSeconds parameter', () => {
@@ -142,7 +149,7 @@ describe('State Management', () => {
       // With 10s TTL, agent1 should be kept, agent2 removed
       const cleaned = cleanupState(paths, 10);
 
-      expect(cleaned.requests.agent1).toBeDefined();
+      expect(cleaned.requests.agent1).toMatchObject({ id: '1', nonce: 'a' });
       expect(cleaned.requests.agent2).toBeUndefined();
     });
 
@@ -193,8 +200,11 @@ describe('State Management', () => {
       setActiveRequest(paths, 'claude', req);
 
       const state = loadState(paths);
-      expect(state.requests.claude).toBeDefined();
-      expect(state.requests.claude?.id).toBe('req-1');
+      expect(state.requests.claude).toMatchObject({
+        id: 'req-1',
+        nonce: 'nonce123',
+        pane: '1.0',
+      });
     });
 
     it('stores request with id, nonce, pane, and startedAtMs', () => {
@@ -244,8 +254,8 @@ describe('State Management', () => {
       setActiveRequest(paths, 'codex', req2);
 
       const state = loadState(paths);
-      expect(state.requests.claude).toBeDefined();
-      expect(state.requests.codex).toBeDefined();
+      expect(state.requests.claude).toMatchObject({ id: '1', nonce: 'a' });
+      expect(state.requests.codex).toMatchObject({ id: '2', nonce: 'b' });
     });
   });
 
@@ -282,7 +292,7 @@ describe('State Management', () => {
       clearActiveRequest(paths, 'claude', 'wrong-id');
 
       const state = loadState(paths);
-      expect(state.requests.claude).toBeDefined(); // Should still exist
+      expect(state.requests.claude).toMatchObject({ id: 'req-1', nonce: 'a' }); // Should still exist
     });
 
     it('clears when requestId matches', () => {
@@ -305,7 +315,7 @@ describe('State Management', () => {
 
       const state = loadState(paths);
       expect(state.requests.claude).toBeUndefined();
-      expect(state.requests.codex).toBeDefined();
+      expect(state.requests.codex).toMatchObject({ id: '2', nonce: 'b' });
     });
   });
 });

package/src/state.ts

@@ -15,6 +15,7 @@ export interface AgentRequestState {
 
 export interface StateFile {
   requests: Record<string, AgentRequestState>;
+  preambleCounters?: Record<string, number>; // agentName -> message count
 }
 
 const DEFAULT_STATE: StateFile = { requests: {} };
@@ -52,7 +53,10 @@ export function cleanupState(paths: Paths, ttlSeconds: number): StateFile {
   const now = Date.now();
 
   const ttlMs = Math.max(1, ttlSeconds) * 1000;
-  const next: StateFile = { requests: {} };
+  const next: StateFile = {
+    requests: {},
+    preambleCounters: state.preambleCounters, // Preserve preamble counters
+  };
 
   for (const [agent, req] of Object.entries(state.requests)) {
     if (!req || typeof req.startedAtMs !== 'number') continue;
@@ -81,3 +85,26 @@ export function clearActiveRequest(paths: Paths, agent: string, requestId?: stri
   delete state.requests[agent];
   saveState(paths, state);
 }
+
+/**
+ * Get the current preamble counter for an agent.
+ * Returns 0 if not set.
+ */
+export function getPreambleCounter(paths: Paths, agent: string): number {
+  const state = loadState(paths);
+  return state.preambleCounters?.[agent] ?? 0;
+}
+
+/**
+ * Increment the preamble counter for an agent and return the new value.
+ */
+export function incrementPreambleCounter(paths: Paths, agent: string): number {
+  const state = loadState(paths);
+  if (!state.preambleCounters) {
+    state.preambleCounters = {};
+  }
+  const newCount = (state.preambleCounters[agent] ?? 0) + 1;
+  state.preambleCounters[agent] = newCount;
+  saveState(paths, state);
+  return newCount;
+}

package/src/types.ts

@@ -10,24 +10,28 @@ export interface AgentConfig {
 export interface PaneEntry {
   pane: string;
   remark?: string;
+  preamble?: string; // Agent preamble (prepended to messages)
+  deny?: string[]; // Permission deny patterns
 }
 
 export interface ConfigDefaults {
   timeout: number; // seconds
   pollInterval: number; // seconds
   captureLines: number;
+  preambleEvery: number; // inject preamble every N messages (default: 3)
+  hideOrphanTasks: boolean; // hide tasks without milestone in list (default: false)
 }
 
 export interface GlobalConfig {
   mode: 'polling' | 'wait';
   preambleMode: 'always' | 'disabled';
   defaults: ConfigDefaults;
-  agents: Record<string, AgentConfig>;
 }
 
 export interface LocalSettings {
   mode?: 'polling' | 'wait';
   preambleMode?: 'always' | 'disabled';
+  preambleEvery?: number; // local override for preamble frequency
 }
 
 export interface LocalConfigFile {

package/src/ui.ts

@@ -7,7 +7,8 @@ import type { UI } from './types.js';
 const isTTY = process.stdout.isTTY;
 
 // Strip ANSI escape codes for accurate length calculation
-const stripAnsi = (s: string) => s.replace(/\x1b\[[0-9;]*m/g, '');
+const ansiEscape = String.fromCharCode(27);
+const stripAnsi = (s: string) => s.replace(new RegExp(`${ansiEscape}\\[[0-9;]*m`, 'g'), '');
 
 export const colors = {
   red: (s: string) => (isTTY ? `\x1b[31m${s}\x1b[0m` : s),