Component Reference

def handle_info(:tick, state) do
  state = refresh_runtime_config(state)
  state = %{state | poll_check_in_progress: true}
  notify_dashboard()
  schedule_poll_cycle_start()
  {:noreply, state}
end

def handle_info(:run_poll_cycle, state) do
  state = maybe_dispatch(state)  # Reconcile + validate + dispatch
  now_ms = System.monotonic_time(:millisecond)
  next_poll_due_at_ms = now_ms + state.poll_interval_ms
  schedule_tick(state.poll_interval_ms)
  {:noreply, %{state | poll_check_in_progress: false, next_poll_due_at_ms: next_poll_due_at_ms}}
end

defp should_dispatch_issue?(
  %Issue{} = issue,
  %State{running: running, claimed: claimed} = state,
  active_states,
  terminal_states
) do
  candidate_issue?(issue, active_states, terminal_states) and
    !todo_issue_blocked_by_non_terminal?(issue, terminal_states) and
    !MapSet.member?(claimed, issue.id) and
    !Map.has_key?(running, issue.id) and
    available_slots(state) > 0 and
    state_slots_available?(issue, running)
end

defp sort_issues_for_dispatch(issues) when is_list(issues) do
  Enum.sort_by(issues, fn
    %Issue{} = issue ->
      {priority_rank(issue.priority), issue_created_at_sort_key(issue), issue.identifier || issue.id || ""}
  end)
end

defp priority_rank(priority) when is_integer(priority) and priority in 1..4, do: priority
defp priority_rank(_priority), do: 5

delay = 1000ms (fixed short delay)
attempt = 1

delay = min(10000 * 2^(attempt-1), max_retry_backoff_ms)
attempt increments: 1, 2, 3, ...

defp retry_delay(attempt, metadata) when is_integer(attempt) and attempt > 0 do
  if metadata[:delay_type] == :continuation and attempt == 1 do
    @continuation_retry_delay_ms  # 1000
  else
    failure_retry_delay(attempt)
  end
end

defp failure_retry_delay(attempt) do
  max_delay_power = min(attempt - 1, 10)
  min(@failure_retry_base_ms * (1 <<< max_delay_power), Config.max_retry_backoff_ms())
end

defp integrate_codex_update(running_entry, %{event: event, timestamp: timestamp} = update) do
  token_delta = extract_token_delta(running_entry, update)
  
  {
    Map.merge(running_entry, %{
      codex_input_tokens: running_entry.codex_input_tokens + token_delta.input_tokens,
      codex_output_tokens: running_entry.codex_output_tokens + token_delta.output_tokens,
      codex_total_tokens: running_entry.codex_total_tokens + token_delta.total_tokens,
      # ... other fields
    }),
    token_delta
  }
end

defmodule SymphonyElixir.Workspace do
  @spec create_for_issue(map() | String.t() | nil) :: {:ok, Path.t()} | {:error, term()}
  def create_for_issue(issue_or_identifier) do
    safe_id = safe_identifier(issue_context.issue_identifier)
    workspace = workspace_path_for_issue(safe_id)
    
    with :ok <- validate_workspace_path(workspace),
         {:ok, created?} <- ensure_workspace(workspace),
         :ok <- maybe_run_after_create_hook(workspace, issue_context, created?) do
      {:ok, workspace}
    end
  end
end

defp safe_identifier(identifier) do
  String.replace(identifier || "issue", ~r/[^a-zA-Z0-9._-]/, "_")
end

defp validate_workspace_path(workspace) when is_binary(workspace) do
  expanded_workspace = Path.expand(workspace)
  root = Path.expand(Config.workspace_root())
  root_prefix = root <> "/"
  
  cond do
    expanded_workspace == root ->
      {:error, {:workspace_equals_root, expanded_workspace, root}}
    
    String.starts_with?(expanded_workspace <> "/", root_prefix) ->
      ensure_no_symlink_components(expanded_workspace, root)
    
    true ->
      {:error, {:workspace_outside_root, expanded_workspace, root}}
  end
end

defp run_hook(command, workspace, issue_context, hook_name) do
  timeout_ms = Config.workspace_hooks()[:timeout_ms]
  
  task = Task.async(fn ->
    System.cmd("sh", ["-lc", command], cd: workspace, stderr_to_stdout: true)
  end)
  
  case Task.yield(task, timeout_ms) do
    {:ok, {_output, 0}} -> :ok
    {:ok, {output, status}} -> {:error, {:workspace_hook_failed, hook_name, status, output}}
    nil -> 
      Task.shutdown(task, :brutal_kill)
      {:error, {:workspace_hook_timeout, hook_name, timeout_ms}}
  end
end

defmodule SymphonyElixir.AgentRunner do
  @spec run(map(), pid() | nil, keyword()) :: :ok | no_return()
  def run(issue, codex_update_recipient, opts) do
    case Workspace.create_for_issue(issue) do
      {:ok, workspace} ->
        try do
          with :ok <- Workspace.run_before_run_hook(workspace, issue),
               :ok <- run_codex_turns(workspace, issue, codex_update_recipient, opts) do
            :ok
          end
        after
          Workspace.run_after_run_hook(workspace, issue)
        end
    end
  end
end

defp do_run_codex_turns(app_session, workspace, issue, recipient, opts, fetcher, turn_number, max_turns) do
  prompt = build_turn_prompt(issue, opts, turn_number, max_turns)
  
  with {:ok, turn_session} <- AppServer.run_turn(app_session, prompt, issue, on_message: handler) do
    case continue_with_issue?(issue, fetcher) do
      {:continue, refreshed_issue} when turn_number < max_turns ->
        # Start next turn on same thread
        do_run_codex_turns(app_session, workspace, refreshed_issue, recipient, opts, fetcher, turn_number + 1, max_turns)
      
      {:continue, _} ->
        Logger.info("Reached max_turns with issue still active; returning to orchestrator")
        :ok
      
      {:done, _} ->
        :ok
    end
  end
end

defp build_turn_prompt(_issue, _opts, turn_number, max_turns) when turn_number > 1 do
  """
  Continuation guidance:
  
  - The previous Codex turn completed normally, but the Linear issue is still active.
  - This is continuation turn ##{turn_number} of #{max_turns}.
  - Resume from current workspace state instead of restarting from scratch.
  - The original task instructions are already in this thread, so do not restate them.
  - Focus on remaining ticket work.
  """
end

defmodule SymphonyElixir.Tracker do
  @callback fetch_candidate_issues() :: {:ok, [term()]} | {:error, term()}
  @callback fetch_issues_by_states([String.t()]) :: {:ok, [term()]} | {:error, term()}
  @callback fetch_issue_states_by_ids([String.t()]) :: {:ok, [term()]} | {:error, term()}
  
  @spec adapter() :: module()
  def adapter do
    case Config.tracker_kind() do
      "memory" -> SymphonyElixir.Tracker.Memory
      _ -> SymphonyElixir.Linear.Adapter
    end
  end
end

# 1. Start session
{:ok, session} <- AppServer.start_session(workspace)

# 2. Send protocol messages
send_initialize(port)     # id: 1
send_initialized(port)
send_thread_start(port)   # id: 2

# 3. Run turn
send_turn_start(port)     # id: 3
await_turn_completion(port, on_message, tool_executor, auto_approve)

# 4. Stop session
AppServer.stop_session(session)