@lazyingart/agintiflow 0.20.201 → 0.20.202

package/.env.example

@@ -6,6 +6,7 @@ LOCALLLM_BASE_URL=http://127.0.0.1:8008/v1
 LOCALLLM_API_KEY=local-dev-key
 AGINTI_LOCALLLM_ROUTE_MODEL=localllm-fast
 AGINTI_LOCALLLM_MAIN_MODEL=localllm-deep
+AGINTI_LOCALLLM_CODE_MODEL=localllm-code
 AGINTI_LOCALLLM_MAX_MODEL=localllm-max
 AGINTI_LOCALLLM_ALLOW_AUTO_MAX=false
 AGINTI_LOCALLLM_VISION_MODEL=localllm-vision-xl
@@ -13,8 +14,10 @@ AGINTI_LOCALLLM_CONTEXT_TOKENS=32768
 AGINTI_LOCALLLM_MAX_OUTPUT_TOKENS=8192
 AGINTI_LOCALLLM_TOOL_SCHEMA_TOKENS=4096
 
-# Auto-Max is off unless explicitly enabled. Enabled runs still require authenticated
-# alias discovery plus a fresh RAM/swap/GPU headroom check before selecting Max.
+# Genuine implementation work uses the code alias only after authenticated model
+# discovery confirms that exact configured alias; otherwise it remains on Deep.
+# Auto-Max is off unless explicitly enabled. Enabled non-code runs still require
+# authenticated alias discovery plus a fresh RAM/swap/GPU headroom check.
 # Hosted provider keys below never act as a LocalLLM failure fallback.
 
 # Optional explicit hosted upgrades. They are never automatic fallbacks.

package/README.md

@@ -85,7 +85,7 @@ aginti init --template aaps
 aginti init --template supervision
 ```
 
-By default, AgInTiFlow connects to the sibling LocalLLM gateway at `http://127.0.0.1:8008/v1`, using `localllm-fast` for routing and the installed 30B-A3B Q4 `localllm-deep` for substantive coding and agent work. The Q8 `localllm-max` remains resource-gated on every new or resumed run (24 GiB available RAM, no more than 75% swap use, and 40 GiB aggregate free NVIDIA memory). The automatic Vision policy requires both a trusted image-input signal and confirmed model capability; the shipped CLI/web currently use the readiness-checked local `read_image` tool or an explicit `localllm-vision-xl` selection rather than inferring vision from prompt keywords. Routing does not load a model. Startup checks the LocalLLM service, its Ollama runtime, selected aliases, and any required Max headroom before inference. A local failure stops with an actionable error; it never silently sends the task to a hosted provider.
+By default, AgInTiFlow connects to the sibling LocalLLM gateway at `http://127.0.0.1:8008/v1`, using `localllm-fast` for routing and the installed 30B-A3B Q4 `localllm-deep` for substantive general agent work. High-confidence coding and repository implementation requests begin on Deep, then switch to the provider-neutral `localllm-code` capability alias only after bearer-authenticated `/v1/models` discovery confirms that exact configured alias. If it is absent, the run stays on Deep; writing, research, documentation, design, explanation-only code questions, explicit providers, and manual model choices are not silently rerouted. Set `AGINTI_LOCALLLM_CODE_MODEL` to another LocalLLM capability alias without coupling AgInTiFlow to an engine tag. The Q8 `localllm-max` remains resource-gated on every new or resumed run (24 GiB available RAM, no more than 75% swap use, and 40 GiB aggregate free NVIDIA memory). The automatic Vision policy requires both a trusted image-input signal and confirmed model capability; the shipped CLI/web currently use the readiness-checked local `read_image` tool or an explicit `localllm-vision-xl` selection rather than inferring vision from prompt keywords. Routing does not load a model. Startup checks the LocalLLM service, its Ollama runtime, selected aliases, and any required Max headroom before inference. A local failure stops with an actionable error; it never silently sends the task to a hosted provider.
 
 Hosted providers are optional, explicit upgrades. When you select DeepSeek, OpenAI, OpenRouter, Qwen, or Venice, the auth wizard can save that provider's key account-wide in `~/.agintiflow/.env` with restricted permissions. Current project `.aginti/.env` files can still override account defaults when needed. You can rerun setup any time:
 
