# `Squidie.Runtime.WorkflowAgent.Projection`
[🔗](https://github.com/dark-trench/squidie/blob/main/lib/squidie/runtime/workflow_agent/projection.ex#L2)

Rebuildable workflow-agent projection over one run-thread journal.

Dispatch completion is not treated as workflow progress here. A runnable is
applied only after the run thread records `:runnable_applied`, preserving the
durable ordering between dispatch results and workflow state transitions.

# `anomaly`

```elixir
@type anomaly() :: %{
  :reason => atom(),
  :entry_type => atom(),
  optional(:child_run_id) => String.t(),
  optional(:runnable_key) => String.t(),
  optional(:run_id) => String.t(),
  optional(:step) => String.t()
}
```

# `manual_state`

```elixir
@type manual_state() :: %{
  :step => String.t(),
  :kind => String.t(),
  :paused_at => DateTime.t(),
  :metadata => map(),
  optional(:deadline) => map()
}
```

# `string_set`

```elixir
@type string_set() :: MapSet.t(String.t()) | %MapSet{map: term()}
```

# `t`

```elixir
@type t() :: %Squidie.Runtime.WorkflowAgent.Projection{
  anomalies: [anomaly()],
  applied_at: %{optional(String.t()) => DateTime.t()},
  applied_execution_opts: %{optional(String.t()) => keyword()},
  applied_results: %{optional(String.t()) => map() | nil},
  applied_runnable_keys: string_set(),
  child_runs: [map()],
  command_history: [map()],
  context: map(),
  definition_fingerprint: String.t() | nil,
  definition_version: String.t() | nil,
  dynamic_work: [map()],
  input: map() | nil,
  manual_state: manual_state() | nil,
  planned_runnables: %{optional(String.t()) => map()},
  replayed_from_run_id: String.t() | nil,
  run_id: String.t() | nil,
  started_at: DateTime.t() | nil,
  status: atom(),
  terminal_at: DateTime.t() | nil,
  terminal_error: map() | nil,
  terminal_status: atom() | nil,
  trigger: String.t() | nil,
  workflow: String.t() | nil
}
```

---

*Consult [api-reference.md](api-reference.md) for complete listing*