@yancyyu/openhermit 1.6.42 → 1.6.43

package/src/renderer/utils/__tests__/leadToolActivity.test.ts

@@ -0,0 +1,124 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  extractRecentToolActivity,
+  formatToolPreview,
+  type ToolActivityMessage,
+} from '../leadToolActivity';
+
+function msg(
+  timestamp: string,
+  toolCalls: Array<{ name: string; input: Record<string, unknown>; id?: string }>
+): ToolActivityMessage {
+  return { timestamp, toolCalls };
+}
+
+describe('formatToolPreview', () => {
+  it('extracts the bash command', () => {
+    expect(formatToolPreview('Bash', { command: 'pnpm test' })).toBe('pnpm test');
+  });
+
+  it('extracts file_path for read/edit/write', () => {
+    expect(formatToolPreview('Edit', { file_path: '/repo/src/index.ts' })).toBe(
+      '/repo/src/index.ts'
+    );
+  });
+
+  it('combines grep pattern and path', () => {
+    expect(formatToolPreview('Grep', { pattern: 'TODO', path: '/repo/src' })).toBe(
+      'TODO  (in /repo/src)'
+    );
+  });
+
+  it('keeps pattern alone when no path', () => {
+    expect(formatToolPreview('Glob', { pattern: '**/*.ts' })).toBe('**/*.ts');
+  });
+
+  it('formats Task/Agent with subagent type and description', () => {
+    expect(formatToolPreview('Task', { subagent_type: 'executor', description: 'fix bug' })).toBe(
+      '[executor] fix bug'
+    );
+  });
+
+  it('counts todos for TodoWrite', () => {
+    expect(formatToolPreview('TodoWrite', { todos: [{}, {}, {}] })).toBe('3 todos');
+  });
+
+  it('falls back to the first string-valued arg for unknown tools', () => {
+    expect(formatToolPreview('CustomTool', { note: 'hello world' })).toBe('hello world');
+  });
+
+  it('truncates long fallback previews', () => {
+    const long = 'x'.repeat(120);
+    expect(formatToolPreview('CustomTool', { note: long })).toBe(`${'x'.repeat(80)}…`);
+  });
+
+  it('returns empty string when nothing useful is present', () => {
+    expect(formatToolPreview('Bash', {})).toBe('');
+    expect(formatToolPreview('Unknown', { count: 5 })).toBe('');
+  });
+});
+
+describe('extractRecentToolActivity', () => {
+  it('returns nothing for an empty session', () => {
+    expect(extractRecentToolActivity([], 5)).toEqual([]);
+  });
+
+  it('returns nothing when limit is zero or negative', () => {
+    const messages = [
+      msg('2026-06-13T00:00:00.000Z', [{ name: 'Bash', input: { command: 'ls' } }]),
+    ];
+    expect(extractRecentToolActivity(messages, 0)).toEqual([]);
+    expect(extractRecentToolActivity(messages, -1)).toEqual([]);
+  });
+
+  it('flattens tool calls across messages and orders newest first', () => {
+    const messages = [
+      msg('2026-06-13T00:00:00.000Z', [{ name: 'Bash', input: { command: 'first' }, id: 't1' }]),
+      msg('2026-06-13T00:00:05.000Z', [
+        { name: 'Read', input: { file_path: '/a.ts' }, id: 't2' },
+        { name: 'Edit', input: { file_path: '/b.ts' }, id: 't3' },
+      ]),
+    ];
+
+    const result = extractRecentToolActivity(messages, 10);
+
+    expect(result.map((a) => a.name)).toEqual(['Edit', 'Read', 'Bash']);
+    expect(result[0]).toEqual({
+      name: 'Edit',
+      preview: '/b.ts',
+      toolUseId: 't3',
+      timestamp: '2026-06-13T00:00:05.000Z',
+    });
+  });
+
+  it('respects the limit, keeping the most recent calls', () => {
+    const messages = [
+      msg('2026-06-13T00:00:00.000Z', [{ name: 'Bash', input: { command: 'old' }, id: 't1' }]),
+      msg('2026-06-13T00:00:01.000Z', [{ name: 'Read', input: { file_path: '/a' }, id: 't2' }]),
+      msg('2026-06-13T00:00:02.000Z', [{ name: 'Edit', input: { file_path: '/b' }, id: 't3' }]),
+    ];
+
+    const result = extractRecentToolActivity(messages, 2);
+
+    expect(result.map((a) => a.name)).toEqual(['Edit', 'Read']);
+  });
+
+  it('inherits the owning message timestamp and normalizes Date objects', () => {
+    const date = new Date('2026-06-13T00:00:00.000Z');
+    const messages = [{ timestamp: date, toolCalls: [{ name: 'Bash', input: { command: 'ls' } }] }];
+
+    const [activity] = extractRecentToolActivity(messages, 5);
+    expect(activity?.timestamp).toBe('2026-06-13T00:00:00.000Z');
+  });
+
+  it('skips messages that have no tool calls', () => {
+    const messages = [
+      msg('2026-06-13T00:00:00.000Z', []),
+      msg('2026-06-13T00:00:01.000Z', [{ name: 'Bash', input: { command: 'ls' }, id: 't1' }]),
+    ];
+
+    const result = extractRecentToolActivity(messages, 5);
+    expect(result.map((a) => a.name)).toEqual(['Bash']);
+  });
+});

