@lazyingart/agintiflow 0.20.188 → 0.20.190

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.188",
+  "version": "0.20.190",
   "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",

package/public/app.js

@@ -711,8 +711,10 @@ const modelRoleGridEl = document.querySelector("#model-role-grid");
 const modelRoutePillEl = document.querySelector("#model-route-pill");
 const routeProviderField = document.querySelector("#routeProvider");
 const routeModelField = document.querySelector("#routeModel");
+const routeReasoningField = document.querySelector("#routeReasoning");
 const mainProviderField = document.querySelector("#mainProvider");
 const mainModelField = document.querySelector("#mainModel");
+const mainReasoningField = document.querySelector("#mainReasoning");
 const spareProviderField = document.querySelector("#spareProvider");
 const spareModelField = document.querySelector("#spareModel");
 const spareReasoningField = document.querySelector("#spareReasoning");
@@ -1859,17 +1861,19 @@ function renderModelRoles() {
       ...(modelRoles.route || {}),
       provider: routeProviderField?.value || modelRoles.route?.provider || "deepseek",
       model: routeModelField?.value || modelRoles.route?.model || "deepseek-v4-flash",
+      reasoning: routeReasoningField?.value ?? modelRoles.route?.reasoning ?? "",
     },
     main: {
       ...(modelRoles.main || {}),
       provider: mainProviderField?.value || modelRoles.main?.provider || "deepseek",
       model: mainModelField?.value || modelRoles.main?.model || "deepseek-v4-pro",
+      reasoning: mainReasoningField?.value ?? modelRoles.main?.reasoning ?? "",
     },
     spare: {
       ...(modelRoles.spare || {}),
       provider: spareProviderField?.value || modelRoles.spare?.provider || "openai",
       model: spareModelField?.value || modelRoles.spare?.model || "gpt-5.4",
-      reasoning: spareReasoningField?.value || modelRoles.spare?.reasoning || "medium",
+      reasoning: spareReasoningField?.value ?? modelRoles.spare?.reasoning ?? "medium",
     },
     wrapper: {
       ...(modelRoles.wrapper || {}),
@@ -1885,7 +1889,7 @@ function renderModelRoles() {
   };
   modelRoleGridEl.innerHTML = Object.values(roles)
     .map((role) => {
-      const reasoning = role.reasoning ? ` · ${role.reasoning}` : "";
+      const reasoning = role.reasoning ? ` · ${role.reasoning}` : role.reasoning === "" ? " · Provider default" : "";
       return `
         <div class="model-role-card">
           <strong>${escapeHtml(role.label || role.id)}</strong>
@@ -2077,11 +2081,13 @@ function formPayload() {
     model: fieldValue(modelField),
     routeProvider: routeProviderField?.value || "deepseek",
     routeModel: fieldValue(routeModelField) || "deepseek-v4-flash",
+    routeReasoning: routeReasoningField?.value ?? "",
     mainProvider: mainProviderField?.value || "deepseek",
     mainModel: fieldValue(mainModelField) || "deepseek-v4-pro",
+    mainReasoning: mainReasoningField?.value ?? "",
     spareProvider: spareProviderField?.value || "openai",
     spareModel: fieldValue(spareModelField) || "gpt-5.4",
-    spareReasoning: spareReasoningField?.value || "medium",
+    spareReasoning: spareReasoningField?.value ?? "medium",
     wrapperModel: fieldValue(wrapperModelField) || "gpt-5.5",
     wrapperReasoning: wrapperReasoningField?.value || "medium",
     auxiliaryProvider: auxiliaryProviderField?.value || "grsai",
@@ -3918,7 +3924,7 @@ veniceModeToggle?.addEventListener("change", () => {
 });
 
 modelField.addEventListener("change", updateRoutingHint);
-[routeProviderField, routeModelField, mainProviderField, mainModelField, spareProviderField, spareModelField, spareReasoningField, wrapperModelField, wrapperReasoningField, auxiliaryProviderField, auxiliaryModelField]
+[routeProviderField, routeModelField, routeReasoningField, mainProviderField, mainModelField, mainReasoningField, spareProviderField, spareModelField, spareReasoningField, wrapperModelField, wrapperReasoningField, auxiliaryProviderField, auxiliaryModelField]
   .filter(Boolean)
   .forEach((field) => {
     field.addEventListener("input", () => {
@@ -4230,9 +4236,11 @@ async function loadConfig() {
   routingModeField.value = prefs.routingMode || "smart";
   providerField.value = prefs.provider || "deepseek";
   if (routeProviderField) routeProviderField.value = prefs.routeProvider || modelRoles.route?.provider || "deepseek";
+  if (routeReasoningField) routeReasoningField.value = prefs.routeReasoning ?? modelRoles.route?.reasoning ?? "";
   if (mainProviderField) mainProviderField.value = prefs.mainProvider || modelRoles.main?.provider || "deepseek";
+  if (mainReasoningField) mainReasoningField.value = prefs.mainReasoning ?? modelRoles.main?.reasoning ?? "";
   if (spareProviderField) spareProviderField.value = prefs.spareProvider || modelRoles.spare?.provider || "openai";
-  if (spareReasoningField) spareReasoningField.value = prefs.spareReasoning || modelRoles.spare?.reasoning || "medium";
+  if (spareReasoningField) spareReasoningField.value = prefs.spareReasoning ?? modelRoles.spare?.reasoning ?? "medium";
   if (wrapperReasoningField) wrapperReasoningField.value = prefs.wrapperReasoning || modelRoles.wrapper?.reasoning || "medium";
   if (auxiliaryProviderField) auxiliaryProviderField.value = prefs.auxiliaryProvider || modelRoles.auxiliary?.provider || "grsai";
   setSelectOptions(

package/public/index.html

@@ -426,6 +426,14 @@
               <select id="routeModel" name="routeModel">
                 <option value="deepseek-v4-flash">DeepSeek v4 flash</option>
               </select>
+              <select id="routeReasoning" name="routeReasoning">
+                <option value="">Provider default</option>
+                <option value="minimal">minimal</option>
+                <option value="low">low</option>
+                <option value="medium">medium</option>
+                <option value="high">high</option>
+                <option value="xhigh">xhigh</option>
+              </select>
             </label>
             <label>
               <span>Main</span>
@@ -439,6 +447,14 @@
               <select id="mainModel" name="mainModel">
                 <option value="deepseek-v4-pro">DeepSeek v4 pro</option>
               </select>
+              <select id="mainReasoning" name="mainReasoning">
+                <option value="">Provider default</option>
+                <option value="minimal">minimal</option>
+                <option value="low">low</option>
+                <option value="medium">medium</option>
+                <option value="high">high</option>
+                <option value="xhigh">xhigh</option>
+              </select>
             </label>
             <label>
               <span>Spare</span>
@@ -453,6 +469,8 @@
                 <option value="gpt-5.4">GPT-5.4</option>
               </select>
               <select id="spareReasoning" name="spareReasoning">
+                <option value="">Provider default</option>
+                <option value="minimal">minimal</option>
                 <option value="low">low</option>
                 <option value="medium">medium</option>
                 <option value="high">high</option>

package/references/agintiflow-intent-routing-overpatch-audit-2026-06-01.md

@@ -0,0 +1,74 @@
+# AgInTiFlow Intent Routing Overpatch Audit
+
+Date: 2026-06-01
+
+## Problem
+
+A bare user message, `hello`, was handled as an execution task. In the observed run, AgInTiFlow planned to inspect the workspace, created `hello.py`, and then stopped without a natural chat answer. That is the wrong default behavior for a general agent UI: a greeting should be answered directly, not converted into a workspace mutation.
+
+## Evidence
+
+Observed session:
+
+- Session: `/home/lachlan/.agintiflow/sessions/web-agent-f798c7cc-b3c2-439f-b2be-2a2746b4944d/state.json`
+- Provider/model: `deepseek/deepseek-v4-flash`
+- Goal: `hello`
+- Task profile: `auto`
+- Selected skills: `[]`
+- Outcome shown by user: AgInTiFlow wrote `hello.py` with `print("Hello from agent!")`
+
+The selected skills list was empty, so this was not caused by a custom skill. The behavior came from the core runtime prompt and the lack of a direct-answer lane.
+
+## Root Cause
+
+The runtime had one dominant path:
+
+1. Create a plan.
+2. Continue with tools until completion.
+3. Prefer real workspace edits/checks over advice-only answers.
+
+The strongest prompt pressure was in:
+
+- `src/agent-runner.js`: system prompt said the plan is not final and the agent should actively use tools until complete.
+- `src/model-client.js`: planner prompt said to prefer real workspace edits/checks over advice-only answers.
+- `src/task-profiles.js`: the `auto` profile told the agent to infer task type and choose a tool mix, but did not define a no-tool conversational mode.
+
+That design is useful for real tasks, but over-applies tool use to short social turns.
+
+## Design Fix
+
+Add a deterministic pre-plan goal-intent classifier:
+
+- Greetings, thanks, and explicit greeting requests finish directly.
+- Explicit create/edit/run/read/search/download/build/test/coding/file/command requests remain agentic.
+- File paths, file extensions, and command-looking inputs remain agentic.
+- The direct path runs before planning, SCS, surgical context, snapshots, browser, shell, canvas, or file tools.
+
+This keeps the fix general. It does not special-case `hello.py`, mock mode, DeepSeek, or a single UI path.
+
+The prompts were also softened:
+
+- Tool use is required only when the user actually asks for workspace/browser/shell/web/canvas/image/MCP/specialist work.
+- Greetings and simple conversational turns should finish directly.
+- Canvas should not be used for ordinary chat replies.
+
+## Regression Contract
+
+Required behavior:
+
+- `hello` returns a direct greeting.
+- `hello` does not create a plan.
+- `hello` does not call tools.
+- `hello` does not create `hello.py`.
+- `create hello.py` still requires tools.
+- `write a hello-world Python script and run it` still requires tools.
+
+## Product Lesson
+
+AgInTiFlow should solve problems at the correct layer:
+
+- Core system flaw: no conversational/direct-answer lane. Fix in runtime intent routing.
+- Core general skill incompleteness: missing reusable task classifier. Add deterministic classifier and tests.
+- Custom skill issue: not applicable here because no skill was selected.
+
+Avoid overpatching by not making every short input a file task and not routing every interaction through heavyweight planning/SCS/tool execution.

package/references/agintiflow-npm-publication-memory.md

@@ -2,7 +2,7 @@
 
 Date: 2026-05-20
 
-Updated: 2026-05-31
+Updated: 2026-06-01
 
 This note records the working publication route for AgInTiFlow so future release work does not get blocked by stale local npm tokens or repeated discussion about why direct `npm publish` failed.
 
@@ -10,6 +10,28 @@ This note records the working publication route for AgInTiFlow so future release
 
 Latest verified release:
 
+- Version: `0.20.189`
+- Commit: `0095284`
+- GitHub Actions run: `https://github.com/lazyingart/AgInTiFlow/actions/runs/26734901522`
+- Workflow result: success
+- npm registry check: `npm view @lazyingart/agintiflow version dist-tags.latest --registry=https://registry.npmjs.org` returned `0.20.189`.
+- Installed verification: `npm install -g @lazyingart/agintiflow@0.20.189` then `aginti --version` returned `0.20.189`.
+- Webapp verification: `aginti webapp restart --port 3210` then `curl -fsS http://127.0.0.1:3210/health` returned `version":"0.20.189"` from the global npm package path.
+- Feature verification: `npm run smoke:model-roles` covered `OPENAI_BASE_URL`, provider-default reasoning, OpenAI chat `reasoning_effort`, and retry-without-reasoning for OpenAI-compatible gateways.
+
+Previous verified release:
+
+- Version: `0.20.188`
+- Commit: `939e2ec`
+- GitHub Actions run: `https://github.com/lazyingart/AgInTiFlow/actions/runs/26705729544`
+- Workflow result: success
+- npm registry check: `npm view @lazyingart/agintiflow version dist-tags.latest --registry=https://registry.npmjs.org` returned `0.20.188`.
+- Installed verification: `npm install -g @lazyingart/agintiflow@0.20.188` then `aginti --version` returned `0.20.188`.
+- Webapp verification: `aginti webapp restart --port 3210` then `curl -fsS http://127.0.0.1:3210/health` returned `version":"0.20.188"` from the global npm package path.
+- OpenRouter verification: `/api/config` reports the OpenRouter default provider as `openrouter/auto` with base URL `https://openrouter.ai/api/v1`; `aginti keys status` reports `openrouter=missing` because no local OpenRouter key was persisted during release verification.
+
+Previous verified release:
+
 - Version: `0.20.187`
 - Commit: `9339b2e`
 - GitHub Actions run: `https://github.com/lazyingart/AgInTiFlow/actions/runs/26701125864`

package/references/lazyingrouter-account-login-design.md

@@ -0,0 +1,259 @@
+# LazyingRouter Account Login Design For AgInTiFlow
+
+Date: 2026-05-31
+
+Purpose: define the later-stage integration where a user logs into LazyingRouter once, authorizes AgInTiFlow, and then uses AgInTiFlow without pasting OpenAI, DeepSeek, OpenRouter, Venice, GRS AI, or other upstream provider keys.
+
+## Product Goal
+
+AgInTiFlow should support two credential modes:
+
+1. Direct provider keys for local power users and development.
+2. LazyingRouter account login for normal users.
+
+In LazyingRouter mode, the user pays LazyingRouter, LazyingRouter owns upstream provider keys, LazyingRouter checks balance and quota, and AgInTiFlow only stores one LazyingRouter-issued user token.
+
+The user-facing experience should be:
+
+```text
+aginti login lazyingrouter
+-> browser opens router.lazying.art
+-> user signs in or registers
+-> user authorizes "AgInTiFlow on this computer"
+-> AgInTiFlow stores an implicit LazyingRouter token
+-> AgInTiFlow runs with provider=lazyingrouter and model=lazying/auto
+```
+
+No user should need to understand upstream provider keys for the normal paid product path.
+
+## Current AgInTiFlow State
+
+AgInTiFlow is currently provider-key oriented.
+
+Relevant files:
+
+- `src/auth-onboarding.js`: defines `MAIN_AUTH_PROVIDERS`, normalizes auth provider names, and prompts for pasted provider keys.
+- `src/project.js`: stores direct provider keys in ignored `.aginti/.env` with local permission control.
+- `src/config.js`: picks the active provider from environment variables such as `DEEPSEEK_API_KEY`, `OPENAI_API_KEY`, `OPENROUTER_API_KEY`, `QWEN_API_KEY`, and `VENICE_API_KEY`.
+- `src/model-routing.js`: returns provider defaults for `deepseek`, `openai`, `openrouter`, `qwen`, `venice`, and `mock`.
+- `src/model-client.js`: creates an OpenAI SDK client from `apiKey` and `baseURL`.
+- `web.js`: exposes key status and provider-key save APIs, and has a provider allow-list in preference normalization.
+- `src/auxiliary-tools.js`: calls image providers directly through GRS AI and Venice keys.
+
+This is a good base because LazyingRouter can be added as another OpenAI-compatible provider. The missing part is account login and a LazyingRouter-issued token.
+
+## Current Key Flow
+
+The current direct-key flow is:
+
+1. User runs `aginti auth`, `aginti login <provider>`, or `aginti keys set <provider> --stdin`.
+2. AgInTiFlow asks the user to paste a provider API key.
+3. `setProviderKey()` writes that secret into project-local `.aginti/.env`.
+4. `resolveRuntimeConfig()` selects a provider and builds `{provider, apiKey, baseURL, model}`.
+5. `createClient()` sends requests through the OpenAI SDK.
+
+This flow should stay available. It is useful for development, private labs, and users who intentionally bring their own keys.
+
+## Proposed Minimal Design
+
+Add `lazyingrouter` as a first-class provider, but do not ask the user to paste any upstream key.
+
+Recommended environment shape:
+
+```env
+LAZYINGROUTER_API_KEY=
+LAZYINGROUTER_BASE_URL=https://router.lazying.art/v1
+LAZYINGROUTER_MODEL=lazying/auto
+LAZYINGROUTER_ACCOUNT_URL=https://router.lazying.art
+LAZYINGROUTER_TOKEN_ID=
+LAZYINGROUTER_USER_ID=
+```
+
+Only `LAZYINGROUTER_API_KEY` is secret. `TOKEN_ID` and `USER_ID` are useful for status, logout, and support but should not be treated as credentials.
+
+Provider defaults:
+
+```js
+{
+  provider: "lazyingrouter",
+  apiKey: process.env.LAZYINGROUTER_API_KEY || "",
+  baseURL: process.env.LAZYINGROUTER_BASE_URL || "https://router.lazying.art/v1",
+  model: process.env.LAZYINGROUTER_MODEL || process.env.LLM_MODEL || "lazying/auto"
+}
+```
+
+AgInTiFlow model routing should remain role-based. LazyingRouter is supply and billing. It should not redefine AgInTiFlow's route/main/spare/SCS semantics.
+
+## Account Authorization Flow
+
+Use a simple device authorization flow instead of asking the user to copy keys.
+
+1. User runs `aginti login lazyingrouter`, clicks "Login with LazyingRouter" in web settings, or starts AgInTiFlow with no direct provider key.
+2. AgInTiFlow generates or reuses a local install id and calls:
+
+```http
+POST https://router.lazying.art/api/app-auth/device/start
+Content-Type: application/json
+
+{
+  "app": "agintiflow",
+  "device_name": "hostname/project",
+  "scopes": ["chat", "models", "usage", "artifacts"],
+  "client_nonce": "random"
+}
+```
+
+3. LazyingRouter returns:
+
+```json
+{
+  "login_url": "https://router.lazying.art/app-auth/authorize?device_code=...",
+  "device_code": "opaque",
+  "user_code": "ABCD-EFGH",
+  "expires_at": 1790000000,
+  "poll_interval_seconds": 3
+}
+```
+
+4. AgInTiFlow opens or prints `login_url`.
+5. User signs into LazyingRouter, tops up if needed, and approves "AgInTiFlow on this computer".
+6. AgInTiFlow polls:
+
+```http
+POST https://router.lazying.art/api/app-auth/device/poll
+Content-Type: application/json
+
+{
+  "device_code": "opaque",
+  "client_nonce": "same-random"
+}
+```
+
+7. On approval, LazyingRouter returns the token once:
+
+```json
+{
+  "ok": true,
+  "api_base": "https://router.lazying.art/v1",
+  "api_key": "sk-...",
+  "model": "lazying/auto",
+  "token_id": 123,
+  "user_id": 456,
+  "display_name": "Lachlan",
+  "quota": {
+    "available": 123456,
+    "display": "$12.34",
+    "topup_url": "https://router.lazying.art/topup"
+  }
+}
+```
+
+8. AgInTiFlow stores the token locally with `0600` permissions and sets provider `lazyingrouter`.
+
+The token should be a normal LazyingRouter user token, visible and revocable in LazyingRouter. It should be named like `AgInTiFlow - <hostname>`.
+
+## Runtime And Quota Behavior
+
+AgInTiFlow should use LazyingRouter as the authority for billing and quota.
+
+Before a run:
+
+- If provider is `lazyingrouter`, call a lightweight status endpoint such as `/api/app-auth/status` or existing `/api/usage/token/`.
+- If no usable balance exists, stop before starting the model loop and print a top-up URL.
+- If the status endpoint is unreachable but the token exists, allow one normal model request unless the user has configured strict preflight.
+
+During a run:
+
+- LazyingRouter remains the hard enforcement layer.
+- If LazyingRouter returns `401`, mark the local token invalid and suggest `aginti login lazyingrouter`.
+- If it returns quota/balance errors, stop gracefully and show the LazyingRouter top-up URL.
+- Do not fall back to direct upstream keys unless the user explicitly configured fallback.
+
+After a run:
+
+- Show spent quota if LazyingRouter returned usage metadata.
+- Store token status evidence in the session log without storing the raw token.
+
+## Commands And UI
+
+CLI additions:
+
+```text
+aginti login lazyingrouter
+aginti logout lazyingrouter
+aginti keys status
+aginti provider lazyingrouter
+/login lazyingrouter
+/logout lazyingrouter
+/provider lazyingrouter
+/balance
+```
+
+Web additions:
+
+- Provider dropdown includes `LazyingRouter`.
+- Settings has "Login with LazyingRouter", "Balance", "Top up", "Revoke this device", and "Use direct provider keys instead".
+- Header status can show `provider=lazyingrouter`, `model=lazying/auto`, and a compact balance label.
+
+## Implementation Points In AgInTiFlow
+
+Add provider identity:
+
+- Add `lazyingrouter` to `MAIN_AUTH_PROVIDERS` in `src/auth-onboarding.js`.
+- Add aliases: `lazying`, `lzy`, `lazying-router`, `lazyingrouter`.
+- Add `LAZYINGROUTER_*` keys to `LOCAL_ENV_KEYS` and provider key candidates in `src/project.js`.
+- Add key status fields and preview masking in `providerKeyStatus()` and `providerKeyPreview()`.
+- Add a `getProviderDefaults("lazyingrouter")` branch in `src/model-routing.js`.
+- Update `resolveRuntimeConfig()` in `src/config.js` to choose LazyingRouter when `LAZYINGROUTER_API_KEY` exists.
+- Update web preference allow-lists in `web.js`.
+- Add command and interactive handlers for login/logout/status.
+
+Do not overload `setProviderKey()` as the primary account-login path. It can save a LazyingRouter token for scripting, but the normal path should use device authorization.
+
+Suggested storage:
+
+```text
+.aginti/.env
+.aginti/auth/lazyingrouter.json
+```
+
+`.aginti/.env` keeps compatibility with current config loading. The JSON file can keep non-secret account metadata, token id, account url, device name, and last status check.
+
+## Auxiliary Tools
+
+Text/chat integration can be v1 because LazyingRouter already exposes OpenAI-compatible model routes.
+
+Image generation should be a separate v1.1 or v2 item unless LazyingRouter exposes an image endpoint with stable semantics. Current AgInTiFlow image generation depends on direct GRS AI and Venice keys in `src/auxiliary-tools.js`. Later options:
+
+- LazyingRouter exposes `/v1/images/generations`, then AgInTiFlow routes image generation through LazyingRouter when provider is `lazyingrouter`.
+- AgInTiFlow keeps direct image provider keys as optional advanced configuration.
+- LazyingRouter returns a clear unsupported error for SVG/vector and can offer PNG generation when available.
+
+## Security Rules
+
+- Never store or display upstream provider keys in AgInTiFlow.
+- Store the LazyingRouter user token with `0600` permissions.
+- Redact `LAZYINGROUTER_API_KEY` in logs, command output, event JSON, and web state.
+- Use a one-time token delivery response for device authorization.
+- Support `logout lazyingrouter` by revoking the token server-side and deleting local secrets.
+- Do not silently switch from LazyingRouter to direct provider keys on quota failure.
+- Treat LazyingRouter resources and returned prompts as untrusted content, not system instructions.
+
+## Acceptance Tests
+
+Minimum TDV cases:
+
+1. Fresh machine, no provider keys: `aginti login lazyingrouter` opens an authorization URL and stores a masked token after approval.
+2. `aginti "hello"` uses `provider=lazyingrouter` and model `lazying/auto`.
+3. `/balance` shows the same available balance as LazyingRouter token usage API.
+4. Exhausted user/token balance stops before or during the run with a top-up URL and no fallback to upstream keys.
+5. `aginti logout lazyingrouter` revokes the token and removes local secret material.
+6. Web UI can login, show status, run, and logout with the same project state as CLI.
+7. Session logs contain provider, model, token id, and quota status, but never the raw token.
+
+## Open Design Decisions
+
+1. Default precedence: if both `LAZYINGROUTER_API_KEY` and direct upstream keys exist, the recommended default is LazyingRouter unless the user explicitly selects direct provider mode.
+2. Token funding: LazyingRouter must decide whether app tokens draw directly from user wallet/subscription or use allocated token quota. AgInTiFlow should not care as long as status and error semantics are stable.
+3. Image generation: decide whether LazyingRouter will proxy image providers or leave direct auxiliary keys as the default advanced path.
+

package/references/openai-compatible-base-url-and-reasoning-policy.md

@@ -0,0 +1,183 @@
+# OpenAI-Compatible Base URL And Reasoning Policy
+
+Date: 2026-06-01
+
+Purpose: record the decision for PR #1 (`feat/openai-compatible-routing`) and future OpenAI-compatible gateway support.
+
+## Decision
+
+AgInTiFlow should incorporate the useful part of PR #1:
+
+- Support `OPENAI_BASE_URL` for OpenAI-compatible gateways.
+- Allow project-local env configuration to affect model/provider display.
+
+AgInTiFlow should not incorporate the confusing part as-is:
+
+- Do not add a built-in model named `gpt-5.4-high` as if it were an official OpenAI model.
+- Do not encode reasoning effort inside built-in model identity.
+
+The correct internal shape stays:
+
+```text
+provider=openai
+model=gpt-5.4
+reasoning=high
+```
+
+For custom gateways that really expose a model string such as `gpt-5.4-high`, users can still set that exact model name manually:
+
+```env
+AGENT_PROVIDER=openai
+OPENAI_BASE_URL=https://example-gateway.local/v1
+OPENAI_DEFAULT_MODEL=gpt-5.4-high
+AGINTI_MAIN_REASONING=none
+```
+
+That sends the custom model name but omits AgInTiFlow's separate reasoning parameter.
+
+## Rationale
+
+AgInTiFlow's current model design separates three concepts:
+
+- **Provider**: the API surface, such as `openai`, `deepseek`, `openrouter`, `qwen`, `venice`, or future `lazyingrouter`.
+- **Model**: the provider model id or gateway alias.
+- **Reasoning**: optional effort level, such as `low`, `medium`, `high`, or `xhigh`.
+
+This separation matters because direct OpenAI, OpenRouter, Venice, and LazyingRouter-style gateways may all expose different model ids while AgInTiFlow still needs a consistent role-based routing layer.
+
+Synthetic built-in ids like `gpt-5.4-high` make the UI look simple but blur the contract. They also risk sending an invalid `model` value to a provider that expects `gpt-5.4` plus a separate reasoning option.
+
+## `OPENAI_BASE_URL`
+
+`OPENAI_BASE_URL` should be accepted as an OpenAI-provider-specific base URL.
+
+Recommended precedence:
+
+```text
+OPENAI_BASE_URL
+LLM_BASE_URL
+https://api.openai.com/v1
+```
+
+Reason:
+
+- `OPENAI_BASE_URL` is explicit and only affects OpenAI-compatible routing.
+- `LLM_BASE_URL` remains a generic fallback.
+- The official OpenAI endpoint remains the default.
+
+Accepted local env keys should include:
+
+```env
+OPENAI_API_KEY=
+OPENAI_BASE_URL=https://api.openai.com/v1
+OPENAI_DEFAULT_MODEL=gpt-5.4-mini
+```
+
+`OPENAI_BASE_URL` is not a secret, but it belongs in the same local environment mechanism because users often configure it together with `OPENAI_API_KEY`.
+
+## Reasoning "None" Option
+
+Reasoning must be optional. Some OpenAI-compatible gateways encode effort in the model name or do not support reasoning at all.
+
+Recommended user-facing selector label:
+
+```text
+Provider default
+```
+
+Recommended internal value:
+
+```text
+""
+```
+
+Accepted CLI/env aliases:
+
+```text
+none
+off
+default
+provider-default
+provider_default
+auto
+""
+```
+
+All of those should normalize to an empty reasoning value, meaning AgInTiFlow should omit the reasoning option from provider requests.
+
+Why not use `none` internally:
+
+- `none` is a user-facing command word, not a provider value.
+- Empty string already means "no explicit reasoning override" in current role config.
+- Keeping the runtime value empty avoids accidentally sending `"reasoning": "none"` to providers.
+
+## Selector Behavior
+
+Model selectors should show reasoning as a separate field:
+
+```text
+Model: GPT-5.4
+Reasoning: Provider default | low | medium | high | xhigh
+```
+
+Preset examples:
+
+```text
+OpenAI GPT-5.4
+provider=openai
+model=gpt-5.4
+reasoning=medium
+
+OpenAI GPT-5.4 High Reasoning
+provider=openai
+model=gpt-5.4
+reasoning=high
+
+Custom OpenAI-Compatible Gateway Model
+provider=openai
+model=gpt-5.4-high
+reasoning=
+```
+
+The last case is a user or project configuration, not a built-in official OpenAI model.
+
+## Incorporation Plan For PR #1
+
+Cherry-pick the useful intent:
+
+1. Add `OPENAI_BASE_URL` to the local env allow-list.
+2. Update OpenAI provider defaults to prefer `OPENAI_BASE_URL`.
+3. Add `OPENAI_BASE_URL` to `.aginti/.env.example` generated by project initialization.
+4. Load project env before `aginti models`, but preserve normal shell-env precedence unless runtime behavior is intentionally changed.
+5. Add a `Provider default` reasoning selector option and normalize common aliases to empty string.
+
+Do not cherry-pick:
+
+1. Built-in `PROVIDER_MODEL_CATALOG.openai` entry for `gpt-5.4-high`.
+2. Provider dropdown defaulting OpenAI to `gpt-5.4-high`.
+3. Examples implying `gpt-5.4-high` is a standard official OpenAI model.
+
+## Tests To Add
+
+Minimum regression tests:
+
+1. `OPENAI_BASE_URL` is used before `LLM_BASE_URL` for provider `openai`.
+2. `LLM_BASE_URL` still works when `OPENAI_BASE_URL` is unset.
+3. `AGINTI_MAIN_REASONING=none` normalizes to empty reasoning.
+4. `AGINTI_MAIN_REASONING=provider-default` normalizes to empty reasoning.
+5. Official OpenAI presets keep `model=gpt-5.4` and a separate reasoning value.
+6. A custom gateway config can use `OPENAI_DEFAULT_MODEL=gpt-5.4-high` with empty reasoning.
+
+## Future LazyingRouter Alignment
+
+This policy also matches the LazyingRouter design:
+
+```env
+AGENT_PROVIDER=lazyingrouter
+LAZYINGROUTER_BASE_URL=https://router.lazying.art/v1
+LAZYINGROUTER_MODEL=lazying/auto
+AGINTI_MAIN_REASONING=provider-default
+```
+
+LazyingRouter can route `lazying/auto` internally without AgInTiFlow inventing provider-specific model aliases or leaking upstream routing semantics into the client UI.
+