akm-cli 0.9.5 → 0.9.7

package/dist/core/asset/frontmatter.js

@@ -207,6 +207,122 @@ export function spliceFrontmatterLine(raw, line) {
     lines.splice(closeIdx, 0, line);
     return lines.join("\n");
 }
+/**
+ * Strip one layer of matching quotes — frontmatter list items are often quoted
+ * refs. Written as an explicit char compare rather than a backreference regex
+ * on purpose: `scripts/lint-repository-sql.ts`'s comment/string stripper has no
+ * regex-literal awareness, so a literal holding an ODD number of quote
+ * characters desyncs its state machine and corrupts every match after it.
+ */
+function unquote(value) {
+    const trimmed = value.trim();
+    if (trimmed.length < 2)
+        return trimmed;
+    const first = trimmed[0];
+    if ((first === '"' || first === "'") && trimmed[trimmed.length - 1] === first)
+        return trimmed.slice(1, -1);
+    return trimmed;
+}
+/**
+ * Remove specific VALUES from one frontmatter list key, preserving every other
+ * byte — the counterpart to {@link spliceFrontmatterLine} for the
+ * `akm lint --prune-dangling-edges` repair (#884).
+ *
+ * Handles the three spellings a belief channel appears in: a block sequence
+ * (`contradictedBy:\n  - a`), an inline flow (`contradictedBy: [a, b]`), and a
+ * bare scalar (`contradictedBy: a`). When every value under the key is removed
+ * the key itself goes too — an empty `contradictedBy: []` is not the same
+ * assertion as no edge at all.
+ *
+ * Returns the rewritten source, or `null` when `raw` has no well-formed
+ * frontmatter block or nothing matched, so the caller can leave the file
+ * untouched and report the finding unfixed. Deliberately source-preserving:
+ * these are user-authored memories, and a repair must not silently reformat
+ * the frontmatter it was not asked to touch.
+ */
+export function removeFrontmatterListValues(raw, key, values) {
+    const remove = new Set(values.map((v) => unquote(v)));
+    if (remove.size === 0)
+        return null;
+    const lines = raw.split(/\r?\n/);
+    if (lines[0]?.trim() !== "---")
+        return null;
+    const closeIdx = lines.findIndex((l, i) => i > 0 && l.trim() === "---");
+    if (closeIdx === -1)
+        return null;
+    const out = [];
+    let changed = false;
+    let index = 0;
+    while (index < lines.length) {
+        const line = lines[index];
+        if (index === 0 || index >= closeIdx) {
+            out.push(line);
+            index += 1;
+            continue;
+        }
+        const kv = line.match(/^(\w[\w-]*):\s*(.*)$/);
+        if (kv === null || kv[1] !== key) {
+            out.push(line);
+            index += 1;
+            continue;
+        }
+        const rest = kv[2].trim();
+        // Inline flow: contradictedBy: [a, b]
+        const flow = rest.match(/^\[(.*)\]$/);
+        if (flow !== null) {
+            const kept = flow[1]
+                .split(",")
+                .map((item) => item.trim())
+                .filter(Boolean)
+                .filter((item) => !remove.has(unquote(item)));
+            const original = flow[1].split(",").filter((s) => s.trim().length > 0).length;
+            if (kept.length !== original) {
+                changed = true;
+                if (kept.length > 0)
+                    out.push(`${key}: [${kept.join(", ")}]`);
+            }
+            else {
+                out.push(line);
+            }
+            index += 1;
+            continue;
+        }
+        // Bare scalar: contradictedBy: a
+        if (rest !== "") {
+            if (remove.has(unquote(rest)))
+                changed = true;
+            else
+                out.push(line);
+            index += 1;
+            continue;
+        }
+        // Block sequence: the key line, then `  - value` items.
+        const header = line;
+        const items = [];
+        let cursor = index + 1;
+        while (cursor < closeIdx) {
+            const itemMatch = lines[cursor].match(/^\s+-\s*(.*)$/);
+            if (itemMatch === null)
+                break;
+            items.push(lines[cursor]);
+            cursor += 1;
+        }
+        const kept = items.filter((item) => !remove.has(unquote(item.replace(/^\s*-\s*/, ""))));
+        if (kept.length !== items.length) {
+            changed = true;
+            if (kept.length > 0) {
+                out.push(header);
+                out.push(...kept);
+            }
+        }
+        else {
+            out.push(header);
+            out.push(...items);
+        }
+        index = cursor;
+    }
+    return changed ? out.join("\n") : null;
+}
 /**
  * Parse a YAML scalar value (string, boolean, or number).
  *

package/dist/core/asset/memory-archive.js

@@ -0,0 +1,97 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+/**
+ * The memory-cleanup archive as a REF-RESOLUTION surface (#884).
+ *
+ * `analyzeMemoryCleanup`'s prune (`commands/improve/memory/memory-improve.ts`
+ * `#archiveMemory`) does not delete a memory: it `rename`s the file under
+ * `.akm/memory-cleanup/archive/<stamp>-<ref>/<originalPath>` and writes a
+ * sibling `cleanup.md` audit asset carrying `ref` / `originalPath` /
+ * `archivedPath`. The bytes and the identity both survive — but the ref stops
+ * resolving at its ORIGINAL location, so every inbound belief edge
+ * (`contradictedBy` / `supersededBy`) pointing at the pruned memory becomes a
+ * `missing-ref` the moment #882 made those channels validatable.
+ *
+ * That is the #884 defect, and the archive already holds everything needed to
+ * fix it: the audit record IS a tombstone. This module reads those tombstones
+ * so ref resolution can answer "archived" instead of "missing". Resolution
+ * stays non-destructive — pruning never rewrites an unrelated memory's
+ * frontmatter, and the contradiction an edge records is preserved rather than
+ * erased (the concern #884 raised against a bare edge-scrub).
+ *
+ * A ref whose target has NO tombstone and no file is genuinely dangling — it
+ * was removed by something other than prune (a hand `git rm`, an older
+ * release). Those stay reported; clearing them mutates user data and so is
+ * gated behind `akm lint --prune-dangling-edges`.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { parseFrontmatter } from "./frontmatter.js";
+/** Stash-relative root the prune path archives into. Must match `memory-improve.ts#createArchiveDir`. */
+export const MEMORY_ARCHIVE_REL = ".akm/memory-cleanup/archive";
+/** Filename of the per-archive audit asset written alongside the archived memory. */
+const AUDIT_FILENAME = "cleanup.md";
+/**
+ * Cache keyed by stash root. A lint sweep resolves thousands of refs against a
+ * directory that only the prune path ever writes, so the scan runs once per
+ * root instead of once per missing ref.
+ */
+const cache = new Map();
+/** @internal Drop the memoized scans — process-global state needs a reset seam for tests (#785). */
+export function resetMemoryArchiveCache() {
+    cache.clear();
+}
+/**
+ * Every stash-relative `originalPath` archived under `root`, i.e. the set of
+ * paths that USED to hold a memory and now hold a tombstone instead.
+ *
+ * Unreadable or malformed audit records are skipped rather than thrown: a
+ * corrupt tombstone must degrade to "this ref is missing" (the pre-#884
+ * answer), never break the whole lint sweep.
+ */
+export function archivedOriginalPaths(root) {
+    const cached = cache.get(root);
+    if (cached !== undefined)
+        return cached;
+    const paths = new Set();
+    const archiveRoot = path.join(root, MEMORY_ARCHIVE_REL);
+    let entries;
+    try {
+        entries = fs.readdirSync(archiveRoot, { withFileTypes: true });
+    }
+    catch {
+        cache.set(root, paths); // no archive dir — nothing was ever pruned here
+        return paths;
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        let raw;
+        try {
+            raw = fs.readFileSync(path.join(archiveRoot, entry.name, AUDIT_FILENAME), "utf8");
+        }
+        catch {
+            continue;
+        }
+        let originalPath;
+        try {
+            originalPath = parseFrontmatter(raw).data.originalPath;
+        }
+        catch {
+            continue;
+        }
+        if (typeof originalPath === "string" && originalPath.trim().length > 0) {
+            paths.add(originalPath.trim().replace(/\\/g, "/"));
+        }
+    }
+    cache.set(root, paths);
+    return paths;
+}
+/**
+ * True when `relPath` (stash-relative, POSIX) names a memory that prune
+ * archived — the ref resolves to a tombstone rather than to nothing.
+ */
+export function isArchivedRelPath(relPath, root) {
+    return archivedOriginalPaths(root).has(relPath.replace(/\\/g, "/"));
+}

