feat: Add structured I/O foundation (Output/Input Schemas)

Implements structured input/output schema support similar to Agno's
Pydantic-based approach, using JSON Schema for Rust.

## Changes

### Core Types (`aof-core/src/schema.rs`)
- **OutputSchema**: JSON Schema for validated LLM responses
  - Schema validation with type checking
  - LLM tool conversion for structured output
  - System prompt instructions generation
  - Format hints (table, list, json, yaml, auto)

- **InputSchema**: JSON Schema for input validation
  - Type-safe input validation
  - Runtime schema enforcement

- **Pre-built schemas** in `schemas::` module:
  - `container_list()` - Docker/K8s container listings
  - `resource_stats()` - CPU/memory statistics
  - `simple_list()` - Generic list outputs
  - `key_value()` - Key-value data structures

### Integration Points
- **AgentContext**: Added `output_schema` and `input_schema` fields
  - `with_output_schema()` builder method
  - `with_input_schema()` builder method

- **Error handling**: Added `AofError::Validation` variant

### Exports
- Exported `OutputSchema`, `InputSchema`, `FormatHint` from `aof-core`

## Design Principles

1. **Runtime flexibility**: Schemas specified per-execution, not per-agent
2. **Type safety**: Rust's compile-time guarantees + runtime validation
3. **LLM-driven**: Uses function calling or response_format for structure
4. **Format hints**: Guides CLI rendering (table vs list vs json)
5. **Graceful degradation**: Validation is strict by default, optional fallback

## Example Usage (Planned)

```rust
use aof_core::schema::schemas;

// Use pre-built schema
let schema = schemas::container_list();

// Execute with schema
runtime.execute_with_schema("agent", "list containers", Some(schema)).await?;
```

```bash
# CLI usage (to be implemented)
aofctl run agent docker-health.yaml --output-schema container-list
aofctl run agent docker-health.yaml --output-schema-file custom.json
```

## Related

- Issue: #74
- Inspired by: Agno's structured I/O
  - https://docs.agno.com/basics/input-output/agent/usage/output-schema-on-run
  - https://docs.agno.com/basics/input-output/agent/usage/structured-input

## Next Steps

- [ ] Update agent executor to use structured output
- [ ] Add CLI support for --output-schema flag
- [ ] Implement schema-based rendering in aofctl
- [ ] Write internal + user-facing docs
- [ ] Comprehensive tests

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: initcron

crates/aof-core/src/agent.rs

@@ -154,6 +154,12 @@ pub struct AgentContext {
 
     /// Execution metadata
     pub metadata: ExecutionMetadata,
+
+    /// Optional output schema for structured responses
+    pub output_schema: Option<crate::schema::OutputSchema>,
+
+    /// Optional input schema for validation
+    pub input_schema: Option<crate::schema::InputSchema>,
 }
 
 /// Message in conversation history
@@ -212,9 +218,23 @@ impl AgentContext {
             state: HashMap::new(),
             tool_results: Vec::new(),
             metadata: ExecutionMetadata::default(),
+            output_schema: None,
+            input_schema: None,
         }
     }
 
+    /// Set output schema for structured responses
+    pub fn with_output_schema(mut self, schema: crate::schema::OutputSchema) -> Self {
+        self.output_schema = Some(schema);
+        self
+    }
+
+    /// Set input schema for validation
+    pub fn with_input_schema(mut self, schema: crate::schema::InputSchema) -> Self {
+        self.input_schema = Some(schema);
+        self
+    }
+
     /// Add a message to history
     pub fn add_message(&mut self, role: MessageRole, content: impl Into<String>) {
         self.messages.push(Message {

crates/aof-core/src/error.rs

@@ -48,6 +48,9 @@ pub enum AofError {
     #[error("Runtime error: {0}")]
     Runtime(String),
 
+    #[error("Validation error: {0}")]
+    Validation(String),
+
     #[error("Unknown error: {0}")]
     Unknown(String),
 }
@@ -100,6 +103,11 @@ impl AofError {
     pub fn runtime(msg: impl Into<String>) -> Self {
         Self::Runtime(msg.into())
     }
+
+    /// Create a validation error
+    pub fn validation(msg: impl Into<String>) -> Self {
+        Self::Validation(msg.into())
+    }
 }
 
 #[cfg(test)]

crates/aof-core/src/lib.rs

@@ -14,6 +14,7 @@ pub mod mcp;
 pub mod memory;
 pub mod model;
 pub mod registry;
+pub mod schema;
 pub mod tool;
 pub mod trigger;
 pub mod workflow;
@@ -31,6 +32,7 @@ pub use model::{
     Model, ModelConfig, ModelProvider, ModelRequest, ModelResponse, RequestMessage, StopReason,
     StreamChunk, ToolDefinition as ModelToolDefinition, Usage,
 };
+pub use schema::{FormatHint, InputSchema, OutputSchema};
 pub use tool::{
     Tool, ToolCall, ToolConfig, ToolDefinition, ToolExecutor, ToolInput, ToolResult, ToolType,
 };