@monotykamary/pi-supervisor 0.5.9

package/tests/ephemeral-supervision.test.ts

@@ -0,0 +1,347 @@
+import { describe, expect, it, vi, beforeEach } from 'vitest';
+import { SupervisorStateManager } from '../src/state/manager.js';
+
+// Mock dependencies
+vi.mock('../src/core/analyzer.js', () => ({
+  analyze: vi.fn(),
+}));
+
+vi.mock('../src/core/inference.js', () => ({
+  inferOutcome: vi.fn(),
+}));
+
+vi.mock('../src/core/prompt-loader.js', () => ({
+  loadSystemPrompt: vi.fn().mockReturnValue({ prompt: 'test prompt', source: 'built-in' }),
+}));
+
+vi.mock('../src/ui/renderer.js', () => ({
+  updateUI: vi.fn(),
+  toggleWidget: vi.fn(),
+}));
+
+vi.mock('../src/ui/model-picker.js', () => ({
+  pickModel: vi.fn(),
+}));
+
+vi.mock('../src/global-config.js', () => ({
+  loadGlobalModel: vi.fn().mockReturnValue(null),
+  saveGlobalModel: vi.fn(),
+}));
+
+vi.mock('../src/session/client.js', () => ({
+  disposeSession: vi.fn(),
+}));
+
+vi.mock('../src/subagent-detector.js', () => ({
+  checkChildPiProcesses: vi.fn().mockResolvedValue({ hasActiveSubagents: false, count: 0 }),
+  waitForSubagents: vi
+    .fn()
+    .mockResolvedValue({ completed: true, finalStatus: { hasActiveSubagents: false, count: 0 } }),
+}));
+
+import { updateUI } from '../src/ui/renderer.js';
+import { disposeSession } from '../src/session/client.js';
+
+function createMockApi() {
+  return {
+    appendEntry: vi.fn(),
+    on: vi.fn(),
+    registerCommand: vi.fn(),
+    registerTool: vi.fn(),
+    sendUserMessage: vi.fn(),
+    sendMessage: vi.fn(),
+    events: { emit: vi.fn(), on: vi.fn() },
+  } as any;
+}
+
+function createMockContext(entries: any[] = [], isIdle = true) {
+  return {
+    ui: {
+      notify: vi.fn(),
+      setStatus: vi.fn(),
+      setWidget: vi.fn(),
+      setWorkingMessage: vi.fn(),
+    },
+    hasUI: true,
+    cwd: '/test',
+    sessionManager: {
+      getBranch: vi.fn().mockReturnValue(entries),
+    },
+    modelRegistry: {},
+    model: undefined,
+    isIdle: vi.fn().mockReturnValue(isIdle),
+    abort: vi.fn(),
+    hasPendingMessages: vi.fn().mockReturnValue(false),
+    shutdown: vi.fn(),
+    getContextUsage: vi.fn(),
+    compact: vi.fn(),
+    getSystemPrompt: vi.fn().mockReturnValue('test'),
+  } as any;
+}
+
+function makeSupervisionData(overrides: Record<string, any> = {}) {
+  return {
+    active: true,
+    outcome: 'Test goal',
+    provider: 'anthropic',
+    modelId: 'claude-haiku',
+    interventions: [],
+    startedAt: Date.now(),
+    reframeTier: 0,
+    ...overrides,
+  };
+}
+
+describe('Ephemeral Supervision - idle agent clears supervision', () => {
+  let api: ReturnType<typeof createMockApi>;
+  let state: SupervisorStateManager;
+
+  beforeEach(() => {
+    api = createMockApi();
+    state = new SupervisorStateManager(api);
+    vi.clearAllMocks();
+  });
+
+  function startActiveSupervision() {
+    state.start('Test goal', 'anthropic', 'claude-haiku');
+    expect(state.isActive()).toBe(true);
+  }
+
+  function createSessionWithSupervision(overrides: Record<string, any> = {}) {
+    return [
+      { type: 'message', message: { role: 'user', content: 'Hello' } },
+      {
+        type: 'custom',
+        customType: 'supervisor-state',
+        data: makeSupervisionData(overrides),
+      },
+    ];
+  }
+
+  describe('session_start (crash resume)', () => {
+    it('clears supervision when agent is idle', () => {
+      startActiveSupervision();
+
+      const entries = createSessionWithSupervision();
+      const ctx = createMockContext(entries, true);
+
+      state.loadFromSession(ctx);
+
+      if (state.isActive() && ctx.isIdle()) {
+        state.stop();
+        disposeSession();
+      }
+
+      expect(state.isActive()).toBe(false);
+    });
+
+    it('keeps supervision when agent is working', () => {
+      startActiveSupervision();
+
+      const entries = createSessionWithSupervision();
+      const ctx = createMockContext(entries, false);
+
+      state.loadFromSession(ctx);
+
+      expect(state.isActive()).toBe(true);
+    });
+  });
+
+  describe('session_start with resume reason (resume another session)', () => {
+    it('clears supervision when agent is idle', () => {
+      startActiveSupervision();
+
+      const entries = createSessionWithSupervision();
+      const ctx = createMockContext(entries, true);
+
+      state.loadFromSession(ctx);
+
+      if (state.isActive() && ctx.isIdle()) {
+        state.stop();
+        disposeSession();
+      }
+
+      expect(state.isActive()).toBe(false);
+    });
+
+    it('keeps supervision when agent is working', () => {
+      startActiveSupervision();
+
+      const entries = createSessionWithSupervision();
+      const ctx = createMockContext(entries, false);
+
+      state.loadFromSession(ctx);
+
+      expect(state.isActive()).toBe(true);
+    });
+  });
+
+  describe('session_tree (navigate history)', () => {
+    it('clears supervision when navigating to history while idle', () => {
+      startActiveSupervision();
+
+      const entries = createSessionWithSupervision();
+      const ctx = createMockContext(entries, true);
+
+      state.loadFromSession(ctx);
+
+      if (state.isActive() && ctx.isIdle()) {
+        state.stop();
+        disposeSession();
+      }
+
+      expect(state.isActive()).toBe(false);
+    });
+
+    it('keeps supervision when at current head with working agent', () => {
+      startActiveSupervision();
+
+      const entries = createSessionWithSupervision();
+      const ctx = createMockContext(entries, false);
+
+      state.loadFromSession(ctx);
+
+      expect(state.isActive()).toBe(true);
+    });
+  });
+
+  describe('session_start with fork reason (fork session)', () => {
+    it('clears supervision when agent is idle', () => {
+      startActiveSupervision();
+
+      const entries = createSessionWithSupervision();
+      const ctx = createMockContext(entries, true);
+
+      state.loadFromSession(ctx);
+
+      if (state.isActive() && ctx.isIdle()) {
+        state.stop();
+        disposeSession();
+      }
+
+      expect(state.isActive()).toBe(false);
+    });
+
+    it('keeps supervision when agent is working', () => {
+      startActiveSupervision();
+
+      const entries = createSessionWithSupervision();
+      const ctx = createMockContext(entries, false);
+
+      state.loadFromSession(ctx);
+
+      expect(state.isActive()).toBe(true);
+    });
+  });
+});
+
+describe('Ephemeral Supervision - compaction behavior', () => {
+  let api: ReturnType<typeof createMockApi>;
+  let state: SupervisorStateManager;
+
+  beforeEach(() => {
+    api = createMockApi();
+    state = new SupervisorStateManager(api);
+    vi.clearAllMocks();
+  });
+
+  function createSessionWithSupervision(overrides: Record<string, any> = {}) {
+    return [
+      { type: 'compaction', summary: 'Earlier conversation' },
+      { type: 'message', message: { role: 'user', content: 'Continue' } },
+      {
+        type: 'custom',
+        customType: 'supervisor-state',
+        data: makeSupervisionData(overrides),
+      },
+    ];
+  }
+
+  it('continues supervision when agent is working after compaction (long-horizon sessions)', () => {
+    state.start('Test goal', 'anthropic', 'claude-haiku');
+    expect(state.isActive()).toBe(true);
+
+    const entries = createSessionWithSupervision({ reframeTier: 1 });
+    const ctx = createMockContext(entries, false);
+
+    state.loadFromSession(ctx);
+
+    expect(state.isActive()).toBe(true);
+    expect(state.getReframeTier()).toBe(1);
+  });
+
+  it('clears supervision when agent is idle after compaction', () => {
+    state.start('Test goal', 'anthropic', 'claude-haiku');
+    expect(state.isActive()).toBe(true);
+
+    const entries = createSessionWithSupervision();
+    const ctx = createMockContext(entries, true);
+
+    state.loadFromSession(ctx);
+
+    if (state.isActive() && ctx.isIdle()) {
+      state.stop();
+      disposeSession();
+    }
+
+    expect(state.isActive()).toBe(false);
+  });
+});
+
+describe('Ephemeral Supervision - UI notifications', () => {
+  let api: ReturnType<typeof createMockApi>;
+  let state: SupervisorStateManager;
+
+  beforeEach(() => {
+    api = createMockApi();
+    state = new SupervisorStateManager(api);
+    vi.clearAllMocks();
+  });
+
+  function createSessionWithSupervision(overrides: Record<string, any> = {}) {
+    return [
+      {
+        type: 'custom',
+        customType: 'supervisor-state',
+        data: makeSupervisionData(overrides),
+      },
+    ];
+  }
+
+  it('notifies user when supervision is cleared on idle session load', () => {
+    const entries = createSessionWithSupervision();
+    const notify = vi.fn();
+    const ctx = {
+      ...createMockContext(entries, true),
+      ui: { ...createMockContext().ui, notify },
+    };
+
+    state.loadFromSession(ctx);
+
+    if (state.isActive() && ctx.isIdle()) {
+      notify('Supervision cleared: agent is idle', 'info');
+    }
+
+    expect(notify).toHaveBeenCalledWith('Supervision cleared: agent is idle', 'info');
+  });
+
+  it('notifies user when supervision is cleared after compaction', () => {
+    const entries = createSessionWithSupervision();
+    const notify = vi.fn();
+    const ctx = {
+      ...createMockContext(entries, true),
+      ui: { ...createMockContext().ui, notify },
+    };
+
+    state.loadFromSession(ctx);
+
+    if (state.isActive() && ctx.isIdle()) {
+      notify('Supervision cleared: compaction complete, agent idle', 'info');
+    }
+
+    expect(notify).toHaveBeenCalledWith(
+      'Supervision cleared: compaction complete, agent idle',
+      'info'
+    );
+  });
+});

