Struct PlanningView 

pub struct PlanningView {

    pub goal: String,
    pub budget: PlanningBudget,
    pub screen: PlanningScreen,
    pub elements: Vec<PlanningElement>,
    pub adapter_facts: Vec<AdapterFactRef>,
    pub adapter_actions: Vec<AdapterActionRef>,
    pub capabilities: Vec<CapabilityRef>,
    pub run_progress: RunProgress,
    pub memories: Vec<MemoryRef>,
    pub knowledge: Vec<KnowledgeRef>,
    pub recent_events: Vec<EventRef>,
    pub blockers: Vec<Blocker>,
    pub anomalies: Vec<AnomalyRef>,
    pub evidence: Vec<EvidenceRef>,
    pub selection_rationale: Option<String>,
    pub omitted_counts: OmittedCounts,
    pub adapter_actions_prompt: Option<String>,
}

Compact, budgeted projection of CEL state for one planner call.

Built by cel-cortex’s planning-view builder from MentalModel plus active adapter facts. Consumed by every planner — built-in or external — instead of raw ScreenContext.

Fields

goal: String

The natural-language goal the planner is working on.

budget: PlanningBudget

The budget the caller asked the builder to respect.

screen: PlanningScreen

Current screen / app / window summary.

elements: Vec<PlanningElement>

Selected elements relevant to the goal, after budget compression.

adapter_facts: Vec<AdapterFactRef>

Active adapter-backed facts (Numbers cells, browser DOM facts, etc.). Empty until adapters expose typed facts; in PR1a builders may leave this empty if no adapter contributed.

adapter_actions: Vec<AdapterActionRef>

Active adapter-backed actions available for this turn. This is the structured, agent-agnostic contract; LLM planners may render it into prompt text, while non-LLM agents can inspect it directly.

capabilities: Vec<CapabilityRef>

Capabilities currently wired up (CDP bound, native input enabled, …). Folds in the boolean flags from the legacy RuntimeCaps.

run_progress: RunProgress

Where in the run the planner is. Lets the planner pace itself — e.g. stop polishing extraction once most of the budget is spent. Folds in the legacy RuntimeCaps::steps_used / max_steps.

memories: Vec<MemoryRef>

Memories selected by the cognition layer (PR3).

knowledge: Vec<KnowledgeRef>

Knowledge records selected by the cognition layer (PR3).

recent_events: Vec<EventRef>

Recent events / actions / checkpoints relevant to the goal.

blockers: Vec<Blocker>

Things actively blocking forward progress (consent walls, modal dialogs, missing capability, etc.). Promoted to first-class so the planner notices them even if elements are aggressively compressed.

anomalies: Vec<AnomalyRef>

Anomalies the cortex flagged (stale state, unexpected window, etc.).

evidence: Vec<EvidenceRef>

References back to source records that explain why selection picked what it picked. Filled when a memory / failure / prior outcome influenced the view.

selection_rationale: Option<String>

One-sentence rationale explaining the selection. Optional — deterministic selectors may leave this absent.

omitted_counts: OmittedCounts

What the builder dropped to fit the budget. Lets the planner know the view is compressed and how aggressively.

adapter_actions_prompt: Option<String>

Transitional pre-rendered “App-Specific Actions” prompt fragment listing the {"type": "custom", "adapter": "...", "action": "...", "params": {...}} shapes for every currently-active adapter. The cortex-side step executor builds this once per turn from Cortex::active_adapter_manifests() and the canonical runner stamps it onto the view post-build. None means no adapter actions are available to the planner this turn — empty equivalent. Prefer adapter_actions for new callers; this field is retained while prompt-only clients migrate.

Trait Implementations

impl Clone for PlanningView

fn clone(&self) -> PlanningView

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PlanningView

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PlanningView

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for PlanningView

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.