akm-cli 0.9.29 → 0.9.31

package/CHANGELOG.md

@@ -6,6 +6,47 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [0.9.31] - 2026-10-09
+
+A patch release: concurrent config writes no longer lose a change, OpenAI's reasoning models work as `llm`
+engines, `akm improve --require-engines` probes send API keys, and the npm package's docs links resolve.
+
+### Fixed
+
+- **`akm improve --require-engines` sends each engine's API key with its probe.** The probe used the engine's
+  connection as resolved, where the key is still a symbolic reference that a dispatch reads only when it sends a
+  request, so every keyed endpoint (OpenAI, a gateway that enforces auth) answered 401 and the run stopped with
+  "engine completion path is not reachable". The probe now builds the connection as a dispatch does; a required key
+  that is missing is reported as that engine's failure.
+- **OpenAI's reasoning models (gpt-5.x) work as `llm` engines.** They answer 400 to any `temperature` but the
+  default and to `max_tokens`, so every akm model call failed on them. Like the existing fallback for the
+  thinking-control fields, a 400 that names `temperature` is retried once without it, and one that asks for
+  `max_completion_tokens` is retried with the cap under that name; the connection keeps the working shape for
+  the rest of the process.
+- **Every relative link in the npm package's docs resolves again.** #1118 made `docs/README.md`,
+  `docs/migration/README.md` and `docs/reference/cli.md` link by relative path to guides and pages the package did
+  not ship. npm always ships a folder's `README.md`, so those links were dead for npm users. The package now ships
+  the user-facing `docs/` folders (`agents`, `architecture`, `guides`, `integration`, `maintainers`, `migration`,
+  `posts`, `reference`), `docs/product-surface.md`, the one plan they link to, and `ROADMAP.md`. `docs/plans` stays
+  out. The link check skips link syntax inside code, which is an example, not a link.
+- **Concurrent `akm config set` runs no longer lose each other's changes.** A lock file was created empty and its
+  owner's PID written a moment later; a process that looked in that gap read no PID, took the live lock for an
+  abandoned one and removed it, so two writers ran at once and one change was lost. A lock now appears with its
+  owner's PID already in it. Every akm lock file (config, index writer, scheduler, `akm.lock`, run, extract, secret)
+  is created this way.
+
+## [0.9.30] - 2026-10-09
+
+A patch release: `akm upgrade` acts only on the `akm-opencode` spec OpenCode's config names.
+
+### Fixed
+
+- **`akm upgrade` leaves alone an OpenCode whose config pins another `akm-opencode` spec (#1117).** A config naming
+  an exact version (seen: `akm-opencode@0.8.0`) loads that version's cache, but the plugin step refreshed `@latest`:
+  the cache went to the trash, OpenCode did not re-create it, and the run exited 1. The step now acts only on the
+  spec the config names: bare or `@latest` on a plain run, `@next` under `--next`; any other spec is skipped with a
+  note, no cache is touched and the CLI is not held to a pin OpenCode does not load. This generalizes #1115.
+
 ## [0.9.29] - 2026-10-09
 
 A patch release on the 0.9.28 line: `akm upgrade` is Stable, and a plain upgrade no longer breaks OpenCode's

package/README.md

@@ -55,7 +55,7 @@ akm show scripts/deploy.sh         # View details and run command
 - **One library for every agent** -- Use the same capability library from Claude Code, OpenCode, Cursor, Aider, Windsurf, or any assistant that can run shell commands.
 - **Load only what the task needs** -- Search or curate a shortlist, then load full content by ref. No giant startup prompt is required.
 - **Package complete capabilities** -- Install and share bundles containing skills, scripts, workflows, agents, instructions, memories, and knowledge -- not just prompt snippets.
-- **Improve through evidence, with review** -- Feedback influences retrieval and produces diffable proposals. Changes remain reviewable and target only writable bundles.
+- **Improve through evidence, with review** -- Feedback re-ranks assets right away. A negative report can carry an exact text fix, and `akm improve` repairs metadata; every edit lands as a diffable proposal you accept, reject or revert, and only writable bundles are changed.
 - **Turn knowledge into repeatable work** -- Run persisted workflows with dispatch, gates, retries, budgets, and resume instead of reconstructing a process from prose every session.
 
 akm retrieves every supported capability type. It directly orchestrates
@@ -80,16 +80,16 @@ Or generate it directly: `akm help agents >> AGENTS.md`
 
 ## Documentation
 
-Full docs, CLI reference, and guides are available on [GitHub](https://github.com/itlackey/akm):
+Full docs, CLI reference, and guides are at **[akm.fwdslsh.dev](https://akm.fwdslsh.dev/)**:
 
-- [Getting Started](https://github.com/itlackey/akm/blob/main/docs/guides/getting-started.md)
-- [Supported Formats](https://github.com/itlackey/akm/blob/main/docs/reference/supported-formats.md)
-- [CLI Reference](https://github.com/itlackey/akm/blob/main/docs/reference/cli.md)
-- [Task v3 Reference](https://github.com/itlackey/akm/blob/main/docs/reference/tasks.md)
-- [0.9.2 Migration Guide](https://github.com/itlackey/akm/blob/main/docs/migration/v0.9.1-to-v0.9.2.md)
-- [Configuration](https://github.com/itlackey/akm/blob/main/docs/reference/configuration.md)
-- [Bundle Authoring Guide](https://github.com/itlackey/akm/blob/main/docs/guides/author-bundles.md)
-- [Registry](https://github.com/itlackey/akm/blob/main/docs/reference/registry.md)
+- [Getting Started](https://akm.fwdslsh.dev/docs/guides/getting-started/)
+- [Supported Formats](https://akm.fwdslsh.dev/docs/reference/supported-formats/)
+- [CLI Reference](https://akm.fwdslsh.dev/docs/reference/cli/)
+- [Task v3 Reference](https://akm.fwdslsh.dev/docs/reference/tasks/)
+- [0.9.2 Migration Guide](https://akm.fwdslsh.dev/docs/migration/v0.9.1-to-v0.9.2/)
+- [Configuration](https://akm.fwdslsh.dev/docs/reference/configuration/)
+- [Bundle Authoring Guide](https://akm.fwdslsh.dev/docs/guides/author-bundles/)
+- [Registry](https://akm.fwdslsh.dev/docs/reference/registry/)
 
 ## License
 

package/ROADMAP.md

@@ -0,0 +1,112 @@
+# Roadmap
+
+This page outlines the high-level focus for the next two releases.
+
+It is intentionally directional rather than exhaustive. Detailed command,
+schema, and migration behavior still lives in the release notes, the
+migration guides, and [STABILITY.md](STABILITY.md), which classifies
+today's public contract by surface. The internal design specs behind the
+0.9.0 architecture consolidation live under
+[`docs/architecture/specs/`](docs/architecture/specs/).
+
+## 0.8 Foundation
+
+Release `0.8.0` already established much of the product shape that `0.9` and
+`1.0` build on.
+
+- The CLI and config surface were substantially redesigned.
+- `akm improve` became the main self-improvement and maintenance entry point.
+- Task assets, proposal workflows, health reporting, and agent command-building
+  all landed as first-class capabilities.
+- Storage, indexing, graph extraction, and migration paths were tightened to
+  support the v1 contract freeze.
+
+That means the next two releases are less about inventing a new direction and
+more about hardening, simplifying, and freezing what `0.8.0` put in place.
+
+## 0.9
+
+Release `0.9` is the architecture-consolidation release ahead of the `1.0`
+contract freeze. It replaces the flat asset-type registry with a
+**bundle / adapter** model and settles the durable contracts `1.0` will freeze.
+
+- **One canonical ref grammar.** Refs are `[bundle//]conceptId` — a
+  subdir-qualified concept id such as `skills/code-review` or `memories/vpn-note`
+  — replacing the pre-`0.9` `type:name` spelling. Durable state stores the
+  fully-qualified form; the short bundle-omitted form is input sugar. This is a
+  deliberate, one-time break, taken pre-`1.0` while it is still cheap.
+- **Format-neutral bundles.** Installed sources are bundles, each recognized by
+  a built-in adapter (Agent Skills, Claude/OpenCode commands and agents,
+  knowledge, YAML workflows, tasks, env/secret files, scripts, OKF and LLM-wiki
+  knowledge bases) instead of a closed asset-type list.
+- **Storage consolidation.** The durable databases collapse from four to three
+  (`state.db` / `index.db` / a separate `logs.db`); config migrates from the
+  flat `stashDir` / `sources` / `installed` keys to `bundles` / `defaultBundle`.
+  The one-time cutover is journaled and crash-resumable via `akm migrate apply`,
+  with a verified backup taken first.
+- **Debt paydown.** The improve / proposal / workflow internals are decomposed
+  onto one file-change transaction model and an ambient run context, the
+  deprecated `0.8` CLI aliases are removed, and the `vault` asset type is
+  retired in favor of `env` / `secret`.
+
+In short: `0.9` reduces ambiguity, pays down pre-`1.0` debt, and arrives at a
+small, durable core ready for the `1.0` freeze.
+
+### The 0.9.x series
+
+`0.9.x` is a series of refactoring and clean-up releases. The intent is to
+have **all technical debt paid off and all planned breaking changes handled
+before the 0.10.x series begins**. To get there quickly, 0.9.x patch releases
+may include breaking changes (see [STABILITY.md](STABILITY.md)); every
+break ships with a CHANGELOG migration note.
+
+Alongside the bug fixes and compatibility improvements, `0.9.x` also focuses
+on **tuning the improve processes** — reflect, distill, consolidate, memory
+inference, graph extraction, and proactive maintenance — and **settling the
+final design of those features** so the `0.10.0` release starts from a
+finished improve surface rather than one still being reshaped.
+
+## 0.10
+
+The `0.10.x` series is focused on **bug fixes and tuning** on top of the
+debt-free 0.9 core — no new architecture. With the clean-up done, 0.10.x
+attempts to return to the normal semver discipline: breaking changes only in
+major and minor releases, never in patches.
+
+## 0.X
+
+There may be other minor releases between 0.10.x and 1.0.0. The goal is to minimize the number of minor releases after 0.10.x, and they will only be used for addressing breaking changes that are justifiable before the 1.0.0 release.
+
+## 1.0
+
+Release `1.0` is focused on freezing the public contract and shipping the first
+stable ecosystem layer around that core.
+
+- Freeze the supported source model, the `[bundle//]conceptId` ref format,
+  search behavior, and write-target rules — the surfaces
+  [STABILITY.md](STABILITY.md)'s own 1.0 contract-freeze section
+  already names — and settle the surfaces it currently classifies as
+  Evolving or Experimental.
+- Carry the `0.8` agent and improvement workflow forward as a stable,
+  documented product surface rather than a collection of pre-release features.
+- Ship an official akm SDK for building integrations against the stable v1
+  contract instead of reverse-engineering CLI behavior.
+- Ship in-process akm plugins for Claude Code and OpenCode, built on that SDK,
+  so those tools can integrate more deeply without changing the CLI-first core
+  model that akm itself relies on.
+- Keep the CLI as the canonical foundation so the SDK and plugin story extends
+  the existing system rather than forking it into separate integration models.
+
+In short: `1.0` is where akm stops being only a strong CLI and becomes a stable
+platform for both direct use and deeper tool integration.
+
+## Scope Notes
+
+- The CLI remains the foundation in both releases.
+- `0.9` prioritizes hardening over expansion.
+- `1.0` adds the SDK and in-process plugin story on top of a frozen core, not
+  instead of it.
+- The roadmap assumes the `0.8.0` redesign is the baseline; later releases are
+  about stabilizing and extending that baseline, not replacing it.
+- Specific features may move between releases as implementation and testing
+  shake out, but the themes above are the intended direction.

package/dist/commands/improve/improve-cli.js

@@ -16,7 +16,8 @@ import { clearLogFile, setLogFile, warn } from "../../core/warn.js";
 import { resolveWriteTarget } from "../../core/write-source.js";
 import { DEFAULT_LLM_TIMEOUT_MS } from "../../integrations/agent/config.js";
 import { defaultWhich } from "../../integrations/agent/detect.js";
-import { collectEngineCredentialValues } from "../../integrations/agent/engine-resolution.js";
+import { collectEngineCredentialValues, materializeLlmConnection, } from "../../integrations/agent/engine-resolution.js";
+import { llmUseFromRunner, sdkFallbackUseFromRunner } from "../../integrations/agent/runner.js";
 import { probeLlmReachable } from "../../llm/client.js";
 import { getOutputMode } from "../../output/context.js";
 import { deliverRendered } from "../../output/html-render.js";
@@ -81,18 +82,36 @@ function collectRequiredEngineTargets(plan) {
     const runners = Object.entries(plan.processes)
         .flatMap(([processName, process]) => (process.runner ? [[processName, process.runner]] : []))
         .concat(plan.triageJudgment ? [["triage.judgment", plan.triageJudgment]] : []);
-    return runners.map(([processName, runner]) => ({
-        process: processName,
-        engine: runner.engine,
-        ...(runner.kind === "llm" ? { connection: probeConnection(runner) } : { bin: runner.profile.bin }),
-        ...(runner.kind === "sdk" && runner.fallbackConnection
-            ? { connection: probeConnection({ connection: runner.fallbackConnection, timeoutMs: runner.fallbackTimeoutMs }) }
-            : {}),
-    }));
+    return runners.map(([processName, runner]) => {
+        // The runner's own timeout, else the connection's (sdkFallbackUseFromRunner already does this).
+        const use = runner.kind === "llm"
+            ? {
+                ...llmUseFromRunner(runner),
+                timeoutMs: runner.timeoutMs !== undefined ? runner.timeoutMs : (runner.connection.timeoutMs ?? null),
+            }
+            : runner.kind === "sdk"
+                ? sdkFallbackUseFromRunner(runner)
+                : undefined;
+        return {
+            process: processName,
+            engine: runner.engine,
+            ...(runner.kind === "llm" ? {} : { bin: runner.profile.bin }),
+            ...(use ? probeConnection(use) : {}),
+        };
+    });
 }
-/** The resolved engine keeps its request timeout beside the connection (the runtime merges it in); the probe needs it on the connection. */
-function probeConnection(runner) {
-    return runner.timeoutMs !== undefined ? { ...runner.connection, timeoutMs: runner.timeoutMs } : runner.connection;
+/**
+ * The connection the probe sends, built as a dispatch builds it: the runner
+ * keeps its credential symbolic, so the key is read and injected here, or the
+ * probe would go out without one.
+ */
+function probeConnection(use) {
+    try {
+        return { connection: materializeLlmConnection(use) };
+    }
+    catch (err) {
+        return { connection: use.connection, error: err instanceof Error ? err.message : String(err) };
+    }
 }
 /**
  * The bound on `--require-engines`' probe: the connection's own request
@@ -133,6 +152,8 @@ export async function assertRequiredEnginesReachable(plan, probeReachable = (con
         }
         if (!target.connection)
             return { ...target, reach: { reachable: true }, latencyMs: 0 };
+        if (target.error)
+            return { ...target, reach: { reachable: false, error: target.error }, latencyMs: 0 };
         return { ...target, ...(await probeConnectionOnce(target.connection)) };
     }));
     const unreachable = probed.filter((item) => !item.reach.reachable);

package/dist/commands/sources/plugin-upgrade.js

@@ -141,13 +141,13 @@ function homeDir() {
     return process.env.HOME?.trim() || process.env.USERPROFILE?.trim() || os.homedir();
 }
 /**
- * Whether the user's global OpenCode config asks for `akm-opencode@next`.
- * A bare `akm-opencode` resolves to `@latest` when OpenCode prefetches it, so
- * only a config that names the tag can follow prereleases. The config is only
- * read, never written; project configs are not looked at (akm does not know
- * which project OpenCode runs in).
+ * The `akm-opencode` spec the user's global OpenCode config names (bare,
+ * `@latest`, `@next`, an exact version, ...), or undefined when none does.
+ * OpenCode caches each spec in its own folder, so this says which cache it
+ * loads. The config is only read, never written; project configs are not
+ * looked at (akm does not know which project OpenCode runs in).
  */
-export function openCodeConfigRequestsNext() {
+export function openCodeConfigSpec() {
     const configHome = process.env.XDG_CONFIG_HOME?.trim() || path.join(homeDir(), ".config");
     const files = [
         process.env.OPENCODE_CONFIG?.trim(),
@@ -162,14 +162,18 @@ export function openCodeConfigRequestsNext() {
             if (!Array.isArray(config.plugin))
                 continue;
             // An entry is a spec string or a `[spec, options]` pair.
-            if (config.plugin.some((entry) => (Array.isArray(entry) ? entry[0] : entry) === OPENCODE_NEXT_SPEC))
-                return true;
+            for (const entry of config.plugin) {
+                const spec = Array.isArray(entry) ? entry[0] : entry;
+                if (typeof spec === "string" && (spec === OPENCODE_PACKAGE || spec.startsWith(`${OPENCODE_PACKAGE}@`))) {
+                    return spec;
+                }
+            }
         }
         catch {
-            // Missing or unparseable: this file does not request it.
+            // Missing or unparseable: this file names no spec.
         }
     }
-    return false;
+    return undefined;
 }
 /**
  * The cached `akm-opencode` OpenCode installed on first use, or undefined when
@@ -294,12 +298,17 @@ function openCodeRunning() {
 }
 const NOT_FOLLOWING_NEXT = `--next: OpenCode resolves a bare "${OPENCODE_PACKAGE}" to @latest, so it is not updated to a prerelease; ` +
     `set "plugin": ["${OPENCODE_NEXT_SPEC}"] in your OpenCode config to follow prereleases`;
-const FOLLOWING_NEXT = `OpenCode loads "${OPENCODE_NEXT_SPEC}" (your OpenCode config), so a plain upgrade leaves it alone; ` +
-    `run \`akm upgrade --next\` to update it, or set "plugin": ["${OPENCODE_PACKAGE}"] to follow stable releases`;
-function upgradeOpenCode(dryRun, cache, latest, tag, notFollowingNext, followingNext) {
-    // Refreshing @latest would trash a cache OpenCode never re-creates (#1115).
-    if (followingNext)
-        return skipped("opencode", FOLLOWING_NEXT);
+/** Why a run leaves alone an OpenCode whose config names a spec this run does not refresh (#1115, #1117). */
+function otherSpecNote(spec) {
+    const loads = `OpenCode loads "${spec}" (your OpenCode config), so this upgrade leaves it alone`;
+    return spec === OPENCODE_NEXT_SPEC
+        ? `${loads}; run \`akm upgrade --next\` to update it, or set "plugin": ["${OPENCODE_PACKAGE}"] to follow stable releases`
+        : `${loads}; set "plugin": ["${OPENCODE_PACKAGE}"] to have \`akm upgrade\` keep it current`;
+}
+function upgradeOpenCode(dryRun, cache, latest, tag, notFollowingNext, otherSpec) {
+    // Refreshing a cache OpenCode does not load would trash one it never re-creates (#1115, #1117).
+    if (otherSpec)
+        return skipped("opencode", otherSpecNote(otherSpec));
     if (!cache || !latest)
         return skipped("opencode", `no cached ${OPENCODE_PACKAGE}@${tag} plugin`);
     if ("error" in latest)
@@ -356,13 +365,13 @@ function withNextNote(entry) {
     return { ...entry, message: entry.message ? `${entry.message}; ${NO_PRERELEASE_CHANNEL}` : NO_PRERELEASE_CHANNEL };
 }
 export function upgradePlugins(opts) {
-    const { cache, latest, tag, notFollowingNext, followingNext } = opts.openCode;
+    const { cache, latest, tag, notFollowingNext, otherSpec } = opts.openCode;
     const claude = upgradeClaudeCode(opts.dryRun);
     const codex = upgradeCodex(opts.dryRun);
     return [
         opts.next ? withNextNote(claude) : claude,
         opts.next ? withNextNote(codex) : codex,
-        upgradeOpenCode(opts.dryRun, cache, latest, tag, notFollowingNext, followingNext),
+        upgradeOpenCode(opts.dryRun, cache, latest, tag, notFollowingNext, otherSpec),
     ];
 }
 /**
@@ -419,16 +428,30 @@ export function applyLockstep(check, latest, tag = "latest") {
 /**
  * Which OpenCode plugin build the CLI is held to, and which cache refreshes.
  * Under `--next` that is `akm-opencode@next`, but only when the user's OpenCode
- * config names that tag: otherwise OpenCode keeps resolving `@latest`, so the
- * lockstep stays against the `@latest` pin and the entry is reported as skipped.
+ * config names that tag: a bare one keeps resolving `@latest`, so the lockstep
+ * stays against the `@latest` pin and the entry is reported as skipped. A config
+ * naming any other spec (an exact version, or `@next` on a plain run) is left
+ * alone, with no lockstep.
  */
 function resolveOpenCodeTarget(next) {
-    const requestsNext = openCodeConfigRequestsNext();
-    const followNext = next && requestsNext;
+    // No config entry behaves like a bare one: OpenCode would resolve @latest.
+    const spec = openCodeConfigSpec() ?? OPENCODE_PACKAGE;
+    const followsLatest = spec === OPENCODE_PACKAGE || spec === `${OPENCODE_PACKAGE}@latest`;
+    const followNext = next && spec === OPENCODE_NEXT_SPEC;
+    // Any other spec loads a cache this run does not refresh, and pins no akm-cli it should be held to.
+    if (!followsLatest && !followNext) {
+        return {
+            cache: undefined,
+            latest: undefined,
+            tag: next ? "next" : "latest",
+            notFollowingNext: false,
+            otherSpec: spec,
+        };
+    }
     const tag = followNext ? "next" : "latest";
     const cache = detectOpenCodeCache(tag);
     const latest = cache ? (followNext ? lookupOpenCodeNext() : lookupOpenCodeLatest()) : undefined;
-    return { cache, latest, tag, notFollowingNext: next && !followNext, followingNext: !next && requestsNext };
+    return { cache, latest, tag, notFollowingNext: next && !followNext };
 }
 /** `akm upgrade`: the CLI step (held to the OpenCode plugin's akm), then the plugins. */
 export async function runUpgrade(args, currentVersion, deps) {

package/dist/core/file-lock.js

@@ -51,14 +51,23 @@ function releaseLockRaw(lockPath) {
 }
 /** Create the lock file atomically; `undefined` when another holder already has it. */
 export function tryAcquireLockSync(lockPath, payload) {
+    // Write the payload under a private name, then hard-link it into place: the
+    // link is the exclusive step and the lock never exists without its payload.
+    // A `wx` write creates the file empty and fills it in afterwards; a contender
+    // probing in that gap reads no pid, calls the live lock stale and reclaims it.
+    const tmpPath = `${lockPath}.tmp-${process.pid}-${randomUUID()}`;
+    fs.writeFileSync(tmpPath, payload, { flag: "wx" });
     try {
-        fs.writeFileSync(lockPath, payload, { flag: "wx" });
+        fs.linkSync(tmpPath, lockPath);
     }
     catch (err) {
         if (err.code === "EEXIST")
             return undefined;
         throw err;
     }
+    finally {
+        releaseLockRaw(tmpPath);
+    }
     let snapshot;
     try {
         snapshot = readLockSnapshot(lockPath);

package/dist/llm/client.js

@@ -227,6 +227,12 @@ const jsonSchemaUnsupportedConnections = new Set();
  * `enable_thinking`): a strict hosted API answers 400 `Unknown parameter`.
  */
 const thinkingControlRejectedConnections = new Set();
+/**
+ * And for OpenAI's reasoning models: they answer 400 to any `temperature` but
+ * the default, and to `max_tokens`, naming `max_completion_tokens` instead.
+ */
+const temperatureRejectedConnections = new Set();
+const maxCompletionTokensConnections = new Set();
 function connectionKey(config) {
     return `${config.endpoint}|${config.model}`;
 }
@@ -234,6 +240,8 @@ function connectionKey(config) {
 export function _resetEndpointSupportTrackersForTests() {
     jsonSchemaUnsupportedConnections.clear();
     thinkingControlRejectedConnections.clear();
+    temperatureRejectedConnections.clear();
+    maxCompletionTokensConnections.clear();
 }
 /**
  * Whether this connection has already been proven, this process, not to
@@ -263,6 +271,10 @@ function isRejectedRequest(err) {
 }
 /** A strict API names the field it does not know: `Unknown parameter: 'chat_template_kwargs'.` */
 const THINKING_FIELD_NAMED = /chat_template_kwargs|enable_thinking/;
+/** `Unsupported value: 'temperature' does not support 0 with this model. Only the default (1) value is supported.` */
+const TEMPERATURE_NAMED = /'temperature'/;
+/** `Unsupported parameter: 'max_tokens' is not supported with this model. Use 'max_completion_tokens' instead.` */
+const MAX_TOKENS_REPLACED = /max_completion_tokens/;
 /**
  * A single chat-completion attempt: one HTTP request/response cycle, with an
  * inline fallback-once when a schema was requested and the provider 4xx's
@@ -275,7 +287,10 @@ const THINKING_FIELD_NAMED = /chat_template_kwargs|enable_thinking/;
  *
  * The thinking-control fields get the same treatment (#1045): a 4xx that
  * names `chat_template_kwargs` or `enable_thinking` is answered by one retry
- * without them, which may in turn fall back without the schema.
+ * without them, which may in turn fall back without the schema. A 4xx that
+ * names `temperature`, or asks for `max_completion_tokens`, is answered the
+ * same way: the connection stops sending `temperature`, or sends the token cap
+ * as `max_completion_tokens`, for the rest of the process.
  */
 async function chatCompletionAttempt(config, messages, options, timeoutMs, includeThinking = (options?.enableThinking ?? config.enableThinking) !== undefined &&
     !isThinkingControlKnownRejected(config)) {
@@ -286,6 +301,17 @@ async function chatCompletionAttempt(config, messages, options, timeoutMs, inclu
     catch (err) {
         if (!isRejectedRequest(err))
             throw err;
+        const key = connectionKey(config);
+        if (TEMPERATURE_NAMED.test(err.message) && !temperatureRejectedConnections.has(key)) {
+            warnVerbose(`[akm] LLM rejected temperature (${err.statusCode}); retrying once without it: ${err.message}`);
+            temperatureRejectedConnections.add(key);
+            return chatCompletionAttempt(config, messages, options, timeoutMs, includeThinking);
+        }
+        if (MAX_TOKENS_REPLACED.test(err.message) && !maxCompletionTokensConnections.has(key)) {
+            warnVerbose(`[akm] LLM rejected max_tokens (${err.statusCode}); retrying once with max_completion_tokens: ${err.message}`);
+            maxCompletionTokensConnections.add(key);
+            return chatCompletionAttempt(config, messages, options, timeoutMs, includeThinking);
+        }
         if (includeThinking && THINKING_FIELD_NAMED.test(err.message)) {
             warnVerbose(`[akm] LLM rejected chat_template_kwargs/enable_thinking (${err.statusCode}); retrying once without them: ${err.message}`);
             const fallback = await chatCompletionAttempt(config, messages, options, timeoutMs, false);
@@ -344,11 +370,15 @@ async function chatCompletionAttemptOnce(config, messages, options, timeoutMs, i
         ? {}
         : { chat_template_kwargs: { enable_thinking: resolvedEnableThinking }, enable_thinking: resolvedEnableThinking };
     const reasoningEffortParams = config.reasoningEffort === undefined ? {} : { reasoning_effort: config.reasoningEffort };
+    const key = connectionKey(config);
+    const maxTokensField = maxCompletionTokensConnections.has(key) ? "max_completion_tokens" : "max_tokens";
     const requestBody = JSON.stringify({
         model: config.model,
         messages,
-        temperature: options?.temperature ?? config.temperature ?? 0.3,
-        ...(resolvedMaxTokens !== undefined ? { max_tokens: resolvedMaxTokens } : {}),
+        ...(temperatureRejectedConnections.has(key)
+            ? {}
+            : { temperature: options?.temperature ?? config.temperature ?? 0.3 }),
+        ...(resolvedMaxTokens !== undefined ? { [maxTokensField]: resolvedMaxTokens } : {}),
         ...config.extraParams,
         ...responseFormat,
         ...thinkingParams,

package/dist/scripts/akm-migrate-node.js

@@ -36842,12 +36842,16 @@ function releaseLockRaw(lockPath) {
   } catch {}
 }
 function tryAcquireLockSync(lockPath, payload) {
+  const tmpPath = `${lockPath}.tmp-${process.pid}-${randomUUID()}`;
+  fs7.writeFileSync(tmpPath, payload, { flag: "wx" });
   try {
-    fs7.writeFileSync(lockPath, payload, { flag: "wx" });
+    fs7.linkSync(tmpPath, lockPath);
   } catch (err) {
     if (err.code === "EEXIST")
       return;
     throw err;
+  } finally {
+    releaseLockRaw(tmpPath);
   }
   let snapshot;
   try {

package/dist/scripts/akm-migrate.js

@@ -36170,12 +36170,16 @@ function releaseLockRaw(lockPath) {
   } catch {}
 }
 function tryAcquireLockSync(lockPath, payload) {
+  const tmpPath = `${lockPath}.tmp-${process.pid}-${randomUUID()}`;
+  fs7.writeFileSync(tmpPath, payload, { flag: "wx" });
   try {
-    fs7.writeFileSync(lockPath, payload, { flag: "wx" });
+    fs7.linkSync(tmpPath, lockPath);
   } catch (err) {
     if (err.code === "EEXIST")
       return;
     throw err;
+  } finally {
+    releaseLockRaw(tmpPath);
   }
   let snapshot;
   try {