v0.4.0: Complete R2/R3 reliability and performance improvements

- Fix Opus 4.6 pricing ($15/$75 -> $5/$25 per million tokens)
- Add BudgetTracker.summary()/as_dict() for structured budget introspection
- Add dynamic pricing: pact pricing command, ~/.config/pact/model_pricing.json
- Wire quality.py audit into contract authoring and validation gate
- Wire structured_side_effects into contract + test authoring prompts
- Wire performance_budget into contract + test authoring prompts
- Wire AuditedAnswer provenance tracking into InterviewResult + CLI approve
- Apply dependency name normalization in main validation gate
- Add pact_resume tool to MCP server
- Optimize implementer.py handoff briefs (include_test_code=False)
- 1501 tests passing, README and landing page updated

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

Author: jmcentire

.gitignore

@@ -36,3 +36,6 @@ Thumbs.db
 .env
 *.key
 *.pem
+
+# User-local pricing overrides
+model_pricing.json

README.md

@@ -170,6 +170,12 @@ pact build my-project sync_tracker --competitive --agents 3
 | `pact incidents <project>` | List active/recent incidents |
 | `pact incident <project> <id>` | Show incident details + diagnostic report |
 | `pact audit <project>` | Spec-compliance audit (compare task.md vs implementations) |
+| `pact tasks <project>` | List phase tasks with status |
+| `pact analyze <project>` | Run cross-artifact analysis |
+| `pact checklist <project>` | Generate requirements checklist |
+| `pact test-gen <project>` | Generate tests + security audit for any codebase |
+| `pact adopt <project>` | Adopt existing codebase under pact governance |
+| `pact pricing` | Show model pricing table (`--export` to override) |
 
 ## Configuration
 
@@ -186,7 +192,7 @@ plan_only: false
 
 # Override token pricing (per million tokens: [input, output])
 model_pricing:
-  claude-opus-4-6: [15.00, 75.00]
+  claude-opus-4-6: [5.00, 25.00]
   claude-sonnet-4-5-20250929: [3.00, 15.00]
   claude-haiku-4-5-20251001: [0.80, 4.00]
 
@@ -282,7 +288,7 @@ my-project/
 
 ```bash
 make dev          # Install with LLM backend support
-make test         # Run full test suite (1482 tests)
+make test         # Run full test suite (1501 tests)
 make test-quick   # Stop on first failure
 make clean        # Remove venv and caches
 ```

docs/index.html

@@ -655,7 +655,7 @@ <h2>If AI writes the code, who debugs it at 3am?</h2>
         <div class="step"><span class="arrow">&#9656;</span> <span>Fixer agent spawned with contract context</span></div>
         <div class="step"><span class="arrow">&#9656;</span> <span>Reproducer test added to contract</span></div>
         <div class="step"><span class="arrow">&#9656;</span> <span>Implementation rebuilt from scratch</span></div>
-        <div class="step"><span class="arrow">&#9656;</span> <span><span class="label">1,482 tests pass</span> <span class="dim">// verified</span></span></div>
+        <div class="step"><span class="arrow">&#9656;</span> <span><span class="label">1,501 tests pass</span> <span class="dim">// verified</span></span></div>
         <div class="step"><span class="arrow">&#9656;</span> <span>Contract got stricter. Bug can't recur.</span></div>
       </div>
     </div>

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pact-agents"
-version = "0.3.1"
+version = "0.4.0"
 description = "Contract-first multi-agent software engineering. Contracts before code. Tests as law. Agents that can't cheat."
 readme = "README.md"
 license = {text = "MIT"}

src/pact/agents/contract_author.py

@@ -28,7 +28,9 @@
 - Error cases must be exhaustive
 - Preconditions and postconditions must be verifiable
 - Dependencies must be explicitly declared
