# Ramificarea fluxurilor de lucru

Queuety poate ramifica un flux de lucru în execuție într-o copie complet independentă. Fluxul de lucru ramificat începe de la același pas și cu aceeași stare ca originalul, dar cele două fluxuri continuă independent din acel punct. Modificările unuia nu îl afectează pe celălalt.

## Ramificarea unui flux de lucru

### PHP API

Apelați `Queuety::fork_workflow()` cu ID-ul fluxului de lucru. Acesta returnează noul ID al fluxului de lucru:

```php
use Queuety\Queuety;

$forked_id = Queuety::fork_workflow( $workflow_id );
```

### CLI

```bash
wp queuety workflow fork <id>
```

| Opțiune | Descriere |
|---|---|
| `<id>` | ID-ul fluxului de lucru de bifurcat (obligatoriu) |

```bash
wp queuety workflow fork 42
# Success: Workflow #42 forked. New workflow ID: 43.
```

## Cum funcționează

Când ramificați un flux de lucru:

1. Rândul fluxului de lucru original este blocat și citit
2. Se inserează un rând nou pentru fluxul de lucru, cu aceeași stare, definiții ale pașilor și pas curent
3. Numele noului flux de lucru este `{original_name}_fork_{timestamp}`
4. Pasul curent este adăugat în coada fluxului de lucru ramificat
5. Se înregistrează un eveniment de jurnal `workflow_forked` atât în fluxul de lucru original, cât și în cel ramificat
6. Fluxul de lucru original continuă procesarea în mod normal

Fluxul de lucru ramificat este complet independent. Are propriul ID, propria copie a stării și propriile intrări în coada de sarcini. Din momentul ramificării, fiecare flux poate evolua separat.

## Cazuri de utilizare

### Testarea A/B a gestionarilor de pași

Ramificați un flux de lucru pentru a testa două implementări diferite ale unui pas viitor:

```php
// Original workflow will use the existing CallLLMHandler (GPT-4).
// Fork it to test with a different handler.
$forked_id = Queuety::fork_workflow( $workflow_id );

// Modify the forked workflow's state to use a different model.
// (Update the state via a custom step or direct DB update.)
```

### Analiză ipotetică

Ramificați un flux de lucru într-un punct de decizie pentru a explora ramuri diferite:

```php
// Workflow is at step 3, about to process data.
// Fork it so we can try two different processing strategies.
$fork_a = Queuety::fork_workflow( $workflow_id );
$fork_b = Queuety::fork_workflow( $workflow_id );
```

Fiecare ramură continuă cu aceeași stare de intrare, dar poate fi modificată pentru a urma o cale diferită.

### Experimentare paralelă

Când fluxul de lucru ajunge într-un punct în care doriți să încercați mai multe abordări în paralel, ramificați-l pentru fiecare abordare și comparați rezultatele după finalizarea tuturor ramurilor.

## Urmărirea ramurilor

Evenimentul de jurnal din fiecare flux de lucru include o referință la celălalt:

- În fluxul original: `context.forked_workflow_id` indică noul flux de lucru
- În fluxul ramificat: `context.forked_from_workflow_id` indică fluxul original

Interogați jurnalele pentru a găsi toate ramurile unui flux de lucru:

```php
$logs = Queuety::logger()->for_workflow( $workflow_id );

foreach ( $logs as $entry ) {
    if ( 'workflow_forked' === $entry['event'] ) {
        $context = json_decode( $entry['context'] ?? '{}', true );
        // $context['forked_workflow_id'] is the new workflow
    }
}
```

## Limitări

- Fluxul de lucru ramificat nu moștenește istoricul jurnalului de evenimente al originalului. Începe cu un jurnal de evenimente gol.
- Relațiile dintre fluxurile de execuție nu sunt duplicate. Dacă fluxul original avea un flux de execuție activ, ramura nu primește o copie a acestuia.
- Ramura este o instantanee a stării curente. Sarcinile aflate în execuție pentru fluxul original nu sunt duplicate.