…itialPrompt handling

- Update NewServer to format InitialPrompt into []MessagePart via FormatMessage
- Pass InitialPrompt and OnSnapshot callback in PTYConversationConfig
- OnSnapshot callback emits status/messages/screen changes to EventEmitter
- Remove initialPrompt string parameter from NewPTY call (now in config)
- Simplify StartSnapshotLoop to just call s.conversation.Start(ctx)
- Remove redundant goroutine, ticker, and initial prompt send logic

The snapshot loop and initial prompt handling are now internalized in
PTYConversation.Start(), which calls the OnSnapshot callback after each
snapshot.

- Update all NewPTY calls to use new signature (config only, no initialPrompt param)
- For tests needing initial prompt, use InitialPrompt config field with []MessagePart
- Update tests to expect status 'changing' until InitialPromptSent is true
  (new behavior prevents status flip 'changing' -> 'stable' -> 'changing')
- Remove direct manipulation of internal fields where possible, use Status() API
- Keep minimal internal field access (InitialPromptSent) where needed for testing
  post-send behavior without running the Start() goroutine

sendLocked() was failing with ErrMessageValidationChanging because
statusLocked() returns ConversationStatusChanging when InitialPromptSent
is false. This is a chicken-and-egg problem: we need to send the initial
prompt before we can set InitialPromptSent=true.

Solution: Add skipStatusCheck parameter to sendLocked() to bypass the
status check for the initial prompt case. The Start() goroutine passes
true to skip the check, while external Send() calls pass false to
preserve the existing validation behavior.

Remove the StartSnapshotLoop method which only delegated to
s.conversation.Start(ctx), and add a Conversation() accessor
method instead. This allows callers to invoke Start() directly
on the conversation.

Part of refactoring to move snapshot loop logic inside PTYConversation.

…versation

Remove exported InitialPromptSent and ReadyForInitialPrompt boolean fields
from PTYConversation struct:

- InitialPromptSent → initialPromptSent (unexported)
- ReadyForInitialPrompt boolean removed entirely

The initialPromptReady channel now handles readiness signaling entirely.
When the agent is ready (detected via cfg.ReadyForInitialPrompt callback),
the channel is closed and set to nil to prevent double-close.

This simplifies statusLocked() by removing the intermediate boolean state
and using the channel's nil state to track whether readiness was already
signaled.

Note: Tests will need updates to verify behavior through Status() API
rather than setting internal fields directly.

…napshotLoop

The StartSnapshotLoop method was removed from Server in favor of
exposing a Conversation() accessor that returns the PTYConversation,
which has its own Start(ctx) method.

The InitialPromptSent field was unexported as initialPromptSent.
Rework the test to verify the same behavior (normal status logic
applies after initial prompt handling) by configuring no InitialPrompt
instead of manually setting the field. When no InitialPrompt is
configured, initialPromptSent defaults to true, which achieves the
same testing outcome through the public API.

…rsation() accessor

- Move the s.conversation.Start(ctx) call into NewServer(), just before
  the return statement, so the conversation starts immediately when the
  server is created.

- Add nil check for config.Process to handle test scenarios where no
  process is configured.

- Remove the Conversation() accessor method from Server since it is no
  longer needed externally.

- Remove the external srv.Conversation().Start(ctx) call from
  cmd/server/server.go.

Remove the skipStatusCheck parameter from sendLocked and move the
status check into Send() where it belongs. This simplifies the code
since:

- Start() always skipped the check (for initial prompt)
- Send() always respected cfg.SkipSendMessageStatusCheck

Now the check happens in Send() before calling sendLocked, and the
initial prompt in Start() naturally bypasses it by calling sendLocked
directly.

Use config.AgentType directly in the OnSnapshot closure instead of
creating a redundant local variable.

Remove unnecessary channel creation for nil initialPromptReady.
In Go's select statement, nil channel cases are simply skipped
(never selected), so we don't need to create a new channel that
blocks forever - the nil channel already has the desired behavior.

Addresses PR review feedback.

Add no-op default functions for OnSnapshot and ReadyForInitialPrompt
in NewPTY() constructor instead of checking for nil throughout the code.

This removes:
- Two nil checks for OnSnapshot in Start() phase 1 and phase 2 loops
- One nil check for ReadyForInitialPrompt in statusLocked()

…ed break

…nnel

Replace the two-phase loop design in PTYConversation.Start() with two
independent goroutines coordinated by an unbuffered stableSignal channel:

- Snapshot loop: takes periodic snapshots and signals when stable with
  queued items
- Send loop: waits for stable signal, then processes the outbound queue

This replaces the agentReady channel mechanism with a simpler coordination
pattern that eliminates duplicated snapshot logic.

Previously the test only built the binary if it didn't exist, causing
stale binary issues when testing changes. Now the binary is always
rebuilt unless AGENTAPI_BINARY_PATH is set to use a custom binary.

The previous implementation had a deadlock condition:
- Snapshot loop signals stableSignal when status == Stable && queue > 0
- But statusLocked() returns 'changing' when queue > 0
- These conditions were mutually exclusive

Fixed by:
1. Adding isScreenStableLocked() helper to check screen stability independently
2. Using the helper in statusLocked() (refactor, same behavior)
3. Making stableSignal a buffered channel (size 1) to allow non-blocking sends
4. Updating snapshot loop to check screen stability and ReadyForInitialPrompt
   independently of statusLocked(), with non-blocking send to avoid deadlock

- Use separate goroutine to poll ReadyForInitialPrompt instead of
  checking on every snapshot tick (reduces overhead)
- Use atomic.Bool to track when initial prompt readiness is achieved
- Change isScreenStableLocked() to use < instead of != for robustness

Replace atomic.Bool with a channel that gets closed for one-time
signaling, which is more idiomatic Go. Remove sync/atomic import
since it's no longer needed.