brosh 0.2.2

package/packages/desktop-electron/tests/main/ai-detection/fixtures/typos.ts

@@ -0,0 +1,123 @@
+/**
+ * Test fixtures for typo detection
+ */
+
+export interface CommandTypo {
+  typo: string;
+  correct: string;
+  fullInput?: string;
+  fullCorrected?: string;
+}
+
+export interface SubcommandTypo {
+  command: string;
+  typo: string;
+  correct: string;
+  fullInput?: string;
+  fullCorrected?: string;
+}
+
+// Command typos (first word)
+export const COMMAND_TYPOS: CommandTypo[] = [
+  // Transposition typos
+  { typo: 'gti', correct: 'git', fullInput: 'gti status', fullCorrected: 'git status' },
+  { typo: 'nmp', correct: 'npm', fullInput: 'nmp install', fullCorrected: 'npm install' },
+  { typo: 'dcoker', correct: 'docker', fullInput: 'dcoker ps', fullCorrected: 'docker ps' },
+  { typo: 'kubeclt', correct: 'kubectl', fullInput: 'kubeclt get pods', fullCorrected: 'kubectl get pods' },
+
+  // Missing character
+  { typo: 'gi', correct: 'git', fullInput: 'gi status', fullCorrected: 'git status' },
+  { typo: 'np', correct: 'npm', fullInput: 'np install', fullCorrected: 'npm install' },
+
+  // Extra character
+  { typo: 'gitt', correct: 'git', fullInput: 'gitt status', fullCorrected: 'git status' },
+  { typo: 'nppm', correct: 'npm', fullInput: 'nppm install', fullCorrected: 'npm install' },
+
+  // Substitution
+  { typo: 'got', correct: 'git', fullInput: 'got status', fullCorrected: 'git status' },
+  { typo: 'npa', correct: 'npm', fullInput: 'npa install', fullCorrected: 'npm install' },
+
+  // Common misspellings
+  { typo: 'yarm', correct: 'yarn', fullInput: 'yarm add react', fullCorrected: 'yarn add react' },
+  { typo: 'cargi', correct: 'cargo', fullInput: 'cargi build', fullCorrected: 'cargo build' },
+  { typo: 'bew', correct: 'brew', fullInput: 'bew install node', fullCorrected: 'brew install node' },
+];
+
+// Subcommand typos (second word for commands with subcommands)
+export const SUBCOMMAND_TYPOS: SubcommandTypo[] = [
+  // Git subcommands
+  { command: 'git', typo: 'comit', correct: 'commit', fullInput: 'git comit -m "msg"', fullCorrected: 'git commit -m "msg"' },
+  { command: 'git', typo: 'stauts', correct: 'status', fullInput: 'git stauts', fullCorrected: 'git status' },
+  { command: 'git', typo: 'psuh', correct: 'push', fullInput: 'git psuh', fullCorrected: 'git push' },
+  { command: 'git', typo: 'pul', correct: 'pull', fullInput: 'git pul', fullCorrected: 'git pull' },
+  { command: 'git', typo: 'brnach', correct: 'branch', fullInput: 'git brnach', fullCorrected: 'git branch' },
+  { command: 'git', typo: 'checkou', correct: 'checkout', fullInput: 'git checkou main', fullCorrected: 'git checkout main' },
+  { command: 'git', typo: 'merg', correct: 'merge', fullInput: 'git merg main', fullCorrected: 'git merge main' },
+
+  // NPM subcommands
+  { command: 'npm', typo: 'instal', correct: 'install', fullInput: 'npm instal react', fullCorrected: 'npm install react' },
+  { command: 'npm', typo: 'uninsatll', correct: 'uninstall', fullInput: 'npm uninsatll lodash', fullCorrected: 'npm uninstall lodash' },
+  { command: 'npm', typo: 'publsih', correct: 'publish', fullInput: 'npm publsih', fullCorrected: 'npm publish' },
+
+  // Docker subcommands
+  { command: 'docker', typo: 'buld', correct: 'build', fullInput: 'docker buld .', fullCorrected: 'docker build .' },
+  { command: 'docker', typo: 'imags', correct: 'images', fullInput: 'docker imags', fullCorrected: 'docker images' },
+  { command: 'docker', typo: 'exce', correct: 'exec', fullInput: 'docker exce -it container bash', fullCorrected: 'docker exec -it container bash' },
+
+  // Yarn subcommands
+  { command: 'yarn', typo: 'ad', correct: 'add', fullInput: 'yarn ad react', fullCorrected: 'yarn add react' },
+  { command: 'yarn', typo: 'remov', correct: 'remove', fullInput: 'yarn remov lodash', fullCorrected: 'yarn remove lodash' },
+
+  // Cargo subcommands
+  { command: 'cargo', typo: 'biuld', correct: 'build', fullInput: 'cargo biuld', fullCorrected: 'cargo build' },
+  { command: 'cargo', typo: 'tets', correct: 'test', fullInput: 'cargo tets', fullCorrected: 'cargo test' },
+];
+
+// Words that should NOT be treated as typos (NL starter words)
+export const NL_NOT_TYPOS = [
+  // Question words
+  'how', 'what', 'why', 'where', 'when', 'who', 'which', 'whose',
+  // Modal verbs
+  'can', 'could', 'would', 'should', 'will', 'shall', 'may', 'might', 'must',
+  // Be verbs
+  'is', 'are', 'was', 'were', 'am', 'be', 'been', 'being',
+  // Other verbs
+  'do', 'does', 'did', 'have', 'has', 'had',
+  // Pronouns
+  'i', 'you', 'he', 'she', 'it', 'we', 'they',
+  // Possessives
+  'my', 'your', 'his', 'her', 'its', 'our', 'their',
+  // Demonstratives
+  'this', 'that', 'these', 'those',
+  // Request words
+  'please', 'help', 'show', 'tell', 'explain', 'describe', 'list', 'find', 'search',
+  // Articles
+  'the', 'a', 'an',
+  // Conversational
+  'yes', 'no', 'ok', 'okay', 'sure', 'thanks', 'thank', 'sorry', 'hi', 'hello',
+  'hey', 'great', 'good', 'nice', 'cool', 'awesome', 'perfect', 'fine', 'right',
+  'yeah', 'yep', 'nope', 'maybe', 'probably', 'definitely', 'absolutely',
+];
+
+// Inputs that look like typos but are actually NL
+export const NL_LOOKS_LIKE_TYPO = [
+  'how far is the moon',
+  'what time is it',
+  'why is the sky blue',
+  'can you help me',
+  'i need assistance',
+  'yes please',
+  'no thanks',
+  'ok let me try',
+  'sure go ahead',
+  'thanks for helping',
+];
+
+// Inputs that are clearly too far from any command to be typos
+export const NOT_TYPOS_TOO_FAR = [
+  'foobar something',
+  'asdfgh',
+  'qwerty',
+  'xyz123',
+  'supercalifragilistic',
+];