@@ -253,7 +253,7 @@ The website keeps the visual walkthrough in a carousel so this README can stay f
 | File tools | `inspect_project`, `list_files`, `read_file`, `search_files`, `write_file`, `apply_patch`, `open_workspace_file`, `preview_workspace`, and `read_image`. |
 | Shell tools | Guarded host or Docker workspace shell execution with package-install policy and command safety checks. |
 | Browser tools | Playwright browser actions with lazy startup and optional domain allowlists. |
-| Model routing | LocalLLM Fast/Deep defaults, explicit and resource-gated Max, image-capability-gated Vision XL, explicit DeepSeek/OpenAI/OpenRouter/Qwen/Venice/mock routes, and optional spare/wrapper/auxiliary models. |
+| Model routing | LocalLLM Fast/Deep defaults, authenticated implementation-only Code capability, explicit and resource-gated Max, image-capability-gated Vision XL, explicit DeepSeek/OpenAI/OpenRouter/Qwen/Venice/mock routes, and optional spare/wrapper/auxiliary models. |
 | Writing specialist | A dedicated writing-only LLM call for prose, chapters, scripts, books, essays, research-paper sections, and revisions, with formatter handoff notes for Markdown/LaTeX/Final Draft. |
 | Patch workflow | Codex-style patch envelopes, unified diffs, exact replacements, hashes, compact diffs, and path guardrails. |
 | Parallel scouts | Optional scout calls for architecture, implementation, review, tests, git flow, research, symbol tracing, and dependency risk. |
@@ -275,6 +275,7 @@ AgInTiFlow does not treat "the model" as one global setting. It has roles:
 | --- | --- | --- |
 | Route | `localllm/localllm-fast` | Local planner, triage, short tasks, and routing decisions. |
 | Main | `localllm/localllm-deep` | Local complex executor for coding, debugging, writing, research, and long tasks. |
+| Code capability | `localllm/localllm-code` | Smart implementation-only upgrade after authenticated alias discovery; unavailable aliases fall back to Deep. |
 | Spare | `localllm/localllm-deep` medium | Local cross-check lane; a hosted spare requires explicit selection. |
 | Wrapper | `codex/gpt-5.5` medium | Optional external coding-agent advisor; `research_wrapper` defaults to `gpt-5.4-mini` medium for image/web second opinions. |
 | Auxiliary | `grsai/nano-banana-2` (off) | Explicitly enabled image generation and other non-text helper tools; no credential-driven provider failover. |
@@ -372,6 +373,7 @@ LOCALLLM_BASE_URL=http://127.0.0.1:8008/v1
 LOCALLLM_API_KEY=local-dev-key
 AGINTI_LOCALLLM_ROUTE_MODEL=localllm-fast
 AGINTI_LOCALLLM_MAIN_MODEL=localllm-deep
+AGINTI_LOCALLLM_CODE_MODEL=localllm-code
 
 # Optional explicit hosted upgrades; never automatic LocalLLM fallbacks.
 DEEPSEEK_API_KEY=...

package/docs/local-first-agent-runtime.md

@@ -30,6 +30,7 @@ health:          http://127.0.0.1:8008/healthz
 models:          authenticated GET /v1/models
 route lane:      localllm-fast
 main lane:       localllm-deep
+coding lane:     localllm-code (authenticated, implementation-only capability upgrade)
 maximum lane:    localllm-max
 vision:          localllm-vision-xl
 embedding:       localllm-embed (sibling-service alias; not an AgInTi text-routing tier)
@@ -39,7 +40,7 @@ The default bearer value used by the local deployment is an interoperability pla
 
 Readiness requires both `health.ok === true` and `health.ollama.ok === true`, followed by an authenticated `/v1/models` check that confirms the requested alias exists. Health alone is not sufficient.
 