-- Names must be descriptive and consistent"""
+- Names must be descriptive and consistent
+- Functions with side effects must declare structured_side_effects (kind: none/reads_file/writes_file/network_call/mutates_state/logging, target, description)
+- Include performance_budget (p95_latency_ms, max_memory_mb, complexity) for performance-sensitive functions"""
 
 
 async def author_contract(
@@ -151,7 +153,9 @@ async def author_contract(
 - Include error cases for each function
 - Add preconditions and postconditions where meaningful
 - List all dependencies by component_id
-- All type references must resolve to types defined in this contract or primitives (str, int, float, bool, None, bytes, dict, list, any)"""
+- All type references must resolve to types defined in this contract or primitives (str, int, float, bool, None, bytes, dict, list, any)
+- Declare structured_side_effects for each function (use kind='none' for pure functions)
+- Set performance_budget on functions with latency or memory constraints"""
 
     contract, in_tok, out_tok = await agent.assess_cached(
         ComponentContract, prompt, CONTRACT_SYSTEM, cache_prefix=cache_prefix,
@@ -169,4 +173,10 @@ async def author_contract(
         in_tok + out_tok,
     )
 
+    # Quality audit — non-blocking warnings for vague language
+    from pact.quality import audit_contract_specificity
+    quality_warnings = audit_contract_specificity(contract)
+    for w in quality_warnings:
+        logger.warning("Quality: %s", w)
+
     return contract, research, plan

src/pact/agents/test_author.py

@@ -111,6 +111,25 @@ def _render_focused_contract(contract: ComponentContract) -> str:
                 for err in f.error_cases:
                     cond = f" when {err.condition}" if err.condition else ""
                     parts.append(f"    error: {err.name}{cond}")
+            # Structured side effects (or fall back to string side_effects)
+            if f.structured_side_effects:
+                for se in f.structured_side_effects:
+                    parts.append(f"    side_effect: {se.kind} -> {se.target}")
+            elif f.side_effects:
+                for se in f.side_effects:
+                    parts.append(f"    side_effect: {se}")
+            # Performance budget
+            if f.performance_budget:
+                pb = f.performance_budget
+                budget_parts = []
+                if pb.p95_latency_ms:
+                    budget_parts.append(f"p95<{pb.p95_latency_ms}ms")
+                if pb.max_memory_mb:
+                    budget_parts.append(f"mem<{pb.max_memory_mb}MB")
+                if pb.complexity:
+                    budget_parts.append(pb.complexity)
+                if budget_parts:
+                    parts.append(f"    performance: {', '.join(budget_parts)}")
 
     # Invariants
     if contract.invariants:

src/pact/budget.py

@@ -6,9 +6,11 @@
 
 from __future__ import annotations
 
+import json
 import logging
 import time
 from dataclasses import dataclass, field
+from pathlib import Path
 
 from pydantic import BaseModel, Field
 
@@ -20,7 +22,7 @@
     # Anthropic
     "claude-haiku-4-5-20251001": (0.80, 4.00),
     "claude-sonnet-4-5-20250929": (3.00, 15.00),
-    "claude-opus-4-6": (15.00, 75.00),
+    "claude-opus-4-6": (5.00, 25.00),
     # OpenAI
     "gpt-4o": (2.50, 10.00),
     "gpt-4o-mini": (0.15, 0.60),
@@ -217,6 +219,25 @@ def cache_hit_rate(self) -> float:
             return 0.0
         return self._cache_read_tokens / total
 
+    def summary(self) -> dict:
+        """Return a dict summarizing all budget and cache metrics."""
+        return {
+            "project_spend": self._project_spend,
+            "project_cap": self.per_project_cap,
+            "budget_remaining": self.budget_remaining,
+            "spend_percentage": self.spend_percentage,
+            "daily_spend": self.daily_spend,
+            "tokens_in": self._project_tokens_in,
+            "tokens_out": self._project_tokens_out,
+            "cache_creation_tokens": self._cache_creation_tokens,
+            "cache_read_tokens": self._cache_read_tokens,
+            "cache_hit_rate": self.cache_hit_rate,
+        }
+
+    def as_dict(self) -> dict:
+        """Alias for summary()."""
+        return self.summary()
+
 
 class PhaseBudget(BaseModel):
     """Budget tracking broken down by pipeline phase."""
@@ -270,3 +291,39 @@ def from_config(cls, shaping_budget_pct: float = 0.15) -> "PhaseBudget":
         if shaping_budget_pct > 0:
             caps["shape"] = shaping_budget_pct
         return cls(phase_caps=caps)
+
+
+# ── External pricing file ─────────────────────────────────────────
+
+
+DEFAULT_PRICING_PATH = Path("~/.config/pact/model_pricing.json").expanduser()
+
+
+def load_pricing_file(path: Path = DEFAULT_PRICING_PATH) -> dict[str, tuple[float, float]]:
+    """Load model pricing from a JSON file.
+
+    File format: {"model_id": [input_cost, output_cost], ...}
+    Returns dict suitable for set_model_pricing_table().
+    """
+    data = json.loads(path.read_text())
+    result: dict[str, tuple[float, float]] = {}
+    for model_id, costs in data.items():
+        if isinstance(costs, list) and len(costs) == 2:
+            result[model_id] = (float(costs[0]), float(costs[1]))
+    return result
+
+
+def save_pricing_file(
+    path: Path = DEFAULT_PRICING_PATH,
+    pricing: dict[str, tuple[float, float]] | None = None,
+) -> Path:
+    """Save pricing table to a JSON file. Defaults to current active pricing.
+
+    Returns the path written to.
+    """
+    if pricing is None:
+        pricing = get_model_pricing_table()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    data = {model: list(costs) for model, costs in sorted(pricing.items())}
+    path.write_text(json.dumps(data, indent=2) + "\n")
+    return path

src/pact/cli.py

@@ -246,6 +246,11 @@ def main() -> None:
     p_health = subparsers.add_parser("health", help="Check pipeline health (dysmemic pressure detection)")
     p_health.add_argument("project_dir", help="Project directory path")
 
+    # pricing
+    p_pricing = subparsers.add_parser("pricing", help="Show or export model pricing table")
+    p_pricing.add_argument("--export", action="store_true", help="Export pricing to ~/.config/pact/model_pricing.json")
+    p_pricing.add_argument("--json", action="store_true", dest="json_output", help="Output as JSON")
+
     args = parser.parse_args()
 
     if args.verbose:
@@ -325,6 +330,35 @@ def main() -> None:
         asyncio.run(cmd_adopt(args))
     elif args.command == "health":
         cmd_health(args)
+    elif args.command == "pricing":
+        cmd_pricing(args)
+
+
+def cmd_pricing(args: argparse.Namespace) -> None:
+    """Show or export model pricing table."""
+    from pact.budget import get_model_pricing_table, save_pricing_file, DEFAULT_PRICING_PATH
+
+    pricing = get_model_pricing_table()
+
+    if args.export:
+        path = save_pricing_file()
+        print(f"Pricing exported to {path}")
+        print("Edit this file to override default pricing.")
+        return
+
+    if args.json_output:
+        import json
+        data = {model: list(costs) for model, costs in sorted(pricing.items())}
+        print(json.dumps(data, indent=2))
+        return
+
+    print("Model Pricing (per million tokens)")
+    print(f"{'Model':<40} {'Input':>10} {'Output':>10}")
+    print("-" * 62)
+    for model, (inp, out) in sorted(pricing.items()):
+        print(f"{model:<40} ${inp:>8.2f} ${out:>8.2f}")
+    print()
+    print(f"Override file: {DEFAULT_PRICING_PATH}")
 
 
 def cmd_init(args: argparse.Namespace) -> None:
@@ -905,6 +939,21 @@ def cmd_approve(args: argparse.Namespace) -> None:
                 answer_sources.append((q, answer, "auto", confidence))
 
         interview.approved = True
+
+        # Build audited answers with provenance
+        from datetime import datetime, timezone
+        from pact.schemas import AuditedAnswer, AnswerSource
+        interview.audited_answers = [
+            AuditedAnswer(
+                question_id=f"q_{i:03d}",
+                answer=ans,
+                source=AnswerSource.USER_INTERACTIVE if src == "user" else AnswerSource.CLI_APPROVE,
+                confidence=conf,
+                timestamp=datetime.now(timezone.utc).isoformat(),
+            )
+            for i, (_, ans, src, conf) in enumerate(answer_sources)
+        ]
+
         project.save_interview(interview)
 
         # Print answer summary

src/pact/config.py

@@ -6,11 +6,14 @@
 
 from __future__ import annotations
 
+import logging
 import os
 from dataclasses import dataclass, field
 from enum import StrEnum
 from pathlib import Path
 
+logger = logging.getLogger(__name__)
+
 import yaml
 
 
@@ -248,9 +251,18 @@ def load_global_config(config_path: str | Path | None = None) -> GlobalConfig:
             fast=model_tiers_raw.get("fast", config.model_tiers.fast),
         )
 
-    # Apply pricing overrides if configured
+    # Load external pricing file if it exists
+    from pact.budget import DEFAULT_PRICING_PATH, load_pricing_file, set_model_pricing_table
+    if DEFAULT_PRICING_PATH.exists():
+        try:
+            file_overrides = load_pricing_file(DEFAULT_PRICING_PATH)
+            if file_overrides:
+                set_model_pricing_table(file_overrides)
+        except Exception as e:
+            logger.warning("Failed to load pricing file %s: %s", DEFAULT_PRICING_PATH, e)
+
+    # Apply pricing overrides from config (takes precedence over file)
     if config.model_pricing:
-        from pact.budget import set_model_pricing_table
         overrides = {
             model_id: (costs[0], costs[1])
             for model_id, costs in config.model_pricing.items()

src/pact/contracts.py

@@ -295,15 +295,25 @@ def validate_all_contracts(
         else:
             all_errors.extend(validate_test_suite(test_suites[node_id]))
 
+        # Quality audit — non-blocking warnings for vague language
+        from pact.quality import audit_contract_specificity
+        quality_warnings = audit_contract_specificity(contract)
+        for w in quality_warnings:
+            logger.warning("Quality: %s", w)
+
     # Check dependency contracts — distinguish internal vs external
     tree_component_ids = set(tree.nodes.keys()) if tree else set()
 
     for cid, contract in contracts.items():
         for dep_id in contract.dependencies:
-            if dep_id in contracts:
+            # Apply name normalization before resolution
+            resolved = normalize_dependency_name(dep_id, list(contracts.keys()))
+            effective_id = resolved or dep_id
+
+            if effective_id in contracts:
                 continue  # Internal dependency with contract — OK
 
-            if dep_id in tree_component_ids:
+            if effective_id in tree_component_ids:
                 # Internal (in decomposition tree) but missing contract — error
                 all_errors.append(
                     f"Contract '{cid}' depends on '{dep_id}' which is in the "