Architect Mode

# Switch to architect mode
Loom.Session.set_mode(session_id, :architect)

# Check current mode
{:ok, mode} = Loom.Session.get_mode(session_id)
# => :architect or :normal

# Switch back to normal mode
Loom.Session.set_mode(session_id, :normal)

{
  "summary": "Refactor authentication to use Pow library",
  "plan": [
    {
      "file": "lib/myapp/accounts/user.ex",
      "action": "edit",
      "description": "Add Pow schema fields",
      "details": "Add `use Pow.Ecto.Schema` after the schema definition. Add pow_user_fields() to the schema block."
    },
    {
      "file": "lib/myapp/accounts/session.ex",
      "action": "delete",
      "description": "Remove custom session module",
      "details": "Delete this file entirely - Pow handles sessions."
    },
    {
      "file": "lib/myapp_web/controllers/auth_controller.ex",
      "action": "create",
      "description": "Add Pow authentication controller",
      "details": "Create controller that uses Pow.Phoenix.Controller. Implement create/2 and delete/2 actions."
    }
  ]
}

Refactor the authentication system to use the Pow library instead of our custom implementation.

## Architect Plan

Refactor authentication to use Pow library

### Steps:
1. **edit** `mix.exs` — Add pow and pow_postgres_store dependencies
2. **edit** `lib/myapp/accounts/user.ex` — Add Pow schema fields and validations
3. **delete** `lib/myapp/accounts/session.ex` — Remove custom session module
4. **create** `lib/myapp_web/controllers/pow_controller.ex` — Add Pow authentication controller
5. **edit** `lib/myapp_web/router.ex` — Replace custom auth routes with Pow routes
6. **create** `priv/repo/migrations/20240315_add_pow_fields.exs` — Migration for pow fields

_Executing plan with editor model..._

## Execution Complete

Refactor authentication to use Pow library

### Results (6/6 succeeded):
1. [OK] edit `mix.exs` — Added pow 1.0.34 and pow_postgres_store 1.0.5 to dependencies
2. [OK] edit `lib/myapp/accounts/user.ex` — Added `use Pow.Ecto.Schema` and pow_user_fields to schema
3. [OK] delete `lib/myapp/accounts/session.ex` — File deleted
4. [OK] create `lib/myapp_web/controllers/pow_controller.ex` — Created controller with Pow actions
5. [OK] edit `lib/myapp_web/router.ex` — Replaced /auth routes with pow_routes()
6. [OK] create `priv/repo/migrations/20240315_add_pow_fields.exs` — Created migration with email and password_hash

defmodule Loom.Session.Architect do
  @moduledoc """
  Two-model workflow: architect plans, editor executes.
  """
  
  def run(user_text, state, opts \\ []) do
    architect_model = resolve_architect_model(opts)
    editor_model = resolve_editor_model(opts)
    
    # Phase 1: Plan with strong model
    case plan(user_text, state, architect_model: architect_model) do
      {:ok, plan_data, state} ->
        # Phase 2: Execute with fast model
        execute_plan(plan_data, state, editor_model: editor_model)
      
      {:error, reason, state} ->
        {:error, reason, state}
    end
  end
  
  # Planning phase returns JSON plan
  def plan(user_text, state, opts) do
    # ... calls architect model with json_schema response format
  end
  
  # Execution phase loops over plan items
  defp execute_plan(plan_data, state, opts) do
    # ... sends each item to editor model
  end
end

# Planning phase started
{:architect_phase, :planning}

# Plan generated
{:architect_plan, session_id, plan_data}

# Execution phase started
{:architect_phase, :executing}

# Each step executing
{:architect_step, session_id, step}

# Tools executing/complete
{:tool_executing, session_id, tool_name}
{:tool_complete, session_id, tool_name, result}

Loom.Session.subscribe(session_id)

receive do
  {:architect_plan, ^session_id, plan} ->
    IO.inspect(plan, label: "Plan generated")
end

Loom.Session.set_mode(session_id, :normal)

❌ "Update the function"
✅ "Replace the function on line 45 with: [exact code]"