-The installed local ladder is capability- and resource-aware. `localllm-fast` handles short routing and bounded work; substantive coding and agent tasks use the 30B-A3B Q4 `localllm-deep` lane. The 30B-A3B Q8 `localllm-max` lane remains explicitly selectable, but every new or resumed Max run performs a fresh pre-inference gate after authenticated alias discovery. It requires at least 24 GiB available host RAM, swap use no higher than 75%, and 40 GiB aggregate free NVIDIA memory (Q8 weights plus working reserve). Missing GPU telemetry fails closed. Automatic Max is off by default and requires `AGINTI_LOCALLLM_ALLOW_AUTO_MAX=true`; an eligible run confirms the configured Max alias and fresh headroom before upgrading the actual model client from Deep. If the optional upgrade cannot be proven safe, it continues on Deep rather than failing. The automatic Vision policy requires both a trusted image-input signal and confirmed model capability. The shipped CLI/web currently reach vision through the local `read_image` tool or explicit `localllm-vision-xl` selection; both paths readiness-check the selected alias, and prompt keywords alone never activate Vision XL.
+The installed local ladder is capability- and resource-aware. `localllm-fast` handles short routing and bounded work; substantive general agent tasks use the 30B-A3B Q4 `localllm-deep` lane. High-confidence implementation work begins on Deep and may upgrade to the independently configured `AGINTI_LOCALLLM_CODE_MODEL` alias only when the same bearer-authenticated `/v1/models` response reports it. Missing or unverified availability stays on Deep, never a hosted provider. The implementation classifier excludes writing, research, paper, book, novel, design, documentation, slides, education, and image profiles, and requires an implementation action rather than a bare code mention or explanation request. The effective selection and a secret-free candidate policy are durable: selected coding sessions resume exactly, while a Deep fallback may re-evaluate authenticated availability on a later resume. Manual models and explicit providers remain exact. The 30B-A3B Q8 `localllm-max` lane remains explicitly selectable, but every new or resumed Max run performs a fresh pre-inference gate after authenticated alias discovery. It requires at least 24 GiB available host RAM, swap use no higher than 75%, and 40 GiB aggregate free NVIDIA memory (Q8 weights plus working reserve). Missing GPU telemetry fails closed. Automatic Max is off by default and requires `AGINTI_LOCALLLM_ALLOW_AUTO_MAX=true`; an eligible non-code run confirms the configured Max alias and fresh headroom before upgrading the actual model client from Deep. If the optional upgrade cannot be proven safe, it continues on Deep rather than failing. The automatic Vision policy requires both a trusted image-input signal and confirmed model capability. The shipped CLI/web currently reach vision through the local `read_image` tool or explicit `localllm-vision-xl` selection; both paths readiness-check the selected alias, and prompt keywords alone never activate Vision XL.
 
 ## Provider-neutral capabilities
 
@@ -171,6 +172,7 @@ Offline deterministic tests run on every change:
 - timeout before output, cancellation, and no post-cancel dispatch;
 - context calculation includes tool schemas and output reserve;
 - no silent hosted fallback;
+- implementation-only coding alias selection requires authenticated exact availability, with Deep fallback and durable resume behavior;
 - session resume preserves provider, model, capability profile, and executed-tool ledger.
 
 Live compatibility tests are opt-in because they load local models:
@@ -180,6 +182,7 @@ Live compatibility tests are opt-in because they load local models:
 | `localllm-pocket` / 4B (direct sibling-service compatibility alias, not an automatic AgInTi tier) | direct answer, one-tool selection, malformed-output recovery, truthful blocker |
 | `localllm-fast` / 8B | focused code inspection/edit/test loop, cancellation, resumed turn |
 | `localllm-deep` / 30B-A3B Q4 | multi-step plan, repair after failed tool evidence, long-context compaction |
+| `localllm-code` / configured coding capability | repository implementation/tool loop, exact-alias readiness, Deep fallback, resumed selection |
 | `localllm-max` / 30B-A3B Q8 | explicit opt-in, resource preflight, highest-fidelity local code task |
 | `localllm-vision-xl` / 30B-A3B Q4 | attached-image understanding with no keyword-only activation |
 | DeepSeek/OpenAI | same fixtures, plus explicit escalation and stronger-model quality comparison |

package/docs/model-selection.md

@@ -20,10 +20,11 @@ The local tier policy uses the workstation's installed aliases without treating
 | --- | --- | --- |
 | `localllm-fast` | Qwen3 8B Q4 routing and bounded work | Default for simple work. |
 | `localllm-deep` | Qwen3 30B-A3B Q4 substantive coding/agent work | Default for complex work. |
+| `localllm-code` | Provider-neutral coding capability (the sibling catalog currently maps it to Qwen3-Coder 30B-A3B Q4) | Smart selection only for high-confidence implementation work and only after authenticated availability; otherwise Deep. |
 | `localllm-max` | Qwen3 30B-A3B Q8 highest-fidelity local text/code | Explicit selection; automatic use additionally requires opt-in, authenticated availability, fresh resource readiness, and no shared-workstation pressure. |
 | `localllm-vision-xl` | Qwen3-VL 30B-A3B Q4 image understanding | The automatic policy requires a trusted image-input signal plus confirmed capability. The shipped CLI/web currently use readiness-checked `read_image` or explicit selection; prompt keywords alone do not activate it. |
 
