nolo-cli 0.38.0-alpha.2 → 0.47.0-alpha.1

package/{chunk-GKHV4UH5.js → chunk-5UOBIU5G.js}

@@ -1,8 +1,14 @@
 import {
   isOpenAiResponsesModel,
   resolvePlatformChatCompletionsEndpoint,
+  resolvePlatformHostedCredentialProvider,
   resolvePlatformResponsesEndpoint
-} from "./chunk-V5GA74HI.js";
+} from "./chunk-MZXZJVVD.js";
+import {
+  CLIENT_VERSION_TOO_OLD_CODE,
+  buildClientVersionGateErrorDetail,
+  evaluatePlatformHostedClientVersionGate
+} from "./chunk-ENYDQKOB.js";
 import {
   asTrimmedLowercaseString
 } from "./chunk-QSJ3HFEF.js";
@@ -89,6 +95,9 @@ function resolveOpenAiCompatibleApiKey(env) {
 function resolvePlatformServerUrl(env) {
   return trimTrailingSlash(env.NOLO_SERVER || env.BASE_URL || "https://nolo.chat");
 }
+function resolveClientVersion(env) {
+  return asOptionalTrimmedString(env.NOLO_CLI_VERSION);
+}
 function resolvePlatformAuthToken(env) {
   return env.AUTH_TOKEN || env.AUTH || env.NOLO_MACHINE_API_KEY || env.BENCHMARK_AUTH_TOKEN || "";
 }
@@ -270,6 +279,21 @@ async function buildProviderExecutionPlan(args) {
     };
   }
   const provider = agentConfig.provider || agentConfig.apiSource || "openai";