package/src/renderer/utils/__tests__/mergeTeamMessages.test.ts

@@ -0,0 +1,81 @@
+import { describe, expect, it } from 'vitest';
+
+import { mergeTeamMessages } from '../mergeTeamMessages';
+
+import type { InboxMessage } from '@shared/types';
+
+function makeMessage(overrides: Partial<InboxMessage> = {}): InboxMessage {
+  return {
+    from: 'user',
+    to: 'team',
+    text: 'hello',
+    timestamp: '2026-01-01T00:00:00.000Z',
+    read: true,
+    ...overrides,
+  };
+}
+
+describe('mergeTeamMessages', () => {
+  it('returns empty array for no inputs', () => {
+    expect(mergeTeamMessages()).toEqual([]);
+  });
+
+  it('returns single list unchanged', () => {
+    const msgs = [makeMessage({ messageId: 'a' }), makeMessage({ messageId: 'b' })];
+    const result = mergeTeamMessages(msgs);
+    expect(result).toHaveLength(2);
+  });
+
+  it('deduplicates by messageId', () => {
+    const listA = [makeMessage({ messageId: 'msg-1', text: 'original' })];
+    const listB = [makeMessage({ messageId: 'msg-1', text: 'updated' })];
+    const result = mergeTeamMessages(listA, listB);
+    expect(result).toHaveLength(1);
+    expect(result[0].text).toBe('updated'); // later array wins
+  });
+
+  it('deduplicates by composite key when no messageId', () => {
+    const base = { from: 'user', timestamp: '2026-06-13T01:00:00.000Z' };
+    const listA = [makeMessage({ ...base, text: 'original' })];
+    const listB = [makeMessage({ ...base, text: 'updated' })];
+    // Same from + timestamp + text prefix → same composite key
+    // BUT different text → different key, so both appear
+    // To test dedup, use same text:
+    const listC = [makeMessage({ ...base, text: 'same' })];
+    const listD = [makeMessage({ ...base, text: 'same' })];
+    const result = mergeTeamMessages(listC, listD);
+    expect(result).toHaveLength(1);
+  });
+
+  it('merges messages from multiple lists, newest first', () => {
+    const listA = [makeMessage({ messageId: 'old', timestamp: '2026-01-01T00:00:00.000Z' })];
+    const listB = [makeMessage({ messageId: 'new', timestamp: '2026-06-13T01:00:00.000Z' })];
+    const result = mergeTeamMessages(listA, listB);
+    expect(result).toHaveLength(2);
+    expect(result[0].messageId).toBe('new');
+    expect(result[1].messageId).toBe('old');
+  });
+
+  it('replaces optimistic message with server message by messageId', () => {
+    const optimistic = makeMessage({
+      messageId: 'optimistic-123',
+      text: '/hermit:loop-scan',
+      source: 'user_sent',
+    });
+    const server = makeMessage({
+      messageId: 'optimistic-123',
+      text: '/hermit:loop-scan',
+      source: 'runtime_delivery',
+    });
+    const result = mergeTeamMessages([optimistic], [server]);
+    expect(result).toHaveLength(1);
+    expect(result[0].source).toBe('runtime_delivery');
+  });
+
+  it('keeps messages with different messageIds', () => {
+    const msgA = makeMessage({ messageId: 'msg-a', text: 'command' });
+    const msgB = makeMessage({ messageId: 'msg-b', text: 'command' });
+    const result = mergeTeamMessages([msgA], [msgB]);
+    expect(result).toHaveLength(2);
+  });
+});