-Installed aliases are not loaded during routing. Automatic Max is off by default; set `AGINTI_LOCALLLM_ALLOW_AUTO_MAX=true` to opt in. An opted-in high-complexity run starts on Deep, confirms the Max alias through authenticated `/v1/models`, and only then samples current resources. Unknown or pressured resource state stays on Deep. Explicit Max also cannot bypass the live gate: immediately before client creation, each new or resumed run rechecks at least 24 GiB available RAM, swap use at or below 75%, and 40 GiB aggregate free NVIDIA memory. A blocked explicit gate creates no model client and performs no inference.
+Installed aliases are not loaded during routing. A genuine coding/implementation request starts on Deep, checks the authenticated model inventory, and selects the exact `AGINTI_LOCALLLM_CODE_MODEL` value only when present. Missing or unverified capability stays on Deep; the decision and effective model are recorded so fallback sessions can re-evaluate and selected sessions resume on the same model. Explanation-only code questions and non-code writing/research/documentation/design keep their existing route. Automatic Max is off by default; set `AGINTI_LOCALLLM_ALLOW_AUTO_MAX=true` to opt in. An opted-in high-complexity non-code run starts on Deep, confirms the Max alias through authenticated `/v1/models`, and only then samples current resources. Unknown or pressured resource state stays on Deep. Explicit Max also cannot bypass the live gate: immediately before client creation, each new or resumed run rechecks at least 24 GiB available RAM, swap use at or below 75%, and 40 GiB aggregate free NVIDIA memory. A blocked explicit gate creates no model client and performs no inference.
 
 Long writing tasks use an additional tool boundary: `writing_specialist`. The main model still plans the run, manages files, formats Markdown/LaTeX/Final Draft output, compiles/checks artifacts, and finishes. The specialist gets only the writing brief, canon, style guide, prior draft, target, audience, constraints, and format intent, then returns prose plus a formatter handoff. It follows the active LocalLLM provider by default even when hosted keys exist. Cross-provider writing requires both an explicit target (`AGINTI_WRITING_PROVIDER` or a per-run provider override) and `AGINTI_ALLOW_HOSTED_WRITING_SPECIALIST=true` (or the equivalent per-run permission flag); language detection and ambient credentials never grant that permission.
 
@@ -75,7 +76,7 @@ Provider families:
 
 | Family | Models |
 | --- | --- |
-| LocalLLM | `localllm-fast`, `localllm-deep`, `localllm-max`, `localllm-vision-xl`; Max and Vision retain the gates above |
+| LocalLLM | `localllm-fast`, `localllm-deep`, `localllm-code`, `localllm-max`, `localllm-vision-xl`; Code, Max, and Vision retain the gates above |
 | DeepSeek | `deepseek-v4-flash`, `deepseek-v4-pro` |
 | Venice | `venice-uncensored-1-2`, `venice-uncensored`, `gemma-4-uncensored` |
 | OpenAI | `gpt-5.5`, `gpt-5.4`, `gpt-5.4-mini`, `gpt-5.3-codex`, `gpt-5.3-codex-spark`, `gpt-5.2`; each has low/medium/high/xhigh reasoning |
@@ -148,7 +149,7 @@ It keeps smart routing enabled. If the Venice key is missing, run `/auth venice`
 
 ## Keys
 
-The LocalLLM baseline uses `http://127.0.0.1:8008/v1` and the installation's loopback key (`local-dev-key` in the documented local setup). `AGINTI_LOCALLLM_MODEL` or `LOCALLLM_MODEL` is the shared local text override; role-specific `AGINTI_LOCALLLM_ROUTE_MODEL` and `AGINTI_LOCALLLM_MAIN_MODEL` take precedence. Optional `AGINTI_LOCALLLM_MAX_MODEL` and `AGINTI_LOCALLLM_VISION_MODEL` name the gated heavyweight aliases. LocalLLM overrides must remain loopback URLs. Generic `LLM_*` values do not redefine the local provider.
+The LocalLLM baseline uses `http://127.0.0.1:8008/v1` and the installation's loopback key (`local-dev-key` in the documented local setup). `AGINTI_LOCALLLM_MODEL` or `LOCALLLM_MODEL` is the shared local text override; role-specific `AGINTI_LOCALLLM_ROUTE_MODEL` and `AGINTI_LOCALLLM_MAIN_MODEL` take precedence. `AGINTI_LOCALLLM_CODE_MODEL` names the independently configurable coding capability alias; AgInTiFlow never needs the underlying engine tag. Optional `AGINTI_LOCALLLM_MAX_MODEL` and `AGINTI_LOCALLLM_VISION_MODEL` name the other gated heavyweight aliases. LocalLLM overrides must remain loopback URLs. Generic `LLM_*` values do not redefine the local provider.
 
 Keys are saved account-wide in `~/.agintiflow/.env` by default. Use `--project` only when the current project needs an override in ignored `.aginti/.env`:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.201",
