@withone/cli 1.44.2 → 1.45.0

package/dist/index.js

@@ -5,22 +5,35 @@ import {
   OneApi,
   TimeoutError,
   buildActionKnowledgeWithGuidance,
+  buildCacheMeta,
+  clearAll,
+  clearEntry,
   filterByPermissions,
   flowRequiresBash,
+  formatAge,
   generateFlowGuide,
+  getAge,
   getNestedStepsKeys,
   getStepTypeDescriptor,
   isActionAllowed,
+  isFresh,
   isMethodAllowed,
+  knowledgeCachePath,
+  listCacheEntries,
   listFlows,
   loadFlowWithMeta,
+  makeCacheEntry,
+  readCache,
+  resolveActionDetails,
   resolveFlowPath,
   saveFlow,
-  validateActionInput
-} from "./chunk-YGOS6KEC.js";
+  searchCachePath,
+  validateActionInput,
+  writeCache
+} from "./chunk-UXKF6AEG.js";
 import {
   memSqlCommand
-} from "./chunk-7ZILTQQO.js";
+} from "./chunk-TLRJMJGU.js";
 import {
   countRecords,
   deleteDatabase,
@@ -45,7 +58,7 @@ import {
   upsertRecords,
   writeDraftProfile,
   writeProfile
-} from "./chunk-VQPV5XET.js";
+} from "./chunk-Z4HKASJT.js";
 import {
   getByDotPath
 } from "./chunk-44CV5IMX.js";
@@ -68,7 +81,7 @@ import {
   semanticSearchUpgradeHint,
   semanticSearchUpgradeLine,
   setAgentMode
-} from "./chunk-MNNKOQ6V.js";
+} from "./chunk-KH4ERRJ5.js";
 import {
   SCHEMA_VERSION,
   addRecord,
@@ -78,44 +91,45 @@ import {
   listBackendPlugins,
   loadBackendFromConfig,
   upsertRecord
-} from "./chunk-YBEVCY4D.js";
+} from "./chunk-TGWQUBKA.js";
 import {
   DEFAULT_MEMORY_CONFIG,
-  configExists,
   defaultSearchableText,
   embed,
+  getMemoryConfig,
+  getMemoryConfigOrDefault,
+  memoryConfigExists,
+  setOpenAiApiKey,
+  updateMemoryConfig
+} from "./chunk-77564KWS.js";
+import {
+  configExists,
   ensureWhoAmI,
   getAccessControl,
   getAccessControlFromAllSources,
   getApiBase,
   getApiKey,
-  getCacheTtl,
   getEnvFromApiKey,
   getGlobalConfigPath,
-  getMemoryConfig,
-  getMemoryConfigOrDefault,
   getOpenAiApiKey,
   getProjectConfigPath,
   getProjectRoot,
   getWhoAmI,
   globalConfigExists,
-  memoryConfigExists,
   projectConfigExists,
   readConfig,
   readGlobalConfig,
   readProjectConfig,
   resolveConfig,
-  setOpenAiApiKey,
   updateAccessControl,
   updateApiBase,
-  updateMemoryConfig,
   updateWhoAmI,
   writeConfig
-} from "./chunk-ZD5S4IWT.js";
+} from "./chunk-TVIZC7AC.js";
 
 // src/cli.ts
 import { createRequire as createRequire2 } from "module";
-import path12 from "path";
+import path11 from "path";
 import { Command } from "commander";
 
 // src/commands/init.ts
@@ -644,14 +658,14 @@ async function fetchLatestVersionInfo() {
     return null;
   }
 }