package/packages/desktop-electron/tests/main/ai-detection/hasValidSubcommand.test.ts

@@ -0,0 +1,218 @@
+import { describe, it, expect } from 'vitest';
+import {
+  hasValidSubcommand,
+  commandHasSubcommands,
+  getSubcommands,
+} from '../../../src/main/ai-detection.js';
+
+describe('hasValidSubcommand', () => {
+  describe('git subcommands', () => {
+    const validGitSubcommands = [
+      'add', 'bisect', 'branch', 'checkout', 'cherry-pick', 'clone', 'commit',
+      'diff', 'fetch', 'grep', 'init', 'log', 'merge', 'mv', 'pull', 'push',
+      'rebase', 'remote', 'reset', 'restore', 'revert', 'rm', 'show', 'stash',
+      'status', 'switch', 'tag', 'worktree',
+    ];
+
+    for (const sub of validGitSubcommands) {
+      it(`should return true for "git ${sub}"`, () => {
+        expect(hasValidSubcommand('git', sub)).toBe(true);
+      });
+    }
+
+    it('should be case insensitive', () => {
+      expect(hasValidSubcommand('git', 'STATUS')).toBe(true);
+      expect(hasValidSubcommand('GIT', 'status')).toBe(true);
+      expect(hasValidSubcommand('Git', 'Commit')).toBe(true);
+    });
+
+    it('should return false for invalid git subcommands', () => {
+      expect(hasValidSubcommand('git', 'foo')).toBe(false);
+      expect(hasValidSubcommand('git', 'how')).toBe(false);
+      expect(hasValidSubcommand('git', 'please')).toBe(false);
+      expect(hasValidSubcommand('git', 'help')).toBe(false); // Not in the registry
+    });
+  });
+
+  describe('npm subcommands', () => {
+    const validNpmSubcommands = [
+      'install', 'uninstall', 'update', 'publish', 'run', 'test', 'start',
+      'init', 'search', 'view', 'audit', 'cache', 'config',
+    ];
+
+    for (const sub of validNpmSubcommands) {
+      it(`should return true for "npm ${sub}"`, () => {
+        expect(hasValidSubcommand('npm', sub)).toBe(true);
+      });
+    }
+
+    it('should return false for invalid npm subcommands', () => {
+      expect(hasValidSubcommand('npm', 'foo')).toBe(false);
+      expect(hasValidSubcommand('npm', 'please')).toBe(false);
+      expect(hasValidSubcommand('npm', 'is')).toBe(false);
+    });
+  });
+
+  describe('docker subcommands', () => {
+    const validDockerSubcommands = [
+      'run', 'build', 'push', 'pull', 'images', 'ps', 'exec', 'logs',
+      'stop', 'start', 'restart', 'rm', 'rmi', 'network', 'volume',
+    ];
+
+    for (const sub of validDockerSubcommands) {
+      it(`should return true for "docker ${sub}"`, () => {
+        expect(hasValidSubcommand('docker', sub)).toBe(true);
+      });
+    }
+
+    it('should return false for invalid docker subcommands', () => {
+      expect(hasValidSubcommand('docker', 'foo')).toBe(false);
+      expect(hasValidSubcommand('docker', 'what')).toBe(false);
+    });
+  });
+
+  describe('kubectl subcommands', () => {
+    const validKubectlSubcommands = [
+      'get', 'describe', 'create', 'apply', 'delete', 'logs', 'exec',
+      'port-forward', 'config', 'cluster-info',
+    ];
+
+    for (const sub of validKubectlSubcommands) {
+      it(`should return true for "kubectl ${sub}"`, () => {
+        expect(hasValidSubcommand('kubectl', sub)).toBe(true);
+      });
+    }
+  });
+
+  describe('brew subcommands', () => {
+    const validBrewSubcommands = [
+      'install', 'uninstall', 'update', 'upgrade', 'search', 'info',
+      'list', 'cleanup', 'doctor', 'services',
+    ];
+
+    for (const sub of validBrewSubcommands) {
+      it(`should return true for "brew ${sub}"`, () => {
+        expect(hasValidSubcommand('brew', sub)).toBe(true);
+      });
+    }
+  });
+
+  describe('yarn subcommands', () => {
+    // Only include subcommands that are actually in the registry
+    const validYarnSubcommands = [
+      'add', 'remove', 'install', 'upgrade', 'init', 'run',
+      'cache', 'config', // 'test' and 'build' are npm scripts, not yarn subcommands
+    ];
+
+    for (const sub of validYarnSubcommands) {
+      it(`should return true for "yarn ${sub}"`, () => {
+        expect(hasValidSubcommand('yarn', sub)).toBe(true);
+      });
+    }
+
+    it('should return false for npm script aliases not in registry', () => {
+      // 'test' and 'build' are common npm scripts but not yarn subcommands
+      expect(hasValidSubcommand('yarn', 'test')).toBe(false);
+      expect(hasValidSubcommand('yarn', 'build')).toBe(false);
+    });
+  });
+
+  describe('cargo subcommands', () => {
+    const validCargoSubcommands = [
+      'build', 'run', 'test', 'check', 'clean', 'doc', 'new', 'init',
+      'publish', 'install', 'uninstall',
+    ];
+
+    for (const sub of validCargoSubcommands) {
+      it(`should return true for "cargo ${sub}"`, () => {
+        expect(hasValidSubcommand('cargo', sub)).toBe(true);
+      });
+    }
+  });
+
+  describe('gh subcommands', () => {
+    const validGhSubcommands = [
+      'repo', 'issue', 'pr', 'release', 'workflow', 'run', 'gist',
+      'auth', 'config', 'api',
+    ];
+
+    for (const sub of validGhSubcommands) {
+      it(`should return true for "gh ${sub}"`, () => {
+        expect(hasValidSubcommand('gh', sub)).toBe(true);
+      });
+    }
+  });
+
+  describe('pnpm subcommands', () => {
+    // Only include subcommands that are actually in the registry
+    const validPnpmSubcommands = [
+      'add', 'install', 'remove', 'update', 'run', 'test',
+      'exec', 'dlx', 'store', // 'build' is not in registry
+    ];
+
+    for (const sub of validPnpmSubcommands) {
+      it(`should return true for "pnpm ${sub}"`, () => {
+        expect(hasValidSubcommand('pnpm', sub)).toBe(true);
+      });
+    }
+
+    it('should return false for npm script aliases not in registry', () => {
+      expect(hasValidSubcommand('pnpm', 'build')).toBe(false);
+    });
+  });
+
+  describe('unregistered commands', () => {
+    it('should return false for commands not in registry', () => {
+      expect(hasValidSubcommand('ls', 'anything')).toBe(false);
+      expect(hasValidSubcommand('cat', 'file')).toBe(false);
+      expect(hasValidSubcommand('grep', 'pattern')).toBe(false);
+      expect(hasValidSubcommand('unknown', 'command')).toBe(false);
+    });
+  });
+});
+
+describe('commandHasSubcommands', () => {
+  it('should return true for registered commands', () => {
+    expect(commandHasSubcommands('git')).toBe(true);
+    expect(commandHasSubcommands('npm')).toBe(true);
+    expect(commandHasSubcommands('docker')).toBe(true);
+    expect(commandHasSubcommands('kubectl')).toBe(true);
+    expect(commandHasSubcommands('brew')).toBe(true);
+    expect(commandHasSubcommands('yarn')).toBe(true);
+    expect(commandHasSubcommands('cargo')).toBe(true);
+    expect(commandHasSubcommands('gh')).toBe(true);
+    expect(commandHasSubcommands('pnpm')).toBe(true);
+  });
+
+  it('should be case insensitive', () => {
+    expect(commandHasSubcommands('GIT')).toBe(true);
+    expect(commandHasSubcommands('Git')).toBe(true);
+    expect(commandHasSubcommands('NPM')).toBe(true);
+  });
+
+  it('should return false for unregistered commands', () => {
+    expect(commandHasSubcommands('ls')).toBe(false);
+    expect(commandHasSubcommands('cat')).toBe(false);
+    expect(commandHasSubcommands('grep')).toBe(false);
+    expect(commandHasSubcommands('unknown')).toBe(false);
+  });
+});
+
+describe('getSubcommands', () => {
+  it('should return Set for registered commands', () => {
+    const gitSubs = getSubcommands('git');
+    expect(gitSubs).toBeInstanceOf(Set);
+    expect(gitSubs?.has('status')).toBe(true);
+    expect(gitSubs?.has('commit')).toBe(true);
+  });
+
+  it('should be case insensitive', () => {
+    expect(getSubcommands('GIT')).toBeInstanceOf(Set);
+    expect(getSubcommands('Git')).toBeInstanceOf(Set);
+  });
+
+  it('should return undefined for unregistered commands', () => {
+    expect(getSubcommands('ls')).toBeUndefined();
+    expect(getSubcommands('unknown')).toBeUndefined();
+  });
+});