package/src/renderer/utils/__tests__/teamMessageFiltering.test.ts

@@ -0,0 +1,213 @@
+import { describe, expect, it } from 'vitest';
+
+import { filterTeamMessages, type TeamMessagesFilter } from '../teamMessageFiltering';
+
+import type { InboxMessage } from '@shared/types';
+
+const defaultFilter: TeamMessagesFilter = { from: new Set(), to: new Set(), showNoise: true };
+
+function makeMessage(overrides: Partial<InboxMessage> = {}): InboxMessage {
+  return {
+    from: 'user',
+    to: 'team',
+    text: 'hello',
+    timestamp: '2026-01-01T00:00:00.000Z',
+    read: true,
+    ...overrides,
+  };
+}
+
+describe('filterTeamMessages', () => {
+  // ── Basic filtering ──────────────────────────────────────────
+
+  it('returns all messages with empty filter', () => {
+    const msgs = [makeMessage(), makeMessage({ messageId: 'b' })];
+    const result = filterTeamMessages(msgs, { filter: defaultFilter, searchQuery: '' });
+    expect(result).toHaveLength(2);
+  });
+
+  it('filters by "from" field', () => {
+    const msgs = [
+      makeMessage({ from: 'user', messageId: 'a' }),
+      makeMessage({ from: 'agent', messageId: 'b' }),
+    ];
+    const result = filterTeamMessages(msgs, {
+      filter: { ...defaultFilter, from: new Set(['user']) },
+      searchQuery: '',
+    });
+    expect(result).toHaveLength(1);
+    expect(result[0].from).toBe('user');
+  });
+
+  it('filters by "to" field', () => {
+    const msgs = [
+      makeMessage({ to: 'team-a', messageId: 'a' }),
+      makeMessage({ to: 'team-b', messageId: 'b' }),
+    ];
+    const result = filterTeamMessages(msgs, {
+      filter: { ...defaultFilter, to: new Set(['team-a']) },
+      searchQuery: '',
+    });
+    expect(result).toHaveLength(1);
+    expect(result[0].to).toBe('team-a');
+  });
+
+  // ── relayOfMessageId dedup ───────────────────────────────────
+
+  it('hides relay copy when original is visible', () => {
+    const original = makeMessage({ messageId: 'msg-1', from: 'user', to: 'lead' });
+    const relay = makeMessage({
+      messageId: 'msg-2',
+      from: 'user',
+      to: 'bridge',
+      relayOfMessageId: 'msg-1',
+    });
+    const result = filterTeamMessages([original, relay], {
+      filter: defaultFilter,
+      searchQuery: '',
+    });
+    expect(result).toHaveLength(1);
+    expect(result[0].messageId).toBe('msg-1');
+  });
+
+  it('keeps relay copy when original is NOT visible (filtered out)', () => {
+    const relay = makeMessage({
+      messageId: 'msg-2',
+      from: 'other-user',
+      to: 'bridge',
+      relayOfMessageId: 'msg-1',
+    });
+    // msg-1 is not in the list at all
+    const result = filterTeamMessages([relay], { filter: defaultFilter, searchQuery: '' });
+    expect(result).toHaveLength(1);
+    expect(result[0].messageId).toBe('msg-2');
+  });
+
+  it('keeps relay copy when original is filtered by "from" filter', () => {
+    const original = makeMessage({ messageId: 'msg-1', from: 'user', to: 'lead' });
+    const relay = makeMessage({
+      messageId: 'msg-2',
+      from: 'bridge',
+      to: 'lead',
+      relayOfMessageId: 'msg-1',
+    });
+    // Filter only shows messages from 'bridge', so original is hidden
+    const result = filterTeamMessages([original, relay], {
+      filter: { ...defaultFilter, from: new Set(['bridge']) },
+      searchQuery: '',
+    });
+    expect(result).toHaveLength(1);
+    expect(result[0].messageId).toBe('msg-2');
+  });
+
+  it('handles message that is its own relay (relayOfMessageId === messageId)', () => {
+    const msg = makeMessage({
+      messageId: 'msg-1',
+      relayOfMessageId: 'msg-1',
+    });
+    const result = filterTeamMessages([msg], { filter: defaultFilter, searchQuery: '' });
+    expect(result).toHaveLength(1);
+  });
+
+  // ── Bug: duplicate slash command messages ─────────────────────
+
+  it('BUG CASE: two messages without relayOfMessageId both show (no dedup)', () => {
+    // This is the current bug: both the direct message and the bridge copy
+    // lack relayOfMessageId, so both pass through the filter
+    const direct = makeMessage({
+      messageId: 'direct-1',
+      from: 'user',
+      to: 'hermit-dev',
+      text: '/hermit:daily-folder-hygiene',
+    });
+    const bridgeCopy = makeMessage({
+      messageId: 'bridge-1',
+      from: 'user',
+      to: 'bridge',
+      text: '/hermit:daily-folder-hygiene',
+    });
+    const result = filterTeamMessages([direct, bridgeCopy], {
+      filter: defaultFilter,
+      searchQuery: '',
+    });
+    // BUG: both appear because neither has relayOfMessageId
+    expect(result).toHaveLength(2);
+  });
+
+  it('duplicate slash commands are deduped when relayOfMessageId is set correctly', () => {
+    const direct = makeMessage({
+      messageId: 'direct-1',
+      from: 'user',
+      to: 'hermit-dev',
+      text: '/hermit:daily-folder-hygiene',
+    });
+    const bridgeCopy = makeMessage({
+      messageId: 'bridge-1',
+      from: 'user',
+      to: 'bridge',
+      text: '/hermit:daily-folder-hygiene',
+      relayOfMessageId: 'direct-1', // FIX: server should set this
+    });
+    const result = filterTeamMessages([direct, bridgeCopy], {
+      filter: defaultFilter,
+      searchQuery: '',
+    });
+    expect(result).toHaveLength(1);
+    expect(result[0].messageId).toBe('direct-1');
+  });
+
+  // ── Search query ─────────────────────────────────────────────
+
+  it('filters by search query in text', () => {
+    const msgs = [
+      makeMessage({ text: 'hello world', messageId: 'a' }),
+      makeMessage({ text: 'foo bar', messageId: 'b' }),
+    ];
+    const result = filterTeamMessages(msgs, { filter: defaultFilter, searchQuery: 'hello' });
+    expect(result).toHaveLength(1);
+    expect(result[0].messageId).toBe('a');
+  });
+
+  it('filters by search query in from/to', () => {
+    const msgs = [
+      makeMessage({ from: 'alice', messageId: 'a' }),
+      makeMessage({ from: 'bob', messageId: 'b' }),
+    ];
+    const result = filterTeamMessages(msgs, { filter: defaultFilter, searchQuery: 'alice' });
+    expect(result).toHaveLength(1);
+  });
+
+  // ── task_comment_notification exclusion ───────────────────────
+
+  it('excludes task_comment_notification messages', () => {
+    const msgs = [
+      makeMessage({ messageId: 'a' }),
+      makeMessage({
+        messageId: 'b',
+        messageKind: 'task_comment_notification' as InboxMessage['messageKind'],
+      }),
+    ];
+    const result = filterTeamMessages(msgs, { filter: defaultFilter, searchQuery: '' });
+    expect(result).toHaveLength(1);
+    expect(result[0].messageId).toBe('a');
+  });
+
+  // ── Time window ──────────────────────────────────────────────
+
+  it('filters by time window', () => {
+    const msgs = [
+      makeMessage({ messageId: 'a', timestamp: '2026-01-01T00:00:00.000Z' }),
+      makeMessage({ messageId: 'b', timestamp: '2026-06-13T01:00:00.000Z' }),
+    ];
+    const result = filterTeamMessages(msgs, {
+      filter: defaultFilter,
+      searchQuery: '',
+      timeWindow: {
+        start: new Date('2026-06-01').getTime(),
+        end: new Date('2026-07-01').getTime(),
+      },
+    });
+    expect(result).toHaveLength(1);
+    expect(result[0].messageId).toBe('b');
+  });
+});

