Reconciler

new Reconciler(
  config: OrchestratorConfig,
  reconcilerConfig: ReconcilerConfig,
  taskQueue: TaskQueue,
  mergeQueue: MergeQueue,
  monitor: Monitor,
  systemPrompt: string,
  deps?: Partial<ReconcilerDeps>
)

interface ReconcilerConfig {
  intervalMs: number      // Sweep interval (default: 300_000 = 5 min)
  maxFixTasks: number     // Max fix tasks per sweep (default: 5)
}

const DEFAULT_RECONCILER_CONFIG: ReconcilerConfig = {
  intervalMs: 300_000,
  maxFixTasks: 5
}

start(): void

stop(): void

async sweep(): Promise<SweepResult>

interface SweepResult {
  buildOk: boolean           // tsc --noEmit passed
  testsOk: boolean           // npm test passed
  hasConflictMarkers: boolean  // <<<<<<< markers detected
  buildOutput: string        // Build error output (truncated to 8000 chars)
  testOutput: string         // Test error output (truncated to 8000 chars)
  conflictFiles: string[]    // Files with conflict markers
  fixTasks: Task[]           // Generated fix tasks
}

const tscResult = await runCommand('npx', ['tsc', '--noEmit'], repoPath)
const buildOutput = tscResult.stdout + tscResult.stderr
const buildNotConfigured = /no inputs were found|could not find a valid tsconfig/i.test(buildOutput)
const buildOk = buildNotConfigured || (tscResult.code === 0 && !tscResult.stderr?.includes('error TS'))

const testResult = await runCommand('npm', ['test'], repoPath)
const testOutput = testResult.stdout + testResult.stderr
const testNotConfigured = /Missing script|no test specified/i.test(testOutput)
const testsOk = testNotConfigured || (testResult.code === 0 && !testResult.stderr?.includes('FAIL'))

const conflictResult = await runCommand(
  'git',
  ['grep', '-rl', '<<<<<<<', '--', '*.ts', '*.tsx', '*.js', '*.json'],
  repoPath
)
const conflictFiles = conflictResult.stdout.trim().split('\n').filter(Boolean)
const hasConflictMarkers = conflictFiles.length > 0

private consecutiveGreenSweeps: number = 0
private currentIntervalMs: number
private readonly minIntervalMs: number  // 60 seconds
private readonly maxIntervalMs: number  // 300 seconds (5 min)

if (buildOk && testsOk && !hasConflictMarkers) {
  this.consecutiveGreenSweeps++
  
  if (this.consecutiveGreenSweeps >= 3) {
    this.adjustInterval(this.maxIntervalMs)  // Slow down to 5 min
  }
} else {
  this.consecutiveGreenSweeps = 0
  this.adjustInterval(this.minIntervalMs)    // Speed up to 1 min
}

const messages: LLMMessage[] = [
  { role: 'system', content: systemPrompt },
  { role: 'user', content: userMessage }
]

## Merge Conflict Markers Found
Files with unresolved conflict markers:
- src/auth/login.ts
- src/api/users.ts

## Build Output (tsc --noEmit)
```typescript
src/auth/login.ts:15:3 - error TS2322: Type 'string' is not assignable to type 'number'

## Test Output (npm test)

4. **Recent Commits**:

5. **Pending Fix Scopes** (deduplication):

### Task Parsing

```typescript
const rawTasks = parseLLMTaskArray(response.content)
const capped = rawTasks.slice(0, reconcilerConfig.maxFixTasks)  // Limit to 5

for (const raw of capped) {
  const scope = raw.scope || []
  
  // Skip if all scope files already covered by pending fixes
  const allScopesCovered = scope.every(f => this.recentFixScopes.has(f))
  if (allScopesCovered) {
    continue
  }
  
  // Create fix task
  const fixTask: Task = {
    id: `fix-${fixCounter}`,
    description: raw.description,
    scope,
    acceptance: raw.acceptance || 'tsc --noEmit returns 0 and npm test returns 0',
    priority: 1,  // Fix tasks get highest priority
    ...
  }
  
  // Track scope to prevent duplicates
  for (const f of scope) {
    this.recentFixScopes.add(f)
  }
}

const mergeCountBefore = this.mergeQueue.getMergeStats().totalMerged
// ... run build, test, conflict checks ...
const mergeCountAfter = this.mergeQueue.getMergeStats().totalMerged

if (mergeCountAfter > mergeCountBefore) {
  logger.info('Merges occurred during sweep — discarding stale results')
  return { buildOk, testsOk, hasConflictMarkers, fixTasks: [] }
}

onSweepComplete(callback: (result: SweepResult) => void): void

onError(callback: (error: Error) => void): void

import { Reconciler, DEFAULT_RECONCILER_CONFIG } from '@longshot/orchestrator'

const reconciler = new Reconciler(
  config,
  DEFAULT_RECONCILER_CONFIG,
  taskQueue,
  mergeQueue,
  monitor,
  reconcilerPrompt
)

// Register callbacks
reconciler.onSweepComplete((result) => {
  console.log(`Sweep: build=${result.buildOk} tests=${result.testsOk}`)
  
  if (result.fixTasks.length > 0) {
    console.log(`Created ${result.fixTasks.length} fix tasks`)
    for (const task of result.fixTasks) {
      planner.injectTask(task)  // Inject into planning loop
    }
  }
})

reconciler.onError((error) => {
  console.error(`Reconciler error: ${error.message}`)
})

// Start periodic sweeps
reconciler.start()

// Manual sweep (e.g., during finalization)
const result = await reconciler.sweep()

// Stop periodic sweeps
reconciler.stop()

interface ReconcilerDeps {
  runCommand: ReconcilerRunCommand
  completeLLM: ReconcilerCompleteLLM
  now: () => number
}

type ReconcilerRunCommand = (
  cmd: string,
  args: string[],
  cwd: string
) => Promise<ExecResult>

type ReconcilerCompleteLLM = (
  messages: LLMMessage[],
  overrides?: Partial<LLMClientConfig>,
  parentSpan?: Span
) => Promise<LLMResponse>

try {
  const response = await this.completeLLM(messages)
  rawTasks = parseLLMTaskArray(response.content)
} catch (llmError) {
  logger.warn('LLM unreachable — skipping fix task generation (will retry next sweep)')
  return { buildOk, testsOk, hasConflictMarkers, fixTasks: [] }
}