akm-cli 0.9.4 → 0.9.6

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/improve-result.js

@@ -456,20 +456,24 @@ function validateCommon(value) {
         }
     }
 }
-/** Decode the persisted public result contract. */
-export function decodeImproveResult(input) {
-    let parsed = input;
-    if (typeof input === "string") {
-        try {
-            parsed = JSON.parse(input);
-        }
-        catch {
-            fail("not valid JSON");
-        }
-    }
-    if (!isRecord(parsed))
-        fail("root must be an object");
-    if (parsed.schemaVersion === 2) {
+/**
+ * Per-`schemaVersion` decoders for the persisted `improve_runs.result_json`
+ * contract, keyed by the literal `schemaVersion` value each accepts.
+ *
+ * #866 item 5 / read-shim policy (same shape as the version router in
+ * src/tasks/source/parse-task-source.ts, which this mirrors): every
+ * `schemaVersion` this build understands gets its own entry here, so
+ * decoding never regresses to "reject every row" the day the version bumps
+ * — it only stops accepting the ONE version that changed shape. All 1,539
+ * live rows today are v2; when a v3 shape is introduced, add a `3` entry
+ * (and, if v2 rows must keep reading under the newer runtime, keep this `2`
+ * entry as-is — every caller already skip-and-counts a decode failure, so a
+ * genuinely unreadable old row degrades to "excluded from metrics", never a
+ * crash). Do not remove the `2` entry when adding `3` unless the schema
+ * bump is known to be a strict superset callers can validate with it.
+ */
+const SCHEMA_DECODERS = {
+    2: (parsed) => {
         requireExactFields(parsed, V2_FIELDS);
         validateCommon(parsed);
         if (typeof parsed.strategy !== "string" || parsed.strategy.length === 0) {
@@ -482,6 +486,23 @@ export function decodeImproveResult(input) {
             envelope: parsed,
             strategy: parsed.strategy,
         };
+    },
+};
+/** Decode the persisted public result contract. */
+export function decodeImproveResult(input) {
+    let parsed = input;
+    if (typeof input === "string") {
+        try {
+            parsed = JSON.parse(input);
+        }
+        catch {
+            fail("not valid JSON");
+        }
     }
+    if (!isRecord(parsed))
+        fail("root must be an object");
+    const decoder = typeof parsed.schemaVersion === "number" ? SCHEMA_DECODERS[parsed.schemaVersion] : undefined;
+    if (decoder)
+        return decoder(parsed);
     fail(`unsupported schemaVersion: ${String(parsed.schemaVersion)}`);
 }

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)

package/dist/core/spawn-env.js

@@ -4,19 +4,15 @@
 /**
  * The ONE allowlist-based child-environment primitive.
  *
- * Two akm code paths spawn a child from an explicit list of environment
+ * Three akm code paths spawn a child from an explicit list of environment
  * variable NAMES — the agent-CLI spawn wrapper
- * (`integrations/agent/spawn.ts`, `profile.envPassthrough`) and the workflow
- * `exec` unit runner (`workflows/exec/exec-unit.ts`) — and both start from an
- * EMPTY environment and copy through named entries with
- * {@link collectAllowlistedEnv}. Keeping that in one leaf module is what makes
- * "allowlist" a single reviewable mechanism instead of two implementations
- * that drift apart.
- *
- * NOT covered: the opencode-sdk server spawn
- * (`integrations/harnesses/opencode-sdk/sdk-runner.ts`) keeps its own
- * hard-coded name list and does not route through here, so it gets neither the
- * platform floor below nor PATH supplementation.
+ * (`integrations/agent/spawn.ts`, `profile.envPassthrough`), the workflow
+ * `exec` unit runner (`workflows/exec/exec-unit.ts`), and the opencode-sdk
+ * server spawn (`integrations/harnesses/opencode-sdk/sdk-runner.ts`) — and
+ * all build their allowlist from {@link COMMON_SPAWN_ENV_PASSTHROUGH} /
+ * {@link spawnEnvNamesFor}. Keeping that in one leaf module is what makes
+ * "allowlist" a single reviewable mechanism instead of independent
+ * implementations that drift apart.
  *
  * A LEAF: node built-ins only, so both the integrations layer and the workflow
  * engine can import it without opening a cycle.

package/dist/core/state/migrations.js

@@ -1132,22 +1132,11 @@ export function runMigrations(db, options) {
     runSqliteMigrations(db, STATE_MIGRATIONS, {
         lockInitialMigrationPrefixThrough: options?.existingUnversionedDatabase ? "002-task-history-per-run" : undefined,
         beforeLedgerInitializationLocked(lockedDb) {
-            if (options?.freshDatabase) {
-                if (!options.verifyFreshDatabaseOwnership) {
-                    throw new Error("A fresh state.db migration requires verified file ownership.");
-                }
-                options.verifyFreshDatabaseOwnership();
+            if (options?.freshDatabase)
                 return;
-            }
             prepareExistingUnversionedState(lockedDb);
         },
         beforeMigrationLocked(migration, lockedDb) {
-            if (options?.freshDatabase) {
-                if (!options.verifyFreshDatabaseOwnership) {
-                    throw new Error("A fresh state.db migration requires verified file ownership.");
-                }
-                options.verifyFreshDatabaseOwnership();
-            }
             if (options?.existingUnversionedDatabase && !existingUnversionedSnapshotPrepared) {
                 prepareExistingUnversionedState(lockedDb);
             }

package/dist/core/state-db.js

@@ -65,6 +65,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 { assertMigrationLedger } from "../storage/engines/sqlite-migrations.js";
 import { openManagedDatabase, withManagedDb } from "../storage/managed-db.js";
@@ -189,20 +190,18 @@ function reserveFreshStateDatabase(dbPath) {
         throw error;
     }
     try {
-        const reservation = {
+        return {
             path: dbPath,
             fd,
             identity: fs.fstatSync(fd, { bigint: true }),
         };
-        assertOwnedFileReservation(reservation, "Fresh state.db");
-        return reservation;
     }
     catch (error) {
         try {
             fs.closeSync(fd);
         }
         catch {
-            // Preserve the ownership failure.
+            // Preserve the fstat failure.
         }
         throw error;
     }
@@ -217,20 +216,18 @@ function openExistingStateDatabaseSource(dbPath) {
         throw new Error(`Could not bind the existing state.db source inode: ${detail}`);
     }
     try {
-        const source = {
+        return {
             path: dbPath,
             fd,
             identity: fs.fstatSync(fd, { bigint: true }),
         };
-        assertStateDatabaseSource(source);
-        return source;
     }
     catch (error) {
         try {
             fs.closeSync(fd);
         }
         catch {
-            // Preserve the source identity failure.
+            // Preserve the fstat failure.
         }
         throw error;
     }
@@ -386,10 +383,7 @@ export function openStateDatabase(dbPath, options) {
         return openManagedDatabase({
             path: resolvedPath,
             pragmas: { dataDir: path.dirname(resolvedPath) },
-            init: (db) => runMigrations(db, {
-                freshDatabase: true,
-                verifyFreshDatabaseOwnership: () => { },
-            }),
+            init: (db) => runMigrations(db, { freshDatabase: true }),
         });
     }
     const isCanonical = path.resolve(resolvedPath) === path.resolve(canonicalPath);
@@ -404,12 +398,10 @@ export function openStateDatabase(dbPath, options) {
         freshReservation = reserveFreshStateDatabase(resolvedPath);
         if (!freshReservation) {
             existingSource = openExistingStateDatabaseSource(resolvedPath);
-            assertStateDatabaseSource(existingSource);
             const preflight = openDatabase(sqliteBoundFilePath(existingSource), {
                 readonly: true,
             });
             try {
-                assertStateDatabaseSource(existingSource);
                 preflight.exec("PRAGMA busy_timeout = 30000");
                 const ledger = assertMigrationLedger(preflight, STATE_MIGRATIONS);
                 existingUnversionedDatabase = ledger.migrationIds.length === 0;
@@ -422,21 +414,13 @@ export function openStateDatabase(dbPath, options) {
                 preflight.close();
             }
         }
-        const ownedFresh = freshReservation;
         const boundSource = existingSource;
-        if (boundSource)
-            assertStateDatabaseSource(boundSource);
         openedDb = openManagedDatabase({
             path: boundSource ? sqliteBoundFilePath(boundSource) : resolvedPath,
             pragmas: { dataDir: path.dirname(resolvedPath) },
             init: (db) => {
-                if (boundSource)
-                    assertStateDatabaseSource(boundSource);
                 runMigrations(db, {
-                    freshDatabase: !!ownedFresh,
-                    verifyFreshDatabaseOwnership: ownedFresh
-                        ? () => assertOwnedFileReservation(ownedFresh, "Fresh state.db")
-                        : undefined,
+                    freshDatabase: !!freshReservation,
                     existingUnversionedDatabase,
                     allowHistoricalDestructiveStateUpgrade: options?.allowHistoricalDestructiveStateUpgrade,
                     beforeExistingUnversionedStateMigration: options?.allowHistoricalDestructiveStateUpgrade
@@ -463,12 +447,10 @@ export function openStateDatabase(dbPath, options) {
             },
         });
         if (existingSource) {
-            assertStateDatabaseSource(existingSource);
             closeFileIdentity(existingSource);
             existingSource = undefined;
         }
         if (freshReservation) {
-            assertOwnedFileReservation(freshReservation, "Fresh state.db");
             closeFileIdentity(freshReservation);
             freshReservation = undefined;
         }
@@ -610,11 +592,11 @@ function isRetryableBeginError(err) {
         msg.includes("did not open a transaction"));
 }
 const WITH_IMMEDIATE_TX_MAX_ATTEMPTS = 5;
-/** Portable synchronous sleep (works under both Bun and Node). */
+/** Portable synchronous sleep (works under both Bun and Node). Delegates to the runtime boundary's `sleepSync`. */
 function sleepSyncMs(ms) {
     if (ms <= 0)
         return;
-    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+    sleepSync(ms);
 }
 /**
  * Open, but deliberately do not finish, an immediate transaction.

package/dist/core/write-source.js

@@ -34,7 +34,7 @@ import { assetPathForName, stashDirFor } from "./asset/asset-placement.js";
 import { conceptIdFromTypeName, displayRef } from "./asset/resolve-ref.js";
 import { deriveBundleId } from "./bundle-id.js";
 import { existingFileMode, isWithin, resolveStashDir, writeFileAtomic } from "./common.js";
-import { resolveConfiguredSources } from "./config/config.js";
+import { bundleContentRoot, resolveConfiguredSources } from "./config/config.js";
 import { ConfigError, UsageError } from "./errors.js";
 import { sanitizeCommitMessage } from "./git-message.js";
 import { warn } from "./warn.js";
@@ -111,7 +111,15 @@ export function planWriteTargetPublication(target, filePaths, options) {
     }
     const unignoredPaths = paths.filter((_, index) => !ignored.has(relativePaths[index]));
     assertWriteTargetPathsClean(target.source, unignoredPaths);
-    assertWriteTargetPlanBase(target, expectedBaseHead);
+    // Not re-verified against `expectedBaseHead` here: any drift during the
+    // ignored/clean-path checks above is caught by the SAME expectedBaseHead
+    // comparison `beginWriteTargetMutation` runs immediately before the first
+    // mutation (its documented contract, and every real caller calls it right
+    // after this function returns) -- checking it again here a few lines
+    // earlier for the exact same value only duplicated that check, not added
+    // a new one. `publishWriteTargetPlan` independently re-checks a third time
+    // after the actual mutation, which is a genuinely different point in time
+    // and stays.
     return { target, paths, publish: ignored.size === 0, expectedBaseHead };
 }
 function assertNoWritePathDescendantSymlinks(source, filePaths) {
@@ -538,7 +546,6 @@ function captureGitPathState(repoPath, absolutePath, relativePath) {
 }
 /** Create or recover the one transaction-owned commit without pushing it. */
 export function ensureGitTransactionCommit(target, publication, options) {
-    assertGitPublicationIdentity(target, publication);
     const paths = normalizePublicationPaths(options.paths);
     validateGitWorktreeSnapshots(target, paths, options.snapshots);
     if (publication.commit !== undefined) {
@@ -626,7 +633,6 @@ export function publishWriteTargetTransaction(target, publication, options) {
 }
 /** Push only the recorded transaction commit, never later local descendants. */
 export function publishGitTransactionCommit(target, publication, transactionId, paths, snapshots) {
-    assertGitPublicationIdentity(target, publication);
     if (publication.commit === undefined) {
         throw new Error(`Git transaction ${transactionId} has no recorded publication decision.`);
     }
@@ -703,20 +709,6 @@ function readGitPublicationIdentity(target) {
         upstream: upstreamResult.stdout.trim(),
     };
 }
-function assertGitPublicationIdentity(target, publication) {
-    if (target.source.kind !== "git") {
-        throw new Error(`Git publication is bound to non-Git target "${target.source.name}".`);
-    }
-    const current = readGitPublicationIdentity(target);
-    for (const key of ["repoPath", "branch", "remote", "mergeRef", "remoteUrl", "upstream"]) {
-        if (current[key] !== publication[key]) {
-            throw new Error(`Git publication target identity changed at ${key} for "${target.source.name}".`);
-        }
-    }
-    if (JSON.stringify(current.pushUrls ?? []) !== JSON.stringify(publication.pushUrls ?? [])) {
-        throw new Error(`Git publication target identity changed at pushUrls for "${target.source.name}".`);
-    }
-}
 function normalizePublicationPaths(paths) {
     const normalized = new Set();
     for (const filePath of paths) {
@@ -951,9 +943,10 @@ export function resolveWorkingStashTarget(akmConfig, options = {}) {
     const requireWritable = options.requireWritable !== false;
     if (process.env.AKM_BUNDLE_DIR?.trim()) {
         const stashDir = resolveStashDir();
+        const resolvedStashDir = path.resolve(stashDir);
         const configured = configuredSources.find((source) => {
             const sourcePath = source.source.type === "filesystem" ? source.source.path : undefined;
-            return sourcePath !== undefined && path.resolve(sourcePath) === path.resolve(stashDir);
+            return sourcePath !== undefined && bundleContentRoot(sourcePath, source.componentRoot) === resolvedStashDir;
         });
         if (configured) {
             const target = adaptConfiguredSource(configured);

package/dist/execution/directory-identity.js

@@ -27,19 +27,48 @@ export function captureFrozenDirectoryIdentity(rootInput, relativeCwd) {
         cwdInode: cwdStat.ino.toString(),
     });
 }
-export function assertFrozenDirectoryIdentity(identity) {
-    let actual;
+/**
+ * Re-verify, immediately before spawn, that a frozen cwd still resolves
+ * inside its execution root — path containment and resolved-path identity,
+ * NOT device/inode identity. Unlike the removed assertFrozenDirectoryIdentity,
+ * this does not compare device/inode numbers against the frozen snapshot: a
+ * remount, an rsync, or a container rebuild that leaves the same real
+ * content at the same real PATH must not abort a dispatch. What still
+ * throws is anything that changes the resolved real PATH itself — a
+ * symlink swap, an ancestor swap, a file replacing the directory, or the
+ * root itself being replaced by a symlink elsewhere (root-vs-cwd
+ * containment alone can't catch that last one, since both resolve together
+ * under the new root; comparing the root's own resolved path to its frozen
+ * value catches it).
+ */
+export function assertFrozenDirectoryContained(identity) {
+    let realRoot;
+    let realCwd;
     try {
-        const relative = path.relative(identity.requestedRoot, identity.requestedCwd);
-        actual = captureFrozenDirectoryIdentity(identity.requestedRoot, relative);
+        realRoot = fs.realpathSync(identity.requestedRoot);
+        realCwd = fs.realpathSync(identity.requestedCwd);
     }
     catch {
         throw changed(identity.requestedCwd);
     }
-    for (const key of ["realRoot", "rootDevice", "rootInode", "realCwd", "cwdDevice", "cwdInode"]) {
-        if (actual[key] !== identity[key])
-            throw changed(identity.requestedCwd);
+    if (realRoot !== identity.realRoot)
+        throw changed(identity.requestedCwd);
+    const relative = path.relative(realRoot, realCwd);
+    if (relative.startsWith("..") || path.isAbsolute(relative)) {
+        throw changed(identity.requestedCwd);
     }
+    let cwdStat;
+    try {
+        cwdStat = fs.statSync(realCwd, { bigint: true });
+    }
+    catch {
+        throw changed(identity.requestedCwd);
+    }
+    if (!cwdStat.isDirectory())
+        throw changed(identity.requestedCwd);
+}
+function changed(cwd) {
+    return new UsageError(`Frozen execution cwd ${cwd} changed and no longer resolves inside its root.`, "PATH_ESCAPE_VIOLATION");
 }
 function requireContained(root, candidate) {
     const relative = path.relative(root, candidate);
@@ -47,6 +76,3 @@ function requireContained(root, candidate) {
         throw new UsageError(`${candidate} escapes its execution root.`, "PATH_ESCAPE_VIOLATION");
     }
 }
-function changed(cwd) {
-    return new UsageError(`Frozen execution cwd ${cwd} changed after publication.`, "RESOURCE_ALREADY_EXISTS");
-}

package/dist/execution/guarded-source.js

@@ -7,7 +7,6 @@ import path from "node:path";
 import { parseFrontmatter } from "../core/asset/frontmatter.js";
 import { UsageError } from "../core/errors.js";
 import { createExecutionSourceIdentity } from "./source.js";
-export const DEFAULT_GUARDED_SOURCE_MAX_BYTES = 1024 * 1024;
 function errorMessage(cause) {
     return cause instanceof Error ? cause.message : String(cause);
 }
@@ -71,10 +70,6 @@ function captureRecord(sourcePathInput, containmentRootInput, options = {}) {
     const sourcePath = path.resolve(sourcePathInput);
     const { containmentRoot, containmentRealPath, containmentStat } = requireContainmentRoot(containmentRootInput);
     const lexicalRelative = containedRelative(containmentRoot, sourcePath, false);
-    const maxBytes = options.maxBytes ?? DEFAULT_GUARDED_SOURCE_MAX_BYTES;
-    if (!Number.isSafeInteger(maxBytes) || maxBytes < 0) {
-        throw new UsageError("Guarded source byte limit must be a non-negative safe integer.", "INVALID_FLAG_VALUE");
-    }
     const noFollow = typeof fs.constants.O_NOFOLLOW === "number" ? fs.constants.O_NOFOLLOW : 0;
     let descriptor;
     try {
@@ -83,9 +78,6 @@ function captureRecord(sourcePathInput, containmentRootInput, options = {}) {
         if (!before.isFile()) {
             throw new UsageError(`${sourcePath} is not a regular guarded source file.`, "INVALID_FLAG_VALUE");
         }
-        if (before.size > BigInt(maxBytes)) {
-            throw new UsageError(`${sourcePath} exceeds the guarded source size limit (1 MiB; ${maxBytes} bytes).`, "INVALID_FLAG_VALUE");
-        }
         const bytes = fs.readFileSync(descriptor);
         const after = fs.fstatSync(descriptor, { bigint: true });
         if (!sameBigIntStat(before, after) || BigInt(bytes.byteLength) !== before.size) {
@@ -127,7 +119,6 @@ function captureRecord(sourcePathInput, containmentRootInput, options = {}) {
                 ...(options.identity ? { identity: options.identity } : {}),
             }),
             stat: numberStat(before),
-            maxBytes,
         };
     }
     catch (cause) {
@@ -402,7 +393,6 @@ export class GuardedExecutionSourceCollector {
             try {
                 current = captureRecord(record.source.sourcePath, record.source.containmentRoot, {
                     authored: record.source.authored,
-                    maxBytes: record.maxBytes,
                     ...(record.source.identity ? { identity: record.source.identity } : {}),
                 }).source;
             }

package/dist/indexer/graph/graph-boost.js

@@ -68,11 +68,7 @@ function combineConfidence(...parts) {
     return out;
 }
 function toConfidenceMultiplier(rawConfidence, weights) {
-    if (weights.confidenceMode === "off")
-        return 1;
     const confidence = normalizeConfidence(rawConfidence) ?? 1;
-    if (weights.confidenceMode === "multiply")
-        return confidence;
     const blendWeight = Math.max(0, Math.min(1, weights.confidenceWeight));
     return 1 - blendWeight + blendWeight * confidence;
 }