+  const localClientVersion = resolveClientVersion(env);
+  const clientVersionGate = evaluatePlatformHostedClientVersionGate({
+    provider,
+    model,
+    clientVersion: localClientVersion,
+    isCustomApi: agentConfig.apiSource === "custom" || Boolean(agentConfig.customProviderUrl?.trim()),
+    hasExplicitCredential: Boolean(agentConfig.apiKey?.trim()) || Boolean(agentConfig.apiKeyRef?.trim())
+  });
+  if (clientVersionGate.blocked) {
+    const gateError = new Error(clientVersionGate.message);
+    gateError.code = CLIENT_VERSION_TOO_OLD_CODE;
+    gateError.detail = buildClientVersionGateErrorDetail(clientVersionGate);
+    throw gateError;
+  }
+  const platformUsageProvider = resolvePlatformHostedCredentialProvider(provider, model);
   const endpoint = transportDecision.transport === "proxy" ? resolvePlatformProviderEndpoint(agentConfig) : resolveChatCompletionsEndpoint(resolveOpenAiCompatibleBaseUrl(env));
   if (transportDecision.transport === "proxy") {
     return {
@@ -282,7 +306,9 @@ async function buildProviderExecutionPlan(args) {
       serverUrl: resolvePlatformServerUrl(env),
       authToken: resolvePlatformAuthToken(env),
       agentKey: agentConfig.key,
-      ...agentConfig.apiSource ? { apiSource: agentConfig.apiSource } : {}
+      ...localClientVersion ? { clientVersion: localClientVersion } : {},
+      ...agentConfig.apiSource ? { apiSource: agentConfig.apiSource } : {},
+      ...platformUsageProvider ? { usageProvider: platformUsageProvider } : {}
       // Platform agents use the server-managed provider credential. Never
       // forward a raw credential from a stale/local agent record through the
       // platform proxy; credentials are resolved by the platform server.
@@ -321,7 +347,8 @@ async function buildProviderExecutionPlan(args) {
     provider: agentConfig.provider || "openai-compatible",
     endpoint,
     requestOptions,
-    apiKey
+    apiKey,
+    ...platformUsageProvider ? { usageProvider: platformUsageProvider } : {}
   };
 }
 
@@ -329,6 +356,7 @@ export {
   pickAgentRuntimeInferenceOptions,
   trimTrailingSlash,
   resolvePlatformServerUrl,
+  resolveClientVersion,
   resolvePlatformAuthToken,
   canUsePlatformChatProvider,
   hasDirectOpenAiCompatibleProvider,

package/{chunk-BMB563Y6.js → chunk-6BYAXNH5.js}

@@ -33,9 +33,9 @@ var STREAM_USAGE_PROVIDERS = /* @__PURE__ */ new Set([
   "deepseek",
   "ollama",
   "ollama-cloud",
-  // OpenAI-compatible /v1/chat/completions endpoint; the hosted branch passes
-  // "upstream-k3" as the usage provider so K3 streams request the terminal usage
-  // chunk (same capability decision as deepinfra/vultr).
+  // endpoint; the hosted branch passes "upstream-k3" as the usage provider so these
+  // streams request the terminal usage chunk (same capability decision as
+  // deepinfra/vultr).
   "upstream-k3",
   // RunInfra hosted fallback channel: OpenAI-compatible chat.completions
   // endpoint, supports stream_options.include_usage (measured to return

package/{chunk-SMPAUSX5.js → chunk-6FGXGFAH.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-ESHYE7WU.js";
 import {
   getDefaultCliLocalRuntimeDb
-} from "./chunk-N4XRDM26.js";
+} from "./chunk-IA3A5373.js";
 import {
   buildCliRuntimeEnv,
   clearProfileAuthToken,
@@ -23,7 +23,7 @@ import {
   createMemoryOwnerIndexKey,
   createMemorySubjectKindIndexKey,
   memoryOwnerRange
-} from "./chunk-2WKUUY2E.js";
+} from "./chunk-SVEUG45B.js";
 import {
   asTrimmedNonEmptyStringArray
 } from "./chunk-I42VC5KR.js";

package/{chunk-6XIE5ZGI.js → chunk-6HIGYUBQ.js}

@@ -1,6 +1,6 @@
 import {
   buildSkillDocMarkdown
-} from "./chunk-AETZ7AD6.js";
+} from "./chunk-EY7V7REW.js";
 
 // packages/cli/docPageHelpers.ts
 import { readFileSync } from "node:fs";

package/{chunk-NT3QRCVS.js → chunk-7US2USK7.js}

@@ -1,32 +1,32 @@
 import {
   addContentToSpace
-} from "./chunk-D72M3G32.js";
+} from "./chunk-FM6ZGNMV.js";
 import {
   prepareAndPersistMessage,
   uiAskChoiceFunc,
   uiAskChoiceFunctionSchema
-} from "./chunk-ARFXKWJH.js";
+} from "./chunk-5PFBRLJN.js";
 import {
   require_date_fns
 } from "./chunk-M76ECQRD.js";
 import {
   TOOL_PACKS
-} from "./chunk-IIOHYLIG.js";
+} from "./chunk-LGUQHYAL.js";
 import {
   buildSkillDocMarkdown
-} from "./chunk-AETZ7AD6.js";
+} from "./chunk-EY7V7REW.js";
 import {
   PLATFORM_HOSTED_DEEPSEEK_FLASH_MODEL,
   PLATFORM_HOSTED_DEEPSEEK_FLASH_PEAK_PRICE,
   PLATFORM_HOSTED_KIMI_PROVIDER
-} from "./chunk-X6EN3KJX.js";
+} from "./chunk-ENYDQKOB.js";
 import {
   read,
   readAndWait,
   removeCachedEntity,
   upsertSSREntity,
   write
-} from "./chunk-23KKIMD5.js";
+} from "./chunk-WVGEBWA6.js";
 import {
   createAgentKey,
   createDialogKey,
@@ -35,7 +35,7 @@ import {
   dialogMessageRange,
   memoryOwnerRange,
   memorySubjectKindRange
-} from "./chunk-2WKUUY2E.js";
+} from "./chunk-SVEUG45B.js";
 import {
   extractCustomId
 } from "./chunk-BJIRLHJR.js";

package/{chunk-FTM4KUOZ.js → chunk-7XTC3KRG.js}

@@ -4,7 +4,7 @@ import {
   openrouterModels,
   platformHostedModels,
   zaiModels
-} from "./chunk-X6EN3KJX.js";
+} from "./chunk-ENYDQKOB.js";
 
 // packages/ai/llm/modelAbility.ts
 var MODEL_ABILITY_TABLE = {

package/{chunk-IMHO5LC6.js → chunk-7XZ5GXSN.js}

@@ -3,7 +3,7 @@ import {
   resolveRunReportJsonPath,
   resolveRunReportPath,
   resolveRunsDir
-} from "./chunk-E2OQ5N2F.js";
+} from "./chunk-AEXP2UZT.js";
 
 // packages/cli/agentRunReport.ts
 import { homedir as nodeHomedir } from "node:os";

package/{chunk-E2OQ5N2F.js → chunk-AEXP2UZT.js}