package/tests/fabric-provider.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, it, vi } from 'vitest';
+import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent';
+import { registerFabricProvider } from '../src/fabric-provider.js';
+
+const createApi = () => {
+  const listeners = new Map<string, (value: unknown) => void>();
+  const emit = vi.fn();
+  const api = {
+    events: {
+      emit,
+      on: vi.fn((name: string, handler: (value: unknown) => void) => {
+        listeners.set(name, handler);
+      }),
+    },
+  } as any as ExtensionAPI;
+  return { api, emit, listeners };
+};
+
+describe('pi-fabric supervisor provider', () => {
+  it('registers eagerly and through discovery', async () => {
+    const { api, emit, listeners } = createApi();
+    const state = {
+      active: true,
+      outcome: 'Ship the feature',
+      provider: 'test',
+      modelId: 'model',
+      interventions: [],
+      startedAt: 1,
+    };
+    const start = vi.fn(async () => 'started');
+    registerFabricProvider(api, { start, getState: () => state });
+
+    expect(emit).toHaveBeenCalledWith(
+      'pi-fabric:provider:register:v1',
+      expect.objectContaining({ version: 1, overwrite: true })
+    );
+    const registration = emit.mock.calls[0][1];
+    const provider = registration.provider;
+    expect((await provider.describe('start')).risk).toBe('agent');
+    expect(await provider.invoke('status', {}, {})).toBe(state);
+
+    const context = {} as ExtensionContext;
+    await expect(
+      provider.invoke('start', { outcome: 'Goal' }, { extensionContext: context })
+    ).resolves.toEqual({
+      message: 'started',
+      state,
+    });
+    expect(start).toHaveBeenCalledWith('Goal', context);
+
+    const register = vi.fn();
+    listeners.get('pi-fabric:provider:discover:v1')?.({ version: 1, register });
+    expect(register).toHaveBeenCalledWith(provider, { overwrite: true });
+  });
+});

