nolo-cli 0.8.0-alpha.2 → 0.8.0-alpha.21

package/chunk-4CQLVGRV.js

@@ -0,0 +1,50 @@
+import {
+  asOptionalTrimmedString
+} from "./chunk-G3SUCT4W.js";
+import {
+  isRecord
+} from "./chunk-KUG52IAP.js";
+
+// packages/cli/cliSpaceHelpers.ts
+function normalizeSpaceIdInput(rawInput) {
+  const raw = rawInput.trim();
+  if (!raw) return "";
+  let candidate = raw;
+  if (raw.startsWith("http://") || raw.startsWith("https://")) {
+    const match = new URL(raw).pathname.match(/^\/space\/([^/?#]+)/);
+    if (!match?.[1]) return "";
+    candidate = decodeURIComponent(match[1]);
+  }
+  return candidate.startsWith("space-") ? candidate.slice("space-".length) : candidate;
+}
+function buildSpaceLookup(rawInput) {
+  const spaceId = normalizeSpaceIdInput(rawInput);
+  return {
+    spaceId,
+    spaceKey: spaceId ? `space-${spaceId}` : ""
+  };
+}
+function getSpaceContentKeys(spaceRecord) {
+  const keys = /* @__PURE__ */ new Set();
+  const contents = spaceRecord?.contents;
+  if (!contents || typeof contents !== "object") return keys;
+  for (const [entryKey, value] of Object.entries(contents)) {
+    const trimmedEntryKey = asOptionalTrimmedString(entryKey);
+    if (trimmedEntryKey) {
+      keys.add(trimmedEntryKey);
+    }
+    if (isRecord(value)) {
+      const contentKey = asOptionalTrimmedString(value.contentKey);
+      if (contentKey) {
+        keys.add(contentKey);
+      }
+    }
+  }
+  return keys;
+}
+
+export {
+  normalizeSpaceIdInput,
+  buildSpaceLookup,
+  getSpaceContentKeys
+};

package/chunk-4IJYA27C.js

@@ -0,0 +1,342 @@
+import {
+  generatePkcePair,
+  startCallbackServer
+} from "./chunk-EHLHSX7R.js";
+import {
+  toErrorMessage
+} from "./chunk-HNMXYYJR.js";
+import {
+  asOptionalFiniteNumber
+} from "./chunk-WWC7I6TA.js";
+
+// packages/cli/oauth/flows/cloudflare.ts
+var CLOUDFLARE_OAUTH_AUTH_ENDPOINT = "https://dash.cloudflare.com/oauth2/auth";
+var CLOUDFLARE_OAUTH_TOKEN_ENDPOINT = "https://dash.cloudflare.com/oauth2/token";
+var CLOUDFLARE_API_BASE = "https://api.cloudflare.com/client/v4";
+var CLOUDFLARE_OAUTH_REDIRECT_HOST = "127.0.0.1";
+var CLOUDFLARE_OAUTH_REDIRECT_PORT = 56122;
+var CLOUDFLARE_OAUTH_REDIRECT_PATH = "/callback";
+var ACCESS_TOKEN_CLIENT_SKEW_MS = 5 * 60 * 1e3;
+var TOKEN_REQUEST_TIMEOUT_MS = 2e4;
+var DEFAULT_SCOPE = "account:read zone:read zone:edit user:read user:edit";
+function generateState() {
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes).map((value) => value.toString(16).padStart(2, "0")).join("");
+}
+function getClientId(args) {
+  const value = args?.clientId?.trim() || process.env.CLOUDFLARE_OAUTH_CLIENT_ID?.trim();
+  if (!value) {
+    throw new Error(
+      "Cloudflare OAuth client ID is required. Set CLOUDFLARE_OAUTH_CLIENT_ID or pass --client-id."
+    );
+  }
+  return value;
+}
+function getScope(args) {
+  return args?.scope?.trim() || process.env.CLOUDFLARE_OAUTH_SCOPE?.trim() || DEFAULT_SCOPE;
+}
+function buildCloudflareAuthorizeUrl(opts) {
+  const params = new URLSearchParams({
+    response_type: "code",
+    client_id: opts.clientId,
+    redirect_uri: opts.redirectUri,
+    scope: opts.scope,
+    code_challenge: opts.codeChallenge,
+    code_challenge_method: "S256",
+    state: opts.state
+  });
+  return `${CLOUDFLARE_OAUTH_AUTH_ENDPOINT}?${params.toString()}`;
+}
+async function exchangeCloudflareToken(fetchImpl, code, redirectUri, verifier, clientId) {
+  const body = new URLSearchParams({
+    grant_type: "authorization_code",
+    client_id: clientId,
+    code,
+    redirect_uri: redirectUri,
+    code_verifier: verifier
+  });
+  const response = await fetchImpl(CLOUDFLARE_OAUTH_TOKEN_ENDPOINT, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded",
+      Accept: "application/json"
+    },
+    body,
+    signal: AbortSignal.timeout(TOKEN_REQUEST_TIMEOUT_MS)
+  });
+  if (!response.ok) {
+    let detail = "";
+    try {
+      detail = (await response.text()).trim();
+    } catch {
+    }
+    throw new Error(
+      `Cloudflare token exchange failed: ${response.status}${detail ? ` ${detail}` : ""}`
+    );
+  }
+  const data = await response.json();
+  if (typeof data.access_token !== "string" || !data.access_token) {
+    throw new Error("Cloudflare token exchange response missing access_token");
+  }
+  return {
+    accessToken: data.access_token,
+    refreshToken: typeof data.refresh_token === "string" ? data.refresh_token : void 0,
+    expiresIn: asOptionalFiniteNumber(data.expires_in),
+    scope: typeof data.scope === "string" ? data.scope : void 0,
+    idToken: typeof data.id_token === "string" ? data.id_token : void 0
+  };
+}
+async function runCloudflareOAuthLogin(deps = {}) {
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const output = deps.output ?? console;
+  const error = deps.error ?? console;
+  const clientId = getClientId(deps);
+  const scope = getScope(deps);
+  const redirectUri = `http://${CLOUDFLARE_OAUTH_REDIRECT_HOST}:${CLOUDFLARE_OAUTH_REDIRECT_PORT}${CLOUDFLARE_OAUTH_REDIRECT_PATH}`;
+  let handle;
+  try {
+    handle = await startCallbackServer({
+      port: CLOUDFLARE_OAUTH_REDIRECT_PORT,
+      hostname: CLOUDFLARE_OAUTH_REDIRECT_HOST,
+      timeoutMs: 5 * 6e4
+    });
+  } catch (err) {
+    throw new Error(
+      `Failed to start Cloudflare OAuth callback server on ${CLOUDFLARE_OAUTH_REDIRECT_PORT}: ${toErrorMessage(err)}`
+    );
+  }
+  try {
+    const state = generateState();
+    const pkce = await generatePkcePair();
+    const authUrl = buildCloudflareAuthorizeUrl({
+      redirectUri,
+      codeChallenge: pkce.challenge,
+      state,
+      clientId,
+      scope
+    });
+    output.log(
+      `Open the following URL in your browser to authorize Cloudflare access:
+  ${authUrl}
+
+Requested scopes: ${scope}`
+    );
+    if (deps.openBrowser) {
+      try {
+        await deps.openBrowser(authUrl);
+      } catch (err) {
+        error.error(
+          `Failed to open browser automatically: ${toErrorMessage(err)}`
+        );
+      }
+    }
+    const callback = await handle.waitForCode();
+    const token = await exchangeCloudflareToken(
+      fetchImpl,
+      callback.code,
+      redirectUri,
+      pkce.verifier,
+      clientId
+    );
+    const now = (deps.now ?? Date.now)();
+    const expiresIn = token.expiresIn;
+    return {
+      provider: "cloudflare",
+      accessToken: token.accessToken,
+      refreshToken: token.refreshToken,
+      expiresAt: typeof expiresIn === "number" ? now + expiresIn * 1e3 - ACCESS_TOKEN_CLIENT_SKEW_MS : void 0,
+      scope: token.scope,
+      idToken: token.idToken,
+      obtainedAt: now
+    };
+  } finally {
+    await handle.close();
+  }
+}
+async function createCloudflareApiToken(input) {
+  const fetchImpl = input.fetchImpl ?? fetch;
+  const response = await fetchImpl(`${CLOUDFLARE_API_BASE}/user/tokens`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${input.accessToken}`
+    },
+    body: JSON.stringify({
+      name: input.name,
+      policies: input.policies
+    }),
+    signal: AbortSignal.timeout(TOKEN_REQUEST_TIMEOUT_MS)
+  });
+  if (!response.ok) {
+    let detail = "";
+    try {
+      detail = (await response.text()).trim();
+    } catch {
+    }
+    throw new Error(
+      `Cloudflare API token creation failed: ${response.status}${detail ? ` ${detail}` : ""}`
+    );
+  }
+  const data = await response.json();
+  const tokenValue = data.result?.value;
+  if (typeof tokenValue !== "string" || !tokenValue) {
+    throw new Error(
+      "Cloudflare API token creation response did not contain a token value"
+    );
+  }
+  return tokenValue;
+}
+async function listCloudflarePermissionGroups(accessToken, fetchImpl = fetch) {
+  const response = await fetchImpl(
+    `${CLOUDFLARE_API_BASE}/user/tokens/permission_groups`,
+    {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        Accept: "application/json"
+      },
+      signal: AbortSignal.timeout(TOKEN_REQUEST_TIMEOUT_MS)
+    }
+  );
+  if (!response.ok) {
+    let detail = "";
+    try {
+      detail = (await response.text()).trim();
+    } catch {
+    }
+    throw new Error(
+      `Cloudflare permission groups lookup failed: ${response.status}${detail ? ` ${detail}` : ""}`
+    );
+  }
+  const data = await response.json();
+  if (!Array.isArray(data.result)) {
+    throw new Error("Cloudflare permission groups response missing result array");
+  }
+  return data.result.filter(
+    (group) => typeof group.id === "string" && typeof group.name === "string" && Array.isArray(group.permissions)
+  ).map((group) => ({
+    id: group.id,
+    name: group.name,
+    permissions: group.permissions
+  }));
+}
+async function findCloudflareZoneIdByName(accessToken, zoneName, fetchImpl = fetch) {
+  const response = await fetchImpl(
+    `${CLOUDFLARE_API_BASE}/zones?name=${encodeURIComponent(zoneName)}`,
+    {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        Accept: "application/json"
+      },
+      signal: AbortSignal.timeout(TOKEN_REQUEST_TIMEOUT_MS)
+    }
+  );
+  if (!response.ok) {
+    let detail = "";
+    try {
+      detail = (await response.text()).trim();
+    } catch {
+    }
+    throw new Error(
+      `Cloudflare zone lookup failed: ${response.status}${detail ? ` ${detail}` : ""}`
+    );
+  }
+  const data = await response.json();
+  if (!Array.isArray(data.result)) {
+    throw new Error("Cloudflare zone lookup response missing result array");
+  }
+  const zone = data.result.find((z) => z.name === zoneName);
+  return zone?.id ?? null;
+}
+async function generateCloudflareEmailRoutingToken(input) {
+  const fetchImpl = input.fetchImpl ?? fetch;
+  const zoneId = await findCloudflareZoneIdByName(
+    input.accessToken,
+    input.zoneName,
+    fetchImpl
+  );
+  if (!zoneId) {
+    throw new Error(`Cloudflare zone "${input.zoneName}" not found`);
+  }
+  const groups = await listCloudflarePermissionGroups(
+    input.accessToken,
+    fetchImpl
+  );
+  const emailRoutingGroup = groups.find(
+    (g) => g.name.toLowerCase().includes("email routing")
+  );
+  if (!emailRoutingGroup) {
+    throw new Error(
+      "Cloudflare Email Routing Edit permission group not found for this account."
+    );
+  }
+  const token = await createCloudflareApiToken({
+    name: input.tokenName ?? `nolo-email-routing-${input.zoneName}-${Date.now()}`,
+    policies: [buildEmailRoutingPolicy(zoneId, [emailRoutingGroup.id])],
+    accessToken: input.accessToken,
+    fetchImpl
+  });
+  return { token, zoneId };
+}
+function buildEmailRoutingPolicy(zoneId, emailRoutingPermissionGroupIds) {
+  if (emailRoutingPermissionGroupIds.length === 0) {
+    throw new Error(
+      "Email routing permission group IDs are required. Resolve them with listCloudflarePermissionGroups."
+    );
+  }
+  return {
+    effect: "allow",
+    resources: {
+      "com.cloudflare.api.account": "*",
+      "com.cloudflare.api.zone": zoneId
+    },
+    permission_groups: emailRoutingPermissionGroupIds.map((id) => ({ id }))
+  };
+}
+
+// packages/cli/oauth/envFile.ts
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { resolve } from "node:path";
+function upsertEnvVariable(filePath, key, value) {
+  const normalizedPath = resolve(filePath);
+  let content = "";
+  if (existsSync(normalizedPath)) {
+    content = readFileSync(normalizedPath, "utf8");
+  }
+  const lines = content.length > 0 ? content.split("\n") : [];
+  const keyPrefix = `${key}=`;
+  let replaced = false;
+  const newLines = lines.map((line) => {
+    const trimmed = line.trim();
+    if (trimmed.startsWith(keyPrefix) || trimmed.startsWith(`${key} =`)) {
+      replaced = true;
+      return `${key}=${value}`;
+    }
+    return line;
+  });
+  if (!replaced) {
+    if (newLines.length > 0 && newLines[newLines.length - 1] !== "") {
+      newLines.push("");
+    }
+    newLines.push(`${key}=${value}`);
+  }
+  writeFileSync(normalizedPath, newLines.join("\n"), "utf8");
+}
+function parseFlagWithOptionalValue(args, flag) {
+  const index = args.indexOf(flag);
+  if (index === -1) return void 0;
+  const next = args[index + 1];
+  if (next && !next.startsWith("--")) {
+    return next;
+  }
+  return true;
+}
+
+export {
+  runCloudflareOAuthLogin,
+  generateCloudflareEmailRoutingToken,
+  upsertEnvVariable,
+  parseFlagWithOptionalValue
+};

package/chunk-4O3CARJ4.js

@@ -0,0 +1,231 @@
+import {
+  DEFAULT_AGENT_BASE_POLICY,
+  DEFAULT_USER_PREFERENCE_PROFILE
+} from "./chunk-VX3SXJ3N.js";
+
+// packages/ai/policy/runtimePolicy.ts
+var clampLevel = (value, fallback) => {
+  const n = Number(value);
+  if (n === 1 || n === 2 || n === 3 || n === 4) {
+    return n;
+  }
+  return fallback;
+};
+var normalizeTonePreset = (value, fallback) => {
+  switch (value) {
+    case "professional":
+    case "friendly":
+    case "direct":
+    case "pragmatic":
+    case "default":
+      return value;
+    default:
+      return fallback;
+  }
+};
+var normalizeToneResolutionMode = (value, fallback) => {
+  switch (value) {
+    case "agent_first":
+    case "user_first":
+    case "blend":
+      return value;
+    default:
+      return fallback;
+  }
+};
+var normalizeSelfEvolutionMode = (value, fallback) => {
+  switch (value) {
+    case "none":
+    case "knowledge_only":
+    case "prompt_and_refs":
+    case "full":
+      return value;
+    default:
+      return fallback;
+  }
+};
+var resolveAgentBasePolicy = (agentConfig) => {
+  const raw = agentConfig?.basePolicy ?? {};
+  return {
+    version: 1,
+    tone: {
+      preset: normalizeTonePreset(
+        raw?.tone?.preset,
+        DEFAULT_AGENT_BASE_POLICY.tone?.preset ?? "default"
+      ),
+      resolutionMode: normalizeToneResolutionMode(
+        raw?.tone?.resolutionMode,
+        DEFAULT_AGENT_BASE_POLICY.tone?.resolutionMode ?? "blend"
+      )
+    },
+    knowledgeCaptureMaxLevel: clampLevel(
+      raw?.knowledgeCaptureMaxLevel,
+      DEFAULT_AGENT_BASE_POLICY.knowledgeCaptureMaxLevel
+    ),
+    spaceContextMaxLevel: clampLevel(
+      raw?.spaceContextMaxLevel,
+      DEFAULT_AGENT_BASE_POLICY.spaceContextMaxLevel
+    ),
+    selfEvolutionMode: normalizeSelfEvolutionMode(
+      raw?.selfEvolutionMode,
+      DEFAULT_AGENT_BASE_POLICY.selfEvolutionMode
+    )
+  };
+};
+var resolveUserPreferenceProfile = (settingsRecord) => {
+  const fallbackSpaceLevel = settingsRecord?.enableReadCurrentSpace === false ? 1 : DEFAULT_USER_PREFERENCE_PROFILE.spaceContextLevel;
+  return {
+    version: 1,
+    tone: {
+      preset: normalizeTonePreset(
+        settingsRecord?.userTonePreset,
+        DEFAULT_USER_PREFERENCE_PROFILE.tone?.preset ?? "default"
+      )
+    },
+    knowledgeCaptureLevel: clampLevel(
+      settingsRecord?.knowledgeCaptureLevel,
+      DEFAULT_USER_PREFERENCE_PROFILE.knowledgeCaptureLevel
+    ),
+    spaceContextLevel: clampLevel(
+      settingsRecord?.spaceContextLevel,
+      fallbackSpaceLevel
+    )
+  };
+};
+var containsAny = (text, patterns) => patterns.some((pattern) => text.includes(pattern));
+var inferCaptureIntent = (userInput) => {
+  const normalized = userInput.toLowerCase();
+  if (containsAny(normalized, [
+    "\u4FDD\u5B58",
+    "\u5B58\u4E00\u4E0B",
+    "\u6C89\u6DC0",
+    "\u8BB0\u4F4F",
+    "\u5199\u5165\u6587\u6863",
+    "\u5EFA\u6587\u6863",
+    "\u521B\u5EFA\u6587\u6863",
+    "\u5BFC\u5165 skill",
+    "\u5BFC\u5165\u8FD9\u4E2A skill",
+    "\u786E\u8BA4\u5BFC\u5165",
+    "\u786E\u8BA4\u5BFC\u5165\u8FD9\u4E2A skill",
+    "\u5BFC\u5165\u8FD9\u4E2A\u6280\u80FD",
+    "\u786E\u8BA4\u5BFC\u5165\u8FD9\u4E2A\u6280\u80FD",
+    "\u521B\u5EFA skill",
+    "\u521B\u5EFA\u8FD9\u4E2A skill",
+    "skill \u6587\u6863",
+    "\u521B\u5EFA\u8868\u683C",
+    "createtable",
+    "addtablerow",
+    "addtablerows",
+    "\u5EFA\u8868",
+    "\u5EFA\u4E2A\u8868",
+    "\u505A\u4E2A\u8868",
+    "\u505A\u4E00\u5F20\u8868",
+    "\u5199\u8868",
+    "\u5199\u5165\u8868",
+    "\u5199\u5165\u4E00\u884C",
+    "\u5199\u5165 table",
+    "\u653E\u5230 table",
+    "\u5B58\u5230 table",
+    "\u4FDD\u5B58\u5230 table",
+    "\u8BB0\u5F55\u4E0B\u6765",
+    "\u91C7\u96C6",
+    "\u505A\u6570\u636E\u96C6",
+    "\u505A\u6210\u6570\u636E\u96C6",
+    "\u6574\u7406\u6210\u6570\u636E\u96C6",
+    "\u6574\u7406\u6210\u8868",
+    "\u6574\u7406\u6210\u4E00\u5F20\u8868",
+    "\u5EFA\u7ACB\u4E00\u4E2A\u8868",
+    "\u5EFA\u7ACB\u4E00\u5F20\u8868",
+    "\u5EFA\u7ACB\u6210\u8868",
+    "\u5EFA\u7ACB\u6210\u4E00\u5F20\u8868",
+    "\u521B\u5EFA\u8FD9\u4E2A\u8868\u683C",
+    "\u786E\u8BA4\u521B\u5EFA",
+    "\u786E\u8BA4\u521B\u5EFA\u8FD9\u5F20\u8868\u683C",
+    "create doc",
+    "import skill",
+    "confirm import",
+    "create skill",
+    "create table",
+    "write table",
+    "save to table",
+    "dataset",
+    "save this",
+    "remember this",
+    "document this"
+  ])) {
+    return "strong";
+  }
+  if (containsAny(normalized, [
+    "\u603B\u7ED3",
+    "\u65B9\u6848",
+    "\u8C03\u7814",
+    "\u89C4\u8303",
+    "\u4F1A\u8BAE\u7EAA\u8981",
+    "\u603B\u7ED3\u4E00\u4E0B",
+    "research",
+    "proposal",
+    "spec",
+    "summary"
+  ])) {
+    return "possible";
+  }
+  return "none";
+};
+var resolveTonePreset = (agentTone, userTone, mode) => {
+  if (mode === "agent_first") {
+    return agentTone === "default" ? userTone : agentTone;
+  }
+  if (mode === "user_first") {
+    return userTone === "default" ? agentTone : userTone;
+  }
+  if (userTone !== "default") return userTone;
+  return agentTone;
+};
+var preloadSummaryCountByLevel = (level) => ({ 1: 0, 2: 0, 3: 8, 4: 16 })[level];
+var preloadBudgetRatioByLevel = (level) => ({ 1: 0, 2: 0.01, 3: 0.04, 4: 0.08 })[level];
+var knowledgeCaptureLevelLabel = (level) => ({
+  1: "\u4E0D\u4E3B\u52A8\u521B\u5EFA",
+  2: "\u5148\u95EE\u518D\u521B\u5EFA",
+  3: "\u56DE\u7B54\u540E\u5EFA\u8BAE\u521B\u5EFA",
+  4: "\u9AD8\u4EF7\u503C\u7ED3\u679C\u53EF\u81EA\u52A8\u521B\u5EFA"
+})[level] ?? "\u672A\u77E5\u7EA7\u522B";
+var spaceContextLevelLabel = (level) => ({
+  1: "\u4E0D\u81EA\u52A8\u8BFB\u53D6",
+  2: "\u53EA\u770B\u7ED3\u6784\u548C\u6807\u9898",
+  3: "\u8F7B\u91CF\u8BFB\u53D6",
+  4: "\u81EA\u9002\u5E94\u8BFB\u53D6"
+})[level] ?? "\u672A\u77E5\u7EA7\u522B";
+var buildStaticUserPolicyContext = (params) => {
+  const agentBasePolicy = resolveAgentBasePolicy(params.agentConfig);
+  const userPreferenceProfile = resolveUserPreferenceProfile(params.settingsRecord);
+  const tonePreset = resolveTonePreset(
+    agentBasePolicy.tone?.preset ?? "default",
+    userPreferenceProfile.tone?.preset ?? "default",
+    agentBasePolicy.tone?.resolutionMode ?? "blend"
+  );
+  const knowledgeLevel = Math.min(
+    agentBasePolicy.knowledgeCaptureMaxLevel,
+    userPreferenceProfile.knowledgeCaptureLevel
+  );
+  const spaceLevel = Math.min(
+    agentBasePolicy.spaceContextMaxLevel,
+    userPreferenceProfile.spaceContextLevel
+  );
+  return [
+    `\u7528\u6237\u8BED\u6C14\u504F\u597D\uFF1A${tonePreset}`,
+    `\u77E5\u8BC6\u6C89\u6DC0\u7EA7\u522B\uFF1A${knowledgeLevel}\uFF08${knowledgeCaptureLevelLabel(knowledgeLevel)}\uFF09`,
+    `\u7A7A\u95F4\u4E0A\u4E0B\u6587\u7EA7\u522B\uFF1A${spaceLevel}\uFF08${spaceContextLevelLabel(spaceLevel)}\uFF09`,
+    "\u8BF7\u5C3D\u91CF\u4FDD\u7559 agent \u81EA\u8EAB\u89D2\u8272\u8BBE\u5B9A\uFF0C\u540C\u65F6\u6309\u7528\u6237\u504F\u597D\u8C03\u6574\u8868\u8FBE\u548C\u81EA\u52A8\u5316\u7A0B\u5EA6\u3002"
+  ].join("\n");
+};
+var resolveSpaceContextPreloadPlan = (level) => ({
+  preloadSummaryCount: preloadSummaryCountByLevel(level),
+  preloadBudgetRatio: preloadBudgetRatioByLevel(level),
+  includeRecentContent: level >= 3
+});
+
+export {
+  inferCaptureIntent,
+  buildStaticUserPolicyContext,
+  resolveSpaceContextPreloadPlan
+};