package/dist/core/common.js

@@ -10,8 +10,6 @@ import { getConfigPath, getDefaultStashDir, getRegistryCacheDir, getRegistryInde
 // Moved to the platform leaf so paths.ts can use it without a common↔paths
 // cycle (chunk-8 WI-8.6, DoD 11); re-exported here for the existing surface.
 export { IS_WINDOWS } from "./platform.js";
-export const MAX_CONFIG_FILE_BYTES = 1024 * 1024;
-export const MAX_LOCAL_METADATA_BYTES = 1024 * 1024;
 export const MAX_LOCK_METADATA_BYTES = 64 * 1024;
 export function isHttpUrl(value) {
     return !!value && /^https?:\/\//.test(value);
@@ -51,10 +49,13 @@ export function readTextFileDescriptorWithLimit(fd, maxBytes, label = "File", di
     }
     return buffer.subarray(0, total).toString("utf8");
 }
-export function readTextFileWithLimit(filePath, maxBytes, label = "File") {
+export function readTextFile(filePath, label = "File") {
     const fd = fs.openSync(filePath, "r");
     try {
-        return readTextFileDescriptorWithLimit(fd, maxBytes, label, filePath);
+        const stat = fs.fstatSync(fd);
+        if (!stat.isFile())
+            throw new ConfigError(`${label} is not a regular file: ${filePath}.`, "INVALID_CONFIG_FILE");
+        return fs.readFileSync(fd, "utf8");
     }
     finally {
         fs.closeSync(fd);
@@ -290,7 +291,7 @@ function isValidDirectory(dir) {
 function readStashDirFromConfig() {
     try {
         const configPath = getConfigPath();
-        const text = readTextFileWithLimit(configPath, MAX_CONFIG_FILE_BYTES, "Config file");
+        const text = readTextFile(configPath, "Config file");
         // The config loader accepts JSONC, so a commented config.json is valid and
         // in use. Parsing it raw here threw, the catch swallowed it, and every
         // caller silently fell back — operating on the wrong bundle or failing with
@@ -544,21 +545,59 @@ export async function fetchWithTimeout(url, opts, timeoutMs = 30_000, signal) {
             clearTimeout(timer);
     }
 }
+/**
+ * Cap on how long a retry loop will wait between attempts, even when a
+ * server-supplied `Retry-After` claims a longer delay. Prevents an
+ * attacker-controlled or misconfigured server from parking a caller
+ * indefinitely.
+ */
+export const DEFAULT_RETRY_MAX_DELAY_MS = 30_000;
+export function shouldRetry(status) {
+    return status === 429 || status >= 500;
+}
+/** Jittered exponential backoff, capped at `maxDelayMs`. */
+export function backoffDelay(attempt, baseDelay = 500, maxDelayMs = DEFAULT_RETRY_MAX_DELAY_MS) {
+    return Math.min(maxDelayMs, baseDelay * 2 ** attempt * (0.5 + Math.random() * 0.5));
+}
+/**
+ * Determine the delay before the next retry attempt.
+ *
+ * Honors a server-supplied `Retry-After` header in both its numeric-seconds
+ * and HTTP-date forms, but always clamps the result to `maxDelayMs` — an
+ * unclamped `Retry-After` lets an attacker/misconfigured server park a
+ * caller for an arbitrarily long time. Falls back to jittered exponential
+ * backoff when the header is absent or unparseable.
+ */
+export function computeRetryDelay(response, attempt, options) {
+    const maxDelayMs = options?.maxDelayMs ?? DEFAULT_RETRY_MAX_DELAY_MS;
+    const baseDelay = options?.baseDelay ?? 500;
+    const retryAfter = response.headers.get("retry-after");
+    if (retryAfter) {
+        const seconds = Number(retryAfter);
+        if (Number.isFinite(seconds)) {
+            return seconds >= 0 ? Math.min(maxDelayMs, seconds * 1_000) : backoffDelay(attempt, baseDelay, maxDelayMs);
+        }
+        const date = Date.parse(retryAfter);
+        if (Number.isFinite(date))
+            return Math.min(maxDelayMs, Math.max(0, date - Date.now()));
+    }
+    return backoffDelay(attempt, baseDelay, maxDelayMs);
+}
 /**
  * Fetch with retry and exponential backoff.
  * Retries on network errors, 429, and 5xx responses.
- * Honors Retry-After header for 429 responses.
+ * Honors Retry-After header, capped at `maxDelayMs`.
  */
 export async function fetchWithRetry(url, init, options) {
     const maxRetries = options?.retries ?? 3;
     const baseDelay = options?.baseDelay ?? 500;
+    const maxDelayMs = options?.maxDelayMs ?? DEFAULT_RETRY_MAX_DELAY_MS;
     const timeout = options?.timeout ?? 30_000;
     for (let attempt = 0; attempt <= maxRetries; attempt++) {
         try {
             const response = await fetchWithTimeout(url, init, timeout, init?.signal ?? undefined);
             if (attempt < maxRetries && shouldRetry(response.status)) {
-                const retryAfter = parseRetryAfter(response);
-                const delay = retryAfter ?? baseDelay * 2 ** attempt * (0.5 + Math.random() * 0.5);
+                const delay = computeRetryDelay(response, attempt, { baseDelay, maxDelayMs });
                 await response.body?.cancel().catch(() => undefined);
                 await abortableDelay(delay, init?.signal);
                 continue;
@@ -571,8 +610,7 @@ export async function fetchWithRetry(url, init, options) {
             // A caller-supplied abort is terminal: never keep retrying past it.
             if (init?.signal?.aborted)
                 throw err;
-            const delay = baseDelay * 2 ** attempt * (0.5 + Math.random() * 0.5);
-            await abortableDelay(delay, init?.signal);
+            await abortableDelay(backoffDelay(attempt, baseDelay, maxDelayMs), init?.signal);
         }
     }
     throw new Error("fetchWithRetry: unreachable");
@@ -584,17 +622,19 @@ export async function fetchWithRetry(url, init, options) {
  * large. Sleeping it out with a bare `setTimeout` ignored the caller's abort
  * signal entirely, so a single `429` could park an operation far past any
  * deadline its caller believed it had imposed — the request timeout bounds
- * only the request, never the wait between attempts.
+ * only the request, never the wait between attempts. Callers using this for
+ * a retry delay should pass a `maxDelayMs`-capped `ms` (see
+ * {@link computeRetryDelay}) to bound the wait itself.
  */
-function abortableDelay(ms, signal) {
+export function abortableDelay(ms, signal, abortMessage = "Aborted") {
     if (!signal)
         return new Promise((resolve) => setTimeout(resolve, ms));
     if (signal.aborted)
-        return Promise.reject(signal.reason ?? new Error("Aborted"));
+        return Promise.reject(signal.reason ?? new Error(abortMessage));
     return new Promise((resolve, reject) => {
         const onAbort = () => {
             clearTimeout(timer);
-            reject(signal.reason ?? new Error("Aborted"));
+            reject(signal.reason ?? new Error(abortMessage));
         };
         const timer = setTimeout(() => {
             signal.removeEventListener("abort", onAbort);
@@ -603,9 +643,6 @@ function abortableDelay(ms, signal) {
         signal.addEventListener("abort", onAbort, { once: true });
     });
 }
-function shouldRetry(status) {
-    return status === 429 || status >= 500;
-}
 /**
  * Read stdin as UTF-8 text if something is piped in. Returns `undefined`
  * when stdin is a TTY (no pipe) or when the piped content is empty.
@@ -789,13 +826,6 @@ export async function jsonWithByteCap(response, maxBytes = DEFAULT_RESPONSE_BYTE
     const text = await readBodyWithByteCap(response, maxBytes, limits);
     return JSON.parse(text);
 }
-function parseRetryAfter(response) {
-    const header = response.headers.get("retry-after");
-    if (!header)
-        return undefined;
-    const seconds = parseInt(header, 10);
-    return Number.isNaN(seconds) ? undefined : seconds * 1000;
-}
 export function toErrorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -871,8 +901,15 @@ export function stringArray(value) {
  * reported alive. Treating it as dead let a lock held by a live process in a
  * shared data dir (agent sandboxes, containers, service accounts — a
  * configuration managed-db.ts explicitly supports) be reclaimed as stale.
+ *
+ * `pid` is `unknown` because callers reading it out of untrusted on-disk
+ * JSON (e.g. a lease file) cannot guarantee it parsed as a valid PID; a
+ * non-positive-integer value is reported dead without ever reaching
+ * `process.kill`.
  */
 export function isProcessAlive(pid) {
+    if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0)
+        return false;
     try {
         process.kill(pid, 0);
         return true;

package/dist/core/config/config-io.js

@@ -15,7 +15,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { sleepSync } from "../../runtime.js";
-import { MAX_CONFIG_FILE_BYTES, readTextFileWithLimit, stripJsonComments, writeFileAtomic } from "../common.js";
+import { readTextFile, stripJsonComments, writeFileAtomic } from "../common.js";
 import { ConfigError } from "../errors.js";
 import { createLockPayload, probeLock, reclaimStaleLock, releaseLock, tryAcquireLockSync } from "../file-lock.js";
 import { getCacheDir, getConfigDir } from "../paths.js";
@@ -25,7 +25,7 @@ import { getCacheDir, getConfigDir } from "../paths.js";
  */
 export function readConfigText(configPath) {
     try {
-        return readTextFileWithLimit(configPath, MAX_CONFIG_FILE_BYTES, "Config file");
+        return readTextFile(configPath, "Config file");
     }
     catch (err) {
         if (err.code === "ENOENT")

package/dist/core/config/config-sources.js

@@ -23,6 +23,16 @@ export function bundleComponentConfig(bundle) {
  * `defaultBundle` first, then map insertion order. Each entry's `name` is its
  * bundle key. Returns `undefined` when no bundles map is configured.
  */
+/**
+ * A bundle's true identity: its configured `path` plus its component's
+ * `root` (default `"."`), fully resolved. Two bundle entries whose bare
+ * `path` differs (relative vs. absolute, trailing slash, `~` vs. expanded)
+ * can still resolve to this same directory — this is the identity akm
+ * compares before registering or reconciling a bundle (issue #870).
+ */
+export function bundleContentRoot(entryPath, componentRoot) {
+    return path.resolve(entryPath, componentRoot ?? ".");
+}
 /**
  * The resolved primary stash path — the `defaultBundle`'s filesystem `path`
  * (spec §10.1) — or `undefined` when no filesystem primary is configured.
@@ -36,9 +46,9 @@ export function primaryBundlePath(config) {
     if (!entry || typeof entry.path !== "string" || entry.path.length === 0)
         return undefined;
     const componentRoot = bundleComponentConfig(entry)?.root;
-    if (!componentRoot || componentRoot === ".")
-        return entry.path;
     const bundleRoot = path.resolve(entry.path);
+    if (!componentRoot || componentRoot === ".")
+        return bundleRoot;
     const resolved = path.resolve(bundleRoot, componentRoot);
     const relative = path.relative(bundleRoot, resolved);
     if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
@@ -46,6 +56,26 @@ export function primaryBundlePath(config) {
     }
     return resolved;
 }
+/**
+ * Every configured filesystem bundle's id paired with its resolved content
+ * root. Used to detect two bundle ids that resolve to the same directory
+ * (issue #870) and to find the id that already owns a given root before a
+ * new one is registered.
+ */
+export function bundleContentRoots(config) {
+    const bundles = config.bundles ?? {};
+    const out = [];
+    for (const [id, entry] of Object.entries(bundles)) {
+        if (typeof entry.path !== "string" || entry.path.length === 0)
+            continue;
+        out.push({ id, contentRoot: bundleContentRoot(entry.path, bundleComponentConfig(entry)?.root) });
+    }
+    return out;
+}
+/** The bundle id whose resolved content root already matches `resolvedContentRoot`, if any. */
+export function bundleKeyForContentRoot(config, resolvedContentRoot) {
+    return bundleContentRoots(config).find((entry) => entry.contentRoot === resolvedContentRoot)?.id;
+}
 export function bundlesToSourceEntries(config) {
     const bundles = config.bundles;
     if (!bundles)

package/dist/core/config/config.js

@@ -376,7 +376,7 @@ export function getIndexPassConfig(config, passName) {
     return entry;
 }
 // Re-export source runtime helpers — implementation lives in config-sources.ts.
-export { bundleComponentConfig, bundleEntryToSourceEntry, bundlesToSourceEntries, installedSourceDescriptor, parseSourceSpec, primaryBundlePath, resolveConfiguredSources, } from "./config-sources.js";
+export { bundleComponentConfig, bundleContentRoot, bundleContentRoots, bundleEntryToSourceEntry, bundleKeyForContentRoot, bundlesToSourceEntries, installedSourceDescriptor, parseSourceSpec, primaryBundlePath, resolveConfiguredSources, } from "./config-sources.js";
 /**
  * Merge a partial user-config override onto a base config. Used by
  * {@link loadUserConfig} (DEFAULT_CONFIG + on-disk) and {@link updateConfig}

package/dist/core/config/engine-semantics.js

@@ -6,9 +6,7 @@ export const BUILTIN_IMPROVE_STRATEGY_NAMES = [
     "default",
     "quick",
     "thorough",
-    "memory-focus",
     "graph-refresh",
-    "frequent",
     "consolidate",
     "catchup",
     "reflect-distill",

package/dist/core/config/schema/engines.js

@@ -15,7 +15,7 @@ import { z } from "zod";
 // a config-schema ↔ config-types type cycle that collapses inference.
 import { HARNESS_AGENT_DISPATCH_IDS, VALID_HARNESS_IDS } from "../../../integrations/harnesses/ids.js";
 import { WORKFLOW_MAX_TIMEOUT_MS } from "../../../workflows/resource-limits.js";
-import { chatCompletionsEndpoint, ENV_REFERENCE_PATTERN, ExtraParamsSchema, engineName, LlmCapabilitiesSchema, nonEmptyString, positiveInt, } from "./primitives.js";
+import { chatCompletionsEndpoint, ENV_REFERENCE_PATTERN, ExtraParamsSchema, engineName, nonEmptyString, positiveInt, } from "./primitives.js";
 /**
  * Engine-config timeouts share the workflow ceiling.
  *
@@ -43,16 +43,20 @@ export const LlmConnectionConfigSchema = z
     maxTokens: positiveInt.optional(),
     timeoutMs: timeoutMsField,
     concurrency: positiveInt.optional(),
-    capabilities: LlmCapabilitiesSchema.optional(),
+    // User-settable override, not a cached probe verdict: attempt-then-
+    // fallback in llm/client.ts tries `response_format: json_schema` whenever
+    // a schema is supplied, degrading to plain text on an unsupported-4xx and
+    // remembering that in-memory for the rest of the process. `false` here
+    // opts a known-incompatible endpoint out of even the first attempt;
+    // `true` is advisory only.
+    supportsJsonSchema: z.boolean().optional(),
     extraParams: ExtraParamsSchema.optional(),
     contextLength: positiveInt.optional(),
     enableThinking: z.boolean().optional(),
     reasoningEffort: nonEmptyString.optional(),
 })
     .passthrough();
-export const LlmProfileConfigSchema = LlmConnectionConfigSchema.extend({
-    supportsJsonSchema: z.boolean().optional(),
-}).passthrough();
+export const LlmProfileConfigSchema = LlmConnectionConfigSchema.passthrough();
 // ── Agent engines ───────────────────────────────────────────────────────────
 // Derives from the canonical VALID_HARNESS_IDS (#565) so the Zod gate cannot
 // drift from the TS union / parse check / setup detection.
@@ -68,7 +72,6 @@ const LlmEngineSchema = z
     maxTokens: positiveInt.optional(),
     timeoutMs: timeoutMsField,
     concurrency: positiveInt.optional(),
-    supportsJsonSchema: z.boolean().optional(),
     extraParams: ExtraParamsSchema.optional(),
     contextLength: positiveInt.optional(),
     enableThinking: z.boolean().optional(),
@@ -103,7 +106,6 @@ const AgentEngineSchema = z
         "temperature",
         "maxTokens",
         "concurrency",
-        "supportsJsonSchema",
         "extraParams",
         "contextLength",
         "enableThinking",

package/dist/core/config/schema/primitives.js

@@ -54,11 +54,6 @@ export const ExtraParamsSchema = z.record(z.unknown()).superRefine((value, ctx)
     }
 });
 // ── Shared connection/invocation building blocks ────────────────────────────
-export const LlmCapabilitiesSchema = z
-    .object({
-    structuredOutput: z.boolean().optional(),
-})
-    .passthrough();
 export const LlmInvocationOverridesSchema = z
     .object({
     temperature: z.number().finite().optional(),

package/dist/core/config/schema/search.js

@@ -16,7 +16,8 @@ const SearchGraphBoostSchema = z
     hopBoostCap: nonNegativeNumber.optional(),
     /** Hard-capped at 3; values > 3 hard-error so users see the typo. */
     maxHops: positiveInt.max(3).optional(),
-    confidenceMode: z.enum(["off", "blend", "multiply"]).default("blend").optional(),
+    /** Only "blend" is exercised; "off"/"multiply" were never set in practice and were removed. */
+    confidenceMode: z.enum(["blend"]).default("blend").optional(),
     /** Range [0, 1]; values > 1 hard-error (no silent clamp). */
     confidenceWeight: z.number().finite().min(0).max(1).default(0.2).optional(),
 })

package/dist/core/file-lock.js

@@ -4,6 +4,7 @@
 import { randomUUID } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
+import { sleepSync } from "../runtime.js";
 import { openDatabase } from "../storage/database.js";
 import { isProcessAlive, MAX_LOCK_METADATA_BYTES, readTextFileDescriptorWithLimit } from "./common.js";
 function readLockSnapshot(lockPath) {
@@ -51,7 +52,7 @@ function withLockOperationMutex(lockPath, run) {
             db.exec("BEGIN IMMEDIATE");
             began = db.inTransaction;
             if (!began)
-                Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 2 ** attempt);
+                sleepSync(2 ** attempt);
         }
         if (!began)
             throw new Error(`Could not acquire lock operation mutex for ${lockPath}.`);

package/dist/core/maintenance-barrier.js

@@ -5,6 +5,7 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { randomUUID } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
+import { sleepSync } from "../runtime.js";
 import { ConfigError } from "./errors.js";
 import { createLockPayload, probeLock, reclaimStaleLock, releaseLock, tryAcquireLockSync } from "./file-lock.js";
 import { getMaintenanceBarrierPath } from "./paths.js";
@@ -93,7 +94,7 @@ function withMaintenanceStartBarrierSyncWait(run) {
     const deadline = Date.now() + 5_000;
     let release = tryAcquireMaintenanceBarrier();
     while (!release && Date.now() < deadline) {
-        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 5);
+        sleepSync(5);
         release = tryAcquireMaintenanceBarrier();
     }
     if (!release)
@@ -107,19 +108,6 @@ function withMaintenanceStartBarrierSyncWait(run) {
         release();
     }
 }
-/** Register a long-lived state operation atomically with other start acquisitions. */
-export async function acquireMaintenanceActivity(name) {
-    return withMaintenanceStartBarrierAsync(async () => {
-        const directory = path.join(path.dirname(getMaintenanceBarrierPath()), "maintenance-activities");
-        fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
-        const lockPath = path.join(directory, `${name}-${process.pid}-${randomUUID()}.lock`);
-        const ownership = tryAcquireLockSync(lockPath, createLockPayload({ purpose: name }));
-        if (!ownership) {
-            throw new ConfigError(`Could not register AKM maintenance activity at ${lockPath}.`, "INVALID_CONFIG_FILE");
-        }
-        return () => releaseLock(ownership);
-    });
-}
 /** Synchronous activity registration for synchronous database handle lifetimes. */
 export function acquireMaintenanceActivitySync(name) {
     return withMaintenanceStartBarrierSyncWait(() => {

package/dist/core/paths.js

@@ -251,9 +251,6 @@ export function getLockfilePath() {
 export function getLockfileLockPath() {
     return path.join(getDataDir(), "akm.lock.lck");
 }
-export function getSemanticStatusPath() {
-    return path.join(getCacheDir(), "semantic-status.json");
-}
 export function getRegistryCacheDir() {
     return path.join(getCacheDir(), "registry");
 }

package/dist/core/redaction.js

@@ -373,11 +373,11 @@ const ERROR_BODY_MAX_LEN = 200;
  * Make an HTTP error body safe to put in an error message: pattern-redact
  * credential shapes, then clip. Provider bodies can echo the credential that
  * was sent and can be megabytes of HTML, and these messages travel — into
- * persisted status files, `--json` output, and agent transcripts.
+ * `--json` output and agent transcripts.
  *
  * Lives here rather than beside one transport because every HTTP client in the
  * codebase needs it; the embeddings transport originally lacked it and leaked
- * raw 10 MB bodies into `semantic-status.json`.
+ * raw 10 MB bodies into error messages.
  */
 export function redactErrorBody(input) {
     if (!input)