-function readCache() {
+function readCache2() {
   try {
     return JSON.parse(readFileSync(CACHE_PATH, "utf8"));
   } catch {
     return null;
   }
 }
-function writeCache(latestVersion, publishedAt) {
+function writeCache2(latestVersion, publishedAt) {
   try {
     mkdirSync(join(homedir(), ".one"), { recursive: true });
     writeFileSync(CACHE_PATH, JSON.stringify({ lastCheck: Date.now(), latestVersion, publishedAt }));
@@ -660,16 +674,16 @@ function writeCache(latestVersion, publishedAt) {
 }
 async function checkLatestVersion() {
   const info = await fetchLatestVersionInfo();
-  if (info) writeCache(info.version, info.publishedAt);
+  if (info) writeCache2(info.version, info.publishedAt);
   return info?.version ?? null;
 }
 async function checkLatestVersionCached() {
-  const cache2 = readCache();
+  const cache2 = readCache2();
   if (cache2 && Date.now() - cache2.lastCheck < CHECK_INTERVAL_MS) {
     return { version: cache2.latestVersion, publishedAt: cache2.publishedAt ?? null };
   }
   const info = await fetchLatestVersionInfo();
-  if (info) writeCache(info.version, info.publishedAt);
+  if (info) writeCache2(info.version, info.publishedAt);
   return info;
 }
 function getCurrentVersion() {
@@ -2340,123 +2354,6 @@ async function platformsCommand(options) {
 // src/commands/actions.ts
 import * as p6 from "@clack/prompts";
 import pc6 from "picocolors";
-
-// src/lib/cache.ts
-import fs4 from "fs";
-import path4 from "path";
-import os4 from "os";
-var CACHE_BASE = path4.join(os4.homedir(), ".one", "cache");
-var KNOWLEDGE_DIR = path4.join(CACHE_BASE, "knowledge");
-var SEARCH_DIR = path4.join(CACHE_BASE, "search");
-function sanitizeFilename(input) {
-  return input.replace(/[^a-zA-Z0-9_\-\.]/g, "_");
-}
-function knowledgeCachePath(actionId) {
-  return path4.join(KNOWLEDGE_DIR, `${sanitizeFilename(actionId)}.json`);
-}
-function searchCachePath(platform, query, type) {
-  const key = `${platform}_${sanitizeFilename(query)}_${type || "knowledge"}`;
-  return path4.join(SEARCH_DIR, `${key}.json`);
-}
-function readCache2(filePath) {
-  try {
-    const content = fs4.readFileSync(filePath, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return null;
-  }
-}
-function writeCache2(filePath, entry) {
-  try {
-    const dir = path4.dirname(filePath);
-    fs4.mkdirSync(dir, { recursive: true });
-    fs4.writeFileSync(filePath, JSON.stringify(entry, null, 2));
-  } catch {
-  }
-}
-function isFresh(entry) {
-  const cachedTime = new Date(entry.cachedAt).getTime();
-  const now = Date.now();
-  return now - cachedTime < entry.ttl * 1e3;
-}
-function getAge(entry) {
-  return Math.floor((Date.now() - new Date(entry.cachedAt).getTime()) / 1e3);
-}
-function buildCacheMeta(entry, hit) {
-  if (!entry) {
-    return { hit: false, age: 0, fresh: false };
-  }
-  return {
-    hit,
-    age: getAge(entry),
-    fresh: isFresh(entry)
-  };
-}
-function formatAge(seconds) {
-  if (seconds < 60) return `${seconds}s`;
-  if (seconds < 3600) return `${Math.floor(seconds / 60)}m`;
-  if (seconds < 86400) {
-    const h2 = Math.floor(seconds / 3600);
-    const m = Math.floor(seconds % 3600 / 60);
-    return m > 0 ? `${h2}h ${m}m` : `${h2}h`;
-  }
-  const d = Math.floor(seconds / 86400);
-  const h = Math.floor(seconds % 86400 / 3600);
-  return h > 0 ? `${d}d ${h}h` : `${d}d`;
-}
-function listCacheEntries() {
-  const entries = [];
-  for (const [dir, type] of [[KNOWLEDGE_DIR, "knowledge"], [SEARCH_DIR, "search"]]) {
-    try {
-      const files = fs4.readdirSync(dir);
-      for (const file of files) {
-        if (!file.endsWith(".json")) continue;
-        const filePath = path4.join(dir, file);
-        const entry = readCache2(filePath);
-        if (entry) {
-          entries.push({ type, filePath, entry });
-        }
-      }
-    } catch {
-    }
-  }
-  return entries;
-}
-function clearAll() {
-  let count = 0;
-  for (const dir of [KNOWLEDGE_DIR, SEARCH_DIR]) {
-    try {
-      const files = fs4.readdirSync(dir);
-      for (const file of files) {
-        fs4.unlinkSync(path4.join(dir, file));
-        count++;
-      }
-      fs4.rmdirSync(dir);
-    } catch {
-    }
-  }
-  return count;
-}
-function clearEntry(actionId) {
-  const filePath = knowledgeCachePath(actionId);
-  try {
-    fs4.unlinkSync(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function makeCacheEntry(key, data, etag) {
-  return {
-    key,
-    etag,
-    cachedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    ttl: getCacheTtl(),
-    data
-  };
-}
-
-// src/commands/actions.ts
 function getConfig() {
   const apiKey = getApiKey();
   if (!apiKey) {
@@ -2486,7 +2383,7 @@ async function actionsSearchCommand(platform, query, options) {
     const agentType = knowledgeAgent ? "knowledge" : options.type || "execute";
     const useCache = options.cache !== false;
     const cachePath = searchCachePath(platform, query, agentType || "knowledge");
-    const cached = useCache ? readCache2(cachePath) : null;
+    const cached = useCache ? readCache(cachePath) : null;
     let cleanedActions;
     let cacheHit = false;
     if (cached && isFresh(cached)) {
@@ -2502,7 +2399,7 @@ async function actionsSearchCommand(platform, query, options) {
         );
         if (result.status === 304 && cached) {
           cached.cachedAt = (/* @__PURE__ */ new Date()).toISOString();
-          writeCache2(cachePath, cached);
+          writeCache(cachePath, cached);
           cleanedActions = cached.data.actions;
           cacheHit = true;
         } else {
@@ -2515,7 +2412,7 @@ async function actionsSearchCommand(platform, query, options) {
             method: action.method,
             path: action.path
           }));
-          writeCache2(cachePath, makeCacheEntry(
+          writeCache(cachePath, makeCacheEntry(
             `${platform}_${query}_${agentType || "knowledge"}`,
             { actions: cleanedActions },
             result.etag
@@ -2539,7 +2436,7 @@ async function actionsSearchCommand(platform, query, options) {
       if (cacheHit && cached) {
         response._cache = buildCacheMeta(cached, true);
       } else {
-        const freshEntry = readCache2(cachePath);
+        const freshEntry = readCache(cachePath);
         response._cache = buildCacheMeta(freshEntry, false);
       }
       json(response);
@@ -2599,7 +2496,7 @@ Execute:     ${pc6.cyan(`one actions execute ${platform} <actionId> <connectionK
 async function actionsKnowledgeCommand(platform, actionId, options) {
   const cachePath = knowledgeCachePath(actionId);
   if (options.cacheStatus) {
-    const entry = readCache2(cachePath);
+    const entry = readCache(cachePath);
     if (!entry) {
       json({
         cached: false,
@@ -2646,44 +2543,13 @@ async function actionsKnowledgeCommand(platform, actionId, options) {
   const spinner5 = createSpinner();
   spinner5.start(`Loading knowledge for action ${pc6.dim(actionId)}...`);
   try {
-    const useCache = options.cache !== false;
-    const cached = useCache ? readCache2(cachePath) : null;
-    let knowledgeData;
-    let cacheHit = false;
-    let cacheEntry = cached;
-    if (cached && isFresh(cached) && useCache) {
-      knowledgeData = cached.data;
-      cacheHit = true;
-    } else {
-      try {
-        const result = await api.getActionKnowledgeWithMeta(
-          actionId,
-          cached?.etag ?? void 0
-        );
-        if (result.status === 304 && cached) {
-          cached.cachedAt = (/* @__PURE__ */ new Date()).toISOString();
-          writeCache2(cachePath, cached);
-          knowledgeData = cached.data;
-          cacheHit = true;
-        } else {
-          knowledgeData = result.data;
-          const newEntry = makeCacheEntry(actionId, knowledgeData, result.etag);
-          writeCache2(cachePath, newEntry);
-          cacheEntry = newEntry;
-        }
-      } catch (fetchError) {
-        if (cached) {
-          process.stderr.write(
-            `Warning: serving cached knowledge (network unavailable, cached ${formatAge(getAge(cached))} ago)
-`
-          );
-          knowledgeData = cached.data;
-          cacheHit = true;
-        } else {
-          throw fetchError;
-        }
-      }
-    }
+    const { details, cacheHit, entry } = await resolveActionDetails(api, actionId, {
+      useCache: options.cache !== false
+    });
+    const knowledgeData = {
+      knowledge: details.knowledge || "No knowledge was found",
+      method: details.method || "No method was found"
+    };
     const knowledgeWithGuidance = buildActionKnowledgeWithGuidance(
       knowledgeData.knowledge,
       knowledgeData.method,
@@ -2694,7 +2560,7 @@ async function actionsKnowledgeCommand(platform, actionId, options) {
       const response = {
         knowledge: knowledgeWithGuidance,
         method: knowledgeData.method,
-        _cache: buildCacheMeta(cacheEntry, cacheHit)
+        _cache: buildCacheMeta(entry, cacheHit)
       };
       json(response);
       return;
@@ -2732,7 +2598,7 @@ async function actionsExecuteCommand(platform, actionId, connectionKey, options)
   const spinner5 = createSpinner();
   spinner5.start("Loading action details...");
   try {
-    const actionDetails = await api.getActionDetails(actionId);
+    const { details: actionDetails, cacheHit: preflightCacheHit } = await resolveActionDetails(api, actionId, { useCache: options.cache !== false });
     if (!isMethodAllowed(actionDetails.method, permissions)) {
       spinner5.stop("Permission denied");
       error(
@@ -2778,7 +2644,8 @@ async function actionsExecuteCommand(platform, actionId, connectionKey, options)
             url: actionDetails.path
           },
           response: mockResponse,
-          ...mockResponse === null ? { message: "No example output available for this action" } : {}
+          ...mockResponse === null ? { message: "No example output available for this action" } : {},
+          _preflight: { cache: preflightCacheHit ? "hit" : "miss" }
         });
         return;
       }
@@ -2819,7 +2686,8 @@ async function actionsExecuteCommand(platform, actionId, connectionKey, options)
           headers: options.dryRun ? result.requestConfig.headers : void 0,
           data: options.dryRun ? result.requestConfig.data : void 0
         },
-        response: options.dryRun ? void 0 : result.responseData
+        response: options.dryRun ? void 0 : result.responseData,
+        _preflight: { cache: preflightCacheHit ? "hit" : "miss" }
       });
       return;
     }
@@ -2863,7 +2731,7 @@ function parseParallelSegments() {
     error('Could not locate "actions execute" in argv');
   }
   const raw = argv.slice(execIdx + 1);
-  const flags = { dryRun: false, mock: false, skipValidation: false, maxConcurrency: 5 };
+  const flags = { dryRun: false, mock: false, skipValidation: false, maxConcurrency: 5, useCache: true };
   const cleaned = [];
   for (let i = 0; i < raw.length; i++) {
     const t = raw[i];
@@ -2880,6 +2748,10 @@ function parseParallelSegments() {
       flags.skipValidation = true;
       continue;
     }
+    if (t === "--no-cache") {
+      flags.useCache = false;
+      continue;
+    }
     if (t === "--max-concurrency") {
       flags.maxConcurrency = parseInt(raw[++i], 10) || 5;
       continue;
@@ -2969,8 +2841,11 @@ async function actionsExecuteParallelCommand() {
       segErrors.push(`Connection key "${seg.connectionKey}" is not allowed`);
     }
     let actionDetails;
+    let preflightCacheHit = false;
     try {
-      actionDetails = await api.getActionDetails(seg.actionId);
+      const resolved = await resolveActionDetails(api, seg.actionId, { useCache: flags.useCache });
+      actionDetails = resolved.details;
+      preflightCacheHit = resolved.cacheHit;
     } catch (err) {
       segErrors.push(`Action not found: ${err instanceof Error ? err.message : String(err)}`);
     }
@@ -3016,7 +2891,7 @@ async function actionsExecuteParallelCommand() {
     if (segErrors.length > 0) {
       errors.push({ segment: i + 1, label, messages: segErrors });
     } else if (actionDetails) {
-      prepared.push({ segment: seg, index: i, actionDetails, data, pathVariables, queryParams, headers });
+      prepared.push({ segment: seg, index: i, actionDetails, preflightCacheHit, data, pathVariables, queryParams, headers });
     }
   }
   if (errors.length > 0) {
@@ -3054,7 +2929,8 @@ async function actionsExecuteParallelCommand() {
             durationMs: Date.now() - start,
             mock: true,
             request: { method: action.actionDetails.method, url: action.actionDetails.path },
-            response: mockResponse
+            response: mockResponse,
+            _preflight: { cache: action.preflightCacheHit ? "hit" : "miss" }
           };
         }
         const result = await api.executePassthroughRequest({
@@ -3081,7 +2957,8 @@ async function actionsExecuteParallelCommand() {
             url: result.requestConfig.url,
             ...flags.dryRun ? { headers: result.requestConfig.headers, data: result.requestConfig.data } : {}
           },
-          response: flags.dryRun ? void 0 : result.responseData
+          response: flags.dryRun ? void 0 : result.responseData,
+          _preflight: { cache: action.preflightCacheHit ? "hit" : "miss" }
         };
       })
     );
@@ -3162,8 +3039,8 @@ function colorMethod(method) {
 import pc7 from "picocolors";
 
 // src/lib/flow-validator.ts
-import fs5 from "fs";
-import path5 from "path";
+import fs4 from "fs";
+import path4 from "path";
 import { spawnSync } from "child_process";
 function validateFlowSchema(flow2) {
   const errors = [];
@@ -3228,32 +3105,32 @@ function validateStepsArray(steps, pathPrefix, errors) {
   const validTypes = FLOW_SCHEMA.stepTypes.map((st) => st.type);
   for (let i = 0; i < steps.length; i++) {
     const step = steps[i];
-    const path13 = `${pathPrefix}[${i}]`;
+    const path12 = `${pathPrefix}[${i}]`;
     if (!step || typeof step !== "object" || Array.isArray(step)) {
-      errors.push({ path: path13, message: "Step must be an object" });
+      errors.push({ path: path12, message: "Step must be an object" });
       continue;
     }
     const s = step;
     if (!s.id || typeof s.id !== "string") {
-      errors.push({ path: `${path13}.id`, message: 'Step must have a string "id"' });
+      errors.push({ path: `${path12}.id`, message: 'Step must have a string "id"' });
     }
     if (!s.name || typeof s.name !== "string") {
-      errors.push({ path: `${path13}.name`, message: 'Step must have a string "name"' });
+      errors.push({ path: `${path12}.name`, message: 'Step must have a string "name"' });
     }
     if (!s.type || !validTypes.includes(s.type)) {
-      errors.push({ path: `${path13}.type`, message: `Step type must be one of: ${validTypes.join(", ")}` });
+      errors.push({ path: `${path12}.type`, message: `Step type must be one of: ${validTypes.join(", ")}` });
       continue;
     }
     if (s.requires !== void 0) {
       if (!Array.isArray(s.requires)) {
-        errors.push({ path: `${path13}.requires`, message: '"requires" must be an array of selector strings (e.g. ["$.steps.foo.output.bar"])' });
+        errors.push({ path: `${path12}.requires`, message: '"requires" must be an array of selector strings (e.g. ["$.steps.foo.output.bar"])' });
       } else {
         for (let r = 0; r < s.requires.length; r++) {
           const sel = s.requires[r];
           if (typeof sel !== "string") {
-            errors.push({ path: `${path13}.requires[${r}]`, message: '"requires" entry must be a selector string' });
+            errors.push({ path: `${path12}.requires[${r}]`, message: '"requires" entry must be a selector string' });
           } else if (!sel.startsWith("$.")) {
-            errors.push({ path: `${path13}.requires[${r}]`, message: `"requires" entry "${sel}" must be a selector starting with "$." (e.g. "$.steps.foo.output.bar")` });
+            errors.push({ path: `${path12}.requires[${r}]`, message: `"requires" entry "${sel}" must be a selector starting with "$." (e.g. "$.steps.foo.output.bar")` });
           }
         }
       }
@@ -3261,7 +3138,7 @@ function validateStepsArray(steps, pathPrefix, errors) {
     if (s.onError && typeof s.onError === "object") {
       const oe = s.onError;
       if (!FLOW_SCHEMA.errorStrategies.includes(oe.strategy)) {
-        errors.push({ path: `${path13}.onError.strategy`, message: `Error strategy must be one of: ${FLOW_SCHEMA.errorStrategies.join(", ")}` });
+        errors.push({ path: `${path12}.onError.strategy`, message: `Error strategy must be one of: ${FLOW_SCHEMA.errorStrategies.join(", ")}` });
       }
     }
     const descriptor = getStepTypeDescriptor(s.type);
@@ -3271,14 +3148,14 @@ function validateStepsArray(steps, pathPrefix, errors) {
     if (!configObj || typeof configObj !== "object") {
       const hint = detectFlatConfigHint(s, descriptor);
       errors.push({
-        path: `${path13}.${configKey}`,
+        path: `${path12}.${configKey}`,
         message: `${capitalize(descriptor.type)} step must have a "${configKey}" config object${hint}`
       });
       continue;
     }
     const config2 = configObj;
     for (const [fieldName, fd] of Object.entries(descriptor.fields)) {
-      const fieldPath = `${path13}.${configKey}.${fieldName}`;
+      const fieldPath = `${path12}.${configKey}.${fieldName}`;
       const value = config2[fieldName];
       if (fd.required && (value === void 0 || value === null || value === "")) {
         errors.push({ path: fieldPath, message: `${capitalize(descriptor.type)} must have ${fd.type === "string" ? "a string" : fd.type === "array" ? "a" : "a"} "${fieldName}"` });
@@ -3311,30 +3188,30 @@ function validateStepsArray(steps, pathPrefix, errors) {
       }
     }
     if (descriptor.type === "action") {
-      validateConnectionForm(config2, `${path13}.${configKey}`, errors);
+      validateConnectionForm(config2, `${path12}.${configKey}`, errors);
     }
     if (descriptor.type === "code") {
       const hasSource = typeof config2.source === "string" && config2.source.length > 0;
       const hasModule = typeof config2.module === "string" && config2.module.length > 0;
       if (!hasSource && !hasModule) {
-        errors.push({ path: `${path13}.${configKey}`, message: 'Code step must define either "source" (inline JS) or "module" (path to .mjs file)' });
+        errors.push({ path: `${path12}.${configKey}`, message: 'Code step must define either "source" (inline JS) or "module" (path to .mjs file)' });
       } else if (hasSource && hasModule) {
-        errors.push({ path: `${path13}.${configKey}`, message: 'Code step cannot define both "source" and "module" \u2014 pick one' });
+        errors.push({ path: `${path12}.${configKey}`, message: 'Code step cannot define both "source" and "module" \u2014 pick one' });
       }
       if (hasModule) {
         const m = config2.module;
         if (m.startsWith("/") || /^[a-zA-Z]:[\\/]/.test(m)) {
-          errors.push({ path: `${path13}.${configKey}.module`, message: "Code module path must be relative to the flow folder (no absolute paths)" });
+          errors.push({ path: `${path12}.${configKey}.module`, message: "Code module path must be relative to the flow folder (no absolute paths)" });
         } else if (m.split(/[\\/]/).includes("..")) {
-          errors.push({ path: `${path13}.${configKey}.module`, message: 'Code module path must not escape the flow folder ("..")' });
+          errors.push({ path: `${path12}.${configKey}.module`, message: 'Code module path must not escape the flow folder ("..")' });
         } else if (!m.endsWith(".mjs")) {
-          errors.push({ path: `${path13}.${configKey}.module`, message: "Code module must be a .mjs file" });
+          errors.push({ path: `${path12}.${configKey}.module`, message: "Code module must be a .mjs file" });
         }
       }
       if (hasSource) {
         const syntaxError = checkCodeSourceSyntax(config2.source);
         if (syntaxError) {
-          errors.push({ path: `${path13}.${configKey}.source`, message: `Syntax error in code step: ${syntaxError}` });
+          errors.push({ path: `${path12}.${configKey}.source`, message: `Syntax error in code step: ${syntaxError}` });
         }
       }
     }
@@ -3406,16 +3283,16 @@ function validateStepIds(flow2) {
   function collectIds(steps, pathPrefix) {
     for (let i = 0; i < steps.length; i++) {
       const step = steps[i];
-      const path13 = `${pathPrefix}[${i}]`;
+      const path12 = `${pathPrefix}[${i}]`;
       if (seen.has(step.id)) {
-        errors.push({ path: `${path13}.id`, message: `Duplicate step ID: "${step.id}"` });
+        errors.push({ path: `${path12}.id`, message: `Duplicate step ID: "${step.id}"` });
       } else {
         seen.add(step.id);
       }
       for (const { configKey, fieldName } of nestedKeys) {
         const config2 = step[configKey];
         if (config2 && Array.isArray(config2[fieldName])) {
-          collectIds(config2[fieldName], `${path13}.${configKey}.${fieldName}`);
+          collectIds(config2[fieldName], `${path12}.${configKey}.${fieldName}`);
         }
       }
     }
@@ -3463,7 +3340,7 @@ function validateSelectorReferences(flow2) {
     }
     return selectors;
   }
-  function checkSelectors(selectors, path13, precedingStepIds) {
+  function checkSelectors(selectors, path12, precedingStepIds) {
     for (const selector of selectors) {
       const parts = selector.split(".");
       if (parts.length < 3) continue;
@@ -3471,15 +3348,15 @@ function validateSelectorReferences(flow2) {
       if (root === "input") {
         const inputName = parts[2];
         if (!inputNames.has(inputName)) {
-          errors.push({ path: path13, message: `Selector "${selector}" references undefined input "${inputName}"` });
+          errors.push({ path: path12, message: `Selector "${selector}" references undefined input "${inputName}"` });
         }
       } else if (root === "steps") {
         const stepId = parts[2].replace(/[\[\]]/g, "").split(/[\[\]]/)[0];
         if (!allStepIds.has(stepId)) {
-          errors.push({ path: path13, message: `Selector "${selector}" references undefined step "${stepId}"` });
+          errors.push({ path: path12, message: `Selector "${selector}" references undefined step "${stepId}"` });
         } else if (precedingStepIds && !precedingStepIds.has(stepId)) {
           errors.push({
-            path: path13,
+            path: path12,
             message: `Selector "${selector}" references step "${stepId}" which is declared after the current step. Steps execute in declaration order, so this will always resolve to undefined at runtime \u2014 move the dependency earlier in the steps array.`
           });
         }
@@ -3487,20 +3364,20 @@ function validateSelectorReferences(flow2) {
     }
   }
   const EXPRESSION_FIELDS = /* @__PURE__ */ new Set(["condition.expression", "while.condition"]);
-  function checkOperatorsInSelectorField(value, path13) {
+  function checkOperatorsInSelectorField(value, path12) {
     if (typeof value === "string" && value.startsWith("$.")) {
       if (value.includes("||")) {
-        errors.push({ path: path13, message: `Selector "${value}" contains unsupported operator "||". Selectors in data fields use dot-path resolution, not JS evaluation. Use the "default" field on the input definition instead, or use a "code" step for complex expressions.` });
+        errors.push({ path: path12, message: `Selector "${value}" contains unsupported operator "||". Selectors in data fields use dot-path resolution, not JS evaluation. Use the "default" field on the input definition instead, or use a "code" step for complex expressions.` });
       } else if (value.includes("&&")) {
-        errors.push({ path: path13, message: `Selector "${value}" contains unsupported operator "&&". Selectors in data fields use dot-path resolution, not JS evaluation. Use a "condition" step or "code" step for complex expressions.` });
+        errors.push({ path: path12, message: `Selector "${value}" contains unsupported operator "&&". Selectors in data fields use dot-path resolution, not JS evaluation. Use a "condition" step or "code" step for complex expressions.` });
       }
     } else if (value && typeof value === "object" && !Array.isArray(value)) {
       for (const [k, v] of Object.entries(value)) {
-        checkOperatorsInSelectorField(v, `${path13}.${k}`);
+        checkOperatorsInSelectorField(v, `${path12}.${k}`);
       }
     } else if (Array.isArray(value)) {
       for (let i = 0; i < value.length; i++) {
-        checkOperatorsInSelectorField(value[i], `${path13}[${i}]`);
+        checkOperatorsInSelectorField(value[i], `${path12}[${i}]`);
       }
     }
   }
@@ -3568,10 +3445,10 @@ var VALID_OUTPUT_SCHEMA_TYPES = /* @__PURE__ */ new Set(["string", "number", "bo
 function isOutputSchemaObject(v) {
   return !!v && typeof v === "object" && !Array.isArray(v);
 }
-function walkOutputSchema(schema, path13) {
+function walkOutputSchema(schema, path12) {
   let current = schema;
-  for (let i = 0; i < path13.length; i++) {
-    const seg = path13[i];
+  for (let i = 0; i < path12.length; i++) {
+    const seg = path12[i];
     if (typeof current === "string") {
       return current === "unknown" || current === "object" || current === "array" ? "opaque" : "opaque";
     }
@@ -3722,8 +3599,8 @@ function validateCodeModules(flow2, rootDir) {
       const stepPath = `${pathPrefix}[${i}]`;
       if (step.type === "code" && step.code?.module) {
         const m = step.code.module;
-        const abs = path5.resolve(rootDir, m);
-        if (!fs5.existsSync(abs)) {
+        const abs = path4.resolve(rootDir, m);
+        if (!fs4.existsSync(abs)) {
           errors.push({
             path: `${stepPath}.code.module`,
             message: `Code module "${m}" not found at ${abs}`
@@ -3752,8 +3629,8 @@ function validateCodeModules(flow2, rootDir) {
 }
 
 // src/commands/flow.ts
-import fs6 from "fs";
-import path6 from "path";
+import fs5 from "fs";
+import path5 from "path";
 function getConfig2() {
   const apiKey = getApiKey();
   if (!apiKey) {
@@ -3811,7 +3688,7 @@ async function flowCreateCommand(key, options) {
     if (raw.startsWith("@")) {
       const filePath = raw.slice(1);
       try {
-        raw = fs6.readFileSync(filePath, "utf-8");
+        raw = fs5.readFileSync(filePath, "utf-8");
       } catch (err) {
         error(`Cannot read file "${filePath}": ${err.message}`);
       }
@@ -4041,9 +3918,9 @@ async function flowValidateCommand(keyOrPath) {
       rootDir = loaded.rootDir;
     } catch {
       const flowPath = resolveFlowPath(keyOrPath);
-      const content = fs6.readFileSync(flowPath, "utf-8");
+      const content = fs5.readFileSync(flowPath, "utf-8");
       flowData = JSON.parse(content);
-      rootDir = path6.dirname(flowPath);
+      rootDir = path5.dirname(flowPath);
     }
   } catch (err) {
     spinner5.stop("Validation failed");
@@ -4866,11 +4743,11 @@ function handleId(response, config2, records) {
 }
 
 // src/lib/memory/sync/state.ts
-import fs7 from "fs";
-import path7 from "path";
-var SYNC_DIR = path7.join(".one", "sync");
-var STATE_DIR = path7.join(SYNC_DIR, "state");
-var LEGACY_SINGLE_FILE = path7.join(SYNC_DIR, "sync_state.json");
+import fs6 from "fs";
+import path6 from "path";
+var SYNC_DIR = path6.join(".one", "sync");
+var STATE_DIR = path6.join(SYNC_DIR, "state");
+var LEGACY_SINGLE_FILE = path6.join(SYNC_DIR, "sync_state.json");
 var legacyMigrationDone = false;
 function rowToState(row) {
   return {
@@ -4898,9 +4775,9 @@ function stateToRow(platform, model, state, lastError) {
 async function migrateLegacyOnce() {
   if (legacyMigrationDone) return;
   legacyMigrationDone = true;
-  if (fs7.existsSync(LEGACY_SINGLE_FILE)) {
+  if (fs6.existsSync(LEGACY_SINGLE_FILE)) {
     try {
-      const raw = fs7.readFileSync(LEGACY_SINGLE_FILE, "utf-8");
+      const raw = fs6.readFileSync(LEGACY_SINGLE_FILE, "utf-8");
       const legacy = JSON.parse(raw);
       const backend = await getBackend();
       for (const [platform, models] of Object.entries(legacy)) {
@@ -4910,32 +4787,32 @@ async function migrateLegacyOnce() {
           await backend.setSyncState(stateToRow(platform, model, modelState));
         }
       }
-      fs7.unlinkSync(LEGACY_SINGLE_FILE);
+      fs6.unlinkSync(LEGACY_SINGLE_FILE);
     } catch {
       try {
-        fs7.unlinkSync(LEGACY_SINGLE_FILE);
+        fs6.unlinkSync(LEGACY_SINGLE_FILE);
       } catch {
       }
     }
   }
-  if (fs7.existsSync(STATE_DIR)) {
+  if (fs6.existsSync(STATE_DIR)) {
     try {
       const backend = await getBackend();
-      const platforms = fs7.readdirSync(STATE_DIR);
+      const platforms = fs6.readdirSync(STATE_DIR);
       for (const platform of platforms) {
-        const platformDir = path7.join(STATE_DIR, platform);
+        const platformDir = path6.join(STATE_DIR, platform);
         let entries;
         try {
-          entries = fs7.readdirSync(platformDir);
+          entries = fs6.readdirSync(platformDir);
         } catch {
           continue;
         }
         for (const entry of entries) {
           if (!entry.endsWith(".json")) continue;
           const model = entry.slice(0, -".json".length);
-          const filePath = path7.join(platformDir, entry);
+          const filePath = path6.join(platformDir, entry);
           try {
-            const raw = fs7.readFileSync(filePath, "utf-8");
+            const raw = fs6.readFileSync(filePath, "utf-8");
             const modelState = JSON.parse(raw);
             const existing = await backend.getSyncState(platform, model);
             if (!existing) {
@@ -4945,7 +4822,7 @@ async function migrateLegacyOnce() {
           }
         }
       }
-      fs7.rmSync(STATE_DIR, { recursive: true, force: true });
+      fs6.rmSync(STATE_DIR, { recursive: true, force: true });
     } catch {
     }
   }
@@ -4989,12 +4866,12 @@ async function removeModelState(platform, model) {
 }
 
 // src/lib/memory/sync/lock.ts
-import fs8 from "fs";
-import path8 from "path";
-var LOCK_DIR_REL = path8.join(".one", "sync", "locks");
+import fs7 from "fs";
+import path7 from "path";
+var LOCK_DIR_REL = path7.join(".one", "sync", "locks");
 var STALE_MS = 30 * 60 * 1e3;
 function lockPath(platform, model) {
-  return path8.join(LOCK_DIR_REL, `${platform}_${model}`);
+  return path7.join(LOCK_DIR_REL, `${platform}_${model}`);
 }
 function isProcessAlive(pid) {
   try {
@@ -5011,15 +4888,15 @@ var SyncLockError = class extends Error {
   }
 };
 function acquireSyncLock(platform, model) {
-  fs8.mkdirSync(LOCK_DIR_REL, { recursive: true });
+  fs7.mkdirSync(LOCK_DIR_REL, { recursive: true });
   const dir = lockPath(platform, model);
-  const pidFile = path8.join(dir, "pid");
+  const pidFile = path7.join(dir, "pid");
   try {
-    fs8.mkdirSync(dir);
+    fs7.mkdirSync(dir);
   } catch (err) {
     const stat = (() => {
       try {
-        return fs8.statSync(dir);
+        return fs7.statSync(dir);
       } catch {
         return null;
       }
@@ -5028,7 +4905,7 @@ function acquireSyncLock(platform, model) {
       const age = Date.now() - stat.mtimeMs;
       let ownerPid = null;
       try {
-        const raw = fs8.readFileSync(pidFile, "utf-8");
+        const raw = fs7.readFileSync(pidFile, "utf-8");
         const parsed = parseInt(raw.trim(), 10);
         if (!isNaN(parsed)) ownerPid = parsed;
       } catch {
@@ -5037,8 +4914,8 @@ function acquireSyncLock(platform, model) {
       const veryOld = age > STALE_MS;
       if (ownerDead || veryOld) {
         try {
-          fs8.rmSync(dir, { recursive: true, force: true });
-          fs8.mkdirSync(dir);
+          fs7.rmSync(dir, { recursive: true, force: true });
+          fs7.mkdirSync(dir);
         } catch {
           throw new SyncLockError(
             `Could not take over stale lock at ${dir}. Remove it manually if no sync is running.`
@@ -5055,13 +4932,13 @@ function acquireSyncLock(platform, model) {
     }
   }
   try {
-    fs8.writeFileSync(pidFile, String(process.pid));
+    fs7.writeFileSync(pidFile, String(process.pid));
   } catch {
   }
   return {
     release() {
       try {
-        fs8.rmSync(dir, { recursive: true, force: true });
+        fs7.rmSync(dir, { recursive: true, force: true });
       } catch {
       }
     }
@@ -5070,9 +4947,9 @@ function acquireSyncLock(platform, model) {
 
 // src/lib/memory/sync/hooks.ts
 import { spawn as spawn2 } from "child_process";
-import fs9 from "fs";
-import path9 from "path";
-var EVENTS_DIR = path9.join(".one", "sync", "events");
+import fs8 from "fs";
+import path8 from "path";
+var EVENTS_DIR = path8.join(".one", "sync", "events");
 function classifyRecords(db, model, records, idField, tableExists2) {
   if (!tableExists2 || records.length === 0) {
     return { inserts: records, updates: [] };
@@ -5118,10 +4995,10 @@ async function fireHooks(hookCommand, events) {
 function appendEventLog(events) {
   if (events.length === 0) return;
   const { platform, model } = events[0];
-  fs9.mkdirSync(EVENTS_DIR, { recursive: true });
-  const logPath = path9.join(EVENTS_DIR, `${platform}_${model}.jsonl`);
+  fs8.mkdirSync(EVENTS_DIR, { recursive: true });
+  const logPath = path8.join(EVENTS_DIR, `${platform}_${model}.jsonl`);
   const lines = events.map((e) => JSON.stringify(e)).join("\n") + "\n";
-  fs9.appendFileSync(logPath, lines);
+  fs8.appendFileSync(logPath, lines);
 }
 function runShellHook(command, events) {
   return new Promise((resolve) => {
@@ -5144,10 +5021,10 @@ function runShellHook(command, events) {
 }
 
 // src/lib/memory/sync/mem-writer.ts
-function resolveWildcardPath(root, path13) {
-  const segments = path13.split("[]");
+function resolveWildcardPath(root, path12) {
+  const segments = path12.split("[]");
   if (segments.length === 1) {
-    return [getByDotPath(root, path13)];
+    return [getByDotPath(root, path12)];
   }
   const recurse = (value, idx) => {
     if (value === null || value === void 0) return [];
@@ -5173,8 +5050,8 @@ function resolveWildcardPath(root, path13) {
 function extractSearchableFromPaths(record, paths) {
   const parts = [];
   const perPath = [];
-  for (const path13 of paths) {
-    const values = resolveWildcardPath(record, path13);
+  for (const path12 of paths) {
+    const values = resolveWildcardPath(record, path12);
     const collected = [];
     const absorb = (v) => {
       if (v === null || v === void 0) return;
@@ -5190,9 +5067,9 @@ function extractSearchableFromPaths(record, paths) {
     for (const v of values) absorb(v);
     if (collected.length > 0) {
       parts.push(...collected);
-      perPath.push({ path: path13, found: true, sample: collected.join(" ").slice(0, 80) });
+      perPath.push({ path: path12, found: true, sample: collected.join(" ").slice(0, 80) });
     } else {
-      perPath.push({ path: path13, found: false, sample: "" });
+      perPath.push({ path: path12, found: false, sample: "" });
     }
   }
   const text5 = parts.join(" ").replace(/\s+/g, " ").trim();
@@ -5371,8 +5248,8 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 function interpolate(template, record) {
-  return template.replace(/\{?\{(\w+(?:\.\w+)*)\}\}?/g, (_, path13) => {
-    const parts = path13.split(".");
+  return template.replace(/\{?\{(\w+(?:\.\w+)*)\}\}?/g, (_, path12) => {
+    const parts = path12.split(".");
     let value = record;
     for (const part of parts) {
       if (typeof value !== "object" || value === null) return "";
@@ -5400,8 +5277,8 @@ function deepMerge(target, source) {
   }
   return result;
 }
-function getByDotPath2(obj, path13) {
-  const parts = path13.split(".");
+function getByDotPath2(obj, path12) {
+  const parts = path12.split(".");
   let current = obj;
   for (const part of parts) {
     if (current === null || current === void 0 || typeof current !== "object") return void 0;
@@ -5410,8 +5287,8 @@ function getByDotPath2(obj, path13) {
   return current;
 }
 function stripExcludedFields(obj, paths) {
-  for (const path13 of paths) {
-    stripOnePath(obj, path13.replace(/\[\]/g, ".*").split("."));
+  for (const path12 of paths) {
+    stripOnePath(obj, path12.replace(/\[\]/g, ".*").split("."));
   }
 }
 function stripOnePath(obj, parts) {
@@ -5480,7 +5357,7 @@ async function enrichPhase(api, db, config2, model, idField, connectionKey, plat
   }
   let detailAction;
   try {
-    detailAction = await api.getActionDetails(config2.actionId);
+    detailAction = (await resolveActionDetails(api, config2.actionId)).details;
   } catch (err) {
     throw new Error(
       `Enrich: could not load action ${config2.actionId}: ${err instanceof Error ? err.message : String(err)}`
@@ -5741,8 +5618,8 @@ function sleep2(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 function stripFields(record, paths) {
-  for (const path13 of paths) {
-    stripOnePath2(record, path13.split("."));
+  for (const path12 of paths) {
+    stripOnePath2(record, path12.split("."));
   }
 }
 function stripOnePath2(obj, parts) {
@@ -5832,7 +5709,7 @@ async function syncModel(api, profile, options) {
         updateModelState(platform, model, { status: "failed", pagesProcessed, lastCursor }),
         (async () => {
           try {
-            const { getBackend: getBackend2 } = await import("./runtime-RVXAPQAZ.js");
+            const { getBackend: getBackend2 } = await import("./runtime-3NDWRLXL.js");
             const backend = await getBackend2();
             await Promise.race([
               backend.close(),
@@ -5909,7 +5786,7 @@ async function syncModel(api, profile, options) {
         queryParams[param] = dateValue;
       }
     }
-    const actionDetails = await api.getActionDetails(profile.actionId);
+    const { details: actionDetails } = await resolveActionDetails(api, profile.actionId);
     if (actionDetails.tags?.includes("custom")) {
       throw new Error(
         `Sync does not support custom actions. Action ${profile.actionId} is tagged "custom". Use a passthrough action \u2014 run 'one actions search ${platform} "${model}"' to find one, or compose a flow that chains passthrough calls if the logic is complex.`
@@ -6187,7 +6064,7 @@ async function syncModel(api, profile, options) {
         db.exec(`DROP TABLE IF EXISTS _seen_ids`);
       }
       if (options.toMemory !== false) {
-        const backend = await (await import("./runtime-RVXAPQAZ.js")).getBackend();
+        const backend = await (await import("./runtime-3NDWRLXL.js")).getBackend();
         const type = `${platform}/${model}`;
         const existing = await backend.listKeysByType(type);
         const sourcePrefix = `${type}:`;
@@ -6267,7 +6144,7 @@ async function syncModel(api, profile, options) {
     let statusCounts;
     if (options.toMemory !== false) {
       try {
-        const backend = await (await import("./runtime-RVXAPQAZ.js")).getBackend();
+        const backend = await (await import("./runtime-3NDWRLXL.js")).getBackend();
         const typeName = `${platform}/${model}`;
         const [active, archived] = await Promise.all([
           backend.count(typeName, { status: "active" }),
@@ -6763,20 +6640,20 @@ function inferProfileFromKnowledge(knowledge, modelName, platform) {
 
 // src/lib/memory/sync/schedule.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import fs11 from "fs";
-import os6 from "os";
-import path11 from "path";
-
-// src/lib/memory/sync/schedule-registry.ts
 import fs10 from "fs";
 import os5 from "os";
 import path10 from "path";
-var REGISTRY_DIR = path10.join(os5.homedir(), ".one", "sync");
-var REGISTRY_FILE = path10.join(REGISTRY_DIR, "schedules.json");
+
+// src/lib/memory/sync/schedule-registry.ts
+import fs9 from "fs";
+import os4 from "os";
+import path9 from "path";
+var REGISTRY_DIR = path9.join(os4.homedir(), ".one", "sync");
+var REGISTRY_FILE = path9.join(REGISTRY_DIR, "schedules.json");
 function readRaw() {
   try {
-    if (!fs10.existsSync(REGISTRY_FILE)) return { schedules: [] };
-    const raw = fs10.readFileSync(REGISTRY_FILE, "utf-8");
+    if (!fs9.existsSync(REGISTRY_FILE)) return { schedules: [] };
+    const raw = fs9.readFileSync(REGISTRY_FILE, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed || !Array.isArray(parsed.schedules)) return { schedules: [] };
     return parsed;
@@ -6785,13 +6662,13 @@ function readRaw() {
   }
 }
 function writeRaw(file) {
-  fs10.mkdirSync(REGISTRY_DIR, { recursive: true });
+  fs9.mkdirSync(REGISTRY_DIR, { recursive: true });
   const tmp = REGISTRY_FILE + ".tmp";
-  fs10.writeFileSync(tmp, JSON.stringify(file, null, 2));
-  fs10.renameSync(tmp, REGISTRY_FILE);
+  fs9.writeFileSync(tmp, JSON.stringify(file, null, 2));
+  fs9.renameSync(tmp, REGISTRY_FILE);
 }
 function makeScheduleId(platform, cwd) {
-  const slug = path10.basename(cwd).replace(/[^a-zA-Z0-9_-]/g, "-").toLowerCase();
+  const slug = path9.basename(cwd).replace(/[^a-zA-Z0-9_-]/g, "-").toLowerCase();
   return `${platform}-${slug}`;
 }
 function listRegistered() {
@@ -6825,7 +6702,7 @@ function removeRegistered(id) {
 
 // src/lib/memory/sync/schedule.ts
 var MARKER = "# one-sync";
-var LOG_DIR_REL = path11.join(".one", "sync", "logs");
+var LOG_DIR_REL = path10.join(".one", "sync", "logs");
 function durationToCron(every) {
   const match = every.match(/^(\d+)([mhd])$/);
   if (!match) return null;
@@ -6858,13 +6735,13 @@ function cronExprToDuration(expr) {
   return null;
 }
 function isWindows() {
-  return os6.platform() === "win32";
+  return os5.platform() === "win32";
 }
 function resolveOneBinary() {
   try {
     const entry = process.argv[1];
-    if (entry && fs11.existsSync(entry)) {
-      return fs11.realpathSync(entry);
+    if (entry && fs10.existsSync(entry)) {
+      return fs10.realpathSync(entry);
     }
   } catch {
   }
@@ -6942,7 +6819,7 @@ function migrateLegacyCronEntries() {
     const modelsMatch = command.match(/--models\s+(\S+)/);
     const models = modelsMatch ? modelsMatch[1].split(",") : void 0;
     const logMatch = command.match(/>>\s+"([^"]+)"/);
-    const logFile = logMatch ? logMatch[1] : path11.resolve(cwd, LOG_DIR_REL, `${platform}.log`);
+    const logFile = logMatch ? logMatch[1] : path10.resolve(cwd, LOG_DIR_REL, `${platform}.log`);
     const id = makeScheduleId(platform, cwd);
     if (registeredIds.has(id)) continue;
     upsertRegistered({
@@ -6976,9 +6853,9 @@ function addSchedule(opts) {
   const cwd = process.cwd();
   const id = makeScheduleId(opts.platform, cwd);
   const replaced = getRegistered(id) !== void 0;
-  const logDir = path11.join(cwd, LOG_DIR_REL);
-  fs11.mkdirSync(logDir, { recursive: true });
-  const logFile = path11.join(logDir, `${opts.platform}.log`);
+  const logDir = path10.join(cwd, LOG_DIR_REL);
+  fs10.mkdirSync(logDir, { recursive: true });
+  const logFile = path10.join(logDir, `${opts.platform}.log`);
   const entry = {
     id,
     platform: opts.platform,
@@ -7032,15 +6909,15 @@ function removeSchedule(idOrPlatform, options) {
 function scheduleStatus() {
   const entries = listSchedules();
   return entries.map((entry) => {
-    const logExists = fs11.existsSync(entry.logFile);
-    const logSize = logExists ? fs11.statSync(entry.logFile).size : 0;
+    const logExists = fs10.existsSync(entry.logFile);
+    const logSize = logExists ? fs10.statSync(entry.logFile).size : 0;
     let logTail = [];
     let lastRunAt = null;
     if (logExists) {
       try {
-        lastRunAt = fs11.statSync(entry.logFile).mtime.toISOString();
+        lastRunAt = fs10.statSync(entry.logFile).mtime.toISOString();
         if (logSize > 0) {
-          const content = fs11.readFileSync(entry.logFile, "utf-8");
+          const content = fs10.readFileSync(entry.logFile, "utf-8");
           logTail = content.trim().split("\n").slice(-10);
         }
       } catch {
@@ -7048,8 +6925,8 @@ function scheduleStatus() {
     }
     let drift = "ok";
     if (!entry.cronInstalled) drift = "missing-cron";
-    else if (!fs11.existsSync(entry.nodeBin)) drift = "stale-node-bin";
-    else if (!fs11.existsSync(entry.cliBin)) drift = "stale-cli-bin";
+    else if (!fs10.existsSync(entry.nodeBin)) drift = "stale-node-bin";
+    else if (!fs10.existsSync(entry.cliBin)) drift = "stale-cli-bin";
     return { entry, logExists, logSize, logTail, lastRunAt, drift };
   });
 }
@@ -7322,11 +7199,11 @@ function isNoise(s) {
   if (/^-?\d+(\.\d+)?([eE][-+]?\d+)?$/.test(s)) return true;
   return false;
 }
-function recordSample(stats, path13, value, jsType, recordIndex, totalSamples) {
-  let s = stats.get(path13);
+function recordSample(stats, path12, value, jsType, recordIndex, totalSamples) {
+  let s = stats.get(path12);
   if (!s) {
     s = {
-      path: path13,
+      path: path12,
       total: totalSamples,
       recordIndices: /* @__PURE__ */ new Set(),
       lenSum: 0,
@@ -7335,7 +7212,7 @@ function recordSample(stats, path13, value, jsType, recordIndex, totalSamples) {
       primaryType: jsType,
       examples: []
     };
-    stats.set(path13, s);
+    stats.set(path12, s);
   }
   s.recordIndices.add(recordIndex);
   s.lenSum += value.length;
@@ -7344,28 +7221,28 @@ function recordSample(stats, path13, value, jsType, recordIndex, totalSamples) {
   if (s.primaryType !== jsType) s.primaryType = "mixed";
   if (s.examples.length < 3 && value.length < 200) s.examples.push(value);
 }
-function walkRecord(record, path13, stats, recordIndex, totalSamples) {
+function walkRecord(record, path12, stats, recordIndex, totalSamples) {
   if (record === null || record === void 0) return;
   if (typeof record === "string") {
     const trimmed = record.trim();
-    if (trimmed) recordSample(stats, path13, trimmed, "string", recordIndex, totalSamples);
+    if (trimmed) recordSample(stats, path12, trimmed, "string", recordIndex, totalSamples);
     return;
   }
   if (typeof record === "number" || typeof record === "boolean") {
     const str = String(record);
     const kind = typeof record === "number" ? "number" : "boolean";
-    if (str) recordSample(stats, path13, str, kind, recordIndex, totalSamples);
+    if (str) recordSample(stats, path12, str, kind, recordIndex, totalSamples);
     return;
   }
   if (Array.isArray(record)) {
-    const childPath = path13 ? `${path13}[]` : "[]";
+    const childPath = path12 ? `${path12}[]` : "[]";
     for (const item of record) walkRecord(item, childPath, stats, recordIndex, totalSamples);
     return;
   }
   if (typeof record === "object") {
     for (const [key, value] of Object.entries(record)) {
       if (key.startsWith("_")) continue;
-      const childPath = path13 ? `${path13}.${key}` : key;
+      const childPath = path12 ? `${path12}.${key}` : key;
       walkRecord(value, childPath, stats, recordIndex, totalSamples);
     }
   }
@@ -7574,8 +7451,8 @@ async function syncInitCommand(platform, model, options) {
       }
       if (actionId && !builtin) {
         try {
-          const knowledgeResp = await api.getActionKnowledge(actionId);
-          inferred = inferProfileFromKnowledge(knowledgeResp?.knowledge, model, platform);
+          const { details } = await resolveActionDetails(api, actionId);
+          inferred = inferProfileFromKnowledge(details.knowledge, model, platform);
           if (inferred.pagination) template.pagination = inferred.pagination;
           if (inferred.resultsPath) template.resultsPath = inferred.resultsPath;
           if (inferred.idField) template.idField = inferred.idField;
@@ -7771,7 +7648,7 @@ function buildSearchablePreview(profile, samples) {
   const first = samples[0];
   const paths = getSearchablePaths(profile);
   if (paths) {
-    const perPathAgg = paths.map((path13) => ({ path: path13, hits: 0, total: samples.length, sample: "" }));
+    const perPathAgg = paths.map((path12) => ({ path: path12, hits: 0, total: samples.length, sample: "" }));
     for (const record of samples) {
       const { paths: perPath } = extractSearchableFromPaths(record, paths);
       perPath.forEach((p10, i) => {
@@ -7900,7 +7777,7 @@ ${result.total} results`);
   }
 }
 async function syncSqlCommand(platformModel, sql) {
-  const { syncSqlCommand: runSyncSql } = await import("./sql-V44IVBHX.js");
+  const { syncSqlCommand: runSyncSql } = await import("./sql-ZABEXIXW.js");
   await runSyncSql(platformModel, sql);
 }
 async function syncDeleteCommand(platformModel, options) {
@@ -7978,7 +7855,7 @@ async function syncDeleteCommand(platformModel, options) {
 async function maybeAutoMigrateLegacy(platform, models) {
   const dbSize = getDatabaseSize(platform);
   if (!dbSize || dbSize === "0 B") return;
-  const { getBackend: getBackend2 } = await import("./runtime-RVXAPQAZ.js");
+  const { getBackend: getBackend2 } = await import("./runtime-3NDWRLXL.js");
   const backend = await getBackend2();
   let memoryHasData = false;
   for (const model of models) {
@@ -7994,7 +7871,7 @@ async function maybeAutoMigrateLegacy(platform, models) {
       `  detected legacy .one/sync/data/${platform}.db (${dbSize}) \u2014 auto-migrating into memory before sync.
 `
     );
-    const { memMigrateCommand: memMigrateCommand3 } = await import("./migrate-J2ZRDEFB.js");
+    const { memMigrateCommand: memMigrateCommand3 } = await import("./migrate-VV3VOXWJ.js");
     await memMigrateCommand3({ platform, yes: true });
     return;
   }
@@ -8003,7 +7880,7 @@ async function maybeAutoMigrateLegacy(platform, models) {
     initialValue: true
   });
   if (p7.isCancel(shouldMigrate) || !shouldMigrate) return;
-  const { memMigrateCommand: memMigrateCommand2 } = await import("./migrate-J2ZRDEFB.js");
+  const { memMigrateCommand: memMigrateCommand2 } = await import("./migrate-VV3VOXWJ.js");
   await memMigrateCommand2({ platform, yes: true });
 }
 async function syncSuggestSearchableCommand(platformModel, options = {}) {
@@ -8064,7 +7941,7 @@ async function syncSuggestSearchableCommand(platformModel, options = {}) {
 async function syncListCommand(platform) {
   const profiles = listProfiles(platform);
   const state = await readSyncState();
-  const { getBackend: getBackend2 } = await import("./runtime-RVXAPQAZ.js");
+  const { getBackend: getBackend2 } = await import("./runtime-3NDWRLXL.js");
   const backend = await getBackend2();
   const syncs = await Promise.all(profiles.map(async (p10) => {
     const modelState = state[p10.platform]?.[p10.model];
@@ -8702,16 +8579,16 @@ function projectEmbeddingApiKey(cfg) {
 }
 function redactSecrets(cfg) {
   const copy = JSON.parse(JSON.stringify(cfg));
-  for (const path13 of SECRET_PATHS) {
-    const val = getPath(copy, path13);
+  for (const path12 of SECRET_PATHS) {
+    const val = getPath(copy, path12);
     if (typeof val === "string" && val.length > 0) {
-      setPath(copy, path13, `${val.slice(0, 6)}\u2026(redacted, use --show-secrets)`);
+      setPath(copy, path12, `${val.slice(0, 6)}\u2026(redacted, use --show-secrets)`);
     }
   }
   return copy;
 }
-function getPath(obj, path13) {
-  const parts = path13.split(".");
+function getPath(obj, path12) {
+  const parts = path12.split(".");
   let cur = obj;
   for (const part of parts) {
     if (cur == null || typeof cur !== "object") return void 0;
@@ -8719,8 +8596,8 @@ function getPath(obj, path13) {
   }
   return cur;
 }
-function setPath(obj, path13, value) {
-  const parts = path13.split(".");
+function setPath(obj, path12, value) {
+  const parts = path12.split(".");
   let cur = obj;
   for (let i = 0; i < parts.length - 1; i++) {
     const part = parts[i];
@@ -8730,8 +8607,8 @@ function setPath(obj, path13, value) {
   cur[parts[parts.length - 1]] = value;
   return obj;
 }
-function unsetPath(obj, path13) {
-  const parts = path13.split(".");
+function unsetPath(obj, path12) {
+  const parts = path12.split(".");
   let cur = obj;
   for (let i = 0; i < parts.length - 1; i++) {
     const part = parts[i];
@@ -8982,7 +8859,7 @@ async function memDoctorCommand() {
   }
   if (cfg.embedding.provider === "openai") {
     try {
-      const { embed: embed2 } = await import("./embedding-GZGDGIUA.js");
+      const { embed: embed2 } = await import("./embedding-C3E4EAQ7.js");
       const result = await embed2("connectivity check");
       checks.push({
         name: "OpenAI embedding provider reachable",
@@ -9040,7 +8917,7 @@ ${pc10.dim(line)}`);
 }
 
 // src/commands/mem/export.ts
-import fs12 from "fs";
+import fs11 from "fs";
 async function memExportCommand(outfile) {
   requireMemoryInit();
   const backend = await getBackend();
@@ -9073,14 +8950,14 @@ async function memExportCommand(outfile) {
     }
     return;
   }
-  fs12.writeFileSync(outfile, lines, "utf-8");
+  fs11.writeFileSync(outfile, lines, "utf-8");
   okJson({ status: "ok", file: outfile, recordsWritten: records.length, storeTotal: stats.recordCount });
 }
 async function memImportCommand(file) {
   requireMemoryInit();
-  if (!fs12.existsSync(file)) error(`File not found: ${file}`);
+  if (!fs11.existsSync(file)) error(`File not found: ${file}`);
   const backend = await getBackend();
-  const raw = fs12.readFileSync(file, "utf-8");
+  const raw = fs11.readFileSync(file, "utf-8");
   const lines = raw.split("\n").filter((l) => l.trim().length > 0);
   let inserted = 0;
   let updated = 0;
@@ -9344,13 +9221,13 @@ async function cacheUpdateAllCommand() {
   for (const e of entries) {
     try {
       if (e.type === "knowledge") {
-        const result = await api.getActionKnowledgeWithMeta(e.entry.key);
+        const result = await api.getActionDetailsWithMeta(e.entry.key);
         const newEntry = makeCacheEntry(e.entry.key, result.data, result.etag);
-        writeCache2(e.filePath, newEntry);
+        writeCache(e.filePath, newEntry);
         updated++;
       } else {
         const refreshed = { ...e.entry, cachedAt: (/* @__PURE__ */ new Date()).toISOString() };
-        writeCache2(e.filePath, refreshed);
+        writeCache(e.filePath, refreshed);
         updated++;
       }
     } catch (err) {
@@ -9436,6 +9313,7 @@ one --agent actions execute <platform> <actionId> <key> -d '{}'  # Execute it
 - \`--mock\` \u2014 Return example response without making an API call (useful for building UI against a response shape)
 - \`--skip-validation\` \u2014 Skip input validation against the action schema
 - \`--output <path>\` \u2014 Save response to a file (for binary downloads like PDFs, images, documents)
+- \`--no-cache\` \u2014 Fetch action details fresh instead of from the local cache (execution itself is never cached)
 
 The CLI validates required parameters against the action schema before executing. If you're missing a required path variable, query param, or body field, you'll get a clear error listing what's missing and which flag to use. Pass \`--skip-validation\` to bypass.
 
@@ -9561,6 +9439,9 @@ one --agent actions execute <platform> <actionId> <connectionKey> [options]
 - \`--mock\` \u2014 Return example response without making an API call
 - \`--skip-validation\` \u2014 Skip input validation against the action schema
 - \`--output <path>\` \u2014 Save response to a file (for binary downloads like PDFs, images, documents)
+- \`--no-cache\` \u2014 Fetch action details fresh instead of from the local cache (execution itself is never cached)
+
+Execute reuses the action details cached by \`actions knowledge\` (method, path, schema), so in the standard search \u2192 knowledge \u2192 execute flow it makes a single API call \u2014 the action being executed. The live response is never cached. In \`--agent\` mode the response includes \`"_preflight": {"cache": "hit"|"miss"}\` showing whether the lookup was served from disk.
 
 **Do NOT** pass path or query parameters in \`-d\`. Use the correct flags.
 
@@ -9575,13 +9456,13 @@ one --agent actions execute --parallel \\
   -- google-sheets append-row conn789 -d '{"values":["x"]}'
 \`\`\`
 
-Each segment separated by \`--\` follows the same format: \`<platform> <actionId> <connectionKey> [-d ...] [--path-vars ...] [--query-params ...]\`. Global flags (\`--dry-run\`, \`--mock\`, \`--skip-validation\`) apply to all segments.
+Each segment separated by \`--\` follows the same format: \`<platform> <actionId> <connectionKey> [-d ...] [--path-vars ...] [--query-params ...]\`. Global flags (\`--dry-run\`, \`--mock\`, \`--skip-validation\`, \`--no-cache\`) apply to all segments.
 
 All segments are validated upfront before any execution starts \u2014 if one segment has bad params, nothing runs. Execution uses \`Promise.allSettled\` so if one action fails the rest still complete. Use \`--max-concurrency <n>\` (default 5) to control batch size.
 
-Agent-mode output:
+Agent-mode output (each result carries its own \`_preflight\` showing whether that action's details were served from cache):
 \`\`\`json
-{"parallel":true,"totalDurationMs":1234,"succeeded":2,"failed":0,"results":[{"segment":1,"platform":"gmail","actionId":"send-email","status":"success","durationMs":800,"response":{...}},{"segment":2,"platform":"slack","actionId":"post-message","status":"success","durationMs":600,"response":{...}}]}
+{"parallel":true,"totalDurationMs":1234,"succeeded":2,"failed":0,"results":[{"segment":1,"platform":"gmail","actionId":"send-email","status":"success","durationMs":800,"response":{...},"_preflight":{"cache":"hit"}},{"segment":2,"platform":"slack","actionId":"post-message","status":"success","durationMs":600,"response":{...},"_preflight":{"cache":"miss"}}]}
 \`\`\`
 
 ## Input Validation
@@ -9714,7 +9595,7 @@ var GUIDE_CACHE = `# One Cache \u2014 Reference
 
 ## Overview
 
-The One CLI caches \`actions knowledge\` and \`actions search\` responses locally so repeated calls serve instantly from disk instead of hitting the API. This is the single biggest latency win for agents who call knowledge for the same actions repeatedly.
+The One CLI caches \`actions knowledge\` and \`actions search\` responses locally so repeated calls serve instantly from disk instead of hitting the API. The knowledge cache stores the action's full details (docs, method, path, schema), so \`actions execute\` reuses it for its preflight lookup \u2014 in the standard search \u2192 knowledge \u2192 execute flow, execute makes exactly one API call: the action itself.
 
 Cache location: \`~/.one/cache/knowledge/\` and \`~/.one/cache/search/\`
 
@@ -9724,6 +9605,7 @@ Cache location: \`~/.one/cache/knowledge/\` and \`~/.one/cache/search/\`
 - **Subsequent calls (within TTL)**: serves from cache instantly, no API call
 - **After TTL expires**: makes a conditional request (ETag). If content unchanged, refreshes the cache timestamp. If changed, writes fresh data.
 - **Network failure with stale cache**: serves the stale cache with a warning \u2014 never fails hard when a cache exists
+- **Shared preflight**: \`actions execute\`, flow action steps, and \`sync\` all read action details (method, path, validation schema) from the same cache and warm it on a miss \u2014 so a knowledge call, a flow run, and a later execute of the same action all reuse one cached lookup
 
 Default TTL: 3600 seconds (1 hour). Configure via \`ONE_CACHE_TTL\` env var or \`cacheTtl\` in \`~/.one/config.json\`.
 
@@ -9731,8 +9613,9 @@ Default TTL: 3600 seconds (1 hour). Configure via \`ONE_CACHE_TTL\` env var or \
 
 | Cached | Not Cached |
 |--------|-----------|
-| \`actions knowledge\` (API docs, change infrequently) | \`actions execute\` (live data, always fresh) |
+| \`actions knowledge\` (API docs, change infrequently) | \`actions execute\` responses (live data, always fresh) |
 | \`actions search\` results | \`connection list\` (changes with add/remove) |
+| Action details used by execute / flow / sync preflight (method, path, schema) | |
 
 ## Agent Mode \`_cache\` Metadata
 
@@ -9763,8 +9646,13 @@ one --agent actions knowledge <platform> <actionId> --cache-status
 
 # Same for search
 one --agent actions search <platform> "<query>" --no-cache
+
+# Same for execute's action-details preflight (the action itself always runs live)
+one --agent actions execute <platform> <actionId> <key> --no-cache
 \`\`\`
 
+In \`--agent\` mode, execute responses include \`"_preflight": {"cache": "hit"|"miss"}\` showing whether the action details came from disk.
+
 ## Cache Management Commands
 
 \`\`\`bash
@@ -10676,7 +10564,7 @@ function buildWorkflowIdeas(connections) {
 }
 
 // src/commands/logout.ts
-import fs13 from "fs";
+import fs12 from "fs";
 import * as p9 from "@clack/prompts";
 function formatWhoami(config2, apiKey, pc13) {
   const whoami = config2.whoami;
@@ -10709,12 +10597,12 @@ async function logoutCommand() {
     const globalPath = getGlobalConfigPath();
     const projectPath = getProjectConfigPath();
     let cleared = false;
-    if (fs13.existsSync(projectPath)) {
-      fs13.unlinkSync(projectPath);
+    if (fs12.existsSync(projectPath)) {
+      fs12.unlinkSync(projectPath);
       cleared = true;
     }
-    if (fs13.existsSync(globalPath)) {
-      fs13.unlinkSync(globalPath);
+    if (fs12.existsSync(globalPath)) {
+      fs12.unlinkSync(globalPath);
       cleared = true;
     }
     json({ status: cleared ? "logged_out" : "not_logged_in", message: cleared ? "Credentials cleared." : "No config found." });
@@ -10783,11 +10671,11 @@ async function logoutCommand() {
   }
   if (targetScope === "project" || targetScope === "both") {
     const projectPath = getProjectConfigPath();
-    if (fs13.existsSync(projectPath)) fs13.unlinkSync(projectPath);
+    if (fs12.existsSync(projectPath)) fs12.unlinkSync(projectPath);
   }
   if (targetScope === "global" || targetScope === "both") {
     const globalPath = getGlobalConfigPath();
-    if (fs13.existsSync(globalPath)) fs13.unlinkSync(globalPath);
+    if (fs12.existsSync(globalPath)) fs12.unlinkSync(globalPath);
   }
   p9.log.success("Credentials cleared.");
   p9.log.info("Your API key is still active. Manage keys at app.withone.ai/settings");
@@ -11005,8 +10893,8 @@ config.command("reset").description("Remove the project config for the current d
         return;
       }
     }
-    const fs15 = await import("fs");
-    fs15.unlinkSync(globalPath);
+    const fs14 = await import("fs");
+    fs14.unlinkSync(globalPath);
     if (isAgentMode()) {
       json({ deleted: true, scope: "global" });
     } else {
@@ -11023,15 +10911,15 @@ config.command("reset").description("Remove the project config for the current d
     }
     return;
   }
-  const fs14 = await import("fs");
-  const configContent = fs14.readFileSync(resolved.path, "utf-8");
-  fs14.unlinkSync(resolved.path);
+  const fs13 = await import("fs");
+  const configContent = fs13.readFileSync(resolved.path, "utf-8");
+  fs13.unlinkSync(resolved.path);
   const next = resolveConfig();
-  fs14.mkdirSync(path12.dirname(resolved.path), { recursive: true });
-  fs14.writeFileSync(resolved.path, configContent);
+  fs13.mkdirSync(path11.dirname(resolved.path), { recursive: true });
+  fs13.writeFileSync(resolved.path, configContent);
   let fallbackLabel;
   if (next.scope === "project") {
-    fallbackLabel = `parent project config (${path12.basename(next.projectRoot)})`;
+    fallbackLabel = `parent project config (${path11.basename(next.projectRoot)})`;
   } else if (next.scope === "global") {
     fallbackLabel = "global config";
   } else {
@@ -11040,7 +10928,7 @@ config.command("reset").description("Remove the project config for the current d
   if (!isAgentMode()) {
     const p10 = await import("@clack/prompts");
     const confirmed = await p10.confirm({
-      message: `Delete project config for ${path12.basename(resolved.projectRoot)}? Will fall back to ${fallbackLabel}.`,
+      message: `Delete project config for ${path11.basename(resolved.projectRoot)}? Will fall back to ${fallbackLabel}.`,
       initialValue: false
     });
     if (p10.isCancel(confirmed) || !confirmed) {
@@ -11048,9 +10936,9 @@ config.command("reset").description("Remove the project config for the current d
       return;
     }
   }
-  fs14.unlinkSync(resolved.path);
+  fs13.unlinkSync(resolved.path);
   try {
-    fs14.rmdirSync(path12.dirname(resolved.path));
+    fs13.rmdirSync(path11.dirname(resolved.path));
   } catch {
   }
   if (isAgentMode()) {
@@ -11079,7 +10967,7 @@ actions.command("search <platform> <query>").description('Search for actions on
 actions.command("knowledge <platform> <actionId>").alias("k").description("Get full docs for an action \u2014 MUST call before execute to know required params").option("--no-cache", "Skip cache, fetch fresh from API").option("--cache-status", "Print cache metadata without fetching").action(async (platform, actionId, options) => {
   await actionsKnowledgeCommand(platform, actionId, options);
 });
-actions.command("execute [platform] [actionId] [connectionKey]").alias("x").allowUnknownOption(true).allowExcessArguments(true).description("Execute an action (or multiple with --parallel, separated by --)").option("-d, --data <json>", "Request body as JSON").option("--path-vars <json>", "Path variables as JSON").option("--query-params <json>", "Query parameters as JSON").option("--headers <json>", "Additional headers as JSON").option("--form-data", "Send as multipart/form-data").option("--form-url-encoded", "Send as application/x-www-form-urlencoded").option("--dry-run", "Show request that would be sent without executing").option("--mock", "Return example response without making an API call").option("--skip-validation", "Skip input validation against the action schema").option("--output <path>", "Save binary response to a file (for non-JSON responses like file downloads)").option("--parallel", "Execute multiple actions concurrently (separate actions with --)").option("--max-concurrency <n>", "Max concurrent actions when using --parallel (default: 5)", "5").action(async (platform, actionId, connectionKey, options) => {
+actions.command("execute [platform] [actionId] [connectionKey]").alias("x").allowUnknownOption(true).allowExcessArguments(true).description("Execute an action (or multiple with --parallel, separated by --)").option("-d, --data <json>", "Request body as JSON").option("--path-vars <json>", "Path variables as JSON").option("--query-params <json>", "Query parameters as JSON").option("--headers <json>", "Additional headers as JSON").option("--form-data", "Send as multipart/form-data").option("--form-url-encoded", "Send as application/x-www-form-urlencoded").option("--dry-run", "Show request that would be sent without executing").option("--mock", "Return example response without making an API call").option("--skip-validation", "Skip input validation against the action schema").option("--no-cache", "Fetch action details fresh instead of using the local cache (execution itself is never cached)").option("--output <path>", "Save binary response to a file (for non-JSON responses like file downloads)").option("--parallel", "Execute multiple actions concurrently (separate actions with --)").option("--max-concurrency <n>", "Max concurrent actions when using --parallel (default: 5)", "5").action(async (platform, actionId, connectionKey, options) => {
   if (options.parallel) {
     await actionsExecuteParallelCommand();
     return;
@@ -11097,7 +10985,8 @@ actions.command("execute [platform] [actionId] [connectionKey]").alias("x").allo
     dryRun: options.dryRun,
     mock: options.mock,
     skipValidation: options.skipValidation,
-    output: options.output
+    output: options.output,
+    cache: options.cache
   });
 });
 var flow = program.command("flow").alias("f").description("Create, execute, and manage multi-step workflows");