agentic-python-coder 3.2.0__tar.gz → 3.4.0__tar.gz

{agentic_python_coder-3.2.0 → agentic_python_coder-3.4.0}/.gitignore

@@ -154,7 +154,6 @@ uv.lock
 # Project specific
 tests/
 coder-examples/
-CLAUDE-archive.md
 EXPERTISE/
 PROCESS_NOTES.md
 conversation_log.json
@@ -162,8 +161,6 @@ coder_output.log
 task.md
 solution.py
 *.tmp
-CLAUDE.md
-**/CLAUDE.md
 TRASH/
 LOCAL/
 ASP/
@@ -172,7 +169,6 @@ CPMPY/
 PAPER/
 PAPER-ASP/
 ZEBRA/
-.mcp.json
 
 # Test files and folders (root level only)
 /test-*/

{agentic_python_coder-3.2.0 → agentic_python_coder-3.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-python-coder
-Version: 3.2.0
+Version: 3.4.0
 Summary: A lightweight Python coding agent that writes, executes, and iterates on code through natural language instructions
 Author: Stefan Szeider
 License: Apache-2.0
@@ -14,21 +14,21 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Code Generators
 Requires-Python: <3.14,>=3.13
-Requires-Dist: ipykernel>=7.2.0
-Requires-Dist: jupyter-client>=8.8.0
-Requires-Dist: mcp>=1.26.0
-Requires-Dist: openai>=2.21.0
-Requires-Dist: python-dotenv>=1.2.1
+Requires-Dist: ipykernel>=7.3.0
+Requires-Dist: jupyter-client>=8.9.1
+Requires-Dist: mcp>=1.28.1
+Requires-Dist: openai>=2.45.0
+Requires-Dist: python-dotenv>=1.2.2
 Requires-Dist: pyyaml>=6.0.3
-Requires-Dist: rich>=14.3.2
+Requires-Dist: rich>=15.0.0
 Provides-Extra: dev
-Requires-Dist: mypy>=1.19.1; extra == 'dev'
-Requires-Dist: ruff>=0.14.14; extra == 'dev'
+Requires-Dist: mypy>=2.2.0; extra == 'dev'
+Requires-Dist: ruff>=0.15.21; extra == 'dev'
 Provides-Extra: test
-Requires-Dist: pytest-asyncio>=1.3.0; extra == 'test'
-Requires-Dist: pytest-cov>=7.0.0; extra == 'test'
+Requires-Dist: pytest-asyncio>=1.4.0; extra == 'test'
+Requires-Dist: pytest-cov>=7.1.0; extra == 'test'
 Requires-Dist: pytest-watch>=4.2.0; extra == 'test'
-Requires-Dist: pytest>=9.0.2; extra == 'test'
+Requires-Dist: pytest>=9.1.1; extra == 'test'
 Description-Content-Type: text/markdown
 
 # Agentic Python Coder
@@ -147,19 +147,41 @@ coder -i
 ```bash
 # Built-in models (versioned names)
 coder --model sonnet45 "task"   # Claude Sonnet 4.5 (default)
+coder --model sonnet46 "task"   # Claude Sonnet 4.6
+coder --model sonnet5 "task"    # Claude Sonnet 5
 coder --model opus45 "task"     # Claude Opus 4.5
+coder --model opus48 "task"     # Claude Opus 4.8
 coder --model deepseek31 "task" # DeepSeek v3.1
 coder --model grok41 "task"     # X.AI Grok 4.1
 coder --model qwen3 "task"      # Qwen3 Coder
 coder --model gemini25 "task"     # Gemini Pro 2.5
 coder --model gemini3pro "task"    # Gemini 3 Pro Preview
+coder --model gemini31 "task"      # Gemini 3.1 Pro Preview
 coder --model gemini3flash "task"  # Gemini 3 Flash Preview (fast, low-cost)
 coder --model gpt52 "task"         # GPT-5.2
+coder --model gpt56sol "task"      # GPT-5.6 Sol
+coder --model gpt56terra "task"    # GPT-5.6 Terra
 
 # Custom model (JSON file)
 coder --model ./mymodel.json "task"
 ```
 
+A custom model JSON can also point at any OpenAI-compatible endpoint
+(OpenAI directly, a local Ollama/vLLM server, etc.) instead of OpenRouter:
+
+```json
+{
+  "path": "gpt-4o-mini",
+  "base_url": "https://api.openai.com/v1",
+  "api_key_env": "OPENAI_API_KEY",
+  "temperature": 0.0
+}
+```
+
+`base_url` overrides the OpenRouter endpoint; `api_key_env` names the
+environment variable holding the key for that endpoint (default:
+`OPENROUTER_API_KEY`).
+
 ### Project Templates
 
 Domain-specific templates improve results. Bundled examples are available on GitHub at [`coder/src/agentic_python_coder/examples/`](coder/src/agentic_python_coder/examples/). Use `--init` to copy them locally:
@@ -225,6 +247,7 @@ messages, stats, log_path = solve_task(
     save_log=True,                   # Save conversation log
     task_basename=None,              # Base name for output files
     step_limit=None,                 # Max agent steps (default: 200)
+    llm_config=None,                 # Pre-built LLMConfig (overrides model/api_key)
 )
 ```
 
@@ -253,6 +276,25 @@ messages2, stats2 = run_agent(agent, "Now plot column A", quiet=True)
 print(get_final_response(messages2))
 ```
 
+Instead of a model name, you can pass a pre-built `LLMConfig` wrapping any
+OpenAI-compatible client:
+
+```python
+from openai import OpenAI
+from agentic_python_coder import LLMConfig, create_coding_agent
+
+llm_config = LLMConfig(
+    client=OpenAI(api_key="...", base_url="https://api.openai.com/v1"),
+    model="gpt-4o-mini",
+    api_params={"temperature": 0.0},
+)
+
+agent = create_coding_agent(
+    working_directory="/tmp/workspace",
+    llm_config=llm_config,
+)
+```
+
 #### `get_openrouter_llm()` — LLM Access
 
 ```python

{agentic_python_coder-3.2.0 → agentic_python_coder-3.4.0}/README.md

@@ -114,19 +114,41 @@ coder -i
 ```bash
 # Built-in models (versioned names)
 coder --model sonnet45 "task"   # Claude Sonnet 4.5 (default)
+coder --model sonnet46 "task"   # Claude Sonnet 4.6
+coder --model sonnet5 "task"    # Claude Sonnet 5
 coder --model opus45 "task"     # Claude Opus 4.5
+coder --model opus48 "task"     # Claude Opus 4.8
 coder --model deepseek31 "task" # DeepSeek v3.1
 coder --model grok41 "task"     # X.AI Grok 4.1
 coder --model qwen3 "task"      # Qwen3 Coder
 coder --model gemini25 "task"     # Gemini Pro 2.5
 coder --model gemini3pro "task"    # Gemini 3 Pro Preview
+coder --model gemini31 "task"      # Gemini 3.1 Pro Preview
 coder --model gemini3flash "task"  # Gemini 3 Flash Preview (fast, low-cost)
 coder --model gpt52 "task"         # GPT-5.2
+coder --model gpt56sol "task"      # GPT-5.6 Sol
+coder --model gpt56terra "task"    # GPT-5.6 Terra
 
 # Custom model (JSON file)
 coder --model ./mymodel.json "task"
 ```
 
+A custom model JSON can also point at any OpenAI-compatible endpoint
+(OpenAI directly, a local Ollama/vLLM server, etc.) instead of OpenRouter:
+
+```json
+{
+  "path": "gpt-4o-mini",
+  "base_url": "https://api.openai.com/v1",
+  "api_key_env": "OPENAI_API_KEY",
+  "temperature": 0.0
+}
+```
+
+`base_url` overrides the OpenRouter endpoint; `api_key_env` names the
+environment variable holding the key for that endpoint (default:
+`OPENROUTER_API_KEY`).
+
 ### Project Templates
 
 Domain-specific templates improve results. Bundled examples are available on GitHub at [`coder/src/agentic_python_coder/examples/`](coder/src/agentic_python_coder/examples/). Use `--init` to copy them locally:
@@ -192,6 +214,7 @@ messages, stats, log_path = solve_task(
     save_log=True,                   # Save conversation log
     task_basename=None,              # Base name for output files
     step_limit=None,                 # Max agent steps (default: 200)
+    llm_config=None,                 # Pre-built LLMConfig (overrides model/api_key)
 )
 ```
 
@@ -220,6 +243,25 @@ messages2, stats2 = run_agent(agent, "Now plot column A", quiet=True)
 print(get_final_response(messages2))
 ```
 
+Instead of a model name, you can pass a pre-built `LLMConfig` wrapping any
+OpenAI-compatible client:
+
+```python
+from openai import OpenAI
+from agentic_python_coder import LLMConfig, create_coding_agent
+
+llm_config = LLMConfig(
+    client=OpenAI(api_key="...", base_url="https://api.openai.com/v1"),
+    model="gpt-4o-mini",
+    api_params={"temperature": 0.0},
+)
+
+agent = create_coding_agent(
+    working_directory="/tmp/workspace",
+    llm_config=llm_config,
+)
+```
+
 #### `get_openrouter_llm()` — LLM Access
 
 ```python

{agentic_python_coder-3.2.0 → agentic_python_coder-3.4.0}/coder/src/agentic_python_coder/__init__.py

@@ -1,6 +1,11 @@
 """Python Coding Agent - A minimal coding assistant using direct OpenAI API and OpenRouter."""
 
-__version__ = "3.0.0"
+from importlib.metadata import PackageNotFoundError, version as _package_version
+
+try:
+    __version__ = _package_version("agentic-python-coder")
+except PackageNotFoundError:  # running from source without installation
+    __version__ = "0.0.0+unknown"
 
 # High-level API (recommended for most users)
 from agentic_python_coder.runner import solve_task

{agentic_python_coder-3.2.0 → agentic_python_coder-3.4.0}/coder/src/agentic_python_coder/agent.py

@@ -50,6 +50,7 @@ def create_coding_agent(
     api_key: Optional[str] = None,
     todo: bool = False,
     verbose: bool = False,
+    llm_config: Optional[LLMConfig] = None,
 ) -> CodingAgent:
     """Create a ReAct agent for Python coding tasks.
 
@@ -65,6 +66,8 @@ def create_coding_agent(
         api_key: Optional API key override
         todo: If True, includes todo_write tool for task tracking
         verbose: If True, print progress info (default False for library use)
+        llm_config: Optional pre-built LLMConfig (any OpenAI-compatible
+            client); takes precedence over model/api_key
 
     Returns:
         Configured CodingAgent
@@ -77,17 +80,19 @@ def create_coding_agent(
         set_task_basename(task_basename)
 
     # Store packages for kernel initialization (clear if None to avoid state leaks)
+    # JSON-encoded: a comma join would corrupt specs like "pkg[extra1,extra2]"
     if with_packages is not None:
-        os.environ["CODER_WITH_PACKAGES"] = ",".join(with_packages)
+        os.environ["CODER_WITH_PACKAGES"] = json.dumps(with_packages)
     else:
         os.environ.pop("CODER_WITH_PACKAGES", None)
 
-    # Get LLM config
-    llm_config = get_openrouter_llm(
-        model=model or DEFAULT_MODEL,
-        api_key=api_key,
-        verbose=verbose,
-    )
+    # Get LLM config (a pre-built one takes precedence)
+    if llm_config is None:
+        llm_config = get_openrouter_llm(
+            model=model or DEFAULT_MODEL,
+            api_key=api_key,
+            verbose=verbose,
+        )
 
     # Create tool registry
     tools = create_tool_registry(todo=todo)
@@ -199,8 +204,9 @@ def run_agent(
     Returns:
         Tuple of (List of new messages from this call, Statistics dictionary)
     """
-    # Set working directory at execution time (not creation time)
-    # This prevents race conditions when multiple agents are created
+    # The working directory is a process-wide singleton; set it at execution
+    # time so it always matches the agent currently running (concurrent
+    # run_agent calls in one process are not supported)
     working_dir.set(agent.working_directory)
 
     limit = step_limit if step_limit is not None else DEFAULT_STEP_LIMIT
@@ -228,7 +234,7 @@ def run_agent(
     openai_tools = agent.tools.get_openai_tools()
 
     # ReAct loop
-    for step_num in range(limit):
+    for _ in range(limit):
         # Build request kwargs
         request_kwargs: dict[str, Any] = {
             "model": agent.llm_config.model,
@@ -243,13 +249,17 @@ def run_agent(
         # Call API
         response = agent.llm_config.client.chat.completions.create(**request_kwargs)
 
-        # Track tokens
+        # Track tokens (some providers return usage objects with None fields)
         if response.usage:
-            stats["token_consumption"]["input_tokens"] += response.usage.prompt_tokens
+            stats["token_consumption"]["input_tokens"] += (
+                response.usage.prompt_tokens or 0
+            )
             stats["token_consumption"]["output_tokens"] += (
-                response.usage.completion_tokens
+                response.usage.completion_tokens or 0
+            )
+            stats["token_consumption"]["total_tokens"] += (
+                response.usage.total_tokens or 0
             )
-            stats["token_consumption"]["total_tokens"] += response.usage.total_tokens
 
         if not response.choices:
             break
@@ -324,6 +334,29 @@ def run_agent(
                     }
                 )
 
+        elif response.choices[0].finish_reason == "length":
+            # Response cut off at max_tokens with no tool call — don't accept
+            # the truncated text as a final answer; ask the model to continue
+            agent.messages.append(
+                {
+                    "role": "assistant",
+                    "content": assistant_message.content or "",
+                }
+            )
+            agent.messages.append(
+                {
+                    "role": "user",
+                    "content": (
+                        "Your previous response was truncated at the max_tokens "
+                        "limit. Continue, and be more concise."
+                    ),
+                }
+            )
+            if not quiet:
+                print(
+                    "Warning: response truncated at max_tokens; asking model to continue"
+                )
+
         else:
             # No tool calls — final answer
             agent.messages.append(
@@ -333,6 +366,11 @@ def run_agent(
                 }
             )
             break
+    else:
+        # Loop exhausted without a final answer
+        stats["step_limit_reached"] = True
+        if not quiet:
+            print(f"Warning: step limit ({limit}) reached without a final response")
 
     stats["execution_time_seconds"] = time.time() - start_time
 

{agentic_python_coder-3.2.0 → agentic_python_coder-3.4.0}/coder/src/agentic_python_coder/cli.py

@@ -260,6 +260,9 @@ def validate_model(model):
             print(f"  - {m}")
         print("\nOr provide a path to a custom model JSON file.")
         sys.exit(1)
+    except ValueError as e:
+        print(f"Error: {e}")
+        sys.exit(1)
 
 
 def load_project_prompt(project_path: str) -> Optional[str]:
@@ -290,12 +293,19 @@ def load_project_prompt(project_path: str) -> Optional[str]:
 
 
 def run_interactive(
-    working_dir: Path, model: str, project_prompt: str, api_key: str, todo: bool
+    working_dir: Path,
+    model: str,
+    project_prompt: str,
+    api_key: str,
+    todo: bool,
+    with_packages=None,
 ):
     """Run the agent in interactive mode."""
     print(f"\nInteractive mode - working in: {working_dir}")
     if project_prompt:
         print("Project configuration loaded")
+    if with_packages:
+        print(f"Dynamic packages: {', '.join(with_packages)}")
     print("Type 'exit' or 'quit' to stop.\n")
 
     # Load system prompt
@@ -307,12 +317,12 @@ def run_interactive(
         system_prompt=system_prompt,
         model=model,
         project_prompt=project_prompt,
+        with_packages=with_packages,
         api_key=api_key,
         todo=todo,
         verbose=True,
     )
 
-    thread_id = "interactive"
     all_messages = []
     cumulative_stats = {
         "tool_usage": {},
@@ -333,7 +343,7 @@ def run_interactive(
                     continue
 
                 print("\nAgent working...\n")
-                messages, stats = run_agent(agent, user_input, thread_id, quiet=False)
+                messages, stats = run_agent(agent, user_input, quiet=False)
                 all_messages.extend(messages)
 
                 # Update cumulative stats
@@ -440,7 +450,12 @@ def main():
     try:
         if args.interactive:
             run_interactive(
-                working_dir, args.model, project_prompt, args.api_key, args.todo
+                working_dir,
+                args.model,
+                project_prompt,
+                args.api_key,
+                args.todo,
+                with_packages=args.with_packages,
             )
         else:
             # Use solve_task for the main flow

{agentic_python_coder-3.2.0 → agentic_python_coder-3.4.0}/coder/src/agentic_python_coder/examples/clingo/clingo.md

@@ -29,9 +29,10 @@ Before completing your solution, verify:
 ☐ 2. **Model solves correctly** - At least one answer set is found (or UNSAT handled)
 ☐ 3. **Optimization applied** - If problem asks for optimal, use #minimize/#maximize
 ☐ 4. **Solution extracted** - Answer set atoms properly extracted and formatted
+☐ 4b. **No Model escapes on_model** - All solution data extracted to plain Python objects inside the callback (touching a Model after solve() returns segfaults)
 ☐ 5. **Output format correct** - JSON output with appropriate structure
 ☐ 6. **Predicates meaningful** - Clear names that reflect the problem domain
-☐ 7. **Constraints verified** - All problem constraints are encoded
+☐ 7. **Constraints verified independently** - All problem constraints are encoded AND re-checked by a plain-Python verify() whose expectations are re-derived from the problem text, not from your encoding's own interpretation
 ☐ 8. **File written** - Create `solution.py` with complete working code
 
 ## Section 2: Critical Rules of Engagement
@@ -474,6 +475,38 @@ def extract_solution(model):
     return solution
 ```
 
+### CRITICAL: The Model Object Is Only Valid Inside on_model (Segfault Risk)
+
+The `clingo.Model` object passed to your `on_model` callback is only valid DURING
+that callback. After `ctl.solve()` returns, clingo frees the underlying model —
+touching it later is a use-after-free that crashes the Python process with a
+segmentation fault (exit code 139) and NO Python traceback.
+
+Extract everything you need into plain Python objects (ints, strings, lists, dicts)
+INSIDE the callback. Never store the Model object itself for later use.
+
+```python
+# WRONG - segfaults after solve() returns:
+saved = None
+def on_model(m):
+    global saved
+    saved = m                        # Model outlives the callback
+ctl.solve(on_model=on_model)
+atoms = saved.symbols(atoms=True)    # use-after-free -> SIGSEGV, no traceback
+
+# CORRECT - extract inside the callback:
+result = []
+def on_model(m):
+    for a in m.symbols(atoms=True):
+        if a.match("assigned", 2):
+            result.append((str(a.arguments[0]), str(a.arguments[1])))
+ctl.solve(on_model=on_model)
+# work with the plain tuples in result
+```
+
+This also applies to verification: snapshot the atoms into plain Python inside
+`on_model`, then run your checks on the snapshot after solving.
+
 ## Section 4: Problem-Solving Pattern Library
 
 ### 4.1 Modeling State and Change (NEW - CRITICAL)
@@ -964,6 +997,36 @@ possible_col(C) :- col(C).
 4. **Let solver determine gaps**: Don't over-constrain non-run cells
 5. **Different is adjacent**: Cells of different colors/states CAN touch
 
+### 4.11 "Reachable Only After" / Ordered Reachability Constraints
+
+When a problem requires that some target element become reachable only after all
+other elements (or only after specific ones) under an evolving reachability process,
+do NOT model it as an existential ordering — guessing a permutation with the target
+pinned last only proves that SOME order exists, which is weaker than what such
+problems ask. The intended reading is almost always about the actual reachability
+process: everything reachable gets reached as soon as it is reachable.
+
+Model the process directly with a time-indexed fixpoint and constrain first-reach
+times:
+
+```asp
+step(0..max_step).
+reached(S, 0) :- start(S).
+reached(Y, T+1) :- edge(X, Y), reached(X, T), step(T+1), unlocked(X, Y, T).
+reached(X, T+1) :- reached(X, T), step(T+1).                    % persistence
+first_reached(X, 0) :- reached(X, 0).
+first_reached(X, T) :- reached(X, T), not reached(X, T-1), T > 0, step(T).
+
+% target must not become reachable before (or together with) any other element:
+:- first_reached(target, Tg), first_reached(X, Tx), X != target, Tx >= Tg.
+```
+
+Adapt `unlocked/3` to whatever gates progression (collected items, satisfied
+prerequisites, ...). Verify with a plain-Python simulation of the same process:
+repeatedly add everything currently reachable, one step at a time, and check the
+required ordering of first-reach steps against the problem text — do not reuse
+your encoding's ordering predicates in the verifier.
+
 ## Section 5: Debugging & Advanced Techniques
 
 ### 5.1 Efficient Generation: Constrain Choices Early (Anti-Pattern: Generate-and-Filter)

agentic_python_coder-3.4.0/coder/src/agentic_python_coder/examples/cpmpy/cpmpy.md

@@ -0,0 +1,100 @@
+# CPMPY project prompt
+
+You are solving constraint programming problems using CPMpy.
+
+## Core Rules
+
+1. Use CPMpy's constraint modeling - never write search algorithms
+2. Output ONLY valid JSON using `json.dumps()` - no other text
+3. Always `import json` if outputting JSON
+4. Check the exact output format required
+5. Test your solution manually to verify it satisfies the problem
+
+## Basic Template
+```python
+from cpmpy import *
+import json
+
+# Variables
+# Constraints  
+# Solve
+if model.solve():
+    # Build result dict as specified
+    result = {...}
+    # Verify solution satisfies problem requirements
+    print(json.dumps(result))
+else:
+    print(json.dumps({"error": "No solution"}))
+```
+
+## Essential Constraints
+- `AllDifferent(vars)` - all different values
+- `sum(vars) == total` - sum constraint
+- `Circuit(x)` - variables x form a Hamiltonian circuit (for routing/tour problems)
+- `InDomain(var, [values])` - restrict variable to a set of values. **Must be explicitly imported**: `from cpmpy import InDomain`
+- Logical: `&`, `|`, `~` on constraints; `(cond).implies(other)` on constraints only
+- Comparison: `==`, `!=`, `<`, `<=`, `>`, `>=` between variables and expressions
+- Element: `vars[idx]` where idx is a decision variable (direct indexing works)
+
+## CPMpy Pitfalls - Avoid These
+- Do NOT use `.is_in()`, `.in_domain()`, or other methods that don't exist — use `InDomain(var, list)` instead
+- Do NOT use `~var` on integer variables — `~` only works on boolean constraints
+- Do NOT call `.implies()` on integer variables — only on boolean expressions/constraints
+- If an operator/method fails, fall back to explicit OR/AND over individual equality constraints
+- When in doubt, use simple comparisons and loops instead of advanced abstractions
+
+## Optimization
+- Use `model.minimize(objective)` or `model.maximize(objective)`
+- CPMpy automatically finds the OPTIMAL solution, not just first valid
+- The solver continues searching until it proves optimality
+- Always verify the objective value matches your expectation
+- Example:
+  ```python
+  profit = sum(price[i] * x[i] for i in range(n))
+  model.maximize(profit)
+  ```
+
+## Output Format Rules
+- Follow the output JSON format specification EXACTLY — do not invent alternative encodings
+- If a field is described as nested arrays, output nested arrays (e.g., `[[1,2],[3,4]]`), never compress to single integers
+- If the narrative text conflicts with the explicit "Output format" block, the Output format block wins
+- If the narrative mentions optional variants or extensions of the problem ("one extension is...", "another version..."), solve the base problem as specified by the input data and the Output format block — do not output an extended variant unless the output spec explicitly requires it
+- Derive every output array's dimensions from parameters stated in the problem and from the axis names in the format spec: `result[a][b]` means outer axis `a` and inner axis `b` — never swap axes or substitute a different quantity
+- Check array dimensions and value ranges match the spec before saving
+
+## Verification Requirement (MANDATORY)
+
+CPMpy models can easily contain subtle logic bugs. Before saving, you MUST:
+
+1. **Solve and extract** the solution values
+2. **Write a `verify()` function** that checks every constraint from the problem statement using plain Python loops and asserts — independent of your CPMpy model:
+   ```python
+   def verify(result):
+       # Check array shapes — sizes re-derived from the problem text,
+       # NOT from variables your model introduced
+       assert len(result["schedule"]) == n_weeks
+       # Check each constraint with plain Python
+       for w in range(n_weeks):
+           teams_this_week = [result["schedule"][w][p] for p in range(n_periods)]
+           assert len(set(teams_this_week)) == len(teams_this_week), "Duplicate team in week"
+       # ... check ALL constraints from the problem statement
+       print("All checks passed")
+   ```
+
+   The verifier must be derived from the problem text alone: re-read the problem
+   statement and re-derive every expected dimension, entry encoding, and constraint
+   from its own parameters. Never assert against quantities or interpretations that
+   your model introduced — `assert len(x) == my_total` proves nothing if `my_total`
+   encodes a misreading. If your model and your verifier share an assumption, a
+   wrong assumption passes silently.
+3. **Execute the verification** via python_exec and confirm it passes
+4. **For optimization**: verify optimality by re-solving with a stricter bound:
+   ```python
+   model2 = Model(model.constraints)
+   model2 += objective < best_value  # or > for maximize
+   assert not model2.solve(), "Solution is not optimal"
+   ```
+
+Do NOT call save_code until verification passes. If it fails, fix the model and re-verify.
+
+That's it. Read the problem carefully, model it declaratively, verify independently, and let CPMpy find the optimal solution.