package/src/renderer/utils/__tests__/teamMessageKey.test.ts

@@ -0,0 +1,75 @@
+import { describe, expect, it } from 'vitest';
+
+import { toMessageKey } from '../teamMessageKey';
+
+import type { InboxMessage } from '@shared/types';
+
+function makeMessage(overrides: Partial<InboxMessage> = {}): InboxMessage {
+  return {
+    from: 'user',
+    to: 'team',
+    text: 'hello',
+    timestamp: '2026-01-01T00:00:00.000Z',
+    read: true,
+    ...overrides,
+  };
+}
+
+describe('toMessageKey', () => {
+  it('uses messageId when present', () => {
+    const msg = makeMessage({ messageId: 'msg-123' });
+    expect(toMessageKey(msg)).toBe('msg-123');
+  });
+
+  it('ignores whitespace-only messageId and falls back to composite key', () => {
+    const msg = makeMessage({ messageId: '   ' });
+    const key = toMessageKey(msg);
+    expect(key).toContain('2026-01-01T00:00:00.000Z');
+    expect(key).toContain('user');
+    expect(key).toContain('hello');
+  });
+
+  it('ignores empty messageId and falls back to composite key', () => {
+    const msg = makeMessage({ messageId: '' });
+    const key = toMessageKey(msg);
+    expect(key).toContain('2026-01-01T00:00:00.000Z');
+  });
+
+  it('builds composite key from timestamp-from-text when no messageId', () => {
+    const msg = makeMessage({
+      from: 'agent',
+      text: 'world',
+      timestamp: '2026-06-13T01:00:00.000Z',
+    });
+    const key = toMessageKey(msg);
+    expect(key).toBe('2026-06-13T01:00:00.000Z-agent-world');
+  });
+
+  it('truncates text to 80 chars in composite key', () => {
+    const longText = 'x'.repeat(200);
+    const msg = makeMessage({ text: longText });
+    const key = toMessageKey(msg);
+    // Composite key format: timestamp-from-text[:80]
+    // Key length = timestamp(24) + '-' + from(4) + '-' + text(80) = 109
+    expect(key.length).toBeLessThanOrEqual(24 + 1 + 4 + 1 + 80);
+  });
+
+  it('handles missing text gracefully', () => {
+    const msg = makeMessage({ text: undefined as unknown as string });
+    const key = toMessageKey(msg);
+    expect(key).toBeDefined();
+    expect(key).toContain('2026-01-01');
+  });
+
+  it('produces same key for messages with same messageId', () => {
+    const a = makeMessage({ messageId: 'shared-id', from: 'user', text: 'hello' });
+    const b = makeMessage({ messageId: 'shared-id', from: 'agent', text: 'world' });
+    expect(toMessageKey(a)).toBe(toMessageKey(b));
+  });
+
+  it('produces different keys for messages without messageId but different content', () => {
+    const a = makeMessage({ from: 'user', text: 'hello' });
+    const b = makeMessage({ from: 'user', text: 'world' });
+    expect(toMessageKey(a)).not.toBe(toMessageKey(b));
+  });
+});