package/packages/desktop-electron/tests/main/ai-detection/isCommandNotFound.test.ts

@@ -0,0 +1,117 @@
+import { describe, it, expect } from 'vitest';
+import { isCommandNotFound } from '../../../src/main/ai-detection.js';
+
+describe('isCommandNotFound', () => {
+  describe('should match "command not found" patterns', () => {
+    it('should match bash style: "bash: foo: command not found"', () => {
+      expect(isCommandNotFound('bash: foo: command not found')).toBe(true);
+      expect(isCommandNotFound('bash: gti: command not found')).toBe(true);
+    });
+
+    it('should match zsh style: "zsh: command not found: foo"', () => {
+      expect(isCommandNotFound('zsh: command not found: foo')).toBe(true);
+      expect(isCommandNotFound('zsh: command not found: gti')).toBe(true);
+    });
+
+    it('should match sh style: "sh: foo: not found"', () => {
+      expect(isCommandNotFound('sh: foo: not found')).toBe(true);
+      expect(isCommandNotFound('sh: 1: gti: not found')).toBe(true);
+    });
+
+    it('should match generic "not found" pattern', () => {
+      expect(isCommandNotFound('foo: not found')).toBe(true);
+      expect(isCommandNotFound('command: not found')).toBe(true);
+    });
+
+    it('should match "unknown command" pattern', () => {
+      expect(isCommandNotFound('unknown command: foo')).toBe(true);
+      expect(isCommandNotFound('Unknown command "gti"')).toBe(true);
+    });
+
+    it('should match Windows style: "\'foo\' is not recognized..."', () => {
+      expect(isCommandNotFound("'foo' is not recognized as an internal or external command")).toBe(true);
+      expect(isCommandNotFound("'gti' is not recognized")).toBe(true);
+    });
+
+    it('should match "No such file or directory"', () => {
+      expect(isCommandNotFound('bash: ./script.sh: No such file or directory')).toBe(true);
+      expect(isCommandNotFound('/usr/bin/foo: No such file or directory')).toBe(true);
+    });
+  });
+
+  describe('should be case insensitive', () => {
+    it('should match regardless of case', () => {
+      expect(isCommandNotFound('COMMAND NOT FOUND')).toBe(true);
+      expect(isCommandNotFound('Command Not Found')).toBe(true);
+      expect(isCommandNotFound('NOT FOUND')).toBe(true);
+      expect(isCommandNotFound('Not Recognized')).toBe(true);
+    });
+  });
+
+  describe('should NOT match other error messages', () => {
+    it('should not match permission denied', () => {
+      expect(isCommandNotFound('Permission denied')).toBe(false);
+      expect(isCommandNotFound('bash: ./script.sh: Permission denied')).toBe(false);
+    });
+
+    it('should not match syntax errors', () => {
+      expect(isCommandNotFound('Syntax error near unexpected token')).toBe(false);
+      expect(isCommandNotFound('bash: syntax error')).toBe(false);
+    });
+
+    it('should not match connection errors', () => {
+      expect(isCommandNotFound('Connection refused')).toBe(false);
+      expect(isCommandNotFound('Connection timed out')).toBe(false);
+    });
+
+    it('should not match empty string', () => {
+      expect(isCommandNotFound('')).toBe(false);
+    });
+
+    it('should not match general error messages', () => {
+      expect(isCommandNotFound('Error: something went wrong')).toBe(false);
+      expect(isCommandNotFound('Failed to execute')).toBe(false);
+      expect(isCommandNotFound('Operation not permitted')).toBe(false);
+    });
+
+    it('should not match success messages', () => {
+      expect(isCommandNotFound('Command executed successfully')).toBe(false);
+      expect(isCommandNotFound('Build completed')).toBe(false);
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle multiline stderr', () => {
+      const multiline = `some output
+bash: foo: command not found
+more output`;
+      expect(isCommandNotFound(multiline)).toBe(true);
+    });
+
+    it('should handle stderr with ANSI codes', () => {
+      expect(isCommandNotFound('\x1b[31mcommand not found\x1b[0m')).toBe(true);
+    });
+
+    it('should handle stderr with extra whitespace', () => {
+      expect(isCommandNotFound('   command not found   ')).toBe(true);
+    });
+  });
+
+  describe('real-world examples', () => {
+    it('should match common real stderr outputs', () => {
+      const examples = [
+        'bash: gti: command not found',
+        'zsh: command not found: nmp',
+        '-bash: dcoker: command not found',
+        'sh: kubeclt: not found',
+        '/bin/sh: 1: foobar: not found',
+        "cmd.exe: 'asdf' is not recognized as an internal or external command",
+        'fish: Unknown command: xyz',
+      ];
+
+      for (const example of examples) {
+        expect(isCommandNotFound(example)).toBe(true);
+      }
+    });
+  });
+});