+  "version": "0.20.202",
   "type": "module",
   "description": "AgInTiFlow is a project-aware agent workspace for hybrid wet-dry R&D, hardware-aware intelligence, software automation, and industrial workflows.",
   "license": "Apache-2.0",
@@ -77,6 +77,7 @@
     "scripts/smoke-inbox.js",
     "scripts/smoke-long-jobs.js",
     "scripts/smoke-localllm-auto-max.js",
+    "scripts/smoke-localllm-code-routing.js",
     "scripts/smoke-local-resource-policy.js",
     "scripts/smoke-localllm-model-tiers.js",
     "scripts/smoke-localllm-provider.js",
@@ -144,6 +145,7 @@
     "smoke:run-stdin": "node scripts/smoke-run-stdin.js",
     "smoke:runtime-core": "node scripts/smoke-runtime-core.js",
     "smoke:localllm-auto-max": "node scripts/smoke-localllm-auto-max.js",
+    "smoke:localllm-code-routing": "node scripts/smoke-localllm-code-routing.js",
     "smoke:local-resource-policy": "node scripts/smoke-local-resource-policy.js",
     "smoke:context-budget-recovery": "node scripts/smoke-context-budget-recovery.js",
     "smoke:localllm-model-tiers": "node scripts/smoke-localllm-model-tiers.js",
@@ -177,7 +179,7 @@
     "storage:migrate": "node bin/aginti-cli.js storage migrate",
     "publish:env": "node scripts/npm-publish-from-env.js publish --access public",
     "publish:env:whoami": "node scripts/npm-publish-from-env.js whoami",
-    "test": "npm run check && npm run smoke:localllm-provider && npm run smoke:localllm-model-tiers && npm run smoke:localllm-auto-max && npm run smoke:local-resource-policy && npm run smoke:context-budget-recovery && npm run smoke:session-runtime && npm run smoke:runtime-core && npm run smoke:progressive-tools && npm run smoke:truthful-completion && npm run smoke:writing-specialist-routing && npm run eval:local-first-agent && npm run eval:provider-attribution && npm run smoke:runtime-compat && npm run smoke:autoupdate && npm run smoke:web-api && npm run smoke:math-rendering && npm run smoke:web-ui && npm run smoke:web-autostart && npm run smoke:webapp-command && npm run smoke:web-port-fallback && npm run smoke:docker-command && npm run smoke:coding-tools && npm run smoke:dynamic-step-budget && npm run smoke:execution-policy && npm run smoke:aaps-adapter && npm run smoke:auxiliary-tools && npm run smoke:perception-research && npm run smoke:deep-research && npm run smoke:public-research && npm run smoke:safe-chat && npm run smoke:auth && npm run smoke:agentlink && npm run smoke:canvas-artifacts && npm run smoke:capabilities && npm run smoke:mcp && npm run smoke:model-roles && npm run smoke:platform && npm run smoke:permission-modes && npm run smoke:skills && npm run smoke:skillmesh && npm run smoke:tmux-tools && npm run smoke:long-jobs && npm run smoke:run-stdin && npm run smoke:cli-chat && npm run smoke:inbox",
+    "test": "npm run check && npm run smoke:localllm-provider && npm run smoke:localllm-model-tiers && npm run smoke:localllm-code-routing && npm run smoke:localllm-auto-max && npm run smoke:local-resource-policy && npm run smoke:context-budget-recovery && npm run smoke:session-runtime && npm run smoke:runtime-core && npm run smoke:progressive-tools && npm run smoke:truthful-completion && npm run smoke:writing-specialist-routing && npm run eval:local-first-agent && npm run eval:provider-attribution && npm run smoke:runtime-compat && npm run smoke:autoupdate && npm run smoke:web-api && npm run smoke:math-rendering && npm run smoke:web-ui && npm run smoke:web-autostart && npm run smoke:webapp-command && npm run smoke:web-port-fallback && npm run smoke:docker-command && npm run smoke:coding-tools && npm run smoke:dynamic-step-budget && npm run smoke:execution-policy && npm run smoke:aaps-adapter && npm run smoke:auxiliary-tools && npm run smoke:perception-research && npm run smoke:deep-research && npm run smoke:public-research && npm run smoke:safe-chat && npm run smoke:auth && npm run smoke:agentlink && npm run smoke:canvas-artifacts && npm run smoke:capabilities && npm run smoke:mcp && npm run smoke:model-roles && npm run smoke:platform && npm run smoke:permission-modes && npm run smoke:skills && npm run smoke:skillmesh && npm run smoke:tmux-tools && npm run smoke:long-jobs && npm run smoke:run-stdin && npm run smoke:cli-chat && npm run smoke:inbox",
     "pack:dry-run": "npm pack --dry-run",
     "smoke:capabilities": "node scripts/smoke-capabilities.js"
   },

