macro-agent 0.2.5 → 0.2.6

package/src/workspace/merge-queue/__tests__/resolver-flow.test.ts

@@ -1,472 +0,0 @@
-/**
- * Resolver Flow Tests
- *
- * Tests for the conflict resolution flow defined in s-bcqm:
- * - Conflict detected → spawn resolver worker
- * - Resolver works on resolver/<id>@<ts> branch
- * - Resolver completes → notifies integrator (NOT through queue)
- * - Integrator merges resolver branch inline
- *
- * IMPORTANT: These tests document the EXPECTED behavior per spec.
- * Many will fail until the resolver flow is implemented.
- *
- * @see s-bcqm Change Management spec - Conflict Resolution (Option C)
- * @see s-1zcx Testing Strategy spec
- */
-
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import Database from 'better-sqlite3';
-import {
-  MergeQueue,
-  createMergeQueue,
-} from '../merge-queue.js';
-import type { MergeQueueEvent } from '../types.js';
-
-describe('Resolver Flow', () => {
-  let db: Database.Database;
-  let queue: MergeQueue;
-
-  beforeEach(() => {
-    db = new Database(':memory:');
-    queue = createMergeQueue({ db });
-  });
-
-  afterEach(() => {
-    queue.close();
-    db.close();
-  });
-
-  // ===========================================================================
-  // Current Behavior (Documenting Gaps)
-  // ===========================================================================
-
-  describe('current behavior (incomplete implementation)', () => {
-    it('marks conflict with files but does NOT spawn resolver', () => {
-      // Per spec s-bcqm: when conflict detected, integrator should spawn resolver
-      // Current behavior: just marks conflict, no resolver spawning
-
-      const mrId = queue.submit({
-        streamId: 'stream-1',
-        taskId: 'task-1',
-        workerBranch: 'worker/agent-1/task-1@123',
-        workerAgentId: 'agent-1',
-      });
-
-      queue.markProcessing(mrId);
-
-      // Simulate conflict detected - but no resolver spawned
-      const conflictFiles = ['src/index.ts', 'src/utils.ts'];
-      queue.markConflict(mrId, conflictFiles);
-
-      const mr = queue.get(mrId);
-      expect(mr!.status).toBe('conflict');
-      expect(mr!.conflictFiles).toEqual(conflictFiles);
-
-      // GAP: resolverTaskId is NOT set because no resolver was spawned
-      expect(mr!.resolverTaskId).toBeNull();
-    });
-
-    it('emits conflict event but without resolver spawn trigger', () => {
-      const events: MergeQueueEvent[] = [];
-      queue.onEvent((event) => events.push(event));
-
-      const mrId = queue.submit({
-        streamId: 'stream-1',
-        taskId: 'task-1',
-        workerBranch: 'branch-1',
-        workerAgentId: 'agent-1',
-      });
-
-      queue.markProcessing(mrId);
-      queue.markConflict(mrId, ['file.ts']);
-
-      const conflictEvent = events.find((e) => e.type === 'mr:conflict');
-      expect(conflictEvent).toBeDefined();
-      expect(conflictEvent!.data.conflictFiles).toEqual(['file.ts']);
-
-      // GAP: Event doesn't trigger resolver spawn
-      // Expected: integrator handler listens to this and spawns resolver
-      expect(conflictEvent!.data.resolverTaskId).toBeUndefined();
-    });
-
-    it('allows marking conflict with resolver task ID but task not actually created', () => {
-      // Current behavior: you CAN pass resolverTaskId to markConflict
-      // but there's no code that actually creates the resolver task
-
-      const mrId = queue.submit({
-        streamId: 'stream-1',
-        taskId: 'task-1',
-        workerBranch: 'branch-1',
-        workerAgentId: 'agent-1',
-      });
-
-      queue.markProcessing(mrId);
-
-      // This is how it SHOULD work - but the calling code doesn't do this
-      queue.markConflict(mrId, ['file.ts'], 'resolver-task-123');
-
-      const mr = queue.get(mrId);
-      expect(mr!.resolverTaskId).toBe('resolver-task-123');
-
-      // GAP: resolver-task-123 doesn't exist anywhere
-      // No task backend, no agent spawned
-    });
-  });
-
-  // ===========================================================================
-  // Expected Behavior (What SHOULD happen per spec)
-  // ===========================================================================
-
-  describe('expected behavior per spec s-bcqm (NOT YET IMPLEMENTED)', () => {
-    /**
-     * Per s-bcqm "Conflict Resolution (Option C: Resolver Branch + Inline Merge)":
-     *
-     * When a merge conflict is detected:
-     * 1. Integrator calls markConflict() on MR
-     * 2. Integrator spawns resolver worker with:
-     *    - role: 'worker.resolver'
-     *    - branch: resolver/<mr-id>@<timestamp>
-     *    - baseBranch: integration branch
-     *    - task with conflict context
-     * 3. Resolver works on its branch, resolves conflicts
-     * 4. Resolver calls done() but does NOT submit to merge queue
-     * 5. Integrator receives RESOLVER_DONE signal
-     * 6. Integrator merges resolver branch inline (not through queue)
-     * 7. Integrator marks MR as merged
-     */
-
-    it('SPEC: conflict should trigger resolver spawn with own branch', () => {
-      // This test documents expected behavior
-      // When implemented, integrator handler should:
-      // 1. Detect conflict in attemptMerge result
-      // 2. Call spawnAgent({ role: 'worker.resolver', ... })
-      // 3. Store resolver ID for later
-
-      const mrId = queue.submit({
-        streamId: 'stream-1',
-        taskId: 'task-1',
-        workerBranch: 'worker/agent-1/task-1@123',
-        workerAgentId: 'agent-1',
-      });
-
-      queue.markProcessing(mrId);
-      queue.markConflict(mrId, ['src/index.ts']);
-
-      // EXPECTED (not implemented):
-      // - Resolver task should be created
-      // - Resolver agent should be spawned
-      // - MR should have resolverTaskId set
-
-      // SKIP: This would require integrating with AgentManager
-      // which is out of scope for unit tests
-    });
-
-    it('SPEC: resolver should work on resolver/<id>@<ts> branch format', () => {
-      // Per spec, resolver branch naming should be:
-      // resolver/<mr-id>@<timestamp>
-
-      const mrId = queue.submit({
-        streamId: 'stream-1',
-        taskId: 'task-1',
-        workerBranch: 'worker/agent-1/task-1@123',
-        workerAgentId: 'agent-1',
-      });
-
-      // Expected branch format for resolver
-      const timestamp = Date.now();
-      const expectedResolverBranch = `resolver/${mrId}@${timestamp}`;
-
-      // This documents the expected naming convention
-      expect(expectedResolverBranch).toMatch(/^resolver\/mr-[a-z0-9-]+@\d+$/);
-    });
-
-    it('SPEC: resolver completion should NOT go through merge queue', () => {
-      // Key design decision from spec:
-      // "Resolver completes → notifies Integrator (does NOT submit to queue)"
-      // This prevents "conflict on conflict resolution" loops
-
-      // Resolver would call done() but worker handler should NOT submit to queue
-      // because role is 'worker.resolver'
-
-      // This is a behavioral test that would require role checking
-    });
-
-    it('SPEC: integrator should merge resolver branch inline', () => {
-      // When resolver completes:
-      // 1. Integrator receives notification (signal or event)
-      // 2. Integrator fetches resolver branch
-      // 3. Integrator merges inline (git merge, not through queue)
-      // 4. Integrator marks original MR as merged
-
-      // This documents the inline merge flow
-    });
-  });
-
-  // ===========================================================================
-  // Nested Conflict Scenario (Spec: Escalation)
-  // ===========================================================================
-
-  describe('nested conflict (resolver also conflicts)', () => {
-    /**
-     * Per s-1zcx Testing Strategy:
-     * "Nested conflict: Resolver also conflicts, escalated to coordinator"
-     *
-     * If the resolver's merge ALSO conflicts, it should:
-     * 1. NOT spawn another resolver (infinite loop prevention)
-     * 2. Escalate to coordinator via signal
-     * 3. Coordinator decides next steps (manual intervention, different strategy)
-     */
-
-    it('SPEC: nested conflict should escalate to coordinator', () => {
-      // Scenario:
-      // 1. Worker A merge conflicts with integration branch
-      // 2. Resolver R spawned to fix conflict
-      // 3. During R's work, another worker B merges
-      // 4. R's resolution now ALSO conflicts with B's changes
-      // 5. R should escalate, not spawn nested resolver
-
-      // This test documents the expected escalation path
-      const mrId = queue.submit({
-        streamId: 'stream-1',
-        taskId: 'task-1',
-        workerBranch: 'worker/agent-1/task-1@123',
-        workerAgentId: 'agent-1',
-      });
-
-      queue.markProcessing(mrId);
-      queue.markConflict(mrId, ['file.ts'], 'resolver-task-1');
-
-      // Resolver tries to merge but also conflicts
-      // Expected: CONFLICT_UNRESOLVED signal to coordinator
-      // NOT: spawn another resolver
-    });
-
-    it('SPEC: should prevent infinite resolver spawning', () => {
-      // Safety check: system should detect resolver-of-resolver pattern
-      // and break the cycle by escalating
-
-      // Implementation would need to track:
-      // - Is this MR already being resolved?
-      // - Is the current worker a resolver?
-      // - Max resolver depth (1 level only)
-    });
-  });
-
-  // ===========================================================================
-  // MergeQueue API Support for Resolver Flow
-  // ===========================================================================
-
-  describe('MergeQueue API support for resolver flow', () => {
-    it('should support querying MRs in conflict state', () => {
-      // Submit multiple MRs
-      const mr1 = queue.submit({
-        streamId: 'stream-1',
-        taskId: 'task-1',
-        workerBranch: 'branch-1',
-        workerAgentId: 'agent-1',
-      });
-      const mr2 = queue.submit({
-        streamId: 'stream-1',
-        taskId: 'task-2',
-        workerBranch: 'branch-2',
-        workerAgentId: 'agent-2',
-      });
-
-      // Process and mark conflicts
-      queue.markProcessing(mr1);
-      queue.markConflict(mr1, ['file1.ts'], 'resolver-1');
-
-      queue.markProcessing(mr2);
-      queue.markConflict(mr2, ['file2.ts']); // No resolver yet
-
-      // Query conflicts
-      const conflicts = queue.getPending('stream-1', { status: 'conflict' });
-      expect(conflicts.length).toBe(2);
-
-      // Filter for those with resolvers
-      const withResolver = conflicts.filter((mr) => mr.resolverTaskId !== null);
-      expect(withResolver.length).toBe(1);
-
-      // Filter for those awaiting resolver
-      const awaitingResolver = conflicts.filter((mr) => mr.resolverTaskId === null);
-      expect(awaitingResolver.length).toBe(1);
-    });
-
-    it('should support updating MR when resolver completes via markResolverComplete', () => {
-      // Setup: MR in conflict with resolver
-      const mrId = queue.submit({
-        streamId: 'stream-1',
-        taskId: 'task-1',
-        workerBranch: 'branch-1',
-        workerAgentId: 'agent-1',
-      });
-
-      queue.markProcessing(mrId);
-      queue.markConflict(mrId, ['file.ts'], 'resolver-task-1');
-
-      // Verify conflict state
-      let mr = queue.get(mrId);
-      expect(mr!.status).toBe('conflict');
-      expect(mr!.resolverTaskId).toBe('resolver-task-1');
-
-      // Use markResolverComplete to transition conflict → merged
-      queue.markResolverComplete(mrId, 'resolved-commit-abc', 'resolver/mr-123@1700000000');
-
-      // Verify merged state
-      mr = queue.get(mrId);
-      expect(mr!.status).toBe('merged');
-      expect(mr!.mergeCommit).toBe('resolved-commit-abc');
-
-      // Direct markMerged still shouldn't work on conflict state
-      const mrId2 = queue.submit({
-        streamId: 'stream-1',
-        taskId: 'task-2',
-        workerBranch: 'branch-2',
-        workerAgentId: 'agent-2',
-      });
-      queue.markProcessing(mrId2);
-      queue.markConflict(mrId2, ['file2.ts']);
-      expect(() => queue.markMerged(mrId2, 'commit')).toThrow();
-    });
-
-    it('should reject markResolverComplete on non-conflict MRs', () => {
-      const mrId = queue.submit({
-        streamId: 'stream-1',
-        taskId: 'task-1',
-        workerBranch: 'branch-1',
-        workerAgentId: 'agent-1',
-      });
-
-      // pending state
-      expect(() => queue.markResolverComplete(mrId, 'commit')).toThrow(/must be 'conflict'/);
-
-      // processing state
-      queue.markProcessing(mrId);
-      expect(() => queue.markResolverComplete(mrId, 'commit')).toThrow(/must be 'conflict'/);
-
-      // merged state
-      queue.markMerged(mrId, 'merge-commit');
-      expect(() => queue.markResolverComplete(mrId, 'commit')).toThrow(/must be 'conflict'/);
-
-      // abandoned state
-      const mrId2 = queue.submit({
-        streamId: 'stream-1',
-        taskId: 'task-2',
-        workerBranch: 'branch-2',
-        workerAgentId: 'agent-2',
-      });
-      queue.markAbandoned(mrId2);
-      expect(() => queue.markResolverComplete(mrId2, 'commit')).toThrow(/must be 'conflict'/);
-    });
-
-    it('should track resolver lifecycle through events', () => {
-      const events: MergeQueueEvent[] = [];
-      queue.onEvent((event) => events.push(event));
-
-      const mrId = queue.submit({
-        streamId: 'stream-1',
-        taskId: 'task-1',
-        workerBranch: 'branch-1',
-        workerAgentId: 'agent-1',
-      });
-
-      queue.markProcessing(mrId);
-      queue.markConflict(mrId, ['file.ts'], 'resolver-task-1');
-
-      // Events before resolution
-      expect(events.map((e) => e.type)).toEqual([
-        'mr:submitted',
-        'mr:processing',
-        'mr:conflict',
-      ]);
-
-      // Complete the resolution
-      queue.markResolverComplete(mrId, 'resolved-commit', 'resolver/mr-123@1700000000');
-
-      // Full event lifecycle
-      expect(events.map((e) => e.type)).toEqual([
-        'mr:submitted',
-        'mr:processing',
-        'mr:conflict',
-        'mr:resolved',
-      ]);
-
-      // Verify resolved event data
-      const resolvedEvent = events.find((e) => e.type === 'mr:resolved');
-      expect(resolvedEvent).toBeDefined();
-      expect(resolvedEvent!.data.mrId).toBe(mrId);
-      expect(resolvedEvent!.data.mergeCommit).toBe('resolved-commit');
-      expect(resolvedEvent!.data.resolverTaskId).toBe('resolver-task-1');
-      expect(resolvedEvent!.data.resolverBranch).toBe('resolver/mr-123@1700000000');
-
-      // NOTE: mr:resolver_spawned would be emitted by integrator handler, not queue
-      // The queue only tracks the MR state transitions
-    });
-  });
-
-  // ===========================================================================
-  // Integration with Worker Handler (Role Check)
-  // ===========================================================================
-
-  describe('resolver role integration', () => {
-    it('documents resolver worker role behavior', () => {
-      // Per spec s-bcqm, resolver has role 'worker.resolver' which:
-      // 1. Extends 'worker' role
-      // 2. Has system prompt for conflict resolution
-      // 3. On done(): does NOT submit to merge queue
-
-      // This is enforced in worker handler, not merge queue
-      // Worker handler checks: if role is 'worker.resolver', skip queue submission
-    });
-
-    it('documents resolver branch naming convention', () => {
-      // Per spec, resolver branch format:
-      // resolver/<mr-id>@<timestamp>
-
-      // Worker for conflict resolution gets workspace config:
-      // {
-      //   baseBranch: integration branch,
-      //   branch: `resolver/${mrId}@${Date.now()}`
-      // }
-    });
-  });
-});
-
-// ===========================================================================
-// Summary of Missing Functionality
-// ===========================================================================
-
-/**
- * MISSING FUNCTIONALITY for Resolver Flow:
- *
- * 1. Integrator Handler (src/lifecycle/handlers/integrator.ts):
- *    - [ ] handleConflict() function that spawns resolver worker
- *    - [ ] pendingResolvers map to track MR → resolver association
- *    - [ ] onResolverDone() handler for resolver completion
- *    - [ ] Inline merge of resolver branch (not through queue)
- *
- * 2. Worker Handler (src/lifecycle/handlers/worker.ts):
- *    - [ ] Check for 'worker.resolver' role
- *    - [ ] Skip queue submission for resolver workers
- *    - [ ] Emit RESOLVER_DONE signal instead of MERGE_REQUEST
- *
- * 3. Role System (src/roles/):
- *    - [ ] Define 'worker.resolver' role extending 'worker'
- *    - [ ] Resolver-specific system prompt
- *    - [ ] Capability restrictions (no child spawning)
- *
- * 4. MergeQueue (src/workspace/merge-queue/):
- *    - [ ] API to transition conflict → merged after resolution
- *    - [ ] Events for resolver lifecycle
- *    - [ ] Query for conflicts awaiting resolution
- *
- * 5. AgentManager Integration:
- *    - [ ] spawnResolver() helper
- *    - [ ] Resolver workspace configuration
- *    - [ ] Branch naming: resolver/<mr-id>@<ts>
- *
- * 6. Nested Conflict Handling:
- *    - [ ] Detect resolver-of-resolver scenario
- *    - [ ] Escalation to coordinator via CONFLICT_UNRESOLVED signal
- *    - [ ] Max resolver depth enforcement
- */

package/src/workspace/merge-queue/index.ts

@@ -1,38 +0,0 @@
-/**
- * MergeQueue Module
- *
- * Provides merge queue functionality for coordinating parallel worker merges.
- *
- * @module workspace/merge-queue
- * @implements [[s-bcqm]] Merge Queue section
- */
-
-// Types
-export type {
-  MergeRequest,
-  MergeRequestStatus,
-  SubmitMergeRequestOptions,
-  ListMergeRequestsOptions,
-  MergeQueueInterface,
-  MergeQueueEvent,
-  MergeQueueEventType,
-  MergeQueueEventCallback,
-} from './types.js';
-
-// Schema
-export {
-  getMergeRequestsTableName,
-  getCreateTableSQL,
-  getCreateIndexesSQL,
-  initMergeQueueSchema,
-  mergeQueueTableExists,
-} from './schema.js';
-
-// Implementation
-export {
-  MergeQueue,
-  createMergeQueue,
-  MergeRequestNotFoundError,
-  MergeRequestStateError,
-  type MergeQueueConfig,
-} from './merge-queue.js';