package/tests/full-fidelity-snapshot.test.ts

@@ -0,0 +1,250 @@
+import { describe, expect, it } from 'vitest';
+import { normalize } from '../src/compaction/normalize.js';
+import { filterNoise } from '../src/compaction/filter-noise.js';
+import { buildCompactionSummary, formatForSupervisor } from '../src/compaction/index.js';
+import type { NormalizedBlock } from '../src/compaction/types.js';
+
+describe('Compaction Pipeline', () => {
+  describe('normalize', () => {
+    it('normalizes user messages', () => {
+      const messages = [{ role: 'user' as const, content: 'Hello world' }];
+      const blocks = normalize(messages);
+      expect(blocks).toHaveLength(1);
+      expect(blocks[0].kind).toBe('user');
+      expect(blocks[0]).toHaveProperty('text', 'Hello world');
+    });
+
+    it('normalizes assistant text content', () => {
+      const messages = [
+        {
+          role: 'assistant' as const,
+          content: [{ type: 'text' as const, text: 'Working on it' }],
+        },
+      ];
+      const blocks = normalize(messages);
+      expect(blocks).toHaveLength(1);
+      expect(blocks[0].kind).toBe('assistant');
+    });
+
+    it('normalizes tool calls from assistant content', () => {
+      const messages = [
+        {
+          role: 'assistant' as const,
+          content: [
+            {
+              type: 'toolCall' as const,
+              name: 'bash',
+              id: 'call_1',
+              arguments: { command: 'ls' },
+            },
+          ],
+        },
+      ];
+      const blocks = normalize(messages);
+      const toolCall = blocks.find((b) => b.kind === 'tool_call');
+      expect(toolCall).toBeDefined();
+      if (toolCall && toolCall.kind === 'tool_call') {
+        expect(toolCall.name).toBe('bash');
+        expect(toolCall.args).toEqual({ command: 'ls' });
+      }
+    });
+
+    it('normalizes tool results', () => {
+      const messages = [
+        {
+          role: 'toolResult' as const,
+          toolName: 'bash',
+          isError: false,
+          content: 'file1.txt\nfile2.txt',
+        },
+      ];
+      const blocks = normalize(messages);
+      expect(blocks).toHaveLength(1);
+      expect(blocks[0].kind).toBe('tool_result');
+      if (blocks[0].kind === 'tool_result') {
+        expect(blocks[0].name).toBe('bash');
+        expect(blocks[0].isError).toBe(false);
+      }
+    });
+
+    it('normalizes bashExecution messages', () => {
+      const messages = [
+        {
+          role: 'bashExecution' as any,
+          command: 'npm test',
+          output: '1 test passed',
+          exitCode: 0,
+        },
+      ];
+      const blocks = normalize(messages);
+      expect(blocks).toHaveLength(1);
+      expect(blocks[0].kind).toBe('bash');
+      if (blocks[0].kind === 'bash') {
+        expect(blocks[0].command).toBe('npm test');
+        expect(blocks[0].exitCode).toBe(0);
+      }
+    });
+
+    it('strips thinking blocks from assistant content', () => {
+      const messages = [
+        {
+          role: 'assistant' as const,
+          content: [
+            { type: 'thinking' as const, thinking: 'Let me think...', redacted: false },
+            { type: 'text' as const, text: 'Here is my answer' },
+          ],
+        },
+      ];
+      const blocks = normalize(messages);
+      const thinking = blocks.find((b) => b.kind === 'thinking');
+      const text = blocks.find((b) => b.kind === 'assistant');
+      expect(thinking).toBeDefined();
+      expect(text).toBeDefined();
+    });
+  });
+
+  describe('filterNoise', () => {
+    it('removes thinking blocks', () => {
+      const blocks: NormalizedBlock[] = [
+        { kind: 'thinking', text: 'Internal reasoning', redacted: false },
+        { kind: 'user', text: 'Hello' },
+      ];
+      const filtered = filterNoise(blocks);
+      expect(filtered).toHaveLength(1);
+      expect(filtered[0].kind).toBe('user');
+    });
+
+    it('removes noise tool calls (TodoWrite, etc.)', () => {
+      const blocks: NormalizedBlock[] = [
+        { kind: 'tool_call', name: 'TodoWrite', args: {} },
+        { kind: 'tool_call', name: 'bash', args: { command: 'ls' } },
+      ];
+      const filtered = filterNoise(blocks);
+      expect(filtered).toHaveLength(1);
+      if (filtered[0].kind === 'tool_call') {
+        expect(filtered[0].name).toBe('bash');
+      }
+    });
+
+    it('removes XML wrapper noise from user messages', () => {
+      const blocks: NormalizedBlock[] = [
+        { kind: 'user', text: '<system-reminder>Some directive</system-reminder>' },
+        { kind: 'user', text: 'Real user message' },
+      ];
+      const filtered = filterNoise(blocks);
+      expect(filtered).toHaveLength(1);
+      if (filtered[0].kind === 'user') {
+        expect(filtered[0].text).toBe('Real user message');
+      }
+    });
+  });
+
+  describe('buildCompactionSummary', () => {
+    it('produces structured sections from messages', () => {
+      const messages = [
+        { role: 'user' as const, content: 'Implement JWT auth' },
+        {
+          role: 'assistant' as const,
+          content: [{ type: 'text' as const, text: 'I will implement JWT auth now' }],
+        },
+      ];
+      const summary = buildCompactionSummary(messages);
+
+      expect(summary.sessionGoal).toBeDefined();
+      expect(summary.briefTranscript).toBeDefined();
+      expect(summary.outstandingContext).toBeDefined();
+      expect(summary.transcriptEntries).toBeDefined();
+      expect(summary.filesAndChanges).toBeDefined();
+    });
+
+    it('extracts goals from user messages', () => {
+      const messages = [
+        {
+          role: 'user' as const,
+          content: 'Please implement JWT authentication with refresh tokens',
+        },
+      ];
+      const summary = buildCompactionSummary(messages);
+
+      expect(summary.sessionGoal.length).toBeGreaterThan(0);
+    });
+
+    it('captures tool errors in outstanding context', () => {
+      const messages = [
+        { role: 'user' as const, content: 'Fix the build' },
+        {
+          role: 'assistant' as const,
+          content: [
+            {
+              type: 'toolCall' as const,
+              name: 'bash',
+              id: '1',
+              arguments: { command: 'npm run build' },
+            },
+          ],
+        },
+        {
+          role: 'toolResult' as const,
+          toolName: 'bash',
+          isError: true,
+          content: 'error TS2304: Cannot find name "auth"',
+        },
+      ];
+      const summary = buildCompactionSummary(messages);
+
+      // Should pick up the error in outstanding context
+      expect(summary.outstandingContext.length).toBeGreaterThan(0);
+    });
+
+    it('produces a brief transcript', () => {
+      const messages = [
+        { role: 'user' as const, content: 'Hello' },
+        {
+          role: 'assistant' as const,
+          content: [{ type: 'text' as const, text: 'Hi there' }],
+        },
+      ];
+      const summary = buildCompactionSummary(messages);
+
+      expect(summary.briefTranscript).toContain('[user]');
+      expect(summary.briefTranscript).toContain('[assistant]');
+    });
+
+    it('handles empty messages gracefully', () => {
+      const summary = buildCompactionSummary([]);
+      expect(summary.sessionGoal).toEqual([]);
+      expect(summary.briefTranscript).toBe('');
+    });
+  });
+
+  describe('formatForSupervisor', () => {
+    it('formats sections as text', () => {
+      const messages = [{ role: 'user' as const, content: 'Implement auth' }];
+      const summary = buildCompactionSummary(messages);
+      const text = formatForSupervisor(summary);
+
+      expect(text.length).toBeGreaterThan(0);
+    });
+
+    it('includes relevant sections for steering decisions', () => {
+      const messages = [
+        { role: 'user' as const, content: 'Implement JWT auth with tests' },
+        {
+          role: 'assistant' as const,
+          content: [{ type: 'text' as const, text: 'Working on it' }],
+        },
+      ];
+      const summary = buildCompactionSummary(messages);
+      const text = formatForSupervisor(summary);
+
+      // Should contain at least some structured sections
+      expect(text).toMatch(/\[.+\]/);
+    });
+
+    it('returns empty string when no data', () => {
+      const summary = buildCompactionSummary([]);
+      const text = formatForSupervisor(summary);
+      expect(text).toBe('');
+    });
+  });
+});