package/packages/desktop-electron/tests/main/error-triage/buildTriagePrompt.test.ts

@@ -0,0 +1,133 @@
+import { describe, it, expect } from 'vitest';
+import { buildTriagePrompt } from '../../../src/main/error-triage.js';
+
+/**
+ * Tests for the error triage prompt builder.
+ *
+ * buildTriagePrompt creates the prompt sent to Claude for error triage,
+ * including command text, exit code, and recent terminal output.
+ */
+
+describe('buildTriagePrompt', () => {
+  describe('prompt structure', () => {
+    it('should include command, exit code, and output', () => {
+      const prompt = buildTriagePrompt('npm run build', 1, 'Error: Module not found');
+
+      expect(prompt).toContain('npm run build');
+      expect(prompt).toContain('Exit code: 1');
+      expect(prompt).toContain('Error: Module not found');
+    });
+
+    it('should include JSON response format instructions', () => {
+      const prompt = buildTriagePrompt('ls /nonexistent', 2, 'No such file');
+
+      expect(prompt).toContain('shouldNotify');
+      expect(prompt).toContain('message');
+      expect(prompt).toContain('JSON');
+    });
+
+    it('should include guidance for shouldNotify=true cases', () => {
+      const prompt = buildTriagePrompt('node app.js', 1, 'crash');
+
+      expect(prompt).toContain('Module/package not found');
+      expect(prompt).toContain('Permission denied');
+      expect(prompt).toContain('Syntax errors');
+    });
+
+    it('should include guidance for shouldNotify=false cases', () => {
+      const prompt = buildTriagePrompt('grep pattern file', 1, '');
+
+      expect(prompt).toContain('grep');
+      expect(prompt).toContain('Ctrl+C');
+    });
+  });
+
+  describe('command handling', () => {
+    it('should handle null command', () => {
+      const prompt = buildTriagePrompt(null, 1, 'some error');
+
+      expect(prompt).toContain('Command: unknown');
+    });
+
+    it('should handle empty string command', () => {
+      const prompt = buildTriagePrompt('', 1, 'some error');
+
+      // Empty string is falsy, should fall back to "unknown"
+      expect(prompt).toContain('Command: unknown');
+    });
+
+    it('should include the actual command when provided', () => {
+      const prompt = buildTriagePrompt('python -m pytest tests/', 1, 'FAILED');
+
+      expect(prompt).toContain('Command: python -m pytest tests/');
+    });
+  });
+
+  describe('exit code handling', () => {
+    it('should include various exit codes', () => {
+      expect(buildTriagePrompt('cmd', 1, 'err')).toContain('Exit code: 1');
+      expect(buildTriagePrompt('cmd', 2, 'err')).toContain('Exit code: 2');
+      expect(buildTriagePrompt('cmd', 127, 'err')).toContain('Exit code: 127');
+      expect(buildTriagePrompt('cmd', 139, 'err')).toContain('Exit code: 139');
+    });
+  });
+
+  describe('output handling', () => {
+    it('should trim whitespace from output', () => {
+      const prompt = buildTriagePrompt('cmd', 1, '  \n  error message  \n  ');
+
+      // The output should be trimmed
+      expect(prompt).toContain('error message');
+      // Should be wrapped in code fences
+      expect(prompt).toContain('```');
+    });
+
+    it('should handle empty output', () => {
+      const prompt = buildTriagePrompt('cmd', 1, '');
+
+      expect(prompt).toContain('Exit code: 1');
+      // Should still have code fence structure even if empty
+      expect(prompt).toContain('```');
+    });
+
+    it('should handle multi-line output', () => {
+      const output = [
+        'Error: Cannot find module "express"',
+        '    at Function._resolveFilename (node:internal/modules/cjs/loader:1405:15)',
+        '    at Function._load (node:internal/modules/cjs/loader:1215:37)',
+      ].join('\n');
+
+      const prompt = buildTriagePrompt('node server.js', 1, output);
+
+      expect(prompt).toContain('Cannot find module');
+      expect(prompt).toContain('_resolveFilename');
+    });
+
+    it('should preserve output with special characters', () => {
+      const output = 'Error: Expected "}" but found "<EOF>"';
+      const prompt = buildTriagePrompt('node -e "{"', 1, output);
+
+      expect(prompt).toContain('Expected');
+    });
+  });
+
+  describe('default behavior guidance', () => {
+    it('should default to shouldNotify=true', () => {
+      const prompt = buildTriagePrompt('cmd', 1, 'error');
+
+      expect(prompt).toContain('DEFAULT: shouldNotify=true');
+    });
+
+    it('should mention that most non-zero exit codes indicate real problems', () => {
+      const prompt = buildTriagePrompt('cmd', 1, 'error');
+
+      expect(prompt).toContain('real problems');
+    });
+
+    it('should advise notifying when in doubt', () => {
+      const prompt = buildTriagePrompt('cmd', 1, 'error');
+
+      expect(prompt).toContain('When in doubt, notify');
+    });
+  });
+});