Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@ai/application.go`:
- Around line 36-43: The WithContext method (Application.WithContext) should
guard against a nil ctx to avoid downstream panics: inside WithContext, check if
the provided ctx is nil and if so substitute context.Background() (or
context.TODO()) before constructing the new Application instance so the returned
AI always has a non-nil ctx; update the function to use that non-nil ctx when
setting the ctx field.
- Around line 46-47: The public method Application.Agent currently returns (nil,
nil) which signals success with a nil conversation and can cause nil
dereferences; update Application.Agent to return a non-nil error when the
operation is unimplemented or fails (e.g., an explicit "not implemented" or
appropriate domain error) instead of returning (nil, nil). Locate the
Application.Agent(func (r *Application) Agent(...)) implementation and replace
the nil-success return with a descriptive error return (keeping the conversation
nil) or implement the actual creation logic so callers never observe (nil, nil).

In `@ai/conversation.go`:
- Around line 22-24: The Prompt method on conversation currently returns nil,
nil and never delegates to the underlying provider; replace the no-op by
invoking the conversation's provider Prompt call (e.g.,
r.provider.Prompt(input)) and return its contractsai.Response and error, and if
r.provider is nil return a meaningful error instead of nil, nil so failures
aren't masked; update conversation.Prompt to forward input to the provider,
handle a nil r.provider (or wrap provider errors) and propagate the provider's
response and error up to the caller.
- Around line 26-31: The Conversation methods are missing implementations:
implement conversation.Messages() to return the conversation's message slice
(e.g. return r.messages) rather than nil, and implement conversation.Reset() to
clear that slice and any related state (e.g. set r.messages = nil or r.messages
= r.messages[:0] and reset any indexes/cursors/metadata on the conversation
struct); if the struct uses synchronization (e.g. r.mu or similar), perform
these reads/writes under the appropriate lock to avoid races.

In `@mocks/ai/Ai.go`:
- Around line 14-16: There is a duplicate type declaration for AI (type AI
struct { mock.Mock }) causing a redeclaration error; locate all declarations of
the AI mock (type name AI and any files in the mocks/ai package that define it),
remove the redundant declaration, and then regenerate mocks so only a single AI
mock type exists (ensure casing-consistent filenames to avoid duplicate
generation across different files).

In `@mocks/ai/AI.go`:
- Around line 1-159: Delete the duplicate autogenerated mock file named
mocks/ai/Ai.go (which collides with mocks/ai/AI.go) so only mocks/ai/AI.go
remains; ensure no other code imports or references the deleted file (tests
should reference the mock type AI and functions like NewAI, AI.Agent,
AI.WithContext from mocks/ai/AI.go) and run the test/build to confirm the
case-insensitive filename collision is resolved.

In `@mocks/ai/Option.go`:
- Around line 1-65: The generated mock incorrectly models the function type
Option as a struct with Execute (symbols: Option, Execute, NewOption); remove
this mock file entirely and update .mockery.yaml to exclude the Option function
(either remove it from generated list or set all: false and explicitly list
types), or if you must keep a mock-like helper, replace usages with a simple
function stub rather than testify/mock structs and use map[string]any (not
map[string]interface{}) where applicable; ensure no other code imports or
references mocks/ai/Option.go before deleting.

---

Nitpick comments:
In `@contracts/ai/response.go`:
- Around line 5-17: The getters on the Response and Usage interfaces
unnecessarily take context.Context; remove the context parameter from
Response.Text, Response.Usage, Response.Raw and from Usage.InputTokens,
Usage.OutputTokens, Usage.TotalTokens, then update all implementing types and
callers to the new no-context signatures (adjust receiver methods on concrete
response/usage structs, update interface assertions and any places calling these
methods), remove unused context imports where applicable, and run tests/build to
ensure all call sites are updated.

In `@mocks/ai/Ai.go`:
- Around line 28-33: The generated mocks use interface{} instead of Go's
preferred alias any; update the mock generation template/config so all
occurrences emit any (e.g., change make([]interface{}, len(options)) ->
make([]any, len(options)) and var _ca []interface{} -> var _ca []any) and then
regenerate the mocks (check files like mocks/ai/Ai.go, Ai.go symbols _va,
options, _ca, agent and other generated files such as AI.go, Provider.go,
Response.go, Usage.go to ensure all interface{} instances are replaced with
any).

In `@mocks/ai/Response.go`:
- Around line 27-70: The generated mock uses the old Go alias interface{}
instead of any; update the mock to use any in the Response.Raw signature and all
helper methods: change the return and parameter types for Response.Raw(ctx
context.Context) (r0 any), the Response_Raw_Call.Return(_a0 any), the helper
Raw(ctx interface{}) (you may keep the helper param type as interface{} if
needed but ensure any is used where it represents the contract type), and
RunAndReturn(run func(context.Context) any) so the types line up with
contracts/ai/response.go; then fix the mockery template/config so future
regenerations emit any instead of interface{} (adjust the template type mapping
or generator flags that control Go 1.18+ alias usage).