@lazyingart/agintiflow 0.20.169 → 0.20.170

package/docs/npm-publishing.md

@@ -31,6 +31,8 @@ The npm trust setup may require the package to exist before trust can be attache
 4. Push the release commit and create a GitHub Release, or run the publish workflow manually.
 5. Confirm the npm package page shows provenance.
 
+If local token publishing fails with `E401` or `E404`, do not treat that as terminal when Trusted Publishing is configured. Use the GitHub Actions workflow with an account that can dispatch workflows for `lazyingart/AgInTiFlow`, then verify the registry and install the published package. See `references/agintiflow-npm-publication-memory.md` for the 2026-05-20 `0.20.169` publication evidence and the known working command sequence.
+
 ## Local Token Fallback
 
 Trusted Publishing is preferred. A local automation token can be used only for bootstrap or emergency fallback:

package/package.json

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

@@ -834,6 +834,7 @@ let selectedArtifactId = "";
 let currentArtifactTab = "canvas";
 let artifactUnreadCount = 0;
 let lastAnnouncedRunKey = "";
+let quickVeniceModeActive = false;
 
 function normalizeLanguage(language) {
   const lower = String(language || "").toLowerCase();
@@ -1266,6 +1267,31 @@ function providerModelOptions(provider = providerField.value) {
   return (modelCatalog[provider] || []).filter((item) => !item.hidden);
 }
 
+function modelIdsForProvider(provider = "") {
+  return new Set(providerModelOptions(provider).map((item) => String(item.id || "")));
+}
+
+function modelDefaultValues() {
+  return new Set(Object.values(defaults).filter(Boolean));
+}
+
+function fallbackModelForProvider(provider = "deepseek", role = "primary") {
+  if (provider === "deepseek" && role === "main") return "deepseek-v4-pro";
+  if (provider === "deepseek") return "deepseek-v4-flash";
+  if (provider === "openai" && role === "spare") return "gpt-5.4";
+  return defaults[provider] || providerModelOptions(provider)[0]?.id || "";
+}
+
+function coerceModelForProvider(provider = "deepseek", currentModel = "", fallbackModel = "") {
+  const current = String(currentModel || "").trim();
+  const fallback = String(fallbackModel || fallbackModelForProvider(provider)).trim();
+  const providerModelIds = modelIdsForProvider(provider);
+  const knownDefault = modelDefaultValues().has(current);
+  const wrongProviderModel = providerModelIds.size > 0 && current && !providerModelIds.has(current);
+  if (!current || knownDefault || wrongProviderModel) return fallback;
+  return current;
+}
+
 function mergeModelOptions(...groups) {
   const seen = new Set();
   const merged = [];
@@ -1327,24 +1353,32 @@ function setSelectOptions(select, options, selectedValue = "", fallbackValue = "
 function refreshModelDropdowns() {
   refreshProviderDropdowns();
   const provider = providerField?.value || "deepseek";
-  setSelectOptions(modelField, providerModelOptions(provider), fieldValue(modelField), defaults[provider]);
+  setSelectOptions(
+    modelField,
+    providerModelOptions(provider),
+    coerceModelForProvider(provider, fieldValue(modelField), fallbackModelForProvider(provider, "primary")),
+    fallbackModelForProvider(provider, "primary")
+  );
+  const routeProvider = routeProviderField?.value || "deepseek";
   setSelectOptions(
     routeModelField,
-    providerModelOptions(routeProviderField?.value || "deepseek"),
-    fieldValue(routeModelField),
-    modelRoles.route?.model || "deepseek-v4-flash"
+    providerModelOptions(routeProvider),
+    coerceModelForProvider(routeProvider, fieldValue(routeModelField), fallbackModelForProvider(routeProvider, "route")),
+    fallbackModelForProvider(routeProvider, "route")
   );
+  const mainProvider = mainProviderField?.value || "deepseek";
   setSelectOptions(
     mainModelField,
-    providerModelOptions(mainProviderField?.value || "deepseek"),
-    fieldValue(mainModelField),
-    modelRoles.main?.model || "deepseek-v4-pro"
+    providerModelOptions(mainProvider),
+    coerceModelForProvider(mainProvider, fieldValue(mainModelField), fallbackModelForProvider(mainProvider, "main")),
+    fallbackModelForProvider(mainProvider, "main")
   );
+  const spareProvider = spareProviderField?.value || "openai";
   setSelectOptions(
     spareModelField,
-    providerModelOptions(spareProviderField?.value || "openai"),
-    fieldValue(spareModelField),
-    modelRoles.spare?.model || "gpt-5.4"
+    providerModelOptions(spareProvider),
+    coerceModelForProvider(spareProvider, fieldValue(spareModelField), fallbackModelForProvider(spareProvider, "spare")),
+    fallbackModelForProvider(spareProvider, "spare")
   );
   setSelectOptions(wrapperModelField, wrapperModelOptions(), fieldValue(wrapperModelField), modelRoles.wrapper?.model || "gpt-5.5");
   setSelectOptions(
@@ -1364,13 +1398,9 @@ function selectedVeniceTextModel() {
   );
 }
 
-function inferVeniceMode() {
-  return [providerField?.value, routeProviderField?.value, mainProviderField?.value].includes("venice");
-}
-
 function syncQuickModeControls() {
   if (aapsModeToggle) aapsModeToggle.checked = (taskProfileField?.value || "auto") === "aaps";
-  if (veniceModeToggle) veniceModeToggle.checked = inferVeniceMode();
+  if (veniceModeToggle) veniceModeToggle.checked = quickVeniceModeActive;
   if (quickModeStatusEl) {
     const scs = enableScsField?.value || "on";
     const profile = taskProfileField?.value || "auto";
@@ -1388,10 +1418,13 @@ function applyAapsMode(enabled) {
 }
 
 function applyVeniceMode(enabled) {
+  quickVeniceModeActive = Boolean(enabled);
   if (enabled) {
     const model = selectedVeniceTextModel();
     routingModeField.value = "smart";
-    providerField.value = "deepseek";
+    providerField.value = "venice";
+    refreshModelDropdowns();
+    if (modelField) setSelectOptions(modelField, providerModelOptions("venice"), model, defaults.venice);
     if (routeProviderField) routeProviderField.value = "venice";
     refreshModelDropdowns();
     if (routeModelField) setSelectOptions(routeModelField, providerModelOptions("venice"), model, defaults.venice);
@@ -1400,10 +1433,13 @@ function applyVeniceMode(enabled) {
     if (mainModelField) setSelectOptions(mainModelField, providerModelOptions("venice"), model, defaults.venice);
   } else {
     routingModeField.value = "smart";
-    providerField.value = "deepseek";
+    if (providerField?.value === "venice") providerField.value = "deepseek";
     if (routeProviderField?.value === "venice") routeProviderField.value = "deepseek";
     if (mainProviderField?.value === "venice") mainProviderField.value = "deepseek";
     refreshModelDropdowns();
+    if (modelField && providerField?.value === "deepseek") {
+      setSelectOptions(modelField, providerModelOptions("deepseek"), "deepseek-v4-flash", "deepseek-v4-flash");
+    }
     if (routeModelField && routeProviderField?.value === "deepseek") {
       setSelectOptions(routeModelField, providerModelOptions("deepseek"), "deepseek-v4-flash", "deepseek-v4-flash");
     }
@@ -1673,6 +1709,7 @@ function formPayload() {
     allowParallelScouts: allowParallelScoutsField?.checked ?? true,
     enableScs: enableScsField?.value || "on",
     dynamicSteps: dynamicStepsField?.value || "auto",
+    veniceMode: quickVeniceModeActive,
     parallelScoutCount: Math.min(Math.max(Number(parallelScoutCountField?.value) || 3, 1), 10),
     allowWrapperTools: allowWrapperToolsField.checked,
     preferredWrapper: preferredWrapperField.value,
@@ -3122,16 +3159,8 @@ providerField.addEventListener("change", () => {
     routingModeField.value = "manual";
   }
 
-  if (
-    !fieldValue(modelField) ||
-    modelField.value === defaults.openai ||
-    modelField.value === defaults.deepseek ||
-    modelField.value === defaults.qwen ||
-    modelField.value === defaults.venice ||
-    modelField.value === defaults.mock
-  ) {
-    modelField.value = defaults[providerField.value] || "";
-  }
+  if (providerField.value !== "venice") quickVeniceModeActive = false;
+  refreshModelDropdowns();
   updateRoutingHint();
   syncQuickModeControls();
   schedulePreferenceSave();
@@ -3394,6 +3423,7 @@ async function loadConfig() {
   defaults.mock = data.defaults?.mock?.model || defaults.mock;
 
   applyLanguage(prefs.language || normalizeLanguage(navigator.language || "en"), { persist: false });
+  quickVeniceModeActive = prefs.veniceMode === true;
   refreshProviderDropdowns();
 
   routingModeField.value = prefs.routingMode || "smart";
@@ -3404,24 +3434,41 @@ async function loadConfig() {
   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(modelField, providerModelOptions(providerField.value), prefs.model || defaults[providerField.value], defaults[providerField.value]);
+  setSelectOptions(
+    modelField,
+    providerModelOptions(providerField.value),
+    coerceModelForProvider(providerField.value, prefs.model, fallbackModelForProvider(providerField.value, "primary")),
+    fallbackModelForProvider(providerField.value, "primary")
+  );
   setSelectOptions(
     routeModelField,
     providerModelOptions(routeProviderField?.value || "deepseek"),
-    prefs.routeModel || modelRoles.route?.model,
-    "deepseek-v4-flash"
+    coerceModelForProvider(
+      routeProviderField?.value || "deepseek",
+      prefs.routeModel || modelRoles.route?.model,
+      fallbackModelForProvider(routeProviderField?.value || "deepseek", "route")
+    ),
+    fallbackModelForProvider(routeProviderField?.value || "deepseek", "route")
   );
   setSelectOptions(
     mainModelField,
     providerModelOptions(mainProviderField?.value || "deepseek"),
-    prefs.mainModel || modelRoles.main?.model,
-    "deepseek-v4-pro"
+    coerceModelForProvider(
+      mainProviderField?.value || "deepseek",
+      prefs.mainModel || modelRoles.main?.model,
+      fallbackModelForProvider(mainProviderField?.value || "deepseek", "main")
+    ),
+    fallbackModelForProvider(mainProviderField?.value || "deepseek", "main")
   );
   setSelectOptions(
     spareModelField,
     providerModelOptions(spareProviderField?.value || "openai"),
-    prefs.spareModel || modelRoles.spare?.model,
-    "gpt-5.4"
+    coerceModelForProvider(
+      spareProviderField?.value || "openai",
+      prefs.spareModel || modelRoles.spare?.model,
+      fallbackModelForProvider(spareProviderField?.value || "openai", "spare")
+    ),
+    fallbackModelForProvider(spareProviderField?.value || "openai", "spare")
   );
   setSelectOptions(wrapperModelField, wrapperModelOptions(), prefs.wrapperModel || modelRoles.wrapper?.model, "gpt-5.5");
   setSelectOptions(
@@ -3463,6 +3510,7 @@ async function loadConfig() {
   renderMcpPanel(data.mcp || null);
   await refreshWorkspaceChanges();
   renderSandboxLogs(data.sandbox?.logs || []);
+  if (quickVeniceModeActive) applyVeniceMode(true);
   updateRoutingHint();
   updatePermissionHint();
   updatePackageWarning();

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

@@ -0,0 +1,89 @@
+# AgInTiFlow npm Publication Memory
+
+Date: 2026-05-20
+
+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.
+
+## Published Evidence
+
+- Package: `@lazyingart/agintiflow`
+- Version: `0.20.169`
+- Commit: `6ef3768`
+- GitHub Actions run: `https://github.com/lazyingart/AgInTiFlow/actions/runs/26149627377`
+- Workflow result: success
+- npm registry check:
+
+```bash
+npm view @lazyingart/agintiflow version dist-tags.latest --registry=https://registry.npmjs.org
+```
+
+Expected result:
+
+```text
+version = '0.20.169'
+dist-tags.latest = '0.20.169'
+```
+
+Installed verification:
+
+```bash
+npm install -g @lazyingart/agintiflow@0.20.169
+aginti --version
+aginti webapp restart --port 3210
+curl -fsS http://127.0.0.1:3210/health
+```
+
+Expected result:
+
+```text
+0.20.169
+```
+
+The health endpoint should report `version":"0.20.169"` and a global npm package path.
+
+## Working Publication Route
+
+Use GitHub Actions Trusted Publishing as the primary route.
+
+Workflow:
+
+- `.github/workflows/npm-publish.yml`
+- permissions include `id-token: write`
+- publish command uses `npm publish --access public --provenance`
+
+The successful dispatch used the configured `lazyingart` GitHub CLI account because the default `lachlanchen` account has `workflow` scope but does not have repository admin permission for workflow dispatch on `lazyingart/AgInTiFlow`.
+
+Reliable command sequence:
+
+```bash
+cd /home/lachlan/ProjectsLFS/Agent/AgInTiFlow
+git status --short
+npm test
+npm pack --dry-run
+git push
+gh auth switch -u lazyingart
+gh workflow run npm-publish.yml --ref main
+gh run watch <run-id> --exit-status
+npm view @lazyingart/agintiflow version dist-tags.latest --registry=https://registry.npmjs.org
+npm install -g @lazyingart/agintiflow@<version>
+aginti --version
+aginti webapp restart --port 3210
+curl -fsS http://127.0.0.1:3210/health
+gh auth switch -u lachlanchen
+```
+
+Do not print tokens. Do not copy token values into notes, logs, or final answers.
+
+## Local Token Failure Is Not Terminal
+
+On 2026-05-20, the env-based local publish path failed:
+
+- `npm whoami` through the env publish script returned `E401`.
+- direct publish returned `E404 PUT https://registry.npmjs.org/@lazyingart%2fagintiflow`.
+- the registry still showed the prior version until the trusted-publishing workflow was dispatched.
+
+Treat this as an auth/scope problem in local npm credentials, not as a package or registry existence problem. When this happens, use GitHub Trusted Publishing before spending time debating the local token path.
+
+## Operational Rule
+
+For future AgInTiFlow releases, do not stop after local token publish failure if the trusted-publishing workflow is available. Trigger the trusted-publishing workflow with the owner account, watch it, verify npm, install globally, restart the webapp, and only then report completion.

package/scripts/smoke-web-api.js

@@ -119,6 +119,7 @@ try {
   if (config.preferences?.workspaceWritePolicy !== "allow") throw new Error("web did not default to workspace writes allowed");
   if (config.preferences?.enableScs !== "on") throw new Error("web did not default to CLI-aligned SCS on mode");
   if (config.preferences?.dynamicSteps !== "auto") throw new Error("web did not default to CLI-aligned dynamic steps auto mode");
+  if (config.preferences?.veniceMode !== false) throw new Error("web should default Venice shortcut mode off");
   if (Number(config.preferences?.maxSteps) < 24) throw new Error("web default max steps is too low");
   if (!Array.isArray(config.taskProfiles) || !config.taskProfiles.some((profile) => profile.id === "latex")) {
     throw new Error("task profiles are not advertised by /api/config");

package/scripts/smoke-web-ui.js

@@ -94,17 +94,38 @@ try {
   await page.waitForFunction(() => document.querySelectorAll("#command-cwd-suggestions option").length > 0);
   if ((await page.locator(".project-status-chip").count()) < 4) throw new Error("project folder status did not render structured chips");
   await page.locator("#run-defaults-card summary").click();
+  if (await page.locator("#veniceModeToggle").isChecked()) throw new Error("Venice quick mode should default off");
+  if ((await page.locator("#routeProvider").inputValue()) !== "deepseek") throw new Error("route provider should default to DeepSeek");
+  if ((await page.locator("#mainProvider").inputValue()) !== "deepseek") throw new Error("main provider should default to DeepSeek");
 
   await page.selectOption("#enableScs", "auto");
   await page.locator("label:has(#aapsModeToggle)").click();
   if ((await page.locator("#taskProfile").inputValue()) !== "aaps") throw new Error("AAPS toggle did not select the AAPS task profile");
   await page.locator("label:has(#veniceModeToggle)").click();
+  if ((await page.locator("#provider").inputValue()) !== "venice") throw new Error("Venice toggle did not set primary provider");
+  if (!/^venice|^e2ee|^gemma|^qwen|^openai|^claude/.test(await page.locator("#model").inputValue())) {
+    throw new Error(`Venice toggle did not update primary model: ${await page.locator("#model").inputValue()}`);
+  }
   if ((await page.locator("#routeProvider").inputValue()) !== "venice") throw new Error("Venice toggle did not set route provider");
   if ((await page.locator("#mainProvider").inputValue()) !== "venice") throw new Error("Venice toggle did not set main provider");
+  if (!/^venice|^e2ee|^gemma|^qwen|^openai|^claude/.test(await page.locator("#routeModel").inputValue())) {
+    throw new Error(`Venice toggle did not update route model: ${await page.locator("#routeModel").inputValue()}`);
+  }
+  if (!/^venice|^e2ee|^gemma|^qwen|^openai|^claude/.test(await page.locator("#mainModel").inputValue())) {
+    throw new Error(`Venice toggle did not update main model: ${await page.locator("#mainModel").inputValue()}`);
+  }
   const quickStatus = await page.locator("#quick-mode-status").innerText();
   if (!/scs=auto/.test(quickStatus) || !/profile=aaps/.test(quickStatus) || !/route venice\//.test(quickStatus)) {
     throw new Error(`quick mode status did not reflect CLI modes: ${quickStatus}`);
   }
+  await page.locator("label:has(#veniceModeToggle)").click();
+  if (await page.locator("#veniceModeToggle").isChecked()) throw new Error("Venice quick mode did not turn off");
+  if ((await page.locator("#provider").inputValue()) !== "deepseek") throw new Error("Venice off did not restore primary provider");
+  if ((await page.locator("#model").inputValue()) !== "deepseek-v4-flash") throw new Error("Venice off did not restore primary model");
+  if ((await page.locator("#routeProvider").inputValue()) !== "deepseek") throw new Error("Venice off did not restore route provider");
+  if ((await page.locator("#routeModel").inputValue()) !== "deepseek-v4-flash") throw new Error("Venice off did not restore route model");
+  if ((await page.locator("#mainProvider").inputValue()) !== "deepseek") throw new Error("Venice off did not restore main provider");
+  if ((await page.locator("#mainModel").inputValue()) !== "deepseek-v4-pro") throw new Error("Venice off did not restore main model");
   const quickBoxes = await Promise.all([
     page.locator(".quick-mode-select").boundingBox(),
     page.locator("label:has(#aapsModeToggle)").boundingBox(),
@@ -136,8 +157,8 @@ try {
   if (firstPayload.dynamicSteps !== "off") {
     throw new Error(`dynamic steps payload mismatch: ${runPayloads.at(-1) || ""}`);
   }
-  if (firstPayload.routeProvider !== "venice" || firstPayload.mainProvider !== "venice") {
-    throw new Error(`Venice route/main payload mismatch: ${runPayloads.at(-1) || ""}`);
+  if (firstPayload.veniceMode !== false || firstPayload.routeProvider !== "deepseek" || firstPayload.mainProvider !== "deepseek") {
+    throw new Error(`default route/main payload mismatch after Venice off: ${runPayloads.at(-1) || ""}`);
   }
   await waitForRunState(page, "running");
   if (!(await page.locator("#stop-run").isVisible())) throw new Error("stop button did not appear while run was active");
@@ -176,6 +197,9 @@ try {
           "working-directory-search-top",
           "project-status-chips",
           "run-defaults-folded",
+          "venice-mode-default-off",
+          "venice-mode-model-sync",
+          "venice-mode-off-restores-deepseek",
           "quick-scs-aaps-venice-controls",
           "quick-mode-control-alignment",
           "dynamic-steps-dropdown",

package/src/web-db.js

@@ -7,7 +7,7 @@ import { deleteSessionIndex, renameSessionIndex, upsertSessionIndex } from "./se
 import { loadDatabaseSync } from "./sqlite.js";
 import { permissionModeDefaults } from "./permission-modes.js";
 
-const PREFERENCES_SCHEMA_VERSION = 9;
+const PREFERENCES_SCHEMA_VERSION = 10;
 
 function jsonStatePath(dbPath) {
   return dbPath.replace(/\.sqlite$/i, ".json");
@@ -73,6 +73,7 @@ function defaultPreferences(baseDir) {
     allowParallelScouts: true,
     enableScs: process.env.AGINTI_SCS_MODE || "on",
     dynamicSteps: process.env.AGINTI_DYNAMIC_STEPS || "auto",
+    veniceMode: false,
     parallelScoutCount: 3,
     allowWrapperTools: false,
     preferredWrapper: "codex",
@@ -228,6 +229,20 @@ export class WebDatabase {
           preferences.enableScs = preferences.enableScs || process.env.AGINTI_SCS_MODE || "on";
           preferences.dynamicSteps = preferences.dynamicSteps || process.env.AGINTI_DYNAMIC_STEPS || "auto";
         }
+        if ((parsed.preferencesSchemaVersion || 1) < 10) {
+          preferences.veniceMode = false;
+          const legacyQuickVenice =
+            (parsed.routingMode || preferences.routingMode) === "smart" &&
+            (parsed.provider || preferences.provider) === "deepseek" &&
+            (parsed.routeProvider || preferences.routeProvider) === "venice" &&
+            (parsed.mainProvider || preferences.mainProvider) === "venice";
+          if (legacyQuickVenice) {
+            preferences.routeProvider = "deepseek";
+            preferences.routeModel = "deepseek-v4-flash";
+            preferences.mainProvider = "deepseek";
+            preferences.mainModel = "deepseek-v4-pro";
+          }
+        }
         this.savePreferences(preferences);
       }
       return preferences;

package/web.js

@@ -282,6 +282,7 @@ function normalizePreferencePayload(body = {}, current = db.getPreferences()) {
       typeof body.allowParallelScouts === "boolean" ? body.allowParallelScouts : current.allowParallelScouts !== false,
     enableScs: normalizeScsMode(body.enableScs || current.enableScs || process.env.AGINTI_SCS_MODE || "on"),
     dynamicSteps: normalizeDynamicStepsMode(body.dynamicSteps || current.dynamicSteps || process.env.AGINTI_DYNAMIC_STEPS || "auto"),
+    veniceMode: typeof body.veniceMode === "boolean" ? body.veniceMode : current.veniceMode === true,
     parallelScoutCount:
       Number.isFinite(parsedParallelScoutCount) && parsedParallelScoutCount > 0
         ? Math.min(Math.max(parsedParallelScoutCount, 1), 10)