autoforge-ai 0.1.21 → 0.1.22

package/.claude/templates/auto_improve_prompt.template.md

@@ -0,0 +1,160 @@
+## YOUR ROLE - AUTO-IMPROVE AGENT
+
+You are running in **auto-improve mode**. Your entire job this session is to make the application **meaningfully better** in exactly ONE way. The project is already finished — all existing features pass. You are here to polish, enhance, and evolve it.
+
+This is a FRESH context window. You have no memory of previous sessions. Previous auto-improve sessions may have already added improvements. Your job is to pick ONE new improvement, implement it, and commit it.
+
+### STEP 1: GET YOUR BEARINGS
+
+Start by orienting yourself:
+
+```bash
+# Understand the project
+pwd
+ls -la
+cat app_spec.txt 2>/dev/null || cat .autoforge/prompts/app_spec.txt 2>/dev/null
+
+# See what's been done recently (previous auto-improvements, other commits)
+git log --oneline -20
+
+# See recent progress notes if they exist
+tail -200 claude-progress.txt 2>/dev/null || true
+```
+
+Then use MCP tools to check feature status:
+
+```
+Use the feature_get_stats tool
+Use the feature_get_summary tool
+```
+
+You are looking at an app that someone is running in "autopilot polish" mode. Respect what is already there. Read some of the actual source to get a feel for the codebase.
+
+### STEP 2: CHOOSE ONE MEANINGFUL IMPROVEMENT
+
+Brainstorm silently, then pick exactly ONE improvement. Valid categories:
+
+- **Performance** — cache a hot path, remove an N+1, memoize an expensive component, debounce a noisy handler
+- **UX / UI polish** — empty states, loading states, error states, keyboard shortcuts, micro-interactions, accessibility
+- **Visual design** — spacing, typography, color hierarchy, alignment, iconography
+- **Small new feature** — a natural next step that fits the app's purpose
+- **Security hardening** — input validation, authorization checks, rate limits, secret handling
+- **Refactor for clarity** — extract a confused function, rename a misleading variable, split a file that has outgrown itself
+- **Accessibility** — focus rings, aria-labels, keyboard navigation, color contrast
+- **Dependency / config** — bump a safe dep, tighten a lint rule that would catch a real class of bugs
+
+**Choose deliberately:**
+- The improvement must be genuinely useful to an end user or to future developers.
+- Prefer improvements that complement what's already there over inventing new scope.
+- If the app has obvious rough edges, fix those first before inventing new features.
+- Do NOT touch any feature on the Kanban that is currently `in_progress` — leave it alone.
+- Avoid duplicating past improvements (read `git log` to see what's already been done).
+
+### STEP 3: ADD THE IMPROVEMENT AS A FEATURE
+
+Call the `feature_create` MCP tool with:
+
+- `category`: e.g., `"Performance"`, `"UX Polish"`, `"Security"`, `"Refactor"`, `"Accessibility"`, `"New Feature"`
+- `name`: a short imperative title, e.g., `"Add empty state to project list"`
+- `description`: 1-3 sentences explaining what the change is and why it matters
+- `steps`: 3-5 concrete acceptance steps (what must be true when this is done)
+
+**Record the returned feature ID.** You will use it in later steps. Then mark it in progress:
+
+```
+Use the feature_mark_in_progress tool with feature_id={your_new_id}
+```
+
+### STEP 4: IMPLEMENT THE IMPROVEMENT
+
+Implement the change fully. Keep scope tight:
+
+- Edit only the files you need to change.
+- Don't add speculative abstractions or "while I'm here" refactors.
+- Don't add comments/docstrings to code you didn't touch.
+- Don't rename things that don't need renaming.
+- If you discover a bug that is NOT your chosen improvement, leave it alone (or note it in `claude-progress.txt` for a future session).
+
+If your improvement is a UI change, actually look at the result — take a screenshot with `playwright-cli` if the dev server is running, or at minimum open the relevant component and verify your edit makes sense.
+
+### STEP 5: VERIFY WITH LINT / TYPECHECK / BUILD
+
+**Mandatory.** Before committing, confirm the code still compiles cleanly. Pick the right commands based on the project type (check `package.json`, `pyproject.toml`, `Cargo.toml`, etc.).
+
+Typical command sets:
+
+- **Node / TypeScript / Vite / Next**: `npm run lint && npm run build`
+  (or `npm run typecheck` if it exists as a separate script)
+- **Python**: `ruff check . && mypy .` (or whatever is configured in `pyproject.toml`)
+- **Rust**: `cargo check && cargo clippy`
+- **Go**: `go vet ./... && go build ./...`
+
+**Resolve any issues your change introduced.** If lint/typecheck/build was already failing before your change (unrelated breakage), do NOT "fix" the unrelated failures — that's scope creep. Revert your change and pick a different improvement if the codebase is in a broken baseline state.
+
+### STEP 6: MARK THE FEATURE PASSING
+
+Call the feature MCP tool:
+
+```
+Use the feature_mark_passing tool with feature_id={your_new_id}
+```
+
+### STEP 7: CREATE A COMMIT
+
+Stage your changes and commit with a **short, concise, TLDR-style message**. One line for the subject, optionally one or two more for the "why". No verbose bullet lists, no trailing summaries.
+
+```bash
+git status
+git add <specific files you changed>
+git commit -m "Add empty state to project list when no projects exist"
+```
+
+Good commit message examples:
+- `"Cache project stats query to cut dashboard load time"`
+- `"Add keyboard shortcut (Cmd+K) to open command palette"`
+- `"Harden upload endpoint against oversized files"`
+- `"Extract confused session handling into its own module"`
+
+Bad commit message examples:
+- `"Various improvements"` (too vague)
+- `"Made the app better by implementing several changes to improve UX including..."` (too long)
+
+### STEP 8: EXIT THIS SESSION
+
+When the commit is created successfully, your work for this session is done. Do NOT try to find a second improvement — one per session is the rule. Stop and let the next scheduled tick handle the next improvement.
+
+---
+
+## GUARDRAILS (READ CAREFULLY)
+
+1. **One improvement per session.** If you finish early, don't start another. Exit cleanly.
+2. **Never skip lint / typecheck / build.** If they fail, fix or revert.
+3. **Never commit broken code.** A commit with failing lint/build is worse than no commit.
+4. **Don't touch features other agents are working on** (anything with `in_progress=True`).
+5. **Don't bypass the feature MCP tools.** Create a real Kanban feature for your change so it shows up in the UI.
+6. **Keep commit messages under 72 characters for the subject line.**
+7. **Don't add dependencies you don't need.** If the improvement needs a new package, be sure it's justified.
+8. **Respect the existing architecture.** Don't rewrite patterns the project has already committed to.
+
+---
+
+## BROWSER AUTOMATION (OPTIONAL)
+
+If your improvement is visual and the dev server is running, you may use `playwright-cli` to verify it renders correctly:
+
+- Open: `playwright-cli open http://localhost:PORT`
+- Screenshot: `playwright-cli screenshot`
+- Read the screenshot file to verify visual appearance
+- Close: `playwright-cli close`
+
+Browser verification is **optional** in auto-improve mode. Lint + typecheck + build is mandatory; visual verification is a bonus when relevant.
+
+---
+
+## SUCCESS CRITERIA
+
+A successful auto-improve session ends with:
+1. One new feature on the Kanban, marked passing.
+2. A clean git commit with a short TLDR message.
+3. No lint / typecheck / build errors introduced.
+4. The agent exits cleanly without starting a second improvement.

package/agent.py

@@ -31,6 +31,7 @@ from progress import (
 )
 from prompts import (
     copy_spec_to_project,
+    get_auto_improve_prompt,
     get_batch_feature_prompt,
     get_coding_prompt,
     get_initializer_prompt,
@@ -163,6 +164,7 @@ async def run_autonomous_agent(
     agent_type: Optional[str] = None,
     testing_feature_id: Optional[int] = None,
     testing_feature_ids: Optional[list[int]] = None,
+    auto_improve: bool = False,
 ) -> None:
     """
     Run the autonomous agent loop.
@@ -177,6 +179,9 @@ async def run_autonomous_agent(
         agent_type: Type of agent: "initializer", "coding", "testing", or None (auto-detect)
         testing_feature_id: For testing agents, the pre-claimed feature ID to test (legacy single mode)
         testing_feature_ids: For testing agents, list of feature IDs to batch test
+        auto_improve: If True, run in auto-improve mode (agent creates one
+            improvement feature, implements it, commits, and exits). Takes
+            precedence over other prompt selection branches.
     """
     print("\n" + "=" * 70)
     print("  AUTONOMOUS CODING AGENT")
@@ -185,6 +190,8 @@ async def run_autonomous_agent(
     print(f"Model: {model}")
     if agent_type:
         print(f"Agent type: {agent_type}")
+    if auto_improve:
+        print("Mode: AUTO-IMPROVE (one improvement + commit per session)")
     if yolo_mode:
         print("Mode: YOLO (testing agents disabled)")
     if feature_ids and len(feature_ids) > 1:
@@ -240,7 +247,8 @@ async def run_autonomous_agent(
 
         # Check if all features are already complete (before starting a new session)
         # Skip this check if running as initializer (needs to create features first)
-        if not is_initializer and iteration == 1:
+        # or auto-improve mode (intentionally runs against finished projects)
+        if not is_initializer and not auto_improve and iteration == 1:
             passing, in_progress, total, _nhi = count_passing_tests(project_dir)
             if total > 0 and passing == total:
                 print("\n" + "=" * 70)
@@ -262,7 +270,11 @@ async def run_autonomous_agent(
         client = create_client(project_dir, model, yolo_mode=yolo_mode, agent_type=agent_type)
 
         # Choose prompt based on agent type
-        if agent_type == "initializer":
+        # auto_improve takes precedence over other branches — it's a distinct
+        # mode where the agent creates its own feature before implementing it.
+        if auto_improve:
+            prompt = get_auto_improve_prompt(project_dir, yolo_mode=yolo_mode)
+        elif agent_type == "initializer":
             prompt = get_initializer_prompt(project_dir)
         elif agent_type == "testing":
             prompt = get_testing_prompt(project_dir, testing_feature_id, testing_feature_ids)

package/autonomous_agent_demo.py

@@ -186,6 +186,17 @@ Authentication:
         help="Max features per coding agent batch (1-15, default: 3)",
     )
 
+    parser.add_argument(
+        "--auto-improve",
+        action="store_true",
+        default=False,
+        help=(
+            "Run in auto-improve mode: a single agent session that analyses "
+            "the codebase, creates one improvement feature, implements it, "
+            "verifies with lint/typecheck/build, commits, and exits."
+        ),
+    )
+
     return parser.parse_args()
 
 
@@ -262,7 +273,22 @@ def main() -> None:
             return
 
     try:
-        if args.agent_type:
+        if args.auto_improve:
+            # Auto-improve mode: single agent session, one improvement per run.
+            # Bypasses the parallel orchestrator entirely — auto-improve is
+            # always single-agent, single-feature, and exits after one commit.
+            print("[AUTO-IMPROVE] Starting single-session improvement run...", flush=True)
+            asyncio.run(
+                run_autonomous_agent(
+                    project_dir=project_dir,
+                    model=args.model,
+                    max_iterations=1,
+                    yolo_mode=args.yolo,
+                    agent_type="coding",
+                    auto_improve=True,
+                )
+            )
+        elif args.agent_type:
             # Subprocess mode - spawned by orchestrator for a specific role
             asyncio.run(
                 run_autonomous_agent(

package/client.py

@@ -38,7 +38,7 @@ def convert_model_for_vertex(model: str) -> str:
 
     Vertex AI uses @ to separate model name from version (e.g., claude-sonnet-4-5@20250929)
     while the Anthropic API uses - (e.g., claude-sonnet-4-5-20250929).
-    Models without a date suffix (e.g., claude-opus-4-6) pass through unchanged.
+    Models without a date suffix (e.g., claude-opus-4-7) pass through unchanged.
 
     Args:
         model: Model name in Anthropic format (with hyphens)
@@ -342,8 +342,10 @@ def create_client(
     # Uses get_effective_sdk_env() which reads provider settings from the database,
     # ensuring UI-configured alternative providers (GLM, Ollama, Kimi, Custom) propagate
     # correctly to the Claude CLI subprocess
-    from registry import get_effective_sdk_env
+    from registry import get_effective_sdk_env, get_effort_setting
     sdk_env = get_effective_sdk_env()
+    effort = get_effort_setting()
+    print(f"   - Reasoning effort: {effort}")
 
     # Detect alternative API mode (Ollama, GLM, or Vertex AI)
     base_url = sdk_env.get("ANTHROPIC_BASE_URL", "")
@@ -452,6 +454,9 @@ def create_client(
     return ClaudeSDKClient(
         options=ClaudeAgentOptions(
             model=model,
+            # SDK 0.1.61's effort Literal omits "xhigh" but the CLI's
+            # --effort flag accepts it; the SDK forwards the string unchanged.
+            effort=effort,  # type: ignore[arg-type]
             cli_path=system_cli,  # Use system CLI to avoid bundled Bun crash (exit code 3)
             system_prompt="You are an expert full-stack developer building a production-quality web application.",
             setting_sources=["project"],  # Enable skills, commands, and CLAUDE.md from project dir

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autoforge-ai",
-  "version": "0.1.21",
+  "version": "0.1.22",
   "description": "Autonomous coding agent with web UI - build complete apps with AI",
   "license": "AGPL-3.0",
   "bin": {

package/prompts.py

@@ -151,6 +151,30 @@ def get_coding_prompt(project_dir: Path | None = None, yolo_mode: bool = False)
     return prompt
 
 
+def get_auto_improve_prompt(project_dir: Path | None = None, yolo_mode: bool = False) -> str:
+    """Load the auto-improve agent prompt (project-specific if available).
+
+    The auto-improve prompt instructs the agent to analyze an already-finished
+    project, pick ONE meaningful improvement, create a feature on the Kanban,
+    implement it, verify with lint/typecheck/build, mark passing, and commit.
+
+    Args:
+        project_dir: Optional project directory for project-specific prompts
+        yolo_mode: If True, strip browser automation sections for YOLO-mode
+            token savings. Browser verification is already optional in
+            auto-improve mode, so this is a small adjustment.
+
+    Returns:
+        The auto-improve prompt, optionally stripped of browser testing.
+    """
+    prompt = load_prompt("auto_improve_prompt", project_dir)
+
+    if yolo_mode:
+        prompt = _strip_browser_testing_sections(prompt)
+
+    return prompt
+
+
 def get_testing_prompt(
     project_dir: Path | None = None,
     testing_feature_id: int | None = None,

package/registry.py

@@ -14,9 +14,9 @@ import time
 from contextlib import contextmanager
 from datetime import datetime
 from pathlib import Path
-from typing import Any
+from typing import Any, Literal, cast
 
-from sqlalchemy import Column, DateTime, Integer, String, create_engine, text
+from sqlalchemy import Boolean, Column, DateTime, Integer, String, create_engine, text
 from sqlalchemy.orm import DeclarativeBase, sessionmaker
 
 # Module logger
@@ -46,14 +46,17 @@ def _migrate_registry_dir() -> None:
 # Available models with display names
 # To add a new model: add an entry here with {"id": "model-id", "name": "Display Name"}
 AVAILABLE_MODELS = [
-    {"id": "claude-opus-4-6", "name": "Claude Opus"},
-    {"id": "claude-sonnet-4-5-20250929", "name": "Claude Sonnet"},
+    {"id": "claude-opus-4-7", "name": "Claude Opus"},
+    {"id": "claude-sonnet-4-6", "name": "Claude Sonnet"},
 ]
 
 # Map legacy model IDs to their current replacements.
 # Used by get_all_settings() to auto-migrate stale values on first read after upgrade.
 LEGACY_MODEL_MAP = {
-    "claude-opus-4-5-20251101": "claude-opus-4-6",
+    "claude-opus-4-5-20251101": "claude-opus-4-7",
+    "claude-opus-4-6": "claude-opus-4-7",
+    "claude-sonnet-4-5": "claude-sonnet-4-6",
+    "claude-sonnet-4-5-20250929": "claude-sonnet-4-6",
 }
 
 # List of valid model IDs (derived from AVAILABLE_MODELS)
@@ -65,7 +68,15 @@ VALID_MODELS = [m["id"] for m in AVAILABLE_MODELS]
 _env_default_model = os.getenv("ANTHROPIC_DEFAULT_OPUS_MODEL")
 if _env_default_model is not None:
     _env_default_model = _env_default_model.strip()
-DEFAULT_MODEL = _env_default_model or "claude-opus-4-6"
+# Auto-remap stale env-provided values (e.g. user's .env still pins 4.6)
+if _env_default_model and _env_default_model in LEGACY_MODEL_MAP:
+    logging.getLogger(__name__).warning(
+        "ANTHROPIC_DEFAULT_OPUS_MODEL=%s is legacy; remapping to %s. "
+        "Update your .env to silence this warning.",
+        _env_default_model, LEGACY_MODEL_MAP[_env_default_model],
+    )
+    _env_default_model = LEGACY_MODEL_MAP[_env_default_model]
+DEFAULT_MODEL = _env_default_model or "claude-opus-4-7"
 
 # Ensure env-provided DEFAULT_MODEL is in VALID_MODELS for validation consistency
 # (idempotent: only adds if missing, doesn't alter AVAILABLE_MODELS semantics)
@@ -119,6 +130,8 @@ class Project(Base):
     path = Column(String, nullable=False)  # POSIX format for cross-platform
     created_at = Column(DateTime, nullable=False)
     default_concurrency = Column(Integer, nullable=False, default=3)
+    auto_improve_enabled = Column(Boolean, nullable=False, default=False)
+    auto_improve_interval_minutes = Column(Integer, nullable=False, default=10)
 
 
 class Settings(Base):
@@ -184,6 +197,7 @@ def _get_engine():
                 )
                 Base.metadata.create_all(bind=_engine)
                 _migrate_add_default_concurrency(_engine)
+                _migrate_add_auto_improve(_engine)
                 _SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=_engine)
                 logger.debug("Initialized registry database at: %s", db_path)
 
@@ -203,6 +217,25 @@ def _migrate_add_default_concurrency(engine) -> None:
             logger.info("Migrated projects table: added default_concurrency column")
 
 
+def _migrate_add_auto_improve(engine) -> None:
+    """Add auto-improve columns if missing (for existing databases)."""
+    with engine.connect() as conn:
+        result = conn.execute(text("PRAGMA table_info(projects)"))
+        columns = [row[1] for row in result.fetchall()]
+        if "auto_improve_enabled" not in columns:
+            conn.execute(text(
+                "ALTER TABLE projects ADD COLUMN auto_improve_enabled INTEGER NOT NULL DEFAULT 0"
+            ))
+            conn.commit()
+            logger.info("Migrated projects table: added auto_improve_enabled column")
+        if "auto_improve_interval_minutes" not in columns:
+            conn.execute(text(
+                "ALTER TABLE projects ADD COLUMN auto_improve_interval_minutes INTEGER NOT NULL DEFAULT 10"
+            ))
+            conn.commit()
+            logger.info("Migrated projects table: added auto_improve_interval_minutes column")
+
+
 @contextmanager
 def _get_session():
     """
@@ -359,7 +392,11 @@ def list_registered_projects() -> dict[str, dict[str, Any]]:
             p.name: {
                 "path": p.path,
                 "created_at": p.created_at.isoformat() if p.created_at else None,
-                "default_concurrency": getattr(p, 'default_concurrency', 3) or 3
+                "default_concurrency": getattr(p, 'default_concurrency', 3) or 3,
+                "auto_improve_enabled": bool(getattr(p, 'auto_improve_enabled', False)),
+                "auto_improve_interval_minutes": int(
+                    getattr(p, 'auto_improve_interval_minutes', 10) or 10
+                ),
             }
             for p in projects
         }
@@ -386,7 +423,11 @@ def get_project_info(name: str) -> dict[str, Any] | None:
         return {
             "path": project.path,
             "created_at": project.created_at.isoformat() if project.created_at else None,
-            "default_concurrency": getattr(project, 'default_concurrency', 3) or 3
+            "default_concurrency": getattr(project, 'default_concurrency', 3) or 3,
+            "auto_improve_enabled": bool(getattr(project, 'auto_improve_enabled', False)),
+            "auto_improve_interval_minutes": int(
+                getattr(project, 'auto_improve_interval_minutes', 10) or 10
+            ),
         }
     finally:
         session.close()
@@ -464,6 +505,71 @@ def set_project_concurrency(name: str, concurrency: int) -> bool:
     return True
 
 
+def get_project_auto_improve(name: str) -> tuple[bool, int]:
+    """
+    Get a project's auto-improve configuration.
+
+    Args:
+        name: The project name.
+
+    Returns:
+        Tuple of (enabled, interval_minutes). Defaults to (False, 10) if
+        the project is not found or the columns are missing.
+    """
+    _, SessionLocal = _get_engine()
+    session = SessionLocal()
+    try:
+        project = session.query(Project).filter(Project.name == name).first()
+        if project is None:
+            return (False, 10)
+        enabled = bool(getattr(project, "auto_improve_enabled", False))
+        interval = int(getattr(project, "auto_improve_interval_minutes", 10) or 10)
+        return (enabled, interval)
+    finally:
+        session.close()
+
+
+def set_project_auto_improve(
+    name: str,
+    enabled: bool | None = None,
+    interval_minutes: int | None = None,
+) -> bool:
+    """
+    Update a project's auto-improve configuration.
+
+    Either field can be updated independently by passing None for the other.
+
+    Args:
+        name: The project name.
+        enabled: If provided, set the enabled flag.
+        interval_minutes: If provided, set the interval in minutes (1-1440).
+
+    Returns:
+        True if updated, False if the project wasn't found.
+
+    Raises:
+        ValueError: If interval_minutes is outside the 1-1440 range.
+    """
+    if interval_minutes is not None and (interval_minutes < 1 or interval_minutes > 1440):
+        raise ValueError("interval_minutes must be between 1 and 1440")
+
+    with _get_session() as session:
+        project = session.query(Project).filter(Project.name == name).first()
+        if not project:
+            return False
+
+        if enabled is not None:
+            project.auto_improve_enabled = bool(enabled)
+        if interval_minutes is not None:
+            project.auto_improve_interval_minutes = int(interval_minutes)
+
+    logger.info(
+        "Set project '%s' auto_improve: enabled=%s, interval=%s",
+        name, enabled, interval_minutes,
+    )
+    return True
+
+
 # =============================================================================
 # Validation Functions
 # =============================================================================
@@ -576,6 +682,28 @@ def get_setting(key: str, default: str | None = None) -> str | None:
         return default
 
 
+# Valid Claude Code reasoning/effort levels. Must match the CLI's --effort
+# choices (low, medium, high, xhigh, max) — note: the SDK's Literal type at
+# 0.1.61 omits "xhigh", but the string is forwarded to the CLI as-is and
+# accepted there.
+EffortLevel = Literal["low", "medium", "high", "xhigh", "max"]
+VALID_EFFORT_LEVELS: tuple[EffortLevel, ...] = ("low", "medium", "high", "xhigh", "max")
+DEFAULT_EFFORT: EffortLevel = "xhigh"
+
+
+def get_effort_setting() -> EffortLevel:
+    """
+    Read the global reasoning-effort setting, falling back to ``xhigh``.
+
+    Unknown/invalid stored values are treated as missing so a DB corruption or
+    schema drift can't force the CLI into an unsupported mode.
+    """
+    value = get_setting("effort")
+    if value in VALID_EFFORT_LEVELS:
+        return cast(EffortLevel, value)
+    return DEFAULT_EFFORT
+
+
 def set_setting(key: str, value: str) -> None:
     """
     Set a setting value (creates or updates).
@@ -604,7 +732,7 @@ def get_all_settings() -> dict[str, str]:
     """
     Get all settings as a dictionary.
 
-    Automatically migrates legacy model IDs (e.g. claude-opus-4-5-20251101 -> claude-opus-4-6)
+    Automatically migrates legacy model IDs (e.g. claude-opus-4-6 -> claude-opus-4-7)
     on first read after upgrade. This is a one-time silent migration.
 
     Returns:
@@ -652,10 +780,10 @@ API_PROVIDERS: dict[str, dict[str, Any]] = {
         "base_url": None,
         "requires_auth": False,
         "models": [
-            {"id": "claude-opus-4-6", "name": "Claude Opus"},
-            {"id": "claude-sonnet-4-5-20250929", "name": "Claude Sonnet"},
+            {"id": "claude-opus-4-7", "name": "Claude Opus"},
+            {"id": "claude-sonnet-4-6", "name": "Claude Sonnet"},
         ],
-        "default_model": "claude-opus-4-6",
+        "default_model": "claude-opus-4-7",
     },
     "kimi": {
         "name": "Kimi K2.5 (Moonshot)",
@@ -683,11 +811,11 @@ API_PROVIDERS: dict[str, dict[str, Any]] = {
         "requires_auth": True,
         "auth_env_var": "ANTHROPIC_API_KEY",
         "models": [
-            {"id": "claude-opus-4-6", "name": "Claude Opus"},
-            {"id": "claude-sonnet-4-5", "name": "Claude Sonnet"},
+            {"id": "claude-opus-4-7", "name": "Claude Opus"},
+            {"id": "claude-sonnet-4-6", "name": "Claude Sonnet"},
             {"id": "claude-haiku-4-5", "name": "Claude Haiku"},
         ],
-        "default_model": "claude-opus-4-6",
+        "default_model": "claude-opus-4-7",
     },
     "ollama": {
         "name": "Ollama (Local)",