misterdev 0.2.2__tar.gz → 0.3.1__tar.gz

{misterdev-0.2.2/misterdev.egg-info → misterdev-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: misterdev
-Version: 0.2.2
+Version: 0.3.1
 Summary: An autonomous, extensible LLM build orchestrator that plans, edits, and verifies code across languages.
 Author-email: David Condrey <david@writerslogic.com>
 License-Expression: AGPL-3.0-or-later
@@ -138,12 +138,20 @@ Every change runs through an ordered gate sequence: **build → lint → tests
 
 ### Dynamic model selection
 
-misterdev keeps a per-model **performance ledger** and pairs it with a **cost-aware selector** that picks for quality-per-dollar, **harvests free models** where they hold up, and caches responses to avoid paying twice. It runs against **OpenRouter or Anthropic** with automatic failover, and token budgeting keeps spend inside the ceiling you set.
+misterdev keeps a per-model **performance ledger** and pairs it with a **cost-aware selector** that picks for quality-per-dollar across the **full breadth of OpenRouter** — routing each task up a **capability ladder** (harvested free / cheap → a strong mid-tier → a frontier tier) and **escalating to a stronger model only when a cheaper one can't clear the gates**. The strongest tier is reserved for the final attempt, so frontier spend is the rare safety net, not the default; a hard task that a mid model stalls on is finished by a frontier model, while easy tasks resolve on free/cheap ones. Quality never drops because a weak model that writes bad code fails the gate and the policy climbs. It runs against **OpenRouter or Anthropic** with automatic failover, caches responses to avoid paying twice, and token budgeting keeps spend inside the ceiling you set.
 
 ### Parallel worktrees
 
 Disjoint tasks run concurrently, each in its own **isolated git worktree**, so independent work doesn't contend for the tree. An **integration gate** re-checks each wave against the full suite and reverts any task that regresses it — parallelism without cross-contamination.
 
+### Self-improving
+
+misterdev keeps a durable, fingerprinted stream of its own real failures and runs an **AlphaEvolve-style keep-if-better loop** over its own source: it attributes what breaks, classifies *why* (harness artifact vs observation gap vs capability), proposes a targeted structural self-edit, and promotes it only when it beats the champion on a **held-out task set it never optimized against** — with zero regressions. A reward-hacking guardrail walls off the tests and benchmark. The result is a loop that removes whole failure classes over time **without overfitting** to any one benchmark. See [docs/path-to-100.md](docs/path-to-100.md).
+
+On the correctness side, misterdev works **reproduction-first**: for an issue-driven task it synthesizes a failing test from the acceptance criteria, **validates that the test actually fails on the clean tree** (a test that reproduces nothing is discarded rather than trusted), then drives the fix to turn it green — so the model edits toward a concrete, verified target instead of a description.
+
+**Two-timescale evolution** *(design; see [docs/two-timescale-evolution.md](docs/two-timescale-evolution.md))* takes the self-improvement further than a memoryless runtime agent can: the agent invents task-specific tools at runtime, and the ones that **prove they generalize** are consolidated — through the same held-out promotion gate — into a **persistent, best-per-capability tool library that future runs start from**. Fast loop explores; slow loop keeps the winners; the held-out gate keeps the library general rather than benchmark-overfit. Capability compounds across runs instead of being reinvented each task.
+
 ### Extensibility
 
 Tools, gates, and targets **self-register through Python entry points**. `pip install misterdev-plugin-x` adds a capability with **zero edits to the core** — misterdev discovers the entry point at runtime and wires it in. A working example lives at [`examples/misterdev-plugin-hello`](examples/misterdev-plugin-hello). See [Extending misterdev](#extending-misterdev).
@@ -152,6 +160,18 @@ Tools, gates, and targets **self-register through Python entry points**. `pip in
 
 misterdev can connect to **Model Context Protocol** servers and let the model call their discovered tools mid-build — bounded, opt-in, and constrained by a tool allowlist. Transports include stdio and **remote streamable-http with auth**, so you can point it at a hosted MCP gateway like **Glama** and give the build access to a whole catalog of tools without running any of them locally.
 
+## Benchmarks
+
+Gate-verified pass@1 on [Aider's polyglot benchmark](https://github.com/Aider-AI/polyglot-benchmark) (Exercism exercises with hidden test suites), `anthropic/claude-sonnet-4-6`:
+
+| Language | Solved | Rate |
+| --- | --- | --- |
+| JavaScript | 9 / 10 | **90%** |
+| Python | 8 / 10 | **80%** |
+| Rust | 7 / 10 | **70%** |
+
+A continuous stress run has solved **20/20** across the three languages with zero failures — including the exercises usually cited as hard (bowling, forth, arbitrary-precision decimal). Every solve is judged by the exercise's own hidden tests, not the model's say-so. Full numbers, methodology, and how to reproduce: **[docs/benchmark-results.md](docs/benchmark-results.md)**. Test suite: **1,897 passing** — **[docs/TESTING.md](docs/TESTING.md)**.
+
 ## CLI reference
 
 **Don't want to remember flags?** If the first argument isn't a subcommand,

{misterdev-0.2.2 → misterdev-0.3.1}/README.md

@@ -85,12 +85,20 @@ Every change runs through an ordered gate sequence: **build → lint → tests
 
 ### Dynamic model selection
 
-misterdev keeps a per-model **performance ledger** and pairs it with a **cost-aware selector** that picks for quality-per-dollar, **harvests free models** where they hold up, and caches responses to avoid paying twice. It runs against **OpenRouter or Anthropic** with automatic failover, and token budgeting keeps spend inside the ceiling you set.
+misterdev keeps a per-model **performance ledger** and pairs it with a **cost-aware selector** that picks for quality-per-dollar across the **full breadth of OpenRouter** — routing each task up a **capability ladder** (harvested free / cheap → a strong mid-tier → a frontier tier) and **escalating to a stronger model only when a cheaper one can't clear the gates**. The strongest tier is reserved for the final attempt, so frontier spend is the rare safety net, not the default; a hard task that a mid model stalls on is finished by a frontier model, while easy tasks resolve on free/cheap ones. Quality never drops because a weak model that writes bad code fails the gate and the policy climbs. It runs against **OpenRouter or Anthropic** with automatic failover, caches responses to avoid paying twice, and token budgeting keeps spend inside the ceiling you set.
 
 ### Parallel worktrees
 
 Disjoint tasks run concurrently, each in its own **isolated git worktree**, so independent work doesn't contend for the tree. An **integration gate** re-checks each wave against the full suite and reverts any task that regresses it — parallelism without cross-contamination.
 
+### Self-improving
+
+misterdev keeps a durable, fingerprinted stream of its own real failures and runs an **AlphaEvolve-style keep-if-better loop** over its own source: it attributes what breaks, classifies *why* (harness artifact vs observation gap vs capability), proposes a targeted structural self-edit, and promotes it only when it beats the champion on a **held-out task set it never optimized against** — with zero regressions. A reward-hacking guardrail walls off the tests and benchmark. The result is a loop that removes whole failure classes over time **without overfitting** to any one benchmark. See [docs/path-to-100.md](docs/path-to-100.md).
+
+On the correctness side, misterdev works **reproduction-first**: for an issue-driven task it synthesizes a failing test from the acceptance criteria, **validates that the test actually fails on the clean tree** (a test that reproduces nothing is discarded rather than trusted), then drives the fix to turn it green — so the model edits toward a concrete, verified target instead of a description.
+
+**Two-timescale evolution** *(design; see [docs/two-timescale-evolution.md](docs/two-timescale-evolution.md))* takes the self-improvement further than a memoryless runtime agent can: the agent invents task-specific tools at runtime, and the ones that **prove they generalize** are consolidated — through the same held-out promotion gate — into a **persistent, best-per-capability tool library that future runs start from**. Fast loop explores; slow loop keeps the winners; the held-out gate keeps the library general rather than benchmark-overfit. Capability compounds across runs instead of being reinvented each task.
+
 ### Extensibility
 
 Tools, gates, and targets **self-register through Python entry points**. `pip install misterdev-plugin-x` adds a capability with **zero edits to the core** — misterdev discovers the entry point at runtime and wires it in. A working example lives at [`examples/misterdev-plugin-hello`](examples/misterdev-plugin-hello). See [Extending misterdev](#extending-misterdev).
@@ -99,6 +107,18 @@ Tools, gates, and targets **self-register through Python entry points**. `pip in
 
 misterdev can connect to **Model Context Protocol** servers and let the model call their discovered tools mid-build — bounded, opt-in, and constrained by a tool allowlist. Transports include stdio and **remote streamable-http with auth**, so you can point it at a hosted MCP gateway like **Glama** and give the build access to a whole catalog of tools without running any of them locally.
 
+## Benchmarks
+
+Gate-verified pass@1 on [Aider's polyglot benchmark](https://github.com/Aider-AI/polyglot-benchmark) (Exercism exercises with hidden test suites), `anthropic/claude-sonnet-4-6`:
+
+| Language | Solved | Rate |
+| --- | --- | --- |
+| JavaScript | 9 / 10 | **90%** |
+| Python | 8 / 10 | **80%** |
+| Rust | 7 / 10 | **70%** |
+
+A continuous stress run has solved **20/20** across the three languages with zero failures — including the exercises usually cited as hard (bowling, forth, arbitrary-precision decimal). Every solve is judged by the exercise's own hidden tests, not the model's say-so. Full numbers, methodology, and how to reproduce: **[docs/benchmark-results.md](docs/benchmark-results.md)**. Test suite: **1,897 passing** — **[docs/TESTING.md](docs/TESTING.md)**.
+
 ## CLI reference
 
 **Don't want to remember flags?** If the first argument isn't a subcommand,

{misterdev-0.2.2 → misterdev-0.3.1}/misterdev/__init__.py

@@ -1,3 +1,3 @@
 """misterdev — an autonomous, extensible LLM build orchestrator."""
 
-__version__ = "0.2.2"
+__version__ = "0.3.1"

{misterdev-0.2.2 → misterdev-0.3.1}/misterdev/agent.py

@@ -38,6 +38,7 @@ from misterdev.core.planning.sovereign import (
     ProbeGenerator,
 )
 from misterdev.core.planning.metacognition import SessionAuditor
+from misterdev.core.learning import FailureLog, SolvedTaskIndex
 from misterdev.core.context.contracts import ContractRegistry
 from misterdev.core.verification.preflight import PreflightValidator
 from misterdev.core.execution.progress import (
@@ -51,6 +52,10 @@ from misterdev.core.models import Task
 from misterdev.analyzers.project_analyzer import (
     analyze_project,
 )
+from misterdev.analyzers.project_analyzer.detection import (
+    detect_lint_command,
+    detect_typecheck_command,
+)
 from misterdev.core.planning.advisor import recommend_work
 from misterdev.llm.client import BudgetExceededError
 from misterdev.task_executors.markdown_plan_executor import (
@@ -86,6 +91,7 @@ class ProjectOrchestrator:
     def __init__(self):
         self.registry = ProjectRegistry()
         self.last_build_succeeded = True
+        self.last_build_cost = 0.0
 
     def scan_directory(self, path: str | Path):
         self.registry.discover_projects(path)
@@ -428,16 +434,40 @@ class ProjectOrchestrator:
             )
         report.key_decisions.append(f"Halted by budget ceiling: {error}")
         report.finalize()
-        usage = project.llm_client.cumulative_usage
-        report.llm_calls = usage.call_count
-        report.llm_tokens = usage.total_tokens
-        report.llm_prompt_tokens = getattr(usage, "prompt_tokens", 0)
-        report.llm_completion_tokens = getattr(usage, "completion_tokens", 0)
-        report.llm_cache_read_tokens = getattr(usage, "cache_read_tokens", 0)
-        report.llm_cost = usage.estimated_cost
+        report.apply_llm_usage(project.llm_client.cumulative_usage)
+        self._persist_learning(project, report)
         report.save(project.path)
         return report.to_markdown()
 
+    def _persist_learning(self, project: Project, report: BuildReport) -> None:
+        """Record this build's spend, real failures, and solved tasks.
+
+        Runs on EVERY terminated build — normal completion and budget halt alike.
+        A budget-exhausted run spent the whole cap and still failed, so it is the
+        highest-signal failure; dropping it would blind the exact features
+        (evolution-from-failures, warm-start) that learn from real use. Each write
+        is best-effort so bookkeeping never turns a finished build into a crash.
+        """
+        # Expose this build's spend so a caller (e.g. the benchmark runner) can
+        # attribute per-run cost without re-deriving it from the saved report.
+        self.last_build_cost = float(
+            getattr(project.llm_client.cumulative_usage, "estimated_cost", 0.0)
+        )
+        try:
+            FailureLog(
+                project.path / ".orchestrator" / "failures.jsonl"
+            ).record_failures(report.failed_tasks)
+        except Exception as e:
+            logger.warning(f"Failure logging failed (non-fatal): {e}")
+            report.degraded_subsystems.append(f"Failure logging: {e}")
+        try:
+            SolvedTaskIndex(
+                project.path / ".orchestrator" / "solved_tasks.jsonl"
+            ).record(report.completed_tasks)
+        except Exception as e:
+            logger.warning(f"Solved-task indexing failed (non-fatal): {e}")
+            report.degraded_subsystems.append(f"Solved-task indexing: {e}")
+
     def interactive_plan(self, project_path: str | Path, args: str = "") -> str:
         """Analyze the project, recommend work, and compose a plan with the user.
 
@@ -649,15 +679,33 @@ class ProjectOrchestrator:
         # Sovereign enhancements (metacognition, AB-MCTS) are best-effort: they
         # refine the spec but must not crash the build, so each degrades to the
         # current spec on failure rather than aborting before any work is done.
-        auditor = SessionAuditor(project.path, project.llm_client)
+        # One embedder, shared by lesson retrieval and warm-start, so a similar
+        # lesson/task surfaces by MEANING, not just shared tokens. Best-effort:
+        # None (no fastembed / disabled) degrades both to lexical ranking.
+        embedder = self._learning_embedder(project)
+        auditor = SessionAuditor(project.path, project.llm_client, embedder=embedder)
         try:
-            lessons = auditor.get_lessons_context()
+            # Bias retrieval toward lessons relevant to this build's goal.
+            lessons = auditor.get_lessons_context(prompt)
             if lessons:
                 spec = f"{lessons}\n\n{spec}"
         except Exception as e:
             logger.warning(f"Lesson injection failed (non-fatal): {e}")
             report.degraded_subsystems.append(f"Lesson injection: {e}")
 
+        # Warm-start: seed the spec with how similar tasks were solved before, so a
+        # recurring shape starts from a proven approach instead of cold.
+        solved_index = SolvedTaskIndex(
+            project.path / ".orchestrator" / "solved_tasks.jsonl", embedder=embedder
+        )
+        try:
+            priors = solved_index.context(prompt)
+            if priors:
+                spec = f"{priors}\n\n{spec}"
+        except Exception as e:
+            logger.warning(f"Warm-start injection failed (non-fatal): {e}")
+            report.degraded_subsystems.append(f"Warm-start injection: {e}")
+
         # AB-MCTS branch-and-evaluate is off by default: it fires several serial
         # LLM calls before any work begins (observed ~30 min on one build) for
         # marginal spec refinement. Opt in with orchestrator.enable_ab_mcts.
@@ -690,6 +738,7 @@ class ProjectOrchestrator:
             max_tasks=max_tasks,
             file_map=file_map,
             targets=targets,
+            staging_hint=self._staging_hint(project),
         )
         tasks = topological_sort(tasks)
 
@@ -760,7 +809,11 @@ class ProjectOrchestrator:
             commands = {
                 "build_command": assessment.structure.build_command,
                 "test_command": assessment.structure.test_command,
-                "lint_command": assessment.structure.lint_command,
+                "lint_command": assessment.structure.lint_command
+                or detect_lint_command(project.path),
+                "audit_command": assessment.structure.audit_command,
+                "typecheck_command": project.config.get("typecheck_command")
+                or detect_typecheck_command(project.path),
                 "golden_command": get_setting(
                     project.config, "orchestrator", "golden_command"
                 ),
@@ -863,18 +916,31 @@ class ProjectOrchestrator:
             logger.warning(f"Session audit failed (non-fatal): {e}")
             report.degraded_subsystems.append(f"Session audit: {e}")
 
-        usage = project.llm_client.cumulative_usage
-        report.llm_calls = usage.call_count
-        report.llm_tokens = usage.total_tokens
-        report.llm_prompt_tokens = getattr(usage, "prompt_tokens", 0)
-        report.llm_completion_tokens = getattr(usage, "completion_tokens", 0)
-        report.llm_cache_read_tokens = getattr(usage, "cache_read_tokens", 0)
-        report.llm_cost = usage.estimated_cost
+        report.apply_llm_usage(project.llm_client.cumulative_usage)
         report.cost_by_task = dict(getattr(project.llm_client, "cost_by_task", {}))
+        # Learning writes + spend accounting, shared with the budget-halt path so
+        # a budget-exhausted run (the highest-signal failure) is not silently
+        # dropped from the streams the self-improvement features learn from.
+        self._persist_learning(project, report)
 
         report.save(project.path)
         return report.to_markdown()
 
+    def _learning_embedder(self, project: Project):
+        """A shared embedder for lesson/warm-start retrieval, or None.
+
+        Reuses the project's embedding-backend config (which prefers a free,
+        offline local model and honours "none"), so semantic ranking is opt-in via
+        the same setting that governs context ranking. Any failure returns None,
+        degrading retrieval to lexical rather than breaking the build."""
+        try:
+            from misterdev.llm.client.embeddings import create_embedding_client
+
+            return create_embedding_client(project.config)
+        except Exception as e:
+            logger.debug(f"Learning embedder unavailable, using lexical ranking: {e}")
+            return None
+
     def _capture_head(self, project: Project) -> Optional[str]:
         """Best-effort current HEAD sha, or None outside a git repo / on error."""
         if not (project.path / ".git").exists():
@@ -1723,6 +1789,108 @@ class ProjectOrchestrator:
         choice = Prompt.ask("Proceed?", choices=["y", "n", "s", "q"], default="y")
         return {"y": "proceed", "q": "quit", "s": "skip", "n": "quit"}[choice]
 
+    def _staging_hint(self, project: Project) -> str:
+        """Dense-reward staging suggestion for a single complex source file.
+
+        Uses the already-built symbol graph: when every public symbol lives in ONE
+        non-test source file, that is a single-file goal — synthesize ordered
+        construction->mutation->query stages so the decomposer can split it into a
+        few sequential, independently-verifiable sub-tasks (raises per-attempt
+        success on state-heavy files). Empty for multi-file goals or when nothing
+        stages; never raises.
+        """
+        try:
+            from misterdev.core.planning.verifier_decomposition import (
+                render_stages,
+                synthesize_stages,
+            )
+
+            graph = getattr(getattr(project, "topography", None), "graph", None)
+            symbols = list(getattr(graph, "symbols", {}).values()) if graph else []
+            src = [
+                s
+                for s in symbols
+                if getattr(s, "file_path", "") and "test" not in s.file_path.lower()
+            ]
+            if len({s.file_path for s in src}) != 1:
+                return ""  # staging only applies to a single-file goal
+            stages = synthesize_stages(src)
+            if len(stages) < 2:
+                return ""
+            return (
+                "\n## Suggested staging (dense-reward decomposition)\n"
+                "This file's public API splits into ordered, independently-"
+                "verifiable stages. Prefer ONE sequential sub-task per stage, in "
+                "this order (each must compile and leave the suite no worse):\n"
+                f"{render_stages(stages)}\n"
+            )
+        except Exception as e:  # a staging hint must never break decomposition
+            logger.debug(f"Staging hint skipped (non-fatal): {e}")
+            return ""
+
+    def _ground_completion_spec(
+        self, assessment: ProjectAssessment, project: Project
+    ) -> str:
+        """Build a COMPLETE-mode spec grounded in objective signals.
+
+        A vague "complete everything" goal on a real codebase otherwise churns:
+        the completeness analyzer flags "incomplete"/"stub" items from a lossy
+        overview and mislabels deliberate design (graceful degradation, platform
+        no-ops) as work, so the spec becomes a pile of speculative tasks. Instead
+        lead with HARD signals — a failing build, failing tests, located
+        TODO/FIXME markers, broken references — which are objective and
+        verifiable, add features the docs promise but are absent, and demote the
+        analyzer's guesses to an explicit "do NOT task these unless corroborated"
+        advisory. When nothing hard or documented exists, the goal is ill-posed:
+        emit zero-task guidance rather than fabricate work.
+        """
+        h = assessment.health
+        f = assessment.features
+        hard: list[str] = []
+        if not h.builds and h.build_output:
+            hard.append(
+                f"- The build is FAILING; fix it first:\n{h.build_output[:400]}"
+            )
+        if not h.tests_pass and h.test_output:
+            hard.append(f"- Tests are FAILING:\n{h.test_output[:400]}")
+        hard.extend(f"- Broken: {item}" for item in f.broken)
+        hard.extend(
+            f"- {t.get('file', '?')}:{t.get('line', '?')} {t.get('text', '')}"
+            for t in f.todos[:20]
+        )
+        documented = [f"- {m.name}: {m.description}" for m in f.missing]
+        speculative = [f"- {i.name}: {i.description}" for i in f.incomplete]
+        speculative += [f"- Stub: {s}" for s in f.stubs]
+
+        parts = [f"# Completion Spec\n## Project: {project.name}\n"]
+        if hard:
+            parts.append(
+                "## Must Fix — objective, verifiable failures\n" + "\n".join(hard)
+            )
+        if documented:
+            parts.append(
+                "\n## Should Add — promised by the docs but absent\n"
+                + "\n".join(documented)
+            )
+        if not hard and not documented:
+            parts.append(
+                "## No concrete objective found\n"
+                "The build and tests pass and there are no TODO/FIXME markers or "
+                "documented-but-missing features. A vague 'complete everything' goal "
+                "has no well-posed work here. Do NOT fabricate tasks from speculation: "
+                "produce ZERO tasks and report that a specific objective (a feature, a "
+                "bug to fix, or --focus <area>) is required."
+            )
+        if speculative:
+            parts.append(
+                "\n## Advisory — analyzer guesses, NOT tasks\n"
+                "Inferred as incomplete/stub from a lossy overview; these often "
+                "mislabel deliberate design. Do NOT create a task for any of these "
+                "unless a failing test or build error above corroborates it.\n"
+                + "\n".join(speculative[:15])
+            )
+        return "\n".join(parts)
+
     def _generate_spec(
         self,
         mode: BuildMode,
@@ -1751,28 +1919,7 @@ class ProjectOrchestrator:
             return "\n".join(parts)
 
         if mode == BuildMode.COMPLETE:
-            parts = [
-                f"# Completion Spec\n## Project: {project.name}",
-                "## Goal: Complete all work\n",
-                "### Must Complete",
-            ]
-            for f in assessment.features.incomplete:
-                parts.append(f"- {f.name}: {f.description}")
-            parts.append("\n### Must Fix")
-            for item in assessment.features.broken:
-                parts.append(f"- {item}")
-            for item in assessment.features.stubs:
-                parts.append(f"- Stub: {item}")
-            parts.append("\n### Should Add")
-            for f in assessment.features.missing:
-                parts.append(f"- {f.name}: {f.description}")
-            if assessment.features.todos:
-                parts.append(f"\n### TODOs ({len(assessment.features.todos)} items)")
-                for todo in assessment.features.todos[:20]:
-                    parts.append(
-                        f"- {todo.get('file', '?')}:{todo.get('line', '?')} {todo.get('text', '')}"
-                    )
-            return "\n".join(parts)
+            return self._ground_completion_spec(assessment, project)
 
         if mode == BuildMode.SPEC:
             spec_path = project.path / prompt.strip()

{misterdev-0.2.2 → misterdev-0.3.1}/misterdev/analyzers/project_analyzer/__init__.py

@@ -17,6 +17,7 @@ from misterdev.llm.client import BaseLLMClient
 from misterdev.logging_setup import setup_logger
 
 from .detection import (
+    detect_audit_command,
     detect_build_command,
     detect_test_command,
     has_test_files,
@@ -109,6 +110,7 @@ def analyze_project(
     )
     assessment.structure.build_command = bc
     assessment.structure.test_command = tc
+    assessment.structure.audit_command = detect_audit_command(project_path)
     health_ground = _health_ground_truth(assessment.health)
 
     def analyze_structure():

{misterdev-0.2.2 → misterdev-0.3.1}/misterdev/analyzers/project_analyzer/detection.py

@@ -131,6 +131,110 @@ def detect_build_command(project_path: Path) -> Optional[str]:
     return None
 
 
+def detect_audit_command(project_path: Path) -> Optional[str]:
+    """Detect a dependency/security-audit command from project markers.
+
+    Supply-chain scanning (the layer above lint): surfaces known-vulnerable
+    dependencies. Returns a runnable command, or None when no recognized
+    ecosystem is found. The audit gate is advisory and SKIPs when the tool is
+    absent, so returning a command the environment may lack is safe.
+    """
+    p = project_path
+    if (p / "Cargo.toml").exists():
+        return "cargo audit"
+    if (p / "package.json").exists():
+        return "npm audit --omit=dev"
+    if (p / "pyproject.toml").exists() or (p / "requirements.txt").exists():
+        return "uv run pip-audit" if (p / "uv.lock").exists() else "pip-audit"
+    if any(p.glob("*.sln")) or any(p.glob("*.csproj")):
+        return "dotnet list package --vulnerable --include-transitive"
+    return None
+
+
+def detect_lint_command(project_path: Path) -> Optional[str]:
+    """Detect a strict linter command from project markers.
+
+    Fallback used when no ``lint_command`` is configured — so the strict tools
+    the guidance recommends actually run in the G2 gate. Conservative: only
+    returns a command when the tool is standard for the ecosystem (clippy ships
+    with rustup) or a config file proves it is set up, so an absent linter never
+    produces a false lint failure.
+    """
+    p = project_path
+    if (p / "Cargo.toml").exists():
+        return "cargo clippy --all-targets --all-features -- -D warnings"
+    ruff_cfg = (p / "ruff.toml").exists() or (p / ".ruff.toml").exists()
+    if ruff_cfg or (
+        (p / "pyproject.toml").exists() and _file_mentions(p / "pyproject.toml", "ruff")
+    ):
+        return "uv run ruff check ." if (p / "uv.lock").exists() else "ruff check ."
+    if (p / "package.json").exists() and any(
+        any(p.glob(pat)) for pat in ("eslint.config.*", ".eslintrc", ".eslintrc.*")
+    ):
+        return "npx --no-install eslint . --max-warnings 0"
+    if (p / "Package.swift").exists() and (p / ".swiftlint.yml").exists():
+        return "swiftlint --strict"
+    if (p / "detekt.yml").exists() or (p / "detekt-config.yml").exists():
+        return "detekt"
+    return None
+
+
+def detect_typecheck_command(project_path: Path) -> Optional[str]:
+    """Detect a standalone type-check command, distinct from the build.
+
+    Only for ecosystems where type-checking is separate from compilation
+    (TypeScript's ``tsc --noEmit``, Python's mypy/pyright) — for compiled
+    languages the build gate already type-checks, so returning one would just
+    duplicate G1. Gated on a config file; the G4 gate SKIPs when the tool is
+    absent, so an uninstalled checker never blocks.
+    """
+    p = project_path
+    if (p / "tsconfig.json").exists():
+        return "npx --no-install tsc --noEmit"
+    mypy_cfg = (
+        (p / "mypy.ini").exists()
+        or (p / ".mypy.ini").exists()
+        or (
+            (p / "pyproject.toml").exists()
+            and _file_mentions(p / "pyproject.toml", "[tool.mypy]")
+        )
+    )
+    if mypy_cfg:
+        return "uv run mypy ." if (p / "uv.lock").exists() else "mypy ."
+    if (p / "pyrightconfig.json").exists():
+        return "pyright"
+    return None
+
+
+def dependency_add_command(project_path: Path, package: str) -> Optional[str]:
+    """Return the command to add a dependency, respecting the lock/manager in use.
+
+    None when the ecosystem edits its manifest by hand (SwiftPM) or is
+    unrecognized. Callers use this for deliberate dependency additions; a
+    refactor must not touch the lock file, only a genuine add.
+    """
+    p = project_path
+    if (p / "Cargo.toml").exists():
+        return f"cargo add {package}"
+    if (p / "package.json").exists():
+        if (p / "pnpm-lock.yaml").exists():
+            return f"pnpm add {package}"
+        if (p / "yarn.lock").exists():
+            return f"yarn add {package}"
+        if (p / "bun.lockb").exists():
+            return f"bun add {package}"
+        return f"npm install {package}"
+    if (p / "pyproject.toml").exists():
+        return (
+            f"uv add {package}"
+            if (p / "uv.lock").exists()
+            else f"pip install {package}"
+        )
+    if any(p.glob("*.csproj")):
+        return f"dotnet add package {package}"
+    return None
+
+
 def _file_mentions(path: Path, needle: str) -> bool:
     try:
         return needle in path.read_text(encoding="utf-8")

{misterdev-0.2.2 → misterdev-0.3.1}/misterdev/config.py

@@ -41,7 +41,23 @@ class LLMSettings:
     # models maps tier name -> model id (or a list of candidate ids). Empty =
     # use the default model.
     routing: Dict[str, Any] = field(default_factory=dict)
-    models: Dict[str, Any] = field(default_factory=dict)
+    # Default capability ladder (grounded in the live OpenRouter catalog). The
+    # cheapest rung also receives auto-harvested free models (use_free_models);
+    # the strongest rung is reached ONLY on the final attempt (see ModelSelector),
+    # so frontier spend is the rare safety net, not the default. Each rung lists
+    # candidates cheapest-strong first so a quality-per-dollar tie breaks toward
+    # the cheaper option and the ledger learns which model wins each cell.
+    models: Dict[str, Any] = field(
+        default_factory=lambda: {
+            "cheap": ["deepseek/deepseek-r1-0528"],
+            "mid": ["anthropic/claude-sonnet-4.6"],
+            "frontier": [
+                "openai/gpt-5.1-codex",
+                "google/gemini-3.1-pro-preview",
+                "anthropic/claude-opus-4.8",
+            ],
+        }
+    )
     # Ledger-driven dynamic model selection. False = off (default), True = on
     # using selection_posture, "auto" = self-activating: explore cheap/free
     # models on easy tasks while a (category, complexity) cell is immature, then
@@ -51,7 +67,7 @@ class LLMSettings:
     # resolves through `models`. The policy uses a cheaper model on early
     # attempts and climbs to the strongest tier by the final attempt.
     dynamic_selection: Any = "auto"
-    escalation: List[str] = field(default_factory=list)
+    escalation: List[str] = field(default_factory=lambda: ["cheap", "mid", "frontier"])
     # A cheaper model is trusted for a first attempt only once it has at least
     # min_observations recorded first-try attempts and a first-try success rate
     # at or above first_try_floor.
@@ -228,9 +244,11 @@ class OrchestratorSettings:
     # off by default (marginal value, large latency/cost).
     enable_ab_mcts: bool = False
     # Empirical probe discovery (SMART/CREATE Phase 1.5) runs an LLM call plus
-    # ephemeral scripts to verify facts before planning. On by default (it grounds
-    # the spec), but set false for a cheaper/faster run that skips the pre-work.
-    enable_probes: bool = True
+    # ephemeral scripts to verify facts before planning. OFF by default: measured
+    # to balloon the pre-execution context (~900K tokens over ~9 calls on a
+    # trivial task) and exhaust the whole budget before any code is written. Worth
+    # enabling only for complex work against an unfamiliar live codebase.
+    enable_probes: bool = False
     # Auto-detect polyglot sub-projects (targets) when none are declared, so a
     # monorepo gets per-toolchain gate routing with zero config. Off by default
     # (explicit ``targets`` is more precise); detected commands are best-effort.
@@ -301,6 +319,15 @@ class OrchestratorSettings:
     critic_auto_categories: List[str] = field(
         default_factory=lambda: ["refactor", "fix", "integration"]
     )
+    # Self-reflection on a failed attempt (the Reflexion pattern). When on, a
+    # failed gate triggers a short model reflection on the ROOT CAUSE and what to
+    # do differently, accumulated across attempts and fed into the next one — so a
+    # retry debugs the underlying problem instead of re-patching the symptom. On
+    # by default: it only ADDS guidance on a failure (never on a first attempt or
+    # a success), is timeout-bounded, and SKIPs cleanly with no client. Costs one
+    # extra short call per failed attempt; set false to disable entirely.
+    reflection: bool = True
+    reflection_timeout: int = 45
     # Independent completeness-claim verifier. Before a build composes its spec
     # and tasks, each feature the analyzer flagged "incomplete" and each "stub"
     # file is rechecked against the REAL file + tests by a second component
@@ -314,6 +341,11 @@ class OrchestratorSettings:
     # claim's judgment.
     verify_claims: bool = True
     verify_claims_timeout: int = 45
+    # Failure-triggered probe: on a red test gate, re-run ONLY the first failing
+    # test in isolation and append its fresh, uncluttered trace to the retry
+    # context. Off by default — the re-run costs a test invocation (cheap for
+    # pytest/jest, a full compile for cargo/swift/dotnet), so it is opt-in.
+    failure_probe: bool = False
 
 
 PROMPT_TEMPLATES = {

{misterdev-0.2.2 → misterdev-0.3.1}/misterdev/core/context/contracts/__init__.py

@@ -34,6 +34,13 @@ from .rust_tree_sitter import (
     _ts_variant_names,
     _walk_rust_ts,
 )
+from .c_tree_sitter import _extract_c_symbols_ts
+from .cpp_tree_sitter import _extract_cpp_symbols_ts
+from .csharp_tree_sitter import _extract_csharp_symbols_ts
+from .javascript_tree_sitter import _extract_javascript_symbols_ts
+from .kotlin_tree_sitter import _extract_kotlin_symbols_ts
+from .swift_tree_sitter import _extract_swift_symbols_ts
+from .typescript_tree_sitter import _extract_typescript_symbols_ts
 
 __all__ = [
     "logger",
@@ -60,4 +67,11 @@ __all__ = [
     "_ts_pub_members",
     "_ts_variant_names",
     "_ts_trait_methods",
+    "_extract_swift_symbols_ts",
+    "_extract_kotlin_symbols_ts",
+    "_extract_typescript_symbols_ts",
+    "_extract_javascript_symbols_ts",
+    "_extract_cpp_symbols_ts",
+    "_extract_c_symbols_ts",
+    "_extract_csharp_symbols_ts",
 ]