Accounting Queue Priority & Fast-Path Processing

UI click "Recreate"
  → Server action
  → Temporal recreateAccountingImpactViaQueueWorkflow
  → prepareAndEnqueueAccountingRecreationActivity
      (soft-delete GL entries, bump accounting_ready_version)
  → batchEnqueueAccountingJobs
      → INSERT into accounting_work_queue (ready_at = now)

Separately, singleton poller (syncAccountingQueueWorkflow):
  → fetchAccountingJobsActivity
      SELECT ... ORDER BY ready_at ASC LIMIT 100 FOR UPDATE SKIP LOCKED
  → batchProcessAccountingJobsActivity
      (process 6 jobs concurrently)
  → poll again immediately if work exists, else sleep 10s

model accounting_work_queue {
  // ... existing fields ...
  priority   Int  @default(1)  // 1 = normal, 2 = high (user-triggered)

  @@index([state, priority, ready_at])  // replaces @@index([state, ready_at])
  @@index([org_id])
}

-- Before
ORDER BY ready_at ASC

-- After
ORDER BY priority DESC, ready_at ASC

Large batch (> 10 docs):           Small batch (≤ 10 docs):
  Prepare (delete GL, bump ver)      Prepare (delete GL, bump ver)
    ↓                                  ↓
  Enqueue with priority=high         processAccountingImpactDirectActivity
    ↓                                  ↓  runs on recreate worker directly
  Wait for singleton poller          Done in seconds
    ↓
  Process (may still wait for
  other high-priority jobs)

// packages/temporal-workflows/src/activities/accounting/process-accounting-impact-direct-activity.ts

export async function processAccountingImpactDirectActivity({
  jobs,               // { orgId, documentId, versionHint, documentType }[]
  concurrencyLimit,
}: ProcessAccountingImpactDirectParams): Promise<ProcessAccountingImpactDirectResult> {
  // Same pre-resolution of system actors and status IDs as batchProcessAccountingJobsActivity
  // Same per-job transaction logic (version check, createAccountingImpact, status update)
  // Difference: no queue row to lease/delete — jobs are passed directly as params
}

// In recreateAccountingImpactViaQueueWorkflow:

const DIRECT_PROCESSING_THRESHOLD = 10;

const result = await prepareAndEnqueueActivity({ ... });

if (result.jobsEnqueued <= DIRECT_PROCESSING_THRESHOLD) {
  // Fast path: process directly on this worker
  await processAccountingImpactDirectActivity({
    jobs: result.jobs,  // prepareAndEnqueue returns prepared job descriptors
    concurrencyLimit: 6,
  });
} else {
  // Queue path: high-priority enqueue, processed by singleton poller
  // (prepareAndEnqueue already enqueued with priority=high)
}