package/src/renderer/utils/__tests__/workflowCommandExecution.test.ts

@@ -0,0 +1,173 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const hoisted = vi.hoisted(() => ({
+  readWorkflowPrompt: vi.fn(),
+}));
+
+vi.mock('@renderer/api', () => ({
+  api: {
+    systemManager: {
+      readWorkflowPrompt: hoisted.readWorkflowPrompt,
+    },
+  },
+}));
+
+import {
+  appendArgsToPrompt,
+  expandWorkflowCommand,
+  resolveWorkflowCommandInput,
+} from '../workflowCommandExecution';
+
+import type { MentionSuggestion } from '@renderer/types/mention';
+
+function workflowSuggestion(overrides: Partial<MentionSuggestion> = {}): MentionSuggestion {
+  return {
+    id: 'admin-workflow:prompt-loop-scan',
+    name: 'loop-scan',
+    type: 'command',
+    command: '/loop-scan',
+    insertText: 'loop-scan',
+    workflowPromptId: 'prompt-loop-scan',
+    workflowPromptFolder: '/workspace/.claude/commands',
+    description: '运行 Loop Scan',
+    ...overrides,
+  };
+}
+
+describe('appendArgsToPrompt', () => {
+  it('trims the prompt and returns it unchanged when there are no args', () => {
+    expect(appendArgsToPrompt('  do the thing  ')).toBe('do the thing');
+  });
+
+  it('appends trimmed args under a User arguments section', () => {
+    expect(appendArgsToPrompt('do the thing', '  --scope src  ')).toBe(
+      'do the thing\n\nUser arguments:\n--scope src'
+    );
+  });
+
+  it('ignores whitespace-only args', () => {
+    expect(appendArgsToPrompt('do the thing', '   ')).toBe('do the thing');
+  });
+});
+
+describe('resolveWorkflowCommandInput', () => {
+  it('returns null for non-slash text', () => {
+    expect(resolveWorkflowCommandInput([workflowSuggestion()], 'just a message')).toBeNull();
+  });
+
+  it('returns null when no suggestion matches the command', () => {
+    expect(resolveWorkflowCommandInput([workflowSuggestion()], '/unknown-cmd')).toBeNull();
+  });
+
+  it('matches the typed command against a workflow suggestion and captures args', () => {
+    const resolved = resolveWorkflowCommandInput([workflowSuggestion()], '/loop-scan --scope src');
+    expect(resolved).toEqual({
+      folder: '/workspace/.claude/commands',
+      id: 'prompt-loop-scan',
+      command: '/loop-scan',
+      args: '--scope src',
+    });
+  });
+
+  it('matches case-insensitively', () => {
+    const resolved = resolveWorkflowCommandInput([workflowSuggestion()], '/Loop-Scan');
+    expect(resolved?.command).toBe('/loop-scan');
+  });
+
+  it('ignores suggestions that lack workflowPromptId / workflowPromptFolder', () => {
+    const plainSuggestion = workflowSuggestion({
+      workflowPromptId: undefined,
+      workflowPromptFolder: undefined,
+    });
+    expect(resolveWorkflowCommandInput([plainSuggestion], '/loop-scan')).toBeNull();
+  });
+});
+
+describe('expandWorkflowCommand', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('loads prompt content via readWorkflowPrompt and formats an injectable body with args', async () => {
+    hoisted.readWorkflowPrompt.mockResolvedValue({
+      prompt: {
+        id: 'prompt-loop-scan',
+        label: 'Loop Scan',
+        filename: 'loop-scan.md',
+        path: '/workspace/.claude/commands/loop-scan.md',
+        folder: '/workspace/.claude/commands',
+        sizeBytes: 1234,
+        updatedAt: '2026-06-13T00:00:00.000Z',
+        source: 'claude-command',
+        commandName: '/loop-scan',
+        description: 'Run loop scan',
+        category: 'loop',
+        safety: 'read-only',
+        builtin: true,
+        order: 5,
+      },
+      content: 'You are a loop scan agent. Inspect the repo.',
+    });
+
+    const expanded = await expandWorkflowCommand({
+      folder: '/workspace/.claude/commands',
+      id: 'prompt-loop-scan',
+      command: '/loop-scan',
+      args: '--scope src',
+    });
+
+    expect(hoisted.readWorkflowPrompt).toHaveBeenCalledWith(
+      '/workspace/.claude/commands',
+      'prompt-loop-scan'
+    );
+    // The raw command name must NOT be the body — the full prompt content is injected,
+    // with args appended. This is the exact behavior that was missing before.
+    expect(expanded.text).toBe(
+      'You are a loop scan agent. Inspect the repo.\n\nUser arguments:\n--scope src'
+    );
+    expect(expanded.summary).toBe('Loop Scan');
+    expect(expanded.slashCommand).toEqual({
+      name: 'loop-scan',
+      command: '/loop-scan',
+      args: '--scope src',
+      knownDescription: 'Run loop scan',
+    });
+  });
+
+  it('falls back to the resolved command name when the prompt has no commandName', async () => {
+    hoisted.readWorkflowPrompt.mockResolvedValue({
+      prompt: {
+        id: 'prompt-doctor',
+        label: 'Doctor',
+        filename: 'doctor.md',
+        path: '/workspace/.claude/commands/doctor.md',
+        folder: '/workspace/.claude/commands',
+        sizeBytes: 10,
+        updatedAt: '2026-06-13T00:00:00.000Z',
+      },
+      content: 'Run diagnostics.',
+    });
+
+    const expanded = await expandWorkflowCommand({
+      folder: '/workspace/.claude/commands',
+      id: 'prompt-doctor',
+      command: '/doctor',
+    });
+
+    expect(expanded.slashCommand.command).toBe('/doctor');
+    expect(expanded.slashCommand.name).toBe('doctor');
+    expect(expanded.slashCommand.knownDescription).toBe('Doctor');
+  });
+
+  it('propagates read failures so the caller can surface them', async () => {
+    hoisted.readWorkflowPrompt.mockRejectedValue(new Error('prompt not found'));
+
+    await expect(
+      expandWorkflowCommand({
+        folder: '/workspace/.claude/commands',
+        id: 'prompt-missing',
+        command: '/missing',
+      })
+    ).rejects.toThrow('prompt not found');
+  });
+});