@@ -35,6 +35,306 @@ function resolveRunRecordPath(runId, env, homedir = nodeHomedir) {
 function resolveRunLogPath(runId, env, homedir = nodeHomedir) {
   return join(resolveRunsDir(env, homedir), `${runId}.log`);
 }
+function resolveRunQueuePath(runId, env, homedir = nodeHomedir) {
+  return join(resolveRunsDir(env, homedir), `${runId}.queue.jsonl`);
+}
+function defaultGenerateQueueEntryId() {
+  const ts = Date.now().toString(36);
+  const rand = Math.random().toString(36).slice(2, 10);
+  return `qmsg-${ts}-${rand}`;
+}
+function _parseQueueLines(content) {
+  if (!content.trim()) return [];
+  const lines = content.split("\n").map((l) => l.trim()).filter(Boolean);
+  const entries = [];
+  for (const line of lines) {
+    try {
+      const item = JSON.parse(line);
+      if (typeof item?.text === "string" && item.text.trim()) {
+        entries.push({
+          id: typeof item.id === "string" && item.id.trim() ? item.id.trim() : defaultGenerateQueueEntryId(),
+          ts: typeof item.ts === "number" ? item.ts : Date.now(),
+          text: item.text.trim()
+        });
+      }
+    } catch {
+      if (line.length > 0) {
+        entries.push({
+          id: defaultGenerateQueueEntryId(),
+          ts: Date.now(),
+          text: line
+        });
+      }
+    }
+  }
+  return entries;
+}
+var parseQueueLines = _parseQueueLines;
+function _serializeQueueEntries(entries) {
+  if (entries.length === 0) return "";
+  return entries.map((e) => JSON.stringify(e)).join("\n") + "\n";
+}
+var serializeQueueEntries = _serializeQueueEntries;
+function _countQueueMessagesLocked(queuePath, fs = nodeFs) {
+  if (!fs.existsSync(queuePath)) return 0;
+  try {
+    const content = fs.readFileSync(queuePath, "utf8");
+    return _parseQueueLines(content).length;
+  } catch {
+    return 0;
+  }
+}
+function _readQueueMessagesLocked(queuePath, fs = nodeFs) {
+  if (!fs.existsSync(queuePath)) return [];
+  try {
+    const content = fs.readFileSync(queuePath, "utf8");
+    return _parseQueueLines(content).map((e) => e.text);
+  } catch {
+    return [];
+  }
+}
+function _readQueueEntriesLocked(queuePath, fs = nodeFs) {
+  if (!fs.existsSync(queuePath)) return [];
+  try {
+    const content = fs.readFileSync(queuePath, "utf8");
+    return _parseQueueLines(content);
+  } catch {
+    return [];
+  }
+}
+function tryUnlinkFile(fs, path) {
+  if (typeof path !== "string" || path.length === 0) return true;
+  try {
+    if (fs.existsSync(path)) {
+      fs.unlinkSync(path);
+    }
+    return true;
+  } catch (error) {
+    const code = error.code;
+    return code === "ENOENT";
+  }
+}
+function tryRmdir(fs, path) {
+  if (typeof path !== "string" || path.length === 0) return true;
+  try {
+    if (typeof fs.rmdirSync === "function") {
+      fs.rmdirSync(path);
+    } else {
+      fs.unlinkSync(path);
+    }
+    return true;
+  } catch (error) {
+    if (error?.code === "ENOENT") return true;
+    return false;
+  }
+}
+var QUEUE_LOCK_STALE_MS = 6e4;
+var QUEUE_LOCK_RETRIES = 20;
+var QUEUE_LOCK_RETRY_INTERVAL_MS = 10;
+function defaultGenerateOwnerTokenId() {
+  const ts = Date.now().toString(36);
+  const rand = Math.random().toString(36).slice(2, 10);
+  return `own-${ts}-${rand}`;
+}
+function normalizeQueueDeps(depsOrFs) {
+  if (!depsOrFs) return {};
+  if ("mkdirSync" in depsOrFs) {
+    return { fs: depsOrFs };
+  }
+  return depsOrFs;
+}
+async function withQueueLock(queuePath, fnOrDeps, depsOrFnOrOpts, maybeOpts) {
+  let fn;
+  let rawDeps;
+  let opts = maybeOpts ?? {};
+  if (typeof fnOrDeps === "function") {
+    fn = fnOrDeps;
+    if (depsOrFnOrOpts && typeof depsOrFnOrOpts === "object" && !("mkdirSync" in depsOrFnOrOpts) && !("fs" in depsOrFnOrOpts) && !("env" in depsOrFnOrOpts)) {
+      opts = { ...depsOrFnOrOpts, ...maybeOpts };
+      rawDeps = void 0;
+    } else {
+      rawDeps = depsOrFnOrOpts;
+    }
+  } else {
+    rawDeps = fnOrDeps;
+    fn = depsOrFnOrOpts;
+  }
+  const deps = normalizeQueueDeps(rawDeps);
+  const fs = deps.fs ?? nodeFs;
+  const now = deps.now ?? (() => /* @__PURE__ */ new Date());
+  const staleLockMs = opts.staleLockMs ?? QUEUE_LOCK_STALE_MS;
+  const retries = opts.retries ?? QUEUE_LOCK_RETRIES;
+  const retryIntervalMs = opts.retryIntervalMs ?? QUEUE_LOCK_RETRY_INTERVAL_MS;
+  const lockPath = `${queuePath}.lock`;
+  const tokenPath = join(lockPath, "owner.json");
+  try {
+    fs.mkdirSync(dirname(lockPath), { recursive: true });
+  } catch {
+  }
+  const myOwnerId = defaultGenerateOwnerTokenId();
+  let held = false;
+  const tryAcquire = () => {
+    let created = false;
+    try {
+      fs.mkdirSync(lockPath);
+      created = true;
+    } catch {
+      try {
+        if (typeof fs.statSync === "function") {
+          const stat = fs.statSync(lockPath);
+          const ageMs = stat ? now().getTime() - stat.mtimeMs : 0;
+          if (ageMs > staleLockMs) {
+            try {
+              tryUnlinkFile(fs, tokenPath);
+              tryRmdir(fs, lockPath);
+            } catch {
+            }
+            try {
+              fs.mkdirSync(lockPath);
+              created = true;
+            } catch {
+            }
+          }
+        }
+      } catch {
+      }
+    }
+    if (created) {
+      try {
+        const token = {
+          ownerId: myOwnerId,
+          pid: process.pid,
+          createdAt: now().toISOString(),
+          createdAtMs: now().getTime()
+        };
+        fs.writeFileSync(tokenPath, JSON.stringify(token), "utf8");
+        return true;
+      } catch (writeTokenErr) {
+        tryRmdir(fs, lockPath);
+        throw writeTokenErr;
+      }
+    }
+    return false;
+  };
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    if (tryAcquire()) {
+      held = true;
+      break;
+    }
+    if (attempt < retries && retryIntervalMs > 0) {
+      await new Promise((resolve2) => setTimeout(resolve2, retryIntervalMs));
+    }
+  }
+  if (!held) {
+    throw new Error(`queue busy: ${queuePath}`);
+  }
+  try {
+    return await fn();
+  } finally {
+    if (held) {
+      try {
+        let currentOwnerId;
+        if (fs.existsSync(tokenPath)) {
+          try {
+            const raw = fs.readFileSync(tokenPath, "utf8");
+            const parsed = JSON.parse(raw);
+            currentOwnerId = parsed?.ownerId;
+          } catch {
+            currentOwnerId = void 0;
+          }
+        }
+        if (currentOwnerId === myOwnerId) {
+          tryUnlinkFile(fs, tokenPath);
+          tryRmdir(fs, lockPath);
+        } else {
+          console.error(
+            `[nolo] Warning: queue lock for ${queuePath} was taken over by another process (owner mismatch: expected ${myOwnerId}, found ${currentOwnerId ?? "none"}). Will not release.`
+          );
+        }
+      } catch (releaseErr) {
+        console.error(`[nolo] Warning: failed to release queue lock for ${queuePath}:`, releaseErr);
+      }
+    }
+  }
+}
+async function appendRunQueue(queuePath, input, depsOrFs = {}) {
+  const deps = normalizeQueueDeps(depsOrFs);
+  const fs = deps.fs ?? nodeFs;
+  const now = deps.now ?? (() => /* @__PURE__ */ new Date());
+  const text = typeof input === "string" ? input : input.text;
+  const entryId = typeof input === "object" && typeof input.id === "string" && input.id.trim() ? input.id.trim() : defaultGenerateQueueEntryId();
+  const entry = { id: entryId, ts: now().getTime(), text };
+  const line = JSON.stringify(entry) + "\n";
+  return await withQueueLock(queuePath, deps, async () => {
+    if (typeof fs.appendFileSync === "function") {
+      fs.appendFileSync(queuePath, line, "utf8");
+    } else {
+      const existing = fs.existsSync(queuePath) ? fs.readFileSync(queuePath, "utf8") : "";
+      fs.writeFileSync(queuePath, existing + line, "utf8");
+    }
+    const currentContent = fs.existsSync(queuePath) ? fs.readFileSync(queuePath, "utf8") : line;
+    return { queuedCount: _parseQueueLines(currentContent).length, entryId };
+  });
+}
+async function countQueueMessages(queuePath, depsOrFs = {}) {
+  const deps = normalizeQueueDeps(depsOrFs);
+  const fs = deps.fs ?? nodeFs;
+  if (!fs.existsSync(queuePath)) return 0;
+  return await withQueueLock(queuePath, deps, async () => {
+    return _countQueueMessagesLocked(queuePath, fs);
+  });
+}
+async function readQueueMessages(queuePath, depsOrFs = {}) {
+  const deps = normalizeQueueDeps(depsOrFs);
+  const fs = deps.fs ?? nodeFs;
+  if (!fs.existsSync(queuePath)) return [];
+  return await withQueueLock(queuePath, deps, async () => {
+    return _readQueueMessagesLocked(queuePath, fs);
+  });
+}
+async function readQueueEntries(queuePath, depsOrFs = {}) {
+  const deps = normalizeQueueDeps(depsOrFs);
+  const fs = deps.fs ?? nodeFs;
+  if (!fs.existsSync(queuePath)) return [];
+  return await withQueueLock(queuePath, deps, async () => {
+    return _readQueueEntriesLocked(queuePath, fs);
+  });
+}
+async function popAllQueueEntries(queuePath, depsOrFs = {}) {
+  const deps = normalizeQueueDeps(depsOrFs);
+  const fs = deps.fs ?? nodeFs;
+  return await withQueueLock(queuePath, deps, async () => {
+    if (!fs.existsSync(queuePath)) return [];
+    const content = fs.readFileSync(queuePath, "utf8");
+    const entries = _parseQueueLines(content);
+    tryUnlinkFile(fs, queuePath);
+    return entries;
+  });
+}
+async function popSingleQueueMessage(queuePath, depsOrFs = {}) {
+  const deps = normalizeQueueDeps(depsOrFs);
+  const fs = deps.fs ?? nodeFs;
+  return await withQueueLock(queuePath, deps, async () => {
+    if (!fs.existsSync(queuePath)) return null;
+    const content = fs.readFileSync(queuePath, "utf8");
+    const entries = _parseQueueLines(content);
+    if (entries.length === 0) {
+      tryUnlinkFile(fs, queuePath);
+      return null;
+    }
+    const [first, ...rest] = entries;
+    if (rest.length === 0) {
+      tryUnlinkFile(fs, queuePath);
+    } else {
+      fs.writeFileSync(queuePath, _serializeQueueEntries(rest), "utf8");
+    }
+    return first;
+  });
+}
+async function popQueueMessages(queuePath, depsOrFs = {}) {
+  const entries = await popAllQueueEntries(queuePath, depsOrFs);
+  return entries.map((e) => e.text);
+}
 function resolveRunReportPath(runId, env, homedir = nodeHomedir) {
   return join(resolveRunsDir(env, homedir), `${runId}.report.md`);
 }