package/scripts/smoke-auth.js

@@ -4,26 +4,22 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { authProviderKeyHelp, authProviderKeyUrl, normalizeAuthProvider } from "../src/auth-onboarding.js";
-import { getProviderDefaults } from "../src/model-routing.js";
-import { maskProviderKey, providerKeyPreview, providerKeyStatus, setProviderKey } from "../src/project.js";
 
 const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "agintiflow-auth-"));
-const envKeys = [
-  "DEEPSEEK_API_KEY",
-  "OPENAI_API_KEY",
-  "OPENROUTER_API_KEY",
-  "LLM_API_KEY",
-  "QWEN_API_KEY",
-  "VENICE_API_KEY",
-  "GRSAI",
-  "GRSAI_API_KEY",
-];
-const originalEnv = Object.fromEntries(envKeys.map((key) => [key, process.env[key]]));
-const originalAgintiflowHome = process.env.AGINTIFLOW_HOME;
-for (const key of envKeys) delete process.env[key];
+const CONFIG_ENV_PATTERN = /^(?:AGENT|AGINTI|AGINTIFLOW|LOCALLLM|LOCAL_LLM|LLM|DEEPSEEK|OPENAI|OPENROUTER|QWEN|VENICE|GRSAI|BRAVE|ALLOW_|WRAPPER_|MAX_STEPS$|SANDBOX_MODE$|USE_DOCKER_SANDBOX$|PACKAGE_INSTALL_POLICY$|COMMAND_CWD$|PREFERRED_WRAPPER$)/u;
+for (const key of Object.keys(process.env)) {
+  if (CONFIG_ENV_PATTERN.test(key)) delete process.env[key];
+}
 process.env.AGINTIFLOW_HOME = path.join(tempRoot, ".agintiflow-home");
+const [authOnboarding, modelRouting, project] = await Promise.all([
+  import("../src/auth-onboarding.js"),
+  import("../src/model-routing.js"),
+  import("../src/project.js"),
+]);
+const { authProviderKeyHelp, authProviderKeyUrl, normalizeAuthProvider } = authOnboarding;
+const { getProviderDefaults } = modelRouting;
+const { loadProjectEnv, maskProviderKey, providerKeyPreview, providerKeyStatus, setProviderKey } = project;
 
 function assert(condition, message) {
   if (!condition) throw new Error(message);
@@ -35,7 +31,12 @@ async function runCli(args, stdin = "") {
       cwd: tempRoot,
       stdio: ["pipe", "pipe", "pipe"],
       env: {
-        ...process.env,
+        PATH: process.env.PATH || "/usr/bin:/bin",
+        HOME: tempRoot,
+        USERPROFILE: tempRoot,
+        LANG: "C.UTF-8",
+        LC_ALL: "C.UTF-8",
+        AGINTIFLOW_HOME: process.env.AGINTIFLOW_HOME,
         AGINTIFLOW_RUNTIME_DIR: "",
       },
     });
