# Neuron Mesin Status Memori + Tinjauan

Pola ini berguna saat agen perlu mempertahankan konteks percakapan di beberapa putaran tinjauan manusia, tetapi keseluruhan siklus hidup tetap perlu diorkestrasi oleh Queuety.

Queuety mengelola mesin status tinjauan, sedangkan Neuron mengelola memori agen untuk utas penyusunan draf.

## Mengapa memori Neuron membantu di sini

Jika peninjau menolak draf dan meminta revisi, panggilan agen berikutnya tidak perlu menyusun ulang seluruh konteks dari awal.

Neuron-nya `SQLChatHistory` cocok untuk itu karena agen dapat terus bekerja dalam utas percakapan yang sama, sementara Queuety mengarahkan keputusan peninjau dan putaran revisi.

## Agen Neuron dengan riwayat berbasis SQL

```php
namespace App\Neuron;

use NeuronAI\Agent\Agent;
use NeuronAI\Chat\History\ChatHistoryInterface;
use NeuronAI\Chat\History\SQLChatHistory;
use NeuronAI\Providers\AIProviderInterface;
use NeuronAI\Providers\Anthropic\Anthropic;
use NeuronAI\SystemPrompt;

final class EditorAgent extends Agent
{
    public function __construct(
        private readonly string $threadId,
        private readonly \PDO $pdo,
    ) {}

    protected function provider(): AIProviderInterface
    {
        return new Anthropic(
            key: $_ENV['ANTHROPIC_API_KEY'],
            model: $_ENV['ANTHROPIC_MODEL'],
        );
    }

    protected function chatHistory(): ChatHistoryInterface
    {
        return new SQLChatHistory(
            thread_id: $this->threadId,
            pdo: $this->pdo,
            table: 'neuron_chat_history',
            contextWindow: 50000,
        );
    }

    public function instructions(): string
    {
        return (string) new SystemPrompt(
            background: [
                'You are an editorial agent for long-form product briefs.',
                'Apply reviewer notes without losing the original intent.',
            ],
        );
    }
}
```

## Buat draf sekali, revisi dengan utas memori yang sama

```php
namespace App\StateMachines\Actions;

use App\Neuron\EditorAgent;
use NeuronAI\Chat\Messages\UserMessage;
use Queuety\Contracts\StateAction;

final class DraftBriefAction implements StateAction
{
    public function handle(array $state, ?string $event = null, array $event_payload = [], array $payload = []): array|string
    {
        // Queuety creates actions with `new DraftBriefAction()`, so build dependencies here.
        $pdo = new \PDO($_ENV['NEURON_DB_DSN'], $_ENV['NEURON_DB_USER'], $_ENV['NEURON_DB_PASSWORD']);

        $threadId = $state['neuron_thread_id'] ?? sprintf(
            'brief:%d:editor',
            $state['brief_id'],
        );

        $prompt = "Write the first draft for brief {$state['brief_id']}.";

        if ('reject' === $event) {
            $prompt = sprintf(
                'Revise the draft using these review notes: %s',
                $event_payload['reason'] ?? 'Tighten the draft and address reviewer concerns.',
            );
        }

        $agent = new EditorAgent($threadId, $pdo);
        $message = $agent->chat(
            new UserMessage($prompt)
        )->getMessage();

        return [
            'neuron_thread_id' => $threadId,
            'draft_markdown' => $message->getContent(),
            'review_round' => (int) ($state['review_round'] ?? 0) + 1,
            '_event' => 'draft_ready',
        ];
    }
}
```

## Mesin status Queuety

```php
use Queuety\Enums\StateMachineStatus;
use Queuety\Queuety;

$machine_id = Queuety::machine('brief_review_session')
    ->version('brief-review-session.v1')
    ->state('drafting')
    ->action(DraftBriefAction::class)
    ->on('draft_ready', 'awaiting_review')
    ->state('awaiting_review')
    ->on('approve', 'completed')
    ->on('reject', 'drafting')
    ->state('completed', StateMachineStatus::Completed)
    ->dispatch([
        'brief_id' => 42,
    ]);

// Later, once the draft action has finished and the machine waits in `awaiting_review`:
Queuety::machine_event(
    $machine_id,
    'reject',
    [ 'reason' => 'Tighten the introduction and add pricing context.' ]
);

Queuety::machine_event(
    $machine_id,
    'approve',
    [ 'reviewer' => 'editor@example.com' ]
);
```

Tahap pertama memasuki `drafting`, menjalankan tindakan yang diantrekan, lalu bertransisi ke `awaiting_review`.

Jika peninjau menolak draf, mesin kembali ke `drafting`. Karena payload peristiwa `reject` diteruskan ke `DraftBriefAction`, draf berikutnya dapat menggunakan catatan peninjau tanpa kehilangan riwayat utas Neuron yang asli.

## Mengapa ini lebih rapi daripada pengulangan workflow

Masalah ini berorientasi pada siklus hidup. Sebuah draf menunggu tinjauan manusia, peninjau dapat menyetujui atau menolaknya, penolakan mengembalikan sesi ke tahap penyusunan draf, dan persetujuan mengakhiri sesi. Pola ini lebih sesuai dengan mesin status daripada workflow linear dengan jalur kembali.

Status workflow tetap sangat baik untuk fakta orkestrasi seperti jumlah putaran tinjauan, ID artefak, ID workflow, dan keputusan perutean. Memori Neuron lebih baik untuk konteks percakapan seperti prompt sebelumnya, revisi berulang, dan respons model yang perlu tetap menjadi bagian dari utas penyusunan draf.

Menggunakan keduanya memberi setiap sistem tugas yang paling sesuai dengannya.

## Kapan sebaiknya tetap menggunakan workflow

Pilih workflow jika jalur tinjauan memiliki batas yang jelas dan berorientasi pada eksekusi, misalnya:

Buat satu draf, tunggu satu persetujuan, lalu publikasikan.

Pilih mesin status jika sesi mungkin kembali ke status yang sama beberapa kali dan peristiwa dari luar menggerakkan siklus hidupnya.

## Dokumentasi terkait

- [Mesin Status](https://queuety.inline0.dev/id/docs/state-machines)
- [Sinyal Workflow](https://queuety.inline0.dev/id/docs/workflows/signals)
- [Orkestrasi Agen](https://queuety.inline0.dev/id/docs/workflows/agent-orchestration)