@@ -269,19 +569,7 @@ function queryRunRecords(query, deps = {}) {
   return { runs: sliced, total, hasMore };
 }
 var DEFAULT_GC_RETENTION_MS = 7 * 24 * 60 * 60 * 1e3;
-function tryUnlinkFile(fs, path) {
-  if (typeof path !== "string" || path.length === 0) return true;
-  try {
-    if (fs.existsSync(path)) {
-      fs.unlinkSync(path);
-    }
-    return true;
-  } catch (error) {
-    const code = error.code;
-    return code === "ENOENT";
-  }
-}
-function gcRunRecords(deps = {}, options = {}) {
+async function gcRunRecords(deps = {}, options = {}) {
   const fs = deps.fs ?? nodeFs;
   const now = (deps.now ?? (() => /* @__PURE__ */ new Date()))();
   const nowMs = now instanceof Date ? now.getTime() : Date.parse(String(now));
@@ -296,14 +584,25 @@ function gcRunRecords(deps = {}, options = {}) {
     if (!Number.isFinite(ageMs) || ageMs < retentionMs) continue;
     const jsonPath = resolveRunRecordPath(record.runId, deps.env, deps.homedir);
     const logPath = resolveRunLogPath(record.runId, deps.env, deps.homedir);
+    const queuePath = record.queuePath ?? resolveRunQueuePath(record.runId, deps.env, deps.homedir);
     const reportPath = resolveRunReportPath(record.runId, deps.env, deps.homedir);
     const reportJsonPath = resolveRunReportJsonPath(record.runId, deps.env, deps.homedir);
     const msgPath = record.msgFile ?? join(resolveRunsDir(deps.env, deps.homedir), `${record.runId}.msg.md`);
     const logOk = tryUnlinkFile(fs, logPath);
     const msgOk = tryUnlinkFile(fs, msgPath);
+    let queueOk = true;
+    if (fs.existsSync(queuePath)) {
+      try {
+        await withQueueLock(queuePath, deps, () => {
+          tryUnlinkFile(fs, queuePath);
+        });
+      } catch {
+        queueOk = false;
+      }
+    }
     tryUnlinkFile(fs, reportPath);
     tryUnlinkFile(fs, reportJsonPath);
-    if (!logOk || !msgOk) {
+    if (!logOk || !msgOk || !queueOk) {
       failedIds.push(record.runId);
       continue;
     }
@@ -430,6 +729,7 @@ async function spawnLocalBackgroundRun(input, deps = {}) {
   const runId = generateRunId();
   const batchId = input.batchId ?? (deps.generateBatchId ?? defaultGenerateBatchId)();
   const logPath = resolveRunLogPath(runId, env, homedir);
+  const queuePath = resolveRunQueuePath(runId, env, homedir);
   const recordPath = resolveRunRecordPath(runId, env, homedir);
   const runsDir = resolveRunsDir(env, homedir);
   fs.mkdirSync(runsDir, { recursive: true });
@@ -473,15 +773,19 @@ async function spawnLocalBackgroundRun(input, deps = {}) {
     ...typeof input.timeoutMs === "number" ? { timeoutMs: input.timeoutMs } : {},
     status: "running",
     logPath,
+    queuePath,
     batchId,
     ...typeof input.parentDialogId === "string" && input.parentDialogId.trim() ? { parentDialogId: input.parentDialogId.trim() } : {},
     ...dodCommands && dodCommands.length > 0 ? { dodCommands } : {},
     ...spawnHead ? { spawnHead } : {}
   };
   fs.writeFileSync(recordPath, JSON.stringify(record, null, 2));
+  const rawArgsWithQueue = (input.rawArgs ?? []).some(
+    (arg) => arg === "--queue-file" || arg.startsWith("--queue-file=")
+  ) ? input.rawArgs : [...input.rawArgs ?? [], "--queue-file", queuePath];
   const { execPath, childArgs } = buildAgentRunChildCommand(
     {
-      rawArgs: input.rawArgs,
+      rawArgs: rawArgsWithQueue,
       commandPath: input.commandPath,
       cliEntrypointPath: input.cliEntrypointPath,
       messagePath
@@ -507,7 +811,7 @@ async function spawnLocalBackgroundRun(input, deps = {}) {
     if (processStartedAt) record.processStartedAt = processStartedAt.toISOString();
     writeRunRecord(record, deps);
   }
-  return { runId, pid: proc.pid, logPath, batchId };
+  return { runId, pid: proc.pid, logPath, queuePath, batchId };
 }
 function ackRunRecord(runId, deps = {}) {
   withRunRecordLock(runId, deps, () => {
@@ -1053,6 +1357,27 @@ export {
   resolveRunsDir,
   resolveRunRecordPath,
   resolveRunLogPath,
+  resolveRunQueuePath,
+  defaultGenerateQueueEntryId,
+  _parseQueueLines,
+  parseQueueLines,
+  _serializeQueueEntries,
+  serializeQueueEntries,
+  _countQueueMessagesLocked,
+  _readQueueMessagesLocked,
+  _readQueueEntriesLocked,
+  QUEUE_LOCK_STALE_MS,
+  QUEUE_LOCK_RETRIES,
+  QUEUE_LOCK_RETRY_INTERVAL_MS,
+  defaultGenerateOwnerTokenId,
+  withQueueLock,
+  appendRunQueue,
+  countQueueMessages,
+  readQueueMessages,
+  readQueueEntries,
+  popAllQueueEntries,
+  popSingleQueueMessage,
+  popQueueMessages,
   resolveRunReportPath,
   resolveRunReportJsonPath,
   defaultGenerateRunId,