@@ -89,7 +90,17 @@ try {
 
   const projectOnlyRoot = path.join(tempRoot, "project-only");
   await fs.mkdir(path.join(projectOnlyRoot, ".aginti"), { recursive: true });
-  await fs.writeFile(path.join(projectOnlyRoot, ".aginti", ".env"), 'OPENAI_API_KEY="project-only-openai-key"\n', "utf8");
+  await fs.writeFile(
+    path.join(projectOnlyRoot, ".aginti", ".env"),
+    ['OPENAI_API_KEY="project-only-openai-key"', 'AGINTI_LOCALLLM_CODE_MODEL="project-code-alias"', ""].join("\n"),
+    "utf8"
+  );
+  const projectOnlyEnv = loadProjectEnv(projectOnlyRoot);
+  assert(projectOnlyEnv.projectEnv, "project-only LocalLLM code model env was not parsed");
+  assert(
+    process.env.AGINTI_LOCALLLM_CODE_MODEL === "project-code-alias",
+    "AGINTI_LOCALLLM_CODE_MODEL was not loaded from the project env"
+  );
   let projectOnlyStatus = providerKeyStatus(projectOnlyRoot);
   assert(projectOnlyStatus.openai && projectOnlyStatus.projectEnv, "project-only key was not loaded");
   await fs.access(path.join(tempRoot, ".agintiflow-home", ".env"))
@@ -100,6 +111,7 @@ try {
       if (error?.code !== "ENOENT") throw error;
     });
   delete process.env.OPENAI_API_KEY;
+  delete process.env.AGINTI_LOCALLLM_CODE_MODEL;
 
   process.env.DEEPSEEK_API_KEY = "ambient-deepseek-key";
   process.env.OPENROUTER_API_KEY = "ambient-openrouter-key";
@@ -182,6 +194,7 @@ try {
           "openrouter-defaults",
           "venice-defaults",
           "project-key-not-auto-promoted",
+          "project-code-model-env",
           "ambient-key-discovery-is-read-only",
           "project-key-override",
           "qwen-key-status",
@@ -195,11 +208,8 @@ try {
     )
   );
 } finally {
-  for (const key of envKeys) {
-    if (originalEnv[key] === undefined) delete process.env[key];
-    else process.env[key] = originalEnv[key];
+  for (const key of Object.keys(process.env)) {
+    if (CONFIG_ENV_PATTERN.test(key)) delete process.env[key];
   }
-  if (originalAgintiflowHome === undefined) delete process.env.AGINTIFLOW_HOME;
-  else process.env.AGINTIFLOW_HOME = originalAgintiflowHome;
   await fs.rm(tempRoot, { recursive: true, force: true });
 }

package/scripts/smoke-localllm-auto-max.js

@@ -16,24 +16,16 @@ import {
 } from "../src/local-auto-max.js";
 import { LOCALLLM_AUTO_MAX_MIN_COMPLEXITY } from "../src/model-routing.js";
 
-const ENV_KEYS = [
-  "AGINTIFLOW_HOME",
-  "AGENT_PROVIDER",
-  "AGINTI_LOCALLLM_ALLOW_AUTO_MAX",
-  "AGINTI_LOCALLLM_MAX_MODEL",
-  "AGINTI_ROUTE_PROVIDER",
-  "AGINTI_ROUTE_MODEL",
-  "AGINTI_MAIN_PROVIDER",
-  "AGINTI_MAIN_MODEL",
-  "LLM_MODEL",
-];
-const envSnapshot = Object.fromEntries(ENV_KEYS.map((key) => [key, process.env[key]]));
+const CONFIG_ENV_PATTERN = /^(?:AGENT|AGINTI|AGINTIFLOW|LOCALLLM|LOCAL_LLM|LLM|DEEPSEEK|OPENAI|OPENROUTER|QWEN|VENICE|GRSAI|BRAVE|ALLOW_|WRAPPER_|MAX_STEPS$|SANDBOX_MODE$|USE_DOCKER_SANDBOX$|PACKAGE_INSTALL_POLICY$|COMMAND_CWD$|PREFERRED_WRAPPER$)/u;
 const TEST_BEARER_TOKEN = "smoke-auto-max-local-bearer";
 const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const smokeRoot = await fs.mkdtemp(path.join(os.tmpdir(), "agintiflow-auto-max-"));
+const smokeProject = path.join(smokeRoot, "project");
+await fs.mkdir(smokeProject, { recursive: true });
 const complexGoal = [
-  "Architect and implement a complex multi-file repository migration.",
-  "Debug the root cause, repair the regression, update the database and CI configuration,",
-  "review security and performance, then run the complete test suite.",
+  "Analyze a complex multi-file repository architecture and migration strategy.",
+  "Compare the root cause, database, CI, security, performance, Docker, Kubernetes, and systemd tradeoffs,",
+  "then produce a detailed design review without changing source files.",
 ].join(" ");
 
 function readiness(models = ["localllm-fast", "localllm-deep", "localllm-max"]) {
@@ -182,11 +174,14 @@ async function createIntegrationConfig({
 }
 
 try {
-  for (const key of ENV_KEYS) delete process.env[key];
+  for (const key of Object.keys(process.env)) {
+    if (CONFIG_ENV_PATTERN.test(key)) delete process.env[key];
+  }
+  process.env.AGINTIFLOW_HOME = path.join(smokeRoot, "home");
 
   const disabledConfig = resolveRuntimeConfig(
     { goal: complexGoal, taskProfile: "large-codebase" },
-    { baseDir: process.cwd(), provider: "localllm", routingMode: "smart" }
+    { baseDir: smokeProject, provider: "localllm", routingMode: "smart" }
   );
   assert.ok(disabledConfig.routeComplexityScore >= LOCALLLM_AUTO_MAX_MIN_COMPLEXITY);
   assert.equal(disabledConfig.model, "localllm-deep");
@@ -196,7 +191,7 @@ try {
   process.env.AGINTI_LOCALLLM_ALLOW_AUTO_MAX = "true";
   const optedInConfig = resolveRuntimeConfig(
     { goal: complexGoal, taskProfile: "large-codebase" },
-    { baseDir: process.cwd(), provider: "localllm", routingMode: "smart" }
+    { baseDir: smokeProject, provider: "localllm", routingMode: "smart" }
   );
   assert.equal(optedInConfig.model, "localllm-deep", "phase one must remain on Deep before authenticated discovery");
   assert.equal(optedInConfig.allowLocalAutoMax, true);
@@ -255,7 +250,7 @@ try {
   const explicitMax = resolveRuntimeConfig(
     { goal: complexGoal, taskProfile: "large-codebase", model: "localllm-max" },
     {
-      baseDir: process.cwd(),
+      baseDir: smokeProject,
       provider: "localllm",
       routingMode: "smart",
       model: "localllm-max",
@@ -266,7 +261,7 @@ try {
 
   const simpleConfig = resolveRuntimeConfig(
     { goal: "Say hello." },
-    { baseDir: process.cwd(), provider: "localllm", routingMode: "smart", allowLocalAutoMax: true }
+    { baseDir: smokeProject, provider: "localllm", routingMode: "smart", allowLocalAutoMax: true }
   );
   let simpleResourceChecks = 0;
   const simpleDecision = await resolveLocalAutoMaxUpgrade(simpleConfig, readiness(), {
@@ -278,10 +273,9 @@ try {
   assert.equal(simpleDecision.outcome, LOCALLLM_AUTO_MAX_OUTCOMES.INELIGIBLE);
   assert.equal(simpleResourceChecks, 0, "low-complexity work must never probe Max resources");
 
-  const integrationRoot = await fs.mkdtemp(path.join(os.tmpdir(), "agintiflow-auto-max-"));
-  process.env.AGINTIFLOW_HOME = path.join(integrationRoot, "home");
-  try {
-    await withLocalFixture(async ({ baseURL, observations: fixtureObservations }) => {
+  const integrationRoot = path.join(smokeRoot, "integration");
+  await fs.mkdir(integrationRoot, { recursive: true });
+  await withLocalFixture(async ({ baseURL, observations: fixtureObservations }) => {
       let selectedResourceChecks = 0;
       const selectedProbe = async () => {
         selectedResourceChecks += 1;
@@ -379,15 +373,12 @@ try {
       );
       assert.equal(fixtureObservations.modelRequests, 4);
       assert.equal(fixtureObservations.authenticatedModelRequests, 4);
-    });
-  } finally {
-    await fs.rm(integrationRoot, { recursive: true, force: true });
-  }
+  });
 } finally {
-  for (const [key, value] of Object.entries(envSnapshot)) {
-    if (value === undefined) delete process.env[key];
-    else process.env[key] = value;
+  for (const key of Object.keys(process.env)) {
+    if (CONFIG_ENV_PATTERN.test(key)) delete process.env[key];
   }
+  await fs.rm(smokeRoot, { recursive: true, force: true });
 }
 
 console.log("LocalLLM automatic Max two-phase policy smoke passed (offline; no model loads).\n");